chore(dev): release 2.13.0 (#32446)

Co-authored-by: Koen Kanters <koenkanters94@gmail.com>

.devcontainer/devcontainer.json

@@ -0,0 +1,23 @@
+{
+    "image": "mcr.microsoft.com/devcontainers/javascript-node:24",
+
+    "postCreateCommand": "pnpm config set store-dir /home/node/.local/share/pnpm/store && npm install typescript -g",
+
+    "customizations": {
+        "vscode": {
+            "settings": {
+                "workbench.colorTheme": "Default Dark Modern",
+                "window.menuBarVisibility": "classic",
+                "editor.defaultFormatter": "biomejs.biome",
+                "notebook.defaultFormatter": "biomejs.biome",
+                "editor.formatOnPaste": true,
+                "editor.formatOnSave": true,
+                "editor.tabSize": 4,
+                "editor.insertSpaces": true,
+                "files.defaultLanguage": "typescript",
+                "files.eol": "\n"
+            },
+            "extensions": ["biomejs.biome", "vitest.explorer"]
+        }
+    }
+}

.github/copilot-instructions.md

@@ -78,7 +78,7 @@ abstract class Extension {
     protected state: State;
     protected publishEntityState: PublishEntityState;
     protected eventBus: EventBus;
-    
+
     async start(): Promise<void> {}
     async stop(): Promise<void> {}
 }
@@ -181,9 +181,9 @@ logger.debug("message");
 - Use TypeScript's strict mode features (`noImplicitAny`, `noImplicitThis`)
 
 ### Performance
-- Use `rimrafSync` for synchronous file deletion when appropriate
+- Use `fs.rmSync(path, {recursive: true, force: true})` for synchronous file deletion when appropriate
 - Leverage async/await for I/O operations to avoid blocking
-- Use JSON stable stringify for consistent object serialization: `json-stable-stringify-without-jsonify`
+- Use JSON stable stringify util for consistent object serialization
 - Cache computed values when appropriate (see device model patterns)
 - Use getter methods for computed properties that should be cached
 
@@ -217,10 +217,10 @@ describe("ComponentName", () => {
     it("Should do something specific", async () => {
         // Arrange
         const input = {};
-        
+
         // Act
         const result = await someFunction(input);
-        
+
         // Assert
         expect(result).toBe(expected);
     });
@@ -414,7 +414,7 @@ this.eventBus.on('deviceMessage', this.onDeviceMessage, this);
 - Device operations through `zigbee-herdsman` API
 - Event handling through EventBus wrappers
 
-### MQTT Integration  
+### MQTT Integration
 - Connect: `await this.mqtt.connect()`
 - Subscribe: `await this.mqtt.subscribe(topic)`
 - Publish: `await this.mqtt.publish(topic, message, options)`

.github/dependabot.yml

@@ -19,8 +19,12 @@ updates:
       schedule:
         interval: weekly
       target-branch: dev
+      commit-message:
+        prefix: fix(ignore)
     - package-ecosystem: github-actions
       directory: /
       schedule:
         interval: weekly
       target-branch: dev
+      commit-message:
+        prefix: chore

.github/workflows/ci.yml

@@ -22,18 +22,18 @@ jobs:
             actions: read # for Nerivec/action-ci-bench
             pull-requests: write # for Nerivec/action-ci-bench
         steps:
-            - uses: actions/checkout@v6
+            - uses: actions/checkout@v7
               if: (github.ref == 'refs/heads/dev' || startsWith(github.ref, 'refs/tags/')) && github.event_name == 'push'
               with:
                   # Required for `release: merge dev -> master and promote dev`
                   token: ${{ secrets.GH_TOKEN }}
 
-            - uses: actions/checkout@v6
+            - uses: actions/checkout@v7
               if: ((github.ref == 'refs/heads/dev' || startsWith(github.ref, 'refs/tags/')) && github.event_name == 'push') == false
 
             - uses: pnpm/action-setup@v6
 
-            - uses: actions/setup-node@v6
+            - uses: actions/setup-node@v7
               with:
                   node-version: 24
                   registry-url: https://registry.npmjs.org/
@@ -216,15 +216,15 @@ jobs:
         strategy:
             matrix:
                 os: [ubuntu-latest, macos-latest, windows-latest]
-                node: [20, 22, 24]
+                node: [22, 24, 26]
         runs-on: ${{ matrix.os }}
         continue-on-error: true
         steps:
-            - uses: actions/checkout@v6
+            - uses: actions/checkout@v7
 
             - uses: pnpm/action-setup@v6
 
-            - uses: actions/setup-node@v6
+            - uses: actions/setup-node@v7
               with:
                   node-version: ${{ matrix.node }}
                   cache: pnpm

.github/workflows/dependency-review.yaml

@@ -10,6 +10,6 @@ jobs:
         runs-on: ubuntu-latest
         steps:
             - name: 'Checkout repository'
-              uses: actions/checkout@v6
+              uses: actions/checkout@v7
             - name: 'Dependency review'
               uses: actions/dependency-review-action@v5

.github/workflows/fail-pr-to-master.yaml

@@ -10,8 +10,10 @@ jobs:
         runs-on: ubuntu-latest
         steps:
             - name: Fail PR to master
+              env:
+                  PR_TITLE: ${{ github.event.pull_request.title }}
               run: |
-                  if [[ "${{ github.event.pull_request.title }}" == "chore(dev): release"* ]]; then
+                  if [[ "$PR_TITLE" == "chore(dev): release"* ]]; then
                     echo "PR title starts with 'chore(dev): release', allowing PR"
                   else
                     echo "Pull requests to the master branch are not allowed, target dev branch"

.github/workflows/issue_bot.yml

@@ -17,13 +17,13 @@ jobs:
       startsWith(github.event.issue.title, '[New device support]') ||
       startsWith(github.event.issue.title, '[External Converter]')
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
         with:
           sparse-checkout: |
             scripts
           path: z2m
 
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
         with:
           repository: Koenkk/zigbee-herdsman-converters
           ref: master

.github/workflows/merge-master-to-dev.yml

@@ -9,7 +9,7 @@ jobs:
     merge-master-to-dev:
         runs-on: ubuntu-latest
         steps:
-            - uses: actions/checkout@v6
+            - uses: actions/checkout@v7
             - uses: devmasx/merge-branch@master
               with:
                   type: now

.github/workflows/release-please.yml

@@ -20,7 +20,7 @@ jobs:
               with:
                   version: 9
 
-            - uses: actions/setup-node@v6
+            - uses: actions/setup-node@v7
               with:
                   node-version: 24
 
@@ -31,18 +31,18 @@ jobs:
                   token: ${{secrets.GH_TOKEN}}
 
             # Checkout repos
-            - uses: actions/checkout@v6
+            - uses: actions/checkout@v7
               with:
                   repository: koenkk/zigbee2mqtt
                   path: ./z2m
-            - uses: actions/checkout@v6
+            - uses: actions/checkout@v7
               with:
                   repository: koenkk/zigbee2mqtt
                   path: ./z2m-master
                   ref: master
 
             - name: Restore cache commit-user-lookup.json
-              uses: actions/cache/restore@v5
+              uses: actions/cache/restore@v6
               with:
                   path: z2m/scripts/commit-user-lookup.json
                   key: commit-user-lookup-dummy
@@ -67,7 +67,7 @@ jobs:
               env:
                   GH_TOKEN: ${{secrets.GH_TOKEN}}
             - name: Save cache commit-user-lookup.json
-              uses: actions/cache/save@v5
+              uses: actions/cache/save@v6
               if: always()
               with:
                   path: z2m/scripts/commit-user-lookup.json

.github/workflows/stale.yml

@@ -9,7 +9,7 @@ jobs:
     stale:
         runs-on: ubuntu-latest
         steps:
-            - uses: actions/stale@v10
+            - uses: actions/stale@v11
               with:
                   repo-token: ${{ secrets.GITHUB_TOKEN }}
                   stale-issue-message: 'This issue is stale because it has been open 60 days with no activity. Remove stale label or comment or this will be closed in 7 days'

.github/workflows/update-dependency.yml

@@ -13,12 +13,12 @@ jobs:
 
         runs-on: ubuntu-latest
         steps:
-            - uses: actions/checkout@v6
+            - uses: actions/checkout@v7
               with:
                   ref: dev
                   token: ${{ secrets.GH_TOKEN }}
             - uses: pnpm/action-setup@v6
-            - uses: actions/setup-node@v6
+            - uses: actions/setup-node@v7
               with:
                   node-version: 24
                   cache: pnpm

.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-    ".": "2.11.0"
+    ".": "2.13.0"
 }

.vscode/extensions.json

@@ -0,0 +1,3 @@
+{
+    "recommendations": ["biomejs.biome", "vitest.explorer"]
+}

.vscode/settings.json

@@ -0,0 +1,11 @@
+{
+    "editor.defaultFormatter": "biomejs.biome",
+    "notebook.defaultFormatter": "biomejs.biome",
+    "editor.tabSize": 4,
+    "editor.insertSpaces": true,
+    "files.defaultLanguage": "typescript",
+    "files.eol": "\n",
+    "[typescript]": {
+        "editor.defaultFormatter": "biomejs.biome"
+    }
+}

AGENTS.md

@@ -9,7 +9,7 @@ Zigbee2MQTT is a Zigbee to MQTT bridge that allows you to use your Zigbee device
 - **Language**: TypeScript 5.9.3 compiled to JavaScript (ES modules with NodeNext resolution)
 - **Runtime**: Node.js (versions 20, 22, or 24)
 - **Package Manager**: pnpm 10.12.1 (strictly enforced via `packageManager` field)
-- **Core Dependencies**: 
+- **Core Dependencies**:
   - `zigbee-herdsman` (6.2.0 - exact version, handles Zigbee adapter communication)
   - `zigbee-herdsman-converters` (25.42.0 - exact version, device definitions)
   - `mqtt` (5.14.1 - MQTT client)
@@ -227,7 +227,7 @@ abstract class Extension {
     protected state: State;
     protected publishEntityState: PublishEntityState;
     protected eventBus: EventBus;
-    
+
     async start(): Promise<void> {}  // Initialize extension
     async stop(): Promise<void> {}   // Cleanup extension
 }
@@ -326,7 +326,7 @@ https://www.zigbee2mqtt.io/guide/installation/01_linux.html
 
 ### Performance Considerations
 
-- Use `rimrafSync` for synchronous file operations
+- Use `fs.rmSync(path, {recursive: true, force: true})` for synchronous file operations
 - Leverage async/await to avoid blocking
 - Cache computed values in getters when appropriate
 - EventBus provides loose coupling between components
@@ -344,7 +344,7 @@ These dependencies use **exact versions** (no semver ranges) - do not upgrade wi
 
 Only these Node.js versions are supported:
 - Node.js 20.x
-- Node.js 22.x  
+- Node.js 22.x
 - Node.js 24.x
 
 Using other versions may cause runtime errors or incompatibilities.

CHANGELOG.md

@@ -1,5 +1,120 @@
 # Changelog
 
+## [2.13.0](https://github.com/Koenkk/zigbee2mqtt/compare/2.12.1...2.13.0) (2026-08-01)
+
+
+### Features
+
+* Add `clear_cache` option to device remove request ([#32631](https://github.com/Koenkk/zigbee2mqtt/issues/32631)) ([83ab522](https://github.com/Koenkk/zigbee2mqtt/commit/83ab5228ff24779773e67bfc217d89f7c7520daa))
+* Home Assistant: add discovery support for Tuya infrared receiver (learn mode) and emitter features ([#32625](https://github.com/Koenkk/zigbee2mqtt/issues/32625)) ([32506b4](https://github.com/Koenkk/zigbee2mqtt/commit/32506b4e8abf81996966632719384f85bad7a66c))
+
+
+### Bug Fixes
+
+* `experimental_event_entities` and `legacy_action_sensor` require restart ([#32535](https://github.com/Koenkk/zigbee2mqtt/issues/32535)) ([2ca80b8](https://github.com/Koenkk/zigbee2mqtt/commit/2ca80b8572293a7c63c019c1b433e942772220c4))
+* Avoid running resolveDefinition in parallel ([#32662](https://github.com/Koenkk/zigbee2mqtt/issues/32662)) ([b46c77b](https://github.com/Koenkk/zigbee2mqtt/commit/b46c77bff0612527bdfc7540ea31ec258bd002b1))
+* Drop redundant types js yaml ([#32619](https://github.com/Koenkk/zigbee2mqtt/issues/32619)) ([c9ddef7](https://github.com/Koenkk/zigbee2mqtt/commit/c9ddef703a1f83a2dc5c84a1a1eaa087bee3f671))
+* Fix restartRequired flag ([#31947](https://github.com/Koenkk/zigbee2mqtt/issues/31947)) ([4174e9c](https://github.com/Koenkk/zigbee2mqtt/commit/4174e9cb783b73527349182b35e06eda4512b101))
+* Home Assistant: discover device trigger when mqtt output = attribute_and_json and add warnings about incompatible settings ([#32603](https://github.com/Koenkk/zigbee2mqtt/issues/32603)) ([d6dea17](https://github.com/Koenkk/zigbee2mqtt/commit/d6dea17961e05b8ca8ce05d7852efd483031260d))
+* Home Assistant: fix action published to wrong topic ([#32544](https://github.com/Koenkk/zigbee2mqtt/issues/32544)) ([a80c2db](https://github.com/Koenkk/zigbee2mqtt/commit/a80c2db4c6038426fa5102477f6da34355f54134))
+* **ignore:** bump @types/node from 24.13.2 to 26.1.0 ([#32453](https://github.com/Koenkk/zigbee2mqtt/issues/32453)) ([83ca274](https://github.com/Koenkk/zigbee2mqtt/commit/83ca2746a789bb92bfdb51506e875edfe5cb06b3))
+* **ignore:** bump actions/setup-node from 6 to 7 ([#32574](https://github.com/Koenkk/zigbee2mqtt/issues/32574)) ([e889592](https://github.com/Koenkk/zigbee2mqtt/commit/e889592baf9b2738c7d2088247ea3f888cd08629))
+* **ignore:** bump the minor-patch group with 2 updates ([#32504](https://github.com/Koenkk/zigbee2mqtt/issues/32504)) ([8f0d981](https://github.com/Koenkk/zigbee2mqtt/commit/8f0d9817652f97414d927e2d3e4f2b101e3d55ca))
+* **ignore:** bump the minor-patch group with 2 updates ([#32514](https://github.com/Koenkk/zigbee2mqtt/issues/32514)) ([74478fd](https://github.com/Koenkk/zigbee2mqtt/commit/74478fd955dc434e039fac547bfe69db5a2f55ae))
+* **ignore:** bump the minor-patch group with 3 updates ([#32692](https://github.com/Koenkk/zigbee2mqtt/issues/32692)) ([3348cea](https://github.com/Koenkk/zigbee2mqtt/commit/3348cea190125b9a466434cc5ea95ab7a857559d))
+* **ignore:** bump the minor-patch group with 5 updates ([#32452](https://github.com/Koenkk/zigbee2mqtt/issues/32452)) ([e8ba0b2](https://github.com/Koenkk/zigbee2mqtt/commit/e8ba0b24f8b8528e98904234a32515713f457781))
+* **ignore:** bump throttleit from 2.1.0 to 3.0.0 ([#32551](https://github.com/Koenkk/zigbee2mqtt/issues/32551)) ([3f7c0ca](https://github.com/Koenkk/zigbee2mqtt/commit/3f7c0ca71502a2a522a11587a878534f1fd42fe1))
+* **ignore:** bump typescript from 6.0.3 to 7.0.2 ([#32552](https://github.com/Koenkk/zigbee2mqtt/issues/32552)) ([fa12ebe](https://github.com/Koenkk/zigbee2mqtt/commit/fa12ebe27c1598e7ac1108f3e3d7d3ffbe2eccab))
+* **ignore:** bump ws from 8.21.0 to 8.21.1 in the minor-patch group across 1 directory ([#32624](https://github.com/Koenkk/zigbee2mqtt/issues/32624)) ([bbad134](https://github.com/Koenkk/zigbee2mqtt/commit/bbad134e8ea420200e6b5f75a17bd5a5a9d601fe))
+* **ignore:** bump zigbee2mqtt-windfront from 2.12.1 to 2.13.0 in the minor-patch group ([#32550](https://github.com/Koenkk/zigbee2mqtt/issues/32550)) ([66db1bd](https://github.com/Koenkk/zigbee2mqtt/commit/66db1bdbcd8b6303c82d7c77679860537b0868e1))
+* **ignore:** Remove attribute_and_json warnings for HA ([#32616](https://github.com/Koenkk/zigbee2mqtt/issues/32616)) ([5e56c45](https://github.com/Koenkk/zigbee2mqtt/commit/5e56c454c3fee03c43152c807ec3e449d6211728))
+* **ignore:** update zigbee-herdsman to 10.6.2 ([#32500](https://github.com/Koenkk/zigbee2mqtt/issues/32500)) ([6e55716](https://github.com/Koenkk/zigbee2mqtt/commit/6e557162cbf548735c5d907231cec69fa94f6c53))
+* **ignore:** update zigbee-herdsman to 10.6.3 ([#32623](https://github.com/Koenkk/zigbee2mqtt/issues/32623)) ([b8d388c](https://github.com/Koenkk/zigbee2mqtt/commit/b8d388ca7afce29cc6f09c452cbe5c01e79d8244))
+* **ignore:** update zigbee-herdsman to 10.8.0 ([#32701](https://github.com/Koenkk/zigbee2mqtt/issues/32701)) ([28e410b](https://github.com/Koenkk/zigbee2mqtt/commit/28e410bbf442f32e9be4298d19fe45ac586b8a88))
+* **ignore:** update zigbee-herdsman-converters to 26.77.0 ([#32462](https://github.com/Koenkk/zigbee2mqtt/issues/32462)) ([4b0c306](https://github.com/Koenkk/zigbee2mqtt/commit/4b0c3067ffeef42d66417445480048a8e546bc68))
+* **ignore:** update zigbee-herdsman-converters to 26.78.0 ([#32489](https://github.com/Koenkk/zigbee2mqtt/issues/32489)) ([f88d992](https://github.com/Koenkk/zigbee2mqtt/commit/f88d99294b8dc42f8657673e80b7ed721220db40))
+* **ignore:** update zigbee-herdsman-converters to 26.79.0 ([#32499](https://github.com/Koenkk/zigbee2mqtt/issues/32499)) ([a2973f2](https://github.com/Koenkk/zigbee2mqtt/commit/a2973f21f6cfebc175b6b1acfcb73ca7cab95c5f))
+* **ignore:** update zigbee-herdsman-converters to 26.80.0 ([#32522](https://github.com/Koenkk/zigbee2mqtt/issues/32522)) ([912fe4c](https://github.com/Koenkk/zigbee2mqtt/commit/912fe4c250f514f6a0e3c97cf1438b15cef1ec6a))
+* **ignore:** update zigbee-herdsman-converters to 26.81.0 ([#32543](https://github.com/Koenkk/zigbee2mqtt/issues/32543)) ([e475de1](https://github.com/Koenkk/zigbee2mqtt/commit/e475de15c901c493dc93f4194fe55b9359712ce3))
+* **ignore:** update zigbee-herdsman-converters to 26.82.0 ([#32572](https://github.com/Koenkk/zigbee2mqtt/issues/32572)) ([576e195](https://github.com/Koenkk/zigbee2mqtt/commit/576e1954efcbe39d8209284e37e4df223a3f37a8))
+* **ignore:** update zigbee-herdsman-converters to 26.83.0 ([#32581](https://github.com/Koenkk/zigbee2mqtt/issues/32581)) ([22d85a6](https://github.com/Koenkk/zigbee2mqtt/commit/22d85a6729f5bbba72308c58123b0b6345f6095a))
+* **ignore:** update zigbee-herdsman-converters to 26.84.0 ([#32598](https://github.com/Koenkk/zigbee2mqtt/issues/32598)) ([e78b23f](https://github.com/Koenkk/zigbee2mqtt/commit/e78b23f5ebeb388402cae31db982759385e74fc5))
+* **ignore:** update zigbee-herdsman-converters to 26.85.0 ([#32612](https://github.com/Koenkk/zigbee2mqtt/issues/32612)) ([752ab37](https://github.com/Koenkk/zigbee2mqtt/commit/752ab37302cffaa2cad664e5f43c61451e099ee6))
+* **ignore:** update zigbee-herdsman-converters to 26.86.0 ([756a824](https://github.com/Koenkk/zigbee2mqtt/commit/756a824488377f973b710d6293b8deadc310ce42))
+* **ignore:** update zigbee-herdsman-converters to 26.87.0 ([#32660](https://github.com/Koenkk/zigbee2mqtt/issues/32660)) ([e6e0b6f](https://github.com/Koenkk/zigbee2mqtt/commit/e6e0b6f8f2b498b771625019b52d42ccbd4aa967))
+* **ignore:** update zigbee-herdsman-converters to 26.88.0 ([#32674](https://github.com/Koenkk/zigbee2mqtt/issues/32674)) ([3bec9e8](https://github.com/Koenkk/zigbee2mqtt/commit/3bec9e87b17985b59e8a50d3c27677056838d26b))
+* **ignore:** update zigbee-herdsman-converters to 26.89.0 ([#32700](https://github.com/Koenkk/zigbee2mqtt/issues/32700)) ([b29fc0e](https://github.com/Koenkk/zigbee2mqtt/commit/b29fc0e49352f583d418a36bc6708d5745d1a788))
+* **ignore:** update zigbee-herdsman-converters to 26.90.0 ([#32715](https://github.com/Koenkk/zigbee2mqtt/issues/32715)) ([e5e36ac](https://github.com/Koenkk/zigbee2mqtt/commit/e5e36ac79c2e1b89ac0fb81f95bcd655455531c1))
+* Publish groups on device leave ([#32676](https://github.com/Koenkk/zigbee2mqtt/issues/32676)) ([fe96204](https://github.com/Koenkk/zigbee2mqtt/commit/fe96204f0b0f2b858ec664d408eb21545dc791d2))
+* Refresh exposes after manual device configure ([#32486](https://github.com/Koenkk/zigbee2mqtt/issues/32486)) ([344776b](https://github.com/Koenkk/zigbee2mqtt/commit/344776b63379ab91bf7b35e9c208cff0f88bb84b))
+* Remove json-stable-stringify-without-jsonify dep ([#32643](https://github.com/Koenkk/zigbee2mqtt/issues/32643)) ([4f18b4e](https://github.com/Koenkk/zigbee2mqtt/commit/4f18b4e38c276c515eb3b132e3328b88ff62bf95))
+* Replace jszip with fflate ([#32683](https://github.com/Koenkk/zigbee2mqtt/issues/32683)) ([316413b](https://github.com/Koenkk/zigbee2mqtt/commit/316413b31c760c4b34c5afb14222bca11236d9d0))
+* replace rimraf with native fs.rmSync ([#32579](https://github.com/Koenkk/zigbee2mqtt/issues/32579)) ([a9ce4b2](https://github.com/Koenkk/zigbee2mqtt/commit/a9ce4b2522c2d0a5bfcae3497cd98d3889b6f440))
+* Replace source-map-support with native Node source map support ([#32620](https://github.com/Koenkk/zigbee2mqtt/issues/32620)) ([2d94100](https://github.com/Koenkk/zigbee2mqtt/commit/2d941000a73e83fbee983e98121510a6710183fc))
+* Support Node 26, remove Node 20 support ([#32508](https://github.com/Koenkk/zigbee2mqtt/issues/32508)) ([5591207](https://github.com/Koenkk/zigbee2mqtt/commit/5591207deaea177c0019fe679f4e197e2efcb286))
+
+## [2.12.1](https://github.com/Koenkk/zigbee2mqtt/compare/2.12.0...2.12.1) (2026-06-30)
+
+
+### Bug Fixes
+
+* Add `mqtt.server_name` option to override TLS SNI ([#32417](https://github.com/Koenkk/zigbee2mqtt/issues/32417)) ([2f26083](https://github.com/Koenkk/zigbee2mqtt/commit/2f26083ce13c30227ac8d1d891751d4c253b3572))
+* Docker: bump alpine from 3.23 to 3.24 ([#32311](https://github.com/Koenkk/zigbee2mqtt/issues/32311)) ([758a80b](https://github.com/Koenkk/zigbee2mqtt/commit/758a80b30c5162b9adb0c2be1785670276905e09))
+* Home Assistant: add conductivity discovery for soil_fertility ([#32356](https://github.com/Koenkk/zigbee2mqtt/issues/32356)) ([29ee3a7](https://github.com/Koenkk/zigbee2mqtt/commit/29ee3a7552017e648c534708a93329e8b3fc52c5))
+* Home Assistant: allow discovery user overrides to win over converter ([#32361](https://github.com/Koenkk/zigbee2mqtt/issues/32361)) ([20ab0a2](https://github.com/Koenkk/zigbee2mqtt/commit/20ab0a2a4f44b760b6db73d105dc8578426b27a0))
+* Home Assistant: apply expose-level Home Assistant discovery metadata ([#32380](https://github.com/Koenkk/zigbee2mqtt/issues/32380)) ([0140708](https://github.com/Koenkk/zigbee2mqtt/commit/0140708076fbd99d33d896e8f214b0e2a8aad8f3))
+* Home Assistant: mark device settings as config ([#32439](https://github.com/Koenkk/zigbee2mqtt/issues/32439)) ([e8a7e6f](https://github.com/Koenkk/zigbee2mqtt/commit/e8a7e6f29da3773ffc2bda63623298a307fbb597))
+* Home Assistant: mark legacy action sensors diagnostic ([#32377](https://github.com/Koenkk/zigbee2mqtt/issues/32377)) ([72be1d7](https://github.com/Koenkk/zigbee2mqtt/commit/72be1d746bb79fda65b056e4441dcd73bf6c69c6))
+* Home Assistant: mark thermostat configuration switches as config ([#32378](https://github.com/Koenkk/zigbee2mqtt/issues/32378)) ([98a0f94](https://github.com/Koenkk/zigbee2mqtt/commit/98a0f9487072cf5a64a901f305c20a73e25c594b))
+* Home Assistant: pass device options to HA discovery overrides ([#32379](https://github.com/Koenkk/zigbee2mqtt/issues/32379)) ([814552a](https://github.com/Koenkk/zigbee2mqtt/commit/814552a615d33ac24c38160f7a24514c7b358623))
+* Home Assistant: support cooling setpoint in climate discovery ([#32411](https://github.com/Koenkk/zigbee2mqtt/issues/32411)) ([0018ca8](https://github.com/Koenkk/zigbee2mqtt/commit/0018ca8f809708d22221c9d557b3208ba2e5c057))
+* Home Assistant: unit conversion for derived weather sensors by restoring device_class with name preservation ([#32392](https://github.com/Koenkk/zigbee2mqtt/issues/32392)) ([7775ac5](https://github.com/Koenkk/zigbee2mqtt/commit/7775ac5cd2ae3929580e401640d97b20facf1491))
+* **ignore:** bump actions/cache from 5 to 6 ([#32394](https://github.com/Koenkk/zigbee2mqtt/issues/32394)) ([280442b](https://github.com/Koenkk/zigbee2mqtt/commit/280442b6710c03cfa4776d69a14396b29d32c4ba))
+* **ignore:** bump actions/checkout from 6 to 7 ([#32368](https://github.com/Koenkk/zigbee2mqtt/issues/32368)) ([679436e](https://github.com/Koenkk/zigbee2mqtt/commit/679436e09b40edea5bb17094e9aa9115733b916f))
+* **ignore:** bump js-yaml from 4.2.0 to 5.0.0 ([#32371](https://github.com/Koenkk/zigbee2mqtt/issues/32371)) ([262139a](https://github.com/Koenkk/zigbee2mqtt/commit/262139a43f878ceef2f327369432e33b74fbd972))
+* **ignore:** bump semver from 7.8.4 to 7.8.5 in the minor-patch group ([#32369](https://github.com/Koenkk/zigbee2mqtt/issues/32369)) ([9a7cac1](https://github.com/Koenkk/zigbee2mqtt/commit/9a7cac1e4c82c1b0ef566b13620e2d4d438d725e))
+* **ignore:** bump the minor-patch group with 3 updates ([#32312](https://github.com/Koenkk/zigbee2mqtt/issues/32312)) ([719de7a](https://github.com/Koenkk/zigbee2mqtt/commit/719de7adcfffc64e2e9133142045e5dd56e4e8d4))
+* **ignore:** update zigbee-herdsman to 10.4.1 ([#32333](https://github.com/Koenkk/zigbee2mqtt/issues/32333)) ([2f44449](https://github.com/Koenkk/zigbee2mqtt/commit/2f4444995361257cbeef0c780532381ec6cc254f))
+* **ignore:** update zigbee-herdsman to 10.4.2 ([#32388](https://github.com/Koenkk/zigbee2mqtt/issues/32388)) ([628f97f](https://github.com/Koenkk/zigbee2mqtt/commit/628f97f498747cd2e6be5808c7c609b948af528f))
+* **ignore:** update zigbee-herdsman to 10.5.0 ([#32406](https://github.com/Koenkk/zigbee2mqtt/issues/32406)) ([6ab52df](https://github.com/Koenkk/zigbee2mqtt/commit/6ab52df08af1e9b80eb4b58752b7f403d52844a7))
+* **ignore:** update zigbee-herdsman to 10.6.0 ([#32422](https://github.com/Koenkk/zigbee2mqtt/issues/32422)) ([dcb16b8](https://github.com/Koenkk/zigbee2mqtt/commit/dcb16b8271349390deee9dc0a0ca4d02239a54bc))
+* **ignore:** update zigbee-herdsman to 10.6.1 ([#32442](https://github.com/Koenkk/zigbee2mqtt/issues/32442)) ([f867694](https://github.com/Koenkk/zigbee2mqtt/commit/f86769483102762798272655c4fb117f33263489))
+* **ignore:** update zigbee-herdsman-converters to 26.64.0 ([#32282](https://github.com/Koenkk/zigbee2mqtt/issues/32282)) ([a68419f](https://github.com/Koenkk/zigbee2mqtt/commit/a68419f0f58324c1809055938cc59bdd07442aa9))
+* **ignore:** update zigbee-herdsman-converters to 26.65.0 ([#32298](https://github.com/Koenkk/zigbee2mqtt/issues/32298)) ([f4f97d1](https://github.com/Koenkk/zigbee2mqtt/commit/f4f97d19208ab951256b69fd7673bfaba667af65))
+* **ignore:** update zigbee-herdsman-converters to 26.66.0 ([#32315](https://github.com/Koenkk/zigbee2mqtt/issues/32315)) ([299b9e6](https://github.com/Koenkk/zigbee2mqtt/commit/299b9e64f52c99d1d3034321e82fc40a49bec604))
+* **ignore:** update zigbee-herdsman-converters to 26.67.0 ([#32334](https://github.com/Koenkk/zigbee2mqtt/issues/32334)) ([95c67c0](https://github.com/Koenkk/zigbee2mqtt/commit/95c67c0e2271e24a236dabe717772c16f52a3017))
+* **ignore:** update zigbee-herdsman-converters to 26.68.0 ([#32340](https://github.com/Koenkk/zigbee2mqtt/issues/32340)) ([1de8609](https://github.com/Koenkk/zigbee2mqtt/commit/1de860945645e748d6173a0368c4ccb44e9f5f13))
+* **ignore:** update zigbee-herdsman-converters to 26.69.0 ([#32350](https://github.com/Koenkk/zigbee2mqtt/issues/32350)) ([0377f96](https://github.com/Koenkk/zigbee2mqtt/commit/0377f965a3a3c21e42afb885f8b3685d6de2fdd1))
+* **ignore:** update zigbee-herdsman-converters to 26.70.0 ([#32357](https://github.com/Koenkk/zigbee2mqtt/issues/32357)) ([c6e7d2d](https://github.com/Koenkk/zigbee2mqtt/commit/c6e7d2dd16b1a7369b8f784caf3ceed6296a9da2))
+* **ignore:** update zigbee-herdsman-converters to 26.71.0 ([#32375](https://github.com/Koenkk/zigbee2mqtt/issues/32375)) ([8768952](https://github.com/Koenkk/zigbee2mqtt/commit/87689523ae685258fa20ee8c03b7a09e8df0f4ba))
+* **ignore:** update zigbee-herdsman-converters to 26.72.0 ([#32387](https://github.com/Koenkk/zigbee2mqtt/issues/32387)) ([b58503b](https://github.com/Koenkk/zigbee2mqtt/commit/b58503bb57054e24855bcde353b43be6a61273c6))
+* **ignore:** update zigbee-herdsman-converters to 26.73.0 ([#32407](https://github.com/Koenkk/zigbee2mqtt/issues/32407)) ([8d5fdad](https://github.com/Koenkk/zigbee2mqtt/commit/8d5fdada38ce32f8e9ee86b3e39b2e00e2e76529))
+* **ignore:** update zigbee-herdsman-converters to 26.74.0 ([#32420](https://github.com/Koenkk/zigbee2mqtt/issues/32420)) ([31fb3a6](https://github.com/Koenkk/zigbee2mqtt/commit/31fb3a6e895170993e893e9ea0d63c6600859259))
+* **ignore:** update zigbee-herdsman-converters to 26.75.0 ([#32431](https://github.com/Koenkk/zigbee2mqtt/issues/32431)) ([3760e63](https://github.com/Koenkk/zigbee2mqtt/commit/3760e631835c8e6e11cea5241bb2c8cf3d374722))
+* **ignore:** update zigbee-herdsman-converters to 26.76.0 ([#32441](https://github.com/Koenkk/zigbee2mqtt/issues/32441)) ([740de2d](https://github.com/Koenkk/zigbee2mqtt/commit/740de2d363109707a90cdfa8c019361f4423a1aa))
+* improve zigbee2mqtt maintenance path ([#32255](https://github.com/Koenkk/zigbee2mqtt/issues/32255)) ([ced6d93](https://github.com/Koenkk/zigbee2mqtt/commit/ced6d93d20502f115d4d0b17b5d292fee7ad30e4))
+* Republish bridge/state online when HA comes online ([#32258](https://github.com/Koenkk/zigbee2mqtt/issues/32258)) ([a81e90b](https://github.com/Koenkk/zigbee2mqtt/commit/a81e90b9812acd795a11a78b6d0489c080dc8f5b))
+
+## [2.12.0](https://github.com/Koenkk/zigbee2mqtt/compare/2.11.0...2.12.0) (2026-06-09)
+
+
+### Features
+
+* Add ability to abort running OTA ([#32022](https://github.com/Koenkk/zigbee2mqtt/issues/32022)) ([de58711](https://github.com/Koenkk/zigbee2mqtt/commit/de58711e11a5ca07c5b55a0c17a1d9f3f452c110))
+
+
+### Bug Fixes
+
+* **ignore:** bump the minor-patch group across 1 directory with 3 updates ([#32236](https://github.com/Koenkk/zigbee2mqtt/issues/32236)) ([41f6886](https://github.com/Koenkk/zigbee2mqtt/commit/41f688659119012a9a84063bd67c2769a1b1892c))
+* **ignore:** bump the minor-patch group with 2 updates ([#32183](https://github.com/Koenkk/zigbee2mqtt/issues/32183)) ([ef8dcb4](https://github.com/Koenkk/zigbee2mqtt/commit/ef8dcb4dc2800defd97fda7523297eab8d2566dc))
+* **ignore:** missing type for new OTA endpoint ([#32195](https://github.com/Koenkk/zigbee2mqtt/issues/32195)) ([6c2c874](https://github.com/Koenkk/zigbee2mqtt/commit/6c2c874641ada9cae1c9bdd963a3201cb1cf0fef))
+* **ignore:** update zigbee-herdsman to 10.2.0 ([#32179](https://github.com/Koenkk/zigbee2mqtt/issues/32179)) ([f9e1bac](https://github.com/Koenkk/zigbee2mqtt/commit/f9e1bac588e65b223e75f4a2b2e9d528933fdbd8))
+* **ignore:** update zigbee-herdsman to 10.3.0 ([#32193](https://github.com/Koenkk/zigbee2mqtt/issues/32193)) ([ea6ccac](https://github.com/Koenkk/zigbee2mqtt/commit/ea6ccac9380af1d9f5672174b2545409f36c2769))
+* **ignore:** update zigbee-herdsman to 10.4.0 ([#32249](https://github.com/Koenkk/zigbee2mqtt/issues/32249)) ([582f153](https://github.com/Koenkk/zigbee2mqtt/commit/582f1538961af9c1b6434e6a1bc4acebc63a2541))
+* **ignore:** update zigbee-herdsman-converters to 26.61.2 ([#32180](https://github.com/Koenkk/zigbee2mqtt/issues/32180)) ([babf7a1](https://github.com/Koenkk/zigbee2mqtt/commit/babf7a17d4617217297eef45f6b8307265f9b921))
+* **ignore:** update zigbee-herdsman-converters to 26.62.0 ([#32194](https://github.com/Koenkk/zigbee2mqtt/issues/32194)) ([120f6ac](https://github.com/Koenkk/zigbee2mqtt/commit/120f6ac779c9fda6914fc68c56674e589c0e82ba))
+* **ignore:** update zigbee-herdsman-converters to 26.63.0 ([#32252](https://github.com/Koenkk/zigbee2mqtt/issues/32252)) ([68daf4f](https://github.com/Koenkk/zigbee2mqtt/commit/68daf4f1deafad3ee6e542acbd77d403340e2caa))
+
 ## [2.11.0](https://github.com/Koenkk/zigbee2mqtt/compare/2.10.1...2.11.0) (2026-06-01)
 
 

biome.json

@@ -1,5 +1,5 @@
 {
-    "$schema": "https://biomejs.dev/schemas/2.4.16/schema.json",
+    "$schema": "https://biomejs.dev/schemas/2.5.3/schema.json",
     "vcs": {
         "enabled": true,
         "clientKind": "git",
@@ -12,7 +12,7 @@
         "bracketSpacing": false
     },
     "files": {
-        "includes": ["**", "!package.json", "!!**/dist", "!!**/coverage"]
+        "includes": ["**", "!package.json", "!!**/dist", "!!**/coverage", "!images"]
     },
     "linter": {
         "includes": ["**"],

docker/Dockerfile

@@ -1,6 +1,6 @@
 ARG TARGETPLATFORM
 
-FROM alpine:3.23 AS base
+FROM alpine:3.24 AS base
 
 ENV NODE_ENV=production
 WORKDIR /app

index.js

@@ -1,7 +1,7 @@
 const fs = require("node:fs");
 const path = require("node:path");
 const {exec} = require("node:child_process");
-require("source-map-support").install();
+process.setSourceMapsEnabled(true);
 
 /** @type {import("./dist/controller").Controller | undefined} */
 let controller;
@@ -12,7 +12,7 @@ let unsolicitedStop = false;
 let watchdogDelays = [2000, 60000, 300000, 900000, 1800000, 3600000];
 
 if (process.env.Z2M_WATCHDOG != null && process.env.Z2M_WATCHDOG !== "default") {
-    if (/^\d+(.\d+)?(,\d+(.\d+)?)*$/.test(process.env.Z2M_WATCHDOG)) {
+    if (/^\d+(\.\d+)?(,\d+(\.\d+)?)*$/.test(process.env.Z2M_WATCHDOG)) {
         watchdogDelays = process.env.Z2M_WATCHDOG.split(",").map((v) => Number.parseFloat(v) * 60000);
     } else {
         console.log(`Invalid watchdog delays (must use number-only CSV format representing minutes, example: 'Z2M_WATCHDOG=1,5,15,30,60'.`);

lib/controller.ts

@@ -1,5 +1,4 @@
 import bind from "bind-decorator";
-import stringify from "json-stable-stringify-without-jsonify";
 import {setLogger as zhSetLogger} from "zigbee-herdsman";
 import {setLogger as zhcSetLogger} from "zigbee-herdsman-converters";
 import EventBus from "./eventBus";
@@ -24,6 +23,7 @@ import type {Zigbee2MQTTAPI} from "./types/api";
 import logger from "./util/logger";
 import {initSdNotify} from "./util/sd-notify";
 import * as settings from "./util/settings";
+import {stringify} from "./util/stringify";
 import utils from "./util/utils";
 import Zigbee from "./zigbee";
 
@@ -462,7 +462,7 @@ export class Controller {
     async iteratePayloadAttributeOutput(topicRoot: string, payload: KeyValue, options: Partial<MqttPublishOptions>): Promise<void> {
         for (const [key, value] of Object.entries(payload)) {
             let subPayload = value;
-            let message = null;
+            let message: string | undefined;
 
             // Special cases
             if (key === "color" && utils.objectHasProperties(subPayload, ["r", "g", "b"])) {
@@ -480,7 +480,7 @@ export class Controller {
                 message = typeof subPayload === "string" ? subPayload : stringify(subPayload);
             }
 
-            if (message !== null) {
+            if (message !== undefined) {
                 await this.mqtt.publish(`${topicRoot}${key}`, message, options);
             }
         }

lib/eventBus.ts

@@ -247,19 +247,20 @@ export default class EventBus {
             this.callbacksByExtension.set(key.constructor.name, []);
         }
 
-        const wrappedCallback = async (...args: never[]): Promise<void> => {
+        const typedCallback = callback as (...args: EventBusMap[K]) => Promise<void> | void;
+        const wrappedCallback = (async (...args: EventBusMap[K]): Promise<void> => {
             try {
-                await callback(...args);
+                await typedCallback(...args);
             } catch (error) {
                 logger.error(`EventBus error '${key.constructor.name}/${event}': ${(error as Error).message}`);
                 // biome-ignore lint/style/noNonNullAssertion: always Error
                 logger.debug((error as Error).stack!);
             }
-        };
+        }) as EventBusListener<keyof EventBusMap>;
 
         // biome-ignore lint/style/noNonNullAssertion: just created if wasn't valid
         this.callbacksByExtension.get(key.constructor.name)!.push({event, callback: wrappedCallback});
-        this.emitter.on(event, wrappedCallback as EventBusListener<K>);
+        (this.emitter as events.EventEmitter).on(event, wrappedCallback);
     }
 
     public removeListeners(key: ListenerKey): void {
@@ -267,7 +268,7 @@ export default class EventBus {
 
         if (callbacks) {
             for (const cb of callbacks) {
-                this.emitter.removeListener(cb.event, cb.callback);
+                (this.emitter as events.EventEmitter).removeListener(cb.event, cb.callback);
             }
         }
     }

lib/extension/bind.ts

@@ -1,7 +1,6 @@
 import assert from "node:assert";
 import bind from "bind-decorator";
 import debounce from "debounce";
-import stringify from "json-stable-stringify-without-jsonify";
 import {Zcl} from "zigbee-herdsman";
 import type {TClusterAttributeKeys} from "zigbee-herdsman/dist/zspec/zcl/definition/clusters-types";
 import type {ClusterName} from "zigbee-herdsman/dist/zspec/zcl/definition/tstype";
@@ -10,6 +9,7 @@ import Group from "../model/group";
 import type {Zigbee2MQTTAPI, Zigbee2MQTTResponseEndpoints} from "../types/api";
 import logger from "../util/logger";
 import * as settings from "../util/settings";
+import {stringify} from "../util/stringify";
 import utils, {DEFAULT_BIND_GROUP_ID} from "../util/utils";
 import Extension from "./extension";
 

lib/extension/bridge.ts

@@ -1,8 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import bind from "bind-decorator";
-import stringify from "json-stable-stringify-without-jsonify";
-import JSZip from "jszip";
+import {zip} from "fflate";
 import objectAssignDeep from "object-assign-deep";
 import type winston from "winston";
 import Transport from "winston-transport";
@@ -15,6 +14,7 @@ import type {Zigbee2MQTTAPI, Zigbee2MQTTDevice, Zigbee2MQTTResponse, Zigbee2MQTT
 import data from "../util/data";
 import logger from "../util/logger";
 import * as settings from "../util/settings";
+import {stringify} from "../util/stringify";
 import utils, {assertString, DEFAULT_BIND_GROUP_ID} from "../util/utils";
 import Extension from "./extension";
 
@@ -141,6 +141,7 @@ export default class Bridge extends Extension {
             await this.mqtt.publish("bridge/event", stringify(payload));
         });
         this.eventBus.onDeviceLeave(this, async (data) => {
+            await this.publishGroups();
             await this.publishDevices();
             await this.publishDefinitions();
 
@@ -243,7 +244,10 @@ export default class Bridge extends Extension {
         }
 
         const newSettings = message.options as Partial<Settings>;
-        this.restartRequired = settings.apply(newSettings);
+        const newRestartRequired = settings.apply(newSettings);
+        if (newRestartRequired) {
+            this.restartRequired = newRestartRequired;
+        }
 
         // Apply some settings on-the-fly.
         if (newSettings.homeassistant) {
@@ -262,7 +266,11 @@ export default class Bridge extends Extension {
             logger.setDebugNamespaceIgnore(settings.get().advanced.log_debug_namespace_ignore);
         }
 
-        logger.info("Successfully changed options");
+        if (newRestartRequired) {
+            logger.info("Changes require restart to take effect");
+        } else {
+            logger.info("Successfully changed options");
+        }
         await this.publishInfo();
         return utils.getResponse(message, {restart_required: this.restartRequired});
     }
@@ -321,7 +329,7 @@ export default class Bridge extends Extension {
         await this.zigbee.backup();
         const dataPath = data.getPath();
         const files = utils.getAllFiles(dataPath);
-        const zip = new JSZip();
+        const zipFiles: Record<string, Uint8Array> = {};
         const logDir = `log${path.sep}`;
         const otaDir = `ota${path.sep}`;
 
@@ -330,12 +338,17 @@ export default class Bridge extends Extension {
 
             // XXX: `log` could technically be something else depending on `log_directory` setting
             if (!name.startsWith(logDir) && !name.startsWith(otaDir)) {
-                zip.file(name, fs.readFileSync(f));
+                zipFiles[name] = fs.readFileSync(f);
             }
         }
 
-        const base64Zip = await zip.generateAsync({type: "base64"});
-        return utils.getResponse(message, {zip: base64Zip});
+        const zipContent = await new Promise<Uint8Array>((resolve, reject) => {
+            // `jszip` defaulted to `STORE`, so backups used to be uncompressed; `fflate`'s default level shrinks them substantially
+            zip(zipFiles, {level: 6}, (error, data) => (error ? reject(error) : resolve(data)));
+        });
+
+        // TODO: replace with `zipContent.toBase64()` once the Node requirement is >=25
+        return utils.getResponse(message, {zip: Buffer.from(zipContent).toString("base64")});
     }
 
     @bind async installCodeAdd(message: KeyValue | string): Promise<Zigbee2MQTTResponse<"bridge/response/install_code/add">> {
@@ -464,12 +477,16 @@ export default class Bridge extends Extension {
             }
         }
 
-        const restartRequired = settings.changeEntityOptions(ID, message.options);
-        if (restartRequired) this.restartRequired = true;
+        const newRestartRequired = settings.changeEntityOptions(ID, message.options);
+        if (newRestartRequired) this.restartRequired = true;
         const newOptions = cleanup(entity.options);
         await this.publishInfo();
 
-        logger.info(`Changed config for ${entityType} ${ID}`);
+        if (newRestartRequired) {
+            logger.info(`New config for ${entityType} ${ID} requires restart to take effect`);
+        } else {
+            logger.info(`Successfully changed config for ${entityType} ${ID}`);
+        }
 
         this.eventBus.emitEntityOptionsChanged({from: oldOptions, to: newOptions, entity});
         return utils.getResponse(message, {from: oldOptions, to: newOptions, id: ID, restart_required: this.restartRequired});
@@ -653,20 +670,25 @@ export default class Bridge extends Extension {
         entityType: T,
         message: string | KeyValue,
     ): Promise<Zigbee2MQTTResponse<T extends "device" ? "bridge/response/device/remove" : "bridge/response/group/remove">> {
-        const ID = typeof message === "object" ? message.id : message.trim();
+        const messageIsObject = typeof message === "object";
+        const ID = messageIsObject ? message.id : message.trim();
         const entity = this.getEntity(entityType, ID);
         // note: entity.name is dynamically retrieved, will change once device is removed (friendly => ieee)
         const friendlyName = entity.name;
         let block = false;
         let force = false;
+        let clearCache = false;
         let blockForceLog = "";
 
-        if (entityType === "device" && typeof message === "object") {
-            block = !!message.block;
-            force = !!message.force;
-            blockForceLog = ` (block: ${block}, force: ${force})`;
-        } else if (entityType === "group" && typeof message === "object") {
-            force = !!message.force;
+        if (entityType === "device" && messageIsObject) {
+            const payload = message as Zigbee2MQTTAPI["bridge/request/device/remove"];
+            block = !!payload.block;
+            force = !!payload.force;
+            clearCache = !!payload.clear_cache;
+            blockForceLog = ` (block: ${block}, force: ${force}, clear cache: ${clearCache})`;
+        } else if (entityType === "group" && messageIsObject) {
+            const payload = message as Zigbee2MQTTAPI["bridge/request/group/remove"];
+            force = !!payload.force;
             blockForceLog = ` (force: ${force})`;
         }
 
@@ -679,9 +701,13 @@ export default class Bridge extends Extension {
                 }
 
                 if (force) {
-                    entity.zh.removeFromDatabase();
+                    entity.zh.removeFromDatabase(clearCache);
                 } else {
-                    await entity.zh.removeFromNetwork();
+                    await entity.zh.removeFromNetwork(clearCache);
+                }
+
+                if (clearCache) {
+                    this.zigbee.removeDeviceFromLookup(entity.ID);
                 }
 
                 settings.removeDevice(entity.ID as string);
@@ -706,19 +732,18 @@ export default class Bridge extends Extension {
 
             logger.info(`Successfully removed ${entityType} '${friendlyName}'${blockForceLog}`);
 
+            await this.publishGroups();
+
             if (entity instanceof Device) {
-                await this.publishGroups();
                 await this.publishDevices();
                 // Refresh Cluster definition
                 await this.publishDefinitions();
 
-                const responseData: Zigbee2MQTTAPI["bridge/response/device/remove"] = {id: ID, block, force};
+                const responseData: Zigbee2MQTTAPI["bridge/response/device/remove"] = {id: ID, block, force, clear_cache: clearCache};
 
                 return utils.getResponse(message, responseData);
             }
 
-            await this.publishGroups();
-
             const responseData: Zigbee2MQTTAPI["bridge/response/group/remove"] = {id: ID, force};
 
             return utils.getResponse(

lib/extension/configure.ts

@@ -1,9 +1,9 @@
 import bind from "bind-decorator";
-import stringify from "json-stable-stringify-without-jsonify";
 import Device from "../model/device";
 import type {Zigbee2MQTTAPI} from "../types/api";
 import logger from "../util/logger";
 import * as settings from "../util/settings";
+import {stringify} from "../util/stringify";
 import utils from "../util/utils";
 import Extension from "./extension";
 
@@ -137,7 +137,7 @@ export default class Configure extends Extension {
             logger.info(`Successfully configured '${device.name}' (definition v${definitionVersion})`);
             device.zh.meta.configured = definitionVersion;
             device.zh.save();
-            this.eventBus.emitDevicesChanged();
+            this.eventBus.emitExposesAndDevicesChanged(device);
         } catch (error) {
             const newAttempts = attempts + 1;
             this.attempts.set(device.ieeeAddr, newAttempts);

lib/extension/externalJS.ts

@@ -2,12 +2,11 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import bind from "bind-decorator";
-import stringify from "json-stable-stringify-without-jsonify";
 import type {Zigbee2MQTTAPI, Zigbee2MQTTResponse} from "../types/api";
-
 import data from "../util/data";
 import logger from "../util/logger";
 import * as settings from "../util/settings";
+import {stringify} from "../util/stringify";
 import utils from "../util/utils";
 import Extension from "./extension";
 

lib/extension/frontend.ts

@@ -8,12 +8,11 @@ import {posix} from "node:path";
 import bind from "bind-decorator";
 import expressStaticGzip from "express-static-gzip";
 import finalhandler from "finalhandler";
-import stringify from "json-stable-stringify-without-jsonify";
 import WebSocket from "ws";
-
 import data from "../util/data";
 import logger from "../util/logger";
 import * as settings from "../util/settings";
+import {stringify} from "../util/stringify";
 import utils from "../util/utils";
 import Extension from "./extension";
 

lib/extension/groups.ts

@@ -1,13 +1,13 @@
 import assert from "node:assert";
 import bind from "bind-decorator";
 import equals from "fast-deep-equal/es6";
-import stringify from "json-stable-stringify-without-jsonify";
 import type * as zhc from "zigbee-herdsman-converters";
 import Device from "../model/device";
 import Group from "../model/group";
 import type {Zigbee2MQTTAPI, Zigbee2MQTTResponseEndpoints} from "../types/api";
 import logger from "../util/logger";
 import * as settings from "../util/settings";
+import {stringify} from "../util/stringify";
 import utils, {isLightExpose} from "../util/utils";
 import Extension from "./extension";
 

lib/extension/homeassistant.ts

@@ -1,10 +1,10 @@
 import assert from "node:assert";
 import bind from "bind-decorator";
-import stringify from "json-stable-stringify-without-jsonify";
 import type * as zhc from "zigbee-herdsman-converters";
 import type {Zh} from "zigbee-herdsman-converters/lib/types";
 import logger from "../util/logger";
 import * as settings from "../util/settings";
+import {stringify} from "../util/stringify";
 import utils, {assertBinaryExpose, assertEnumExpose, assertNumericExpose, isBinaryExpose, isEnumExpose, isNumericExpose} from "../util/utils";
 import Extension from "./extension";
 
@@ -48,17 +48,31 @@ const GROUP_SUPPORTED_TYPES: ReadonlyArray<string> = ["light", "switch", "lock",
 const COVER_OPENING_LOOKUP: ReadonlyArray<string> = ["opening", "open", "forward", "up", "rising"];
 const COVER_CLOSING_LOOKUP: ReadonlyArray<string> = ["closing", "close", "backward", "back", "reverse", "down", "declining"];
 const COVER_STOPPED_LOOKUP: ReadonlyArray<string> = ["stopped", "stop", "pause", "paused"];
-const SWITCH_DIFFERENT: ReadonlyArray<string> = ["valve_detection", "window_detection", "auto_lock", "away_mode"];
+const CONFIG_SWITCH_DISCOVERY_LOOKUP: {[s: string]: KeyValue} = {
+    auto_lock: {entity_category: "config", icon: "mdi:lock"},
+    away_mode: {entity_category: "config", icon: "mdi:home-export-outline"},
+    comfort_smiley: {entity_category: "config", icon: "mdi:emoticon-happy-outline"},
+    enable_display: {entity_category: "config", icon: "mdi:monitor"},
+    indicator: {entity_category: "config", icon: "mdi:led-on"},
+    tilt_mode: {entity_category: "config", icon: "mdi:angle-acute"},
+    valve_detection: {entity_category: "config", icon: "mdi:pipe-valve"},
+    window_detection: {entity_category: "config", icon: "mdi:window-open-variant"},
+} as const;
+const SWITCH_DIFFERENT: ReadonlyArray<string> = Object.keys(CONFIG_SWITCH_DISCOVERY_LOOKUP);
 const BINARY_DISCOVERY_LOOKUP: {[s: string]: KeyValue} = {
     activity_led_indicator: {icon: "mdi:led-on"},
     area1Occupancy: {device_class: "occupancy"},
     area2Occupancy: {device_class: "occupancy"},
     area3Occupancy: {device_class: "occupancy"},
     area4Occupancy: {device_class: "occupancy"},
+    auto_lock: {entity_category: "config", icon: "mdi:lock"},
     auto_off: {icon: "mdi:flash-auto"},
+    away_mode: {entity_category: "config", icon: "mdi:home-export-outline"},
     battery_low: {entity_category: "diagnostic", device_class: "battery"},
     button_lock: {entity_category: "config", icon: "mdi:lock"},
     calibration: {entity_category: "config", icon: "mdi:progress-wrench"},
+    calibration_left: {entity_category: "config", icon: "mdi:progress-wrench"},
+    calibration_right: {entity_category: "config", icon: "mdi:progress-wrench"},
     capabilities_configurable_curve: {entity_category: "diagnostic", icon: "mdi:tune"},
     capabilities_forward_phase_control: {entity_category: "diagnostic", icon: "mdi:tune"},
     capabilities_overload_detection: {entity_category: "diagnostic", icon: "mdi:tune"},
@@ -71,16 +85,22 @@ const BINARY_DISCOVERY_LOOKUP: {[s: string]: KeyValue} = {
     consumer_connected: {device_class: "plug"},
     contact: {device_class: "door"},
     garage_door_contact: {device_class: "garage_door", payload_on: false, payload_off: true},
+    frost_protection: {entity_category: "config", icon: "mdi:snowflake-thermometer"},
+    heating_stop: {entity_category: "config", icon: "mdi:radiator-off"},
     eco_mode: {entity_category: "config", icon: "mdi:leaf"},
+    enable_display: {entity_category: "config", icon: "mdi:monitor"},
     expose_pin: {entity_category: "config", icon: "mdi:pin"},
     flip_indicator_light: {entity_category: "config", icon: "mdi:arrow-left-right"},
     gas: {device_class: "gas"},
+    indicator: {entity_category: "config", icon: "mdi:led-on"},
     indicator_mode: {entity_category: "config", icon: "mdi:led-on"},
     invert_cover: {entity_category: "config", icon: "mdi:arrow-left-right"},
     led_disabled_night: {entity_category: "config", icon: "mdi:led-off"},
     led_indication: {entity_category: "config", icon: "mdi:led-on"},
     led_enable: {entity_category: "config", icon: "mdi:led-on"},
     motor_reversal: {entity_category: "config", icon: "mdi:arrow-left-right"},
+    motor_reversal_left: {entity_category: "config", icon: "mdi:arrow-left-right"},
+    motor_reversal_right: {entity_category: "config", icon: "mdi:arrow-left-right"},
     moving: {device_class: "moving"},
     no_position_support: {entity_category: "config", icon: "mdi:minus-circle-outline"},
     noise_detected: {device_class: "sound"},
@@ -101,14 +121,15 @@ const BINARY_DISCOVERY_LOOKUP: {[s: string]: KeyValue} = {
     temperature_scale: {entity_category: "config", icon: "mdi:temperature-celsius"},
     test: {entity_category: "diagnostic", icon: "mdi:test-tube"},
     th_heater: {icon: "mdi:heat-wave"},
+    tilt_mode: {entity_category: "config", icon: "mdi:angle-acute"},
     trigger_indicator: {icon: "mdi:led-on"},
     valve_alarm: {device_class: "problem"},
-    valve_detection: {icon: "mdi:pipe-valve"},
+    valve_detection: {entity_category: "config", icon: "mdi:pipe-valve"},
     valve_state: {device_class: "opening"},
     vibration: {device_class: "vibration"},
     water_leak: {device_class: "moisture"},
     window: {device_class: "window"},
-    window_detection: {icon: "mdi:window-open-variant"},
+    window_detection: {entity_category: "config", icon: "mdi:window-open-variant"},
     window_open: {device_class: "window"},
 } as const;
 const NUMERIC_DISCOVERY_LOOKUP: {[s: string]: KeyValue} = {
@@ -120,7 +141,7 @@ const NUMERIC_DISCOVERY_LOOKUP: {[s: string]: KeyValue} = {
     alarm_temperature_min: {device_class: "temperature", entity_category: "config", icon: "mdi:thermometer-low"},
     angle: {icon: "angle-acute"},
     angle_axis: {icon: "angle-acute"},
-    apparent_temperature: {icon: "mdi:thermometer-lines", state_class: "measurement"},
+    apparent_temperature: {device_class: "temperature", icon: "mdi:thermometer-lines", preserve_name: true, state_class: "measurement"},
     aqi: {device_class: "aqi", state_class: "measurement"},
     auto_relock_time: {entity_category: "config", icon: "mdi:timer"},
     away_preset_days: {entity_category: "config", icon: "mdi:timer"},
@@ -137,8 +158,14 @@ const NUMERIC_DISCOVERY_LOOKUP: {[s: string]: KeyValue} = {
     boost_time: {entity_category: "config", icon: "mdi:timer"},
     calibration: {entity_category: "config", icon: "mdi:wrench-clock"},
     calibration_time: {entity_category: "config", icon: "mdi:wrench-clock"},
+    calibration_time_left: {entity_category: "config", icon: "mdi:wrench-clock"},
+    calibration_time_right: {entity_category: "config", icon: "mdi:wrench-clock"},
     co2: {device_class: "carbon_dioxide", state_class: "measurement"},
+    comfort_humidity_max: {device_class: "humidity", entity_category: "config", icon: "mdi:water-percent"},
+    comfort_humidity_min: {device_class: "humidity", entity_category: "config", icon: "mdi:water-percent"},
     comfort_temperature: {entity_category: "config", icon: "mdi:thermometer"},
+    comfort_temperature_max: {device_class: "temperature", entity_category: "config", icon: "mdi:thermometer-high"},
+    comfort_temperature_min: {device_class: "temperature", entity_category: "config", icon: "mdi:thermometer-low"},
     cpu_temperature: {
         device_class: "temperature",
         entity_category: "diagnostic",
@@ -149,13 +176,14 @@ const NUMERIC_DISCOVERY_LOOKUP: {[s: string]: KeyValue} = {
     current_phase_b: {device_class: "current", state_class: "measurement"},
     current_phase_c: {device_class: "current", state_class: "measurement"},
     deadzone_temperature: {entity_category: "config", icon: "mdi:thermometer"},
+    detection_delay: {entity_category: "config", icon: "mdi:timer"},
     detection_interval: {icon: "mdi:timer"},
     device_temperature: {
         device_class: "temperature",
         entity_category: "diagnostic",
         state_class: "measurement",
     },
-    dew_point: {icon: "mdi:thermometer-water", state_class: "measurement"},
+    dew_point: {device_class: "temperature", icon: "mdi:thermometer-water", preserve_name: true, state_class: "measurement"},
     distance: {device_class: "distance", state_class: "measurement"},
     duration: {entity_category: "config", icon: "mdi:timer"},
     eco2: {device_class: "volatile_organic_compounds_parts", state_class: "measurement"},
@@ -164,14 +192,15 @@ const NUMERIC_DISCOVERY_LOOKUP: {[s: string]: KeyValue} = {
     external_temperature_input: {device_class: "temperature", icon: "mdi:thermometer"},
     external_temperature: {device_class: "temperature", icon: "mdi:thermometer", state_class: "measurement"},
     external_humidity: {device_class: "humidity", icon: "mdi:water-percent", state_class: "measurement"},
+    fading_time: {entity_category: "config", icon: "mdi:timer"},
     formaldehyd: {state_class: "measurement"},
     flow: {device_class: "volume_flow_rate", state_class: "measurement"},
     gas: {device_class: "gas", state_class: "total_increasing", icon: "mdi:meter-gas"},
     gas_density: {icon: "mdi:google-circles-communities", state_class: "measurement"},
-    gust_speed: {icon: "mdi:weather-windy-variant", state_class: "measurement"},
+    gust_speed: {device_class: "wind_speed", icon: "mdi:weather-windy-variant", preserve_name: true, state_class: "measurement"},
     hcho: {icon: "mdi:air-filter", state_class: "measurement"},
     heat_stress: {icon: "mdi:weather-sunny-alert", state_class: "measurement"},
-    humidex: {icon: "mdi:thermometer-alert", state_class: "measurement"},
+    humidex: {device_class: "temperature", icon: "mdi:thermometer-alert", preserve_name: true, state_class: "measurement"},
     humidity: {device_class: "humidity", state_class: "measurement"},
     humidity_calibration: {entity_category: "config", icon: "mdi:wrench-clock"},
     humidity_max: {entity_category: "config", icon: "mdi:water-percent"},
@@ -179,6 +208,7 @@ const NUMERIC_DISCOVERY_LOOKUP: {[s: string]: KeyValue} = {
     illuminance_calibration: {entity_category: "config", icon: "mdi:wrench-clock"},
     illuminance: {device_class: "illuminance", state_class: "measurement"},
     illuminance_raw: {state_class: "measurement"},
+    interval_time: {entity_category: "config", icon: "mdi:timer"},
     internalTemperature: {
         device_class: "temperature",
         entity_category: "diagnostic",
@@ -192,13 +222,20 @@ const NUMERIC_DISCOVERY_LOOKUP: {[s: string]: KeyValue} = {
     },
     load_estimate: {state_class: "measurement"},
     local_temperature: {device_class: "temperature", state_class: "measurement"},
+    large_motion_detection_distance: {entity_category: "config", icon: "mdi:signal-distance-variant"},
+    large_motion_detection_sensitivity: {entity_category: "config", icon: "mdi:motion-sensor"},
     max_range: {entity_category: "config", icon: "mdi:signal-distance-variant"},
     max_temperature: {entity_category: "config", icon: "mdi:thermometer-high"},
     max_temperature_limit: {entity_category: "config", icon: "mdi:thermometer-high"},
+    maximum_range: {entity_category: "config", icon: "mdi:signal-distance-variant"},
+    measurement_interval: {entity_category: "config", icon: "mdi:clock-out"},
     min_temperature_limit: {entity_category: "config", icon: "mdi:thermometer-low"},
     min_temperature: {entity_category: "config", icon: "mdi:thermometer-low"},
+    minimum_range: {entity_category: "config", icon: "mdi:signal-distance-variant"},
     minimum_on_level: {entity_category: "config"},
     measurement_poll_interval: {entity_category: "config", icon: "mdi:clock-out"},
+    medium_motion_detection_distance: {entity_category: "config", icon: "mdi:signal-distance-variant"},
+    medium_motion_detection_sensitivity: {entity_category: "config", icon: "mdi:motion-sensor"},
     motion_sensitivity: {entity_category: "config", icon: "mdi:motion-sensor"},
     noise: {device_class: "sound_pressure", state_class: "measurement"},
     noise_detect_level: {icon: "mdi:volume-equal"},
@@ -234,13 +271,21 @@ const NUMERIC_DISCOVERY_LOOKUP: {[s: string]: KeyValue} = {
         icon: "mdi:brightness-5",
     },
     smoke_density: {icon: "mdi:google-circles-communities", state_class: "measurement"},
+    sensitivity: {entity_category: "config", icon: "mdi:tune"},
+    small_detection_distance: {entity_category: "config", icon: "mdi:signal-distance-variant"},
+    small_detection_sensitivity: {entity_category: "config", icon: "mdi:motion-sensor"},
+    soil_calibration: {entity_category: "config", icon: "mdi:wrench-clock"},
+    soil_fertility: {device_class: "conductivity", state_class: "measurement"},
     soil_moisture: {device_class: "moisture", state_class: "measurement"},
+    soil_sampling: {entity_category: "config", icon: "mdi:clock-out"},
+    soil_warning: {entity_category: "config", icon: "mdi:water-percent-alert"},
     temperature: {device_class: "temperature", state_class: "measurement"},
     temperature_probe: {device_class: "temperature", state_class: "measurement"},
     temperature_calibration: {entity_category: "config", icon: "mdi:wrench-clock"},
     temperature_max: {entity_category: "config", icon: "mdi:thermometer-plus"},
     temperature_min: {entity_category: "config", icon: "mdi:thermometer-minus"},
     temperature_offset: {icon: "mdi:thermometer-lines"},
+    temperature_sampling: {entity_category: "config", icon: "mdi:clock-out"},
     transition: {entity_category: "config", icon: "mdi:transition"},
     trigger_count: {icon: "mdi:counter", enabled_by_default: false, state_class: "measurement"},
     uv_index: {icon: "mdi:white-balance-sunny", state_class: "measurement"},
@@ -255,7 +300,7 @@ const NUMERIC_DISCOVERY_LOOKUP: {[s: string]: KeyValue} = {
         device_class: "water",
         state_class: "total_increasing",
     },
-    wind_chill: {icon: "mdi:snowflake-thermometer", state_class: "measurement"},
+    wind_chill: {device_class: "temperature", icon: "mdi:snowflake-thermometer", preserve_name: true, state_class: "measurement"},
     wind_direction: {icon: "mdi:compass-outline", state_class: "measurement"},
     wind_speed: {device_class: "wind_speed", icon: "mdi:weather-windy", state_class: "measurement"},
     x: {icon: "mdi:axis-x-arrow", state_class: "measurement"},
@@ -287,6 +332,7 @@ const ENUM_DISCOVERY_LOOKUP: {[s: string]: KeyValue} = {
     mode_phase_control: {entity_category: "config", icon: "mdi:tune"},
     mode: {entity_category: "config", icon: "mdi:tune"},
     mode_switch: {icon: "mdi:tune"},
+    motor_direction: {entity_category: "config", icon: "mdi:arrow-left-right"},
     motion_sensitivity: {entity_category: "config", icon: "mdi:tune"},
     operation_mode: {entity_category: "config", icon: "mdi:tune"},
     power_on_behavior: {entity_category: "config", icon: "mdi:power-settings"},
@@ -297,11 +343,13 @@ const ENUM_DISCOVERY_LOOKUP: {[s: string]: KeyValue} = {
     sensitivity: {entity_category: "config", icon: "mdi:tune"},
     sensor: {icon: "mdi:tune"},
     sensors_type: {entity_category: "config", icon: "mdi:tune"},
+    set_limits: {entity_category: "config", icon: "mdi:ray-start-end"},
     sound_volume: {entity_category: "config", icon: "mdi:volume-high"},
     status: {icon: "mdi:state-machine"},
     switch_type: {entity_category: "config", icon: "mdi:tune"},
     temperature_display_mode: {entity_category: "config", icon: "mdi:thermometer"},
     temperature_sensor_select: {entity_category: "config", icon: "mdi:home-thermometer"},
+    temperature_unit: {entity_category: "config", icon: "mdi:temperature-celsius"},
     thermostat_unit: {entity_category: "config", icon: "mdi:thermometer"},
     update: {device_class: "update"},
     volume: {entity_category: "config", icon: "mdi: volume-high"},
@@ -313,7 +361,7 @@ const LIST_DISCOVERY_LOOKUP: {[s: string]: KeyValue} = {
     color_options: {icon: "mdi:palette"},
     level_config: {entity_category: "diagnostic"},
     programming_mode: {icon: "mdi:calendar-clock"},
-    schedule_settings: {icon: "mdi:calendar-clock"},
+    schedule_settings: {entity_category: "config", icon: "mdi:calendar-clock"},
 } as const;
 
 const featurePropertyWithoutEndpoint = (feature: zhc.Feature): string => {
@@ -324,6 +372,44 @@ const featurePropertyWithoutEndpoint = (feature: zhc.Feature): string => {
     return feature.property;
 };
 
+const applyHomeAssistantExposeMetadata = (payload: DiscoveryEntry, homeAssistant: zhc.Expose["homeassistant"]): void => {
+    if (!homeAssistant) {
+        return;
+    }
+
+    if (homeAssistant.type !== undefined) {
+        payload.type = homeAssistant.type;
+    }
+
+    if (homeAssistant.schema !== undefined) {
+        payload.discovery_payload.schema = homeAssistant.schema;
+    }
+
+    if (homeAssistant.entityCategory !== undefined) {
+        payload.discovery_payload.entity_category = homeAssistant.entityCategory;
+    }
+
+    if (homeAssistant.deviceClass !== undefined) {
+        payload.discovery_payload.device_class = homeAssistant.deviceClass;
+    }
+
+    if (homeAssistant.enabledByDefault !== undefined) {
+        payload.discovery_payload.enabled_by_default = homeAssistant.enabledByDefault;
+    }
+
+    if (homeAssistant.icon !== undefined) {
+        payload.discovery_payload.icon = homeAssistant.icon;
+    }
+
+    if (homeAssistant.valueTemplate !== undefined) {
+        if (homeAssistant.valueTemplate === null) {
+            delete payload.discovery_payload.value_template;
+        } else {
+            payload.discovery_payload.value_template = homeAssistant.valueTemplate;
+        }
+    }
+};
+
 /**
  * This class handles the bridge entity configuration for Home Assistant Discovery.
  */
@@ -411,9 +497,13 @@ export class HomeAssistant extends Extension {
     ) {
         super(zigbee, mqtt, state, publishEntityState, eventBus, enableDisableExtension, restartCallback, addExtension);
         if (settings.get().advanced.output === "attribute") {
-            throw new Error("Home Assistant integration is not possible with attribute output!");
+            throw new Error("Home Assistant integration requires 'output: json' under 'advanced'");
         }
 
+        // TODO (Z2M 3.0.0): Prevent starting without cache_state, instead of warning
+        // if (!settings.get().advanced.cache_state) {
+        //     throw new Error("Home Assistant integration is not possible without caching states! Set `cache_state: true` under `advanced`");
+        // }
         const haSettings = settings.get().homeassistant;
         assert(haSettings.enabled, `Home Assistant extension created with setting 'enabled: false'`);
         this.discoveryTopic = haSettings.discovery_topic;
@@ -429,8 +519,9 @@ export class HomeAssistant extends Extension {
     }
 
     override async start(): Promise<void> {
+        // TODO (Z2M 3.0.0): Prevent starting without cache_state, instead of warning
         if (!settings.get().advanced.cache_state) {
-            logger.warning("In order for Home Assistant integration to work properly set `cache_state: true");
+            logger.warning("In order for Home Assistant integration to work properly, set `cache_state: true` under `advanced`");
         }
 
         this.zigbee2MQTTVersion = (await utils.getZigbee2MQTTVersion(false)).version;
@@ -602,25 +693,26 @@ export class HomeAssistant extends Extension {
                     discoveryEntry.discovery_payload.state_off = state.value_off;
                     discoveryEntry.discovery_payload.state_on = state.value_on;
                     discoveryEntry.object_id = property;
-
-                    if (property === "window_detection") {
-                        discoveryEntry.discovery_payload.icon = "mdi:window-open-variant";
-                    }
+                    Object.assign(discoveryEntry.discovery_payload, CONFIG_SWITCH_DISCOVERY_LOOKUP[property]);
                 }
 
                 discoveryEntries.push(discoveryEntry);
                 break;
             }
             case "climate": {
-                const setpointProperties = ["occupied_heating_setpoint", "current_heating_setpoint"];
-                const setpoint = (firstExpose as zhc.Climate).features.filter(isNumericExpose).find((f) => setpointProperties.includes(f.name));
+                const heatingSetpoint = (firstExpose as zhc.Climate).features
+                    .filter(isNumericExpose)
+                    .find((f) => ["occupied_heating_setpoint", "current_heating_setpoint"].includes(f.name));
+                const coolingSetpoint = (firstExpose as zhc.Climate).features
+                    .filter(isNumericExpose)
+                    .find((f) => f.name === "occupied_cooling_setpoint");
+                const primarySetpoint = heatingSetpoint ?? coolingSetpoint;
                 assert(
-                    setpoint && setpoint.value_min !== undefined && setpoint.value_max !== undefined,
+                    primarySetpoint && primarySetpoint.value_min !== undefined && primarySetpoint.value_max !== undefined,
                     "No setpoint found or it is missing value_min/max",
                 );
                 const temperature = (firstExpose as zhc.Climate).features.find((f) => f.name === "local_temperature");
                 assert(temperature, "No temperature found");
-
                 const discoveryEntry: DiscoveryEntry = {
                     type: "climate",
                     object_id: endpointName ? `climate_${endpointName}` : "climate",
@@ -631,9 +723,9 @@ export class HomeAssistant extends Extension {
                         state_topic: false,
                         temperature_unit: "C",
                         // Setpoint
-                        temp_step: setpoint.value_step,
-                        min_temp: setpoint.value_min.toString(),
-                        max_temp: setpoint.value_max.toString(),
+                        temp_step: primarySetpoint.value_step,
+                        min_temp: primarySetpoint.value_min.toString(),
+                        max_temp: primarySetpoint.value_max.toString(),
                         // Temperature
                         current_temperature_topic: true,
                         current_temperature_template: `{{ value_json["${temperature.property}"] }}`,
@@ -662,17 +754,16 @@ export class HomeAssistant extends Extension {
                     discoveryEntry.discovery_payload.action_template = `{% set values = {None:None,'idle':'idle','heat':'heating','cool':'cooling','fan_only':'fan'} %}{{ values[value_json["${state.property}"]] }}`;
                 }
 
-                const coolingSetpoint = (firstExpose as zhc.Climate).features.find((f) => f.name === "occupied_cooling_setpoint");
-                if (coolingSetpoint) {
-                    discoveryEntry.discovery_payload.temperature_low_command_topic = setpoint.name;
-                    discoveryEntry.discovery_payload.temperature_low_state_template = `{{ value_json["${setpoint.property}"] }}`;
+                if (heatingSetpoint && coolingSetpoint) {
+                    discoveryEntry.discovery_payload.temperature_low_command_topic = heatingSetpoint.name;
+                    discoveryEntry.discovery_payload.temperature_low_state_template = `{{ value_json["${heatingSetpoint.property}"] }}`;
                     discoveryEntry.discovery_payload.temperature_low_state_topic = true;
                     discoveryEntry.discovery_payload.temperature_high_command_topic = coolingSetpoint.name;
                     discoveryEntry.discovery_payload.temperature_high_state_template = `{{ value_json["${coolingSetpoint.property}"] }}`;
                     discoveryEntry.discovery_payload.temperature_high_state_topic = true;
                 } else {
-                    discoveryEntry.discovery_payload.temperature_command_topic = setpoint.name;
-                    discoveryEntry.discovery_payload.temperature_state_template = `{{ value_json["${setpoint.property}"] }}`;
+                    discoveryEntry.discovery_payload.temperature_command_topic = primarySetpoint.name;
+                    discoveryEntry.discovery_payload.temperature_state_template = `{{ value_json["${primarySetpoint.property}"] }}`;
                     discoveryEntry.discovery_payload.temperature_state_topic = true;
                 }
 
@@ -1226,6 +1317,7 @@ export class HomeAssistant extends Extension {
                         discovery_payload: {
                             name: endpointName ? `${firstExpose.label} ${endpointName}` : firstExpose.label,
                             value_template: valueTemplate,
+                            ...(firstExpose.property === "action" ? {entity_category: "diagnostic"} : {}),
                             ...ENUM_DISCOVERY_LOOKUP[firstExpose.name],
                         },
                     });
@@ -1335,6 +1427,8 @@ export class HomeAssistant extends Extension {
         }
 
         for (const entry of discoveryEntries) {
+            applyHomeAssistantExposeMetadata(entry, firstExpose.homeassistant);
+
             // If a sensor has entity category `config`, then change
             // it to `diagnostic`. Sensors have no input, so can't be configured.
             // https://github.com/Koenkk/zigbee2mqtt/pull/19474
@@ -1347,8 +1441,9 @@ export class HomeAssistant extends Extension {
                 delete entry.discovery_payload.entity_category;
             }
 
-            // Let Home Assistant generate entity name when device_class is present
-            if (entry.discovery_payload.device_class) {
+            // Let Home Assistant generate entity name when device_class is present.
+            // preserve_name allows device_class and explicit name to coexist (e.g. derived sensors).
+            if (entry.discovery_payload.device_class && !NUMERIC_DISCOVERY_LOOKUP[firstExpose.name]?.preserve_name) {
                 delete entry.discovery_payload.name;
             }
 
@@ -1403,7 +1498,7 @@ export class HomeAssistant extends Extension {
 
                 if (match) {
                     const endpoint = match[1];
-                    const endpointRegExp = new RegExp(`(.*)_${endpoint}`);
+                    const endpointRegExp = new RegExp(`(.*)_${endpoint}$`);
                     const payload: KeyValue = {};
                     for (const key of Object.keys(data.message)) {
                         const keyMatch = endpointRegExp.exec(key);
@@ -1432,10 +1527,12 @@ export class HomeAssistant extends Extension {
          * Whenever a device publish an {action: *} we discover an MQTT device trigger sensor
          * and republish it to zigbee2mqtt/my_device/action
          */
-        if (settings.get().advanced.output === "json" && entity.isDevice() && entity.definition && data.message.action) {
+        if (entity.isDevice() && entity.definition && data.message.action) {
             const value = data.message.action.toString();
             await this.publishDeviceTriggerDiscover(entity, "action", value);
-            await this.mqtt.publish(`${data.entity.name}/action`, value, {});
+            if (settings.get().advanced.output === "json") {
+                await this.mqtt.publish(`${data.entity.name}/action`, value, {});
+            }
         }
     }
 
@@ -1814,7 +1911,16 @@ export class HomeAssistant extends Extension {
                 payload.current_humidity_topic = stateTopic;
             }
 
-            // Override configuration with user settings.
+            if (entity.isDevice()) {
+                try {
+                    entity.definition?.meta?.overrideHaDiscoveryPayload?.(payload, entity.options);
+                } catch (error) {
+                    logger.error(`Failed to override HA discovery payload (${(error as Error).stack})`);
+                }
+            }
+
+            // Override configuration with user settings after converter compatibility
+            // mappings, so per-device configuration remains the final authority.
             if (entity.options.homeassistant != null) {
                 const add = (obj: KeyValue, ignoreName: boolean): void => {
                     for (const key in obj) {
@@ -1845,14 +1951,6 @@ export class HomeAssistant extends Extension {
                 }
             }
 
-            if (entity.isDevice()) {
-                try {
-                    entity.definition?.meta?.overrideHaDiscoveryPayload?.(payload);
-                } catch (error) {
-                    logger.error(`Failed to override HA discovery payload (${(error as Error).stack})`);
-                }
-            }
-
             const topic = this.getDiscoveryTopic(config, entity);
             const payloadStr = stringify(payload);
             newDiscoveredTopics.add(topic);
@@ -1938,6 +2036,9 @@ export class HomeAssistant extends Extension {
             }
         } else if (data.topic === this.statusTopic && data.message.toLowerCase() === "online") {
             const timer = setTimeout(async () => {
+                // Re-publish bridge state so HA marks all entities as available before receiving cached device states.
+                await this.mqtt.publish("bridge/state", stringify({state: "online"}), {clientOptions: {retain: true, qos: 1}});
+
                 // Publish all device states.
                 for (const entity of this.zigbee.devicesAndGroupsIterator(utils.deviceNotCoordinator)) {
                     if (this.state.exists(entity)) {

lib/extension/networkMap.ts

@@ -1,10 +1,10 @@
 import bind from "bind-decorator";
-import stringify from "json-stable-stringify-without-jsonify";
 import type {Eui64} from "zigbee-herdsman/dist/zspec/tstypes";
 import type {LQITableEntry, RoutingTableEntry} from "zigbee-herdsman/dist/zspec/zdo/definition/tstypes";
 import type {Zigbee2MQTTAPI, Zigbee2MQTTNetworkMap} from "../types/api";
 import logger from "../util/logger";
 import * as settings from "../util/settings";
+import {stringify} from "../util/stringify";
 import utils from "../util/utils";
 import Extension from "./extension";
 

lib/extension/otaUpdate.ts

@@ -2,7 +2,6 @@ import assert from "node:assert";
 import {existsSync, mkdirSync, rmSync, writeFileSync} from "node:fs";
 import {join} from "node:path";
 import bind from "bind-decorator";
-import stringify from "json-stable-stringify-without-jsonify";
 import {setOtaConfiguration, Zcl} from "zigbee-herdsman";
 import type {OtaDataSettings, OtaSource, OtaUpdateAvailableResult} from "zigbee-herdsman/dist/controller/tstype";
 import Device from "../model/device";
@@ -10,6 +9,7 @@ import type {Zigbee2MQTTAPI} from "../types/api";
 import dataDir from "../util/data";
 import logger from "../util/logger";
 import * as settings from "../util/settings";
+import {stringify} from "../util/stringify";
 import utils from "../util/utils";
 import Extension from "./extension";
 
@@ -50,7 +50,7 @@ function writeFirmwareHexToDataDir(hex: string, fileName: string | undefined, de
 
 export default class OTAUpdate extends Extension {
     #topicRegex = new RegExp(
-        `^${settings.get().mqtt.base_topic}/bridge/request/device/ota_update/(update|check|schedule|unschedule)/?(downgrade)?`,
+        `^${settings.get().mqtt.base_topic}/bridge/request/device/ota_update/(update|check|schedule|unschedule)/?(downgrade|abort)?`,
         "i",
     );
     #inProgress = new Set<string>();
@@ -248,6 +248,7 @@ export default class OTAUpdate extends Extension {
             | Zigbee2MQTTAPI["bridge/request/device/ota_update/check/downgrade"]
             | Zigbee2MQTTAPI["bridge/request/device/ota_update/update"]
             | Zigbee2MQTTAPI["bridge/request/device/ota_update/update/downgrade"]
+            | Zigbee2MQTTAPI["bridge/request/device/ota_update/update/abort"]
             | Zigbee2MQTTAPI["bridge/request/device/ota_update/schedule"]
             | Zigbee2MQTTAPI["bridge/request/device/ota_update/schedule/downgrade"]
             | Zigbee2MQTTAPI["bridge/request/device/ota_update/unschedule"];
@@ -258,18 +259,31 @@ export default class OTAUpdate extends Extension {
             assert(message.id, "Invalid payload");
         }
 
-        const ID = (messageObject ? message.id : message) as string;
-        const device = this.zigbee.resolveEntity(ID);
+        const id = (messageObject ? message.id : message) as string;
+        const device = this.zigbee.resolveEntity(id);
         const type = topicMatch[1] as "check" | "update" | "schedule" | "unschedule";
         const downgrade = topicMatch[2] === "downgrade";
+        const abort = topicMatch[2] === "abort";
         let error: string | undefined;
         let errorStack: string | undefined;
 
         if (!(device instanceof Device)) {
-            error = `Device '${ID}' does not exist`;
+            error = `Device '${id}' does not exist`;
         } else if (this.#inProgress.has(device.ieeeAddr)) {
-            // also guards against scheduling while check/update op in progress that could result in undesired OTA state
-            error = `OTA update or check for update already in progress for '${device.name}'`;
+            if (abort) {
+                device.zh.abortOta();
+                this.#inProgress.delete(device.ieeeAddr);
+                // cleanup same as a fail
+                this.#removeProgressAndRemainingFromState(device);
+                await this.publishEntityState(device, this.#getEntityPublishPayload(device, "available"));
+                await this.mqtt.publish(
+                    "bridge/response/device/ota_update/update/abort",
+                    stringify(utils.getResponse<"bridge/response/device/ota_update/update/abort">(message, {id})),
+                );
+            } else {
+                // also guards against scheduling while check/update op in progress that could result in undesired OTA state
+                error = `OTA update or check for update already in progress for '${device.name}'`;
+            }
         } else {
             switch (type) {
                 case "check": {
@@ -304,7 +318,7 @@ export default class OTAUpdate extends Extension {
                         this.#lastChecked.set(device.ieeeAddr, Date.now());
 
                         const response = utils.getResponse<"bridge/response/device/ota_update/check">(message, {
-                            id: ID,
+                            id,
                             update_available: availableResult.available,
                             downgrade: source.downgrade,
                             source: availableResult.availableMeta?.url,
@@ -321,6 +335,11 @@ export default class OTAUpdate extends Extension {
                 }
 
                 case "update": {
+                    if (abort) {
+                        error = `No OTA in progress to abort for device '${device.name}'`;
+                        break;
+                    }
+
                     this.#inProgress.add(device.ieeeAddr);
 
                     const otaSettings = settings.get().ota;
@@ -378,7 +397,7 @@ export default class OTAUpdate extends Extension {
 
                         const firmwareTo = await this.#readSoftwareBuildIDAndDateCode(device);
                         const response = utils.getResponse<"bridge/response/device/ota_update/update">(message, {
-                            id: ID,
+                            id,
                             from: {
                                 file_version: fromVersion,
                                 software_build_id: firmwareFrom?.softwareBuildID,
@@ -427,7 +446,7 @@ export default class OTAUpdate extends Extension {
                     device.zh.scheduleOta(source);
                     await this.publishEntityState(device, this.#getEntityPublishPayload(device, "scheduled"));
 
-                    const response = utils.getResponse<"bridge/response/device/ota_update/schedule">(message, {id: ID, url: source.url});
+                    const response = utils.getResponse<"bridge/response/device/ota_update/schedule">(message, {id, url: source.url});
 
                     await this.mqtt.publish("bridge/response/device/ota_update/schedule", stringify(response));
 
@@ -442,9 +461,7 @@ export default class OTAUpdate extends Extension {
                     device.zh.unscheduleOta();
                     await this.publishEntityState(device, this.#getEntityPublishPayload(device, "idle"));
 
-                    const response = utils.getResponse<"bridge/response/device/ota_update/unschedule">(message, {
-                        id: ID,
-                    });
+                    const response = utils.getResponse<"bridge/response/device/ota_update/unschedule">(message, {id});
 
                     await this.mqtt.publish("bridge/response/device/ota_update/unschedule", stringify(response));
 

lib/extension/publish.ts

@@ -1,11 +1,10 @@
 import bind from "bind-decorator";
-import stringify from "json-stable-stringify-without-jsonify";
 import type * as zhc from "zigbee-herdsman-converters";
-
 import Device from "../model/device";
 import Group from "../model/group";
 import logger from "../util/logger";
 import * as settings from "../util/settings";
+import {stringify} from "../util/stringify";
 import utils from "../util/utils";
 import Extension from "./extension";
 

lib/extension/receive.ts

@@ -1,14 +1,11 @@
 import assert from "node:assert";
-
 import bind from "bind-decorator";
 import debounce from "debounce";
-import stringify from "json-stable-stringify-without-jsonify";
 import throttle from "throttleit";
-
 import * as zhc from "zigbee-herdsman-converters";
-
 import logger from "../util/logger";
 import * as settings from "../util/settings";
+import {stringify} from "../util/stringify";
 import utils from "../util/utils";
 import Extension from "./extension";
 

lib/model/device.ts

@@ -18,6 +18,7 @@ export default class Device {
     public zh: zh.Device;
     public definition?: zhc.Definition;
     private _definitionModelID?: string;
+    #isResolvingDefinition?: boolean;
 
     get ieeeAddr(): string {
         return this.zh.ieeeAddr;
@@ -64,9 +65,11 @@ export default class Device {
     }
 
     async resolveDefinition(ignoreCache = false): Promise<void> {
-        if (this.interviewed && (!this.definition || this._definitionModelID !== this.zh.modelID || ignoreCache)) {
+        if (this.interviewed && !this.#isResolvingDefinition && (!this.definition || this._definitionModelID !== this.zh.modelID || ignoreCache)) {
+            this.#isResolvingDefinition = true;
             this.definition = await zhc.findByDevice(this.zh, true);
             this._definitionModelID = this.zh.modelID;
+            this.#isResolvingDefinition = false;
         }
     }
 

lib/mqtt.ts

@@ -109,6 +109,11 @@ export default class Mqtt {
             options.rejectUnauthorized = false;
         }
 
+        if (mqttSettings.server_name) {
+            logger.debug(`MQTT SSL/TLS: SNI server name = ${mqttSettings.server_name}`);
+            options.servername = mqttSettings.server_name;
+        }
+
         this.client = await connectAsync(mqttSettings.server, options);
 
         // https://github.com/Koenkk/zigbee2mqtt/issues/9822

lib/types/api.ts

@@ -133,6 +133,7 @@ export interface Zigbee2MQTTSettings {
         cert?: string;
         client_id?: string;
         reject_unauthorized?: boolean;
+        server_name?: string;
         maximum_packet_size: number;
     };
     serial: {
@@ -621,12 +622,14 @@ export interface Zigbee2MQTTAPI {
         id: string;
         block?: boolean;
         force?: boolean;
+        clear_cache?: boolean;
     };
 
     "bridge/response/device/remove": {
         id: string;
         block: boolean;
         force: boolean;
+        clear_cache: boolean;
     };
 
     "bridge/request/device/ota_update/check": {
@@ -677,6 +680,14 @@ export interface Zigbee2MQTTAPI {
         default_maximum_data_size?: number | null;
     };
 
+    "bridge/request/device/ota_update/update/abort": {
+        id: string;
+    };
+
+    "bridge/response/device/ota_update/update/abort": {
+        id: string;
+    };
+
     "bridge/response/device/ota_update/update": {
         id: string;
         from:
@@ -1001,6 +1012,7 @@ export type Zigbee2MQTTRequestEndpoints =
     | "bridge/request/device/ota_update/check/downgrade"
     | "bridge/request/device/ota_update/update"
     | "bridge/request/device/ota_update/update/downgrade"
+    | "bridge/request/device/ota_update/update/abort"
     | "bridge/request/device/ota_update/schedule"
     | "bridge/request/device/ota_update/schedule/downgrade"
     | "bridge/request/device/ota_update/unschedule"
@@ -1050,6 +1062,7 @@ export type Zigbee2MQTTResponseEndpoints =
     | "bridge/response/device/remove"
     | "bridge/response/device/ota_update/check"
     | "bridge/response/device/ota_update/update"
+    | "bridge/response/device/ota_update/update/abort"
     | "bridge/response/device/ota_update/schedule"
     | "bridge/response/device/ota_update/unschedule"
     | "bridge/response/device/interview"

lib/types/dom.shim.d.ts

@@ -1,8 +1,5 @@
 // minimal required because of sub-deps in mqtt >= 5.14.0 to avoid requiring `dom` type
 declare global {
-    // map to node, doesn't really matter, just needs to be there, and the right "type vs value" to avoid lib check problems
-    /** @deprecated DOM SHIM, DO NOT USE */
-    type MessagePort = import("node:worker_threads").MessagePort;
     /** @deprecated DOM SHIM, DO NOT USE */
     type Worker = import("node:worker_threads").Worker;
     /** @deprecated DOM SHIM, DO NOT USE */

lib/types/json-stable-stringify-without-jsonify.d.ts

@@ -1,3 +0,0 @@
-declare module "json-stable-stringify-without-jsonify" {
-    export default function (obj: unknown): string;
-}

lib/types/zigbee2mqtt-frontend.d.ts

@@ -6,7 +6,7 @@ declare module "zigbee2mqtt-frontend" {
     export default frontend;
 }
 
-declare module "http" {
+declare module "node:http" {
     interface IncomingMessage {
         originalUrl?: string;
         path?: string;

lib/util/logger.ts

@@ -2,7 +2,6 @@ import assert from "node:assert";
 import fs from "node:fs";
 import path from "node:path";
 
-import {rimrafSync} from "rimraf";
 import winston from "winston";
 import * as settings from "./settings";
 
@@ -235,7 +234,7 @@ class Logger {
             for (const dir of directories) {
                 this.debug(`Removing old log directory '${dir.path}'`);
                 try {
-                    rimrafSync(dir.path);
+                    fs.rmSync(dir.path, {recursive: true, force: true});
                 } catch (e) {
                     this.error(`Failed to remove old log directory '${dir.path}': ${e}`);
                 }

lib/util/onboarding.ts

@@ -3,11 +3,11 @@ import type {ServerResponse} from "node:http";
 import {createServer} from "node:http";
 import path from "node:path";
 import expressStaticGzip from "express-static-gzip";
+import {type Unzipped, unzip} from "fflate";
 import finalhandler from "finalhandler";
-import stringify from "json-stable-stringify-without-jsonify";
-import JSZip from "jszip";
 import {findAllDevices} from "zigbee-herdsman/dist/adapter/adapterDiscovery";
 import type {OnboardData, OnboardFailureData, OnboardSubmitResponse, Zigbee2MQTTSettings} from "../types/api";
+import {stringify} from "../util/stringify";
 import data from "./data";
 import * as settings from "./settings";
 import {YAMLFileException} from "./yaml";
@@ -49,20 +49,22 @@ function getZipEntryTargetPath(entryName: string): string {
 }
 
 async function extractZipDataToDataPath(zipContent: Buffer): Promise<void> {
-    const zip = await JSZip.loadAsync(zipContent);
+    const entries = await new Promise<Unzipped>((resolve, reject) => {
+        unzip(zipContent, (error, data) => (error ? reject(error) : resolve(data)));
+    });
 
-    for (const key in zip.files) {
-        const entry = zip.files[key];
-        const targetPath = getZipEntryTargetPath(entry.name);
+    for (const name in entries) {
+        const targetPath = getZipEntryTargetPath(name);
 
-        if (entry.dir) {
+        // directory entries are identified by a trailing slash
+        if (name.endsWith("/")) {
             mkdirSync(targetPath, {recursive: true});
 
             continue;
         }
 
         mkdirSync(path.dirname(targetPath), {recursive: true});
-        writeFileSync(targetPath, await entry.async("nodebuffer"));
+        writeFileSync(targetPath, entries[name]);
     }
 }
 

lib/util/settings.schema.json

@@ -9,7 +9,7 @@
                 "enabled": {
                     "type": "boolean",
                     "title": "Enabled",
-                    "description": "Enable Home Assistant integration",
+                    "description": "Enable Home Assistant integration. Also check 'cache_state' and 'output' options under 'advanced'.",
                     "default": false,
                     "requiresRestart": true
                 },
@@ -33,12 +33,14 @@
                     "type": "boolean",
                     "title": "Home Assistant legacy action sensors",
                     "description": "Home Assistant legacy actions sensor, when enabled a action sensor will be discoverd and an empty `action` will be send after every published action.",
+                    "requiresRestart": true,
                     "default": false
                 },
                 "experimental_event_entities": {
                     "type": "boolean",
                     "title": "Home Assistant experimental event entities",
                     "description": "Home Assistant experimental event entities, when enabled Zigbee2MQTT will add event entities for exposed actions. The events and attributes are currently deemed experimental and subject to change.",
+                    "requiresRestart": true,
                     "default": false
                 }
             },
@@ -188,6 +190,13 @@
                     "description": "Disable self-signed SSL certificate",
                     "default": true
                 },
+                "server_name": {
+                    "type": "string",
+                    "title": "TLS server name (SNI)",
+                    "requiresRestart": true,
+                    "description": "Override the TLS SNI / hostname used for certificate verification when it differs from the host in 'server' (e.g. connecting to an internal service DNS name while validating a public certificate SAN). Leave unset to use the hostname from 'server'.",
+                    "examples": ["mqtt.example.com"]
+                },
                 "include_device_information": {
                     "type": "boolean",
                     "title": "Include device information",
@@ -739,7 +748,7 @@
                 "cache_state": {
                     "type": "boolean",
                     "title": "Cache state",
-                    "description": "MQTT message payload will contain all attributes, not only changed ones. Has to be true when integrating via Home Assistant",
+                    "description": "MQTT message payload will contain all attributes, not only changed ones. Must be true when integrating via Home Assistant",
                     "default": true
                 },
                 "cache_state_persistent": {
@@ -806,7 +815,7 @@
                     "type": "string",
                     "enum": ["attribute_and_json", "attribute", "json"],
                     "title": "MQTT output type",
-                    "description": "Examples when 'state' of a device is published json: topic: 'zigbee2mqtt/my_bulb' payload '{\"state\": \"ON\"}' attribute: topic 'zigbee2mqtt/my_bulb/state' payload 'ON' attribute_and_json: both json and attribute (see above)",
+                    "description": "How the 'state' of a device is published. json: topic 'zigbee2mqtt/my_bulb' payload '{\"state\": \"ON\"}'. attribute: topic 'zigbee2mqtt/my_bulb/state' payload 'ON'. attribute_and_json: both json and attribute (see above). Home Assistant requires json",
                     "default": "json"
                 },
                 "enable_external_js": {

lib/util/stringify.ts

@@ -0,0 +1,153 @@
+// Stable stringify inspired by https://github.com/BridgeAR/safe-stable-stringify
+// Takes advantage of Node env and Z2M's object-only use-case.
+
+// biome-ignore lint/suspicious/noControlCharactersInRegex: escape regex
+const STR_ESC_SEQ_REGEXP = /[\u0000-\u001f\u0022\u005c\ud800-\udfff]/;
+
+// Escape C0 control characters, double quotes, the backslash and every code
+// unit with a numeric value in the inclusive range 0xD800 to 0xDFFF.
+function strEscape(str: string): string {
+    // Some magic numbers that worked out fine while benchmarking with v8 8.0
+    if (str.length < 5000 && !STR_ESC_SEQ_REGEXP.test(str)) {
+        return `"${str}"`;
+    }
+
+    return JSON.stringify(str);
+}
+
+function sort(array: string[]) {
+    // Insertion sort is very efficient for small input sizes, but it has a bad
+    // worst case complexity. Thus, use native array sort for bigger values.
+    if (array.length > 2e2) {
+        return array.sort();
+    }
+
+    for (let i = 1; i < array.length; i++) {
+        const currentValue = array[i];
+        let position = i;
+
+        while (position !== 0 && array[position - 1] > currentValue) {
+            array[position] = array[position - 1];
+            position--;
+        }
+
+        array[position] = currentValue;
+    }
+}
+
+function isTypedArray(value: unknown): value is unknown[] {
+    return ArrayBuffer.isView(value) && !(value instanceof DataView);
+}
+
+function stringifyTypedArray(array: unknown[]): string {
+    const isBigInt = typeof array[0] === "bigint";
+    let res = `"0":${isBigInt ? `"${array[0]}"` : array[0]}`;
+
+    for (let i = 1; i < array.length; i++) {
+        res += `,"${i}":${isBigInt ? `"${array[1]}"` : array[1]}`;
+    }
+
+    return res;
+}
+
+function stringifySimple(key: string, value: unknown, stack: unknown[]): string | undefined {
+    switch (typeof value) {
+        case "string":
+            return strEscape(value);
+        case "object": {
+            if (value === null) {
+                return "null";
+            }
+
+            if ("toJSON" in value && typeof value.toJSON === "function") {
+                value = value.toJSON(key);
+
+                // Prevent calling `toJSON` again
+                if (typeof value !== "object") {
+                    return stringifySimple(key, value, stack);
+                }
+
+                if (value === null) {
+                    return "null";
+                }
+            }
+
+            if (stack.indexOf(value) !== -1) {
+                return '"[Circular]"';
+            }
+
+            let res = "";
+
+            if (Array.isArray(value)) {
+                if (value.length === 0) {
+                    return "[]";
+                }
+
+                stack.push(value);
+
+                let i = 0;
+
+                for (; i < value.length - 1; i++) {
+                    const tmp = stringifySimple(`${i}`, value[i], stack);
+                    res += tmp !== undefined ? tmp : "null";
+                    res += ",";
+                }
+
+                const tmp = stringifySimple(`${i}`, value[i], stack);
+                res += tmp !== undefined ? tmp : "null";
+
+                stack.pop();
+
+                return `[${res}]`;
+            }
+
+            let keys = Object.keys(value);
+            const keysLength = keys.length;
+
+            if (keysLength === 0) {
+                return "{}";
+            }
+
+            let separator = "";
+            let propsToStringify = keysLength;
+
+            if (isTypedArray(value)) {
+                res += stringifyTypedArray(value);
+                keys = keys.slice(value.length);
+                propsToStringify -= value.length;
+                separator = ",";
+            }
+
+            sort(keys);
+            stack.push(value);
+
+            for (let i = 0; i < propsToStringify; i++) {
+                const valKey = keys[i];
+                const tmp = stringifySimple(valKey, (value as Record<string, unknown>)[valKey], stack);
+
+                if (tmp !== undefined) {
+                    res += `${separator}${strEscape(valKey)}:${tmp}`;
+                    separator = ",";
+                }
+            }
+
+            stack.pop();
+
+            return `{${res}}`;
+        }
+        case "number":
+            return Number.isFinite(value) ? `${value}` : "null";
+        case "boolean":
+            return value === true ? "true" : "false";
+        case "undefined":
+            return undefined;
+        case "bigint":
+            return `"${value}"`;
+        default:
+            return undefined;
+    }
+}
+
+export function stringify(value: object): string {
+    return stringifySimple("", value, []) ?? "null";
+}

lib/util/yaml.ts

@@ -2,7 +2,7 @@ import assert from "node:assert";
 import fs from "node:fs";
 
 import equals from "fast-deep-equal/es6";
-import yaml, {YAMLException} from "js-yaml";
+import {dump, load, YAMLException} from "js-yaml";
 
 export class YAMLFileException extends YAMLException {
     file: string;
@@ -20,7 +20,7 @@ export class YAMLFileException extends YAMLException {
 
 function read(file: string): KeyValue {
     try {
-        const result = yaml.load(fs.readFileSync(file, "utf8"));
+        const result = load(fs.readFileSync(file, "utf8"));
         assert(result instanceof Object, `The content of ${file} is expected to be an object`);
         return result as KeyValue;
     } catch (error) {
@@ -40,7 +40,7 @@ function writeIfChanged(file: string, content: KeyValue): void {
     const before = readIfExists(file);
 
     if (!equals(before, content)) {
-        fs.writeFileSync(file, yaml.dump(content));
+        fs.writeFileSync(file, dump(content));
     }
 }
 

lib/zigbee.ts

@@ -1,6 +1,5 @@
 import {randomInt} from "node:crypto";
 import bind from "bind-decorator";
-import stringify from "json-stable-stringify-without-jsonify";
 import type {Events as ZHEvents} from "zigbee-herdsman";
 import {Controller} from "zigbee-herdsman";
 import type {StartResult} from "zigbee-herdsman/dist/adapter/tstype";
@@ -9,6 +8,7 @@ import Group from "./model/group";
 import data from "./util/data";
 import logger from "./util/logger";
 import * as settings from "./util/settings";
+import {stringify} from "./util/stringify";
 import utils from "./util/utils";
 
 const entityIDRegex = /^(.+?)(?:\/([^/]+))?$/;
@@ -61,7 +61,7 @@ export default class Zigbee {
 
         logger.debug(
             () =>
-                `Using zigbee-herdsman with settings: '${stringify(JSON.stringify(herdsmanSettings).replaceAll(JSON.stringify(herdsmanSettings.network.networkKey), '"HIDDEN"'))}'`,
+                `Using zigbee-herdsman with settings: '${stringify(herdsmanSettings).replaceAll(stringify(herdsmanSettings.network.networkKey), '"HIDDEN"')}'`,
         );
 
         let startResult: StartResult;
@@ -467,7 +467,11 @@ export default class Zigbee {
         return this.resolveGroup(id);
     }
 
-    removeGroupFromLookup(id: number): void {
-        this.groupLookup.delete(id);
+    removeDeviceFromLookup(ieee: string): boolean {
+        return this.deviceLookup.delete(ieee);
+    }
+
+    removeGroupFromLookup(id: number): boolean {
+        return this.groupLookup.delete(id);
     }
 }

package.json

@@ -1,6 +1,6 @@
 {
     "name": "zigbee2mqtt",
-    "version": "2.11.0",
+    "version": "2.13.0",
     "description": "Zigbee to MQTT bridge using Zigbee-herdsman",
     "main": "index.js",
     "types": "dist/types/api.d.ts",
@@ -10,7 +10,7 @@
         "url": "git+https://github.com/Koenkk/zigbee2mqtt.git"
     },
     "engines": {
-        "node": "^20.15.0 || ^22.2.0 || ^24"
+        "node": "^22.2.0 || ^24 || ^26"
     },
     "keywords": [
         "xiaomi",
@@ -33,7 +33,7 @@
         "test:watch": "vitest watch --config ./test/vitest.config.mts",
         "bench": "vitest bench --run --config ./test/vitest.config.mts",
         "prepack": "pnpm run clean && pnpm run build",
-        "clean": "rimraf coverage dist tsconfig.tsbuildinfo"
+        "clean": "node -e \"for (const p of ['coverage', 'dist', 'tsconfig.tsbuildinfo']) require('node:fs').rmSync(p, {recursive: true, force: true, maxRetries: process.platform === 'win32' ? 10 : 0})\""
     },
     "author": "Koen Kanters",
     "license": "GPL-3.0",
@@ -47,39 +47,35 @@
         "debounce": "^3.0.0",
         "express-static-gzip": "^3.0.1",
         "fast-deep-equal": "^3.1.3",
+        "fflate": "^0.8.3",
         "finalhandler": "^2.1.1",
-        "humanize-duration": "^3.33.2",
-        "js-yaml": "^4.1.0",
-        "json-stable-stringify-without-jsonify": "^1.0.1",
-        "jszip": "^3.10.1",
-        "mqtt": "^5.15.1",
+        "humanize-duration": "^3.34.0",
+        "js-yaml": "^5.2.2",
+        "mqtt": "^5.15.2",
         "object-assign-deep": "^0.4.0",
-        "rimraf": "^6.1.3",
-        "semver": "^7.8.1",
-        "source-map-support": "^0.5.21",
-        "throttleit": "^2.1.0",
+        "semver": "^7.8.5",
+        "throttleit": "^3.0.0",
         "winston": "^3.19.0",
         "winston-syslog": "^2.7.1",
         "winston-transport": "^4.9.0",
-        "ws": "^8.21.0",
-        "zigbee-herdsman": "10.1.0",
-        "zigbee-herdsman-converters": "26.61.1",
+        "ws": "^8.21.1",
+        "zigbee-herdsman": "10.8.0",
+        "zigbee-herdsman-converters": "26.90.0",
         "zigbee2mqtt-frontend": "0.9.21",
-        "zigbee2mqtt-windfront": "2.11.3"
+        "zigbee2mqtt-windfront": "2.14.0"
     },
     "devDependencies": {
-        "@biomejs/biome": "^2.4.16",
+        "@biomejs/biome": "^2.5.3",
         "@types/finalhandler": "^1.2.3",
         "@types/humanize-duration": "^3.27.4",
-        "@types/js-yaml": "^4.0.9",
-        "@types/node": "^24.12.4",
+        "@types/node": "^26.1.2",
         "@types/object-assign-deep": "^0.4.3",
-        "@types/readable-stream": "4.0.23",
+        "@types/readable-stream": "4.0.24",
         "@types/serve-static": "^2.2.0",
         "@types/ws": "8.18.1",
         "@vitest/coverage-v8": "^3.1.1",
         "tmp": "^0.2.7",
-        "typescript": "^6.0.3",
+        "typescript": "^7.0.2",
         "vitest": "^3.1.1"
     },
     "pnpm": {
@@ -99,4 +95,4 @@
     "optionalDependencies": {
         "unix-dgram": "^2.0.7"
     }
-}
+}

test/controller.bench.ts

@@ -1,5 +1,4 @@
 import {existsSync, mkdirSync} from "node:fs";
-import stringify from "json-stable-stringify-without-jsonify";
 import {bench, describe, vi} from "vitest";
 import {type Controller, Zcl, Zdo, ZSpec} from "zigbee-herdsman";
 import type Adapter from "zigbee-herdsman/dist/adapter/adapter";
@@ -12,6 +11,7 @@ import type {DeviceType} from "zigbee-herdsman/dist/controller/tstype";
 import {Foundation} from "zigbee-herdsman/dist/zspec/zcl/definition/foundation";
 import type {RequestToResponseMap} from "zigbee-herdsman/dist/zspec/zdo/definition/tstypes";
 import data from "../lib/util/data";
+import {stringify} from "../lib/util/stringify";
 import {BENCH_OPTIONS} from "./benchOptions";
 
 vi.doMock("zigbee-herdsman", async (importOriginal) => {
@@ -257,7 +257,7 @@ const adapter = {
                 switch (zclFrame.command.ID) {
                     case Foundation.read.ID: {
                         for (const attr of zclFrame.payload) {
-                            const attribute = zclFrame.cluster.getAttribute(attr.attrId);
+                            const attribute = Zcl.Utils.getClusterAttribute(zclFrame.cluster, attr.attrId, undefined);
 
                             if (attribute && attribute.type !== Zcl.DataType.NO_DATA && attribute.type < Zcl.DataType.OCTET_STR) {
                                 payload.push({
@@ -421,7 +421,6 @@ const initController = async () => {
         disconnecting: false,
         disconnected: false,
         endAsync: async () => {},
-        // @ts-expect-error Z2M does not make use of return
         publishAsync: async () => {},
     };
     controller.mqtt.connect = async () => {

test/controller.test.ts

@@ -17,9 +17,9 @@ import {devices, mockController as mockZHController, events as mockZHEvents, ret
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import stringify from "json-stable-stringify-without-jsonify";
 import tmp from "tmp";
 
+import {stringify} from "../lib/util/stringify";
 import type {Mock, MockInstance} from "vitest";
 import {Controller as ZHController} from "zigbee-herdsman";
 import {Controller} from "../lib/controller";
@@ -149,6 +149,7 @@ describe("Controller", () => {
             user: "user1",
             client_id: "my_client_id",
             reject_unauthorized: false,
+            server_name: "mqtt.example.com",
             version: 5,
             maximum_packet_size: 20000,
         };
@@ -166,6 +167,7 @@ describe("Controller", () => {
             username: "user1",
             clientId: "my_client_id",
             rejectUnauthorized: false,
+            servername: "mqtt.example.com",
             protocolVersion: 5,
             properties: {maximumPacketSize: 20000},
         };

test/data.test.ts

@@ -15,12 +15,21 @@ describe("Data", () => {
             const expected = tmp.dirSync().name;
             process.env.ZIGBEE2MQTT_DATA = expected;
             data._testReload();
-            const actual = data.getPath();
-            expect(actual).toBe(expected);
-            expect(data.joinPath("test")).toStrictEqual(path.join(expected, "test"));
-            expect(data.joinPath("/test")).toStrictEqual(path.resolve(expected, "/test"));
-            delete process.env.ZIGBEE2MQTT_DATA;
-            data._testReload();
+
+            try {
+                const actual = data.getPath();
+                expect(actual).toBe(expected);
+                expect(data.joinPath("test")).toStrictEqual(path.join(expected, "test"));
+                expect(data.joinPath("/test")).toStrictEqual(path.resolve(expected, "/test"));
+            } finally {
+                delete process.env.ZIGBEE2MQTT_DATA;
+                data._testReload();
+            }
+        });
+
+        it("Should return data path when joinPath with empty string", () => {
+            const expected = data.getPath();
+            expect(data.joinPath("")).toStrictEqual(expected);
         });
     });
 });

test/extensions/availability.test.ts

@@ -7,7 +7,7 @@ import {flushPromises} from "../mocks/utils";
 import {devices, events as mockZHEvents, returnDevices} from "../mocks/zigbeeHerdsman";
 
 import assert from "node:assert";
-import stringify from "json-stable-stringify-without-jsonify";
+import {stringify} from "../../lib/util/stringify";
 import {Controller} from "../../lib/controller";
 import Availability from "../../lib/extension/availability";
 import * as settings from "../../lib/util/settings";

test/extensions/bind.test.ts

@@ -7,7 +7,7 @@ import {events as mockMQTTEvents, mockMQTTPublishAsync} from "../mocks/mqtt";
 import {flushPromises} from "../mocks/utils";
 import {type Device, devices, groups, events as mockZHEvents} from "../mocks/zigbeeHerdsman";
 
-import stringify from "json-stable-stringify-without-jsonify";
+import {stringify} from "../../lib/util/stringify";
 import {Controller} from "../../lib/controller";
 import Bind from "../../lib/extension/bind";
 import * as settings from "../../lib/util/settings";

test/extensions/bridge.test.ts

@@ -2,7 +2,7 @@
 import {afterAll, beforeAll, beforeEach, describe, expect, it, vi} from "vitest";
 import {Zdo} from "zigbee-herdsman";
 import * as data from "../mocks/data";
-import {mockJSZipFile, mockJSZipGenerateAsync} from "../mocks/jszip";
+import {mockFflateZip, mockFflateZipFailOnce} from "../mocks/fflate";
 import {mockLogger} from "../mocks/logger";
 import {events as mockMQTTEvents, mockMQTTPublishAsync} from "../mocks/mqtt";
 import {flushPromises} from "../mocks/utils";
@@ -12,7 +12,7 @@ import assert from "node:assert";
 import fs from "node:fs";
 import {platform} from "node:os";
 import path from "node:path";
-import stringify from "json-stable-stringify-without-jsonify";
+import {stringify} from "../../lib/util/stringify";
 import type {Mock} from "vitest";
 import {Controller} from "../../lib/controller";
 import Bridge from "../../lib/extension/bridge";
@@ -2806,7 +2806,7 @@ describe("Extension: Bridge", () => {
         mockMQTTPublishAsync.mockClear();
         await mockZHEvents.deviceLeave({ieeeAddr: devices.bulb.ieeeAddr});
         await flushPromises();
-        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(3);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(4);
         expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             "zigbee2mqtt/bridge/event",
             stringify({type: "device_leave", data: {ieee_address: "0x000b57fffec6a5b2", friendly_name: "bulb"}}),
@@ -2819,6 +2819,7 @@ describe("Extension: Bridge", () => {
             expect.any(String),
             {retain: true},
         );
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith("zigbee2mqtt/bridge/groups", expect.any(String), {retain: true});
     });
 
     it("Should allow permit join on all", async () => {
@@ -2973,6 +2974,7 @@ describe("Extension: Bridge", () => {
 
     it("Should allow to remove device by string", async () => {
         const device = devices.bulb;
+        const removeSpy = vi.spyOn(controller.zigbee, "removeDeviceFromLookup");
         mockMQTTPublishAsync.mockClear();
         mockMQTTEvents.message("zigbee2mqtt/bridge/request/device/remove", "bulb");
         await flushPromises();
@@ -2981,11 +2983,12 @@ describe("Extension: Bridge", () => {
         expect(device.removeFromNetwork).toHaveBeenCalledTimes(1);
         expect(device.removeFromDatabase).not.toHaveBeenCalled();
         expect(settings.getDevice("bulb")).toBeUndefined();
+        expect(removeSpy).not.toHaveBeenCalled();
         expect(mockMQTTPublishAsync).toHaveBeenCalledWith("zigbee2mqtt/bulb", "", {retain: true});
         expect(mockMQTTPublishAsync).toHaveBeenCalledWith("zigbee2mqtt/bridge/devices", expect.any(String), expect.any(Object));
         expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             "zigbee2mqtt/bridge/response/device/remove",
-            stringify({data: {id: "bulb", block: false, force: false}, status: "ok"}),
+            stringify({data: {id: "bulb", block: false, force: false, clear_cache: false}, status: "ok"}),
             {},
         );
         expect(settings.get().blocklist).toStrictEqual([]);
@@ -2995,52 +2998,76 @@ describe("Extension: Bridge", () => {
 
     it("Should allow to remove device by object ID", async () => {
         const device = devices.bulb;
+        const removeSpy = vi.spyOn(controller.zigbee, "removeDeviceFromLookup");
         mockMQTTPublishAsync.mockClear();
         mockMQTTEvents.message("zigbee2mqtt/bridge/request/device/remove", stringify({id: "bulb"}));
         await flushPromises();
         expect(device.removeFromNetwork).toHaveBeenCalledTimes(1);
         expect(device.removeFromDatabase).not.toHaveBeenCalled();
         expect(settings.getDevice("bulb")).toBeUndefined();
+        expect(removeSpy).not.toHaveBeenCalled();
         expect(mockMQTTPublishAsync).toHaveBeenCalledWith("zigbee2mqtt/bridge/devices", expect.any(String), expect.any(Object));
         expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             "zigbee2mqtt/bridge/response/device/remove",
-            stringify({data: {id: "bulb", block: false, force: false}, status: "ok"}),
+            stringify({data: {id: "bulb", block: false, force: false, clear_cache: false}, status: "ok"}),
             {},
         );
     });
 
     it("Should allow to force remove device", async () => {
         const device = devices.bulb;
+        const removeSpy = vi.spyOn(controller.zigbee, "removeDeviceFromLookup");
         mockMQTTPublishAsync.mockClear();
         mockMQTTEvents.message("zigbee2mqtt/bridge/request/device/remove", stringify({id: "bulb", force: true}));
         await flushPromises();
         expect(device.removeFromDatabase).toHaveBeenCalledTimes(1);
         expect(device.removeFromNetwork).not.toHaveBeenCalled();
         expect(settings.getDevice("bulb")).toBeUndefined();
+        expect(removeSpy).not.toHaveBeenCalled();
         expect(mockMQTTPublishAsync).toHaveBeenCalledWith("zigbee2mqtt/bridge/devices", expect.any(String), expect.any(Object));
         expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             "zigbee2mqtt/bridge/response/device/remove",
-            stringify({data: {id: "bulb", block: false, force: true}, status: "ok"}),
+            stringify({data: {id: "bulb", block: false, force: true, clear_cache: false}, status: "ok"}),
             {},
         );
     });
 
     it("Should allow to block device", async () => {
         const device = devices.bulb;
+        const removeSpy = vi.spyOn(controller.zigbee, "removeDeviceFromLookup");
         mockMQTTPublishAsync.mockClear();
         mockMQTTEvents.message("zigbee2mqtt/bridge/request/device/remove", stringify({id: "bulb", block: true, force: true}));
         await flushPromises();
         expect(device.removeFromDatabase).toHaveBeenCalledTimes(1);
         expect(settings.getDevice("bulb")).toBeUndefined();
+        expect(removeSpy).not.toHaveBeenCalled();
         expect(mockMQTTPublishAsync).toHaveBeenCalledWith("zigbee2mqtt/bridge/devices", expect.any(String), expect.any(Object));
         expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             "zigbee2mqtt/bridge/response/device/remove",
-            stringify({data: {id: "bulb", block: true, force: true}, status: "ok"}),
+            stringify({data: {id: "bulb", block: true, force: true, clear_cache: false}, status: "ok"}),
             {},
         );
         expect(settings.get().blocklist).toStrictEqual(["0x000b57fffec6a5b2"]);
     });
 
+    it("Should allow to clear cache when removing device", async () => {
+        const device = devices.bulb;
+        const removeSpy = vi.spyOn(controller.zigbee, "removeDeviceFromLookup");
+        mockMQTTPublishAsync.mockClear();
+        mockMQTTEvents.message("zigbee2mqtt/bridge/request/device/remove", stringify({id: "bulb", clear_cache: true}));
+        await flushPromises();
+        expect(device.removeFromNetwork).toHaveBeenCalledTimes(1);
+        expect(device.removeFromDatabase).not.toHaveBeenCalled();
+        expect(settings.getDevice("bulb")).toBeUndefined();
+        expect(removeSpy).toHaveNthReturnedWith(1, true);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith("zigbee2mqtt/bridge/devices", expect.any(String), expect.any(Object));
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
+            "zigbee2mqtt/bridge/response/device/remove",
+            stringify({data: {id: "bulb", block: false, force: false, clear_cache: true}, status: "ok"}),
+            {},
+        );
+    });
+
     it("Should allow to remove group", async () => {
         const group = groups.group_1;
         const removeGroupFromLookup = vi.spyOn(controller.zigbee, "removeGroupFromLookup");
@@ -3105,7 +3132,11 @@ describe("Extension: Bridge", () => {
         await flushPromises();
         expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             "zigbee2mqtt/bridge/response/device/remove",
-            stringify({data: {}, status: "error", error: "Failed to remove device 'bulb' (block: false, force: false) (Error: device timeout)"}),
+            stringify({
+                data: {},
+                status: "error",
+                error: "Failed to remove device 'bulb' (block: false, force: false, clear cache: false) (Error: device timeout)",
+            }),
             {},
         );
     });
@@ -4162,13 +4193,24 @@ describe("Extension: Bridge", () => {
         mockMQTTEvents.message("zigbee2mqtt/bridge/request/backup", "");
         await flushPromises();
         expect(mockZHController.backup).toHaveBeenCalledTimes(1);
-        expect(mockJSZipFile).toHaveBeenCalledTimes(4);
-        expect(mockJSZipFile).toHaveBeenNthCalledWith(1, "configuration.yaml", expect.any(Object));
-        expect(mockJSZipFile).toHaveBeenNthCalledWith(2, path.join("ext_converters", "123", "myfile.js"), expect.any(Object));
-        expect(mockJSZipFile).toHaveBeenNthCalledWith(3, path.join("ext_converters", "afile.js"), expect.any(Object));
-        expect(mockJSZipFile).toHaveBeenNthCalledWith(4, "state.json", expect.any(Object));
-        expect(mockJSZipGenerateAsync).toHaveBeenCalledTimes(1);
-        expect(mockJSZipGenerateAsync).toHaveBeenNthCalledWith(1, {type: "base64"});
+        expect(mockFflateZip).toHaveBeenCalledTimes(1);
+        expect(mockFflateZip).toHaveBeenNthCalledWith(
+            1,
+            {
+                "configuration.yaml": expect.any(Buffer),
+                [path.join("ext_converters", "123", "myfile.js")]: expect.any(Buffer),
+                [path.join("ext_converters", "afile.js")]: expect.any(Buffer),
+                "state.json": expect.any(Buffer),
+            },
+            {level: 6},
+            expect.any(Function),
+        );
+        expect(Object.keys(mockFflateZip.mock.calls[0][0])).toStrictEqual([
+            "configuration.yaml",
+            path.join("ext_converters", "123", "myfile.js"),
+            path.join("ext_converters", "afile.js"),
+            "state.json",
+        ]);
         expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             "zigbee2mqtt/bridge/response/backup",
             stringify({data: {zip: "THISISBASE64"}, status: "ok"}),
@@ -4176,6 +4218,18 @@ describe("Extension: Bridge", () => {
         );
     });
 
+    it("Should return an error when the backup archive cannot be created", async () => {
+        mockMQTTPublishAsync.mockClear();
+        mockFflateZipFailOnce(new Error("invalid zip data"));
+        mockMQTTEvents.message("zigbee2mqtt/bridge/request/backup", "");
+        await flushPromises();
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
+            "zigbee2mqtt/bridge/response/backup",
+            stringify({data: {}, status: "error", error: "invalid zip data"}),
+            {},
+        );
+    });
+
     it("Should allow to restart", async () => {
         mockMQTTPublishAsync.mockClear();
         mockMQTTEvents.message("zigbee2mqtt/bridge/request/restart", "");
@@ -4325,6 +4379,58 @@ describe("Extension: Bridge", () => {
         );
     });
 
+    it("Change options consecutively, check restart required", async () => {
+        settings.apply({health: {interval: 10, reset_on_check: false}});
+        mockMQTTPublishAsync.mockClear();
+
+        // Change option that doesn't require restart
+        mockMQTTEvents.message("zigbee2mqtt/bridge/request/options", stringify({options: {health: {reset_on_check: true}}}));
+        await flushPromises();
+
+        expect(settings.get().health.reset_on_check).toBe(true);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
+            "zigbee2mqtt/bridge/response/options",
+            stringify({data: {restart_required: false}, status: "ok"}),
+            {},
+        );
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith("zigbee2mqtt/bridge/info", expect.stringContaining('"restart_required":false'), {
+            retain: true,
+        });
+        mockMQTTPublishAsync.mockClear();
+
+        // Change option that requires restart
+        mockMQTTEvents.message("zigbee2mqtt/bridge/request/options", stringify({options: {health: {interval: 11}}}));
+        await flushPromises();
+
+        expect(settings.get().health.interval).toBe(11);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
+            "zigbee2mqtt/bridge/response/options",
+            stringify({data: {restart_required: true}, status: "ok"}),
+            {},
+        );
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith("zigbee2mqtt/bridge/info", expect.stringContaining('"restart_required":true'), {
+            retain: true,
+        });
+        mockMQTTPublishAsync.mockClear();
+
+        // Change option that doesn't require restart
+        mockMQTTEvents.message("zigbee2mqtt/bridge/request/options", stringify({options: {health: {reset_on_check: false}}}));
+        await flushPromises();
+
+        expect(settings.get().health.reset_on_check).toBe(false);
+
+        // System still requires restart
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
+            "zigbee2mqtt/bridge/response/options",
+            stringify({data: {restart_required: true}, status: "ok"}),
+            {},
+        );
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith("zigbee2mqtt/bridge/info", expect.stringContaining('"restart_required":true'), {
+            retain: true,
+        });
+        mockMQTTPublishAsync.mockClear();
+    });
+
     it("Icon link handling", () => {
         const bridge = controller.getExtension("Bridge")! as Bridge;
         expect(bridge).toBeDefined();

test/extensions/configure.test.ts

@@ -6,7 +6,7 @@ import {events as mockMQTTEvents, mockMQTTPublishAsync} from "../mocks/mqtt";
 import {flushPromises} from "../mocks/utils";
 import {devices, type Endpoint, events as mockZHEvents, type Device as ZhDevice} from "../mocks/zigbeeHerdsman";
 
-import stringify from "json-stable-stringify-without-jsonify";
+import {stringify} from "../../lib/util/stringify";
 import {InterviewState} from "zigbee-herdsman/dist/controller/model/device";
 import {Controller} from "../../lib/controller";
 import Device from "../../lib/model/device";
@@ -193,16 +193,28 @@ describe("Extension: Configure", () => {
     });
 
     it("Should allow to configure via MQTT", async () => {
+        const emitDevicesChanged = vi.spyOn(controller.eventBus, "emitDevicesChanged");
+        const emitExposesChanged = vi.spyOn(controller.eventBus, "emitExposesChanged");
+
         mockClear(devices.remote);
         expectRemoteNotConfigured();
-        await mockMQTTEvents.message("zigbee2mqtt/bridge/request/device/configure", "remote");
-        await flushPromises();
-        expectRemoteConfigured();
-        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
-            "zigbee2mqtt/bridge/response/device/configure",
-            stringify({data: {id: "remote"}, status: "ok"}),
-            {},
-        );
+        try {
+            await mockMQTTEvents.message("zigbee2mqtt/bridge/request/device/configure", "remote");
+            await flushPromises();
+            expectRemoteConfigured();
+            expect(emitDevicesChanged).toHaveBeenCalledTimes(1);
+            expect(emitExposesChanged).toHaveBeenCalledWith({
+                device: controller.zigbee.resolveEntity(devices.remote),
+            });
+            expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
+                "zigbee2mqtt/bridge/response/device/configure",
+                stringify({data: {id: "remote"}, status: "ok"}),
+                {},
+            );
+        } finally {
+            emitExposesChanged.mockRestore();
+            emitDevicesChanged.mockRestore();
+        }
     });
 
     it("Fail to configure via MQTT when device does not exist", async () => {

test/extensions/externalConverters.test.ts

@@ -9,7 +9,7 @@ import {devices, mockController as mockZHController, returnDevices} from "../moc
 
 import fs from "node:fs";
 import path from "node:path";
-import stringify from "json-stable-stringify-without-jsonify";
+import {stringify} from "../../lib/util/stringify";
 import * as zhc from "zigbee-herdsman-converters";
 import {Controller} from "../../lib/controller";
 import ExternalConverters from "../../lib/extension/externalConverters";

test/extensions/externalExtensions.test.ts

@@ -8,7 +8,7 @@ import {devices, mockController as mockZHController, returnDevices} from "../moc
 
 import fs from "node:fs";
 import path from "node:path";
-import stringify from "json-stable-stringify-without-jsonify";
+import {stringify} from "../../lib/util/stringify";
 import {Controller} from "../../lib/controller";
 import ExternalExtensions from "../../lib/extension/externalExtensions";
 import * as settings from "../../lib/util/settings";

test/extensions/frontend.test.ts

@@ -7,7 +7,7 @@ import {type EventHandler, flushPromises} from "../mocks/utils";
 import {devices, events as mockZHEvents} from "../mocks/zigbeeHerdsman";
 
 import path from "node:path";
-import stringify from "json-stable-stringify-without-jsonify";
+import {stringify} from "../../lib/util/stringify";
 import type {Mock} from "vitest";
 import ws from "ws";
 import {Controller} from "../../lib/controller";

test/extensions/groups.test.ts

@@ -6,7 +6,7 @@ import {events as mockMQTTEvents, mockMQTTPublishAsync} from "../mocks/mqtt";
 import {flushPromises} from "../mocks/utils";
 import {devices, groups, events as mockZHEvents, resetGroupMembers, returnDevices} from "../mocks/zigbeeHerdsman";
 
-import stringify from "json-stable-stringify-without-jsonify";
+import {stringify} from "../../lib/util/stringify";
 import * as zhcGlobalStore from "zigbee-herdsman-converters/lib/store";
 import {Controller} from "../../lib/controller";
 import * as settings from "../../lib/util/settings";

test/extensions/homeassistant.test.ts

@@ -9,7 +9,7 @@ import type {Device as ZhDevice} from "../mocks/zigbeeHerdsman";
 import {devices, groups, events as mockZHEvents} from "../mocks/zigbeeHerdsman";
 
 import assert from "node:assert";
-import stringify from "json-stable-stringify-without-jsonify";
+import {stringify} from "../../lib/util/stringify";
 import type {MockInstance} from "vitest";
 import * as zhc from "zigbee-herdsman-converters";
 import type {KeyValueAny} from "zigbee-herdsman-converters/lib/types";
@@ -128,6 +128,159 @@ describe("Extension: HomeAssistant", () => {
         expect(duplicated).toStrictEqual([]);
     });
 
+    it("Should mark thermostat configuration toggles as config entities", () => {
+        const switchExposes = [
+            new zhc.Switch().withLabel("Auto lock").withState("auto_lock", false, "Enable/disable auto lock", zhc.access.STATE_SET, "AUTO", "MANUAL"),
+            new zhc.Switch().withLabel("Away mode").withState("away_mode", false, "Enable/disable away mode", zhc.access.STATE_SET),
+            new zhc.Switch().withLabel("Valve detection").withState("valve_detection", true, "Valve detection", zhc.access.STATE_SET),
+            new zhc.Switch()
+                .withLabel("Window detection")
+                .withState("window_detection", true, "Enables/disables window detection", zhc.access.STATE_SET),
+        ];
+        const binaryExposes = [
+            new zhc.Binary("frost_protection", zhc.access.STATE_SET, "ON", "OFF").withDescription("Anti-freeze protection"),
+            new zhc.Binary("heating_stop", zhc.access.STATE_SET, "ON", "OFF").withDescription("Heating stop"),
+            new zhc.Binary("away_mode", zhc.access.STATE_SET, "ON", "OFF").withDescription("Away mode"),
+            new zhc.Binary("window_detection", zhc.access.STATE_SET, "ON", "OFF").withDescription("Open window detection"),
+        ];
+        const getDiscoveryConfigs = (expose: zhc.Expose): KeyValueAny[] => {
+            const device = {
+                definition: {},
+                isDevice: (): boolean => true,
+                isGroup: (): boolean => false,
+                endpoint: () => undefined,
+                options: {},
+                exposes: (): zhc.Expose[] => [expose],
+                zh: {endpoints: []},
+            };
+            // @ts-expect-error private method and minimal test device
+            return extension.getConfigs(device);
+        };
+
+        for (const expose of switchExposes) {
+            const [config] = getDiscoveryConfigs(expose);
+            expect(config.type).toStrictEqual("switch");
+            expect(config.object_id).toStrictEqual(expose.features[0].property);
+            expect(config.discovery_payload.entity_category).toStrictEqual("config");
+            expect(config.discovery_payload.command_topic_postfix).toStrictEqual(expose.features[0].property);
+        }
+
+        for (const expose of binaryExposes) {
+            const [config] = getDiscoveryConfigs(expose);
+            expect(config.type).toStrictEqual("switch");
+            expect(config.object_id).toStrictEqual(`switch_${expose.name}`);
+            expect(config.discovery_payload.entity_category).toStrictEqual("config");
+            expect(config.discovery_payload.command_topic_postfix).toStrictEqual(expose.property);
+        }
+    });
+
+    it("Should mark device settings as config entities", () => {
+        const getDiscoveryConfigs = (expose: zhc.Expose): KeyValueAny[] => {
+            const device = {
+                definition: {},
+                isDevice: (): boolean => true,
+                isGroup: (): boolean => false,
+                endpoint: () => undefined,
+                options: {},
+                exposes: (): zhc.Expose[] => [expose],
+                zh: {endpoints: []},
+            };
+            // @ts-expect-error private method and minimal test device
+            return extension.getConfigs(device);
+        };
+
+        const enumExposes = [
+            new zhc.Enum("set_limits", zhc.access.STATE_SET, ["START", "END", "RESET"]),
+            new zhc.Enum("motor_direction", zhc.access.STATE_SET, ["forward", "back"]),
+            new zhc.Enum("temperature_unit", zhc.access.STATE_SET, ["celsius", "fahrenheit"]),
+        ];
+
+        for (const expose of enumExposes) {
+            const [config] = getDiscoveryConfigs(expose);
+            expect(config.type).toStrictEqual("select");
+            expect(config.object_id).toStrictEqual(expose.property);
+            expect(config.discovery_payload.entity_category).toStrictEqual("config");
+        }
+
+        const binaryExposes = [
+            new zhc.Binary("tilt_mode", zhc.access.STATE_SET, "ON", "OFF"),
+            new zhc.Binary("calibration_left", zhc.access.STATE_SET, "ON", "OFF"),
+            new zhc.Binary("motor_reversal_right", zhc.access.STATE_SET, "ON", "OFF"),
+            new zhc.Binary("enable_display", zhc.access.STATE_SET, "ON", "OFF"),
+            new zhc.Binary("indicator", zhc.access.STATE_SET, "ON", "OFF"),
+        ];
+
+        for (const expose of binaryExposes) {
+            const [config] = getDiscoveryConfigs(expose);
+            expect(config.type).toStrictEqual("switch");
+            expect(config.object_id).toStrictEqual(`switch_${expose.property}`);
+            expect(config.discovery_payload.entity_category).toStrictEqual("config");
+        }
+
+        const numericExposes = [
+            new zhc.Numeric("calibration_time_left", zhc.access.STATE_SET),
+            new zhc.Numeric("comfort_temperature_min", zhc.access.STATE_SET),
+            new zhc.Numeric("comfort_humidity_max", zhc.access.STATE_SET),
+            new zhc.Numeric("measurement_interval", zhc.access.STATE_SET),
+            new zhc.Numeric("minimum_range", zhc.access.STATE_SET),
+            new zhc.Numeric("maximum_range", zhc.access.STATE_SET),
+            new zhc.Numeric("detection_delay", zhc.access.STATE_SET),
+            new zhc.Numeric("fading_time", zhc.access.STATE_SET),
+            new zhc.Numeric("large_motion_detection_sensitivity", zhc.access.STATE_SET),
+            new zhc.Numeric("medium_motion_detection_distance", zhc.access.STATE_SET),
+            new zhc.Numeric("small_detection_sensitivity", zhc.access.STATE_SET),
+            new zhc.Numeric("soil_calibration", zhc.access.STATE_SET),
+            new zhc.Numeric("soil_sampling", zhc.access.STATE_SET),
+            new zhc.Numeric("soil_warning", zhc.access.STATE_SET),
+        ];
+
+        for (const expose of numericExposes) {
+            const [config] = getDiscoveryConfigs(expose);
+            expect(config.type).toStrictEqual("number");
+            expect(config.object_id).toStrictEqual(expose.property);
+            expect(config.discovery_payload.entity_category).toStrictEqual("config");
+        }
+
+        const [textConfig] = getDiscoveryConfigs(new zhc.Text("schedule_settings", zhc.access.STATE_SET));
+        expect(textConfig.type).toStrictEqual("text");
+        expect(textConfig.object_id).toStrictEqual("schedule_settings");
+        expect(textConfig.discovery_payload.entity_category).toStrictEqual("config");
+    });
+
+    it("Should apply expose-level Home Assistant discovery metadata", () => {
+        const createDevice = (exposes: zhc.Expose[]): Device =>
+            ({
+                definition: {},
+                isDevice: (): boolean => true,
+                isGroup: (): boolean => false,
+                endpoint: () => undefined,
+                options: {},
+                exposes: (): zhc.Expose[] => exposes,
+                zh: {endpoints: []},
+            }) as Device;
+
+        const voltageExpose = new zhc.Numeric("voltage", zhc.access.STATE).withUnit("V");
+        Object.assign(voltageExpose, {
+            homeassistant: {
+                type: "valve",
+                entityCategory: "diagnostic",
+                deviceClass: "voltage",
+                enabledByDefault: false,
+                icon: "mdi:flash",
+            },
+        });
+
+        // @ts-expect-error private
+        const configs = extension.getConfigs(createDevice([voltageExpose]));
+        expect(configs.find((config) => config.object_id === "voltage")?.discovery_payload).toMatchObject({
+            device_class: "voltage",
+            enabled_by_default: false,
+            entity_category: "diagnostic",
+            icon: "mdi:flash",
+        });
+        expect(configs.find((config) => config.object_id === "voltage")?.discovery_payload).not.toHaveProperty("type");
+    });
+
     it("Should discover devices and groups", async () => {
         settings.set(["homeassistant", "experimental_event_entities"], true);
         settings.set(["groups", "9", "homeassistant"], {name: "HA Discovery Group", icon: "mdi:lightbulb-group"});
@@ -1196,6 +1349,24 @@ describe("Extension: HomeAssistant", () => {
         });
     });
 
+    it("Should apply user configuration after converter compatibility mapping", async () => {
+        settings.set(["devices", "0x18fc2600000d7ae2", "homeassistant", "climate"], {
+            modes: ["off", "heat", "auto"],
+            mode_command_template: null,
+        });
+
+        await resetExtension();
+        await flushPromises();
+
+        const call = mockMQTTPublishAsync.mock.calls.find((c) => c[0] === "homeassistant/climate/0x18fc2600000d7ae2/climate/config");
+        expect(call).toBeDefined();
+        const payload = JSON.parse(call![1] as string);
+
+        expect(payload.modes).toStrictEqual(["off", "heat", "auto"]);
+        expect(payload.mode_command_template).toBeUndefined();
+        expect(payload.mode_command_topic).toStrictEqual("zigbee2mqtt/bosch_radiator/set");
+    });
+
     it("does not throw when discovery payload override throws", async () => {
         const bosch = getZ2MEntity(devices["RBSH-TRV0-ZB-EU"]) as Device;
         assert(typeof bosch.definition?.meta?.overrideHaDiscoveryPayload === "function");
@@ -1252,6 +1423,30 @@ describe("Extension: HomeAssistant", () => {
         overrideSpy.mockRestore();
     });
 
+    it("passes device options to discovery payload overrides", async () => {
+        const bosch = getZ2MEntity(devices["RBSH-TRV0-ZB-EU"]) as Device;
+        assert(typeof bosch.definition?.meta?.overrideHaDiscoveryPayload === "function");
+        const overrideSpy = vi.spyOn(bosch.definition.meta, "overrideHaDiscoveryPayload") as MockInstance;
+        settings.set(["devices", "0x18fc2600000d7ae2", "discovery_option_marker"], "passed");
+
+        overrideSpy.mockImplementation((payload, options) => {
+            if (payload.mode_command_topic?.endsWith("/system_mode")) {
+                payload.discovery_option_marker = options?.discovery_option_marker;
+            }
+        });
+
+        await resetExtension();
+
+        expect(overrideSpy).toHaveBeenCalledWith(expect.any(Object), expect.objectContaining({discovery_option_marker: "passed"}));
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
+            "homeassistant/climate/0x18fc2600000d7ae2/climate/config",
+            expect.stringContaining('"discovery_option_marker":"passed"'),
+            {qos: 1, retain: true},
+        );
+
+        overrideSpy.mockRestore();
+    });
+
     it("Should discover Bosch BTH-RM230Z with a current_humidity attribute", () => {
         const payload = {
             action_template:
@@ -1275,11 +1470,11 @@ describe("Extension: HomeAssistant", () => {
             min_temp: "5",
             mode_command_topic: "zigbee2mqtt/bosch_rm230z/set",
             mode_state_template:
-                "{% set values = {'schedule':'auto','manual':'heat','pause':'off'} %}{% set value = value_json.operating_mode %}{% if value == \"manual\" %}{{ value_json.system_mode }}{% else %}{{ values[value] if value in values.keys() else 'off' }}{% endif %}",
+                "{% set active_modes = ['heat'] %}{% set fallback_mode = 'heat' %}{% set values = {'schedule':'auto','pause':'off'} %}{% set value = value_json.operating_mode %}{% set mode = value_json.system_mode %}{% if value == 'manual' %}{{ mode if mode in active_modes else fallback_mode }}{% else %}{{ values[value] if value in values.keys() else 'off' }}{% endif %}",
             mode_command_template:
-                "{% set values = { 'auto':'schedule','heat':'manual','cool':'manual','off':'pause'} %}{% if value == \"heat\" or value == \"cool\" %}{\"operating_mode\": \"manual\", \"system_mode\": \"{{ value }}\"}{% else %}{\"operating_mode\": \"{{ values[value] if value in values.keys() else 'pause' }}\"}{% endif %}",
+                "{% set active_modes = ['heat'] %}{% set values = {'auto':'schedule','off':'pause'} %}{% if value in active_modes %}{\"operating_mode\": \"manual\", \"system_mode\": \"{{ value }}\"}{% else %}{\"operating_mode\": \"{{ values[value] if value in values.keys() else 'pause' }}\"}{% endif %}",
             mode_state_topic: "zigbee2mqtt/bosch_rm230z",
-            modes: ["off", "heat", "cool", "auto"],
+            modes: ["off", "heat", "auto"],
             name: null,
             object_id: "bosch_rm230z",
             origin,
@@ -1328,6 +1523,37 @@ describe("Extension: HomeAssistant", () => {
         });
     });
 
+    it("Should discover climate with cooling-only setpoint", () => {
+        const climateExpose = new zhc.Climate()
+            .withSetpoint("occupied_cooling_setpoint", 16, 32, 0.5)
+            .withLocalTemperature()
+            .withSystemMode(["off", "cool", "auto"]);
+        const device = {
+            definition: {},
+            isDevice: (): boolean => true,
+            isGroup: (): boolean => false,
+            endpoint: () => undefined,
+            options: {},
+            exposes: (): zhc.Expose[] => [climateExpose],
+            zh: {endpoints: []},
+        } as Device;
+
+        // @ts-expect-error private
+        const configs = extension.getConfigs(device);
+        const climate = configs.find((c) => c.type === "climate");
+        expect(climate).toBeDefined();
+        expect(climate!.discovery_payload).toMatchObject({
+            temperature_command_topic: "occupied_cooling_setpoint",
+            temperature_state_template: '{{ value_json["occupied_cooling_setpoint"] }}',
+            temperature_state_topic: true,
+            min_temp: "16",
+            max_temp: "32",
+            temp_step: 0.5,
+        });
+        expect(climate!.discovery_payload).not.toHaveProperty("temperature_low_command_topic");
+        expect(climate!.discovery_payload).not.toHaveProperty("temperature_high_command_topic");
+    });
+
     it("Should discover devices with cover_position", () => {
         let payload;
 
@@ -1473,6 +1699,62 @@ describe("Extension: HomeAssistant", () => {
         });
     });
 
+    it("Should discover an infrared emitter entity", () => {
+        const infraredEmitterExpose = new zhc.Text("emitter", zhc.access.SET).withHomeAssistant({
+            type: "infrared",
+            schema: "emitter",
+            valueTemplate: null,
+        });
+        const device = {
+            definition: {},
+            isDevice: (): boolean => true,
+            isGroup: (): boolean => false,
+            endpoint: () => undefined,
+            options: {},
+            exposes: (): zhc.Expose[] => [infraredEmitterExpose],
+            zh: {endpoints: []},
+        } as Device;
+
+        // @ts-expect-error private
+        const configs = extension.getConfigs(device);
+        const infrared = configs.find((c) => c.type === "infrared");
+        expect(infrared).toBeDefined();
+        expect(infrared!.discovery_payload).toMatchObject({
+            name: "Emitter",
+            schema: "emitter",
+            command_topic: true,
+            state_topic: 0,
+        });
+        expect(infrared!.discovery_payload).not.toHaveProperty("value_template");
+    });
+
+    it("Should discover an infrared receiver entity", () => {
+        const infraredReceiverExpose = new zhc.Text("receiver", zhc.access.STATE).withHomeAssistant({
+            type: "infrared",
+            schema: "receiver",
+            valueTemplate: "{{ json_value.emitter }}",
+        });
+        const device = {
+            definition: {},
+            isDevice: (): boolean => true,
+            isGroup: (): boolean => false,
+            endpoint: () => undefined,
+            options: {},
+            exposes: (): zhc.Expose[] => [infraredReceiverExpose],
+            zh: {endpoints: []},
+        } as Device;
+
+        // @ts-expect-error private
+        const configs = extension.getConfigs(device);
+        const infrared = configs.find((c) => c.type === "infrared");
+        expect(infrared).toBeDefined();
+        expect(infrared!.discovery_payload).toMatchObject({
+            name: "Receiver",
+            schema: "receiver",
+        });
+        expect(infrared!.discovery_payload).toHaveProperty("value_template");
+    });
+
     it("Should discover devices with custom homeassistant.discovery_topic", async () => {
         settings.set(["homeassistant", "discovery_topic"], "my_custom_discovery_topic");
         await resetExtension();
@@ -1513,7 +1795,7 @@ describe("Extension: HomeAssistant", () => {
 
         await expect(async () => {
             await controller.start();
-        }).rejects.toThrow("Home Assistant integration is not possible with attribute output!");
+        }).rejects.toThrow("Home Assistant integration requires 'output: json' under 'advanced'");
     });
 
     it("Should throw error when homeassistant.discovery_topic equals the mqtt.base_topic", async () => {
@@ -1529,7 +1811,9 @@ describe("Extension: HomeAssistant", () => {
         settings.set(["advanced", "cache_state"], false);
         mockLogger.warning.mockClear();
         await resetExtension();
-        expect(mockLogger.warning).toHaveBeenCalledWith("In order for Home Assistant integration to work properly set `cache_state: true");
+        expect(mockLogger.warning).toHaveBeenCalledWith(
+            "In order for Home Assistant integration to work properly, set `cache_state: true` under `advanced`",
+        );
     });
 
     it("Should set missing values to null", async () => {
@@ -1722,6 +2006,7 @@ describe("Extension: HomeAssistant", () => {
         await flushPromises();
         await vi.runOnlyPendingTimersAsync();
         await flushPromises();
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith("zigbee2mqtt/bridge/state", stringify({state: "online"}), {retain: true, qos: 1});
         expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             "zigbee2mqtt/bulb",
             stringify({
@@ -1762,6 +2047,7 @@ describe("Extension: HomeAssistant", () => {
         await flushPromises();
         await vi.runOnlyPendingTimersAsync();
         await flushPromises();
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith("zigbee2mqtt/bridge/state", stringify({state: "online"}), {retain: true, qos: 1});
         expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
             "zigbee2mqtt/bulb",
             stringify({
@@ -3021,11 +3307,15 @@ describe("Extension: HomeAssistant", () => {
         settings.set(["homeassistant", "legacy_action_sensor"], true);
         await resetExtension();
 
-        // Should discovery action sensor
-        expect(mockMQTTPublishAsync).toHaveBeenCalledWith("homeassistant/sensor/0x0017880104e45520/action/config", expect.any(String), {
-            retain: true,
-            qos: 1,
+        // Should discover action sensor as a diagnostic helper instead of a primary entity.
+        const actionDiscovery = mockMQTTPublishAsync.mock.calls.find(([topic]) => topic === "homeassistant/sensor/0x0017880104e45520/action/config");
+        assert(actionDiscovery);
+        expect(JSON.parse(actionDiscovery[1])).toMatchObject({
+            entity_category: "diagnostic",
+            name: "Action",
+            object_id: "button_action",
         });
+        expect(actionDiscovery[2]).toStrictEqual({retain: true, qos: 1});
 
         // Should counter an action payload with an empty payload
         mockMQTTPublishAsync.mockClear();

test/extensions/networkMap.test.ts

@@ -10,7 +10,7 @@ import {devices, events as mockZHEvents, returnDevices} from "../mocks/zigbeeHer
 
 import fs from "node:fs";
 import path from "node:path";
-import stringify from "json-stable-stringify-without-jsonify";
+import {stringify} from "../../lib/util/stringify";
 import {Controller} from "../../lib/controller";
 import * as settings from "../../lib/util/settings";
 

test/extensions/otaUpdate.test.ts

@@ -9,7 +9,7 @@ import {devices, events as mockZHEvents} from "../mocks/zigbeeHerdsman";
 
 import {join} from "node:path";
 import {existsSync, readFileSync, rmSync} from "node:fs";
-import stringify from "json-stable-stringify-without-jsonify";
+import {stringify} from "../../lib/util/stringify";
 import {Controller} from "../../lib/controller";
 import OTAUpdate from "../../lib/extension/otaUpdate";
 import * as settings from "../../lib/util/settings";
@@ -546,6 +546,71 @@ describe("Extension: OTAUpdate", () => {
         expect(existsSync(saveFilePath)).toStrictEqual(false);
     });
 
+    it("aborts running OTA", async () => {
+        let timer: NodeJS.Timeout | undefined;
+        devices.bulb.updateOta.mockImplementationOnce(
+            async (_source, _requestPayload, _requestTsn, _extraMetas, onProgress, _dataSettings, _endpoint) => {
+                onProgress(0, 36000.5678);
+                onProgress(10, 3600.2123);
+
+                return await new Promise((resolve) => {
+                    timer = setTimeout(
+                        () =>
+                            resolve([
+                                {
+                                    ...DEFAULT_CURRENT,
+                                    fileVersion: 1,
+                                },
+                                {
+                                    ...DEFAULT_CURRENT,
+                                    fileVersion: 90,
+                                },
+                            ]),
+                        10000,
+                    );
+                });
+            },
+        );
+        mockMQTTEvents.message("zigbee2mqtt/bridge/request/device/ota_update/update", stringify({id: "bulb"}));
+        await flushPromises();
+        await vi.advanceTimersByTimeAsync(9000);
+        mockMQTTEvents.message("zigbee2mqtt/bridge/request/device/ota_update/update/abort", stringify({id: "bulb"}));
+        await flushPromises();
+
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
+            "zigbee2mqtt/bulb",
+            stringify({update: {state: "updating", progress: 0, remaining: 36001}}),
+            {
+                retain: true,
+                qos: 0,
+            },
+        );
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
+            "zigbee2mqtt/bulb",
+            stringify({update: {state: "updating", progress: 10, remaining: 3600}}),
+            {retain: true, qos: 0},
+        );
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith("zigbee2mqtt/bulb", stringify({update: {state: "available"}}), {retain: true, qos: 0});
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
+            "zigbee2mqtt/bridge/response/device/ota_update/update/abort",
+            stringify({data: {id: "bulb"}, status: "ok"}),
+            {},
+        );
+
+        clearTimeout(timer);
+    });
+
+    it("handles abort when no running OTA", async () => {
+        mockMQTTEvents.message("zigbee2mqtt/bridge/request/device/ota_update/update/abort", stringify({id: "bulb"}));
+        await flushPromises();
+
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
+            "zigbee2mqtt/bridge/response/device/ota_update/update",
+            stringify({data: {}, status: "error", error: `No OTA in progress to abort for device 'bulb'`}),
+            {},
+        );
+    });
+
     it("handles when OTA update fails", async () => {
         devices.bulb.endpoints[0].read.mockImplementation(() => {
             return {swBuildId: 1, dateCode: "2019010"};

test/extensions/publish.test.ts

@@ -7,7 +7,7 @@ import * as mockSleep from "../mocks/sleep";
 import {flushPromises} from "../mocks/utils";
 import {devices, groups, events as mockZHEvents} from "../mocks/zigbeeHerdsman";
 
-import stringify from "json-stable-stringify-without-jsonify";
+import {stringify} from "../../lib/util/stringify";
 import {clearGlobalStore} from "zigbee-herdsman-converters";
 import {Controller} from "../../lib/controller";
 import {loadTopicGetSetRegex} from "../../lib/extension/publish";

test/extensions/receive.test.ts

@@ -7,7 +7,7 @@ import * as mockSleep from "../mocks/sleep";
 import {flushPromises} from "../mocks/utils";
 import {devices, events as mockZHEvents} from "../mocks/zigbeeHerdsman";
 
-import stringify from "json-stable-stringify-without-jsonify";
+import {stringify} from "../../lib/util/stringify";
 import {Controller} from "../../lib/controller";
 import * as settings from "../../lib/util/settings";
 

test/logger.test.ts

@@ -5,20 +5,13 @@ import * as data from "./mocks/data";
 import fs from "node:fs";
 import {platform} from "node:os";
 import path from "node:path";
-import {rimrafSync} from "rimraf";
 import tmp from "tmp";
 import type {MockInstance} from "vitest";
 import Transport from "winston-transport";
 import logger from "../lib/util/logger";
 import * as settings from "../lib/util/settings";
 
-vi.mock("rimraf", async (importOriginal) => {
-    const actual = await importOriginal<typeof import("rimraf")>();
-    return {
-        ...actual,
-        rimrafSync: vi.fn(actual.rimrafSync),
-    };
-});
+const rmSync = (target: string): void => fs.rmSync(target, {recursive: true, force: true});
 
 describe("Logger", () => {
     let consoleWriteSpy: MockInstance;
@@ -56,7 +49,7 @@ describe("Logger", () => {
 
     it("Should cleanup (default setting)", () => {
         for (const d of fs.readdirSync(dir.name)) {
-            rimrafSync(path.join(dir.name, d));
+            rmSync(path.join(dir.name, d));
         }
 
         for (let i = 0; i < 20; i++) {
@@ -70,25 +63,30 @@ describe("Logger", () => {
 
     it("Should handle cleanup error", () => {
         for (const d of fs.readdirSync(dir.name)) {
-            rimrafSync(path.join(dir.name, d));
+            rmSync(path.join(dir.name, d));
         }
 
         for (let i = 0; i < 20; i++) {
             fs.mkdirSync(path.join(dir.name, `log_${i}`));
         }
 
-        vi.mocked(rimrafSync).mockImplementationOnce(() => {
+        const rmSyncSpy = vi.spyOn(fs, "rmSync").mockImplementationOnce(() => {
             throw new Error("EACCES: permission denied");
         });
 
         const errorSpy = vi.spyOn(logger, "error");
-        logger.init();
-        expect(errorSpy).toHaveBeenCalledWith(expect.stringMatching(/Failed to remove old log directory '.*': Error: EACCES: permission denied/));
+
+        try {
+            logger.init();
+            expect(errorSpy).toHaveBeenCalledWith(expect.stringMatching(/Failed to remove old log directory '.*': Error: EACCES: permission denied/));
+        } finally {
+            rmSyncSpy.mockRestore();
+        }
     });
 
     it("Should cleanup (15 folders setting)", () => {
         for (const d of fs.readdirSync(dir.name)) {
-            rimrafSync(path.join(dir.name, d));
+            rmSync(path.join(dir.name, d));
         }
 
         for (let i = 0; i < 20; i++) {
@@ -103,7 +101,7 @@ describe("Logger", () => {
 
     it("Should not cleanup when there is no timestamp set", () => {
         for (const d of fs.readdirSync(dir.name)) {
-            rimrafSync(path.join(dir.name, d));
+            rmSync(path.join(dir.name, d));
         }
 
         for (let i = 30; i < 50; i++) {

test/mocks/data.ts

@@ -1,8 +1,8 @@
 import fs from "node:fs";
 import path from "node:path";
-import stringify from "json-stable-stringify-without-jsonify";
 import tmp from "tmp";
 import {vi} from "vitest";
+import {stringify} from "../../lib/util/stringify";
 import yaml from "../../lib/util/yaml";
 
 export const mockDir: string = tmp.dirSync().name;

test/mocks/fflate.ts

@@ -0,0 +1,19 @@
+import type {AsyncZipOptions, AsyncZippable, FlateError} from "fflate";
+
+/** `THISISBASE64` is valid base64, so it round-trips through `Buffer.from(...).toString("base64")` */
+export const mockFflateZipContent = Uint8Array.from(Buffer.from("THISISBASE64", "base64"));
+
+export const mockFflateZip = vi.fn((_data: AsyncZippable, _opts: AsyncZipOptions, cb: (error: FlateError | null, data: Uint8Array) => void): void => {
+    cb(null, mockFflateZipContent);
+});
+
+/** Makes the next `zip` call report the given error through its callback */
+export const mockFflateZipFailOnce = (error: Error): void => {
+    mockFflateZip.mockImplementationOnce((_data, _opts, cb) => {
+        cb(error as FlateError, new Uint8Array());
+    });
+};
+
+vi.mock("fflate", () => ({
+    zip: mockFflateZip,
+}));

test/mocks/jszip.ts

@@ -1,11 +0,0 @@
-export const mockJSZipFile = vi.fn();
-export const mockJSZipGenerateAsync = vi.fn().mockReturnValue("THISISBASE64");
-
-vi.mock("jszip", () => ({
-    default: vi.fn().mockImplementation(() => {
-        return {
-            file: mockJSZipFile,
-            generateAsync: mockJSZipGenerateAsync,
-        };
-    }),
-}));

test/mocks/types.d.ts

@@ -1,7 +1,3 @@
-declare module "json-stable-stringify-without-jsonify" {
-    export default function (obj: unknown): string;
-}
-
 declare module "tmp" {
     export function dirSync(): {
         name: string;

test/mocks/zigbeeHerdsman.ts

@@ -283,6 +283,7 @@ export class Device {
     unscheduleOta = vi.fn(() => {
         this.scheduledOta = undefined;
     });
+    abortOta = vi.fn();
     scheduledOta: OtaSource | undefined = undefined;
 
     constructor(
@@ -345,6 +346,7 @@ export class Device {
         this.updateOta.mockClear();
         this.scheduleOta.mockClear();
         this.unscheduleOta.mockClear();
+        this.abortOta.mockClear();
         this.meta = {};
         this.scheduledOta = undefined;
 

test/onboarding.test.ts

@@ -5,7 +5,7 @@ import * as data from "./mocks/data";
 import {readFileSync, rmSync, writeFileSync} from "node:fs";
 import {join} from "node:path";
 import type {IncomingMessage, OutgoingHttpHeader, OutgoingHttpHeaders, RequestListener, Server, ServerResponse} from "node:http";
-import JSZip from "jszip";
+import {zipSync} from "fflate";
 import type {findAllDevices} from "zigbee-herdsman/dist/adapter/adapterDiscovery";
 import type {OnboardFailureData, OnboardInitData, OnboardSubmitResponse} from "../lib/types/api";
 import {onboard} from "../lib/util/onboarding";
@@ -540,205 +540,132 @@ describe("Onboarding", () => {
         await responsePromise;
     };
 
-    const createZipRestore = (): Awaited<ReturnType<typeof JSZip.loadAsync>> => {
-        return {
-            files: {
-                "configuration.yaml": {
-                    name: "configuration.yaml",
-                    dir: false,
-                    // @ts-expect-error minimal mock
-                    async: async () => await Promise.resolve(Buffer.from(JSON.stringify(SAMPLE_SETTINGS_SAVE))),
-                },
-                // @ts-expect-error minimal mock
-                "nested/": {
-                    name: "nested/",
-                    dir: true,
-                },
-                "nested/notes.txt": {
-                    name: "nested/notes.txt",
-                    dir: false,
-                    // @ts-expect-error minimal mock
-                    async: async () => await Promise.resolve(Buffer.from("zip-restore")),
-                },
-            },
-        };
-    };
+    const createZipPayload = (files: Parameters<typeof zipSync>[0]): string => Buffer.from(zipSync(files)).toString("base64");
+
+    const createZipRestore = (): string =>
+        createZipPayload({
+            "configuration.yaml": Buffer.from(JSON.stringify(SAMPLE_SETTINGS_SAVE)),
+            nested: {"notes.txt": Buffer.from("zip-restore")},
+        });
 
     it("extracts uploaded ZIP files into the data path", async () => {
         data.removeConfiguration();
-        const loadAsyncSpy = vi.spyOn(JSZip, "loadAsync").mockResolvedValue(createZipRestore());
 
-        try {
-            let p;
-            const submitData = await new Promise<OnboardSubmitResponse>((resolve, reject) => {
-                mockHttpOnListen.mockImplementationOnce(async () => {
-                    try {
-                        resolve(await submitZipPayload(Buffer.from("zip").toString("base64"), false, false));
-                    } catch (error) {
-                        reject(error);
-                    }
-                });
-
-                p = onboard();
+        let p;
+        const submitData = await new Promise<OnboardSubmitResponse>((resolve, reject) => {
+            mockHttpOnListen.mockImplementationOnce(async () => {
+                try {
+                    resolve(await submitZipPayload(createZipRestore(), false, false));
+                } catch (error) {
+                    reject(error);
+                }
             });
 
-            await expect(p).resolves.toStrictEqual(true);
-            expect(data.read()).toStrictEqual(SAMPLE_SETTINGS_SAVE);
-            expect(readFileSync(join(data.mockDir, "nested", "notes.txt"), "utf8")).toStrictEqual("zip-restore");
-            expect(loadAsyncSpy).toHaveBeenCalledTimes(1);
-            expect(submitData).toStrictEqual({success: true, frontendUrl: null});
-        } finally {
-            loadAsyncSpy.mockRestore();
-        }
+            p = onboard();
+        });
+
+        await expect(p).resolves.toStrictEqual(true);
+        expect(data.read()).toStrictEqual(SAMPLE_SETTINGS_SAVE);
+        expect(readFileSync(join(data.mockDir, "nested", "notes.txt"), "utf8")).toStrictEqual("zip-restore");
+        expect(submitData).toStrictEqual({success: true, frontendUrl: null});
     });
 
     it("rejects non-zip upload payloads", async () => {
         data.removeConfiguration();
-        const loadAsyncSpy = vi
-            .spyOn(JSZip, "loadAsync")
-            .mockRejectedValueOnce(new Error("Can't find end of central directory : is this a zip file ?"))
-            .mockResolvedValueOnce(createZipRestore());
 
-        try {
-            let p;
-            const [firstSubmitData, secondSubmitData] = await new Promise<[OnboardSubmitResponse, OnboardSubmitResponse]>((resolve, reject) => {
-                mockHttpOnListen.mockImplementationOnce(async () => {
-                    try {
-                        const failedSubmit = await submitZipPayload(Buffer.from("ignored").toString("base64"), true, false);
-                        const successfulSubmit = await submitZipPayload(Buffer.from("zip").toString("base64"), false, false);
+        let p;
+        const [firstSubmitData, secondSubmitData] = await new Promise<[OnboardSubmitResponse, OnboardSubmitResponse]>((resolve, reject) => {
+            mockHttpOnListen.mockImplementationOnce(async () => {
+                try {
+                    const failedSubmit = await submitZipPayload(Buffer.from("not-a-zip-file").toString("base64"), true, false);
+                    const successfulSubmit = await submitZipPayload(createZipRestore(), false, false);
 
-                        resolve([failedSubmit, successfulSubmit]);
-                    } catch (error) {
-                        reject(error);
-                    }
-                });
-
-                p = onboard();
+                    resolve([failedSubmit, successfulSubmit]);
+                } catch (error) {
+                    reject(error);
+                }
             });
 
-            await expect(p).resolves.toStrictEqual(true);
-            expect(loadAsyncSpy).toHaveBeenCalledTimes(2);
-            expect(data.read()).toStrictEqual(SAMPLE_SETTINGS_SAVE);
-            expect(readFileSync(join(data.mockDir, "nested", "notes.txt"), "utf8")).toStrictEqual("zip-restore");
-            expect(firstSubmitData).toStrictEqual({success: false, error: expect.stringContaining("is this a zip file")});
-            expect(secondSubmitData).toStrictEqual({success: true, frontendUrl: null});
-        } finally {
-            loadAsyncSpy.mockRestore();
-        }
+            p = onboard();
+        });
+
+        await expect(p).resolves.toStrictEqual(true);
+        expect(data.read()).toStrictEqual(SAMPLE_SETTINGS_SAVE);
+        expect(readFileSync(join(data.mockDir, "nested", "notes.txt"), "utf8")).toStrictEqual("zip-restore");
+        expect(firstSubmitData).toStrictEqual({success: false, error: expect.stringContaining("invalid zip data")});
+        expect(secondSubmitData).toStrictEqual({success: true, frontendUrl: null});
     });
 
     it("rejects ZIP upload payloads with invalid entry paths", async () => {
         data.removeConfiguration();
-        const loadAsyncSpy = vi
-            .spyOn(JSZip, "loadAsync")
-            .mockResolvedValueOnce({
-                files: {
-                    "/dragons.txt": {
-                        name: "/dragons.txt",
-                        dir: false,
-                        // @ts-expect-error minimal mock
-                        async: async () => await Promise.resolve(Buffer.from("dragons")),
-                    },
-                },
-            })
-            .mockResolvedValueOnce(createZipRestore());
 
-        try {
-            let p;
-            const [firstSubmitData, secondSubmitData] = await new Promise<[OnboardSubmitResponse, OnboardSubmitResponse]>((resolve, reject) => {
-                mockHttpOnListen.mockImplementationOnce(async () => {
-                    try {
-                        const failedSubmit = await submitZipPayload(Buffer.from("zip-invalid-path").toString("base64"), true, false);
-                        const successfulSubmit = await submitZipPayload(Buffer.from("zip").toString("base64"), false, false);
+        let p;
+        const [firstSubmitData, secondSubmitData] = await new Promise<[OnboardSubmitResponse, OnboardSubmitResponse]>((resolve, reject) => {
+            mockHttpOnListen.mockImplementationOnce(async () => {
+                try {
+                    const failedSubmit = await submitZipPayload(createZipPayload({"/dragons.txt": Buffer.from("dragons")}), true, false);
+                    const successfulSubmit = await submitZipPayload(createZipRestore(), false, false);
 
-                        resolve([failedSubmit, successfulSubmit]);
-                    } catch (error) {
-                        reject(error);
-                    }
-                });
-
-                p = onboard();
+                    resolve([failedSubmit, successfulSubmit]);
+                } catch (error) {
+                    reject(error);
+                }
             });
 
-            await expect(p).resolves.toStrictEqual(true);
-            expect(firstSubmitData).toStrictEqual({success: false, error: expect.stringContaining("Invalid ZIP entry path")});
-            expect(secondSubmitData).toStrictEqual({success: true, frontendUrl: null});
-            expect(loadAsyncSpy).toHaveBeenCalledTimes(2);
-        } finally {
-            loadAsyncSpy.mockRestore();
-        }
+            p = onboard();
+        });
+
+        await expect(p).resolves.toStrictEqual(true);
+        expect(firstSubmitData).toStrictEqual({success: false, error: expect.stringContaining("Invalid ZIP entry path")});
+        expect(secondSubmitData).toStrictEqual({success: true, frontendUrl: null});
     });
 
     it("rejects ZIP upload payloads with unsafe relative entry paths", async () => {
         data.removeConfiguration();
-        const loadAsyncSpy = vi
-            .spyOn(JSZip, "loadAsync")
-            .mockResolvedValueOnce({
-                files: {
-                    "../dragons.txt": {
-                        name: "../dragons.txt",
-                        dir: false,
-                        // @ts-expect-error minimal mock
-                        async: async () => await Promise.resolve(Buffer.from("dragons")),
-                    },
-                },
-            })
-            .mockResolvedValueOnce(createZipRestore());
 
-        try {
-            let p;
-            const [firstSubmitData, secondSubmitData] = await new Promise<[OnboardSubmitResponse, OnboardSubmitResponse]>((resolve, reject) => {
-                mockHttpOnListen.mockImplementationOnce(async () => {
-                    try {
-                        const failedSubmit = await submitZipPayload(Buffer.from("zip-unsafe-path").toString("base64"), true, false);
-                        const successfulSubmit = await submitZipPayload(Buffer.from("zip").toString("base64"), false, false);
+        let p;
+        const [firstSubmitData, secondSubmitData] = await new Promise<[OnboardSubmitResponse, OnboardSubmitResponse]>((resolve, reject) => {
+            mockHttpOnListen.mockImplementationOnce(async () => {
+                try {
+                    const failedSubmit = await submitZipPayload(createZipPayload({"../dragons.txt": Buffer.from("dragons")}), true, false);
+                    const successfulSubmit = await submitZipPayload(createZipRestore(), false, false);
 
-                        resolve([failedSubmit, successfulSubmit]);
-                    } catch (error) {
-                        reject(error);
-                    }
-                });
-
-                p = onboard();
+                    resolve([failedSubmit, successfulSubmit]);
+                } catch (error) {
+                    reject(error);
+                }
             });
 
-            await expect(p).resolves.toStrictEqual(true);
-            expect(firstSubmitData).toStrictEqual({success: false, error: expect.stringContaining("Unsafe ZIP entry path")});
-            expect(secondSubmitData).toStrictEqual({success: true, frontendUrl: null});
-            expect(loadAsyncSpy).toHaveBeenCalledTimes(2);
-        } finally {
-            loadAsyncSpy.mockRestore();
-        }
+            p = onboard();
+        });
+
+        await expect(p).resolves.toStrictEqual(true);
+        expect(firstSubmitData).toStrictEqual({success: false, error: expect.stringContaining("Unsafe ZIP entry path")});
+        expect(secondSubmitData).toStrictEqual({success: true, frontendUrl: null});
     });
 
     it("handles empty ZIP upload payloads", async () => {
         data.removeConfiguration();
-        const loadAsyncSpy = vi.spyOn(JSZip, "loadAsync").mockResolvedValue(createZipRestore());
 
-        try {
-            let p;
-            const [firstSubmitData, secondSubmitData] = await new Promise<[OnboardSubmitResponse, OnboardSubmitResponse]>((resolve, reject) => {
-                mockHttpOnListen.mockImplementationOnce(async () => {
-                    try {
-                        const failedSubmit = await submitZipPayload("", true, false);
-                        const successfulSubmit = await submitZipPayload(Buffer.from("zip").toString("base64"), false, false);
+        let p;
+        const [firstSubmitData, secondSubmitData] = await new Promise<[OnboardSubmitResponse, OnboardSubmitResponse]>((resolve, reject) => {
+            mockHttpOnListen.mockImplementationOnce(async () => {
+                try {
+                    const failedSubmit = await submitZipPayload("", true, false);
+                    const successfulSubmit = await submitZipPayload(createZipRestore(), false, false);
 
-                        resolve([failedSubmit, successfulSubmit]);
-                    } catch (error) {
-                        reject(error);
-                    }
-                });
-
-                p = onboard();
+                    resolve([failedSubmit, successfulSubmit]);
+                } catch (error) {
+                    reject(error);
+                }
             });
 
-            await expect(p).resolves.toStrictEqual(true);
-            expect(firstSubmitData).toStrictEqual({success: false, error: "Invalid ZIP payload: missing content"});
-            expect(secondSubmitData).toStrictEqual({success: true, frontendUrl: null});
-            expect(loadAsyncSpy).toHaveBeenCalledTimes(1);
-        } finally {
-            loadAsyncSpy.mockRestore();
-        }
+            p = onboard();
+        });
+
+        await expect(p).resolves.toStrictEqual(true);
+        expect(firstSubmitData).toStrictEqual({success: false, error: "Invalid ZIP payload: missing content"});
+        expect(secondSubmitData).toStrictEqual({success: true, frontendUrl: null});
     });
 
     it("handles request stream errors for submit endpoint", async () => {
@@ -767,32 +694,26 @@ describe("Onboarding", () => {
 
     it("handles request stream errors for submit-zip endpoint", async () => {
         data.removeConfiguration();
-        const loadAsyncSpy = vi.spyOn(JSZip, "loadAsync").mockResolvedValue(createZipRestore());
 
-        try {
-            let p;
-            const [firstSubmitData, secondSubmitData] = await new Promise<[OnboardSubmitResponse, OnboardSubmitResponse]>((resolve, reject) => {
-                mockHttpOnListen.mockImplementationOnce(async () => {
-                    try {
-                        const failedSubmit = await submitZipPayload("", true, true);
-                        const successfulSubmit = await submitZipPayload(Buffer.from("zip").toString("base64"), false, false);
+        let p;
+        const [firstSubmitData, secondSubmitData] = await new Promise<[OnboardSubmitResponse, OnboardSubmitResponse]>((resolve, reject) => {
+            mockHttpOnListen.mockImplementationOnce(async () => {
+                try {
+                    const failedSubmit = await submitZipPayload("", true, true);
+                    const successfulSubmit = await submitZipPayload(createZipRestore(), false, false);
 
-                        resolve([failedSubmit, successfulSubmit]);
-                    } catch (error) {
-                        reject(error);
-                    }
-                });
-
-                p = onboard();
+                    resolve([failedSubmit, successfulSubmit]);
+                } catch (error) {
+                    reject(error);
+                }
             });
 
-            await expect(p).resolves.toStrictEqual(true);
-            expect(firstSubmitData).toStrictEqual({success: false, error: "request error submit-zip"});
-            expect(secondSubmitData).toStrictEqual({success: true, frontendUrl: null});
-            expect(loadAsyncSpy).toHaveBeenCalledTimes(1);
-        } finally {
-            loadAsyncSpy.mockRestore();
-        }
+            p = onboard();
+        });
+
+        await expect(p).resolves.toStrictEqual(true);
+        expect(firstSubmitData).toStrictEqual({success: false, error: "request error submit-zip"});
+        expect(secondSubmitData).toStrictEqual({success: true, frontendUrl: null});
     });
 
     it("passes unknown onboarding routes to static file server", async () => {

test/settings.test.ts

@@ -3,7 +3,7 @@ import {beforeEach, describe, expect, it} from "vitest";
 import "./mocks/data";
 
 import fs from "node:fs";
-import yaml from "js-yaml";
+import {dump, load} from "js-yaml";
 import objectAssignDeep from "object-assign-deep";
 
 import mockedData from "../lib/util/data";
@@ -21,14 +21,14 @@ const minimalConfig = {
 
 describe("Settings", () => {
     const write = (file: string, json: Record<string, unknown>, reread = true): void => {
-        fs.writeFileSync(file, yaml.dump(json));
+        fs.writeFileSync(file, dump(json));
 
         if (reread) {
             settings.reRead();
         }
     };
 
-    const read = (file: string): unknown => yaml.load(fs.readFileSync(file, "utf8"));
+    const read = (file: string): unknown => load(fs.readFileSync(file, "utf8"));
 
     const remove = (file: string): void => {
         if (fs.existsSync(file)) {

test/utils.test.ts

@@ -2,6 +2,7 @@ import {exec} from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import {describe, expect, it, vi} from "vitest";
+import {stringify} from "../lib/util/stringify";
 import utils, {assertString} from "../lib/util/utils";
 
 // keep the implementations, just spy
@@ -155,4 +156,37 @@ describe("Utils", () => {
             },
         });
     });
+
+    it("stable stringify", () => {
+        expect(
+            stringify({
+                a: "a",
+                b: 2,
+                3: "c",
+                d: Buffer.from([1, 2]),
+                e: new Int16Array([0xfffd, 0xff11]),
+                beef: 0xfacen,
+                zed: new BigUint64Array([1n, 0xffffffffn]),
+                ris: [1, undefined, "b", 0xfeefn, Number.NaN, undefined],
+                ls: undefined,
+            }),
+        ).toStrictEqual(
+            `{"3":"c","a":"a","b":2,"beef":"64206","d":{"data":[1,2],"type":"Buffer"},"e":{"0":-3,"1":-239},"ris":[1,null,"b","65263",null,null],"zed":{"0":"1","1":"4294967295"}}`,
+        );
+        // @ts-expect-error intentional to reach code for coverage
+        expect(stringify(undefined)).toStrictEqual("null");
+
+        const circularObj: Record<string, unknown> = {a: 1, b: undefined};
+        circularObj.b = circularObj;
+
+        expect(stringify(circularObj)).toStrictEqual(`{"a":1,"b":"[Circular]"}`);
+
+        const toJSONIsString = {a: 1, toJSON: () => `{"a":1}`};
+
+        expect(stringify(toJSONIsString)).toStrictEqual(`"{\\"a\\":1}"`);
+
+        const toJSONIsNull = {a: 1, toJSON: () => null};
+
+        expect(stringify(toJSONIsNull)).toStrictEqual("null");
+    });
 });