chore(dev): release 2.5.1 (#27879 )

fix: Various Windfront frontend improvements @nerivec (#27880 )
fix(ignore): update zigbee-herdsman to 4.3.1 (#27878 )
2026-08-29 15:18:41 +00:00 · 2025-07-02 21:36:29 +02:00 · 2025-07-02 21:35:07 +02:00 · 2025-07-02 19:15:36 +00:00 · 2025-07-01 18:38:36 +00:00 · 2025-07-01 20:27:23 +02:00
166 changed files with 36553 additions and 31246 deletions
@@ -1,2 +0,0 @@
-node_modules/*
-test/
@@ -1,46 +0,0 @@
-
-module.exports = {
-    'env': {
-        'jest/globals': true,
-        'es6': true,
-        'node': true,
-    },
-    'extends': ['eslint:recommended', 'google', 'plugin:jest/recommended', 'plugin:jest/style'],
-    'parserOptions': {
-        'ecmaVersion': 2018,
-        'sourceType': 'module',
-    },
-    'rules': {
-        'require-jsdoc': 'off',
-        'indent': ['error', 4],
-        'max-len': ['error', {'code': 120}],
-        'no-prototype-builtins': 'off',
-        'linebreak-style': ['error', (process.platform === 'win32' ? 'windows' : 'unix')], // https://stackoverflow.com/q/39114446/2771889
-    },
-    'plugins': [
-        'jest',
-    ],
-    'overrides': [{
-        files: ['*.ts'],
-        parser: '@typescript-eslint/parser',
-        plugins: ['@typescript-eslint'],
-        extends: ['plugin:@typescript-eslint/recommended'],
-        parserOptions: {
-            project: './tsconfig.json',
-        },
-        rules: {
-            '@typescript-eslint/await-thenable': 'error',
-            '@typescript-eslint/ban-ts-comment': 'off',
-            '@typescript-eslint/explicit-function-return-type': 'error',
-            '@typescript-eslint/no-empty-function': 'off',
-            '@typescript-eslint/no-explicit-any': 'error',
-            '@typescript-eslint/no-unused-vars': 'error',
-            '@typescript-eslint/semi': ['error'],
-            'array-bracket-spacing': ['error', 'never'],
-            'indent': ['error', 4],
-            'max-len': ['error', {'code': 120}],
-            'no-return-await': 'error',
-            'object-curly-spacing': ['error', 'never'],
-        },
-    }],
-};
@@ -1,4 +1,4 @@
 github: [koenkk]
 custom:
-  - https://www.paypal.me/koenkk
-  - https://www.buymeacoffee.com/koenkk
+    - https://www.paypal.me/koenkk
+    - https://www.buymeacoffee.com/koenkk
@@ -1,20 +1,26 @@
 blank_issues_enabled: false
 contact_links:
-  - name: "IMPORTANT: Check development branch changelog first!!"
-    url: https://gist.github.com/Koenkk/bfd4c3d1725a2cccacc11d6ba51008ba
-    about: "Before submitting an issue, check that the issue hasn't already been solved in the development branch. Click 'Open' to see the release notes of the development branch. In case it is, you can read here how to switch to the development branch: https://www.zigbee2mqtt.io/advanced/more/switch-to-dev-branch.html"
-  - name: Questions/discussion
-    url: https://github.com/Koenkk/zigbee2mqtt/discussions/new
-    about: Ask questions, discuss about devices or show things you made
-  - name: Frontend issues
-    url: https://github.com/nurikk/z2m-frontend/issues
-    about: Issues related to the frontend.
-  - name: Home Assistant addon issues
-    url: https://github.com/zigbee2mqtt/hassio-zigbee2mqtt/issues
-    about: Issues related to the Home Assistant addon.
-  - name: FAQ
-    url: https://www.zigbee2mqtt.io/guide/faq
-    about: Frequently asked questions.
-  - name: Support Chat
-    url: https://discord.gg/NyseBeK
-    about: Chat for feedback, questions and troubleshooting.
+    - name: 'IMPORTANT: Check development branch changelog first!!'
+      url: https://gist.github.com/Koenkk/bfd4c3d1725a2cccacc11d6ba51008ba
+      about: Before submitting an issue, check that it has not already been solved in the development branch. Click here to see the release notes of the development branch.
+    - name: Switch to the development branch
+      url: https://www.zigbee2mqtt.io/advanced/more/switch-to-dev-branch.html
+      about: If the development branch solves an issue you are facing, click here to see the instructions to switch to the development branch.
+    - name: Questions/discussions
+      url: https://github.com/Koenkk/zigbee2mqtt/discussions/new
+      about: Ask questions, discuss devices, show things you made...
+    - name: Original frontend issues
+      url: https://github.com/nurikk/zigbee2mqtt-frontend/issues
+      about: Issues with the frontend package zigbee2mqtt-frontend
+    - name: WindFront frontend issues
+      url: https://github.com/Nerivec/zigbee2mqtt-windfront/issues
+      about: Issues with the frontend package zigbee2mqtt-windfront
+    - name: Home Assistant addon issues
+      url: https://github.com/zigbee2mqtt/hassio-zigbee2mqtt/issues
+      about: Issues with the Home Assistant addon
+    - name: FAQ
+      url: https://www.zigbee2mqtt.io/guide/faq
+      about: Frequently asked questions
+    - name: Support Chat
+      url: https://discord.gg/NyseBeK
+      about: Chat for feedback, questions and troubleshooting
@@ -1,38 +1,38 @@
 name: Feature request
 description: Suggest an idea for this project
-title: "[Feature request]: "
+title: '[Feature request]: '
 labels: [feature request]
 body:
-  - type: markdown
-    attributes:
-      value: |
-        **IMPORTANT:** Before submitting:
-        - Is your feature request related to the frontend? Then click [here](https://github.com/nurikk/zigbee2mqtt-frontend/issues/new?assignees=&labels=&template=feature_request.md&title=)
-  - type: textarea
-    id: textarea1
-    attributes:
-      label: Is your feature request related to a problem? Please describe
-      placeholder: A clear and concise description of what the problem is. Eg. I'm always frustrated when [...]
-    validations:
-      required: true
-  - type: textarea
-    id: textarea2
-    attributes:
-      label: Describe the solution you'd like
-      placeholder: A clear and concise description of what you want to happen.
-    validations:
-      required: true
-  - type: textarea
-    id: textarea3
-    attributes:
-      label: Describe alternatives you've considered
-      placeholder: A clear and concise description of any alternative solutions or features you've considered.
-    validations:
-      required: true
-  - type: textarea
-    id: textarea4
-    attributes:
-      label: Additional context
-      placeholder: Add any other context or screenshots about the feature request here.
-    validations:
-      required: true
+    - type: markdown
+      attributes:
+          value: |
+              **IMPORTANT:** Before submitting:
+              - Is your feature request related to the frontend? Then click [here](https://github.com/nurikk/zigbee2mqtt-frontend/issues/new?assignees=&labels=&template=feature_request.md&title=)
+    - type: textarea
+      id: textarea1
+      attributes:
+          label: Is your feature request related to a problem? Please describe
+          placeholder: A clear and concise description of what the problem is. Eg. I'm always frustrated when [...]
+      validations:
+          required: true
+    - type: textarea
+      id: textarea2
+      attributes:
+          label: Describe the solution you'd like
+          placeholder: A clear and concise description of what you want to happen.
+      validations:
+          required: true
+    - type: textarea
+      id: textarea3
+      attributes:
+          label: Describe alternatives you've considered
+          placeholder: A clear and concise description of any alternative solutions or features you've considered.
+      validations:
+          required: true
+    - type: textarea
+      id: textarea4
+      attributes:
+          label: Additional context
+          placeholder: Add any other context or screenshots about the feature request here.
+      validations:
+          required: true
@@ -1,43 +1,57 @@
 name: New device support request
 description: Request support for a new device
-title: "[New device support]: "
+title: '[New device support]: '
 labels: [new device support]
 body:
-  - type: markdown
-    attributes:
-      value: |
-        **IMPORTANT:** Before submitting:
-        - Make sure this device is not already supported in the dev branch by checking the [dev branch changelog](https://gist.github.com/Koenkk/bfd4c3d1725a2cccacc11d6ba51008ba#new-supported-devices)
-        - Make sure there is no existing issue or PR for this device already, search for your device here: https://github.com/Koenkk/zigbee2mqtt/issues
-        - Follow this [guide](https://www.zigbee2mqtt.io/advanced/support-new-devices/01_support_new_devices.html)
-        - If you are using the Home Assistant addon and are still on 1.18.1, check the first point of [this](https://github.com/Koenkk/zigbee2mqtt/releases/tag/1.19.0)
-  - type: input
-    id: link
-    attributes:
-      label: Link
-      description: Link of this device (product page)
-      placeholder: https://www.linktomydevice.org
-    validations:
-      required: true
-  - type: input
-    id: database
-    attributes:
-      label: Database entry
-      description: Entry of this device in `data/database.db` after pairing it
-      placeholder: '{"id":53,"type":"Router","ieeeAddr":"0x10458d00024284f69","nwkAddr":10148,"manufId":4151,"manufName":"LUMI","powerSource":"DC Source","modelId":"lumi.relay.c2acn01","epList":[1,2],"endpoints":{"1":{"profId":260,"epId":1,"devId":257,"inClusterList":[0,3,4,5,1,2,10,6,16,2820,12],"outClusterList":[25,10],"clusters":{"genBasic":{"attributes":{"modelId":"lumi.relay.c2acn01","appVersion":1,"manufacturerName":"LUMI","powerSource":4,"zclVersion":0,"stackVersion":2,"hwVersion":18,"dateCode":"8-6-2020"}},"genAnalogInput":{"attributes":{"presentValue":129.04425048828125}},"genOnOff":{"attributes":{"61440":117440715,"onOff":1}}},"binds":[],"configuredReportings":[],"meta":{}},"2":{"profId":260,"epId":2,"devId":257,"inClusterList":[6,16,4,5],"outClusterList":[],"clusters":{"genOnOff":{"attributes":{"61440":237478966,"onOff":0}}},"binds":[],"configuredReportings":[],"meta":{}}},"appVersion":1,"stackVersion":2,"hwVersion":18,"dateCode":"8-6-2020","zclVersion":0,"interviewCompleted":true,"meta":{},"lastSeen":1640285631405}'
-    validations:
-      required: true
-  - type: textarea
-    id: notes
-    attributes:
-      label: Comments
-      placeholder: I tried to follow the supporting new device page but got stuck at...
-    validations:
-      required: true
-  - type: textarea
-    attributes:
-      label: External definition
-      description: See [Creating the external definition](https://www.zigbee2mqtt.io/advanced/support-new-devices/01_support_new_devices.html#_2-creating-the-external-definition)
-      render: shell
-    validations:
-      required: true
+    - type: markdown
+      attributes:
+          value: |
+              **IMPORTANT:** Before submitting:
+              - Make sure this device is not already supported in the dev branch by checking the [dev branch changelog](https://gist.github.com/Koenkk/bfd4c3d1725a2cccacc11d6ba51008ba#new-supported-devices)
+              - Make sure there is no existing issue or PR for this device already, search for your device here: https://github.com/Koenkk/zigbee2mqtt/issues
+              - Follow this [guide](https://www.zigbee2mqtt.io/advanced/support-new-devices/01_support_new_devices.html)
+              - If you are using the Home Assistant addon and are still on 1.18.1, check the first point of [this](https://github.com/Koenkk/zigbee2mqtt/releases/tag/1.19.0)
+    - type: input
+      id: link
+      attributes:
+          label: Link
+          description: Link of this device (product page)
+          placeholder: https://www.linktomydevice.org
+      validations:
+          required: true
+    - type: input
+      id: database
+      attributes:
+          label: Database entry
+          description: Entry of this device in `data/database.db` after pairing it
+          placeholder: '{"id":53,"type":"Router","ieeeAddr":"0x10458d00024284f69","nwkAddr":10148,"manufId":4151,"manufName":"LUMI","powerSource":"DC Source","modelId":"lumi.relay.c2acn01","epList":[1,2],"endpoints":{"1":{"profId":260,"epId":1,"devId":257,"inClusterList":[0,3,4,5,1,2,10,6,16,2820,12],"outClusterList":[25,10],"clusters":{"genBasic":{"attributes":{"modelId":"lumi.relay.c2acn01","appVersion":1,"manufacturerName":"LUMI","powerSource":4,"zclVersion":0,"stackVersion":2,"hwVersion":18,"dateCode":"8-6-2020"}},"genAnalogInput":{"attributes":{"presentValue":129.04425048828125}},"genOnOff":{"attributes":{"61440":117440715,"onOff":1}}},"binds":[],"configuredReportings":[],"meta":{}},"2":{"profId":260,"epId":2,"devId":257,"inClusterList":[6,16,4,5],"outClusterList":[],"clusters":{"genOnOff":{"attributes":{"61440":237478966,"onOff":0}}},"binds":[],"configuredReportings":[],"meta":{}}},"appVersion":1,"stackVersion":2,"hwVersion":18,"dateCode":"8-6-2020","zclVersion":0,"interviewCompleted":true,"meta":{},"lastSeen":1640285631405}'
+      validations:
+          required: true
+    - type: input
+      id: z2m_version
+      attributes:
+          label: Zigbee2MQTT version
+          description: Can be found in the frontend -> settings -> about -> Zigbee2MQTT version. Are you running Zigbee2MQTT 1.18.1? Then read [this](https://github.com/Koenkk/zigbee2mqtt/releases/tag/1.19.0).
+          placeholder: '1.22.1'
+      validations:
+          required: true
+    - type: textarea
+      id: notes
+      attributes:
+          label: Comments
+          placeholder: I tried to follow the supporting new device page but got stuck at...
+      validations:
+          required: true
+    - type: textarea
+      attributes:
+          label: External definition
+          description: See [Creating the external definition](https://www.zigbee2mqtt.io/advanced/support-new-devices/01_support_new_devices.html#_2-creating-the-external-definition)
+          render: shell
+      validations:
+          required: true
+    - type: textarea
+      attributes:
+          label: What does/doesn't work with the external definition?
+          description: Indicate what works and what doesn't work with the external definition.
+      validations:
+          required: true
@@ -2,75 +2,78 @@ name: Problem report
 description: Create a report to help us improve
 labels: [problem]
 body:
-  - type: markdown
-    attributes:
-      value: |
-        **IMPORTANT:** Before submitting:
-        - You read the [FAQ](https://www.zigbee2mqtt.io/guide/faq/)
-        - Are you using an EZSP adapter (e.g. Dongle-E/SkyConnect)? Try the [new driver](https://github.com/Koenkk/zigbee2mqtt/discussions/21462) 
-        - Zigbee2MQTT fails to start? Read [this](https://www.zigbee2mqtt.io/guide/installation/20_zigbee2mqtt-fails-to-start.html)
-        - Make sure the bug also occurs in the [dev branch](https://www.zigbee2mqtt.io/advanced/more/switch-to-dev-branch.html)
-        - Make sure you are using the [latest firmware](https://www.zigbee2mqtt.io/guide/adapters/#recommended) on your adapter
-        - The issue has not been [reported already](https://github.com/Koenkk/zigbee2mqtt/issues)
-        - Is your issue related to the frontend? Then click [here](https://github.com/nurikk/zigbee2mqtt-frontend/issues/new?assignees=&labels=bug%2Ctriage&template=bug_report.yaml&title=%5BBug%5D%3A+)
-        - If you are using the Home Assistant addon and are still on 1.18.1, check the first point of [this](https://github.com/Koenkk/zigbee2mqtt/releases/tag/1.19.0)
-  - type: textarea
-    id: what_happend
-    attributes:
-      label: What happened?
-    validations:
-      required: true
-  - type: textarea
-    id: expect_to_happen
-    attributes:
-      label: What did you expect to happen?
-      placeholder: I expected that ...
-    validations:
-      required: false
-  - type: textarea
-    id: reproduce
-    attributes:
-      label: How to reproduce it (minimal and precise)
-      placeholder: First do this, then this..
-    validations:
-      required: false
-  - type: input
-    id: z2m_version
-    attributes:
-      label: Zigbee2MQTT version
-      description: Can be found in the frontend -> settings -> about -> Zigbee2MQTT version. Are you running Zigbee2MQTT 1.18.1? Then read [this](https://github.com/Koenkk/zigbee2mqtt/releases/tag/1.19.0).
-      placeholder: '1.22.1'
-    validations:
-      required: true
-  - type: input
-    id: adapter_fwversion
-    attributes:
-      label: Adapter firmware version
-      description: Can be found in the frontend -> settings -> about -> coordinator revision
-      placeholder: '20211210'
-    validations:
-      required: true
-  - type: input
-    id: adapter
-    attributes:
-      label: Adapter
-      description: The adapter you are using
-      placeholder: Electrolama zig-a-zig-ah! (zzh!), Slaesh's CC2652RB stick, ...
-    validations:
-      required: true
-  - type: input
-    id: setup
-    attributes:
-      label: Setup
-      description: How do you run Z2M (plain, add-on...) and on what machine (Pi, x86-64, containerized...)?
-      placeholder: Add-on on Home Assistant OS on Intel NUC, Plain on Docker container, ...
-    validations:
-      required: true
-  - type: textarea
-    id: log
-    attributes:
-      label: Debug log
-      description: After enabling [debug logging](https://www.zigbee2mqtt.io/guide/usage/debug.html) the log can be found under `data/log`. Attach the file below
-      placeholder: Click here and drag the file into it or click on "Attach files by.." below
-    validations:
-      required: false
+    - type: markdown
+      attributes:
+          value: |
+              **IMPORTANT:** Before submitting:
+              - Zigbee2MQTT fails to start? Read [this](https://www.zigbee2mqtt.io/guide/installation/20_zigbee2mqtt-fails-to-start.html)
+              - Raspberry Pi users? Make sure to check [this](https://www.zigbee2mqtt.io/guide/installation/20_zigbee2mqtt-fails-to-start_crashes-runtime.html#raspberry-pi-users-use-a-good-power-supply)
+              - You read the [FAQ](https://www.zigbee2mqtt.io/guide/faq/)
+              - Are you using an EZSP adapter (e.g. Dongle-E/SkyConnect)? Try the [new driver](https://github.com/Koenkk/zigbee2mqtt/discussions/21462) 
+              - Make sure the bug also occurs in the [dev branch](https://www.zigbee2mqtt.io/advanced/more/switch-to-dev-branch.html)
+              - Make sure you are using the [latest firmware](https://www.zigbee2mqtt.io/guide/adapters/#recommended) on your adapter
+              - The issue has not been [reported already](https://github.com/Koenkk/zigbee2mqtt/issues)
+              - Is your issue related to the frontend? Then click [here](https://github.com/nurikk/zigbee2mqtt-frontend/issues/new?assignees=&labels=bug%2Ctriage&template=bug_report.yaml&title=%5BBug%5D%3A+)
+              - If you are using the Home Assistant addon and are still on 1.18.1, check the first point of [this](https://github.com/Koenkk/zigbee2mqtt/releases/tag/1.19.0)
+    - type: textarea
+      id: what_happend
+      attributes:
+          label: What happened?
+      validations:
+          required: true
+    - type: textarea
+      id: expect_to_happen
+      attributes:
+          label: What did you expect to happen?
+          placeholder: I expected that ...
+      validations:
+          required: false
+    - type: textarea
+      id: reproduce
+      attributes:
+          label: How to reproduce it (minimal and precise)
+          placeholder: First do this, then this..
+      validations:
+          required: false
+    - type: input
+      id: z2m_version
+      attributes:
+          label: Zigbee2MQTT version
+          description: Can be found in the frontend -> settings -> about -> Zigbee2MQTT version. Are you running Zigbee2MQTT 1.18.1? Then read [this](https://github.com/Koenkk/zigbee2mqtt/releases/tag/1.19.0).
+          placeholder: '1.22.1'
+      validations:
+          required: true
+    - type: input
+      id: adapter_fwversion
+      attributes:
+          label: Adapter firmware version
+          description: Can be found in the frontend -> settings -> about -> coordinator revision
+          placeholder: '20211210'
+      validations:
+          required: true
+    - type: input
+      id: adapter
+      attributes:
+          label: Adapter
+          description: The adapter you are using. In case of EZSP, try the [new `ember` driver](https://github.com/Koenkk/zigbee2mqtt/discussions/21462) first.
+          placeholder: Electrolama zig-a-zig-ah! (zzh!), Slaesh's CC2652RB stick, ...
+      validations:
+          required: true
+    - type: textarea
+      id: setup
+      attributes:
+          label: Setup
+          description: |-
+              How do you run Z2M (plain, add-on...) and on what machine (Pi, x86-64, containerized...)?
+              When running on Linux also include output of: `uname -a && cat /etc/issue.net`
+          placeholder: Add-on on Home Assistant OS on Intel NUC, Plain on Docker container, ...
+      validations:
+          required: true
+    - type: textarea
+      id: log
+      attributes:
+          label: Debug log
+          description: After enabling [debug logging](https://www.zigbee2mqtt.io/guide/configuration/logging.html#debugging) the log can be found under `data/log`. Attach the file below
+          placeholder: Click here and drag the file into it or click on "Attach files by.." below
+      validations:
+          required: false
@@ -1,64 +1,64 @@
 name: Wrong device picture/vendor/model/description
 description: Use if device is detected as supported and is fully functional but has a wrong picture, vendor, model or description
-title: "[Wrong device]: "
+title: '[Wrong device]: '
 labels: [wrong device]
 body:
-  - type: markdown
-    attributes:
-      value: |
-        Only use this if the device is detected as **supported** and is **fully functional** but has a wrong picture, vendor, model or description.
-  - type: input
-    id: link
-    attributes:
-      label: Link
-      description: Link of this device (product page)
-      placeholder: https://www.linktomydevice.org
-    validations:
-      required: true
-  - type: input
-    id: model
-    attributes:
-      label: Model
-      description: Expected model, model that is printed on the device, for TuYa device this is NOT something like TS0601 or _TZE200_cf1sl3tj
-      placeholder: RTCGQ01LM
-    validations:
-      required: true
-  - type: input
-    id: description
-    attributes:
-      label: Description
-      description: Expected description
-      placeholder: Motion sensor
-    validations:
-      required: true
-  - type: input
-    id: vendor
-    attributes:
-      label: Vendor
-      description: Expected vendor
-      placeholder: Xiaomi
-    validations:
-      required: true
-  - type: input
-    id: picture
-    attributes:
-      label: Picture (link)
-      description: Expected picture
-      placeholder: https://www.linktomydevice.org/RTCGQ01LM.jpg
-    validations:
-      required: true
-  - type: input
-    id: database
-    attributes:
-      label: Database entry
-      description: Entry of this device in `data/database.db` after pairing it
-      placeholder: '{"id":53,"type":"Router","ieeeAddr":"0x10458d00024284f69","nwkAddr":10148,"manufId":4151,"manufName":"LUMI","powerSource":"DC Source","modelId":"lumi.relay.c2acn01","epList":[1,2],"endpoints":{"1":{"profId":260,"epId":1,"devId":257,"inClusterList":[0,3,4,5,1,2,10,6,16,2820,12],"outClusterList":[25,10],"clusters":{"genBasic":{"attributes":{"modelId":"lumi.relay.c2acn01","appVersion":1,"manufacturerName":"LUMI","powerSource":4,"zclVersion":0,"stackVersion":2,"hwVersion":18,"dateCode":"8-6-2020"}},"genAnalogInput":{"attributes":{"presentValue":129.04425048828125}},"genOnOff":{"attributes":{"61440":117440715,"onOff":1}}},"binds":[],"configuredReportings":[],"meta":{}},"2":{"profId":260,"epId":2,"devId":257,"inClusterList":[6,16,4,5],"outClusterList":[],"clusters":{"genOnOff":{"attributes":{"61440":237478966,"onOff":0}}},"binds":[],"configuredReportings":[],"meta":{}}},"appVersion":1,"stackVersion":2,"hwVersion":18,"dateCode":"8-6-2020","zclVersion":0,"interviewCompleted":true,"meta":{},"lastSeen":1640285631405}'
-    validations:
-      required: true
-  - type: textarea
-    id: notes
-    attributes:
-      label: Notes
-      placeholder: Some additional notes...
-    validations:
-      required: false
+    - type: markdown
+      attributes:
+          value: |
+              Only use this if the device is detected as **supported** and is **fully functional** but has a wrong picture, vendor, model or description.
+    - type: input
+      id: link
+      attributes:
+          label: Link
+          description: Link of this device (product page)
+          placeholder: https://www.linktomydevice.org
+      validations:
+          required: true
+    - type: input
+      id: model
+      attributes:
+          label: Model
+          description: Expected model, model that is printed on the device, for Tuya device this is NOT something like TS0601 or _TZE200_cf1sl3tj
+          placeholder: RTCGQ01LM
+      validations:
+          required: true
+    - type: input
+      id: description
+      attributes:
+          label: Description
+          description: Expected description
+          placeholder: Motion sensor
+      validations:
+          required: true
+    - type: input
+      id: vendor
+      attributes:
+          label: Vendor
+          description: Expected vendor
+          placeholder: Xiaomi
+      validations:
+          required: true
+    - type: input
+      id: picture
+      attributes:
+          label: Picture (link)
+          description: Expected picture
+          placeholder: https://www.linktomydevice.org/RTCGQ01LM.jpg
+      validations:
+          required: true
+    - type: input
+      id: database
+      attributes:
+          label: Database entry
+          description: Entry of this device in `data/database.db` after pairing it
+          placeholder: '{"id":53,"type":"Router","ieeeAddr":"0x10458d00024284f69","nwkAddr":10148,"manufId":4151,"manufName":"LUMI","powerSource":"DC Source","modelId":"lumi.relay.c2acn01","epList":[1,2],"endpoints":{"1":{"profId":260,"epId":1,"devId":257,"inClusterList":[0,3,4,5,1,2,10,6,16,2820,12],"outClusterList":[25,10],"clusters":{"genBasic":{"attributes":{"modelId":"lumi.relay.c2acn01","appVersion":1,"manufacturerName":"LUMI","powerSource":4,"zclVersion":0,"stackVersion":2,"hwVersion":18,"dateCode":"8-6-2020"}},"genAnalogInput":{"attributes":{"presentValue":129.04425048828125}},"genOnOff":{"attributes":{"61440":117440715,"onOff":1}}},"binds":[],"configuredReportings":[],"meta":{}},"2":{"profId":260,"epId":2,"devId":257,"inClusterList":[6,16,4,5],"outClusterList":[],"clusters":{"genOnOff":{"attributes":{"61440":237478966,"onOff":0}}},"binds":[],"configuredReportings":[],"meta":{}}},"appVersion":1,"stackVersion":2,"hwVersion":18,"dateCode":"8-6-2020","zclVersion":0,"interviewCompleted":true,"meta":{},"lastSeen":1640285631405}'
+      validations:
+          required: true
+    - type: textarea
+      id: notes
+      attributes:
+          label: Notes
+          placeholder: Some additional notes...
+      validations:
+          required: false
@@ -1,13 +1,25 @@
 version: 2
 updates:
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      interval: "daily"
-    target-branch: dev
-
-  - package-ecosystem: "docker"
-    directory: "/docker"
-    schedule:
-      interval: "daily"
-    target-branch: dev
+    - package-ecosystem: npm
+      directory: /
+      schedule:
+          interval: weekly
+      target-branch: dev
+      commit-message:
+        prefix: fix(ignore)
+      groups:
+          minor-patch:
+              applies-to: version-updates
+              update-types:
+                  - minor
+                  - patch
+    - package-ecosystem: docker
+      directory: /
+      schedule:
+        interval: weekly
+      target-branch: dev
+    - package-ecosystem: github-actions
+      directory: /
+      schedule:
+        interval: weekly
+      target-branch: dev
@@ -1,139 +1,221 @@
-name: ci
+name: CI

-on: [pull_request, push]
+on:
+  push:
+    tags:        
+      - '**' 
+    branches-ignore:
+      - dev-types
+  pull_request:

 permissions:
-  contents: write
-  pull-requests: write
+    contents: write
+    pull-requests: write

 jobs:
-  ci:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-      if: (github.ref == 'refs/heads/dev' || startsWith(github.ref, 'refs/tags/')) && github.event_name == 'push'
-      with:
-        # Required for `release: merge dev -> master and promote dev`
-        token: ${{secrets.GH_TOKEN}}
-    - uses: actions/checkout@v4
-      if: ((github.ref == 'refs/heads/dev' || startsWith(github.ref, 'refs/tags/')) && github.event_name == 'push') == false
-    - uses: actions/setup-node@v4
-      with:
-        node-version: 20
-        registry-url: https://registry.npmjs.org/
-        cache: npm
-    - name: Install dependencies
-      run: npm ci
-    - name: Build
-      run: npm run build
-    - name: Test
-      run: npm run test-with-coverage
-    - name: Lint
-      run: npm run eslint
-    - name: Docker login
-      if: (github.ref == 'refs/heads/dev' || startsWith(github.ref, 'refs/tags/')) && github.event_name == 'push'
-      run: echo ${{ secrets.DOCKER_KEY }} | docker login -u koenkk --password-stdin
-    - name: Docker login ghcr.io
-      if: (github.ref == 'refs/heads/dev' || startsWith(github.ref, 'refs/tags/')) && github.event_name == 'push'
-      run: echo ${{ secrets.GH_TOKEN }} | docker login ghcr.io -u koenkk --password-stdin
-    - name: Docker setup - QEMU
-      if: (github.ref == 'refs/heads/dev' || startsWith(github.ref, 'refs/tags/')) && github.event_name == 'push'
-      uses: docker/setup-qemu-action@v3
-      with:
-        platforms: all
-    - name: Docker setup - Buildx
-      if: (github.ref == 'refs/heads/dev' || startsWith(github.ref, 'refs/tags/')) && github.event_name == 'push'
-      id: buildx
-      uses: docker/setup-buildx-action@v3
-      with:
-        version: latest
-    - name: "dev: Docker build"
-      if: github.ref == 'refs/heads/dev' && github.event_name == 'push'
-      run: |
-        docker buildx build \
-          --build-arg COMMIT=$(git rev-parse --short HEAD) \
-          --platform linux/arm64/v8,linux/386,linux/amd64,linux/arm/v6,linux/arm/v7 \
-          -f docker/Dockerfile \
-          --provenance=false \
-          --push \
-          -t koenkk/zigbee2mqtt:latest-dev -t ghcr.io/koenkk/zigbee2mqtt:latest-dev \
-          .
-    - name: "release: Docker build"
-      if: startsWith(github.ref, 'refs/tags/') && github.event_name == 'push'
-      run: |
-        TAG="$(git describe --tags)"
-        docker buildx build \
-          --build-arg COMMIT=$(git rev-parse --short HEAD) \
-          --platform linux/arm64/v8,linux/386,linux/amd64,linux/arm/v6,linux/arm/v7 \
-          -f docker/Dockerfile \
-          --provenance=false \
-          --push \
-          -t koenkk/zigbee2mqtt:latest -t "koenkk/zigbee2mqtt:$TAG" -t ghcr.io/koenkk/zigbee2mqtt:latest -t "ghcr.io/koenkk/zigbee2mqtt:$TAG" \
-          .
-    - name: "release: Publish to npm"
-      if: startsWith(github.ref, 'refs/tags/') && github.event_name == 'push'
-      run: npm publish
-      env:
-        NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN }}
-    - name: "dev: Trigger zigbee2mqtt/hassio-zigbee2mqtt build"
-      if: github.ref == 'refs/heads/dev' && github.event_name == 'push'
-      run: |
-        curl \
-          -X POST \
-          -H "Authorization: token ${{ secrets.GH_TOKEN }}" \
-          -H "Accept: application/vnd.github.v3+json" \
-          https://api.github.com/repos/zigbee2mqtt/hassio-zigbee2mqtt/actions/workflows/ci.yml/dispatches \
-          -d '{"ref":"master","inputs":{}}'
-    - name: "release: Trigger zigbee2mqtt/hassio-zigbee2mqtt build"
-      if: startsWith(github.ref, 'refs/tags/') && github.event_name == 'push'
-      run: |
-        TAG=${GITHUB_REF#refs/*/}
-        echo "Triggering with tag '$TAG'"
-        curl \
-          -X POST \
-          -H "Authorization: token ${{ secrets.GH_TOKEN }}" \
-          -H "Accept: application/vnd.github.everest-preview+json" \
-          -H "Content-Type: application/json" \
-          https://api.github.com/repos/zigbee2mqtt/hassio-zigbee2mqtt/dispatches \
-          --data "{\"event_type\": \"release\", \"client_payload\": { \"version\": \"$TAG-1\"}}"
-    - name: "release: merge dev -> master and promote dev"
-      if: startsWith(github.ref, 'refs/tags/') && github.event_name == 'push'  
-      run: |
-        TAG=${GITHUB_REF#refs/*/}
-        git config --local user.email "41898282+github-actions[bot]@users.noreply.github.com"
-        git config --local user.name "github-actions[bot]"
-        git fetch --unshallow
-        git fetch origin
-        git checkout master
-        git merge --ff-only origin/dev
-        git push origin master
-        git checkout dev
-        jq ".version = \"$TAG-dev\"" package.json > package.json.tmp
-        jq ".version = \"$TAG-dev\"" package-lock.json > package-lock.json.tmp
-        mv package.json.tmp package.json
-        mv package-lock.json.tmp package-lock.json
-        git add -A
-        git commit -m "chore: promote to dev"
-        git push origin dev
+    ci:
+        runs-on: ubuntu-latest
+        permissions:
+            id-token: write
+        steps:
+            - uses: actions/checkout@v4
+              if: (github.ref == 'refs/heads/dev' || startsWith(github.ref, 'refs/tags/')) && github.event_name == 'push'
+              with:
+                  # Required for `release: merge dev -> master and promote dev`
+                  token: ${{ secrets.GH_TOKEN }}

-  tests:
-    strategy:
-      matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
-        node: [18, 20]
-    runs-on: ${{ matrix.os }}
-    continue-on-error: true
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: ${{ matrix.node }}
-          registry-url: https://registry.npmjs.org/
-          cache: 'npm'
-      - name: Install dependencies
-        # --ignore-scripts prevents the serialport build which often fails on Windows
-        run: npm ci --ignore-scripts
-      - name: Build
-        run: npm run build
-      - name: Test
-        run: npm run test-with-coverage
+            - uses: actions/checkout@v4
+              if: ((github.ref == 'refs/heads/dev' || startsWith(github.ref, 'refs/tags/')) && github.event_name == 'push') == false
+
+            - uses: pnpm/action-setup@v4
+
+            - uses: actions/setup-node@v4
+              with:
+                  node-version: 24
+                  registry-url: https://registry.npmjs.org/
+                  cache: pnpm
+
+            - name: Install dependencies
+              run: pnpm i --frozen-lockfile
+
+            - name: Check
+              run: pnpm run check
+
+            - name: Build
+              run: pnpm run build
+
+            - name: Test
+              run: pnpm run test:coverage
+
+            - 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
+              with:
+                  username: koenkk
+                  password: ${{ secrets.DOCKER_KEY }}
+
+            - name: Log in to the GitHub container registry
+              if: (github.ref == 'refs/heads/dev' || startsWith(github.ref, 'refs/tags/')) && github.event_name == 'push'
+              uses: docker/login-action@v3
+              with:
+                  registry: ghcr.io
+                  username: koenkk
+                  password: ${{ secrets.GH_TOKEN }}
+
+            - name: Docker setup - QEMU
+              if: (github.ref == 'refs/heads/dev' || startsWith(github.ref, 'refs/tags/')) && github.event_name == 'push'
+              uses: docker/setup-qemu-action@v3
+              with:
+                  platforms: all
+
+            - name: Docker setup - Buildx
+              if: (github.ref == 'refs/heads/dev' || startsWith(github.ref, 'refs/tags/')) && github.event_name == 'push'
+              id: buildx
+              uses: docker/setup-buildx-action@v3
+              with:
+                  version: latest
+
+            - name: dev - Docker build and push
+              if: github.ref == 'refs/heads/dev' && github.event_name == 'push'
+              uses: docker/build-push-action@v6
+              with:
+                  context: .
+                  file: docker/Dockerfile
+                  platforms: linux/arm64/v8,linux/amd64,linux/arm/v6,linux/arm/v7,linux/riscv64,linux/386
+                  tags: koenkk/zigbee2mqtt:latest-dev,ghcr.io/koenkk/zigbee2mqtt:latest-dev
+                  push: true
+                  build-args: |
+                      COMMIT=${{ github.sha }}
+                      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
+              id: meta
+              with:
+                  images: |
+                      koenkk/zigbee2mqtt
+                      ghcr.io/koenkk/zigbee2mqtt
+                  tags: |
+                      type=semver,pattern={{version}}
+                      type=semver,pattern={{major}}.{{minor}}
+                      type=semver,pattern={{major}}
+
+            - name: release - Docker build and push
+              if: startsWith(github.ref, 'refs/tags/') && github.event_name == 'push'
+              uses: docker/build-push-action@v6
+              with:
+                  context: .
+                  file: docker/Dockerfile
+                  platforms: linux/arm64/v8,linux/amd64,linux/arm/v6,linux/arm/v7,linux/riscv64,linux/386
+                  tags: ${{ steps.meta.outputs.tags }}
+                  push: true
+                  build-args: |
+                      COMMIT=${{ github.sha }}
+                      VERSION=${{ github.ref_name }}
+                      DATE=${{ github.event.repository.updated_at }}
+
+            - name: 'release: Publish to npm'
+              if: startsWith(github.ref, 'refs/tags/') && github.event_name == 'push'
+              run: pnpm publish --no-git-checks
+              env:
+                  NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN }}
+                  NPM_CONFIG_PROVENANCE: true
+
+            - name: 'dev: Trigger zigbee2mqtt/hassio-zigbee2mqtt build'
+              if: github.ref == 'refs/heads/dev' && github.event_name == 'push'
+              run: |
+                  curl \
+                    -X POST \
+                    -H "Authorization: token ${{ secrets.GH_TOKEN }}" \
+                    -H "Accept: application/vnd.github.v3+json" \
+                    https://api.github.com/repos/zigbee2mqtt/hassio-zigbee2mqtt/actions/workflows/ci.yml/dispatches \
+                    -d '{"ref":"master","inputs":{}}'
+
+            - name: 'release: Trigger zigbee2mqtt/hassio-zigbee2mqtt build'
+              if: startsWith(github.ref, 'refs/tags/') && github.event_name == 'push'
+              run: |
+                  TAG=${GITHUB_REF#refs/*/}
+                  echo "Triggering with tag '$TAG'"
+                  curl \
+                    -X POST \
+                    -H "Authorization: token ${{ secrets.GH_TOKEN }}" \
+                    -H "Accept: application/vnd.github.everest-preview+json" \
+                    -H "Content-Type: application/json" \
+                    https://api.github.com/repos/zigbee2mqtt/hassio-zigbee2mqtt/dispatches \
+                    --data "{\"event_type\": \"release\", \"client_payload\": { \"version\": \"$TAG-1\"}}"
+
+            - name: 'release: Trigger zigbee2mqtt-chart image update'
+              if: startsWith(github.ref, 'refs/tags/') && github.event_name == 'push'
+              run: |
+                  TAG=${GITHUB_REF#refs/*/}
+                  echo "Triggering with tag '$TAG'"
+                  curl -L \
+                    -X POST \
+                    -H "Accept: application/vnd.github+json" \
+                    -H "Authorization: Bearer ${{ secrets.GH_TOKEN }}" \
+                    -H "X-GitHub-Api-Version: 2022-11-28" \
+                    https://api.github.com/repos/Koenkk/zigbee2mqtt-chart/actions/workflows/on_zigbee2mqtt_release.yaml/dispatches \
+                    --data "{\"ref\": \"main\", \"inputs\": { \"zigbee2mqtt_version\": \"$TAG\"}}"
+
+            - name: 'release: merge dev -> master and promote dev'
+              if: startsWith(github.ref, 'refs/tags/') && github.event_name == 'push'
+              run: |
+                  TAG=${GITHUB_REF#refs/*/}
+                  git config --local user.email "41898282+github-actions[bot]@users.noreply.github.com"
+                  git config --local user.name "github-actions[bot]"
+                  git fetch --unshallow
+                  git fetch origin
+                  git checkout master
+                  git merge --ff-only origin/dev
+                  git push origin master
+                  git checkout dev
+                  jq --indent 4 ".version = \"$TAG-dev\"" package.json > package.json.tmp
+                  mv package.json.tmp package.json
+                  git add -A
+                  git commit -m "chore: promote to dev"
+                  git push origin dev
+
+    tests:
+        strategy:
+            matrix:
+                os: [ubuntu-latest, macos-latest, windows-latest]
+                node: [20, 22, 24]
+        runs-on: ${{ matrix.os }}
+        continue-on-error: true
+        steps:
+            - uses: actions/checkout@v4
+
+            - uses: pnpm/action-setup@v4
+
+            - uses: actions/setup-node@v4
+              with:
+                  node-version: ${{ matrix.node }}
+                  cache: pnpm
+
+            - name: Install dependencies
+              # --ignore-scripts prevents build on Windows (only for unix-dgram, so doesn't matter, others have pre-builds)
+              run: pnpm i --frozen-lockfile ${{ matrix.os == 'windows-latest' && '--ignore-scripts' || '' }}
+
+            - name: Build
+              run: pnpm run build
+
+            - name: Test
+              run: pnpm run test:coverage
@@ -1,23 +0,0 @@
-name: codeql
-
-on:
-  push:
-    branches:
-      - dev
-
-jobs:
-  CodeQL-Build:
-    runs-on: ubuntu-latest
-
-    permissions:
-      security-events: write
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-      - name: Initialize CodeQL
-        uses: github/codeql-action/init@v3
-      - name: Autobuild
-        uses: github/codeql-action/autobuild@v3
-      - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v3
@@ -0,0 +1,15 @@
+name: Dependency review
+
+on: [pull_request]
+
+permissions:
+    contents: read
+
+jobs:
+    dependency-review:
+        runs-on: ubuntu-latest
+        steps:
+            - name: 'Checkout repository'
+              uses: actions/checkout@v4
+            - name: 'Dependency review'
+              uses: actions/dependency-review-action@v4
@@ -1,14 +0,0 @@
-name: deps-review
-on: [pull_request]
-
-permissions:
-  contents: read
-
-jobs:
-  dependency-review:
-    runs-on: ubuntu-latest
-    steps:
-      - name: 'Checkout repository'
-        uses: actions/checkout@v4
-      - name: 'Dependency review'
-        uses: actions/dependency-review-action@v4
@@ -0,0 +1,19 @@
+name: Fail PR to master
+
+on:
+    pull_request:
+        branches:
+            - master
+
+jobs:
+    fail-pr-to-master:
+        runs-on: ubuntu-latest
+        steps:
+            - name: Fail PR to master
+              run: |
+                  if [[ "${{ github.event.pull_request.title }}" == "chore(dev): release"* ]]; then
+                    echo "PR title starts with 'chore(dev): release', allowing PR"
+                  else
+                    echo "Pull requests to the master branch are not allowed, target dev branch"
+                    exit 1
+                  fi
@@ -0,0 +1,34 @@
+on:
+    workflow_dispatch:
+
+name: GHCR cleanup
+
+permissions: {}
+jobs:
+    build:
+        runs-on: ubuntu-latest
+
+        steps:
+            - name: Delete untagged images
+              uses: actions/github-script@v7
+              with:
+                  github-token: ${{ secrets.GH_TOKEN }}
+                  script: |
+                      const response = await github.request("GET /${{ env.OWNER }}/packages/container/${{ env.PACKAGE_NAME }}/versions",
+                        { per_page: ${{ env.PER_PAGE }}
+                      });
+                      for(version of response.data) {
+                          if (version.metadata.container.tags.length == 0) {
+                              try {
+                                  console.log("delete " + version.id)
+                                  const deleteResponse = await github.request("DELETE /${{ env.OWNER }}/packages/container/${{ env.PACKAGE_NAME }}/versions/" + version.id, { });
+                                  console.log("status " + deleteResponse.status)
+                              } catch (e) {
+                                  console.log("failed")
+                              }
+                          }
+                      }
+              env:
+                  OWNER: user
+                  PACKAGE_NAME: zigbee2mqtt
+                  PER_PAGE: 2000
@@ -1,34 +0,0 @@
-on:
-  workflow_dispatch:
-
-name: ghcr-cleanup
-
-permissions: {}
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Delete untagged images
-        uses: actions/github-script@v7
-        with:
-          github-token: ${{ secrets.GH_TOKEN }}
-          script: |
-            const response = await github.request("GET /${{ env.OWNER }}/packages/container/${{ env.PACKAGE_NAME }}/versions",
-              { per_page: ${{ env.PER_PAGE }}
-            });
-            for(version of response.data) {
-                if (version.metadata.container.tags.length == 0) {
-                    try {
-                        console.log("delete " + version.id)
-                        const deleteResponse = await github.request("DELETE /${{ env.OWNER }}/packages/container/${{ env.PACKAGE_NAME }}/versions/" + version.id, { });
-                        console.log("status " + deleteResponse.status)
-                    } catch (e) {
-                        console.log("failed")
-                    }
-                }
-            }
-        env:
-          OWNER: user
-          PACKAGE_NAME: zigbee2mqtt
-          PER_PAGE: 2000
@@ -0,0 +1,19 @@
+name: Merge master to dev
+
+on:
+    push:
+        branches:
+            - master
+
+jobs:
+    merge-master-to-dev:
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v4
+            - uses: devmasx/merge-branch@master
+              with:
+                  type: now
+                  head_to_merge: master
+                  target_branch: dev
+                  message: 'chore: merge master to dev'
+                  github_token: ${{ secrets.GH_TOKEN }}
@@ -1,19 +0,0 @@
-name: merge-master-to-dev
-
-on:
-  push:
-    branches:
-      - master
-
-jobs:
-  merge_master_to_dev:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: devmasx/merge-branch@master
-        with:
-          type: now
-          head_to_merge: master
-          target_branch: dev
-          message: "chore: merge master to dev"
-          github_token: ${{ secrets.GH_TOKEN }}
@@ -0,0 +1,73 @@
+on:
+    push:
+        branches:
+            - dev
+
+permissions:
+    contents: write
+    pull-requests: write
+
+name: Release Please
+
+jobs:
+    release-please:
+        runs-on: ubuntu-latest
+        outputs:
+            release_created: ${{ steps.release.outputs.release_created }}
+            version: '${{steps.release.outputs.major}}.${{steps.release.outputs.minor}}.${{steps.release.outputs.patch}}'
+        steps:
+            - uses: pnpm/action-setup@v4
+              with:
+                  version: 9
+
+            - uses: actions/setup-node@v4
+              with:
+                  node-version: 24
+
+            - uses: googleapis/release-please-action@v4
+              id: release
+              with:
+                  target-branch: dev
+                  token: ${{secrets.GH_TOKEN}}
+
+            # Checkout repos
+            - uses: actions/checkout@v4
+              with:
+                  repository: koenkk/zigbee2mqtt
+                  path: ./z2m
+            - uses: actions/checkout@v4
+              with:
+                  repository: koenkk/zigbee2mqtt
+                  path: ./z2m-master
+                  ref: master
+
+            - name: Restore cache commit-user-lookup.json
+              uses: actions/cache/restore@v4
+              with:
+                  path: z2m/scripts/commit-user-lookup.json
+                  key: commit-user-lookup-dummy
+                  restore-keys: |
+                      commit-user-lookup-
+            - name: Generate changelog
+              run: |
+                  MASTER_Z2M_VERSION=$(cat z2m-master/package.json | jq -r '.version')
+                  MASTER_ZHC_VERSION=$(cat z2m-master/package.json | jq -r '.dependencies."zigbee-herdsman-converters"')
+                  MASTER_ZH_VERSION=$(cat z2m-master/package.json | jq -r '.dependencies."zigbee-herdsman"')
+                  MASTER_FRONTEND_VERSION=$(cat z2m-master/package.json | jq -r '.dependencies."zigbee2mqtt-frontend"')
+                  wget -q -O - https://raw.githubusercontent.com/Koenkk/zigbee2mqtt/release-please--branches--dev--components--zigbee2mqtt/CHANGELOG.md > z2m/CHANGELOG.md
+                  cd z2m
+                  pnpm i --frozen-lockfile
+                  node scripts/generateChangelog.js $MASTER_Z2M_VERSION $MASTER_ZHC_VERSION $MASTER_ZH_VERSION $MASTER_FRONTEND_VERSION >> ../changelog.md
+              env:
+                  GH_TOKEN: ${{secrets.GH_TOKEN}}
+            - name: Update changelog gist
+              run: |
+                  gh gist edit bfd4c3d1725a2cccacc11d6ba51008ba -a changelog.md
+              env:
+                  GH_TOKEN: ${{secrets.GH_TOKEN}}
+            - name: Save cache commit-user-lookup.json
+              uses: actions/cache/save@v4
+              if: always()
+              with:
+                  path: z2m/scripts/commit-user-lookup.json
+                  key: commit-user-lookup-${{ hashFiles('z2m/scripts/commit-user-lookup.json') }}
@@ -1,69 +0,0 @@
-on:
-  push:
-    branches:
-      - dev
-
-permissions:
-  contents: write
-  pull-requests: write
-
-name: release-please
-
-jobs:
-  release-please:
-    runs-on: ubuntu-latest
-    outputs:
-      release_created: ${{ steps.release.outputs.release_created }}
-      version: "${{steps.release.outputs.major}}.${{steps.release.outputs.minor}}.${{steps.release.outputs.patch}}"
-    steps:
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
-
-      - uses: google-github-actions/release-please-action@v4
-        id: release
-        with:
-          target-branch: dev
-          token: ${{secrets.GH_TOKEN}}
-
-      # Checkout repos
-      - uses: actions/checkout@v4
-        with:
-          repository: koenkk/zigbee2mqtt
-          path: ./z2m
-      - uses: actions/checkout@v4
-        with:
-          repository: koenkk/zigbee2mqtt
-          path: ./z2m-master
-          ref: master
-
-      - name: Restore cache commit-user-lookup.json
-        uses: actions/cache/restore@v4
-        with:
-          path: z2m/scripts/commit-user-lookup.json
-          key: commit-user-lookup-dummy
-          restore-keys: |
-            commit-user-lookup-
-      - name: Generate changelog
-        run: |
-          MASTER_Z2M_VERSION=$(cat z2m-master/package.json | jq -r '.version')
-          MASTER_ZHC_VERSION=$(cat z2m-master/package.json | jq -r '.dependencies."zigbee-herdsman-converters"')
-          MASTER_ZH_VERSION=$(cat z2m-master/package.json | jq -r '.dependencies."zigbee-herdsman"')
-          MASTER_FRONTEND_VERSION=$(cat z2m-master/package.json | jq -r '.dependencies."zigbee2mqtt-frontend"')
-          wget -q -O - https://raw.githubusercontent.com/Koenkk/zigbee2mqtt/release-please--branches--dev--components--zigbee2mqtt/CHANGELOG.md > z2m/CHANGELOG.md
-          cd z2m
-          npm ci
-          node scripts/generateChangelog.js $MASTER_Z2M_VERSION $MASTER_ZHC_VERSION $MASTER_ZH_VERSION $MASTER_FRONTEND_VERSION >> ../changelog.md
-        env:
-          GH_TOKEN: ${{secrets.GH_TOKEN}}
-      - name: Update changelog gist
-        run: |
-          gh gist edit bfd4c3d1725a2cccacc11d6ba51008ba -a changelog.md
-        env:
-          GH_TOKEN: ${{secrets.GH_TOKEN}}
-      - name: Save cache commit-user-lookup.json
-        uses: actions/cache/save@v4
-        if: always()
-        with:
-          path: z2m/scripts/commit-user-lookup.json
-          key: commit-user-lookup-${{ hashFiles('z2m/scripts/commit-user-lookup.json') }}
@@ -1,20 +1,20 @@
-name: stale
+name: Stale

 on:
-  schedule:
-  - cron: "0 0 * * *"
-  workflow_dispatch:
+    schedule:
+        - cron: '0 0 * * *'
+    workflow_dispatch:

 jobs:
-  stale:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/stale@v9
-      with:
-        repo-token: ${{ secrets.GITHUB_TOKEN }}
-        stale-issue-message: 'This issue is stale because it has been open 180 days with no activity. Remove stale label or comment or this will be closed in 30 days'
-        stale-pr-message: 'This pull request is stale because it has been open 180 days with no activity. Remove stale label or comment or this will be closed in 30 days'
-        days-before-stale: 180
-        days-before-close: 30
-        exempt-issue-labels: dont-stale
-        operations-per-run: 500
+    stale:
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/stale@v9
+              with:
+                  repo-token: ${{ secrets.GITHUB_TOKEN }}
+                  stale-issue-message: 'This issue is stale because it has been open 60 days with no activity. Remove stale label or comment or this will be closed in 7 days'
+                  stale-pr-message: 'This pull request is stale because it has been open 60 days with no activity. Remove stale label or comment or this will be closed in 7 days'
+                  days-before-stale: 60
+                  days-before-close: 7
+                  exempt-issue-labels: dont-stale,feature-request
+                  operations-per-run: 500
@@ -0,0 +1,39 @@
+on:
+    repository_dispatch:
+        types: update_dep
+
+name: Update dependency
+
+permissions: {}
+jobs:
+    update-dependency:
+        permissions:
+            contents: write
+            pull-requests: write
+
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v4
+              with:
+                  ref: dev
+                  token: ${{ secrets.GH_TOKEN }}
+            - uses: pnpm/action-setup@v4
+            - uses: actions/setup-node@v4
+              with:
+                  node-version: 24
+                  cache: pnpm
+            - run: |
+                  pnpm install ${{ github.event.client_payload.package }}@${{ github.event.client_payload.version }} --save-exact
+                  pnpm install --no-frozen-lockfile
+            - uses: peter-evans/create-pull-request@v7
+              id: cpr
+              with:
+                  commit-message: 'fix(ignore): update ${{ github.event.client_payload.package }} to ${{ github.event.client_payload.version }}'
+                  branch: 'deps/${{ github.event.client_payload.package }}'
+                  title: 'fix(ignore): update ${{ github.event.client_payload.package }} to ${{ github.event.client_payload.version }}'
+                  token: ${{ secrets.GH_TOKEN }}
+            - run: sleep 5 # Otherwise pull request may not exist yet causing automerge to fail
+            - run: gh pr merge --squash --auto "${{ steps.cpr.outputs.pull-request-number }}"
+              if: steps.cpr.outputs.pull-request-operation == 'created'
+              env:
+                  GH_TOKEN: ${{ secrets.GH_TOKEN }}
@@ -1,36 +0,0 @@
-on:
-  repository_dispatch:
-    types: update_dep
-
-name: update-dep
-
-permissions: {}
-jobs:
-  update_dep:
-    permissions:
-      contents: write
-      pull-requests: write
-
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-      with:
-        ref: dev
-        token: ${{ secrets.GH_TOKEN }}
-    - uses: actions/setup-node@v4
-      with:
-        node-version: 20
-        cache: npm
-    - run: npm install ${{ github.event.client_payload.package }}@${{ github.event.client_payload.version }} --save-exact
-    - uses: peter-evans/create-pull-request@v6
-      id: cpr
-      with:
-        commit-message: "fix(ignore): update ${{ github.event.client_payload.package }} to ${{ github.event.client_payload.version }}"
-        branch: "deps/${{ github.event.client_payload.package }}"
-        title: Update ${{ github.event.client_payload.package }} to ${{ github.event.client_payload.version }}
-        token: ${{ secrets.GH_TOKEN }}
-    - run: sleep 5 # Otherwise pull request may not exist yet causing automerge to fail
-    - run: gh pr merge --squash --auto "${{ steps.cpr.outputs.pull-request-number }}"
-      if: steps.cpr.outputs.pull-request-operation == 'created'
-      env:
-        GH_TOKEN: ${{ secrets.GH_TOKEN }}
@@ -1,35 +0,0 @@
-name: Update dependencies
-on:
-  workflow_dispatch:
-  schedule:
-  - cron: "0 0 * * 0"
-
-permissions:
-  contents: read
-
-jobs:
-  update_deps:
-    permissions:
-      contents: write  # for peter-evans/create-pull-request to create branch
-      pull-requests: write  # for peter-evans/create-pull-request to create a PR
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-      with:
-        ref: dev
-        token: ${{ secrets.GH_TOKEN }}
-    - uses: actions/setup-node@v4
-      with:
-        node-version: 20
-        cache: npm
-    # connect-gzip-static@4.0.0 requires Node 20 >=
-    # eslint: https://github.com/typescript-eslint/typescript-eslint/issues/8211
-    - run: npx npm-check-updates -u -x connect-gzip-static -x eslint
-    - run: rm -f package-lock.json
-    - run: npm install
-    - uses: peter-evans/create-pull-request@v6
-      with:
-        commit-message: "fix(ignore): update dependencies"
-        branch: "deps/all"
-        title: Update dependencies
-        token: ${{ secrets.GH_TOKEN }}
@@ -45,11 +45,15 @@ typings/
 # Optional npm cache directory
 .npm

+# Optional pnpm cache directory
+.pnpm-store
+
 # Optional eslint cache
 .eslintcache

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

 # Optional REPL history
 .node_repl_history
@@ -63,26 +67,15 @@ tsconfig.tsbuildinfo
 # dotenv environment variables file
 .env

-# data
-data/database.db
-data/config.json
-data/log*.txt
-data/state.json
-data/log
-data-backup/
-data/coordinator_backup.json
-data/.storage
-data/database.db.backup
-data/extension
-
 # MacOS indexing file
 .DS_Store

 # IDE specific folders
 .idea
+.*.swp

 # Ignore config
-data/*.yaml
+data/*
 !data/configuration.example.yaml

 # commit-user-lookup.json
@@ -1,3 +1,3 @@
 {
-  ".": "1.37.0"
-}
+    ".": "2.5.1"
+}
@@ -1,4 +1,3 @@
-
 # Contributor Covenant Code of Conduct

 ## Our Pledge
@@ -18,23 +17,23 @@ diverse, inclusive, and healthy community.
 Examples of behavior that contributes to a positive environment for our
 community include:

-* Demonstrating empathy and kindness toward other people
-* Being respectful of differing opinions, viewpoints, and experiences
-* Giving and gracefully accepting constructive feedback
-* Accepting responsibility and apologizing to those affected by our mistakes,
+- Demonstrating empathy and kindness toward other people
+- Being respectful of differing opinions, viewpoints, and experiences
+- Giving and gracefully accepting constructive feedback
+- Accepting responsibility and apologizing to those affected by our mistakes,
  and learning from the experience
-* Focusing on what is best not just for us as individuals, but for the
+- Focusing on what is best not just for us as individuals, but for the
  overall community

 Examples of unacceptable behavior include:

-* The use of sexualized language or imagery, and sexual attention or
+- The use of sexualized language or imagery, and sexual attention or
  advances of any kind
-* Trolling, insulting or derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or email
+- Trolling, insulting or derogatory comments, and personal or political attacks
+- Public or private harassment
+- Publishing others' private information, such as a physical or email
  address, without their explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
+- Other conduct which could reasonably be considered inappropriate in a
  professional setting

 ## Enforcement Responsibilities
@@ -106,7 +105,7 @@ Violating these terms may lead to a permanent ban.
 ### 4. Permanent Ban

 **Community Impact**: Demonstrating a pattern of violation of community
-standards, including sustained inappropriate behavior,  harassment of an
+standards, including sustained inappropriate behavior, harassment of an
 individual, or aggression toward or disparagement of classes of individuals.

 **Consequence**: A permanent ban from any sort of public interaction within
@@ -4,5 +4,5 @@ Everybody is invited and welcome to contribute to Zigbee2MQTT. Zigbee2MQTT is wr

 - Pull requests are always created against the [**dev**](https://github.com/Koenkk/zigbee2mqtt/tree/dev) branch.
 - Easiest way to start developing Zigbee2MQTT is by setting up a development environment (aka bare-metal installation). You can follow this [guide](https://www.zigbee2mqtt.io/guide/installation/01_linux.html) to do this.
- You can run the tests locally by executing `npm test`. Zigbee2MQTT enforces 100% code coverage, in case you add new code check if your code is covered by running `npm run test-with-coverage`. The coverage report can be found under `coverage/lcov-report/index.html`. Linting is also enforced and can be run with `npm run eslint`.
+- You can run the tests locally by executing `pnpm test`. Zigbee2MQTT enforces 100% code coverage, in case you add new code check if your code is covered by running `pnpm run test-with-coverage`. The coverage report can be found under `coverage/lcov-report/index.html`. Linting is also enforced and can be run with `pnpm run eslint`.
 - When you want to add support for a new device no changes to Zigbee2MQTT have to be made, only to zigbee-herdsman-converters. You can find a guide for it [here](https://www.zigbee2mqtt.io/advanced/support-new-devices/01_support_new_devices.html).
@@ -5,8 +5,8 @@
    <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 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">
@@ -43,16 +43,19 @@
 </div>

 ## [Getting started](https://www.zigbee2mqtt.io/guide/getting-started)
+
 The [documentation](https://www.zigbee2mqtt.io/) provides you all the information needed to get up and running! Make sure you don't skip sections if this is your first visit, as there might be important details in there for you.

 If you aren't familiar with **Zigbee** terminology make sure you [read this](https://www.zigbee2mqtt.io/advanced/zigbee/01_zigbee_network.html) to help you out.

 ## [Integrations](https://www.zigbee2mqtt.io/guide/usage/integrations.html)
+
 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)

@@ -61,6 +64,7 @@ Zigbee2MQTT integrates well with (almost) every home automation solution because
 <img align="left" height="100px" width="100px" src="https://etc.athom.com/logo/white/256.png">

 ### [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)

@@ -69,6 +73,7 @@ Zigbee2MQTT integrates well with (almost) every home automation solution because
 <img align="left" height="100px" width="100px" src="https://user-images.githubusercontent.com/2734836/47615848-b8dd8700-dabd-11e8-9d77-175002dd8987.png">

 ### [Domoticz](https://www.domoticz.com/)
+
 - Integration implemented in Domoticz ([documentation](https://www.domoticz.com/wiki/Zigbee2MQTT)).

 <br>
@@ -76,6 +81,7 @@ Zigbee2MQTT integrates well with (almost) every home automation solution because
 <img align="left" height="100px" width="100px" src="./images/gladys-assistant-logo.jpg">

 ### [Gladys Assistant](https://gladysassistant.com/)
+
 - Integration implemented natively in Gladys Assistant ([documentation](https://gladysassistant.com/docs/integrations/zigbee2mqtt/)).

 <br>
@@ -83,23 +89,32 @@ Zigbee2MQTT integrates well with (almost) every home automation solution because
 <img align="left" height="100px" width="100px" src="https://forum.iobroker.net/assets/uploads/system/site-logo.png">

 ### [IoBroker](https://www.iobroker.net/)
+
 - Integration implemented in IoBroker ([documentation](https://github.com/o0shojo0o/ioBroker.zigbee2mqtt)).
-  
+
 <br>

 ## Architecture
+
 ![Architecture](images/architecture.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 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.

 ### 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 `npm run build`. For faster development instead of running `npm run build` you can run `npm run build-watch` in another terminal session, this will recompile as you change files.
+
+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.
+
+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`.

 ## Supported devices
+
 See [Supported devices](https://www.zigbee2mqtt.io/supported-devices) to check whether your device is supported. There is quite an extensive list, including devices from vendors like [Xiaomi](https://www.zigbee2mqtt.io/supported-devices/#v=Xiaomi), [Ikea](https://www.zigbee2mqtt.io/supported-devices/#v=IKEA), [Philips](https://www.zigbee2mqtt.io/supported-devices/#v=Philips), [OSRAM](https://www.zigbee2mqtt.io/supported-devices/#v=OSRAM) and more.

 If it's not listed in [Supported devices](https://www.zigbee2mqtt.io/supported-devices), support can be added (fairly) easily, see [How to support new devices](https://www.zigbee2mqtt.io/advanced/support-new-devices/01_support_new_devices.html).

 ## Support & help
+
 If you need assistance you can check [opened issues](https://github.com/Koenkk/zigbee2mqtt/issues). Feel free to help with Pull Requests when you were able to fix things or add new devices or just share the love on social media.
@@ -1,10 +0,0 @@
-module.exports = {
-    presets: [
-        ['@babel/preset-env', {targets: {node: 'current'}}],
-        '@babel/preset-typescript',
-    ],
-    assumptions: {setPublicClassFields: true},
-    plugins: [
-        ['@babel/plugin-proposal-decorators', {'legacy': true}],
-    ],
-};
@@ -0,0 +1,94 @@
+{
+    "$schema": "https://biomejs.dev/schemas/2.0.6/schema.json",
+    "vcs": {
+        "enabled": true,
+        "clientKind": "git",
+        "useIgnoreFile": true
+    },
+    "formatter": {
+        "indentStyle": "space",
+        "indentWidth": 4,
+        "lineWidth": 150,
+        "bracketSpacing": false
+    },
+    "files": {
+        "includes": ["**", "!package.json"]
+    },
+    "linter": {
+        "includes": ["**"],
+        "rules": {
+            "correctness": {
+                "noUnusedImports": "error"
+            },
+            "style": {
+                "noParameterAssign": "off",
+                "useThrowNewError": "error",
+                "useThrowOnlyError": "error",
+                "useNamingConvention": {
+                    "level": "error",
+                    "options": {
+                        "strictCase": false,
+                        "conventions": [
+                            {
+                                "selector": {
+                                    "kind": "objectLiteralProperty"
+                                },
+                                "formats": ["snake_case", "camelCase", "CONSTANT_CASE", "PascalCase"]
+                            },
+                            {
+                                "selector": {
+                                    "kind": "const"
+                                },
+                                "formats": ["snake_case", "camelCase", "CONSTANT_CASE", "PascalCase"]
+                            },
+                            {
+                                "selector": {
+                                    "kind": "typeProperty"
+                                },
+                                "formats": ["snake_case", "camelCase", "CONSTANT_CASE", "PascalCase"]
+                            },
+                            {
+                                "selector": {
+                                    "kind": "enumMember"
+                                },
+                                "formats": ["CONSTANT_CASE", "PascalCase"]
+                            }
+                        ]
+                    }
+                },
+                "useAsConstAssertion": "error",
+                "useDefaultParameterLast": "error",
+                "useEnumInitializers": "error",
+                "useSelfClosingElements": "error",
+                "useSingleVarDeclarator": "error",
+                "noUnusedTemplateLiteral": "error",
+                "useNumberNamespace": "error",
+                "noInferrableTypes": "error",
+                "noUselessElse": "error"
+            },
+            "performance": {
+                "noDelete": "off"
+            },
+            "suspicious": {
+                "noConstEnum": "off",
+                "useAwait": "error"
+            }
+        }
+    },
+    "overrides": [
+        {
+            "includes": ["test/**"],
+            "linter": {
+                "rules": {
+                    "style": {
+                        "noNonNullAssertion": "off",
+                        "useNamingConvention": "off"
+                    },
+                    "suspicious": {
+                        "noImplicitAnyLet": "off"
+                    }
+                }
+            }
+        }
+    ]
+}
@@ -1,4 +1,4 @@
 #!/usr/bin/env node
-const path = require('path');
-process.env['ZIGBEE2MQTT_DATA'] = process.env['ZIGBEE2MQTT_DATA'] || path.join(process.env['HOME'], '.z2m');
-require('./index');
+const path = require("node:path");
+process.env.ZIGBEE2MQTT_DATA = process.env.ZIGBEE2MQTT_DATA || path.join(process.env.HOME, ".z2m");
+require("./index");
@@ -1,29 +1,46 @@
+# Indicates the configuration version (used by configuration migrations)
+version: 4
+
 # Home Assistant integration (MQTT discovery)
-homeassistant: false
+homeassistant:
+    enabled: false

 # Enable the frontend, runs on port 8080 by default
-frontend: true
+frontend:
+    enabled: true
+    # port: 8080

 # MQTT settings
 mqtt:
-  # MQTT base topic for zigbee2mqtt MQTT messages
-  base_topic: zigbee2mqtt
-  # MQTT server URL
-  server: 'mqtt://localhost'
-  # MQTT server authentication, uncomment if required:
-  # user: my_user
-  # password: my_password
+    # MQTT base topic for zigbee2mqtt MQTT messages
+    base_topic: zigbee2mqtt
+    # MQTT server URL
+    server: 'mqtt://localhost'
+    # MQTT server authentication, uncomment if required:
+    # user: my_user
+    # password: my_password

-# Serial settings
-serial:
-  # Location of CC2531 USB sniffer
-  port: /dev/ttyACM0
+# Serial settings, only required when Zigbee2MQTT fails to start with:
+#   USB adapter discovery error (No valid USB adapter found).
+#   Specify valid 'adapter' and 'port' in your configuration.
+# serial:
+#     # Location of the adapter
+#     # USB adapters - use format "port: /dev/serial/by-id/XXX"
+#     # Ethernet adapters - use format "port: tcp://192.168.1.12:6638"
+#     port: /dev/serial/by-id/usb-Texas_Instruments_TI_CC2531_USB_CDC___0X00124B0018ED3DDF-if00
+#     # Adapter type, allowed values: `zstack`, `ember`, `deconz`, `zigate` or `zboss`
+#     adapter: zstack
+
+# Periodically check whether devices are online/offline
+# availability:
+#     enabled: false

 # Advanced settings
 advanced:
-  # Let Zigbee2MQTT generate a network key on first start
-  network_key: GENERATE
-  # Let Zigbee2MQTT generate a pan_id on first start
-  pan_id: GENERATE
-  # Let Zigbee2MQTT generate a ext_pan_id on first start
-  ext_pan_id: GENERATE
+    # channel: 11
+    # Let Zigbee2MQTT generate a network key on first start
+    network_key: GENERATE
+    # Let Zigbee2MQTT generate a pan_id on first start
+    pan_id: GENERATE
+    # Let Zigbee2MQTT generate a ext_pan_id on first start
+    ext_pan_id: GENERATE
@@ -1,20 +0,0 @@
-# Home Assistant integration (MQTT discovery)
-homeassistant: false
-
-# allow new devices to join
-permit_join: true
-
-# MQTT settings
-mqtt:
-  # MQTT base topic for zigbee2mqtt MQTT messages
-  base_topic: zigbee2mqtt
-  # MQTT server URL
-  server: 'mqtt://localhost'
-  # MQTT server authentication, uncomment if required:
-  # user: my_user
-  # password: my_password
-
-# Serial settings
-serial:
-  # Location of CC2531 USB sniffer
-  port: /dev/ttyACM0
@@ -1,26 +1,41 @@
-FROM alpine:3.18.4 as base
+ARG TARGETPLATFORM

+FROM alpine:3.22 AS base
+
+ENV NODE_ENV=production
 WORKDIR /app
 RUN apk add --no-cache tzdata eudev tini nodejs

 # Dependencies and build
-FROM base as dependencies_and_build
+FROM base AS deps

-COPY package*.json tsconfig.json index.js ./
-COPY lib ./lib
-
-RUN apk add --no-cache --virtual .buildtools make gcc g++ python3 linux-headers git npm && \
-    npm ci --production --no-audit --no-optional --no-update-notifier && \
-    # Serialport needs to be rebuild for Alpine https://serialport.io/docs/9.x.x/guide-installation#alpine-linux
-    npm rebuild --build-from-source && \
-    apk del .buildtools
+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@$(sed -n 's/.*"packageManager": "pnpm@\([0-9.]*\)".*/\1/p' package.json) && \
+    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` && \
+    pnpm rebuild @serialport/bindings-cpp

 # Release
-FROM base as release
+FROM base AS release

-COPY --from=dependencies_and_build /app/node_modules ./node_modules
+ARG DATE
+ARG VERSION
+LABEL org.opencontainers.image.authors="Koen Kanters"
+LABEL org.opencontainers.image.title="Zigbee2MQTT"
+LABEL org.opencontainers.image.description="Zigbee to MQTT bridge using Zigbee-herdsman"
+LABEL org.opencontainers.image.url="https://github.com/Koenkk/zigbee2mqtt"
+LABEL org.opencontainers.image.documentation="https://www.zigbee2mqtt.io/"
+LABEL org.opencontainers.image.source="https://github.com/Koenkk/zigbee2mqtt"
+LABEL org.opencontainers.image.licenses="GPL-3.0"
+LABEL org.opencontainers.image.created=${DATE}
+LABEL org.opencontainers.image.version=${VERSION}
+
+COPY --from=deps /app/node_modules ./node_modules
 COPY dist ./dist
-COPY package.json LICENSE index.js data/configuration.yaml data/configuration.example.yaml ./
+COPY package.json LICENSE index.js data/configuration.example.yaml ./

 COPY docker/docker-entrypoint.sh /usr/local/bin/
 RUN chmod +x /usr/local/bin/docker-entrypoint.sh
@@ -30,7 +45,5 @@ RUN mkdir /app/data
 ARG COMMIT
 RUN echo "$COMMIT" > dist/.hash

-ENV NODE_ENV production
-
 ENTRYPOINT ["docker-entrypoint.sh"]
 CMD [ "/sbin/tini", "--", "node", "index.js"]
@@ -1,14 +0,0 @@
-  version: '3'
-  services:
-    zigbee2mqtt:
-      container_name: zigbee2mqtt
-      image: koenkk/zigbee2mqtt
-      volumes:
-        - ./data:/app/data
-      devices:
-        # CC251
-        #- /dev/ttyUSB_cc2531:/dev/ttyACM0
-        # CC2530 / GBAN GB2530S
-        #- /dev/ttyUSB_cc2530:/dev/ttyACM0
-      restart: always
-      network_mode: host
@@ -9,9 +9,4 @@ fi

 echo "Using '$DATA' as data directory"

-if [ ! -f "$DATA/configuration.yaml" ]; then
-    echo "Creating configuration file..."
-    cp /app/configuration.example.yaml "$DATA/configuration.yaml"
-fi
-
 exec "$@"
@@ -1,65 +1,106 @@
-const semver = require('semver');
-const engines = require('./package.json').engines;
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const {exec} = require('child_process');
-const {rimrafSync} = require('rimraf');
-require('source-map-support').install();
+const semver = require("semver");
+const engines = require("./package.json").engines;
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const {exec} = require("node:child_process");
+require("source-map-support").install();

 let controller;
 let stopping = false;
+const watchdog = process.env.Z2M_WATCHDOG != null;
+let watchdogCount = 0;
+let unsolicitedStop = false;
+// csv in minutes, default: 1min, 5min, 15min, 30min, 60min
+let watchdogDelays = [2000, 60000, 300000, 900000, 1800000, 3600000];

-const hashFile = path.join(__dirname, 'dist', '.hash');
+if (watchdog && process.env.Z2M_WATCHDOG !== "default") {
+    if (/^\d+(.\d+)?(,\d+(.\d+)?)*$/.test(process.env.Z2M_WATCHDOG)) {
+        watchdogDelays = process.env.Z2M_WATCHDOG.split(",").map((v) => Number.parseFloat(v) * 60000);
+    } else {
+        console.log(`Invalid watchdog delays (must use number-only CSV format representing minutes, example: 'Z2M_WATCHDOG=1,5,15,30,60'.`);
+        process.exit(1);
+    }
+}
+
+const hashFile = path.join(__dirname, "dist", ".hash");
+
+async function triggerWatchdog(code) {
+    const delay = watchdogDelays[watchdogCount];
+    watchdogCount += 1;
+
+    if (delay) {
+        // garbage collector
+        controller = undefined;
+
+        console.log(`WATCHDOG: Waiting ${delay / 60000}min before next start try.`);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        await start();
+    } else {
+        process.exit(code);
+    }
+}

 async function restart() {
    await stop(true);
    await start();
 }

-async function exit(code, restart) {
+async function exit(code, restart = false) {
    if (!restart) {
-        process.exit(code);
+        if (watchdog && unsolicitedStop) {
+            await triggerWatchdog(code);
+        } else {
+            process.exit(code);
+        }
    }
 }

 async function currentHash() {
-    const git = require('git-last-commit');
-    return new Promise((resolve) => {
-        git.getLastCommit((err, commit) => {
-            if (err) resolve('unknown');
-            else resolve(commit.shortHash);
+    return await new Promise((resolve) => {
+        exec("git rev-parse --short=8 HEAD", (error, stdout) => {
+            const commitHash = stdout.trim();
+
+            if (error || commitHash === "") {
+                resolve("unknown");
+            } else {
+                resolve(commitHash);
+            }
        });
    });
 }

 async function writeHash() {
    const hash = await currentHash();
+
    fs.writeFileSync(hashFile, hash);
 }

 async function build(reason) {
-    return new Promise((resolve, reject) => {
-        process.stdout.write(`Building Zigbee2MQTT... (${reason})`);
-        rimrafSync('dist');
+    process.stdout.write(`Building Zigbee2MQTT... (${reason})`);
+
+    return await new Promise((resolve, reject) => {
        const env = {...process.env};
-        const _600mb = 629145600;
-        if (_600mb > os.totalmem() && !env.NODE_OPTIONS) {
+        const mb600 = 629145600;
+
+        if (mb600 > os.totalmem() && !env.NODE_OPTIONS) {
            // Prevent OOM on tsc compile for system with low memory
            // https://github.com/Koenkk/zigbee2mqtt/issues/12034
-            env.NODE_OPTIONS = '--max_old_space_size=256';
+            env.NODE_OPTIONS = "--max_old_space_size=256";
        }

-        exec('npm run build', {env, cwd: __dirname}, async (err, stdout, stderr) => {
+        // clean build, prevent failures due to tsc incremental building
+        exec("pnpm run prepack", {env, cwd: __dirname}, (err) => {
            if (err) {
-                process.stdout.write(', failed\n');
+                process.stdout.write(", failed\n");
+
                if (err.code === 134) {
-                    process.stderr.write(
-                        '\n\nBuild failed; ran out-of-memory, free some memory (RAM) and start again\n\n');
+                    process.stderr.write("\n\nBuild failed; ran out-of-memory, free some memory (RAM) and start again\n\n");
                }
+
                reject(err);
            } else {
-                process.stdout.write(', finished\n');
+                process.stdout.write(", finished\n");
                resolve();
            }
        });
@@ -68,66 +109,80 @@ async function build(reason) {

 async function checkDist() {
    if (!fs.existsSync(hashFile)) {
-        await build('initial build');
+        await build("initial build");
    }

-    const distHash = fs.readFileSync(hashFile, 'utf-8');
+    const distHash = fs.readFileSync(hashFile, "utf8");
    const hash = await currentHash();
-    if (hash !== 'unknown' && distHash !== hash) {
-        await build('hash changed');
+
+    if (hash !== "unknown" && distHash !== hash) {
+        await build("hash changed");
    }
 }

 async function start() {
+    console.log(`Starting Zigbee2MQTT ${watchdog ? `with watchdog (${watchdogDelays})` : "without watchdog"}.`);
    await checkDist();

-    const version = engines.node;
-    if (!semver.satisfies(process.version, version)) {
-        console.log(`\t\tZigbee2MQTT requires node version ${version}, you are running ${process.version}!\n`); // eslint-disable-line
-    }
+    // gc
+    {
+        const version = engines.node;

-    // Validate settings
-    const settings = require('./dist/util/settings');
-    settings.reRead();
-    const errors = settings.validate();
-    if (errors.length > 0) {
-        console.log(`\n\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!`);
-        console.log('            READ THIS CAREFULLY\n');
-        console.log(`Refusing to start because configuration is not valid, found the following errors:`);
-        for (const error of errors) {
-            console.log(`- ${error}`);
+        if (!semver.satisfies(process.version, version)) {
+            console.log(`\t\tZigbee2MQTT requires node version ${version}, you are running ${process.version}!\n`);
+        }
+
+        const {onboard} = require("./dist/util/onboarding");
+
+        const success = await onboard();
+
+        if (!success) {
+            unsolicitedStop = false;
+
+            return await exit(1);
        }
-        console.log(`\nIf you don't know how to solve this, read https://www.zigbee2mqtt.io/guide/configuration`); // eslint-disable-line
-        console.log(`\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n\n`);
-        exit(1);
    }

-    const Controller = require('./dist/controller');
+    const {Controller} = require("./dist/controller");
    controller = new Controller(restart, exit);
+
    await controller.start();
+
+    // consider next controller.stop() call as unsolicited, only after successful first start
+    unsolicitedStop = true;
+    watchdogCount = 0; // reset
 }

 async function stop(restart) {
+    // `handleQuit` or `restart` never unsolicited
+    unsolicitedStop = false;
+
    await controller.stop(restart);
 }

 async function handleQuit() {
-    if (!stopping && controller) {
-        stopping = true;
-        await stop(false);
+    if (!stopping) {
+        if (controller) {
+            stopping = true;
+
+            await stop(false);
+        } else {
+            process.exit(0);
+        }
    }
 }

-if (require.main === module || require.main.filename.endsWith(path.sep + 'cli.js')) {
-    if (process.argv.length === 3 && process.argv[2] === 'writehash') {
+if (require.main === module || require.main.filename.endsWith(`${path.sep}cli.js`)) {
+    if (process.argv.length === 3 && process.argv[2] === "writehash") {
        writeHash();
    } else {
-        process.on('SIGINT', handleQuit);
-        process.on('SIGTERM', handleQuit);
+        process.on("SIGINT", handleQuit);
+        process.on("SIGTERM", handleQuit);
        start();
    }
 } else {
-    process.on('SIGINT', handleQuit);
-    process.on('SIGTERM', handleQuit);
+    process.on("SIGINT", handleQuit);
+    process.on("SIGTERM", handleQuit);
+
    module.exports = {start};
 }
@@ -1,211 +1,300 @@
-import MQTT from './mqtt';
-import Zigbee from './zigbee';
-import EventBus from './eventBus';
-import State from './state';
-import logger from './util/logger';
-import * as settings from './util/settings';
-import utils from './util/utils';
-import stringify from 'json-stable-stringify-without-jsonify';
-import assert from 'assert';
-import bind from 'bind-decorator';
-import {setLogger as zhcSetLogger} from 'zigbee-herdsman-converters';
-import {setLogger as zhSetLogger} from 'zigbee-herdsman';
-
+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 ExtensionFrontend from './extension/frontend';
-import ExtensionPublish from './extension/publish';
-import ExtensionReceive from './extension/receive';
-import ExtensionNetworkMap from './extension/networkMap';
-import ExtensionSoftReset from './extension/legacy/softReset';
-import ExtensionHomeAssistant from './extension/homeassistant';
-import ExtensionConfigure from './extension/configure';
-import ExtensionDeviceGroupMembership from './extension/legacy/deviceGroupMembership';
-import ExtensionBridgeLegacy from './extension/legacy/bridgeLegacy';
-import ExtensionBridge from './extension/bridge';
-import ExtensionGroups from './extension/groups';
-import ExtensionAvailability from './extension/availability';
-import ExtensionBind from './extension/bind';
-import ExtensionReport from './extension/legacy/report';
-import ExtensionOnEvent from './extension/onEvent';
-import ExtensionOTAUpdate from './extension/otaUpdate';
-import ExtensionExternalConverters from './extension/externalConverters';
-import ExtensionExternalExtension from './extension/externalExtension';
-
-const AllExtensions = [
-    ExtensionPublish, ExtensionReceive, ExtensionNetworkMap, ExtensionSoftReset, ExtensionHomeAssistant,
-    ExtensionConfigure, ExtensionDeviceGroupMembership, ExtensionBridgeLegacy, ExtensionBridge, ExtensionGroups,
-    ExtensionBind, ExtensionReport, ExtensionOnEvent, ExtensionOTAUpdate,
-    ExtensionExternalConverters, ExtensionFrontend, ExtensionExternalExtension, ExtensionAvailability,
-];
-
-type ExtensionArgs = [Zigbee, MQTT, State, PublishEntityState, EventBus,
-    (enable: boolean, name: string) => Promise<void>, () => void, (extension: Extension) => Promise<void>];
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-let sdNotify: any = null;
-try {
-    sdNotify = process.env.NOTIFY_SOCKET ? require('sd-notify') : null;
-} catch {
-    // sd-notify is optional
-}
+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";
+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";
+import utils from "./util/utils";
+import Zigbee from "./zigbee";

 export class Controller {
    private eventBus: EventBus;
    private zigbee: Zigbee;
    private state: State;
-    private mqtt: MQTT;
-    private restartCallback: () => void;
-    private exitCallback: (code: number, restart: boolean) => void;
-    private extensions: Extension[];
-    private extensionArgs: ExtensionArgs;
+    private mqtt: Mqtt;
+    private restartCallback: () => Promise<void>;
+    private exitCallback: (code: number, restart: boolean) => Promise<void>;
+    public readonly extensions: Set<Extension>;
+    public readonly extensionArgs: ConstructorParameters<typeof Extension>;
+    private sdNotify: Awaited<ReturnType<typeof initSdNotify>>;

-    constructor(restartCallback: () => void, exitCallback: (code: number, restart: boolean) => void) {
+    constructor(restartCallback: () => Promise<void>, exitCallback: (code: number, restart: boolean) => Promise<void>) {
+        logger.init();
        zhSetLogger(logger);
        zhcSetLogger(logger);
        this.eventBus = new EventBus();
        this.zigbee = new Zigbee(this.eventBus);
-        this.mqtt = new MQTT(this.eventBus);
+        this.mqtt = new Mqtt(this.eventBus);
        this.state = new State(this.eventBus, this.zigbee);
        this.restartCallback = restartCallback;
        this.exitCallback = exitCallback;

        // Initialize extensions.
-        this.extensionArgs = [this.zigbee, this.mqtt, this.state, this.publishEntityState, this.eventBus,
-            this.enableDisableExtension, this.restartCallback, this.addExtension];
+        this.extensionArgs = [
+            this.zigbee,
+            this.mqtt,
+            this.state,
+            this.publishEntityState,
+            this.eventBus,
+            this.enableDisableExtension,
+            this.restartCallback,
+            this.addExtension,
+        ];

-        this.extensions = [
+        this.extensions = new Set([
+            new ExtensionExternalConverters(...this.extensionArgs),
+            new ExtensionOnEvent(...this.extensionArgs),
            new ExtensionBridge(...this.extensionArgs),
            new ExtensionPublish(...this.extensionArgs),
            new ExtensionReceive(...this.extensionArgs),
-            new ExtensionDeviceGroupMembership(...this.extensionArgs),
            new ExtensionConfigure(...this.extensionArgs),
            new ExtensionNetworkMap(...this.extensionArgs),
            new ExtensionGroups(...this.extensionArgs),
            new ExtensionBind(...this.extensionArgs),
-            new ExtensionOnEvent(...this.extensionArgs),
            new ExtensionOTAUpdate(...this.extensionArgs),
-            new ExtensionReport(...this.extensionArgs),
-            new ExtensionExternalExtension(...this.extensionArgs),
+            new ExtensionExternalExtensions(...this.extensionArgs),
            new ExtensionAvailability(...this.extensionArgs),
-            settings.get().frontend && new ExtensionFrontend(...this.extensionArgs),
-            settings.get().advanced.legacy_api && new ExtensionBridgeLegacy(...this.extensionArgs),
-            settings.get().external_converters.length && new ExtensionExternalConverters(...this.extensionArgs),
-            settings.get().homeassistant && new ExtensionHomeAssistant(...this.extensionArgs),
-            /* istanbul ignore next */
-            settings.get().advanced.soft_reset_timeout !== 0 && new ExtensionSoftReset(...this.extensionArgs),
-        ].filter((n) => n);
+            new ExtensionHealth(...this.extensionArgs),
+        ]);
    }

    async start(): Promise<void> {
+        if (settings.get().frontend.enabled) {
+            const {Frontend} = await import("./extension/frontend.js");
+
+            this.extensions.add(new Frontend(...this.extensionArgs));
+        }
+
+        if (settings.get().homeassistant.enabled) {
+            const {HomeAssistant} = await import("./extension/homeassistant.js");
+
+            this.extensions.add(new HomeAssistant(...this.extensionArgs));
+        }
+
        this.state.start();

        const info = await utils.getZigbee2MQTTVersion();
        logger.info(`Starting Zigbee2MQTT version ${info.version} (commit #${info.commitHash})`);

        // Start zigbee
-        let startResult;
        try {
-            startResult = await this.zigbee.start();
+            await this.zigbee.start();
            this.eventBus.onAdapterDisconnected(this, this.onZigbeeAdapterDisconnected);
        } catch (error) {
-            logger.error('Failed to start zigbee');
-            logger.error('Check https://www.zigbee2mqtt.io/guide/installation/20_zigbee2mqtt-fails-to-start.html for possible solutions'); /* eslint-disable-line max-len */
-            logger.error('Exiting...');
-            logger.error(error.stack);
-            await this.exit(1);
-        }
+            logger.error("Failed to start zigbee-herdsman");
+            logger.error(
+                "Check https://www.zigbee2mqtt.io/guide/installation/20_zigbee2mqtt-fails-to-start_crashes-runtime.html for possible solutions",
+            );
+            logger.error("Exiting...");
+            // biome-ignore lint/style/noNonNullAssertion: always Error
+            logger.error((error as Error).stack!);

-        // Disable some legacy options on new network creation
-        if (startResult === 'reset') {
-            settings.set(['advanced', 'homeassistant_legacy_entity_attributes'], false);
-            settings.set(['advanced', 'legacy_api'], false);
-            settings.set(['advanced', 'legacy_availability_payload'], false);
-            settings.set(['device_options', 'legacy'], false);
-            this.enableDisableExtension(false, 'BridgeLegacy');
+            /* v8 ignore start */
+            if ((error as Error).message.includes("USB adapter discovery error (No valid USB adapter found)")) {
+                logger.error("If this happens after updating to Zigbee2MQTT 2.0.0, see https://github.com/Koenkk/zigbee2mqtt/discussions/24364");
+            }
+            /* v8 ignore stop */
+
+            return await this.exit(1);
        }

        // Log zigbee clients on startup
-        const devices = this.zigbee.devices(false);
-        logger.info(`Currently ${devices.length} devices are joined:`);
-        for (const device of devices) {
-            const model = device.isSupported ?
-                `${device.definition.model} - ${device.definition.vendor} ${device.definition.description}` :
-                'Not supported';
+        let deviceCount = 0;
+
+        for (const device of this.zigbee.devicesIterator(utils.deviceNotCoordinator)) {
+            // `definition` validated by `isSupported`
+            const model = device.isSupported
+                ? // biome-ignore lint/style/noNonNullAssertion: valid from `isSupported`
+                  `${device.definition!.model} - ${device.definition!.vendor} ${device.definition!.description}`
+                : "Not supported";
            logger.info(`${device.name} (${device.ieeeAddr}): ${model} (${device.zh.type})`);
+
+            deviceCount++;
        }

-        // Enable zigbee join
-        try {
-            if (settings.get().permit_join) {
-                logger.warning('`permit_join` set to  `true` in configuration.yaml.');
-                logger.warning('Allowing new devices to join.');
-                logger.warning('Set `permit_join` to `false` once you joined all devices.');
-            }
-
-            await this.zigbee.permitJoin(settings.get().permit_join);
-        } catch (error) {
-            logger.error(`Failed to set permit join to ${settings.get().permit_join}`);
-        }
+        logger.info(`Currently ${deviceCount} devices are joined.`);

        // MQTT
        try {
            await this.mqtt.connect();
        } catch (error) {
-            logger.error(`MQTT failed to connect, exiting...`);
+            logger.error(`MQTT failed to connect, exiting... (${(error as Error).message})`);
            await this.zigbee.stop();
-            await this.exit(1);
+            return await this.exit(1);
        }

-        // Call extensions
-        await this.callExtensions('start', [...this.extensions]);
+        // copy current Set of extensions to ignore possible external extensions added while looping
+        for (const extension of new Set(this.extensions)) {
+            await this.startExtension(extension);
+        }

        // Send all cached states.
        if (settings.get().advanced.cache_state_send_on_startup && settings.get().advanced.cache_state) {
-            for (const entity of [...devices, ...this.zigbee.groups()]) {
+            for (const entity of this.zigbee.devicesAndGroupsIterator()) {
                if (this.state.exists(entity)) {
-                    this.publishEntityState(entity, this.state.get(entity), 'publishCached');
+                    await this.publishEntityState(entity, this.state.get(entity), "publishCached");
                }
            }
        }

-        this.eventBus.onLastSeenChanged(this,
-            (data) => utils.publishLastSeen(data, settings.get(), false, this.publishEntityState));
+        this.eventBus.onLastSeenChanged(this, (data) => utils.publishLastSeen(data, settings.get(), false, this.publishEntityState));

-        logger.info(`Zigbee2MQTT started!`);
+        logger.info("Zigbee2MQTT started!");

-        const watchdogInterval = sdNotify?.watchdogInterval() || 0;
-        if (watchdogInterval > 0) {
-            sdNotify.startWatchdogMode(Math.floor(watchdogInterval / 2));
-        }
-        sdNotify?.ready();
+        this.sdNotify = await initSdNotify();
+
+        settings.setOnboarding(false);
    }

    @bind async enableDisableExtension(enable: boolean, name: string): Promise<void> {
-        if (!enable) {
-            const extension = this.extensions.find((e) => e.constructor.name === name);
-            if (extension) {
-                await this.callExtensions('stop', [extension]);
-                this.extensions.splice(this.extensions.indexOf(extension), 1);
+        if (enable) {
+            switch (name) {
+                case "Frontend": {
+                    if (!settings.get().frontend.enabled) {
+                        throw new Error("Tried to enable Frontend extension disabled in settings");
+                    }
+
+                    // this is not actually used, not tested either
+                    /* v8 ignore start */
+                    const {Frontend} = await import("./extension/frontend.js");
+
+                    await this.addExtension(new Frontend(...this.extensionArgs));
+
+                    break;
+                    /* v8 ignore stop */
+                }
+                case "HomeAssistant": {
+                    if (!settings.get().homeassistant.enabled) {
+                        throw new Error("Tried to enable HomeAssistant extension disabled in settings");
+                    }
+
+                    const {HomeAssistant} = await import("./extension/homeassistant.js");
+
+                    await this.addExtension(new HomeAssistant(...this.extensionArgs));
+
+                    break;
+                }
+                default: {
+                    throw new Error(
+                        `Extension ${name} does not exist (should be added with 'addExtension') or is built-in that cannot be enabled at runtime`,
+                    );
+                }
            }
        } else {
-            const Extension = AllExtensions.find((e) => e.name === name);
-            assert(Extension, `Extension '${name}' does not exist`);
-            const extension = new Extension(...this.extensionArgs);
-            this.extensions.push(extension);
-            await this.callExtensions('start', [extension]);
+            switch (name) {
+                case "Frontend": {
+                    if (settings.get().frontend.enabled) {
+                        throw new Error("Tried to disable Frontend extension enabled in settings");
+                    }
+
+                    break;
+                }
+                case "HomeAssistant": {
+                    if (settings.get().homeassistant.enabled) {
+                        throw new Error("Tried to disable HomeAssistant extension enabled in settings");
+                    }
+
+                    break;
+                }
+                case "Availability":
+                case "Bind":
+                case "Bridge":
+                case "Configure":
+                case "ExternalConverters":
+                case "ExternalExtensions":
+                case "Groups":
+                case "NetworkMap":
+                case "OnEvent":
+                case "OTAUpdate":
+                case "Publish":
+                case "Receive": {
+                    throw new Error(`Built-in extension ${name} cannot be disabled at runtime`);
+                }
+            }
+
+            const extension = this.getExtension(name);
+
+            if (extension) {
+                await this.removeExtension(extension);
+            }
+        }
+    }
+
+    public getExtension(name: string): Extension | undefined {
+        for (const extension of this.extensions) {
+            if (extension.constructor.name === name) {
+                return extension;
+            }
        }
    }

    @bind async addExtension(extension: Extension): Promise<void> {
-        this.extensions.push(extension);
-        await this.callExtensions('start', [extension]);
+        for (const ext of this.extensions) {
+            if (ext.constructor.name === extension.constructor.name) {
+                throw new Error(`Extension with name ${ext.constructor.name} already present`);
+            }
+        }
+
+        this.extensions.add(extension);
+        await this.startExtension(extension);
+    }
+
+    async removeExtension(extension: Extension): Promise<void> {
+        if (this.extensions.delete(extension)) {
+            await this.stopExtension(extension);
+        }
+    }
+
+    private async startExtension(extension: Extension): Promise<void> {
+        try {
+            await extension.start();
+        } catch (error) {
+            logger.error(`Failed to start '${extension.constructor.name}' (${(error as Error).stack})`);
+        }
+    }
+
+    private async stopExtension(extension: Extension): Promise<void> {
+        try {
+            await extension.stop();
+        } catch (error) {
+            logger.error(`Failed to stop '${extension.constructor.name}' (${(error as Error).stack})`);
+        }
    }

    async stop(restart = false): Promise<void> {
-        sdNotify?.stopping();
+        this.sdNotify?.notifyStopping();
+
+        let code = 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;
+            }
+        }

-        // Call extensions
-        await this.callExtensions('stop', this.extensions);
        this.eventBus.removeListeners(this);

        // Wrap-up
@@ -214,29 +303,28 @@ export class Controller {

        try {
            await this.zigbee.stop();
-            logger.info('Stopped Zigbee2MQTT');
-            await this.exit(0, restart);
+            logger.info("Stopped Zigbee2MQTT");
        } catch (error) {
-            logger.error('Failed to stop Zigbee2MQTT');
-            await this.exit(1, restart);
+            logger.error(`Failed to stop Zigbee2MQTT (${(error as Error).stack})`);
+            code = 1;
        }

-        sdNotify?.stopWatchdogMode();
+        this.sdNotify?.stop();
+        return await this.exit(code, restart);
    }

    async exit(code: number, restart = false): Promise<void> {
        await logger.end();
-        this.exitCallback(code, restart);
+        return await this.exitCallback(code, restart);
    }

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

-    @bind async publishEntityState(entity: Group | Device, payload: KeyValue,
-        stateChangeReason?: StateChangeReason): Promise<void> {
-        let message = {...payload};
+    @bind async publishEntityState(entity: Group | Device, payload: KeyValue, stateChangeReason?: StateChangeReason): Promise<void> {
+        let message: Zigbee2MQTTAPI["{friendlyName}"] = {...payload};

        // Update state cache with new state.
        const newState = this.state.set(entity, payload, stateChangeReason);
@@ -246,34 +334,46 @@ export class Controller {
            message = newState;
        }

-        const options: MQTTOptions = {
-            retain: utils.getObjectProperty(entity.options, 'retain', false) as boolean,
-            qos: utils.getObjectProperty(entity.options, 'qos', 0) as 0 | 1 | 2,
+        const options: MakePartialExcept<MqttPublishOptions, "clientOptions" | "meta"> = {
+            clientOptions: {
+                retain: utils.getObjectProperty(entity.options, "retain", false),
+                qos: utils.getObjectProperty(entity.options, "qos", 0),
+            },
+            meta: {
+                isEntityState: true,
+            },
        };
+        const retention = utils.getObjectProperty<number | false>(entity.options, "retention", false);

-        const retention = utils.getObjectProperty(entity.options, 'retention', false);
        if (retention !== false) {
-            options.properties = {messageExpiryInterval: retention as number};
+            options.clientOptions.properties = {messageExpiryInterval: retention};
        }

        if (entity.isDevice() && settings.get().mqtt.include_device_information) {
            message.device = {
-                friendlyName: entity.name, model: entity.definition?.model,
-                ieeeAddr: entity.ieeeAddr, networkAddress: entity.zh.networkAddress, type: entity.zh.type,
+                friendlyName: entity.name,
+                model: entity.definition?.model,
+                ieeeAddr: entity.ieeeAddr,
+                networkAddress: entity.zh.networkAddress,
+                type: entity.zh.type,
                manufacturerID: entity.zh.manufacturerID,
-                powerSource: entity.zh.powerSource, applicationVersion: entity.zh.applicationVersion,
-                stackVersion: entity.zh.stackVersion, zclVersion: entity.zh.zclVersion,
-                hardwareVersion: entity.zh.hardwareVersion, dateCode: entity.zh.dateCode,
+                powerSource: entity.zh.powerSource,
+                applicationVersion: entity.zh.applicationVersion,
+                stackVersion: entity.zh.stackVersion,
+                zclVersion: entity.zh.zclVersion,
+                hardwareVersion: entity.zh.hardwareVersion,
+                dateCode: entity.zh.dateCode,
                softwareBuildID: entity.zh.softwareBuildID,
                // Manufacturer name can contain \u0000, remove this.
                // https://github.com/home-assistant/core/issues/85691
-                manufacturerName: entity.zh.manufacturerName?.split('\u0000')[0],
+                /* v8 ignore next */
+                manufacturerName: entity.zh.manufacturerName?.split("\u0000")[0],
            };
        }

        // Add lastseen
        const lastSeen = settings.get().advanced.last_seen;
-        if (entity.isDevice() && lastSeen !== 'disable' && entity.zh.lastSeen) {
+        if (entity.isDevice() && lastSeen !== "disable" && entity.zh.lastSeen) {
            message.last_seen = utils.formatDate(entity.zh.lastSeen, lastSeen);
        }

@@ -289,13 +389,13 @@ export class Controller {
        // Filter mqtt message attributes
        utils.filterProperties(entity.options.filtered_attributes, message);

-        if (Object.entries(message).length) {
+        if (!utils.objectIsEmpty(message)) {
            const output = settings.get().advanced.output;
-            if (output === 'attribute_and_json' || output === 'json') {
+            if (output === "attribute_and_json" || output === "json") {
                await this.mqtt.publish(entity.name, stringify(message), options);
            }

-            if (output === 'attribute_and_json' || output === 'attribute') {
+            if (output === "attribute_and_json" || output === "attribute") {
                await this.iteratePayloadAttributeOutput(`${entity.name}/`, message, options);
            }
        }
@@ -303,25 +403,25 @@ export class Controller {
        this.eventBus.emitPublishEntityState({entity, message, stateChangeReason, payload});
    }

-    async iteratePayloadAttributeOutput(topicRoot: string, payload: KeyValue, options: MQTTOptions): Promise<void> {
+    async iteratePayloadAttributeOutput(topicRoot: string, payload: KeyValue, options: Partial<MqttPublishOptions>): Promise<void> {
        for (const [key, value] of Object.entries(payload)) {
            let subPayload = value;
            let message = null;

            // Special cases
-            if (key === 'color' && utils.objectHasProperties(subPayload, ['r', 'g', 'b'])) {
+            if (key === "color" && utils.objectHasProperties(subPayload, ["r", "g", "b"])) {
                subPayload = [subPayload.r, subPayload.g, subPayload.b];
            }

            // Check Array first, since it is also an Object
            if (subPayload === null || subPayload === undefined) {
-                message = '';
+                message = "";
            } else if (Array.isArray(subPayload)) {
-                message = subPayload.map((x) => `${x}`).join(',');
-            } else if (typeof subPayload === 'object') {
+                message = subPayload.map((x) => `${x}`).join(",");
+            } else if (typeof subPayload === "object") {
                await this.iteratePayloadAttributeOutput(`${topicRoot}${key}-`, subPayload, options);
            } else {
-                message = typeof subPayload === 'string' ? subPayload : stringify(subPayload);
+                message = typeof subPayload === "string" ? subPayload : stringify(subPayload);
            }

            if (message !== null) {
@@ -329,17 +429,4 @@ export class Controller {
            }
        }
    }
-
-    private async callExtensions(method: 'start' | 'stop', extensions: Extension[]): Promise<void> {
-        for (const extension of extensions) {
-            try {
-                await extension[method]?.();
-            } catch (error) {
-                /* istanbul ignore next */
-                logger.error(`Failed to call '${extension.constructor.name}' '${method}' (${error.stack})`);
-            }
-        }
-    }
 }
-
-module.exports = Controller;
@@ -1,188 +1,274 @@
-import events from 'events';
-import logger from './util/logger';
+import events from "node:events";
+
+import logger from "./util/logger";

-// eslint-disable-next-line
 type ListenerKey = object;

+interface EventBusMap {
+    adapterDisconnected: [];
+    permitJoinChanged: [data: eventdata.PermitJoinChanged];
+    publishAvailability: [];
+    deviceRenamed: [data: eventdata.EntityRenamed];
+    deviceRemoved: [data: eventdata.EntityRemoved];
+    lastSeenChanged: [data: eventdata.LastSeenChanged];
+    deviceNetworkAddressChanged: [data: eventdata.DeviceNetworkAddressChanged];
+    deviceAnnounce: [data: eventdata.DeviceAnnounce];
+    deviceInterview: [data: eventdata.DeviceInterview];
+    deviceJoined: [data: eventdata.DeviceJoined];
+    entityOptionsChanged: [data: eventdata.EntityOptionsChanged];
+    exposesChanged: [data: eventdata.ExposesChanged];
+    deviceLeave: [data: eventdata.DeviceLeave];
+    deviceMessage: [data: eventdata.DeviceMessage];
+    mqttMessage: [data: eventdata.MQTTMessage];
+    mqttMessagePublished: [data: eventdata.MQTTMessagePublished];
+    publishEntityState: [data: eventdata.PublishEntityState];
+    groupMembersChanged: [data: eventdata.GroupMembersChanged];
+    devicesChanged: [];
+    scenesChanged: [data: eventdata.ScenesChanged];
+    reconfigure: [data: eventdata.Reconfigure];
+    stateChange: [data: eventdata.StateChange];
+}
+type EventBusListener<K> = K extends keyof EventBusMap
+    ? EventBusMap[K] extends unknown[]
+        ? (...args: EventBusMap[K]) => Promise<void> | void
+        : 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: { [s: string]: { event: string, callback: (...args: unknown[]) => void }[] } = {};
-    private emitter = new events.EventEmitter();
+    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);
    }

    public emitAdapterDisconnected(): void {
-        this.emitter.emit('adapterDisconnected');
+        this.emitter.emit("adapterDisconnected");
    }
    public onAdapterDisconnected(key: ListenerKey, callback: () => void): void {
-        this.on('adapterDisconnected', callback, key);
+        this.on("adapterDisconnected", callback, key);
    }

    public emitPermitJoinChanged(data: eventdata.PermitJoinChanged): void {
-        this.emitter.emit('permitJoinChanged', data);
+        this.emitter.emit("permitJoinChanged", data);
    }
    public onPermitJoinChanged(key: ListenerKey, callback: (data: eventdata.PermitJoinChanged) => void): void {
-        this.on('permitJoinChanged', callback, key);
-    }
-
-    public emitPublishAvailability(): void {
-        this.emitter.emit('publishAvailability');
-    }
-    public onPublishAvailability(key: ListenerKey, callback: () => void): void {
-        this.on('publishAvailability', callback, key);
+        this.on("permitJoinChanged", callback, key);
    }

    public emitEntityRenamed(data: eventdata.EntityRenamed): void {
-        this.emitter.emit('deviceRenamed', data);
+        this.emitter.emit("deviceRenamed", data);
    }
    public onEntityRenamed(key: ListenerKey, callback: (data: eventdata.EntityRenamed) => void): void {
-        this.on('deviceRenamed', callback, key);
+        this.on("deviceRenamed", callback, key);
    }

-    public emitDeviceRemoved(data: eventdata.DeviceRemoved): void {
-        this.emitter.emit('deviceRemoved', data);
+    public emitEntityRemoved(data: eventdata.EntityRemoved): void {
+        this.emitter.emit("deviceRemoved", data);
    }
-    public onDeviceRemoved(key: ListenerKey, callback: (data: eventdata.DeviceRemoved) => void): void {
-        this.on('deviceRemoved', callback, key);
+    public onEntityRemoved(key: ListenerKey, callback: (data: eventdata.EntityRemoved) => void): void {
+        this.on("deviceRemoved", callback, key);
    }

    public emitLastSeenChanged(data: eventdata.LastSeenChanged): void {
-        this.emitter.emit('lastSeenChanged', data);
+        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);
+        this.on("lastSeenChanged", callback, key);
    }

    public emitDeviceNetworkAddressChanged(data: eventdata.DeviceNetworkAddressChanged): void {
-        this.emitter.emit('deviceNetworkAddressChanged', data);
+        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);
+    public onDeviceNetworkAddressChanged(key: ListenerKey, callback: (data: eventdata.DeviceNetworkAddressChanged) => void): void {
+        this.on("deviceNetworkAddressChanged", callback, key);
    }

    public emitDeviceAnnounce(data: eventdata.DeviceAnnounce): void {
-        this.emitter.emit('deviceAnnounce', data);
+        this.emitter.emit("deviceAnnounce", data);
    }
    public onDeviceAnnounce(key: ListenerKey, callback: (data: eventdata.DeviceAnnounce) => void): void {
-        this.on('deviceAnnounce', callback, key);
+        this.on("deviceAnnounce", callback, key);
    }

    public emitDeviceInterview(data: eventdata.DeviceInterview): void {
-        this.emitter.emit('deviceInterview', data);
+        this.emitter.emit("deviceInterview", data);
    }
    public onDeviceInterview(key: ListenerKey, callback: (data: eventdata.DeviceInterview) => void): void {
-        this.on('deviceInterview', callback, key);
+        this.on("deviceInterview", callback, key);
    }

    public emitDeviceJoined(data: eventdata.DeviceJoined): void {
-        this.emitter.emit('deviceJoined', data);
+        this.emitter.emit("deviceJoined", data);
    }
    public onDeviceJoined(key: ListenerKey, callback: (data: eventdata.DeviceJoined) => void): void {
-        this.on('deviceJoined', callback, key);
+        this.on("deviceJoined", callback, key);
    }

    public emitEntityOptionsChanged(data: eventdata.EntityOptionsChanged): void {
-        this.emitter.emit('entityOptionsChanged', data);
+        this.emitter.emit("entityOptionsChanged", data);
    }
    public onEntityOptionsChanged(key: ListenerKey, callback: (data: eventdata.EntityOptionsChanged) => void): void {
-        this.on('entityOptionsChanged', callback, key);
+        this.on("entityOptionsChanged", callback, key);
    }

    public emitExposesChanged(data: eventdata.ExposesChanged): void {
-        this.emitter.emit('exposesChanged', data);
+        this.emitter.emit("exposesChanged", data);
    }
    public onExposesChanged(key: ListenerKey, callback: (data: eventdata.ExposesChanged) => void): void {
-        this.on('exposesChanged', callback, key);
+        this.on("exposesChanged", callback, key);
    }

    public emitDeviceLeave(data: eventdata.DeviceLeave): void {
-        this.emitter.emit('deviceLeave', data);
+        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);
+        this.on("deviceLeave", callback, key);
    }

    public emitDeviceMessage(data: eventdata.DeviceMessage): void {
-        this.emitter.emit('deviceMessage', data);
+        this.emitter.emit("deviceMessage", data);
    }
    public onDeviceMessage(key: ListenerKey, callback: (data: eventdata.DeviceMessage) => void): void {
-        this.on('deviceMessage', callback, key);
+        this.on("deviceMessage", callback, key);
    }

    public emitMQTTMessage(data: eventdata.MQTTMessage): void {
-        this.emitter.emit('mqttMessage', data);
+        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);
+        this.on("mqttMessage", callback, key);
    }

    public emitMQTTMessagePublished(data: eventdata.MQTTMessagePublished): void {
-        this.emitter.emit('mqttMessagePublished', data);
+        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);
+        this.on("mqttMessagePublished", callback, key);
    }

    public emitPublishEntityState(data: eventdata.PublishEntityState): void {
-        this.emitter.emit('publishEntityState', data);
+        this.emitter.emit("publishEntityState", data);
    }
    public onPublishEntityState(key: ListenerKey, callback: (data: eventdata.PublishEntityState) => void): void {
-        this.on('publishEntityState', callback, key);
+        this.on("publishEntityState", callback, key);
    }

    public emitGroupMembersChanged(data: eventdata.GroupMembersChanged): void {
-        this.emitter.emit('groupMembersChanged', data);
+        this.emitter.emit("groupMembersChanged", data);
    }
    public onGroupMembersChanged(key: ListenerKey, callback: (data: eventdata.GroupMembersChanged) => void): void {
-        this.on('groupMembersChanged', callback, key);
+        this.on("groupMembersChanged", callback, key);
    }

    public emitDevicesChanged(): void {
-        this.emitter.emit('devicesChanged');
+        this.emitter.emit("devicesChanged");
    }
    public onDevicesChanged(key: ListenerKey, callback: () => void): void {
-        this.on('devicesChanged', callback, key);
+        this.on("devicesChanged", callback, key);
    }

    public emitScenesChanged(data: eventdata.ScenesChanged): void {
-        this.emitter.emit('scenesChanged', data);
+        this.emitter.emit("scenesChanged", data);
    }
    public onScenesChanged(key: ListenerKey, callback: (data: eventdata.ScenesChanged) => void): void {
-        this.on('scenesChanged', callback, key);
+        this.on("scenesChanged", callback, key);
    }

    public emitReconfigure(data: eventdata.Reconfigure): void {
-        this.emitter.emit('reconfigure', data);
+        this.emitter.emit("reconfigure", data);
    }
    public onReconfigure(key: ListenerKey, callback: (data: eventdata.Reconfigure) => void): void {
-        this.on('reconfigure', callback, key);
+        this.on("reconfigure", callback, key);
    }

    public emitStateChange(data: eventdata.StateChange): void {
-        this.emitter.emit('stateChange', data);
+        this.emitter.emit("stateChange", data);
    }
    public onStateChange(key: ListenerKey, callback: (data: eventdata.StateChange) => void): void {
-        this.on('stateChange', callback, key);
+        this.on("stateChange", callback, key);
    }

-    private on(event: string, callback: (...args: unknown[]) => (Promise<void> | void), key: ListenerKey): void {
-        if (!this.callbacksByExtension[key.constructor.name]) this.callbacksByExtension[key.constructor.name] = [];
-        const wrappedCallback = async (...args: unknown[]): Promise<void> => {
+    public emitExposesAndDevicesChanged(device: Device): void {
+        this.emitDevicesChanged();
+        this.emitExposesChanged({device});
+    }
+
+    private on<K extends keyof EventBusMap>(event: K, callback: EventBusListener<K>, key: ListenerKey): void {
+        if (!this.callbacksByExtension.has(key.constructor.name)) {
+            this.callbacksByExtension.set(key.constructor.name, []);
+        }
+
+        const wrappedCallback = async (...args: never[]): Promise<void> => {
            try {
                await callback(...args);
            } catch (error) {
-                logger.error(`EventBus error '${key.constructor.name}/${event}': ${error.message}`);
-                logger.debug(error.stack);
+                logger.error(`EventBus error '${key.constructor.name}/${event}': ${(error as Error).message}`);
+                // biome-ignore lint/style/noNonNullAssertion: always Error
+                logger.debug((error as Error).stack!);
            }
        };
-        this.callbacksByExtension[key.constructor.name].push({event, callback: wrappedCallback});
-        this.emitter.on(event, wrappedCallback);
+
+        // biome-ignore lint/style/noNonNullAssertion: just created if wasn't valid
+        this.callbacksByExtension.get(key.constructor.name)!.push({event, callback: wrappedCallback});
+        this.emitter.on(event, wrappedCallback as EventBusListener<K>);
    }

    public removeListeners(key: ListenerKey): void {
-        this.callbacksByExtension[key.constructor.name]?.forEach(
-            (e) => this.emitter.removeListener(e.event, e.callback));
+        const callbacks = this.callbacksByExtension.get(key.constructor.name);
+
+        if (callbacks) {
+            for (const cb of callbacks) {
+                this.emitter.removeListener(cb.event, cb.callback);
+            }
+        }
    }
 }
@@ -1,96 +1,168 @@
-import Extension from './extension';
-import logger from '../util/logger';
-import utils from '../util/utils';
-import * as settings from '../util/settings';
-import debounce from 'debounce';
-import bind from 'bind-decorator';
-import * as zhc from 'zigbee-herdsman-converters';
+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";

-const retrieveOnReconnect = [
-    {keys: ['state']},
-    {keys: ['brightness'], condition: (state: KeyValue): boolean => state.state === 'ON'},
-    {keys: ['color', 'color_temp'], condition: (state: KeyValue): boolean => state.state === 'ON'},
+import logger from "../util/logger";
+import * as settings from "../util/settings";
+import utils from "../util/utils";
+import Extension from "./extension";
+
+const RETRIEVE_ON_RECONNECT: readonly {keys: string[]; condition?: (state: KeyValue) => boolean}[] = [
+    {keys: ["state"]},
+    {keys: ["brightness"], condition: (state: KeyValue): boolean => state.state === "ON"},
+    {keys: ["color", "color_temp"], condition: (state: KeyValue): boolean => state.state === "ON"},
 ];

 export default class Availability extends Extension {
-    private timers: {[s: string]: NodeJS.Timeout} = {};
-    private availabilityCache: {[s: string]: boolean} = {};
-    private retrieveStateDebouncers: {[s: string]: () => void} = {};
+    /** Mapped by IEEE address */
+    private readonly timers = new Map<string, NodeJS.Timeout>();
+    /** Mapped by IEEE address or Group ID */
+    private readonly lastPublishedAvailabilities = new Map<string | number, boolean>();
+    /** Mapped by IEEE address */
+    private readonly pingBackoffs = new Map<string, number>();
+    /** IEEE addresses, waiting for last seen changes to take them out of "availability sleep" */
+    private readonly backoffPausedDevices = new Set<string>();
+    /** Mapped by IEEE address */
+    private readonly retrieveStateDebouncers = new Map<string, () => void>();
    private pingQueue: Device[] = [];
    private pingQueueExecuting = false;
    private stopped = false;

    private getTimeout(device: Device): number {
-        if (typeof device.options.availability === 'object' && device.options.availability?.timeout != null) {
+        if (typeof device.options.availability === "object" && device.options.availability?.timeout != null) {
            return utils.minutes(device.options.availability.timeout);
        }

-        const key = this.isActiveDevice(device) ? 'active' : 'passive';
-        let value = settings.get().availability?.[key]?.timeout;
-        if (value == null) value = key == 'active' ? 10 : 1500;
-        return utils.minutes(value);
+        return utils.minutes(this.isActiveDevice(device) ? settings.get().availability.active.timeout : settings.get().availability.passive.timeout);
+    }
+
+    private getMaxJitter(device: Device): number {
+        if (typeof device.options.availability === "object" && device.options.availability?.max_jitter != null) {
+            return device.options.availability.max_jitter;
+        }
+
+        return settings.get().availability.active.max_jitter;
+    }
+
+    private getBackoff(device: Device): boolean {
+        if (typeof device.options.availability === "object" && device.options.availability?.backoff != null) {
+            return device.options.availability.backoff;
+        }
+
+        return settings.get().availability.active.backoff;
+    }
+
+    private getPauseOnBackoffGt(device: Device): number {
+        if (typeof device.options.availability === "object" && device.options.availability?.pause_on_backoff_gt != null) {
+            return device.options.availability.pause_on_backoff_gt;
+        }
+
+        return settings.get().availability.active.pause_on_backoff_gt;
    }

    private isActiveDevice(device: Device): boolean {
-        return (device.zh.type === 'Router' && device.zh.powerSource !== 'Battery') ||
-            device.zh.powerSource === 'Mains (single phase)';
+        return (
+            (device.zh.type === "Router" && device.zh.powerSource !== "Battery") ||
+            (device.zh.powerSource !== undefined && device.zh.powerSource !== "Unknown" && device.zh.powerSource !== "Battery")
+        );
    }

    private isAvailable(entity: Device | Group): boolean {
        if (entity.isDevice()) {
-            const ago = Date.now() - entity.zh.lastSeen;
-            return ago < this.getTimeout(entity);
+            const lastSeen = entity.zh.lastSeen ?? /* v8 ignore next */ 0;
+
+            return Date.now() - lastSeen < this.getTimeout(entity);
+        }
+
+        for (const memberDevice of entity.membersDevices()) {
+            if (this.lastPublishedAvailabilities.get(memberDevice.ieeeAddr) === true) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private resetTimer(device: Device, resetBackoff = false): void {
+        clearTimeout(this.timers.get(device.ieeeAddr));
+        this.removeFromPingQueue(device);
+
+        // If the timer triggers, the device is not available anymore otherwise resetTimer already has been called
+        if (this.isActiveDevice(device)) {
+            const backoffEnabled = this.getBackoff(device);
+            const jitter = Math.random() * this.getMaxJitter(device);
+            let backoff = 1;
+
+            if (resetBackoff) {
+                // always cleanup even if backoff disabled (ensures proper state if changed at runtime)
+                this.backoffPausedDevices.delete(device.ieeeAddr);
+                this.pingBackoffs.delete(device.ieeeAddr);
+            } else if (backoffEnabled) {
+                backoff = this.pingBackoffs.get(device.ieeeAddr) ?? 1;
+            }
+
+            // never paused if was reset (just deleted) or backoff disabled, might as well skip the Set lookup
+            if (!backoffEnabled || resetBackoff || !this.backoffPausedDevices.has(device.ieeeAddr)) {
+                // If device did not check in, ping it, if that fails it will be marked as offline
+                this.timers.set(
+                    device.ieeeAddr,
+                    setTimeout(this.addToPingQueue.bind(this, device), (this.getTimeout(device) + utils.seconds(1) + jitter) * backoff),
+                );
+            }
        } else {
-            return entity.membersDevices().length === 0 ||
-                entity.membersDevices().map((d) => this.availabilityCache[d.ieeeAddr]).includes(true);
+            this.timers.set(
+                device.ieeeAddr,
+                setTimeout(this.publishAvailability.bind(this, device, true), this.getTimeout(device) + utils.seconds(1)),
+            );
        }
    }

-    private resetTimer(device: Device): void {
-        clearTimeout(this.timers[device.ieeeAddr]);
-
-        // If the timer triggers, the device is not available anymore otherwise resetTimer already have been called
-        if (this.isActiveDevice(device)) {
-            // If device did not check in, ping it, if that fails it will be marked as offline
-            this.timers[device.ieeeAddr] = setTimeout(
-                () => this.addToPingQueue(device), this.getTimeout(device) + utils.seconds(1));
-        } else {
-            this.timers[device.ieeeAddr] = setTimeout(
-                () => this.publishAvailability(device, true), this.getTimeout(device) + utils.seconds(1));
-        }
+    private clearTimer(ieeeAddress: string): void {
+        clearTimeout(this.timers.get(ieeeAddress));
+        this.timers.delete(ieeeAddress);
    }

    private addToPingQueue(device: Device): void {
        this.pingQueue.push(device);
-        this.pingQueueExecuteNext();
+        this.pingQueueExecuteNext().catch(utils.noop);
    }

    private removeFromPingQueue(device: Device): void {
        const index = this.pingQueue.findIndex((d) => d.ieeeAddr === device.ieeeAddr);
-        index != -1 && this.pingQueue.splice(index, 1);
+        if (index !== -1) {
+            this.pingQueue.splice(index, 1);
+        }
    }

    private async pingQueueExecuteNext(): Promise<void> {
-        if (this.pingQueue.length === 0 || this.pingQueueExecuting) return;
-        this.pingQueueExecuting = true;
+        if (this.pingQueue.length === 0 || this.pingQueueExecuting) {
+            return;
+        }

+        this.pingQueueExecuting = true;
        const device = this.pingQueue[0];
-        let pingedSuccessfully = false;
-        const available = this.availabilityCache[device.ieeeAddr] || this.isAvailable(device);
+        let pingSuccess = false;
+        const available = this.lastPublishedAvailabilities.get(device.ieeeAddr) || this.isAvailable(device);
        const attempts = available ? 2 : 1;
-        for (let i = 0; i < attempts; i++) {
+
+        for (let i = 1; i <= attempts; i++) {
            try {
                // Enable recovery if device is marked as available and first ping fails.
-                const disableRecovery = !(i == 1 && available);
-                await device.zh.ping(disableRecovery);
-                pingedSuccessfully = true;
-                logger.debug(`Successfully pinged '${device.name}' (attempt ${i + 1}/${attempts})`);
+                await device.zh.ping(!available || i !== 2);
+
+                pingSuccess = true;
+
+                logger.debug(`Successfully pinged '${device.name}' (attempt ${i}/${attempts})`);
                break;
            } catch (error) {
-                logger.warning(`Failed to ping '${device.name}' (attempt ${i + 1}/${attempts}, ${error.message})`);
+                logger.warning(`Failed to ping '${device.name}' (attempt ${i}/${attempts}, ${(error as Error).message})`);
+
                // Try again in 3 seconds.
-                const lastAttempt = i - 1 === attempts;
-                !lastAttempt && await utils.sleep(3);
+                if (i !== attempts) {
+                    await utils.sleep(3);
+                }
            }
        }

@@ -99,104 +171,125 @@ export default class Availability extends Extension {
            return;
        }

-        this.publishAvailability(device, !pingedSuccessfully);
-        this.resetTimer(device);
+        if (!pingSuccess && this.getBackoff(device)) {
+            const currentBackoff = this.pingBackoffs.get(device.ieeeAddr) ?? 1;
+            // setting is "greater than" but since we already did the ping, we use ">=" for comparison below (pause next)
+            const pauseOnBackoff = this.getPauseOnBackoffGt(device);
+
+            if (pauseOnBackoff > 0 && currentBackoff >= pauseOnBackoff) {
+                this.backoffPausedDevices.add(device.ieeeAddr);
+            } else {
+                // results in backoffs: *1.5, *3, *6, *12... (with default timeout: 10, 15, 30, 60, 120)
+                this.pingBackoffs.set(device.ieeeAddr, currentBackoff * (available ? 1.5 : 2));
+            }
+        }
+
+        await this.publishAvailability(device, !pingSuccess);
+        this.resetTimer(device, pingSuccess);
        this.removeFromPingQueue(device);

        // Sleep 2 seconds before executing next ping
        await utils.sleep(2);
+
        this.pingQueueExecuting = false;
-        this.pingQueueExecuteNext();
+
+        await this.pingQueueExecuteNext();
    }

    override async start(): Promise<void> {
        if (this.stopped) {
-            throw new Error('This extension cannot be restarted.');
+            throw new Error("This extension cannot be restarted.");
        }

-        this.eventBus.onEntityRenamed(this, (data) => {
+        this.eventBus.onEntityRenamed(this, async (data) => {
            if (utils.isAvailabilityEnabledForEntity(data.entity, settings.get())) {
-                this.mqtt.publish(`${data.from}/availability`, null, {retain: true, qos: 1});
-                this.publishAvailability(data.entity, false, true);
+                await this.mqtt.publish(`${data.from}/availability`, "", {clientOptions: {retain: true, qos: 1}});
+                await this.publishAvailability(data.entity, false, true);
            }
        });
-
-        this.eventBus.onDeviceRemoved(this, (data) => clearTimeout(this.timers[data.ieeeAddr]));
-        this.eventBus.onDeviceLeave(this, (data) => clearTimeout(this.timers[data.ieeeAddr]));
+        this.eventBus.onEntityRemoved(this, (data) => data.type === "device" && this.clearTimer(data.id));
+        this.eventBus.onDeviceLeave(this, (data) => this.clearTimer(data.ieeeAddr));
        this.eventBus.onDeviceAnnounce(this, (data) => this.retrieveState(data.device));
        this.eventBus.onLastSeenChanged(this, this.onLastSeenChanged);
-        this.eventBus.onPublishAvailability(this, this.publishAvailabilityForAllEntities);
        this.eventBus.onGroupMembersChanged(this, (data) => this.publishAvailability(data.group, false));
-        this.publishAvailabilityForAllEntities();
-    }

-    @bind private publishAvailabilityForAllEntities(): void {
-        for (const entity of [...this.zigbee.devices(false), ...this.zigbee.groups()]) {
-            if (utils.isAvailabilityEnabledForEntity(entity, settings.get())) {
-                // Publish initial availability
-                this.publishAvailability(entity, true, false, true);
+        // Publish initial availability
+        await this.publishAvailabilityForAllEntities();

-                if (entity.isDevice()) {
-                    this.resetTimer(entity);
+        // Start availability for the devices
+        for (const device of this.zigbee.devicesIterator(utils.deviceNotCoordinator)) {
+            if (utils.isAvailabilityEnabledForEntity(device, settings.get())) {
+                this.resetTimer(device);

-                    // If an active device is initially unavailable, ping it.
-                    if (this.isActiveDevice(entity) && !this.isAvailable(entity)) {
-                        this.addToPingQueue(entity);
-                    }
+                // If an active device is unavailable on start, add it to the pingqueue immediately.
+                if (this.isActiveDevice(device) && !this.isAvailable(device)) {
+                    this.addToPingQueue(device);
                }
            }
        }
    }

-    private publishAvailability(entity: Device | Group, logLastSeen: boolean,
-        forcePublish=false, skipGroups=false): void {
+    private async publishAvailabilityForAllEntities(): Promise<void> {
+        for (const entity of this.zigbee.devicesAndGroupsIterator(utils.deviceNotCoordinator)) {
+            if (utils.isAvailabilityEnabledForEntity(entity, settings.get())) {
+                await this.publishAvailability(entity, true, false, true);
+            }
+        }
+    }
+
+    private async publishAvailability(entity: Device | Group, logLastSeen: boolean, forcePublish = false, skipGroups = false): Promise<void> {
        if (logLastSeen && entity.isDevice()) {
-            const ago = Date.now() - entity.zh.lastSeen;
+            const ago = Date.now() - (entity.zh.lastSeen ?? /* v8 ignore next */ 0);
+
            if (this.isActiveDevice(entity)) {
-                logger.debug(`Active device '${entity.name}' was last seen ` +
-                    `'${(ago / utils.minutes(1)).toFixed(2)}' minutes ago.`);
+                logger.debug(`Active device '${entity.name}' was last seen '${(ago / utils.minutes(1)).toFixed(2)}' minutes ago.`);
            } else {
-                logger.debug(
-                    `Passive device '${entity.name}' was last seen '${(ago / utils.hours(1)).toFixed(2)}' hours ago.`);
+                logger.debug(`Passive device '${entity.name}' was last seen '${(ago / utils.hours(1)).toFixed(2)}' hours ago.`);
            }
        }

        const available = this.isAvailable(entity);
-        if (!forcePublish && this.availabilityCache[entity.ID] == available) {
+
+        if (!forcePublish && this.lastPublishedAvailabilities.get(entity.ID) === available) {
            return;
        }

-        if (entity.isDevice() && entity.ieeeAddr in this.availabilityCache && available &&
-            this.availabilityCache[entity.ieeeAddr] === false) {
+        if (entity.isDevice() && available && this.lastPublishedAvailabilities.get(entity.ieeeAddr) === false) {
            logger.debug(`Device '${entity.name}' reconnected`);
            this.retrieveState(entity);
        }

        const topic = `${entity.name}/availability`;
-        const payload = utils.availabilityPayload(available ? 'online' : 'offline', settings.get());
-        this.availabilityCache[entity.ID] = available;
-        this.mqtt.publish(topic, payload, {retain: true, qos: 1});
+        const payload: Zigbee2MQTTAPI["{friendlyName}/availability"] = {state: available ? "online" : "offline"};
+        this.lastPublishedAvailabilities.set(entity.ID, available);
+        await this.mqtt.publish(topic, JSON.stringify(payload), {clientOptions: {retain: true, qos: 1}});

        if (!skipGroups && entity.isDevice()) {
-            this.zigbee.groups().filter((g) => g.hasMember(entity))
-                .filter((g) => utils.isAvailabilityEnabledForEntity(g, settings.get()))
-                .forEach((g) => this.publishAvailability(g, false, forcePublish));
+            for (const group of this.zigbee.groupsIterator()) {
+                if (group.hasMember(entity) && utils.isAvailabilityEnabledForEntity(group, settings.get())) {
+                    await this.publishAvailability(group, false, forcePublish);
+                }
+            }
        }
    }

-    @bind private onLastSeenChanged(data: eventdata.LastSeenChanged): void {
+    @bind private async onLastSeenChanged(data: eventdata.LastSeenChanged): Promise<void> {
        if (utils.isAvailabilityEnabledForEntity(data.device, settings.get())) {
            // Remove from ping queue, not necessary anymore since we know the device is online.
            this.removeFromPingQueue(data.device);
-            this.resetTimer(data.device);
-            this.publishAvailability(data.device, false);
+            this.resetTimer(data.device, true);
+            await this.publishAvailability(data.device, false);
        }
    }

    override async stop(): Promise<void> {
        this.stopped = true;
        this.pingQueue = [];
-        Object.values(this.timers).forEach((t) => clearTimeout(t));
+
+        for (const [, t] of this.timers) {
+            clearTimeout(t);
+        }
+
        await super.stop();
    }

@@ -205,28 +298,48 @@ export default class Availability extends Extension {
         * Retrieve state of a device in a debounced manner, this function is called on a 'deviceAnnounce' which a
         * device can send multiple times after each other.
         */
-        if (device.definition && !device.zh.interviewing && !this.retrieveStateDebouncers[device.ieeeAddr]) {
-            this.retrieveStateDebouncers[device.ieeeAddr] = debounce(async () => {
-                logger.debug(`Retrieving state of '${device.name}' after reconnect`);
-                // Color and color temperature converters do both, only needs to be called once.
-                for (const item of retrieveOnReconnect) {
-                    if (item.condition && this.state.get(device) && !item.condition(this.state.get(device))) continue;
-                    const converter = device.definition.toZigbee.find((c) => c.key.find((k) => item.keys.includes(k)));
-                    const options: KeyValue = device.options;
-                    const state = this.state.get(device);
-                    const meta: zhc.Tz.Meta = {
-                        message: this.state.get(device), mapped: device.definition, endpoint_name: null,
-                        options, state, device: device.zh,
-                    };
-                    await converter?.convertGet?.(device.endpoint(), item.keys[0], meta)
-                        .catch((e) => {
-                            logger.error(`Failed to read state of '${device.name}' after reconnect (${e.message})`);
-                        });
-                    await utils.sleep(500);
-                }
-            }, utils.seconds(2));
+        if (device.definition && device.interviewed && !this.retrieveStateDebouncers.get(device.ieeeAddr)) {
+            this.retrieveStateDebouncers.set(
+                device.ieeeAddr,
+                debounce(async () => {
+                    logger.debug(`Retrieving state of '${device.name}' after reconnect`);
+
+                    // Color and color temperature converters do both, only needs to be called once.
+                    for (const item of RETRIEVE_ON_RECONNECT) {
+                        if (item.condition && this.state.get(device) && !item.condition(this.state.get(device))) {
+                            continue;
+                        }
+
+                        // biome-ignore lint/style/noNonNullAssertion: doesn't change once valid
+                        const converter = device.definition!.toZigbee.find((c) => !c.key || c.key.find((k) => item.keys.includes(k)));
+                        const options: KeyValue = device.options;
+                        const state = this.state.get(device);
+                        const meta: zhc.Tz.Meta = {
+                            message: this.state.get(device),
+                            // biome-ignore lint/style/noNonNullAssertion: doesn't change once valid
+                            mapped: device.definition!,
+                            endpoint_name: undefined,
+                            options,
+                            state,
+                            device: device.zh,
+                            /* v8 ignore next */
+                            publish: (payload: KeyValue) => this.publishEntityState(device, payload),
+                        };
+
+                        try {
+                            const endpoint = device.endpoint();
+                            assert(endpoint);
+                            await converter?.convertGet?.(endpoint, item.keys[0], meta);
+                        } catch (error) {
+                            logger.error(`Failed to read state of '${device.name}' after reconnect (${(error as Error).message})`);
+                        }
+
+                        await utils.sleep(500);
+                    }
+                }, utils.seconds(2)),
+            );
        }

-        this.retrieveStateDebouncers[device.ieeeAddr]?.();
+        this.retrieveStateDebouncers.get(device.ieeeAddr)?.();
    }
 }
@@ -1,363 +1,443 @@
-import * as settings from '../util/settings';
-import logger from '../util/logger';
-import utils from '../util/utils';
-import Extension from './extension';
-import stringify from 'json-stable-stringify-without-jsonify';
-import debounce from 'debounce';
-import * as zigbeeHerdsman from 'zigbee-herdsman/dist';
-import bind from 'bind-decorator';
-import Device from '../model/device';
-import Group from '../model/group';
+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 Extension from "./extension";

-const legacyApi = settings.get().advanced.legacy_api;
-const legacyTopicRegex = new RegExp(`^${settings.get().mqtt.base_topic}/bridge/(bind|unbind)/.+$`);
-const topicRegex = new RegExp(`^${settings.get().mqtt.base_topic}/bridge/request/device/(bind|unbind)`);
-const allClusterCandidates = ['genScenes', 'genOnOff', 'genLevelCtrl', 'lightingColorCtrl', 'closuresWindowCovering',
-    'hvacThermostat', 'msIlluminanceMeasurement', 'msTemperatureMeasurement', 'msRelativeHumidity',
-    'msSoilMoisture', 'msCO2'];
+const TOPIC_REGEX = new RegExp(`^${settings.get().mqtt.base_topic}/bridge/request/device/(bind|unbind)`);
+const ALL_CLUSTER_CANDIDATES: readonly ClusterName[] = [
+    "genScenes",
+    "genOnOff",
+    "genLevelCtrl",
+    "lightingColorCtrl",
+    "closuresWindowCovering",
+    "hvacThermostat",
+    "msIlluminanceMeasurement",
+    "msTemperatureMeasurement",
+    "msRelativeHumidity",
+    "msSoilMoisture",
+    "msCO2",
+];

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

-const defaultReportConfiguration = {
-    minimumReportInterval: 5, maximumReportInterval: 3600, reportableChange: 1,
-};
-
-const getColorCapabilities = async (endpoint: zh.Endpoint): Promise<{colorTemperature: boolean, colorXY: boolean}> => {
-    if (endpoint.getClusterAttributeValue('lightingColorCtrl', 'colorCapabilities') == null) {
-        await endpoint.read('lightingColorCtrl', ['colorCapabilities']);
+const getColorCapabilities = async (endpoint: zh.Endpoint): Promise<{colorTemperature: boolean; colorXY: boolean}> => {
+    if (endpoint.getClusterAttributeValue("lightingColorCtrl", "colorCapabilities") == null) {
+        await endpoint.read("lightingColorCtrl", ["colorCapabilities"]);
    }

-    const value = endpoint.getClusterAttributeValue('lightingColorCtrl', 'colorCapabilities') as number;
+    const value = endpoint.getClusterAttributeValue("lightingColorCtrl", "colorCapabilities") as number;
+
    return {
-        colorTemperature: (value & 1<<4) > 0,
-        colorXY: (value & 1<<3) > 0,
+        colorTemperature: (value & (1 << 4)) > 0,
+        colorXY: (value & (1 << 3)) > 0,
    };
 };

-const reportClusters: {[s: string]:
-    {attribute: string, minimumReportInterval: number, maximumReportInterval: number, reportableChange: number
-        condition?: (endpoint: zh.Endpoint) => Promise<boolean>}[]} =
-{
-    'genOnOff': [
-        {attribute: 'onOff', ...defaultReportConfiguration, minimumReportInterval: 0, reportableChange: 0},
-    ],
-    'genLevelCtrl': [
-        {attribute: 'currentLevel', ...defaultReportConfiguration},
-    ],
-    'lightingColorCtrl': [
+const REPORT_CLUSTERS: Readonly<
+    Partial<
+        Record<
+            ClusterName,
+            Readonly<{
+                attribute: string;
+                minimumReportInterval: number;
+                maximumReportInterval: number;
+                reportableChange: number;
+                condition?: (endpoint: zh.Endpoint) => Promise<boolean>;
+            }>[]
+        >
+    >
+> = {
+    genOnOff: [{attribute: "onOff", ...DEFAULT_REPORT_CONFIG, minimumReportInterval: 0, reportableChange: 0}],
+    genLevelCtrl: [{attribute: "currentLevel", ...DEFAULT_REPORT_CONFIG}],
+    lightingColorCtrl: [
        {
-            attribute: 'colorTemperature', ...defaultReportConfiguration,
+            attribute: "colorTemperature",
+            ...DEFAULT_REPORT_CONFIG,
            condition: async (endpoint): Promise<boolean> => (await getColorCapabilities(endpoint)).colorTemperature,
        },
        {
-            attribute: 'currentX', ...defaultReportConfiguration,
+            attribute: "currentX",
+            ...DEFAULT_REPORT_CONFIG,
            condition: async (endpoint): Promise<boolean> => (await getColorCapabilities(endpoint)).colorXY,
        },
        {
-            attribute: 'currentY', ...defaultReportConfiguration,
+            attribute: "currentY",
+            ...DEFAULT_REPORT_CONFIG,
            condition: async (endpoint): Promise<boolean> => (await getColorCapabilities(endpoint)).colorXY,
        },
    ],
-    'closuresWindowCovering': [
-        {attribute: 'currentPositionLiftPercentage', ...defaultReportConfiguration},
-        {attribute: 'currentPositionTiltPercentage', ...defaultReportConfiguration},
+    closuresWindowCovering: [
+        {attribute: "currentPositionLiftPercentage", ...DEFAULT_REPORT_CONFIG},
+        {attribute: "currentPositionTiltPercentage", ...DEFAULT_REPORT_CONFIG},
    ],
 };

 type PollOnMessage = {
-    cluster: {[s: string]: {type: string, data: KeyValue}[]}
-    read: {cluster: string, attributes: string[], attributesForEndpoint?: (endpoint: zh.Endpoint) => Promise<string[]>}
-    manufacturerIDs: number[],
-    manufacturerNames: string [],
+    cluster: Readonly<Partial<Record<ClusterName, {type: string; data: KeyValue}[]>>>;
+    read: Readonly<{cluster: string; attributes: string[]; attributesForEndpoint?: (endpoint: zh.Endpoint) => Promise<string[]>}>;
+    manufacturerIDs: readonly Zcl.ManufacturerCode[];
+    manufacturerNames: readonly string[];
 }[];

-const pollOnMessage: PollOnMessage = [
+const POLL_ON_MESSAGE: Readonly<PollOnMessage> = [
    {
        // On messages that have the cluster and type of below
        cluster: {
            manuSpecificPhilips: [
-                {type: 'commandHueNotification', data: {button: 2}},
-                {type: 'commandHueNotification', data: {button: 3}},
+                {type: "commandHueNotification", data: {button: 2}},
+                {type: "commandHueNotification", data: {button: 3}},
            ],
            genLevelCtrl: [
-                {type: 'commandStep', data: {}},
-                {type: 'commandStepWithOnOff', data: {}},
-                {type: 'commandStop', data: {}},
-                {type: 'commandMoveWithOnOff', data: {}},
-                {type: 'commandStopWithOnOff', data: {}},
-                {type: 'commandMove', data: {}},
-                {type: 'commandMoveToLevelWithOnOff', data: {}},
-            ],
-            genScenes: [
-                {type: 'commandRecall', data: {}},
+                {type: "commandStep", data: {}},
+                {type: "commandStepWithOnOff", data: {}},
+                {type: "commandStop", data: {}},
+                {type: "commandMoveWithOnOff", data: {}},
+                {type: "commandStopWithOnOff", data: {}},
+                {type: "commandMove", data: {}},
+                {type: "commandMoveToLevelWithOnOff", data: {}},
            ],
+            genScenes: [{type: "commandRecall", data: {}}],
        },
        // Read the following attributes
-        read: {cluster: 'genLevelCtrl', attributes: ['currentLevel']},
+        read: {cluster: "genLevelCtrl", attributes: ["currentLevel"]},
        // When the bound devices/members of group have the following manufacturerIDs
        manufacturerIDs: [
-            zigbeeHerdsman.Zcl.ManufacturerCode.SIGNIFY_NETHERLANDS_B_V,
-            zigbeeHerdsman.Zcl.ManufacturerCode.ATMEL,
-            zigbeeHerdsman.Zcl.ManufacturerCode.GLEDOPTO_CO_LTD,
-            zigbeeHerdsman.Zcl.ManufacturerCode.MUELLER_LICHT_INTERNATIONAL_INC,
-            zigbeeHerdsman.Zcl.ManufacturerCode.TELINK_MICRO,
-            zigbeeHerdsman.Zcl.ManufacturerCode.BUSCH_JAEGER_ELEKTRO,
-        ],
-        manufacturerNames: [
-            'GLEDOPTO',
-            'Trust International B.V.\u0000',
+            Zcl.ManufacturerCode.SIGNIFY_NETHERLANDS_B_V,
+            Zcl.ManufacturerCode.ATMEL,
+            Zcl.ManufacturerCode.GLEDOPTO_CO_LTD,
+            Zcl.ManufacturerCode.MUELLER_LICHT_INTERNATIONAL_INC,
+            Zcl.ManufacturerCode.TELINK_MICRO,
+            Zcl.ManufacturerCode.BUSCH_JAEGER_ELEKTRO,
        ],
+        manufacturerNames: ["GLEDOPTO", "Trust International B.V.\u0000"],
    },
    {
        cluster: {
            genLevelCtrl: [
-                {type: 'commandStepWithOnOff', data: {}},
-                {type: 'commandMoveWithOnOff', data: {}},
-                {type: 'commandStopWithOnOff', data: {}},
-                {type: 'commandMoveToLevelWithOnOff', data: {}},
+                {type: "commandStepWithOnOff", data: {}},
+                {type: "commandMoveWithOnOff", data: {}},
+                {type: "commandStopWithOnOff", data: {}},
+                {type: "commandMoveToLevelWithOnOff", data: {}},
            ],
            genOnOff: [
-                {type: 'commandOn', data: {}},
-                {type: 'commandOff', data: {}},
-                {type: 'commandOffWithEffect', data: {}},
-                {type: 'commandToggle', data: {}},
-            ],
-            genScenes: [
-                {type: 'commandRecall', data: {}},
+                {type: "commandOn", data: {}},
+                {type: "commandOff", data: {}},
+                {type: "commandOffWithEffect", data: {}},
+                {type: "commandToggle", data: {}},
            ],
+            genScenes: [{type: "commandRecall", data: {}}],
            manuSpecificPhilips: [
-                {type: 'commandHueNotification', data: {button: 1}},
-                {type: 'commandHueNotification', data: {button: 4}},
+                {type: "commandHueNotification", data: {button: 1}},
+                {type: "commandHueNotification", data: {button: 4}},
            ],
        },
-        read: {cluster: 'genOnOff', attributes: ['onOff']},
+        read: {cluster: "genOnOff", attributes: ["onOff"]},
        manufacturerIDs: [
-            zigbeeHerdsman.Zcl.ManufacturerCode.SIGNIFY_NETHERLANDS_B_V,
-            zigbeeHerdsman.Zcl.ManufacturerCode.ATMEL,
-            zigbeeHerdsman.Zcl.ManufacturerCode.GLEDOPTO_CO_LTD,
-            zigbeeHerdsman.Zcl.ManufacturerCode.MUELLER_LICHT_INTERNATIONAL_INC,
-            zigbeeHerdsman.Zcl.ManufacturerCode.TELINK_MICRO,
-            zigbeeHerdsman.Zcl.ManufacturerCode.BUSCH_JAEGER_ELEKTRO,
-        ],
-        manufacturerNames: [
-            'GLEDOPTO',
-            'Trust International B.V.\u0000',
+            Zcl.ManufacturerCode.SIGNIFY_NETHERLANDS_B_V,
+            Zcl.ManufacturerCode.ATMEL,
+            Zcl.ManufacturerCode.GLEDOPTO_CO_LTD,
+            Zcl.ManufacturerCode.MUELLER_LICHT_INTERNATIONAL_INC,
+            Zcl.ManufacturerCode.TELINK_MICRO,
+            Zcl.ManufacturerCode.BUSCH_JAEGER_ELEKTRO,
        ],
+        manufacturerNames: ["GLEDOPTO", "Trust International B.V.\u0000"],
    },
    {
        cluster: {
-            genScenes: [
-                {type: 'commandRecall', data: {}},
-            ],
+            genScenes: [{type: "commandRecall", data: {}}],
        },
        read: {
-            cluster: 'lightingColorCtrl',
+            cluster: "lightingColorCtrl",
            attributes: [] as string[],
            // Since not all devices support the same attributes they need to be calculated dynamically
            // depending on the capabilities of the endpoint.
            attributesForEndpoint: async (endpoint): Promise<string[]> => {
                const supportedAttrs = await getColorCapabilities(endpoint);
                const readAttrs: string[] = [];
-                supportedAttrs.colorXY && readAttrs.push('currentX', 'currentY');
-                supportedAttrs.colorTemperature && readAttrs.push('colorTemperature');
+
+                if (supportedAttrs.colorXY) {
+                    readAttrs.push("currentX", "currentY");
+                }
+
+                if (supportedAttrs.colorTemperature) {
+                    readAttrs.push("colorTemperature");
+                }
+
                return readAttrs;
            },
        },
        manufacturerIDs: [
-            zigbeeHerdsman.Zcl.ManufacturerCode.SIGNIFY_NETHERLANDS_B_V,
-            zigbeeHerdsman.Zcl.ManufacturerCode.ATMEL,
-            zigbeeHerdsman.Zcl.ManufacturerCode.GLEDOPTO_CO_LTD,
-            zigbeeHerdsman.Zcl.ManufacturerCode.MUELLER_LICHT_INTERNATIONAL_INC,
-            zigbeeHerdsman.Zcl.ManufacturerCode.TELINK_MICRO,
+            Zcl.ManufacturerCode.SIGNIFY_NETHERLANDS_B_V,
+            Zcl.ManufacturerCode.ATMEL,
+            Zcl.ManufacturerCode.GLEDOPTO_CO_LTD,
+            Zcl.ManufacturerCode.MUELLER_LICHT_INTERNATIONAL_INC,
+            Zcl.ManufacturerCode.TELINK_MICRO,
            // Note: ManufacturerCode.BUSCH_JAEGER is left out intentionally here as their devices don't support colors
        ],
-        manufacturerNames: [
-            'GLEDOPTO',
-            'Trust International B.V.\u0000',
-        ],
+        manufacturerNames: ["GLEDOPTO", "Trust International B.V.\u0000"],
    },
 ];

 interface ParsedMQTTMessage {
-    type: 'bind' | 'unbind', sourceKey: string, targetKey: string, clusters: string[], skipDisableReporting: boolean
+    type: "bind" | "unbind";
+    sourceKey?: string;
+    sourceEndpointKey?: string | number;
+    targetKey?: string | number;
+    targetEndpointKey?: string | number;
+    clusters?: string[];
+    skipDisableReporting: boolean;
+    resolvedSource?: Device;
+    resolvedTarget?: Device | Group | typeof DEFAULT_BIND_GROUP;
+    resolvedSourceEndpoint?: zh.Endpoint;
+    resolvedBindTarget?: number | zh.Endpoint | zh.Group;
 }

 export default class Bind extends Extension {
    private pollDebouncers: {[s: string]: () => void} = {};

+    // biome-ignore lint/suspicious/useAwait: API
    override async start(): Promise<void> {
        this.eventBus.onDeviceMessage(this, this.poll);
        this.eventBus.onMQTTMessage(this, this.onMQTTMessage);
        this.eventBus.onGroupMembersChanged(this, this.onGroupMembersChanged);
    }

-    private parseMQTTMessage(data: eventdata.MQTTMessage): ParsedMQTTMessage {
-        let type: 'bind' | 'unbind' = null;
-        let sourceKey = null;
-        let targetKey = null;
-        let clusters = null;
-        let skipDisableReporting = false;
+    private parseMQTTMessage(
+        data: eventdata.MQTTMessage,
+    ): [raw: KeyValue | undefined, parsed: ParsedMQTTMessage | undefined, error: string | undefined] {
+        if (data.topic.match(TOPIC_REGEX)) {
+            const type = data.topic.endsWith("unbind") ? "unbind" : "bind";
+            let skipDisableReporting = false;
+            const message = JSON.parse(data.message) as Zigbee2MQTTAPI["bridge/request/device/bind"];

-        if (legacyApi && data.topic.match(legacyTopicRegex)) {
-            const topic = data.topic.replace(`${settings.get().mqtt.base_topic}/bridge/`, '');
-            type = topic.split('/')[0] as 'bind' | 'unbind';
-            sourceKey = topic.replace(`${type}/`, '');
-            targetKey = data.message;
-        } else if (data.topic.match(topicRegex)) {
-            type = data.topic.endsWith('unbind') ? 'unbind' : 'bind';
-            const message = JSON.parse(data.message);
-            sourceKey = message.from;
-            targetKey = message.to;
-            clusters = message.clusters;
-            skipDisableReporting = 'skip_disable_reporting' in message ? message.skip_disable_reporting : false;
+            if (typeof message !== "object" || message.from == null || message.to == null) {
+                return [message, {type, skipDisableReporting}, "Invalid payload"];
+            }
+
+            const sourceKey = message.from;
+            const sourceEndpointKey = message.from_endpoint ?? "default";
+            const targetKey = message.to;
+            const targetEndpointKey = message.to_endpoint;
+            const clusters = message.clusters;
+            skipDisableReporting = message.skip_disable_reporting != null ? message.skip_disable_reporting : false;
+            const resolvedSource = this.zigbee.resolveEntity(message.from) as Device;
+
+            if (!resolvedSource || !(resolvedSource instanceof Device)) {
+                return [message, {type, skipDisableReporting}, `Source device '${message.from}' does not exist`];
+            }
+
+            const resolvedTarget =
+                message.to === DEFAULT_BIND_GROUP.name || message.to === DEFAULT_BIND_GROUP.ID
+                    ? DEFAULT_BIND_GROUP
+                    : this.zigbee.resolveEntity(message.to);
+
+            if (!resolvedTarget) {
+                return [message, {type, skipDisableReporting}, `Target device or group '${message.to}' does not exist`];
+            }
+
+            const resolvedSourceEndpoint = resolvedSource.endpoint(sourceEndpointKey);
+
+            if (!resolvedSourceEndpoint) {
+                return [
+                    message,
+                    {type, skipDisableReporting},
+                    `Source device '${resolvedSource.name}' does not have endpoint '${sourceEndpointKey}'`,
+                ];
+            }
+
+            // resolves to 'default' endpoint if targetEndpointKey is invalid (used by frontend for 'Coordinator')
+            const resolvedBindTarget =
+                resolvedTarget instanceof Device
+                    ? resolvedTarget.endpoint(targetEndpointKey)
+                    : resolvedTarget instanceof Group
+                      ? resolvedTarget.zh
+                      : Number(resolvedTarget.ID);
+
+            if (resolvedTarget instanceof Device && !resolvedBindTarget) {
+                return [
+                    message,
+                    {type, skipDisableReporting},
+                    `Target device '${resolvedTarget.name}' does not have endpoint '${targetEndpointKey}'`,
+                ];
+            }
+
+            return [
+                message,
+                {
+                    type,
+                    sourceKey,
+                    sourceEndpointKey,
+                    targetKey,
+                    targetEndpointKey,
+                    clusters,
+                    skipDisableReporting,
+                    resolvedSource,
+                    resolvedTarget,
+                    resolvedSourceEndpoint,
+                    resolvedBindTarget,
+                },
+                undefined,
+            ];
        }

-        return {type, sourceKey, targetKey, clusters, skipDisableReporting};
+        return [undefined, undefined, undefined];
    }

    @bind private async onMQTTMessage(data: eventdata.MQTTMessage): Promise<void> {
-        const {type, sourceKey, targetKey, clusters, skipDisableReporting} = this.parseMQTTMessage(data);
-        if (!type) return null;
-        const message = utils.parseJSON(data.message, data.message);
+        const [raw, parsed, error] = this.parseMQTTMessage(data);

-        let error = null;
-        const parsedSource = this.zigbee.resolveEntityAndEndpoint(sourceKey);
-        const parsedTarget = this.zigbee.resolveEntityAndEndpoint(targetKey);
-        const source = parsedSource.entity;
-        const target = targetKey === 'default_bind_group' ? defaultBindGroup : parsedTarget.entity;
-        const responseData: KeyValue = {from: sourceKey, to: targetKey};
+        if (!raw || !parsed) {
+            return;
+        }

-        if (!source || !(source instanceof Device)) {
-            error = `Source device '${sourceKey}' does not exist`;
-        } else if (parsedSource.endpointID && !parsedSource.endpoint) {
-            error = `Source device '${parsedSource.ID}' does not have endpoint '${parsedSource.endpointID}'`;
-        } else if (!target) {
-            error = `Target device or group '${targetKey}' does not exist`;
-        } else if (target instanceof Device && parsedTarget.endpointID && !parsedTarget.endpoint) {
-            error = `Target device '${parsedTarget.ID}' does not have endpoint '${parsedTarget.endpointID}'`;
-        } else {
-            const successfulClusters: string[] = [];
-            const failedClusters = [];
-            const attemptedClusters = [];
+        if (error) {
+            await this.publishResponse(parsed.type, raw, {}, error);
+            return;
+        }

-            const bindSource: zh.Endpoint = parsedSource.endpoint;
-            let bindTarget: number | zh.Group | zh.Endpoint = null;
-            if (target instanceof Device) bindTarget = parsedTarget.endpoint;
-            else if (target instanceof Group) bindTarget = target.zh;
-            else bindTarget = Number(target.ID);
+        const {
+            type,
+            sourceKey,
+            sourceEndpointKey,
+            targetKey,
+            targetEndpointKey,
+            clusters,
+            skipDisableReporting,
+            resolvedSource,
+            resolvedTarget,
+            resolvedSourceEndpoint,
+            resolvedBindTarget,
+        } = parsed;

-            // Find which clusters are supported by both the source and target.
-            // Groups are assumed to support all clusters.
-            const clusterCandidates = clusters ?? allClusterCandidates;
-            for (const cluster of clusterCandidates) {
-                let matchingClusters = false;
+        assert(resolvedSource, "`resolvedSource` is missing");
+        assert(resolvedTarget, "`resolvedTarget` is missing");
+        assert(resolvedSourceEndpoint, "`resolvedSourceEndpoint` is missing");
+        assert(resolvedBindTarget !== undefined, "`resolvedBindTarget` is missing");

-                const anyClusterValid = utils.isZHGroup(bindTarget) || typeof bindTarget === 'number' ||
-                    (target as Device).zh.type === 'Coordinator';
+        const successfulClusters: string[] = [];
+        const failedClusters = [];
+        const attemptedClusters = [];
+        // Find which clusters are supported by both the source and target.
+        // Groups are assumed to support all clusters.
+        const clusterCandidates = clusters ?? ALL_CLUSTER_CANDIDATES;

-                if (!anyClusterValid && utils.isEndpoint(bindTarget)) {
-                    matchingClusters = ((bindTarget.supportsInputCluster(cluster) &&
-                            bindSource.supportsOutputCluster(cluster)) ||
-                            (bindSource.supportsInputCluster(cluster) &&
-                            bindTarget.supportsOutputCluster(cluster)) );
+        for (const cluster of clusterCandidates) {
+            let matchingClusters = false;
+
+            const anyClusterValid =
+                utils.isZHGroup(resolvedBindTarget) ||
+                typeof resolvedBindTarget === "number" ||
+                (resolvedTarget instanceof Device && resolvedTarget.zh.type === "Coordinator");
+
+            if (!anyClusterValid && utils.isZHEndpoint(resolvedBindTarget)) {
+                matchingClusters =
+                    (resolvedBindTarget.supportsInputCluster(cluster) && resolvedSourceEndpoint.supportsOutputCluster(cluster)) ||
+                    (resolvedSourceEndpoint.supportsInputCluster(cluster) && resolvedBindTarget.supportsOutputCluster(cluster));
+            }
+
+            const sourceValid = resolvedSourceEndpoint.supportsInputCluster(cluster) || resolvedSourceEndpoint.supportsOutputCluster(cluster);
+
+            if (sourceValid && (anyClusterValid || matchingClusters)) {
+                logger.debug(`${type}ing cluster '${cluster}' from '${resolvedSource.name}' to '${resolvedTarget.name}'`);
+                attemptedClusters.push(cluster);
+
+                try {
+                    if (type === "bind") {
+                        await resolvedSourceEndpoint.bind(cluster, resolvedBindTarget);
+                    } else {
+                        await resolvedSourceEndpoint.unbind(cluster, resolvedBindTarget);
+                    }
+
+                    successfulClusters.push(cluster);
+                    logger.info(
+                        `Successfully ${type === "bind" ? "bound" : "unbound"} cluster '${cluster}' from '${resolvedSource.name}' to '${resolvedTarget.name}'`,
+                    );
+                } catch (error) {
+                    failedClusters.push(cluster);
+                    logger.error(`Failed to ${type} cluster '${cluster}' from '${resolvedSource.name}' to '${resolvedTarget.name}' (${error})`);
                }
+            }
+        }

-                const sourceValid = bindSource.supportsInputCluster(cluster) ||
-                bindSource.supportsOutputCluster(cluster);
+        if (attemptedClusters.length === 0) {
+            logger.error(`Nothing to ${type} from '${resolvedSource.name}' to '${resolvedTarget.name}'`);
+            await this.publishResponse(parsed.type, raw, {}, `Nothing to ${type}`);
+            return;
+        }

-                if ( sourceValid && (anyClusterValid || matchingClusters)) {
-                    logger.debug(`${type}ing cluster '${cluster}' from '${source.name}' to '${target.name}'`);
-                    attemptedClusters.push(cluster);
+        if (failedClusters.length === attemptedClusters.length) {
+            await this.publishResponse(parsed.type, raw, {}, `Failed to ${type}`);
+            return;
+        }

-                    try {
-                        if (type === 'bind') {
-                            await bindSource.bind(cluster, bindTarget);
-                        } else {
-                            await bindSource.unbind(cluster, bindTarget);
-                        }
+        const responseData: Zigbee2MQTTAPI["bridge/response/device/bind"] | Zigbee2MQTTAPI["bridge/response/device/unbind"] = {
+            // biome-ignore lint/style/noNonNullAssertion: valid with assert above on `resolvedSource`
+            from: sourceKey!,
+            // biome-ignore lint/style/noNonNullAssertion: valid with assert above on `resolvedSourceEndpoint`
+            from_endpoint: sourceEndpointKey!,
+            // biome-ignore lint/style/noNonNullAssertion: valid with assert above on `resolvedTarget`
+            to: targetKey!,
+            to_endpoint: targetEndpointKey,
+            clusters: successfulClusters,
+            failed: failedClusters,
+        };

-                        successfulClusters.push(cluster);
-                        logger.info(
-                            `Successfully ${type === 'bind' ? 'bound' : 'unbound'} cluster '${cluster}' from ` +
-                            `'${source.name}' to '${target.name}'`,
-                        );
+        if (successfulClusters.length !== 0) {
+            if (type === "bind") {
+                await this.setupReporting(
+                    resolvedSourceEndpoint.binds.filter((b) => successfulClusters.includes(b.cluster.name) && b.target === resolvedBindTarget),
+                );
+            } else if (typeof resolvedBindTarget !== "number" && !skipDisableReporting) {
+                await this.disableUnnecessaryReportings(resolvedBindTarget);
+            }
+        }

-                        /* istanbul ignore else */
-                        if (settings.get().advanced.legacy_api) {
-                            this.mqtt.publish(
-                                'bridge/log',
-                                stringify({type: `device_${type}`,
-                                    message: {from: source.name, to: target.name, cluster}}),
-                            );
-                        }
-                    } catch (error) {
-                        failedClusters.push(cluster);
-                        logger.error(
-                            `Failed to ${type} cluster '${cluster}' from '${source.name}' to ` +
-                            `'${target.name}' (${error})`,
-                        );
+        await this.publishResponse(parsed.type, raw, responseData);
+        this.eventBus.emitDevicesChanged();
+    }

-                        /* istanbul ignore else */
-                        if (settings.get().advanced.legacy_api) {
-                            this.mqtt.publish(
-                                'bridge/log',
-                                stringify({type: `device_${type}_failed`,
-                                    message: {from: source.name, to: target.name, cluster}}),
-                            );
+    private async publishResponse<T extends Zigbee2MQTTResponseEndpoints>(
+        type: ParsedMQTTMessage["type"],
+        request: KeyValue,
+        data: Zigbee2MQTTAPI[T],
+        error?: string,
+    ): Promise<void> {
+        const response = utils.getResponse(request, data, error);
+        await this.mqtt.publish(`bridge/response/device/${type}`, stringify(response));
+
+        if (error) {
+            logger.error(error);
+        }
+    }
+
+    @bind async onGroupMembersChanged(data: eventdata.GroupMembersChanged): Promise<void> {
+        if (data.action === "add") {
+            const bindsToGroup: zh.Bind[] = [];
+
+            for (const device of this.zigbee.devicesIterator(utils.deviceNotCoordinator)) {
+                for (const endpoint of device.zh.endpoints) {
+                    for (const bind of endpoint.binds) {
+                        if (bind.target === data.group.zh) {
+                            bindsToGroup.push(bind);
                        }
                    }
                }
            }

-            if (attemptedClusters.length === 0) {
-                logger.error(`Nothing to ${type} from '${source.name}' to '${target.name}'`);
-                error = `Nothing to ${type}`;
-
-                /* istanbul ignore else */
-                if (settings.get().advanced.legacy_api) {
-                    this.mqtt.publish(
-                        'bridge/log',
-                        stringify({type: `device_${type}_failed`, message: {from: source.name, to: target.name}}),
-                    );
-                }
-            } else if (failedClusters.length === attemptedClusters.length) {
-                error = `Failed to ${type}`;
-            }
-
-            responseData[`clusters`] = successfulClusters;
-            responseData[`failed`] = failedClusters;
-
-            if (successfulClusters.length !== 0) {
-                if (type === 'bind') {
-                    await this.setupReporting(bindSource.binds.filter((b) =>
-                        successfulClusters.includes(b.cluster.name) && b.target === bindTarget));
-                } else if ((typeof bindTarget !== 'number') && !skipDisableReporting) {
-                    await this.disableUnnecessaryReportings(bindTarget);
-                }
-            }
-        }
-
-        const triggeredViaLegacyApi = data.topic.match(legacyTopicRegex);
-        if (!triggeredViaLegacyApi) {
-            const response = utils.getResponse(message, responseData, error);
-            await this.mqtt.publish(`bridge/response/device/${type}`, stringify(response));
-        }
-
-        if (error) {
-            logger.error(error);
-        } else {
-            this.eventBus.emitDevicesChanged();
-        }
-    }
-
-    @bind async onGroupMembersChanged(data: eventdata.GroupMembersChanged): Promise<void> {
-        if (data.action === 'add') {
-            const bindsToGroup = this.zigbee.devices(false).map((c) => c.zh.endpoints)
-                .reduce((a, v) => a.concat(v)).map((e) => e.binds)
-                .reduce((a, v) => a.concat(v)).filter((b) => b.target === data.group.zh);
            await this.setupReporting(bindsToGroup);
-        } else { // action === remove/remove_all
+        } else {
+            // action === remove/remove_all
            if (!data.skipDisableReporting) {
                await this.disableUnnecessaryReportings(data.endpoint);
            }
@@ -365,36 +445,55 @@ export default class Bind extends Extension {
    }

    getSetupReportingEndpoints(bind: zh.Bind, coordinatorEp: zh.Endpoint): zh.Endpoint[] {
-        const endpoints = utils.isEndpoint(bind.target) ? [bind.target] : bind.target.members;
+        const endpoints = utils.isZHEndpoint(bind.target) ? [bind.target] : bind.target.members;
+
        return endpoints.filter((e) => {
-            const supportsInputCluster = e.supportsInputCluster(bind.cluster.name);
-            const hasConfiguredReporting = !!e.configuredReportings.find((c) => c.cluster.name === bind.cluster.name);
-            const hasBind = !!e.binds.find((b) => b.cluster.name === bind.cluster.name && b.target === coordinatorEp);
-            return supportsInputCluster && !(hasBind && hasConfiguredReporting);
+            if (!e.supportsInputCluster(bind.cluster.name)) {
+                return false;
+            }
+
+            const hasConfiguredReporting = e.configuredReportings.some((c) => c.cluster.name === bind.cluster.name);
+
+            if (!hasConfiguredReporting) {
+                return true;
+            }
+
+            const hasBind = e.binds.some((b) => b.cluster.name === bind.cluster.name && b.target === coordinatorEp);
+
+            return !hasBind;
        });
    }

    async setupReporting(binds: zh.Bind[]): Promise<void> {
        const coordinatorEndpoint = this.zigbee.firstCoordinatorEndpoint();
-        for (const bind of binds.filter((b) => b.cluster.name in reportClusters)) {
-            for (const endpoint of this.getSetupReportingEndpoints(bind, coordinatorEndpoint)) {
-                const entity = `${this.zigbee.resolveEntity(endpoint.getDevice()).name}/${endpoint.ID}`;
-                try {
-                    await endpoint.bind(bind.cluster.name, coordinatorEndpoint);
-                    const items = [];
-                    for (const c of reportClusters[bind.cluster.name]) {
-                        /* istanbul ignore else */
-                        if (!c.condition || await c.condition(endpoint)) {
-                            const i = {...c};
-                            delete i.condition;
-                            items.push(i);
-                        }
-                    }

-                    await endpoint.configureReporting(bind.cluster.name, items);
-                    logger.info(`Successfully setup reporting for '${entity}' cluster '${bind.cluster.name}'`);
-                } catch (error) {
-                    logger.warning(`Failed to setup reporting for '${entity}' cluster '${bind.cluster.name}'`);
+        for (const bind of binds) {
+            if (bind.cluster.name in REPORT_CLUSTERS) {
+                for (const endpoint of this.getSetupReportingEndpoints(bind, coordinatorEndpoint)) {
+                    // biome-ignore lint/style/noNonNullAssertion: TODO: biome migration: ???
+                    const resolvedDevice = this.zigbee.resolveEntity(endpoint.getDevice())!;
+                    const entity = `${resolvedDevice.name}/${endpoint.ID}`;
+
+                    try {
+                        await endpoint.bind(bind.cluster.name, coordinatorEndpoint);
+
+                        const items = [];
+
+                        // biome-ignore lint/style/noNonNullAssertion: valid from outer `if`
+                        for (const c of REPORT_CLUSTERS[bind.cluster.name as ClusterName]!) {
+                            if (!c.condition || (await c.condition(endpoint))) {
+                                const i = {...c};
+                                delete i.condition;
+
+                                items.push(i);
+                            }
+                        }
+
+                        await endpoint.configureReporting(bind.cluster.name, items);
+                        logger.info(`Successfully setup reporting for '${entity}' cluster '${bind.cluster.name}'`);
+                    } catch (error) {
+                        logger.warning(`Failed to setup reporting for '${entity}' cluster '${bind.cluster.name}' (${(error as Error).message})`);
+                    }
                }
            }
        }
@@ -404,39 +503,55 @@ export default class Bind extends Extension {

    async disableUnnecessaryReportings(target: zh.Group | zh.Endpoint): Promise<void> {
        const coordinator = this.zigbee.firstCoordinatorEndpoint();
-        const endpoints = utils.isEndpoint(target) ? [target] : target.members;
+        const endpoints = utils.isZHEndpoint(target) ? [target] : target.members;
+        const allBinds: zh.Bind[] = [];
+
+        for (const device of this.zigbee.devicesIterator(utils.deviceNotCoordinator)) {
+            for (const endpoint of device.zh.endpoints) {
+                for (const bind of endpoint.binds) {
+                    allBinds.push(bind);
+                }
+            }
+        }
+
        for (const endpoint of endpoints) {
            const device = this.zigbee.resolveEntity(endpoint.getDevice()) as Device;
            const entity = `${device.name}/${endpoint.ID}`;
-            const boundClusters = endpoint.binds.filter((b) => b.target === coordinator)
-                .map((b) => b.cluster.name);
-            const requiredClusters = this.zigbee.devices(false).map((c) => c.zh.endpoints)
-                .reduce((a, v) => a.concat(v))
-                .map((e) => e.binds).reduce((a, v) => a.concat(v)).filter((bind) => {
-                    if (utils.isEndpoint(bind.target)) {
-                        return bind.target === endpoint;
-                    } else {
-                        return bind.target.members.includes(endpoint);
-                    }
-                }).map((b) => b.cluster.name).filter((v, i, a) => a.indexOf(v) === i);
+            const requiredClusters: string[] = [];
+            const boundClusters: string[] = [];

-            for (const cluster of boundClusters.filter((c) => !requiredClusters.includes(c) && c in reportClusters)) {
+            for (const bind of allBinds) {
+                if (utils.isZHEndpoint(bind.target) ? bind.target === endpoint : bind.target.members.includes(endpoint)) {
+                    requiredClusters.push(bind.cluster.name);
+                }
+            }
+
+            for (const b of endpoint.binds) {
+                if (b.target === coordinator && !requiredClusters.includes(b.cluster.name) && b.cluster.name in REPORT_CLUSTERS) {
+                    boundClusters.push(b.cluster.name);
+                }
+            }
+
+            for (const cluster of boundClusters) {
                try {
                    await endpoint.unbind(cluster, coordinator);
+
                    const items = [];
-                    for (const item of reportClusters[cluster]) {
-                        /* istanbul ignore else */
-                        if (!item.condition || await item.condition(endpoint)) {
+
+                    // biome-ignore lint/style/noNonNullAssertion: valid from loop (pushed to array only if in)
+                    for (const item of REPORT_CLUSTERS[cluster as ClusterName]!) {
+                        if (!item.condition || (await item.condition(endpoint))) {
                            const i = {...item};
                            delete i.condition;
-                            items.push({...i, maximumReportInterval: 0xFFFF});
+
+                            items.push({...i, maximumReportInterval: 0xffff});
                        }
                    }

                    await endpoint.configureReporting(cluster, items);
                    logger.info(`Successfully disabled reporting for '${entity}' cluster '${cluster}'`);
                } catch (error) {
-                    logger.warning(`Failed to disable reporting for '${entity}' cluster '${cluster}'`);
+                    logger.warning(`Failed to disable reporting for '${entity}' cluster '${cluster}' (${(error as Error).message})`);
                }
            }

@@ -453,48 +568,61 @@ export default class Bind extends Extension {
         * When dimming the bulb via the dimmer switch the state is therefore not reported.
         * When we receive a message from a Hue dimmer we read the brightness from the bulb (if bound).
         */
-        const polls = pollOnMessage.filter((p) =>
-            p.cluster[data.cluster]?.find((c) => c.type === data.type && utils.equalsPartial(data.data, c.data)));
+        const polls = POLL_ON_MESSAGE.filter((p) =>
+            p.cluster[data.cluster as ClusterName]?.some((c) => c.type === data.type && utils.equalsPartial(data.data, c.data)),
+        );

        if (polls.length) {
-            const toPoll: Set<zh.Endpoint> = new Set();
+            const toPoll = new Set<zh.Endpoint>();
+
            // Add bound devices
            for (const endpoint of data.device.zh.endpoints) {
                for (const bind of endpoint.binds) {
-                    if (utils.isEndpoint(bind.target) && bind.target.getDevice().type !== 'Coordinator') {
+                    if (utils.isZHEndpoint(bind.target) && bind.target.getDevice().type !== "Coordinator") {
                        toPoll.add(bind.target);
                    }
                }
            }

-            // If message is published to a group, add members of the group
-            const group = data.groupID && data.groupID !== 0 && this.zigbee.groupByID(data.groupID);
-            if (group) {
-                group.zh.members.forEach((m) => toPoll.add(m));
+            if (data.groupID && data.groupID !== 0) {
+                // If message is published to a group, add members of the group
+                const group = this.zigbee.groupByID(data.groupID);
+
+                if (group) {
+                    for (const member of group.zh.members) {
+                        toPoll.add(member);
+                    }
+                }
            }

            for (const endpoint of toPoll) {
+                const device = endpoint.getDevice();
                for (const poll of polls) {
-                    if ((!poll.manufacturerIDs.includes(endpoint.getDevice().manufacturerID) &&
-                        !poll.manufacturerNames.includes(endpoint.getDevice().manufacturerName)) ||
-                        !endpoint.supportsInputCluster(poll.read.cluster)) {
+                    if (
+                        // biome-ignore lint/style/noNonNullAssertion: manufacturerID/manufacturerName can be undefined and won't match `includes`, but TS enforces same-type
+                        (!poll.manufacturerIDs.includes(device.manufacturerID!) && !poll.manufacturerNames.includes(device.manufacturerName!)) ||
+                        !endpoint.supportsInputCluster(poll.read.cluster)
+                    ) {
                        continue;
                    }

                    let readAttrs = poll.read.attributes;
+
                    if (poll.read.attributesForEndpoint) {
                        const attrsForEndpoint = await poll.read.attributesForEndpoint(endpoint);
                        readAttrs = [...poll.read.attributes, ...attrsForEndpoint];
                    }

-                    const key = `${endpoint.getDevice().ieeeAddr}_${endpoint.ID}_${pollOnMessage.indexOf(poll)}`;
+                    const key = `${device.ieeeAddr}_${endpoint.ID}_${POLL_ON_MESSAGE.indexOf(poll)}`;
+
                    if (!this.pollDebouncers[key]) {
                        this.pollDebouncers[key] = debounce(async () => {
                            try {
                                await endpoint.read(poll.read.cluster, readAttrs);
                            } catch (error) {
-                                logger.error(`Failed to poll ${readAttrs} from ` +
-                                    `${this.zigbee.resolveEntity(endpoint.getDevice()).name}`);
+                                // biome-ignore lint/style/noNonNullAssertion: TODO: biome migration: ???
+                                const resolvedDevice = this.zigbee.resolveEntity(device)!;
+                                logger.error(`Failed to poll ${readAttrs} from ${resolvedDevice.name} (${(error as Error).message})`);
                            }
                        }, 1000);
                    }
@@ -1,11 +1,12 @@
-import * as settings from '../util/settings';
-import utils from '../util/utils';
-import logger from '../util/logger';
-import stringify from 'json-stable-stringify-without-jsonify';
-import * as zhc from 'zigbee-herdsman-converters';
-import Extension from './extension';
-import bind from 'bind-decorator';
-import Device from '../model/device';
+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";
+import Extension from "./extension";

 /**
 * This extension calls the zigbee-herdsman-converters definition configure() method
@@ -14,94 +15,95 @@ export default class Configure extends Extension {
    private configuring = new Set();
    private attempts: {[s: string]: number} = {};
    private topic = `${settings.get().mqtt.base_topic}/bridge/request/device/configure`;
-    private legacyTopic = `${settings.get().mqtt.base_topic}/bridge/configure`;

    @bind private async onReconfigure(data: eventdata.Reconfigure): Promise<void> {
        // Disabling reporting unbinds some cluster which could be bound by configure, re-setup.
-        if (data.device.zh.meta?.hasOwnProperty('configured')) {
+        if (data.device.zh.meta?.configured !== undefined) {
            delete data.device.zh.meta.configured;
            data.device.zh.save();
        }

-        await this.configure(data.device, 'reporting_disabled');
+        await this.configure(data.device, "reporting_disabled");
    }

    @bind private async onMQTTMessage(data: eventdata.MQTTMessage): Promise<void> {
-        if (data.topic === this.legacyTopic) {
-            const device = this.zigbee.resolveEntity(data.message);
-            if (!device || !(device instanceof Device)) {
-                logger.error(`Device '${data.message}' does not exist`);
-                return;
-            }
+        if (data.topic === this.topic) {
+            const message = utils.parseJSON(data.message, data.message) as Zigbee2MQTTAPI["bridge/request/device/configure"];
+            const ID = typeof message === "object" ? message.id : message;
+            let error: string | undefined;

-            if (!device.definition || !device.definition.configure) {
-                logger.warning(`Skipping configure of '${device.name}', device does not require this.`);
-                return;
-            }
-
-            this.configure(device, 'mqtt_message', true);
-        } else if (data.topic === this.topic) {
-            const message = utils.parseJSON(data.message, data.message);
-            const ID = typeof message === 'object' && message.hasOwnProperty('id') ? message.id : message;
-            let error = null;
-
-            const device = this.zigbee.resolveEntity(ID);
-            if (!device || !(device instanceof Device)) {
-                error = `Device '${ID}' does not exist`;
-            } else if (!device.definition || !device.definition.configure) {
-                error = `Device '${device.name}' cannot be configured`;
+            if (ID === undefined) {
+                error = "Invalid payload";
            } else {
-                try {
-                    await this.configure(device, 'mqtt_message', true, true);
-                } catch (e) {
-                    error = `Failed to configure (${e.message})`;
+                const device = this.zigbee.resolveEntity(ID);
+
+                if (!device || !(device instanceof Device)) {
+                    error = `Device '${ID}' does not exist`;
+                } else if (!device.definition || !device.definition.configure) {
+                    error = `Device '${device.name}' cannot be configured`;
+                } else {
+                    try {
+                        await this.configure(device, "mqtt_message", true, true);
+                    } catch (e) {
+                        error = `Failed to configure (${(e as Error).message})`;
+                    }
                }
            }

-            const response = utils.getResponse(message, {id: ID}, error);
-            await this.mqtt.publish(`bridge/response/device/configure`, stringify(response));
+            const response = utils.getResponse<"bridge/response/device/configure">(message, {id: ID}, error);
+
+            await this.mqtt.publish("bridge/response/device/configure", stringify(response));
        }
    }

-    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
-            for (const device of this.zigbee.devices(false).filter((d) => d.zh.type === 'Router')) {
-                // Sleep 10 seconds between configuring on startup to not DDoS the coordinator
-                // when many devices have to be configured.
+            for (const device of this.zigbee.devicesIterator((d) => d.type === "Router")) {
+                // Sleep 10 seconds between configuring on startup to not DDoS the coordinator when many devices have to be configured.
                await utils.sleep(10);
-                await this.configure(device, 'started');
+                await this.configure(device, "started");
            }
        });

-        this.eventBus.onDeviceJoined(this, (data) => {
-            if (data.device.zh.meta.hasOwnProperty('configured')) {
+        this.eventBus.onDeviceJoined(this, async (data) => {
+            if (data.device.zh.meta.configured !== undefined) {
                delete data.device.zh.meta.configured;
                data.device.zh.save();
            }

-            this.configure(data.device, 'zigbee_event');
+            await this.configure(data.device, "zigbee_event");
        });
-        this.eventBus.onDeviceInterview(this, (data) => this.configure(data.device, 'zigbee_event'));
-        this.eventBus.onLastSeenChanged(this, (data) => this.configure(data.device, 'zigbee_event'));
+        this.eventBus.onDeviceInterview(this, (data) => this.configure(data.device, "zigbee_event"));
+        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(device: Device, event: 'started' | 'zigbee_event' | 'reporting_disabled' | 'mqtt_message',
-        force=false, throwError=false): Promise<void> {
+    private async configure(
+        device: Device,
+        event: "started" | "zigbee_event" | "reporting_disabled" | "mqtt_message",
+        force = false,
+        throwError = false,
+    ): Promise<void> {
+        if (!device.definition?.configure) {
+            return;
+        }
+
        if (!force) {
-            if (device.options.disabled || !device.definition?.configure || !device.zh.interviewCompleted) {
+            if (device.options.disabled || !device.interviewed) {
                return;
            }

-            if (device.zh.meta?.hasOwnProperty('configured')) {
+            if (device.zh.meta?.configured !== undefined) {
                return;
            }

            // Only configure end devices when it is active, otherwise it will likely fails as they are sleeping.
-            if (device.zh.type === 'EndDevice' && event !== 'zigbee_event') {
+            if (device.zh.type === "EndDevice" && event !== "zigbee_event") {
                return;
            }
        }
@@ -112,7 +114,7 @@ export default class Configure extends Extension {

        this.configuring.add(device.ieeeAddr);

-        if (!this.attempts.hasOwnProperty(device.ieeeAddr)) {
+        if (this.attempts[device.ieeeAddr] === undefined) {
            this.attempts[device.ieeeAddr] = 0;
        }

@@ -126,7 +128,7 @@ export default class Configure extends Extension {
        } catch (error) {
            this.attempts[device.ieeeAddr]++;
            const attempt = this.attempts[device.ieeeAddr];
-            const msg = `Failed to configure '${device.name}', attempt ${attempt} (${error.stack})`;
+            const msg = `Failed to configure '${device.name}', attempt ${attempt} (${(error as Error).stack})`;
            logger.error(msg);

            if (throwError) {
@@ -1,18 +1,18 @@
 abstract class Extension {
    protected zigbee: Zigbee;
-    protected mqtt: MQTT;
+    protected mqtt: Mqtt;
    protected state: State;
    protected publishEntityState: PublishEntityState;
    protected eventBus: EventBus;
    protected enableDisableExtension: (enable: boolean, name: string) => Promise<void>;
-    protected restartCallback: () => void;
+    protected restartCallback: () => Promise<void>;
    protected addExtension: (extension: Extension) => Promise<void>;

    /**
     * Besides initializing variables, the constructor should do nothing!
     *
     * @param {Zigbee} zigbee Zigbee controller
-     * @param {MQTT} mqtt MQTT controller
+     * @param {Mqtt} mqtt MQTT controller
     * @param {State} state State controller
     * @param {Function} publishEntityState Method to publish device state to MQTT.
     * @param {EventBus} eventBus The event bus
@@ -20,9 +20,16 @@ abstract class Extension {
     * @param {restartCallback} restartCallback Restart Zigbee2MQTT
     * @param {addExtension} addExtension Add an extension
     */
-    constructor(zigbee: Zigbee, mqtt: MQTT, state: State, publishEntityState: PublishEntityState,
-        eventBus: EventBus, enableDisableExtension: (enable: boolean, name: string) => Promise<void>,
-        restartCallback: () => void, addExtension: (extension: Extension) => Promise<void>) {
+    constructor(
+        zigbee: Zigbee,
+        mqtt: Mqtt,
+        state: State,
+        publishEntityState: PublishEntityState,
+        eventBus: EventBus,
+        enableDisableExtension: (enable: boolean, name: string) => Promise<void>,
+        restartCallback: () => Promise<void>,
+        addExtension: (extension: Extension) => Promise<void>,
+    ) {
        this.zigbee = zigbee;
        this.mqtt = mqtt;
        this.state = state;
@@ -36,18 +43,18 @@ abstract class Extension {
    /**
     * Is called once the extension has to start
     */
-    /* istanbul ignore next */
    async start(): Promise<void> {}

    /**
     * Is called once the extension has to stop
     */
+
+    // biome-ignore lint/suspicious/useAwait: API
    async stop(): Promise<void> {
        this.eventBus.removeListeners(this);
    }

-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    public adjustMessageBeforePublish(entity: Group | Device, message: KeyValue): void {}
+    public adjustMessageBeforePublish(_entity: Group | Device, _message: KeyValue): void {}
 }

 export default Extension;
@@ -1,32 +1,67 @@
-import * as zhc from 'zigbee-herdsman-converters';
-import * as settings from '../util/settings';
-import {loadExternalConverter} from '../util/utils';
-import Extension from './extension';
-import logger from '../util/logger';
+import type {ExternalDefinitionWithExtend} from "zigbee-herdsman-converters";

-export default class ExternalConverters extends Extension {
-    constructor(zigbee: Zigbee, mqtt: MQTT, state: State, publishEntityState: PublishEntityState,
-        eventBus: EventBus, enableDisableExtension: (enable: boolean, name: string) => Promise<void>,
-        restartCallback: () => void, addExtension: (extension: Extension) => Promise<void>) {
-        super(zigbee, mqtt, state, publishEntityState, eventBus, enableDisableExtension, restartCallback, addExtension);
+import {addExternalDefinition, removeExternalDefinitions} from "zigbee-herdsman-converters";

-        for (const file of settings.get().external_converters) {
-            try {
-                for (const definition of loadExternalConverter(file)) {
-                    const toAdd = {...definition};
-                    delete toAdd['homeassistant'];
-                    zhc.addDefinition(toAdd);
-                }
-            } catch (error) {
-                logger.error(`Failed to load external converter file '${file}' (${error.message})`);
-                logger.error(
-                    `Probably there is a syntax error in the file or the external converter is not ` +
-                    `compatible with the current Zigbee2MQTT version`);
-                logger.error(
-                    `Note that external converters are not meant for long term usage, it's meant for local ` +
-                    `testing after which a pull request should be created to add out-of-the-box support for the device`,
-                );
+import logger from "../util/logger";
+import ExternalJSExtension from "./externalJS";
+
+type TModule = ExternalDefinitionWithExtend | ExternalDefinitionWithExtend[];
+
+export default class ExternalConverters extends ExternalJSExtension<TModule> {
+    constructor(
+        zigbee: Zigbee,
+        mqtt: Mqtt,
+        state: State,
+        publishEntityState: PublishEntityState,
+        eventBus: EventBus,
+        enableDisableExtension: (enable: boolean, name: string) => Promise<void>,
+        restartCallback: () => Promise<void>,
+        addExtension: (extension: Extension) => Promise<void>,
+    ) {
+        super(
+            zigbee,
+            mqtt,
+            state,
+            publishEntityState,
+            eventBus,
+            enableDisableExtension,
+            restartCallback,
+            addExtension,
+            "converter",
+            "external_converters",
+        );
+    }
+
+    protected async removeJS(name: string, _mod: TModule): Promise<void> {
+        removeExternalDefinitions(name);
+
+        await this.zigbee.resolveDevicesDefinitions(true);
+    }
+
+    protected async loadJS(name: string, mod: TModule, newName?: string): Promise<void> {
+        try {
+            removeExternalDefinitions(name);
+
+            const definitions = Array.isArray(mod) ? mod : [mod];
+
+            for (const definition of definitions) {
+                definition.externalConverterName = newName ?? name;
+
+                addExternalDefinition(definition);
+                logger.info(`Loaded external converter '${newName ?? name}'.`);
            }
+
+            await this.zigbee.resolveDevicesDefinitions(true);
+        } catch (error) {
+            logger.error(
+                /* v8 ignore next */
+                `Failed to load external converter '${newName ?? name}'. Check the code for syntax error and make sure it is up to date with the current Zigbee2MQTT version.`,
+            );
+            logger.warning(
+                "External converters are not meant for long term usage, but for local testing after which a pull request should be created to add out-of-the-box support for the device",
+            );
+
+            throw error;
        }
    }
 }
@@ -1,109 +0,0 @@
-import * as settings from '../util/settings';
-import utils from '../util/utils';
-import fs from 'fs';
-import data from './../util/data';
-import path from 'path';
-import logger from './../util/logger';
-import stringify from 'json-stable-stringify-without-jsonify';
-import bind from 'bind-decorator';
-import Extension from './extension';
-
-const requestRegex = new RegExp(`${settings.get().mqtt.base_topic}/bridge/request/extension/(save|remove)`);
-
-export default class ExternalExtension extends Extension {
-    private requestLookup: {[s: string]: (message: KeyValue) => Promise<MQTTResponse>};
-
-    override async start(): Promise<void> {
-        this.eventBus.onMQTTMessage(this, this.onMQTTMessage);
-        this.requestLookup = {'save': this.saveExtension, 'remove': this.removeExtension};
-        this.loadUserDefinedExtensions();
-        await this.publishExtensions();
-    }
-
-    private getExtensionsBasePath(): string {
-        return data.joinPath('extension');
-    }
-
-    private getListOfUserDefinedExtensions(): {name: string, code: string}[] {
-        const basePath = this.getExtensionsBasePath();
-        if (fs.existsSync(basePath)) {
-            return fs.readdirSync(basePath).filter((f) => f.endsWith('.js')).map((fileName) => {
-                const extensionFilePath = path.join(basePath, fileName);
-                return {'name': fileName, 'code': fs.readFileSync(extensionFilePath, 'utf-8')};
-            });
-        } else {
-            return [];
-        }
-    }
-
-    @bind private async removeExtension(message: KeyValue): Promise<MQTTResponse> {
-        const {name} = message;
-        const extensions = this.getListOfUserDefinedExtensions();
-        const extensionToBeRemoved = extensions.find((e) => e.name === name);
-
-        if (extensionToBeRemoved) {
-            await this.enableDisableExtension(false, extensionToBeRemoved.name);
-            const basePath = this.getExtensionsBasePath();
-            const extensionFilePath = path.join(basePath, path.basename(name));
-            fs.unlinkSync(extensionFilePath);
-            this.publishExtensions();
-            logger.info(`Extension ${name} removed`);
-            return utils.getResponse(message, {}, null);
-        } else {
-            return utils.getResponse(message, {}, `Extension ${name} doesn't exists`);
-        }
-    }
-
-    @bind private async saveExtension(message: KeyValue): Promise<MQTTResponse> {
-        const {name, code} = message;
-        const ModuleConstructor = utils.loadModuleFromText(code, name) as typeof Extension;
-        await this.loadExtension(ModuleConstructor);
-        const basePath = this.getExtensionsBasePath();
-        /* istanbul ignore else */
-        if (!fs.existsSync(basePath)) {
-            fs.mkdirSync(basePath);
-        }
-        const extensionFilePath = path.join(basePath, path.basename(name));
-        fs.writeFileSync(extensionFilePath, code);
-        this.publishExtensions();
-        logger.info(`Extension ${name} loaded`);
-        return utils.getResponse(message, {}, null);
-    }
-
-    @bind async onMQTTMessage(data: eventdata.MQTTMessage): Promise<void> {
-        const match = data.topic.match(requestRegex);
-        if (match && this.requestLookup[match[1].toLowerCase()]) {
-            const message = utils.parseJSON(data.message, data.message) as KeyValue;
-            try {
-                const response = await this.requestLookup[match[1].toLowerCase()](message);
-                await this.mqtt.publish(`bridge/response/extension/${match[1]}`, stringify(response));
-            } catch (error) {
-                logger.error(`Request '${data.topic}' failed with error: '${error.message}'`);
-                const response = utils.getResponse(message, {}, error.message);
-                await this.mqtt.publish(`bridge/response/extension/${match[1]}`, stringify(response));
-            }
-        }
-    }
-
-    @bind private async loadExtension(ConstructorClass: typeof Extension): Promise<void> {
-        await this.enableDisableExtension(false, ConstructorClass.name);
-        // @ts-ignore
-        await this.addExtension(new ConstructorClass(this.zigbee, this.mqtt, this.state, this.publishEntityState,
-            this.eventBus, settings, logger));
-    }
-
-    private loadUserDefinedExtensions(): void {
-        const extensions = this.getListOfUserDefinedExtensions();
-        extensions
-            .map(({code, name}) => utils.loadModuleFromText(code, name))
-            .map(this.loadExtension);
-    }
-
-    private async publishExtensions(): Promise<void> {
-        const extensions = this.getListOfUserDefinedExtensions();
-        await this.mqtt.publish('bridge/extensions', stringify(extensions), {
-            retain: true,
-            qos: 0,
-        }, settings.get().mqtt.base_topic, true);
-    }
-}
@@ -0,0 +1,69 @@
+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;
+
+export default class ExternalExtensions extends ExternalJSExtension<TModule> {
+    constructor(
+        zigbee: Zigbee,
+        mqtt: Mqtt,
+        state: State,
+        publishEntityState: PublishEntityState,
+        eventBus: EventBus,
+        enableDisableExtension: (enable: boolean, name: string) => Promise<void>,
+        restartCallback: () => Promise<void>,
+        addExtension: (extension: Extension) => Promise<void>,
+    ) {
+        super(
+            zigbee,
+            mqtt,
+            state,
+            publishEntityState,
+            eventBus,
+            enableDisableExtension,
+            restartCallback,
+            addExtension,
+            "extension",
+            "external_extensions",
+        );
+    }
+
+    protected async removeJS(_name: string, mod: TModule): Promise<void> {
+        await this.enableDisableExtension(false, mod.name);
+    }
+
+    protected async loadJS(name: string, mod: TModule, newName?: string): Promise<void> {
+        try {
+            // stop if already started
+            await this.enableDisableExtension(false, mod.name);
+            await this.addExtension(
+                new mod(
+                    this.zigbee,
+                    this.mqtt,
+                    this.state,
+                    this.publishEntityState,
+                    this.eventBus,
+                    this.enableDisableExtension,
+                    this.restartCallback,
+                    this.addExtension,
+                    // @ts-expect-error additional params that don't fit the internal `Extension` type
+                    settings,
+                    logger,
+                ),
+            );
+
+            /* v8 ignore start */
+            logger.info(`Loaded external extension '${newName ?? name}'.`);
+        } catch (error) {
+            logger.error(
+                /* v8 ignore next */
+                `Failed to load external extension '${newName ?? name}'. Check the code for syntax error and make sure it is up to date with the current Zigbee2MQTT version.`,
+            );
+
+            throw error;
+        }
+        /* v8 ignore stop */
+    }
+}
@@ -0,0 +1,226 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import bind from "bind-decorator";
+import stringify from "json-stable-stringify-without-jsonify";
+import type {Zigbee2MQTTAPI, Zigbee2MQTTResponse} from "../types/api";
+
+import data from "../util/data";
+import logger from "../util/logger";
+import * as settings from "../util/settings";
+import utils from "../util/utils";
+import Extension from "./extension";
+
+const SUPPORTED_OPERATIONS = ["save", "remove"];
+const TMP_PREFIX = ".tmp-ed42d4f2-";
+
+export default abstract class ExternalJSExtension<M> extends Extension {
+    protected folderName: string;
+    protected mqttTopic: string;
+    protected requestRegex: RegExp;
+    protected basePath: string;
+    protected nodeModulesSymlinked = false;
+
+    constructor(
+        zigbee: Zigbee,
+        mqtt: Mqtt,
+        state: State,
+        publishEntityState: PublishEntityState,
+        eventBus: EventBus,
+        enableDisableExtension: (enable: boolean, name: string) => Promise<void>,
+        restartCallback: () => Promise<void>,
+        addExtension: (extension: Extension) => Promise<void>,
+        mqttTopic: string,
+        folderName: string,
+    ) {
+        super(zigbee, mqtt, state, publishEntityState, eventBus, enableDisableExtension, restartCallback, addExtension);
+
+        this.folderName = folderName;
+        this.mqttTopic = mqttTopic;
+        this.requestRegex = new RegExp(`${settings.get().mqtt.base_topic}/bridge/request/${mqttTopic}/(save|remove)`);
+        this.basePath = data.joinPath(folderName);
+    }
+
+    /**
+     * In case the external JS is not in the Z2M install dir (e.g. when `ZIGBEE2MQTT_DATA` is used), the external
+     * JS cannot import from `node_modules`.
+     * To workaround this create a symlink to `node_modules` in the external JS dir.
+     * https://nodejs.org/api/esm.html#no-node_path
+     */
+    private symlinkNodeModulesIfNecessary() {
+        if (!this.nodeModulesSymlinked) {
+            this.nodeModulesSymlinked = true;
+            const nodeModulesPath = path.join(__dirname, "..", "..", "node_modules");
+            const z2mDirNormalized = `${path.resolve(path.join(nodeModulesPath, ".."))}${path.sep}`;
+            const basePathNormalized = `${path.resolve(this.basePath)}${path.sep}`;
+            const basePathInZ2mDir = basePathNormalized.startsWith(z2mDirNormalized);
+            if (!basePathInZ2mDir) {
+                logger.debug(`External JS folder '${this.folderName}' is outside the Z2M install dir, creating a symlink to 'node_modules'`);
+                const nodeModulesSymlink = path.join(this.basePath, "node_modules");
+                if (fs.existsSync(nodeModulesSymlink)) {
+                    fs.unlinkSync(nodeModulesSymlink);
+                }
+                // Type `junction` is required on Windows.
+                // https://github.com/nodejs/node/issues/18518#issuecomment-513866491
+                /* v8 ignore next */
+                fs.symlinkSync(nodeModulesPath, nodeModulesSymlink, os.platform() === "win32" ? "junction" : "dir");
+            }
+        }
+    }
+
+    override async start(): Promise<void> {
+        await super.start();
+        this.eventBus.onMQTTMessage(this, this.onMQTTMessage);
+        await this.loadFiles();
+        await this.publishExternalJS();
+    }
+
+    private getFilePath(name: string, mkBasePath = false): string {
+        if (mkBasePath && !fs.existsSync(this.basePath)) {
+            fs.mkdirSync(this.basePath, {recursive: true});
+        }
+
+        return path.join(this.basePath, name);
+    }
+
+    protected getFileCode(name: string): string {
+        return fs.readFileSync(this.getFilePath(name), "utf8");
+    }
+
+    protected *getFiles(): Generator<{name: string; code: string}> {
+        if (fs.existsSync(this.basePath)) {
+            for (const fileName of fs.readdirSync(this.basePath)) {
+                if (!fileName.startsWith(TMP_PREFIX) && (fileName.endsWith(".js") || fileName.endsWith(".cjs") || fileName.endsWith(".mjs"))) {
+                    yield {name: fileName, code: this.getFileCode(fileName)};
+                }
+            }
+        }
+    }
+
+    @bind async onMQTTMessage(data: eventdata.MQTTMessage): Promise<void> {
+        const match = data.topic.match(this.requestRegex);
+
+        if (match && SUPPORTED_OPERATIONS.includes(match[1].toLowerCase())) {
+            const message = utils.parseJSON(data.message, data.message);
+
+            try {
+                let response: Awaited<ReturnType<typeof this.save | typeof this.remove>>;
+
+                if (match[1].toLowerCase() === "save") {
+                    response = await this.save(
+                        message as Zigbee2MQTTAPI["bridge/request/converter/save"] | Zigbee2MQTTAPI["bridge/request/extension/save"],
+                    );
+                } else {
+                    response = await this.remove(
+                        message as Zigbee2MQTTAPI["bridge/request/converter/remove"] | Zigbee2MQTTAPI["bridge/request/extension/remove"],
+                    );
+                }
+
+                await this.mqtt.publish(`bridge/response/${this.mqttTopic}/${match[1]}`, stringify(response));
+            } catch (error) {
+                logger.error(`Request '${data.topic}' failed with error: '${(error as Error).message}'`);
+
+                const response = utils.getResponse(message, {}, `${(error as Error).message}`);
+
+                await this.mqtt.publish(`bridge/response/${this.mqttTopic}/${match[1]}`, stringify(response));
+            }
+        }
+    }
+
+    protected abstract removeJS(name: string, mod: M): Promise<void>;
+
+    protected abstract loadJS(name: string, mod: M, newName?: string): Promise<void>;
+
+    @bind private async remove(
+        message: Zigbee2MQTTAPI["bridge/request/converter/remove"] | Zigbee2MQTTAPI["bridge/request/extension/remove"],
+    ): Promise<Zigbee2MQTTResponse<"bridge/response/converter/remove" | "bridge/response/extension/remove">> {
+        if (!message.name) {
+            return utils.getResponse(message, {}, "Invalid payload");
+        }
+
+        const {name} = message;
+        const toBeRemoved = this.getFilePath(name);
+
+        if (fs.existsSync(toBeRemoved)) {
+            const mod = await this.importFile(toBeRemoved);
+
+            await this.removeJS(name, mod.default);
+            fs.rmSync(toBeRemoved, {force: true});
+            logger.info(`${name} (${toBeRemoved}) removed.`);
+            await this.publishExternalJS();
+
+            return utils.getResponse(message, {});
+        }
+
+        return utils.getResponse(message, {}, `${name} (${toBeRemoved}) doesn't exists`);
+    }
+
+    @bind private async save(
+        message: Zigbee2MQTTAPI["bridge/request/converter/save"] | Zigbee2MQTTAPI["bridge/request/extension/save"],
+    ): Promise<Zigbee2MQTTResponse<"bridge/response/converter/save" | "bridge/response/extension/save">> {
+        if (!message.name || !message.code) {
+            return utils.getResponse(message, {}, "Invalid payload");
+        }
+
+        const {name, code} = message;
+        const filePath = this.getFilePath(name, true);
+        try {
+            fs.writeFileSync(filePath, code, "utf8");
+            this.symlinkNodeModulesIfNecessary();
+
+            const mod = await this.importFile(filePath);
+
+            await this.loadJS(name, mod.default, name);
+            logger.info(`${name} loaded. Contents written to '${filePath}'.`);
+            await this.publishExternalJS();
+
+            return utils.getResponse(message, {});
+        } catch (error) {
+            return utils.getResponse(message, {}, `${name} contains invalid code: ${(error as Error).message}`);
+        }
+    }
+
+    private async loadFiles(): Promise<void> {
+        for (const extension of this.getFiles()) {
+            this.symlinkNodeModulesIfNecessary();
+            const filePath = this.getFilePath(extension.name);
+
+            try {
+                const mod = await this.importFile(filePath);
+                await this.loadJS(extension.name, mod.default);
+            } catch (error) {
+                // change ext so Z2M doesn't try to load it again and again
+                fs.renameSync(filePath, `${filePath}.invalid`);
+
+                logger.error(
+                    `Invalid external ${this.mqttTopic} '${extension.name}' was ignored and renamed to prevent interference with Zigbee2MQTT.`,
+                );
+                // biome-ignore lint/style/noNonNullAssertion: always Error
+                logger.debug((error as Error).stack!);
+            }
+        }
+    }
+
+    private async publishExternalJS(): Promise<void> {
+        await this.mqtt.publish(`bridge/${this.mqttTopic}s`, stringify(Array.from(this.getFiles())), {
+            clientOptions: {retain: true},
+            skipLog: true,
+        });
+    }
+
+    // biome-ignore lint/suspicious/noExplicitAny: dynamic module
+    private async importFile(file: string): Promise<any> {
+        const ext = path.extname(file);
+        // Create the file in a temp path to bypass node module cache when importing multiple times.
+        const tmpFile = path.join(this.basePath, `${TMP_PREFIX}${path.basename(file, ext)}-${crypto.randomUUID()}${ext}`);
+        fs.copyFileSync(file, tmpFile);
+        try {
+            // Do `replaceAll("\\", "/")` to prevent issues on Windows
+            /* v8 ignore next */
+            const mod = await import(os.platform() === "win32" ? `file:///${tmpFile.replaceAll("\\", "/")}` : tmpFile);
+            return mod;
+        } finally {
+            fs.rmSync(tmpFile);
+        }
+    }
+}
@@ -1,129 +1,169 @@
-import http from 'http';
-import https from 'https';
-import gzipStatic, {RequestHandler} from 'connect-gzip-static';
-import finalhandler from 'finalhandler';
-import logger from '../util/logger';
-import frontend from 'zigbee2mqtt-frontend';
-import WebSocket from 'ws';
-import net from 'net';
-import url from 'url';
-import fs from 'fs';
-import * as settings from '../util/settings';
-import utils from '../util/utils';
-import stringify from 'json-stable-stringify-without-jsonify';
-import Extension from './extension';
-import bind from 'bind-decorator';
+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 type {RequestHandler} from "express-static-gzip";
+import expressStaticGzip from "express-static-gzip";
+import finalhandler from "finalhandler";
+import stringify from "json-stable-stringify-without-jsonify";
+import WebSocket from "ws";
+
+import data from "../util/data";
+import logger from "../util/logger";
+import * as settings from "../util/settings";
+import utils from "../util/utils";
+import Extension from "./extension";

 /**
 * This extension servers the frontend
 */
-export default class Frontend extends Extension {
-    private mqttBaseTopic = settings.get().mqtt.base_topic;
-    private host = settings.get().frontend.host;
-    private port = settings.get().frontend.port;
-    private sslCert = settings.get().frontend.ssl_cert;
-    private sslKey = settings.get().frontend.ssl_key;
-    private authToken = settings.get().frontend.auth_token;
-    private retainedMessages = new Map();
-    private server: http.Server;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    private fileServer: RequestHandler;
-    private wss: WebSocket.Server = null;
+export class Frontend extends Extension {
+    private mqttBaseTopic: string;
+    private server!: Server;
+    private fileServer!: RequestHandler;
+    private deviceIconsFileServer!: RequestHandler;
+    private wss!: WebSocket.Server;
+    private baseUrl: string;

-    constructor(zigbee: Zigbee, mqtt: MQTT, state: State, publishEntityState: PublishEntityState,
-        eventBus: EventBus, enableDisableExtension: (enable: boolean, name: string) => Promise<void>,
-        restartCallback: () => void, addExtension: (extension: Extension) => Promise<void>) {
+    constructor(
+        zigbee: Zigbee,
+        mqtt: Mqtt,
+        state: State,
+        publishEntityState: PublishEntityState,
+        eventBus: EventBus,
+        enableDisableExtension: (enable: boolean, name: string) => Promise<void>,
+        restartCallback: () => Promise<void>,
+        addExtension: (extension: Extension) => Promise<void>,
+    ) {
        super(zigbee, mqtt, state, publishEntityState, eventBus, enableDisableExtension, restartCallback, addExtension);
-        this.eventBus.onMQTTMessagePublished(this, this.onMQTTPublishMessage);
-    }

-    private isHttpsConfigured():boolean {
-        if (this.sslCert && this.sslKey) {
-            if (!fs.existsSync(this.sslCert) || !fs.existsSync(this.sslKey)) {
-                logger.error(`defined ssl_cert '${this.sslCert}' or ssl_key '${this.sslKey}' file path does not exists, server won't be secured.`); /* eslint-disable-line max-len */
-                return false;
-            }
-            return true;
-        }
-        return false;
+        const frontendSettings = settings.get().frontend;
+        assert(frontendSettings.enabled, `Frontend extension created with setting 'enabled: false'`);
+        this.baseUrl = frontendSettings.base_url;
+        this.mqttBaseTopic = settings.get().mqtt.base_topic;
    }

-
    override async start(): Promise<void> {
-        if (this.isHttpsConfigured()) {
-            const serverOptions = {
-                key: fs.readFileSync(this.sslKey),
-                cert: fs.readFileSync(this.sslCert)};
-            this.server = https.createServer(serverOptions, this.onRequest);
-        } else {
-            this.server = http.createServer(this.onRequest);
-        }
-
-        this.server.on('upgrade', this.onUpgrade);
-
-        /* istanbul ignore next */
-        const options = {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            setHeaders: (res: any, path: string): void => {
-                if (path.endsWith('index.html')) {
-                    res.setHeader('Cache-Control', 'no-store');
+        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");
+                    }
+                },
+                /* v8 ignore stop */
            },
        };
-        this.fileServer = gzipStatic(frontend.getPath(), options);
-        this.wss = new WebSocket.Server({noServer: true});
-        this.wss.on('connection', this.onWebSocketConnection);
+        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")});

-        if (!this.host) {
-            this.server.listen(this.port);
-            logger.info(`Started frontend on port ${this.port}`);
-        } else if (this.host.startsWith('/')) {
-            this.server.listen(this.host);
-            logger.info(`Started frontend on socket ${this.host}`);
+        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.listen(this.port, this.host);
-            logger.info(`Started frontend on port ${this.host}:${this.port}`);
+            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> {
-        super.stop();
-        this.wss?.clients.forEach((client) => {
-            client.send(stringify({topic: 'bridge/state', payload: 'offline'}));
-            client.terminate();
-        });
-        this.wss?.close();
-        /* istanbul ignore else */
-        if (this.server) {
-            return new Promise((cb: () => void) => this.server.close(cb));
+        await super.stop();
+
+        if (this.wss) {
+            for (const client of this.wss.clients) {
+                client.send(stringify({topic: "bridge/state", payload: {state: "offline"}}));
+                client.terminate();
+            }
+
+            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);
        }
    }

-    @bind private onRequest(request: http.IncomingMessage, response: http.ServerResponse): void {
-        // @ts-ignore
-        this.fileServer(request, response, finalhandler(request, response));
-    }
-
-    private authenticate(request: http.IncomingMessage, cb: (authenticate: boolean) => void): void {
-        const {query} = url.parse(request.url, true);
-        cb(!this.authToken || this.authToken === query.token);
-    }
-
-    @bind private onUpgrade(request: http.IncomingMessage, socket: net.Socket, head: Buffer): void {
+    @bind private onUpgrade(request: IncomingMessage, socket: Socket, head: Buffer): void {
        this.wss.handleUpgrade(request, socket, head, (ws) => {
-            this.authenticate(request, (isAuthenticated) => {
-                if (isAuthenticated) {
-                    this.wss.emit('connection', ws, request);
-                } else {
-                    ws.close(4401, 'Unauthorized');
-                }
-            });
+            // biome-ignore lint/style/noNonNullAssertion: `Only valid for request obtained from Server`
+            const {query} = parse(request.url!, true);
+            const authToken = settings.get().frontend.auth_token;
+
+            if (!authToken || authToken === query.token) {
+                this.wss.emit("connection", ws, request);
+            } else {
+                ws.close(4401, "Unauthorized");
+            }
        });
    }

    @bind private onWebSocketConnection(ws: WebSocket): void {
-        ws.on('error', (msg) => logger.error(`WebSocket error: ${msg.message}`));
-        ws.on('message', (data: Buffer, isBinary: boolean) => {
+        ws.on("error", (msg) => logger.error(`WebSocket error: ${msg.message}`));
+        ws.on("message", (data: Buffer, isBinary: boolean) => {
            if (!isBinary && data) {
                const message = data.toString();
                const {topic, payload} = JSON.parse(message);
@@ -131,16 +171,24 @@ export default class Frontend extends Extension {
            }
        });

-        for (const [key, value] of this.retainedMessages) {
-            ws.send(stringify({topic: key, payload: value}));
+        for (const [topic, payload] of Object.entries(this.mqtt.retainedMessages)) {
+            if (topic.startsWith(`${this.mqttBaseTopic}/`)) {
+                ws.send(
+                    stringify({
+                        // Send topic without base_topic
+                        topic: topic.substring(this.mqttBaseTopic.length + 1),
+                        payload: utils.parseJSON(payload.payload, payload.payload),
+                    }),
+                );
+            }
        }

-        for (const device of this.zigbee.devices(false)) {
+        for (const device of this.zigbee.devicesIterator(utils.deviceNotCoordinator)) {
            const payload = this.state.get(device);
            const lastSeen = settings.get().advanced.last_seen;
-            /* istanbul ignore if */
-            if (lastSeen !== 'disable') {
-                payload.last_seen = utils.formatDate(device.zh.lastSeen, lastSeen);
+
+            if (lastSeen !== "disable") {
+                payload.last_seen = utils.formatDate(device.zh.lastSeen ?? /* v8 ignore next */ 0, lastSeen);
            }

            if (device.zh.linkquality !== undefined) {
@@ -151,23 +199,34 @@ export default class Frontend extends Extension {
        }
    }

-    @bind private onMQTTPublishMessage(data: eventdata.MQTTMessagePublished): void {
-        if (data.topic.startsWith(`${this.mqttBaseTopic}/`)) {
-            // Send topic without base_topic
-            const topic = data.topic.substring(this.mqttBaseTopic.length + 1);
-            const payload = utils.parseJSON(data.payload, data.payload);
-            if (data.options.retain) {
-                this.retainedMessages.set(topic, payload);
-            }
+    @bind private onMQTTPublishMessageOrEntityState(data: eventdata.MQTTMessagePublished | eventdata.PublishEntityState): void {
+        let topic: string;
+        let payload: KeyValue | string;

-            if (this.wss) {
-                for (const client of this.wss.clients) {
-                    /* istanbul ignore else */
-                    if (client.readyState === WebSocket.OPEN) {
-                        client.send(stringify({topic, payload}));
-                    }
-                }
+        if ("topic" in data) {
+            // MQTTMessagePublished
+            if (data.options.meta.isEntityState || !data.topic.startsWith(`${this.mqttBaseTopic}/`)) {
+                // Don't send entity state to frontend on `MQTTMessagePublished` event, this is handled by
+                // `PublishEntityState` instead. Reason for this is to skip attribute messages when `output` is
+                // set to `attribute` or `attribute_and_json`, we only want to send JSON entity states to the
+                // frontend.
+                return;
+            }
+            // Send topic without base_topic
+            topic = data.topic.substring(this.mqttBaseTopic.length + 1);
+            payload = utils.parseJSON(data.payload, data.payload);
+        } else {
+            // PublishEntityState
+            topic = data.entity.name;
+            payload = data.message;
+        }
+
+        for (const client of this.wss.clients) {
+            if (client.readyState === WebSocket.OPEN) {
+                client.send(stringify({topic, payload}));
            }
        }
    }
 }
+
+export default Frontend;
@@ -1,178 +1,146 @@
-import * as settings from '../util/settings';
-import logger from '../util/logger';
-import utils from '../util/utils';
-import stringify from 'json-stable-stringify-without-jsonify';
-import equals from 'fast-deep-equal/es6';
-import bind from 'bind-decorator';
-import Extension from './extension';
-import Device from '../model/device';
-import Group from '../model/group';
-import * as zhc from 'zigbee-herdsman-converters';
+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 topicRegex =
-    new RegExp(`^${settings.get().mqtt.base_topic}/bridge/request/group/members/(remove|add|remove_all)$`);
-const legacyTopicRegex = new RegExp(`^${settings.get().mqtt.base_topic}/bridge/group/(.+)/(remove|add|remove_all)$`);
-const legacyTopicRegexRemoveAll = new RegExp(`^${settings.get().mqtt.base_topic}/bridge/group/remove_all$`);
+const TOPIC_REGEX = new RegExp(`^${settings.get().mqtt.base_topic}/bridge/request/group/members/(remove|add|remove_all)$`);

-const stateProperties: {[s: string]: (value: string, exposes: zhc.Expose[]) => boolean} = {
-    'state': () => true,
-    'brightness': (value, exposes) =>
-        !!exposes.find((e) => e.type === 'light' && e.features.find((f) => f.name === 'brightness')),
-    'color_temp': (value, exposes) =>
-        !!exposes.find((e) => e.type === 'light' && e.features.find((f) => f.name === 'color_temp')),
-    'color': (value, exposes) =>
-        !!exposes.find((e) => e.type === 'light' &&
-            e.features.find((f) => f.name === 'color_xy' || f.name === 'color_hs')),
-    'color_mode': (value, exposes) =>
-        !!exposes.find((e) => e.type === 'light' && (
-            (e.features.find((f) => f.name === `color_${value}`)) ||
-            (value === 'color_temp' && e.features.find((f) => f.name === 'color_temp')) )),
+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")),
+    color_temp: (_value, exposes) => exposes.some((e) => isLightExpose(e) && e.features.some((f) => f.name === "color_temp")),
+    color: (_value, exposes) => exposes.some((e) => isLightExpose(e) && e.features.some((f) => f.name === "color_xy" || f.name === "color_hs")),
+    color_mode: (value, exposes) =>
+        exposes.some(
+            (e) =>
+                isLightExpose(e) &&
+                (e.features.some((f) => f.name === `color_${value}`) || (value === "color_temp" && e.features.some((f) => f.name === "color_temp"))),
+        ),
 };

 interface ParsedMQTTMessage {
-    type: 'remove' | 'add' | 'remove_all', resolvedEntityGroup: Group, resolvedEntityDevice: Device,
-    error: string, groupKey: string, deviceKey: string, triggeredViaLegacyApi: boolean,
-    skipDisableReporting: boolean, resolvedEntityEndpoint: zh.Endpoint,
+    type: "remove" | "add" | "remove_all";
+    resolvedGroup?: Group;
+    resolvedDevice?: Device;
+    resolvedEndpoint?: zh.Endpoint;
+    groupKey?: string;
+    deviceKey?: string;
+    endpointKey?: string | number;
+    skipDisableReporting: boolean;
 }

 export default class Groups extends Extension {
-    private legacyApi = settings.get().advanced.legacy_api;
    private lastOptimisticState: {[s: string]: KeyValue} = {};

+    // biome-ignore lint/suspicious/useAwait: API
    override async start(): Promise<void> {
        this.eventBus.onStateChange(this, this.onStateChange);
        this.eventBus.onMQTTMessage(this, this.onMQTTMessage);
-        await this.syncGroupsWithSettings();
-    }
-
-    private async syncGroupsWithSettings(): Promise<void> {
-        const settingsGroups = settings.getGroups();
-        const zigbeeGroups = this.zigbee.groups();
-
-        const addRemoveFromGroup = async (action: 'add' | 'remove', deviceName: string,
-            groupName: string | number, endpoint: zh.Endpoint, group: Group): Promise<void> => {
-            try {
-                logger.info(`${action === 'add' ? 'Adding' : 'Removing'} '${deviceName}' to group '${groupName}'`);
-                if (action === 'remove') {
-                    await endpoint.removeFromGroup(group.zh);
-                } else {
-                    await endpoint.addToGroup(group.zh);
-                }
-            } catch (error) {
-                logger.error(`Failed to ${action} '${deviceName}' from '${groupName}'`);
-                logger.debug(error.stack);
-            }
-        };
-
-        for (const settingGroup of settingsGroups) {
-            const groupID = settingGroup.ID;
-            const zigbeeGroup = zigbeeGroups.find((g) => g.ID === groupID) || this.zigbee.createGroup(groupID);
-            const settingsEndpoint = settingGroup.devices.map((d) => {
-                const parsed = this.zigbee.resolveEntityAndEndpoint(d);
-                const entity = parsed.entity as Device;
-                if (!entity) logger.error(`Cannot find '${d}' of group '${settingGroup.friendly_name}'`);
-                if (parsed.endpointID && !parsed.endpoint) {
-                    logger.error(`Cannot find endpoint '${parsed.endpointID}' of device '${parsed.ID}'`);
-                }
-                return {'endpoint': parsed.endpoint, 'name': entity?.name};
-            }).filter((e) => e.endpoint != null);
-
-            // In settings but not in zigbee
-            for (const entity of settingsEndpoint) {
-                if (!zigbeeGroup.zh.hasMember(entity.endpoint)) {
-                    addRemoveFromGroup('add', entity.name, settingGroup.friendly_name, entity.endpoint, zigbeeGroup);
-                }
-            }
-
-            // In zigbee but not in settings
-            for (const endpoint of zigbeeGroup.zh.members) {
-                if (!settingsEndpoint.find((e) => e.endpoint === endpoint)) {
-                    const deviceName = settings.getDevice(endpoint.getDevice().ieeeAddr).friendly_name;
-                    addRemoveFromGroup('remove', deviceName, settingGroup.friendly_name, endpoint, zigbeeGroup);
-                }
-            }
-        }
-
-        for (const zigbeeGroup of zigbeeGroups) {
-            if (!settingsGroups.find((g) => g.ID === zigbeeGroup.ID)) {
-                for (const endpoint of zigbeeGroup.zh.members) {
-                    const deviceName = settings.getDevice(endpoint.getDevice().ieeeAddr).friendly_name;
-                    addRemoveFromGroup('remove', deviceName, zigbeeGroup.ID, endpoint, zigbeeGroup);
-                }
-            }
-        }
    }

    @bind async onStateChange(data: eventdata.StateChange): Promise<void> {
-        const reason = 'groupOptimistic';
-        if (data.reason === reason || data.reason === 'publishCached') {
+        const reason = "groupOptimistic";
+
+        if (data.reason === reason || data.reason === "publishCached") {
            return;
        }

        const payload: KeyValue = {};
-
-        let endpointName: string = null;
+        let endpointName: string | undefined;
        const endpointNames: string[] = data.entity instanceof Device ? data.entity.getEndpointNames() : [];
-        for (let [prop, value] of Object.entries(data.update)) {
+
+        for (let prop of Object.keys(data.update)) {
+            const value = data.update[prop];
            const endpointNameMatch = endpointNames.find((n) => prop.endsWith(`_${n}`));
+
            if (endpointNameMatch) {
                prop = prop.substring(0, prop.length - endpointNameMatch.length - 1);
                endpointName = endpointNameMatch;
            }

-            if (prop in stateProperties) {
+            if (prop in STATE_PROPERTIES) {
                payload[prop] = value;
            }
        }

-        if (Object.keys(payload).length) {
+        const payloadKeys = Object.keys(payload);
+
+        if (payloadKeys.length) {
            const entity = data.entity;
-            const groups = this.zigbee.groups().filter((g) => {
-                return g.options && (!g.options.hasOwnProperty('optimistic') || g.options.optimistic);
-            });
+            const groups = [];
+
+            for (const group of this.zigbee.groupsIterator()) {
+                if (group.options && (group.options.optimistic == null || group.options.optimistic)) {
+                    groups.push(group);
+                }
+            }

            if (entity instanceof Device) {
-                for (const group of groups) {
-                    if (group.zh.hasMember(entity.endpoint(endpointName)) &&
-                        !equals(this.lastOptimisticState[group.ID], payload) &&
-                        this.shouldPublishPayloadForGroup(group, payload)) {
-                        this.lastOptimisticState[group.ID] = payload;
-                        await this.publishEntityState(group, payload, reason);
+                const endpoint = entity.endpoint(endpointName);
+
+                if (endpoint) {
+                    for (const group of groups) {
+                        if (
+                            group.zh.hasMember(endpoint) &&
+                            !equals(this.lastOptimisticState[group.ID], payload) &&
+                            this.shouldPublishPayloadForGroup(group, payload)
+                        ) {
+                            this.lastOptimisticState[group.ID] = payload;
+
+                            await this.publishEntityState(group, payload, reason);
+                        }
                    }
                }
            } else {
                // Invalidate the last optimistic group state when group state is changed directly.
                delete this.lastOptimisticState[entity.ID];

-                const groupsToPublish: Set<Group> = new Set();
+                const groupsToPublish = new Set<Group>();
+
                for (const member of entity.zh.members) {
                    const device = this.zigbee.resolveEntity(member.getDevice()) as Device;
-                    if (device.options.disabled) continue;
+
+                    if (device.options.disabled) {
+                        continue;
+                    }
+
                    const exposes = device.exposes();
                    const memberPayload: KeyValue = {};
-                    Object.keys(payload).forEach((key) => {
-                        if (stateProperties[key](payload[key], exposes)) {
+
+                    for (const key of payloadKeys) {
+                        if (STATE_PROPERTIES[key](payload[key], exposes)) {
                            memberPayload[key] = payload[key];
                        }
-                    });
+                    }

                    const endpointName = device.endpointName(member);
+
                    if (endpointName) {
-                        Object.keys(memberPayload).forEach((key) => {
+                        for (const key of Object.keys(memberPayload)) {
                            memberPayload[`${key}_${endpointName}`] = memberPayload[key];
                            delete memberPayload[key];
-                        });
+                        }
                    }

                    await this.publishEntityState(device, memberPayload, reason);
+
                    for (const zigbeeGroup of groups) {
-                        if (zigbeeGroup.zh.hasMember(member) &&
-                            this.shouldPublishPayloadForGroup(zigbeeGroup, payload)) {
+                        if (zigbeeGroup.zh.hasMember(member) && this.shouldPublishPayloadForGroup(zigbeeGroup, payload)) {
                            groupsToPublish.add(zigbeeGroup);
                        }
                    }
                }
+
                groupsToPublish.delete(entity);
+
                for (const group of groupsToPublish) {
                    await this.publishEntityState(group, payload, reason);
                }
@@ -181,219 +149,181 @@ export default class Groups extends Extension {
    }

    private shouldPublishPayloadForGroup(group: Group, payload: KeyValue): boolean {
-        if (group.options.off_state === 'last_member_state') return true;
-        if (!payload || payload.state !== 'OFF') return true;
-        if (this.areAllMembersOff(group)) return true;
-        return false;
+        return (
+            group.options.off_state === "last_member_state" ||
+            !payload ||
+            (payload.state !== "OFF" && payload.state !== "CLOSE") ||
+            this.areAllMembersOffOrClosed(group)
+        );
    }

-    private areAllMembersOff(group: Group): boolean {
+    private areAllMembersOffOrClosed(group: Group): boolean {
        for (const member of group.zh.members) {
-            const device = this.zigbee.resolveEntity(member.getDevice());
+            // biome-ignore lint/style/noNonNullAssertion: TODO: biome migration: valid from loop?
+            const device = this.zigbee.resolveEntity(member.getDevice())!;
+
            if (this.state.exists(device)) {
                const state = this.state.get(device);
-                if (state.state === 'ON') {
+                const endpointNames = device.isDevice() && device.getEndpointNames();
+                const stateKey =
+                    endpointNames &&
+                    endpointNames.length >= member.ID &&
+                    device.definition?.meta?.multiEndpoint &&
+                    (!device.definition.meta.multiEndpointSkip || !device.definition.meta.multiEndpointSkip.includes("state"))
+                        ? `state_${endpointNames[member.ID - 1]}`
+                        : "state";
+
+                if (state[stateKey] === "ON" || state[stateKey] === "OPEN") {
                    return false;
                }
            }
        }
+
        return true;
    }

-    private parseMQTTMessage(data: eventdata.MQTTMessage): ParsedMQTTMessage {
-        let type: 'remove' | 'add' | 'remove_all' = null;
-        let resolvedEntityGroup: Group = null;
-        let resolvedEntityDevice: Device = null;
-        let resolvedEntityEndpoint: zh.Endpoint = null;
-        let error: string = null;
-        let groupKey: string = null;
-        let deviceKey: string = null;
-        let triggeredViaLegacyApi = false;
-        let skipDisableReporting = false;
+    private parseMQTTMessage(
+        data: eventdata.MQTTMessage,
+    ): [raw: KeyValue | undefined, parsed: ParsedMQTTMessage | undefined, error: string | undefined] {
+        const topicRegexMatch = data.topic.match(TOPIC_REGEX);

-        /* istanbul ignore else */
-        const topicRegexMatch = data.topic.match(topicRegex);
-        const legacyTopicRegexRemoveAllMatch = data.topic.match(legacyTopicRegexRemoveAll);
-        const legacyTopicRegexMatch = data.topic.match(legacyTopicRegex);
+        if (topicRegexMatch) {
+            const type = topicRegexMatch[1] as "remove" | "add" | "remove_all";
+            let resolvedGroup: Group | undefined;
+            let groupKey: string | undefined;
+            let skipDisableReporting = false;
+            const message = JSON.parse(data.message) as
+                | Zigbee2MQTTAPI["bridge/request/group/members/add"]
+                | Zigbee2MQTTAPI["bridge/request/group/members/remove"]
+                | Zigbee2MQTTAPI["bridge/request/group/members/remove_all"];

-        if (this.legacyApi && (legacyTopicRegexMatch || legacyTopicRegexRemoveAllMatch)) {
-            triggeredViaLegacyApi = true;
-            if (legacyTopicRegexMatch) {
-                resolvedEntityGroup = this.zigbee.resolveEntity(legacyTopicRegexMatch[1]) as Group;
-                type = legacyTopicRegexMatch[2] as 'remove' | 'remove_all' | 'add';
-
-                if (!resolvedEntityGroup || !(resolvedEntityGroup instanceof Group)) {
-                    logger.error(`Group '${legacyTopicRegexMatch[1]}' does not exist`);
-
-                    /* istanbul ignore else */
-                    if (settings.get().advanced.legacy_api) {
-                        const payload = {friendly_name: data.message,
-                            group: legacyTopicRegexMatch[1], error: 'group doesn\'t exists'};
-                        this.mqtt.publish(
-                            'bridge/log',
-                            stringify({type: `device_group_${type}_failed`, message: payload}),
-                        );
-                    }
-
-                    return null;
-                }
-            } else {
-                type = 'remove_all';
+            if (typeof message !== "object" || message.device == null) {
+                return [message, {type, skipDisableReporting}, "Invalid payload"];
            }

-            const parsedEntity = this.zigbee.resolveEntityAndEndpoint(data.message);
-            resolvedEntityDevice = parsedEntity.entity as Device;
-            if (!resolvedEntityDevice || !(resolvedEntityDevice instanceof Device)) {
-                logger.error(`Device '${data.message}' does not exist`);
+            const deviceKey = message.device;
+            skipDisableReporting = message.skip_disable_reporting != null ? message.skip_disable_reporting : false;

-                /* istanbul ignore else */
-                if (settings.get().advanced.legacy_api) {
-                    const payload = {
-                        friendly_name: data.message, group: legacyTopicRegexMatch[1], error: 'entity doesn\'t exists',
-                    };
-                    this.mqtt.publish(
-                        'bridge/log',
-                        stringify({type: `device_group_${type}_failed`, message: payload}),
-                    );
+            if (type !== "remove_all") {
+                if (!("group" in message) || message.group == null) {
+                    return [message, {type, skipDisableReporting}, "Invalid payload"];
                }

-                return null;
-            }
-
-            resolvedEntityEndpoint = parsedEntity.endpoint;
-            if (parsedEntity.endpointID && !resolvedEntityEndpoint) {
-                logger.error(`Device '${parsedEntity.ID}' does not have endpoint '${parsedEntity.endpointID}'`);
-                return null;
-            }
-        } else if (topicRegexMatch) {
-            type = topicRegexMatch[1] as 'remove' | 'add' | 'remove_all';
-            const message = JSON.parse(data.message);
-            deviceKey = message.device;
-            skipDisableReporting = 'skip_disable_reporting' in message ? message.skip_disable_reporting : false;
-
-            if (type !== 'remove_all') {
                groupKey = message.group;
-                resolvedEntityGroup = this.zigbee.resolveEntity(message.group) as Group;
-                if (!resolvedEntityGroup || !(resolvedEntityGroup instanceof Group)) {
-                    error = `Group '${message.group}' does not exist`;
+
+                const group = this.zigbee.resolveEntity(message.group);
+
+                if (!group || !(group instanceof Group)) {
+                    return [message, {type, skipDisableReporting}, `Group '${message.group}' does not exist`];
                }
+
+                resolvedGroup = group;
            }

-            const parsed = this.zigbee.resolveEntityAndEndpoint(message.device);
-            resolvedEntityDevice = parsed?.entity as Device;
-            if (!error && (!resolvedEntityDevice || !(resolvedEntityDevice instanceof Device))) {
-                error = `Device '${message.device}' does not exist`;
+            const resolvedDevice = this.zigbee.resolveEntity(message.device);
+
+            if (!resolvedDevice || !(resolvedDevice instanceof Device)) {
+                return [message, {type, skipDisableReporting}, `Device '${message.device}' does not exist`];
            }
-            if (!error) {
-                resolvedEntityEndpoint = parsed.endpoint;
-                if (parsed.endpointID && !resolvedEntityEndpoint) {
-                    error = `Device '${parsed.ID}' does not have endpoint '${parsed.endpointID}'`;
-                }
+
+            const endpointKey = message.endpoint ?? "default";
+            const resolvedEndpoint = resolvedDevice.endpoint(message.endpoint);
+
+            if (!resolvedEndpoint) {
+                return [message, {type, skipDisableReporting}, `Device '${resolvedDevice.name}' does not have endpoint '${endpointKey}'`];
            }
+
+            return [
+                message,
+                {
+                    resolvedGroup,
+                    resolvedDevice,
+                    resolvedEndpoint,
+                    type,
+                    groupKey,
+                    deviceKey,
+                    endpointKey,
+                    skipDisableReporting,
+                },
+                undefined,
+            ];
        }

-        return {
-            resolvedEntityGroup, resolvedEntityDevice, type, error, groupKey, deviceKey,
-            triggeredViaLegacyApi, skipDisableReporting, resolvedEntityEndpoint,
-        };
+        return [undefined, undefined, undefined];
    }

    @bind private async onMQTTMessage(data: eventdata.MQTTMessage): Promise<void> {
-        const parsed = this.parseMQTTMessage(data);
-        if (!parsed || !parsed.type) return;
-        let {
-            resolvedEntityGroup, resolvedEntityDevice, type, error, triggeredViaLegacyApi,
-            groupKey, deviceKey, skipDisableReporting, resolvedEntityEndpoint,
-        } = parsed;
-        const message = utils.parseJSON(data.message, data.message);
-        let changedGroups: Group[] = [];
+        const [raw, parsed, error] = this.parseMQTTMessage(data);

-        const responseData: KeyValue = {device: deviceKey};
-        if (groupKey) {
-            responseData.group = groupKey;
-        }
-
-        if (!error) {
-            try {
-                const keys = [
-                    `${resolvedEntityDevice.ieeeAddr}/${resolvedEntityEndpoint.ID}`,
-                    `${resolvedEntityDevice.name}/${resolvedEntityEndpoint.ID}`,
-                ];
-
-                const endpointNameLocal = resolvedEntityDevice.endpointName(resolvedEntityEndpoint);
-                if (endpointNameLocal) {
-                    keys.push(`${resolvedEntityDevice.ieeeAddr}/${endpointNameLocal}`);
-                    keys.push(`${resolvedEntityDevice.name}/${endpointNameLocal}`);
-                }
-
-                if (!endpointNameLocal) {
-                    keys.push(resolvedEntityDevice.name);
-                    keys.push(resolvedEntityDevice.ieeeAddr);
-                }
-
-                if (type === 'add') {
-                    logger.info(`Adding '${resolvedEntityDevice.name}' to '${resolvedEntityGroup.name}'`);
-                    await resolvedEntityEndpoint.addToGroup(resolvedEntityGroup.zh);
-                    settings.addDeviceToGroup(resolvedEntityGroup.ID.toString(), keys);
-                    changedGroups.push(resolvedEntityGroup);
-
-                    /* istanbul ignore else */
-                    if (settings.get().advanced.legacy_api) {
-                        const payload = {friendly_name: resolvedEntityDevice.name, group: resolvedEntityGroup.name};
-                        this.mqtt.publish(
-                            'bridge/log',
-                            stringify({type: `device_group_add`, message: payload}),
-                        );
-                    }
-                } else if (type === 'remove') {
-                    logger.info(`Removing '${resolvedEntityDevice.name}' from '${resolvedEntityGroup.name}'`);
-                    await resolvedEntityEndpoint.removeFromGroup(resolvedEntityGroup.zh);
-                    settings.removeDeviceFromGroup(resolvedEntityGroup.ID.toString(), keys);
-                    changedGroups.push(resolvedEntityGroup);
-
-                    /* istanbul ignore else */
-                    if (settings.get().advanced.legacy_api) {
-                        const payload = {friendly_name: resolvedEntityDevice.name, group: resolvedEntityGroup.name};
-                        this.mqtt.publish(
-                            'bridge/log',
-                            stringify({type: `device_group_remove`, message: payload}),
-                        );
-                    }
-                } else { // remove_all
-                    logger.info(`Removing '${resolvedEntityDevice.name}' from all groups`);
-                    changedGroups = this.zigbee.groups().filter((g) => g.zh.members.includes(resolvedEntityEndpoint));
-                    await resolvedEntityEndpoint.removeFromAllGroups();
-                    for (const settingsGroup of settings.getGroups()) {
-                        settings.removeDeviceFromGroup(settingsGroup.ID.toString(), keys);
-
-                        /* istanbul ignore else */
-                        if (settings.get().advanced.legacy_api) {
-                            const payload = {friendly_name: resolvedEntityDevice.name};
-                            this.mqtt.publish(
-                                'bridge/log',
-                                stringify({type: `device_group_remove_all`, message: payload}),
-                            );
-                        }
-                    }
-                }
-            } catch (e) {
-                error = `Failed to ${type} from group (${e.message})`;
-                logger.debug(e.stack);
-            }
-        }
-
-        if (!triggeredViaLegacyApi) {
-            const response = utils.getResponse(message, responseData, error);
-            await this.mqtt.publish(`bridge/response/group/members/${type}`, stringify(response));
+        if (!raw || !parsed) {
+            return;
        }

        if (error) {
-            logger.error(error);
-        } else {
-            for (const group of changedGroups) {
-                this.eventBus.emitGroupMembersChanged({
-                    group, action: type, endpoint: resolvedEntityEndpoint, skipDisableReporting});
+            await this.publishResponse(parsed.type, raw, {}, error);
+            return;
+        }
+
+        const {resolvedGroup, resolvedDevice, resolvedEndpoint, type, groupKey, deviceKey, endpointKey, skipDisableReporting} = parsed;
+        const changedGroups: Group[] = [];
+
+        assert(resolvedDevice, "`resolvedDevice` is missing");
+        assert(resolvedEndpoint, "`resolvedEndpoint` is missing");
+
+        try {
+            if (type === "add") {
+                assert(resolvedGroup, "`resolvedGroup` is missing");
+                logger.info(`Adding '${resolvedDevice.name}' to '${resolvedGroup.name}'`);
+                await resolvedEndpoint.addToGroup(resolvedGroup.zh);
+                changedGroups.push(resolvedGroup);
+                // biome-ignore lint/style/noNonNullAssertion: valid from resolved asserts
+                const respPayload = {device: deviceKey!, endpoint: endpointKey!, group: groupKey!};
+                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}'`);
+                await resolvedEndpoint.removeFromGroup(resolvedGroup.zh);
+                changedGroups.push(resolvedGroup);
+                // biome-ignore lint/style/noNonNullAssertion: valid from resolved asserts
+                const respPayload = {device: deviceKey!, endpoint: endpointKey!, group: groupKey!};
+                await this.publishResponse<"bridge/response/group/members/remove">(parsed.type, raw, respPayload);
+            } else {
+                // remove_all
+                logger.info(`Removing '${resolvedDevice.name}' from all groups`);
+
+                for (const group of this.zigbee.groupsIterator((g) => g.members.includes(resolvedEndpoint))) {
+                    changedGroups.push(group);
+                }
+
+                await resolvedEndpoint.removeFromAllGroups();
+                // biome-ignore lint/style/noNonNullAssertion: valid from resolved asserts
+                const respPayload = {device: deviceKey!, endpoint: endpointKey!};
+                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})`;
+            await this.publishResponse(parsed.type, raw, {}, errorMsg);
+            // biome-ignore lint/style/noNonNullAssertion: always Error
+            logger.debug((e as Error).stack!);
+            return;
+        }
+
+        for (const group of changedGroups) {
+            this.eventBus.emitGroupMembersChanged({group, action: type, endpoint: resolvedEndpoint, skipDisableReporting});
+        }
+    }
+
+    private async publishResponse<T extends Zigbee2MQTTResponseEndpoints>(
+        type: ParsedMQTTMessage["type"],
+        request: KeyValue,
+        data: Zigbee2MQTTAPI[T],
+        error?: string,
+    ): Promise<void> {
+        const response = utils.getResponse(request, data, error);
+        await this.mqtt.publish(`bridge/response/group/members/${type}`, stringify(response));
+
+        if (error) {
+            logger.error(error);
        }
    }
 }
@@ -0,0 +1,77 @@
+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 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((sysMemTotalKb - sysMemFreeKb) / 1024),
+                memory_percent: round4((sysMemFreeKb / 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,455 +0,0 @@
-import * as settings from '../../util/settings';
-import logger from '../../util/logger';
-import utils from '../../util/utils';
-import assert from 'assert';
-import Extension from '../extension';
-import stringify from 'json-stable-stringify-without-jsonify';
-import bind from 'bind-decorator';
-
-const configRegex =
-    new RegExp(`${settings.get().mqtt.base_topic}/bridge/config/((?:\\w+/get)|(?:\\w+/factory_reset)|(?:\\w+))`);
-const allowedLogLevels = ['error', 'warn', 'info', 'debug'];
-
-export default class BridgeLegacy extends Extension {
-    private lastJoinedDeviceName: string = null;
-    private supportedOptions: {[s: string]: (topic: string, message: string) => Promise<void> | void};
-
-    override async start(): Promise<void> {
-        this.supportedOptions = {
-            'permit_join': this.permitJoin,
-            'last_seen': this.lastSeen,
-            'elapsed': this.elapsed,
-            'reset': this.reset,
-            'log_level': this.logLevel,
-            'devices': this.devices,
-            'groups': this.groups,
-            'devices/get': this.devices,
-            'rename': this.rename,
-            'rename_last': this.renameLast,
-            'remove': this.remove,
-            'force_remove': this.forceRemove,
-            'ban': this.ban,
-            'device_options': this.deviceOptions,
-            'add_group': this.addGroup,
-            'remove_group': this.removeGroup,
-            'force_remove_group': this.removeGroup,
-            'whitelist': this.whitelist,
-            'touchlink/factory_reset': this.touchlinkFactoryReset,
-        };
-
-        this.eventBus.onDeviceJoined(this, (data) => this.onZigbeeEvent_('deviceJoined', data, data.device));
-        this.eventBus.onDeviceInterview(this, (data) => this.onZigbeeEvent_('deviceInterview', data, data.device));
-        this.eventBus.onDeviceAnnounce(this, (data) => this.onZigbeeEvent_('deviceAnnounce', data, data.device));
-        this.eventBus.onDeviceLeave(this, (data) => this.onZigbeeEvent_('deviceLeave', data, null));
-        this.eventBus.onMQTTMessage(this, this.onMQTTMessage);
-
-        await this.publish();
-    }
-
-    @bind whitelist(topic: string, message: string): void {
-        try {
-            const entity = settings.getDevice(message);
-            assert(entity, `Entity '${message}' does not exist`);
-            settings.addDeviceToPasslist(entity.ID.toString());
-            logger.info(`Whitelisted '${entity.friendly_name}'`);
-            this.mqtt.publish(
-                'bridge/log',
-                stringify({type: 'device_whitelisted', message: {friendly_name: entity.friendly_name}}),
-            );
-        } catch (error) {
-            logger.error(`Failed to whitelist '${message}' '${error}'`);
-        }
-    }
-
-    @bind deviceOptions(topic: string, message: string): void {
-        let json = null;
-        try {
-            json = JSON.parse(message);
-        } catch (e) {
-            logger.error('Failed to parse message as JSON');
-            return;
-        }
-
-        if (!json.hasOwnProperty('friendly_name') || !json.hasOwnProperty('options')) {
-            logger.error('Invalid JSON message, should contain "friendly_name" and "options"');
-            return;
-        }
-
-        const entity = settings.getDevice(json.friendly_name);
-        assert(entity, `Entity '${json.friendly_name}' does not exist`);
-        settings.changeEntityOptions(entity.ID.toString(), json.options);
-        logger.info(`Changed device specific options of '${json.friendly_name}' (${stringify(json.options)})`);
-    }
-
-    @bind async permitJoin(topic: string, message: string): Promise<void> {
-        await this.zigbee.permitJoin(message.toLowerCase() === 'true');
-        this.publish();
-    }
-
-    @bind async reset(): Promise<void> {
-        try {
-            await this.zigbee.reset('soft');
-            logger.info('Soft reset ZNP');
-        } catch (error) {
-            logger.error('Soft reset failed');
-        }
-    }
-
-    @bind lastSeen(topic: string, message: string): void {
-        const allowed = ['disable', 'ISO_8601', 'epoch', 'ISO_8601_local'];
-        if (!allowed.includes(message)) {
-            logger.error(`${message} is not an allowed value, possible: ${allowed}`);
-            return;
-        }
-
-        settings.set(['advanced', 'last_seen'], message);
-        logger.info(`Set last_seen to ${message}`);
-    }
-
-    @bind elapsed(topic: string, message: string): void {
-        const allowed = ['true', 'false'];
-        if (!allowed.includes(message)) {
-            logger.error(`${message} is not an allowed value, possible: ${allowed}`);
-            return;
-        }
-
-        settings.set(['advanced', 'elapsed'], message === 'true');
-        logger.info(`Set elapsed to ${message}`);
-    }
-
-    @bind logLevel(topic: string, message: string): void {
-        const level = message.toLowerCase() as 'error' | 'warn' | 'info' | 'debug';
-        if (allowedLogLevels.includes(level)) {
-            logger.info(`Switching log level to '${level}'`);
-            logger.setLevel(level);
-        } else {
-            logger.error(`Could not set log level to '${level}'. Allowed level: '${allowedLogLevels.join(',')}'`);
-        }
-
-        this.publish();
-    }
-
-    @bind async devices(topic: string): Promise<void> {
-        const coordinator = await this.zigbee.getCoordinatorVersion();
-        const devices = this.zigbee.devices().map((device) => {
-            const payload: KeyValue = {
-                ieeeAddr: device.ieeeAddr,
-                type: device.zh.type,
-                networkAddress: device.zh.networkAddress,
-            };
-
-            if (device.zh.type !== 'Coordinator') {
-                const definition = device.definition;
-                payload.model = definition ? definition.model : device.zh.modelID;
-                payload.vendor = definition ? definition.vendor : '-';
-                payload.description = definition ? definition.description : '-';
-                payload.friendly_name = device.name;
-                payload.manufacturerID = device.zh.manufacturerID;
-                payload.manufacturerName = device.zh.manufacturerName;
-                payload.powerSource = device.zh.powerSource;
-                payload.modelID = device.zh.modelID;
-                payload.hardwareVersion = device.zh.hardwareVersion;
-                payload.softwareBuildID = device.zh.softwareBuildID;
-                payload.dateCode = device.zh.dateCode;
-                payload.lastSeen = device.zh.lastSeen;
-            } else {
-                payload.friendly_name = 'Coordinator';
-                payload.softwareBuildID = coordinator.type;
-                payload.dateCode = coordinator.meta.revision.toString();
-                payload.lastSeen = Date.now();
-            }
-
-            return payload;
-        });
-
-        if (topic.split('/').pop() == 'get') {
-            this.mqtt.publish(
-                `bridge/config/devices`, stringify(devices), {}, settings.get().mqtt.base_topic, false, false,
-            );
-        } else {
-            this.mqtt.publish('bridge/log', stringify({type: 'devices', message: devices}));
-        }
-    }
-
-    @bind groups(): void {
-        const payload = settings.getGroups().map((g) => {
-            return {...g, ID: Number(g.ID)};
-        });
-
-        this.mqtt.publish('bridge/log', stringify({type: 'groups', message: payload}));
-    }
-
-    @bind rename(topic: string, message: string): void {
-        const invalid =
-            `Invalid rename message format expected {"old": "friendly_name", "new": "new_name"} got ${message}`;
-
-        let json = null;
-        try {
-            json = JSON.parse(message);
-        } catch (e) {
-            logger.error(invalid);
-            return;
-        }
-
-        // Validate message
-        if (!json.new || !json.old) {
-            logger.error(invalid);
-            return;
-        }
-
-        this._renameInternal(json.old, json.new);
-    }
-
-    @bind renameLast(topic: string, message: string): void {
-        if (!this.lastJoinedDeviceName) {
-            logger.error(`Cannot rename last joined device, no device has joined during this session`);
-            return;
-        }
-
-        this._renameInternal(this.lastJoinedDeviceName, message);
-    }
-
-    _renameInternal(from: string, to: string): void {
-        try {
-            const isGroup = settings.getGroup(from) !== null;
-            settings.changeFriendlyName(from, to);
-            logger.info(`Successfully renamed - ${from} to ${to} `);
-            const entity = this.zigbee.resolveEntity(to);
-            if (entity.isDevice()) {
-                this.eventBus.emitEntityRenamed({homeAssisantRename: false, from, to, entity});
-            }
-
-            this.mqtt.publish(
-                'bridge/log',
-                stringify({type: `${isGroup ? 'group' : 'device'}_renamed`, message: {from, to}}),
-            );
-        } catch (error) {
-            logger.error(`Failed to rename - ${from} to ${to}`);
-        }
-    }
-
-    @bind addGroup(topic: string, message: string): void {
-        let id = null;
-        let name = null;
-        try {
-            // json payload with id and friendly_name
-            const json = JSON.parse(message);
-            if (json.hasOwnProperty('id')) {
-                id = json.id;
-                name = `group_${id}`;
-            }
-            if (json.hasOwnProperty('friendly_name')) {
-                name = json.friendly_name;
-            }
-        } catch (e) {
-            // just friendly_name
-            name = message;
-        }
-
-        if (name == null) {
-            logger.error('Failed to add group, missing friendly_name!');
-            return;
-        }
-
-        const group = settings.addGroup(name, id);
-        this.zigbee.createGroup(group.ID);
-        this.mqtt.publish('bridge/log', stringify({type: `group_added`, message: name}));
-        logger.info(`Added group '${name}'`);
-    }
-
-    @bind removeGroup(topic: string, message: string): void {
-        const name = message;
-        const entity = this.zigbee.resolveEntity(message) as Group;
-        assert(entity && entity.isGroup(), `Group '${message}' does not exist`);
-
-        if (topic.includes('force')) {
-            entity.zh.removeFromDatabase();
-        } else {
-            entity.zh.removeFromNetwork();
-        }
-        settings.removeGroup(message);
-
-        this.mqtt.publish('bridge/log', stringify({type: `group_removed`, message}));
-        logger.info(`Removed group '${name}'`);
-    }
-
-    @bind async forceRemove(topic: string, message: string): Promise<void> {
-        await this.removeForceRemoveOrBan('force_remove', message);
-    }
-
-    @bind async remove(topic: string, message: string): Promise<void> {
-        await this.removeForceRemoveOrBan('remove', message);
-    }
-
-    @bind async ban(topic: string, message: string): Promise<void> {
-        await this.removeForceRemoveOrBan('ban', message);
-    }
-
-    @bind async removeForceRemoveOrBan(action: string, message: string): Promise<void> {
-        const entity = this.zigbee.resolveEntity(message.trim()) as Device;
-        const lookup: KeyValue = {
-            ban: ['banned', 'Banning', 'ban'],
-            force_remove: ['force_removed', 'Force removing', 'force remove'],
-            remove: ['removed', 'Removing', 'remove'],
-        };
-
-        if (!entity) {
-            logger.error(`Cannot ${lookup[action][2]}, device '${message}' does not exist`);
-
-            this.mqtt.publish('bridge/log', stringify({type: `device_${lookup[action][0]}_failed`, message}));
-            return;
-        }
-
-        const ieeeAddr = entity.ieeeAddr;
-        const name = entity.name;
-
-        const cleanup = (): void => {
-            // Fire event
-            this.eventBus.emitDeviceRemoved({ieeeAddr, name});
-
-            // Remove from configuration.yaml
-            settings.removeDevice(entity.ieeeAddr);
-
-            // Remove from state
-            this.state.remove(ieeeAddr);
-
-            logger.info(`Successfully ${lookup[action][0]} ${entity.name}`);
-            this.mqtt.publish('bridge/log', stringify({type: `device_${lookup[action][0]}`, message}));
-        };
-
-        try {
-            logger.info(`${lookup[action][1]} '${entity.name}'`);
-            if (action === 'force_remove') {
-                entity.zh.removeFromDatabase();
-            } else {
-                await entity.zh.removeFromNetwork();
-            }
-
-            cleanup();
-        } catch (error) {
-            logger.error(`Failed to ${lookup[action][2]} ${entity.name} (${error})`);
-            // eslint-disable-next-line
-            logger.error(`See https://www.zigbee2mqtt.io/guide/usage/mqtt_topics_and_messages.html#zigbee2mqtt-bridge-request for more info`);
-
-            this.mqtt.publish('bridge/log', stringify({type: `device_${lookup[action][0]}_failed`, message}));
-        }
-
-        if (action === 'ban') {
-            settings.blockDevice(ieeeAddr);
-        }
-    }
-
-    @bind async onMQTTMessage(data: eventdata.MQTTMessage): Promise<void> {
-        const {topic, message} = data;
-        if (!topic.match(configRegex)) {
-            return;
-        }
-
-        const option = topic.match(configRegex)[1];
-
-        if (!this.supportedOptions.hasOwnProperty(option)) {
-            return;
-        }
-
-        await this.supportedOptions[option](topic, message);
-
-        return;
-    }
-
-    async publish(): Promise<void> {
-        const info = await utils.getZigbee2MQTTVersion();
-        const coordinator = await this.zigbee.getCoordinatorVersion();
-        const topic = `bridge/config`;
-        const payload = {
-            version: info.version,
-            commit: info.commitHash,
-            coordinator,
-            network: await this.zigbee.getNetworkParameters(),
-            log_level: logger.getLevel(),
-            permit_join: this.zigbee.getPermitJoin(),
-        };
-
-        await this.mqtt.publish(topic, stringify(payload), {retain: true, qos: 0});
-    }
-
-    onZigbeeEvent_(type: string, data: KeyValue, resolvedEntity: Device): void {
-        if (type === 'deviceJoined' && resolvedEntity) {
-            this.lastJoinedDeviceName = resolvedEntity.name;
-        }
-
-        if (type === 'deviceJoined') {
-            this.mqtt.publish(
-                'bridge/log',
-                stringify({type: `device_connected`, message: {friendly_name: resolvedEntity.name}}),
-            );
-        } else if (type === 'deviceInterview') {
-            if (data.status === 'successful') {
-                if (resolvedEntity.isSupported) {
-                    const {vendor, description, model} = resolvedEntity.definition;
-                    const log = {friendly_name: resolvedEntity.name, model, vendor, description, supported: true};
-                    this.mqtt.publish(
-                        'bridge/log',
-                        stringify({type: `pairing`, message: 'interview_successful', meta: log}),
-                    );
-                } else {
-                    const meta = {friendly_name: resolvedEntity.name, supported: false};
-                    this.mqtt.publish(
-                        'bridge/log',
-                        stringify({type: `pairing`, message: 'interview_successful', meta}),
-                    );
-                }
-            } else if (data.status === 'failed') {
-                const meta = {friendly_name: resolvedEntity.name};
-                this.mqtt.publish(
-                    'bridge/log',
-                    stringify({type: `pairing`, message: 'interview_failed', meta}),
-                );
-            } else {
-                /* istanbul ignore else */
-                if (data.status === 'started') {
-                    const meta = {friendly_name: resolvedEntity.name};
-                    this.mqtt.publish(
-                        'bridge/log',
-                        stringify({type: `pairing`, message: 'interview_started', meta}),
-                    );
-                }
-            }
-        } else if (type === 'deviceAnnounce') {
-            const meta = {friendly_name: resolvedEntity.name};
-            this.mqtt.publish('bridge/log', stringify({type: `device_announced`, message: 'announce', meta}));
-        } else {
-            /* istanbul ignore else */
-            if (type === 'deviceLeave') {
-                const name = data.ieeeAddr;
-                const meta = {friendly_name: name};
-                this.mqtt.publish(
-                    'bridge/log',
-                    stringify({type: `device_removed`, message: 'left_network', meta}),
-                );
-            }
-        }
-    }
-
-    @bind async touchlinkFactoryReset(): Promise<void> {
-        logger.info('Starting touchlink factory reset...');
-        this.mqtt.publish(
-            'bridge/log',
-            stringify({type: `touchlink`, message: 'reset_started', meta: {status: 'started'}}),
-        );
-        const result = await this.zigbee.touchlinkFactoryResetFirst();
-
-        if (result) {
-            logger.info('Successfully factory reset device through Touchlink');
-            this.mqtt.publish(
-                'bridge/log',
-                stringify({type: `touchlink`, message: 'reset_success', meta: {status: 'success'}}),
-            );
-        } else {
-            logger.warning('Failed to factory reset device through Touchlink');
-            this.mqtt.publish(
-                'bridge/log',
-                stringify({type: `touchlink`, message: 'reset_failed', meta: {status: 'failed'}}),
-            );
-        }
-    }
-}
@@ -1,61 +0,0 @@
-/* istanbul ignore file */
-import * as settings from '../../util/settings';
-import logger from '../../util/logger';
-import Extension from '../extension';
-import bind from 'bind-decorator';
-import Device from '../../model/device';
-
-const topicRegex = new RegExp(`^${settings.get().mqtt.base_topic}/bridge/device/(.+)/get_group_membership$`);
-
-export default class DeviceGroupMembership extends Extension {
-    override async start(): Promise<void> {
-        this.eventBus.onMQTTMessage(this, this.onMQTTMessage);
-    }
-
-    @bind async onMQTTMessage(data: eventdata.MQTTMessage): Promise<void> {
-        const match = data.topic.match(topicRegex);
-        if (!match) {
-            return null;
-        }
-
-        const parsed = this.zigbee.resolveEntityAndEndpoint(match[1]);
-        const device = parsed?.entity as Device;
-        if (!device || !(device instanceof Device)) {
-            logger.error(`Device '${match[1]}' does not exist`);
-            return;
-        }
-
-        const endpoint = parsed.endpoint;
-        if (parsed.endpointID && !endpoint) {
-            logger.error(`Device '${parsed.ID}' does not have endpoint '${parsed.endpointID}'`);
-            return;
-        }
-
-        const response = await endpoint.command(
-            `genGroups`, 'getMembership', {groupcount: 0, grouplist: []}, {},
-        );
-
-        if (!response) {
-            logger.warning(`Couldn't get group membership of ${device.ieeeAddr}`);
-            return;
-        }
-
-        let {grouplist, capacity} = response;
-
-        grouplist = grouplist.map((gid: string) => {
-            const g = settings.getGroup(gid);
-            return g ? g.friendly_name : gid;
-        });
-
-        const msgGroupList = `${device.ieeeAddr} is in groups [${grouplist}]`;
-        let msgCapacity;
-        if (capacity === 254) {
-            msgCapacity = 'it can be a part of at least 1 more group';
-        } else {
-            msgCapacity = `its remaining group capacity is ${capacity === 255 ? 'unknown' : capacity}`;
-        }
-        logger.info(`${msgGroupList} and ${msgCapacity}`);
-
-        this.publishEntityState(device, {group_list: grouplist, group_capacity: capacity});
-    }
-}
@@ -1,194 +0,0 @@
-import * as zhc from 'zigbee-herdsman-converters';
-import logger from '../../util/logger';
-import * as settings from '../../util/settings';
-import Extension from '../extension';
-
-const defaultConfiguration = {
-    minimumReportInterval: 3, maximumReportInterval: 300, reportableChange: 1,
-};
-
-const ZNLDP12LM = zhc.definitions.find((d) => d.model === 'ZNLDP12LM');
-
-const devicesNotSupportingReporting = [
-    zhc.definitions.find((d) => d.model === 'CC2530.ROUTER'),
-    zhc.definitions.find((d) => d.model === 'BASICZBR3'),
-    zhc.definitions.find((d) => d.model === 'ZM-CSW032-D'),
-    zhc.definitions.find((d) => d.model === 'TS0001'),
-    zhc.definitions.find((d) => d.model === 'TS0115'),
-];
-
-const reportKey = 1;
-
-const getColorCapabilities = async (endpoint: zh.Endpoint): Promise<{colorTemperature: boolean, colorXY: boolean}> => {
-    if (endpoint.getClusterAttributeValue('lightingColorCtrl', 'colorCapabilities') === undefined) {
-        await endpoint.read('lightingColorCtrl', ['colorCapabilities']);
-    }
-
-    const value = endpoint.getClusterAttributeValue('lightingColorCtrl', 'colorCapabilities') as number;
-    return {
-        colorTemperature: (value & 1<<4) > 0,
-        colorXY: (value & 1<<3) > 0,
-    };
-};
-
-const clusters: {[s: string]:
-    {attribute: string, minimumReportInterval: number, maximumReportInterval: number, reportableChange: number
-        condition?: (endpoint: zh.Endpoint) => Promise<boolean>}[]} =
-{
-    'genOnOff': [
-        {attribute: 'onOff', ...defaultConfiguration, minimumReportInterval: 0, reportableChange: 0},
-    ],
-    'genLevelCtrl': [
-        {attribute: 'currentLevel', ...defaultConfiguration},
-    ],
-    'lightingColorCtrl': [
-        {
-            attribute: 'colorTemperature', ...defaultConfiguration,
-            condition: async (endpoint): Promise<boolean> => (await getColorCapabilities(endpoint)).colorTemperature,
-        },
-        {
-            attribute: 'currentX', ...defaultConfiguration,
-            condition: async (endpoint): Promise<boolean> => (await getColorCapabilities(endpoint)).colorXY,
-        },
-        {
-            attribute: 'currentY', ...defaultConfiguration,
-            condition: async (endpoint): Promise<boolean> => (await getColorCapabilities(endpoint)).colorXY,
-        },
-    ],
-    'closuresWindowCovering': [
-        {attribute: 'currentPositionLiftPercentage', ...defaultConfiguration},
-        {attribute: 'currentPositionTiltPercentage', ...defaultConfiguration},
-    ],
-};
-
-export default class Report extends Extension {
-    private queue: Set<string> = new Set();
-    private failed: Set<string> = new Set();
-    private enabled = settings.get().advanced.report;
-
-    shouldIgnoreClusterForDevice(cluster: string, definition: zhc.Definition): boolean {
-        if (definition === ZNLDP12LM && cluster === 'closuresWindowCovering') {
-            // Device announces it but doesn't support it
-            // https://github.com/Koenkk/zigbee2mqtt/issues/2611
-            return true;
-        }
-
-        return false;
-    }
-
-    async setupReporting(device: Device): Promise<void> {
-        if (this.queue.has(device.ieeeAddr) || this.failed.has(device.ieeeAddr)) return;
-        this.queue.add(device.ieeeAddr);
-
-        const term1 = this.enabled ? 'Setup' : 'Disable';
-        const term2 = this.enabled ? 'setup' : 'disabled';
-
-        try {
-            for (const ep of device.zh.endpoints) {
-                for (const [cluster, configuration] of Object.entries(clusters)) {
-                    if (ep.supportsInputCluster(cluster) &&
-                        !this.shouldIgnoreClusterForDevice(cluster, device.definition)) {
-                        logger.debug(`${term1} reporting for '${device.ieeeAddr}' - ${ep.ID} - ${cluster}`);
-
-                        const items = [];
-                        for (const entry of configuration) {
-                            if (!entry.hasOwnProperty('condition') || (await entry.condition(ep))) {
-                                const toAdd = {...entry};
-                                if (!this.enabled) toAdd.maximumReportInterval = 0xFFFF;
-                                items.push(toAdd);
-                                delete items[items.length - 1].condition;
-                            }
-                        }
-
-                        this.enabled ?
-                            await ep.bind(cluster, this.zigbee.firstCoordinatorEndpoint()) :
-                            await ep.unbind(cluster, this.zigbee.firstCoordinatorEndpoint());
-
-                        await ep.configureReporting(cluster, items);
-                        logger.info(
-                            `Successfully ${term2} reporting for '${device.ieeeAddr}' - ${ep.ID} - ${cluster}`,
-                        );
-                    }
-                }
-            }
-
-            if (this.enabled) {
-                device.zh.meta.reporting = reportKey;
-            } else {
-                delete device.zh.meta.reporting;
-                this.eventBus.emitReconfigure({device});
-            }
-
-            this.eventBus.emitDevicesChanged();
-        } catch (error) {
-            logger.error(
-                `Failed to ${term1.toLowerCase()} reporting for '${device.ieeeAddr}' - ${error.stack}`,
-            );
-
-            this.failed.add(device.ieeeAddr);
-        }
-
-        device.zh.save();
-        this.queue.delete(device.ieeeAddr);
-    }
-
-    shouldSetupReporting(device: Device, messageType: string): boolean {
-        if (!device || !device.zh || !device.definition) return false;
-
-        // Handle messages of type endDeviceAnnce and devIncoming.
-        // This message is typically send when a device comes online after being powered off
-        // Ikea TRADFRI tend to forget their reporting after powered off.
-        // Re-setup reporting.
-        // Only resetup reporting if configuredReportings was not populated yet,
-        // else reconfigure is done in zigbee-herdsman-converters ikea.js/bulbOnEvent
-        // configuredReportings are saved since Zigbee2MQTT 1.17.0
-        // https://github.com/Koenkk/zigbee2mqtt/issues/966
-        if (this.enabled && messageType === 'deviceAnnounce' && device.isIkeaTradfri() &&
-            device.zh.endpoints.filter((e) => e.configuredReportings.length === 0).length ===
-                device.zh.endpoints.length) {
-            return true;
-        }
-
-        // These do not support reproting.
-        // https://github.com/Koenkk/zigbee-herdsman/issues/110
-        const philipsIgnoreSw = ['5.127.1.26581', '5.130.1.30000'];
-        if (device.zh.manufacturerName === 'Philips' &&
-            philipsIgnoreSw.includes(device.zh.softwareBuildID)) return false;
-
-        if (device.zh.interviewing === true) return false;
-        if (device.zh.type !== 'Router' || device.zh.powerSource === 'Battery') return false;
-        // Gledopto devices don't support reporting.
-        if (devicesNotSupportingReporting.includes(device.definition) ||
-            device.definition.vendor === 'Gledopto') return false;
-
-        if (this.enabled && device.zh.meta.hasOwnProperty('reporting') &&
-            device.zh.meta.reporting === reportKey) {
-            return false;
-        }
-
-        if (!this.enabled && !device.zh.meta.hasOwnProperty('reporting')) {
-            return false;
-        }
-
-        return true;
-    }
-
-    override async start(): Promise<void> {
-        for (const device of this.zigbee.devices(false)) {
-            if (this.shouldSetupReporting(device, null)) {
-                await this.setupReporting(device);
-            }
-        }
-
-        this.eventBus.onDeviceAnnounce(this, (data) => this.onZigbeeEvent_('deviceAnnounce', data.device));
-        this.eventBus.onDeviceMessage(this, (data) => this.onZigbeeEvent_('dummy', data.device));
-        this.eventBus.onDeviceJoined(this, (data) => this.onZigbeeEvent_('dummy', data.device));
-        this.eventBus.onDeviceNetworkAddressChanged(this, (data) => this.onZigbeeEvent_('dummy', data.device));
-    }
-
-    async onZigbeeEvent_(type: string, device: Device): Promise<void> {
-        if (this.shouldSetupReporting(device, type)) {
-            await this.setupReporting(device);
-        }
-    }
-}
@@ -1,62 +0,0 @@
-/* istanbul ignore file */
-// DEPRECATED
-import * as settings from '../../util/settings';
-import logger from '../../util/logger';
-import utils from '../../util/utils';
-import Extension from '../extension';
-
-/**
- * This extensions soft resets the ZNP after a certain timeout.
- */
-export default class SoftReset extends Extension {
-    private timer: NodeJS.Timeout = null;
-    private timeout = utils.seconds(settings.get().advanced.soft_reset_timeout);
-
-    override async start(): Promise<void> {
-        logger.debug(`Soft reset timeout set to ${this.timeout / 1000} seconds`);
-        this.resetTimer();
-        this.eventBus.onDeviceMessage(this, () => this.resetTimer());
-        this.eventBus.onDeviceAnnounce(this, () => this.resetTimer());
-        this.eventBus.onDeviceNetworkAddressChanged(this, () => this.resetTimer());
-        this.eventBus.onDeviceJoined(this, () => this.resetTimer());
-        this.eventBus.onDeviceInterview(this, () => this.resetTimer());
-    }
-
-    private clearTimer(): void {
-        if (this.timer) {
-            clearTimeout(this.timer);
-            this.timer = null;
-        }
-    }
-
-    private resetTimer(): void {
-        if (this.timeout === 0) {
-            return;
-        }
-
-        this.clearTimer();
-        this.timer = setTimeout(() => this.handleTimeout(), this.timeout);
-    }
-
-    private async handleTimeout(): Promise<void> {
-        logger.warning('Soft reset timeout triggered');
-
-        try {
-            await this.zigbee.reset('soft');
-            logger.warning('Soft reset ZNP due to timeout');
-        } catch (error) {
-            logger.warning('Soft reset failed, trying stop/start');
-
-            await this.zigbee.stop();
-            logger.warning('Zigbee stopped');
-
-            try {
-                await this.zigbee.start();
-            } catch (error) {
-                logger.error('Failed to restart!');
-            }
-        }
-
-        this.resetTimer();
-    }
-}
@@ -1,91 +1,73 @@
-import * as settings from '../util/settings';
-import utils from '../util/utils';
-import logger from '../util/logger';
-import stringify from 'json-stable-stringify-without-jsonify';
-import Extension from './extension';
-import bind from 'bind-decorator';
+import bind from "bind-decorator";
+import stringify from "json-stable-stringify-without-jsonify";
+import type {Zigbee2MQTTAPI, Zigbee2MQTTNetworkMap} from "../types/api";

-interface Link {
-    source: {ieeeAddr: string, networkAddress: number}, target: {ieeeAddr: string, networkAddress: number},
-    linkquality: number, depth: number, routes: zh.RoutingTableEntry[],
-    sourceIeeeAddr: string, targetIeeeAddr: string, sourceNwkAddr: number, lqi: number, relationship: number,
-}
+import logger from "../util/logger";
+import * as settings from "../util/settings";
+import utils from "../util/utils";
+import Extension from "./extension";

-interface Topology {
-    nodes: {
-        ieeeAddr: string, friendlyName: string, type: string, networkAddress: number, manufacturerName: string,
-        modelID: string, failed: string[], lastSeen: number,
-        definition: {model: string, vendor: string, supports: string, description: string}}[],
-    links: Link[],
-}
+const SUPPORTED_FORMATS = ["raw", "graphviz", "plantuml"];

 /**
 * This extension creates a network map
 */
 export default class NetworkMap extends Extension {
-    private legacyApi = settings.get().advanced.legacy_api;
-    private legacyTopic = `${settings.get().mqtt.base_topic}/bridge/networkmap`;
-    private legacyTopicRoutes = `${settings.get().mqtt.base_topic}/bridge/networkmap/routes`;
    private topic = `${settings.get().mqtt.base_topic}/bridge/request/networkmap`;
-    private supportedFormats: {[s: string]: (topology: Topology) => KeyValue | string};

+    // biome-ignore lint/suspicious/useAwait: API
    override async start(): Promise<void> {
        this.eventBus.onMQTTMessage(this, this.onMQTTMessage);
-        this.supportedFormats = {
-            'raw': this.raw,
-            'graphviz': this.graphviz,
-            'plantuml': this.plantuml,
-        };
    }

    @bind async onMQTTMessage(data: eventdata.MQTTMessage): Promise<void> {
-        /* istanbul ignore else */
-        if (this.legacyApi) {
-            if ((data.topic === this.legacyTopic || data.topic === this.legacyTopicRoutes) &&
-                this.supportedFormats.hasOwnProperty(data.message)) {
-                const includeRoutes = data.topic === this.legacyTopicRoutes;
-                const topology = await this.networkScan(includeRoutes);
-                let converted = this.supportedFormats[data.message](topology);
-                converted = data.message === 'raw' ? stringify(converted) : converted;
-                this.mqtt.publish(`bridge/networkmap/${data.message}`, converted as string, {});
-            }
-        }
-
        if (data.topic === this.topic) {
-            const message = utils.parseJSON(data.message, data.message);
+            const message = utils.parseJSON(data.message, data.message) as Zigbee2MQTTAPI["bridge/request/networkmap"];
+
            try {
-                const type = typeof message === 'object' ? message.type : message;
-                if (!this.supportedFormats.hasOwnProperty(type)) {
-                    throw new Error(`Type '${type}' not supported, allowed are: ${Object.keys(this.supportedFormats)}`);
+                const type = typeof message === "object" ? message.type : message;
+
+                if (!SUPPORTED_FORMATS.includes(type)) {
+                    throw new Error(`Type '${type}' not supported, allowed are: ${SUPPORTED_FORMATS.join(",")}`);
                }

-                const routes = typeof message === 'object' && message.routes;
+                const routes = typeof message === "object" && message.routes;
                const topology = await this.networkScan(routes);
-                const value = this.supportedFormats[type](topology);
-                await this.mqtt.publish(
-                    'bridge/response/networkmap',
-                    stringify(utils.getResponse(message, {routes, type, value}, null)),
-                );
+                let responseData: Zigbee2MQTTAPI["bridge/response/networkmap"];
+
+                switch (type) {
+                    case "raw": {
+                        responseData = {type, routes, value: this.raw(topology)};
+                        break;
+                    }
+                    case "graphviz": {
+                        responseData = {type, routes, value: this.graphviz(topology)};
+                        break;
+                    }
+                    case "plantuml": {
+                        responseData = {type, routes, value: this.plantuml(topology)};
+                        break;
+                    }
+                }
+
+                await this.mqtt.publish("bridge/response/networkmap", stringify(utils.getResponse(message, responseData)));
            } catch (error) {
-                await this.mqtt.publish(
-                    'bridge/response/networkmap',
-                    stringify(utils.getResponse(message, {}, error.message)),
-                );
+                await this.mqtt.publish("bridge/response/networkmap", stringify(utils.getResponse(message, {}, (error as Error).message)));
            }
        }
    }

-    @bind raw(topology: Topology): KeyValue {
+    raw(topology: Zigbee2MQTTNetworkMap): Zigbee2MQTTNetworkMap {
        return topology;
    }

-    @bind graphviz(topology: Topology): string {
+    graphviz(topology: Zigbee2MQTTNetworkMap): string {
        const colors = settings.get().map_options.graphviz.colors;

-        let text = 'digraph G {\nnode[shape=record];\n';
-        let style = '';
+        let text = "digraph G {\nnode[shape=record];\n";
+        let style = "";

-        topology.nodes.forEach((node) => {
+        for (const node of topology.nodes) {
            const labels = [];

            // Add friendly name
@@ -93,186 +75,206 @@ export default class NetworkMap extends Extension {

            // Add the device short network address, ieeaddr and scan note (if any)
            labels.push(
-                `${node.ieeeAddr} (${utils.toNetworkAddressHex(node.networkAddress)})` +
-                ((node.failed && node.failed.length) ? `failed: ${node.failed.join(',')}` : ''),
+                `${node.ieeeAddr} (${utils.toNetworkAddressHex(node.networkAddress)})${node.failed?.length ? `failed: ${node.failed.join(",")}` : ""}`,
            );

            // Add the device model
-            if (node.type !== 'Coordinator') {
+            if (node.type !== "Coordinator") {
                labels.push(`${node.definition?.vendor} ${node.definition?.description} (${node.definition?.model})`);
            }

            // Add the device last_seen timestamp
-            let lastSeen = 'unknown';
-            const date = node.type === 'Coordinator' ? Date.now() : node.lastSeen;
+            let lastSeen = "unknown";
+            const date = node.type === "Coordinator" ? Date.now() : node.lastSeen;
            if (date) {
-                lastSeen = utils.formatDate(date, 'relative') as string;
+                lastSeen = utils.formatDate(date, "relative") as string;
            }

            labels.push(lastSeen);

            // Shape the record according to device type
-            if (node.type == 'Coordinator') {
-                style = `style="bold, filled", fillcolor="${colors.fill.coordinator}", ` +
-                    `fontcolor="${colors.font.coordinator}"`;
-            } else if (node.type == 'Router') {
-                style = `style="rounded, filled", fillcolor="${colors.fill.router}", ` +
-                    `fontcolor="${colors.font.router}"`;
+            if (node.type === "Coordinator") {
+                style = `style="bold, filled", fillcolor="${colors.fill.coordinator}", fontcolor="${colors.font.coordinator}"`;
+            } else if (node.type === "Router") {
+                style = `style="rounded, filled", fillcolor="${colors.fill.router}", fontcolor="${colors.font.router}"`;
            } else {
-                style = `style="rounded, dashed, filled", fillcolor="${colors.fill.enddevice}", ` +
-                    `fontcolor="${colors.font.enddevice}"`;
+                style = `style="rounded, dashed, filled", fillcolor="${colors.fill.enddevice}", fontcolor="${colors.font.enddevice}"`;
            }

            // Add the device with its labels to the graph as a node.
-            text += `  "${node.ieeeAddr}" [`+style+`, label="{${labels.join('|')}}"];\n`;
+            text += `  "${node.ieeeAddr}" [${style}, label="{${labels.join("|")}}"];\n`;

            /**
             * Add an edge between the device and its child to the graph
             * NOTE: There are situations where a device is NOT in the topology, this can be e.g.
             * due to not responded to the lqi scan. In that case we do not add an edge for this device.
             */
-            topology.links.filter((e) => (e.source.ieeeAddr === node.ieeeAddr)).forEach((e) => {
-                const lineStyle = (node.type=='EndDevice') ? 'penwidth=1, ' :
-                    (!e.routes.length) ? 'penwidth=0.5, ' : 'penwidth=2, ';
-                const lineWeight = (!e.routes.length) ? `weight=0, color="${colors.line.inactive}", ` :
-                    `weight=1, color="${colors.line.active}", `;
-                const textRoutes = e.routes.map((r) => utils.toNetworkAddressHex(r.destinationAddress));
-                const lineLabels = (!e.routes.length) ? `label="${e.linkquality}"` :
-                    `label="${e.linkquality} (routes: ${textRoutes.join(',')})"`;
-                text += `  "${node.ieeeAddr}" -> "${e.target.ieeeAddr}"`;
-                text += ` [${lineStyle}${lineWeight}${lineLabels}]\n`;
-            });
-        });
+            for (const link of topology.links) {
+                if (link.source.ieeeAddr === node.ieeeAddr) {
+                    const lineStyle = node.type === "EndDevice" ? "penwidth=1, " : !link.routes.length ? "penwidth=0.5, " : "penwidth=2, ";
+                    const lineWeight = !link.routes.length
+                        ? `weight=0, color="${colors.line.inactive}", `
+                        : `weight=1, color="${colors.line.active}", `;
+                    const textRoutes = link.routes.map((r) => utils.toNetworkAddressHex(r.destinationAddress));
+                    const lineLabels = !link.routes.length
+                        ? `label="${link.linkquality}"`
+                        : `label="${link.linkquality} (routes: ${textRoutes.join(",")})"`;
+                    text += `  "${node.ieeeAddr}" -> "${link.target.ieeeAddr}"`;
+                    text += ` [${lineStyle}${lineWeight}${lineLabels}]\n`;
+                }
+            }
+        }

-        text += '}';
+        text += "}";

-        return text.replace(/\0/g, '');
+        return text.replace(/\0/g, "");
    }

-    @bind plantuml(topology: Topology): string {
+    plantuml(topology: Zigbee2MQTTNetworkMap): string {
        const text = [];

        text.push(`' paste into: https://www.planttext.com/`);
-        text.push(``);
-        text.push('@startuml');
+        text.push("");
+        text.push("@startuml");

-        topology.nodes.sort((a, b) => a.friendlyName.localeCompare(b.friendlyName)).forEach((node) => {
+        for (const node of topology.nodes.sort((a, b) => a.friendlyName.localeCompare(b.friendlyName))) {
            // Add friendly name
            text.push(`card ${node.ieeeAddr} [`);
            text.push(`${node.friendlyName}`);
-            text.push(`---`);
+            text.push("---");

            // Add the device short network address, ieeaddr and scan note (if any)
            text.push(
-                `${node.ieeeAddr} (${utils.toNetworkAddressHex(node.networkAddress)})` +
-                ((node.failed && node.failed.length) ? ` failed: ${node.failed.join(',')}` : ''),
+                `${node.ieeeAddr} (${utils.toNetworkAddressHex(node.networkAddress)})${node.failed?.length ? ` failed: ${node.failed.join(",")}` : ""}`,
            );

            // Add the device model
-            if (node.type !== 'Coordinator') {
-                text.push(`---`);
+            if (node.type !== "Coordinator") {
+                text.push("---");
                const definition = (this.zigbee.resolveEntity(node.ieeeAddr) as Device).definition;
                text.push(`${definition?.vendor} ${definition?.description} (${definition?.model})`);
            }

            // Add the device last_seen timestamp
-            let lastSeen = 'unknown';
-            const date = node.type === 'Coordinator' ? Date.now() : node.lastSeen;
+            let lastSeen = "unknown";
+            const date = node.type === "Coordinator" ? Date.now() : node.lastSeen;
            if (date) {
-                lastSeen = utils.formatDate(date, 'relative') as string;
+                lastSeen = utils.formatDate(date, "relative") as string;
            }
-            text.push(`---`);
+            text.push("---");
            text.push(lastSeen);
-            text.push(`]`);
-            text.push(``);
-        });
+            text.push("]");
+            text.push("");
+        }

        /**
         * Add edges between the devices
         * NOTE: There are situations where a device is NOT in the topology, this can be e.g.
         * due to not responded to the lqi scan. In that case we do not add an edge for this device.
         */
-        topology.links.forEach((link) => {
+        for (const link of topology.links) {
            text.push(`${link.sourceIeeeAddr} --> ${link.targetIeeeAddr}: ${link.lqi}`);
-        });
-        text.push('');
+        }

-        text.push(`@enduml`);
+        text.push("");

-        return text.join(`\n`);
+        text.push("@enduml");
+
+        return text.join("\n");
    }

-    async networkScan(includeRoutes: boolean): Promise<Topology> {
+    async networkScan(includeRoutes: boolean): Promise<Zigbee2MQTTNetworkMap> {
        logger.info(`Starting network scan (includeRoutes '${includeRoutes}')`);
-        const devices = this.zigbee.devices().filter((d) => d.zh.type !== 'GreenPower' && !d.options.disabled);
-        const lqis: Map<Device, zh.LQI> = new Map();
-        const routingTables: Map<Device, zh.RoutingTable> = new Map();
-        const failed: Map<Device, string[]> = new Map();
+        const lqis = new Map<Device, zh.LQI>();
+        const routingTables = new Map<Device, zh.RoutingTable>();
+        const failed = new Map<Device, string[]>();
+        const requestWithRetry = async <T>(request: () => Promise<T>): Promise<T> => {
+            try {
+                const result = await request();

-        for (const device of devices.filter((d) => d.zh.type != 'EndDevice')) {
-            failed.set(device, []);
+                return result;
+            } catch {
+                // Network is possibly congested, sleep 5 seconds to let the network settle.
+                await utils.sleep(5);
+                return await request();
+            }
+        };
+
+        for (const device of this.zigbee.devicesIterator((d) => d.type !== "GreenPower" && d.type !== "EndDevice")) {
+            if (device.options.disabled) {
+                continue;
+            }
+
+            const deviceFailures: string[] = [];
+            failed.set(device, deviceFailures);
            await utils.sleep(1); // sleep 1 second between each scan to reduce stress on network.

-            const doRequest = async <T>(request: () => Promise<T>, firstAttempt = true): Promise<T> => {
-                try {
-                    return await request();
-                } catch (error) {
-                    if (!firstAttempt) {
-                        throw error;
-                    } else {
-                        // Network is possibly congested, sleep 5 seconds to let the network settle.
-                        await utils.sleep(5);
-                        return doRequest(request, false);
-                    }
-                }
-            };
-
            try {
-                const result = await doRequest<zh.LQI>(async () => device.zh.lqi());
+                const result = await requestWithRetry<zh.LQI>(async () => await device.zh.lqi());
                lqis.set(device, result);
                logger.debug(`LQI succeeded for '${device.name}'`);
            } catch (error) {
-                failed.get(device).push('lqi');
+                deviceFailures.push("lqi"); // set above
                logger.error(`Failed to execute LQI for '${device.name}'`);
-                logger.debug(error.stack);
+                // biome-ignore lint/style/noNonNullAssertion: always Error
+                logger.debug((error as Error).stack!);
            }

            if (includeRoutes) {
                try {
-                    const result = await doRequest(async () => device.zh.routingTable());
+                    const result = await requestWithRetry<zh.RoutingTable>(async () => await device.zh.routingTable());
                    routingTables.set(device, result);
                    logger.debug(`Routing table succeeded for '${device.name}'`);
                } catch (error) {
-                    failed.get(device).push('routingTable');
+                    deviceFailures.push("routingTable"); // set above
                    logger.error(`Failed to execute routing table for '${device.name}'`);
+                    // biome-ignore lint/style/noNonNullAssertion: always Error
+                    logger.debug((error as Error).stack!);
                }
            }
        }

-        logger.info(`Network scan finished`);
+        logger.info("Network scan finished");

-        const topology: Topology = {nodes: [], links: []};
-        // Add nodes
-        for (const device of devices) {
-            const definition = device.definition ? {
-                model: device.definition.model,
-                vendor: device.definition.vendor,
-                description: device.definition.description,
-                supports: Array.from(new Set((device.exposes()).map((e) => {
-                    return e.name ?? `${e.type} (${e.features.map((f) => f.name).join(', ')})`;
-                }))).join(', '),
-            } : null;
+        const topology: Zigbee2MQTTNetworkMap = {nodes: [], links: []};
+
+        // XXX: display GP/disabled devices in the map, better feedback than just hiding them?
+        for (const device of this.zigbee.devicesIterator((d) => d.type !== "GreenPower")) {
+            if (device.options.disabled) {
+                continue;
+            }
+
+            // Add nodes
+            const definition = device.definition
+                ? {
+                      model: device.definition.model,
+                      vendor: device.definition.vendor,
+                      description: device.definition.description,
+                      supports: Array.from(
+                          new Set(
+                              device.exposes().map((e) => {
+                                  return e.name ?? `${e.type} (${e.features?.map((f) => f.name).join(", ")})`;
+                              }),
+                          ),
+                      ).join(", "),
+                  }
+                : undefined;

            topology.nodes.push({
-                ieeeAddr: device.ieeeAddr, friendlyName: device.name, type: device.zh.type,
-                networkAddress: device.zh.networkAddress, manufacturerName: device.zh.manufacturerName,
-                modelID: device.zh.modelID, failed: failed.get(device), lastSeen: device.zh.lastSeen,
+                ieeeAddr: device.ieeeAddr,
+                friendlyName: device.name,
+                type: device.zh.type,
+                networkAddress: device.zh.networkAddress,
+                manufacturerName: device.zh.manufacturerName,
+                modelID: device.zh.modelID,
+                failed: failed.get(device),
+                lastSeen: device.zh.lastSeen,
                definition,
            });
        }

        // Add links
-        lqis.forEach((lqi, device) => {
+        for (const [device, lqi] of lqis) {
            for (const neighbor of lqi.neighbors) {
                if (neighbor.relationship > 3) {
                    // Relationship is not active, skip it
@@ -281,30 +283,41 @@ export default class NetworkMap extends Extension {

                // Some Xiaomi devices return 0x00 as the neighbor ieeeAddr (obviously not correct).
                // Determine the correct ieeeAddr based on the networkAddress.
-                const neighborDevice = this.zigbee.deviceByNetworkAddress(neighbor.networkAddress);
-                if (neighbor.ieeeAddr === '0x0000000000000000' && neighborDevice) {
-                    neighbor.ieeeAddr = neighborDevice.ieeeAddr;
+                if (neighbor.ieeeAddr === "0x0000000000000000") {
+                    const neighborDevice = this.zigbee.deviceByNetworkAddress(neighbor.networkAddress);
+
+                    if (neighborDevice) {
+                        neighbor.ieeeAddr = neighborDevice.ieeeAddr;
+                    }
                }

-                const link: Link = {
+                const link: Zigbee2MQTTNetworkMap["links"][number] = {
                    source: {ieeeAddr: neighbor.ieeeAddr, networkAddress: neighbor.networkAddress},
                    target: {ieeeAddr: device.ieeeAddr, networkAddress: device.zh.networkAddress},
-                    linkquality: neighbor.linkquality, depth: neighbor.depth, routes: [],
+                    linkquality: neighbor.linkquality,
+                    depth: neighbor.depth,
+                    routes: [],
                    // DEPRECATED:
-                    sourceIeeeAddr: neighbor.ieeeAddr, targetIeeeAddr: device.ieeeAddr,
-                    sourceNwkAddr: neighbor.networkAddress, lqi: neighbor.linkquality,
+                    sourceIeeeAddr: neighbor.ieeeAddr,
+                    targetIeeeAddr: device.ieeeAddr,
+                    sourceNwkAddr: neighbor.networkAddress,
+                    lqi: neighbor.linkquality,
                    relationship: neighbor.relationship,
                };

                const routingTable = routingTables.get(device);
+
                if (routingTable) {
-                    link.routes = routingTable.table
-                        .filter((t) => t.status === 'ACTIVE' && t.nextHop === neighbor.networkAddress);
+                    for (const entry of routingTable.table) {
+                        if (entry.status === "ACTIVE" && entry.nextHop === neighbor.networkAddress) {
+                            link.routes.push(entry);
+                        }
+                    }
                }

                topology.links.push(link);
            }
-        });
+        }

        return topology;
    }
@@ -1,51 +1,74 @@
-import * as zhc from 'zigbee-herdsman-converters';
-import Extension from './extension';
+import {onEvent} from "zigbee-herdsman-converters";
+
+import utils from "../util/utils";
+import Extension from "./extension";

 /**
 * This extension calls the zigbee-herdsman-converters onEvent.
 */
 export default class OnEvent extends Extension {
+    // biome-ignore lint/suspicious/useAwait: API
    override async start(): Promise<void> {
-        for (const device of this.zigbee.devices(false)) {
-            this.callOnEvent(device, 'start', {});
+        for (const device of this.zigbee.devicesIterator(utils.deviceNotCoordinator)) {
+            // don't await, in case of repeated failures this would hold startup
+            this.callOnEvent(device, "start", {}).catch(utils.noop);
        }

-        this.eventBus.onDeviceMessage(this, (data) => this.callOnEvent(data.device, 'message', this.convertData(data)));
-        this.eventBus.onDeviceJoined(this,
-            (data) => this.callOnEvent(data.device, 'deviceJoined', this.convertData(data)));
-        this.eventBus.onDeviceInterview(this,
-            (data) => this.callOnEvent(data.device, 'deviceInterview', this.convertData(data)));
-        this.eventBus.onDeviceAnnounce(this,
-            (data) => this.callOnEvent(data.device, 'deviceAnnounce', this.convertData(data)));
-        this.eventBus.onDeviceNetworkAddressChanged(this,
-            (data) => this.callOnEvent(data.device, 'deviceNetworkAddressChanged', this.convertData(data)));
-        this.eventBus.onEntityOptionsChanged(this,
-            (data) => {
-                if (data.entity.isDevice()) {
-                    this.callOnEvent(data.entity, 'deviceOptionsChanged', data)
-                        .then(() => this.eventBus.emitDevicesChanged());
-                }
+        this.eventBus.onDeviceMessage(this, async (data) => {
+            await this.callOnEvent(data.device, "message", {
+                endpoint: data.endpoint,
+                meta: data.meta,
+                cluster: typeof data.cluster === "string" ? data.cluster : /* v8 ignore next */ undefined, // XXX: ZH typing is wrong?
+                type: data.type,
+                data: data.data, // XXX: typing is a bit convoluted: ZHC has `KeyValueAny` here while Z2M has `KeyValue | Array<string | number>`
            });
-    }
-
-    private convertData(data: KeyValue): KeyValue {
-        return {...data, device: data.device.zh};
+        });
+        this.eventBus.onDeviceJoined(this, async (data) => {
+            await this.callOnEvent(data.device, "deviceJoined", {});
+        });
+        this.eventBus.onDeviceLeave(this, async (data) => {
+            if (data.device) {
+                await this.callOnEvent(data.device, "stop", {});
+            }
+        });
+        this.eventBus.onDeviceInterview(this, async (data) => {
+            await this.callOnEvent(data.device, "deviceInterview", {});
+        });
+        this.eventBus.onDeviceAnnounce(this, async (data) => {
+            await this.callOnEvent(data.device, "deviceAnnounce", {});
+        });
+        this.eventBus.onDeviceNetworkAddressChanged(this, async (data) => {
+            await this.callOnEvent(data.device, "deviceNetworkAddressChanged", {});
+        });
+        this.eventBus.onEntityOptionsChanged(this, async (data) => {
+            if (data.entity.isDevice()) {
+                await this.callOnEvent(data.entity, "deviceOptionsChanged", {});
+                this.eventBus.emitDevicesChanged();
+            }
+        });
    }

    override async stop(): Promise<void> {
-        super.stop();
-        for (const device of this.zigbee.devices(false)) {
-            await this.callOnEvent(device, 'stop', {});
+        await super.stop();
+
+        for (const device of this.zigbee.devicesIterator(utils.deviceNotCoordinator)) {
+            await this.callOnEvent(device, "stop", {});
        }
    }

-    private async callOnEvent(device: Device, type: zhc.OnEventType, data: KeyValue): Promise<void> {
+    private async callOnEvent(device: Device, type: Parameters<typeof onEvent>[0], data: Parameters<typeof onEvent>[1]): Promise<void> {
+        if (device.options.disabled) {
+            return;
+        }
+
        const state = this.state.get(device);
-        zhc.onEvent(type, data, device.zh);
+        const deviceExposesChanged = (): void => this.eventBus.emitExposesAndDevicesChanged(device);
+
+        await onEvent(type, data, device.zh, {deviceExposesChanged});

        if (device.definition?.onEvent) {
            const options: KeyValue = device.options;
-            await device.definition.onEvent(type, data, device.zh, options, state);
+            await device.definition.onEvent(type, data, device.zh, options, state, {deviceExposesChanged});
        }
    }
 }
@@ -1,323 +1,440 @@
-import * as settings from '../util/settings';
-import logger from '../util/logger';
-import stringify from 'json-stable-stringify-without-jsonify';
-import utils from '../util/utils';
-import Extension from './extension';
-import bind from 'bind-decorator';
-import Device from '../model/device';
-import dataDir from '../util/data';
-import * as URI from 'uri-js';
-import path from 'path';
-import * as zhc from 'zigbee-herdsman-converters';
+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";
+import utils from "../util/utils";
+import Extension from "./extension";

-function isValidUrl(url: string): boolean {
-    let parsed;
-    try {
-        parsed = URI.parse(url);
-    } catch (_) {
-        // istanbul ignore next
-        return false;
-    }
-    return parsed.scheme === 'http' || parsed.scheme === 'https';
-}
+type UpdateState = "updating" | "idle" | "available" | "scheduled";

-type UpdateState = 'updating' | 'idle' | 'available';
-interface UpdatePayload {
-    update_available?: boolean
-    // eslint-disable-next-line camelcase
+export interface UpdatePayload {
    update: {
-        progress?: number, remaining?: number, state: UpdateState,
-        installed_version: number | null, latest_version: number | null
-    }
+        progress?: number;
+        remaining?: number;
+        state: UpdateState;
+        installed_version: number | null;
+        latest_version: number | null;
+    };
 }

-const legacyTopicRegex = new RegExp(`^${settings.get().mqtt.base_topic}/bridge/ota_update/.+$`);
-const topicRegex =
-    new RegExp(`^${settings.get().mqtt.base_topic}/bridge/request/device/ota_update/(update|check)`, 'i');
+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 {
-    private inProgress = new Set();
-    private lastChecked: {[s: string]: number} = {};
-    private legacyApi = settings.get().advanced.legacy_api;
+    private inProgress = new Set<string>();
+    private lastChecked = new Map<string, number>();
+    private scheduledUpgrades = new Set<string>();
+    private scheduledDowngrades = new Set<string>();

+    // biome-ignore lint/suspicious/useAwait: API
    override async start(): Promise<void> {
        this.eventBus.onMQTTMessage(this, this.onMQTTMessage);
        this.eventBus.onDeviceMessage(this, this.onZigbeeEvent);
-        if (settings.get().ota.ikea_ota_use_test_url) {
-            zhc.ota.tradfri.useTestURL();
-        }

-        // Let zigbeeOTA module know if the override index file is provided
-        let overrideOTAIndex = settings.get().ota.zigbee_ota_override_index_location;
-        if (overrideOTAIndex) {
-            // If the file name is not a full path, then treat it as a relative to the data directory
-            if (!isValidUrl(overrideOTAIndex) && !path.isAbsolute(overrideOTAIndex)) {
-                overrideOTAIndex = dataDir.joinPath(overrideOTAIndex);
-            }
+        const otaSettings = settings.get().ota;
+        // Let OTA module know if the override index file is provided
+        let overrideIndexLocation = otaSettings.zigbee_ota_override_index_location;

-            zhc.ota.zigbeeOTA.useIndexOverride(overrideOTAIndex);
+        // If the file name is not a full path, then treat it as a relative to the data directory
+        if (overrideIndexLocation && !ota.isValidUrl(overrideIndexLocation) && !path.isAbsolute(overrideIndexLocation)) {
+            overrideIndexLocation = dataDir.joinPath(overrideIndexLocation);
        }

        // In order to support local firmware files we need to let zigbeeOTA know where the data directory is
-        zhc.ota.setDataDir(dataDir.getPath());
+        ota.setConfiguration({
+            dataDir: dataDir.getPath(),
+            overrideIndexLocation,
+            // TODO: implement me
+            imageBlockResponseDelay: otaSettings.image_block_response_delay,
+            defaultMaximumDataSize: otaSettings.default_maximum_data_size,
+        });

-        // In case Zigbee2MQTT is restared during an update, progress and remaining values are still in state.
-        // remove them.
-        for (const device of this.zigbee.devices(false)) {
+        // In case Zigbee2MQTT is restared during an update, progress and remaining values are still in state, remove them.
+        for (const device of this.zigbee.devicesIterator(utils.deviceNotCoordinator)) {
            this.removeProgressAndRemainingFromState(device);
+
            // Reset update state, e.g. when Z2M restarted during update.
-            if (this.state.get(device).update?.state === 'updating') {
-                this.state.get(device).update.state = 'available';
+            if (this.state.get(device).update?.state === "updating") {
+                this.state.get(device).update.state = "available";
            }
        }
    }

    private removeProgressAndRemainingFromState(device: Device): void {
-        delete this.state.get(device).update?.progress;
-        delete this.state.get(device).update?.remaining;
+        const deviceState = this.state.get(device);
+
+        if (deviceState.update) {
+            delete deviceState.update.progress;
+            delete deviceState.update.remaining;
+        }
    }

    @bind private async onZigbeeEvent(data: eventdata.DeviceMessage): Promise<void> {
-        if (data.type !== 'commandQueryNextImageRequest' || !data.device.definition ||
-            this.inProgress.has(data.device.ieeeAddr)) return;
+        if (data.type !== "commandQueryNextImageRequest" || !data.device.definition || this.inProgress.has(data.device.ieeeAddr)) {
+            return;
+        }
+
+        // `commandQueryNextImageRequest` check above should ensures this is valid but...
+        assert(
+            data.meta.zclTransactionSequenceNumber !== undefined,
+            "Missing 'queryNextImageRequest' transaction sequence number (cannot match reply)",
+        );
+
        logger.debug(`Device '${data.device.name}' requested OTA`);

-        const automaticOTACheckDisabled = settings.get().ota.disable_automatic_update_check;
-        let supportsOTA = !!data.device.definition.ota;
-        if (supportsOTA && !automaticOTACheckDisabled) {
-            // When a device does a next image request, it will usually do it a few times after each other
-            // with only 10 - 60 seconds inbetween. It doesn't make sense to check for a new update
-            // each time, so this interval can be set by the user. The default is 1,440 minutes (one day).
-            const updateCheckInterval = settings.get().ota.update_check_interval * 1000 * 60;
-            const check = this.lastChecked.hasOwnProperty(data.device.ieeeAddr) ?
-                (Date.now() - this.lastChecked[data.device.ieeeAddr]) > updateCheckInterval : true;
-            if (!check) return;
+        if (data.device.definition.ota) {
+            if (this.scheduledUpgrades.has(data.device.ieeeAddr) || this.scheduledDowngrades.has(data.device.ieeeAddr)) {
+                this.inProgress.add(data.device.ieeeAddr);

-            this.lastChecked[data.device.ieeeAddr] = Date.now();
-            let availableResult: zhc.OtaUpdateAvailableResult = null;
-            try {
-                // @ts-expect-error typing guaranteed by data.type
-                const dataData: zhc.ota.ImageInfo = data.data;
-                availableResult = await data.device.definition.ota.isUpdateAvailable(data.device.zh, dataData);
-            } catch (e) {
-                supportsOTA = false;
-                logger.debug(`Failed to check if update available for '${data.device.name}' (${e.message})`);
+                logger.info(`Updating '${data.device.name}' to latest firmware`);
+
+                try {
+                    const fileVersion = await ota.update(
+                        data.device.zh,
+                        data.device.otaExtraMetas,
+                        this.scheduledDowngrades.has(data.device.ieeeAddr),
+                        async (progress, remaining) => {
+                            let msg = `Update of '${data.device.name}' at ${progress.toFixed(2)}%`;
+
+                            if (remaining) {
+                                msg += `, ≈ ${Math.round(remaining / 60)} minutes remaining`;
+                            }
+
+                            logger.info(msg);
+
+                            await this.publishEntityState(
+                                data.device,
+                                this.getEntityPublishPayload(data.device, "updating", progress, remaining ?? undefined),
+                            );
+                        },
+                        data.data as Ota.ImageInfo,
+                        data.meta.zclTransactionSequenceNumber,
+                    );
+
+                    // remove right away on update success or no image in case any of the below calls fail
+                    this.scheduledUpgrades.delete(data.device.ieeeAddr);
+                    this.scheduledDowngrades.delete(data.device.ieeeAddr);
+
+                    if (fileVersion === undefined) {
+                        logger.info(`No image currently available for '${data.device.name}'. Unscheduling.`);
+
+                        // XXX: superfluous?
+                        this.removeProgressAndRemainingFromState(data.device);
+                        await this.publishEntityState(data.device, this.getEntityPublishPayload(data.device, "idle"));
+                        this.inProgress.delete(data.device.ieeeAddr);
+
+                        return;
+                    }
+
+                    logger.info(`Finished update of '${data.device.name}'`);
+
+                    this.removeProgressAndRemainingFromState(data.device);
+                    await this.publishEntityState(
+                        data.device,
+                        this.getEntityPublishPayload(data.device, {available: false, currentFileVersion: fileVersion, otaFileVersion: fileVersion}),
+                    );
+
+                    const firmwareTo = await this.readSoftwareBuildIDAndDateCode(data.device);
+
+                    logger.info(() => `Device '${data.device.name}' was updated to '${stringify(firmwareTo)}'`);
+
+                    /**
+                     * Re-configure after reading software build ID and date code, some devices use a
+                     * custom attribute for this (e.g. Develco SMSZB-120)
+                     */
+                    this.eventBus.emitReconfigure({device: data.device});
+                    this.eventBus.emitDevicesChanged();
+                } catch (e) {
+                    logger.debug(`Update of '${data.device.name}' failed (${e}). Retry scheduled for next request.`);
+
+                    this.removeProgressAndRemainingFromState(data.device);
+                    await this.publishEntityState(data.device, this.getEntityPublishPayload(data.device, "scheduled"));
+                }
+
+                this.inProgress.delete(data.device.ieeeAddr);
+
+                return; // we're done
            }

-            const payload = this.getEntityPublishPayload(data.device, availableResult ?? 'idle');
-            this.publishEntityState(data.device, payload);
+            if (!settings.get().ota.disable_automatic_update_check) {
+                // When a device does a next image request, it will usually do it a few times after each other
+                // with only 10 - 60 seconds inbetween. It doesn't make sense to check for a new update
+                // each time, so this interval can be set by the user. The default is 1,440 minutes (one day).
+                const updateCheckInterval = settings.get().ota.update_check_interval * 1000 * 60;
+                const deviceLastChecked = this.lastChecked.get(data.device.ieeeAddr);
+                const check = deviceLastChecked !== undefined ? Date.now() - deviceLastChecked > updateCheckInterval : true;

-            if (availableResult?.available) {
-                const message = `Update available for '${data.device.name}'`;
-                logger.info(message);
+                if (!check) {
+                    return;
+                }

-                /* istanbul ignore else */
-                if (settings.get().advanced.legacy_api) {
-                    const meta = {status: 'available', device: data.device.name};
-                    this.mqtt.publish(
-                        'bridge/log',
-                        stringify({type: `ota_update`, message, meta}),
-                    );
+                this.inProgress.add(data.device.ieeeAddr);
+                this.lastChecked.set(data.device.ieeeAddr, Date.now());
+                let availableResult: Ota.UpdateAvailableResult | undefined;
+
+                try {
+                    // never use 'previous' when responding to device request
+                    availableResult = await ota.isUpdateAvailable(data.device.zh, data.device.otaExtraMetas, data.data as Ota.ImageInfo, false);
+                } catch (error) {
+                    logger.debug(`Failed to check if update available for '${data.device.name}' (${error})`);
+                }
+
+                await this.publishEntityState(data.device, this.getEntityPublishPayload(data.device, availableResult ?? "idle"));
+
+                if (availableResult?.available) {
+                    const message = `Update available for '${data.device.name}'`;
+                    logger.info(message);
                }
            }
        }

-        // Respond to the OTA request: respond with NO_IMAGE_AVAILABLE (0x98) (so the client stops requesting OTAs)
-        const endpoint = data.device.zh.endpoints.find((e) => e.supportsOutputCluster('genOta')) || data.endpoint;
-        await endpoint.commandResponse('genOta', 'queryNextImageResponse',
-            {status: 0x98}, undefined, data.meta.zclTransactionSequenceNumber);
+        // Respond to stop the client from requesting OTAs
+        const endpoint = data.device.zh.endpoints.find((e) => e.supportsOutputCluster("genOta")) || data.endpoint;
+        await endpoint.commandResponse(
+            "genOta",
+            "queryNextImageResponse",
+            {status: Zcl.Status.NO_IMAGE_AVAILABLE},
+            undefined,
+            data.meta.zclTransactionSequenceNumber,
+        );
        logger.debug(`Responded to OTA request of '${data.device.name}' with 'NO_IMAGE_AVAILABLE'`);
+        this.inProgress.delete(data.device.ieeeAddr);
    }

-    private async readSoftwareBuildIDAndDateCode(device: Device, sendPolicy?: 'immediate'):
-        Promise<{softwareBuildID: string, dateCode: string}> {
+    private async readSoftwareBuildIDAndDateCode(
+        device: Device,
+        sendPolicy?: "immediate",
+    ): Promise<{softwareBuildID: string; dateCode: string} | undefined> {
        try {
-            const endpoint = device.zh.endpoints.find((e) => e.supportsInputCluster('genBasic'));
-            const result = await endpoint.read('genBasic', ['dateCode', 'swBuildId'], {sendPolicy});
+            const endpoint = device.zh.endpoints.find((e) => e.supportsInputCluster("genBasic"));
+            assert(endpoint);
+            const result = await endpoint.read("genBasic", ["dateCode", "swBuildId"], {sendPolicy});
            return {softwareBuildID: result.swBuildId, dateCode: result.dateCode};
-        } catch (e) {
-            return null;
+        } catch {
+            return undefined;
        }
    }

-    private getEntityPublishPayload(device: Device, state: zhc.OtaUpdateAvailableResult | UpdateState,
-        progress: number=null, remaining: number=null): UpdatePayload {
+    private getEntityPublishPayload(
+        device: Device,
+        state: Ota.UpdateAvailableResult | UpdateState,
+        progress?: number,
+        remaining?: number,
+    ): UpdatePayload {
        const deviceUpdateState = this.state.get(device).update;
-        const payload: UpdatePayload = {update: {
-            state: typeof state === 'string' ? state : (state.available ? 'available' : 'idle'),
-            installed_version: typeof state === 'string' ?
-                deviceUpdateState?.installed_version : state.currentFileVersion,
-            latest_version: typeof state === 'string' ?
-                deviceUpdateState?.latest_version : state.otaFileVersion,
-        }};
-        if (progress !== null) payload.update.progress = progress;
-        if (remaining !== null) payload.update.remaining = Math.round(remaining);
+        const payload: UpdatePayload = {
+            update: {
+                state: typeof state === "string" ? state : state.available ? "available" : "idle",
+                installed_version: typeof state === "string" ? deviceUpdateState?.installed_version : state.currentFileVersion,
+                latest_version: typeof state === "string" ? deviceUpdateState?.latest_version : state.otaFileVersion,
+            },
+        };

-        /* istanbul ignore else */
-        if (this.legacyApi) {
-            payload.update_available = typeof state === 'string' ? state === 'available' : state.available;
+        if (progress !== undefined) {
+            payload.update.progress = progress;
+        }
+
+        if (remaining !== undefined) {
+            payload.update.remaining = Math.round(remaining);
        }

        return payload;
    }

    @bind async onMQTTMessage(data: eventdata.MQTTMessage): Promise<void> {
-        if ((!this.legacyApi || !data.topic.match(legacyTopicRegex)) && !data.topic.match(topicRegex)) {
-            return null;
+        const topicMatch = data.topic.match(topicRegex);
+
+        if (!topicMatch) {
+            return;
        }

-        const message = utils.parseJSON(data.message, data.message);
-        const ID = (typeof message === 'object' && message.hasOwnProperty('id') ? message.id : message) as string;
+        const message = utils.parseJSON(data.message, data.message) as
+            | Zigbee2MQTTAPI["bridge/request/device/ota_update/check"]
+            | Zigbee2MQTTAPI["bridge/request/device/ota_update/check/downgrade"]
+            | Zigbee2MQTTAPI["bridge/request/device/ota_update/update"]
+            | Zigbee2MQTTAPI["bridge/request/device/ota_update/update/downgrade"]
+            | Zigbee2MQTTAPI["bridge/request/device/ota_update/schedule"]
+            | Zigbee2MQTTAPI["bridge/request/device/ota_update/schedule/downgrade"]
+            | Zigbee2MQTTAPI["bridge/request/device/ota_update/unschedule"];
+        const ID = (typeof message === "object" && message.id !== undefined ? message.id : message) as string;
        const device = this.zigbee.resolveEntity(ID);
-        const type = data.topic.substring(data.topic.lastIndexOf('/') + 1);
-        const responseData: {id: string, updateAvailable?: boolean, from?: string, to?: string}= {id: ID};
-        let error = null;
-        let errorStack = null;
+        const type = topicMatch[1] as "check" | "update" | "schedule" | "unschedule";
+        const downgrade = topicMatch[2] === "downgrade";
+        let error: string | undefined;
+        let errorStack: string | undefined;

        if (!(device instanceof Device)) {
            error = `Device '${ID}' does not exist`;
        } else if (!device.definition || !device.definition.ota) {
            error = `Device '${device.name}' does not support OTA updates`;
-
-            /* istanbul ignore else */
-            if (settings.get().advanced.legacy_api) {
-                const meta = {status: `not_supported`, device: device.name};
-                this.mqtt.publish(
-                    'bridge/log',
-                    stringify({type: `ota_update`, message: error, meta}),
-                );
-            }
        } else if (this.inProgress.has(device.ieeeAddr)) {
+            // also guards against scheduling while check/update op in progress that could result in undesired OTA state
            error = `Update or check for update already in progress for '${device.name}'`;
        } else {
-            this.inProgress.add(device.ieeeAddr);
+            switch (type) {
+                case "check": {
+                    this.inProgress.add(device.ieeeAddr);

-            if (type === 'check') {
-                const msg = `Checking if update available for '${device.name}'`;
-                logger.info(msg);
+                    logger.info(`Checking if update available for '${device.name}'`);

-                /* istanbul ignore else */
-                if (settings.get().advanced.legacy_api) {
-                    const meta = {status: `checking_if_available`, device: device.name};
-                    this.mqtt.publish(
-                        'bridge/log',
-                        stringify({type: `ota_update`, message: msg, meta}),
-                    );
-                }
+                    try {
+                        const availableResult = await ota.isUpdateAvailable(device.zh, device.otaExtraMetas, undefined, downgrade);

-                try {
-                    const availableResult = await device.definition.ota.isUpdateAvailable(device.zh, null);
-                    const msg = `${availableResult.available ? 'Update' : 'No update'} available for '${device.name}'`;
-                    logger.info(msg);
+                        logger.info(`${availableResult.available ? "Update" : "No update"} available for '${device.name}'`);

-                    /* istanbul ignore else */
-                    if (settings.get().advanced.legacy_api) {
-                        const meta = {
-                            status: availableResult.available ? 'available' : 'not_available', device: device.name};
-                        this.mqtt.publish(
-                            'bridge/log',
-                            stringify({type: `ota_update`, message: msg, meta}),
-                        );
+                        await this.publishEntityState(device, this.getEntityPublishPayload(device, availableResult));
+                        this.lastChecked.set(device.ieeeAddr, Date.now());
+
+                        const response = utils.getResponse<"bridge/response/device/ota_update/check">(message, {
+                            id: ID,
+                            update_available: availableResult.available,
+                        });
+
+                        await this.mqtt.publish("bridge/response/device/ota_update/check", stringify(response));
+                    } catch (e) {
+                        error = `Failed to check if update available for '${device.name}' (${(e as Error).message})`;
+                        errorStack = (e as Error).stack;
                    }

-                    const payload = this.getEntityPublishPayload(device, availableResult);
-                    this.publishEntityState(device, payload);
-                    this.lastChecked[device.ieeeAddr] = Date.now();
-                    responseData.updateAvailable = availableResult.available;
-                } catch (e) {
-                    error = `Failed to check if update available for '${device.name}' (${e.message})`;
-                    errorStack = e.stack;
+                    break;
+                }

-                    /* istanbul ignore else */
-                    if (settings.get().advanced.legacy_api) {
-                        const meta = {status: `check_failed`, device: device.name};
-                        this.mqtt.publish(
-                            'bridge/log',
-                            stringify({type: `ota_update`, message: error, meta}),
-                        );
+                case "update": {
+                    this.inProgress.add(device.ieeeAddr);
+
+                    if (this.scheduledUpgrades.delete(device.ieeeAddr)) {
+                        logger.info(`Previously scheduled '${device.name}' upgrade was cancelled by manual update`);
+                    } else if (this.scheduledDowngrades.delete(device.ieeeAddr)) {
+                        logger.info(`Previously scheduled '${device.name}' downgrade was cancelled by manual update`);
                    }
-                }
-            } else { // type === 'update'
-                const msg = `Updating '${device.name}' to latest firmware`;
-                logger.info(msg);

-                /* istanbul ignore else */
-                if (settings.get().advanced.legacy_api) {
-                    const meta = {status: `update_in_progress`, device: device.name};
-                    this.mqtt.publish(
-                        'bridge/log',
-                        stringify({type: `ota_update`, message: msg, meta}),
-                    );
-                }
+                    logger.info(`Updating '${device.name}' to ${downgrade ? "previous" : "latest"} firmware`);

-                try {
-                    const onProgress = (progress: number, remaining: number): void => {
-                        let msg = `Update of '${device.name}' at ${progress.toFixed(2)}%`;
-                        if (remaining) {
-                            msg += `, ≈ ${Math.round(remaining / 60)} minutes remaining`;
+                    try {
+                        const firmwareFrom = await this.readSoftwareBuildIDAndDateCode(device, "immediate");
+                        const fileVersion = await ota.update(device.zh, device.otaExtraMetas, downgrade, async (progress, remaining) => {
+                            let msg = `Update of '${device.name}' at ${progress.toFixed(2)}%`;
+
+                            if (remaining) {
+                                msg += `, ≈ ${Math.round(remaining / 60)} minutes remaining`;
+                            }
+
+                            logger.info(msg);
+
+                            await this.publishEntityState(device, this.getEntityPublishPayload(device, "updating", progress, remaining ?? undefined));
+                        });
+
+                        if (fileVersion === undefined) {
+                            throw new Error("No image currently available");
                        }

-                        logger.info(msg);
+                        logger.info(`Finished update of '${device.name}'`);
+                        this.removeProgressAndRemainingFromState(device);
+                        await this.publishEntityState(
+                            device,
+                            this.getEntityPublishPayload(device, {available: false, currentFileVersion: fileVersion, otaFileVersion: fileVersion}),
+                        );

-                        const payload = this.getEntityPublishPayload(device, 'updating', progress, remaining);
-                        this.publishEntityState(device, payload);
+                        const firmwareTo = await this.readSoftwareBuildIDAndDateCode(device);

-                        /* istanbul ignore else */
-                        if (settings.get().advanced.legacy_api) {
-                            const meta = {status: `update_progress`, device: device.name, progress};
-                            this.mqtt.publish('bridge/log', stringify({type: `ota_update`, message: msg, meta}));
+                        logger.info(() => `Device '${device.name}' was updated from '${stringify(firmwareFrom)}' to '${stringify(firmwareTo)}'`);
+
+                        /**
+                         * Re-configure after reading software build ID and date code, some devices use a
+                         * custom attribute for this (e.g. Develco SMSZB-120)
+                         */
+                        this.eventBus.emitReconfigure({device});
+                        this.eventBus.emitDevicesChanged();
+
+                        const response = utils.getResponse<"bridge/response/device/ota_update/update">(message, {
+                            id: ID,
+                            from: firmwareFrom ? {software_build_id: firmwareFrom.softwareBuildID, date_code: firmwareFrom.dateCode} : undefined,
+                            to: firmwareTo ? {software_build_id: firmwareTo.softwareBuildID, date_code: firmwareTo.dateCode} : undefined,
+                        });
+
+                        await this.mqtt.publish("bridge/response/device/ota_update/update", stringify(response));
+                    } catch (e) {
+                        logger.debug(`Update of '${device.name}' failed (${e})`);
+                        error = `Update of '${device.name}' failed (${(e as Error).message})`;
+                        errorStack = (e as Error).stack;
+
+                        this.removeProgressAndRemainingFromState(device);
+                        await this.publishEntityState(device, this.getEntityPublishPayload(device, "available"));
+                    }
+
+                    break;
+                }
+
+                case "schedule": {
+                    // ensure only one type scheduled by deleting from the other if necessary
+                    if (downgrade) {
+                        if (this.scheduledUpgrades.delete(device.ieeeAddr)) {
+                            logger.info(`Previously scheduled '${device.name}' upgrade was cancelled in favor of new downgrade request`);
                        }
-                    };

-                    const from_ = await this.readSoftwareBuildIDAndDateCode(device, 'immediate');
-                    const fileVersion = await device.definition.ota.updateToLatest(device.zh, onProgress);
-                    logger.info(`Finished update of '${device.name}'`);
-                    this.eventBus.emitReconfigure({device});
-                    this.removeProgressAndRemainingFromState(device);
-                    const payload = this.getEntityPublishPayload(device,
-                        {available: false, currentFileVersion: fileVersion, otaFileVersion: fileVersion});
-                    this.publishEntityState(device, payload);
-                    const to = await this.readSoftwareBuildIDAndDateCode(device);
-                    const [fromS, toS] = [stringify(from_), stringify(to)];
-                    logger.info(`Device '${device.name}' was updated from '${fromS}' to '${toS}'`);
-                    responseData.from = from_ ? utils.toSnakeCase(from_) : null;
-                    responseData.to = to ? utils.toSnakeCase(to) : null;
-                    this.eventBus.emitDevicesChanged();
+                        this.scheduledDowngrades.add(device.ieeeAddr);
+                    } else {
+                        if (this.scheduledDowngrades.delete(device.ieeeAddr)) {
+                            logger.info(`Previously scheduled '${device.name}' downgrade was cancelled in favor of new upgrade request`);
+                        }

-                    /* istanbul ignore else */
-                    if (settings.get().advanced.legacy_api) {
-                        const meta = {status: `update_succeeded`, device: device.name, from: from_, to};
-                        this.mqtt.publish('bridge/log', stringify({type: `ota_update`, message, meta}));
+                        this.scheduledUpgrades.add(device.ieeeAddr);
                    }
-                } catch (e) {
-                    logger.debug(`Update of '${device.name}' failed (${e})`);
-                    error = `Update of '${device.name}' failed (${e.message})`;
-                    errorStack = e.stack;

-                    this.removeProgressAndRemainingFromState(device);
-                    const payload = this.getEntityPublishPayload(device, 'available');
-                    this.publishEntityState(device, payload);
+                    logger.info(`Scheduled '${device.name}' to ${downgrade ? "downgrade" : "upgrade"} firmware on next request from device`);

-                    /* istanbul ignore else */
-                    if (settings.get().advanced.legacy_api) {
-                        const meta = {status: `update_failed`, device: device.name};
-                        this.mqtt.publish('bridge/log', stringify({type: `ota_update`, message: error, meta}));
+                    await this.publishEntityState(device, this.getEntityPublishPayload(device, "scheduled", undefined, undefined));
+
+                    const response = utils.getResponse<"bridge/response/device/ota_update/schedule">(message, {
+                        id: ID,
+                    });
+
+                    await this.mqtt.publish("bridge/response/device/ota_update/schedule", stringify(response));
+
+                    break;
+                }
+
+                case "unschedule": {
+                    if (this.scheduledUpgrades.delete(device.ieeeAddr)) {
+                        logger.info(`Previously scheduled '${device.name}' upgrade was cancelled`);
+                    } else if (this.scheduledDowngrades.delete(device.ieeeAddr)) {
+                        logger.info(`Previously scheduled '${device.name}' downgrade was cancelled`);
                    }
+
+                    await this.publishEntityState(device, this.getEntityPublishPayload(device, "idle", undefined, undefined));
+
+                    const response = utils.getResponse<"bridge/response/device/ota_update/unschedule">(message, {
+                        id: ID,
+                    });
+
+                    await this.mqtt.publish("bridge/response/device/ota_update/unschedule", stringify(response));
+
+                    break;
                }
            }

            this.inProgress.delete(device.ieeeAddr);
        }

-        const triggeredViaLegacyApi = data.topic.match(legacyTopicRegex);
-        if (!triggeredViaLegacyApi) {
-            const response = utils.getResponse(message, responseData, error);
-            await this.mqtt.publish(`bridge/response/device/ota_update/${type}`, stringify(response));
-        }
-
        if (error) {
+            const response = utils.getResponse(message, {}, error);
+
+            await this.mqtt.publish(`bridge/response/device/ota_update/${type}`, stringify(response));
            logger.error(error);
-            errorStack && logger.debug(errorStack);
+
+            if (errorStack) {
+                logger.debug(errorStack);
+            }
        }
    }
 }
@@ -1,173 +1,144 @@
+import bind from "bind-decorator";
+import stringify from "json-stable-stringify-without-jsonify";
+import type * as zhc from "zigbee-herdsman-converters";

-import * as settings from '../util/settings';
-import * as zhc from 'zigbee-herdsman-converters';
-import * as philips from 'zigbee-herdsman-converters/lib/philips';
-import logger from '../util/logger';
-import utils from '../util/utils';
-import Extension from './extension';
-import stringify from 'json-stable-stringify-without-jsonify';
-import Group from '../model/group';
-import Device from '../model/device';
-import bind from 'bind-decorator';
+import Device from "../model/device";
+import Group from "../model/group";
+import logger from "../util/logger";
+import * as settings from "../util/settings";
+import utils from "../util/utils";
+import Extension from "./extension";

-const topicGetSetRegex = new RegExp(`^(.+?)/(get|set)(?:/(.+))?`);
-const stateValues = ['on', 'off', 'toggle', 'open', 'close', 'stop', 'lock', 'unlock'];
-const sceneConverterKeys = ['scene_store', 'scene_add', 'scene_remove', 'scene_remove_all', 'scene_rename'];
+let topicGetSetRegex: RegExp;
+// Used by `publish.test.js` to reload regex when changing `mqtt.base_topic`.
+export const loadTopicGetSetRegex = (): void => {
+    topicGetSetRegex = new RegExp(`^${settings.get().mqtt.base_topic}/(?!bridge)(.+?)/(get|set)(?:/(.+))?$`);
+};
+loadTopicGetSetRegex();

-// Legacy: don't provide default converters anymore, this is required by older z2m installs not saving group members
-const defaultGroupConverters = [
-    zhc.toZigbee.light_onoff_brightness,
-    zhc.toZigbee.light_color_colortemp,
-    philips.tz.effect, // Support Hue effects for groups
-    zhc.toZigbee.ignore_transition,
-    zhc.toZigbee.cover_position_tilt,
-    zhc.toZigbee.thermostat_occupied_heating_setpoint,
-    zhc.toZigbee.tint_scene,
-    zhc.toZigbee.light_brightness_move,
-    zhc.toZigbee.light_brightness_step,
-    zhc.toZigbee.light_colortemp_step,
-    zhc.toZigbee.light_colortemp_move,
-    zhc.toZigbee.light_hue_saturation_move,
-    zhc.toZigbee.light_hue_saturation_step,
-];
+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"];

-interface ParsedTopic {ID: string, endpoint: string, attribute: string, type: 'get' | 'set'}
+interface ParsedTopic {
+    ID: string;
+    endpoint: string | undefined;
+    attribute: string;
+    type: "get" | "set";
+}

 export default class Publish extends Extension {
-    async start(): Promise<void> {
+    // biome-ignore lint/suspicious/useAwait: API
+    override async start(): Promise<void> {
        this.eventBus.onMQTTMessage(this, this.onMQTTMessage);
    }

-    parseTopic(topic: string): ParsedTopic | null {
+    parseTopic(topic: string): ParsedTopic | undefined {
        // The function supports the following topic formats (below are for 'set'. 'get' will look the same):
-        // - <base_topic>/device_name/set (endpoint and attribute is defined in the payload)
+        // - <base_topic>/device_name/set (auto-matches endpoint and attribute is defined in the payload)
        // - <base_topic>/device_name/set/attribute (default endpoint used)
        // - <base_topic>/device_name/endpoint/set (attribute is defined in the payload)
        // - <base_topic>/device_name/endpoint/set/attribute (payload is the value)

-        // The first step is to get rid of base topic part
-        topic = topic.replace(`${settings.get().mqtt.base_topic}/`, '');
-
-        // Also bridge requests are something we don't care about
-        if (topic.match(/bridge/)) return null;
-
        // Make the rough split on get/set keyword.
        // Before the get/set is the device name and optional endpoint name.
        // After it there will be an optional attribute name.
        const match = topic.match(topicGetSetRegex);
-        if (!match) return null;
+
+        if (!match) {
+            return undefined;
+        }

        const deviceNameAndEndpoint = match[1];
        const attribute = match[3];

        // Now parse the device/group name, and endpoint name
        const entity = this.zigbee.resolveEntityAndEndpoint(deviceNameAndEndpoint);
-        return {ID: entity.ID, endpoint: entity.endpointID, type: match[2] as 'get' | 'set', attribute: attribute};
+        return {ID: entity.ID, endpoint: entity.endpointID, type: match[2] as "get" | "set", attribute: attribute};
    }

-    parseMessage(parsedTopic: ParsedTopic, data: eventdata.MQTTMessage): KeyValue | null {
+    parseMessage(parsedTopic: ParsedTopic, data: eventdata.MQTTMessage): KeyValue | undefined {
        if (parsedTopic.attribute) {
            try {
                return {[parsedTopic.attribute]: JSON.parse(data.message)};
-            } catch (e) {
+            } catch {
                return {[parsedTopic.attribute]: data.message};
            }
        } else {
            try {
                return JSON.parse(data.message);
-            } catch (e) {
-                if (stateValues.includes(data.message.toLowerCase())) {
-                    return {state: data.message};
-                } else {
-                    return null;
-                }
+            } catch {
+                return STATE_VALUES.includes(data.message.toLowerCase()) ? {state: data.message} : undefined;
            }
        }
    }

-    legacyLog(payload: KeyValue): void {
-        /* istanbul ignore else */
-        if (settings.get().advanced.legacy_api) {
-            this.mqtt.publish('bridge/log', stringify(payload));
-        }
-    }
-
-    legacyRetrieveState(re: Device | Group, converter: zhc.Tz.Converter, result: zhc.Tz.ConvertSetResult,
-        target: zh.Endpoint | zh.Group, key: string, meta: zhc.Tz.Meta): void {
-        // It's possible for devices to get out of sync when writing an attribute that's not reportable.
-        // So here we re-read the value after a specified timeout, this timeout could for example be the
-        // transition time of a color change or for forcing a state read for devices that don't
-        // automatically report a new state when set.
-        // When reporting is requested for a device (report: true in device-specific settings) we won't
-        // ever issue a read here, as we assume the device will properly report changes.
-        // Only do this when the retrieve_state option is enabled for this device.
-        // retrieve_state == deprecated
-        if (re instanceof Device && result && result.hasOwnProperty('readAfterWriteTime') &&
-            re.options.retrieve_state
-        ) {
-            setTimeout(() => converter.convertGet(target, key, meta), result.readAfterWriteTime);
-        }
-    }
-
    updateMessageHomeAssistant(message: KeyValue, entityState: KeyValue): void {
        /**
         * Home Assistant always publishes 'state', even when e.g. only setting
         * the color temperature. This would lead to 2 zigbee publishes, where the first one
         * (state) is probably unnecessary.
         */
-        if (settings.get().homeassistant) {
-            const hasColorTemp = message.hasOwnProperty('color_temp');
-            const hasColor = message.hasOwnProperty('color');
-            const hasBrightness = message.hasOwnProperty('brightness');
-            const isOn = entityState.state === 'ON' ? true : false;
-            if (isOn && (hasColorTemp || hasColor) && !hasBrightness) {
+        if (settings.get().homeassistant.enabled) {
+            const hasColorTemp = message.color_temp !== undefined;
+            const hasColor = message.color !== undefined;
+            const hasBrightness = message.brightness !== undefined;
+            if (entityState.state === "ON" && (hasColorTemp || hasColor) && !hasBrightness) {
                delete message.state;
-                logger.debug('Skipping state because of Home Assistant');
+                logger.debug("Skipping state because of Home Assistant");
            }
        }
    }

    @bind async onMQTTMessage(data: eventdata.MQTTMessage): Promise<void> {
        const parsedTopic = this.parseTopic(data.topic);
-        if (!parsedTopic) return;
+
+        if (!parsedTopic) {
+            return;
+        }

        const re = this.zigbee.resolveEntity(parsedTopic.ID);
-        if (re == null) {
-            this.legacyLog({type: `entity_not_found`, message: {friendly_name: parsedTopic.ID}});
+
+        if (!re) {
            logger.error(`Entity '${parsedTopic.ID}' is unknown`);
            return;
        }

        // Get entity details
-        const definition = re instanceof Device ? re.definition : re.membersDefinitions();
+        let definition: zhc.Definition | zhc.Definition[];
+        if (re instanceof Device) {
+            if (!re.definition) {
+                logger.error(`Cannot publish to unsupported device '${re.name}'`);
+                return;
+            }
+            definition = re.definition;
+        } else {
+            definition = re.membersDefinitions();
+        }
        const target = re instanceof Group ? re.zh : re.endpoint(parsedTopic.endpoint);
-        if (target == null) {
+
+        if (!target) {
            logger.error(`Device '${re.name}' has no endpoint '${parsedTopic.endpoint}'`);
            return;
        }
-        const device = re instanceof Device ? re.zh : null;
-        const entitySettings = re.options;
-        const entityState = this.state.get(re);
-        const membersState = re instanceof Group ?
-            Object.fromEntries(re.zh.members.map((e) => [e.getDevice().ieeeAddr,
-                this.state.get(this.zigbee.resolveEntity(e.getDevice().ieeeAddr))])) : null;
-        let converters: zhc.Tz.Converter[];
-        {
-            if (Array.isArray(definition)) {
-                const c = new Set(definition.map((d) => d.toZigbee).flat());
-                if (c.size == 0) converters = defaultGroupConverters;
-                else converters = Array.from(c);
-            } else {
-                converters = definition.toZigbee;
-            }
-        }

        // Convert the MQTT message to a Zigbee message.
        const message = this.parseMessage(parsedTopic, data);
-        if (message == null) {
+
+        if (!message) {
            logger.error(`Invalid message '${message}', skipping...`);
            return;
        }
+
+        const device = re instanceof Device ? re.zh : undefined;
+        const entitySettings = re.options;
+        const entityState = this.state.get(re);
+        const membersState =
+            re instanceof Group
+                ? // biome-ignore lint/style/noNonNullAssertion: TODO: biome migration: might be a bit much assumed here?
+                  Object.fromEntries(re.zh.members.map((e) => [e.deviceIeeeAddress, this.state.get(this.zigbee.resolveEntity(e.deviceIeeeAddress)!)]))
+                : undefined;
+        const converters = this.getDefinitionConverters(definition);
+
        this.updateMessageHomeAssistant(message, entityState);

        /**
@@ -180,8 +151,8 @@ export default class Publish extends Extension {
         * bulb off => move state & brightness to the front
         */
        const entries = Object.entries(message);
-        const sorter = typeof message.state === 'string' && message.state.toLowerCase() === 'off' ? 1 : -1;
-        entries.sort((a) => (['state', 'brightness', 'brightness_percent'].includes(a[0]) ? sorter : sorter * -1));
+        const sorter = typeof message.state === "string" && message.state.toLowerCase() === "off" ? 1 : -1;
+        entries.sort((a) => (["state", "brightness", "brightness_percent"].includes(a[0]) ? sorter : sorter * -1));

        // For each attribute call the corresponding converter
        const usedConverters: {[s: number]: zhc.Tz.Converter[]} = {};
@@ -189,57 +160,72 @@ export default class Publish extends Extension {
        const toPublishEntity: {[s: number | string]: Device | Group} = {};
        const addToToPublish = (entity: Device | Group, payload: KeyValue): void => {
            const ID = entity.ID;
+
            if (!(ID in toPublish)) {
                toPublish[ID] = {};
                toPublishEntity[ID] = entity;
            }
+
            toPublish[ID] = {...toPublish[ID], ...payload};
        };

        const endpointNames = re instanceof Device ? re.getEndpointNames() : [];
-        const propertyEndpointRegex = new RegExp(`^(.*?)_(${endpointNames.join('|')})$`);
+        const propertyEndpointRegex = new RegExp(`^(.*?)_(${endpointNames.join("|")})$`);
+        let scenesChanged = false;

-        for (let [key, value] of entries) {
+        for (const entry of entries) {
+            let key = entry[0];
+            const value = entry[1];
            let endpointName = parsedTopic.endpoint;
            let localTarget = target;
-            let endpointOrGroupID = utils.isEndpoint(target) ? target.ID : target.groupID;
+            let endpointOrGroupID = utils.isZHEndpoint(target) ? target.ID : target.groupID;

            // When the key has a endpointName included (e.g. state_right), this will override the target.
            const propertyEndpointMatch = key.match(propertyEndpointRegex);
+
            if (re instanceof Device && propertyEndpointMatch) {
                endpointName = propertyEndpointMatch[2];
                key = propertyEndpointMatch[1];
-                localTarget = re.endpoint(endpointName);
+                // biome-ignore lint/style/noNonNullAssertion: endpointName is always matched to an existing endpoint of the device since `propertyEndpointRegex` only contains valid endpoints for this device
+                localTarget = re.endpoint(endpointName)!;
                endpointOrGroupID = localTarget.ID;
            }

-            if (!usedConverters.hasOwnProperty(endpointOrGroupID)) usedConverters[endpointOrGroupID] = [];
-            /* istanbul ignore next */
-            const converter = converters.find((c) =>
-                c.key.includes(key) && (!c.endpoint || c.endpoint == endpointName));
+            if (usedConverters[endpointOrGroupID] === undefined) usedConverters[endpointOrGroupID] = [];
+            // Match any key if the toZigbee converter defines no key.
+            const converter = converters.find(
+                (c) =>
+                    (!c.key || c.key.includes(key)) && (re instanceof Group || !c.endpoints || (endpointName && c.endpoints.includes(endpointName))),
+            );

-            if (parsedTopic.type === 'set' && usedConverters[endpointOrGroupID].includes(converter)) {
+            if (parsedTopic.type === "set" && converter && usedConverters[endpointOrGroupID].includes(converter)) {
                // Use a converter for set only once
                // (e.g. light_onoff_brightness converters can convert state and brightness)
                continue;
            }

            if (!converter) {
-                logger.error(`No converter available for '${key}' (${stringify(message[key])})`);
+                logger.error(`No converter available for '${key}' on '${re.name}': (${stringify(message[key])})`);
                continue;
            }

            // If the endpoint_name name is a number, try to map it to a friendlyName
-            if (!isNaN(Number(endpointName)) && re.isDevice() && utils.isEndpoint(localTarget) &&
-                re.endpointName(localTarget)) {
+            if (!Number.isNaN(Number(endpointName)) && re.isDevice() && utils.isZHEndpoint(localTarget) && re.endpointName(localTarget)) {
                endpointName = re.endpointName(localTarget);
            }

            // Converter didn't return a result, skip
            const entitySettingsKeyValue: KeyValue = entitySettings;
-            const meta = {
-                endpoint_name: endpointName, options: entitySettingsKeyValue,
-                message: {...message}, logger, device, state: entityState, membersState, mapped: definition,
+            const meta: zhc.Tz.Meta = {
+                endpoint_name: endpointName,
+                options: entitySettingsKeyValue,
+                message: {...message},
+                device,
+                state: entityState,
+                membersState,
+                mapped: definition,
+                /* v8 ignore next */
+                publish: (payload: KeyValue) => this.publishEntityState(re, payload),
            };

            // Strip endpoint name from meta.message properties.
@@ -254,11 +240,12 @@ export default class Publish extends Extension {
            }

            try {
-                if (parsedTopic.type === 'set' && converter.convertSet) {
+                if (parsedTopic.type === "set" && converter.convertSet) {
                    logger.debug(`Publishing '${parsedTopic.type}' '${key}' to '${re.name}'`);
                    const result = await converter.convertSet(localTarget, key, value, meta);
-                    const optimistic = !entitySettings.hasOwnProperty('optimistic') || entitySettings.optimistic;
-                    if (result && result.state && optimistic) {
+                    const optimistic = entitySettings.optimistic === undefined || entitySettings.optimistic;
+
+                    if (result?.state && optimistic) {
                        const msg = result.state;

                        if (endpointName) {
@@ -274,14 +261,13 @@ export default class Publish extends Extension {
                        addToToPublish(re, msg);
                    }

-                    if (result && result.membersState && optimistic) {
+                    if (result?.membersState && optimistic) {
                        for (const [ieeeAddr, state] of Object.entries(result.membersState)) {
-                            addToToPublish(this.zigbee.resolveEntity(ieeeAddr), state);
+                            // biome-ignore lint/style/noNonNullAssertion: might be a bit much assumed here?
+                            addToToPublish(this.zigbee.resolveEntity(ieeeAddr)!, state);
                        }
                    }
-
-                    this.legacyRetrieveState(re, converter, result, localTarget, key, meta);
-                } else if (parsedTopic.type === 'get' && converter.convertGet) {
+                } else if (parsedTopic.type === "get" && converter.convertGet) {
                    logger.debug(`Publishing get '${parsedTopic.type}' '${key}' to '${re.name}'`);
                    await converter.convertGet(localTarget, key, meta);
                } else {
@@ -289,26 +275,35 @@ export default class Publish extends Extension {
                    continue;
                }
            } catch (error) {
-                const message =
-                    `Publish '${parsedTopic.type}' '${key}' to '${re.name}' failed: '${error}'`;
+                const message = `Publish '${parsedTopic.type}' '${key}' to '${re.name}' failed: '${error}'`;
                logger.error(message);
-                logger.debug(error.stack);
-                this.legacyLog({type: `zigbee_publish_error`, message, meta: {friendly_name: re.name}});
+                // biome-ignore lint/style/noNonNullAssertion: always Error
+                logger.debug((error as Error).stack!);
            }

            usedConverters[endpointOrGroupID].push(converter);
-        }

-        for (const [ID, payload] of Object.entries(toPublish)) {
-            if (Object.keys(payload).length != 0) {
-                this.publishEntityState(toPublishEntity[ID], payload);
+            if (!scenesChanged && converter.key) {
+                scenesChanged = converter.key.some((k) => SCENE_CONVERTER_KEYS.includes(k));
+            }
+        }
+
+        for (const [ID, payload] of Object.entries(toPublish)) {
+            if (!utils.objectIsEmpty(payload)) {
+                await this.publishEntityState(toPublishEntity[ID], payload);
            }
        }

-        const scenesChanged = Object.values(usedConverters)
-            .some((cl) => cl.some((c) => c.key.some((k) => sceneConverterKeys.includes(k))));
        if (scenesChanged) {
            this.eventBus.emitScenesChanged({entity: re});
        }
    }
+
+    private getDefinitionConverters(definition: zhc.Definition | zhc.Definition[]): ReadonlyArray<zhc.Tz.Converter> {
+        if (Array.isArray(definition)) {
+            return definition.length ? Array.from(new Set(definition.flatMap((d) => d.toZigbee))) : [];
+        }
+
+        return definition?.toZigbee;
+    }
 }
@@ -1,43 +1,55 @@
-import * as settings from '../util/settings';
-import logger from '../util/logger';
-import debounce from 'debounce';
-import Extension from './extension';
-import stringify from 'json-stable-stringify-without-jsonify';
-import bind from 'bind-decorator';
-import utils from '../util/utils';
-import * as zhc from 'zigbee-herdsman-converters';
+import assert from "node:assert";

-type DebounceFunction = (() => void) & { clear(): void; } & { flush(): void; };
+import bind from "bind-decorator";
+import debounce from "debounce";
+import stringify from "json-stable-stringify-without-jsonify";
+import throttle from "throttleit";
+
+import * as zhc from "zigbee-herdsman-converters";
+
+import logger from "../util/logger";
+import * as settings from "../util/settings";
+import utils from "../util/utils";
+import Extension from "./extension";
+
+type DebounceFunction = (() => void) & {clear(): void} & {flush(): void};

 export default class Receive extends Extension {
+    // TODO: move all to `Map`
    private elapsed: {[s: string]: number} = {};
-    private debouncers: {[s: string]: {payload: KeyValue, publish: DebounceFunction }} = {};
+    private debouncers: {[s: string]: {payload: KeyValue; publish: DebounceFunction}} = {};
+    private throttlers: {[s: string]: {publish: PublishEntityState}} = {};

-    async start(): Promise<void> {
+    // biome-ignore lint/suspicious/useAwait: API
+    override async start(): Promise<void> {
        this.eventBus.onPublishEntityState(this, this.onPublishEntityState);
        this.eventBus.onDeviceMessage(this, this.onDeviceMessage);
    }

-    @bind async onPublishEntityState(data: eventdata.PublishEntityState): Promise<void> {
+    @bind onPublishEntityState(data: eventdata.PublishEntityState): void {
        /**
         * Prevent that outdated properties are being published.
         * In case that e.g. the state is currently held back by a debounce and a new state is published
         * remove it from the to be send debounced message.
         */
-        if (data.entity.isDevice() && this.debouncers[data.entity.ieeeAddr] &&
-            data.stateChangeReason !== 'publishDebounce' && data.stateChangeReason !== 'lastSeenChanged') {
+        if (
+            data.entity.isDevice() &&
+            this.debouncers[data.entity.ieeeAddr] &&
+            data.stateChangeReason !== "publishDebounce" &&
+            data.stateChangeReason !== "lastSeenChanged"
+        ) {
            for (const key of Object.keys(data.payload)) {
                delete this.debouncers[data.entity.ieeeAddr].payload[key];
            }
        }
    }

-    publishDebounce(device: Device, payload: KeyValue, time: number, debounceIgnore: string[]): void {
+    publishDebounce(device: Device, payload: KeyValue, time: number, debounceIgnore: string[] | undefined): void {
        if (!this.debouncers[device.ieeeAddr]) {
            this.debouncers[device.ieeeAddr] = {
                payload: {},
-                publish: debounce(() => {
-                    this.publishEntityState(device, this.debouncers[device.ieeeAddr].payload, 'publishDebounce');
+                publish: debounce(async () => {
+                    await this.publishEntityState(device, this.debouncers[device.ieeeAddr].payload, "publishDebounce");
                    this.debouncers[device.ieeeAddr].payload = {};
                }, time * 1000),
            };
@@ -60,39 +72,43 @@ export default class Receive extends Extension {
        this.debouncers[device.ieeeAddr].publish();
    }

+    async publishThrottle(device: Device, payload: KeyValue, time: number): Promise<void> {
+        if (!this.throttlers[device.ieeeAddr]) {
+            this.throttlers[device.ieeeAddr] = {
+                publish: throttle(this.publishEntityState, time * 1000),
+            };
+        }
+
+        // Update state cache right away. This makes sure that during throttling cached state is always up to date.
+        // By updating cache we make sure that state cache is always up-to-date.
+        this.state.set(device, payload);
+
+        await this.throttlers[device.ieeeAddr].publish(device, payload, "publishThrottle");
+    }
+
    // if debounce_ignore are specified (Array of strings)
    // then all newPayload values with key present in debounce_ignore
    // should equal or be undefined in oldPayload
    // otherwise payload is conflicted
-    isPayloadConflicted(newPayload: KeyValue, oldPayload: KeyValue, debounceIgnore: string[] | null): boolean {
+    isPayloadConflicted(newPayload: KeyValue, oldPayload: KeyValue, debounceIgnore: string[] | undefined): boolean {
        let result = false;
-        Object.keys(oldPayload)
-            .filter((key) => (debounceIgnore || []).includes(key))
-            .forEach((key) => {
-                if (typeof newPayload[key] !== 'undefined' && newPayload[key] !== oldPayload[key]) {
-                    result = true;
-                }
-            });
+
+        for (const key in oldPayload) {
+            if (debounceIgnore?.includes(key) && typeof newPayload[key] !== "undefined" && newPayload[key] !== oldPayload[key]) {
+                result = true;
+            }
+        }

        return result;
    }

-    shouldProcess(data: eventdata.DeviceMessage): boolean {
-        if (!data.device.definition || data.device.zh.interviewing) {
-            logger.debug(`Skipping message, still interviewing`);
-            return false;
-        }
-
-        return true;
-    }
-
    @bind async onDeviceMessage(data: eventdata.DeviceMessage): Promise<void> {
-        /* istanbul ignore next */
+        /* v8 ignore next */
        if (!data.device) return;

-        if (!this.shouldProcess(data)) {
-            utils.publishLastSeen({device: data.device, reason: 'messageEmitted'},
-                settings.get(), true, this.publishEntityState);
+        if (!data.device.definition || !data.device.interviewed) {
+            logger.debug("Skipping message, still interviewing");
+            await utils.publishLastSeen({device: data.device, reason: "messageEmitted"}, settings.get(), true, this.publishEntityState);
            return;
        }

@@ -102,12 +118,13 @@ export default class Receive extends Extension {
        });

        // Check if there is an available converter, genOta messages are not interesting.
-        const ignoreClusters: (string | number)[] = ['genOta', 'genTime', 'genBasic', 'genPollCtrl'];
-        if (converters.length == 0 && !ignoreClusters.includes(data.cluster)) {
-            logger.debug(`No converter available for '${data.device.definition.model}' with ` +
-                `cluster '${data.cluster}' and type '${data.type}' and data '${stringify(data.data)}'`);
-            utils.publishLastSeen({device: data.device, reason: 'messageEmitted'},
-                settings.get(), true, this.publishEntityState);
+        const ignoreClusters: (string | number)[] = ["genOta", "genTime", "genBasic", "genPollCtrl"];
+        if (converters.length === 0 && !ignoreClusters.includes(data.cluster)) {
+            logger.debug(
+                `No converter available for '${data.device.definition.model}' with ` +
+                    `cluster '${data.cluster}' and type '${data.type}' and data '${stringify(data.data)}'`,
+            );
+            await utils.publishLastSeen({device: data.device, reason: "messageEmitted"}, settings.get(), true, this.publishEntityState);
            return;
        }

@@ -116,7 +133,8 @@ export default class Receive extends Extension {
        // - If a payload is returned publish it to the MQTT broker
        // - If NO payload is returned do nothing. This is for non-standard behaviour
        //   for e.g. click switches where we need to count number of clicks and detect long presses.
-        const publish = (payload: KeyValue): void => {
+        const publish = async (payload: KeyValue): Promise<void> => {
+            assert(data.device.definition);
            const options: KeyValue = data.device.options;
            zhc.postProcessConvertedFromZigbeeMessage(data.device.definition, payload, options);

@@ -129,43 +147,44 @@ export default class Receive extends Extension {
                this.elapsed[data.device.ieeeAddr] = now;
            }

-            // Check if we have to debounce
+            // Check if we have to debounce or throttle
            if (data.device.options.debounce) {
-                this.publishDebounce(data.device, payload, data.device.options.debounce,
-                    data.device.options.debounce_ignore);
+                this.publishDebounce(data.device, payload, data.device.options.debounce, data.device.options.debounce_ignore);
+            } else if (data.device.options.throttle) {
+                await this.publishThrottle(data.device, payload, data.device.options.throttle);
            } else {
-                this.publishEntityState(data.device, payload);
+                await this.publishEntityState(data.device, payload);
            }
        };

-        const deviceExposesChanged = (): void => {
-            this.eventBus.emitDevicesChanged();
-            this.eventBus.emitExposesChanged({device: data.device});
+        const meta = {
+            device: data.device.zh,
+            logger,
+            state: this.state.get(data.device),
+            deviceExposesChanged: (): void => this.eventBus.emitExposesAndDevicesChanged(data.device),
        };
-
-        const meta = {device: data.device.zh, logger, state: this.state.get(data.device),
-            deviceExposesChanged: deviceExposesChanged};
        let payload: KeyValue = {};
        for (const converter of converters) {
            try {
                const convertData = {...data, device: data.device.zh};
                const options: KeyValue = data.device.options;
-                const converted = await converter.convert(
-                    data.device.definition, convertData, publish, options, meta);
+                const converted = await converter.convert(data.device.definition, convertData, publish, options, meta);
                if (converted) {
                    payload = {...payload, ...converted};
                }
-            } catch (error) /* istanbul ignore next */ {
-                logger.error(`Exception while calling fromZigbee converter: ${error.message}}`);
-                logger.debug(error.stack);
+                /* v8 ignore start */
+            } catch (error) {
+                logger.error(`Exception while calling fromZigbee converter: ${(error as Error).message}}`);
+                // biome-ignore lint/style/noNonNullAssertion: always Error
+                logger.debug((error as Error).stack!);
            }
+            /* v8 ignore stop */
        }

-        if (Object.keys(payload).length) {
-            publish(payload);
+        if (!utils.objectIsEmpty(payload)) {
+            await publish(payload);
        } else {
-            utils.publishLastSeen({device: data.device, reason: 'messageEmitted'},
-                settings.get(), true, this.publishEntityState);
+            await utils.publishLastSeen({device: data.device, reason: "messageEmitted"}, settings.get(), true, this.publishEntityState);
        }
    }
 }
@@ -1,20 +1,48 @@
-/* eslint-disable brace-style */
-import * as settings from '../util/settings';
-import * as zhc from 'zigbee-herdsman-converters';
+import assert from "node:assert";
+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";
+
+const LINKQUALITY = new Numeric("linkquality", access.STATE)
+    .withUnit("lqi")
+    .withDescription("Link quality (signal strength)")
+    .withValueMin(0)
+    .withValueMax(255)
+    .withCategory("diagnostic");

 export default class Device {
    public zh: zh.Device;
-    public definition: zhc.Definition;
-    private _definitionModelID: string;
+    public definition?: zhc.Definition;
+    private _definitionModelID?: string;

-    get ieeeAddr(): string {return this.zh.ieeeAddr;}
-    get ID(): string {return this.zh.ieeeAddr;}
-    get options(): DeviceOptions {return {...settings.get().device_options, ...settings.getDevice(this.ieeeAddr)};}
+    get ieeeAddr(): string {
+        return this.zh.ieeeAddr;
+    }
+    // biome-ignore lint/style/useNamingConvention: API
+    get ID(): string {
+        return this.zh.ieeeAddr;
+    }
+    get options(): DeviceOptionsWithId {
+        const deviceOptions = settings.getDevice(this.ieeeAddr) ?? {friendly_name: this.ieeeAddr, ID: this.ieeeAddr};
+        return {...settings.get().device_options, ...deviceOptions};
+    }
    get name(): string {
-        return this.zh.type === 'Coordinator' ? 'Coordinator' : this.options?.friendly_name || this.ieeeAddr;
+        return this.zh.type === "Coordinator" ? "Coordinator" : this.options?.friendly_name;
    }
    get isSupported(): boolean {
-        return this.zh.type === 'Coordinator' || (this.definition && !this.definition.generated);
+        return this.zh.type === "Coordinator" || Boolean(this.definition && !this.definition.generated);
+    }
+    get customClusters(): CustomClusters {
+        return this.zh.customClusters;
+    }
+    get otaExtraMetas(): zhc.Ota.ExtraMetas {
+        return typeof this.definition?.ota === "object" ? this.definition.ota : {};
+    }
+    get interviewed(): boolean {
+        return this.zh.interviewState === InterviewState.Successful || this.zh.interviewState === InterviewState.Failed;
    }

    constructor(device: zh.Device) {
@@ -22,69 +50,94 @@ export default class Device {
    }

    exposes(): zhc.Expose[] {
-        /* istanbul ignore if */
-        if (typeof this.definition.exposes == 'function') {
+        const exposes: zhc.Expose[] = [];
+        assert(this.definition, "Cannot retreive exposes before definition is resolved");
+        if (typeof this.definition.exposes === "function") {
            const options: KeyValue = this.options;
-            return this.definition.exposes(this.zh, options);
+            exposes.push(...this.definition.exposes(this.zh, options));
        } else {
-            return this.definition.exposes;
+            exposes.push(...this.definition.exposes);
        }
+        exposes.push(LINKQUALITY);
+        return exposes;
    }

-    async resolveDefinition(): Promise<void> {
-        if (!this.zh.interviewing && (!this.definition || this._definitionModelID !== this.zh.modelID)) {
+    async resolveDefinition(ignoreCache = false): Promise<void> {
+        if (this.interviewed && (!this.definition || this._definitionModelID !== this.zh.modelID || ignoreCache)) {
            this.definition = await zhc.findByDevice(this.zh, true);
            this._definitionModelID = this.zh.modelID;
        }
    }

    ensureInSettings(): void {
-        if (this.zh.type !== 'Coordinator' && !settings.getDevice(this.zh.ieeeAddr)) {
+        if (this.zh.type !== "Coordinator" && !settings.getDevice(this.zh.ieeeAddr)) {
            settings.addDevice(this.zh.ieeeAddr);
        }
    }

-    endpoint(key?: string | number): zh.Endpoint {
-        let endpoint: zh.Endpoint;
-        if (key == null || key == '') key = 'default';
+    endpoint(key?: string | number): zh.Endpoint | undefined {
+        let endpoint: zh.Endpoint | undefined;

-        if (!isNaN(Number(key))) {
+        if (!key) {
+            key = "default";
+        }
+
+        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 (ID) endpoint = this.zh.getEndpoint(ID);
-            else if (key === 'default') endpoint = this.zh.endpoints[0];
-            else return null;
+
+            if (ID) {
+                endpoint = this.zh.getEndpoint(ID);
+            } else if (key === "default") {
+                endpoint = this.zh.endpoints[0];
+            } else {
+                return undefined;
+            }
        } else {
-            /* istanbul ignore next */
-            if (key !== 'default') return null;
+            if (key !== "default") {
+                return undefined;
+            }
+
            endpoint = this.zh.endpoints[0];
        }

        return endpoint;
    }

-    endpointName(endpoint: zh.Endpoint): string {
-        let epName = null;
+    endpointName(endpoint: zh.Endpoint): string | 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) {
+                if (id === endpoint.ID) {
                    epName = name;
                }
            }
        }
-        /* istanbul ignore next */
-        return epName === 'default' ? null : epName;
+
+        /* v8 ignore next */
+        return epName === "default" ? undefined : epName;
    }

    getEndpointNames(): string[] {
-        return Object.keys(this.definition?.endpoint?.(this.zh) ?? {}).filter((name) => name !== 'default');
+        const names: string[] = [];
+
+        for (const name in this.definition?.endpoint?.(this.zh) ?? {}) {
+            if (name !== "default") {
+                names.push(name);
+            }
+        }
+
+        return names;
    }

-    isIkeaTradfri(): boolean {return this.zh.manufacturerID === 4476;}
+    isDevice(): this is Device {
+        return true;
+    }

-    isDevice(): this is Device {return true;}
-    /* istanbul ignore next */
-    isGroup(): this is Group {return false;}
+    isGroup(): this is Group {
+        return false;
+    }
 }
@@ -1,16 +1,24 @@
-/* eslint-disable brace-style */
-import * as settings from '../util/settings';
-import * as zhc from 'zigbee-herdsman-converters';
+import type * as zhc from "zigbee-herdsman-converters";
+
+import * as settings from "../util/settings";

 export default class Group {
    public zh: zh.Group;
-    private resolveDevice: (ieeeAddr: string) => Device;
+    private resolveDevice: (ieeeAddr: string) => Device | undefined;

-    get ID(): number {return this.zh.groupID;}
-    get options(): GroupOptions {return {...settings.getGroup(this.ID)};}
-    get name(): string {return this.options?.friendly_name || this.ID.toString();}
+    // biome-ignore lint/style/useNamingConvention: API
+    get ID(): number {
+        return this.zh.groupID;
+    }
+    get options(): GroupOptions {
+        // biome-ignore lint/style/noNonNullAssertion: Group always exists in settings
+        return {...settings.getGroup(this.ID)!};
+    }
+    get name(): string {
+        return this.options?.friendly_name || this.ID.toString();
+    }

-    constructor(group: zh.Group, resolveDevice: (ieeeAddr: string) => Device) {
+    constructor(group: zh.Group, resolveDevice: (ieeeAddr: string) => Device | undefined) {
        this.zh = group;
        this.resolveDevice = resolveDevice;
    }
@@ -19,14 +27,32 @@ export default class Group {
        return !!device.zh.endpoints.find((e) => this.zh.members.includes(e));
    }

-    membersDevices(): Device[] {
-        return this.zh.members.map((e) => this.resolveDevice(e.getDevice().ieeeAddr)).filter((d) => d);
+    *membersDevices(): Generator<Device> {
+        for (const member of this.zh.members) {
+            const resolvedDevice = this.resolveDevice(member.deviceIeeeAddress);
+
+            if (resolvedDevice) {
+                yield resolvedDevice;
+            }
+        }
    }

    membersDefinitions(): zhc.Definition[] {
-        return this.membersDevices().map((d) => d.definition).filter((d) => d);
+        const definitions: zhc.Definition[] = [];
+
+        for (const member of this.membersDevices()) {
+            if (member.definition) {
+                definitions.push(member.definition);
+            }
+        }
+
+        return definitions;
    }

-    isDevice(): this is Device {return false;}
-    isGroup(): this is Group {return true;}
+    isDevice(): this is Device {
+        return false;
+    }
+    isGroup(): this is Group {
+        return true;
+    }
 }
@@ -1,36 +1,70 @@
-import * as mqtt from 'mqtt';
-import logger from './util/logger';
-import * as settings from './util/settings';
-import utils from './util/utils';
-import fs from 'fs';
-import bind from 'bind-decorator';
-import type {QoS} from 'mqtt-packet';
+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";

-export default class MQTT {
-    private publishedTopics: Set<string> = new Set();
-    private connectionTimer: NodeJS.Timeout;
-    private client: mqtt.MqttClient;
+import logger from "./util/logger";
+import * as settings from "./util/settings";
+import utils from "./util/utils";
+
+const NS = "z2m:mqtt";
+
+export interface MqttPublishOptions {
+    clientOptions: IClientPublishOptions;
+    baseTopic: string;
+    skipLog: boolean;
+    skipReceive: boolean;
+    meta: {isEntityState?: boolean};
+}
+
+export default class Mqtt {
+    private publishedTopics = new Set<string>();
+    private connectionTimer?: NodeJS.Timeout;
+    private client!: MqttClient;
    private eventBus: EventBus;
-    private initialConnect = true;
-    private republishRetainedTimer: NodeJS.Timeout;
-    private retainedMessages: {[s: string]: {payload: string, options: MQTTOptions,
-        skipLog: boolean, skipReceive: boolean, topic: string, base: string}} = {};
+    private republishRetainedTimer?: NodeJS.Timeout;
+    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 = {
+            clientOptions: {},
+            baseTopic: settings.get().mqtt.base_topic,
+            skipLog: false,
+            skipReceive: true,
+            meta: {},
+        };
    }

    async connect(): Promise<void> {
        const mqttSettings = settings.get().mqtt;
+
        logger.info(`Connecting to MQTT server at ${mqttSettings.server}`);

-        const options: mqtt.IClientOptions = {
+        const options: IClientOptions = {
            will: {
                topic: `${settings.get().mqtt.base_topic}/bridge/state`,
-                payload: Buffer.from(utils.availabilityPayload('offline', settings.get())),
-                retain: settings.get().mqtt.force_disable_retain ? false : true,
+                payload: Buffer.from(JSON.stringify({state: "offline"})),
+                retain: !settings.get().mqtt.force_disable_retain,
                qos: 1,
            },
+            properties: {maximumPacketSize: mqttSettings.maximum_packet_size},
        };

        if (mqttSettings.version) {
@@ -58,8 +92,11 @@ export default class MQTT {
            logger.debug(`Using MQTT login with username: ${mqttSettings.user}`);
            options.username = mqttSettings.user;
            options.password = mqttSettings.password;
+        } else if (mqttSettings.user) {
+            logger.debug(`Using MQTT login with username only: ${mqttSettings.user}`);
+            options.username = mqttSettings.user;
        } else {
-            logger.debug(`Using MQTT anonymous login`);
+            logger.debug("Using MQTT anonymous login");
        }

        if (mqttSettings.client_id) {
@@ -67,131 +104,144 @@ export default class MQTT {
            options.clientId = mqttSettings.client_id;
        }

-        if (mqttSettings.hasOwnProperty('reject_unauthorized') && !mqttSettings.reject_unauthorized) {
-            logger.debug(`MQTT reject_unauthorized set false, ignoring certificate warnings.`);
+        if (mqttSettings.reject_unauthorized !== undefined && !mqttSettings.reject_unauthorized) {
+            logger.debug("MQTT reject_unauthorized set false, ignoring certificate warnings.");
            options.rejectUnauthorized = false;
        }

-        return new Promise((resolve, reject) => {
-            this.client = mqtt.connect(mqttSettings.server, options);
-            // @ts-ignore https://github.com/Koenkk/zigbee2mqtt/issues/9822
-            this.client.stream.setMaxListeners(0);
-            this.eventBus.onPublishAvailability(this, () => this.publishStateOnline());
+        this.client = await connectAsync(mqttSettings.server, options);

-            const onConnect = this.onConnect;
-            this.client.on('connect', async () => {
-                await onConnect();
-                resolve();
-            });
+        // https://github.com/Koenkk/zigbee2mqtt/issues/9822
+        this.client.stream.setMaxListeners(0);

-            this.client.on('error', (err) => {
-                logger.error(`MQTT error: ${err.message}`);
-                reject(err);
-            });
-            this.client.on('message', this.onMessage);
+        this.client.on("error", (err) => {
+            logger.error(`MQTT error: ${err.message}`);
        });
-    }

-    @bind private async onConnect(): Promise<void> {
-        // Set timer at interval to check if connected to MQTT server.
-        clearTimeout(this.connectionTimer);
-        this.connectionTimer = setInterval(() => {
-            if (this.client.reconnecting) {
-                logger.error('Not connected to MQTT server!');
-            }
-        }, utils.seconds(10));
-
-        logger.info('Connected to MQTT server');
-        await this.publishStateOnline();
-
-        if (!this.initialConnect) {
-            this.republishRetainedTimer = setTimeout(() => {
-                // Republish retained messages in case MQTT broker does not persist them.
-                // https://github.com/Koenkk/zigbee2mqtt/issues/9629
-                Object.values(this.retainedMessages).forEach((e) =>
-                    this.publish(e.topic, e.payload, e.options, e.base, e.skipLog, e.skipReceive));
-            }, 2000);
+        if (mqttSettings.version != null && mqttSettings.version >= 5) {
+            this.client.on("disconnect", (packet) => {
+                logger.error(`MQTT disconnect: reason ${packet.reasonCode} (${packet.properties?.reasonString})`);
+            });
        }

-        this.initialConnect = false;
-        this.subscribe(`${settings.get().mqtt.base_topic}/#`);
-    }
+        this.client.on("message", this.onMessage);

-    async publishStateOnline(): Promise<void> {
-        await this.publish('bridge/state', utils.availabilityPayload('online', settings.get()), {retain: true, qos: 0});
+        await this.onConnect();
+
+        this.client.on("connect", this.onConnect);
+
+        this.republishRetainedTimer = setTimeout(async () => {
+            // Republish retained messages in case MQTT broker does not persist them.
+            // https://github.com/Koenkk/zigbee2mqtt/issues/9629
+            for (const msg of Object.values(this.retainedMessages)) {
+                await this.publish(msg.topic, msg.payload, msg.options);
+            }
+        }, 2000);
+
+        // Set timer at interval to check if connected to MQTT server.
+        this.connectionTimer = setInterval(() => {
+            if (!this.isConnected()) {
+                logger.error("Not connected to MQTT server!");
+            }
+        }, utils.seconds(10));
    }

    async disconnect(): Promise<void> {
        clearTimeout(this.connectionTimer);
-        await this.publish('bridge/state', utils.availabilityPayload('offline', settings.get()),
-            {retain: true, qos: 0});
+        clearTimeout(this.republishRetainedTimer);
+
+        const stateData: Zigbee2MQTTAPI["bridge/state"] = {state: "offline"};
+
+        await this.publish("bridge/state", JSON.stringify(stateData), {clientOptions: {retain: true}});
        this.eventBus.removeListeners(this);
-        logger.info('Disconnecting from MQTT server');
-        this.client?.end();
+        logger.info("Disconnecting from MQTT server");
+        await this.client?.endAsync();
    }

-    subscribe(topic: string): void {
-        this.client.subscribe(topic);
+    async subscribe(topic: string): Promise<void> {
+        await this.client.subscribeAsync(topic);
+    }
+
+    async unsubscribe(topic: string): Promise<void> {
+        await this.client.unsubscribeAsync(topic);
+    }
+
+    @bind private async onConnect(): Promise<void> {
+        logger.info("Connected to MQTT server");
+
+        const stateData: Zigbee2MQTTAPI["bridge/state"] = {state: "online"};
+
+        await this.publish("bridge/state", JSON.stringify(stateData), {clientOptions: {retain: true}});
+        await this.subscribe(`${settings.get().mqtt.base_topic}/#`);
    }

    @bind public onMessage(topic: string, message: Buffer): void {
        // Since we subscribe to zigbee2mqtt/# we also receive the message we send ourselves, skip these.
        if (!this.publishedTopics.has(topic)) {
-            logger.debug(`Received MQTT message on '${topic}' with data '${message.toString()}'`);
+            logger.debug(() => `Received MQTT message on '${topic}' with data '${message.toString()}'`, NS);
            this.eventBus.emitMQTTMessage({topic, message: message.toString()});
        }

        if (this.republishRetainedTimer && topic === `${settings.get().mqtt.base_topic}/bridge/info`) {
            clearTimeout(this.republishRetainedTimer);
-            this.republishRetainedTimer = null;
+
+            this.republishRetainedTimer = undefined;
        }
    }

    isConnected(): boolean {
-        return this.client && !this.client.reconnecting;
+        return this.client && !this.client.reconnecting && !this.client.disconnecting && !this.client.disconnected;
    }

-    async publish(topic: string, payload: string, options: MQTTOptions={},
-        base=settings.get().mqtt.base_topic, skipLog=false, skipReceive=true,
-    ): Promise<void> {
-        const defaultOptions: {qos: QoS, retain: boolean} = {qos: 0, retain: false};
-        topic = `${base}/${topic}`;
+    async publish(topic: string, payload: string, options: Partial<MqttPublishOptions> = {}): Promise<void> {
+        if (topic.includes("+") || topic.includes("#")) {
+            // https://github.com/Koenkk/zigbee2mqtt/issues/26939#issuecomment-2772309646
+            logger.error(`Topic '${topic}' includes wildcard characters, skipping publish.`);
+            return;
+        }

-        if (skipReceive) {
+        const finalOptions = {...this.defaultPublishOptions, ...options};
+        topic = `${finalOptions.baseTopic}/${topic}`;
+
+        if (finalOptions.skipReceive) {
            this.publishedTopics.add(topic);
        }

-        if (options.retain) {
+        if (finalOptions.clientOptions.retain) {
            if (payload) {
-                this.retainedMessages[topic] =
-                    {payload, options, skipReceive, skipLog, topic: topic.substring(base.length + 1), base};
+                this.retainedMessages[topic] = {payload, options: finalOptions, topic: topic.substring(finalOptions.baseTopic.length + 1)};
            } else {
                delete this.retainedMessages[topic];
            }
        }

-        this.eventBus.emitMQTTMessagePublished({topic, payload, options: {...defaultOptions, ...options}});
+        this.eventBus.emitMQTTMessagePublished({topic, payload, options: finalOptions});

        if (!this.isConnected()) {
-            /* istanbul ignore else */
-            if (!skipLog) {
-                logger.error(`Not connected to MQTT server!`);
+            if (!finalOptions.skipLog) {
+                logger.error("Not connected to MQTT server!");
                logger.error(`Cannot send message: topic: '${topic}', payload: '${payload}`);
            }
+
            return;
        }

-        if (!skipLog) {
-            logger.debug(`MQTT publish: topic '${topic}', payload '${payload}'`);
+        if (!finalOptions.skipLog) {
+            logger.info(() => `MQTT publish: topic '${topic}', payload '${payload}'`, NS);
        }

-        const actualOptions: mqtt.IClientPublishOptions = {...defaultOptions, ...options};
+        let clientOptions: IClientPublishOptions = finalOptions.clientOptions;
        if (settings.get().mqtt.force_disable_retain) {
-            actualOptions.retain = false;
+            clientOptions = {...finalOptions.clientOptions, retain: false};
        }

-        return new Promise((resolve) => {
-            this.client.publish(topic, payload, actualOptions, () => resolve());
-        });
+        try {
+            await this.client.publishAsync(topic, payload, clientOptions);
+        } catch (error) {
+            if (!finalOptions.skipLog) {
+                logger.error(`MQTT server error: ${(error as Error).message}`);
+                logger.error(`Could not send message: topic: '${topic}', payload: '${payload}`);
+            }
+        }
    }
 }
@@ -1,24 +1,44 @@
-import logger from './util/logger';
-import data from './util/data';
-import * as settings from './util/settings';
-import utils from './util/utils';
-import fs from 'fs';
-import objectAssignDeep from 'object-assign-deep';
+import {existsSync, readFileSync, writeFileSync} from "node:fs";

-const saveInterval = 1000 * 60 * 5; // 5 minutes
+import objectAssignDeep from "object-assign-deep";

-const dontCacheProperties = [
-    'action', 'action_.*', 'button', 'button_left', 'button_right', 'click', 'forgotten', 'keyerror',
-    'step_size', 'transition_time', 'group_list', 'group_capacity', 'no_occupancy_since',
-    'step_mode', 'transition_time', 'duration', 'elapsed', 'from_side', 'to_side',
+import data from "./util/data";
+import logger from "./util/logger";
+import * as settings from "./util/settings";
+import utils from "./util/utils";
+
+const SAVE_INTERVAL = 1000 * 60 * 5; // 5 minutes
+const CACHE_IGNORE_PROPERTIES = [
+    "action",
+    "action_.*",
+    "button",
+    "button_left",
+    "button_right",
+    "forgotten",
+    "keyerror",
+    "step_size",
+    "transition_time",
+    "group_list",
+    "group_capacity",
+    "no_occupancy_since",
+    "step_mode",
+    "transition_time",
+    "duration",
+    "elapsed",
+    "from_side",
+    "to_side",
+    "illuminance_lux", // removed in z2m 2.0.0
 ];

 class State {
-    private state: {[s: string | number]: KeyValue} = {};
-    private file = data.joinPath('state.json');
-    private timer: NodeJS.Timeout = null;
+    private readonly state = new Map<string | number, KeyValue>();
+    private readonly file = data.joinPath("state.json");
+    private timer?: NodeJS.Timeout;

-    constructor(private readonly eventBus: EventBus, private readonly zigbee: Zigbee) {
+    constructor(
+        private readonly eventBus: EventBus,
+        private readonly zigbee: Zigbee,
+    ) {
        this.eventBus = eventBus;
        this.zigbee = zigbee;
    }
@@ -27,26 +47,40 @@ class State {
        this.load();

        // Save the state on every interval
-        this.timer = setInterval(() => this.save(), saveInterval);
+        this.timer = setInterval(() => this.save(), SAVE_INTERVAL);
    }

    stop(): void {
        // Remove any invalid states (ie when the device has left the network) when the system is stopped
-        Object.keys(this.state)
-            .filter((k) => typeof k === 'string' && !this.zigbee.resolveEntity(k)) // string key = ieeeAddr
-            .forEach((k) => delete this.state[k]);
+        for (const [key] of this.state) {
+            if (typeof key === "string" && key.startsWith("0x") && !this.zigbee.resolveEntity(key)) {
+                // string key = ieeeAddr
+                this.state.delete(key);
+            }
+        }

        clearTimeout(this.timer);
        this.save();
    }

+    clear(): void {
+        this.state.clear();
+    }
+
    private load(): void {
-        if (fs.existsSync(this.file)) {
+        this.state.clear();
+
+        if (existsSync(this.file)) {
            try {
-                this.state = JSON.parse(fs.readFileSync(this.file, 'utf8'));
+                const stateObj = JSON.parse(readFileSync(this.file, "utf8")) as KeyValue;
+
+                for (const key in stateObj) {
+                    this.state.set(key.startsWith("0x") ? key : Number.parseInt(key, 10), stateObj[key]);
+                }
+
                logger.debug(`Loaded state from file ${this.file}`);
-            } catch (e) {
-                logger.debug(`Failed to load state from file ${this.file} (corrupt file?)`);
+            } catch (error) {
+                logger.debug(`Failed to load state from file ${this.file} (corrupt file?) (${(error as Error).message})`);
            }
        } else {
            logger.debug(`Can't load state from file ${this.file} (doesn't exist)`);
@@ -56,40 +90,42 @@ class State {
    private save(): void {
        if (settings.get().advanced.cache_state_persistent) {
            logger.debug(`Saving state to file ${this.file}`);
-            const json = JSON.stringify(this.state, null, 4);
+
+            const json = JSON.stringify(Object.fromEntries(this.state), null, 4);
+
            try {
-                fs.writeFileSync(this.file, json, 'utf8');
-            } catch (e) {
-                logger.error(`Failed to write state to '${this.file}' (${e.message})`);
+                writeFileSync(this.file, json, "utf8");
+            } catch (error) {
+                logger.error(`Failed to write state to '${this.file}' (${error})`);
            }
        } else {
-            logger.debug(`Not saving state`);
+            logger.debug("Not saving state");
        }
    }

    exists(entity: Device | Group): boolean {
-        return this.state.hasOwnProperty(entity.ID);
+        return this.state.has(entity.ID);
    }

    get(entity: Group | Device): KeyValue {
-        return this.state[entity.ID] || {};
+        return this.state.get(entity.ID) || {};
    }

-    set(entity: Group | Device, update: KeyValue, reason: string=null): KeyValue {
-        const fromState = this.state[entity.ID] || {};
+    set(entity: Group | Device, update: KeyValue, reason?: string): KeyValue {
+        const fromState = this.state.get(entity.ID) || {};
        const toState = objectAssignDeep({}, fromState, update);
        const newCache = {...toState};
        const entityDontCacheProperties = entity.options.filtered_cache || [];

-        utils.filterProperties(dontCacheProperties.concat(entityDontCacheProperties), newCache);
+        utils.filterProperties(CACHE_IGNORE_PROPERTIES.concat(entityDontCacheProperties), newCache);

-        this.state[entity.ID] = newCache;
+        this.state.set(entity.ID, newCache);
        this.eventBus.emitStateChange({entity, from: fromState, to: toState, reason, update});
        return toState;
    }

-    remove(ID: string | number): void {
-        delete this.state[ID];
+    remove(id: string | number): boolean {
+        return this.state.delete(id);
    }
 }

@@ -0,0 +1,970 @@
+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";
+export type * as Zdo from "zigbee-herdsman/dist/zspec/zdo";
+
+export type Zigbee2MQTTFeatures = {
+    base: Base;
+    switch: zigbeeHerdsmanConverter.Switch;
+    lock: zigbeeHerdsmanConverter.Lock;
+    binary: zigbeeHerdsmanConverter.Binary;
+    list: zigbeeHerdsmanConverter.List;
+    numeric: zigbeeHerdsmanConverter.Numeric;
+    enum: zigbeeHerdsmanConverter.Enum;
+    text: zigbeeHerdsmanConverter.Text;
+    composite: zigbeeHerdsmanConverter.Composite;
+    light: zigbeeHerdsmanConverter.Light;
+    cover: zigbeeHerdsmanConverter.Cover;
+    fan: zigbeeHerdsmanConverter.Fan;
+    climate: zigbeeHerdsmanConverter.Climate;
+};
+
+import type {UpdatePayload} from "../extension/otaUpdate";
+import type {LogLevel, schemaJson} from "../util/settings";
+
+// biome-ignore lint/suspicious/noExplicitAny: API
+type KeyValue = Record<string, any>;
+
+export interface Zigbee2MQTTDeviceOptions {
+    disabled?: boolean;
+    retention?: number;
+    availability?:
+        | boolean
+        | {
+              timeout: number;
+              max_jitter?: number;
+              backoff?: boolean;
+              pause_on_backoff_gt?: number;
+          };
+    optimistic?: boolean;
+    debounce?: number;
+    debounce_ignore?: string[];
+    throttle?: number;
+    filtered_attributes?: string[];
+    filtered_cache?: string[];
+    filtered_optimistic?: string[];
+    icon?: string;
+    homeassistant?: KeyValue;
+    friendly_name: string;
+    description?: string;
+    qos?: 0 | 1 | 2;
+}
+
+export interface Zigbee2MQTTGroupOptions {
+    ID: number;
+    optimistic?: boolean;
+    off_state?: "all_members_off" | "last_member_state";
+    filtered_attributes?: string[];
+    filtered_cache?: string[];
+    filtered_optimistic?: string[];
+    homeassistant?: KeyValue;
+    friendly_name: string;
+    description?: string;
+    qos?: 0 | 1 | 2;
+}
+
+export interface Zigbee2MQTTSettings {
+    version?: number;
+    /** only used internally during startup, removed on successful Z2M start */
+    onboarding?: true;
+    homeassistant: {
+        enabled: boolean;
+        discovery_topic: string;
+        status_topic: string;
+        experimental_event_entities: boolean;
+        legacy_action_sensor: boolean;
+    };
+    availability: {
+        enabled: boolean;
+        active: {
+            timeout: number;
+            max_jitter: number;
+            backoff: boolean;
+            pause_on_backoff_gt: number;
+        };
+        passive: {timeout: number};
+    };
+    mqtt: {
+        base_topic: string;
+        include_device_information: boolean;
+        force_disable_retain: boolean;
+        version?: 3 | 4 | 5;
+        user?: string;
+        password?: string;
+        server: string;
+        ca?: string;
+        keepalive?: number;
+        key?: string;
+        cert?: string;
+        client_id?: string;
+        reject_unauthorized?: boolean;
+        maximum_packet_size: number;
+    };
+    serial: {
+        disable_led: boolean;
+        port?: string;
+        adapter?: "deconz" | "zstack" | "ezsp" | "zigate" | "ember" | "zboss" | "zoh";
+        baudrate?: number;
+        rtscts?: boolean;
+    };
+    passlist: string[];
+    blocklist: string[];
+    map_options: {
+        graphviz: {
+            colors: {
+                fill: {
+                    enddevice: string;
+                    coordinator: string;
+                    router: string;
+                };
+                font: {
+                    coordinator: string;
+                    router: string;
+                    enddevice: string;
+                };
+                line: {
+                    active: string;
+                    inactive: string;
+                };
+            };
+        };
+    };
+    ota: {
+        update_check_interval: number;
+        disable_automatic_update_check: boolean;
+        zigbee_ota_override_index_location?: string;
+        image_block_response_delay?: number;
+        default_maximum_data_size?: number;
+    };
+    frontend: {
+        enabled: boolean;
+        package: "zigbee2mqtt-frontend" | "zigbee2mqtt-windfront";
+        auth_token?: string;
+        host?: string;
+        port: number;
+        base_url: string;
+        url?: string;
+        ssl_cert?: string;
+        ssl_key?: string;
+        notification_filter?: string[];
+    };
+    devices: {[s: string]: Zigbee2MQTTDeviceOptions};
+    groups: {[s: string]: Omit<Zigbee2MQTTGroupOptions, "ID">};
+    device_options: KeyValue;
+    advanced: {
+        log_rotation: boolean;
+        log_console_json: boolean;
+        log_symlink_current: boolean;
+        log_output: ("console" | "file" | "syslog")[];
+        log_directory: string;
+        log_file: string;
+        log_level: LogLevel;
+        log_namespaced_levels: Record<string, LogLevel>;
+        log_syslog: KeyValue;
+        log_debug_to_mqtt_frontend: boolean;
+        log_debug_namespace_ignore: string;
+        log_directories_to_keep: number;
+        pan_id: number | "GENERATE";
+        ext_pan_id: number[] | "GENERATE";
+        channel: number;
+        adapter_concurrent?: number;
+        adapter_delay?: number;
+        cache_state: boolean;
+        cache_state_persistent: boolean;
+        cache_state_send_on_startup: boolean;
+        last_seen: "disable" | "ISO_8601" | "ISO_8601_local" | "epoch";
+        elapsed: boolean;
+        network_key: number[] | "GENERATE";
+        timestamp_format: string;
+        output: "json" | "attribute" | "attribute_and_json";
+        transmit_power?: number;
+    };
+    health: {
+        /** in minutes */
+        interval: number;
+        reset_on_check: boolean;
+    };
+}
+
+export interface Zigbee2MQTTScene {
+    id: number;
+    name: string;
+}
+
+export interface Zigbee2MQTTDeviceEndpoint {
+    bindings: Zigbee2MQTTDeviceEndpointBinding[];
+    configured_reportings: Zigbee2MQTTDeviceEndpointConfiguredReporting[];
+    clusters: {input: string[]; output: string[]};
+    scenes: Zigbee2MQTTScene[];
+}
+
+export interface Zigbee2MQTTDeviceEndpointBinding {
+    cluster: string;
+    target: Zigbee2MQTTDeviceEndpointBindingTarget;
+}
+
+export type Zigbee2MQTTDeviceEndpointBindingTarget = {type: "endpoint"; ieee_address: string; endpoint: number} | {type: "group"; id: number};
+
+export interface Zigbee2MQTTDeviceEndpointConfiguredReporting {
+    cluster: string;
+    attribute: string | number;
+    minimum_report_interval: number;
+    maximum_report_interval: number;
+    reportable_change: number;
+}
+
+export interface Zigbee2MQTTDeviceDefinition {
+    model: string;
+    vendor: string;
+    description: string;
+    exposes: zigbeeHerdsmanConverter.Expose[];
+    supports_ota: boolean;
+    options: zigbeeHerdsmanConverter.Option[];
+    icon: string;
+}
+
+export interface Zigbee2MQTTDevice {
+    ieee_address: zigbeeHerdsman.Models.Device["ieeeAddr"];
+    type: zigbeeHerdsman.Models.Device["type"];
+    network_address: zigbeeHerdsman.Models.Device["networkAddress"];
+    supported: boolean;
+    friendly_name: string;
+    disabled: boolean;
+    description?: string;
+    definition?: Zigbee2MQTTDeviceDefinition;
+    power_source: zigbeeHerdsman.Models.Device["powerSource"];
+    software_build_id: zigbeeHerdsman.Models.Device["softwareBuildID"];
+    date_code: zigbeeHerdsman.Models.Device["dateCode"];
+    model_id: zigbeeHerdsman.Models.Device["modelID"];
+    interviewing: boolean;
+    interview_completed: boolean;
+    interview_state: zigbeeHerdsman.Models.Device["interviewState"];
+    manufacturer: zigbeeHerdsman.Models.Device["manufacturerName"];
+    endpoints: Record<number, Zigbee2MQTTDeviceEndpoint>;
+}
+
+export interface Zigbee2MQTTGroupMember {
+    ieee_address: zigbeeHerdsman.Models.Device["ieeeAddr"];
+    endpoint: number;
+}
+
+export interface Zigbee2MQTTGroup {
+    id: number;
+    friendly_name: "default_bind_group" | string;
+    description?: string;
+    scenes: Zigbee2MQTTScene[];
+    members: Zigbee2MQTTGroupMember[];
+}
+
+export interface Zigbee2MQTTNetworkMap {
+    nodes: {
+        ieeeAddr: string;
+        friendlyName: string;
+        type: string;
+        networkAddress: number;
+        manufacturerName?: string;
+        modelID?: string;
+        failed?: string[];
+        lastSeen?: number;
+        definition?: {model: string; vendor: string; supports: string; description: string};
+    }[];
+    links: {
+        source: {ieeeAddr: string; networkAddress: number};
+        target: {ieeeAddr: string; networkAddress: number};
+        linkquality: number;
+        depth: number;
+        routes: {
+            destinationAddress: number;
+            status: string;
+            nextHop: number;
+        }[];
+        sourceIeeeAddr: string;
+        targetIeeeAddr: string;
+        sourceNwkAddr: number;
+        lqi: number;
+        relationship: number;
+    }[];
+}
+
+/**
+ * Zigbee2MQTT state/request/response API endpoints
+ */
+export interface Zigbee2MQTTAPI {
+    "bridge/logging": {
+        message: string;
+        level: LogLevel;
+        namespace: string;
+    };
+
+    "bridge/state": {
+        state: "online" | "offline";
+    };
+
+    "bridge/definitions": {
+        clusters: Readonly<Record<ClusterName, Readonly<ClusterDefinition>>>;
+        custom_clusters: Record<string, CustomClusters>;
+    };
+
+    "bridge/event":
+        | {
+              type: "device_leave" | "device_joined" | "device_announce";
+              data: {
+                  friendly_name: string;
+                  ieee_address: string;
+              };
+          }
+        | {
+              type: "device_interview";
+              data:
+                  | {
+                        friendly_name: string;
+                        ieee_address: string;
+                        status: "started" | "failed";
+                    }
+                  | {
+                        friendly_name: string;
+                        ieee_address: string;
+                        status: "successful";
+                        supported: boolean;
+                        definition: Zigbee2MQTTDeviceDefinition | undefined;
+                    };
+          };
+
+    "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};
+        zigbee_herdsman: {version: string};
+        coordinator: {
+            ieee_address: string;
+            type: string;
+            meta: {
+                [s: string]: number | string;
+            };
+        };
+        network: {
+            pan_id: number;
+            /** `0x${string}` 8-len */
+            extended_pan_id: string;
+            channel: number;
+        };
+        log_level: "debug" | "info" | "warning" | "error";
+        permit_join: boolean;
+        permit_join_end: number | undefined;
+        restart_required: boolean;
+        config: Zigbee2MQTTSettings;
+        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[];
+
+    "bridge/converters": {name: string; code: string}[];
+
+    "bridge/extensions": {name: string; code: string}[];
+
+    "bridge/request/permit_join":
+        | {
+              /** [0-254], 0 meaning disable */
+              time: number;
+              device?: string;
+          }
+        | `${number}`;
+
+    "bridge/response/permit_join": {
+        /** [0-254], 0 meaning disable */
+        time: number;
+        device?: string;
+    };
+
+    "bridge/request/health_check": "";
+
+    "bridge/response/health_check": {
+        /** XXX: currently always returns true */
+        healthy: boolean;
+    };
+
+    "bridge/request/coordinator_check": "";
+
+    "bridge/response/coordinator_check": {
+        missing_routers: {
+            ieee_address: string;
+            friendly_name: string;
+        }[];
+    };
+
+    "bridge/request/restart": "";
+
+    "bridge/response/restart": Record<string, never>;
+
+    "bridge/request/networkmap":
+        | {
+              type: "raw" | "graphviz" | "plantuml";
+              routes: boolean;
+          }
+        | "raw"
+        | "graphviz"
+        | "plantuml";
+
+    "bridge/response/networkmap":
+        | {
+              type: "raw";
+              routes: boolean;
+              value: Zigbee2MQTTNetworkMap;
+          }
+        | {
+              type: "graphviz" | "plantuml";
+              routes: boolean;
+              value: string;
+          };
+
+    "bridge/request/extension/save": {
+        name: string;
+        code: string;
+    };
+
+    "bridge/response/extension/save": Record<string, never>;
+
+    "bridge/request/extension/remove": {
+        name: string;
+    };
+
+    "bridge/response/extension/remove": Record<string, never>;
+
+    "bridge/request/converter/save": {
+        name: string;
+        code: string;
+    };
+
+    "bridge/response/converter/save": Record<string, never>;
+
+    "bridge/request/converter/remove": {
+        name: string;
+    };
+
+    "bridge/response/converter/remove": Record<string, never>;
+
+    "bridge/request/backup": "";
+
+    "bridge/response/backup": {
+        /** base64 encoded ZIP archive */
+        zip: string;
+    };
+
+    "bridge/request/install_code/add": {
+        value: string;
+    };
+
+    "bridge/response/install_code/add": {
+        value: string;
+    };
+
+    /**
+     * Applied on-the-fly:
+     * - newSettings.homeassistant
+     * - newSettings.advanced?.log_level
+     * - newSettings.advanced?.log_namespaced_levels
+     * - newSettings.advanced?.log_debug_namespace_ignore
+     */
+    "bridge/request/options": {
+        options: Record<string, unknown>;
+    };
+
+    "bridge/response/options": {
+        restart_required: boolean;
+    };
+
+    "bridge/request/device/bind": {
+        from: string;
+        from_endpoint: string | number | "default";
+        to: string | number;
+        to_endpoint?: string | number;
+        clusters?: string[];
+        skip_disable_reporting?: boolean;
+    };
+
+    "bridge/response/device/bind": {
+        from: string;
+        from_endpoint: string | number;
+        to: string | number;
+        to_endpoint: string | number | undefined;
+        clusters: string[];
+        failed: string[];
+    };
+
+    "bridge/request/device/unbind": {
+        from: string;
+        from_endpoint: string | number | "default";
+        to: string | number;
+        to_endpoint?: string | number;
+        clusters?: string[];
+        skip_disable_reporting?: boolean;
+    };
+
+    "bridge/response/device/unbind": {
+        from: string;
+        from_endpoint: string | number;
+        to: string | number;
+        to_endpoint: string | number | undefined;
+        clusters: string[];
+        failed: string[];
+    };
+
+    "bridge/request/device/configure":
+        | {
+              id: string | number;
+          }
+        | string;
+
+    "bridge/response/device/configure": {
+        id: string | number;
+    };
+
+    "bridge/request/device/remove": {
+        id: string;
+        block?: boolean;
+        force?: boolean;
+    };
+
+    "bridge/response/device/remove": {
+        id: string;
+        block: boolean;
+        force: boolean;
+    };
+
+    "bridge/request/device/ota_update/check": {
+        id: string;
+    };
+
+    "bridge/request/device/ota_update/check/downgrade": {
+        id: string;
+    };
+
+    "bridge/response/device/ota_update/check": {
+        id: string;
+        update_available: boolean;
+    };
+
+    "bridge/request/device/ota_update/update": {
+        id: string;
+    };
+
+    "bridge/request/device/ota_update/update/downgrade": {
+        id: string;
+    };
+
+    "bridge/response/device/ota_update/update": {
+        id: string;
+        from:
+            | {
+                  software_build_id: string;
+                  date_code: string;
+              }
+            | undefined;
+        to:
+            | {
+                  software_build_id: string;
+                  date_code: string;
+              }
+            | undefined;
+    };
+
+    "bridge/request/device/ota_update/schedule": {
+        id: string;
+    };
+
+    "bridge/request/device/ota_update/schedule/downgrade": {
+        id: string;
+    };
+
+    "bridge/response/device/ota_update/schedule": {
+        id: string;
+    };
+
+    "bridge/request/device/ota_update/unschedule": {
+        id: string;
+    };
+
+    "bridge/response/device/ota_update/unschedule": {
+        id: string;
+    };
+
+    "bridge/request/device/interview": {
+        id: string | number;
+    };
+
+    "bridge/response/device/interview": {
+        id: string | number;
+    };
+
+    "bridge/request/device/generate_external_definition": {
+        id: string | number;
+    };
+
+    "bridge/response/device/generate_external_definition": {
+        id: string | number;
+        source: string;
+    };
+
+    "bridge/request/device/options": {
+        id: string;
+        options: Record<string, unknown>;
+    };
+
+    "bridge/response/device/options": {
+        id: string;
+        from: Record<string, unknown>;
+        to: Record<string, unknown>;
+        restart_required: boolean;
+    };
+
+    "bridge/request/device/rename":
+        | {
+              last: true;
+              from?: string;
+              to: string;
+              homeassistant_rename?: boolean;
+          }
+        | {
+              last: false | undefined;
+              from: string;
+              to: string;
+              homeassistant_rename?: boolean;
+          };
+
+    "bridge/response/device/rename": {
+        from: string;
+        to: string;
+        homeassistant_rename: boolean;
+    };
+
+    "bridge/request/device/configure_reporting": {
+        id: string;
+        endpoint: string | number;
+        cluster: string | number;
+        attribute: string | number | {ID: number; type: number};
+        minimum_report_interval: number;
+        maximum_report_interval: number;
+        reportable_change: number;
+        option: Record<string, unknown>;
+    };
+
+    "bridge/response/device/configure_reporting": {
+        id: string;
+        endpoint: string | number;
+        cluster: string | number;
+        attribute: string | number | {ID: number; type: number};
+        minimum_report_interval: number;
+        maximum_report_interval: number;
+        reportable_change: number;
+    };
+
+    "bridge/request/group/remove": {
+        id: string;
+        force?: boolean;
+    };
+
+    "bridge/response/group/remove": {
+        id: string;
+        force: boolean;
+    };
+
+    "bridge/request/group/add": {
+        friendly_name: string;
+        id?: string;
+    };
+
+    "bridge/response/group/add": {
+        friendly_name: string;
+        id: number;
+    };
+
+    "bridge/request/group/rename": {
+        from: string;
+        to: string;
+        homeassistant_rename?: boolean;
+    };
+
+    "bridge/response/group/rename": {
+        from: string;
+        to: string;
+        homeassistant_rename: boolean;
+    };
+
+    "bridge/request/group/options": {
+        id: string;
+        options: Record<string, unknown>;
+    };
+
+    "bridge/response/group/options": {
+        id: string;
+        from: Record<string, unknown>;
+        to: Record<string, unknown>;
+        restart_required: boolean;
+    };
+
+    "bridge/request/group/members/add": {
+        device: string;
+        group: string;
+        endpoint: string | number | "default";
+        skip_disable_reporting?: boolean;
+    };
+
+    "bridge/response/group/members/add": {
+        device: string;
+        group: string;
+        endpoint: string | number | "default";
+    };
+
+    "bridge/request/group/members/remove": {
+        device: string;
+        group: string;
+        endpoint: string | number | "default";
+        skip_disable_reporting?: boolean;
+    };
+
+    "bridge/response/group/members/remove": {
+        device: string;
+        group: string;
+        endpoint: string | number | "default";
+    };
+
+    "bridge/request/group/members/remove_all": {
+        device: string;
+        endpoint: string | number | "default";
+        skip_disable_reporting?: boolean;
+    };
+
+    "bridge/response/group/members/remove_all": {
+        device: string;
+        endpoint: string | number | "default";
+    };
+
+    "bridge/request/touchlink/factory_reset":
+        | {
+              ieee_address: string;
+              channel: number;
+          }
+        | "";
+
+    "bridge/response/touchlink/factory_reset":
+        | {
+              ieee_address: string;
+              channel: number;
+          }
+        | Record<string, never>;
+
+    "bridge/request/touchlink/scan": "";
+
+    "bridge/response/touchlink/scan": {
+        found: {
+            ieee_address: string;
+            channel: number;
+        }[];
+    };
+
+    "bridge/request/touchlink/identify": {
+        ieee_address: string;
+        channel: number;
+    };
+
+    "bridge/response/touchlink/identify": {
+        ieee_address: string;
+        channel: number;
+    };
+
+    /**
+     * entity state response
+     */
+    "{friendlyName}": {
+        [key: string]: unknown;
+        update?: UpdatePayload["update"];
+    };
+
+    "{friendlyName}/availability": {
+        state: "online" | "offline";
+    };
+
+    /** entity set request (tries to match endpoint to definition, else uses "default") */
+    "{friendlyNameOrId}/set": {
+        [attribute: string]: {[key: string]: unknown} | string | boolean;
+    };
+    /** entity set request (tries to match endpoint to definition, else uses "default") */
+    "{friendlyNameOrId}/set/{attribute}": {
+        [key: string]: unknown;
+    };
+    /** entity set request */
+    "{friendlyNameOrId}/{endpoint}/set": {
+        [attribute: string]: {[key: string]: unknown} | string | boolean;
+    };
+    /** entity set request */
+    "{friendlyNameOrId}/{endpoint}/set/{attribute}": {
+        [key: string]: unknown;
+    };
+
+    /** entity get request (tries to match endpoint to definition, else uses "default") */
+    "{friendlyNameOrId}/get": {
+        [attribute: string]: {[key: string]: unknown} | string | boolean;
+    };
+    /** entity get request (tries to match endpoint to definition, else uses "default") */
+    "{friendlyNameOrId}/get/{attribute}": {
+        [key: string]: unknown;
+    };
+    /** entity get request */
+    "{friendlyNameOrId}/{endpoint}/get": {
+        [attribute: string]: {[key: string]: unknown} | string | boolean;
+    };
+    /** entity get request */
+    "{friendlyNameOrId}/{endpoint}/get/{attribute}": {
+        [key: string]: unknown;
+    };
+}
+
+export type Zigbee2MQTTRequestEndpoints =
+    | "bridge/request/permit_join"
+    | "bridge/request/health_check"
+    | "bridge/request/coordinator_check"
+    | "bridge/request/restart"
+    | "bridge/request/networkmap"
+    | "bridge/request/extension/save"
+    | "bridge/request/extension/remove"
+    | "bridge/request/converter/save"
+    | "bridge/request/converter/remove"
+    | "bridge/request/backup"
+    | "bridge/request/install_code/add"
+    | "bridge/request/options"
+    | "bridge/request/device/bind"
+    | "bridge/request/device/unbind"
+    | "bridge/request/device/configure"
+    | "bridge/request/device/remove"
+    | "bridge/request/device/ota_update/check"
+    | "bridge/request/device/ota_update/check/downgrade"
+    | "bridge/request/device/ota_update/update"
+    | "bridge/request/device/ota_update/update/downgrade"
+    | "bridge/request/device/ota_update/schedule"
+    | "bridge/request/device/ota_update/schedule/downgrade"
+    | "bridge/request/device/ota_update/unschedule"
+    | "bridge/request/device/interview"
+    | "bridge/request/device/generate_external_definition"
+    | "bridge/request/device/options"
+    | "bridge/request/device/rename"
+    | "bridge/request/device/configure_reporting"
+    | "bridge/request/group/remove"
+    | "bridge/request/group/add"
+    | "bridge/request/group/rename"
+    | "bridge/request/group/options"
+    | "bridge/request/group/members/add"
+    | "bridge/request/group/members/remove"
+    | "bridge/request/group/members/remove_all"
+    | "bridge/request/touchlink/factory_reset"
+    | "bridge/request/touchlink/scan"
+    | "bridge/request/touchlink/identify"
+    | "{friendlyNameOrId}/set"
+    | "{friendlyNameOrId}/set/{attribute}"
+    | "{friendlyNameOrId}/{endpoint}/set"
+    | "{friendlyNameOrId}/{endpoint}/set/{attribute}"
+    | "{friendlyNameOrId}/get"
+    | "{friendlyNameOrId}/get/{attribute}"
+    | "{friendlyNameOrId}/{endpoint}/get"
+    | "{friendlyNameOrId}/{endpoint}/get/{attribute}";
+
+export type Zigbee2MQTTResponseEndpoints =
+    | "bridge/response/permit_join"
+    | "bridge/response/health_check"
+    | "bridge/response/coordinator_check"
+    | "bridge/response/restart"
+    | "bridge/response/networkmap"
+    | "bridge/response/extension/save"
+    | "bridge/response/extension/remove"
+    | "bridge/response/converter/save"
+    | "bridge/response/converter/remove"
+    | "bridge/response/backup"
+    | "bridge/response/install_code/add"
+    | "bridge/response/options"
+    | "bridge/response/device/bind"
+    | "bridge/response/device/unbind"
+    | "bridge/response/device/configure"
+    | "bridge/response/device/remove"
+    | "bridge/response/device/ota_update/check"
+    | "bridge/response/device/ota_update/update"
+    | "bridge/response/device/ota_update/schedule"
+    | "bridge/response/device/ota_update/unschedule"
+    | "bridge/response/device/interview"
+    | "bridge/response/device/generate_external_definition"
+    | "bridge/response/device/options"
+    | "bridge/response/device/rename"
+    | "bridge/response/device/configure_reporting"
+    | "bridge/response/group/remove"
+    | "bridge/response/group/add"
+    | "bridge/response/group/rename"
+    | "bridge/response/group/options"
+    | "bridge/response/group/members/add"
+    | "bridge/response/group/members/remove"
+    | "bridge/response/group/members/remove_all"
+    | "bridge/response/touchlink/factory_reset"
+    | "bridge/response/touchlink/scan"
+    | "bridge/response/touchlink/identify";
+
+export type Zigbee2MQTTRequest<T extends Zigbee2MQTTRequestEndpoints> = {
+    transaction?: string;
+} & Zigbee2MQTTAPI[T];
+
+export type Zigbee2MQTTResponseOK<T extends Zigbee2MQTTResponseEndpoints> = {
+    status: "ok";
+    data: Zigbee2MQTTAPI[T];
+    transaction?: string;
+};
+
+export type Zigbee2MQTTResponseError = {
+    status: "error";
+    data: Record<string, never>;
+    error: string;
+    transaction?: string;
+};
+
+export type Zigbee2MQTTResponse<T extends Zigbee2MQTTResponseEndpoints> = Zigbee2MQTTResponseOK<T> | Zigbee2MQTTResponseError;
@@ -1,3 +1,3 @@
-declare module 'json-stable-stringify-without-jsonify' {
+declare module "json-stable-stringify-without-jsonify" {
    export default function (obj: unknown): string;
 }
@@ -1,3 +0,0 @@
-declare module 'mkdir-recursive' {
-    export function mkdirSync(path: string): void;
-}
@@ -1,44 +1,20 @@
-/* eslint-disable camelcase */
-import type {
-    Device as ZHDevice,
-    Group as ZHGroup,
-    Endpoint as ZHEndpoint,
-} from 'zigbee-herdsman/dist/controller/model';
+import type {AdapterTypes as ZHAdapterTypes, Events as ZHEvents, Models as ZHModels} from "zigbee-herdsman";
+import type {Cluster as ZHCluster, FrameControl as ZHFrameControl} from "zigbee-herdsman/dist/zspec/zcl/definition/tstype";

-import type {
-    NetworkParameters as ZHNetworkParameters,
-    CoordinatorVersion as ZHCoordinatorVersion,
-    LQI as ZHLQI,
-    RoutingTable as ZHRoutingTable,
-    RoutingTableEntry as ZHRoutingTableEntry,
-} from 'zigbee-herdsman/dist/adapter/tstype';
-
-import type {
-    Cluster as ZHCluster,
-} from 'zigbee-herdsman/dist/zcl/tstype';
-
-import type {
-    FrameControl as ZHFrameControl,
-} from 'zigbee-herdsman/dist/zcl';
-
-import type * as zhc from 'zigbee-herdsman-converters';
-
-import type * as ZHEvents from 'zigbee-herdsman/dist/controller/events';
-
-import type TypeEventBus from 'lib/eventBus';
-import type TypeMQTT from 'lib/mqtt';
-import type TypeState from 'lib/state';
-import type TypeZigbee from 'lib/zigbee';
-import type TypeDevice from 'lib/model/device';
-import type TypeGroup from 'lib/model/group';
-import type TypeExtension from 'lib/extension/extension';
-
-import type {QoS} from 'mqtt-packet';
+import type TypeEventBus from "../eventBus";
+import type TypeExtension from "../extension/extension";
+import type TypeDevice from "../model/device";
+import type TypeGroup from "../model/group";
+import type TypeMqtt from "../mqtt";
+import type {MqttPublishOptions} from "../mqtt";
+import type TypeState from "../state";
+import type TypeZigbee from "../zigbee";
+import type {Zigbee2MQTTDeviceOptions, Zigbee2MQTTGroupOptions, Zigbee2MQTTSettings} from "./api";

 declare global {
    // Define some class types as global
    type EventBus = TypeEventBus;
-    type MQTT = TypeMQTT;
+    type Mqtt = TypeMqtt;
    type Zigbee = TypeZigbee;
    type Group = TypeGroup;
    type Device = TypeDevice;
@@ -46,213 +22,79 @@ declare global {
    type Extension = TypeExtension;

    // Types
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    type ExternalDefinition = zhc.Definition & {homeassistant: any};
-    interface MQTTResponse {data: KeyValue, status: 'error' | 'ok', error?: string, transaction?: string}
-    interface MQTTOptions {qos?: QoS, retain?: boolean, properties?: {messageExpiryInterval: number}}
-    type Scene = {id: number, name: string};
-    type StateChangeReason = 'publishDebounce' | 'groupOptimistic' | 'lastSeenChanged' | 'publishCached';
-    type PublishEntityState = (entity: Device | Group, payload: KeyValue,
-        stateChangeReason?: StateChangeReason) => Promise<void>;
-    type RecursivePartial<T> = {[P in keyof T]?: RecursivePartial<T[P]>;};
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    interface KeyValue {[s: string]: any}
+    type StateChangeReason = "publishDebounce" | "groupOptimistic" | "lastSeenChanged" | "publishCached" | "publishThrottle";
+    type PublishEntityState = (entity: Device | Group, payload: KeyValue, stateChangeReason?: StateChangeReason) => Promise<void>;
+    type RecursivePartial<T> = {[P in keyof T]?: RecursivePartial<T[P]>};
+    type MakePartialExcept<T, K extends keyof T> = Partial<Omit<T, K>> & Pick<T, K>;
+    interface KeyValue {
+        // biome-ignore lint/suspicious/noExplicitAny: API
+        [s: string]: any;
+    }

    // zigbee-herdsman
    namespace zh {
-        type Endpoint = ZHEndpoint;
-        type Device = ZHDevice;
-        type Group = ZHGroup;
-        type LQI = ZHLQI;
-        type RoutingTable = ZHRoutingTable;
-        type RoutingTableEntry = ZHRoutingTableEntry;
-        type CoordinatorVersion = ZHCoordinatorVersion;
-        type NetworkParameters = ZHNetworkParameters;
-        type Cluster = ZHCluster;
+        type Endpoint = ZHModels.Endpoint;
+        type Device = ZHModels.Device;
+        type Group = ZHModels.Group;
+        // biome-ignore lint/style/useNamingConvention: API
+        type LQI = ZHAdapterTypes.Lqi;
+        type RoutingTable = ZHAdapterTypes.RoutingTable;
+        type CoordinatorVersion = ZHAdapterTypes.CoordinatorVersion;
+        type NetworkParameters = ZHAdapterTypes.NetworkParameters;
        interface Bind {
-            cluster: zh.Cluster;
+            cluster: ZHCluster;
            target: zh.Endpoint | zh.Group;
        }
    }

    namespace eventdata {
-        type EntityRenamed = { entity: Device | Group, homeAssisantRename: boolean, from: string, to: string };
-        type DeviceRemoved = { ieeeAddr: string, name: string };
-        type MQTTMessage = { topic: string, message: string };
-        type MQTTMessagePublished = { topic: string, payload: string, options: {retain: boolean, qos: number} };
+        type EntityRenamed = {entity: Device | Group; homeAssisantRename: boolean; from: string; to: string};
+        type EntityRemoved = {id: string; name: string; type: "device"} | {id: number; name: string; type: "group"};
+        type MQTTMessage = {topic: string; message: string};
+        type MQTTMessagePublished = {topic: string; payload: string; options: MqttPublishOptions};
        type StateChange = {
-            entity: Device | Group, from: KeyValue, to: KeyValue, reason: string | null, update: KeyValue };
+            entity: Device | Group;
+            from: KeyValue;
+            to: KeyValue;
+            reason?: string;
+            update: KeyValue;
+        };
        type PermitJoinChanged = ZHEvents.PermitJoinChangedPayload;
-        type LastSeenChanged = { device: Device,
-            reason: 'deviceAnnounce' | 'networkAddress' | 'deviceJoined' | 'messageEmitted' | 'messageNonEmitted'; };
-        type DeviceNetworkAddressChanged = { device: Device };
-        type DeviceAnnounce = { device: Device };
-        type DeviceInterview = { device: Device, status: 'started' | 'successful' | 'failed' };
-        type DeviceJoined = { device: Device };
-        type EntityOptionsChanged = { entity: Device | Group, from: KeyValue, to: KeyValue };
-        type ExposesChanged = { device: Device };
-        type Reconfigure = { device: Device };
-        type DeviceLeave = { ieeeAddr: string, name: string };
-        type GroupMembersChanged = {group: Group, action: 'remove' | 'add' | 'remove_all',
-            endpoint: zh.Endpoint, skipDisableReporting: boolean };
-        type PublishEntityState = {entity: Group | Device, message: KeyValue, stateChangeReason: StateChangeReason,
-                payload: KeyValue};
+        type LastSeenChanged = {
+            device: Device;
+            reason: "deviceAnnounce" | "networkAddress" | "deviceJoined" | "messageEmitted" | "messageNonEmitted";
+        };
+        type DeviceNetworkAddressChanged = {device: Device};
+        type DeviceAnnounce = {device: Device};
+        type DeviceInterview = {device: Device; status: "started" | "successful" | "failed"};
+        type DeviceJoined = {device: Device};
+        type EntityOptionsChanged = {entity: Device | Group; from: KeyValue; to: KeyValue};
+        type ExposesChanged = {device: Device};
+        type Reconfigure = {device: Device};
+        type DeviceLeave = {ieeeAddr: string; name: string; device?: Device};
+        type GroupMembersChanged = {group: Group; action: "remove" | "add" | "remove_all"; endpoint: zh.Endpoint; skipDisableReporting: boolean};
+        type PublishEntityState = {entity: Group | Device; message: KeyValue; stateChangeReason?: StateChangeReason; payload: KeyValue};
        type DeviceMessage = {
            type: ZHEvents.MessagePayloadType;
            device: Device;
            endpoint: zh.Endpoint;
            linkquality: number;
-            groupID: number;
+            groupID: number; // XXX: should this be `?`
            cluster: string | number;
            data: KeyValue | Array<string | number>;
-            meta: {zclTransactionSequenceNumber?: number; manufacturerCode?: number; frameControl?: ZHFrameControl;};
+            meta: {zclTransactionSequenceNumber?: number; manufacturerCode?: number; frameControl?: ZHFrameControl};
        };
-        type ScenesChanged = { entity: Device | Group };
+        type ScenesChanged = {entity: Device | Group};
    }

    // Settings
-    // eslint-disable camelcase
-    interface Settings {
-        homeassistant?: {
-            discovery_topic: string,
-            status_topic: string,
-            legacy_entity_attributes: boolean,
-            legacy_triggers: boolean,
-        },
-        permit_join?: boolean,
-        availability?: {
-            active: {timeout: number},
-            passive: {timeout: number}
-        },
-        external_converters: string[],
-        mqtt: {
-            base_topic: string,
-            include_device_information: boolean,
-            force_disable_retain: boolean
-            version?: 3 | 4 | 5,
-            user?: string,
-            password?: string,
-            server: string,
-            ca?: string,
-            keepalive?: number,
-            key?: string,
-            cert?: string,
-            client_id?: string,
-            reject_unauthorized?: boolean,
-        },
-        serial: {
-            disable_led: boolean,
-            port?: string,
-            adapter?: 'deconz' | 'zstack' | 'ezsp' | 'zigate' | 'ember',
-            baudrate?: number,
-            rtscts?: boolean,
-        },
-        passlist: string[],
-        blocklist: string[],
-        map_options: {
-            graphviz: {
-                colors: {
-                    fill: {
-                        enddevice: string,
-                        coordinator: string,
-                        router: string,
-                    },
-                    font: {
-                        coordinator: string,
-                        router: string,
-                        enddevice: string,
-                    },
-                    line: {
-                        active: string,
-                        inactive: string,
-                    },
-                },
-            },
-        },
-        ota: {
-            update_check_interval: number,
-            disable_automatic_update_check: boolean,
-            zigbee_ota_override_index_location?: string,
-            ikea_ota_use_test_url?: boolean,
-        },
-        frontend?: {
-            auth_token?: string,
-            host?: string,
-            port?: number,
-            url?: string,
-            ssl_cert?: string,
-            ssl_key?: string,
-        },
-        devices?: {[s: string]: DeviceOptions},
-        groups?: {[s: string]: GroupOptions},
-        device_options: KeyValue,
-        advanced: {
-            legacy_api: boolean,
-            legacy_availability_payload: boolean,
-            log_rotation: boolean,
-            log_symlink_current: boolean,
-            log_output: ('console' | 'file' | 'syslog')[],
-            log_directory: string,
-            log_file: string,
-            log_level: 'debug' | 'info' | 'error' | 'warn',
-            log_syslog: KeyValue,
-            pan_id: number | 'GENERATE',
-            ext_pan_id: number[] | 'GENERATE',
-            channel: number,
-            adapter_concurrent: number | null,
-            adapter_delay: number | null,
-            cache_state: boolean,
-            cache_state_persistent: boolean,
-            cache_state_send_on_startup: boolean,
-            last_seen: 'disable' | 'ISO_8601' | 'ISO_8601_local' | 'epoch',
-            elapsed: boolean,
-            network_key: number[] | 'GENERATE',
-            timestamp_format: string,
-            output: 'json' | 'attribute' | 'attribute_and_json',
-            transmit_power?: number,
-            // Everything below is deprecated
-            availability_timeout?: number,
-            availability_blocklist?: string[],
-            availability_passlist?: string[],
-            availability_blacklist?: string[],
-            availability_whitelist?: string[],
-            soft_reset_timeout: number,
-            report: boolean,
-        },
+    type Settings = Zigbee2MQTTSettings;
+
+    type DeviceOptions = Zigbee2MQTTDeviceOptions;
+
+    interface DeviceOptionsWithId extends DeviceOptions {
+        ID: string;
    }

-    interface DeviceOptions {
-        ID?: string,
-        disabled?: boolean,
-        retention?: number,
-        availability?: boolean | {timeout: number},
-        optimistic?: boolean,
-        retrieve_state?: boolean,
-        debounce?: number,
-        debounce_ignore?: string[],
-        filtered_attributes?: string[],
-        filtered_cache?: string[],
-        filtered_optimistic?: string[],
-        icon?: string,
-        homeassistant?: KeyValue,
-        legacy?: boolean,
-        friendly_name: string,
-        description?: string,
-        qos?: 0 | 1 | 2,
-    }
-
-    interface GroupOptions {
-        devices?: string[],
-        ID?: number,
-        optimistic?: boolean,
-        off_state?: 'all_members_off' | 'last_member_state'
-        filtered_attributes?: string[],
-        filtered_cache?: string[],
-        filtered_optimistic?: string[],
-        retrieve_state?: boolean,
-        homeassistant?: KeyValue,
-        friendly_name: string,
-        description?: string,
-        qos?: 0 | 1 | 2,
-    }
+    type GroupOptions = Zigbee2MQTTGroupOptions;
 }
@@ -0,0 +1,13 @@
+declare module "unix-dgram" {
+    import {EventEmitter} from "node:events";
+
+    export class UnixDgramSocket extends EventEmitter {
+        send(buf: Buffer, callback?: (err?: Error) => void): void;
+        send(buf: Buffer, offset: number, length: number, path: string, callback?: (err?: Error) => void): void;
+        bind(path: string): void;
+        connect(remotePath: string): void;
+        close(): void;
+    }
+
+    export function createSocket(type: "unix_dgram", listener?: (msg: Buffer) => void): UnixDgramSocket;
+}
@@ -1,9 +1,21 @@
-declare module 'zigbee2mqtt-frontend' {
-    export function getPath(): string;
+declare module "zigbee2mqtt-frontend" {
+    const frontend: {
+        getPath: () => string;
+    };
+
+    export default frontend;
 }

-declare module 'connect-gzip-static' {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    export type RequestHandler = (req: any, res: any) => void;
-    export default function gzipStatic(root: string, options?: Record<string, unknown>): RequestHandler;
+declare module "http" {
+    interface IncomingMessage {
+        originalUrl?: string;
+        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;
 }
@@ -1,17 +1,10 @@
-import path from 'path';
+import path from "node:path";

-let dataPath: string = null;
-
-function load(): void {
-    if (process.env.ZIGBEE2MQTT_DATA) {
-        dataPath = process.env.ZIGBEE2MQTT_DATA;
-    } else {
-        dataPath = path.join(__dirname, '..', '..', 'data');
-        dataPath = path.normalize(dataPath);
-    }
+function setPath(): string {
+    return process.env.ZIGBEE2MQTT_DATA ? process.env.ZIGBEE2MQTT_DATA : path.normalize(path.join(__dirname, "..", "..", "data"));
 }

-load();
+let dataPath = setPath();

 function joinPath(file: string): string {
    return path.resolve(dataPath, file);
@@ -21,9 +14,9 @@ function getPath(): string {
    return dataPath;
 }

-// eslint-disable-next-line camelcase
-function testingOnlyReload(): void {
-    load();
+function _testReload(): void {
+    dataPath = setPath();
 }

-export default {joinPath, getPath, testingOnlyReload};
+// biome-ignore lint/style/useNamingConvention: test
+export default {joinPath, getPath, _testReload};
@@ -1,90 +1,98 @@
-import winston from 'winston';
-import moment from 'moment';
-import * as settings from './settings';
-import path from 'path';
-import fs from 'fs';
-import fx from 'mkdir-recursive';
-import {rimrafSync} from 'rimraf';
-import assert from 'assert';
+import assert from "node:assert";
+import fs from "node:fs";
+import path from "node:path";

-const LOG_LEVELS = ['error', 'warning', 'info', 'debug'] as const;
-type LogLevel = typeof LOG_LEVELS[number];
+import moment from "moment";
+import {rimrafSync} from "rimraf";
+import winston from "winston";
+
+import * as settings from "./settings";
+
+const NAMESPACE_SEPARATOR = ":";

 class Logger {
-    private level: LogLevel;
-    private readonly output: string[];
-    private readonly directory: string;
-    private readonly logger: winston.Logger;
-    private readonly fileTransport: winston.transports.FileTransportInstance;
+    // @ts-expect-error initalized in `init`
+    private level: settings.LogLevel;
+    // @ts-expect-error initalized in `init`
+    private output: string[];
+    // @ts-expect-error initalized in `init`
+    private directory: string;
+    // @ts-expect-error initalized in `init`
+    private logger: winston.Logger;
+    // @ts-expect-error initalized in `init`
+    private fileTransport: winston.transports.FileTransportInstance;
+    private debugNamespaceIgnoreRegex?: RegExp;
+    // @ts-expect-error initalized in `init`
+    private namespacedLevels: Record<string, settings.LogLevel>;
+    // @ts-expect-error initalized in `init`
+    private cachedNamespacedLevels: Record<string, settings.LogLevel>;

-    constructor() {
+    public init(): void {
        // What transports to enable
        this.output = settings.get().advanced.log_output;
        // Directory to log to
-        const timestamp = moment(Date.now()).format('YYYY-MM-DD.HH-mm-ss');
-        this.directory = settings.get().advanced.log_directory.replace('%TIMESTAMP%', timestamp);
-        const logFilename = settings.get().advanced.log_file.replace('%TIMESTAMP%', timestamp);
-        // Determine the log level.
-        const settingLevel = settings.get().advanced.log_level;
-        // workaround for syslog<>npm level conflict
-        this.level = settingLevel === 'warn' ? 'warning' : settingLevel;
+        const timestamp = moment(Date.now()).format("YYYY-MM-DD.HH-mm-ss");
+        this.directory = settings.get().advanced.log_directory.replace("%TIMESTAMP%", timestamp);
+        const logFilename = settings.get().advanced.log_file.replace("%TIMESTAMP%", timestamp);
+        this.level = settings.get().advanced.log_level;
+        this.namespacedLevels = settings.get().advanced.log_namespaced_levels;
+        this.cachedNamespacedLevels = Object.assign({}, this.namespacedLevels);

-        assert(
-            LOG_LEVELS.includes(this.level),
-            `'${this.level}' is not valid log_level, use one of '${LOG_LEVELS.join(', ')}'`,
-        );
+        assert(settings.LOG_LEVELS.includes(this.level), `'${this.level}' is not valid log_level, use one of '${settings.LOG_LEVELS.join(", ")}'`);

        const timestampFormat = (): string => moment().format(settings.get().advanced.timestamp_format);

        this.logger = winston.createLogger({
-            level: this.level,
-            format: winston.format.combine(
-                winston.format.errors({stack: true}),
-                winston.format.timestamp({format: timestampFormat}),
-            ),
+            level: "debug",
+            format: winston.format.combine(winston.format.errors({stack: true}), winston.format.timestamp({format: timestampFormat})),
            levels: winston.config.syslog.levels,
        });

-        const consoleSilenced = !this.output.includes('console');
+        const consoleSilenced = !this.output.includes("console");
        // Print to user what logging is active
-        let logging = `Logging to console${consoleSilenced ? ' (silenced)' : ''}`;
+        let logging = `Logging to console${consoleSilenced ? " (silenced)" : ""}`;

        // Setup default console logger
-        this.logger.add(new winston.transports.Console({
-            silent: consoleSilenced,
-            // winston.config.syslog.levels sets 'warning' as 'red'
-            format: winston.format.combine(
-                winston.format.colorize({colors: {debug: 'blue', info: 'green', warning: 'yellow', error: 'red'}}),
-                winston.format.printf(/* istanbul ignore next */(info) => {
-                    return `[${info.timestamp}] ${info.level}: \t${info.namespace}: ${info.message}`;
-                }),
-            ),
-        }));
+        this.logger.add(
+            new winston.transports.Console({
+                silent: consoleSilenced,
+                format: settings.get().advanced.log_console_json
+                    ? winston.format.json()
+                    : winston.format.combine(
+                          // winston.config.syslog.levels sets 'warning' as 'red'
+                          winston.format.colorize({colors: {debug: "blue", info: "green", warning: "yellow", error: "red"}}),
+                          winston.format.printf((info) => {
+                              return `[${info.timestamp}] ${info.level}: \t${info.message}`;
+                          }),
+                      ),
+            }),
+        );

-        if (this.output.includes('file')) {
+        if (this.output.includes("file")) {
            logging += `, file (filename: ${logFilename})`;

            // Make sure that log directory exists when not logging to stdout only
-            fx.mkdirSync(this.directory);
+            fs.mkdirSync(this.directory, {recursive: true});

            if (settings.get().advanced.log_symlink_current) {
-                const current = settings.get().advanced.log_directory.replace('%TIMESTAMP%', 'current');
-                const actual = './' + timestamp;
-                /* istanbul ignore next */
+                const current = settings.get().advanced.log_directory.replace("%TIMESTAMP%", "current");
+                const actual = `./${timestamp}`;
+
+                /* v8 ignore start */
                if (fs.existsSync(current)) {
                    fs.unlinkSync(current);
                }
+                /* v8 ignore stop */
+
                fs.symlinkSync(actual, current);
            }

            // Add file logger when enabled
-            // eslint-disable-next-line max-len
            // NOTE: the initiation of the logger even when not added as transport tries to create the logging directory
-            const transportFileOptions: KeyValue = {
+            const transportFileOptions: winston.transports.FileTransportOptions = {
                filename: path.join(this.directory, logFilename),
-                json: false,
-                format: winston.format.printf(/* istanbul ignore next */(info) => {
-                    return `[${info.timestamp}] ${info.level}: \t${info.namespace}: ${info.message}`;
+                format: winston.format.printf((info) => {
+                    return `[${info.timestamp}] ${info.level}: \t${info.message}`;
                }),
            };

@@ -96,29 +104,30 @@ class Logger {

            this.fileTransport = new winston.transports.File(transportFileOptions);
            this.logger.add(this.fileTransport);
+            this.cleanup();
        }

-        /* istanbul ignore next */
-        if (this.output.includes('syslog')) {
-            logging += `, syslog`;
-            // eslint-disable-next-line
-            require('winston-syslog').Syslog;
+        /* v8 ignore start */
+        if (this.output.includes("syslog")) {
+            logging += ", syslog";
+            require("winston-syslog").Syslog;

            const options: KeyValue = {
-                app_name: 'Zigbee2MQTT',
-                format: winston.format.printf(/* istanbul ignore next */(info) => {
-                    return `${info.namespace}: ${info.message}`;
-                }),
+                app_name: "Zigbee2MQTT",
+                format: winston.format.printf((info) => info.message as string),
                ...settings.get().advanced.log_syslog,
            };

-            if (options.hasOwnProperty('type')) {
+            if (options.type !== undefined) {
                options.type = options.type.toString();
            }

            // @ts-expect-error untyped transport
            this.logger.add(new winston.transports.Syslog(options));
        }
+        /* v8 ignore stop */
+
+        this.setDebugNamespaceIgnore(settings.get().advanced.log_debug_namespace_ignore);

        this.info(logging);
    }
@@ -128,7 +137,6 @@ class Logger {
    }

    public addTransport(transport: winston.transport): void {
-        transport.level = this.level;
        this.logger.add(transport);
    }

@@ -136,44 +144,92 @@ class Logger {
        this.logger.remove(transport);
    }

-    // TODO refactor Z2M level to 'warning' to simplify logic
-    public getLevel(): LogLevel | 'warn' {
-        return this.level === 'warning' ? 'warn' : this.level;
+    public getDebugNamespaceIgnore(): string {
+        return (
+            this.debugNamespaceIgnoreRegex
+                ?.toString()
+                .slice(1, -1) /* remove slashes */ ?? ""
+        );
    }

-    public setLevel(level: LogLevel | 'warn'): void {
-        if (level === 'warn') {
-            level = 'warning';
+    public setDebugNamespaceIgnore(value: string): void {
+        this.debugNamespaceIgnoreRegex = value !== "" ? new RegExp(value) : undefined;
+    }
+
+    public getLevel(): settings.LogLevel {
+        return this.level;
+    }
+
+    public setLevel(level: settings.LogLevel): void {
+        this.level = level;
+        this.resetCachedNamespacedLevels();
+    }
+
+    public getNamespacedLevels(): Record<string, settings.LogLevel> {
+        return this.namespacedLevels;
+    }
+
+    public setNamespacedLevels(nsLevels: Record<string, settings.LogLevel>): void {
+        this.namespacedLevels = nsLevels;
+        this.resetCachedNamespacedLevels();
+    }
+
+    private resetCachedNamespacedLevels(): void {
+        this.cachedNamespacedLevels = Object.assign({}, this.namespacedLevels);
+    }
+
+    private cacheNamespacedLevel(namespace: string): string {
+        let cached = namespace;
+
+        while (this.cachedNamespacedLevels[namespace] === undefined) {
+            const sep = cached.lastIndexOf(NAMESPACE_SEPARATOR);
+
+            if (sep === -1) {
+                this.cachedNamespacedLevels[namespace] = this.level;
+
+                return this.level;
+            }
+
+            cached = cached.slice(0, sep);
+            this.cachedNamespacedLevels[namespace] = this.cachedNamespacedLevels[cached];
        }

-        this.level = level;
-        this.logger.transports.forEach((transport) => transport.level = this.level);
+        return this.cachedNamespacedLevels[namespace];
    }

-    public warning(message: string, namespace: string = 'z2m'): void {
-        this.logger.warning(message, {namespace});
+    private log(level: settings.LogLevel, messageOrLambda: string | (() => string), namespace: string): void {
+        const nsLevel = this.cacheNamespacedLevel(namespace);
+
+        if (settings.LOG_LEVELS.indexOf(level) <= settings.LOG_LEVELS.indexOf(nsLevel)) {
+            const message: string = messageOrLambda instanceof Function ? messageOrLambda() : messageOrLambda;
+            this.logger.log(level, `${namespace}: ${message}`);
+        }
    }

-    public info(message: string, namespace: string = 'z2m'): void {
-        this.logger.info(message, {namespace});
+    public error(messageOrLambda: string | (() => string), namespace = "z2m"): void {
+        this.log("error", messageOrLambda, namespace);
    }

-    public debug(message: string, namespace: string = 'z2m'): void {
-        if (this.level !== 'debug') {
+    public warning(messageOrLambda: string | (() => string), namespace = "z2m"): void {
+        this.log("warning", messageOrLambda, namespace);
+    }
+
+    public info(messageOrLambda: string | (() => string), namespace = "z2m"): void {
+        this.log("info", messageOrLambda, namespace);
+    }
+
+    public debug(messageOrLambda: string | (() => string), namespace = "z2m"): void {
+        if (this.debugNamespaceIgnoreRegex?.test(namespace)) {
            return;
        }

-        this.logger.debug(message, {namespace});
-    }
-
-    public error(message: string, namespace: string = 'z2m'): void {
-        this.logger.error(message, {namespace});
+        this.log("debug", messageOrLambda, namespace);
    }

    // Cleanup any old log directory.
-    public cleanup(): void {
-        if (settings.get().advanced.log_directory.includes('%TIMESTAMP%')) {
-            const rootDirectory = path.join(this.directory, '..');
+    private cleanup(): void {
+        if (settings.get().advanced.log_directory.includes("%TIMESTAMP%")) {
+            const rootDirectory = path.join(this.directory, "..");

            let directories = fs.readdirSync(rootDirectory).map((d) => {
                d = path.join(rootDirectory, d);
@@ -181,35 +237,37 @@ class Logger {
            });

            directories.sort((a: KeyValue, b: KeyValue) => b.birth - a.birth);
-            directories = directories.slice(10, directories.length);
-            directories.forEach((dir) => {
+            directories = directories.slice(settings.get().advanced.log_directories_to_keep, directories.length);
+
+            for (const dir of directories) {
                this.debug(`Removing old log directory '${dir.path}'`);
                rimrafSync(dir.path);
-            });
+            }
        }
    }

    // Workaround for https://github.com/winstonjs/winston/issues/1629.
    // https://github.com/Koenkk/zigbee2mqtt/pull/10905
-    /* istanbul ignore next */
+    /* v8 ignore start */
    public async end(): Promise<void> {
-        this.logger.end();
-
-        await new Promise<void>((resolve) => {
-            if (!this.fileTransport) {
-                process.nextTick(resolve);
-            } else {
+        // Only flush the file transport, don't end logger itself as log() might still be called
+        // causing a UnhandledPromiseRejection (`Error: write after end`). Flushing the file transport
+        // ensures the log files are written before stopping.
+        if (this.fileTransport) {
+            await new Promise<void>((resolve) => {
                // @ts-expect-error workaround
                if (this.fileTransport._dest) {
                    // @ts-expect-error workaround
-                    this.fileTransport._dest.on('finish', resolve);
+                    this.fileTransport._dest.on("finish", resolve);
                } else {
                    // @ts-expect-error workaround
-                    this.fileTransport.on('open', () => this.fileTransport._dest.on('finish', resolve));
+                    this.fileTransport.on("open", () => this.fileTransport._dest.on("finish", resolve));
                }
-            }
-        });
+                this.fileTransport.end();
+            });
+        }
    }
+    /* v8 ignore stop */
 }

 export default new Logger();
@@ -0,0 +1,579 @@
+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";
+
+type OnboardSettings = {
+    mqtt_base_topic?: string;
+    mqtt_server?: string;
+    mqtt_user?: string;
+    mqtt_password?: string;
+    serial_port?: string;
+    serial_adapter?: Settings["serial"]["adapter"];
+    serial_baudrate?: string;
+    serial_rtscts?: "on";
+    network_channel?: string;
+    network_key?: string;
+    network_pan_id?: string;
+    network_ext_pan_id?: string;
+    frontend_enabled?: "on";
+    frontend_port?: string;
+    homeassistant_enabled?: "on";
+    log_level?: Settings["advanced"]["log_level"];
+};
+
+function escapeHtml(s: string): string {
+    return s.replace(/[^0-9A-Za-z \-_.]/g, (c) => `&#${c.charCodeAt(0)};`);
+}
+
+function generateHtmlDone(frontendUrl: string | undefined): string {
+    return `
+<!doctype html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>Zigbee2MQTT Onboarding</title>
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@picocss/pico@2/css/pico.classless.min.css">
+</head>
+<body>
+    <main>
+        <h1>Zigbee2MQTT Onboarding</h1>
+        <p>Settings saved.</p>
+        <p>Zigbee2MQTT is now starting...</p>
+        <small>${frontendUrl ? `Redirecting to Zigbee2MQTT frontend at <a href="${frontendUrl}">${frontendUrl}</a> in 30 seconds.` : "You can close this page."}</small>
+    </main>
+    ${frontendUrl ? `<script>setTimeout(() => { window.location.replace("${frontendUrl}"); }, 30000);</script>` : ""}
+</body>
+</html>
+`;
+}
+
+function generateHtmlForm(currentSettings: RecursivePartial<Settings>, devices: Awaited<ReturnType<typeof findAllDevices>>): string {
+    let devicesSelect = "";
+
+    if (devices.length > 0) {
+        devicesSelect += '<select id="found_device" onchange="setFoundDevice(this)">';
+        devicesSelect += '<option value="">Select a device</option>';
+
+        for (const device of devices) {
+            // just in case name has commas, remove them to not mess with `split` logic
+            const deviceStr = `${device.name.replaceAll(",", "")}, ${device.path}, ${device.adapter ?? "unknown"}`;
+
+            devicesSelect += `<option value="${deviceStr}">${deviceStr}</option>`;
+        }
+
+        devicesSelect += "</select>";
+        devicesSelect += "<small>Optionally allows to configure coordinator port and type (if known) automatically.</small>";
+    } else {
+        devicesSelect = "<small>No device found</small>";
+    }
+
+    let generateCheckbox = "";
+
+    if (
+        Array.isArray(currentSettings.advanced?.network_key) ||
+        typeof currentSettings.advanced?.pan_id === "number" ||
+        Array.isArray(currentSettings.advanced?.ext_pan_id)
+    ) {
+        generateCheckbox = `
+<label for="generate_network">
+    <input
+        type="checkbox"
+        id="generate_network"
+        onclick="setGenerate(this)"
+        ${process.env.ZIGBEE2MQTT_CONFIG_ADVANCED_NETWORK_KEY || process.env.ZIGBEE2MQTT_CONFIG_ADVANCED_PAN_ID || process.env.ZIGBEE2MQTT_CONFIG_ADVANCED_EXT_PAN_ID ? "disabled" : ""}>
+    Generate network?
+</label>
+`;
+    }
+
+    /* v8 ignore start */
+    return `
+<!doctype html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>Zigbee2MQTT Onboarding</title>
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@picocss/pico@2/css/pico.classless.min.css">
+</head>
+<body>
+    <main>
+        <h1>Zigbee2MQTT Onboarding</h1>
+        <p>Set the base configuration to start Zigbee2MQTT.</p>
+        <p>Optional fields will either be ignored or fallback to defaults if not set (see appropriate documentation page for more details).</p>
+        <p>If a field is disabled, it means <a href="https://www.zigbee2mqtt.io/guide/configuration/#environment-variables" target="_blank">environment variables</a> are being used to override specific values (for example, through the Home Assistant add-on configuration page).</p>
+        <hr>
+        <form method="post">
+            <fieldset ${process.env.ZIGBEE2MQTT_CONFIG_SERIAL || process.env.ZIGBEE2MQTT_CONFIG_SERIAL_PORT || process.env.ZIGBEE2MQTT_CONFIG_SERIAL_ADAPTER ? "disabled" : ""}>
+                <label for="found_device">Found Devices</label>
+                ${devicesSelect}
+            </fieldset>
+            <fieldset ${process.env.ZIGBEE2MQTT_CONFIG_SERIAL ? "disabled" : ""}>
+                <label for="serial_port">Coordinator/Adapter Port/Path</label>
+                <input
+                    type="text"
+                    id="serial_port"
+                    name="serial_port"
+                    value="${currentSettings.serial?.port ?? ""}"
+                    required
+                    ${process.env.ZIGBEE2MQTT_CONFIG_SERIAL_PORT ? "disabled" : ""}>
+                <label for="serial_adapter">Coordinator/Adapter Type/Stack/Driver</label>
+                <select id="serial_adapter" name="serial_adapter" required ${process.env.ZIGBEE2MQTT_CONFIG_SERIAL_ADAPTER ? "disabled" : ""}>
+                    <option value="zstack" ${currentSettings.serial?.adapter === "zstack" ? "selected" : ""}>zstack</option>
+                    <option value="ember" ${currentSettings.serial?.adapter === "ember" ? "selected" : ""}>ember</option>
+                    <option value="deconz" ${currentSettings.serial?.adapter === "deconz" ? "selected" : ""}>deconz</option>
+                    <option value="zigate" ${currentSettings.serial?.adapter === "zigate" ? "selected" : ""}>zigate</option>
+                    <option value="zboss" ${currentSettings.serial?.adapter === "zboss" ? "selected" : ""}>zboss</option>
+                </select>
+                <label for="serial_baudrate">Coordinator/Adapter Baudrate</label>
+                <select id="serial_baudrate" name="serial_baudrate" ${process.env.ZIGBEE2MQTT_CONFIG_SERIAL_BAUDRATE ? "disabled" : ""}>
+                    <option value="38400" ${currentSettings.serial?.baudrate === 38400 ? "selected" : ""}>38400</option>
+                    <option value="57600" ${currentSettings.serial?.baudrate === 57600 ? "selected" : ""}>57600</option>
+                    <option value="115200" ${!currentSettings.serial?.baudrate || currentSettings.serial?.baudrate === 115200 ? "selected" : ""}>115200</option>
+                    <option value="230400" ${currentSettings.serial?.baudrate === 230400 ? "selected" : ""}>230400</option>
+                    <option value="460800" ${currentSettings.serial?.baudrate === 460800 ? "selected" : ""}>460800</option>
+                    <option value="921600" ${currentSettings.serial?.baudrate === 921600 ? "selected" : ""}>921600</option>
+                </select>
+                <small>Can be ignored for networked coordinators (TCP).</small>
+                <label for="serial_rtscts">Coordinator/Adapter Hardware Flow Control ("rtscts: true")</label>
+                <input
+                    type="checkbox"
+                    id="serial_rtscts"
+                    name="serial_rtscts"
+                    ${currentSettings.serial?.rtscts ? "checked" : ""}
+                    style="margin-bottom: 1rem;">
+                <small>Can be ignored for networked coordinators (TCP).</small>
+            </fieldset>
+            <small>
+                <a href="https://www.zigbee2mqtt.io/guide/configuration/adapter-settings.html" target="_blank">https://www.zigbee2mqtt.io/guide/configuration/adapter-settings.html</a>
+            </small>
+            <hr>
+            <fieldset ${process.env.ZIGBEE2MQTT_CONFIG_ADVANCED ? "disabled" : ""}>
+                <label for="closest_wifi_channel">Closest WiFi Channel</label>
+                <input
+                    type="number"
+                    min="0"
+                    max="14"
+                    id="closest_wifi_channel"
+                    value="0"
+                    onclick="setBestZigbeeChannel(this)"
+                    ${process.env.ZIGBEE2MQTT_CONFIG_ADVANCED_CHANNEL ? "disabled" : ""}>
+                <small>Optionally set to your closest WiFi channel to pick the best value for "Network channel" below.</small>
+                <label for="network_channel">Network Channel</label>
+                <input
+                    type="number"
+                    min="11"
+                    max="26"
+                    id="network_channel"
+                    name="network_channel"
+                    value="${currentSettings.advanced?.channel ?? "25"}"
+                    required
+                    ${process.env.ZIGBEE2MQTT_CONFIG_ADVANCED_CHANNEL ? "disabled" : ""}>
+            </fieldset>
+            <fieldset ${process.env.ZIGBEE2MQTT_CONFIG_ADVANCED ? "disabled" : ""}>
+                ${generateCheckbox}
+                <label for="network_key">Network Key</label>
+                <input
+                    type="text"
+                    id="network_key"
+                    name="network_key"
+                    value="${currentSettings.advanced?.network_key ?? "GENERATE"}"
+                    pattern="^([0-9]+(,[0-9]+){15})|GENERATE$"
+                    required
+                    ${process.env.ZIGBEE2MQTT_CONFIG_ADVANCED_NETWORK_KEY ? "disabled" : ""}>
+                <label for="network_pan_id">Network PAN ID</label>
+                <input
+                    type="text"
+                    id="network_pan_id"
+                    name="network_pan_id"
+                    value="${currentSettings.advanced?.pan_id ?? "GENERATE"}"
+                    pattern="^([0-9]{1,5})|GENERATE$"
+                    required
+                    ${process.env.ZIGBEE2MQTT_CONFIG_ADVANCED_PAN_ID ? "disabled" : ""}>
+                <label for="network_ext_pan_id">Network Extended PAN ID</label>
+                <input
+                    type="text"
+                    id="network_ext_pan_id"
+                    name="network_ext_pan_id"
+                    value="${currentSettings.advanced?.ext_pan_id ?? "GENERATE"}"
+                    pattern="^([0-9]+(,[0-9]+){7})|GENERATE$"
+                    required
+                    ${process.env.ZIGBEE2MQTT_CONFIG_ADVANCED_EXT_PAN_ID ? "disabled" : ""}>
+            </fieldset>
+            <small>
+                <a href="https://www.zigbee2mqtt.io/guide/configuration/zigbee-network.html" target="_blank">https://www.zigbee2mqtt.io/guide/configuration/zigbee-network.html</a>
+            </small>
+            <hr>
+            <fieldset ${process.env.ZIGBEE2MQTT_CONFIG_MQTT ? "disabled" : ""}>
+                <label for="mqtt_base_topic">MQTT Base Topic</label>
+                <input
+                    type="text"
+                    id="mqtt_base_topic"
+                    name="mqtt_base_topic"
+                    value="${currentSettings.mqtt?.base_topic ?? "zigbee2mqtt"}"
+                    required
+                    ${process.env.ZIGBEE2MQTT_CONFIG_MQTT_BASE_TOPIC ? "disabled" : ""}>
+                <label for="mqtt_server">MQTT Server</label>
+                <input
+                    type="text"
+                    id="mqtt_server"
+                    name="mqtt_server"
+                    value="${currentSettings.mqtt?.server ?? "mqtt://localhost:1883"}"
+                    required
+                    ${process.env.ZIGBEE2MQTT_CONFIG_MQTT_SERVER ? "disabled" : ""}>
+                <label for="mqtt_user">MQTT User</label>
+                <input
+                    type="text"
+                    id="mqtt_user"
+                    name="mqtt_user"
+                    value="${currentSettings.mqtt?.user ?? ""}"
+                    ${process.env.ZIGBEE2MQTT_CONFIG_MQTT_USER ? "disabled" : ""}>
+                <small>Optional. Set only if using authentication.</small>
+                <label for="mqtt_password">MQTT Password</label>
+                <input
+                    type="password"
+                    id="mqtt_password"
+                    name="mqtt_password"
+                    value="${currentSettings.mqtt?.password ?? ""}"
+                    ${process.env.ZIGBEE2MQTT_CONFIG_MQTT_PASSWORD ? "disabled" : ""}>
+                <small>Optional. Set only if using authentication.</small>
+            </fieldset>
+            <small>
+                <a href="https://www.zigbee2mqtt.io/guide/configuration/mqtt.html" target="_blank">https://www.zigbee2mqtt.io/guide/configuration/mqtt.html</a>
+            </small>
+            <hr>
+            <fieldset ${process.env.ZIGBEE2MQTT_CONFIG_FRONTEND ? "disabled" : ""}>
+                <label for="frontend_enabled">
+                    <input
+                        type="checkbox"
+                        id="frontend_enabled"
+                        name="frontend_enabled"
+                        ${currentSettings.frontend?.enabled ? "checked" : ""}
+                        ${process.env.ZIGBEE2MQTT_CONFIG_FRONTEND_ENABLED ? "disabled" : ""}>
+                    Frontend enabled?
+                </label>
+                <label for="frontend_port">Frontend Port</label>
+                <input
+                    type="number"
+                    min="0"
+                    max="65535"
+                    id="frontend_port"
+                    name="frontend_port"
+                    value="${currentSettings.frontend?.port ?? "8080"}"
+                    required
+                    ${process.env.ZIGBEE2MQTT_CONFIG_FRONTEND_PORT ? "disabled" : ""}>
+            </fieldset>
+            <small>
+                <a href="https://www.zigbee2mqtt.io/guide/configuration/frontend.html" target="_blank">https://www.zigbee2mqtt.io/guide/configuration/frontend.html</a>
+            </small>
+            <fieldset ${process.env.ZIGBEE2MQTT_CONFIG_HOMEASSISTANT ? "disabled" : ""}>
+                <label for="homeassistant_enabled" ${process.env.ZIGBEE2MQTT_CONFIG_HOMEASSISTANT_ENABLED ? "disabled" : ""}>
+                    <input type="checkbox" id="homeassistant_enabled" name="homeassistant_enabled" ${currentSettings.homeassistant?.enabled ? "checked" : ""}>
+                    Home Assistant enabled?
+                </label>
+            </fieldset>
+            <small>
+                <a href="https://www.zigbee2mqtt.io/guide/configuration/homeassistant.html" target="_blank">https://www.zigbee2mqtt.io/guide/configuration/homeassistant.html</a>
+            </small>
+            <hr>
+            <fieldset ${process.env.ZIGBEE2MQTT_CONFIG_ADVANCED ? "disabled" : ""}>
+                <label for="log_level">Log Level</label>
+                <select id="log_level" name="log_level" ${process.env.ZIGBEE2MQTT_CONFIG_ADVANCED_LOG_LEVEL ? "disabled" : ""}>
+                    <option value="error" ${currentSettings.advanced?.log_level === "error" ? "selected" : ""}>error</option>
+                    <option value="warning" ${currentSettings.advanced?.log_level === "warning" ? "selected" : ""}>warning</option>
+                    <option value="info" ${!currentSettings.advanced?.log_level || currentSettings.advanced?.log_level === "info" ? "selected" : ""}>info</option>
+                    <option value="debug" ${currentSettings.advanced?.log_level === "debug" ? "selected" : ""}>debug</option>
+                </select>
+            </fieldset>
+            <small>
+                <a href="https://www.zigbee2mqtt.io/guide/configuration/logging.html" target="_blank">https://www.zigbee2mqtt.io/guide/configuration/logging.html</a>
+            </small>
+            <hr>
+            <input type="submit" value="Submit">
+        </form>
+    </main>
+    <script>
+        function setFoundDevice(e) {
+            if (!e.value) {
+                return;
+            }
+
+            const [, path, adapter] = e.value.split(", ");
+            const serialPortEl = document.querySelector("#serial_port");
+            serialPortEl.value = path;
+            const serialAdapterEl = document.querySelector("#serial_adapter");
+
+            if (['zstack', 'ember', 'deconz', 'zigate', 'zboss'].includes(adapter)) {
+                serialAdapterEl.value = adapter;
+            } else {
+                serialAdapterEl.value = '';
+            }
+        }
+
+        function setBestZigbeeChannel(e) {
+            const wifiChannel = parseInt(e.value, 10);
+            const networkChannelEl = document.querySelector("#network_channel");
+
+            if (wifiChannel >= 11) {
+                // WiFi 11-14
+                networkChannelEl.value = 15;
+            } else if (wifiChannel >= 6) {
+                // WiFi 6-10
+                networkChannelEl.value = 11;
+            } else {
+                // WiFi 1-5
+                networkChannelEl.value = 25;
+            }
+        }
+
+        function setGenerate(e) {
+            document.querySelector("#network_key").value = e.checked ? "GENERATE" : "${currentSettings.advanced?.network_key ?? "GENERATE"}";
+            document.querySelector("#network_pan_id").value = e.checked ? "GENERATE" : "${currentSettings.advanced?.pan_id ?? "GENERATE"}";
+            document.querySelector("#network_ext_pan_id").value = e.checked ? "GENERATE" : "${currentSettings.advanced?.ext_pan_id ?? "GENERATE"}";
+        }
+    </script>
+</body>
+</html>
+`;
+    /* v8 ignore stop */
+}
+
+function generateHtmlError(errors: string): string {
+    return `
+<!doctype html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>Zigbee2MQTT Onboarding</title>
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@picocss/pico@2/css/pico.classless.min.css">
+</head>
+<body>
+    <main>
+        <h1>Zigbee2MQTT configuration is not valid</h1>
+        <p style="color: #F00;">Found the following errors:</p>
+        ${errors}
+        <hr>
+        <p>If you don't know how to solve this, read <a href="https://www.zigbee2mqtt.io/guide/configuration" target="_blank">https://www.zigbee2mqtt.io/guide/configuration</a></p>
+        <form method="post" action="/">
+            <input type="submit" value="Close">
+        </form>
+    </main>
+</body>
+</html>
+`;
+}
+
+function getServerUrl(): URL {
+    return new URL(process.env.Z2M_ONBOARD_URL ?? "http://0.0.0.0:8080");
+}
+
+async function startOnboardingServer(): Promise<boolean> {
+    const currentSettings = settings.get();
+    const serverUrl = getServerUrl();
+    let server: ReturnType<typeof createServer> | undefined;
+    let failed = false;
+
+    const success = await new Promise<boolean>((resolve) => {
+        server = createServer(async (req, res) => {
+            if (req.method === "POST") {
+                if (failed) {
+                    res.end(() => {
+                        resolve(false);
+                    });
+                } else {
+                    let body = "";
+
+                    req.on("data", (chunk) => {
+                        body += chunk;
+                    });
+
+                    req.on("end", () => {
+                        const result = parse(body) as unknown as OnboardSettings;
+                        const frontendEnabled = result.frontend_enabled === "on";
+                        const updatedSettings: RecursivePartial<Settings> = {
+                            mqtt: {
+                                base_topic: result.mqtt_base_topic,
+                                server: result.mqtt_server,
+                                user: result.mqtt_user || undefined, // empty string => removed
+                                password: result.mqtt_password || undefined, // empty string => removed
+                            },
+                            serial: {
+                                port: result.serial_port,
+                                adapter: result.serial_adapter,
+                                baudrate: result.serial_baudrate ? Number.parseInt(result.serial_baudrate, 10) : undefined,
+                                rtscts: result.serial_rtscts === "on",
+                            },
+                            advanced: {
+                                log_level: result.log_level,
+                                channel: result.network_channel ? Number.parseInt(result.network_channel, 10) : undefined,
+                                network_key: result.network_key
+                                    ? result.network_key === "GENERATE"
+                                        ? result.network_key
+                                        : result.network_key.split(",").map((v) => Number.parseInt(v, 10))
+                                    : undefined,
+                                pan_id: result.network_pan_id
+                                    ? result.network_pan_id === "GENERATE"
+                                        ? result.network_pan_id
+                                        : Number.parseInt(result.network_pan_id, 10)
+                                    : undefined,
+                                ext_pan_id: result.network_ext_pan_id
+                                    ? result.network_ext_pan_id === "GENERATE"
+                                        ? result.network_ext_pan_id
+                                        : result.network_ext_pan_id.split(",").map((v) => Number.parseInt(v, 10))
+                                    : undefined,
+                            },
+                            frontend: {
+                                enabled: frontendEnabled,
+                                port: result.frontend_port ? Number.parseInt(result.frontend_port, 10) : undefined,
+                            },
+                            homeassistant: {
+                                enabled: result.homeassistant_enabled === "on",
+                            },
+                        };
+
+                        try {
+                            settings.apply(updatedSettings);
+
+                            // to redirect, make sure frontend "will be" enabled, and host isn't socket
+                            const redirect =
+                                !process.env.Z2M_ONBOARD_NO_REDIRECT &&
+                                frontendEnabled &&
+                                (!currentSettings.frontend?.host || !currentSettings.frontend.host.startsWith("/"));
+                            const protocol = currentSettings.frontend?.ssl_cert && currentSettings.frontend.ssl_key ? "https" : "http";
+
+                            res.setHeader("Content-Type", "text/html");
+                            res.writeHead(200);
+                            res.end(
+                                generateHtmlDone(
+                                    redirect
+                                        ? /* v8 ignore next */ `${protocol}://${currentSettings.frontend?.host ?? "localhost"}:${currentSettings.frontend?.port ?? "8080"}${currentSettings.frontend?.base_url ?? "/"}`
+                                        : undefined,
+                                ),
+                                () => {
+                                    resolve(true);
+                                },
+                            );
+                        } catch (error) {
+                            console.error(`Failed to apply configuration: ${(error as Error).message}`);
+                            failed = true;
+
+                            if (process.env.Z2M_ONBOARD_NO_FAILURE_PAGE) {
+                                res.end(() => {
+                                    resolve(false);
+                                });
+                            } else {
+                                res.setHeader("Content-Type", "text/html");
+                                res.writeHead(406);
+                                res.end(generateHtmlError(`<p>${escapeHtml((error as Error).message)}</p>`));
+                            }
+                        }
+                    });
+                }
+            } else {
+                res.setHeader("Content-Type", "text/html");
+                res.writeHead(200);
+                res.end(generateHtmlForm(currentSettings, await findAllDevices()));
+            }
+        });
+
+        server.listen(Number.parseInt(serverUrl.port), serverUrl.hostname, () => {
+            console.log(`Onboarding page is available at ${serverUrl.href}`);
+        });
+    });
+
+    await new Promise((resolve) => server?.close(resolve));
+
+    return success;
+}
+
+async function startFailureServer(errors: string): Promise<void> {
+    const serverUrl = getServerUrl();
+    let server: ReturnType<typeof createServer> | undefined;
+
+    await new Promise<void>((resolve) => {
+        server = createServer((req, res) => {
+            if (req.method === "POST") {
+                res.end(() => {
+                    resolve();
+                });
+            } else {
+                res.setHeader("Content-Type", "text/html");
+                res.writeHead(406);
+                res.end(generateHtmlError(errors));
+            }
+        });
+
+        server.listen(Number.parseInt(serverUrl.port), serverUrl.hostname, () => {
+            console.error(`Failure page is available at ${serverUrl.href}`);
+        });
+    });
+
+    await new Promise((resolve) => server?.close(resolve));
+}
+
+export async function onboard(): Promise<boolean> {
+    if (!existsSync(data.getPath())) {
+        mkdirSync(data.getPath(), {recursive: true});
+    }
+
+    const confExists = existsSync(data.joinPath("configuration.yaml"));
+
+    if (!confExists) {
+        settings.writeMinimalDefaults();
+    } else {
+        // migrate first
+        const {migrateIfNecessary} = await import("./settingsMigration.js");
+
+        migrateIfNecessary();
+        // trigger initial writing of `ZIGBEE2MQTT_CONFIG_*` ENVs
+        settings.write();
+    }
+
+    // use `configuration.yaml` file to detect "brand new install"
+    // env allows to re-run onboard even with existing install
+    if (!process.env.Z2M_ONBOARD_NO_SERVER && (process.env.Z2M_ONBOARD_FORCE_RUN || !confExists || settings.get().onboarding)) {
+        settings.setOnboarding(true);
+
+        const success = await startOnboardingServer();
+
+        if (!success) {
+            return false;
+        }
+    }
+
+    settings.reRead();
+
+    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);
+        }
+
+        return false;
+    }
+
+    return true;
+}
@@ -0,0 +1,69 @@
+import {platform} from "node:os";
+import type {UnixDgramSocket} from "unix-dgram";
+
+import logger from "./logger";
+
+/**
+ * Handle sd_notify protocol, @see https://www.freedesktop.org/software/systemd/man/latest/sd_notify.html
+ * No-op if running on unsupported platforms or without Type=notify
+ * Soft-fails if improperly setup (this is not necessary for Zigbee2MQTT to function properly)
+ */
+export async function initSdNotify(): Promise<{notifyStopping: () => void; stop: () => void} | undefined> {
+    if (!process.env.NOTIFY_SOCKET) {
+        return;
+    }
+
+    let socket: UnixDgramSocket | undefined;
+
+    try {
+        const {createSocket} = await import("unix-dgram");
+        socket = createSocket("unix_dgram");
+    } catch (error) {
+        if (platform() !== "win32" || process.env.WSL_DISTRO_NAME) {
+            // not on plain Windows
+            logger.error(`Could not init sd_notify: ${(error as Error).message}`);
+            // biome-ignore lint/style/noNonNullAssertion: always Error
+            logger.debug((error as Error).stack!);
+        } else {
+            // this should not happen
+            logger.warning(`NOTIFY_SOCKET env is set: ${(error as Error).message}`);
+        }
+
+        return;
+    }
+
+    const sendToSystemd = (msg: string): void => {
+        const buffer = Buffer.from(msg);
+
+        // biome-ignore lint/style/noNonNullAssertion: valid from start of function
+        socket.send(buffer, 0, buffer.byteLength, process.env.NOTIFY_SOCKET!, (err) => {
+            if (err) {
+                logger.warning(`Failed to send "${msg}" to systemd: ${err.message}`);
+            }
+        });
+    };
+    const notifyStopping = (): void => sendToSystemd("STOPPING=1");
+
+    sendToSystemd("READY=1");
+
+    const wdUSec = process.env.WATCHDOG_USEC !== undefined ? Math.max(0, Number.parseInt(process.env.WATCHDOG_USEC, 10)) : -1;
+
+    if (wdUSec > 0) {
+        // Convert us to ms, send twice as frequently as the timeout
+        const watchdogInterval = setInterval(() => sendToSystemd("WATCHDOG=1"), wdUSec / 1000 / 2);
+
+        return {
+            notifyStopping,
+            stop: (): void => clearInterval(watchdogInterval),
+        };
+    }
+
+    if (wdUSec !== -1) {
+        logger.warning(`WATCHDOG_USEC invalid: "${process.env.WATCHDOG_USEC}", parsed to "${wdUSec}"`);
+    }
+
+    return {
+        notifyStopping,
+        stop: (): void => {},
+    };
+}
@@ -0,0 +1,589 @@
+import {copyFileSync, writeFileSync} from "node:fs";
+
+import data from "./data";
+import * as settings from "./settings";
+import utils from "./utils";
+
+interface SettingsMigration {
+    path: string[];
+    note: string;
+    noteIf?: (previousValue: unknown) => boolean;
+}
+
+interface SettingsAdd extends Omit<SettingsMigration, "noteIf"> {
+    value: unknown;
+}
+
+type SettingsRemove = SettingsMigration;
+
+interface SettingsChange extends SettingsMigration {
+    previousValueAnyOf?: unknown[];
+    newValue: unknown;
+}
+
+interface SettingsTransfer extends SettingsMigration {
+    newPath: string[];
+}
+
+interface SettingsCustomHandler extends Omit<SettingsMigration, "path"> {
+    execute: (currentSettings: Partial<Settings>) => [validPath: boolean, previousValue: unknown, changed: boolean];
+}
+
+const SUPPORTED_VERSIONS: Settings["version"][] = [undefined, 2, 3, settings.CURRENT_VERSION];
+
+function backupSettings(version: number): void {
+    const filePath = data.joinPath("configuration.yaml");
+
+    copyFileSync(filePath, filePath.replace(".yaml", `_backup_v${version}.yaml`));
+}
+
+/**
+ * Set the given path in given settings to given value. If requested, create path.
+ *
+ * @param currentSettings
+ * @param path
+ * @param value
+ * @param createPathIfNotExist
+ * @returns Returns true if value was set, false if not.
+ */
+// biome-ignore lint/suspicious/noExplicitAny: auto-parsing
+function setValue(currentSettings: any, path: string[], value: unknown, createPathIfNotExist = false): boolean {
+    for (let i = 0; i < path.length; i++) {
+        const key = path[i];
+
+        if (i === path.length - 1) {
+            currentSettings[key] = value;
+        } else {
+            if (!currentSettings[key]) {
+                if (createPathIfNotExist) {
+                    currentSettings[key] = {};
+                    /* v8 ignore start */
+                } else {
+                    // invalid path
+                    // ignored in test since currently call is always guarded by get-validated path, so this is never reached
+                    return false;
+                }
+                /* v8 ignore stop */
+            }
+
+            currentSettings = currentSettings[key];
+        }
+    }
+
+    return true;
+}
+
+/**
+ * Get the value at the given path in given settings.
+ *
+ * @param currentSettings
+ * @param path
+ * @returns
+ *   - true if path was valid
+ *   - the value at path
+ */
+// biome-ignore lint/suspicious/noExplicitAny: auto-parsing
+function getValue(currentSettings: any, path: string[]): [validPath: boolean, value: unknown] {
+    for (let i = 0; i < path.length; i++) {
+        const key = path[i];
+        const value = currentSettings[key];
+
+        if (i === path.length - 1) {
+            return [value !== undefined, value];
+        }
+
+        if (!value) {
+            // invalid path
+            break;
+        }
+
+        currentSettings = value;
+    }
+
+    return [false, undefined];
+}
+
+/**
+ * Add a value at given path, path is created as needed.
+ * @param currentSettings
+ * @param addition
+ */
+function addValue(currentSettings: Partial<Settings>, addition: SettingsAdd): void {
+    setValue(currentSettings, addition.path, addition.value, true);
+}
+
+/**
+ * Remove value at given path, if path is valid.
+ * Value is actually set to undefined, which triggers removal when `settings.apply` is called.
+ * @param currentSettings
+ * @param removal
+ * @returns
+ */
+function removeValue(currentSettings: Partial<Settings>, removal: SettingsRemove): [validPath: boolean, previousValue: unknown] {
+    const [validPath, previousValue] = getValue(currentSettings, removal.path);
+
+    if (validPath && previousValue != null) {
+        setValue(currentSettings, removal.path, undefined);
+    }
+
+    return [validPath, previousValue];
+}
+
+/**
+ * Change value at given path, if path is valid, and value matched one of the defined values (if any).
+ * @param currentSettings
+ * @param change
+ * @returns
+ */
+function changeValue(currentSettings: Partial<Settings>, change: SettingsChange): [validPath: boolean, previousValue: unknown, changed: boolean] {
+    const [validPath, previousValue] = getValue(currentSettings, change.path);
+    let changed = false;
+
+    if (validPath && previousValue !== change.newValue) {
+        if (!change.previousValueAnyOf || change.previousValueAnyOf.includes(previousValue)) {
+            setValue(currentSettings, change.path, change.newValue);
+
+            changed = true;
+        }
+    }
+
+    return [validPath, previousValue, changed];
+}
+
+/**
+ * Transfer value at given path, to new path.
+ * Given path must be valid.
+ * New path must not be valid or new path value must be nullish, otherwise given path is removed only.
+ * Value at given path is actually set to undefined, which triggers removal when `settings.apply` is called.
+ * New path is created as needed.
+ * @param currentSettings
+ * @param transfer
+ * @returns
+ */
+function transferValue(
+    currentSettings: Partial<Settings>,
+    transfer: SettingsTransfer,
+): [validPath: boolean, previousValue: unknown, transfered: boolean] {
+    const [validPath, previousValue] = getValue(currentSettings, transfer.path);
+    const [destValidPath, destValue] = getValue(currentSettings, transfer.newPath);
+    const transfered = validPath && previousValue != null && (!destValidPath || destValue == null || Array.isArray(destValue));
+
+    // no point in set if already undefined
+    if (validPath && previousValue != null) {
+        setValue(currentSettings, transfer.path, undefined);
+    }
+
+    if (transfered) {
+        if (Array.isArray(previousValue) && Array.isArray(destValue)) {
+            setValue(currentSettings, transfer.newPath, [...previousValue, ...destValue], true);
+        } else {
+            setValue(currentSettings, transfer.newPath, previousValue, true);
+        }
+    }
+
+    return [validPath, previousValue, transfered];
+}
+
+const noteIfWasTrue = (previousValue: unknown): boolean => previousValue === true;
+const noteIfWasDefined = (previousValue: unknown): boolean => previousValue != null;
+const noteIfWasNonEmptyArray = (previousValue: unknown): boolean => Array.isArray(previousValue) && previousValue.length > 0;
+
+function migrateToTwo(
+    currentSettings: Partial<Settings>,
+    transfers: SettingsTransfer[],
+    changes: SettingsChange[],
+    additions: SettingsAdd[],
+    removals: SettingsRemove[],
+    customHandlers: SettingsCustomHandler[],
+): void {
+    transfers.push(
+        {
+            path: ["advanced", "homeassistant_discovery_topic"],
+            note: "HA discovery_topic was moved from advanced.homeassistant_discovery_topic to homeassistant.discovery_topic.",
+            noteIf: noteIfWasDefined,
+            newPath: ["homeassistant", "discovery_topic"],
+        },
+        {
+            path: ["advanced", "homeassistant_status_topic"],
+            note: "HA status_topic was moved from advanced.homeassistant_status_topic to homeassistant.status_topic.",
+            noteIf: noteIfWasDefined,
+            newPath: ["homeassistant", "status_topic"],
+        },
+        {
+            path: ["advanced", "baudrate"],
+            note: "Baudrate was moved from advanced.baudrate to serial.baudrate.",
+            noteIf: noteIfWasDefined,
+            newPath: ["serial", "baudrate"],
+        },
+        {
+            path: ["advanced", "rtscts"],
+            note: "RTSCTS was moved from advanced.rtscts to serial.rtscts.",
+            noteIf: noteIfWasDefined,
+            newPath: ["serial", "rtscts"],
+        },
+        {
+            path: ["experimental", "transmit_power"],
+            note: "Transmit power was moved from experimental.transmit_power to advanced.transmit_power.",
+            noteIf: noteIfWasDefined,
+            newPath: ["advanced", "transmit_power"],
+        },
+        {
+            path: ["experimental", "output"],
+            note: "Output was moved from experimental.output to advanced.output.",
+            noteIf: noteIfWasDefined,
+            newPath: ["advanced", "output"],
+        },
+        {
+            path: ["ban"],
+            note: "ban was renamed to passlist.",
+            noteIf: noteIfWasDefined,
+            newPath: ["blocklist"],
+        },
+        {
+            path: ["whitelist"],
+            note: "whitelist was renamed to passlist.",
+            noteIf: noteIfWasDefined,
+            newPath: ["passlist"],
+        },
+    );
+
+    changes.push({
+        path: ["advanced", "log_level"],
+        note: `Log level 'warn' has been renamed to 'warning'.`,
+        noteIf: (previousValue): boolean => previousValue === "warn",
+        previousValueAnyOf: ["warn"],
+        newValue: "warning",
+    });
+
+    additions.push({
+        path: ["version"],
+        note: "Migrated settings to version 2",
+        value: 2,
+    });
+
+    const haLegacyTriggers: SettingsRemove = {
+        path: ["homeassistant", "legacy_triggers"],
+        note: "Action and click sensors have been removed (homeassistant.legacy_triggers setting). This means all sensor.*_action and sensor.*_click entities are removed. Use the MQTT device trigger instead.",
+        noteIf: noteIfWasTrue,
+    };
+    const haLegacyEntityAttrs: SettingsRemove = {
+        path: ["homeassistant", "legacy_entity_attributes"],
+        note: "Entity attributes (homeassistant.legacy_entity_attributes setting) has been removed. This means that entities discovered by Zigbee2MQTT will no longer have entity attributes (Home Assistant entity attributes are accessed via e.g. states.binary_sensor.my_sensor.attributes).",
+        noteIf: noteIfWasTrue,
+    };
+    const otaIkeaUseTestUrl: SettingsRemove = {
+        path: ["ota", "ikea_ota_use_test_url"],
+        note: "Due to the OTA rework, the ota.ikea_ota_use_test_url option has been removed.",
+        noteIf: noteIfWasTrue,
+    };
+
+    removals.push(
+        haLegacyTriggers,
+        haLegacyEntityAttrs,
+        {
+            path: ["advanced", "homeassistant_legacy_triggers"],
+            note: haLegacyTriggers.note,
+            noteIf: haLegacyTriggers.noteIf,
+        },
+        {
+            path: ["advanced", "homeassistant_legacy_entity_attributes"],
+            note: haLegacyEntityAttrs.note,
+            noteIf: haLegacyEntityAttrs.noteIf,
+        },
+        {
+            path: ["permit_join"],
+            note: "The permit_join setting has been removed, use the frontend or MQTT to permit joining.",
+            noteIf: noteIfWasTrue,
+        },
+        otaIkeaUseTestUrl,
+        {
+            path: ["advanced", "ikea_ota_use_test_url"],
+            note: otaIkeaUseTestUrl.note,
+            noteIf: otaIkeaUseTestUrl.noteIf,
+        },
+        {
+            path: ["advanced", "legacy_api"],
+            note: "The MQTT legacy API has been removed (advanced.legacy_api setting). See link below for affected topics.",
+            noteIf: noteIfWasTrue,
+        },
+        {
+            path: ["advanced", "legacy_availability_payload"],
+            note: 'Due to the removal of advanced.legacy_availability_payload, zigbee2mqtt/bridge/state will now always be a JSON object ({"state":"online"} or {"state":"offline"})',
+            noteIf: noteIfWasTrue,
+        },
+        {
+            path: ["advanced", "soft_reset_timeout"],
+            note: "Removed deprecated: Soft reset feature (advanced.soft_reset_timeout setting)",
+            noteIf: noteIfWasDefined,
+        },
+        {
+            path: ["advanced", "report"],
+            note: "Removed deprecated: Report feature (advanced.report setting)",
+            noteIf: noteIfWasTrue,
+        },
+        {
+            path: ["advanced", "availability_timeout"],
+            note: "Removed deprecated: advanced.availability_timeout availability settings",
+            noteIf: noteIfWasDefined,
+        },
+        {
+            path: ["advanced", "availability_blocklist"],
+            note: "Removed deprecated: advanced.availability_blocklist availability settings",
+            noteIf: noteIfWasNonEmptyArray,
+        },
+        {
+            path: ["advanced", "availability_passlist"],
+            note: "Removed deprecated: advanced.availability_passlist availability settings",
+            noteIf: noteIfWasNonEmptyArray,
+        },
+        {
+            path: ["advanced", "availability_blacklist"],
+            note: "Removed deprecated: advanced.availability_blacklist availability settings",
+            noteIf: noteIfWasNonEmptyArray,
+        },
+        {
+            path: ["advanced", "availability_whitelist"],
+            note: "Removed deprecated: advanced.availability_whitelist availability settings",
+            noteIf: noteIfWasNonEmptyArray,
+        },
+        {
+            path: ["device_options", "legacy"],
+            note: "Removed everything that was enabled through device_options.legacy. See link below for affected devices.",
+            noteIf: noteIfWasTrue,
+        },
+        {
+            path: ["experimental"],
+            note: "The entire experimental section was removed.",
+            noteIf: noteIfWasDefined,
+        },
+        {
+            path: ["external_converters"],
+            note: "External converters are now automatically loaded from the 'data/external_converters' directory without requiring settings to be set. Make sure your external converters are still needed (might be supported out-of-the-box now), and if so, move them to that directory.",
+            noteIf: noteIfWasNonEmptyArray,
+        },
+    );
+
+    // note only once
+    const noteEntityOptionsRetrieveState = "Retrieve state option ((devices|groups).xyz.retrieve_state setting)";
+
+    for (const deviceKey in currentSettings.devices) {
+        removals.push({
+            path: ["devices", deviceKey, "retrieve_state"],
+            note: noteEntityOptionsRetrieveState,
+            noteIf: noteIfWasTrue,
+        });
+    }
+
+    for (const groupKey in currentSettings.groups) {
+        removals.push({
+            path: ["groups", groupKey, "retrieve_state"],
+            note: noteEntityOptionsRetrieveState,
+            noteIf: noteIfWasTrue,
+        });
+        removals.push({
+            path: ["groups", groupKey, "devices"],
+            note: "Removed configuring group members through configuration.yaml (groups.xyz.devices setting). This will not impact current group members; however, you will no longer be able to add or remove devices from a group through the configuration.yaml.",
+            noteIf: noteIfWasDefined,
+        });
+    }
+
+    customHandlers.push();
+}
+
+function migrateToThree(
+    _currentSettings: Partial<Settings>,
+    transfers: SettingsTransfer[],
+    changes: SettingsChange[],
+    additions: SettingsAdd[],
+    removals: SettingsRemove[],
+    customHandlers: SettingsCustomHandler[],
+): void {
+    transfers.push();
+    changes.push({
+        path: ["version"],
+        note: "Migrated settings to version 3",
+        newValue: 3,
+    });
+    additions.push();
+    removals.push();
+
+    const changeToObject = (currentSettings: Partial<Settings>, path: string[]): ReturnType<SettingsCustomHandler["execute"]> => {
+        const [validPath, previousValue] = getValue(currentSettings, path);
+
+        if (validPath) {
+            if (typeof previousValue === "boolean") {
+                setValue(currentSettings, path, {enabled: previousValue});
+            } else {
+                setValue(currentSettings, path, {enabled: true, ...(previousValue as object)});
+            }
+        }
+
+        return [validPath, previousValue, validPath];
+    };
+
+    customHandlers.push(
+        {
+            note: `Property 'homeassistant' is now always an object.`,
+            noteIf: () => true,
+            execute: (currentSettings) => changeToObject(currentSettings, ["homeassistant"]),
+        },
+        {
+            note: `Property 'frontend' is now always an object.`,
+            noteIf: () => true,
+            execute: (currentSettings) => changeToObject(currentSettings, ["frontend"]),
+        },
+        {
+            note: `Property 'availability' is now always an object.`,
+            noteIf: () => true,
+            execute: (currentSettings) => changeToObject(currentSettings, ["availability"]),
+        },
+    );
+}
+
+function migrateToFour(
+    _currentSettings: Partial<Settings>,
+    transfers: SettingsTransfer[],
+    changes: SettingsChange[],
+    additions: SettingsAdd[],
+    removals: SettingsRemove[],
+    customHandlers: SettingsCustomHandler[],
+): void {
+    transfers.push();
+    changes.push({
+        path: ["version"],
+        note: "Migrated settings to version 4",
+        newValue: 4,
+    });
+    additions.push();
+    removals.push();
+
+    const saveBase64DeviceIconsAsImage = (currentSettings: Partial<Settings>): ReturnType<SettingsCustomHandler["execute"]> => {
+        const [validPath, previousValue] = getValue(currentSettings, ["devices"]);
+        let changed = false;
+
+        if (validPath) {
+            for (const deviceKey in currentSettings.devices) {
+                const base64Match = utils.matchBase64File(currentSettings.devices[deviceKey].icon);
+                if (base64Match) {
+                    changed = true;
+                    currentSettings.devices[deviceKey].icon = utils.saveBase64DeviceIcon(base64Match);
+                }
+            }
+        }
+
+        return [validPath, previousValue, changed];
+    };
+
+    customHandlers.push({
+        note: "Device icons are now saved as images.",
+        noteIf: () => true,
+        execute: (currentSettings) => saveBase64DeviceIconsAsImage(currentSettings),
+    });
+}
+
+/**
+ * Order of execution:
+ * - Transfer
+ * - Change
+ * - Add
+ * - Remove
+ *
+ * Should allow the most flexibility whenever combination of migrations is necessary (e.g. Transfer + Change)
+ */
+export function migrateIfNecessary(): void {
+    const currentSettings = settings.getPersistedSettings();
+
+    if (!SUPPORTED_VERSIONS.includes(currentSettings.version)) {
+        throw new Error(
+            `Your configuration.yaml has an unsupported version ${currentSettings.version}, expected one of ${SUPPORTED_VERSIONS.map((v) => String(v)).join(",")}.`,
+        );
+    }
+
+    /* v8 ignore next */
+    const finalVersion = process.env.VITEST_WORKER_ID ? settings.testing.CURRENT_VERSION : settings.CURRENT_VERSION;
+
+    if (currentSettings.version === finalVersion) {
+        // when same version as current, nothing to do
+        return;
+    }
+
+    while (currentSettings.version !== finalVersion) {
+        let migrationNotesFileName: string | undefined;
+        // don't duplicate outputs
+        const migrationNotes = new Set<string>();
+        const transfers: SettingsTransfer[] = [];
+        const changes: SettingsChange[] = [];
+        const additions: SettingsAdd[] = [];
+        const removals: SettingsRemove[] = [];
+        const customHandlers: SettingsCustomHandler[] = [];
+
+        backupSettings(currentSettings.version || 1);
+
+        // each version should only bump to the next version so as to gradually migrate if necessary
+        if (currentSettings.version == null) {
+            // migrating from 1 (`version` did not exist) to 2
+            migrationNotesFileName = "migration-1-to-2.log";
+
+            migrateToTwo(currentSettings, transfers, changes, additions, removals, customHandlers);
+        } else if (currentSettings.version === 2) {
+            migrationNotesFileName = "migration-2-to-3.log";
+
+            migrateToThree(currentSettings, transfers, changes, additions, removals, customHandlers);
+        } else if (currentSettings.version === 3) {
+            migrationNotesFileName = "migration-3-to-4.log";
+
+            migrateToFour(currentSettings, transfers, changes, additions, removals, customHandlers);
+        }
+
+        for (const transfer of transfers) {
+            const [validPath, previousValue, transfered] = transferValue(currentSettings, transfer);
+
+            if (validPath && (!transfer.noteIf || transfer.noteIf(previousValue))) {
+                migrationNotes.add(`[${transfered ? "TRANSFER" : "REMOVAL"}] ${transfer.note}`);
+            }
+        }
+
+        for (const change of changes) {
+            const [validPath, previousValue, changed] = changeValue(currentSettings, change);
+
+            if (validPath && changed && (!change.noteIf || change.noteIf(previousValue))) {
+                migrationNotes.add(`[CHANGE] ${change.note}`);
+            }
+        }
+
+        for (const addition of additions) {
+            addValue(currentSettings, addition);
+
+            migrationNotes.add(`[ADDITION] ${addition.note}`);
+        }
+
+        for (const removal of removals) {
+            const [validPath, previousValue] = removeValue(currentSettings, removal);
+
+            if (validPath && (!removal.noteIf || removal.noteIf(previousValue))) {
+                migrationNotes.add(`[REMOVAL] ${removal.note}`);
+            }
+        }
+
+        for (const customHandler of customHandlers) {
+            const [validPath, previousValue, changed] = customHandler.execute(currentSettings);
+
+            if (validPath && changed && (!customHandler.noteIf || customHandler.noteIf(previousValue))) {
+                migrationNotes.add(`[SPECIAL] ${customHandler.note}`);
+            }
+        }
+
+        if (migrationNotesFileName && migrationNotes.size > 0) {
+            migrationNotes.add("For more details, see https://github.com/Koenkk/zigbee2mqtt/discussions/24198");
+            const migrationNotesFilePath = data.joinPath(migrationNotesFileName);
+
+            writeFileSync(migrationNotesFilePath, Array.from(migrationNotes).join("\r\n\r\n"), "utf8");
+
+            console.log(`Migration notes written in ${migrationNotesFilePath}`);
+        }
+    }
+
+    // don't throw, onboarding will validate at end of process
+    settings.apply(currentSettings as unknown as Record<string, unknown>, false);
+    settings.reRead();
+}
@@ -1,12 +1,21 @@
-import equals from 'fast-deep-equal/es6';
-import humanizeDuration from 'humanize-duration';
-import data from './data';
-import vm from 'vm';
-import fs from 'fs';
-import path from 'path';
-import {detailedDiff} from 'deep-object-diff';
-import objectAssignDeep from 'object-assign-deep';
-import type * as zhc from 'zigbee-herdsman-converters';
+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>.+)/;
+
+function pad(num: number): string {
+    const norm = Math.floor(Math.abs(num));
+    return (norm < 10 ? "0" : "") + norm;
+}

 // construct a local ISO8601 string (instead of UTC-based)
 // Example:
@@ -14,77 +23,74 @@ import type * as zhc from 'zigbee-herdsman-converters';
 //  - ISO8601 (local) = 2019-03-01T16:32:45.941+0100 (for timezone GMT+1)
 function toLocalISOString(date: Date): string {
    const tzOffset = -date.getTimezoneOffset();
-    const plusOrMinus = tzOffset >= 0 ? '+' : '-';
-    const pad = (num: number): string => {
-        const norm = Math.floor(Math.abs(num));
-        return (norm < 10 ? '0' : '') + norm;
-    };
+    const plusOrMinus = tzOffset >= 0 ? "+" : "-";

-    return date.getFullYear() +
-        '-' + pad(date.getMonth() + 1) +
-        '-' + pad(date.getDate()) +
-        'T' + pad(date.getHours()) +
-        ':' + pad(date.getMinutes()) +
-        ':' + pad(date.getSeconds()) +
-        plusOrMinus + pad(tzOffset / 60) +
-        ':' + pad(tzOffset % 60);
+    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}T${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}${plusOrMinus}${pad(tzOffset / 60)}:${pad(tzOffset % 60)}`;
 }

 function capitalize(s: string): string {
    return s[0].toUpperCase() + s.slice(1);
 }

-async function getZigbee2MQTTVersion(includeCommitHash=true): Promise<{commitHash: string, version: string}> {
-    const git = await import('git-last-commit');
-    const packageJSON = await import('../..' + '/package.json');
+export async function getZigbee2MQTTVersion(includeCommitHash = true): Promise<{commitHash?: string; version: string}> {
+    const packageJSON = (await import("../../package.json", {with: {type: "json"}})).default;
+    const version = packageJSON.version;
+    let commitHash: string | undefined;

    if (!includeCommitHash) {
-        return {version: packageJSON.version, commitHash: null};
+        return {version, commitHash};
    }

-    return new Promise((resolve) => {
-        const version = packageJSON.version;
+    return await new Promise((resolve) => {
+        exec("git rev-parse --short=8 HEAD", (error, stdout) => {
+            commitHash = stdout.trim();

-        git.getLastCommit((err: Error, commit: {shortHash: string}) => {
-            let commitHash = null;
-
-            if (err) {
+            if (error || commitHash === "") {
                try {
-                    commitHash = fs.readFileSync(path.join(__dirname, '..', '..', 'dist', '.hash'), 'utf-8');
-                } catch (error) {
-                    /* istanbul ignore next */
-                    commitHash = 'unknown';
+                    commitHash = fs.readFileSync(path.join(__dirname, "..", "..", "dist", ".hash"), "utf-8");
+                } catch {
+                    commitHash = "unknown";
                }
-            } else {
-                commitHash = commit.shortHash;
            }

-            commitHash = commitHash.trim();
            resolve({commitHash, version});
        });
    });
 }

 async function getDependencyVersion(depend: string): Promise<{version: string}> {
-    const modulePath = path.dirname(require.resolve(depend));
-    const packageJSONPath = path.join(modulePath.slice(0, modulePath.indexOf(depend) + depend.length), 'package.json');
-    const packageJSON = await import(packageJSONPath);
-    const version = packageJSON.version;
-    return {version};
+    const packageJSON = (await import(`${depend}/package.json`, {with: {type: "json"}})).default;
+    return {version: packageJSON.version};
 }

-function formatDate(time: number, type: 'ISO_8601' | 'ISO_8601_local' | 'epoch' | 'relative'): string | number {
-    if (type === 'ISO_8601') return new Date(time).toISOString();
-    else if (type === 'ISO_8601_local') return toLocalISOString(new Date(time));
-    else if (type === 'epoch') return time;
-    else { // relative
-        return humanizeDuration(Date.now() - time, {language: 'en', largest: 2, round: true}) + ' ago';
+function formatDate(time: number, type: "ISO_8601" | "ISO_8601_local" | "epoch" | "relative"): string | number {
+    switch (type) {
+        case "ISO_8601":
+            // ISO8601 (UTC) = 2019-03-01T15:32:45.941Z
+            return new Date(time).toISOString();
+
+        case "ISO_8601_local":
+            // ISO8601 (local) = 2019-03-01T16:32:45.941+01:00 (for timezone GMT+1)
+            return toLocalISOString(new Date(time));
+
+        case "epoch":
+            return time;
+
+        default:
+            // relative
+            return `${humanizeDuration(Date.now() - time, {language: "en", largest: 2, round: true})} ago`;
    }
 }

+function objectIsEmpty(object: object): boolean {
+    // much faster than checking `Object.keys(object).length`
+    for (const _k in object) return false;
+    return true;
+}
+
 function objectHasProperties(object: {[s: string]: unknown}, properties: string[]): boolean {
    for (const property of properties) {
-        if (!object.hasOwnProperty(property)) {
+        if (object[property] === undefined) {
            return false;
        }
    }
@@ -102,119 +108,90 @@ function equalsPartial(object: KeyValue, expected: KeyValue): boolean {
    return true;
 }

-function getObjectProperty(object: KeyValue, key: string, defaultValue: unknown): unknown {
-    return object && object.hasOwnProperty(key) ? object[key] : defaultValue;
+function getObjectProperty<T>(object: KeyValue, key: string, defaultValue: NoInfer<T>): T {
+    return object && object[key] !== undefined ? object[key] : defaultValue;
 }

-function getResponse(request: KeyValue | string, data: KeyValue, error: string): MQTTResponse {
-    const response: MQTTResponse = {data, status: error ? 'error' : 'ok'};
-    if (error) response.error = error;
-    if (typeof request === 'object' && request.hasOwnProperty('transaction')) {
+function getResponse<T extends Zigbee2MQTTResponseEndpoints>(
+    request: KeyValue | string,
+    data: Zigbee2MQTTAPI[T],
+    error?: string,
+): Zigbee2MQTTResponse<T> {
+    if (error !== undefined) {
+        const response: Zigbee2MQTTResponse<T> = {
+            data: {}, // always return an empty `data` payload on error
+            status: "error",
+            error: error,
+        };
+
+        if (typeof request === "object" && request.transaction !== undefined) {
+            response.transaction = request.transaction;
+        }
+
+        return response;
+    }
+
+    const response: Zigbee2MQTTResponse<T> = {
+        data, // valid from error check
+        status: "ok",
+    };
+
+    if (typeof request === "object" && request.transaction !== undefined) {
        response.transaction = request.transaction;
    }
+
    return response;
 }

 function parseJSON(value: string, fallback: string): KeyValue | string {
    try {
        return JSON.parse(value);
-    } catch (e) {
+    } catch {
        return fallback;
    }
 }

-function loadModuleFromText(moduleCode: string, name?: string): unknown {
-    const moduleFakePath = path.join(__dirname, '..', '..', 'data', 'extension', name || 'externally-loaded.js');
-    const sandbox = {
-        require: require,
-        module: {},
-        console,
-        setTimeout,
-        clearTimeout,
-        setInterval,
-        clearInterval,
-        setImmediate,
-        clearImmediate,
-    };
-    vm.runInNewContext(moduleCode, sandbox, moduleFakePath);
-    /* eslint-disable-line */ // @ts-ignore
-    return sandbox.module.exports;
-}
-
-function loadModuleFromFile(modulePath: string): unknown {
-    const moduleCode = fs.readFileSync(modulePath, {encoding: 'utf8'});
-    return loadModuleFromText(moduleCode);
-}
-
-export function* loadExternalConverter(moduleName: string): Generator<ExternalDefinition> {
-    let converter;
-
-    if (moduleName.endsWith('.js')) {
-        converter = loadModuleFromFile(data.joinPath(moduleName));
-    } else {
-        converter = require(moduleName);
-    }
-
-    if (Array.isArray(converter)) {
-        for (const item of converter) {
-            yield item;
-        }
-    } else {
-        yield converter;
-    }
-}
-
-function removeNullPropertiesFromObject(obj: KeyValue): void {
+/**
+ * Delete all keys from passed object that have null/undefined values.
+ *
+ * @param {KeyValue} obj Object to process (in-place)
+ * @param {string[]} [ignoreKeys] Recursively ignore these keys in the object (keep null/undefined values).
+ */
+function removeNullPropertiesFromObject(obj: KeyValue, ignoreKeys: string[] = []): void {
    for (const key of Object.keys(obj)) {
+        if (ignoreKeys.includes(key)) {
+            continue;
+        }
+
        const value = obj[key];
+
        if (value == null) {
            delete obj[key];
-        } else if (typeof value === 'object') {
-            removeNullPropertiesFromObject(value);
+        } else if (typeof value === "object") {
+            removeNullPropertiesFromObject(value, ignoreKeys);
        }
    }
 }

 function toNetworkAddressHex(value: number): string {
    const hex = value.toString(16);
-    return `0x${'0'.repeat(4 - hex.length)}${hex}`;
-}
-
-// eslint-disable-next-line
-function toSnakeCase(value: string | KeyValue): any {
-    if (typeof value === 'object') {
-        value = {...value};
-        for (const key of Object.keys(value)) {
-            const keySnakeCase = toSnakeCase(key);
-            if (key !== keySnakeCase) {
-                value[keySnakeCase] = value[key];
-                delete value[key];
-            }
-        }
-        return value;
-    } else {
-        return value.replace(/\.?([A-Z])/g, (x, y) => '_' + y.toLowerCase()).replace(/^_/, '').replace('_i_d', '_id');
-    }
+    return `0x${"0".repeat(4 - hex.length)}${hex}`;
 }

 function charRange(start: string, stop: string): number[] {
    const result = [];
-    for (let idx=start.charCodeAt(0), end=stop.charCodeAt(0); idx <=end; ++idx) {
+    for (let idx = start.charCodeAt(0), end = stop.charCodeAt(0); idx <= end; ++idx) {
        result.push(idx);
    }
    return result;
 }

-const controlCharacters = [
-    ...charRange('\u0000', '\u001F'),
-    ...charRange('\u007f', '\u009F'),
-    ...charRange('\ufdd0', '\ufdef'),
-];
+const controlCharacters = [...charRange("\u0000", "\u001F"), ...charRange("\u007f", "\u009F"), ...charRange("\ufdd0", "\ufdef")];

 function containsControlCharacter(str: string): boolean {
    for (let i = 0; i < str.length; i++) {
        const ch = str.charCodeAt(i);
-        if (controlCharacters.includes(ch) || [0xFFFE, 0xFFFF].includes(ch & 0xFFFF)) {
+        if (controlCharacters.includes(ch) || [0xfffe, 0xffff].includes(ch & 0xffff)) {
            return true;
        }
    }
@@ -234,14 +211,14 @@ function getAllFiles(path_: string): string[] {
    return result;
 }

-function validateFriendlyName(name: string, throwFirstError=false): string[] {
+function validateFriendlyName(name: string, throwFirstError = false): string[] {
    const errors = [];

-    if (name.length === 0) errors.push(`friendly_name must be at least 1 char long`);
-    if (name.endsWith('/') || name.startsWith('/')) errors.push(`friendly_name is not allowed to end or start with /`);
-    if (containsControlCharacter(name)) errors.push(`friendly_name is not allowed to contain control char`);
+    if (name.length === 0) errors.push("friendly_name must be at least 1 char long");
+    if (name.endsWith("/") || name.startsWith("/")) errors.push("friendly_name is not allowed to end or start with /");
+    if (containsControlCharacter(name)) errors.push("friendly_name is not allowed to contain control char");
    if (name.match(/.*\/\d*$/)) errors.push(`Friendly name cannot end with a "/DIGIT" ('${name}')`);
-    if (name.includes('#') || name.includes('+')) {
+    if (name.includes("#") || name.includes("+")) {
        errors.push(`MQTT wildcard (+ and #) not allowed in friendly_name ('${name}')`);
    }

@@ -257,42 +234,37 @@ function sleep(seconds: number): Promise<void> {
 }

 function sanitizeImageParameter(parameter: string): string {
-    const replaceByDash = [/\?/g, /&/g, /[^a-z\d\- _./:]/gi];
-    let sanitized = parameter;
-    replaceByDash.forEach((r) => sanitized = sanitized.replace(r, '-'));
-    return sanitized;
+    return parameter.replace(/\?|&|[^a-z\d\- _./:]/gi, "-");
 }

 function isAvailabilityEnabledForEntity(entity: Device | Group, settings: Settings): boolean {
-    if (entity.isGroup()) {
-        return !entity.membersDevices().map((d) => isAvailabilityEnabledForEntity(d, settings)).includes(false);
+    if (entity.isDevice() && entity.options.disabled) {
+        return false;
    }

-    if (entity.options.hasOwnProperty('availability')) {
+    if (entity.isGroup()) {
+        for (const memberDevice of entity.membersDevices()) {
+            if (!isAvailabilityEnabledForEntity(memberDevice, settings)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    if (entity.options.availability != null) {
        return !!entity.options.availability;
    }

-    // availability_timeout = deprecated
-    const enabledGlobal = settings.advanced.availability_timeout || settings.availability;
-    if (!enabledGlobal) return false;
-
-    if (entity.isDevice() && entity.options.disabled) return false;
-
-    const passlist = settings.advanced.availability_passlist.concat(settings.advanced.availability_whitelist);
-    if (passlist.length > 0) {
-        return passlist.includes(entity.name) || passlist.includes(entity.ieeeAddr);
-    }
-
-    const blocklist = settings.advanced.availability_blacklist.concat(settings.advanced.availability_blocklist);
-    return !blocklist.includes(entity.name) && !blocklist.includes(entity.ieeeAddr);
+    return settings.availability.enabled;
 }

-function isEndpoint(obj: unknown): obj is zh.Endpoint {
-    return obj.constructor.name.toLowerCase() === 'endpoint';
+function isZHEndpoint(obj: unknown): obj is zh.Endpoint {
+    return obj?.constructor.name.toLowerCase() === "endpoint";
 }

 function flatten<Type>(arr: Type[][]): Type[] {
-    return [].concat(...arr);
+    return ([] as Type[]).concat(...arr);
 }

 function arrayUnique<Type>(arr: Type[]): Type[] {
@@ -300,19 +272,19 @@ function arrayUnique<Type>(arr: Type[]): Type[] {
 }

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

-function availabilityPayload(state: 'online' | 'offline', settings: Settings): string {
-    return settings.advanced.legacy_availability_payload ? state : JSON.stringify({state});
-}
+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;

-const hours = (hours: number): number => 1000 * 60 * 60 * hours;
-const minutes = (minutes: number): number => 1000 * 60 * minutes;
-const seconds = (seconds: number): number => 1000 * seconds;
-
-function publishLastSeen(data: eventdata.LastSeenChanged, settings: Settings, allowMessageEmitted: boolean,
-    publishEntityState: PublishEntityState): void {
+async function publishLastSeen(
+    data: eventdata.LastSeenChanged,
+    settings: Settings,
+    allowMessageEmitted: boolean,
+    publishEntityState: PublishEntityState,
+): Promise<void> {
    /**
     * Prevent 2 MQTT publishes when 1 message event is received;
     * - In case reason == messageEmitted, receive.ts will only call this when it did not publish a
@@ -320,13 +292,13 @@ function publishLastSeen(data: eventdata.LastSeenChanged, settings: Settings, al
     * - In case reason !== messageEmitted, controller.ts will call this based on the zigbee-herdsman
     *      lastSeenChanged event.
     */
-    const allow = data.reason !== 'messageEmitted' || (data.reason === 'messageEmitted' && allowMessageEmitted);
-    if (settings.advanced.last_seen && settings.advanced.last_seen !== 'disable' && allow) {
-        publishEntityState(data.device, {}, 'lastSeenChanged');
+    const allow = data.reason !== "messageEmitted" || (data.reason === "messageEmitted" && allowMessageEmitted);
+    if (settings.advanced.last_seen && settings.advanced.last_seen !== "disable" && allow) {
+        await publishEntityState(data.device, {}, "lastSeenChanged");
    }
 }

-function filterProperties(filter: string[], data: KeyValue): void {
+function filterProperties(filter: string[] | undefined, data: KeyValue): void {
    if (filter) {
        for (const property of Object.keys(data)) {
            if (filter.find((p) => property.match(`^${p}$`))) {
@@ -336,65 +308,50 @@ function filterProperties(filter: string[], data: KeyValue): void {
    }
 }

-function clone(obj: KeyValue): KeyValue {
-    return JSON.parse(JSON.stringify(obj));
+export function isNumericExpose(expose: zhc.Expose): expose is zhc.Numeric {
+    return expose?.type === "numeric";
 }

-export function isNumericExposeFeature(feature: zhc.Feature): feature is zhc.Numeric {
-    return feature?.type === 'numeric';
+export function assertEnumExpose(expose: zhc.Expose): asserts expose is zhc.Enum {
+    assert(expose?.type === "enum");
 }

-export function isEnumExposeFeature(feature: zhc.Feature): feature is zhc.Enum {
-    return feature?.type === 'enum';
+export function assertNumericExpose(expose: zhc.Expose): asserts expose is zhc.Numeric {
+    assert(expose?.type === "numeric");
 }

-export function isBinaryExposeFeature(feature: zhc.Feature): feature is zhc.Binary {
-    return feature?.type === 'binary';
+export function assertBinaryExpose(expose: zhc.Expose): asserts expose is zhc.Binary {
+    assert(expose?.type === "binary");
 }

-function computeSettingsToChange(current: KeyValue, new_: KeyValue): KeyValue {
-    const diff: KeyValue = detailedDiff(current, new_);
-
-    // Remove any settings that are in the deleted.diff but not in the passed options
-    const cleanupDeleted = (options: KeyValue, deleted: KeyValue): void => {
-        for (const key of Object.keys(deleted)) {
-            if (!(key in options)) {
-                delete deleted[key];
-            } else if (!Array.isArray(options[key])) {
-                cleanupDeleted(options[key], deleted[key]);
-            }
-        }
-    };
-    cleanupDeleted(new_, diff.deleted);
-
-    // objectAssignDeep requires object prototype which is missing from detailedDiff, therefore clone
-    const newSettings = objectAssignDeep({}, clone(diff.added), clone(diff.updated), clone(diff.deleted));
-
-    // deep-object-diff converts arrays to objects, set original array back here
-    const convertBackArray = (before: KeyValue, after: KeyValue): void => {
-        for (const [key, afterValue] of Object.entries(after)) {
-            const beforeValue = before[key];
-            if (Array.isArray(beforeValue)) {
-                after[key] = beforeValue;
-            } else if (afterValue && typeof beforeValue === 'object') {
-                convertBackArray(beforeValue, afterValue);
-            }
-        }
-    };
-    convertBackArray(new_, newSettings);
-    return newSettings;
+export function isEnumExpose(expose: zhc.Expose): expose is zhc.Enum {
+    return expose?.type === "enum";
 }

-function getScenes(entity: zh.Endpoint | zh.Group): Scene[] {
-    const scenes: {[id: number]: Scene} = {};
-    const endpoints = isEndpoint(entity) ? [entity] : entity.members;
-    const groupID = isEndpoint(entity) ? 0 : entity.groupID;
+export function isBinaryExpose(expose: zhc.Expose): expose is zhc.Binary {
+    return expose?.type === "binary";
+}
+
+export function isLightExpose(expose: zhc.Expose): expose is zhc.Light {
+    return expose.type === "light";
+}
+
+export function assertString(value: unknown, property: string): asserts value is string {
+    if (typeof value !== "string") {
+        throw new Error(`${property} is not a string, got ${typeof value} (${value})`);
+    }
+}
+
+function getScenes(entity: zh.Endpoint | zh.Group): Zigbee2MQTTScene[] {
+    const scenes: {[id: number]: Zigbee2MQTTScene} = {};
+    const endpoints = isZHEndpoint(entity) ? [entity] : entity.members;
+    const groupID = isZHEndpoint(entity) ? 0 : entity.groupID;

    for (const endpoint of endpoints) {
        for (const [key, data] of Object.entries(endpoint.meta?.scenes || {})) {
-            const split = key.split('_');
-            const sceneID = parseInt(split[0], 10);
-            const sceneGroupID = parseInt(split[1], 10);
+            const split = key.split("_");
+            const sceneID = Number.parseInt(split[0], 10);
+            const sceneGroupID = Number.parseInt(split[1], 10);
            if (sceneGroupID === groupID) {
                scenes[sceneID] = {id: sceneID, name: (data as KeyValue).name || `Scene ${sceneID}`};
            }
@@ -404,11 +361,63 @@ function getScenes(entity: zh.Endpoint | zh.Group): Scene[] {
    return Object.values(scenes);
 }

+function deviceNotCoordinator(device: zh.Device): boolean {
+    return device.type !== "Coordinator";
+}
+
+function matchBase64File(value: string | undefined): {extension: string; data: string} | false {
+    if (value !== undefined) {
+        const match = value.match(BASE64_IMAGE_REGEX);
+        if (match) {
+            assert(match.groups?.extension && match.groups?.data);
+            return {extension: match.groups.extension, data: match.groups.data};
+        }
+    }
+    return false;
+}
+
+function saveBase64DeviceIcon(base64Match: {extension: string; data: string}): string {
+    const md5Hash = crypto.createHash("md5").update(base64Match.data).digest("hex");
+    const fileSettings = `device_icons/${md5Hash}.${base64Match.extension}`;
+    const file = path.join(data.getPath(), fileSettings);
+    fs.mkdirSync(path.dirname(file), {recursive: true});
+    fs.writeFileSync(file, base64Match.data, {encoding: "base64"});
+    return fileSettings;
+}
+
+/* v8 ignore next */
+const noop = (): void => {};
+
 export default {
-    capitalize, getZigbee2MQTTVersion, getDependencyVersion, formatDate, objectHasProperties,
-    equalsPartial, getObjectProperty, getResponse, parseJSON, loadModuleFromText, loadModuleFromFile,
-    removeNullPropertiesFromObject, toNetworkAddressHex, toSnakeCase,
-    isEndpoint, isZHGroup, hours, minutes, seconds, validateFriendlyName, sleep,
-    sanitizeImageParameter, isAvailabilityEnabledForEntity, publishLastSeen, availabilityPayload,
-    getAllFiles, filterProperties, flatten, arrayUnique, clone, computeSettingsToChange, getScenes,
+    matchBase64File,
+    saveBase64DeviceIcon,
+    capitalize,
+    getZigbee2MQTTVersion,
+    getDependencyVersion,
+    formatDate,
+    objectIsEmpty,
+    objectHasProperties,
+    equalsPartial,
+    getObjectProperty,
+    getResponse,
+    parseJSON,
+    removeNullPropertiesFromObject,
+    toNetworkAddressHex,
+    isZHEndpoint,
+    isZHGroup,
+    hours,
+    minutes,
+    seconds,
+    validateFriendlyName,
+    sleep,
+    sanitizeImageParameter,
+    isAvailabilityEnabledForEntity,
+    publishLastSeen,
+    getAllFiles,
+    filterProperties,
+    flatten,
+    arrayUnique,
+    getScenes,
+    deviceNotCoordinator,
+    noop,
 };
@@ -1,26 +1,44 @@
-import yaml from 'js-yaml';
-import fs from 'fs';
-import equals from 'fast-deep-equal/es6';
+import assert from "node:assert";
+import fs from "node:fs";
+
+import equals from "fast-deep-equal/es6";
+import yaml, {YAMLException} from "js-yaml";
+
+export class YAMLFileException extends YAMLException {
+    file: string;
+
+    constructor(error: YAMLException, file: string) {
+        super(error.reason, error.mark);
+
+        this.name = "YAMLFileException";
+        this.cause = error.cause;
+        this.message = error.message;
+        this.stack = error.stack;
+        this.file = file;
+    }
+}

 function read(file: string): KeyValue {
    try {
-        const result = yaml.load(fs.readFileSync(file, 'utf8'));
-        return result as KeyValue ?? {};
+        const result = yaml.load(fs.readFileSync(file, "utf8"));
+        assert(result instanceof Object);
+        return result as KeyValue;
    } catch (error) {
-        if (error.name === 'YAMLException') {
-            error.file = file;
+        if (error instanceof YAMLException) {
+            throw new YAMLFileException(error, file);
        }

        throw error;
    }
 }

-function readIfExists(file: string, default_?: KeyValue): KeyValue {
-    return fs.existsSync(file) ? read(file) : default_;
+function readIfExists(file: string, fallback: KeyValue = {}): KeyValue {
+    return fs.existsSync(file) ? read(file) : fallback;
 }

 function writeIfChanged(file: string, content: KeyValue): void {
    const before = readIfExists(file);
+
    if (!equals(before, content)) {
        fs.writeFileSync(file, yaml.dump(content));
    }
@@ -1,44 +1,47 @@
-import {Controller} from 'zigbee-herdsman';
-import logger from './util/logger';
-import * as settings from './util/settings';
-import data from './util/data';
-import utils from './util/utils';
-import objectAssignDeep from 'object-assign-deep';
-import stringify from 'json-stable-stringify-without-jsonify';
-import Device from './model/device';
-import Group from './model/group';
-import * as ZHEvents from 'zigbee-herdsman/dist/controller/events';
-import bind from 'bind-decorator';
-import {randomInt} from 'crypto';
+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";

-const entityIDRegex = new RegExp(`^(.+?)(?:/([^/]+))?$`);
+import Device from "./model/device";
+import Group from "./model/group";
+import data from "./util/data";
+import logger from "./util/logger";
+import * as settings from "./util/settings";
+import utils from "./util/utils";
+
+const entityIDRegex = /^(.+?)(?:\/([^/]+))?$/;

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

    constructor(eventBus: EventBus) {
        this.eventBus = eventBus;
    }

-    async start(): Promise<'reset' | 'resumed' | 'restored'> {
-        const infoHerdsman = await utils.getDependencyVersion('zigbee-herdsman');
+    async start(): Promise<StartResult> {
+        const infoHerdsman = await utils.getDependencyVersion("zigbee-herdsman");
        logger.info(`Starting zigbee-herdsman (${infoHerdsman.version})`);
+        const panId = settings.get().advanced.pan_id;
+        const extPanId = settings.get().advanced.ext_pan_id;
+        const networkKey = settings.get().advanced.network_key;
        const herdsmanSettings = {
            network: {
-                panID: settings.get().advanced.pan_id === 'GENERATE' ?
-                    this.generatePanID() : settings.get().advanced.pan_id as number,
-                extendedPanID: settings.get().advanced.ext_pan_id === 'GENERATE' ?
-                    this.generateExtPanID() : settings.get().advanced.ext_pan_id as number[],
+                panID: panId === "GENERATE" ? this.generatePanID() : panId,
+                extendedPanID: extPanId === "GENERATE" ? this.generateExtPanID() : extPanId,
                channelList: [settings.get().advanced.channel],
-                networkKey: settings.get().advanced.network_key === 'GENERATE' ?
-                    this.generateNetworkKey() : settings.get().advanced.network_key as number[],
+                networkKey: networkKey === "GENERATE" ? this.generateNetworkKey() : networkKey,
            },
-            databasePath: data.joinPath('database.db'),
-            databaseBackupPath: data.joinPath('database.db.backup'),
-            backupPath: data.joinPath('coordinator_backup.json'),
+            databasePath: data.joinPath("database.db"),
+            databaseBackupPath: data.joinPath("database.db.backup"),
+            backupPath: data.joinPath("coordinator_backup.json"),
            serialPort: {
                baudRate: settings.get().serial.baudrate,
                rtscts: settings.get().serial.rtscts,
@@ -49,71 +52,79 @@ export default class Zigbee {
                concurrent: settings.get().advanced.adapter_concurrent,
                delay: settings.get().advanced.adapter_delay,
                disableLED: settings.get().serial.disable_led,
+                transmitPower: settings.get().advanced.transmit_power,
            },
            acceptJoiningDeviceHandler: this.acceptJoiningDeviceHandler,
        };

-        const herdsmanSettingsLog = objectAssignDeep({}, herdsmanSettings, {network: {networkKey: 'HIDDEN'}});
-        logger.debug(`Using zigbee-herdsman with settings: '${stringify(herdsmanSettingsLog)}'`);
+        logger.debug(
+            () =>
+                `Using zigbee-herdsman with settings: '${stringify(JSON.stringify(herdsmanSettings).replaceAll(JSON.stringify(herdsmanSettings.network.networkKey), '"HIDDEN"'))}'`,
+        );

-        let startResult;
+        let startResult: StartResult;
        try {
            this.herdsman = new Controller(herdsmanSettings);
            startResult = await this.herdsman.start();
        } catch (error) {
-            logger.error(`Error while starting zigbee-herdsman`);
+            logger.error("Error while starting zigbee-herdsman");
            throw error;
        }

-        for (const device of this.devices(false)) {
-            await device.resolveDefinition();
-        }
+        this.coordinatorIeeeAddr = this.herdsman.getDevicesByType("Coordinator")[0].ieeeAddr;
+        await this.resolveDevicesDefinitions();

-        this.herdsman.on('adapterDisconnected', () => this.eventBus.emitAdapterDisconnected());
-        this.herdsman.on('lastSeenChanged', (data: ZHEvents.LastSeenChangedPayload) => {
-            this.eventBus.emitLastSeenChanged({device: this.resolveDevice(data.device.ieeeAddr), reason: data.reason});
+        this.herdsman.on("adapterDisconnected", () => this.eventBus.emitAdapterDisconnected());
+        this.herdsman.on("lastSeenChanged", (data: ZHEvents.LastSeenChangedPayload) => {
+            // biome-ignore lint/style/noNonNullAssertion: assumed valid
+            this.eventBus.emitLastSeenChanged({device: this.resolveDevice(data.device.ieeeAddr)!, reason: data.reason});
        });
-        this.herdsman.on('permitJoinChanged', (data: ZHEvents.PermitJoinChangedPayload) => {
+        this.herdsman.on("permitJoinChanged", (data: ZHEvents.PermitJoinChangedPayload) => {
            this.eventBus.emitPermitJoinChanged(data);
        });
-        this.herdsman.on('deviceNetworkAddressChanged', (data: ZHEvents.DeviceNetworkAddressChangedPayload) => {
-            const device = this.resolveDevice(data.device.ieeeAddr);
+        this.herdsman.on("deviceNetworkAddressChanged", (data: ZHEvents.DeviceNetworkAddressChangedPayload) => {
+            // biome-ignore lint/style/noNonNullAssertion: assumed valid
+            const device = this.resolveDevice(data.device.ieeeAddr)!;
            logger.debug(`Device '${device.name}' changed network address`);
            this.eventBus.emitDeviceNetworkAddressChanged({device});
        });
-        this.herdsman.on('deviceAnnounce', (data: ZHEvents.DeviceAnnouncePayload) => {
-            const device = this.resolveDevice(data.device.ieeeAddr);
+        this.herdsman.on("deviceAnnounce", (data: ZHEvents.DeviceAnnouncePayload) => {
+            // biome-ignore lint/style/noNonNullAssertion: assumed valid
+            const device = this.resolveDevice(data.device.ieeeAddr)!;
            logger.debug(`Device '${device.name}' announced itself`);
            this.eventBus.emitDeviceAnnounce({device});
        });
-        this.herdsman.on('deviceInterview', async (data: ZHEvents.DeviceInterviewPayload) => {
+        this.herdsman.on("deviceInterview", async (data: ZHEvents.DeviceInterviewPayload) => {
            const device = this.resolveDevice(data.device.ieeeAddr);
-            /* istanbul ignore if */ if (!device) return; // Prevent potential race
+            /* v8 ignore next */ if (!device) return; // Prevent potential race
            await device.resolveDefinition();
            const d = {device, status: data.status};
            this.logDeviceInterview(d);
            this.eventBus.emitDeviceInterview(d);
        });
-        this.herdsman.on('deviceJoined', async (data: ZHEvents.DeviceJoinedPayload) => {
+        this.herdsman.on("deviceJoined", async (data: ZHEvents.DeviceJoinedPayload) => {
            const device = this.resolveDevice(data.device.ieeeAddr);
-            /* istanbul ignore if */ if (!device) return; // Prevent potential race
+            /* v8 ignore next */ if (!device) return; // Prevent potential race
            await device.resolveDefinition();
            logger.info(`Device '${device.name}' joined`);
            this.eventBus.emitDeviceJoined({device});
        });
-        this.herdsman.on('deviceLeave', (data: ZHEvents.DeviceLeavePayload) => {
+        this.herdsman.on("deviceLeave", (data: ZHEvents.DeviceLeavePayload) => {
            const name = settings.getDevice(data.ieeeAddr)?.friendly_name || data.ieeeAddr;
            logger.warning(`Device '${name}' left the network`);
-            this.eventBus.emitDeviceLeave({ieeeAddr: data.ieeeAddr, name});
+            this.eventBus.emitDeviceLeave({ieeeAddr: data.ieeeAddr, name, device: this.deviceLookup.get(data.ieeeAddr)});
        });
-        this.herdsman.on('message', async (data: ZHEvents.MessagePayload) => {
-            const device = this.resolveDevice(data.device.ieeeAddr);
+        this.herdsman.on("message", async (data: ZHEvents.MessagePayload) => {
+            // biome-ignore lint/style/noNonNullAssertion: assumed valid
+            const device = this.resolveDevice(data.device.ieeeAddr)!;
            await device.resolveDefinition();
-            logger.debug(`Received Zigbee message from '${device.name}', type '${data.type}', ` +
-                `cluster '${data.cluster}', data '${stringify(data.data)}' from endpoint ${data.endpoint.ID}` +
-                (data.hasOwnProperty('groupID') ? ` with groupID ${data.groupID}` : ``) +
-                (device.zh.type === 'Coordinator' ? `, ignoring since it is from coordinator` : ``));
-            if (device.zh.type === 'Coordinator') return;
+            logger.debug(() => {
+                const groupId = data.groupID !== undefined ? ` with groupID ${data.groupID}` : "";
+                const fromCoord = device.zh.type === "Coordinator" ? ", ignoring since it is from coordinator" : "";
+
+                return `Received Zigbee message from '${device.name}', type '${data.type}', cluster '${data.cluster}', data '${stringify(data.data)}' from endpoint ${data.endpoint.ID}${groupId}${fromCoord}`;
+            });
+            if (device.zh.type === "Coordinator") return;
            this.eventBus.emitDeviceMessage({...data, device});
        });

@@ -121,7 +132,7 @@ export default class Zigbee {
        logger.info(`Coordinator firmware version: '${stringify(await this.getCoordinatorVersion())}'`);
        logger.debug(`Zigbee network parameters: ${stringify(await this.herdsman.getNetworkParameters())}`);

-        for (const device of this.devices(false)) {
+        for (const device of this.devicesIterator(utils.deviceNotCoordinator)) {
            // If a passlist is used, all other device will be removed from the network.
            const passlist = settings.get().passlist;
            const blocklist = settings.get().blocklist;
@@ -129,71 +140,66 @@ export default class Zigbee {
                try {
                    await device.zh.removeFromNetwork();
                } catch (error) {
-                    logger.error(`Failed to remove '${device.ieeeAddr}' (${error.message})`);
+                    logger.error(`Failed to remove '${device.ieeeAddr}' (${(error as Error).message})`);
                }
            };
+
            if (passlist.length > 0) {
                if (!passlist.includes(device.ieeeAddr)) {
-                    logger.warning(`Device which is not on passlist connected (${device.ieeeAddr}), removing...`);
+                    logger.warning(`Device not on passlist currently connected (${device.ieeeAddr}), removing...`);
                    await remove(device);
                }
            } else if (blocklist.includes(device.ieeeAddr)) {
-                logger.warning(`Device on blocklist is connected (${device.ieeeAddr}), removing...`);
+                logger.warning(`Device on blocklist currently connected (${device.ieeeAddr}), removing...`);
                await remove(device);
            }
        }

-        // Check if we have to set a transmit power
-        if (settings.get().advanced.hasOwnProperty('transmit_power')) {
-            const transmitPower = settings.get().advanced.transmit_power;
-            await this.herdsman.setTransmitPower(transmitPower);
-            logger.info(`Set transmit power to '${transmitPower}'`);
-        }
-
        return startResult;
    }

    private logDeviceInterview(data: eventdata.DeviceInterview): void {
        const name = data.device.name;
-        if (data.status === 'successful') {
+        if (data.status === "successful") {
            logger.info(`Successfully interviewed '${name}', device has successfully been paired`);

            if (data.device.isSupported) {
-                const {vendor, description, model} = data.device.definition;
+                // biome-ignore lint/style/noNonNullAssertion: valid from `isSupported`
+                const {vendor, description, model} = data.device.definition!;
                logger.info(`Device '${name}' is supported, identified as: ${vendor} ${description} (${model})`);
            } else {
-                logger.warning(`Device '${name}' with Zigbee model '${data.device.zh.modelID}' and manufacturer name ` +
-                    `'${data.device.zh.manufacturerName}' is NOT supported, ` +
-                    // eslint-disable-next-line max-len
-                    `please follow https://www.zigbee2mqtt.io/advanced/support-new-devices/01_support_new_devices.html`);
+                logger.warning(
+                    `Device '${name}' with Zigbee model '${data.device.zh.modelID}' and manufacturer name '${data.device.zh.manufacturerName}' is NOT supported, please follow https://www.zigbee2mqtt.io/advanced/support-new-devices/01_support_new_devices.html`,
+                );
            }
-        } else if (data.status === 'failed') {
+        } else if (data.status === "failed") {
            logger.error(`Failed to interview '${name}', device has not successfully been paired`);
-        } else { // data.status === 'started'
+        } else {
+            // data.status === 'started'
            logger.info(`Starting interview of '${name}'`);
        }
    }

    private generateNetworkKey(): number[] {
        const key = Array.from({length: 16}, () => randomInt(256));
-        settings.set(['advanced', 'network_key'], key);
+        settings.set(["advanced", "network_key"], key);
        return key;
    }

    private generateExtPanID(): number[] {
        const key = Array.from({length: 8}, () => randomInt(256));
-        settings.set(['advanced', 'ext_pan_id'], key);
+        settings.set(["advanced", "ext_pan_id"], key);
        return key;
    }

    private generatePanID(): number {
-        const panID = randomInt(1, 0xFFFF - 1);
-        settings.set(['advanced', 'pan_id'], panID);
+        const panID = randomInt(1, 0xffff - 1);
+        settings.set(["advanced", "pan_id"], panID);
        return panID;
    }

    async getCoordinatorVersion(): Promise<zh.CoordinatorVersion> {
-        return this.herdsman.getCoordinatorVersion();
+        return await this.herdsman.getCoordinatorVersion();
    }

    isStopping(): boolean {
@@ -201,92 +207,98 @@ export default class Zigbee {
    }

    async backup(): Promise<void> {
-        return this.herdsman.backup();
+        return await this.herdsman.backup();
    }

    async coordinatorCheck(): Promise<{missingRouters: Device[]}> {
        const check = await this.herdsman.coordinatorCheck();
-        return {missingRouters: check.missingRouters.map((d) => this.resolveDevice(d.ieeeAddr))};
+        // biome-ignore lint/style/noNonNullAssertion: assumed valid
+        return {missingRouters: check.missingRouters.map((d) => this.resolveDevice(d.ieeeAddr)!)};
    }

    async getNetworkParameters(): Promise<zh.NetworkParameters> {
-        return this.herdsman.getNetworkParameters();
-    }
-
-    async reset(type: 'soft' | 'hard'): Promise<void> {
-        await this.herdsman.reset(type);
+        return await this.herdsman.getNetworkParameters();
    }

    async stop(): Promise<void> {
-        logger.info('Stopping zigbee-herdsman...');
+        logger.info("Stopping zigbee-herdsman...");
        await this.herdsman.stop();
-        logger.info('Stopped zigbee-herdsman');
+        logger.info("Stopped zigbee-herdsman");
    }

    getPermitJoin(): boolean {
        return this.herdsman.getPermitJoin();
    }

-    getPermitJoinTimeout(): number {
-        return this.herdsman.getPermitJoinTimeout();
+    getPermitJoinEnd(): number | undefined {
+        return this.herdsman.getPermitJoinEnd();
    }

-    async permitJoin(permit: boolean, device?: Device, time: number=undefined): Promise<void> {
-        if (permit) {
-            logger.info(`Zigbee: allowing new devices to join${device ? ` via ${device.name}` : ''}.`);
+    async permitJoin(time: number, device?: Device): Promise<void> {
+        if (time > 0) {
+            logger.info(`Zigbee: allowing new devices to join${device ? ` via ${device.name}` : ""}.`);
        } else {
-            logger.info('Zigbee: disabling joining new devices.');
+            logger.info("Zigbee: disabling joining new devices.");
        }

-        if (device && permit) {
-            await this.herdsman.permitJoin(permit, device.zh, time);
-        } else {
-            await this.herdsman.permitJoin(permit, undefined, time);
+        await this.herdsman.permitJoin(time, device?.zh);
+    }
+
+    async resolveDevicesDefinitions(ignoreCache = false): Promise<void> {
+        for (const device of this.devicesIterator(utils.deviceNotCoordinator)) {
+            await device.resolveDefinition(ignoreCache);
        }
    }

-    @bind private resolveDevice(ieeeAddr: string): Device {
-        if (!this.deviceLookup[ieeeAddr]) {
+    @bind private resolveDevice(ieeeAddr: string): Device | undefined {
+        if (!this.deviceLookup.has(ieeeAddr)) {
            const device = this.herdsman.getDeviceByIeeeAddr(ieeeAddr);
-            device && (this.deviceLookup[ieeeAddr] = new Device(device));
+            if (device) {
+                this.deviceLookup.set(ieeeAddr, new Device(device));
+            }
        }

-        const device = this.deviceLookup[ieeeAddr];
+        const device = this.deviceLookup.get(ieeeAddr);
        if (device && !device.zh.isDeleted) {
            device.ensureInSettings();
            return device;
        }
    }

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

-        return this.groupLookup[groupID];
+        return this.groupLookup.get(groupID);
    }

-    resolveEntity(key: string | number | zh.Device): Device | Group {
-        if (typeof key === 'object') {
+    resolveEntity(key: string | number | zh.Device): Device | Group | undefined {
+        if (typeof key === "object") {
            return this.resolveDevice(key.ieeeAddr);
-        } else if (typeof key === 'string' && key.toLowerCase() === 'coordinator') {
-            return this.resolveDevice(this.herdsman.getDevicesByType('Coordinator')[0].ieeeAddr);
-        } else {
-            const settingsDevice = settings.getDevice(key.toString());
-            if (settingsDevice) return this.resolveDevice(settingsDevice.ID);
+        }

-            const groupSettings = settings.getGroup(key);
-            if (groupSettings) {
-                const group = this.resolveGroup(groupSettings.ID);
-                // If group does not exist, create it (since it's already in configuration.yaml)
-                return group ? group : this.createGroup(groupSettings.ID);
-            }
+        if (typeof key === "string" && (key.toLowerCase() === "coordinator" || key === this.coordinatorIeeeAddr)) {
+            return this.resolveDevice(this.coordinatorIeeeAddr);
+        }
+
+        const settingsDevice = settings.getDevice(key.toString());
+
+        if (settingsDevice) {
+            return this.resolveDevice(settingsDevice.ID);
+        }
+
+        const groupSettings = settings.getGroup(key);
+
+        if (groupSettings) {
+            const group = this.resolveGroup(groupSettings.ID);
+            // If group does not exist, create it (since it's already in configuration.yaml)
+            return group ? group : this.createGroup(groupSettings.ID);
        }
    }

-    resolveEntityAndEndpoint(ID: string)
-        : {ID: string, entity: Device | Group, endpointID: string, endpoint: zh.Endpoint} {
+    resolveEntityAndEndpoint(id: string): {ID: string; entity: Device | Group | undefined; endpointID?: string; endpoint?: zh.Endpoint} {
        // This function matches the following entity formats:
        // device_name          (just device name)
        // device_name/ep_name  (device name and endpoint numeric ID or name)
@@ -294,43 +306,65 @@ export default class Zigbee {
        // device/name/ep_name  (device name with slashes, and endpoint numeric ID or name)

        // The function tries to find an exact match first
-        let entityName = ID;
-        let deviceOrGroup = this.resolveEntity(ID);
-        let endpointNameOrID = undefined;
+        let entityName = id;
+        let deviceOrGroup = this.resolveEntity(id);
+        let endpointNameOrID: string | undefined;

-        // If exact match did not happenc, try matching a device_name/endpoint pattern
+        // If exact match did not happen, try matching a device_name/endpoint pattern
        if (!deviceOrGroup) {
            // First split the input token by the latest slash
-            const match = ID.match(entityIDRegex);
+            const match = id.match(entityIDRegex);

-            // Get the resulting IDs from the match
-            entityName = match[1];
-            deviceOrGroup = this.resolveEntity(match[1]);
-            endpointNameOrID = match[2];
+            if (match) {
+                // Get the resulting IDs from the match
+                entityName = match[1];
+                deviceOrGroup = this.resolveEntity(entityName);
+                endpointNameOrID = match[2];
+            }
        }

        // If the function returns non-null endpoint name, but the endpoint field is null, then
        // it means that endpoint was not matched because there is no such endpoint on the device
        // (or the entity is a group)
-        const endpoint = deviceOrGroup?.isDevice() ? deviceOrGroup.endpoint(endpointNameOrID) : null;
+        const endpoint = deviceOrGroup?.isDevice() ? deviceOrGroup.endpoint(endpointNameOrID) : undefined;

-        return {ID: entityName, entity: deviceOrGroup, endpointID: endpointNameOrID, endpoint: endpoint};
+        return {ID: entityName, entity: deviceOrGroup, endpointID: endpointNameOrID, endpoint};
    }

    firstCoordinatorEndpoint(): zh.Endpoint {
-        return this.herdsman.getDevicesByType('Coordinator')[0].endpoints[0];
+        return this.herdsman.getDevicesByType("Coordinator")[0].endpoints[0];
    }

-    groups(): Group[] {
-        return this.herdsman.getGroups().map((g) => this.resolveGroup(g.groupID));
+    *devicesAndGroupsIterator(
+        devicePredicate?: (value: zh.Device) => boolean,
+        groupPredicate?: (value: zh.Group) => boolean,
+    ): Generator<Device | Group> {
+        for (const device of this.herdsman.getDevicesIterator(devicePredicate)) {
+            // biome-ignore lint/style/noNonNullAssertion: assumed valid
+            yield this.resolveDevice(device.ieeeAddr)!;
+        }
+
+        for (const group of this.herdsman.getGroupsIterator(groupPredicate)) {
+            // biome-ignore lint/style/noNonNullAssertion: assumed valid
+            yield this.resolveGroup(group.groupID)!;
+        }
    }

-    devices(includeCoordinator=true): Device[] {
-        return this.herdsman.getDevices()
-            .map((d) => this.resolveDevice(d.ieeeAddr))
-            .filter((d) => includeCoordinator || d.zh.type !== 'Coordinator');
+    *groupsIterator(predicate?: (value: zh.Group) => boolean): Generator<Group> {
+        for (const group of this.herdsman.getGroupsIterator(predicate)) {
+            // biome-ignore lint/style/noNonNullAssertion: assumed valid
+            yield this.resolveGroup(group.groupID)!;
+        }
    }

+    *devicesIterator(predicate?: (value: zh.Device) => boolean): Generator<Device> {
+        for (const device of this.herdsman.getDevicesIterator(predicate)) {
+            // biome-ignore lint/style/noNonNullAssertion: assumed valid
+            yield this.resolveDevice(device.ieeeAddr)!;
+        }
+    }
+
+    // biome-ignore lint/suspicious/useAwait: API
    @bind private async acceptJoiningDeviceHandler(ieeeAddr: string): Promise<boolean> {
        // If passlist is set, all devices not on passlist will be rejected to join the network
        const passlist = settings.get().passlist;
@@ -339,29 +373,30 @@ export default class Zigbee {
            if (passlist.includes(ieeeAddr)) {
                logger.info(`Accepting joining device which is on passlist '${ieeeAddr}'`);
                return true;
-            } else {
-                logger.info(`Rejecting joining not in passlist device '${ieeeAddr}'`);
-                return false;
            }
-        } else if (blocklist.length > 0) {
+
+            logger.info(`Rejecting joining not in passlist device '${ieeeAddr}'`);
+            return false;
+        }
+
+        if (blocklist.length > 0) {
            if (blocklist.includes(ieeeAddr)) {
                logger.info(`Rejecting joining device which is on blocklist '${ieeeAddr}'`);
                return false;
-            } else {
-                logger.info(`Accepting joining not in blocklist device '${ieeeAddr}'`);
-                return true;
            }
-        } else {
-            return true;
+
+            logger.info(`Accepting joining not in blocklist device '${ieeeAddr}'`);
        }
+
+        return true;
    }

    async touchlinkFactoryResetFirst(): Promise<boolean> {
-        return this.herdsman.touchlinkFactoryResetFirst();
+        return await this.herdsman.touchlinkFactoryResetFirst();
    }

    async touchlinkFactoryReset(ieeeAddr: string, channel: number): Promise<boolean> {
-        return this.herdsman.touchlinkFactoryReset(ieeeAddr, channel);
+        return await this.herdsman.touchlinkFactoryReset(ieeeAddr, channel);
    }

    async addInstallCode(installCode: string): Promise<void> {
@@ -372,21 +407,22 @@ export default class Zigbee {
        await this.herdsman.touchlinkIdentify(ieeeAddr, channel);
    }

-    async touchlinkScan(): Promise<{ieeeAddr: string, channel: number}[]> {
-        return this.herdsman.touchlinkScan();
+    async touchlinkScan(): Promise<{ieeeAddr: string; channel: number}[]> {
+        return await this.herdsman.touchlinkScan();
    }

-    createGroup(ID: number): Group {
-        this.herdsman.createGroup(ID);
-        return this.resolveGroup(ID);
+    createGroup(id: number): Group {
+        this.herdsman.createGroup(id);
+        // biome-ignore lint/style/noNonNullAssertion: just created
+        return this.resolveGroup(id)!;
    }

-    deviceByNetworkAddress(networkAddress: number): Device {
+    deviceByNetworkAddress(networkAddress: number): Device | undefined {
        const device = this.herdsman.getDeviceByNetworkAddress(networkAddress);
        return device && this.resolveDevice(device.ieeeAddr);
    }

-    groupByID(ID: number): Group {
-        return this.resolveGroup(ID);
+    groupByID(id: number): Group | undefined {
+        return this.resolveGroup(id);
    }
 }
@@ -1,115 +1,102 @@
 {
-  "name": "zigbee2mqtt",
-  "version": "1.37.0",
-  "description": "Zigbee to MQTT bridge using Zigbee-herdsman",
-  "main": "index.js",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Koenkk/zigbee2mqtt.git"
-  },
-  "engines": {
-    "node": "^18 || ^20 || ^21"
-  },
-  "keywords": [
-    "xiaomi",
-    "tradfri",
-    "hue",
-    "bridge",
-    "zigbee",
-    "mqtt",
-    "cc2531"
-  ],
-  "scripts": {
-    "build": "tsc && node index.js writehash",
-    "build-watch": "tsc --watch",
-    "eslint": "eslint lib/ --max-warnings=0",
-    "start": "node index.js",
-    "test-with-coverage": "jest test --coverage",
-    "test": "jest test",
-    "test-watch": "jest test --watch"
-  },
-  "author": "Koen Kanters",
-  "license": "GPL-3.0",
-  "bugs": {
-    "url": "https://github.com/Koenkk/zigbee2mqtt/issues"
-  },
-  "homepage": "https://koenkk.github.io/zigbee2mqtt",
-  "dependencies": {
-    "ajv": "^8.12.0",
-    "bind-decorator": "^1.0.11",
-    "connect-gzip-static": "3.0.1",
-    "debounce": "^2.0.0",
-    "deep-object-diff": "^1.1.9",
-    "fast-deep-equal": "^3.1.3",
-    "finalhandler": "^1.2.0",
-    "git-last-commit": "^1.0.1",
-    "humanize-duration": "^3.32.0",
-    "js-yaml": "^4.1.0",
-    "json-stable-stringify-without-jsonify": "^1.0.1",
-    "jszip": "^3.10.1",
-    "mkdir-recursive": "^0.4.0",
-    "moment": "^2.30.1",
-    "mqtt": "^5.5.4",
-    "object-assign-deep": "^0.4.0",
-    "rimraf": "^5.0.5",
-    "semver": "^7.6.0",
-    "source-map-support": "^0.5.21",
-    "uri-js": "^4.4.1",
-    "winston": "^3.13.0",
-    "winston-syslog": "^2.7.0",
-    "winston-transport": "^4.7.0",
-    "ws": "^8.17.0",
-    "zigbee-herdsman": "0.45.0",
-    "zigbee-herdsman-converters": "19.32.0",
-    "zigbee2mqtt-frontend": "0.6.165"
-  },
-  "devDependencies": {
-    "@babel/core": "^7.24.4",
-    "@babel/plugin-proposal-decorators": "^7.24.1",
-    "@babel/preset-env": "^7.24.4",
-    "@babel/preset-typescript": "^7.24.1",
-    "@types/debounce": "^1.2.4",
-    "@types/finalhandler": "^1.2.3",
-    "@types/humanize-duration": "^3.27.4",
-    "@types/jest": "^29.5.12",
-    "@types/js-yaml": "^4.0.9",
-    "@types/node": "^20.12.7",
-    "@types/object-assign-deep": "^0.4.3",
-    "@types/readable-stream": "4.0.11",
-    "@types/ws": "8.5.10",
-    "@typescript-eslint/eslint-plugin": "^7.7.1",
-    "@typescript-eslint/parser": "^7.7.1",
-    "babel-jest": "^29.7.0",
-    "eslint": "^8.57.0",
-    "eslint-config-google": "^0.14.0",
-    "eslint-plugin-jest": "^28.3.0",
-    "jest": "^29.7.0",
-    "tmp": "^0.2.3",
-    "typescript": "^5.4.5"
-  },
-  "overrides": {
-    "zigbee-herdsman-converters": {
-      "zigbee-herdsman": "$zigbee-herdsman"
-    }
-  },
-  "jest": {
-    "coverageThreshold": {
-      "global": {
-        "branches": 100,
-        "functions": 100,
-        "lines": 100,
-        "statements": 100
-      }
+    "name": "zigbee2mqtt",
+    "version": "2.5.1",
+    "description": "Zigbee to MQTT bridge using Zigbee-herdsman",
+    "main": "index.js",
+    "types": "dist/types/api.d.ts",
+    "packageManager": "pnpm@10.12.1",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/Koenkk/zigbee2mqtt.git"
    },
-    "collectCoverageFrom": [
-      "lib/**/*.js",
-      "lib/**/*.ts"
-    ]
-  },
-  "bin": {
-    "zigbee2mqtt": "cli.js"
-  },
-  "optionalDependencies": {
-    "sd-notify": "^2.8.0"
-  }
+    "engines": {
+        "node": "^20 || ^22 || ^24"
+    },
+    "keywords": [
+        "xiaomi",
+        "tradfri",
+        "hue",
+        "bridge",
+        "zigbee",
+        "mqtt",
+        "cc2531"
+    ],
+    "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 --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",
+        "prepack": "pnpm run clean && pnpm run build",
+        "clean": "rimraf coverage dist tsconfig.tsbuildinfo"
+    },
+    "author": "Koen Kanters",
+    "license": "GPL-3.0",
+    "bugs": {
+        "url": "https://github.com/Koenkk/zigbee2mqtt/issues"
+    },
+    "homepage": "https://koenkk.github.io/zigbee2mqtt",
+    "dependencies": {
+        "ajv": "^8.17.1",
+        "bind-decorator": "^1.0.11",
+        "debounce": "^2.2.0",
+        "express-static-gzip": "^3.0.0",
+        "fast-deep-equal": "^3.1.3",
+        "finalhandler": "^2.1.0",
+        "humanize-duration": "^3.32.1",
+        "js-yaml": "^4.1.0",
+        "json-stable-stringify-without-jsonify": "^1.0.1",
+        "jszip": "^3.10.1",
+        "moment": "^2.30.1",
+        "mqtt": "^5.11.0",
+        "object-assign-deep": "^0.4.0",
+        "rimraf": "^6.0.1",
+        "semver": "^7.7.1",
+        "source-map-support": "^0.5.21",
+        "throttleit": "^2.1.0",
+        "winston": "^3.17.0",
+        "winston-syslog": "^2.7.1",
+        "winston-transport": "^4.9.0",
+        "ws": "^8.18.1",
+        "zigbee-herdsman": "4.3.1",
+        "zigbee-herdsman-converters": "23.69.0",
+        "zigbee2mqtt-frontend": "0.9.16",
+        "zigbee2mqtt-windfront": "^1.2.1"
+    },
+    "devDependencies": {
+        "@biomejs/biome": "^2.0.5",
+        "@types/finalhandler": "^1.2.3",
+        "@types/humanize-duration": "^3.27.4",
+        "@types/js-yaml": "^4.0.9",
+        "@types/node": "^24.0.3",
+        "@types/object-assign-deep": "^0.4.3",
+        "@types/readable-stream": "4.0.21",
+        "@types/serve-static": "^1.15.7",
+        "@types/ws": "8.18.1",
+        "@vitest/coverage-v8": "^3.1.1",
+        "tmp": "^0.2.3",
+        "typescript": "^5.8.3",
+        "vitest": "^3.1.1"
+    },
+    "pnpm": {
+        "overrides": {
+            "zigbee-herdsman": "$zigbee-herdsman"
+        },
+        "onlyBuiltDependencies": [
+            "@biomejs/biome",
+            "@serialport/bindings-cpp",
+            "esbuild",
+            "unix-dgram"
+        ]
+    },
+    "bin": {
+        "zigbee2mqtt": "cli.js"
+    },
+    "optionalDependencies": {
+        "unix-dgram": "^2.0.6"
+    }
 }
@@ -1,11 +1,12 @@
 {
-  "packages": {
-    ".": {
-      "release-type": "node",
-      "include-component-in-tag": false,
-      "include-v-in-tag": false,
-      "draft": true
-    }
-  },
-  "$schema": "https://raw.githubusercontent.com/googleapis/release-please/main/schemas/config.json"
-}
+    "packages": {
+        ".": {
+            "release-type": "node",
+            "include-component-in-tag": false,
+            "include-v-in-tag": false,
+            "draft": true
+        }
+    },
+    "pull-request-title-pattern": "chore${scope}: release ${version}",
+    "$schema": "https://raw.githubusercontent.com/googleapis/release-please/main/schemas/config.json"
+}
@@ -1,9 +1,8 @@
-/* eslint max-len: 0 */
-const path = require('path');
-const fs = require('fs');
-const process = require('process');
-const {execSync} = require('child_process');
-const zhc = require('zigbee-herdsman-converters');
+const path = require("node:path");
+const fs = require("node:fs");
+const process = require("node:process");
+const {execSync} = require("node:child_process");
+const zhc = require("zigbee-herdsman-converters");

 const z2mTillVersion = process.argv[2];
 const zhcTillVersion = process.argv[3];
@@ -11,14 +10,27 @@ const zhTillVersion = process.argv[4];
 const frontendTillVersion = process.argv[5];

 const changelogs = [
-    {tillVersion: z2mTillVersion, project: 'koenkk/zigbee2mqtt',
-        contents: fs.readFileSync(path.join(__dirname, '..', 'CHANGELOG.md'), 'utf-8').split('\n')},
-    {tillVersion: zhcTillVersion, project: 'koenkk/zigbee-herdsman-converters',
-        contents: fs.readFileSync(path.join(__dirname, '..', 'node_modules', 'zigbee-herdsman-converters', 'CHANGELOG.md'), 'utf-8').split('\n')},
-    {tillVersion: zhTillVersion, project: 'koenkk/zigbee-herdsman',
-        contents: fs.readFileSync(path.join(__dirname, '..', 'node_modules', 'zigbee-herdsman', 'CHANGELOG.md'), 'utf-8').split('\n')},
-    {tillVersion: frontendTillVersion, project: 'nurikk/zigbee2mqtt-frontend', isFrontend: true,
-        contents: fs.readFileSync(path.join(__dirname, '..', 'node_modules', 'zigbee2mqtt-frontend', 'CHANGELOG.md'), 'utf-8').split('\n')},
+    {
+        tillVersion: z2mTillVersion,
+        project: "koenkk/zigbee2mqtt",
+        contents: fs.readFileSync(path.join(__dirname, "..", "CHANGELOG.md"), "utf-8").split("\n"),
+    },
+    {
+        tillVersion: zhcTillVersion,
+        project: "koenkk/zigbee-herdsman-converters",
+        contents: fs.readFileSync(path.join(__dirname, "..", "node_modules", "zigbee-herdsman-converters", "CHANGELOG.md"), "utf-8").split("\n"),
+    },
+    {
+        tillVersion: zhTillVersion,
+        project: "koenkk/zigbee-herdsman",
+        contents: fs.readFileSync(path.join(__dirname, "..", "node_modules", "zigbee-herdsman", "CHANGELOG.md"), "utf-8").split("\n"),
+    },
+    {
+        tillVersion: frontendTillVersion,
+        project: "nurikk/zigbee2mqtt-frontend",
+        isFrontend: true,
+        contents: fs.readFileSync(path.join(__dirname, "..", "node_modules", "zigbee2mqtt-frontend", "CHANGELOG.md"), "utf-8").split("\n"),
+    },
 ];

 const releaseRe = /## \[(.+)\]/;
@@ -32,11 +44,15 @@ const changeRe = [
 const frontendChangeRe = /^\* (\*\*.+:\*\* )()?(.+) \(\[.+\]\(https:.+\/()(.+)\)\)(.+)?$/;

 let commitUserLookup = {};
-const commitUserFile = path.join(__dirname, 'commit-user-lookup.json');
+const commitUserFile = path.join(__dirname, "commit-user-lookup.json");
 if (fs.existsSync(commitUserFile)) {
-    commitUserLookup = JSON.parse(fs.readFileSync(commitUserFile, 'utf8'));
+    commitUserLookup = JSON.parse(fs.readFileSync(commitUserFile, "utf8"));
 }

+const definitions = require("zigbee-herdsman-converters/devices/index").default.map((d) => zhc.prepareDefinition(d));
+const whiteLabels = definitions.filter((d) => d.whiteLabel).flatMap((d) => d.whiteLabel);
+const capitalizeFirstChar = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
 for (const changelog of changelogs) {
    for (const line of changelog.contents) {
        const releaseMatch = line.match(releaseRe);
@@ -45,84 +61,97 @@ for (const changelog of changelogs) {
            if (releaseMatch[1] === changelog.tillVersion) {
                break;
            }
-        } else if (line === '### Features') {
-            context = 'features';
-        } else if (line === '### Bug Fixes') {
-            context = 'fixes';
-        } else if (line.startsWith('* **ignore:**')) {
-            continue;
+        } else if (line === "### Features") {
+            context = "features";
+        } else if (line === "### Bug Fixes") {
+            context = "fixes";
+        } else if (line.startsWith("* **ignore:**")) {
+            // continue;
        } else if (changeMatch) {
-            let localContext = changelog.isFrontend ? 'frontend' : (changeMatch[2] ? changeMatch[2] : context);
-            if (!changes[localContext]) localContext = 'error';
+            let localContext = changelog.isFrontend ? "frontend" : changeMatch[2] ? changeMatch[2] : context;
+            if (!changes[localContext]) localContext = "error";

            const commit = changeMatch[5];
            const commitUserKey = `${changelog.project}-${commit} `;
-            let user = commitUserKey in commitUserLookup ? commitUserLookup[commitUserKey] :
-                execSync(`curl -s https://api.github.com/repos/${changelog.project}/commits/${commit} | jq -r '.author.login'`).toString().trim();
-            if (user !== 'null') commitUserLookup[commitUserKey] = user;
+            let user =
+                commitUserKey in commitUserLookup
+                    ? commitUserLookup[commitUserKey]
+                    : execSync(`curl -s https://api.github.com/repos/${changelog.project}/commits/${commit} | jq -r '.author.login'`)
+                          .toString()
+                          .trim();
+            if (user !== "null") commitUserLookup[commitUserKey] = user;
            const messages = [];
            let message = changeMatch[3].trim();
-            if (message.endsWith('.')) message = message.substring(0, message.length - 1);
-            message = message.charAt(0).toUpperCase() + message.slice(1);
+            if (message.endsWith(".")) message = message.substring(0, message.length - 1);

            if (changelog.isFrontend) {
-                changes[localContext].push(`- [${commit.slice(0, 7)}](https://github.com/${changelog.project}/commit/${commit}) ${message} (@${user})`);
-                messages.push(message);
+                changes[localContext].push(
+                    `- [${commit.slice(0, 7)}](https://github.com/${changelog.project}/commit/${commit}) ${message} (@${user})`,
+                );
+                messages.push(capitalizeFirstChar(message));
            } else {
                const otherUser = message.match(/\[@(.+)\]\(https:\/\/github.com\/.+\)/) || message.match(/@(.+)/);
                if (otherUser) {
                    user = otherUser[1];
-                    message = message.replace(otherUser[0], '');
+                    message = message.replace(otherUser[0], "");
                }

-                if (localContext === 'add') {
-                    for (const model of message.split(',')) {
-                        const definition = zhc.definitions.find((d) => d.model === model.trim());
-                        if (definition) {
-                            messages.push(`\`${definition.model}\` ${definition.vendor} ${definition.description}`);
+                if (localContext === "add") {
+                    for (const model of message.split(",")) {
+                        const definition = definitions.find((d) => d.model === model.trim());
+                        const whiteLabel = whiteLabels.find((d) => d.model === model.trim());
+                        const match = definition || whiteLabel;
+                        if (match) {
+                            messages.push(`\`${match.model}\` ${match.vendor} ${match.description}`);
                        } else {
-                            changes['error'].push(`${line} (model '${model}' does not exist)`);
+                            changes.error.push(`${line} (model '${model}' does not exist)`);
                        }
                    }
                } else {
-                    messages.push(message);
+                    messages.push(capitalizeFirstChar(message));
                }

                let issue = changeMatch[4].trim();
-                if (issue && !issue.startsWith('[#')) issue = `[#${issue.split('/').pop()}](${issue})`;
+                if (issue && !issue.startsWith("[#")) issue = `[#${issue.split("/").pop()}](${issue})`;
                if (!issue) {
-                    issue = '_NO_ISSUE_';
-                    localContext = 'error';
+                    issue = "_NO_ISSUE_";
+                    localContext = "error";
                }

-                messages.forEach((m) => changes[localContext].push(`- ${issue} ${m} (@${user})`));
+                for (const message of messages) {
+                    changes[localContext].push(`- ${issue} ${message} (@${user})`);
+                }
            }
-        } else if (line === '# Changelog' || line === '### ⚠ BREAKING CHANGES' || !line) {
-            continue;
+        } else if (line === "# Changelog" || line === "### ⚠ BREAKING CHANGES" || !line) {
+            // continue;
        } else {
-            changes['error'].push(`- Unmatched line: ${line}`);
+            changes.error.push(`- Unmatched line: ${line}`);
        }
    }
 }

-let result = '';
+let result = "";
 const names = [
-    ['features', 'Improvements'],
-    ['fixes', 'Fixes'],
-    ['frontend', 'Frontend'],
-    ['add', 'New supported devices'],
-    ['detect', 'Fixed device detections'],
-    ['error', 'Changelog generator error'],
+    ["features", "Improvements"],
+    ["fixes", "Fixes"],
+    ["frontend", "Frontend"],
+    ["add", "New supported devices"],
+    ["detect", "Fixed device detections"],
+    ["error", "Changelog generator error"],
 ];
 for (const name of names) {
    result += `# ${name[1]}\n`;
-    if (name[0] === 'add') {
-        result += `This release adds support for ${changes['add'].length} devices: \n`;
+    if (name[0] === "add") {
+        result += `This release adds support for ${changes.add.length} devices: \n`;
    }
-    changes[name[0]].forEach((e) => result += `${e}\n`);
-    result += '\n';
+
+    for (const change of changes[name[0]]) {
+        result += `${change}\n`;
+    }
+
+    result += "\n";
 }

-fs.writeFileSync(commitUserFile, JSON.stringify(commitUserLookup), 'utf-8');
+fs.writeFileSync(commitUserFile, JSON.stringify(commitUserLookup), "utf-8");

 console.log(result.trim());
@@ -1,75 +0,0 @@
-#!/bin/bash
-function zigbee2mqtt-show-short-info {
-  echo "Setup for Zigbee2MQTT bridge."
-}
-
-function zigbee2mqtt-show-long-info {
-  echo "This script installs the Zigbee2MQTT bridge"
-}
-
-function zigbee2mqtt-show-copyright-info {
-  echo "Original concept by Landrash <https://github.com/landrash>."
-}
-
-function zigbee2mqtt-install-package {
-echo -n "Installing dependencies : "
-node=$(which npm)
-if [ -z "${node}" ]; then #Installing NodeJS if not already installed.
-  printf "Downloading and installing NodeJS...\\n"
-  curl -sL https://deb.nodesource.com/setup_10.x | bash -
-  apt install -y nodejs
-fi
-
-echo "Cloning Zigbee2MQTT git repository"
-git clone https://github.com/Koenkk/zigbee2mqtt.git /opt/zigbee2mqtt
-chown -R pi:pi /opt/zigbee2mqtt
-
-echo "Running install. This might take a while and can produce some expected errors"
-cd /opt/zigbee2mqtt || exit
-su pi -c "npm ci"
-
-echo "Creating service file zigbee2mqtt.service"
-service_path="/etc/systemd/system/zigbee2mqtt.service"
-
-echo "[Unit]
-Description=zigbee2mqtt
-After=network.target
-
-[Service]
-Type=notify
-ExecStart=/usr/bin/node index.js
-WorkingDirectory=/opt/zigbee2mqtt
-StandardOutput=inherit
-StandardError=inherit
-WatchdogSec=10s
-Restart=always
-User=pi
-
-[Install]
-WantedBy=multi-user.target" > $service_path
-
-echo "Checking the installation..."
-if [ ! -f /opt/zigbee2mqtt/data/configuration.yaml ]; then
-  validation=""
-else
-  validation="ok"
-fi
-
-if [ ! -z "${validation}" ]; then
-  echo
-  echo -e "\\e[32mInstallation done..\\e[0m"
-  echo -e "Update of configuration.yaml is required found at /opt/zigbee2mqtt/data/"
-  echo -e "Some further configuration is required and details can be found here https://www.zigbee2mqtt.io"
-  echo
-  echo -e "Service can be started after configuration but running sudo systemctl start zigbee2mqtt"
-  echo
-else
-  echo
-  echo -e "\\e[31mInstallation failed..."
-  echo
-  return 1
-fi
-return 0
-}
-
-[[ "$_" == "$0" ]] && zigbee2mqtt-install-package
@@ -1,10 +1,10 @@
-const assert = require('assert');
-const vm = require('vm');
-const fs = require('fs');
-const path = require('path');
+const assert = require("node:assert");
+const vm = require("node:vm");
+const fs = require("node:fs");
+const path = require("node:path");
 const filename = process.argv[2];
 const moduleCode = fs.readFileSync(filename);
-const moduleFakePath = path.join(__dirname, 'externally-loaded.js');
+const moduleFakePath = path.join(__dirname, "externally-loaded.js");
 const sandbox = {
    require: require,
    module: {},
@@ -18,5 +18,5 @@ const sandbox = {
 };
 vm.runInNewContext(moduleCode, sandbox, moduleFakePath);
 const converter = sandbox.module.exports;
-assert(!converter.toZigbee.includes(undefined));
-assert(!converter.fromZigbee.includes(undefined));
+assert(!converter.toZigbee || !converter.toZigbee.includes(undefined));
+assert(!converter.fromZigbee || !converter.fromZigbee.includes(undefined));
@@ -1,8 +1,7 @@
-const {ZnpCommandStatus, NvSystemIds} = require('zigbee-herdsman/dist/adapter/z-stack/constants/common');
-const {ZnpVersion} = require('zigbee-herdsman/dist/adapter/z-stack/adapter/tstype');
-const {Subsystem} = require('zigbee-herdsman/dist/adapter/z-stack/unpi/constants');
-const {Znp} = require('zigbee-herdsman/dist/adapter/z-stack/znp');
-
+const {ZnpCommandStatus, NvSystemIds} = require("zigbee-herdsman/dist/adapter/z-stack/constants/common");
+const {ZnpVersion} = require("zigbee-herdsman/dist/adapter/z-stack/adapter/tstype");
+const {Subsystem} = require("zigbee-herdsman/dist/adapter/z-stack/unpi/constants");
+const {Znp} = require("zigbee-herdsman/dist/adapter/z-stack/znp");

 class ZStackNvMemEraser {
    constructor(device) {
@@ -14,7 +13,7 @@ class ZStackNvMemEraser {
        const attempts = 3;
        for (let i = 0; i < attempts; i++) {
            try {
-                await this.znp.request(Subsystem.SYS, 'ping', {capabilities: 1});
+                await this.znp.request(Subsystem.SYS, "ping", {capabilities: 1});
                break;
            } catch (e) {
                if (attempts - 1 === i) {
@@ -24,11 +23,10 @@ class ZStackNvMemEraser {
        }
        // Old firmware did not support version, assume it's Z-Stack 1.2 for now.
        try {
-            this.version = (await this.znp.request(Subsystem.SYS, 'version', {})).payload;
-        } catch (e) {
-            console.log(`Failed to get zStack version, assuming 1.2`);
-            this.version = {'transportrev': 2, 'product': 0, 'majorrel': 2,
-                'minorrel': 0, 'maintrel': 0, 'revision': ''};
+            this.version = (await this.znp.request(Subsystem.SYS, "version", {})).payload;
+        } catch {
+            console.log("Failed to get zStack version, assuming 1.2");
+            this.version = {transportrev: 2, product: 0, majorrel: 2, minorrel: 0, maintrel: 0, revision: ""};
        }

        console.log(`Detected znp version '${ZnpVersion[this.version.product]}' (${JSON.stringify(this.version)})`);
@@ -41,34 +39,41 @@ class ZStackNvMemEraser {
    async clearAllNvMemItems() {
        let maxNvMemId;
        switch (this.version.product) {
-        case ZnpVersion.zStack12: maxNvMemId = 0x0302; break;
-        case ZnpVersion.zStack30x: maxNvMemId = 0x033F; break;
-        case ZnpVersion.zStack3x0: maxNvMemId = 0x032F; break;
+            case ZnpVersion.ZStack12:
+                maxNvMemId = 0x0302;
+                break;
+            case ZnpVersion.ZStack30x:
+                maxNvMemId = 0x033f;
+                break;
+            case ZnpVersion.ZStack3x0:
+                maxNvMemId = 0x032f;
+                break;
        }

        let deletedCount = 0;
        console.log(`Clearing all NVMEM items, from 0 to ${maxNvMemId}`);
-        for (let id=0; id<=maxNvMemId; id++) {
+        for (let id = 0; id <= maxNvMemId; id++) {
            let len;
-            const needOsal = !(this.version.product == ZnpVersion.zStack3x0 && id <= 7);
+            const needOsal = !(this.version.product === ZnpVersion.zStack3x0 && id <= 7);
            if (needOsal) {
-                const lengthRes = await this.znp.request(Subsystem.SYS, 'osalNvLength', {id: id});
-                len = lengthRes.payload['length'];
+                const lengthRes = await this.znp.request(Subsystem.SYS, "osalNvLength", {id: id});
+                len = lengthRes.payload.length;
            } else {
-                const lengthRes = await this.znp.request(Subsystem.SYS, 'nvLength',
-                    {sysid: NvSystemIds.ZSTACK, itemid: id, subid: 0});
-                len = lengthRes.payload['len'];
+                const lengthRes = await this.znp.request(Subsystem.SYS, "nvLength", {sysid: NvSystemIds.ZSTACK, itemid: id, subid: 0});
+                len = lengthRes.payload.len;
            }
-            if (len != 0) {
+            if (len !== 0) {
                console.log(`NVMEM item #${id} - deleting, size: ${len}`);
                if (needOsal) {
-                    await this.znp.request(Subsystem.SYS, 'osalNvDelete',
-                        {id: id, len: len},
-                        null, null, [ZnpCommandStatus.SUCCESS, ZnpCommandStatus.NV_ITEM_INITIALIZED]);
+                    await this.znp.request(Subsystem.SYS, "osalNvDelete", {id: id, len: len}, undefined, undefined, [
+                        ZnpCommandStatus.SUCCESS,
+                        ZnpCommandStatus.NV_ITEM_INITIALIZED,
+                    ]);
                } else {
-                    await this.znp.request(Subsystem.SYS, 'nvDelete',
-                        {sysid: NvSystemIds.ZSTACK, itemid: id, subid: 0},
-                        null, null, [ZnpCommandStatus.SUCCESS, ZnpCommandStatus.NV_ITEM_INITIALIZED]);
+                    await this.znp.request(Subsystem.SYS, "nvDelete", {sysid: NvSystemIds.ZSTACK, itemid: id, subid: 0}, undefined, undefined, [
+                        ZnpCommandStatus.SUCCESS,
+                        ZnpCommandStatus.NV_ITEM_INITIALIZED,
+                    ]);
                }
                deletedCount++;
            }
@@ -77,10 +82,10 @@ class ZStackNvMemEraser {
    }
 }
 const processArgs = process.argv.slice(2);
-if (processArgs.length != 1) {
-    console.log('ZStack NVMEM eraser.');
-    console.log('Usage:');
-    console.log('   node zStackEraseAllNvMem.js <SERIAL_PORT>');
+if (processArgs.length !== 1) {
+    console.log("ZStack NVMEM eraser.");
+    console.log("Usage:");
+    console.log("   node zStackEraseAllNvMem.js <SERIAL_PORT>");
    process.exit(1);
 }

@@ -1,12 +0,0 @@
-class Example {
-    constructor(zigbee, mqtt, state, publishEntityState, eventBus) {
-        this.mqtt = mqtt;
-        this.mqtt.publish('example/extension', 'call from constructor')
-    }
-
-    start() {
-        this.mqtt.publish('example/extension', 'test')
-    }
-}
-
-module.exports = Example;
@@ -0,0 +1,24 @@
+const mockDevices = [
+    {
+        mock: 1,
+        model: "external_converters_device_1",
+        zigbeeModel: ["external_converter_device_1"],
+        vendor: "external_1",
+        description: "external_1",
+        fromZigbee: [],
+        toZigbee: [],
+        exposes: [],
+    },
+    {
+        mock: 2,
+        model: "external_converters_device_2",
+        zigbeeModel: ["external_converter_device_2"],
+        vendor: "external_2",
+        description: "external_2",
+        fromZigbee: [],
+        toZigbee: [],
+        exposes: [],
+    },
+];
+
+module.exports = mockDevices;
@@ -0,0 +1,14 @@
+const {posix} = require("node:path");
+
+const mockDevice = {
+    mock: true,
+    zigbeeModel: ["external_converter_device"],
+    vendor: "external",
+    model: "external_converter_device",
+    description: posix.join("external", "converter"),
+    fromZigbee: [],
+    toZigbee: [],
+    exposes: [],
+};
+
+module.exports = mockDevice;
@@ -0,0 +1,22 @@
+export default [
+    {
+        mock: 1,
+        model: "external_converters_device_1",
+        zigbeeModel: ["external_converter_device_1"],
+        vendor: "external_1",
+        description: "external_1",
+        fromZigbee: [],
+        toZigbee: [],
+        exposes: [],
+    },
+    {
+        mock: 2,
+        model: "external_converters_device_2",
+        zigbeeModel: ["external_converter_device_2"],
+        vendor: "external_2",
+        description: "external_2",
+        fromZigbee: [],
+        toZigbee: [],
+        exposes: [],
+    },
+];
@@ -0,0 +1,12 @@
+import {posix} from "node:path";
+
+import {identify} from "zigbee-herdsman-converters/lib/modernExtend";
+
+export default {
+    mock: true,
+    zigbeeModel: ["external_converter_device"],
+    vendor: "external",
+    model: "external_converter_device",
+    description: posix.join("external", "converter"),
+    extend: [identify()],
+};
@@ -0,0 +1,16 @@
+class Example2 {
+    constructor(_zigbee, mqtt, _state, _publishEntityState, _eventBus) {
+        this.mqtt = mqtt;
+        this.mqtt.publish("example2/extension", "call2 from constructor");
+    }
+
+    start() {
+        this.mqtt.publish("example2/extension", "call2 from start");
+    }
+
+    stop() {
+        this.mqtt.publish("example/extension", "call2 from stop");
+    }
+}
+
+module.exports = Example2;
@@ -0,0 +1,16 @@
+class Example {
+    constructor(_zigbee, mqtt, _state, _publishEntityState, _eventBus) {
+        this.mqtt = mqtt;
+        this.mqtt.publish("example/extension", "call from constructor");
+    }
+
+    start() {
+        this.mqtt.publish("example/extension", "call from start");
+    }
+
+    stop() {
+        this.mqtt.publish("example/extension", "call from stop");
+    }
+}
+
+module.exports = Example;
@@ -0,0 +1,14 @@
+export default class Example2 {
+    constructor(_zigbee, mqtt, _state, _publishEntityState, _eventBus) {
+        this.mqtt = mqtt;
+        this.mqtt.publish("example2/extension", "call2 from constructor");
+    }
+
+    start() {
+        this.mqtt.publish("example2/extension", "call2 from start");
+    }
+
+    stop() {
+        this.mqtt.publish("example/extension", "call2 from stop");
+    }
+}
@@ -0,0 +1,17 @@
+export default class Example {
+    constructor(_zigbee, mqtt, _state, _publishEntityState, _eventBus) {
+        this.mqtt = mqtt;
+        this.mqtt.publish("example/extension", "call from constructor");
+        this.counter = 0;
+    }
+
+    start() {
+        this.mqtt.publish("example/extension", "call from start");
+        this.mqtt.publish("example/extension/counter", `start ${this.counter++}`);
+    }
+
+    stop() {
+        this.mqtt.publish("example/extension", "call from stop");
+        this.mqtt.publish("example/extension/counter", `stop ${--this.counter}`);
+    }
+}
--- a/Show More
+++ b/Show More