chore(dev): release 2.6.0 (#27881 )

fix(ignore): update zigbee-herdsman-converters to 24.11.0 (#28143 )
fix(ignore): update zigbee-herdsman to 5.0.4 (#28141 )
2026-08-29 15:18:41 +00:00 · 2025-08-01 17:37:30 +02:00 · 2025-08-01 15:22:20 +00:00 · 2025-08-01 15:04:45 +00:00 · 2025-08-01 14:56:52 +00:00 · 2025-07-31 20:26:36 +02:00
70 changed files with 3140 additions and 1027 deletions
@@ -69,6 +69,12 @@ body:
          placeholder: Add-on on Home Assistant OS on Intel NUC, Plain on Docker container, ...
      validations:
          required: true
+    - type: input
+      id: device
+      attributes:
+          label: Device `database.db` entry
+          description: If the problem is related to a specific device, paste the `database.db` entry here
+          placeholder: '{"id":117,"type":"EndDevice","ieeeAddr":"0x00158d0001d8e1d2","nwkAddr":25887 ...'
    - type: textarea
      id: log
      attributes:
@@ -1,6 +1,7 @@
 version: 2
 updates:
    - package-ecosystem: npm
+      versioning-strategy: increase
      directory: /
      schedule:
          interval: weekly
@@ -14,7 +15,7 @@ updates:
                  - minor
                  - patch
    - package-ecosystem: docker
-      directory: /
+      directory: /docker
      schedule:
        interval: weekly
      target-branch: dev
@@ -1,6 +1,13 @@
 name: CI

-on: [pull_request, push]
+on:
+  push:
+    tags:        
+      - '[0-9]+.[0-9]+.[0-9]+' 
+    branches:
+      - dev
+      - master
+  pull_request:

 permissions:
    contents: write
@@ -41,6 +48,13 @@ jobs:
            - name: Test
              run: pnpm run test:coverage

+            - name: Bench
+              if: github.ref == 'refs/heads/dev' || (github.event_name == 'pull_request' && !startsWith(github.head_ref, 'release-please-'))
+              uses: CodSpeedHQ/action@v3
+              with:
+                run: pnpm run bench
+                token: ${{ secrets.CODSPEED_TOKEN }}
+
            - name: Log in to the Docker container registry
              if: (github.ref == 'refs/heads/dev' || startsWith(github.ref, 'refs/tags/')) && github.event_name == 'push'
              uses: docker/login-action@v3
@@ -83,6 +97,22 @@ jobs:
                      VERSION=dev
                      DATE=${{ github.event.repository.updated_at }}

+            - name: dev - Publish types
+              if: github.ref == 'refs/heads/dev' && github.event_name == 'push'
+              run: |
+                pnpm run build:types
+                temp_dir=$(mktemp -d)
+                cp -R package.json LICENSE dist $temp_dir
+                git fetch --unshallow
+                git checkout dev-types
+                rm -rf *
+                cp -R $temp_dir/* .
+                git add -A
+                git config --local user.email "41898282+github-actions[bot]@users.noreply.github.com"
+                git config --local user.name "github-actions[bot]"
+                git commit -m "$GITHUB_SHA" || echo 'Nothing to commit'
+                git push --force --set-upstream origin dev-types
+
            - name: release - Docker meta
              if: startsWith(github.ref, 'refs/tags/') && github.event_name == 'push'
              uses: docker/metadata-action@v5
@@ -53,6 +53,7 @@ typings/

 # Build cache
 tsconfig.tsbuildinfo
+tsconfig.types.tsbuildinfo

 # Optional REPL history
 .node_repl_history
@@ -76,6 +77,7 @@ tsconfig.tsbuildinfo
 # Ignore config
 data/*
 !data/configuration.example.yaml
+data-bench

 # commit-user-lookup.json
 scripts/commit-user-lookup.json
@@ -1,3 +1,3 @@
 {
-    ".": "2.4.0"
+    ".": "2.6.0"
 }
@@ -1,5 +1,125 @@
 # Changelog

+## [2.6.0](https://github.com/Koenkk/zigbee2mqtt/compare/2.5.1...2.6.0) (2025-08-01)
+
+
+### Features
+
+* Allow to disable internal frontend UI serving for standalone serving ([#27851](https://github.com/Koenkk/zigbee2mqtt/issues/27851)) ([0215e76](https://github.com/Koenkk/zigbee2mqtt/commit/0215e76118c8dcbe77c1ed4890846aaf7da85bae))
+
+
+### Bug Fixes
+
+* erroneous Health OS memory percent calculation ([#27892](https://github.com/Koenkk/zigbee2mqtt/issues/27892)) ([190cfe9](https://github.com/Koenkk/zigbee2mqtt/commit/190cfe99ac62b9dc6db4dc59a4389afda85e8177))
+* Exit with code 2 when adapters disconnects ([#28013](https://github.com/Koenkk/zigbee2mqtt/issues/28013)) ([0e0a561](https://github.com/Koenkk/zigbee2mqtt/commit/0e0a5618af9a1b5707ddccbca2cde983cafb40b5))
+* Fix settings schema defaults ([#27961](https://github.com/Koenkk/zigbee2mqtt/issues/27961)) ([ecadda4](https://github.com/Koenkk/zigbee2mqtt/commit/ecadda45e7c5665f9e242c956f5f140b7caa6eed))
+* Ignore symbolic links in `data` during backup ([#28132](https://github.com/Koenkk/zigbee2mqtt/issues/28132)) ([0182c4b](https://github.com/Koenkk/zigbee2mqtt/commit/0182c4b32efafc85d1f4a38840345944501feaef))
+* **ignore:** add test to specifically check HA envs ([#27969](https://github.com/Koenkk/zigbee2mqtt/issues/27969)) ([833605b](https://github.com/Koenkk/zigbee2mqtt/commit/833605b71f110b4e7aeb6632694820cdd1110e25))
+* **ignore:** bump the minor-patch group with 2 updates ([#27924](https://github.com/Koenkk/zigbee2mqtt/issues/27924)) ([8ceb087](https://github.com/Koenkk/zigbee2mqtt/commit/8ceb08704f7e5d637b661c745c804beebf38eed9))
+* **ignore:** bump the minor-patch group with 4 updates ([#28046](https://github.com/Koenkk/zigbee2mqtt/issues/28046)) ([e505a93](https://github.com/Koenkk/zigbee2mqtt/commit/e505a93a4036affe9e531b24e29ee543ed4cb0f5))
+* **ignore:** fix 71cf2b41603a9923024c0472ffc1f7bfe3d14fc7 ([6dd812f](https://github.com/Koenkk/zigbee2mqtt/commit/6dd812f71cf9ca6737777c3d4acfab35c52a76b8))
+* **ignore:** fix breaking changes of https://github.com/Koenkk/zigbee2mqtt/pull/28077 ([713551b](https://github.com/Koenkk/zigbee2mqtt/commit/713551b5257f8624ed03f7901f0addf6864faf1f))
+* **ignore:** Remove retain/qos from mqtt publish logging https://github.com/Koenkk/zigbee2mqtt/pull/27983 ([e2b7df9](https://github.com/Koenkk/zigbee2mqtt/commit/e2b7df9f84550aa413f3453bb97a13ba2eee4187))
+* **ignore:** update zigbee-herdsman to 4.3.2 ([#27900](https://github.com/Koenkk/zigbee2mqtt/issues/27900)) ([4afdd4e](https://github.com/Koenkk/zigbee2mqtt/commit/4afdd4e89241eddeb27e5f6c1c7b6604ce4a41cb))
+* **ignore:** update zigbee-herdsman to 4.4.0 ([#27906](https://github.com/Koenkk/zigbee2mqtt/issues/27906)) ([e663e86](https://github.com/Koenkk/zigbee2mqtt/commit/e663e86e09cf86078877407e2233447468d66899))
+* **ignore:** update zigbee-herdsman to 4.4.1 ([#27918](https://github.com/Koenkk/zigbee2mqtt/issues/27918)) ([eb82973](https://github.com/Koenkk/zigbee2mqtt/commit/eb829730678dad354d3feede2155f142d58a140f))
+* **ignore:** update zigbee-herdsman to 4.5.0 ([#28044](https://github.com/Koenkk/zigbee2mqtt/issues/28044)) ([cc6f7b0](https://github.com/Koenkk/zigbee2mqtt/commit/cc6f7b02bc2d7548f142ec162696eae06027d6a3))
+* **ignore:** update zigbee-herdsman to 5.0.0 ([#28077](https://github.com/Koenkk/zigbee2mqtt/issues/28077)) ([9a215ef](https://github.com/Koenkk/zigbee2mqtt/commit/9a215efe26be6fafde0f0a779b651ded860cd90c))
+* **ignore:** update zigbee-herdsman to 5.0.1 ([#28080](https://github.com/Koenkk/zigbee2mqtt/issues/28080)) ([6432571](https://github.com/Koenkk/zigbee2mqtt/commit/6432571c61b6e2d4bcc17cc952eeacdaf72213f6))
+* **ignore:** update zigbee-herdsman to 5.0.2 ([#28110](https://github.com/Koenkk/zigbee2mqtt/issues/28110)) ([e9f2a3f](https://github.com/Koenkk/zigbee2mqtt/commit/e9f2a3f5326954f361199bd4d73ed944f72f6ebe))
+* **ignore:** update zigbee-herdsman to 5.0.3 ([#28121](https://github.com/Koenkk/zigbee2mqtt/issues/28121)) ([e5f677b](https://github.com/Koenkk/zigbee2mqtt/commit/e5f677bdd1cc3df4d05dd1f8164220ae2258f081))
+* **ignore:** update zigbee-herdsman to 5.0.4 ([#28141](https://github.com/Koenkk/zigbee2mqtt/issues/28141)) ([9fcc41b](https://github.com/Koenkk/zigbee2mqtt/commit/9fcc41b199082e47d96de4cad996c55c39da83a5))
+* **ignore:** update zigbee-herdsman-converters to 23.70.0 ([#27905](https://github.com/Koenkk/zigbee2mqtt/issues/27905)) ([163a15d](https://github.com/Koenkk/zigbee2mqtt/commit/163a15d664432631f100814927647b918563d85b))
+* **ignore:** update zigbee-herdsman-converters to 23.70.1 ([#27916](https://github.com/Koenkk/zigbee2mqtt/issues/27916)) ([e047324](https://github.com/Koenkk/zigbee2mqtt/commit/e04732462c218cd42c2b617aefba37a5f61d1ce6))
+* **ignore:** update zigbee-herdsman-converters to 23.71.0 ([#27931](https://github.com/Koenkk/zigbee2mqtt/issues/27931)) ([93c1824](https://github.com/Koenkk/zigbee2mqtt/commit/93c1824b1d81c997f0e5a445acac421300f55758))
+* **ignore:** update zigbee-herdsman-converters to 23.72.0 ([#27943](https://github.com/Koenkk/zigbee2mqtt/issues/27943)) ([b4a9424](https://github.com/Koenkk/zigbee2mqtt/commit/b4a9424d604c47609071ef33e88ee55a55a6c8d5))
+* **ignore:** update zigbee-herdsman-converters to 24.0.0 ([#27946](https://github.com/Koenkk/zigbee2mqtt/issues/27946)) ([c465ef8](https://github.com/Koenkk/zigbee2mqtt/commit/c465ef83526c434cac6555836d82e7707072b754))
+* **ignore:** update zigbee-herdsman-converters to 24.1.0 ([#27973](https://github.com/Koenkk/zigbee2mqtt/issues/27973)) ([a837702](https://github.com/Koenkk/zigbee2mqtt/commit/a837702b2c1f517dcfa3a0f578d9b5b3700b171d))
+* **ignore:** update zigbee-herdsman-converters to 24.10.0 ([#28122](https://github.com/Koenkk/zigbee2mqtt/issues/28122)) ([ee1c884](https://github.com/Koenkk/zigbee2mqtt/commit/ee1c884031fdef516393ce68754a9dbcc8ad093d))
+* **ignore:** update zigbee-herdsman-converters to 24.11.0 ([#28143](https://github.com/Koenkk/zigbee2mqtt/issues/28143)) ([3765549](https://github.com/Koenkk/zigbee2mqtt/commit/376554943d15c45a15d30713002d825286204581))
+* **ignore:** update zigbee-herdsman-converters to 24.2.0 ([#27986](https://github.com/Koenkk/zigbee2mqtt/issues/27986)) ([6ede403](https://github.com/Koenkk/zigbee2mqtt/commit/6ede4036886066bf91953b13714a16ba96217b6d))
+* **ignore:** update zigbee-herdsman-converters to 24.3.0 ([#28015](https://github.com/Koenkk/zigbee2mqtt/issues/28015)) ([21fa5cb](https://github.com/Koenkk/zigbee2mqtt/commit/21fa5cbdeddb51d55364c4d28b887791384a951b))
+* **ignore:** update zigbee-herdsman-converters to 24.4.0 ([#28022](https://github.com/Koenkk/zigbee2mqtt/issues/28022)) ([74e9357](https://github.com/Koenkk/zigbee2mqtt/commit/74e9357a5989c6b1eeb25aa91c0da27b7b54fa67))
+* **ignore:** update zigbee-herdsman-converters to 24.5.0 ([#28045](https://github.com/Koenkk/zigbee2mqtt/issues/28045)) ([bc74d0b](https://github.com/Koenkk/zigbee2mqtt/commit/bc74d0b11b58bb2cb2bcc07f5ae9c47b1ca7a13e))
+* **ignore:** update zigbee-herdsman-converters to 24.6.0 ([#28051](https://github.com/Koenkk/zigbee2mqtt/issues/28051)) ([4bc6a59](https://github.com/Koenkk/zigbee2mqtt/commit/4bc6a59ff38f9a102259afbff2606a75409042a3))
+* **ignore:** update zigbee-herdsman-converters to 24.7.0 ([#28070](https://github.com/Koenkk/zigbee2mqtt/issues/28070)) ([81bafa5](https://github.com/Koenkk/zigbee2mqtt/commit/81bafa55201d6d7a34b364a85c19423a56eceeee))
+* **ignore:** update zigbee-herdsman-converters to 24.8.0 ([#28081](https://github.com/Koenkk/zigbee2mqtt/issues/28081)) ([caf91cd](https://github.com/Koenkk/zigbee2mqtt/commit/caf91cd7ffb8ae4961c3f43875f051b182f1a379))
+* **ignore:** update zigbee-herdsman-converters to 24.9.0 ([71cf2b4](https://github.com/Koenkk/zigbee2mqtt/commit/71cf2b41603a9923024c0472ffc1f7bfe3d14fc7))
+* **ignore:** update zigbee2mqtt-frontend to 0.9.17 ([#27917](https://github.com/Koenkk/zigbee2mqtt/issues/27917)) ([a3e7f69](https://github.com/Koenkk/zigbee2mqtt/commit/a3e7f69b3ff6173a59b4d5e2ad1f09c2c414b416))
+* **ignore:** update zigbee2mqtt-frontend to 0.9.19 ([#28021](https://github.com/Koenkk/zigbee2mqtt/issues/28021)) ([8b87682](https://github.com/Koenkk/zigbee2mqtt/commit/8b876823da7fbde4f980fefa54cec7c3fa52c423))
+* **ignore:** update zigbee2mqtt-windfront to 1.3.0 ([#27953](https://github.com/Koenkk/zigbee2mqtt/issues/27953)) ([1b37bae](https://github.com/Koenkk/zigbee2mqtt/commit/1b37baefd3e6817fc9dbf36c9ec9e8aec4481643))
+* **ignore:** update zigbee2mqtt-windfront to 1.3.1 ([#27999](https://github.com/Koenkk/zigbee2mqtt/issues/27999)) ([a51216e](https://github.com/Koenkk/zigbee2mqtt/commit/a51216e3c76335b66a9383b1734a213ad948d70a))
+* **ignore:** update zigbee2mqtt-windfront to 1.4.1 ([#28062](https://github.com/Koenkk/zigbee2mqtt/issues/28062)) ([d322dc2](https://github.com/Koenkk/zigbee2mqtt/commit/d322dc20479faffa8f923e2190c1a5f82d17d5e4))
+* **ignore:** update zigbee2mqtt-windfront to 1.5.0 ([#28082](https://github.com/Koenkk/zigbee2mqtt/issues/28082)) ([29e56ad](https://github.com/Koenkk/zigbee2mqtt/commit/29e56adc159268038727d955135d3edbedbaae8b))
+* **ignore:** update zigbee2mqtt-windfront to 1.5.1 ([#28123](https://github.com/Koenkk/zigbee2mqtt/issues/28123)) ([31d3e19](https://github.com/Koenkk/zigbee2mqtt/commit/31d3e19f3862b067555bcbc9bbcd3a5ded6df211))
+* **ignore:** update zigbee2mqtt-windfront to 1.5.2 ([#28140](https://github.com/Koenkk/zigbee2mqtt/issues/28140)) ([fe5639c](https://github.com/Koenkk/zigbee2mqtt/commit/fe5639ce40cf0a4035cd996a558c952dc065fcd0))
+* Improve startup settings validation ([#27988](https://github.com/Koenkk/zigbee2mqtt/issues/27988)) ([435a6cc](https://github.com/Koenkk/zigbee2mqtt/commit/435a6cceb9aea1ac6941c99603d7785ef91e274a))
+* log error message when external JS fails to load ([#27837](https://github.com/Koenkk/zigbee2mqtt/issues/27837)) ([f4d821d](https://github.com/Koenkk/zigbee2mqtt/commit/f4d821deca71540f830f38f631d1a3759c1d0f40))
+* Publish definition source in `bridge/devices` ([#28076](https://github.com/Koenkk/zigbee2mqtt/issues/28076)) ([65eef1b](https://github.com/Koenkk/zigbee2mqtt/commit/65eef1b6900afdf831c809047ab68e93df59b4b0))
+* Publish endpoint names in `bridge/devices` ([#28057](https://github.com/Koenkk/zigbee2mqtt/issues/28057)) ([5f9019a](https://github.com/Koenkk/zigbee2mqtt/commit/5f9019a95fb460f1dc4a31d09e2424ff56049c14))
+* Set MQTT retain and qos=1 on (re)connect ([#27983](https://github.com/Koenkk/zigbee2mqtt/issues/27983)) ([ef07505](https://github.com/Koenkk/zigbee2mqtt/commit/ef07505b31782936a3ae517688c7e1eb9e541daf))
+* Various fixes to align behaviors (+add benchmarks for dev) ([#28011](https://github.com/Koenkk/zigbee2mqtt/issues/28011)) ([db20369](https://github.com/Koenkk/zigbee2mqtt/commit/db203694477ff718386a3d97ca260dccd0dc0597))
+
+## [2.5.1](https://github.com/Koenkk/zigbee2mqtt/compare/2.5.0...2.5.1) (2025-07-02)
+
+
+### Bug Fixes
+
+* **ignore:** update zigbee-herdsman to 4.3.1 ([#27878](https://github.com/Koenkk/zigbee2mqtt/issues/27878)) ([917d852](https://github.com/Koenkk/zigbee2mqtt/commit/917d8527a5efcf349153ed71e8a44b6d6c87b398))
+* Various Windfront frontend improvements [@nerivec](https://github.com/nerivec) ([#27880](https://github.com/Koenkk/zigbee2mqtt/issues/27880)) ([4dd7dab](https://github.com/Koenkk/zigbee2mqtt/commit/4dd7dabf0803e3cad6e9b6aa1683a2ea8984fb0e))
+
+## [2.5.0](https://github.com/Koenkk/zigbee2mqtt/compare/2.4.0...2.5.0) (2025-07-01)
+
+
+### Features
+
+* New health extension & extras in `bridge/info` ([#27164](https://github.com/Koenkk/zigbee2mqtt/issues/27164)) ([cd9b752](https://github.com/Koenkk/zigbee2mqtt/commit/cd9b752ede91db1d02c567dded92c4e52c05b88d))
+
+
+### Bug Fixes
+
+* Bump Alpine to 3.22 ([#27690](https://github.com/Koenkk/zigbee2mqtt/issues/27690)) ([f6c3887](https://github.com/Koenkk/zigbee2mqtt/commit/f6c3887c812ea6e15e950e6d55e0274356f2eea5))
+* Fix devices not immediately marked as offline when timeout expires ([#27691](https://github.com/Koenkk/zigbee2mqtt/issues/27691)) ([e4b253e](https://github.com/Koenkk/zigbee2mqtt/commit/e4b253e08beb147367872aa4517df93a03ef1a4f))
+* Generate group ID if empty string given ([#27702](https://github.com/Koenkk/zigbee2mqtt/issues/27702)) ([0e66b29](https://github.com/Koenkk/zigbee2mqtt/commit/0e66b29983ae691a2dab44f6649e20a9e00a43cd))
+* **ignore:** API correctness ([#27637](https://github.com/Koenkk/zigbee2mqtt/issues/27637)) ([018fad2](https://github.com/Koenkk/zigbee2mqtt/commit/018fad27afb5861b1d9c7adff3161c926ccbbaa4))
+* **ignore:** bump @types/node from 22.15.30 to 24.0.3 ([#27745](https://github.com/Koenkk/zigbee2mqtt/issues/27745)) ([de80045](https://github.com/Koenkk/zigbee2mqtt/commit/de800450ad31e5d8ad5c342b061dc3c59f0d565e))
+* **ignore:** bump the minor-patch group across 1 directory with 4 updates ([#27858](https://github.com/Koenkk/zigbee2mqtt/issues/27858)) ([c8dc26b](https://github.com/Koenkk/zigbee2mqtt/commit/c8dc26b241ae6562271d56fe59a13f05927b2bb4))
+* **ignore:** bump the minor-patch group with 2 updates ([#27797](https://github.com/Koenkk/zigbee2mqtt/issues/27797)) ([50b0ffd](https://github.com/Koenkk/zigbee2mqtt/commit/50b0ffd7e7ef343fec983a62d2268feda28b01ba))
+* **ignore:** bump the minor-patch group with 3 updates ([#27598](https://github.com/Koenkk/zigbee2mqtt/issues/27598)) ([7e82a3d](https://github.com/Koenkk/zigbee2mqtt/commit/7e82a3d1e960d4fa2d89558b6d6a20534e7d6ecf))
+* **ignore:** bump the minor-patch group with 4 updates ([#27610](https://github.com/Koenkk/zigbee2mqtt/issues/27610)) ([ac80bb6](https://github.com/Koenkk/zigbee2mqtt/commit/ac80bb6430007e494c544089af323c3fb99c3541))
+* **ignore:** bump the minor-patch group with 6 updates ([#27678](https://github.com/Koenkk/zigbee2mqtt/issues/27678)) ([587a02f](https://github.com/Koenkk/zigbee2mqtt/commit/587a02f66319688cb93df82fde02539bce0263ea))
+* **ignore:** bump zigbee2mqtt-windfront from 1.0.5 to 1.0.6 in the minor-patch group ([#27744](https://github.com/Koenkk/zigbee2mqtt/issues/27744)) ([9776729](https://github.com/Koenkk/zigbee2mqtt/commit/977672976f06f644ed6e02e4a17c07b63873c8da))
+* **ignore:** Migrate to Biome 2 ([#27785](https://github.com/Koenkk/zigbee2mqtt/issues/27785)) ([c87d452](https://github.com/Koenkk/zigbee2mqtt/commit/c87d4524d599302a0728b85799c9bf7c0784a8f4))
+* **ignore:** update zigbee-herdsman to 4.1.1 ([#27640](https://github.com/Koenkk/zigbee2mqtt/issues/27640)) ([4b95b54](https://github.com/Koenkk/zigbee2mqtt/commit/4b95b54be7abc53a7f7a83814994f9cdde90134e))
+* **ignore:** update zigbee-herdsman to 4.1.2 ([#27729](https://github.com/Koenkk/zigbee2mqtt/issues/27729)) ([242815e](https://github.com/Koenkk/zigbee2mqtt/commit/242815e1390e9e3a5ded929e8bfc4a9a4329a526))
+* **ignore:** update zigbee-herdsman to 4.2.0 ([#27786](https://github.com/Koenkk/zigbee2mqtt/issues/27786)) ([15f3eaf](https://github.com/Koenkk/zigbee2mqtt/commit/15f3eaf96629caa5fbd7e02ae002883becc1b49f))
+* **ignore:** update zigbee-herdsman to 4.2.1 ([#27835](https://github.com/Koenkk/zigbee2mqtt/issues/27835)) ([16faef1](https://github.com/Koenkk/zigbee2mqtt/commit/16faef1511e9bfb1cf76c5faaa1008e195ef67fc))
+* **ignore:** update zigbee-herdsman to 4.3.0 ([#27853](https://github.com/Koenkk/zigbee2mqtt/issues/27853)) ([50c7d2d](https://github.com/Koenkk/zigbee2mqtt/commit/50c7d2d6adb9c9366d5c7f829003c84a140f7a19))
+* **ignore:** update zigbee-herdsman-converters to 23.54.0 ([#27600](https://github.com/Koenkk/zigbee2mqtt/issues/27600)) ([1765fe8](https://github.com/Koenkk/zigbee2mqtt/commit/1765fe8925e359b917c1e2e08d3691d4c8bdcf3f))
+* **ignore:** update zigbee-herdsman-converters to 23.55.0 ([#27618](https://github.com/Koenkk/zigbee2mqtt/issues/27618)) ([4594142](https://github.com/Koenkk/zigbee2mqtt/commit/4594142c09ee8d19af2d32238ffa58512694d2ed))
+* **ignore:** update zigbee-herdsman-converters to 23.56.0 ([#27639](https://github.com/Koenkk/zigbee2mqtt/issues/27639)) ([f637e7d](https://github.com/Koenkk/zigbee2mqtt/commit/f637e7d59cc71f32b8d04e8f4bfc414027e7d23a))
+* **ignore:** update zigbee-herdsman-converters to 23.57.0 ([#27646](https://github.com/Koenkk/zigbee2mqtt/issues/27646)) ([252bfba](https://github.com/Koenkk/zigbee2mqtt/commit/252bfbaa20beccd315592dac811cb23309cdee01))
+* **ignore:** update zigbee-herdsman-converters to 23.57.1 ([#27689](https://github.com/Koenkk/zigbee2mqtt/issues/27689)) ([56d3a8f](https://github.com/Koenkk/zigbee2mqtt/commit/56d3a8f9d8bc01e30a6e469b517545d3406941e2))
+* **ignore:** update zigbee-herdsman-converters to 23.58.0 ([#27695](https://github.com/Koenkk/zigbee2mqtt/issues/27695)) ([6a8d208](https://github.com/Koenkk/zigbee2mqtt/commit/6a8d20858ede85de72c34ce58e9df41fa2e91d0d))
+* **ignore:** update zigbee-herdsman-converters to 23.59.0 ([#27712](https://github.com/Koenkk/zigbee2mqtt/issues/27712)) ([87ff0f3](https://github.com/Koenkk/zigbee2mqtt/commit/87ff0f3711e043eb47319e9fb8abcdfa878d9868))
+* **ignore:** update zigbee-herdsman-converters to 23.60.0 ([#27752](https://github.com/Koenkk/zigbee2mqtt/issues/27752)) ([f33d360](https://github.com/Koenkk/zigbee2mqtt/commit/f33d3606be9e916989d08c7d418c4505dcbfe4ea))
+* **ignore:** update zigbee-herdsman-converters to 23.61.0 ([#27759](https://github.com/Koenkk/zigbee2mqtt/issues/27759)) ([b537f9a](https://github.com/Koenkk/zigbee2mqtt/commit/b537f9a93a61095b6b0b82d04d85f7e264aec27c))
+* **ignore:** update zigbee-herdsman-converters to 23.62.0 ([#27767](https://github.com/Koenkk/zigbee2mqtt/issues/27767)) ([281e10c](https://github.com/Koenkk/zigbee2mqtt/commit/281e10c15fa09358e999f1f6b506fe9b08295608))
+* **ignore:** update zigbee-herdsman-converters to 23.63.0 ([#27784](https://github.com/Koenkk/zigbee2mqtt/issues/27784)) ([0d5de75](https://github.com/Koenkk/zigbee2mqtt/commit/0d5de750ffed0674c5a23c2c4d8d1e954c602197))
+* **ignore:** update zigbee-herdsman-converters to 23.64.0 ([#27799](https://github.com/Koenkk/zigbee2mqtt/issues/27799)) ([b7d9c78](https://github.com/Koenkk/zigbee2mqtt/commit/b7d9c78309a8c3e3cf551948b6542d2b71b70697))
+* **ignore:** update zigbee-herdsman-converters to 23.65.0 ([#27804](https://github.com/Koenkk/zigbee2mqtt/issues/27804)) ([4190ba4](https://github.com/Koenkk/zigbee2mqtt/commit/4190ba43b43e1f688e246f9236bfe7c60230a927))
+* **ignore:** update zigbee-herdsman-converters to 23.66.0 ([#27831](https://github.com/Koenkk/zigbee2mqtt/issues/27831)) ([33234d9](https://github.com/Koenkk/zigbee2mqtt/commit/33234d9ce45323a2a10b7839c5f7aebc84a9cc32))
+* **ignore:** update zigbee-herdsman-converters to 23.67.0 ([#27842](https://github.com/Koenkk/zigbee2mqtt/issues/27842)) ([6930fa6](https://github.com/Koenkk/zigbee2mqtt/commit/6930fa6f3fce8f415302c8db32294b1a9d0ea333))
+* **ignore:** update zigbee-herdsman-converters to 23.68.0 ([#27852](https://github.com/Koenkk/zigbee2mqtt/issues/27852)) ([3ccbaf2](https://github.com/Koenkk/zigbee2mqtt/commit/3ccbaf21d227b7c4ad7952522a980a9083f06463))
+* **ignore:** update zigbee-herdsman-converters to 23.69.0 ([#27860](https://github.com/Koenkk/zigbee2mqtt/issues/27860)) ([5285b7b](https://github.com/Koenkk/zigbee2mqtt/commit/5285b7b95e3c977cca14d28444b9f4f2a9d8996c))
+* **ignore:** update zigbee2mqtt-frontend to 0.9.14 ([#27645](https://github.com/Koenkk/zigbee2mqtt/issues/27645)) ([66e1318](https://github.com/Koenkk/zigbee2mqtt/commit/66e1318a79502cb723cf88d888c9ac23daeb7fd8))
+* **ignore:** update zigbee2mqtt-frontend to 0.9.15 ([#27711](https://github.com/Koenkk/zigbee2mqtt/issues/27711)) ([8ecb9be](https://github.com/Koenkk/zigbee2mqtt/commit/8ecb9be98efb44db23f386e05509389c7d681025))
+* **ignore:** update zigbee2mqtt-frontend to 0.9.16 ([#27783](https://github.com/Koenkk/zigbee2mqtt/issues/27783)) ([7109900](https://github.com/Koenkk/zigbee2mqtt/commit/7109900bcfeff48fdea48456455cd1c6cebf380a))
+* **ignore:** update zigbee2mqtt-windfront to 1.0.5 ([#27656](https://github.com/Koenkk/zigbee2mqtt/issues/27656)) ([eaa3e45](https://github.com/Koenkk/zigbee2mqtt/commit/eaa3e458b5a8a9c5ebf31e12ae7e68fcf60f762f))
+* **ignore:** update zigbee2mqtt-windfront to 1.1.0 ([#27763](https://github.com/Koenkk/zigbee2mqtt/issues/27763)) ([cdad6cc](https://github.com/Koenkk/zigbee2mqtt/commit/cdad6ccd75200061ded795af032f0fed0bb21484))
+* Rename fix typo in backoff settings https://github.com/Koenkk/zigbee2mqtt/issues/27642 ([0181263](https://github.com/Koenkk/zigbee2mqtt/commit/0181263d32dd1099676ed92226a3fc2ee6ac701e))
+* update zigbee2mqtt-windfront to 1.0.4 ([#27641](https://github.com/Koenkk/zigbee2mqtt/issues/27641)) ([9a4ce6f](https://github.com/Koenkk/zigbee2mqtt/commit/9a4ce6fcd0fce6fea9c195ff48a41096b738dccb))
+
 ## [2.4.0](https://github.com/Koenkk/zigbee2mqtt/compare/2.3.0...2.4.0) (2025-06-01)


@@ -5,33 +5,27 @@
    <br>
    <br>
    <div style="display: flex;">
-        <a href="https://github.com/Koenkk/zigbee2mqtt/actions?query=workflow%3Aci">
-            <img src="https://github.com/koenkk/zigbee2mqtt/workflows/ci/badge.svg">
-        </a>
        <a href="https://github.com/Koenkk/zigbee2mqtt/releases">
            <img src="https://img.shields.io/github/release/koenkk/zigbee2mqtt.svg">
        </a>
+        <a href="https://www.npmjs.com/package/zigbee2mqtt">
+            <img src="https://img.shields.io/npm/v/zigbee2mqtt">
+        </a>
+        <a href="https://github.com/Koenkk/zigbee2mqtt/actions/workflows/ci.yml">
+            <img src="https://github.com/Koenkk/zigbee2mqtt/actions/workflows/ci.yml/badge.svg">
+        </a>
+        <a href="https://github.com/Koenkk/zigbee2mqtt/actions/workflows/github-code-scanning/codeql">
+            <img src="https://github.com/Koenkk/zigbee2mqtt/actions/workflows/github-code-scanning/codeql/badge.svg">
+        </a>
+        <a href="https://discord.gg/dadfWYE">
+            <img src="https://img.shields.io/discord/556563650429583360.svg">
+        </a>
        <a href="https://github.com/Koenkk/zigbee2mqtt/stargazers">
            <img src="https://img.shields.io/github/stars/koenkk/zigbee2mqtt.svg">
        </a>
        <a href="https://www.paypal.me/koenkk">
            <img src="https://img.shields.io/badge/donate-PayPal-blue.svg">
        </a>
-        <a href="https://discord.gg/dadfWYE">
-            <img src="https://img.shields.io/discord/556563650429583360.svg">
-        </a>
-        <a href="http://zigbee2mqtt.discourse.group/">
-            <img src="https://img.shields.io/discourse/https/zigbee2mqtt.discourse.group/status.svg">
-        </a>
-        <a>
-            <img src="https://img.shields.io/badge/Coverage-100%25-brightgreen.svg">
-        </a>
-        <a href="https://www.codacy.com/manual/Koenkk/zigbee2mqtt?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=Koenkk/zigbee2mqtt&amp;utm_campaign=Badge_Grade">
-            <img src="https://api.codacy.com/project/badge/Grade/24f1e0fe39f04daa810e8a1416693d3f">
-        </a>
-        <a href="https://www.npmjs.com/package/zigbee2mqtt">
-            <img src="https://img.shields.io/npm/v/zigbee2mqtt">
-        </a>
    </div>
    <h1>Zigbee2MQTT  🌉 🐝</h1>
    <p>
@@ -52,59 +46,67 @@ If you aren't familiar with **Zigbee** terminology make sure you [read this](htt

 Zigbee2MQTT integrates well with (almost) every home automation solution because it uses MQTT. However the following integrations are worth mentioning:

-<img align="left" height="100px" width="100px" src="https://user-images.githubusercontent.com/7738048/40914297-49e6e560-6800-11e8-8904-36cce896e5a8.png">
-
 ### [Home Assistant](https://www.home-assistant.io/)

- [Home Assistant OS](https://www.home-assistant.io/installation/): Using [the official addon](https://github.com/zigbee2mqtt/hassio-zigbee2mqtt)
- Other installation: using instructions [here](https://www.zigbee2mqtt.io/guide/usage/integrations/home_assistant.html)
+<img align="left" height="75px" width="75px" src="https://user-images.githubusercontent.com/7738048/40914297-49e6e560-6800-11e8-8904-36cce896e5a8.png">

-<br>
+<br clear="right">

-<img align="left" height="100px" width="100px" src="https://etc.athom.com/logo/white/256.png">
+[Home Assistant OS](https://www.home-assistant.io/installation/) using [the official addon](https://github.com/zigbee2mqtt/hassio-zigbee2mqtt) ([other installations](https://www.zigbee2mqtt.io/guide/usage/integrations/home_assistant.html))
+
+<br clear="both">

 ### [Homey](https://homey.app/)

- Integration implemented in the [Homey App](https://homey.app/nl-nl/app/com.gruijter.zigbee2mqtt/)
- Documentation and support in the [Homey Forum](https://community.homey.app/t/83214)
+<img align="left" height="75px" width="75px" src="https://etc.athom.com/logo/white/256.png">

-<br>
+<br clear="right">

-<img align="left" height="100px" width="100px" src="https://user-images.githubusercontent.com/2734836/47615848-b8dd8700-dabd-11e8-9d77-175002dd8987.png">
+Integration implemented in the [Homey App](https://homey.app/nl-nl/app/com.gruijter.zigbee2mqtt/) ([documentation & support](https://community.homey.app/t/83214))
+
+<br clear="both">

 ### [Domoticz](https://www.domoticz.com/)

- Integration implemented in Domoticz ([documentation](https://www.domoticz.com/wiki/Zigbee2MQTT)).
+<img align="left" height="75px" width="75px" src="https://user-images.githubusercontent.com/2734836/47615848-b8dd8700-dabd-11e8-9d77-175002dd8987.png">

-<br>
+<br clear="right">

-<img align="left" height="100px" width="100px" src="./images/gladys-assistant-logo.jpg">
+Integration implemented in Domoticz ([documentation](https://www.domoticz.com/wiki/Zigbee2MQTT)).
+
+<br clear="both">

 ### [Gladys Assistant](https://gladysassistant.com/)

- Integration implemented natively in Gladys Assistant ([documentation](https://gladysassistant.com/docs/integrations/zigbee2mqtt/)).
+<img align="left" height="75px" width="75px" src="./images/gladys-assistant-logo.jpg">

-<br>
+<br clear="right">

-<img align="left" height="100px" width="100px" src="https://forum.iobroker.net/assets/uploads/system/site-logo.png">
+Integration implemented natively in Gladys Assistant ([documentation](https://gladysassistant.com/docs/integrations/zigbee2mqtt/)).
+
+<br clear="both">

 ### [IoBroker](https://www.iobroker.net/)

- Integration implemented in IoBroker ([documentation](https://github.com/o0shojo0o/ioBroker.zigbee2mqtt)).
+<img align="left" height="75px" width="75px" src="https://forum.iobroker.net/assets/uploads/system/site-logo.png">

-<br>
+<br clear="right">
+
+Integration implemented in IoBroker ([documentation](https://github.com/o0shojo0o/ioBroker.zigbee2mqtt)).
+
+<br clear="both">

 ## Architecture

-![Architecture](images/architecture.png)
+![Architecture](images/architecture-new.png)

 ### Internal Architecture

-Zigbee2MQTT is made up of three modules, each developed in its own Github project. Starting from the hardware (adapter) and moving up; [zigbee-herdsman](https://github.com/koenkk/zigbee-herdsman) connects to your Zigbee adapter and makes an API available to the higher levels of the stack. For e.g. Texas Instruments hardware, zigbee-herdsman uses the [TI zStack monitoring and test API](https://github.com/koenkk/zigbee-herdsman/raw/master/docs/Z-Stack%20Monitor%20and%20Test%20API.pdf) to communicate with the adapter. Zigbee-herdsman handles the core Zigbee communication. The module [zigbee-herdsman-converters](https://github.com/koenkk/zigbee-herdsman-converters) handles the mapping from individual device models to the Zigbee clusters they support. [Zigbee clusters](https://github.com/Koenkk/zigbee-herdsman/blob/master/docs/07-5123-08-Zigbee-Cluster-Library.pdf) are the layers of the Zigbee protocol on top of the base protocol that define things like how lights, sensors and switches talk to each other over the Zigbee network. Finally, the Zigbee2MQTT module drives zigbee-herdsman and maps the zigbee messages to MQTT messages. Zigbee2MQTT also keeps track of the state of the system. It uses a `database.db` file to store this state; a text file with a JSON database of connected devices and their capabilities. Zigbee2MQTT provides a [web-based interface](https://github.com/nurikk/zigbee2mqtt-frontend) that allows monitoring and configuration.
+Zigbee2MQTT is made up of three modules, each developed in its own Github project. Starting from the hardware (adapter) and moving up; [zigbee-herdsman](https://github.com/koenkk/zigbee-herdsman) connects to your adapter to handle Zigbee communication and makes an API available to the higher levels of the stack. For e.g. Texas Instruments hardware, zigbee-herdsman uses the [TI zStack monitoring and test API](https://github.com/Koenkk/zigbee-herdsman/wiki/References#texas-instruments-zstack) to communicate with the adapter. The module [zigbee-herdsman-converters](https://github.com/koenkk/zigbee-herdsman-converters) handles the mapping from individual device models to the Zigbee clusters they support. [Zigbee clusters](https://github.com/Koenkk/zigbee-herdsman/wiki/References#csa-zigbee-alliance-spec) are the layers of the Zigbee protocol on top of the base protocol that define things like how lights, sensors and switches talk to each other over the Zigbee network. Finally, the Zigbee2MQTT module drives zigbee-herdsman and maps the zigbee messages to MQTT messages. Zigbee2MQTT also keeps track of the state of the system. It uses a `database.db` file to store this state; a text file with a JSON database of connected devices and their capabilities. Zigbee2MQTT provides several web-based interfaces ([zigbee2mqtt-frontend](https://github.com/nurikk/zigbee2mqtt-frontend), [zigbee2mqtt-windfront](https://github.com/Nerivec/zigbee2mqtt-windfront)) that allows monitoring and configuration.

 ### Developing

-Zigbee2MQTT uses TypeScript (partially for now). Therefore after making changes to files in the `lib/` directory you need to recompile Zigbee2MQTT. This can be done by executing `pnpm run build`. For faster development instead of running `pnpm run build` you can run `pnpm run build-watch` in another terminal session, this will recompile as you change files.
+Zigbee2MQTT uses TypeScript. Therefore after making changes to files in the `lib/` directory you need to recompile Zigbee2MQTT. This can be done by executing `pnpm run build`. For faster development instead of running `pnpm run build` you can run `pnpm run build-watch` in another terminal session, this will recompile as you change files.

 Before running any of the commands, you'll first need to run `pnpm install --include=dev`.
 Before submitting changes run `pnpm run check:w` then `pnpm run test:coverage`.
@@ -1,5 +1,5 @@
 {
-    "$schema": "https://biomejs.dev/schemas/1.9.4/schema.json",
+    "$schema": "https://biomejs.dev/schemas/2.1.2/schema.json",
    "vcs": {
        "enabled": true,
        "clientKind": "git",
@@ -12,10 +12,10 @@
        "bracketSpacing": false
    },
    "files": {
-        "ignore": ["package.json"]
+        "includes": ["**", "!package.json"]
    },
    "linter": {
-        "ignore": [],
+        "includes": ["**"],
        "rules": {
            "correctness": {
                "noUnusedImports": "error"
@@ -55,7 +55,16 @@
                            }
                        ]
                    }
-                }
+                },
+                "useAsConstAssertion": "error",
+                "useDefaultParameterLast": "error",
+                "useEnumInitializers": "error",
+                "useSelfClosingElements": "error",
+                "useSingleVarDeclarator": "error",
+                "noUnusedTemplateLiteral": "error",
+                "useNumberNamespace": "error",
+                "noInferrableTypes": "error",
+                "noUselessElse": "error"
            },
            "performance": {
                "noDelete": "off"
@@ -68,7 +77,7 @@
    },
    "overrides": [
        {
-            "include": ["test/**"],
+            "includes": ["test/**"],
            "linter": {
                "rules": {
                    "style": {
@@ -1,6 +1,6 @@
 ARG TARGETPLATFORM

-FROM alpine:3.21 AS base
+FROM alpine:3.22 AS base

 ENV NODE_ENV=production
 WORKDIR /app
@@ -10,12 +10,16 @@ RUN apk add --no-cache tzdata eudev tini nodejs
 FROM base AS deps

 COPY package.json pnpm-lock.yaml ./
+
 # Make and such are needed to compile serialport for riscv64
-RUN apk add make gcc g++ python3 linux-headers npm && \
-    npm install -g pnpm@10.4.1 && \
+# Install pnpm, configure a tmp-based store, then use it under a cache mount so each arch gets its own store
+RUN --mount=type=cache,id=pnpm-store,target=/tmp/pnpm-store \
+    apk add --no-cache make gcc g++ python3 linux-headers npm && \
+    npm install -g pnpm@$(sed -n 's/.*"packageManager": "pnpm@\([0-9.]*\)".*/\1/p' package.json) && \
+    pnpm config set store-dir /tmp/pnpm-store && \
    pnpm install --frozen-lockfile --no-optional && \
    # serialport has outdated prebuilds that appear to fail on some archs, force build on target platform
-    rm -rf `find ./node_modules/.pnpm/ -wholename "*/@serialport/bindings-cpp/prebuilds" -type d` && \
+    rm -rf $(find ./node_modules/.pnpm/ -wholename "*/@serialport/bindings-cpp/prebuilds" -type d) && \
    pnpm rebuild @serialport/bindings-cpp

 # Release
@@ -1,21 +1,18 @@
-import type Extension from "./extension/extension";
-import type {Zigbee2MQTTAPI} from "./types/api";
-
 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";
 // Extensions
 import ExtensionAvailability from "./extension/availability";
 import ExtensionBind from "./extension/bind";
 import ExtensionBridge from "./extension/bridge";
 import ExtensionConfigure from "./extension/configure";
+import type Extension from "./extension/extension";
 import ExtensionExternalConverters from "./extension/externalConverters";
 import ExtensionExternalExtensions from "./extension/externalExtensions";
 import ExtensionGroups from "./extension/groups";
+import ExtensionHealth from "./extension/health";
 import ExtensionNetworkMap from "./extension/networkMap";
 import ExtensionOnEvent from "./extension/onEvent";
 import ExtensionOTAUpdate from "./extension/otaUpdate";
@@ -23,6 +20,7 @@ import ExtensionPublish from "./extension/publish";
 import ExtensionReceive from "./extension/receive";
 import Mqtt, {type MqttPublishOptions} from "./mqtt";
 import State from "./state";
+import type {Zigbee2MQTTAPI} from "./types/api";
 import logger from "./util/logger";
 import {initSdNotify} from "./util/sd-notify";
 import * as settings from "./util/settings";
@@ -30,10 +28,10 @@ import utils from "./util/utils";
 import Zigbee from "./zigbee";

 export class Controller {
-    private eventBus: EventBus;
-    private zigbee: Zigbee;
-    private state: State;
-    private mqtt: Mqtt;
+    public readonly eventBus: EventBus;
+    public readonly zigbee: Zigbee;
+    public readonly state: State;
+    public readonly mqtt: Mqtt;
    private restartCallback: () => Promise<void>;
    private exitCallback: (code: number, restart: boolean) => Promise<void>;
    public readonly extensions: Set<Extension>;
@@ -76,6 +74,7 @@ export class Controller {
            new ExtensionOTAUpdate(...this.extensionArgs),
            new ExtensionExternalExtensions(...this.extensionArgs),
            new ExtensionAvailability(...this.extensionArgs),
+            new ExtensionHealth(...this.extensionArgs),
        ]);
    }

@@ -282,17 +281,16 @@ export class Controller {
        }
    }

-    async stop(restart = false): Promise<void> {
+    async stop(restart = false, code = 0): Promise<void> {
        this.sdNotify?.notifyStopping();

-        let code = 0;
-
+        let localCode = 0;
        for (const extension of this.extensions) {
            try {
                await extension.stop();
            } catch (error) {
                logger.error(`Failed to stop '${extension.constructor.name}' (${(error as Error).stack})`);
-                code = 1;
+                localCode = 1;
            }
        }

@@ -307,11 +305,11 @@ export class Controller {
            logger.info("Stopped Zigbee2MQTT");
        } catch (error) {
            logger.error(`Failed to stop Zigbee2MQTT (${(error as Error).stack})`);
-            code = 1;
+            localCode = 1;
        }

        this.sdNotify?.stop();
-        return await this.exit(code, restart);
+        return await this.exit(code !== 0 ? code : localCode, restart);
    }

    async exit(code: number, restart = false): Promise<void> {
@@ -321,7 +319,7 @@ export class Controller {

    @bind async onZigbeeAdapterDisconnected(): Promise<void> {
        logger.error("Adapter disconnected, stopping");
-        await this.stop();
+        await this.stop(false, 2);
    }

    @bind async publishEntityState(entity: Group | Device, payload: KeyValue, stateChangeReason?: StateChangeReason): Promise<void> {
@@ -34,9 +34,25 @@ type EventBusListener<K> = K extends keyof EventBusMap
        : never
    : never;

+type Stats = {
+    devices: Map<
+        string, // IEEE address
+        {
+            lastSeenChanges?: {messages: number; first: number};
+            leaveCounts: number;
+            networkAddressChanges: number;
+        }
+    >;
+    mqtt: {
+        published: number;
+        received: number;
+    };
+};
+
 export default class EventBus {
    private callbacksByExtension = new Map<string, {event: keyof EventBusMap; callback: EventBusListener<keyof EventBusMap>}[]>();
    private emitter = new events.EventEmitter<EventBusMap>();
+    readonly stats: Stats = {devices: new Map(), mqtt: {published: 0, received: 0}};

    constructor() {
        this.emitter.setMaxListeners(100);
@@ -72,6 +88,18 @@ export default class EventBus {

    public emitLastSeenChanged(data: eventdata.LastSeenChanged): void {
        this.emitter.emit("lastSeenChanged", data);
+
+        const device = this.stats.devices.get(data.device.ieeeAddr);
+
+        if (device?.lastSeenChanges) {
+            device.lastSeenChanges.messages += 1;
+        } else {
+            this.stats.devices.set(data.device.ieeeAddr, {
+                lastSeenChanges: {messages: 1, first: Date.now()},
+                leaveCounts: 0,
+                networkAddressChanges: 0,
+            });
+        }
    }
    public onLastSeenChanged(key: ListenerKey, callback: (data: eventdata.LastSeenChanged) => void): void {
        this.on("lastSeenChanged", callback, key);
@@ -79,6 +107,14 @@ export default class EventBus {

    public emitDeviceNetworkAddressChanged(data: eventdata.DeviceNetworkAddressChanged): void {
        this.emitter.emit("deviceNetworkAddressChanged", data);
+
+        const device = this.stats.devices.get(data.device.ieeeAddr);
+
+        if (device) {
+            device.networkAddressChanges += 1;
+        } else {
+            this.stats.devices.set(data.device.ieeeAddr, {leaveCounts: 0, networkAddressChanges: 1});
+        }
    }
    public onDeviceNetworkAddressChanged(key: ListenerKey, callback: (data: eventdata.DeviceNetworkAddressChanged) => void): void {
        this.on("deviceNetworkAddressChanged", callback, key);
@@ -121,6 +157,14 @@ export default class EventBus {

    public emitDeviceLeave(data: eventdata.DeviceLeave): void {
        this.emitter.emit("deviceLeave", data);
+
+        const device = this.stats.devices.get(data.ieeeAddr);
+
+        if (device) {
+            device.leaveCounts += 1;
+        } else {
+            this.stats.devices.set(data.ieeeAddr, {leaveCounts: 1, networkAddressChanges: 0});
+        }
    }
    public onDeviceLeave(key: ListenerKey, callback: (data: eventdata.DeviceLeave) => void): void {
        this.on("deviceLeave", callback, key);
@@ -135,6 +179,8 @@ export default class EventBus {

    public emitMQTTMessage(data: eventdata.MQTTMessage): void {
        this.emitter.emit("mqttMessage", data);
+
+        this.stats.mqtt.received += 1;
    }
    public onMQTTMessage(key: ListenerKey, callback: (data: eventdata.MQTTMessage) => void): void {
        this.on("mqttMessage", callback, key);
@@ -142,6 +188,8 @@ export default class EventBus {

    public emitMQTTMessagePublished(data: eventdata.MQTTMessagePublished): void {
        this.emitter.emit("mqttMessagePublished", data);
+
+        this.stats.mqtt.published += 1;
    }
    public onMQTTMessagePublished(key: ListenerKey, callback: (data: eventdata.MQTTMessagePublished) => void): void {
        this.on("mqttMessagePublished", callback, key);
@@ -1,11 +1,8 @@
-import type * as zhc from "zigbee-herdsman-converters";
-
-import type {Zigbee2MQTTAPI} from "../types/api";
-
 import assert from "node:assert";
-
 import bind from "bind-decorator";
 import debounce from "debounce";
+import type * as zhc from "zigbee-herdsman-converters";
+import type {Zigbee2MQTTAPI} from "../types/api";

 import logger from "../util/logger";
 import * as settings from "../util/settings";
@@ -76,7 +73,7 @@ export default class Availability extends Extension {
        if (entity.isDevice()) {
            const lastSeen = entity.zh.lastSeen ?? /* v8 ignore next */ 0;

-            return Date.now() - lastSeen < this.getTimeout(entity) + this.getMaxJitter(entity);
+            return Date.now() - lastSeen < this.getTimeout(entity);
        }

        for (const memberDevice of entity.membersDevices()) {
@@ -1,23 +1,17 @@
-import type {ClusterName} from "zigbee-herdsman/dist/zspec/zcl/definition/tstype";
-
-import type {Zigbee2MQTTAPI, Zigbee2MQTTResponseEndpoints} from "../types/api";
-
 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 {ClusterName} from "zigbee-herdsman/dist/zspec/zcl/definition/tstype";
 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 utils from "../util/utils";
+import utils, {DEFAULT_BIND_GROUP_ID} from "../util/utils";
 import Extension from "./extension";

-const TOPIC_REGEX = new RegExp(`^${settings.get().mqtt.base_topic}/bridge/request/device/(bind|unbind)`);
 const ALL_CLUSTER_CANDIDATES: readonly ClusterName[] = [
    "genScenes",
    "genOnOff",
@@ -33,7 +27,7 @@ const ALL_CLUSTER_CANDIDATES: readonly ClusterName[] = [
 ];

 // See zigbee-herdsman-converters
-const DEFAULT_BIND_GROUP = {type: "group_number", ID: 901, name: "default_bind_group"};
+const DEFAULT_BIND_GROUP = {type: "group_number", ID: DEFAULT_BIND_GROUP_ID, name: "default_bind_group"};
 const DEFAULT_REPORT_CONFIG = {minimumReportInterval: 5, maximumReportInterval: 3600, reportableChange: 1};

 const getColorCapabilities = async (endpoint: zh.Endpoint): Promise<{colorTemperature: boolean; colorXY: boolean}> => {
@@ -209,6 +203,7 @@ interface ParsedMQTTMessage {
 }

 export default class Bind extends Extension {
+    #topicRegex = new RegExp(`^${settings.get().mqtt.base_topic}/bridge/request/device/(bind|unbind)`);
    private pollDebouncers: {[s: string]: () => void} = {};

    // biome-ignore lint/suspicious/useAwait: API
@@ -221,7 +216,7 @@ export default class Bind extends Extension {
    private parseMQTTMessage(
        data: eventdata.MQTTMessage,
    ): [raw: KeyValue | undefined, parsed: ParsedMQTTMessage | undefined, error: string | undefined] {
-        if (data.topic.match(TOPIC_REGEX)) {
+        if (data.topic.match(this.#topicRegex)) {
            const type = data.topic.endsWith("unbind") ? "unbind" : "bind";
            let skipDisableReporting = false;
            const message = JSON.parse(data.message) as Zigbee2MQTTAPI["bridge/request/device/bind"];
@@ -1,30 +1,26 @@
-import type winston from "winston";
-
-import type Group from "../model/group";
-import type {Zigbee2MQTTAPI, Zigbee2MQTTDevice, Zigbee2MQTTResponse, Zigbee2MQTTResponseEndpoints} from "../types/api";
-
 import fs from "node:fs";
-
 import bind from "bind-decorator";
 import stringify from "json-stable-stringify-without-jsonify";
 import JSZip from "jszip";
 import objectAssignDeep from "object-assign-deep";
+import type winston from "winston";
 import Transport from "winston-transport";
-
 import {Zcl} from "zigbee-herdsman";
-import * as zhc from "zigbee-herdsman-converters";
 import {InterviewState} from "zigbee-herdsman/dist/controller/model/device";
-
+import * as zhc from "zigbee-herdsman-converters";
 import Device from "../model/device";
+import type Group from "../model/group";
+import type {Zigbee2MQTTAPI, Zigbee2MQTTDevice, Zigbee2MQTTResponse, Zigbee2MQTTResponseEndpoints} from "../types/api";
 import data from "../util/data";
 import logger from "../util/logger";
 import * as settings from "../util/settings";
-import utils, {assertString} from "../util/utils";
+import utils, {assertString, DEFAULT_BIND_GROUP_ID} from "../util/utils";
 import Extension from "./extension";

-const REQUEST_REGEX = new RegExp(`${settings.get().mqtt.base_topic}/bridge/request/(.*)`);
-
 export default class Bridge extends Extension {
+    #requestRegex = new RegExp(`${settings.get().mqtt.base_topic}/bridge/request/(.*)`);
+    // set on `start`
+    #osInfo!: Zigbee2MQTTAPI["bridge/info"]["os"];
    private zigbee2mqttVersion!: {commitHash?: string; version: string};
    private zigbeeHerdsmanVersion!: {version: string};
    private zigbeeHerdsmanConvertersVersion!: {version: string};
@@ -92,6 +88,15 @@ export default class Bridge extends Extension {

        logger.addTransport(this.logTransport);

+        const os = await import("node:os");
+        const process = await import("node:process");
+        const logicalCpuCores = os.cpus();
+        this.#osInfo = {
+            version: `${os.version()} - ${os.release()} - ${os.arch()}`,
+            node_version: process.version,
+            cpus: `${[...new Set(logicalCpuCores.map((cpu) => cpu.model))].join(" | ")} (x${logicalCpuCores.length})`,
+            memory_mb: Math.round(os.totalmem() / 1024 / 1024),
+        };
        this.zigbee2mqttVersion = await utils.getZigbee2MQTTVersion();
        this.zigbeeHerdsmanVersion = await utils.getDependencyVersion("zigbee-herdsman");
        this.zigbeeHerdsmanConvertersVersion = await utils.getDependencyVersion("zigbee-herdsman-converters");
@@ -191,7 +196,7 @@ export default class Bridge extends Extension {
    }

    @bind async onMQTTMessage(data: eventdata.MQTTMessage): Promise<void> {
-        const match = data.topic.match(REQUEST_REGEX);
+        const match = data.topic.match(this.#requestRegex);

        if (!match) {
            return;
@@ -691,6 +696,8 @@ export default class Bridge extends Extension {

        const networkParams = await this.zigbee.getNetworkParameters();
        const payload: Zigbee2MQTTAPI["bridge/info"] = {
+            os: this.#osInfo,
+            mqtt: this.mqtt.info,
            version: this.zigbee2mqttVersion.version,
            commit: this.zigbee2mqttVersion.commitHash,
            zigbee_herdsman_converters: this.zigbeeHerdsmanConvertersVersion,
@@ -723,6 +730,7 @@ export default class Bridge extends Extension {

            for (const endpoint of device.zh.endpoints) {
                const data: (typeof endpoints)[keyof typeof endpoints] = {
+                    name: device.endpointName(endpoint),
                    scenes: utils.getScenes(endpoint),
                    bindings: [],
                    configured_reportings: [],
@@ -789,7 +797,7 @@ export default class Bridge extends Extension {

            groups.push({
                id: group.ID,
-                friendly_name: group.ID === 901 ? "default_bind_group" : group.name,
+                friendly_name: group.ID === DEFAULT_BIND_GROUP_ID ? "default_bind_group" : group.name,
                description: group.options.description,
                scenes: utils.getScenes(group.zh),
                members,
@@ -824,11 +832,12 @@ export default class Bridge extends Extension {

        if (icon) {
            /* v8 ignore next */
-            icon = icon.replace("${zigbeeModel}", utils.sanitizeImageParameter(device.zh.modelID ?? ""));
-            icon = icon.replace("${model}", utils.sanitizeImageParameter(device.definition.model));
+            icon = icon.replace("$zigbeeModel", utils.sanitizeImageParameter(device.zh.modelID ?? ""));
+            icon = icon.replace("$model", utils.sanitizeImageParameter(device.definition.model));
        }

        const payload: Zigbee2MQTTDevice["definition"] = {
+            source: device.definition.externalConverterName ? "external" : device.definition.generated ? "generated" : "native",
            model: device.definition.model,
            vendor: device.definition.vendor,
            description: device.definition.description,
@@ -1,11 +1,8 @@
-import type {Zigbee2MQTTAPI} from "../types/api";
-
 import bind from "bind-decorator";
 import stringify from "json-stable-stringify-without-jsonify";
-
 import * as zhc from "zigbee-herdsman-converters";
-
 import Device from "../model/device";
+import type {Zigbee2MQTTAPI} from "../types/api";
 import logger from "../util/logger";
 import * as settings from "../util/settings";
 import utils from "../util/utils";
@@ -59,7 +56,7 @@ export default class Configure extends Extension {
        }
    }

-    override async start(): Promise<void> {
+    override start(): Promise<void> {
        setImmediate(async () => {
            // Only configure routers on startup, end devices are likely sleeping and
            // will reconfigure once they send a message
@@ -82,6 +79,8 @@ export default class Configure extends Extension {
        this.eventBus.onLastSeenChanged(this, (data) => this.configure(data.device, "zigbee_event"));
        this.eventBus.onMQTTMessage(this, this.onMQTTMessage);
        this.eventBus.onReconfigure(this, this.onReconfigure);
+
+        return Promise.resolve();
    }

    private async configure(
@@ -1,7 +1,6 @@
-import type Extension from "./extension";
-
 import logger from "../util/logger";
 import * as settings from "../util/settings";
+import type Extension from "./extension";
 import ExternalJSExtension from "./externalJS";

 type TModule = new (...args: ConstructorParameters<typeof Extension>) => Extension;
@@ -1,11 +1,9 @@
-import type {Zigbee2MQTTAPI, Zigbee2MQTTResponse} from "../types/api";
-
 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";
@@ -195,7 +193,7 @@ export default abstract class ExternalJSExtension<M> extends Extension {
                fs.renameSync(filePath, `${filePath}.invalid`);

                logger.error(
-                    `Invalid external ${this.mqttTopic} '${extension.name}' was ignored and renamed to prevent interference with Zigbee2MQTT.`,
+                    `Invalid external ${this.mqttTopic} '${extension.name}' was ignored and renamed to prevent interference with Zigbee2MQTT. (${(error as Error).message})`,
                );
                // biome-ignore lint/style/noNonNullAssertion: always Error
                logger.debug((error as Error).stack!);
@@ -1,15 +1,11 @@
-import type {IncomingMessage, Server, ServerResponse} from "node:http";
-import type {Socket} from "node:net";
-
-import type {RequestHandler} from "express-static-gzip";
-
 import assert from "node:assert";
 import {existsSync, readFileSync} from "node:fs";
+import type {IncomingMessage, Server, ServerResponse} from "node:http";
 import {createServer} from "node:http";
 import {createServer as createSecureServer} from "node:https";
+import type {Socket} from "node:net";
 import {posix} from "node:path";
 import {parse} from "node:url";
-
 import bind from "bind-decorator";
 import expressStaticGzip from "express-static-gzip";
 import finalhandler from "finalhandler";
@@ -27,9 +23,7 @@ import Extension from "./extension";
 */
 export class Frontend extends Extension {
    private mqttBaseTopic: string;
-    private server!: Server;
-    private fileServer!: RequestHandler;
-    private deviceIconsFileServer!: RequestHandler;
+    private server: Server | undefined;
    private wss!: WebSocket.Server;
    private baseUrl: string;

@@ -52,60 +46,97 @@ export class Frontend extends Extension {
    }

    override async start(): Promise<void> {
-        const hasSSL = (val: string | undefined, key: string): val is string => {
-            if (val) {
-                if (!existsSync(val)) {
-                    logger.error(`Defined ${key} '${val}' file path does not exists, server won't be secured.`);
-                    return false;
-                }
-                return true;
-            }
-            return false;
-        };
-        const {host, port, ssl_key: sslKey, ssl_cert: sslCert} = settings.get().frontend;
-        const options = {
-            enableBrotli: true,
-            // TODO: https://github.com/Koenkk/zigbee2mqtt/issues/24654 - enable compressed index serving when express-static-gzip is fixed.
-            index: false,
-            serveStatic: {
-                index: "index.html",
-                /* v8 ignore start */
-                setHeaders: (res: ServerResponse, path: string): void => {
-                    if (path.endsWith("index.html")) {
-                        res.setHeader("Cache-Control", "no-store");
+        if (settings.get().frontend.disable_ui_serving) {
+            const {host, port} = settings.get().frontend;
+            this.wss = new WebSocket.Server({port, host, path: posix.join(this.baseUrl, "api")});
+
+            logger.info(
+                /* v8 ignore next */
+                `Frontend UI serving is disabled. WebSocket at: ${this.wss.options.host ?? "0.0.0.0"}:${this.wss.options.port}${this.wss.options.path}`,
+            );
+        } else {
+            const {host, port, ssl_key: sslKey, ssl_cert: sslCert} = settings.get().frontend;
+            const hasSSL = (val: string | undefined, key: string): val is string => {
+                if (val) {
+                    if (existsSync(val)) {
+                        return true;
                    }
+
+                    logger.error(`Defined ${key} '${val}' file path does not exists, server won't be secured.`);
+                }
+
+                return false;
+            };
+            const options: expressStaticGzip.ExpressStaticGzipOptions = {
+                enableBrotli: true,
+                serveStatic: {
+                    /* v8 ignore start */
+                    setHeaders: (res: ServerResponse, path: string): void => {
+                        if (path.endsWith("index.html")) {
+                            res.setHeader("Cache-Control", "no-store");
+                        }
+                    },
+                    /* v8 ignore stop */
                },
-                /* v8 ignore stop */
-            },
-        };
-        const frontend = (await import(settings.get().frontend.package)) as typeof import("zigbee2mqtt-frontend");
-        this.fileServer = expressStaticGzip(frontend.default.getPath(), options);
-        this.deviceIconsFileServer = expressStaticGzip(data.joinPath("device_icons"), options);
-        this.wss = new WebSocket.Server({noServer: true, path: posix.join(this.baseUrl, "api")});
+            };
+            const frontend = (await import(settings.get().frontend.package)) as typeof import("zigbee2mqtt-frontend");
+            const fileServer = expressStaticGzip(frontend.default.getPath(), options);
+            const deviceIconsFileServer = expressStaticGzip(data.joinPath("device_icons"), options);
+            const onRequest = (request: IncomingMessage, response: ServerResponse): void => {
+                const next = finalhandler(request, response);
+                // biome-ignore lint/style/noNonNullAssertion: `Only valid for request obtained from Server`
+                const newUrl = posix.relative(this.baseUrl, request.url!);
+
+                // The request url is not within the frontend base url, so the relative path starts with '..'
+                if (newUrl.startsWith(".")) {
+                    next();
+
+                    return;
+                }
+
+                // Attach originalUrl so that static-server can perform a redirect to '/' when serving the root directory.
+                // This is necessary for the browser to resolve relative assets paths correctly.
+                request.originalUrl = request.url;
+                request.url = `/${newUrl}`;
+                request.path = request.url;
+
+                if (newUrl.startsWith("device_icons/")) {
+                    request.path = request.path.replace("device_icons/", "");
+                    request.url = request.url.replace("/device_icons", "");
+
+                    deviceIconsFileServer(request, response, next);
+                } else {
+                    fileServer(request, response, next);
+                }
+            };
+
+            if (hasSSL(sslKey, "ssl_key") && hasSSL(sslCert, "ssl_cert")) {
+                const serverOptions = {key: readFileSync(sslKey), cert: readFileSync(sslCert)};
+                this.server = createSecureServer(serverOptions, onRequest);
+            } else {
+                this.server = createServer(onRequest);
+            }
+
+            this.server.on("upgrade", this.onUpgrade);
+
+            if (!host) {
+                this.server.listen(port);
+                logger.info(`Started frontend on port ${port}`);
+            } else if (host.startsWith("/")) {
+                this.server.listen(host);
+                logger.info(`Started frontend on socket ${host}`);
+            } else {
+                this.server.listen(port, host);
+                logger.info(`Started frontend on port ${host}:${port}`);
+            }
+
+            this.wss = new WebSocket.Server({noServer: true, path: posix.join(this.baseUrl, "api")});
+        }

        this.wss.on("connection", this.onWebSocketConnection);

-        if (hasSSL(sslKey, "ssl_key") && hasSSL(sslCert, "ssl_cert")) {
-            const serverOptions = {key: readFileSync(sslKey), cert: readFileSync(sslCert)};
-            this.server = createSecureServer(serverOptions, this.onRequest);
-        } else {
-            this.server = createServer(this.onRequest);
-        }
-
-        this.server.on("upgrade", this.onUpgrade);
        this.eventBus.onMQTTMessagePublished(this, this.onMQTTPublishMessageOrEntityState);
        this.eventBus.onPublishEntityState(this, this.onMQTTPublishMessageOrEntityState);
-
-        if (!host) {
-            this.server.listen(port);
-            logger.info(`Started frontend on port ${port}`);
-        } else if (host.startsWith("/")) {
-            this.server.listen(host);
-            logger.info(`Started frontend on socket ${host}`);
-        } else {
-            this.server.listen(port, host);
-            logger.info(`Started frontend on port ${host}:${port}`);
-        }
    }

    override async stop(): Promise<void> {
@@ -120,34 +151,7 @@ export class Frontend extends Extension {
            this.wss.close();
        }

-        await new Promise((resolve) => this.server?.close(resolve));
-    }
-
-    @bind private onRequest(request: IncomingMessage, response: ServerResponse): void {
-        const fin = finalhandler(request, response);
-        // biome-ignore lint/style/noNonNullAssertion: `Only valid for request obtained from Server`
-        const newUrl = posix.relative(this.baseUrl, request.url!);
-
-        // The request url is not within the frontend base url, so the relative path starts with '..'
-        if (newUrl.startsWith(".")) {
-            fin();
-
-            return;
-        }
-
-        // Attach originalUrl so that static-server can perform a redirect to '/' when serving the root directory.
-        // This is necessary for the browser to resolve relative assets paths correctly.
-        request.originalUrl = request.url;
-        request.url = `/${newUrl}`;
-        request.path = request.url;
-
-        if (newUrl.startsWith("device_icons/")) {
-            request.path = request.path.replace("device_icons/", "");
-            request.url = request.url.replace("/device_icons", "");
-            this.deviceIconsFileServer(request, response, fin);
-        } else {
-            this.fileServer(request, response, fin);
-        }
+        await new Promise((resolve) => (this.server ? this.server.close(resolve) : resolve(undefined)));
    }

    @bind private onUpgrade(request: IncomingMessage, socket: Socket, head: Buffer): void {
@@ -1,22 +1,16 @@
-import type * as zhc from "zigbee-herdsman-converters";
-
-import type {Zigbee2MQTTAPI, Zigbee2MQTTResponseEndpoints} from "../types/api";
-
 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 utils, {isLightExpose} from "../util/utils";
 import Extension from "./extension";

-const TOPIC_REGEX = new RegExp(`^${settings.get().mqtt.base_topic}/bridge/request/group/members/(remove|add|remove_all)$`);
-
 const STATE_PROPERTIES: Readonly<Record<string, (value: string, exposes: zhc.Expose[]) => boolean>> = {
    state: () => true,
    brightness: (_value, exposes) => exposes.some((e) => isLightExpose(e) && e.features.some((f) => f.name === "brightness")),
@@ -42,6 +36,7 @@ interface ParsedMQTTMessage {
 }

 export default class Groups extends Extension {
+    #topicRegex = new RegExp(`^${settings.get().mqtt.base_topic}/bridge/request/group/members/(remove|add|remove_all)$`);
    private lastOptimisticState: {[s: string]: KeyValue} = {};

    // biome-ignore lint/suspicious/useAwait: API
@@ -189,7 +184,7 @@ export default class Groups extends Extension {
    private parseMQTTMessage(
        data: eventdata.MQTTMessage,
    ): [raw: KeyValue | undefined, parsed: ParsedMQTTMessage | undefined, error: string | undefined] {
-        const topicRegexMatch = data.topic.match(TOPIC_REGEX);
+        const topicRegexMatch = data.topic.match(this.#topicRegex);

        if (topicRegexMatch) {
            const type = topicRegexMatch[1] as "remove" | "add" | "remove_all";
@@ -277,7 +272,7 @@ export default class Groups extends Extension {
        try {
            if (type === "add") {
                assert(resolvedGroup, "`resolvedGroup` is missing");
-                logger.info(`Adding '${resolvedDevice.name}' to '${resolvedGroup.name}'`);
+                logger.info(`Adding endpoint '${resolvedEndpoint.ID}' of device '${resolvedDevice.name}' to group '${resolvedGroup.name}'`);
                await resolvedEndpoint.addToGroup(resolvedGroup.zh);
                changedGroups.push(resolvedGroup);
                // biome-ignore lint/style/noNonNullAssertion: valid from resolved asserts
@@ -285,7 +280,7 @@ export default class Groups extends Extension {
                await this.publishResponse<"bridge/response/group/members/add">(parsed.type, raw, respPayload);
            } else if (type === "remove") {
                assert(resolvedGroup, "`resolvedGroup` is missing");
-                logger.info(`Removing '${resolvedDevice.name}' from '${resolvedGroup.name}'`);
+                logger.info(`Removing endpoint '${resolvedEndpoint.ID}' of device '${resolvedDevice.name}' from group '${resolvedGroup.name}'`);
                await resolvedEndpoint.removeFromGroup(resolvedGroup.zh);
                changedGroups.push(resolvedGroup);
                // biome-ignore lint/style/noNonNullAssertion: valid from resolved asserts
@@ -293,7 +288,7 @@ export default class Groups extends Extension {
                await this.publishResponse<"bridge/response/group/members/remove">(parsed.type, raw, respPayload);
            } else {
                // remove_all
-                logger.info(`Removing '${resolvedDevice.name}' from all groups`);
+                logger.info(`Removing endpoint '${resolvedEndpoint.ID}' of device '${resolvedDevice.name}' from all groups`);

                for (const group of this.zigbee.groupsIterator((g) => g.members.includes(resolvedEndpoint))) {
                    changedGroups.push(group);
@@ -305,7 +300,7 @@ export default class Groups extends Extension {
                await this.publishResponse<"bridge/response/group/members/remove_all">(parsed.type, raw, respPayload);
            }
        } catch (e) {
-            const errorMsg = `Failed to ${type} from group (${(e as Error).message})`;
+            const errorMsg = `Failed to ${type} ${type === "add" ? "to" : "from"} group (${(e as Error).message})`;
            await this.publishResponse(parsed.type, raw, {}, errorMsg);
            // biome-ignore lint/style/noNonNullAssertion: always Error
            logger.debug((e as Error).stack!);
@@ -0,0 +1,78 @@
+import * as os from "node:os";
+import * as process from "node:process";
+import type {Zigbee2MQTTAPI} from "../types/api";
+import * as settings from "../util/settings";
+import utils from "../util/utils";
+import Extension from "./extension";
+
+/** Round with 2 decimals */
+const round2 = (n: number): number => Math.round(n * 100.0) / 100.0;
+/** Round with 4 decimals */
+const round4 = (n: number): number => Math.round(n * 10000.0) / 10000.0;
+
+export default class Health extends Extension {
+    #checkTimer: NodeJS.Timeout | undefined;
+
+    override async start(): Promise<void> {
+        await super.start();
+
+        this.#checkTimer = setInterval(this.#checkHealth.bind(this), utils.minutes(settings.get().health.interval));
+    }
+
+    override async stop(): Promise<void> {
+        clearInterval(this.#checkTimer);
+        await super.stop();
+    }
+
+    clearStats(): void {
+        this.eventBus.stats.devices.clear();
+        this.eventBus.stats.mqtt.published = 0;
+        this.eventBus.stats.mqtt.received = 0;
+    }
+
+    async #checkHealth(): Promise<void> {
+        const sysMemTotalKb = os.totalmem() / 1024;
+        const sysMemFreeKb = os.freemem() / 1024;
+        const sysMemUsedKb = sysMemTotalKb - sysMemFreeKb;
+        const procMemUsedKb = process.memoryUsage().rss / 1024;
+        const healthcheck: Zigbee2MQTTAPI["bridge/health"] = {
+            response_time: Date.now(),
+            os: {
+                load_average: os.loadavg(), // will be [0,0,0] on Windows (not supported)
+                memory_used_mb: round2(sysMemUsedKb / 1024),
+                memory_percent: round4((sysMemUsedKb / sysMemTotalKb) * 100.0),
+            },
+            process: {
+                uptime_sec: Math.floor(process.uptime()),
+                memory_used_mb: round2(procMemUsedKb / 1024),
+                memory_percent: round4((procMemUsedKb / sysMemTotalKb) * 100.0),
+            },
+            mqtt: {...this.mqtt.stats, ...this.eventBus.stats.mqtt},
+            devices: {},
+        };
+
+        for (const [ieeeAddr, device] of this.eventBus.stats.devices) {
+            let messages = 0;
+            let mps = 0;
+
+            if (device.lastSeenChanges) {
+                const timeDiff = Date.now() - device.lastSeenChanges.first;
+                messages = device.lastSeenChanges.messages;
+                mps = timeDiff > 0 ? round4(messages / (timeDiff / 1000.0)) : 0;
+            }
+
+            healthcheck.devices[ieeeAddr] = {
+                messages,
+                messages_per_sec: mps,
+                leave_count: device.leaveCounts,
+                network_address_changes: device.networkAddressChanges,
+            };
+        }
+
+        if (settings.get().health.reset_on_check) {
+            this.clearStats();
+        }
+
+        await this.mqtt.publish("bridge/health", JSON.stringify(healthcheck), {clientOptions: {retain: true, qos: 1}});
+    }
+}
@@ -1,9 +1,7 @@
-import type * as zhc from "zigbee-herdsman-converters";
-
 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 logger from "../util/logger";
 import * as settings from "../util/settings";
@@ -1,7 +1,6 @@
-import type {Zigbee2MQTTAPI, Zigbee2MQTTNetworkMap} from "../types/api";
-
 import bind from "bind-decorator";
 import stringify from "json-stable-stringify-without-jsonify";
+import type {Zigbee2MQTTAPI, Zigbee2MQTTNetworkMap} from "../types/api";

 import logger from "../util/logger";
 import * as settings from "../util/settings";
@@ -14,7 +13,7 @@ const SUPPORTED_FORMATS = ["raw", "graphviz", "plantuml"];
 * This extension creates a network map
 */
 export default class NetworkMap extends Extension {
-    private topic = `${settings.get().mqtt.base_topic}/bridge/request/networkmap`;
+    #topic = `${settings.get().mqtt.base_topic}/bridge/request/networkmap`;

    // biome-ignore lint/suspicious/useAwait: API
    override async start(): Promise<void> {
@@ -22,7 +21,7 @@ export default class NetworkMap extends Extension {
    }

    @bind async onMQTTMessage(data: eventdata.MQTTMessage): Promise<void> {
-        if (data.topic === this.topic) {
+        if (data.topic === this.#topic) {
            const message = utils.parseJSON(data.message, data.message) as Zigbee2MQTTAPI["bridge/request/networkmap"];

            try {
@@ -1,17 +1,12 @@
-import type {Ota} from "zigbee-herdsman-converters";
-
-import type {Zigbee2MQTTAPI} from "../types/api";
-
 import assert from "node:assert";
 import path from "node:path";
-
 import bind from "bind-decorator";
 import stringify from "json-stable-stringify-without-jsonify";
-
 import {Zcl} from "zigbee-herdsman";
+import type {Ota} from "zigbee-herdsman-converters";
 import {ota} from "zigbee-herdsman-converters";
-
 import Device from "../model/device";
+import type {Zigbee2MQTTAPI} from "../types/api";
 import dataDir from "../util/data";
 import logger from "../util/logger";
 import * as settings from "../util/settings";
@@ -30,12 +25,11 @@ export interface UpdatePayload {
    };
 }

-const topicRegex = new RegExp(
-    `^${settings.get().mqtt.base_topic}/bridge/request/device/ota_update/(update|check|schedule|unschedule)/?(downgrade)?`,
-    "i",
-);
-
 export default class OTAUpdate extends Extension {
+    #topicRegex = new RegExp(
+        `^${settings.get().mqtt.base_topic}/bridge/request/device/ota_update/(update|check|schedule|unschedule)/?(downgrade)?`,
+        "i",
+    );
    private inProgress = new Set<string>();
    private lastChecked = new Map<string, number>();
    private scheduledUpgrades = new Set<string>();
@@ -257,7 +251,7 @@ export default class OTAUpdate extends Extension {
    }

    @bind async onMQTTMessage(data: eventdata.MQTTMessage): Promise<void> {
-        const topicMatch = data.topic.match(topicRegex);
+        const topicMatch = data.topic.match(this.#topicRegex);

        if (!topicMatch) {
            return;
@@ -1,7 +1,6 @@
-import type * as zhc from "zigbee-herdsman-converters";
-
 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";
@@ -10,12 +9,12 @@ import * as settings from "../util/settings";
 import utils from "../util/utils";
 import Extension from "./extension";

+// TODO: get rid of this, use class member
 let topicGetSetRegex: RegExp;
-// Used by `publish.test.js` to reload regex when changing `mqtt.base_topic`.
+// Used by `publish.test.ts` to reload regex when changing `mqtt.base_topic`.
 export const loadTopicGetSetRegex = (): void => {
    topicGetSetRegex = new RegExp(`^${settings.get().mqtt.base_topic}/(?!bridge)(.+?)/(get|set)(?:/(.+))?$`);
 };
-loadTopicGetSetRegex();

 const STATE_VALUES: ReadonlyArray<string> = ["on", "off", "toggle", "open", "close", "stop", "lock", "unlock"];
 const SCENE_CONVERTER_KEYS: ReadonlyArray<string> = ["scene_store", "scene_add", "scene_remove", "scene_remove_all", "scene_rename"];
@@ -30,6 +29,7 @@ interface ParsedTopic {
 export default class Publish extends Extension {
    // biome-ignore lint/suspicious/useAwait: API
    override async start(): Promise<void> {
+        loadTopicGetSetRegex();
        this.eventBus.onMQTTMessage(this, this.onMQTTMessage);
    }

@@ -1,10 +1,8 @@
-import type {CustomClusters} from "zigbee-herdsman/dist/zspec/zcl/definition/tstype";
-
 import assert from "node:assert";
-
-import * as zhc from "zigbee-herdsman-converters";
-import {Numeric, access} from "zigbee-herdsman-converters";
 import {InterviewState} from "zigbee-herdsman/dist/controller/model/device";
+import type {CustomClusters} from "zigbee-herdsman/dist/zspec/zcl/definition/tstype";
+import * as zhc from "zigbee-herdsman-converters";
+import {access, Numeric} from "zigbee-herdsman-converters";

 import * as settings from "../util/settings";

@@ -78,43 +76,33 @@ export default class Device {
    }

    endpoint(key?: string | number): zh.Endpoint | undefined {
-        let endpoint: zh.Endpoint | undefined;
-
        if (!key) {
            key = "default";
+        } else if (!Number.isNaN(Number(key))) {
+            return this.zh.getEndpoint(Number(key));
        }

-        if (!Number.isNaN(Number(key))) {
-            endpoint = this.zh.getEndpoint(Number(key));
-        } else if (this.definition?.endpoint) {
-            const ID = this.definition?.endpoint?.(this.zh)[key];
+        if (this.definition?.endpoint) {
+            const ID = this.definition.endpoint(this.zh)[key];

            if (ID) {
-                endpoint = this.zh.getEndpoint(ID);
-            } else if (key === "default") {
-                endpoint = this.zh.endpoints[0];
-            } else {
-                return undefined;
+                return this.zh.getEndpoint(ID);
            }
-        } else {
-            if (key !== "default") {
-                return undefined;
-            }
-
-            endpoint = this.zh.endpoints[0];
        }

-        return endpoint;
+        return key === "default" ? this.zh.endpoints[0] : undefined;
    }

    endpointName(endpoint: zh.Endpoint): string | undefined {
-        let epName = undefined;
+        let epName: string | undefined;

        if (this.definition?.endpoint) {
-            const mapping = this.definition?.endpoint(this.zh);
-            for (const [name, id] of Object.entries(mapping)) {
-                if (id === endpoint.ID) {
+            const mapping = this.definition.endpoint(this.zh);
+
+            for (const name in mapping) {
+                if (mapping[name] === endpoint.ID) {
                    epName = name;
+                    break;
                }
            }
        }
@@ -126,9 +114,11 @@ export default class Device {
    getEndpointNames(): string[] {
        const names: string[] = [];

-        for (const name in this.definition?.endpoint?.(this.zh) ?? {}) {
-            if (name !== "default") {
-                names.push(name);
+        if (this.definition?.endpoint) {
+            for (const name in this.definition.endpoint(this.zh)) {
+                if (name !== "default") {
+                    names.push(name);
+                }
            }
        }

@@ -1,6 +1,6 @@
 import type * as zhc from "zigbee-herdsman-converters";
-
 import * as settings from "../util/settings";
+import {DEFAULT_BIND_GROUP_ID} from "../util/utils";

 export default class Group {
    public zh: zh.Group;
@@ -23,6 +23,12 @@ export default class Group {
        this.resolveDevice = resolveDevice;
    }

+    ensureInSettings(): void {
+        if (this.ID !== DEFAULT_BIND_GROUP_ID && !settings.getGroup(this.ID)) {
+            settings.addGroup(this.name, this.ID.toString());
+        }
+    }
+
    hasMember(device: Device): boolean {
        return !!device.zh.endpoints.find((e) => this.zh.members.includes(e));
    }
@@ -1,11 +1,8 @@
-import type {IClientOptions, IClientPublishOptions, MqttClient} from "mqtt";
-
-import type {Zigbee2MQTTAPI} from "./types/api";
-
 import fs from "node:fs";
-
 import bind from "bind-decorator";
+import type {IClientOptions, IClientPublishOptions, MqttClient} from "mqtt";
 import {connectAsync} from "mqtt";
+import type {Zigbee2MQTTAPI} from "./types/api";

 import logger from "./util/logger";
 import * as settings from "./util/settings";
@@ -30,6 +27,20 @@ export default class Mqtt {
    private defaultPublishOptions: MqttPublishOptions;
    public retainedMessages: {[s: string]: {topic: string; payload: string; options: MqttPublishOptions}} = {};

+    get info() {
+        return {
+            version: this.client.options.protocolVersion,
+            server: `${this.client.options.protocol}://${this.client.options.host}:${this.client.options.port}`,
+        };
+    }
+
+    get stats() {
+        return {
+            connected: this.isConnected(),
+            queued: this.client.queue.length,
+        };
+    }
+
    constructor(eventBus: EventBus) {
        this.eventBus = eventBus;
        this.defaultPublishOptions = {
@@ -160,7 +171,7 @@ export default class Mqtt {

        const stateData: Zigbee2MQTTAPI["bridge/state"] = {state: "online"};

-        await this.publish("bridge/state", JSON.stringify(stateData), {clientOptions: {retain: true}});
+        await this.publish("bridge/state", JSON.stringify(stateData), {clientOptions: {retain: true, qos: 1}});
        await this.subscribe(`${settings.get().mqtt.base_topic}/#`);
    }

@@ -211,19 +222,18 @@ export default class Mqtt {
                logger.error("Not connected to MQTT server!");
                logger.error(`Cannot send message: topic: '${topic}', payload: '${payload}`);
            }
-
            return;
        }

-        if (!finalOptions.skipLog) {
-            logger.info(() => `MQTT publish: topic '${topic}', payload '${payload}'`, NS);
-        }
-
        let clientOptions: IClientPublishOptions = finalOptions.clientOptions;
        if (settings.get().mqtt.force_disable_retain) {
            clientOptions = {...finalOptions.clientOptions, retain: false};
        }

+        if (!finalOptions.skipLog) {
+            logger.info(() => `MQTT publish: topic '${topic}', payload '${payload}'`, NS);
+        }
+
        try {
            await this.client.publishAsync(topic, payload, clientOptions);
        } catch (error) {
@@ -1,7 +1,7 @@
-import type * as zigbeeHerdsmanConverter from "zigbee-herdsman-converters";
-import type {Base} from "zigbee-herdsman-converters/lib/exposes";
 import type * as zigbeeHerdsman from "zigbee-herdsman/dist";
 import type {ClusterDefinition, ClusterName, CustomClusters} from "zigbee-herdsman/dist/zspec/zcl/definition/tstype";
+import type * as zigbeeHerdsmanConverter from "zigbee-herdsman-converters";
+import type {Base} from "zigbee-herdsman-converters/lib/exposes";

 export type * as ZSpec from "zigbee-herdsman/dist/zspec";
 export type * as Zcl from "zigbee-herdsman/dist/zspec/zcl";
@@ -151,6 +151,7 @@ export interface Zigbee2MQTTSettings {
        ssl_cert?: string;
        ssl_key?: string;
        notification_filter?: string[];
+        disable_ui_serving?: boolean;
    };
    devices: {[s: string]: Zigbee2MQTTDeviceOptions};
    groups: {[s: string]: Omit<Zigbee2MQTTGroupOptions, "ID">};
@@ -183,6 +184,11 @@ export interface Zigbee2MQTTSettings {
        output: "json" | "attribute" | "attribute_and_json";
        transmit_power?: number;
    };
+    health: {
+        /** in minutes */
+        interval: number;
+        reset_on_check: boolean;
+    };
 }

 export interface Zigbee2MQTTScene {
@@ -191,6 +197,7 @@ export interface Zigbee2MQTTScene {
 }

 export interface Zigbee2MQTTDeviceEndpoint {
+    name?: string;
    bindings: Zigbee2MQTTDeviceEndpointBinding[];
    configured_reportings: Zigbee2MQTTDeviceEndpointConfiguredReporting[];
    clusters: {input: string[]; output: string[]};
@@ -213,6 +220,7 @@ export interface Zigbee2MQTTDeviceEndpointConfiguredReporting {
 }

 export interface Zigbee2MQTTDeviceDefinition {
+    source: "native" | "generated" | "external";
    model: string;
    vendor: string;
    description: string;
@@ -229,8 +237,8 @@ export interface Zigbee2MQTTDevice {
    supported: boolean;
    friendly_name: string;
    disabled: boolean;
-    description: string | undefined;
-    definition: Zigbee2MQTTDeviceDefinition | undefined;
+    description?: string;
+    definition?: Zigbee2MQTTDeviceDefinition;
    power_source: zigbeeHerdsman.Models.Device["powerSource"];
    software_build_id: zigbeeHerdsman.Models.Device["softwareBuildID"];
    date_code: zigbeeHerdsman.Models.Device["dateCode"];
@@ -250,7 +258,7 @@ export interface Zigbee2MQTTGroupMember {
 export interface Zigbee2MQTTGroup {
    id: number;
    friendly_name: "default_bind_group" | string;
-    description: string | undefined;
+    description?: string;
    scenes: Zigbee2MQTTScene[];
    members: Zigbee2MQTTGroupMember[];
 }
@@ -261,10 +269,10 @@ export interface Zigbee2MQTTNetworkMap {
        friendlyName: string;
        type: string;
        networkAddress: number;
-        manufacturerName: string | undefined;
-        modelID: string | undefined;
+        manufacturerName?: string;
+        modelID?: string;
        failed?: string[];
-        lastSeen: number | undefined;
+        lastSeen?: number;
        definition?: {model: string; vendor: string; supports: string; description: string};
    }[];
    links: {
@@ -330,6 +338,16 @@ export interface Zigbee2MQTTAPI {
          };

    "bridge/info": {
+        os: {
+            version: string;
+            node_version: string;
+            cpus: string;
+            memory_mb: number;
+        };
+        mqtt: {
+            version: number | undefined;
+            server: string;
+        };
        version: string;
        commit: string | undefined;
        zigbee_herdsman_converters: {version: string};
@@ -355,6 +373,36 @@ export interface Zigbee2MQTTAPI {
        config_schema: typeof schemaJson;
    };

+    "bridge/health": {
+        /** time of message, msec from epoch, UTC */
+        response_time: number;
+        os: {
+            load_average: number[];
+            memory_used_mb: number;
+            memory_percent: number;
+        };
+        process: {
+            uptime_sec: number;
+            memory_used_mb: number;
+            memory_percent: number;
+        };
+        mqtt: {
+            connected: boolean;
+            queued: number;
+            received: number;
+            published: number;
+        };
+        devices: Record<
+            string /* ieee */,
+            {
+                messages: number;
+                messages_per_sec: number;
+                leave_count: number;
+                network_address_changes: number;
+            }
+        >;
+    };
+
    "bridge/devices": Zigbee2MQTTDevice[];

    "bridge/groups": Zigbee2MQTTGroup[];
@@ -12,10 +12,3 @@ declare module "http" {
        path?: string;
    }
 }
-
-declare module "express-static-gzip" {
-    import type {IncomingMessage, ServerResponse} from "node:http";
-
-    export type RequestHandler = (req: IncomingMessage, res: ServerResponse, finalhandler: (err: unknown) => void) => void;
-    export default function expressStaticGzip(root: string, options?: Record<string, unknown>): RequestHandler;
-}
@@ -18,4 +18,5 @@ function _testReload(): void {
    dataPath = setPath();
 }

+// biome-ignore lint/style/useNamingConvention: test
 export default {joinPath, getPath, _testReload};
@@ -1,11 +1,10 @@
 import {existsSync, mkdirSync} from "node:fs";
 import {createServer} from "node:http";
 import {parse} from "node:querystring";
-
 import {findAllDevices} from "zigbee-herdsman/dist/adapter/adapterDiscovery";
-
 import data from "./data";
 import * as settings from "./settings";
+import {YAMLFileException} from "./yaml";

 type OnboardSettings = {
    mqtt_base_topic?: string;
@@ -498,7 +497,7 @@ async function startFailureServer(errors: string): Promise<void> {
    let server: ReturnType<typeof createServer> | undefined;

    await new Promise<void>((resolve) => {
-        server = createServer(async (req, res) => {
+        server = createServer((req, res) => {
            if (req.method === "POST") {
                res.end(() => {
                    resolve();
@@ -518,6 +517,27 @@ async function startFailureServer(errors: string): Promise<void> {
    await new Promise((resolve) => server?.close(resolve));
 }

+async function onSettingsErrors(errors: string[]): Promise<void> {
+    let pErrors = "";
+
+    console.error("\n\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+    console.error("            READ THIS CAREFULLY\n");
+    console.error("Refusing to start because configuration is not valid, found the following errors:");
+
+    for (const error of errors) {
+        console.error(`- ${error}`);
+
+        pErrors += `<p>- ${escapeHtml(error)}</p>`;
+    }
+
+    console.error("\nIf you don't know how to solve this, read https://www.zigbee2mqtt.io/guide/configuration");
+    console.error("\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n\n");
+
+    if (!process.env.Z2M_ONBOARD_NO_SERVER && !process.env.Z2M_ONBOARD_NO_FAILURE_PAGE) {
+        await startFailureServer(pErrors);
+    }
+}
+
 export async function onboard(): Promise<boolean> {
    if (!existsSync(data.getPath())) {
        mkdirSync(data.getPath(), {recursive: true});
@@ -525,15 +545,38 @@ export async function onboard(): Promise<boolean> {

    const confExists = existsSync(data.joinPath("configuration.yaml"));

-    if (!confExists) {
-        settings.writeMinimalDefaults();
-    } else {
+    if (confExists) {
+        // initial caching, ensure file is valid yaml first
+        try {
+            settings.getPersistedSettings();
+        } catch (error) {
+            await onSettingsErrors(
+                error instanceof YAMLFileException
+                    ? [`Your configuration file: '${error.file}' is invalid (use https://jsonformatter.org/yaml-validator to find and fix the issue)`]
+                    : [`${error}`],
+            );
+
+            return false;
+        }
+
        // migrate first
        const {migrateIfNecessary} = await import("./settingsMigration.js");

        migrateIfNecessary();
+
+        // make sure existing settings are valid before applying envs
+        const errors = settings.validateNonRequired();
+
+        if (errors.length > 0) {
+            await onSettingsErrors(errors);
+
+            return false;
+        }
+
        // trigger initial writing of `ZIGBEE2MQTT_CONFIG_*` ENVs
        settings.write();
+    } else {
+        settings.writeMinimalDefaults();
    }

    // use `configuration.yaml` file to detect "brand new install"
@@ -553,24 +596,7 @@ export async function onboard(): Promise<boolean> {
    const errors = settings.validate();

    if (errors.length > 0) {
-        let pErrors = "";
-
-        console.error("\n\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
-        console.error("            READ THIS CAREFULLY\n");
-        console.error("Refusing to start because configuration is not valid, found the following errors:");
-
-        for (const error of errors) {
-            console.error(`- ${error}`);
-
-            pErrors += `<p>- ${escapeHtml(error)}</p>`;
-        }
-
-        console.error("\nIf you don't know how to solve this, read https://www.zigbee2mqtt.io/guide/configuration");
-        console.error("\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n\n");
-
-        if (!process.env.Z2M_ONBOARD_NO_SERVER && !process.env.Z2M_ONBOARD_NO_FAILURE_PAGE) {
-            await startFailureServer(pErrors);
-        }
+        await onSettingsErrors(errors);

        return false;
    }
@@ -1,6 +1,5 @@
-import type {UnixDgramSocket} from "unix-dgram";
-
 import {platform} from "node:os";
+import type {UnixDgramSocket} from "unix-dgram";

 import logger from "./logger";

@@ -78,7 +78,7 @@
                        },
                        "backoff": {
                            "type": "boolean",
-                            "title": "Enabled",
+                            "title": "Backoff",
                            "description": "Enable timeout backoff on failed availability pings (x1.5, x3, x6, x12...)",
                            "default": true
                        },
@@ -248,8 +248,8 @@
                    "type": "number",
                    "title": "Baudrate",
                    "requiresRestart": true,
-                    "description": "Baud rate speed for serial port, this can be anything firmware support but default is 115200 for Z-Stack and EZSP, 38400 for Deconz, however note that some EZSP firmware need 57600",
-                    "examples": [38400, 57600, 115200]
+                    "description": "Baud rate speed for the serial port. This must match what the firmware on your adapter supports (most commonly 115200).",
+                    "examples": [115200, 921600, 460800, 230400, 57600, 38400]
                },
                "rtscts": {
                    "type": "boolean",
@@ -291,13 +291,16 @@
                                    "type": "object",
                                    "properties": {
                                        "enddevice": {
-                                            "type": "string"
+                                            "type": "string",
+                                            "default": "#fff8ce"
                                        },
                                        "coordinator": {
-                                            "type": "string"
+                                            "type": "string",
+                                            "default": "#e04e5d"
                                        },
                                        "router": {
-                                            "type": "string"
+                                            "type": "string",
+                                            "default": "#4ea3e0"
                                        }
                                    }
                                },
@@ -305,13 +308,16 @@
                                    "type": "object",
                                    "properties": {
                                        "enddevice": {
-                                            "type": "string"
+                                            "type": "string",
+                                            "default": "#000000"
                                        },
                                        "coordinator": {
-                                            "type": "string"
+                                            "type": "string",
+                                            "default": "#ffffff"
                                        },
                                        "router": {
-                                            "type": "string"
+                                            "type": "string",
+                                            "default": "#ffffff"
                                        }
                                    }
                                },
@@ -319,10 +325,12 @@
                                    "type": "object",
                                    "properties": {
                                        "active": {
-                                            "type": "string"
+                                            "type": "string",
+                                            "default": "#009900"
                                        },
                                        "inactive": {
-                                            "type": "string"
+                                            "type": "string",
+                                            "default": "#994444"
                                        }
                                    }
                                }
@@ -446,6 +454,12 @@
                    "items": {
                        "type": "string"
                    }
+                },
+                "disable_ui_serving": {
+                    "type": ["boolean", "null"],
+                    "title": "Disable UI serving",
+                    "description": "If true, the frontend UI is not served, only the WebSocket is maintained by Zigbee2MQTT (you are required to serve a standalone UI yourself as needed).",
+                    "requiresRestart": true
                }
            },
            "required": []
@@ -509,7 +523,8 @@
                        "enum": ["console", "file", "syslog"]
                    },
                    "title": "Log output",
-                    "description": "Output location of the log, leave empty to suppress logging"
+                    "description": "Output location of the log, leave empty to suppress logging",
+                    "default": ["console", "file"]
                },
                "log_directory": {
                    "type": "string",
@@ -524,7 +539,7 @@
                    "requiresRestart": true,
                    "description": "Log file name, can also contain timestamp",
                    "examples": ["zigbee2mqtt_%TIMESTAMP%.log"],
-                    "default": "log.txt"
+                    "default": "log.log"
                },
                "log_level": {
                    "type": "string",
@@ -545,7 +560,7 @@
                    "title": "Log Namespaced Levels",
                    "description": "Set individual log levels for certain namespaces",
                    "default": {},
-                    "examples": [{ "z2m:mqtt": "warning" }, { "zh:ember:uart:ash": "info" }]
+                    "examples": [{"z2m:mqtt": "warning"}, {"zh:ember:uart:ash": "info"}]
                },
                "log_debug_to_mqtt_frontend": {
                    "type": "boolean",
@@ -653,7 +668,8 @@
                    ],
                    "title": "Pan ID",
                    "requiresRestart": true,
-                    "description": "ZigBee pan ID, changing requires re-pairing all devices!"
+                    "description": "ZigBee pan ID, changing requires re-pairing all devices!",
+                    "default": 6754
                },
                "ext_pan_id": {
                    "oneOf": [
@@ -671,7 +687,8 @@
                    ],
                    "title": "Ext Pan ID",
                    "requiresRestart": true,
-                    "description": "Zigbee extended pan ID, changing requires re-pairing all devices!"
+                    "description": "Zigbee extended pan ID, changing requires re-pairing all devices!",
+                    "default": [221, 221, 221, 221, 221, 221, 221, 221]
                },
                "channel": {
                    "type": "number",
@@ -689,6 +706,7 @@
                    "type": ["number", "null"],
                    "minimum": 1,
                    "maximum": 64,
+                    "default": null,
                    "description": "Adapter concurrency (e.g. 2 for CC2531 or 16 for CC26X2R1) (default: null, uses recommended value)"
                },
                "adapter_delay": {
@@ -697,6 +715,7 @@
                    "title": "Adapter delay",
                    "minimum": 0,
                    "maximum": 1000,
+                    "default": null,
                    "description": "Adapter delay"
                },
                "cache_state": {
@@ -746,14 +765,16 @@
                    ],
                    "title": "Network key",
                    "requiresRestart": true,
-                    "description": "Network encryption key, changing requires re-pairing all devices!"
+                    "description": "Network encryption key, changing requires re-pairing all devices!",
+                    "default": [1, 3, 5, 7, 9, 11, 13, 15, 0, 2, 4, 6, 8, 10, 12, 13]
                },
                "timestamp_format": {
                    "type": "string",
                    "title": "Timestamp format",
                    "requiresRestart": true,
                    "description": "Log timestamp format",
-                    "examples": ["YYYY-MM-DD HH:mm:ss"]
+                    "default": "YYYY-MM-DD HH:mm:ss",
+                    "examples": ["YYYY-MM-DD HH:mm:ss.SSS"]
                },
                "transmit_power": {
                    "type": ["number", "null"],
@@ -767,9 +788,31 @@
                    "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": "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)",
+                    "default": "json"
                }
            }
+        },
+        "health": {
+            "title": "Health",
+            "description": "Periodically check the health of Zigbee2MQTT",
+            "type": "object",
+            "properties": {
+                "interval": {
+                    "type": "number",
+                    "title": "Interval",
+                    "description": "Interval between checks in minutes",
+                    "default": 10,
+                    "requiresRestart": true
+                },
+                "reset_on_check": {
+                    "type": "boolean",
+                    "title": "Reset on check",
+                    "description": "If true, will reset stats every time the health check is executed (only applicable to stats that can be reset).",
+                    "default": false
+                }
+            },
+            "required": []
        }
    },
    "required": ["mqtt"],
@@ -800,7 +843,8 @@
                    "description": "Sets the MQTT Message Expiry in seconds, Make sure to set mqtt.version to 5"
                },
                "qos": {
-                    "type": "number",
+                    "type": ["number"],
+                    "enum": [0, 1, 2],
                    "title": "QoS",
                    "description": "QoS level for MQTT messages of this device"
                },
@@ -890,13 +934,16 @@
                    "type": "boolean"
                },
                "qos": {
-                    "type": "number"
+                    "type": ["number"],
+                    "enum": [0, 1, 2],
+                    "title": "QoS",
+                    "description": "QoS level for MQTT messages of this group"
                },
                "off_state": {
                    "type": ["string"],
                    "enum": ["all_members_off", "last_member_state"],
                    "title": "Group off state",
-                    "default": "auto",
+                    "default": "all_members_off",
                    "requiresRestart": true,
                    "description": "Control when to publish state OFF or CLOSE for a group. 'all_members_off': only publish state OFF/CLOSE when all group members are in state OFF/CLOSE,  'last_member_state': publish state OFF whenever one of its members changes to OFF"
                },
@@ -1,6 +1,5 @@
-import type {ValidateFunction} from "ajv";
-
 import path from "node:path";
+import type {ValidateFunction} from "ajv";

 import Ajv from "ajv";
 import objectAssignDeep from "object-assign-deep";
@@ -8,7 +7,7 @@ import objectAssignDeep from "object-assign-deep";
 import data from "./data";
 import schemaJson from "./settings.schema.json";
 import utils from "./utils";
-import yaml, {YAMLFileException} from "./yaml";
+import yaml from "./yaml";

 export {schemaJson};
 // When updating also update:
@@ -53,6 +52,9 @@ export const defaults = {
        force_disable_retain: false,
        // 1MB = roughly 3.5KB per device * 300 devices for `/bridge/devices`
        maximum_packet_size: 1048576,
+        keepalive: 60,
+        reject_unauthorized: true,
+        version: 4,
    },
    serial: {
        disable_led: false,
@@ -113,6 +115,10 @@ export const defaults = {
        timestamp_format: "YYYY-MM-DD HH:mm:ss",
        output: "json",
    },
+    health: {
+        interval: 10,
+        reset_on_check: false,
+    },
 } satisfies RecursivePartial<Settings>;

 let _settings: Partial<Settings> | undefined;
@@ -254,15 +260,7 @@ export function write(): void {
 }

 export function validate(): string[] {
-    try {
-        getPersistedSettings();
-    } catch (error) {
-        if (error instanceof YAMLFileException) {
-            return [`Your YAML file: '${error.file}' is invalid (use https://jsonformatter.org/yaml-validator to find and fix the issue)`];
-        }
-
-        return [`${error}`];
-    }
+    getPersistedSettings();

    if (!ajvSetting(_settings)) {
        // biome-ignore lint/style/noNonNullAssertion: When `ajvSetting()` return false it always has `errors`
@@ -292,9 +290,6 @@ export function validate(): string[] {
        if ("icon" in e && e.icon && !e.icon.startsWith("http://") && !e.icon.startsWith("https://") && !e.icon.startsWith("device_icons/")) {
            errors.push(`Device icon of '${e.friendly_name}' should start with 'device_icons/', got '${e.icon}'`);
        }
-        if (e.qos != null && ![0, 1, 2].includes(e.qos)) {
-            errors.push(`QOS for '${e.friendly_name}' not valid, should be 0, 1 or 2 got ${e.qos}`);
-        }
    };

    const settingsWithDefaults = get();
@@ -318,6 +313,19 @@ export function validate(): string[] {
    return errors;
 }

+export function validateNonRequired(): string[] {
+    getPersistedSettings();
+
+    if (!ajvSetting(_settings)) {
+        // biome-ignore lint/style/noNonNullAssertion: When `ajvSetting()` return false it always has `errors`
+        const errors = ajvSetting.errors!.filter((e) => e.keyword !== "required");
+
+        return errors.map((v) => `${v.instancePath.substring(1)} ${v.message}`);
+    }
+
+    return [];
+}
+
 function read(): Partial<Settings> {
    const s = yaml.read(CONFIG_FILE_PATH) as Partial<Settings>;

@@ -475,12 +483,12 @@ export function apply(settings: Record<string, unknown>, throwOnError = true): b
    const newSettings = objectAssignDeep.noMutate(_settings, settings);

    utils.removeNullPropertiesFromObject(newSettings, NULLABLE_SETTINGS);
-    ajvSetting(newSettings);

-    if (throwOnError) {
-        const errors = ajvSetting.errors?.filter((e) => e.keyword !== "required");
+    if (!ajvSetting(newSettings) && throwOnError) {
+        // biome-ignore lint/style/noNonNullAssertion: When `ajvSetting()` return false it always has `errors`
+        const errors = ajvSetting.errors!.filter((e) => e.keyword !== "required");

-        if (errors?.length) {
+        if (errors.length) {
            const error = errors[0];
            throw new Error(`${error.instancePath.substring(1)} ${error.message}`);
        }
@@ -596,7 +604,7 @@ export function addGroup(name: string, id?: string): GroupOptions {
        settings.groups = {};
    }

-    if (id == null) {
+    if (id == null || (typeof id === "string" && id.trim() === "")) {
        // look for free ID
        id = "1";

@@ -1,20 +1,19 @@
-import type * as zhc from "zigbee-herdsman-converters";
-
-import type {Zigbee2MQTTAPI, Zigbee2MQTTResponse, Zigbee2MQTTResponseEndpoints, Zigbee2MQTTScene} from "../types/api";
-
 import assert from "node:assert";
 import {exec} from "node:child_process";
 import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
-
 import equals from "fast-deep-equal/es6";
 import humanizeDuration from "humanize-duration";
+import type * as zhc from "zigbee-herdsman-converters";
+import type {Zigbee2MQTTAPI, Zigbee2MQTTResponse, Zigbee2MQTTResponseEndpoints, Zigbee2MQTTScene} from "../types/api";

 import data from "./data";

 const BASE64_IMAGE_REGEX = /data:image\/(?<extension>.+);base64,(?<data>.+)/;

+export const DEFAULT_BIND_GROUP_ID = 901;
+
 function pad(num: number): string {
    const norm = Math.floor(Math.abs(num));
    return (norm < 10 ? "0" : "") + norm;
@@ -87,7 +86,6 @@ function formatDate(time: number, type: "ISO_8601" | "ISO_8601_local" | "epoch"

 function objectIsEmpty(object: object): boolean {
    // much faster than checking `Object.keys(object).length`
-    // biome-ignore lint/style/useNamingConvention: bad detection
    for (const _k in object) return false;
    return true;
 }
@@ -204,14 +202,21 @@ function containsControlCharacter(str: string): boolean {

 function getAllFiles(path_: string): string[] {
    const result = [];
-    for (let item of fs.readdirSync(path_)) {
-        item = path.join(path_, item);
-        if (fs.lstatSync(item).isFile()) {
-            result.push(item);
+
+    for (const item of fs.readdirSync(path_, {withFileTypes: true})) {
+        if (item.isSymbolicLink()) {
+            continue;
+        }
+
+        const fileName = path.join(path_, item.name);
+
+        if (fs.lstatSync(fileName).isFile()) {
+            result.push(fileName);
        } else {
-            result.push(...getAllFiles(item));
+            result.push(...getAllFiles(fileName));
        }
    }
+
    return result;
 }

@@ -279,9 +284,9 @@ function isZHGroup(obj: unknown): obj is zh.Group {
    return obj?.constructor.name.toLowerCase() === "group";
 }

-const hours = (hours: number): number => 1000 * 60 * 60 * hours;
-const minutes = (minutes: number): number => 1000 * 60 * minutes;
-const seconds = (seconds: number): number => 1000 * seconds;
+export const hours = (hours: number): number => 1000 * 60 * 60 * hours;
+export const minutes = (minutes: number): number => 1000 * 60 * minutes;
+export const seconds = (seconds: number): number => 1000 * seconds;

 async function publishLastSeen(
    data: eventdata.LastSeenChanged,
@@ -21,7 +21,7 @@ export class YAMLFileException extends YAMLException {
 function read(file: string): KeyValue {
    try {
        const result = yaml.load(fs.readFileSync(file, "utf8"));
-        assert(result instanceof Object);
+        assert(result instanceof Object, `The content of ${file} is expected to be an object`);
        return result as KeyValue;
    } catch (error) {
        if (error instanceof YAMLException) {
@@ -1,12 +1,9 @@
-import type {Events as ZHEvents} from "zigbee-herdsman";
-import type {StartResult} from "zigbee-herdsman/dist/adapter/tstype";
-
 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";

 import Device from "./model/device";
 import Group from "./model/group";
@@ -18,8 +15,7 @@ import utils from "./util/utils";
 const entityIDRegex = /^(.+?)(?:\/([^/]+))?$/;

 export default class Zigbee {
-    // @ts-expect-error initialized in start
-    private herdsman: Controller;
+    private herdsman!: Controller;
    private eventBus: EventBus;
    private groupLookup = new Map<number /* group ID */, Group>();
    private deviceLookup = new Map<string /* IEEE address */, Device>();
@@ -269,12 +265,20 @@ export default class Zigbee {
    }

    private resolveGroup(groupID: number): Group | undefined {
-        const group = this.herdsman.getGroupByID(Number(groupID));
-        if (group && !this.groupLookup.has(groupID)) {
-            this.groupLookup.set(groupID, new Group(group, this.resolveDevice));
+        if (!this.groupLookup.has(groupID)) {
+            const group = this.herdsman.getGroupByID(groupID);
+
+            if (group) {
+                this.groupLookup.set(groupID, new Group(group, this.resolveDevice));
+            }
        }

-        return this.groupLookup.get(groupID);
+        const group = this.groupLookup.get(groupID);
+
+        if (group) {
+            group.ensureInSettings();
+            return group;
+        }
    }

    resolveEntity(key: string | number | zh.Device): Device | Group | undefined {
@@ -1,10 +1,10 @@
 {
    "name": "zigbee2mqtt",
-    "version": "2.4.0",
+    "version": "2.6.0",
    "description": "Zigbee to MQTT bridge using Zigbee-herdsman",
    "main": "index.js",
    "types": "dist/types/api.d.ts",
-    "packageManager": "pnpm@10.4.1",
+    "packageManager": "pnpm@10.12.1",
    "repository": {
        "type": "git",
        "url": "git+https://github.com/Koenkk/zigbee2mqtt.git"
@@ -23,13 +23,15 @@
    ],
    "scripts": {
        "build": "tsc && node index.js writehash",
+        "build:types": "pnpm run clean && tsc --project tsconfig.types.json && cp lib/util/settings.schema.json dist/util",
        "build:watch": "tsc --watch",
-        "check": "biome check",
+        "check": "biome check --error-on-warnings",
        "check:w": "biome check --write",
        "start": "node index.js",
        "test": "vitest run --config ./test/vitest.config.mts",
        "test:coverage": "vitest run --config ./test/vitest.config.mts --coverage",
        "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"
    },
@@ -61,19 +63,20 @@
        "winston-syslog": "^2.7.1",
        "winston-transport": "^4.9.0",
        "ws": "^8.18.1",
-        "zigbee-herdsman": "4.1.0",
-        "zigbee-herdsman-converters": "23.53.0",
-        "zigbee2mqtt-frontend": "0.9.13",
-        "zigbee2mqtt-windfront": "^1.0.2"
+        "zigbee-herdsman": "5.0.4",
+        "zigbee-herdsman-converters": "24.11.0",
+        "zigbee2mqtt-frontend": "0.9.19",
+        "zigbee2mqtt-windfront": "^1.5.2"
    },
    "devDependencies": {
-        "@biomejs/biome": "^1.9.4",
+        "@biomejs/biome": "^2.0.5",
+        "@codspeed/vitest-plugin": "^4.0.1",
        "@types/finalhandler": "^1.2.3",
        "@types/humanize-duration": "^3.27.4",
        "@types/js-yaml": "^4.0.9",
-        "@types/node": "^22.14.1",
+        "@types/node": "^24.0.3",
        "@types/object-assign-deep": "^0.4.3",
-        "@types/readable-stream": "4.0.20",
+        "@types/readable-stream": "4.0.21",
        "@types/serve-static": "^1.15.7",
        "@types/ws": "8.18.1",
        "@vitest/coverage-v8": "^3.1.1",
@@ -0,0 +1,672 @@
+import {existsSync, mkdirSync} from "node:fs";
+import stringify from "json-stable-stringify-without-jsonify";
+import {afterAll, afterEach, beforeAll, beforeEach, bench, describe} from "vitest";
+import {Zcl, Zdo, ZSpec} from "zigbee-herdsman";
+import type Adapter from "zigbee-herdsman/dist/adapter/adapter";
+import type {ZclPayload} from "zigbee-herdsman/dist/adapter/events";
+import {Device, InterviewState} from "zigbee-herdsman/dist/controller/model/device";
+import {Endpoint} from "zigbee-herdsman/dist/controller/model/endpoint";
+import Entity from "zigbee-herdsman/dist/controller/model/entity";
+import {Group} from "zigbee-herdsman/dist/controller/model/group";
+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";
+
+process.env.ZIGBEE2MQTT_DATA = "data-bench";
+data._testReload();
+
+if (!existsSync(data.getPath())) {
+    mkdirSync(data.getPath(), {recursive: true});
+}
+
+const createEndpoint = (id: number, ieeeAddr: string, networkAddress: number) => {
+    const ep = Endpoint.create(
+        id,
+        id === ZSpec.GP_ENDPOINT ? ZSpec.GP_PROFILE_ID : ZSpec.HA_PROFILE_ID,
+        id === ZSpec.GP_ENDPOINT ? 0x66 : 0x65,
+        id === ZSpec.GP_ENDPOINT ? [Zcl.Clusters.greenPower.ID] : [Zcl.Clusters.genBasic.ID, Zcl.Clusters.genOnOff.ID],
+        id === ZSpec.GP_ENDPOINT ? [Zcl.Clusters.greenPower.ID] : [Zcl.Clusters.genBasic.ID],
+        networkAddress,
+        ieeeAddr,
+    );
+    ep.save = () => {};
+
+    return ep;
+};
+// `Device.create` requires `Database`, bypass it by using the private constructor directly
+const createDevice = (
+    dbId: number,
+    type: DeviceType,
+    ieeeAddr: string,
+    networkAddress: number,
+    manufacturerID: number | undefined,
+    manufacturerName: string | undefined,
+    powerSource: string | undefined,
+    modelID: string | undefined,
+): Device => {
+    const haEp = createEndpoint(ZSpec.HA_ENDPOINT, ieeeAddr, networkAddress);
+    const ep2 = createEndpoint(2, ieeeAddr, networkAddress);
+    const endpoints = [haEp, ep2];
+
+    if (type === "Coordinator" || type === "Router") {
+        const gpEp = createEndpoint(ZSpec.GP_ENDPOINT, ieeeAddr, networkAddress);
+
+        endpoints.push(gpEp);
+    }
+
+    // @ts-expect-error mocking private
+    const device = new Device(
+        dbId,
+        type,
+        ieeeAddr,
+        networkAddress,
+        manufacturerID,
+        endpoints,
+        manufacturerName,
+        powerSource,
+        modelID,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        InterviewState.Successful,
+        {},
+        undefined,
+        undefined,
+        0,
+        undefined,
+    );
+
+    // in-memory only
+    device.save = () => {};
+
+    return device;
+};
+// `Group.create` requires `Database`, bypass it by using the private constructor directly
+const createGroup = (dbId: number, id: number): Group => {
+    // @ts-expect-error mocking private
+    const group = new Group(dbId, id, [], {});
+
+    // in-memory only
+    group.save = () => {};
+
+    return group;
+};
+
+const COORD_IEEE = "0x0101010101010101";
+const EXT_PAN_ID = [0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd];
+const NETWORK_PARAMS = {
+    panID: 0x1a62,
+    extendedPanID: `0x${Buffer.from(EXT_PAN_ID).toString("hex")}`,
+    channel: 11,
+    nwkUpdateID: 1,
+};
+const NETWORK_KEY = [1, 3, 5, 7, 9, 11, 13, 15, 0, 2, 4, 6, 8, 10, 12, 13];
+const ZH_DEVICES: Device[] = [];
+const ZH_GROUPS: Group[] = [];
+const MANY_DEVICES = 100;
+
+const initDevices = () => {
+    ZH_DEVICES.splice(0, ZH_DEVICES.length);
+
+    ZH_DEVICES.push(
+        createDevice(
+            0,
+            "Coordinator",
+            COORD_IEEE,
+            ZSpec.COORDINATOR_ADDRESS,
+            Zcl.ManufacturerCode.SILICON_LABORATORIES,
+            undefined,
+            undefined,
+            undefined,
+        ),
+    );
+    ZH_DEVICES.push(
+        createDevice(1, "Router", "0xf1f1f1f1f1f1f1f1", 0x0001, Zcl.ManufacturerCode.INNR_LIGHTING_BV, "Innr", "Mains (single phase)", "AE 262"),
+    );
+    ZH_DEVICES.push(
+        createDevice(2, "EndDevice", "0xe2e2e2e2e2e2e2e2", 0x0002, Zcl.ManufacturerCode.TUYA_GLOBAL_INC, "_TYZB01_kvwjujy9", "Battery", "TS0222"),
+    );
+    ZH_DEVICES.push(createDevice(3, "GreenPower", "0x00000000015d3d3d", 0x0003, undefined, undefined, undefined, "GreenPower_7"));
+    // these have configure, without setTimeout, they hammer really badly (# of fn calls), so, only one of each
+    ZH_DEVICES.push(
+        createDevice(
+            4,
+            "Router",
+            "0xd3d3d3d3d3d3d3d3",
+            0x0004,
+            Zcl.ManufacturerCode.LEDVANCE_GMBH,
+            "LEDVANCE",
+            "Mains (single phase)",
+            "PLUG OUTDOOR EU T",
+        ),
+    );
+    ZH_DEVICES.push(
+        createDevice(5, "Router", "0xc4c4c4c4c4c4c4c4", 0x0005, Zcl.ManufacturerCode.INOVELLI, "Inovelli", "Mains (single phase)", "VZM35-SN"),
+    );
+    ZH_DEVICES.push(
+        createDevice(
+            6,
+            "Router",
+            "0xb5b5b5b5b5b5b5b5",
+            0x0006,
+            Zcl.ManufacturerCode.SILICON_LABORATORIES,
+            "SMLIGHT",
+            "Mains (single phase)",
+            "SLZB-06Mg24",
+        ),
+    );
+    ZH_DEVICES.push(
+        createDevice(
+            7,
+            "Router",
+            "0xa6a6a6a6a6a6a6a6",
+            0x0007,
+            Zcl.ManufacturerCode.TUYA_GLOBAL_INC,
+            "_TZE200_p0gzbqct",
+            "Mains (single phase)",
+            "TS0601",
+        ),
+    );
+};
+
+const initGroups = () => {
+    ZH_GROUPS.splice(0, ZH_GROUPS.length);
+
+    ZH_GROUPS.push(createGroup(0, 1));
+};
+
+const addManyDevices = () => {
+    for (let i = 0; i < MANY_DEVICES; i++) {
+        const ieee = `0xf1f1f1f1f1f1f1${i.toString(16).padStart(2, "0")}`;
+
+        // device without `configure` (too many calls otherwise)
+        ZH_DEVICES.push(createDevice(1, "Router", ieee, 0x0008 + i, Zcl.ManufacturerCode.INNR_LIGHTING_BV, "Innr", "Mains (single phase)", "AE 262"));
+    }
+};
+
+const getMidDeviceIeee = () =>
+    `0xf1f1f1f1f1f1f1${Math.floor(MANY_DEVICES / 2)
+        .toString(16)
+        .padStart(2, "0")}`;
+
+Device.byIeeeAddr = (ieeeAddr, _includeDeleted) => ZH_DEVICES.find((device) => device.ieeeAddr === ieeeAddr);
+Device.byType = (type) => ZH_DEVICES.filter((device) => device.type === type);
+
+const adapter = {
+    sendZclFrameToEndpoint: async (
+        _ieeeAddr: string,
+        networkAddress: number,
+        endpoint: number,
+        zclFrame: Zcl.Frame,
+        _timeout: number,
+        disableResponse: boolean,
+        _disableRecovery: boolean,
+        sourceEndpoint?: number,
+    ): Promise<ZclPayload | undefined> => {
+        const payload: {[key: string]: unknown}[] = [];
+
+        if (!disableResponse) {
+            if (zclFrame.header.isGlobal) {
+                switch (zclFrame.command.ID) {
+                    case Foundation.read.ID: {
+                        for (const attr of zclFrame.payload) {
+                            const attribute = zclFrame.cluster.getAttribute(attr.attrId);
+
+                            if (attribute && attribute.type !== Zcl.DataType.NO_DATA && attribute.type < Zcl.DataType.OCTET_STR) {
+                                payload.push({
+                                    attrId: attr.attrId,
+                                    dataType: attribute.type,
+                                    attrData: 1,
+                                    status: 0,
+                                });
+                            }
+                        }
+
+                        const messageContents = Zcl.Frame.create(
+                            0,
+                            Zcl.Direction.SERVER_TO_CLIENT,
+                            true,
+                            undefined,
+                            10,
+                            Foundation.readRsp.ID,
+                            zclFrame.cluster.ID,
+                            payload,
+                            {},
+                        ).toBuffer();
+
+                        return await Promise.resolve({
+                            clusterID: zclFrame.cluster.ID,
+                            header: Zcl.Header.fromBuffer(messageContents),
+                            address: networkAddress,
+                            data: messageContents,
+                            endpoint: sourceEndpoint ?? 1,
+                            linkquality: 200,
+                            groupID: 0,
+                            wasBroadcast: false,
+                            destinationEndpoint: endpoint,
+                        });
+                    }
+                    case Foundation.configReport.ID: {
+                        for (const item of zclFrame.payload) {
+                            payload.push({attrId: item.attrId, status: 0, direction: 1});
+                        }
+
+                        const messageContents = Zcl.Frame.create(
+                            0,
+                            Zcl.Direction.SERVER_TO_CLIENT,
+                            true,
+                            undefined,
+                            10,
+                            Foundation.configReportRsp.ID,
+                            zclFrame.cluster.ID,
+                            payload,
+                            {},
+                        ).toBuffer();
+
+                        return await Promise.resolve({
+                            clusterID: zclFrame.cluster.ID,
+                            header: Zcl.Header.fromBuffer(messageContents),
+                            address: networkAddress,
+                            data: messageContents,
+                            endpoint: sourceEndpoint ?? 1,
+                            linkquality: 200,
+                            groupID: 0,
+                            wasBroadcast: false,
+                            destinationEndpoint: endpoint,
+                        });
+                    }
+                }
+            }
+        }
+
+        return await Promise.resolve(undefined);
+    },
+    sendZclFrameToGroup: async (_groupID: number, _zclFrame: Zcl.Frame, _sourceEndpoint?: number): Promise<void> => await Promise.resolve(),
+    sendZdo: async (
+        _ieeeAddress: string,
+        _networkAddress: number,
+        clusterId: Zdo.ClusterId,
+        _payload: Buffer,
+        _disableResponse: boolean,
+    ): Promise<RequestToResponseMap[keyof RequestToResponseMap] | undefined> => {
+        switch (clusterId) {
+            case Zdo.ClusterId.BIND_REQUEST:
+            case Zdo.ClusterId.UNBIND_REQUEST: {
+                return await Promise.resolve([Zdo.Status.SUCCESS, undefined]);
+            }
+        }
+
+        return await Promise.resolve(undefined);
+    },
+};
+
+Entity.injectAdapter(adapter as Adapter);
+
+// use plain type to avoid early import that otherwise messes with data path
+let controller: import("../lib/controller.js").Controller;
+const origSetImmediate = global.setImmediate;
+const origSetTimeout = global.setTimeout;
+
+const mockGlobalThis = () => {
+    const setImmediateProms: (void | Promise<void>)[] = [];
+    const setTimeoutProms: (void | Promise<void>)[] = [];
+
+    // @ts-expect-error mock
+    globalThis.setImmediate = (callback: () => void) => {
+        setImmediateProms.push(callback());
+    };
+    // @ts-expect-error mock
+    globalThis.setTimeout = (callback: () => void) => {
+        setTimeoutProms.push(callback());
+    };
+
+    return {setImmediateProms, setTimeoutProms};
+};
+
+const unmockGlobalThis = () => {
+    globalThis.setImmediate = origSetImmediate;
+    globalThis.setTimeout = origSetTimeout;
+};
+
+const settle = async (mockedGlobal: ReturnType<typeof mockGlobalThis>) => {
+    await Promise.allSettled(mockedGlobal.setImmediateProms);
+    await Promise.allSettled(mockedGlobal.setTimeoutProms);
+    await new Promise((resolve) => origSetImmediate(resolve));
+};
+
+const initSettings = async (pathValuePairs?: [string[], string | number | boolean][]) => {
+    const settings = await import("../lib/util/settings.js");
+
+    settings.writeMinimalDefaults();
+    // disable logging, too much influence on perf
+    settings.set(["advanced", "log_level"], "error");
+    settings.set(["advanced", "log_output"], []);
+    settings.set(["advanced", "pan_id"], NETWORK_PARAMS.panID);
+    settings.set(["advanced", "ext_pan_id"], EXT_PAN_ID);
+    settings.set(["advanced", "network_key"], NETWORK_KEY);
+
+    if (pathValuePairs) {
+        for (const [path, value] of pathValuePairs) {
+            settings.set(path, value);
+        }
+    }
+};
+
+const initController = async () => {
+    const {Controller} = await import("../lib/controller.js");
+
+    controller = new Controller(
+        async () => {},
+        async () => {},
+    );
+
+    controller.zigbee.start = async () => {
+        await controller.zigbee.resolveDevicesDefinitions();
+
+        return "resumed";
+    };
+    controller.zigbee.stop = async () => {
+        await Promise.resolve();
+    };
+    // @ts-expect-error mocking private
+    controller.zigbee.herdsman = {
+        isStopping: () => false,
+        getCoordinatorVersion: async () =>
+            Promise.resolve({
+                type: "Dummy",
+                meta: {revision: "9.9.9"},
+            }),
+        getNetworkParameters: async () => Promise.resolve({...NETWORK_PARAMS}),
+        getPermitJoin: () => false,
+        getPermitJoinEnd: () => undefined,
+        getDeviceByIeeeAddr: (ieeeAddr) => ZH_DEVICES.find((device) => device.ieeeAddr === ieeeAddr),
+        getGroupByID: (id) => ZH_GROUPS.find((group) => group.groupID === id),
+        getDevicesByType: (type) => ZH_DEVICES.filter((device) => device.type === type),
+        getDeviceByNetworkAddress: (networkAddress) => ZH_DEVICES.find((device) => device.networkAddress === networkAddress),
+        *getDevicesIterator(predicate) {
+            for (const device of ZH_DEVICES) {
+                if (!predicate || predicate(device)) {
+                    yield device;
+                }
+            }
+        },
+        *getGroupsIterator(predicate) {
+            for (const group of ZH_GROUPS) {
+                if (!predicate || predicate(group)) {
+                    yield group;
+                }
+            }
+        },
+    };
+
+    // all dummies, can trigger `controller.mqtt.onMessage(topic, message)` as needed
+    // @ts-expect-error mocking private
+    controller.mqtt.client = {
+        options: {
+            protocolVersion: 5,
+            protocol: "mqtt",
+            host: "localhost",
+            port: 1883,
+        },
+        queue: [],
+        reconnecting: false,
+        disconnecting: false,
+        disconnected: false,
+        endAsync: async () => {},
+        // @ts-expect-error Z2M does not make use of return
+        publishAsync: async () => {},
+    };
+    controller.mqtt.connect = async () => {
+        // @ts-expect-error private
+        await controller.mqtt.onConnect();
+    };
+    controller.mqtt.subscribe = async () => {};
+    controller.mqtt.unsubscribe = async () => {};
+
+    // will be in-memory only
+    controller.state.start = () => {};
+    controller.state.stop = () => {};
+};
+
+describe("Controller with dummy zigbee/mqtt", () => {
+    describe("defaults start & stop", () => {
+        beforeEach(async () => {
+            initDevices();
+            initGroups();
+            await initSettings();
+            await initController();
+        });
+
+        afterEach(() => {
+            unmockGlobalThis();
+        });
+
+        bench(
+            "[defaults] start & stop controller",
+            async () => {
+                const mockedGlobal = mockGlobalThis();
+
+                await controller.start();
+                await settle(mockedGlobal);
+
+                if ((await controller.zigbee.getCoordinatorVersion()).type !== "Dummy") {
+                    throw new Error("Invalid");
+                }
+
+                await controller.stop();
+            },
+            {throws: true},
+        );
+    });
+
+    describe("HA start & stop", () => {
+        beforeEach(async () => {
+            initDevices();
+            initGroups();
+            await initSettings([[["homeassistant", "enabled"], true]]);
+            await initController();
+        });
+
+        afterEach(() => {
+            unmockGlobalThis();
+        });
+
+        bench(
+            "[HA] start & stop controller",
+            async () => {
+                const mockedGlobal = mockGlobalThis();
+
+                await controller.start();
+                controller.mqtt.onMessage("homeassistant/status", Buffer.from("online", "utf8"));
+                await settle(mockedGlobal);
+
+                if ((await controller.zigbee.getCoordinatorVersion()).type !== "Dummy") {
+                    throw new Error("Invalid");
+                }
+
+                await controller.stop();
+            },
+            {throws: true},
+        );
+    });
+
+    describe("defaults runtime", () => {
+        beforeAll(async () => {
+            initDevices();
+            initGroups();
+            await initSettings();
+            await initController();
+            const mockedGlobal = mockGlobalThis();
+
+            await controller.start();
+            await settle(mockedGlobal);
+        });
+
+        afterAll(async () => {
+            await controller.stop();
+            unmockGlobalThis();
+        });
+
+        bench(
+            "[defaults] receive device message",
+            async () => {
+                const mockedGlobal = mockGlobalThis();
+
+                controller.eventBus.emitDeviceMessage({
+                    type: "attributeReport",
+                    device: controller.zigbee.resolveEntity("0xf1f1f1f1f1f1f1f1"),
+                    endpoint: ZSpec.HA_ENDPOINT,
+                    linkquality: 200,
+                    groupID: 0,
+                    cluster: "genOnOff",
+                    data: {onOff: 1},
+                    meta: {},
+                });
+                await settle(mockedGlobal);
+            },
+            {throws: true},
+        );
+
+        bench(
+            "[defaults] receive MQTT message",
+            async () => {
+                const mockedGlobal = mockGlobalThis();
+
+                controller.mqtt.onMessage("zigbee2mqtt/0xf1f1f1f1f1f1f1f1/set", Buffer.from(`{"state": "OFF"}`, "utf8"));
+                await settle(mockedGlobal);
+            },
+            {throws: true},
+        );
+
+        bench(
+            "[defaults] add group member",
+            async () => {
+                const mockedGlobal = mockGlobalThis();
+
+                controller.eventBus.emitMQTTMessage({
+                    topic: "zigbee2mqtt/bridge/request/group/members/add",
+                    message: stringify({
+                        device: "0xf1f1f1f1f1f1f1f1",
+                        group: `${ZH_GROUPS[0].groupID}`,
+                        endpoint: ZSpec.HA_ENDPOINT,
+                    }),
+                });
+
+                await settle(mockedGlobal);
+
+                if (ZH_GROUPS[0].members.length !== 1) {
+                    throw new Error("Invalid state");
+                }
+            },
+            {throws: true},
+        );
+    });
+
+    describe("defaults/stress runtime", () => {
+        beforeAll(async () => {
+            initDevices();
+            initGroups();
+            addManyDevices();
+            await initSettings();
+            await initController();
+            const mockedGlobal = mockGlobalThis();
+
+            await controller.start();
+            await settle(mockedGlobal);
+        }, 60000);
+
+        afterAll(async () => {
+            await controller.stop();
+            unmockGlobalThis();
+        });
+
+        // this is mostly just to confirm the number of devices does not influence the processing (much)
+        bench(
+            "[defaults/stress] receive device message",
+            async () => {
+                const mockedGlobal = mockGlobalThis();
+
+                controller.eventBus.emitDeviceMessage({
+                    type: "attributeReport",
+                    device: controller.zigbee.resolveEntity(getMidDeviceIeee()),
+                    endpoint: ZSpec.HA_ENDPOINT,
+                    linkquality: 200,
+                    groupID: 0,
+                    cluster: "genOnOff",
+                    data: {onOff: 1},
+                    meta: {},
+                });
+                await settle(mockedGlobal);
+            },
+            {throws: true},
+        );
+    });
+
+    describe("HA runtime", () => {
+        beforeAll(async () => {
+            initDevices();
+            initGroups();
+            await initSettings([[["homeassistant", "enabled"], true]]);
+            await initController();
+            const mockedGlobal = mockGlobalThis();
+
+            await controller.start();
+            controller.mqtt.onMessage("homeassistant/status", Buffer.from("online", "utf8"));
+            await settle(mockedGlobal);
+        });
+
+        afterAll(async () => {
+            await controller.stop();
+            unmockGlobalThis();
+        });
+
+        bench(
+            "[HA] receive device message",
+            async () => {
+                const mockedGlobal = mockGlobalThis();
+
+                controller.eventBus.emitDeviceMessage({
+                    type: "attributeReport",
+                    device: controller.zigbee.resolveEntity("0xf1f1f1f1f1f1f1f1"),
+                    endpoint: ZSpec.HA_ENDPOINT,
+                    linkquality: 200,
+                    groupID: 0,
+                    cluster: "genOnOff",
+                    data: {onOff: 1},
+                    meta: {},
+                });
+                await settle(mockedGlobal);
+            },
+            {throws: true},
+        );
+
+        bench(
+            "[HA] receive MQTT message",
+            async () => {
+                const mockedGlobal = mockGlobalThis();
+
+                controller.mqtt.onMessage("zigbee2mqtt/0xf1f1f1f1f1f1f1f1/set", Buffer.from(`{"state": "OFF"}`, "utf8"));
+                await settle(mockedGlobal);
+            },
+            {throws: true},
+        );
+
+        bench(
+            "[HA] receive MQTT discovery message",
+            async () => {
+                const mockedGlobal = mockGlobalThis();
+
+                controller.mqtt.onMessage(
+                    "homeassistant/sensor/0xe2e2e2e2e2e2e2e2/update/config",
+                    Buffer.from(stringify({availability: [{topic: "zigbee2mqtt/bridge/state", value_template: "{{ value_json.state }}"}]}), "utf8"),
+                );
+                await settle(mockedGlobal);
+            },
+            {throws: true},
+        );
+    });
+});
@@ -1,3 +1,5 @@
+// biome-ignore assist/source/organizeImports: import mocks first
+import {afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi} from "vitest";
 import * as data from "./mocks/data";
 import {mockLogger} from "./mocks/logger";
 import {
@@ -9,23 +11,19 @@ import {
    mockMQTTUnsubscribeAsync,
 } from "./mocks/mqtt";
 import {flushPromises} from "./mocks/utils";
-import {devices, mockController as mockZHController, events as mockZHEvents, returnDevices} from "./mocks/zigbeeHerdsman";
-
-import type {Mock, MockInstance} from "vitest";
-
-import type Device from "../lib/model/device";
 import type {Device as ZhDevice} from "./mocks/zigbeeHerdsman";
+import {devices, mockController as mockZHController, events as mockZHEvents, returnDevices} from "./mocks/zigbeeHerdsman";

 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 type {Mock, MockInstance} from "vitest";
 import {Controller as ZHController} from "zigbee-herdsman";
-
 import {Controller} from "../lib/controller";
+import type Device from "../lib/model/device";
 import * as settings from "../lib/util/settings";

 const LOG_MQTT_NS = "z2m:mqtt";
@@ -58,7 +56,6 @@ describe("Controller", () => {
    let mockExit: Mock;

    const getZ2MDevice = (zhDevice: string | number | ZhDevice): Device => {
-        // @ts-expect-error private
        return controller.zigbee.resolveEntity(zhDevice)! as Device;
    };

@@ -115,6 +112,8 @@ describe("Controller", () => {
        expect(mockMQTTConnectAsync).toHaveBeenCalledWith("mqtt://localhost", {
            will: {payload: Buffer.from('{"state":"offline"}'), retain: true, topic: "zigbee2mqtt/bridge/state", qos: 1},
            properties: {maximumPacketSize: 1048576},
+            keepalive: 60,
+            protocolVersion: 4,
        });
        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
            "zigbee2mqtt/bulb",
@@ -296,11 +295,9 @@ describe("Controller", () => {
        await controller.start();
        await flushPromises();
        mockMQTTPublishAsync.mockClear();
-        // @ts-expect-error private
        await controller.mqtt.publish("z2m/#/status", "empty");
        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(0);
        expect(mockLogger.error).toHaveBeenCalledWith(`Topic 'z2m/#/status' includes wildcard characters, skipping publish.`);
-        // @ts-expect-error private
        await controller.mqtt.publish("z2m/+/status", "empty");
        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(0);
        expect(mockLogger.error).toHaveBeenCalledWith(`Topic 'z2m/+/status' includes wildcard characters, skipping publish.`);
@@ -413,14 +410,15 @@ describe("Controller", () => {
    });

    it("Start controller adapter disconnects", async () => {
-        mockZHController.stop.mockRejectedValueOnce("failed");
+        // Fail to stop extension exit code 1 should not override adapter disconnect exit code 2
+        vi.spyOn(Array.from(controller.extensions)[0], "stop").mockRejectedValueOnce(new Error("failed"));
        await controller.start();
        await mockZHEvents.adapterDisconnected();
        await flushPromises();
        expect(mockMQTTEndAsync).toHaveBeenCalledTimes(1);
        expect(mockZHController.stop).toHaveBeenCalledTimes(1);
        expect(mockExit).toHaveBeenCalledTimes(1);
-        expect(mockExit).toHaveBeenCalledWith(1, false);
+        expect(mockExit).toHaveBeenCalledWith(2, false);
    });

    it("does not throw when extension fails to stop on controller stop", async () => {
@@ -503,7 +501,6 @@ describe("Controller", () => {
    });

    it("Handle mqtt message", async () => {
-        // @ts-expect-error private
        const spyEventbusEmitMQTTMessage = vi.spyOn(controller.eventBus, "emitMQTTMessage").mockImplementation(vi.fn());

        await controller.start();
@@ -514,7 +511,6 @@ describe("Controller", () => {
    });

    it("Skip MQTT messages on topic we published to", async () => {
-        // @ts-expect-error private
        const spyEventbusEmitMQTTMessage = vi.spyOn(controller.eventBus, "emitMQTTMessage").mockImplementation(vi.fn());

        await controller.start();
@@ -522,7 +518,6 @@ describe("Controller", () => {
        await mockMQTTEvents.message("zigbee2mqtt/skip-this-topic", "skipped");
        expect(spyEventbusEmitMQTTMessage).toHaveBeenCalledWith({topic: "zigbee2mqtt/skip-this-topic", message: "skipped"});
        mockLogger.debug.mockClear();
-        // @ts-expect-error private
        await controller.mqtt.publish("skip-this-topic", "", {});
        await mockMQTTEvents.message("zigbee2mqtt/skip-this-topic", "skipped");
        expect(mockLogger.debug).toHaveBeenCalledTimes(0);
@@ -844,13 +839,11 @@ describe("Controller", () => {
        mockMQTTPublishAsync.mockClear();

        const device = getZ2MDevice("bulb");
-        // @ts-expect-error private
        expect(controller.state.get(device)).toStrictEqual({brightness: 50, color_temp: 370, linkquality: 99, state: "ON"});

        await controller.publishEntityState(device, {state: "ON", brightness: 200, color_temp: 370, linkquality: 87});
        await flushPromises();

-        // @ts-expect-error private
        expect(controller.state.get(device)).toStrictEqual({brightness: 200, color_temp: 370, state: "ON"});
        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(5);
        expect(mockMQTTPublishAsync).toHaveBeenCalledWith("zigbee2mqtt/bulb/state", "ON", {qos: 0, retain: true});
@@ -870,13 +863,11 @@ describe("Controller", () => {
        mockMQTTPublishAsync.mockClear();

        const device = getZ2MDevice("bulb");
-        // @ts-expect-error private
        expect(controller.state.get(device)).toStrictEqual({brightness: 50, color_temp: 370, linkquality: 99, state: "ON"});

        await controller.publishEntityState(device, {state: "ON", brightness: 200, color_temp: 370, linkquality: 87});
        await flushPromises();

-        // @ts-expect-error private
        expect(controller.state.get(device)).toStrictEqual({brightness: 200, color_temp: 370, state: "ON"});
        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(5);
        expect(mockMQTTPublishAsync).toHaveBeenCalledWith("zigbee2mqtt/bulb/state", "ON", {qos: 0, retain: true});
@@ -1048,6 +1039,8 @@ describe("Controller", () => {
        expect(mockMQTTConnectAsync).toHaveBeenCalledTimes(1);
        const expected = {
            will: {payload: Buffer.from('{"state":"offline"}'), retain: false, topic: "zigbee2mqtt/bridge/state", qos: 1},
+            keepalive: 60,
+            protocolVersion: 4,
            properties: {maximumPacketSize: 1048576},
        };
        expect(mockMQTTConnectAsync).toHaveBeenCalledWith("mqtt://localhost", expected);
@@ -1057,10 +1050,7 @@ describe("Controller", () => {
        await controller.start();
        await flushPromises();

-        const retainedMessages = Object.keys(
-            // @ts-expect-error private
-            controller.mqtt.retainedMessages,
-        ).length;
+        const retainedMessages = Object.keys(controller.mqtt.retainedMessages).length;

        mockMQTTPublishAsync.mockClear();
        await vi.advanceTimersByTimeAsync(2500); // before any startup configure triggers
@@ -1081,7 +1071,6 @@ describe("Controller", () => {

    it("Should prevent any message being published with retain flag when force_disable_retain is set", async () => {
        settings.set(["mqtt", "force_disable_retain"], true);
-        // @ts-expect-error private
        await controller.mqtt.connect();
        mockMQTTPublishAsync.mockClear();
        // @ts-expect-error private
@@ -1139,7 +1128,6 @@ describe("Controller", () => {
    it("Should remove state of removed device when stopped", async () => {
        await controller.start();
        const device = getZ2MDevice("bulb");
-        // @ts-expect-error private
        expect(controller.state.get(device)).toStrictEqual({brightness: 50, color_temp: 370, linkquality: 99, state: "ON"});
        device.zh.isDeleted = true;
        await controller.stop();
@@ -1148,7 +1136,6 @@ describe("Controller", () => {
    });

    it("EventBus should handle sync errors", async () => {
-        // @ts-expect-error private
        const eventbus = controller.eventBus;
        const callback = vi.fn().mockImplementation(() => {
            throw new Error("Whoops!");
@@ -1161,7 +1148,6 @@ describe("Controller", () => {
    });

    it("EventBus should handle async errors", async () => {
-        // @ts-expect-error private
        const eventbus = controller.eventBus;
        const callback = vi.fn().mockRejectedValue(new Error("Whoops!"));
        eventbus.onStateChange({constructor: {name: "Test"}}, callback);
@@ -1,7 +1,6 @@
 import path from "node:path";
-
 import tmp from "tmp";
-
+import {describe, expect, it} from "vitest";
 import data from "../lib/util/data";

 describe("Data", () => {
@@ -1,3 +1,5 @@
+// biome-ignore assist/source/organizeImports: import mocks first
+import {afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi} from "vitest";
 import * as data from "../mocks/data";
 import {mockLogger} from "../mocks/logger";
 import {events as mockMQTTEvents, mockMQTTPublishAsync} from "../mocks/mqtt";
@@ -5,9 +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 {Controller} from "../../lib/controller";
 import Availability from "../../lib/extension/availability";
 import * as settings from "../../lib/util/settings";
@@ -282,9 +282,7 @@ describe("Extension: Availability", () => {
    });

    it("Should retrieve device state when it reconnects", async () => {
-        // @ts-expect-error private
        const device = controller.zigbee.resolveEntity(devices.bulb_color.ieeeAddr);
-        // @ts-expect-error private
        controller.state.set(device, {state: "OFF"});

        const endpoint = devices.bulb_color.getEndpoint(1);
@@ -1,3 +1,5 @@
+// biome-ignore assist/source/organizeImports: import mocks first
+import {afterAll, beforeAll, beforeEach, describe, expect, it, vi} from "vitest";
 import * as data from "../mocks/data";
 import {mockDebounce} from "../mocks/debounce";
 import {mockLogger} from "../mocks/logger";
@@ -6,10 +8,10 @@ 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 {Controller} from "../../lib/controller";
 import Bind from "../../lib/extension/bind";
 import * as settings from "../../lib/util/settings";
+import {DEFAULT_BIND_GROUP_ID} from "../../lib/util/utils";

 const mocksClear = [
    mockDebounce,
@@ -648,9 +650,9 @@ describe("Extension: Bind", () => {
        mockMQTTEvents.message("zigbee2mqtt/bridge/request/device/unbind", stringify({from: "remote", to: target}));
        await flushPromises();
        expect(endpoint.unbind).toHaveBeenCalledTimes(3);
-        expect(endpoint.unbind).toHaveBeenCalledWith("genOnOff", 901);
-        expect(endpoint.unbind).toHaveBeenCalledWith("genLevelCtrl", 901);
-        expect(endpoint.unbind).toHaveBeenCalledWith("genScenes", 901);
+        expect(endpoint.unbind).toHaveBeenCalledWith("genOnOff", DEFAULT_BIND_GROUP_ID);
+        expect(endpoint.unbind).toHaveBeenCalledWith("genLevelCtrl", DEFAULT_BIND_GROUP_ID);
+        expect(endpoint.unbind).toHaveBeenCalledWith("genScenes", DEFAULT_BIND_GROUP_ID);
        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
            "zigbee2mqtt/bridge/response/device/unbind",
            stringify({
@@ -1,3 +1,5 @@
+// biome-ignore assist/source/organizeImports: import mocks first
+import {afterAll, beforeAll, beforeEach, describe, expect, it, vi} from "vitest";
 import * as data from "../mocks/data";
 import {mockJSZipFile, mockJSZipGenerateAsync} from "../mocks/jszip";
 import {mockLogger} from "../mocks/logger";
@@ -5,18 +7,16 @@ import {events as mockMQTTEvents, mockMQTTPublishAsync} from "../mocks/mqtt";
 import {flushPromises} from "../mocks/utils";
 import {CUSTOM_CLUSTERS, devices, groups, mockController as mockZHController, events as mockZHEvents, returnDevices} from "../mocks/zigbeeHerdsman";

-import type {Mock} from "vitest";
-
 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 type {Mock} from "vitest";
 import {Controller} from "../../lib/controller";
 import Bridge from "../../lib/extension/bridge";
 import * as settings from "../../lib/util/settings";
-import utils from "../../lib/util/utils";
+import utils, {DEFAULT_BIND_GROUP_ID} from "../../lib/util/utils";

 returnDevices.push(devices.coordinator.ieeeAddr);
 returnDevices.push(devices.bulb.ieeeAddr);
@@ -41,6 +41,19 @@ const mocksClear = [

 const deviceIconsDir = path.join(data.mockDir, "device_icons");

+vi.mock("node:os", async (importOriginal) => ({
+    ...(await importOriginal()),
+    version: vi.fn(() => "Linux"),
+    release: vi.fn(() => "0.0.1"),
+    arch: vi.fn(() => "x64"),
+    cpus: vi.fn(() => [{model: "Intel Core i7-9999"}]),
+    totalmem: vi.fn(() => 10485760),
+}));
+vi.mock("node:process", async (importOriginal) => ({
+    ...(await importOriginal()),
+    version: "v1.2.3",
+}));
+
 describe("Extension: Bridge", () => {
    let controller: Controller;
    let mockRestart: Mock;
@@ -94,12 +107,16 @@ describe("Extension: Bridge", () => {
        const zhVersion = await utils.getDependencyVersion("zigbee-herdsman");
        const zhcVersion = await utils.getDependencyVersion("zigbee-herdsman-converters");
        const directory = settings.get().advanced.log_directory;
-        // console.log(mockMQTTPublishAsync.mock.calls.find((c) => c[0] === 'zigbee2mqtt/bridge/info')![1]);
+        // console.log(mockMQTTPublishAsync.mock.calls.find((c) => c[0] === "zigbee2mqtt/bridge/info")![1]);
        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
            "zigbee2mqtt/bridge/info",
            stringify({
                commit: version.commitHash,
                config: {
+                    health: {
+                        interval: 10,
+                        reset_on_check: false,
+                    },
                    advanced: {
                        adapter_concurrent: undefined,
                        adapter_delay: undefined,
@@ -294,6 +311,9 @@ describe("Extension: Bridge", () => {
                        force_disable_retain: false,
                        include_device_information: false,
                        maximum_packet_size: 1048576,
+                        keepalive: 60,
+                        reject_unauthorized: true,
+                        version: 4,
                        server: "mqtt://localhost",
                    },
                    ota: {
@@ -315,6 +335,16 @@ describe("Extension: Bridge", () => {
                version: version.version,
                zigbee_herdsman: zhVersion,
                zigbee_herdsman_converters: zhcVersion,
+                os: {
+                    version: "Linux - 0.0.1 - x64",
+                    node_version: "v1.2.3",
+                    cpus: "Intel Core i7-9999 (x1)",
+                    memory_mb: 10,
+                },
+                mqtt: {
+                    server: "mqtt://localhost:1883",
+                    version: 5,
+                },
            }),
            {retain: true},
        );
@@ -322,7 +352,7 @@ describe("Extension: Bridge", () => {

    it("Should publish devices on startup", async () => {
        await resetExtension();
-        // console.log(mockMQTTPublishAsync.mock.calls.find((c) => c[0] === 'zigbee2mqtt/bridge/devices')[1]);
+        // console.log(mockMQTTPublishAsync.mock.calls.find((c) => c[0] === "zigbee2mqtt/bridge/devices")[1]);
        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
            "zigbee2mqtt/bridge/devices",
            stringify([
@@ -340,6 +370,7 @@ describe("Extension: Bridge", () => {
                },
                {
                    definition: {
+                        source: "native",
                        description: "TRADFRI bulb E26/E27, white spectrum, globe, opal, 980 lm",
                        exposes: [
                            {
@@ -597,6 +628,7 @@ describe("Extension: Bridge", () => {
                {
                    date_code: "2019.09",
                    definition: {
+                        source: "native",
                        description: "Hue Go",
                        exposes: [
                            {
@@ -792,6 +824,7 @@ describe("Extension: Bridge", () => {
                },
                {
                    definition: {
+                        source: "native",
                        description: "Hue dimmer switch",
                        exposes: [
                            {
@@ -895,6 +928,7 @@ describe("Extension: Bridge", () => {
                    disabled: false,
                    endpoints: {
                        "1": {
+                            name: "ep1",
                            bindings: [
                                {cluster: "genLevelCtrl", target: {endpoint: 1, ieee_address: "0x000b57fffec6a5b3", type: "endpoint"}},
                                {cluster: "genOnOff", target: {endpoint: 1, ieee_address: "0x000b57fffec6a5b3", type: "endpoint"}},
@@ -906,7 +940,13 @@ describe("Extension: Bridge", () => {
                            configured_reportings: [],
                            scenes: [],
                        },
-                        "2": {bindings: [], clusters: {input: ["genBasic"], output: ["genOta", "genOnOff"]}, configured_reportings: [], scenes: []},
+                        "2": {
+                            name: "ep2",
+                            bindings: [],
+                            clusters: {input: ["genBasic"], output: ["genOta", "genOnOff"]},
+                            configured_reportings: [],
+                            scenes: [],
+                        },
                    },
                    friendly_name: "remote",
                    ieee_address: "0x0017880104e45517",
@@ -921,6 +961,7 @@ describe("Extension: Bridge", () => {
                },
                {
                    definition: {
+                        source: "generated",
                        description: "Automatically generated definition",
                        exposes: [
                            {
@@ -1015,6 +1056,7 @@ describe("Extension: Bridge", () => {
                },
                {
                    definition: {
+                        source: "native",
                        description: "Wireless mini switch",
                        exposes: [
                            {
@@ -1090,6 +1132,7 @@ describe("Extension: Bridge", () => {
                                name: "device_temperature_calibration",
                                property: "device_temperature_calibration",
                                type: "numeric",
+                                value_step: 0.1,
                            },
                        ],
                        supports_ota: false,
@@ -1125,6 +1168,7 @@ describe("Extension: Bridge", () => {
                },
                {
                    definition: {
+                        source: "native",
                        description: "Temperature and humidity sensor",
                        exposes: [
                            {
@@ -1198,6 +1242,7 @@ describe("Extension: Bridge", () => {
                                name: "temperature_calibration",
                                property: "temperature_calibration",
                                type: "numeric",
+                                value_step: 0.1,
                            },
                            {
                                access: 2,
@@ -1217,6 +1262,7 @@ describe("Extension: Bridge", () => {
                                name: "humidity_calibration",
                                property: "humidity_calibration",
                                type: "numeric",
+                                value_step: 0.1,
                            },
                            {
                                access: 2,
@@ -1236,6 +1282,7 @@ describe("Extension: Bridge", () => {
                                name: "pressure_calibration",
                                property: "pressure_calibration",
                                type: "numeric",
+                                value_step: 0.1,
                            },
                            {
                                access: 2,
@@ -1267,6 +1314,7 @@ describe("Extension: Bridge", () => {
                },
                {
                    definition: {
+                        source: "native",
                        description: "Mi smart plug",
                        exposes: [
                            {
@@ -1346,6 +1394,7 @@ describe("Extension: Bridge", () => {
                                name: "power_calibration",
                                property: "power_calibration",
                                type: "numeric",
+                                value_step: 0.1,
                            },
                            {
                                access: 2,
@@ -1365,6 +1414,7 @@ describe("Extension: Bridge", () => {
                                name: "energy_calibration",
                                property: "energy_calibration",
                                type: "numeric",
+                                value_step: 0.1,
                            },
                            {
                                access: 2,
@@ -1384,6 +1434,7 @@ describe("Extension: Bridge", () => {
                                name: "device_temperature_calibration",
                                property: "device_temperature_calibration",
                                type: "numeric",
+                                value_step: 0.1,
                            },
                            {
                                access: 2,
@@ -1414,6 +1465,7 @@ describe("Extension: Bridge", () => {
                },
                {
                    definition: {
+                        source: "native",
                        description: "zigfred plus smart in-wall switch",
                        exposes: [
                            {
@@ -1859,42 +1911,49 @@ describe("Extension: Bridge", () => {
                    disabled: false,
                    endpoints: {
                        "10": {
+                            name: "l5",
                            bindings: [],
                            clusters: {input: ["genBasic", "genScenes", "genOnOff", "genLevelCtrl"], output: []},
                            configured_reportings: [],
                            scenes: [],
                        },
                        "11": {
+                            name: "l6",
                            bindings: [],
                            clusters: {input: ["genBasic", "genScenes", "closuresWindowCovering"], output: []},
                            configured_reportings: [],
                            scenes: [],
                        },
                        "12": {
+                            name: "l7",
                            bindings: [],
                            clusters: {input: ["genBasic", "genScenes", "closuresWindowCovering"], output: []},
                            configured_reportings: [],
                            scenes: [],
                        },
                        "5": {
+                            name: "l1",
                            bindings: [],
                            clusters: {input: ["genBasic", "genScenes", "genOnOff", "genLevelCtrl", "lightingColorCtrl"], output: []},
                            configured_reportings: [],
                            scenes: [],
                        },
                        "7": {
+                            name: "l2",
                            bindings: [],
                            clusters: {input: ["genBasic", "genScenes", "genOnOff", "genLevelCtrl"], output: []},
                            configured_reportings: [],
                            scenes: [],
                        },
                        "8": {
+                            name: "l3",
                            bindings: [],
                            clusters: {input: ["genBasic", "genScenes", "genOnOff", "genLevelCtrl"], output: []},
                            configured_reportings: [],
                            scenes: [],
                        },
                        "9": {
+                            name: "l4",
                            bindings: [],
                            clusters: {input: ["genBasic", "genScenes", "genOnOff", "genLevelCtrl"], output: []},
                            configured_reportings: [],
@@ -1915,6 +1974,7 @@ describe("Extension: Bridge", () => {
                },
                {
                    definition: {
+                        source: "native",
                        description: "TRADFRI bulb E26/E27, white spectrum, globe, opal, 980 lm",
                        exposes: [
                            {
@@ -2260,7 +2320,7 @@ describe("Extension: Bridge", () => {
                    scenes: [],
                },
                {friendly_name: "gledopto_group", id: 21, members: [{endpoint: 15, ieee_address: "0x0017880104e45724"}], scenes: []},
-                {friendly_name: "default_bind_group", id: 901, members: [], scenes: []},
+                {friendly_name: "default_bind_group", id: DEFAULT_BIND_GROUP_ID, members: [], scenes: []},
                {
                    friendly_name: "ha_discovery_group",
                    id: 9,
@@ -2349,6 +2409,7 @@ describe("Extension: Bridge", () => {
            stringify({
                data: {
                    definition: {
+                        source: "native",
                        description: "TRADFRI bulb E26/E27, white spectrum, globe, opal, 980 lm",
                        exposes: [
                            {
@@ -2584,6 +2645,7 @@ describe("Extension: Bridge", () => {
            stringify({
                data: {
                    definition: {
+                        source: "generated",
                        description: "Automatically generated definition",
                        exposes: [
                            {
@@ -3119,7 +3181,6 @@ describe("Extension: Bridge", () => {
    });

    it("Should allow interviewing a device by ieeeAddr", async () => {
-        // @ts-expect-error private
        const device = controller.zigbee.resolveEntity(devices.bulb)!;
        assert("resolveDefinition" in device);
        device.resolveDefinition = vi.fn();
@@ -3781,6 +3842,11 @@ describe("Extension: Bridge", () => {
        fs.writeFileSync(path.join(data.mockDir, "log", "log.log"), "test123");
        fs.mkdirSync(path.join(data.mockDir, "ext_converters", "123"));
        fs.writeFileSync(path.join(data.mockDir, "ext_converters", "123", "myfile.js"), "test123");
+        fs.symlinkSync(
+            path.join(data.mockDir, "ext_converters"),
+            path.join(data.mockDir, "ext_converters_sym"),
+            platform() === "win32" ? "junction" : "dir",
+        );
        mockMQTTPublishAsync.mockClear();
        mockMQTTEvents.message("zigbee2mqtt/bridge/request/backup", "");
        await flushPromises();
@@ -3939,7 +4005,7 @@ describe("Extension: Bridge", () => {
        );
    });

-    it("Icon link handling", async () => {
+    it("Icon link handling", () => {
        const bridge = controller.getExtension("Bridge")! as Bridge;
        expect(bridge).toBeDefined();

@@ -3970,14 +4036,14 @@ describe("Extension: Bridge", () => {
        expect(payload.icon).not.toBeUndefined();
        expect(payload.icon).toBe(svg_icon);

-        definition.icon = "_${model}_";
+        definition.icon = "_$model_";
        // @ts-expect-error bare minimum mock
        payload = bridge.getDefinitionPayload({...device, zh: device, definition, exposes: () => definition.exposes, options: {}});
        assert(payload);
        expect(payload.icon).not.toBeUndefined();
        expect(payload.icon).toBe("_lumi.plug_");

-        definition.icon = "_${model}_${zigbeeModel}_";
+        definition.icon = "_$model_$zigbeeModel_";
        // @ts-expect-error bare minimum mock
        payload = bridge.getDefinitionPayload({...device, zh: device, definition, exposes: () => definition.exposes, options: {}});
        assert(payload);
@@ -3993,7 +4059,7 @@ describe("Extension: Bridge", () => {

        device.modelID = "?._Z\\NC+Z02*LM";
        definition.model = "&&&&*+";
-        definition.icon = "_${model}_${zigbeeModel}_";
+        definition.icon = "_$model_$zigbeeModel_";
        // @ts-expect-error bare minimum mock
        payload = bridge.getDefinitionPayload({...device, zh: device, definition, exposes: () => definition.exposes, options: {}});
        assert(payload);
@@ -1,13 +1,13 @@
+// biome-ignore assist/source/organizeImports: import mocks first
+import {afterAll, beforeAll, beforeEach, describe, expect, it, vi} from "vitest";
 import * as data from "../mocks/data";
 import {mockLogger} from "../mocks/logger";
 import {events as mockMQTTEvents, mockMQTTPublishAsync} from "../mocks/mqtt";
 import {flushPromises} from "../mocks/utils";
-import {type Device, type Endpoint, devices, events as mockZHEvents} from "../mocks/zigbeeHerdsman";
+import {type Device, devices, type Endpoint, events as mockZHEvents} from "../mocks/zigbeeHerdsman";

 import stringify from "json-stable-stringify-without-jsonify";
-
 import {InterviewState} from "zigbee-herdsman/dist/controller/model/device";
-
 import {Controller} from "../../lib/controller";
 import Configure from "../../lib/extension/configure";
 import * as settings from "../../lib/util/settings";
@@ -121,11 +121,9 @@ describe("Extension: Configure", () => {

    it("Should reconfigure reporting on reconfigure event", async () => {
        expectBulbConfigured();
-        // @ts-expect-error private
        const device = controller.zigbee.resolveEntity(devices.bulb)!;
        mockClear(device.zh);
        expectBulbNotConfigured();
-        // @ts-expect-error private
        controller.eventBus.emitReconfigure({device});
        await flushPromises();
        expectBulbConfigured();
@@ -1,21 +1,19 @@
+// biome-ignore assist/source/organizeImports: import mocks first
+import {afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi} from "vitest";
 import * as data from "../mocks/data";
 import {mockLogger} from "../mocks/logger";
 import {mockMQTTEndAsync, mockMQTTPublishAsync} from "../mocks/mqtt";
 import {flushPromises} from "../mocks/utils";
-import {devices, mockController as mockZHController, returnDevices} from "../mocks/zigbeeHerdsman";
-
-import type Device from "../../lib/model/device";
 import type {Device as ZhDevice} from "../mocks/zigbeeHerdsman";
+import {devices, mockController as mockZHController, returnDevices} from "../mocks/zigbeeHerdsman";

 import fs from "node:fs";
 import path from "node:path";
-
 import stringify from "json-stable-stringify-without-jsonify";
-
 import * as zhc from "zigbee-herdsman-converters";
-
 import {Controller} from "../../lib/controller";
 import ExternalConverters from "../../lib/extension/externalConverters";
+import type Device from "../../lib/model/device";
 import * as settings from "../../lib/util/settings";

 const BASE_DIR = "external_converters";
@@ -52,7 +50,6 @@ describe("Extension: ExternalConverters", () => {
    };

    const getZ2MDevice = (zhDevice: string | number | ZhDevice): Device => {
-        // @ts-expect-error private
        return controller.zigbee.resolveEntity(zhDevice)! as Device;
    };

@@ -75,7 +72,6 @@ describe("Extension: ExternalConverters", () => {

    beforeEach(async () => {
        zhc.removeExternalDefinitions(); // remove all external converters
-        // @ts-expect-error private - clear cached
        await controller.zigbee.resolveDevicesDefinitions(true);
        for (const mock of mocksClear) mock.mockClear();
        data.writeDefaultConfiguration();
@@ -351,6 +347,7 @@ describe("Extension: ExternalConverters", () => {
            );
            expect(fs.existsSync(filepath)).toStrictEqual(false);
            expect(fs.existsSync(path.join(mockBasePath, "invalid.mjs.invalid"))).toStrictEqual(true);
+            expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining("Parse failure: Expected ';', '}' or <eof>"));
        });
    });

@@ -1,3 +1,5 @@
+// biome-ignore assist/source/organizeImports: import mocks first
+import {afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi} from "vitest";
 import * as data from "../mocks/data";
 import {mockLogger} from "../mocks/logger";
 import {mockMQTTEndAsync, mockMQTTPublishAsync} from "../mocks/mqtt";
@@ -6,9 +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 {Controller} from "../../lib/controller";
 import ExternalExtensions from "../../lib/extension/externalExtensions";
 import * as settings from "../../lib/util/settings";
@@ -1,3 +1,5 @@
+// biome-ignore assist/source/organizeImports: import mocks first
+import {afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi} from "vitest";
 import * as data from "../mocks/data";
 import {mockLogger} from "../mocks/logger";
 import {events as mockMQTTEvents, mockMQTTPublishAsync} from "../mocks/mqtt";
@@ -5,11 +7,9 @@ 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 type {Mock} from "vitest";
 import ws from "ws";
-
 import {Controller} from "../../lib/controller";
 import * as settings from "../../lib/util/settings";

@@ -23,7 +23,6 @@ const mockHTTP = {
    close: vi.fn<(cb: (err?: Error) => void) => void>((cb) => cb()),
 };

-let mockHTTPSOnRequest: (request: {url: string}, response: number) => void;
 const mockHTTPSEvents: Record<string, EventHandler> = {};
 const mockHTTPS = {
    listen: vi.fn(),
@@ -56,7 +55,7 @@ const mockWS = {
    handleUpgrade: vi.fn().mockImplementation((_request, _socket, _head, cb) => {
        cb(mockWSocket);
    }),
-    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    // biome-ignore lint/suspicious/noExplicitAny: ignore
    emit: vi.fn<(eventName: string, ...args: any[]) => void>(),
    close: vi.fn<(code?: number, data?: string | Buffer) => void>(),
 };
@@ -76,10 +75,7 @@ vi.mock("node:http", () => ({
 }));

 vi.mock("node:https", () => ({
-    createServer: vi.fn().mockImplementation((onRequest) => {
-        mockHTTPSOnRequest = onRequest;
-        return mockHTTPS;
-    }),
+    createServer: vi.fn().mockImplementation(() => mockHTTPS),
    Agent: vi.fn(),
 }));

@@ -491,4 +487,17 @@ describe("Extension: Frontend", () => {

        await vi.waitFor(() => controller.getExtension("Frontend") === undefined);
    });
+
+    it("disables serving", async () => {
+        settings.set(["frontend", "disable_ui_serving"], true);
+        controller = new Controller(vi.fn(), vi.fn());
+        await controller.start();
+
+        expect(mockHTTP.listen).toHaveBeenCalledTimes(0);
+        mockWS.clients.push(mockWSClient);
+        await controller.stop();
+        expect(mockWSClient.terminate).toHaveBeenCalledTimes(1);
+        expect(mockHTTP.close).toHaveBeenCalledTimes(0);
+        expect(mockWS.close).toHaveBeenCalledTimes(1);
+    });
 });
@@ -1,3 +1,5 @@
+// biome-ignore assist/source/organizeImports: import mocks first
+import {afterAll, beforeAll, beforeEach, describe, expect, it, vi} from "vitest";
 import * as data from "../mocks/data";
 import {mockLogger} from "../mocks/logger";
 import {events as mockMQTTEvents, mockMQTTPublishAsync} from "../mocks/mqtt";
@@ -5,9 +7,7 @@ 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 * as zhcGlobalStore from "zigbee-herdsman-converters/lib/store";
-
 import {Controller} from "../../lib/controller";
 import * as settings from "../../lib/util/settings";

@@ -45,7 +45,6 @@ describe("Extension: Groups", () => {
        mockMQTTPublishAsync.mockClear();
        groups.gledopto_group.command.mockClear();
        zhcGlobalStore.clear();
-        // @ts-expect-error private
        controller.state.clear();
    });

@@ -460,7 +459,6 @@ describe("Extension: Groups", () => {
        await mockMQTTEvents.message("zigbee2mqtt/group_1/set", stringify({state: "ON"}));
        await flushPromises();
        mockMQTTPublishAsync.mockClear();
-        // @ts-expect-error private
        controller.state.clear();

        await mockMQTTEvents.message("zigbee2mqtt/bulb_color/set", stringify({state: "OFF"}));
@@ -507,7 +505,7 @@ describe("Extension: Groups", () => {
        expect(mockMQTTPublishAsync).not.toHaveBeenCalledWith("zigbee2mqtt/bridge/groups", expect.any(String), expect.any(Object));
        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
            "zigbee2mqtt/bridge/response/group/members/add",
-            stringify({data: {}, status: "error", error: "Failed to add from group (timeout)"}),
+            stringify({data: {}, status: "error", error: "Failed to add to group (timeout)"}),
            {},
        );
    });
@@ -592,6 +590,26 @@ describe("Extension: Groups", () => {
        );
    });

+    it("Remove from group via MQTT fails", async () => {
+        const device = devices.bulb_color;
+        const endpoint = device.getEndpoint(1)!;
+        const group = groups.group_1;
+        group.members.push(endpoint);
+        endpoint.removeFromGroup.mockImplementationOnce(() => {
+            throw new Error("timeout");
+        });
+        mockMQTTPublishAsync.mockClear();
+        mockMQTTEvents.message("zigbee2mqtt/bridge/request/group/members/remove", stringify({group: "group_1", device: "bulb_color"}));
+        await flushPromises();
+        expect(group.members.length).toStrictEqual(1);
+        expect(mockMQTTPublishAsync).not.toHaveBeenCalledWith("zigbee2mqtt/bridge/groups", expect.any(String), expect.any(Object));
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(
+            "zigbee2mqtt/bridge/response/group/members/remove",
+            stringify({data: {}, status: "error", error: "Failed to remove from group (timeout)"}),
+            {},
+        );
+    });
+
    it("Remove from group via MQTT keeping device reporting", async () => {
        const device = devices.bulb_color;
        const endpoint = device.getEndpoint(1)!;
@@ -0,0 +1,315 @@
+// biome-ignore assist/source/organizeImports: import mocks first
+import {afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi} from "vitest";
+import * as data from "../mocks/data";
+import {mockLogger} from "../mocks/logger";
+import {events as mockMQTTEvents, mockMQTTPublishAsync} from "../mocks/mqtt";
+import {flushPromises} from "../mocks/utils";
+import {devices, events as mockZHEvents, returnDevices} from "../mocks/zigbeeHerdsman";
+
+import {Controller} from "../../lib/controller";
+import Health from "../../lib/extension/health";
+import * as settings from "../../lib/util/settings";
+import {minutes, seconds} from "../../lib/util/utils";
+
+const mocksClear = [mockMQTTPublishAsync, mockLogger.warning, mockLogger.info];
+
+returnDevices.push(devices.bulb_color.ieeeAddr, devices.bulb_color_2.ieeeAddr, devices.coordinator.ieeeAddr);
+
+describe("Extension: Health", () => {
+    let controller: Controller;
+
+    const getExtension = (): Health => controller.getExtension("Health") as Health;
+
+    const resetExtension = async (): Promise<void> => {
+        await controller.removeExtension(getExtension());
+        await controller.addExtension(new Health(...controller.extensionArgs));
+    };
+
+    beforeAll(async () => {
+        vi.useFakeTimers();
+        settings.reRead();
+
+        controller = new Controller(vi.fn(), vi.fn());
+
+        await controller.start();
+        await flushPromises();
+    });
+
+    beforeEach(() => {
+        data.writeDefaultConfiguration();
+        settings.reRead();
+        settings.set(["devices", devices.bulb_color_2.ieeeAddr, "health"], false);
+
+        for (const mock of mocksClear) {
+            mock.mockClear();
+        }
+
+        getExtension().clearStats();
+    });
+
+    afterEach(async () => {});
+
+    afterAll(async () => {
+        await controller?.stop();
+        await flushPromises();
+        vi.useRealTimers();
+    });
+
+    it("checks health at default interval", async () => {
+        await resetExtension();
+        await mockZHEvents.lastSeenChanged({device: devices.bulb_color});
+        await mockZHEvents.lastSeenChanged({device: devices.bulb_color_2});
+        await mockZHEvents.deviceLeave({ieeeAddr: devices.bulb_color.ieeeAddr});
+        await mockZHEvents.deviceJoined({device: devices.bulb_color});
+        await mockZHEvents.deviceNetworkAddressChanged({device: devices.bulb_color});
+        await vi.advanceTimersByTimeAsync(seconds(1));
+        await mockZHEvents.lastSeenChanged({device: devices.bulb_color});
+        await vi.advanceTimersByTimeAsync(seconds(1));
+        await mockZHEvents.lastSeenChanged({device: devices.bulb_color});
+        await vi.advanceTimersByTimeAsync(seconds(1));
+        await mockZHEvents.lastSeenChanged({device: devices.bulb_color});
+        await mockMQTTEvents.message("zigbee2mqtt/mock", "mocked");
+        await vi.advanceTimersByTimeAsync(minutes(11));
+
+        let calls = mockMQTTPublishAsync.mock.calls.filter((call) => call[0] === "zigbee2mqtt/bridge/health");
+
+        expect(calls.length).toStrictEqual(1);
+        expect(JSON.parse(calls[0][1])).toStrictEqual({
+            response_time: expect.any(Number),
+            os: {
+                load_average: [expect.any(Number), expect.any(Number), expect.any(Number)],
+                memory_used_mb: expect.any(Number),
+                memory_percent: expect.any(Number),
+            },
+            process: {uptime_sec: expect.any(Number), memory_used_mb: expect.any(Number), memory_percent: expect.any(Number)},
+            mqtt: {
+                connected: true,
+                queued: 0,
+                published: expect.any(Number),
+                received: 1,
+            },
+            devices: {
+                [devices.bulb_color.ieeeAddr]: {
+                    leave_count: 1,
+                    messages: 4,
+                    messages_per_sec: 0.0067,
+                    network_address_changes: 1,
+                },
+                [devices.bulb_color_2.ieeeAddr]: {
+                    leave_count: 0,
+                    messages: 1,
+                    messages_per_sec: 0.0017,
+                    network_address_changes: 0,
+                },
+            },
+        });
+        expect(calls[0][2]).toStrictEqual({retain: true, qos: 1});
+
+        mockMQTTPublishAsync.mockClear();
+        await mockMQTTEvents.message("zigbee2mqtt/mock2", "mocked2");
+        await vi.advanceTimersByTimeAsync(minutes(11));
+
+        calls = mockMQTTPublishAsync.mock.calls.filter((call) => call[0] === "zigbee2mqtt/bridge/health");
+
+        expect(calls.length).toStrictEqual(1);
+        expect(JSON.parse(calls[0][1])).toStrictEqual({
+            response_time: expect.any(Number),
+            os: {
+                load_average: [expect.any(Number), expect.any(Number), expect.any(Number)],
+                memory_used_mb: expect.any(Number),
+                memory_percent: expect.any(Number),
+            },
+            process: {uptime_sec: expect.any(Number), memory_used_mb: expect.any(Number), memory_percent: expect.any(Number)},
+            mqtt: {
+                connected: true,
+                queued: 0,
+                published: expect.any(Number),
+                received: 2,
+            },
+            devices: {
+                [devices.bulb_color.ieeeAddr]: {
+                    leave_count: 1,
+                    messages: 4,
+                    messages_per_sec: 0.0033,
+                    network_address_changes: 1,
+                },
+                [devices.bulb_color_2.ieeeAddr]: {
+                    leave_count: 0,
+                    messages: 1,
+                    messages_per_sec: 0.0008,
+                    network_address_changes: 0,
+                },
+            },
+        });
+        expect(calls[0][2]).toStrictEqual({retain: true, qos: 1});
+    });
+
+    it("checks health at given interval", async () => {
+        settings.set(["health", "interval"], 20);
+        await resetExtension();
+        await vi.advanceTimersByTimeAsync(minutes(11));
+
+        let calls = mockMQTTPublishAsync.mock.calls.filter((call) => call[0] === "zigbee2mqtt/bridge/health");
+
+        expect(calls.length).toStrictEqual(0);
+
+        await vi.advanceTimersByTimeAsync(minutes(10));
+
+        calls = mockMQTTPublishAsync.mock.calls.filter((call) => call[0] === "zigbee2mqtt/bridge/health");
+
+        expect(calls.length).toStrictEqual(1);
+        expect(JSON.parse(calls[0][1])).toStrictEqual({
+            response_time: expect.any(Number),
+            os: {
+                load_average: [expect.any(Number), expect.any(Number), expect.any(Number)],
+                memory_used_mb: expect.any(Number),
+                memory_percent: expect.any(Number),
+            },
+            process: {uptime_sec: expect.any(Number), memory_used_mb: expect.any(Number), memory_percent: expect.any(Number)},
+            mqtt: {
+                connected: true,
+                queued: 0,
+                published: expect.any(Number),
+                received: 0,
+            },
+            devices: {},
+        });
+        expect(calls[0][2]).toStrictEqual({retain: true, qos: 1});
+    });
+
+    it("init device health from leave", async () => {
+        await resetExtension();
+        await mockZHEvents.deviceLeave({ieeeAddr: devices.bulb_color.ieeeAddr});
+        await mockZHEvents.deviceJoined({device: devices.bulb_color});
+        await vi.advanceTimersByTimeAsync(minutes(11));
+
+        const calls = mockMQTTPublishAsync.mock.calls.filter((call) => call[0] === "zigbee2mqtt/bridge/health");
+
+        expect(calls.length).toStrictEqual(1);
+        expect(JSON.parse(calls[0][1])).toStrictEqual({
+            response_time: expect.any(Number),
+            os: {
+                load_average: [expect.any(Number), expect.any(Number), expect.any(Number)],
+                memory_used_mb: expect.any(Number),
+                memory_percent: expect.any(Number),
+            },
+            process: {uptime_sec: expect.any(Number), memory_used_mb: expect.any(Number), memory_percent: expect.any(Number)},
+            mqtt: {
+                connected: true,
+                queued: 0,
+                published: expect.any(Number),
+                received: 0,
+            },
+            devices: {
+                [devices.bulb_color.ieeeAddr]: {
+                    leave_count: 1,
+                    messages: 0,
+                    messages_per_sec: 0,
+                    network_address_changes: 0,
+                },
+            },
+        });
+        expect(calls[0][2]).toStrictEqual({retain: true, qos: 1});
+    });
+
+    it("init device health from network address change", async () => {
+        await resetExtension();
+        await mockZHEvents.deviceNetworkAddressChanged({device: devices.bulb_color});
+        await vi.advanceTimersByTimeAsync(minutes(11));
+
+        const calls = mockMQTTPublishAsync.mock.calls.filter((call) => call[0] === "zigbee2mqtt/bridge/health");
+
+        expect(calls.length).toStrictEqual(1);
+        expect(JSON.parse(calls[0][1])).toStrictEqual({
+            response_time: expect.any(Number),
+            os: {
+                load_average: [expect.any(Number), expect.any(Number), expect.any(Number)],
+                memory_used_mb: expect.any(Number),
+                memory_percent: expect.any(Number),
+            },
+            process: {uptime_sec: expect.any(Number), memory_used_mb: expect.any(Number), memory_percent: expect.any(Number)},
+            mqtt: {
+                connected: true,
+                queued: 0,
+                published: expect.any(Number),
+                received: 0,
+            },
+            devices: {
+                [devices.bulb_color.ieeeAddr]: {
+                    leave_count: 0,
+                    messages: 0,
+                    messages_per_sec: 0,
+                    network_address_changes: 1,
+                },
+            },
+        });
+        expect(calls[0][2]).toStrictEqual({retain: true, qos: 1});
+    });
+
+    it("checks health then resets possible stats", async () => {
+        settings.set(["health", "reset_on_check"], true);
+        await resetExtension();
+        await mockZHEvents.lastSeenChanged({device: devices.bulb_color});
+        await mockZHEvents.lastSeenChanged({device: devices.bulb_color}); // coverage no time diff first/last
+        await mockZHEvents.lastSeenChanged({device: devices.bulb_color_2});
+        await vi.advanceTimersByTimeAsync(minutes(11));
+
+        let calls = mockMQTTPublishAsync.mock.calls.filter((call) => call[0] === "zigbee2mqtt/bridge/health");
+
+        expect(calls.length).toStrictEqual(1);
+        expect(JSON.parse(calls[0][1])).toStrictEqual({
+            response_time: expect.any(Number),
+            os: {
+                load_average: [expect.any(Number), expect.any(Number), expect.any(Number)],
+                memory_used_mb: expect.any(Number),
+                memory_percent: expect.any(Number),
+            },
+            process: {uptime_sec: expect.any(Number), memory_used_mb: expect.any(Number), memory_percent: expect.any(Number)},
+            mqtt: {
+                connected: true,
+                queued: 0,
+                published: expect.any(Number),
+                received: 0,
+            },
+            devices: {
+                [devices.bulb_color.ieeeAddr]: {
+                    leave_count: 0,
+                    messages: 2,
+                    messages_per_sec: 0.0033,
+                    network_address_changes: 0,
+                },
+                [devices.bulb_color_2.ieeeAddr]: {
+                    leave_count: 0,
+                    messages: 1,
+                    messages_per_sec: 0.0017,
+                    network_address_changes: 0,
+                },
+            },
+        });
+        expect(calls[0][2]).toStrictEqual({retain: true, qos: 1});
+
+        mockMQTTPublishAsync.mockClear();
+        await vi.advanceTimersByTimeAsync(minutes(11));
+
+        calls = mockMQTTPublishAsync.mock.calls.filter((call) => call[0] === "zigbee2mqtt/bridge/health");
+
+        expect(calls.length).toStrictEqual(1);
+        expect(JSON.parse(calls[0][1])).toStrictEqual({
+            response_time: expect.any(Number),
+            os: {
+                load_average: [expect.any(Number), expect.any(Number), expect.any(Number)],
+                memory_used_mb: expect.any(Number),
+                memory_percent: expect.any(Number),
+            },
+            process: {uptime_sec: expect.any(Number), memory_used_mb: expect.any(Number), memory_percent: expect.any(Number)},
+            mqtt: {
+                connected: true,
+                queued: 0,
+                published: expect.any(Number),
+                received: 0,
+            },
+            devices: {},
+        });
+        expect(calls[0][2]).toStrictEqual({retain: true, qos: 1});
+    });
+});
@@ -1,25 +1,23 @@
+// biome-ignore assist/source/organizeImports: import mocks first
+import {afterAll, beforeAll, beforeEach, describe, expect, it, test, vi} from "vitest";
 import * as data from "../mocks/data";
 import {mockLogger} from "../mocks/logger";
 import {events as mockMQTTEvents, mockMQTTPublishAsync, mockMQTTSubscribeAsync, mockMQTTUnsubscribeAsync} from "../mocks/mqtt";
 import * as mockSleep from "../mocks/sleep";
 import {flushPromises, getZhcBaseDefinitions} from "../mocks/utils";
+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 type {MockInstance} from "vitest";
+import * as zhc from "zigbee-herdsman-converters";
+import type {KeyValueAny} from "zigbee-herdsman-converters/lib/types";
+import {Controller} from "../../lib/controller";
+import HomeAssistant from "../../lib/extension/homeassistant";

 import type Device from "../../lib/model/device";
 import type Group from "../../lib/model/group";
-import type {Device as ZhDevice} from "../mocks/zigbeeHerdsman";
-
-import assert from "node:assert";
-
-import stringify from "json-stable-stringify-without-jsonify";
-
-import * as zhc from "zigbee-herdsman-converters";
-import type {KeyValueAny} from "zigbee-herdsman-converters/lib/types";
-
-import {Controller} from "../../lib/controller";
-import HomeAssistant from "../../lib/extension/homeassistant";
 import * as settings from "../../lib/util/settings";

 const mocksClear = [mockMQTTPublishAsync, mockLogger.debug, mockLogger.warning, mockLogger.error];
@@ -58,7 +56,6 @@ describe("Extension: HomeAssistant", () => {
    };

    const getZ2MEntity = (zhDeviceOrGroup: string | number | ZhDevice): Device | Group => {
-        // @ts-expect-error private
        return controller.zigbee.resolveEntity(zhDeviceOrGroup)!;
    };

@@ -101,7 +98,7 @@ describe("Extension: HomeAssistant", () => {

        for (const baseDefinition of await getZhcBaseDefinitions()) {
            const d = zhc.prepareDefinition(baseDefinition);
-            const exposes = typeof d.exposes === "function" ? d.exposes(undefined, undefined) : d.exposes;
+            const exposes = typeof d.exposes === "function" ? d.exposes({isDummyDevice: true}, {}) : d.exposes;
            const device = {
                definition: d,
                isDevice: (): boolean => true,
@@ -921,7 +918,7 @@ describe("Extension: HomeAssistant", () => {
        });
    });

-    it("Should discover devices with speed-controlled fan", async () => {
+    it("Should discover devices with speed-controlled fan", () => {
        const payload = {
            state_topic: "zigbee2mqtt/fanbee",
            state_value_template: "{{ value_json.state }}",
@@ -1182,9 +1179,9 @@ describe("Extension: HomeAssistant", () => {
            command_topic: "zigbee2mqtt/0xa4c138018cf95021/left/set",
            device: {
                identifiers: ["zigbee2mqtt_0xa4c138018cf95021"],
-                manufacturer: "Lonsonho",
-                model: "Dual curtain/blind module",
-                model_id: "TS130F_dual",
+                manufacturer: "Girier",
+                model: "Dual smart curtain switch",
+                model_id: "TS130F_GIRIER_DUAL",
                name: "0xa4c138018cf95021",
                via_device: "zigbee2mqtt_bridge_0x00124b00120144ae",
            },
@@ -1212,9 +1209,9 @@ describe("Extension: HomeAssistant", () => {
            command_topic: "zigbee2mqtt/0xa4c138018cf95021/right/set",
            device: {
                identifiers: ["zigbee2mqtt_0xa4c138018cf95021"],
-                manufacturer: "Lonsonho",
-                model: "Dual curtain/blind module",
-                model_id: "TS130F_dual",
+                manufacturer: "Girier",
+                model: "Dual smart curtain switch",
+                model_id: "TS130F_GIRIER_DUAL",
                name: "0xa4c138018cf95021",
                via_device: "zigbee2mqtt_bridge_0x00124b00120144ae",
            },
@@ -1233,6 +1230,8 @@ describe("Extension: HomeAssistant", () => {
            value_template: '{% if "moving" in value_json and value_json.moving %} {{ value_json.moving }} {% else %} STOP {% endif %}',
        };

+        console.log(mockMQTTPublishAsync.mock.calls.find((c) => c[0] === "homeassistant/cover/0xa4c138018cf95021/cover_left/config"));
+
        expect(mockMQTTPublishAsync).toHaveBeenCalledWith("homeassistant/cover/0xa4c138018cf95021/cover_left/config", stringify(payload_left), {
            retain: true,
            qos: 1,
@@ -1467,7 +1466,6 @@ describe("Extension: HomeAssistant", () => {
        assert("ieeeAddr" in device);
        resetDiscoveryPayloads(device.ieeeAddr);
        mockMQTTPublishAsync.mockClear();
-        // @ts-expect-error private
        controller.eventBus.emitEntityOptionsChanged({entity: device, from: {}, to: {test: 123}});
        await flushPromises();
        expect(mockMQTTPublishAsync).toHaveBeenCalledWith(`homeassistant/light/${device.ID}/light/config`, expect.any(String), expect.any(Object));
@@ -1564,7 +1562,8 @@ describe("Extension: HomeAssistant", () => {
        await flushPromises();
        await vi.runOnlyPendingTimersAsync();
        await flushPromises();
-        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(0);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(1);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith("zigbee2mqtt/bridge/health", expect.any(String), expect.any(Object));
    });

    it("Shouldnt send all status when home assistant comes online with different topic", async () => {
@@ -1577,7 +1576,8 @@ describe("Extension: HomeAssistant", () => {
        await flushPromises();
        await vi.runOnlyPendingTimersAsync();
        await flushPromises();
-        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(0);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(1);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith("zigbee2mqtt/bridge/health", expect.any(String), expect.any(Object));
    });

    it("Should discover devices with availability", async () => {
@@ -2385,7 +2385,6 @@ describe("Extension: HomeAssistant", () => {
        resetDiscoveryPayloads(device.ieeeAddr);

        mockMQTTPublishAsync.mockClear();
-        // @ts-expect-error private
        controller.eventBus.emitScenesChanged({entity: device});
        await flushPromises();

@@ -2422,7 +2421,6 @@ describe("Extension: HomeAssistant", () => {
        resetDiscoveryPayloads("9");

        mockMQTTPublishAsync.mockClear();
-        // @ts-expect-error private
        controller.eventBus.emitScenesChanged({entity: group});
        await flushPromises();

@@ -2456,7 +2454,8 @@ describe("Extension: HomeAssistant", () => {
            stringify(payload),
            {retain: true, qos: 1},
        );
-        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(6);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(7);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledWith("zigbee2mqtt/bridge/health", expect.any(String), expect.any(Object));
    });

    it("Should not clear bridge entities unnecessarily", async () => {
@@ -2483,7 +2482,6 @@ describe("Extension: HomeAssistant", () => {
            availability_mode: "all",
        };

-        // @ts-expect-error private
        controller.eventBus.emitMQTTMessage({
            topic: topic,
            message: stringify(payload),
@@ -1,3 +1,5 @@
+// biome-ignore assist/source/organizeImports: import mocks first
+import {afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi} from "vitest";
 import * as data from "../mocks/data";
 import {mockLogger} from "../mocks/logger";
 import {events as mockMQTTEvents, mockMQTTPublishAsync} from "../mocks/mqtt";
@@ -7,9 +9,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 {Controller} from "../../lib/controller";
 import * as settings from "../../lib/util/settings";

@@ -1,19 +1,18 @@
+// biome-ignore assist/source/organizeImports: import mocks first
+import {afterAll, beforeAll, beforeEach, describe, expect, it, vi} from "vitest";
 import * as data from "../mocks/data";
 import {mockLogger} from "../mocks/logger";
 import {mockMQTTPublishAsync} from "../mocks/mqtt";
 import {flushPromises} from "../mocks/utils";
+import type {Device as ZhDevice} from "../mocks/zigbeeHerdsman";
 import {devices, events as mockZHEvents, returnDevices} from "../mocks/zigbeeHerdsman";

 import type {MockInstance} from "vitest";
-import type {OnEvent as DefinitionOnEvent} from "zigbee-herdsman-converters/lib/types";
-
-import type Device from "../../lib/model/device";
-import type {Device as ZhDevice} from "../mocks/zigbeeHerdsman";
-
 import * as zhc from "zigbee-herdsman-converters";
-
+import type {OnEvent as DefinitionOnEvent} from "zigbee-herdsman-converters/lib/types";
 import {Controller} from "../../lib/controller";
 import OnEvent from "../../lib/extension/onEvent";
+import type Device from "../../lib/model/device";
 import * as settings from "../../lib/util/settings";

 const mocksClear = [mockMQTTPublishAsync, mockLogger.warning, mockLogger.debug];
@@ -26,7 +25,6 @@ describe("Extension: OnEvent", () => {
    let deviceOnEventSpy: MockInstance<DefinitionOnEvent>;

    const getZ2MDevice = (zhDevice: string | number | ZhDevice): Device => {
-        // @ts-expect-error private
        return controller.zigbee.resolveEntity(zhDevice)! as Device;
    };

@@ -1,3 +1,5 @@
+// biome-ignore assist/source/organizeImports: import mocks first
+import {afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi} from "vitest";
 import * as data from "../mocks/data";
 import {mockLogger} from "../mocks/logger";
 import {events as mockMQTTEvents, mockMQTTPublishAsync} from "../mocks/mqtt";
@@ -6,11 +8,8 @@ import {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 * as zhc from "zigbee-herdsman-converters";
-
 import {Controller} from "../../lib/controller";
 import OTAUpdate from "../../lib/extension/otaUpdate";
 import * as settings from "../../lib/util/settings";
@@ -69,7 +68,6 @@ describe("Extension: OTAUpdate", () => {
        devices.bulb.mockClear();
        updateSpy.mockClear();
        isUpdateAvailableSpy.mockClear();
-        // @ts-expect-error private
        controller.state.clear();
    });

@@ -749,12 +747,9 @@ describe("Extension: OTAUpdate", () => {
    });

    it("clear update state on startup", async () => {
-        // @ts-expect-error private
        const device = controller.zigbee.resolveEntity(devices.bulb_color.ieeeAddr);
-        // @ts-expect-error private
        controller.state.set(device, {update: {progress: 100, remaining: 10, state: "updating"}});
        await resetExtension();
-        // @ts-expect-error private
        expect(controller.state.get(device)).toStrictEqual({update: {state: "available"}});
    });
 });
@@ -1,3 +1,5 @@
+// biome-ignore assist/source/organizeImports: import mocks first
+import {afterAll, beforeAll, beforeEach, describe, expect, it, vi} from "vitest";
 import * as data from "../mocks/data";
 import {mockLogger} from "../mocks/logger";
 import {events as mockMQTTEvents, mockMQTTPublishAsync} from "../mocks/mqtt";
@@ -6,9 +8,7 @@ import {flushPromises} from "../mocks/utils";
 import {devices, groups, events as mockZHEvents} from "../mocks/zigbeeHerdsman";

 import stringify from "json-stable-stringify-without-jsonify";
-
 import {clearGlobalStore} from "zigbee-herdsman-converters";
-
 import {Controller} from "../../lib/controller";
 import {loadTopicGetSetRegex} from "../../lib/extension/publish";
 import * as settings from "../../lib/util/settings";
@@ -42,7 +42,6 @@ describe("Extension: Publish", () => {

    beforeEach(() => {
        data.writeDefaultConfiguration();
-        // @ts-expect-error private
        controller.state.clear();
        settings.reRead();
        loadTopicGetSetRegex();
@@ -1257,11 +1256,8 @@ describe("Extension: Publish", () => {

    it("Home Assistant: should not set state when color temperature is also set and device is already on", async () => {
        settings.set(["homeassistant"], {enabled: true});
-        // @ts-expect-error private
        const device = controller.zigbee.resolveEntity(devices.bulb_color.ieeeAddr)!;
-        // @ts-expect-error private
        controller.state.remove(devices.bulb_color.ieeeAddr);
-        // @ts-expect-error private
        controller.state.set(device, {state: "ON"});
        const endpoint = device.zh.getEndpoint(1)!;
        const payload = {state: "ON", color_temp: 100};
@@ -1276,11 +1272,8 @@ describe("Extension: Publish", () => {

    it("Home Assistant: should set state when color temperature is also set and device is off", async () => {
        settings.set(["homeassistant"], {enabled: true});
-        // @ts-expect-error private
        const device = controller.zigbee.resolveEntity(devices.bulb_color.ieeeAddr)!;
-        // @ts-expect-error private
        controller.state.remove(devices.bulb_color.ieeeAddr);
-        // @ts-expect-error private
        controller.state.set(device, {state: "OFF"});
        const endpoint = device.zh.getEndpoint(1)!;
        const payload = {state: "ON", color_temp: 100};
@@ -1299,11 +1292,8 @@ describe("Extension: Publish", () => {

    it("Home Assistant: should not set state when color is also set", async () => {
        settings.set(["homeassistant"], {enabled: true});
-        // @ts-expect-error private
        const device = controller.zigbee.resolveEntity(devices.bulb_color.ieeeAddr)!;
-        // @ts-expect-error private
        controller.state.remove(devices.bulb_color.ieeeAddr);
-        // @ts-expect-error private
        controller.state.set(device, {state: "ON"});
        const endpoint = device.zh.getEndpoint(1)!;
        const payload = {state: "ON", color: {x: 0.41, y: 0.25}};
@@ -1,3 +1,5 @@
+// biome-ignore assist/source/organizeImports: import mocks first
+import {afterAll, beforeAll, beforeEach, describe, expect, it, vi} from "vitest";
 import * as data from "../mocks/data";
 import {mockLogger} from "../mocks/logger";
 import {events as mockMQTTEvents, mockMQTTPublishAsync} from "../mocks/mqtt";
@@ -6,7 +8,6 @@ import {flushPromises} from "../mocks/utils";
 import {devices, events as mockZHEvents} from "../mocks/zigbeeHerdsman";

 import stringify from "json-stable-stringify-without-jsonify";
-
 import {Controller} from "../../lib/controller";
 import * as settings from "../../lib/util/settings";

@@ -24,7 +25,6 @@ describe("Extension: Receive", () => {
    });

    beforeEach(() => {
-        // @ts-expect-error private
        controller.state.clear();
        data.writeDefaultConfiguration();
        settings.reRead();
@@ -183,10 +183,11 @@ describe("Extension: Receive", () => {
        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(0);
        vi.runOnlyPendingTimers();
        await flushPromises();
-        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(1);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(2);
        expect(mockMQTTPublishAsync.mock.calls[0][0]).toStrictEqual("zigbee2mqtt/weather_sensor");
        expect(JSON.parse(mockMQTTPublishAsync.mock.calls[0][1])).toStrictEqual({temperature: 0.08, humidity: 0.01, pressure: 2});
        expect(mockMQTTPublishAsync.mock.calls[0][2]).toStrictEqual({qos: 1, retain: false});
+        expect(mockMQTTPublishAsync.mock.calls[1][0]).toStrictEqual("zigbee2mqtt/bridge/health");
    });

    it("Should debounce and retain messages when set via device_options", async () => {
@@ -229,10 +230,11 @@ describe("Extension: Receive", () => {
        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(0);
        vi.runOnlyPendingTimers();
        await flushPromises();
-        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(1);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(2);
        expect(mockMQTTPublishAsync.mock.calls[0][0]).toStrictEqual("zigbee2mqtt/weather_sensor");
        expect(JSON.parse(mockMQTTPublishAsync.mock.calls[0][1])).toStrictEqual({temperature: 0.08, humidity: 0.01, pressure: 2});
        expect(mockMQTTPublishAsync.mock.calls[0][2]).toStrictEqual({qos: 1, retain: true});
+        expect(mockMQTTPublishAsync.mock.calls[1][0]).toStrictEqual("zigbee2mqtt/bridge/health");
    });

    it("Should debounce messages only with the same payload values for provided debounce_ignore keys", async () => {
@@ -281,8 +283,9 @@ describe("Extension: Receive", () => {
        expect(JSON.parse(mockMQTTPublishAsync.mock.calls[0][1])).toStrictEqual({temperature: 0.08, pressure: 2});
        vi.runOnlyPendingTimers();
        await flushPromises();
-        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(2);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(3);
        expect(JSON.parse(mockMQTTPublishAsync.mock.calls[1][1])).toStrictEqual({temperature: 0.07, pressure: 2, humidity: 0.03});
+        expect(mockMQTTPublishAsync.mock.calls[2][0]).toStrictEqual("zigbee2mqtt/bridge/health");
    });

    it("Should NOT publish old messages from State cache during debouncing", async () => {
@@ -322,9 +325,10 @@ describe("Extension: Receive", () => {
        vi.runOnlyPendingTimers();

        // Test that only one MQTT is sent out and test its values.
-        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(1);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(1 + 1 /* "bridge/health" */);
        expect(mockMQTTPublishAsync.mock.calls[0][0]).toStrictEqual("zigbee2mqtt/weather_sensor");
        expect(JSON.parse(mockMQTTPublishAsync.mock.calls[0][1])).toStrictEqual({temperature: 0.08, humidity: 0.01, pressure: 2});
+        expect(mockMQTTPublishAsync.mock.calls[1][0]).toStrictEqual("zigbee2mqtt/bridge/health");

        // Send another Zigbee message...
        await mockZHEvents.message({
@@ -335,7 +339,6 @@ describe("Extension: Receive", () => {
            type: "attributeReport",
            linkquality: 10,
        });
-        // @ts-expect-error private
        const realDevice = controller.zigbee.resolveEntity(device);

        // Trigger asynchronous event while device is "debouncing" to trigger Message to be sent out from State cache.
@@ -343,12 +346,14 @@ describe("Extension: Receive", () => {
        vi.runOnlyPendingTimers();

        // Total of 3 messages should have triggered.
-        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(3);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(5);

+        expect(mockMQTTPublishAsync.mock.calls[1][0]).toStrictEqual("zigbee2mqtt/bridge/health");
        // Test that message pushed by asynchronous message contains NEW measurement and not old.
-        expect(JSON.parse(mockMQTTPublishAsync.mock.calls[1][1])).toStrictEqual({temperature: 0.09, humidity: 0.01, pressure: 2});
-        // Test that messages after debouncing contains NEW measurement and not old.
        expect(JSON.parse(mockMQTTPublishAsync.mock.calls[2][1])).toStrictEqual({temperature: 0.09, humidity: 0.01, pressure: 2});
+        // Test that messages after debouncing contains NEW measurement and not old.
+        expect(JSON.parse(mockMQTTPublishAsync.mock.calls[3][1])).toStrictEqual({temperature: 0.09, humidity: 0.01, pressure: 2});
+        expect(mockMQTTPublishAsync.mock.calls[4][0]).toStrictEqual("zigbee2mqtt/bridge/health");
    });

    it("Should throttle multiple messages from spamming devices", async () => {
@@ -439,9 +444,10 @@ describe("Extension: Receive", () => {
        await mockMQTTEvents.message("zigbee2mqtt/bulb/set", stringify({state: "ON"}));
        await flushPromises();
        vi.runOnlyPendingTimers();
-        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(2);
+        expect(mockMQTTPublishAsync).toHaveBeenCalledTimes(2 + 1);
        expect(JSON.parse(mockMQTTPublishAsync.mock.calls[0][1])).toStrictEqual({state: "ON"});
        expect(JSON.parse(mockMQTTPublishAsync.mock.calls[1][1])).toStrictEqual({state: "ON"});
+        expect(mockMQTTPublishAsync.mock.calls[2][0]).toStrictEqual("zigbee2mqtt/bridge/health");
    });

    it("Should handle a zigbee message with 1 precision", async () => {
@@ -1,15 +1,14 @@
+// biome-ignore assist/source/organizeImports: import mocks first
+import {afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi} from "vitest";
 import * as data from "./mocks/data";

-import type {MockInstance} from "vitest";
-
 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";

@@ -25,6 +25,13 @@ export const mockMQTTConnectAsync = vi.fn(() => ({
        events[type] = handler;
    }),
    stream: {setMaxListeners: vi.fn()},
+    options: {
+        protocolVersion: 5,
+        protocol: "mqtt",
+        host: "localhost",
+        port: 1883,
+    },
+    queue: [],
 }));

 vi.mock("mqtt", () => ({
@@ -1,11 +1,10 @@
+import assert from "node:assert";
 import type {Mock} from "vitest";
 import type {AdapterTypes} from "zigbee-herdsman";

-import assert from "node:assert";
-
 import {Zcl} from "zigbee-herdsman";
 import {InterviewState} from "zigbee-herdsman/dist/controller/model/device";
-
+import {DEFAULT_BIND_GROUP_ID} from "../../lib/util/utils";
 import type {EventHandler} from "./utils";

 type ZHConfiguredReporting = {
@@ -506,7 +505,7 @@ export const groups = {
    thermostat_group: new Group(12, [TS0601_thermostat.endpoints[0]]),
    group_with_switch: new Group(14, [ZNCZ02LM.endpoints[0], bulb_2.endpoints[0]]),
    gledopto_group: new Group(21, [GLEDOPTO_2ID.endpoints[3]]),
-    default_bind_group: new Group(901, []),
+    default_bind_group: new Group(DEFAULT_BIND_GROUP_ID, []),
    ha_discovery_group: new Group(9, [bulb_color_2.endpoints[0], bulb_2.endpoints[0], QBKG03LM.endpoints[2]]),
    hue_twilight_group: new Group(19, [hue_twilight.endpoints[1]]),
 };
@@ -1,11 +1,11 @@
+// biome-ignore assist/source/organizeImports: import mocks first
+import {afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi} from "vitest";
 import * as data from "./mocks/data";

+import {rmSync, writeFileSync} from "node:fs";
+import {join} from "node:path";
 import type {IncomingMessage, OutgoingHttpHeader, OutgoingHttpHeaders, RequestListener, Server, ServerResponse} from "node:http";
-
-import {rmSync} from "node:fs";
-
 import type {findAllDevices} from "zigbee-herdsman/dist/adapter/adapterDiscovery";
-
 import {onboard} from "../lib/util/onboarding";
 import * as settings from "../lib/util/settings";

@@ -188,10 +188,10 @@ describe("Onboarding", () => {
        expectWriteMinimal: boolean,
        expectFailure: boolean,
    ): Promise<[getHtml: string, postHtml: string]> => {
-        // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+        // biome-ignore lint/suspicious/noExplicitAny: ignore
        const reqDataListener = vi.fn<(chunk: any) => void>();
        const reqEndListener = vi.fn<() => void>();
-        // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+        // biome-ignore lint/suspicious/noExplicitAny: ignore
        const resEnd = vi.fn<(chunk: any | (() => void), cb?: () => void) => ServerResponse<IncomingMessage>>(
            // @ts-expect-error return not used
            (chunk, cb) => {
@@ -299,7 +299,7 @@ describe("Onboarding", () => {
    };

    const runFailure = async (): Promise<string> => {
-        // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+        // biome-ignore lint/suspicious/noExplicitAny: ignore
        const resEnd = vi.fn<(chunk: any | (() => void), cb?: () => void) => ServerResponse<IncomingMessage>>(
            // @ts-expect-error return not used
            (chunk, cb) => {
@@ -753,7 +753,13 @@ describe("Onboarding", () => {
    });

    it("handles validation failure", async () => {
-        settings.set(["serial", "adapter"], "emberz");
+        const reReadSpy = vi.spyOn(settings, "reRead");
+
+        // set after onboarding server is done to reach bottom code path
+        reReadSpy.mockImplementationOnce(() => {
+            settings.set(["serial", "adapter"], "emberz");
+            settings.reRead();
+        });

        let p;
        const getHtml = await new Promise<string>((resolve, reject) => {
@@ -770,6 +776,88 @@ describe("Onboarding", () => {

        await expect(p).resolves.toStrictEqual(false);
        expect(getHtml).toContain("adapter must be equal to one of the allowed values");
+
+        reReadSpy.mockRestore();
+    });
+
+    it("handles non-required validation failure before applying envs", async () => {
+        settings.set(["serial"], "/dev/ttyUSB0");
+
+        let p;
+        const getHtml = await new Promise<string>((resolve, reject) => {
+            mockHttpOnListen.mockImplementationOnce(async () => {
+                try {
+                    resolve(await runFailure());
+                } catch (error) {
+                    reject(error);
+                }
+            });
+
+            p = onboard();
+        });
+
+        await expect(p).resolves.toStrictEqual(false);
+        expect(getHtml).toContain("serial must be object");
+    });
+
+    it("handles invalid yaml file", async () => {
+        settings.testing.clear();
+
+        const configFile = join(data.mockDir, "configuration.yaml");
+
+        writeFileSync(
+            configFile,
+            `
+                good: 9
+                \t wrong
+        `,
+        );
+
+        let p;
+        const getHtml = await new Promise<string>((resolve, reject) => {
+            mockHttpOnListen.mockImplementationOnce(async () => {
+                try {
+                    resolve(await runFailure());
+                } catch (error) {
+                    reject(error);
+                }
+            });
+
+            p = onboard();
+        });
+
+        await expect(p).resolves.toStrictEqual(false);
+        expect(getHtml).toContain("Your configuration file");
+        expect(getHtml).toContain("is invalid");
+
+        data.removeConfiguration();
+    });
+
+    it("handles error while loading yaml file", async () => {
+        settings.testing.clear();
+
+        const configFile = join(data.mockDir, "configuration.yaml");
+
+        writeFileSync(configFile, "badfile");
+
+        let p;
+        const getHtml = await new Promise<string>((resolve, reject) => {
+            mockHttpOnListen.mockImplementationOnce(async () => {
+                try {
+                    resolve(await runFailure());
+                } catch (error) {
+                    reject(error);
+                }
+            });
+
+            p = onboard();
+        });
+
+        await expect(p).resolves.toStrictEqual(false);
+        expect(getHtml).toContain("AssertionError");
+        expect(getHtml).toContain("expected to be an object");
+
+        data.removeConfiguration();
    });

    it("handles creating data path", async () => {
@@ -1,3 +1,5 @@
+// biome-ignore assist/source/organizeImports: import mocks first
+import {afterAll, beforeAll, beforeEach, describe, expect, it, vi} from "vitest";
 import {mockLogger} from "./mocks/logger";

 import {initSdNotify} from "../lib/util/sd-notify";
@@ -1,8 +1,8 @@
 // side-effect ensures using mock paths
+import {beforeEach, describe, expect, it} from "vitest";
 import "./mocks/data";

 import fs from "node:fs";
-
 import yaml from "js-yaml";
 import objectAssignDeep from "object-assign-deep";

@@ -165,6 +165,43 @@ describe("Settings", () => {
        writeAndCheck();
    });

+    it("Should apply Home Assistant environment variables", () => {
+        // should be kept in sync with envs in https://github.com/zigbee2mqtt/hassio-zigbee2mqtt/blob/master/common/rootfs/docker-entrypoint.sh
+        process.env.ZIGBEE2MQTT_CONFIG_FRONTEND_ENABLED = "true";
+        process.env.ZIGBEE2MQTT_CONFIG_FRONTEND_PORT = "8099";
+        process.env.ZIGBEE2MQTT_CONFIG_HOMEASSISTANT_ENABLED = "true";
+        process.env.ZIGBEE2MQTT_CONFIG_SERIAL_PORT =
+            "/dev/serial/by-id/usb-ITead_Sonoff_Zigbee_3.0_USB_Dongle_Plus_48be7a7468d8ed11bfea786ff2c613ac-if00-port0";
+        process.env.ZIGBEE2MQTT_CONFIG_MQTT_SERVER = "mqtt://core-mosquitto:1883";
+        process.env.ZIGBEE2MQTT_CONFIG_MQTT_USER = "addons";
+        process.env.ZIGBEE2MQTT_CONFIG_MQTT_PASSWORD = "7RbR4NBSskS8TKG4ugzdRilXw6TPQ4NKFs259j2DxeultOFtl5JwciNZFd6feT5o";
+
+        write(configurationFile, {});
+
+        // @ts-expect-error workaround
+        const expected = objectAssignDeep.noMutate({}, settings.testing.defaults);
+        expected.frontend.enabled = true;
+        expected.frontend.port = 8099;
+        expected.homeassistant.enabled = true;
+        expected.serial.port = "/dev/serial/by-id/usb-ITead_Sonoff_Zigbee_3.0_USB_Dongle_Plus_48be7a7468d8ed11bfea786ff2c613ac-if00-port0";
+        expected.mqtt.server = "mqtt://core-mosquitto:1883";
+        expected.mqtt.user = "addons";
+        expected.mqtt.password = "7RbR4NBSskS8TKG4ugzdRilXw6TPQ4NKFs259j2DxeultOFtl5JwciNZFd6feT5o";
+        expected.devices = {};
+        expected.groups = {};
+
+        const writeAndCheck = (): void => {
+            expect(settings.write()); // trigger writing of ENVs
+            expect(settings.validate()).toStrictEqual([]);
+            expect(settings.get()).toStrictEqual(expected);
+        };
+
+        // Write trice to ensure there are no side effects.
+        writeAndCheck();
+        writeAndCheck();
+        writeAndCheck();
+    });
+
    it("Should write environment variables as overrides to configuration.yaml, not in the ref file", () => {
        write(secretFile, {password: "password-in-secret-file"}, false);
        write(configurationFile, {mqtt: {password: "!secret password", server: "server"}});
@@ -275,6 +312,9 @@ describe("Settings", () => {
            base_topic: "zigbee2mqtt",
            include_device_information: false,
            maximum_packet_size: 1048576,
+            keepalive: 60,
+            reject_unauthorized: true,
+            version: 4,
            force_disable_retain: false,
            password: "mysecretpassword",
            server: "my.mqtt.server",
@@ -320,6 +360,9 @@ describe("Settings", () => {
            base_topic: "zigbee2mqtt",
            include_device_information: false,
            maximum_packet_size: 1048576,
+            keepalive: 60,
+            reject_unauthorized: true,
+            version: 4,
            force_disable_retain: false,
            password: "mysecretpassword",
            server: "my.mqtt.server",
@@ -506,7 +549,7 @@ describe("Settings", () => {
    it("Should read groups", () => {
        const content = {
            groups: {
-                1: {
+                "1": {
                    friendly_name: "123",
                },
            },
@@ -515,18 +558,17 @@ describe("Settings", () => {
        write(configurationFile, content);

        const group = settings.getGroup("1");
-        const expected = {
+
+        expect(group).toStrictEqual({
            ID: 1,
            friendly_name: "123",
-        };
-
-        expect(group).toStrictEqual(expected);
+        });
    });

    it("Throw if removing non-existing group", () => {
        const content = {
            groups: {
-                1: {
+                "1": {
                    friendly_name: "123",
                },
            },
@@ -543,7 +585,7 @@ describe("Settings", () => {
        };

        const contentGroups = {
-            1: {
+            "1": {
                friendly_name: "123",
            },
        };
@@ -552,12 +594,11 @@ describe("Settings", () => {
        write(groupsFile, contentGroups);

        const group = settings.getGroup("1");
-        const expected = {
+
+        expect(group).toStrictEqual({
            ID: 1,
            friendly_name: "123",
-        };
-
-        expect(group).toStrictEqual(expected);
+        });
    });

    it("Combine everything! groups and devices from separate file :)", () => {
@@ -567,9 +608,8 @@ describe("Settings", () => {
        };

        const contentGroups = {
-            1: {
+            "1": {
                friendly_name: "123",
-                devices: [],
            },
        };
        write(configurationFile, contentConfiguration);
@@ -586,44 +626,48 @@ describe("Settings", () => {

        expect(read(configurationFile)).toStrictEqual(expectedConfiguration);

-        const expectedDevice = {
+        expect(read(devicesFile)).toStrictEqual({
            "0x1234": {
                friendly_name: "0x1234",
            },
-        };
-
-        expect(read(devicesFile)).toStrictEqual(expectedDevice);
+        });

        const group = settings.getGroup("1");
-        const expectedGroup = {
+
+        expect(group).toStrictEqual({
            ID: 1,
            friendly_name: "123",
-            devices: [],
-        };
-
-        expect(group).toStrictEqual(expectedGroup);
+        });

        expect(read(configurationFile)).toStrictEqual(expectedConfiguration);

-        const expectedDevice2 = {
+        expect(settings.getDevice("0x1234")).toStrictEqual({
            ID: "0x1234",
            friendly_name: "0x1234",
-        };
-
-        expect(settings.getDevice("0x1234")).toStrictEqual(expectedDevice2);
+        });
    });

    it("Should add groups", () => {
        write(configurationFile, {});

        settings.addGroup("test123");
-        const expected = {
-            1: {
+
+        expect(settings.get().groups).toStrictEqual({
+            "1": {
                friendly_name: "test123",
            },
-        };
+        });

-        expect(settings.get().groups).toStrictEqual(expected);
+        settings.addGroup("test456", "");
+
+        expect(settings.get().groups).toStrictEqual({
+            "1": {
+                friendly_name: "test123",
+            },
+            "2": {
+                friendly_name: "test456",
+            },
+        });
    });

    it("Should allow username without password", () => {
@@ -637,6 +681,9 @@ describe("Settings", () => {
            base_topic: "zigbee2mqtt",
            include_device_information: false,
            maximum_packet_size: 1048576,
+            keepalive: 60,
+            reject_unauthorized: true,
+            version: 4,
            force_disable_retain: false,
            server: "my.mqtt.server",
            user: "myusername",
@@ -650,7 +697,7 @@ describe("Settings", () => {

        settings.addGroup("test123", "123");
        const expected = {
-            123: {
+            "123": {
                friendly_name: "test123",
            },
        };
@@ -682,7 +729,7 @@ describe("Settings", () => {
            settings.addGroup("test123");
        }).toThrow(`friendly_name 'test123' is already in use`);
        const expected = {
-            1: {
+            "1": {
                friendly_name: "test123",
            },
        };
@@ -698,7 +745,7 @@ describe("Settings", () => {
            settings.addGroup("test_id_123", "123");
        }).toThrow(new Error("Group ID '123' is already in use"));
        const expected = {
-            123: {
+            "123": {
                friendly_name: "test123",
            },
        };
@@ -800,25 +847,6 @@ describe("Settings", () => {
        expect(settings.get().blocklist).toStrictEqual(["0x123", "0x1234"]);
    });

-    it("Should throw error when yaml file is invalid", () => {
-        fs.writeFileSync(
-            configurationFile,
-            `
-             good: 9
-             \t wrong
-        `,
-        );
-
-        settings.testing.clear();
-        const error = `Your YAML file: '${configurationFile}' is invalid (use https://jsonformatter.org/yaml-validator to find and fix the issue)`;
-        expect(settings.validate()).toEqual(expect.arrayContaining([error]));
-    });
-
-    it("Should throw error when yaml file does not exist", () => {
-        settings.testing.clear();
-        expect(settings.validate()[0]).toContain("ENOENT: no such file or directory, open ");
-    });
-
    it("Configuration shouldnt be valid when invalid QOS value is used", () => {
        write(configurationFile, {
            ...minimalConfig,
@@ -827,7 +855,7 @@ describe("Settings", () => {

        settings.reRead();

-        const error = `QOS for 'myname' not valid, should be 0, 1 or 2 got 3`;
+        const error = "devices/0x0017880104e45519/qos must be equal to one of the allowed values";
        expect(settings.validate()).toEqual(expect.arrayContaining([error]));
    });

@@ -835,7 +863,7 @@ describe("Settings", () => {
        write(configurationFile, {
            ...minimalConfig,
            devices: {"0x0017880104e45519": {friendly_name: "myname", retain: false}},
-            groups: {1: {friendly_name: "myname", retain: false}},
+            groups: {"1": {friendly_name: "myname", retain: false}},
        });

        settings.reRead();
@@ -924,7 +952,7 @@ describe("Settings", () => {
        expect(settings.validate()).toEqual(expect.arrayContaining([error]));
    });

-    it("Configuration shouldnt be valid when duplicate friendly_name are used", async () => {
+    it("Configuration shouldnt be valid when duplicate friendly_name are used", () => {
        write(configurationFile, {
            devices: {
                "0x0017880104e45519": {friendly_name: "myname", retain: false},
@@ -939,7 +967,7 @@ describe("Settings", () => {
        }).toThrowError(`friendly_name 'myname' is already in use`);
    });

-    it("Should throw when removing device which doesnt exist", async () => {
+    it("Should throw when removing device which doesnt exist", () => {
        write(configurationFile, {
            devices: {
                "0x0017880104e45519": {friendly_name: "myname", retain: false},
@@ -1,10 +1,9 @@
-// side-effect ensures using mock paths
+// biome-ignore assist/source/organizeImports: import mocks first
+import {afterAll, afterEach, beforeAll, beforeEach, describe, expect, it} from "vitest";
 import * as data from "./mocks/data";

 import {existsSync, readFileSync, rmSync} from "node:fs";
-
 import objectAssignDeep from "object-assign-deep";
-
 import mockedData from "../lib/util/data";
 import * as settings from "../lib/util/settings";
 import * as settingsMigration from "../lib/util/settingsMigration";
@@ -2,9 +2,8 @@
    "extends": "../tsconfig",
    "include": ["./**/*", "vitest.config.mts"],
    "compilerOptions": {
-        "types": ["vitest/globals"],
        "rootDir": "..",
        "noEmit": true
    },
-    "references": [{ "path": ".." }]
+    "references": [{"path": ".."}]
 }
@@ -1,7 +1,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 utils, {assertString} from "../lib/util/utils";

 // keep the implementations, just spy
@@ -1,6 +1,8 @@
+import codspeedPlugin from "@codspeed/vitest-plugin";
 import {defineConfig} from "vitest/config";

 export default defineConfig({
+    plugins: [codspeedPlugin()],
    test: {
        globals: true,
        onConsoleLog(_log: string, _type: "stdout" | "stderr"): boolean | undefined {
@@ -0,0 +1,6 @@
+{
+    "extends": "./tsconfig",
+    "compilerOptions": {
+        "emitDeclarationOnly": true
+    }
+}
Author	SHA1	Message	Date
Koen Kanters	0bdc3fd1f7	chore(dev): release 2.6.0 (#27881 )	2025-08-01 17:37:30 +02:00
Koen Kanters	376554943d	fix(ignore): update zigbee-herdsman-converters to 24.11.0 (#28143 )	2025-08-01 15:22:20 +00:00
Koen Kanters	9fcc41b199	fix(ignore): update zigbee-herdsman to 5.0.4 (#28141 )	2025-08-01 15:04:45 +00:00
Nerivec	fe5639ce40	fix(ignore): update zigbee2mqtt-windfront to 1.5.2 (#28140 )	2025-08-01 14:56:52 +00:00
Rob van OostenrijkandNerivec	0182c4b32e	fix: Ignore symbolic links in `data` during backup (#28132 ) Co-authored-by: Nerivec <62446222+Nerivec@users.noreply.github.com>	2025-07-31 20:26:36 +02:00
Koen Kanters	c12f07c5a0	chore: don't run codspeed on release-please prs	2025-07-30 21:34:29 +02:00
Nerivec	31d3e19f38	fix(ignore): update zigbee2mqtt-windfront to 1.5.1 (#28123 )	2025-07-30 19:06:35 +00:00
Koen Kanters	ee1c884031	fix(ignore): update zigbee-herdsman-converters to 24.10.0 (#28122 )	2025-07-30 18:55:55 +00:00
Koen Kanters	e5f677bdd1	fix(ignore): update zigbee-herdsman to 5.0.3 (#28121 )	2025-07-30 18:48:26 +00:00
Koen Kanters	6dd812f71c	fix(ignore): fix `71cf2b4160`	2025-07-29 20:47:51 +02:00
Koenkk	71cf2b4160	fix(ignore): update zigbee-herdsman-converters to 24.9.0	2025-07-29 18:34:40 +00:00
Koen Kanters	e9f2a3f532	fix(ignore): update zigbee-herdsman to 5.0.2 (#28110 )	2025-07-29 18:34:03 +00:00
Nerivec	0725374db7	chore: update readme (#28085 )	2025-07-27 13:01:47 +02:00
Nerivec	6f7c6eec04	chore: import vitest instead of relying on globals (#28084 )	2025-07-26 20:05:13 +02:00
Nerivec	29e56adc15	fix(ignore): update zigbee2mqtt-windfront to 1.5.0 (#28082 )	2025-07-26 17:00:38 +00:00
Koen KantersandNerivec	caf91cd7ff	fix(ignore): update zigbee-herdsman-converters to 24.8.0 (#28081 ) Co-authored-by: Nerivec <62446222+Nerivec@users.noreply.github.com>	2025-07-26 16:37:46 +00:00
Koen Kanters	6432571c61	fix(ignore): update zigbee-herdsman to 5.0.1 (#28080 )	2025-07-26 11:13:06 +00:00
Koen Kanters	713551b525	fix(ignore): fix breaking changes of https://github.com/Koenkk/zigbee2mqtt/pull/28077	2025-07-25 20:30:48 +02:00
Koen Kanters	9a215efe26	fix(ignore): update zigbee-herdsman to 5.0.0 (#28077 )	2025-07-25 18:25:44 +00:00
Nerivec	65eef1b690	fix: Publish definition source in `bridge/devices` (#28076 )	2025-07-25 19:22:17 +02:00
Koen Kanters	81bafa5520	fix(ignore): update zigbee-herdsman-converters to 24.7.0 (#28070 )	2025-07-24 18:37:06 +00:00
Nerivec	d322dc2047	fix(ignore): update zigbee2mqtt-windfront to 1.4.1 (#28062 )	2025-07-23 19:37:34 +00:00
Nerivec	5f9019a95f	fix: Publish endpoint names in `bridge/devices` (#28057 )	2025-07-23 20:12:16 +02:00
Koen Kanters	4bc6a59ff3	fix(ignore): update zigbee-herdsman-converters to 24.6.0 (#28051 )	2025-07-22 18:26:50 +00:00
dependabot[bot]dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>Nerivec	e505a93a40	fix(ignore): bump the minor-patch group with 4 updates (#28046 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Co-authored-by: Nerivec <62446222+Nerivec@users.noreply.github.com>	2025-07-22 19:58:18 +02:00
Koen Kanters	bc74d0b11b	fix(ignore): update zigbee-herdsman-converters to 24.5.0 (#28045 )	2025-07-21 18:23:20 +00:00
Koen Kanters	cc6f7b02bc	fix(ignore): update zigbee-herdsman to 4.5.0 (#28044 )	2025-07-21 18:18:32 +00:00
Koen Kanters	74e9357a59	fix(ignore): update zigbee-herdsman-converters to 24.4.0 (#28022 )	2025-07-18 20:13:44 +00:00
Koen Kantersandnurikk	8b876823da	fix(ignore): update zigbee2mqtt-frontend to 0.9.19 (#28021 ) Co-authored-by: nurikk <1525421+nurikk@users.noreply.github.com>	2025-07-18 22:05:48 +02:00
Nerivec	db20369447	fix: Various fixes to align behaviors (+add benchmarks for dev) (#28011 )	2025-07-18 21:34:51 +02:00
Koen Kanters	0e0a5618af	fix: Exit with code 2 when adapters disconnects (#28013 )	2025-07-18 20:32:39 +02:00
Koen Kanters	21fa5cbded	fix(ignore): update zigbee-herdsman-converters to 24.3.0 (#28015 )	2025-07-17 12:28:32 +00:00
Koen Kanters	e2b7df9f84	fix(ignore): Remove retain/qos from mqtt publish logging https://github.com/Koenkk/zigbee2mqtt/pull/27983	2025-07-15 13:56:17 +02:00
Donald FlissingerandKoen Kanters	ef07505b31	fix: Set MQTT retain and qos=1 on (re)connect (#27983 ) Co-authored-by: Koen Kanters <koenkanters94@gmail.com>	2025-07-15 13:29:57 +02:00
Nerivec	435a6cceb9	fix: Improve startup settings validation (#27988 )	2025-07-15 13:15:11 +02:00
Nerivec	a51216e3c7	fix(ignore): update zigbee2mqtt-windfront to 1.3.1 (#27999 )	2025-07-15 10:55:37 +00:00
Koen Kanters	6ede403688	fix(ignore): update zigbee-herdsman-converters to 24.2.0 (#27986 )	2025-07-14 11:49:06 +00:00
NerivecandKoen Kanters	ecadda45e7	fix: Fix settings schema defaults (#27961 ) Co-authored-by: Koen Kanters <koenkanters94@gmail.com>	2025-07-12 18:36:56 +02:00
Koen Kanters	a837702b2c	fix(ignore): update zigbee-herdsman-converters to 24.1.0 (#27973 )	2025-07-12 12:40:05 +00:00
Koen Kanters	57e04bb547	chore: merge master to dev	2025-07-12 13:36:44 +02:00
Koen Kanters	ffdd353e16	chore: Add device database.db entry to problem report template	2025-07-12 13:36:24 +02:00
Nerivec	0215e76118	feat: Allow to disable internal frontend UI serving for standalone serving (#27851 )	2025-07-12 09:33:26 +02:00
Nerivec	833605b71f	fix(ignore): add test to specifically check HA envs (#27969 )	2025-07-11 19:53:05 +02:00
Boris Conforty	f4d821deca	fix: log error message when external JS fails to load (#27837 )	2025-07-11 17:36:06 +02:00
Koen Kanters	c465ef8352	fix(ignore): update zigbee-herdsman-converters to 24.0.0 (#27946 )	2025-07-10 13:06:50 +00:00
Koen Kanters	0dd4b6a991	chore: fix Docker Dependabot	2025-07-10 14:45:45 +02:00
Nerivec	1b37baefd3	fix(ignore): update zigbee2mqtt-windfront to 1.3.0 (#27953 )	2025-07-09 22:37:02 +00:00
Koen Kanters	b4a9424d60	fix(ignore): update zigbee-herdsman-converters to 23.72.0 (#27943 )	2025-07-09 12:48:46 +00:00
Koen Kanters	93c1824b1d	fix(ignore): update zigbee-herdsman-converters to 23.71.0 (#27931 )	2025-07-08 11:27:01 +00:00
dependabot[bot]anddependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	8ceb08704f	fix(ignore): bump the minor-patch group with 2 updates (#27924 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2025-07-07 20:47:07 +02:00
Koen Kanters	eb82973067	fix(ignore): update zigbee-herdsman to 4.4.1 (#27918 )	2025-07-06 19:21:12 +00:00
Koen Kantersandnurikk	a3e7f69b3f	fix(ignore): update zigbee2mqtt-frontend to 0.9.17 (#27917 ) Co-authored-by: nurikk <1525421+nurikk@users.noreply.github.com>	2025-07-06 21:15:40 +02:00
Koen Kanters	373fa43136	chore: change dependabot versioning strategy to increase	2025-07-06 21:13:57 +02:00
Koen Kanters	e04732462c	fix(ignore): update zigbee-herdsman-converters to 23.70.1 (#27916 )	2025-07-06 19:01:12 +00:00
Koen Kanters	e663e86e09	fix(ignore): update zigbee-herdsman to 4.4.0 (#27906 )	2025-07-04 18:37:18 +00:00
Koen Kanters	163a15d664	fix(ignore): update zigbee-herdsman-converters to 23.70.0 (#27905 )	2025-07-04 20:34:17 +02:00
Koen Kanters	4afdd4e892	fix(ignore): update zigbee-herdsman to 4.3.2 (#27900 )	2025-07-04 11:47:05 +00:00
Nerivec	190cfe99ac	fix: erroneous Health OS memory percent calculation (#27892 )	2025-07-03 16:31:03 +02:00
github-actions[bot]	c9284f6b33	chore: promote to dev	2025-07-02 19:48:07 +00:00
Koen Kanters	5063c7d3ad	chore(dev): release 2.5.1 (#27879 )	2025-07-02 21:36:29 +02:00
Koen Kanters	4dd7dabf08	fix: Various Windfront frontend improvements @nerivec (#27880 )	2025-07-02 21:35:07 +02:00
Koen Kanters	917d8527a5	fix(ignore): update zigbee-herdsman to 4.3.1 (#27878 )	2025-07-02 19:15:36 +00:00
github-actions[bot]	f307467e37	chore: promote to dev	2025-07-01 18:38:36 +00:00
Koen Kanters	c0cd2c6b96	chore(dev): release 2.5.0 (#27573 )	2025-07-01 20:27:23 +02:00
Koen Kanters	4a4ee8888d	chore: fix ci not triggering on tag	2025-07-01 20:27:16 +02:00
Koen Kanters	5285b7b95e	fix(ignore): update zigbee-herdsman-converters to 23.69.0 (#27860 )	2025-07-01 17:53:36 +00:00
dependabot[bot]	c8dc26b241	fix(ignore): bump the minor-patch group across 1 directory with 4 updates (#27858 )	2025-07-01 17:59:28 +02:00
Koen Kanters	25ea77e038	chore: fix ci not running for pull request	2025-06-30 21:05:47 +02:00
Koen Kanters	50c7d2d6ad	fix(ignore): update zigbee-herdsman to 4.3.0 (#27853 )	2025-06-30 18:40:20 +00:00
Koen Kanters	3ccbaf21d2	fix(ignore): update zigbee-herdsman-converters to 23.68.0 (#27852 )	2025-06-30 18:35:49 +00:00
Koen Kanters	6930fa6f3f	fix(ignore): update zigbee-herdsman-converters to 23.67.0 (#27842 )	2025-06-29 19:06:51 +00:00
Koen Kanters	16faef1511	fix(ignore): update zigbee-herdsman to 4.2.1 (#27835 )	2025-06-28 08:24:18 +00:00
Koen Kanters	c87d4524d5	fix(ignore): Migrate to Biome 2 (#27785 )	2025-06-28 10:20:41 +02:00
Koen Kanters	33234d9ce4	fix(ignore): update zigbee-herdsman-converters to 23.66.0 (#27831 )	2025-06-27 18:49:45 +00:00
Koen Kanters	4190ba43b4	fix(ignore): update zigbee-herdsman-converters to 23.65.0 (#27804 )	2025-06-24 20:02:56 +00:00
Koen Kanters	b7d9c78309	fix(ignore): update zigbee-herdsman-converters to 23.64.0 (#27799 )	2025-06-23 18:51:22 +00:00
dependabot[bot]anddependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	50b0ffd7e7	fix(ignore): bump the minor-patch group with 2 updates (#27797 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2025-06-23 20:35:51 +02:00
Koen Kanters	15f3eaf966	fix(ignore): update zigbee-herdsman to 4.2.0 (#27786 )	2025-06-22 20:14:19 +00:00
Koen Kanters	0d5de750ff	fix(ignore): update zigbee-herdsman-converters to 23.63.0 (#27784 )	2025-06-22 19:32:39 +00:00
Koen Kantersandnurikk	7109900bcf	fix(ignore): update zigbee2mqtt-frontend to 0.9.16 (#27783 ) Co-authored-by: nurikk <1525421+nurikk@users.noreply.github.com>	2025-06-22 19:26:13 +00:00
Koen Kanters	281e10c15f	fix(ignore): update zigbee-herdsman-converters to 23.62.0 (#27767 )	2025-06-19 18:23:04 +00:00
Nerivec	cdad6ccd75	fix(ignore): update zigbee2mqtt-windfront to 1.1.0 (#27763 )	2025-06-19 19:49:25 +02:00
Koen Kanters	b537f9a93a	fix(ignore): update zigbee-herdsman-converters to 23.61.0 (#27759 )	2025-06-18 19:57:08 +00:00
Koen Kanters	1b56e63aab	chore: Use commit SHA instead of `Update` in dev-types commit message https://github.com/Koenkk/zigbee2mqtt/pull/27746	2025-06-18 20:00:38 +02:00
Koen Kanters	f33d3606be	fix(ignore): update zigbee-herdsman-converters to 23.60.0 (#27752 )	2025-06-17 18:25:09 +00:00
Koen Kanters	fb60cfde38	chore: Publish types (#27746 )	2025-06-17 20:20:34 +02:00
dependabot[bot]anddependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	de800450ad	fix(ignore): bump @types/node from 22.15.30 to 24.0.3 (#27745 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2025-06-16 19:52:03 +02:00
dependabot[bot]anddependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	977672976f	fix(ignore): bump zigbee2mqtt-windfront from 1.0.5 to 1.0.6 in the minor-patch group (#27744 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2025-06-16 19:51:52 +02:00
NerivecandKoen Kanters	cd9b752ede	feat: New health extension & extras in `bridge/info` (#27164 ) Co-authored-by: Koen Kanters <koenkanters94@gmail.com>	2025-06-16 19:45:36 +02:00
Koen Kanters	242815e139	fix(ignore): update zigbee-herdsman to 4.1.2 (#27729 )	2025-06-15 11:47:16 +00:00
Koen Kanters	87ff0f3711	fix(ignore): update zigbee-herdsman-converters to 23.59.0 (#27712 )	2025-06-13 18:45:44 +00:00
Koen Kantersandnurikk	8ecb9be98e	fix(ignore): update zigbee2mqtt-frontend to 0.9.15 (#27711 ) Co-authored-by: nurikk <1525421+nurikk@users.noreply.github.com>	2025-06-13 18:23:04 +00:00
NerivecandKoen Kanters	0e66b29983	fix: Generate group ID if empty string given (#27702 ) Co-authored-by: Koen Kanters <koenkanters94@gmail.com>	2025-06-12 20:28:55 +02:00
Koen Kanters	6a8d20858e	fix(ignore): update zigbee-herdsman-converters to 23.58.0 (#27695 )	2025-06-11 18:14:46 +00:00
Koen Kanters	e4b253e08b	fix: Fix devices not immediately marked as offline when timeout expires (#27691 )	2025-06-11 19:48:52 +02:00
Koen Kanters	56d3a8f9d8	fix(ignore): update zigbee-herdsman-converters to 23.57.1 (#27689 )	2025-06-10 19:10:57 +00:00
Koen Kanters	f6c3887c81	fix: Bump Alpine to 3.22 (#27690 )	2025-06-10 21:05:39 +02:00
Koen Kanters	2affe188c5	chore: bump pnpm	2025-06-10 20:25:01 +02:00
dependabot[bot]anddependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	587a02f663	fix(ignore): bump the minor-patch group with 6 updates (#27678 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2025-06-10 20:09:49 +02:00
Koen Kanters	0181263d32	fix: Rename fix typo in backoff settings https://github.com/Koenkk/zigbee2mqtt/issues/27642	2025-06-08 19:34:05 +02:00
Nerivec	eaa3e458b5	fix(ignore): update zigbee2mqtt-windfront to 1.0.5 (#27656 )	2025-06-08 18:33:34 +02:00
Koen Kanters	252bfbaa20	fix(ignore): update zigbee-herdsman-converters to 23.57.0 (#27646 )	2025-06-07 17:27:45 +00:00
Koen Kantersandnurikk	66e1318a79	fix(ignore): update zigbee2mqtt-frontend to 0.9.14 (#27645 ) Co-authored-by: nurikk <1525421+nurikk@users.noreply.github.com>	2025-06-07 17:23:03 +00:00
Nerivec	9a4ce6fcd0	fix: update zigbee2mqtt-windfront to 1.0.4 (#27641 )	2025-06-06 23:57:37 +02:00
Koen Kanters	4b95b54be7	fix(ignore): update zigbee-herdsman to 4.1.1 (#27640 )	2025-06-06 20:13:33 +00:00
Koen Kanters	f637e7d59c	fix(ignore): update zigbee-herdsman-converters to 23.56.0 (#27639 )	2025-06-06 19:41:31 +00:00
Nerivec	018fad27af	fix(ignore): API correctness (#27637 )	2025-06-06 20:01:07 +02:00
Koen Kanters	4594142c09	fix(ignore): update zigbee-herdsman-converters to 23.55.0 (#27618 )	2025-06-04 18:16:29 +00:00
dependabot[bot]anddependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	ac80bb6430	fix(ignore): bump the minor-patch group with 4 updates (#27610 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2025-06-03 21:15:11 +02:00
Koen Kanters	1765fe8925	fix(ignore): update zigbee-herdsman-converters to 23.54.0 (#27600 )	2025-06-02 18:11:51 +00:00
dependabot[bot]anddependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	7e82a3d1e9	fix(ignore): bump the minor-patch group with 3 updates (#27598 ) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2025-06-02 19:51:26 +02:00
github-actions[bot]	9df6cccd31	chore: promote to dev	2025-06-01 18:18:38 +00:00