chore(dev): release 2.7.1 (#29926)

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

.github/ISSUE_TEMPLATE/config.yml

@@ -2,19 +2,25 @@ 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
+      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 about devices or show things you made
-    - name: Frontend issues
-      url: https://github.com/nurikk/z2m-frontend/issues
-      about: Issues related to the frontend.
+      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 related to the Home Assistant addon.
+      about: Issues with the Home Assistant addon
     - name: FAQ
       url: https://www.zigbee2mqtt.io/guide/faq
-      about: Frequently asked questions.
+      about: Frequently asked questions
     - name: Support Chat
       url: https://discord.gg/NyseBeK
-      about: Chat for feedback, questions and troubleshooting.
+      about: Chat for feedback, questions and troubleshooting

.github/ISSUE_TEMPLATE/external_converter.yaml

@@ -0,0 +1,55 @@
+name: External converter
+description: Submit an external converter
+title: '[External Converter]: '
+labels: [external converter]
+body:
+    - type: markdown
+      attributes:
+          value: |
+            **IMPORTANT:** In case the external converter fully works, please consider submitting a [pull request](https://www.zigbee2mqtt.io/advanced/support-new-devices/01_support_new_devices.html#_4-create-a-pull-request) instead.
+    - 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: external_definition
+      attributes:
+          label: External converter
+          description: Code of the external converter, to retrieve in the Z2M frontend go to Settings -> Dev Console -> External Converters
+          render: JavaScript
+      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
+    - type: textarea
+      id: notes
+      attributes:
+          label: Notes
+          description: Any additional information or context that might be helpful
+          placeholder: Add any relevant notes or context here
+      validations:
+          required: false

.github/ISSUE_TEMPLATE/new_device_support.yaml

@@ -36,17 +36,11 @@ body:
       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
+      id: external_definition
       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
+          render: JavaScript
       validations:
           required: true
     - type: textarea
@@ -55,3 +49,11 @@ body:
           description: Indicate what works and what doesn't work with the external definition.
       validations:
           required: true
+    - type: textarea
+      id: notes
+      attributes:
+          label: Notes
+          description: Any additional information or context that might be helpful
+          placeholder: Add any relevant notes or context here
+      validations:
+          required: false

.github/ISSUE_TEMPLATE/problem_report.yaml

@@ -6,9 +6,10 @@ body:
       attributes:
           value: |
               **IMPORTANT:** Before submitting:
+              - Zigbee2MQTT fails to start? Read [this](https://www.zigbee2mqtt.io/guide/installation/20_zigbee2mqtt-fails-to-start_crashes-runtime.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) 
-              - 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)
@@ -58,14 +59,22 @@ body:
           placeholder: Electrolama zig-a-zig-ah! (zzh!), Slaesh's CC2652RB stick, ...
       validations:
           required: true
-    - type: input
+    - type: textarea
       id: setup
       attributes:
           label: Setup
-          description: How do you run Z2M (plain, add-on...) and on what machine (Pi, x86-64, containerized...)?
+          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: input
+      id: device
+      attributes:
+          label: Device `database.db` entry
+          description: If the problem is related to a specific device, paste the `database.db` entry here
+          placeholder: '{"id":117,"type":"EndDevice","ieeeAddr":"0x00158d0001d8e1d2","nwkAddr":25887 ...'
     - type: textarea
       id: log
       attributes:
@@ -74,3 +83,11 @@ body:
           placeholder: Click here and drag the file into it or click on "Attach files by.." below
       validations:
           required: false
+    - type: textarea
+      id: notes
+      attributes:
+          label: Notes
+          description: Any additional information or context that might be helpful
+          placeholder: Add any relevant notes or context here
+      validations:
+          required: false

.github/ISSUE_TEMPLATE/wrong_device.yaml

@@ -6,7 +6,10 @@ 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.
+            Submit this issue only if your device is detected as **supported** and works **fully**, but displays an incorrect picture, vendor, model, or description.
+
+            **IMPORTANT**: Before opening this issue, please review the [guide](https://www.zigbee2mqtt.io/advanced/support-new-devices/02_support_new_tuya_devices.html#fixing-tuya-device-detection) for instructions on fixing the device detection yourself.
+            This usually only takes 5 minutes.
     - type: input
       id: link
       attributes:

.github/copilot-instructions.md

@@ -0,0 +1,459 @@
+# GitHub Copilot Instructions
+
+## Priority Guidelines
+
+When generating code for this repository:
+
+1. **Version Compatibility**: Always detect and respect the exact versions of languages, frameworks, and libraries used in this project
+2. **Context Files**: Prioritize patterns and standards defined in the .github/copilot directory
+3. **Codebase Patterns**: When context files don't provide specific guidance, scan the codebase for established patterns
+4. **Architectural Consistency**: Maintain our layered architectural style with clear separation between controller, extensions, models, and utilities
+5. **Code Quality**: Prioritize maintainability, performance, security, and testability in all generated code
+
+## Technology Stack
+
+### Core Technologies
+- **Language**: TypeScript 5.9.3 with target `esnext` and module `NodeNext`
+- **Runtime**: Node.js ^20 || ^22 || ^24
+- **Package Manager**: pnpm 10.12.1
+- **Testing**: Vitest 3.1.1 with @vitest/coverage-v8
+- **Linting/Formatting**: Biome 2.2.5 (configured with 4-space indents, 150 line width, no bracket spacing)
+
+### Key Dependencies
+- **zigbee-herdsman**: 6.2.0 (exact version - critical for Zigbee protocol compatibility)
+- **zigbee-herdsman-converters**: 25.42.0 (exact version - device definitions)
+- **MQTT**: mqtt 5.14.1
+- **Logging**: winston 3.18.3
+- **YAML**: js-yaml 4.1.0
+- **Decorators**: bind-decorator 1.0.11
+- **WebSocket**: ws 8.18.1
+
+### TypeScript Configuration
+- **Strict Mode**: Enabled with `noImplicitAny` and `noImplicitThis`
+- **Module System**: NodeNext with ESM interop
+- **Decorators**: Experimental decorators enabled
+- **Composite**: True (for project references)
+- **Source Maps**: Inline source maps enabled
+- **Output**: Compiled to `dist/` directory
+
+## Project Architecture
+
+### Directory Structure
+```
+lib/                    # Source TypeScript files
+├── controller.ts       # Main controller orchestrating all components
+├── mqtt.ts            # MQTT client management
+├── zigbee.ts          # Zigbee network management
+├── state.ts           # State management
+├── eventBus.ts        # Event-driven communication
+├── extension/         # Extension system (plugins)
+│   ├── extension.ts   # Abstract base class
+│   ├── availability.ts
+│   ├── bind.ts
+│   ├── bridge.ts
+│   ├── configure.ts
+│   └── ...
+├── model/             # Domain models
+│   ├── device.ts
+│   └── group.ts
+├── util/              # Utility functions
+│   ├── logger.ts
+│   ├── settings.ts
+│   ├── utils.ts
+│   └── ...
+└── types/             # TypeScript type definitions
+    └── api.ts
+test/                  # Vitest test files
+data/                  # Runtime configuration and data
+```
+
+### Architectural Patterns
+
+#### Extension Pattern
+All extensions inherit from the abstract `Extension` base class:
+```typescript
+abstract class Extension {
+    protected zigbee: Zigbee;
+    protected mqtt: Mqtt;
+    protected state: State;
+    protected publishEntityState: PublishEntityState;
+    protected eventBus: EventBus;
+    
+    async start(): Promise<void> {}
+    async stop(): Promise<void> {}
+}
+```
+
+#### Event-Driven Architecture
+Use the `EventBus` for component communication. Events are strongly typed:
+```typescript
+interface EventBusMap {
+    deviceMessage: [data: eventdata.DeviceMessage];
+    mqttMessage: [data: eventdata.MQTTMessage];
+    publishEntityState: [data: eventdata.PublishEntityState];
+    // ... other events
+}
+```
+
+#### Dependency Injection
+The `Controller` class instantiates and injects dependencies into extensions. Follow this pattern when creating new extensions.
+
+## Code Style and Conventions
+
+### Naming Conventions
+- **Classes**: PascalCase (e.g., `Extension`, `Device`, `EventBus`)
+- **Interfaces/Types**: PascalCase (e.g., `MqttPublishOptions`, `DeviceOptions`)
+- **Functions/Methods**: camelCase (e.g., `publishEntityState`, `enableDisableExtension`)
+- **Constants**: SCREAMING_SNAKE_CASE for top-level constants (e.g., `CURRENT_VERSION`, `LOG_LEVELS`)
+- **Private members**: Prefix with underscore for private class fields only when needed to distinguish from public properties (e.g., `_definitionModelID`)
+- **Files**: camelCase for TypeScript files (e.g., `eventBus.ts`, `externalJS.ts`)
+
+### Import Organization
+Follow this import order (separated by blank lines):
+1. Node.js built-in modules (use `node:` prefix: `import fs from "node:fs"`)
+2. Third-party libraries (e.g., `bind-decorator`, `mqtt`)
+3. Type-only imports from external packages (using `type` keyword)
+4. Internal absolute imports from project root
+5. Type-only imports from internal modules
+
+Example:
+```typescript
+import fs from "node:fs";
+import bind from "bind-decorator";
+import type {IClientOptions} from "mqtt";
+import {connectAsync} from "mqtt";
+import type {Zigbee2MQTTAPI} from "./types/api";
+import logger from "./util/logger";
+import * as settings from "./util/settings";
+```
+
+### Type Annotations
+- Use `type` imports for TypeScript types: `import type * as zhc from "zigbee-herdsman-converters"`
+- Explicitly type function parameters and return types
+- Use `KeyValue` type for generic object payloads: `type KeyValue = Record<string, any>`
+- Prefer interfaces for object shapes, type aliases for unions/intersections
+- Use namespace exports for related types: `export type * as ZSpec from "zigbee-herdsman/dist/zspec"`
+
+### Async/Await Patterns
+- Always use `async/await` for asynchronous operations
+- Return types should be explicitly `Promise<Type>`
+- Methods that don't return values should be `Promise<void>`
+- Use `Awaited<ReturnType<typeof fn>>` for inferring async function return types
+
+### Decorators
+Use `@bind` decorator from `bind-decorator` for methods that need `this` binding:
+```typescript
+@bind async onMQTTMessage(data: eventdata.MQTTMessage): Promise<void> {
+    // Implementation
+}
+```
+
+### Error Handling
+- Use `throw new Error("message")` for explicit errors
+- Include descriptive error messages
+- Log errors using the logger: `logger.error("message")`
+- For Zigbee-herdsman errors, log the stack trace: `logger.error((error as Error).stack!)`
+- Catch and handle errors at appropriate boundaries (controller level)
+
+### Logging
+Use the centralized logger (winston-based):
+```typescript
+import logger from "./util/logger";
+
+logger.info("message");
+logger.warning("message");
+logger.error("message");
+logger.debug("message");
+```
+
+- Use namespaced loggers for specific modules (created internally by logger)
+- Log levels: `error`, `warning`, `info`, `debug` (from most to least critical)
+- Include relevant context in log messages (device names, IEEE addresses, etc.)
+
+## Code Quality Standards
+
+### Maintainability
+- Write self-documenting code with clear, descriptive names
+- Keep methods focused on single responsibilities
+- Abstract classes should define clear contracts with protected members for subclasses
+- Use constructor dependency injection for required dependencies
+- Limit function complexity - methods should be concise and focused
+- Use TypeScript's strict mode features (`noImplicitAny`, `noImplicitThis`)
+
+### Performance
+- Use `rimrafSync` for synchronous file deletion when appropriate
+- Leverage async/await for I/O operations to avoid blocking
+- Use JSON stable stringify for consistent object serialization: `json-stable-stringify-without-jsonify`
+- Cache computed values when appropriate (see device model patterns)
+- Use getter methods for computed properties that should be cached
+
+### Security
+- Validate input using Ajv JSON schema validation (see `settings.ts` pattern)
+- Sanitize file paths using `path.join` from Node.js
+- Use YAML safe loading: `yaml.safeLoad()`
+- Handle sensitive data (credentials, tokens) through settings with proper defaults
+- Never log sensitive information (passwords, tokens)
+
+### Testability
+- Write tests using Vitest with describe/it/expect patterns
+- Mock external dependencies using Vitest's `vi.mock()`
+- Use `beforeEach`, `afterEach`, `beforeAll`, `afterAll` for test setup/teardown
+- Place test files in `test/` directory with `.test.ts` extension
+- Mock constructors and modules in the pattern shown in `test/controller.test.ts`
+- Use `flushPromises()` utility for async test synchronization
+- Target 100% code coverage (configured in vitest.config.mts)
+
+## Testing Standards
+
+### Unit Testing Structure
+```typescript
+import {afterAll, beforeAll, beforeEach, describe, expect, it, vi} from "vitest";
+
+describe("ComponentName", () => {
+    beforeEach(() => {
+        // Setup
+    });
+
+    it("Should do something specific", async () => {
+        // Arrange
+        const input = {};
+        
+        // Act
+        const result = await someFunction(input);
+        
+        // Assert
+        expect(result).toBe(expected);
+    });
+});
+```
+
+### Mocking Patterns
+- Create mock modules in `test/mocks/` directory
+- Use `vi.fn()` for function mocks
+- Use `vi.mock()` for module mocks
+- Clear mocks in `afterEach` or between tests
+- Mock external libraries like `mqtt`, `zigbee-herdsman` consistently
+
+### Test Coverage
+- All code in `lib/**` should be covered
+- Use coverage reports: `pnpm test:coverage`
+- Thresholds set to 100% (can be adjusted per project needs)
+- Tests should cover both success and failure paths
+
+## Documentation Standards
+
+### JSDoc Comments
+Use JSDoc-style comments for classes and public methods:
+```typescript
+/**
+ * Besides initializing variables, the constructor should do nothing!
+ *
+ * @param {Zigbee} zigbee Zigbee 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
+ */
+constructor(zigbee: Zigbee, mqtt: Mqtt, state: State, ...) {
+```
+
+### Comment Style
+- Use single-line comments (`//`) for implementation notes
+- Use JSDoc (`/** */`) for public APIs and class/method documentation
+- Include context for non-obvious logic
+- Document parameters with their types and purposes
+- Use `@param` tags with TypeScript types in braces
+- Use biome-ignore comments when necessary: `// biome-ignore lint/rule: reason`
+
+### Code Documentation
+- Document complex algorithms or business logic
+- Explain "why" not just "what" when logic is non-trivial
+- Include links to relevant issues or documentation when applicable
+- Document deprecations and breaking changes
+
+## TypeScript-Specific Guidelines
+
+### Module System
+- Use ES modules with `import`/`export` syntax
+- Default exports for main classes: `export default class Device {}`
+- Named exports for utilities and types: `export const LOG_LEVELS = ...`
+- Namespace exports for related types: `export type * as ZSpec from ...`
+- Use `.js` extension in imports for local modules when using dynamic imports: `await import("./extension/frontend.js")`
+
+### Type Safety
+- Enable all strict type checking options
+- Use type guards and assertions when necessary: `asserts expose is zhc.Numeric`
+- Prefer `unknown` over `any` when type is truly unknown
+- Use `// biome-ignore lint/suspicious/noExplicitAny: API` when `any` is necessary
+- Define proper interfaces for external module types (e.g., `unix-dgram.d.ts`)
+
+### Generic Types
+- Use generics for reusable, type-safe abstractions
+- Example: `abstract class ExternalJSExtension<M> extends Extension`
+- Constrain generics when appropriate
+- Document generic type parameters
+
+### Utility Types
+- Use built-in utility types: `Partial`, `Required`, `Pick`, `Omit`, `Record`
+- Use `Awaited<ReturnType<typeof fn>>` for async function return types
+- Define custom utility types when patterns emerge
+- Use `type` for aliases, `interface` for object shapes
+
+## Version Control and Releases
+
+### Versioning Strategy
+- Follow Semantic Versioning (MAJOR.MINOR.PATCH)
+- Current version managed in `package.json`
+- Use `-dev` suffix for development versions (e.g., `2.6.2-dev`)
+- Configuration version tracked separately: `CURRENT_VERSION = 4`
+
+### Changelog
+- Maintain CHANGELOG.md with all changes
+- Group changes by type: Bug Fixes, Features, Breaking Changes
+- Include issue/PR references: `([#28583](url))`
+- Include commit references: `([09f33b3](url))`
+- Use conventional commits format
+
+### Git Workflow
+- Development on `dev` branch
+- Production releases from `master` branch
+- Use meaningful commit messages
+- Reference issues in commits
+
+## Project-Specific Patterns
+
+### Settings Management
+- All configuration loaded through `util/settings.ts`
+- Validate settings using Ajv with JSON schema
+- Schema defined in `settings.schema.json`
+- Support runtime setting changes with restart detection
+- Use `settings.get()` to access current configuration
+- Use `settings.getDevice(ieeeAddr)` for device-specific config
+
+### Device and Group Models
+- Devices and groups are domain models wrapping `zigbee-herdsman` entities
+- Access underlying entity via `.zh` property
+- Expose computed properties as getters
+- Include definition from `zigbee-herdsman-converters`
+- Handle coordinator devices specially (type checking)
+
+### MQTT Integration
+- MQTT client wrapped in `Mqtt` class
+- Publish options: `retain`, `qos` properties
+- Topics follow pattern: `{base_topic}/{device}/{attribute}`
+- Event-based message handling via EventBus
+- Clean disconnect handling with retry logic
+
+### Extension System
+- Extensions are loosely coupled plugins
+- Lifecycle: constructor → start() → stop()
+- Constructor should only assign properties (no side effects)
+- Use EventBus for inter-extension communication
+- Extensions can be enabled/disabled at runtime
+- External extensions loaded from `data/external_extensions/`
+
+### State Management
+- State persisted to `state.json`
+- Cached in memory for performance
+- Device states include all exposed attributes
+- State changes trigger events via EventBus
+
+## Best Practices Specific to This Project
+
+1. **Never use language features beyond TypeScript 5.9.3 or ES2024**
+2. **Always respect exact versions of zigbee-herdsman and zigbee-herdsman-converters** - these are critical for device compatibility
+3. **Use the EventBus for all component communication** - avoid direct coupling
+4. **Follow the Extension pattern for new features** - don't add logic directly to Controller
+5. **Log appropriately** - info for user-relevant events, debug for developer info, error for failures
+6. **Test with real Zigbee scenarios** - many edge cases exist with different device types
+7. **Handle coordinator specially** - coordinator is a device but with unique behavior
+8. **Validate all external input** - MQTT messages, configuration files, device data
+9. **Use the bind decorator** for event handlers to preserve `this` context
+10. **Match the exact code formatting** - Biome enforces 4 spaces, 150 line width, no bracket spacing
+
+## Common Patterns to Follow
+
+### Creating a New Extension
+1. Extend `Extension` abstract class
+2. Accept all dependencies in constructor
+3. Implement `start()` method for initialization
+4. Subscribe to EventBus events in `start()`
+5. Implement `stop()` method for cleanup
+6. Export as default: `export default class MyExtension extends Extension`
+
+### Accessing Device Information
+```typescript
+const device: Device; // Our wrapper
+device.ieeeAddr;      // IEEE address
+device.name;          // Friendly name
+device.zh;            // Underlying zigbee-herdsman device
+device.definition;    // zigbee-herdsman-converters definition
+device.options;       // User configuration
+```
+
+### Publishing MQTT Messages
+```typescript
+await this.mqtt.publish(topic, message, {retain: true, qos: 0});
+```
+
+### Emitting Events
+```typescript
+this.eventBus.emit('deviceMessage', {device, message});
+```
+
+### Listening to Events
+```typescript
+this.eventBus.on('deviceMessage', this.onDeviceMessage, this);
+```
+
+## Integration Points
+
+### Zigbee-Herdsman Integration
+- Start controller: `await this.zigbee.start()`
+- Access coordinator: `this.zigbee.coordinator()`
+- Device operations through `zigbee-herdsman` API
+- Event handling through EventBus wrappers
+
+### MQTT Integration  
+- Connect: `await this.mqtt.connect()`
+- Subscribe: `await this.mqtt.subscribe(topic)`
+- Publish: `await this.mqtt.publish(topic, message, options)`
+- Handle messages via EventBus `mqttMessage` event
+
+### Frontend Integration
+- Optional extension loaded dynamically
+- Serves static files with compression
+- WebSocket support for real-time updates
+- Configurable port and base URL
+
+### Home Assistant Integration
+- Optional extension for discovery
+- Publishes discovery messages to MQTT
+- Supports entities, sensors, and devices
+- Configurable discovery topic
+
+## Critical Compatibility Notes
+
+1. **Node.js**: Only versions 20, 22, and 24 are supported
+2. **TypeScript**: Features must be compatible with 5.9.3
+3. **Zigbee Libraries**: Exact versions are critical - do not suggest upgrades without testing
+4. **MQTT Protocol**: Uses MQTT 3.1.1 and 5.0 features
+5. **ES Modules**: Project uses ESM with NodeNext resolution
+6. **Experimental Decorators**: Required for `@bind` decorator support
+
+## When in Doubt
+
+1. **Search for similar patterns** in the existing codebase
+2. **Check existing extensions** for implementation examples
+3. **Follow the controller and extension architecture** - don't bypass it
+4. **Consult the test files** for usage examples
+5. **Match the exact style** - run `pnpm check` to verify
+6. **Prioritize consistency** over external best practices
+7. **Test thoroughly** - this project controls real hardware
+
+## Resources
+
+- Repository: https://github.com/Koenkk/zigbee2mqtt
+- Documentation: https://koenkk.github.io/zigbee2mqtt
+- License: GPL-3.0
+- Issue Tracker: https://github.com/Koenkk/zigbee2mqtt/issues

.github/dependabot.yml

@@ -1,13 +1,26 @@
 version: 2
 updates:
-    - package-ecosystem: 'github-actions'
-      directory: '/'
+    - package-ecosystem: npm
+      versioning-strategy: increase
+      directory: /
       schedule:
-          interval: 'daily'
+          interval: weekly
       target-branch: dev
-
-    - package-ecosystem: 'docker'
-      directory: '/docker'
+      commit-message:
+        prefix: fix(ignore)
+      groups:
+          minor-patch:
+              applies-to: version-updates
+              update-types:
+                  - minor
+                  - patch
+    - package-ecosystem: docker
+      directory: /docker
       schedule:
-          interval: 'daily'
+        interval: weekly
+      target-branch: dev
+    - package-ecosystem: github-actions
+      directory: /
+      schedule:
+        interval: weekly
       target-branch: dev

.github/prompts/copilot-instructions-blueprint-generator.prompt.md

@@ -0,0 +1,294 @@
+---
+description: 'Technology-agnostic blueprint generator for creating comprehensive copilot-instructions.md files that guide GitHub Copilot to produce code consistent with project standards, architecture patterns, and exact technology versions by analyzing existing codebase patterns and avoiding assumptions.'
+mode: 'agent'
+---
+
+# Copilot Instructions Blueprint Generator
+
+## Configuration Variables
+${PROJECT_TYPE="Auto-detect|.NET|Java|JavaScript|TypeScript|React|Angular|Python|Multiple|Other"} <!-- Primary technology -->
+${ARCHITECTURE_STYLE="Layered|Microservices|Monolithic|Domain-Driven|Event-Driven|Serverless|Mixed"} <!-- Architectural approach -->
+${CODE_QUALITY_FOCUS="Maintainability|Performance|Security|Accessibility|Testability|All"} <!-- Quality priorities -->
+${DOCUMENTATION_LEVEL="Minimal|Standard|Comprehensive"} <!-- Documentation requirements -->
+${TESTING_REQUIREMENTS="Unit|Integration|E2E|TDD|BDD|All"} <!-- Testing approach -->
+${VERSIONING="Semantic|CalVer|Custom"} <!-- Versioning approach -->
+
+## Generated Prompt
+
+"Generate a comprehensive copilot-instructions.md file that will guide GitHub Copilot to produce code consistent with our project's standards, architecture, and technology versions. The instructions must be strictly based on actual code patterns in our codebase and avoid making any assumptions. Follow this approach:
+
+### 1. Core Instruction Structure
+
+```markdown
+# GitHub Copilot Instructions
+
+## Priority Guidelines
+
+When generating code for this repository:
+
+1. **Version Compatibility**: Always detect and respect the exact versions of languages, frameworks, and libraries used in this project
+2. **Context Files**: Prioritize patterns and standards defined in the .github/copilot directory
+3. **Codebase Patterns**: When context files don't provide specific guidance, scan the codebase for established patterns
+4. **Architectural Consistency**: Maintain our ${ARCHITECTURE_STYLE} architectural style and established boundaries
+5. **Code Quality**: Prioritize ${CODE_QUALITY_FOCUS == "All" ? "maintainability, performance, security, accessibility, and testability" : CODE_QUALITY_FOCUS} in all generated code
+
+## Technology Version Detection
+
+Before generating code, scan the codebase to identify:
+
+1. **Language Versions**: Detect the exact versions of programming languages in use
+   - Examine project files, configuration files, and package managers
+   - Look for language-specific version indicators (e.g., <LangVersion> in .NET projects)
+   - Never use language features beyond the detected version
+
+2. **Framework Versions**: Identify the exact versions of all frameworks
+   - Check package.json, .csproj, pom.xml, requirements.txt, etc.
+   - Respect version constraints when generating code
+   - Never suggest features not available in the detected framework versions
+
+3. **Library Versions**: Note the exact versions of key libraries and dependencies
+   - Generate code compatible with these specific versions
+   - Never use APIs or features not available in the detected versions
+
+## Context Files
+
+Prioritize the following files in .github/copilot directory (if they exist):
+
+- **architecture.md**: System architecture guidelines
+- **tech-stack.md**: Technology versions and framework details
+- **coding-standards.md**: Code style and formatting standards
+- **folder-structure.md**: Project organization guidelines
+- **exemplars.md**: Exemplary code patterns to follow
+
+## Codebase Scanning Instructions
+
+When context files don't provide specific guidance:
+
+1. Identify similar files to the one being modified or created
+2. Analyze patterns for:
+   - Naming conventions
+   - Code organization
+   - Error handling
+   - Logging approaches
+   - Documentation style
+   - Testing patterns
+   
+3. Follow the most consistent patterns found in the codebase
+4. When conflicting patterns exist, prioritize patterns in newer files or files with higher test coverage
+5. Never introduce patterns not found in the existing codebase
+
+## Code Quality Standards
+
+${CODE_QUALITY_FOCUS.includes("Maintainability") || CODE_QUALITY_FOCUS == "All" ? `### Maintainability
+- Write self-documenting code with clear naming
+- Follow the naming and organization conventions evident in the codebase
+- Follow established patterns for consistency
+- Keep functions focused on single responsibilities
+- Limit function complexity and length to match existing patterns` : ""}
+
+${CODE_QUALITY_FOCUS.includes("Performance") || CODE_QUALITY_FOCUS == "All" ? `### Performance
+- Follow existing patterns for memory and resource management
+- Match existing patterns for handling computationally expensive operations
+- Follow established patterns for asynchronous operations
+- Apply caching consistently with existing patterns
+- Optimize according to patterns evident in the codebase` : ""}
+
+${CODE_QUALITY_FOCUS.includes("Security") || CODE_QUALITY_FOCUS == "All" ? `### Security
+- Follow existing patterns for input validation
+- Apply the same sanitization techniques used in the codebase
+- Use parameterized queries matching existing patterns
+- Follow established authentication and authorization patterns
+- Handle sensitive data according to existing patterns` : ""}
+
+${CODE_QUALITY_FOCUS.includes("Accessibility") || CODE_QUALITY_FOCUS == "All" ? `### Accessibility
+- Follow existing accessibility patterns in the codebase
+- Match ARIA attribute usage with existing components
+- Maintain keyboard navigation support consistent with existing code
+- Follow established patterns for color and contrast
+- Apply text alternative patterns consistent with the codebase` : ""}
+
+${CODE_QUALITY_FOCUS.includes("Testability") || CODE_QUALITY_FOCUS == "All" ? `### Testability
+- Follow established patterns for testable code
+- Match dependency injection approaches used in the codebase
+- Apply the same patterns for managing dependencies
+- Follow established mocking and test double patterns
+- Match the testing style used in existing tests` : ""}
+
+## Documentation Requirements
+
+${DOCUMENTATION_LEVEL == "Minimal" ? 
+`- Match the level and style of comments found in existing code
+- Document according to patterns observed in the codebase
+- Follow existing patterns for documenting non-obvious behavior
+- Use the same format for parameter descriptions as existing code` : ""}
+
+${DOCUMENTATION_LEVEL == "Standard" ? 
+`- Follow the exact documentation format found in the codebase
+- Match the XML/JSDoc style and completeness of existing comments
+- Document parameters, returns, and exceptions in the same style
+- Follow existing patterns for usage examples
+- Match class-level documentation style and content` : ""}
+
+${DOCUMENTATION_LEVEL == "Comprehensive" ? 
+`- Follow the most detailed documentation patterns found in the codebase
+- Match the style and completeness of the best-documented code
+- Document exactly as the most thoroughly documented files do
+- Follow existing patterns for linking documentation
+- Match the level of detail in explanations of design decisions` : ""}
+
+## Testing Approach
+
+${TESTING_REQUIREMENTS.includes("Unit") || TESTING_REQUIREMENTS == "All" ? 
+`### Unit Testing
+- Match the exact structure and style of existing unit tests
+- Follow the same naming conventions for test classes and methods
+- Use the same assertion patterns found in existing tests
+- Apply the same mocking approach used in the codebase
+- Follow existing patterns for test isolation` : ""}
+
+${TESTING_REQUIREMENTS.includes("Integration") || TESTING_REQUIREMENTS == "All" ? 
+`### Integration Testing
+- Follow the same integration test patterns found in the codebase
+- Match existing patterns for test data setup and teardown
+- Use the same approach for testing component interactions
+- Follow existing patterns for verifying system behavior` : ""}
+
+${TESTING_REQUIREMENTS.includes("E2E") || TESTING_REQUIREMENTS == "All" ? 
+`### End-to-End Testing
+- Match the existing E2E test structure and patterns
+- Follow established patterns for UI testing
+- Apply the same approach for verifying user journeys` : ""}
+
+${TESTING_REQUIREMENTS.includes("TDD") || TESTING_REQUIREMENTS == "All" ? 
+`### Test-Driven Development
+- Follow TDD patterns evident in the codebase
+- Match the progression of test cases seen in existing code
+- Apply the same refactoring patterns after tests pass` : ""}
+
+${TESTING_REQUIREMENTS.includes("BDD") || TESTING_REQUIREMENTS == "All" ? 
+`### Behavior-Driven Development
+- Match the existing Given-When-Then structure in tests
+- Follow the same patterns for behavior descriptions
+- Apply the same level of business focus in test cases` : ""}
+
+## Technology-Specific Guidelines
+
+${PROJECT_TYPE == ".NET" || PROJECT_TYPE == "Auto-detect" || PROJECT_TYPE == "Multiple" ? `### .NET Guidelines
+- Detect and strictly adhere to the specific .NET version in use
+- Use only C# language features compatible with the detected version
+- Follow LINQ usage patterns exactly as they appear in the codebase
+- Match async/await usage patterns from existing code
+- Apply the same dependency injection approach used in the codebase
+- Use the same collection types and patterns found in existing code` : ""}
+
+${PROJECT_TYPE == "Java" || PROJECT_TYPE == "Auto-detect" || PROJECT_TYPE == "Multiple" ? `### Java Guidelines
+- Detect and adhere to the specific Java version in use
+- Follow the exact same design patterns found in the codebase
+- Match exception handling patterns from existing code
+- Use the same collection types and approaches found in the codebase
+- Apply the dependency injection patterns evident in existing code` : ""}
+
+${PROJECT_TYPE == "JavaScript" || PROJECT_TYPE == "TypeScript" || PROJECT_TYPE == "Auto-detect" || PROJECT_TYPE == "Multiple" ? `### JavaScript/TypeScript Guidelines
+- Detect and adhere to the specific ECMAScript/TypeScript version in use
+- Follow the same module import/export patterns found in the codebase
+- Match TypeScript type definitions with existing patterns
+- Use the same async patterns (promises, async/await) as existing code
+- Follow error handling patterns from similar files` : ""}
+
+${PROJECT_TYPE == "React" || PROJECT_TYPE == "Auto-detect" || PROJECT_TYPE == "Multiple" ? `### React Guidelines
+- Detect and adhere to the specific React version in use
+- Match component structure patterns from existing components
+- Follow the same hooks and lifecycle patterns found in the codebase
+- Apply the same state management approach used in existing components
+- Match prop typing and validation patterns from existing code` : ""}
+
+${PROJECT_TYPE == "Angular" || PROJECT_TYPE == "Auto-detect" || PROJECT_TYPE == "Multiple" ? `### Angular Guidelines
+- Detect and adhere to the specific Angular version in use
+- Follow the same component and module patterns found in the codebase
+- Match decorator usage exactly as seen in existing code
+- Apply the same RxJS patterns found in the codebase
+- Follow existing patterns for component communication` : ""}
+
+${PROJECT_TYPE == "Python" || PROJECT_TYPE == "Auto-detect" || PROJECT_TYPE == "Multiple" ? `### Python Guidelines
+- Detect and adhere to the specific Python version in use
+- Follow the same import organization found in existing modules
+- Match type hinting approaches if used in the codebase
+- Apply the same error handling patterns found in existing code
+- Follow the same module organization patterns` : ""}
+
+## Version Control Guidelines
+
+${VERSIONING == "Semantic" ? 
+`- Follow Semantic Versioning patterns as applied in the codebase
+- Match existing patterns for documenting breaking changes
+- Follow the same approach for deprecation notices` : ""}
+
+${VERSIONING == "CalVer" ? 
+`- Follow Calendar Versioning patterns as applied in the codebase
+- Match existing patterns for documenting changes
+- Follow the same approach for highlighting significant changes` : ""}
+
+${VERSIONING == "Custom" ? 
+`- Match the exact versioning pattern observed in the codebase
+- Follow the same changelog format used in existing documentation
+- Apply the same tagging conventions used in the project` : ""}
+
+## General Best Practices
+
+- Follow naming conventions exactly as they appear in existing code
+- Match code organization patterns from similar files
+- Apply error handling consistent with existing patterns
+- Follow the same approach to testing as seen in the codebase
+- Match logging patterns from existing code
+- Use the same approach to configuration as seen in the codebase
+
+## Project-Specific Guidance
+
+- Scan the codebase thoroughly before generating any code
+- Respect existing architectural boundaries without exception
+- Match the style and patterns of surrounding code
+- When in doubt, prioritize consistency with existing code over external best practices
+```
+
+### 2. Codebase Analysis Instructions
+
+To create the copilot-instructions.md file, first analyze the codebase to:
+
+1. **Identify Exact Technology Versions**:
+   - ${PROJECT_TYPE == "Auto-detect" ? "Detect all programming languages, frameworks, and libraries by scanning file extensions and configuration files" : `Focus on ${PROJECT_TYPE} technologies`}
+   - Extract precise version information from project files, package.json, .csproj, etc.
+   - Document version constraints and compatibility requirements
+
+2. **Understand Architecture**:
+   - Analyze folder structure and module organization
+   - Identify clear layer boundaries and component relationships
+   - Document communication patterns between components
+
+3. **Document Code Patterns**:
+   - Catalog naming conventions for different code elements
+   - Note documentation styles and completeness
+   - Document error handling patterns
+   - Map testing approaches and coverage
+
+4. **Note Quality Standards**:
+   - Identify performance optimization techniques actually used
+   - Document security practices implemented in the code
+   - Note accessibility features present (if applicable)
+   - Document code quality patterns evident in the codebase
+
+### 3. Implementation Notes
+
+The final copilot-instructions.md should:
+- Be placed in the .github directory
+- Reference only patterns and standards that exist in the codebase
+- Include explicit version compatibility requirements
+- Avoid prescribing any practices not evident in the code
+- Provide concrete examples from the codebase
+- Be comprehensive yet concise enough for Copilot to effectively use
+
+Important: Only include guidance based on patterns actually observed in the codebase. Explicitly instruct Copilot to prioritize consistency with existing code over external best practices or newer language features.
+"
+
+## Expected Output
+
+A comprehensive copilot-instructions.md file that will guide GitHub Copilot to produce code that is perfectly compatible with your existing technology versions and follows your established patterns and architecture.

.github/prompts/create-agentsmd.prompt.md

@@ -0,0 +1,249 @@
+---
+description: "Prompt for generating an AGENTS.md file for a repository"
+mode: "agent"
+---
+
+# Create high‑quality AGENTS.md file
+
+You are a code agent. Your task is to create a complete, accurate AGENTS.md at the root of this repository that follows the public guidance at https://agents.md/.
+
+AGENTS.md is an open format designed to provide coding agents with the context and instructions they need to work effectively on a project.
+
+## What is AGENTS.md?
+
+AGENTS.md is a Markdown file that serves as a "README for agents" - a dedicated, predictable place to provide context and instructions to help AI coding agents work on your project. It complements README.md by containing detailed technical context that coding agents need but might clutter a human-focused README.
+
+## Key Principles
+
+- **Agent-focused**: Contains detailed technical instructions for automated tools
+- **Complements README.md**: Doesn't replace human documentation but adds agent-specific context
+- **Standardized location**: Placed at repository root (or subproject roots for monorepos)
+- **Open format**: Uses standard Markdown with flexible structure
+- **Ecosystem compatibility**: Works across 20+ different AI coding tools and agents
+
+## File Structure and Content Guidelines
+
+### 1. Required Setup
+
+- Create the file as `AGENTS.md` in the repository root
+- Use standard Markdown formatting
+- No required fields - flexible structure based on project needs
+
+### 2. Essential Sections to Include
+
+#### Project Overview
+
+- Brief description of what the project does
+- Architecture overview if complex
+- Key technologies and frameworks used
+
+#### Setup Commands
+
+- Installation instructions
+- Environment setup steps
+- Dependency management commands
+- Database setup if applicable
+
+#### Development Workflow
+
+- How to start development server
+- Build commands
+- Watch/hot-reload setup
+- Package manager specifics (npm, pnpm, yarn, etc.)
+
+#### Testing Instructions
+
+- How to run tests (unit, integration, e2e)
+- Test file locations and naming conventions
+- Coverage requirements
+- Specific test patterns or frameworks used
+- How to run subset of tests or focus on specific areas
+
+#### Code Style Guidelines
+
+- Language-specific conventions
+- Linting and formatting rules
+- File organization patterns
+- Naming conventions
+- Import/export patterns
+
+#### Build and Deployment
+
+- Build commands and outputs
+- Environment configurations
+- Deployment steps and requirements
+- CI/CD pipeline information
+
+### 3. Optional but Recommended Sections
+
+#### Security Considerations
+
+- Security testing requirements
+- Secrets management
+- Authentication patterns
+- Permission models
+
+#### Monorepo Instructions (if applicable)
+
+- How to work with multiple packages
+- Cross-package dependencies
+- Selective building/testing
+- Package-specific commands
+
+#### Pull Request Guidelines
+
+- Title format requirements
+- Required checks before submission
+- Review process
+- Commit message conventions
+
+#### Debugging and Troubleshooting
+
+- Common issues and solutions
+- Logging patterns
+- Debug configuration
+- Performance considerations
+
+## Example Template
+
+Use this as a starting template and customize based on the specific project:
+
+```markdown
+# AGENTS.md
+
+## Project Overview
+
+[Brief description of the project, its purpose, and key technologies]
+
+## Setup Commands
+
+- Install dependencies: `[package manager] install`
+- Start development server: `[command]`
+- Build for production: `[command]`
+
+## Development Workflow
+
+- [Development server startup instructions]
+- [Hot reload/watch mode information]
+- [Environment variable setup]
+
+## Testing Instructions
+
+- Run all tests: `[command]`
+- Run unit tests: `[command]`
+- Run integration tests: `[command]`
+- Test coverage: `[command]`
+- [Specific testing patterns or requirements]
+
+## Code Style
+
+- [Language and framework conventions]
+- [Linting rules and commands]
+- [Formatting requirements]
+- [File organization patterns]
+
+## Build and Deployment
+
+- [Build process details]
+- [Output directories]
+- [Environment-specific builds]
+- [Deployment commands]
+
+## Pull Request Guidelines
+
+- Title format: [component] Brief description
+- Required checks: `[lint command]`, `[test command]`
+- [Review requirements]
+
+## Additional Notes
+
+- [Any project-specific context]
+- [Common gotchas or troubleshooting tips]
+- [Performance considerations]
+```
+
+## Working Example from agents.md
+
+Here's a real example from the agents.md website:
+
+```markdown
+# Sample AGENTS.md file
+
+## Dev environment tips
+
+- Use `pnpm dlx turbo run where <project_name>` to jump to a package instead of scanning with `ls`.
+- Run `pnpm install --filter <project_name>` to add the package to your workspace so Vite, ESLint, and TypeScript can see it.
+- Use `pnpm create vite@latest <project_name> -- --template react-ts` to spin up a new React + Vite package with TypeScript checks ready.
+- Check the name field inside each package's package.json to confirm the right name—skip the top-level one.
+
+## Testing instructions
+
+- Find the CI plan in the .github/workflows folder.
+- Run `pnpm turbo run test --filter <project_name>` to run every check defined for that package.
+- From the package root you can just call `pnpm test`. The commit should pass all tests before you merge.
+- To focus on one step, add the Vitest pattern: `pnpm vitest run -t "<test name>"`.
+- Fix any test or type errors until the whole suite is green.
+- After moving files or changing imports, run `pnpm lint --filter <project_name>` to be sure ESLint and TypeScript rules still pass.
+- Add or update tests for the code you change, even if nobody asked.
+
+## PR instructions
+
+- Title format: [<project_name>] <Title>
+- Always run `pnpm lint` and `pnpm test` before committing.
+```
+
+## Implementation Steps
+
+1. **Analyze the project structure** to understand:
+
+   - Programming languages and frameworks used
+   - Package managers and build tools
+   - Testing frameworks
+   - Project architecture (monorepo, single package, etc.)
+
+2. **Identify key workflows** by examining:
+
+   - package.json scripts
+   - Makefile or other build files
+   - CI/CD configuration files
+   - Documentation files
+
+3. **Create comprehensive sections** covering:
+
+   - All essential setup and development commands
+   - Testing strategies and commands
+   - Code style and conventions
+   - Build and deployment processes
+
+4. **Include specific, actionable commands** that agents can execute directly
+
+5. **Test the instructions** by ensuring all commands work as documented
+
+6. **Keep it focused** on what agents need to know, not general project information
+
+## Best Practices
+
+- **Be specific**: Include exact commands, not vague descriptions
+- **Use code blocks**: Wrap commands in backticks for clarity
+- **Include context**: Explain why certain steps are needed
+- **Stay current**: Update as the project evolves
+- **Test commands**: Ensure all listed commands actually work
+- **Consider nested files**: For monorepos, create AGENTS.md files in subprojects as needed
+
+## Monorepo Considerations
+
+For large monorepos:
+
+- Place a main AGENTS.md at the repository root
+- Create additional AGENTS.md files in subproject directories
+- The closest AGENTS.md file takes precedence for any given location
+- Include navigation tips between packages/projects
+
+## Final Notes
+
+- AGENTS.md works with 20+ AI coding tools including Cursor, Aider, Gemini CLI, and many others
+- The format is intentionally flexible - adapt it to your project's needs
+- Focus on actionable instructions that help agents understand and work with your codebase
+- This is living documentation - update it as your project evolves
+
+When creating the AGENTS.md file, prioritize clarity, completeness, and actionability. The goal is to give any coding agent enough context to effectively contribute to the project without requiring additional human guidance.

.github/prompts/create-specification.prompt.md

@@ -0,0 +1,127 @@
+---
+mode: 'agent'
+description: 'Create a new specification file for the solution, optimized for Generative AI consumption.'
+tools: ['changes', 'codebase', 'editFiles', 'extensions', 'fetch', 'githubRepo', 'openSimpleBrowser', 'problems', 'runTasks', 'search', 'searchResults', 'terminalLastCommand', 'terminalSelection', 'testFailure', 'usages', 'vscodeAPI']
+---
+# Create Specification
+
+Your goal is to create a new specification file for `${input:SpecPurpose}`.
+
+The specification file must define the requirements, constraints, and interfaces for the solution components in a manner that is clear, unambiguous, and structured for effective use by Generative AIs. Follow established documentation standards and ensure the content is machine-readable and self-contained.
+
+## Best Practices for AI-Ready Specifications
+
+- Use precise, explicit, and unambiguous language.
+- Clearly distinguish between requirements, constraints, and recommendations.
+- Use structured formatting (headings, lists, tables) for easy parsing.
+- Avoid idioms, metaphors, or context-dependent references.
+- Define all acronyms and domain-specific terms.
+- Include examples and edge cases where applicable.
+- Ensure the document is self-contained and does not rely on external context.
+
+The specification should be saved in the [/spec/](/spec/) directory and named according to the following convention: `spec-[a-z0-9-]+.md`, where the name should be descriptive of the specification's content and starting with the highlevel purpose, which is one of [schema, tool, data, infrastructure, process, architecture, or design].
+
+The specification file must be formatted in well formed Markdown.
+
+Specification files must follow the template below, ensuring that all sections are filled out appropriately. The front matter for the markdown should be structured correctly as per the example following:
+
+```md
+---
+title: [Concise Title Describing the Specification's Focus]
+version: [Optional: e.g., 1.0, Date]
+date_created: [YYYY-MM-DD]
+last_updated: [Optional: YYYY-MM-DD]
+owner: [Optional: Team/Individual responsible for this spec]
+tags: [Optional: List of relevant tags or categories, e.g., `infrastructure`, `process`, `design`, `app` etc]
+---
+
+# Introduction
+
+[A short concise introduction to the specification and the goal it is intended to achieve.]
+
+## 1. Purpose & Scope
+
+[Provide a clear, concise description of the specification's purpose and the scope of its application. State the intended audience and any assumptions.]
+
+## 2. Definitions
+
+[List and define all acronyms, abbreviations, and domain-specific terms used in this specification.]
+
+## 3. Requirements, Constraints & Guidelines
+
+[Explicitly list all requirements, constraints, rules, and guidelines. Use bullet points or tables for clarity.]
+
+- **REQ-001**: Requirement 1
+- **SEC-001**: Security Requirement 1
+- **[3 LETTERS]-001**: Other Requirement 1
+- **CON-001**: Constraint 1
+- **GUD-001**: Guideline 1
+- **PAT-001**: Pattern to follow 1
+
+## 4. Interfaces & Data Contracts
+
+[Describe the interfaces, APIs, data contracts, or integration points. Use tables or code blocks for schemas and examples.]
+
+## 5. Acceptance Criteria
+
+[Define clear, testable acceptance criteria for each requirement using Given-When-Then format where appropriate.]
+
+- **AC-001**: Given [context], When [action], Then [expected outcome]
+- **AC-002**: The system shall [specific behavior] when [condition]
+- **AC-003**: [Additional acceptance criteria as needed]
+
+## 6. Test Automation Strategy
+
+[Define the testing approach, frameworks, and automation requirements.]
+
+- **Test Levels**: Unit, Integration, End-to-End
+- **Frameworks**: MSTest, FluentAssertions, Moq (for .NET applications)
+- **Test Data Management**: [approach for test data creation and cleanup]
+- **CI/CD Integration**: [automated testing in GitHub Actions pipelines]
+- **Coverage Requirements**: [minimum code coverage thresholds]
+- **Performance Testing**: [approach for load and performance testing]
+
+## 7. Rationale & Context
+
+[Explain the reasoning behind the requirements, constraints, and guidelines. Provide context for design decisions.]
+
+## 8. Dependencies & External Integrations
+
+[Define the external systems, services, and architectural dependencies required for this specification. Focus on **what** is needed rather than **how** it's implemented. Avoid specific package or library versions unless they represent architectural constraints.]
+
+### External Systems
+- **EXT-001**: [External system name] - [Purpose and integration type]
+
+### Third-Party Services
+- **SVC-001**: [Service name] - [Required capabilities and SLA requirements]
+
+### Infrastructure Dependencies
+- **INF-001**: [Infrastructure component] - [Requirements and constraints]
+
+### Data Dependencies
+- **DAT-001**: [External data source] - [Format, frequency, and access requirements]
+
+### Technology Platform Dependencies
+- **PLT-001**: [Platform/runtime requirement] - [Version constraints and rationale]
+
+### Compliance Dependencies
+- **COM-001**: [Regulatory or compliance requirement] - [Impact on implementation]
+
+**Note**: This section should focus on architectural and business dependencies, not specific package implementations. For example, specify "OAuth 2.0 authentication library" rather than "Microsoft.AspNetCore.Authentication.JwtBearer v6.0.1".
+
+## 9. Examples & Edge Cases
+
+```code
+// Code snippet or data example demonstrating the correct application of the guidelines, including edge cases
+```
+
+## 10. Validation Criteria
+
+[List the criteria or tests that must be satisfied for compliance with this specification.]
+
+## 11. Related Specifications / Further Reading
+
+[Link to related spec 1]
+[Link to relevant external documentation]
+
+```

.github/prompts/review-and-refactor.prompt.md

@@ -0,0 +1,15 @@
+---
+mode: 'agent'
+description: 'Review and refactor code in your project according to defined instructions'
+---
+
+## Role
+
+You're a senior expert software engineer with extensive experience in maintaining projects over a long time and ensuring clean code and best practices. 
+
+## Task
+
+1. Take a deep breath, and review all coding guidelines instructions in `.github/instructions/*.md` and `.github/copilot-instructions.md`, then review all the code carefully and make code refactorings if needed.
+2. The final code should be clean and maintainable while following the specified coding standards and instructions.
+3. Do not split up the code, keep the existing files intact.
+4. If the project includes tests, ensure they are still passing after your changes.

.github/prompts/update-specification.prompt.md

@@ -0,0 +1,127 @@
+---
+mode: 'agent'
+description: 'Update an existing specification file for the solution, optimized for Generative AI consumption based on new requirements or updates to any existing code.'
+tools: ['changes', 'codebase', 'editFiles', 'extensions', 'fetch', 'githubRepo', 'openSimpleBrowser', 'problems', 'runTasks', 'search', 'searchResults', 'terminalLastCommand', 'terminalSelection', 'testFailure', 'usages', 'vscodeAPI']
+---
+# Update Specification
+
+Your goal is to update the existing specification file `${file}` based on new requirements or updates to any existing code.
+
+The specification file must define the requirements, constraints, and interfaces for the solution components in a manner that is clear, unambiguous, and structured for effective use by Generative AIs. Follow established documentation standards and ensure the content is machine-readable and self-contained.
+
+## Best Practices for AI-Ready Specifications
+
+- Use precise, explicit, and unambiguous language.
+- Clearly distinguish between requirements, constraints, and recommendations.
+- Use structured formatting (headings, lists, tables) for easy parsing.
+- Avoid idioms, metaphors, or context-dependent references.
+- Define all acronyms and domain-specific terms.
+- Include examples and edge cases where applicable.
+- Ensure the document is self-contained and does not rely on external context.
+
+The specification should be saved in the [/spec/](/spec/) directory and named according to the following convention: `[a-z0-9-]+.md`, where the name should be descriptive of the specification's content and starting with the highlevel purpose, which is one of [schema, tool, data, infrastructure, process, architecture, or design].
+
+The specification file must be formatted in well formed Markdown.
+
+Specification files must follow the template below, ensuring that all sections are filled out appropriately. The front matter for the markdown should be structured correctly as per the example following:
+
+```md
+---
+title: [Concise Title Describing the Specification's Focus]
+version: [Optional: e.g., 1.0, Date]
+date_created: [YYYY-MM-DD]
+last_updated: [Optional: YYYY-MM-DD]
+owner: [Optional: Team/Individual responsible for this spec]
+tags: [Optional: List of relevant tags or categories, e.g., `infrastructure`, `process`, `design`, `app` etc]
+---
+
+# Introduction
+
+[A short concise introduction to the specification and the goal it is intended to achieve.]
+
+## 1. Purpose & Scope
+
+[Provide a clear, concise description of the specification's purpose and the scope of its application. State the intended audience and any assumptions.]
+
+## 2. Definitions
+
+[List and define all acronyms, abbreviations, and domain-specific terms used in this specification.]
+
+## 3. Requirements, Constraints & Guidelines
+
+[Explicitly list all requirements, constraints, rules, and guidelines. Use bullet points or tables for clarity.]
+
+- **REQ-001**: Requirement 1
+- **SEC-001**: Security Requirement 1
+- **[3 LETTERS]-001**: Other Requirement 1
+- **CON-001**: Constraint 1
+- **GUD-001**: Guideline 1
+- **PAT-001**: Pattern to follow 1
+
+## 4. Interfaces & Data Contracts
+
+[Describe the interfaces, APIs, data contracts, or integration points. Use tables or code blocks for schemas and examples.]
+
+## 5. Acceptance Criteria
+
+[Define clear, testable acceptance criteria for each requirement using Given-When-Then format where appropriate.]
+
+- **AC-001**: Given [context], When [action], Then [expected outcome]
+- **AC-002**: The system shall [specific behavior] when [condition]
+- **AC-003**: [Additional acceptance criteria as needed]
+
+## 6. Test Automation Strategy
+
+[Define the testing approach, frameworks, and automation requirements.]
+
+- **Test Levels**: Unit, Integration, End-to-End
+- **Frameworks**: MSTest, FluentAssertions, Moq (for .NET applications)
+- **Test Data Management**: [approach for test data creation and cleanup]
+- **CI/CD Integration**: [automated testing in GitHub Actions pipelines]
+- **Coverage Requirements**: [minimum code coverage thresholds]
+- **Performance Testing**: [approach for load and performance testing]
+
+## 7. Rationale & Context
+
+[Explain the reasoning behind the requirements, constraints, and guidelines. Provide context for design decisions.]
+
+## 8. Dependencies & External Integrations
+
+[Define the external systems, services, and architectural dependencies required for this specification. Focus on **what** is needed rather than **how** it's implemented. Avoid specific package or library versions unless they represent architectural constraints.]
+
+### External Systems
+- **EXT-001**: [External system name] - [Purpose and integration type]
+
+### Third-Party Services
+- **SVC-001**: [Service name] - [Required capabilities and SLA requirements]
+
+### Infrastructure Dependencies
+- **INF-001**: [Infrastructure component] - [Requirements and constraints]
+
+### Data Dependencies
+- **DAT-001**: [External data source] - [Format, frequency, and access requirements]
+
+### Technology Platform Dependencies
+- **PLT-001**: [Platform/runtime requirement] - [Version constraints and rationale]
+
+### Compliance Dependencies
+- **COM-001**: [Regulatory or compliance requirement] - [Impact on implementation]
+
+**Note**: This section should focus on architectural and business dependencies, not specific package implementations. For example, specify "OAuth 2.0 authentication library" rather than "Microsoft.AspNetCore.Authentication.JwtBearer v6.0.1".
+
+## 9. Examples & Edge Cases
+
+```code
+// Code snippet or data example demonstrating the correct application of the guidelines, including edge cases
+```
+
+## 10. Validation Criteria
+
+[List the criteria or tests that must be satisfied for compliance with this specification.]
+
+## 11. Related Specifications / Further Reading
+
+[Link to related spec 1]
+[Link to relevant external documentation]
+
+```

.github/workflows/ci.yml

@@ -1,46 +1,66 @@
-name: ci
+name: CI
 
-on: [pull_request, push]
+on:
+  push:
+    tags:        
+      - '[0-9]+.[0-9]+.[0-9]+' 
+    branches:
+      - dev
+      - master
+  pull_request:
 
 permissions:
     contents: write
     pull-requests: write
+    id-token: write
 
 jobs:
     ci:
         runs-on: ubuntu-latest
+        permissions:
+            id-token: write # for npm publish
+            actions: read # for Nerivec/action-ci-bench
+            pull-requests: write # for Nerivec/action-ci-bench
         steps:
-            - uses: actions/checkout@v4
+            - uses: actions/checkout@v6
               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
+            - uses: actions/checkout@v6
               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
+            - uses: actions/setup-node@v6
               with:
-                  node-version: 20
+                  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: Lint
-              run: |
-                  pnpm run pretty:check
-                  pnpm run eslint
-
             - name: Test
               run: pnpm run test:coverage
 
+            - name: Bench
+              if: github.ref == 'refs/heads/dev' || (github.event_name == 'pull_request' && !startsWith(github.head_ref, 'release-please-'))
+              uses: Nerivec/action-ci-bench@main
+              with:
+                token: ${{ secrets.GITHUB_TOKEN }}
+                compare-against: dev
+                base-cmd: npx vitest bench --run --config ./test/vitest.config.mts --outputJson bench.json
+                compare-cmd: npx vitest bench --run --config ./test/vitest.config.mts --compare bench.json
+                base-result: bench.json
+
             - name: Log in to the Docker container registry
               if: (github.ref == 'refs/heads/dev' || startsWith(github.ref, 'refs/tags/')) && github.event_name == 'push'
               uses: docker/login-action@v3
@@ -83,6 +103,27 @@ jobs:
                       VERSION=dev
                       DATE=${{ github.event.repository.updated_at }}
 
+            - name: dev - Publish types
+              if: github.ref == 'refs/heads/dev' && github.event_name == 'push'
+              run: |
+                pnpm run build:types
+                temp_dir=$(mktemp -d)
+                cp -R package.json LICENSE dist $temp_dir
+                git fetch --unshallow
+                git checkout dev-types
+                rm -rf *
+                cp -R $temp_dir/* .
+                # remove unnecessary dependencies
+                KEEP_DEPS='["zigbee-herdsman","zigbee-herdsman-converters"]'
+                tmp_pkg=$(mktemp)
+                jq --indent 4 --argjson keep "$KEEP_DEPS" 'def filterDeps: (. // {}) | with_entries(select(.key as $k | $keep | index($k))); .dependencies |= filterDeps | .devDependencies |= filterDeps | .optionalDependencies |= filterDeps' package.json > "$tmp_pkg"
+                mv "$tmp_pkg" package.json
+                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
@@ -102,7 +143,6 @@ jobs:
               with:
                   context: .
                   file: docker/Dockerfile
-                  provenance: false
                   platforms: linux/arm64/v8,linux/amd64,linux/arm/v6,linux/arm/v7,linux/riscv64,linux/386
                   tags: ${{ steps.meta.outputs.tags }}
                   push: true
@@ -116,6 +156,7 @@ jobs:
               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'
@@ -175,21 +216,22 @@ jobs:
         strategy:
             matrix:
                 os: [ubuntu-latest, macos-latest, windows-latest]
-                node: [18, 20, 22]
+                node: [20, 22, 24]
         runs-on: ${{ matrix.os }}
         continue-on-error: true
         steps:
-            - uses: actions/checkout@v4
+            - uses: actions/checkout@v6
+
             - uses: pnpm/action-setup@v4
 
-            - uses: actions/setup-node@v4
+            - uses: actions/setup-node@v6
               with:
                   node-version: ${{ matrix.node }}
                   cache: pnpm
 
             - name: Install dependencies
-              # --ignore-scripts prevents the serialport build which often fails on Windows
-              run: pnpm i --frozen-lockfile --ignore-scripts
+              # --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

.github/workflows/codeql.yaml

@@ -1,92 +0,0 @@
-# For most projects, this workflow file will not need changing; you simply need
-# to commit it to your repository.
-#
-# You may wish to alter this file to override the set of languages analyzed,
-# or to provide custom queries or build logic.
-#
-# ******** NOTE ********
-# We have attempted to detect the languages in your repository. Please check
-# the `language` matrix defined below to confirm you have the correct set of
-# supported CodeQL languages.
-#
-name: 'CodeQL'
-
-on:
-    push:
-        branches: ['master', 'dev']
-    pull_request:
-        branches: ['master', 'dev']
-    schedule:
-        - cron: '15 2 * * 2'
-
-jobs:
-    analyze:
-        name: Analyze (${{ matrix.language }})
-        # Runner size impacts CodeQL analysis time. To learn more, please see:
-        #   - https://gh.io/recommended-hardware-resources-for-running-codeql
-        #   - https://gh.io/supported-runners-and-hardware-resources
-        #   - https://gh.io/using-larger-runners (GitHub.com only)
-        # Consider using larger runners or machines with greater resources for possible analysis time improvements.
-        runs-on: ${{ (matrix.language == 'swift' && 'macos-latest') || 'ubuntu-latest' }}
-        permissions:
-            # required for all workflows
-            security-events: write
-
-            # required to fetch internal or private CodeQL packs
-            packages: read
-
-            # only required for workflows in private repositories
-            actions: read
-            contents: read
-
-        strategy:
-            fail-fast: false
-            matrix:
-                include:
-                    - language: javascript-typescript
-                      build-mode: none
-                # CodeQL supports the following values keywords for 'language': 'c-cpp', 'csharp', 'go', 'java-kotlin', 'javascript-typescript', 'python', 'ruby', 'swift'
-                # Use `c-cpp` to analyze code written in C, C++ or both
-                # Use 'java-kotlin' to analyze code written in Java, Kotlin or both
-                # Use 'javascript-typescript' to analyze code written in JavaScript, TypeScript or both
-                # To learn more about changing the languages that are analyzed or customizing the build mode for your analysis,
-                # see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/customizing-your-advanced-setup-for-code-scanning.
-                # If you are analyzing a compiled language, you can modify the 'build-mode' for that language to customize how
-                # your codebase is analyzed, see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/codeql-code-scanning-for-compiled-languages
-        steps:
-            - name: Checkout repository
-              uses: actions/checkout@v4
-
-            # Initializes the CodeQL tools for scanning.
-            - name: Initialize CodeQL
-              uses: github/codeql-action/init@v3
-              with:
-                  languages: ${{ matrix.language }}
-                  build-mode: ${{ matrix.build-mode }}
-                  # If you wish to specify custom queries, you can do so here or in a config file.
-                  # By default, queries listed here will override any specified in a config file.
-                  # Prefix the list here with "+" to use these queries and those in the config file.
-
-                  # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
-                  # queries: security-extended,security-and-quality
-
-            # If the analyze step fails for one of the languages you are analyzing with
-            # "We were unable to automatically build your code", modify the matrix above
-            # to set the build mode to "manual" for that language. Then modify this step
-            # to build your code.
-            # ℹ️ Command-line programs to run using the OS shell.
-            # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
-            - if: matrix.build-mode == 'manual'
-              shell: bash
-              run: |
-                  echo 'If you are using a "manual" build mode for one or more of the' \
-                    'languages you are analyzing, replace this with the commands to build' \
-                    'your code, for example:'
-                  echo '  make bootstrap'
-                  echo '  make release'
-                  exit 1
-
-            - name: Perform CodeQL Analysis
-              uses: github/codeql-action/analyze@v3
-              with:
-                  category: '/language:${{matrix.language}}'

.github/workflows/dependency-review.yaml

@@ -1,4 +1,5 @@
-name: deps-review
+name: Dependency review
+
 on: [pull_request]
 
 permissions:
@@ -9,6 +10,6 @@ jobs:
         runs-on: ubuntu-latest
         steps:
             - name: 'Checkout repository'
-              uses: actions/checkout@v4
+              uses: actions/checkout@v6
             - name: 'Dependency review'
               uses: actions/dependency-review-action@v4

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

@@ -6,7 +6,7 @@ on:
             - master
 
 jobs:
-    fail_pr:
+    fail-pr-to-master:
         runs-on: ubuntu-latest
         steps:
             - name: Fail PR to master

.github/workflows/ghcr-cleanup.yml

@@ -1,7 +1,7 @@
 on:
     workflow_dispatch:
 
-name: ghcr-cleanup
+name: GHCR cleanup
 
 permissions: {}
 jobs:
@@ -10,7 +10,7 @@ jobs:
 
         steps:
             - name: Delete untagged images
-              uses: actions/github-script@v7
+              uses: actions/github-script@v8
               with:
                   github-token: ${{ secrets.GH_TOKEN }}
                   script: |

.github/workflows/issue_bot.yml

@@ -0,0 +1,38 @@
+name: Issue Bot
+
+on:
+  issues:
+    types: [opened, edited]
+
+permissions:
+  issues: write
+  contents: read
+
+jobs:
+  comment:
+    runs-on: ubuntu-latest
+    if: |
+      contains(github.event.issue.labels.*.name, 'new device support') ||
+      contains(github.event.issue.labels.*.name, 'external converter') ||
+      startsWith(github.event.issue.title, '[New device support]') ||
+      startsWith(github.event.issue.title, '[External Converter]')
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          sparse-checkout: |
+            scripts
+          path: z2m
+
+      - uses: actions/checkout@v6
+        with:
+          repository: Koenkk/zigbee-herdsman-converters
+          ref: master
+          fetch-depth: 1
+          path: zhc
+
+      - name: Comment on new device support/external converter issue
+        uses: actions/github-script@v8
+        with:
+          script: |
+            const {newDeviceSupport} = await import("${{ github.workspace }}/z2m/scripts/issueBot.mjs")
+            await newDeviceSupport(github, core, context, "${{ github.workspace }}/zhc")

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

@@ -1,4 +1,4 @@
-name: merge-master-to-dev
+name: Merge master to dev
 
 on:
     push:
@@ -6,10 +6,10 @@ on:
             - master
 
 jobs:
-    merge_master_to_dev:
+    merge-master-to-dev:
         runs-on: ubuntu-latest
         steps:
-            - uses: actions/checkout@v4
+            - uses: actions/checkout@v6
             - uses: devmasx/merge-branch@master
               with:
                   type: now

.github/workflows/release-please.yml

@@ -7,7 +7,7 @@ permissions:
     contents: write
     pull-requests: write
 
-name: release-please
+name: Release Please
 
 jobs:
     release-please:
@@ -20,9 +20,9 @@ jobs:
               with:
                   version: 9
 
-            - uses: actions/setup-node@v4
+            - uses: actions/setup-node@v6
               with:
-                  node-version: 20
+                  node-version: 24
 
             - uses: googleapis/release-please-action@v4
               id: release
@@ -31,11 +31,11 @@ jobs:
                   token: ${{secrets.GH_TOKEN}}
 
             # Checkout repos
-            - uses: actions/checkout@v4
+            - uses: actions/checkout@v6
               with:
                   repository: koenkk/zigbee2mqtt
                   path: ./z2m
-            - uses: actions/checkout@v4
+            - uses: actions/checkout@v6
               with:
                   repository: koenkk/zigbee2mqtt
                   path: ./z2m-master
@@ -54,10 +54,11 @@ jobs:
                   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"')
+                  MASTER_WINDFRONT_VERSION=$(cat z2m-master/package.json | jq -r '.dependencies."zigbee2mqtt-windfront"')
                   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
+                  node scripts/generateChangelog.mjs $MASTER_Z2M_VERSION $MASTER_ZHC_VERSION $MASTER_ZH_VERSION $MASTER_FRONTEND_VERSION $MASTER_WINDFRONT_VERSION >> ../changelog.md
               env:
                   GH_TOKEN: ${{secrets.GH_TOKEN}}
             - name: Update changelog gist

.github/workflows/stale.yml

@@ -1,4 +1,4 @@
-name: stale
+name: Stale
 
 on:
     schedule:
@@ -9,12 +9,12 @@ jobs:
     stale:
         runs-on: ubuntu-latest
         steps:
-            - uses: actions/stale@v9
+            - uses: actions/stale@v10
               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
+                  exempt-issue-labels: dont-stale,feature-request
                   operations-per-run: 500

.github/workflows/update-dependency.yml

@@ -2,25 +2,25 @@ on:
     repository_dispatch:
         types: update_dep
 
-name: update-dep
+name: Update dependency
 
 permissions: {}
 jobs:
-    update_dep:
+    update-dependency:
         permissions:
             contents: write
             pull-requests: write
 
         runs-on: ubuntu-latest
         steps:
-            - uses: actions/checkout@v4
+            - uses: actions/checkout@v6
               with:
                   ref: dev
                   token: ${{ secrets.GH_TOKEN }}
             - uses: pnpm/action-setup@v4
-            - uses: actions/setup-node@v4
+            - uses: actions/setup-node@v6
               with:
-                  node-version: 20
+                  node-version: 24
                   cache: pnpm
             - run: |
                   pnpm install ${{ github.event.client_payload.package }}@${{ github.event.client_payload.version }} --save-exact

.github/workflows/update_deps.yml

@@ -1,33 +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: pnpm/action-setup@v4
-            - uses: actions/setup-node@v4
-              with:
-                  node-version: 20
-                  cache: pnpm
-            - run: |
-                  pnpm up --latest
-            - uses: peter-evans/create-pull-request@v7
-              with:
-                  commit-message: 'fix(ignore): update dependencies'
-                  branch: 'deps/all'
-                  title: 'fix(ignore): update dependencies'
-                  token: ${{ secrets.GH_TOKEN }}

.gitignore

@@ -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
@@ -68,10 +72,12 @@ tsconfig.tsbuildinfo
 
 # IDE specific folders
 .idea
+.*.swp
 
 # Ignore config
 data/*
 !data/configuration.example.yaml
+data-bench
 
 # commit-user-lookup.json
 scripts/commit-user-lookup.json

.prettierignore

@@ -1,2 +0,0 @@
-pnpm-lock.yaml
-CHANGELOG.md

.prettierrc

@@ -1,28 +0,0 @@
-{
-    "semi": true,
-    "trailingComma": "all",
-    "singleQuote": true,
-    "printWidth": 150,
-    "bracketSpacing": false,
-    "endOfLine": "lf",
-    "tabWidth": 4,
-    "importOrder": [
-        "^[./]*/mocks",
-        "",
-        "<TYPES>^(node:)",
-        "",
-        "<TYPES>",
-        "",
-        "<TYPES>^[.]",
-        "",
-        "<BUILTIN_MODULES>",
-        "",
-        "<THIRD_PARTY_MODULES>",
-        "",
-        "^zigbee",
-        "",
-        "^[.]"
-    ],
-    "importOrderParserPlugins": ["typescript", "decorators"],
-    "plugins": ["@ianvs/prettier-plugin-sort-imports"]
-}

.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-    ".": "2.1.1"
+    ".": "2.7.1"
 }

AGENTS.md

@@ -0,0 +1,386 @@
+# AGENTS.md
+
+## Project Overview
+
+Zigbee2MQTT is a Zigbee to MQTT bridge that allows you to use your Zigbee devices without the vendor's bridge or gateway. It bridges events and allows you to control Zigbee devices via MQTT, integrating them with any smart home infrastructure.
+
+### Architecture
+
+- **Language**: TypeScript 5.9.3 compiled to JavaScript (ES modules with NodeNext resolution)
+- **Runtime**: Node.js (versions 20, 22, or 24)
+- **Package Manager**: pnpm 10.12.1 (strictly enforced via `packageManager` field)
+- **Core Dependencies**: 
+  - `zigbee-herdsman` (6.2.0 - exact version, handles Zigbee adapter communication)
+  - `zigbee-herdsman-converters` (25.42.0 - exact version, device definitions)
+  - `mqtt` (5.14.1 - MQTT client)
+  - `winston` (3.18.3 - logging)
+
+### Project Structure
+
+```
+lib/                    # TypeScript source code
+├── controller.ts       # Main controller orchestrating components
+├── mqtt.ts            # MQTT client management
+├── zigbee.ts          # Zigbee network management
+├── state.ts           # State management
+├── eventBus.ts        # Event-driven communication
+├── extension/         # Extension system (plugins)
+│   └── extension.ts   # Abstract base class
+├── model/             # Domain models (Device, Group)
+├── util/              # Utility functions
+└── types/             # TypeScript type definitions
+test/                  # Vitest test files with mocks
+data/                  # Runtime configuration and database
+dist/                  # Compiled JavaScript output
+```
+
+## Setup Commands
+
+### Prerequisites
+
+- Node.js version 20, 22, or 24
+- pnpm 10.12.1 (will be auto-installed via corepack if not present)
+
+### Installation
+
+```bash
+# Install dependencies (uses pnpm lockfile)
+pnpm install --frozen-lockfile
+
+# For development without lockfile restrictions
+pnpm install
+```
+
+### Initial Build
+
+```bash
+# Full build (TypeScript compilation + hash generation)
+pnpm run build
+
+# Build type definitions only
+pnpm run build:types
+```
+
+## Development Workflow
+
+### Starting Development
+
+```bash
+# Watch mode - recompile on file changes
+pnpm run build:watch
+
+# In another terminal, start Zigbee2MQTT
+pnpm start
+```
+
+### Code Quality Checks
+
+```bash
+# Run Biome linter and formatter (check only)
+pnpm run check
+
+# Auto-fix linting and formatting issues
+pnpm run check:w
+
+# The check runs with --error-on-warnings flag
+# Configuration: biome.json (4-space indent, 150 line width, no bracket spacing)
+```
+
+### Clean Build
+
+```bash
+# Remove build artifacts
+pnpm run clean
+
+# Removes: coverage/, dist/, tsconfig.tsbuildinfo
+```
+
+## Testing Instructions
+
+### Running Tests
+
+```bash
+# Run all tests once
+pnpm test
+
+# Run tests with coverage report
+pnpm run test:coverage
+
+# Watch mode - re-run tests on changes
+pnpm run test:watch
+
+# Run benchmarks
+pnpm run bench
+```
+
+### Test Requirements
+
+- **Coverage**: 100% code coverage is enforced (configured in `test/vitest.config.mts`)
+- **Framework**: Vitest 3.1.1 with @vitest/coverage-v8
+- **Test Files**: Located in `test/` directory with `.test.ts` extension
+- **Mocks**: Centralized in `test/mocks/` directory
+- **Coverage Report**: Generated in `coverage/` directory (HTML report at `coverage/index.html`)
+
+### Running Specific Tests
+
+```bash
+# Run tests matching a pattern
+pnpm vitest run -t "test name pattern" --config ./test/vitest.config.mts
+
+# Run specific test file
+pnpm vitest run test/controller.test.ts --config ./test/vitest.config.mts
+
+# Focus on one test area in watch mode
+pnpm vitest watch -t "Extension" --config ./test/vitest.config.mts
+```
+
+## Code Style Guidelines
+
+### TypeScript Conventions
+
+- **Module System**: ES modules with NodeNext resolution
+- **Target**: ESNext
+- **Strict Mode**: Enabled (`noImplicitAny`, `noImplicitThis`)
+- **Decorators**: Experimental decorators enabled (used for `@bind` from `bind-decorator`)
+
+### Import Order
+
+1. Node.js built-in modules (with `node:` prefix)
+2. Third-party libraries
+3. Type-only imports from external packages (using `type` keyword)
+4. Internal absolute imports
+5. Type-only imports from internal modules
+
+Example:
+```typescript
+import fs from "node:fs";
+import bind from "bind-decorator";
+import type {IClientOptions} from "mqtt";
+import {connectAsync} from "mqtt";
+import type {Zigbee2MQTTAPI} from "./types/api";
+import logger from "./util/logger";
+```
+
+### Naming Conventions
+
+- **Classes**: PascalCase (e.g., `Extension`, `Device`)
+- **Functions/Methods**: camelCase (e.g., `publishEntityState`)
+- **Constants**: SCREAMING_SNAKE_CASE (e.g., `CURRENT_VERSION`)
+- **Interfaces/Types**: PascalCase (e.g., `MqttPublishOptions`)
+- **Files**: camelCase for TypeScript (e.g., `eventBus.ts`)
+
+### Code Patterns
+
+- **Async/Await**: Always use async/await, explicitly type return as `Promise<Type>`
+- **Error Handling**: Use `throw new Error("message")`, log with winston logger
+- **Event Handlers**: Use `@bind` decorator to preserve `this` context
+- **Logging**: Use `logger.info()`, `logger.warning()`, `logger.error()`, `logger.debug()`
+
+### Formatting Rules (Biome)
+
+- 4-space indentation
+- 150 character line width
+- No bracket spacing in objects
+- Run `pnpm run check:w` to auto-format
+
+## Build and Deployment
+
+### Build Process
+
+```bash
+# Production build
+pnpm run build
+
+# Outputs:
+# - Compiled JavaScript in dist/
+# - Type definitions in dist/types/
+# - Includes hash generation for version tracking
+```
+
+### Pre-publish
+
+```bash
+# Automatically runs before publishing
+pnpm run prepack
+
+# Performs: clean + build
+```
+
+### Environment Setup
+
+- Configuration stored in `data/configuration.yaml`
+- Database in `data/database.db`
+- Logs in `data/log/`
+- External extensions in `data/external_extensions/`
+- External converters in `data/external_converters/`
+
+## Architecture Patterns
+
+### Extension System
+
+All features are implemented as extensions that inherit from the abstract `Extension` base class:
+
+```typescript
+abstract class Extension {
+    protected zigbee: Zigbee;
+    protected mqtt: Mqtt;
+    protected state: State;
+    protected publishEntityState: PublishEntityState;
+    protected eventBus: EventBus;
+    
+    async start(): Promise<void> {}  // Initialize extension
+    async stop(): Promise<void> {}   // Cleanup extension
+}
+```
+
+**Key Points**:
+- Constructor should only assign properties (no side effects)
+- Initialization happens in `start()` method
+- Use EventBus for inter-component communication
+- Extensions are loaded and managed by the Controller
+
+### Event-Driven Communication
+
+Components communicate via the strongly-typed EventBus:
+
+```typescript
+// Emit events
+this.eventBus.emit('deviceMessage', {device, message});
+
+// Listen to events
+this.eventBus.on('deviceMessage', this.onDeviceMessage, this);
+```
+
+### Dependency Injection
+
+The Controller instantiates and injects dependencies into all extensions. Follow this pattern when creating new extensions.
+
+## Pull Request Guidelines
+
+### Target Branch
+
+- **Always create PRs against the `dev` branch**
+- The `master` branch is for production releases only
+
+### Before Submitting
+
+```bash
+# Run all checks
+pnpm run check
+pnpm test
+
+# Ensure 100% code coverage
+pnpm run test:coverage
+
+# Build successfully
+pnpm run build
+```
+
+### PR Requirements
+
+- All CI checks must pass (linting, tests, build)
+- 100% test coverage maintained
+- Code follows Biome formatting rules
+- Commit messages should be descriptive
+- Reference related issues when applicable
+
+### CI Pipeline
+
+The GitHub Actions CI workflow (`.github/workflows/ci.yml`) runs:
+1. Biome code quality checks (`pnpm run check`)
+2. TypeScript compilation (`pnpm run build`)
+3. Full test suite with coverage (`pnpm run test:coverage`)
+4. Benchmarks (on dev branch and PRs)
+5. Docker image builds (on dev branch and tags)
+
+## Working with Device Support
+
+### Adding New Devices
+
+**Important**: Device support is NOT added to this repository. All device definitions live in `zigbee-herdsman-converters`.
+
+- Follow the guide at: https://www.zigbee2mqtt.io/advanced/support-new-devices/01_support_new_devices.html
+- No changes to zigbee2mqtt codebase are needed for new devices
+- Device definitions are automatically picked up from `zigbee-herdsman-converters`
+
+## Debugging and Troubleshooting
+
+### Development Setup
+
+For the easiest development experience, set up a bare-metal installation following:
+https://www.zigbee2mqtt.io/guide/installation/01_linux.html
+
+### Logging
+
+- Winston logger is initialized in `lib/util/logger.ts`
+- Log levels: `error`, `warning`, `info`, `debug`
+- Logs are written to console and/or file based on configuration
+- Use structured logging with context (device names, IEEE addresses)
+
+### Common Issues
+
+1. **Import errors after file moves**: Run `pnpm run check` to verify TypeScript and ESLint
+2. **Test failures**: Check if mocks in `test/mocks/` need updates
+3. **Build errors**: Ensure Node.js version is 20, 22, or 24
+4. **Coverage issues**: View HTML report at `coverage/index.html` to identify uncovered code
+
+### Performance Considerations
+
+- Use `rimrafSync` for synchronous file operations
+- Leverage async/await to avoid blocking
+- Cache computed values in getters when appropriate
+- EventBus provides loose coupling between components
+
+## Critical Version Requirements
+
+### Exact Versions
+
+These dependencies use **exact versions** (no semver ranges) - do not upgrade without thorough testing:
+
+- `zigbee-herdsman@6.2.0` - Critical for Zigbee protocol compatibility
+- `zigbee-herdsman-converters@25.42.0` - Device definitions must match herdsman version
+
+### Node.js Compatibility
+
+Only these Node.js versions are supported:
+- Node.js 20.x
+- Node.js 22.x  
+- Node.js 24.x
+
+Using other versions may cause runtime errors or incompatibilities.
+
+## Additional Notes
+
+### Package Manager
+
+This project **requires pnpm 10.12.1**. The `packageManager` field in package.json enforces this via Corepack.
+
+Do not use npm or yarn - they will not respect the pnpm-specific configuration.
+
+### TypeScript Compilation
+
+- Source files in `lib/` are compiled to `dist/`
+- Type definitions exported from `dist/types/api.d.ts`
+- Source maps are inlined for debugging
+- Uses composite project references for faster incremental builds
+
+### External Extensions
+
+To load external extensions:
+1. Place JavaScript files in `data/external_extensions/`
+2. They will be automatically loaded on startup
+3. No configuration changes needed
+
+### Code Quality Tools
+
+- **Linting/Formatting**: Biome 2.2.5 (replaces ESLint + Prettier)
+- **Type Checking**: TypeScript 5.9.3
+- **Testing**: Vitest 3.1.1
+- **Coverage**: @vitest/coverage-v8
+
+### Documentation
+
+- Main documentation: https://www.zigbee2mqtt.io/
+- Contributing guide: `CONTRIBUTING.md`
+- Coding standards: `.github/copilot-instructions.md`
+- Issue tracker: https://github.com/Koenkk/zigbee2mqtt/issues

CHANGELOG.md

@@ -1,5 +1,555 @@
 # Changelog
 
+## [2.7.1](https://github.com/Koenkk/zigbee2mqtt/compare/2.7.0...2.7.1) (2025-12-06)
+
+
+### Bug Fixes
+
+* Home Assistant: Accept multiple access levels for `current_humidity` source property ([#29936](https://github.com/Koenkk/zigbee2mqtt/issues/29936)) ([fa99c6d](https://github.com/Koenkk/zigbee2mqtt/commit/fa99c6dcca97d2c8c90136249293dea3d42e0998))
+* Home Assistant: Translate boolean to state topic for `current_humidity_topic` ([#30014](https://github.com/Koenkk/zigbee2mqtt/issues/30014)) ([9ca85df](https://github.com/Koenkk/zigbee2mqtt/commit/9ca85dfac8b0f0421ad0622dfdbe36c8766d22b4))
+* **ignore:** bump finalhandler from 2.1.0 to 2.1.1 in the minor-patch group ([#29920](https://github.com/Koenkk/zigbee2mqtt/issues/29920)) ([ce27ff3](https://github.com/Koenkk/zigbee2mqtt/commit/ce27ff3cbfac204579b38d034e71733e4e4bb18f))
+* **ignore:** update zigbee-herdsman to 7.0.2 ([#29956](https://github.com/Koenkk/zigbee2mqtt/issues/29956)) ([403bd4a](https://github.com/Koenkk/zigbee2mqtt/commit/403bd4a72541bf7342de246b033c5090b186df32))
+* **ignore:** update zigbee-herdsman to 7.0.3 ([#30008](https://github.com/Koenkk/zigbee2mqtt/issues/30008)) ([bae9bb8](https://github.com/Koenkk/zigbee2mqtt/commit/bae9bb8812c81e46d4068b4284e0f9957821f88a))
+* **ignore:** update zigbee-herdsman to 7.0.4 ([#30041](https://github.com/Koenkk/zigbee2mqtt/issues/30041)) ([334fa2a](https://github.com/Koenkk/zigbee2mqtt/commit/334fa2a60d04c66749978b8b8f4b9b5af6c7c7eb))
+* **ignore:** update zigbee-herdsman-converters to 25.81.0 ([#29959](https://github.com/Koenkk/zigbee2mqtt/issues/29959)) ([fd4282b](https://github.com/Koenkk/zigbee2mqtt/commit/fd4282b98d9630f9a98e82f627c12c5920d810b4))
+* **ignore:** update zigbee-herdsman-converters to 25.82.0 ([#29990](https://github.com/Koenkk/zigbee2mqtt/issues/29990)) ([740edd8](https://github.com/Koenkk/zigbee2mqtt/commit/740edd8b58b7d72b7a2a5247f7f6ac8ee99ff0fa))
+* **ignore:** update zigbee-herdsman-converters to 25.83.0 ([#30011](https://github.com/Koenkk/zigbee2mqtt/issues/30011)) ([a7f1345](https://github.com/Koenkk/zigbee2mqtt/commit/a7f1345a9164f6c83cb81688c33511b14646fab8))
+* **ignore:** update zigbee-herdsman-converters to 25.83.1 ([#30050](https://github.com/Koenkk/zigbee2mqtt/issues/30050)) ([9b60353](https://github.com/Koenkk/zigbee2mqtt/commit/9b6035387be6f285fab455f7845baa75f3f722be))
+
+## [2.7.0](https://github.com/Koenkk/zigbee2mqtt/compare/2.6.3...2.7.0) (2025-12-01)
+
+
+### Features
+
+* Add `action` bridge/request API ([#29730](https://github.com/Koenkk/zigbee2mqtt/issues/29730)) ([a61646d](https://github.com/Koenkk/zigbee2mqtt/commit/a61646d584c0a0de46abb3545cd964f65d84312d))
+* Add new bind/reporting/map features ([#29750](https://github.com/Koenkk/zigbee2mqtt/issues/29750)) ([f26ade4](https://github.com/Koenkk/zigbee2mqtt/commit/f26ade4f938350d10ed22a32a2e30365f7514a72))
+
+
+### Bug Fixes
+
+* Add port 8080 `EXPOSE` to container ([#29754](https://github.com/Koenkk/zigbee2mqtt/issues/29754)) ([4c21b66](https://github.com/Koenkk/zigbee2mqtt/commit/4c21b660794ee3b85c9a9a6d01b0df5ec8bce639))
+* Home Assistant: expose `current_humidity` for `climate` devices exposing `humidity` ([#29842](https://github.com/Koenkk/zigbee2mqtt/issues/29842)) ([631c4f6](https://github.com/Koenkk/zigbee2mqtt/commit/631c4f6a5729888d65a1125e0cca8f9ba2ff0e59))
+* **ignore:** bump @biomejs/biome from 2.3.3 to 2.3.4 in the minor-patch group ([#29571](https://github.com/Koenkk/zigbee2mqtt/issues/29571)) ([517b286](https://github.com/Koenkk/zigbee2mqtt/commit/517b2865835a7c21b4c5ce68018fd30ae45d1a3f))
+* **ignore:** bump debounce from 2.2.0 to 3.0.0 ([#29444](https://github.com/Koenkk/zigbee2mqtt/issues/29444)) ([8099322](https://github.com/Koenkk/zigbee2mqtt/commit/8099322cc2e93e5c1faf355d41485f2c673e0cea))
+* **ignore:** bump the minor-patch group with 2 updates ([#29443](https://github.com/Koenkk/zigbee2mqtt/issues/29443)) ([619b939](https://github.com/Koenkk/zigbee2mqtt/commit/619b939b148394bd6a083c17cc5cf254c8eb3aea))
+* **ignore:** bump the minor-patch group with 2 updates ([#29859](https://github.com/Koenkk/zigbee2mqtt/issues/29859)) ([c02ed09](https://github.com/Koenkk/zigbee2mqtt/commit/c02ed092116c7454220c0611bff5d078e12a8ecc))
+* **ignore:** bump the minor-patch group with 3 updates ([#29804](https://github.com/Koenkk/zigbee2mqtt/issues/29804)) ([e2232e9](https://github.com/Koenkk/zigbee2mqtt/commit/e2232e9e9173ea9ec55152ac33bc0ee0141471bb))
+* **ignore:** bump zigbee2mqtt-windfront from 2.4.0 to 2.4.1 in the minor-patch group ([#29905](https://github.com/Koenkk/zigbee2mqtt/issues/29905)) ([4a020fd](https://github.com/Koenkk/zigbee2mqtt/commit/4a020fd8de2dab2973b859c34b934416a15e82a5))
+* **ignore:** bump zigbee2mqtt-windfront to 2.4.2 ([#29919](https://github.com/Koenkk/zigbee2mqtt/issues/29919)) ([3dce854](https://github.com/Koenkk/zigbee2mqtt/commit/3dce8548ceee111f49a5b3460fdb2cbb4f47da62))
+* **ignore:** prop name convention on new API endpoints ([#29820](https://github.com/Koenkk/zigbee2mqtt/issues/29820)) ([ad06968](https://github.com/Koenkk/zigbee2mqtt/commit/ad0696856a9a63fc74b9c2115f08d7fd97850545))
+* **ignore:** update zigbee-herdsman to 6.3.3 ([#29500](https://github.com/Koenkk/zigbee2mqtt/issues/29500)) ([39c5bc8](https://github.com/Koenkk/zigbee2mqtt/commit/39c5bc8c0446a7ccdffe6f82ae9e7f31f60f20ba))
+* **ignore:** update zigbee-herdsman to 6.4.0 ([#29522](https://github.com/Koenkk/zigbee2mqtt/issues/29522)) ([e788c52](https://github.com/Koenkk/zigbee2mqtt/commit/e788c520a9268498daf0f88d7bedb289546d226e))
+* **ignore:** update zigbee-herdsman to 6.4.1 ([#29595](https://github.com/Koenkk/zigbee2mqtt/issues/29595)) ([61c6ec6](https://github.com/Koenkk/zigbee2mqtt/commit/61c6ec611174529e4c041a56146ba8405cfe9ed8))
+* **ignore:** update zigbee-herdsman to 6.4.2 ([#29683](https://github.com/Koenkk/zigbee2mqtt/issues/29683)) ([53b7eaa](https://github.com/Koenkk/zigbee2mqtt/commit/53b7eaabf0647c8d1edb0de24b89776991af576c))
+* **ignore:** update zigbee-herdsman to 7.0.0 ([3e2aefb](https://github.com/Koenkk/zigbee2mqtt/commit/3e2aefbcf84f43d45c1d6ca33397c8bb76648822))
+* **ignore:** update zigbee-herdsman to 7.0.1 ([#29855](https://github.com/Koenkk/zigbee2mqtt/issues/29855)) ([802271e](https://github.com/Koenkk/zigbee2mqtt/commit/802271ed37d404944d315f83f3b623ba9e424bb9))
+* **ignore:** update zigbee-herdsman-converters to 25.60.0 ([#29426](https://github.com/Koenkk/zigbee2mqtt/issues/29426)) ([eeed56e](https://github.com/Koenkk/zigbee2mqtt/commit/eeed56ef2c01dfe67e7a0cd7cafd35ef1876f5b4))
+* **ignore:** update zigbee-herdsman-converters to 25.62.0 ([#29449](https://github.com/Koenkk/zigbee2mqtt/issues/29449)) ([ea1c5a8](https://github.com/Koenkk/zigbee2mqtt/commit/ea1c5a8f4e8537a2f8c59988bb712f62a0adffd7))
+* **ignore:** update zigbee-herdsman-converters to 25.63.0 ([#29482](https://github.com/Koenkk/zigbee2mqtt/issues/29482)) ([5a6a9cf](https://github.com/Koenkk/zigbee2mqtt/commit/5a6a9cf4d2de803a10cd38bc19f3ec256eff5929))
+* **ignore:** update zigbee-herdsman-converters to 25.64.0 ([#29499](https://github.com/Koenkk/zigbee2mqtt/issues/29499)) ([5c4e43f](https://github.com/Koenkk/zigbee2mqtt/commit/5c4e43fd109321ddcfad3a67b60423f0197c51a6))
+* **ignore:** update zigbee-herdsman-converters to 25.65.0 ([#29523](https://github.com/Koenkk/zigbee2mqtt/issues/29523)) ([8822aed](https://github.com/Koenkk/zigbee2mqtt/commit/8822aedb5e254f5be5f6cda0cfe18fc6f69c84d6))
+* **ignore:** update zigbee-herdsman-converters to 25.66.0 ([#29558](https://github.com/Koenkk/zigbee2mqtt/issues/29558)) ([940fff2](https://github.com/Koenkk/zigbee2mqtt/commit/940fff244c39da04d0de5d7e4076359dc6245aed))
+* **ignore:** update zigbee-herdsman-converters to 25.67.0 ([#29572](https://github.com/Koenkk/zigbee2mqtt/issues/29572)) ([4794b3c](https://github.com/Koenkk/zigbee2mqtt/commit/4794b3c81f9e38660f8549995b7f3ef8b4cd4318))
+* **ignore:** update zigbee-herdsman-converters to 25.68.0 ([#29606](https://github.com/Koenkk/zigbee2mqtt/issues/29606)) ([564e9ab](https://github.com/Koenkk/zigbee2mqtt/commit/564e9ab9eb49c3517913917af8b23d4758c6b6c7))
+* **ignore:** update zigbee-herdsman-converters to 25.69.0 ([#29659](https://github.com/Koenkk/zigbee2mqtt/issues/29659)) ([16d0e56](https://github.com/Koenkk/zigbee2mqtt/commit/16d0e5696859e79be4701154dd35f7780e47acae))
+* **ignore:** update zigbee-herdsman-converters to 25.70.0 ([#29684](https://github.com/Koenkk/zigbee2mqtt/issues/29684)) ([73225e2](https://github.com/Koenkk/zigbee2mqtt/commit/73225e2436bb56ff4ed47d787e8a1793fd10998d))
+* **ignore:** update zigbee-herdsman-converters to 25.71.0 ([#29716](https://github.com/Koenkk/zigbee2mqtt/issues/29716)) ([d6bf517](https://github.com/Koenkk/zigbee2mqtt/commit/d6bf5174be905128432e90d54b3c43c2a68e75ac))
+* **ignore:** update zigbee-herdsman-converters to 25.72.0 ([#29735](https://github.com/Koenkk/zigbee2mqtt/issues/29735)) ([7b7b988](https://github.com/Koenkk/zigbee2mqtt/commit/7b7b9889607a6e48001ae3cda5950386c24f5fd6))
+* **ignore:** update zigbee-herdsman-converters to 25.73.0 ([#29752](https://github.com/Koenkk/zigbee2mqtt/issues/29752)) ([be774a4](https://github.com/Koenkk/zigbee2mqtt/commit/be774a4d0d70122ced0f6ca79f49c060a7d2d2cb))
+* **ignore:** update zigbee-herdsman-converters to 25.74.0 ([#29770](https://github.com/Koenkk/zigbee2mqtt/issues/29770)) ([ba77ce7](https://github.com/Koenkk/zigbee2mqtt/commit/ba77ce7c8df0b29845a090c9defb4ce8aaf0f924))
+* **ignore:** update zigbee-herdsman-converters to 25.75.0 ([#29811](https://github.com/Koenkk/zigbee2mqtt/issues/29811)) ([854df49](https://github.com/Koenkk/zigbee2mqtt/commit/854df498bd3c8999393b683052dfba6b906ba669))
+* **ignore:** update zigbee-herdsman-converters to 25.76.0 ([#29823](https://github.com/Koenkk/zigbee2mqtt/issues/29823)) ([72d862f](https://github.com/Koenkk/zigbee2mqtt/commit/72d862f4a080bfcd91bf99d4c13387e719dfdb8e))
+* **ignore:** update zigbee-herdsman-converters to 25.77.0 ([#29838](https://github.com/Koenkk/zigbee2mqtt/issues/29838)) ([35d8a5d](https://github.com/Koenkk/zigbee2mqtt/commit/35d8a5da7f1d817727f8b029da1992901f5b4115))
+* **ignore:** update zigbee-herdsman-converters to 25.78.0 ([#29856](https://github.com/Koenkk/zigbee2mqtt/issues/29856)) ([49b4876](https://github.com/Koenkk/zigbee2mqtt/commit/49b4876768c5d15fcff1ad0c9c2d02dda96543d0))
+* **ignore:** update zigbee-herdsman-converters to 25.79.0 ([#29903](https://github.com/Koenkk/zigbee2mqtt/issues/29903)) ([d411fc5](https://github.com/Koenkk/zigbee2mqtt/commit/d411fc5c693300863a19c2798f0a7a05cfc7e55f))
+* **ignore:** update zigbee-herdsman-converters to 25.80.0 ([#29924](https://github.com/Koenkk/zigbee2mqtt/issues/29924)) ([445890a](https://github.com/Koenkk/zigbee2mqtt/commit/445890a0710ba7f6b101b651bf379f10390f9e7e))
+* **ignore:** update zigbee2mqtt-windfront to 2.3.1 ([#29788](https://github.com/Koenkk/zigbee2mqtt/issues/29788)) ([17520f7](https://github.com/Koenkk/zigbee2mqtt/commit/17520f7cfb69b577ebd986b86da80931a15a39db))
+* Reporting payload detection fixes ([#29854](https://github.com/Koenkk/zigbee2mqtt/issues/29854)) ([42fc6e0](https://github.com/Koenkk/zigbee2mqtt/commit/42fc6e03a7a3092502e3c3d1defbcb3ed6438230))
+
+## [2.6.3](https://github.com/Koenkk/zigbee2mqtt/compare/2.6.2...2.6.3) (2025-11-01)
+
+
+### Bug Fixes
+
+* Add pi cooling demand to Home Assistant auto discovery ([#28843](https://github.com/Koenkk/zigbee2mqtt/issues/28843)) ([09fd675](https://github.com/Koenkk/zigbee2mqtt/commit/09fd675d0f215af11e64515ea60b91ed28b5e683))
+* Fix `onEvent` called twice first time when device options are changed ([#29322](https://github.com/Koenkk/zigbee2mqtt/issues/29322)) ([e037a2c](https://github.com/Koenkk/zigbee2mqtt/commit/e037a2c21cb985b6e71d9c1fa169f0886e8af832))
+* Fix input onboarding environment variable disabled check ([#29354](https://github.com/Koenkk/zigbee2mqtt/issues/29354)) ([c306300](https://github.com/Koenkk/zigbee2mqtt/commit/c30630091d1ac14fed6df9c5ee43a275db877821))
+* Home Assistant: fix device and group configuration URL ([#29211](https://github.com/Koenkk/zigbee2mqtt/issues/29211)) ([c0190c1](https://github.com/Koenkk/zigbee2mqtt/commit/c0190c18ede7accb407b805f6016c3242c11146a))
+* Home Assistant: make PI heating demand from writable ([#29188](https://github.com/Koenkk/zigbee2mqtt/issues/29188)) ([174ba64](https://github.com/Koenkk/zigbee2mqtt/commit/174ba64449b04777d1d5743fbb7b498a29c40ae2))
+* **ignore:** bump @types/node from 24.7.2 to 24.8.1 in the minor-patch group ([#29191](https://github.com/Koenkk/zigbee2mqtt/issues/29191)) ([d8fc69d](https://github.com/Koenkk/zigbee2mqtt/commit/d8fc69dac3cba33f3d69e377e338e03facbc19e7))
+* **ignore:** bump @types/serve-static from 1.15.10 to 2.2.0 ([#29394](https://github.com/Koenkk/zigbee2mqtt/issues/29394)) ([b2c31f8](https://github.com/Koenkk/zigbee2mqtt/commit/b2c31f89c69cfe04d0d671235bd18eb3cfa7ed72))
+* **ignore:** bump the minor-patch group across 1 directory with 4 updates ([#29395](https://github.com/Koenkk/zigbee2mqtt/issues/29395)) ([dc7749b](https://github.com/Koenkk/zigbee2mqtt/commit/dc7749b57e188835f1243fad4b1d9dcccd7dca7d))
+* **ignore:** bump the minor-patch group with 3 updates ([#29068](https://github.com/Koenkk/zigbee2mqtt/issues/29068)) ([aa916ad](https://github.com/Koenkk/zigbee2mqtt/commit/aa916ad60451fea471217e65fbdbb38635879c8e))
+* **ignore:** bump the minor-patch group with 4 updates ([#28916](https://github.com/Koenkk/zigbee2mqtt/issues/28916)) ([e24ec79](https://github.com/Koenkk/zigbee2mqtt/commit/e24ec79980535d62b02e849359e23a189f2255ed))
+* **ignore:** bump the minor-patch group with 5 updates ([#29314](https://github.com/Koenkk/zigbee2mqtt/issues/29314)) ([82f1092](https://github.com/Koenkk/zigbee2mqtt/commit/82f10923027806f5cd3b31e27184883e07768c71))
+* **ignore:** update zigbee-herdsman to 6.2.0 ([#28900](https://github.com/Koenkk/zigbee2mqtt/issues/28900)) ([8b4a4be](https://github.com/Koenkk/zigbee2mqtt/commit/8b4a4be2a4404a8b165bb62c43bca73894d6b13f))
+* **ignore:** update zigbee-herdsman to 6.3.0 ([#29113](https://github.com/Koenkk/zigbee2mqtt/issues/29113)) ([354d06a](https://github.com/Koenkk/zigbee2mqtt/commit/354d06aebc8fc786309ce9d66403e335799d46ab))
+* **ignore:** update zigbee-herdsman to 6.3.1 ([#29153](https://github.com/Koenkk/zigbee2mqtt/issues/29153)) ([feac6aa](https://github.com/Koenkk/zigbee2mqtt/commit/feac6aa677cb169bf3c9b47aa4e6687ea8e6432d))
+* **ignore:** update zigbee-herdsman to 6.3.2 ([#29246](https://github.com/Koenkk/zigbee2mqtt/issues/29246)) ([ef15924](https://github.com/Koenkk/zigbee2mqtt/commit/ef15924260cf2aa0094f2f93db0ddd8fcfa0ac6f))
+* **ignore:** update zigbee-herdsman-converters to 25.36.0 ([#28790](https://github.com/Koenkk/zigbee2mqtt/issues/28790)) ([ca489da](https://github.com/Koenkk/zigbee2mqtt/commit/ca489daad8def2683f4a5c248e8098d01cc7cc6f))
+* **ignore:** update zigbee-herdsman-converters to 25.37.0 ([#28837](https://github.com/Koenkk/zigbee2mqtt/issues/28837)) ([d1ce146](https://github.com/Koenkk/zigbee2mqtt/commit/d1ce1465421f81a68e03ffe76e928e2ea33cdde0))
+* **ignore:** update zigbee-herdsman-converters to 25.37.1 ([#28857](https://github.com/Koenkk/zigbee2mqtt/issues/28857)) ([c66008b](https://github.com/Koenkk/zigbee2mqtt/commit/c66008b36bccdc1626a7f095f1af498b100610e3))
+* **ignore:** update zigbee-herdsman-converters to 25.37.2 ([#28859](https://github.com/Koenkk/zigbee2mqtt/issues/28859)) ([1d38da6](https://github.com/Koenkk/zigbee2mqtt/commit/1d38da6ac5ac6a54c1c13a09003545f9accbfa7a))
+* **ignore:** update zigbee-herdsman-converters to 25.38.0 ([#28872](https://github.com/Koenkk/zigbee2mqtt/issues/28872)) ([a75a40b](https://github.com/Koenkk/zigbee2mqtt/commit/a75a40b042c8276e2b52c666b555fae4f656fa04))
+* **ignore:** update zigbee-herdsman-converters to 25.39.0 ([#28899](https://github.com/Koenkk/zigbee2mqtt/issues/28899)) ([548f646](https://github.com/Koenkk/zigbee2mqtt/commit/548f646f2fc1f53e18f84aec817f845de8edb04d))
+* **ignore:** update zigbee-herdsman-converters to 25.40.0 ([#28928](https://github.com/Koenkk/zigbee2mqtt/issues/28928)) ([5f08c3e](https://github.com/Koenkk/zigbee2mqtt/commit/5f08c3e83beaa98f6e5cf5fd32e106730e86f611))
+* **ignore:** update zigbee-herdsman-converters to 25.41.0 ([#28945](https://github.com/Koenkk/zigbee2mqtt/issues/28945)) ([79a27e3](https://github.com/Koenkk/zigbee2mqtt/commit/79a27e3b060dd552110a1851252dd6a17524be9b))
+* **ignore:** update zigbee-herdsman-converters to 25.42.0 ([#28963](https://github.com/Koenkk/zigbee2mqtt/issues/28963)) ([8b1f5a5](https://github.com/Koenkk/zigbee2mqtt/commit/8b1f5a555c571990e9e895b285060872ba27402f))
+* **ignore:** update zigbee-herdsman-converters to 25.43.0 ([#29014](https://github.com/Koenkk/zigbee2mqtt/issues/29014)) ([9c19aa9](https://github.com/Koenkk/zigbee2mqtt/commit/9c19aa94948205489b50ac79063b2a065495a8a8))
+* **ignore:** update zigbee-herdsman-converters to 25.44.0 ([#29050](https://github.com/Koenkk/zigbee2mqtt/issues/29050)) ([bafc8e4](https://github.com/Koenkk/zigbee2mqtt/commit/bafc8e4284d9493388c8ad8497bb55781238c547))
+* **ignore:** update zigbee-herdsman-converters to 25.46.0 ([#29096](https://github.com/Koenkk/zigbee2mqtt/issues/29096)) ([ad9b114](https://github.com/Koenkk/zigbee2mqtt/commit/ad9b114b1af8225e8e1414ffa23b322271fb1694))
+* **ignore:** update zigbee-herdsman-converters to 25.47.0 ([#29130](https://github.com/Koenkk/zigbee2mqtt/issues/29130)) ([03a81c6](https://github.com/Koenkk/zigbee2mqtt/commit/03a81c6ab14d9ae7b2a9fdd7513dcbbe55cdc16c))
+* **ignore:** update zigbee-herdsman-converters to 25.48.0 ([#29141](https://github.com/Koenkk/zigbee2mqtt/issues/29141)) ([1d69715](https://github.com/Koenkk/zigbee2mqtt/commit/1d69715a5a75779509f81788a1541dd4c492ca9e))
+* **ignore:** update zigbee-herdsman-converters to 25.49.0 ([#29154](https://github.com/Koenkk/zigbee2mqtt/issues/29154)) ([3ecb0c5](https://github.com/Koenkk/zigbee2mqtt/commit/3ecb0c5e41b514bfb824926fc9cf19636ec68ff5))
+* **ignore:** update zigbee-herdsman-converters to 25.50.0 ([#29180](https://github.com/Koenkk/zigbee2mqtt/issues/29180)) ([df70f11](https://github.com/Koenkk/zigbee2mqtt/commit/df70f11a154e27208188432be453fac821f73597))
+* **ignore:** update zigbee-herdsman-converters to 25.51.0 ([#29195](https://github.com/Koenkk/zigbee2mqtt/issues/29195)) ([4080522](https://github.com/Koenkk/zigbee2mqtt/commit/408052282d9a28f46df33266112cf52dbc0f98c0))
+* **ignore:** update zigbee-herdsman-converters to 25.51.1 ([#29212](https://github.com/Koenkk/zigbee2mqtt/issues/29212)) ([238ea7c](https://github.com/Koenkk/zigbee2mqtt/commit/238ea7c4c8073cb0164281cc0cdec05a3212d6ad))
+* **ignore:** update zigbee-herdsman-converters to 25.52.0 ([#29247](https://github.com/Koenkk/zigbee2mqtt/issues/29247)) ([05382a9](https://github.com/Koenkk/zigbee2mqtt/commit/05382a969232d5c1a286ba1a85c6422d0a81a39f))
+* **ignore:** update zigbee-herdsman-converters to 25.53.0 ([#29266](https://github.com/Koenkk/zigbee2mqtt/issues/29266)) ([d719c1f](https://github.com/Koenkk/zigbee2mqtt/commit/d719c1f36848c08efaad3eda8e90fb5d61c4c657))
+* **ignore:** update zigbee-herdsman-converters to 25.54.0 ([#29306](https://github.com/Koenkk/zigbee2mqtt/issues/29306)) ([003c81b](https://github.com/Koenkk/zigbee2mqtt/commit/003c81b745be7f3262d6e778957aec6a9cf3a404))
+* **ignore:** update zigbee-herdsman-converters to 25.55.0 ([#29323](https://github.com/Koenkk/zigbee2mqtt/issues/29323)) ([592c256](https://github.com/Koenkk/zigbee2mqtt/commit/592c256f96cca5219eb8620422f3ebf73fba3c1e))
+* **ignore:** update zigbee-herdsman-converters to 25.56.0 ([#29338](https://github.com/Koenkk/zigbee2mqtt/issues/29338)) ([61d99b7](https://github.com/Koenkk/zigbee2mqtt/commit/61d99b7ece63af35055fabbd9c07d43b3cbc80f9))
+* **ignore:** update zigbee-herdsman-converters to 25.57.0 ([#29370](https://github.com/Koenkk/zigbee2mqtt/issues/29370)) ([faa65f7](https://github.com/Koenkk/zigbee2mqtt/commit/faa65f78a29f5738a83d6fd67dd749f7d02adb39))
+* **ignore:** update zigbee-herdsman-converters to 25.59.0 ([#29382](https://github.com/Koenkk/zigbee2mqtt/issues/29382)) ([40bf14b](https://github.com/Koenkk/zigbee2mqtt/commit/40bf14b93cb94292cce954916eba30f48d3170e2))
+* Remove Moment.js dependency ([#28797](https://github.com/Koenkk/zigbee2mqtt/issues/28797)) ([74335fb](https://github.com/Koenkk/zigbee2mqtt/commit/74335fbb686edd63e5965c50b6cfc853abd07717))
+* Rename `ZigBee` -> `Zigbee` ([#29131](https://github.com/Koenkk/zigbee2mqtt/issues/29131)) ([eaaed1f](https://github.com/Koenkk/zigbee2mqtt/commit/eaaed1fec79401cb0b15b6e4bb4ddfba7bcf3d39))
+* Require at least Node ^20.15.0 ([#29284](https://github.com/Koenkk/zigbee2mqtt/issues/29284)) ([8ac2f55](https://github.com/Koenkk/zigbee2mqtt/commit/8ac2f55d87c3bebbda31cf1e9f1806e98b78c114))
+* Require at least Node ^22.2.0 ([#29285](https://github.com/Koenkk/zigbee2mqtt/issues/29285)) ([6c48498](https://github.com/Koenkk/zigbee2mqtt/commit/6c48498e0d1cbf49ab5ccc4d7539c932ea92a22e))
+
+## [2.6.2](https://github.com/Koenkk/zigbee2mqtt/compare/2.6.1...2.6.2) (2025-10-01)
+
+
+### Bug Fixes
+
+* Fix `DatabaseEntry with ID 'X' does not exist` when adding device to delete group ID ([#28583](https://github.com/Koenkk/zigbee2mqtt/issues/28583)) ([09f33b3](https://github.com/Koenkk/zigbee2mqtt/commit/09f33b31a940c72ecfd42586427f54b3567b097b))
+* Handle empty or null Home Assistant name in device settings ([#28364](https://github.com/Koenkk/zigbee2mqtt/issues/28364)) ([a5e1e8c](https://github.com/Koenkk/zigbee2mqtt/commit/a5e1e8c0c316f500cdc19d7c47b5156ed0b1e0f0))
+* HomeAssistant: add `default_entity_id` to discovery message ([#28560](https://github.com/Koenkk/zigbee2mqtt/issues/28560)) ([15e00ea](https://github.com/Koenkk/zigbee2mqtt/commit/15e00ea8a49cc26e6c359bb60fbec0e76499fbf1))
+* **ignore:** bump @types/node from 24.4.0 to 24.5.2 in the minor-patch group ([#28700](https://github.com/Koenkk/zigbee2mqtt/issues/28700)) ([e8847d1](https://github.com/Koenkk/zigbee2mqtt/commit/e8847d1a342d04cd2e82704518cfb23745010dd1))
+* **ignore:** bump the minor-patch group with 3 updates ([#28541](https://github.com/Koenkk/zigbee2mqtt/issues/28541)) ([86b4581](https://github.com/Koenkk/zigbee2mqtt/commit/86b458111b44a2e99f4abacaaadc4caf0d6b912c))
+* **ignore:** bump the minor-patch group with 3 updates ([#28638](https://github.com/Koenkk/zigbee2mqtt/issues/28638)) ([c3e1525](https://github.com/Koenkk/zigbee2mqtt/commit/c3e1525f60d577ff2669761516fcfb23b4ee1bb7))
+* **ignore:** bump the minor-patch group with 4 updates ([#28778](https://github.com/Koenkk/zigbee2mqtt/issues/28778)) ([c9d01f4](https://github.com/Koenkk/zigbee2mqtt/commit/c9d01f4118cdef2a54bae43b09edb5e54c4f3042))
+* **ignore:** bump zigbee2mqtt-windfront from 2.1.0 to 2.2.0 in the minor-patch group ([#28764](https://github.com/Koenkk/zigbee2mqtt/issues/28764)) ([1166341](https://github.com/Koenkk/zigbee2mqtt/commit/116634193a0c7693c6431ceccb373cf5e3f99e40))
+* **ignore:** update zigbee-herdsman to 6.1.0 ([#28460](https://github.com/Koenkk/zigbee2mqtt/issues/28460)) ([06862c7](https://github.com/Koenkk/zigbee2mqtt/commit/06862c72594abf083411cf517c8dfb3db12fd4a9))
+* **ignore:** update zigbee-herdsman to 6.1.1 ([#28597](https://github.com/Koenkk/zigbee2mqtt/issues/28597)) ([c28ca79](https://github.com/Koenkk/zigbee2mqtt/commit/c28ca79d8a8d5264c3e53f1d1eb96ce5dce1f90e))
+* **ignore:** update zigbee-herdsman to 6.1.2 ([#28689](https://github.com/Koenkk/zigbee2mqtt/issues/28689)) ([79c0c09](https://github.com/Koenkk/zigbee2mqtt/commit/79c0c0933ab2500ae4d5bd42dea57923729f8d86))
+* **ignore:** update zigbee-herdsman to 6.1.3 ([#28717](https://github.com/Koenkk/zigbee2mqtt/issues/28717)) ([892f924](https://github.com/Koenkk/zigbee2mqtt/commit/892f92448e256acd59d329cde4b7519d18cd829a))
+* **ignore:** update zigbee-herdsman to 6.1.4 ([#28762](https://github.com/Koenkk/zigbee2mqtt/issues/28762)) ([508318d](https://github.com/Koenkk/zigbee2mqtt/commit/508318de57267791422d731fcb9a423fa01c8062))
+* **ignore:** update zigbee-herdsman to 6.1.5 ([#28773](https://github.com/Koenkk/zigbee2mqtt/issues/28773)) ([a0d91cc](https://github.com/Koenkk/zigbee2mqtt/commit/a0d91cc063437cc595dd693e33fe5b1f044cd6bf))
+* **ignore:** update zigbee-herdsman-converters to 25.15.0 ([#28462](https://github.com/Koenkk/zigbee2mqtt/issues/28462)) ([3f27f79](https://github.com/Koenkk/zigbee2mqtt/commit/3f27f79d7dabd1951c9c1f2f3dfc24d6bc741edd))
+* **ignore:** update zigbee-herdsman-converters to 25.17.0 ([#28480](https://github.com/Koenkk/zigbee2mqtt/issues/28480)) ([3018e40](https://github.com/Koenkk/zigbee2mqtt/commit/3018e40daef092d74de4eea9e2cb8f174899cd71))
+* **ignore:** update zigbee-herdsman-converters to 25.17.1 ([#28511](https://github.com/Koenkk/zigbee2mqtt/issues/28511)) ([54d729e](https://github.com/Koenkk/zigbee2mqtt/commit/54d729e37a80b0d7a22b67b6223e28685cbf1974))
+* **ignore:** update zigbee-herdsman-converters to 25.18.0 ([#28518](https://github.com/Koenkk/zigbee2mqtt/issues/28518)) ([e8e4977](https://github.com/Koenkk/zigbee2mqtt/commit/e8e4977327c147f6338d323662823dd3316d54a3))
+* **ignore:** update zigbee-herdsman-converters to 25.19.0 ([#28533](https://github.com/Koenkk/zigbee2mqtt/issues/28533)) ([5f2630c](https://github.com/Koenkk/zigbee2mqtt/commit/5f2630c93b8541eafbb737c6eb134155ae2fa6f5))
+* **ignore:** update zigbee-herdsman-converters to 25.20.0 ([#28545](https://github.com/Koenkk/zigbee2mqtt/issues/28545)) ([a297b92](https://github.com/Koenkk/zigbee2mqtt/commit/a297b9255b961d19c0164f6dc29fcaf3cc10aab6))
+* **ignore:** update zigbee-herdsman-converters to 25.21.0 ([#28561](https://github.com/Koenkk/zigbee2mqtt/issues/28561)) ([01d5863](https://github.com/Koenkk/zigbee2mqtt/commit/01d5863487322729fed61da167b6754289d26919))
+* **ignore:** update zigbee-herdsman-converters to 25.22.0 ([#28580](https://github.com/Koenkk/zigbee2mqtt/issues/28580)) ([5f6fae0](https://github.com/Koenkk/zigbee2mqtt/commit/5f6fae0df729b8fafa4d8835ba48dc5e25578330))
+* **ignore:** update zigbee-herdsman-converters to 25.23.0 ([#28598](https://github.com/Koenkk/zigbee2mqtt/issues/28598)) ([3f25834](https://github.com/Koenkk/zigbee2mqtt/commit/3f258342d8acd2cd4f69902679735dee2a7e0e01))
+* **ignore:** update zigbee-herdsman-converters to 25.24.0 ([#28608](https://github.com/Koenkk/zigbee2mqtt/issues/28608)) ([2edf85f](https://github.com/Koenkk/zigbee2mqtt/commit/2edf85f6e1c8b0a42eacfd38a4fd4a43875e86d1))
+* **ignore:** update zigbee-herdsman-converters to 25.25.0 ([#28621](https://github.com/Koenkk/zigbee2mqtt/issues/28621)) ([b2f7460](https://github.com/Koenkk/zigbee2mqtt/commit/b2f74607cc32d17df12fc7361b9bab7eafebf5bd))
+* **ignore:** update zigbee-herdsman-converters to 25.26.0 ([#28629](https://github.com/Koenkk/zigbee2mqtt/issues/28629)) ([2cb7dcc](https://github.com/Koenkk/zigbee2mqtt/commit/2cb7dcc12ab00dbc966717ab70b5f8ad8a86012e))
+* **ignore:** update zigbee-herdsman-converters to 25.29.0 ([#28654](https://github.com/Koenkk/zigbee2mqtt/issues/28654)) ([382d37e](https://github.com/Koenkk/zigbee2mqtt/commit/382d37e839bad69c02c6a560b32964b03305ac67))
+* **ignore:** update zigbee-herdsman-converters to 25.30.0 ([#28707](https://github.com/Koenkk/zigbee2mqtt/issues/28707)) ([77926bc](https://github.com/Koenkk/zigbee2mqtt/commit/77926bc1c31a86bf2ded7838216a59380f3bde1e))
+* **ignore:** update zigbee-herdsman-converters to 25.31.0 ([#28726](https://github.com/Koenkk/zigbee2mqtt/issues/28726)) ([a310627](https://github.com/Koenkk/zigbee2mqtt/commit/a310627e19fb0f684be407d7d54bf90ff112041a))
+* **ignore:** update zigbee-herdsman-converters to 25.32.0 ([#28746](https://github.com/Koenkk/zigbee2mqtt/issues/28746)) ([87c474d](https://github.com/Koenkk/zigbee2mqtt/commit/87c474d2f5433f74fda122a42d4ffa16c64b3a00))
+* **ignore:** update zigbee-herdsman-converters to 25.33.0 ([#28758](https://github.com/Koenkk/zigbee2mqtt/issues/28758)) ([26c74b5](https://github.com/Koenkk/zigbee2mqtt/commit/26c74b57786e0feffe5d1bb3ae7406e25449a591))
+* **ignore:** update zigbee-herdsman-converters to 25.34.0 ([#28763](https://github.com/Koenkk/zigbee2mqtt/issues/28763)) ([f6c0ce7](https://github.com/Koenkk/zigbee2mqtt/commit/f6c0ce735ff582e8d07a11f951a1faa9720367c1))
+* **ignore:** update zigbee-herdsman-converters to 25.35.1 ([#28774](https://github.com/Koenkk/zigbee2mqtt/issues/28774)) ([1283859](https://github.com/Koenkk/zigbee2mqtt/commit/1283859a12d09ed1b7ea2605acbf2293adc80df0))
+* **ignore:** update zigbee2mqtt-frontend to 0.9.21 ([#28745](https://github.com/Koenkk/zigbee2mqtt/issues/28745)) ([2c70deb](https://github.com/Koenkk/zigbee2mqtt/commit/2c70deb411fbf670f14b7c5457e96d21f7203822))
+* **ignore:** update zigbee2mqtt-windfront to 2.1.0 ([#28471](https://github.com/Koenkk/zigbee2mqtt/issues/28471)) ([e52203a](https://github.com/Koenkk/zigbee2mqtt/commit/e52203a1b8b543820506780981de997e6e7edeff))
+* Make windfront the default frontend ([#28546](https://github.com/Koenkk/zigbee2mqtt/issues/28546)) ([fefae99](https://github.com/Koenkk/zigbee2mqtt/commit/fefae9957c9d35bc2cfa1264cb23c4731d21a64a))
+
+## [2.6.1](https://github.com/Koenkk/zigbee2mqtt/compare/2.6.0...2.6.1) (2025-09-01)
+
+
+### Bug Fixes
+
+* Always unlink `node_modules` symlinks on stop ([#28202](https://github.com/Koenkk/zigbee2mqtt/issues/28202)) ([63a4207](https://github.com/Koenkk/zigbee2mqtt/commit/63a4207061039e4dab50f5f999febe4d87397856))
+* Home Assistant: set icon and state class for orientation sensors ([#28192](https://github.com/Koenkk/zigbee2mqtt/issues/28192)) ([b7cbd9b](https://github.com/Koenkk/zigbee2mqtt/commit/b7cbd9b5d830fc1b936208076c440bc561552220))
+* Home Assistant: use "occupancy" device_class for human presence sensors ([#28329](https://github.com/Koenkk/zigbee2mqtt/issues/28329)) ([ccfab84](https://github.com/Koenkk/zigbee2mqtt/commit/ccfab84e7f93be151e841834943d8a65500fe5d9))
+* **ignore:** bump the minor-patch group with 2 updates ([#28383](https://github.com/Koenkk/zigbee2mqtt/issues/28383)) ([a8fd23b](https://github.com/Koenkk/zigbee2mqtt/commit/a8fd23b6cc97468f345216913ebb6c8f27e83789))
+* **ignore:** bump the minor-patch group with 4 updates ([#28147](https://github.com/Koenkk/zigbee2mqtt/issues/28147)) ([b72abd6](https://github.com/Koenkk/zigbee2mqtt/commit/b72abd675f409fca324b34936c1bfb6f3d8aefd4))
+* **ignore:** bump the minor-patch group with 5 updates ([#28237](https://github.com/Koenkk/zigbee2mqtt/issues/28237)) ([1dd6cc3](https://github.com/Koenkk/zigbee2mqtt/commit/1dd6cc3da54527eb5560c7edec7e56324ef38ea1))
+* **ignore:** update zigbee-herdsman to 6.0.0 ([#28235](https://github.com/Koenkk/zigbee2mqtt/issues/28235)) ([bd1be88](https://github.com/Koenkk/zigbee2mqtt/commit/bd1be886022ac13bb71828fc773df0f8f144ec8a))
+* **ignore:** update zigbee-herdsman to 6.0.1 ([#28287](https://github.com/Koenkk/zigbee2mqtt/issues/28287)) ([bed8bec](https://github.com/Koenkk/zigbee2mqtt/commit/bed8beccbc54c06430bdd97bcfb8d14158756216))
+* **ignore:** update zigbee-herdsman to 6.0.2 ([#28406](https://github.com/Koenkk/zigbee2mqtt/issues/28406)) ([264440e](https://github.com/Koenkk/zigbee2mqtt/commit/264440ebcc7c86fb6f2fbacd76a3b1bc451f01ad))
+* **ignore:** update zigbee-herdsman to 6.0.4 ([#28438](https://github.com/Koenkk/zigbee2mqtt/issues/28438)) ([7788653](https://github.com/Koenkk/zigbee2mqtt/commit/77886530fe8c6599cfa1a1a797743fc07cdee75c))
+* **ignore:** update zigbee-herdsman-converters to 24.12.0 ([#28170](https://github.com/Koenkk/zigbee2mqtt/issues/28170)) ([9836f0e](https://github.com/Koenkk/zigbee2mqtt/commit/9836f0e27a57863bdbd98f9770ea37036ccf243c))
+* **ignore:** update zigbee-herdsman-converters to 24.13.0 ([#28175](https://github.com/Koenkk/zigbee2mqtt/issues/28175)) ([2056b89](https://github.com/Koenkk/zigbee2mqtt/commit/2056b89baca9018254e23b02fbf0a5250314159b))
+* **ignore:** update zigbee-herdsman-converters to 24.14.0 ([#28199](https://github.com/Koenkk/zigbee2mqtt/issues/28199)) ([09f046c](https://github.com/Koenkk/zigbee2mqtt/commit/09f046c72d309ad4270e404376bcf009b3411b00))
+* **ignore:** update zigbee-herdsman-converters to 25.0.0 ([#28236](https://github.com/Koenkk/zigbee2mqtt/issues/28236)) ([3160219](https://github.com/Koenkk/zigbee2mqtt/commit/3160219824bcb12c4cbff232d2b7ec5c5a73317b))
+* **ignore:** update zigbee-herdsman-converters to 25.1.0 ([#28264](https://github.com/Koenkk/zigbee2mqtt/issues/28264)) ([2b17808](https://github.com/Koenkk/zigbee2mqtt/commit/2b1780879a62c8f1a044be7f2a525517f8af4082))
+* **ignore:** update zigbee-herdsman-converters to 25.10.0 ([#28399](https://github.com/Koenkk/zigbee2mqtt/issues/28399)) ([32d8265](https://github.com/Koenkk/zigbee2mqtt/commit/32d82651e233665e1850d86d7f8a30a1cdead507))
+* **ignore:** update zigbee-herdsman-converters to 25.11.0 ([#28407](https://github.com/Koenkk/zigbee2mqtt/issues/28407)) ([c07fce9](https://github.com/Koenkk/zigbee2mqtt/commit/c07fce936f8bbbfe6405938221c426ba8dd5eff2))
+* **ignore:** update zigbee-herdsman-converters to 25.12.0 ([#28417](https://github.com/Koenkk/zigbee2mqtt/issues/28417)) ([bdeab61](https://github.com/Koenkk/zigbee2mqtt/commit/bdeab6100195a129980cf9d0151d6eb1b849a802))
+* **ignore:** update zigbee-herdsman-converters to 25.13.0 ([#28427](https://github.com/Koenkk/zigbee2mqtt/issues/28427)) ([203019a](https://github.com/Koenkk/zigbee2mqtt/commit/203019aa26e3ee028e68d1ef9b4d032624fd7991))
+* **ignore:** update zigbee-herdsman-converters to 25.14.0 ([#28439](https://github.com/Koenkk/zigbee2mqtt/issues/28439)) ([bf22dda](https://github.com/Koenkk/zigbee2mqtt/commit/bf22ddac466db6523b659b422a36c968700c385f))
+* **ignore:** update zigbee-herdsman-converters to 25.2.0 ([#28280](https://github.com/Koenkk/zigbee2mqtt/issues/28280)) ([4c97842](https://github.com/Koenkk/zigbee2mqtt/commit/4c9784255bab79d7d8a394135bfd6f5b9e40ef9b))
+* **ignore:** update zigbee-herdsman-converters to 25.3.0 ([#28301](https://github.com/Koenkk/zigbee2mqtt/issues/28301)) ([5f7c005](https://github.com/Koenkk/zigbee2mqtt/commit/5f7c00515adc8941c51b6ede219529719949a9bf))
+* **ignore:** update zigbee-herdsman-converters to 25.4.0 ([#28313](https://github.com/Koenkk/zigbee2mqtt/issues/28313)) ([384bd30](https://github.com/Koenkk/zigbee2mqtt/commit/384bd309a6d980ba1555a7dcfe13539df67699a1))
+* **ignore:** update zigbee-herdsman-converters to 25.5.0 ([#28328](https://github.com/Koenkk/zigbee2mqtt/issues/28328)) ([23f831a](https://github.com/Koenkk/zigbee2mqtt/commit/23f831a1feae67aacd5b76ac81bf3c857065f5d3))
+* **ignore:** update zigbee-herdsman-converters to 25.6.0 ([#28344](https://github.com/Koenkk/zigbee2mqtt/issues/28344)) ([4bd0c04](https://github.com/Koenkk/zigbee2mqtt/commit/4bd0c04bdcdf22e08e152d52f3f5d9a565d8f5f7))
+* **ignore:** update zigbee-herdsman-converters to 25.7.0 ([#28361](https://github.com/Koenkk/zigbee2mqtt/issues/28361)) ([7bd7bce](https://github.com/Koenkk/zigbee2mqtt/commit/7bd7bce69c4065d94a809baef80966ee07691efc))
+* **ignore:** update zigbee-herdsman-converters to 25.8.0 ([#28373](https://github.com/Koenkk/zigbee2mqtt/issues/28373)) ([8e6ba79](https://github.com/Koenkk/zigbee2mqtt/commit/8e6ba7975b292b4ba0817de8b7877fb7b9892aed))
+* **ignore:** update zigbee-herdsman-converters to 25.9.0 ([#28380](https://github.com/Koenkk/zigbee2mqtt/issues/28380)) ([0147441](https://github.com/Koenkk/zigbee2mqtt/commit/0147441c935a4a77f4fccdb59499672de64fabd5))
+* **ignore:** update zigbee2mqtt-frontend to 0.9.20 ([#28250](https://github.com/Koenkk/zigbee2mqtt/issues/28250)) ([800b85c](https://github.com/Koenkk/zigbee2mqtt/commit/800b85c812e57e982a689554b64cbe73aee4f192))
+* **ignore:** update zigbee2mqtt-windfront to 1.6.0 ([#28207](https://github.com/Koenkk/zigbee2mqtt/issues/28207)) ([092c95b](https://github.com/Koenkk/zigbee2mqtt/commit/092c95b7169d7e23c30db154988fb50d4099d750))
+* **ignore:** update zigbee2mqtt-windfront to 1.8.0 ([#28266](https://github.com/Koenkk/zigbee2mqtt/issues/28266)) ([f4cfcba](https://github.com/Koenkk/zigbee2mqtt/commit/f4cfcbacde8cab83e0a7ea742f39f87c2bceb1e1))
+* **ignore:** update zigbee2mqtt-windfront to 1.8.1 ([#28272](https://github.com/Koenkk/zigbee2mqtt/issues/28272)) ([d04ab53](https://github.com/Koenkk/zigbee2mqtt/commit/d04ab53f1d584aed400ab8fd0bcd985f78611cb5))
+* **ignore:** update zigbee2mqtt-windfront to 2.0.1 ([#28420](https://github.com/Koenkk/zigbee2mqtt/issues/28420)) ([08903f6](https://github.com/Koenkk/zigbee2mqtt/commit/08903f68d9a9e20994a1da2eb4835ad28ca68877))
+* Remove 60 MB (28%) of dev dependencies from Docker image ([#28160](https://github.com/Koenkk/zigbee2mqtt/issues/28160)) ([050ebfc](https://github.com/Koenkk/zigbee2mqtt/commit/050ebfc9f5dd5a2de07f5402d3c99ac8ab3b12b4))
+* Set minimum for some settings ([#28209](https://github.com/Koenkk/zigbee2mqtt/issues/28209)) ([a102fac](https://github.com/Koenkk/zigbee2mqtt/commit/a102fac2c8ab09a126fddfb0cc7170d57bf114c0))
+* Support for new ZH typing ([#28257](https://github.com/Koenkk/zigbee2mqtt/issues/28257)) ([b21f926](https://github.com/Koenkk/zigbee2mqtt/commit/b21f926b3e152176d09dc7f95fbc02b2b5ec13da))
+* Update to refactored zhc api and fix `onEvent(stop)` not being called when device is force removed ([#27984](https://github.com/Koenkk/zigbee2mqtt/issues/27984)) ([5286570](https://github.com/Koenkk/zigbee2mqtt/commit/5286570bd625a714fad432dd693308caf59344de))
+* update zigbee2mqtt-windfront to 2.0.0 ([#28389](https://github.com/Koenkk/zigbee2mqtt/issues/28389)) ([2df363f](https://github.com/Koenkk/zigbee2mqtt/commit/2df363f3af8f13c5fde91bab7ac276de3be7ee44))
+
+## [2.6.0](https://github.com/Koenkk/zigbee2mqtt/compare/2.5.1...2.6.0) (2025-08-01)
+
+
+### Features
+
+* Allow to disable internal frontend UI serving for standalone serving ([#27851](https://github.com/Koenkk/zigbee2mqtt/issues/27851)) ([0215e76](https://github.com/Koenkk/zigbee2mqtt/commit/0215e76118c8dcbe77c1ed4890846aaf7da85bae))
+
+
+### Bug Fixes
+
+* erroneous Health OS memory percent calculation ([#27892](https://github.com/Koenkk/zigbee2mqtt/issues/27892)) ([190cfe9](https://github.com/Koenkk/zigbee2mqtt/commit/190cfe99ac62b9dc6db4dc59a4389afda85e8177))
+* Exit with code 2 when adapters disconnects ([#28013](https://github.com/Koenkk/zigbee2mqtt/issues/28013)) ([0e0a561](https://github.com/Koenkk/zigbee2mqtt/commit/0e0a5618af9a1b5707ddccbca2cde983cafb40b5))
+* Fix settings schema defaults ([#27961](https://github.com/Koenkk/zigbee2mqtt/issues/27961)) ([ecadda4](https://github.com/Koenkk/zigbee2mqtt/commit/ecadda45e7c5665f9e242c956f5f140b7caa6eed))
+* Ignore symbolic links in `data` during backup ([#28132](https://github.com/Koenkk/zigbee2mqtt/issues/28132)) ([0182c4b](https://github.com/Koenkk/zigbee2mqtt/commit/0182c4b32efafc85d1f4a38840345944501feaef))
+* **ignore:** add test to specifically check HA envs ([#27969](https://github.com/Koenkk/zigbee2mqtt/issues/27969)) ([833605b](https://github.com/Koenkk/zigbee2mqtt/commit/833605b71f110b4e7aeb6632694820cdd1110e25))
+* **ignore:** bump the minor-patch group with 2 updates ([#27924](https://github.com/Koenkk/zigbee2mqtt/issues/27924)) ([8ceb087](https://github.com/Koenkk/zigbee2mqtt/commit/8ceb08704f7e5d637b661c745c804beebf38eed9))
+* **ignore:** bump the minor-patch group with 4 updates ([#28046](https://github.com/Koenkk/zigbee2mqtt/issues/28046)) ([e505a93](https://github.com/Koenkk/zigbee2mqtt/commit/e505a93a4036affe9e531b24e29ee543ed4cb0f5))
+* **ignore:** fix 71cf2b41603a9923024c0472ffc1f7bfe3d14fc7 ([6dd812f](https://github.com/Koenkk/zigbee2mqtt/commit/6dd812f71cf9ca6737777c3d4acfab35c52a76b8))
+* **ignore:** fix breaking changes of https://github.com/Koenkk/zigbee2mqtt/pull/28077 ([713551b](https://github.com/Koenkk/zigbee2mqtt/commit/713551b5257f8624ed03f7901f0addf6864faf1f))
+* **ignore:** Remove retain/qos from mqtt publish logging https://github.com/Koenkk/zigbee2mqtt/pull/27983 ([e2b7df9](https://github.com/Koenkk/zigbee2mqtt/commit/e2b7df9f84550aa413f3453bb97a13ba2eee4187))
+* **ignore:** update zigbee-herdsman to 4.3.2 ([#27900](https://github.com/Koenkk/zigbee2mqtt/issues/27900)) ([4afdd4e](https://github.com/Koenkk/zigbee2mqtt/commit/4afdd4e89241eddeb27e5f6c1c7b6604ce4a41cb))
+* **ignore:** update zigbee-herdsman to 4.4.0 ([#27906](https://github.com/Koenkk/zigbee2mqtt/issues/27906)) ([e663e86](https://github.com/Koenkk/zigbee2mqtt/commit/e663e86e09cf86078877407e2233447468d66899))
+* **ignore:** update zigbee-herdsman to 4.4.1 ([#27918](https://github.com/Koenkk/zigbee2mqtt/issues/27918)) ([eb82973](https://github.com/Koenkk/zigbee2mqtt/commit/eb829730678dad354d3feede2155f142d58a140f))
+* **ignore:** update zigbee-herdsman to 4.5.0 ([#28044](https://github.com/Koenkk/zigbee2mqtt/issues/28044)) ([cc6f7b0](https://github.com/Koenkk/zigbee2mqtt/commit/cc6f7b02bc2d7548f142ec162696eae06027d6a3))
+* **ignore:** update zigbee-herdsman to 5.0.0 ([#28077](https://github.com/Koenkk/zigbee2mqtt/issues/28077)) ([9a215ef](https://github.com/Koenkk/zigbee2mqtt/commit/9a215efe26be6fafde0f0a779b651ded860cd90c))
+* **ignore:** update zigbee-herdsman to 5.0.1 ([#28080](https://github.com/Koenkk/zigbee2mqtt/issues/28080)) ([6432571](https://github.com/Koenkk/zigbee2mqtt/commit/6432571c61b6e2d4bcc17cc952eeacdaf72213f6))
+* **ignore:** update zigbee-herdsman to 5.0.2 ([#28110](https://github.com/Koenkk/zigbee2mqtt/issues/28110)) ([e9f2a3f](https://github.com/Koenkk/zigbee2mqtt/commit/e9f2a3f5326954f361199bd4d73ed944f72f6ebe))
+* **ignore:** update zigbee-herdsman to 5.0.3 ([#28121](https://github.com/Koenkk/zigbee2mqtt/issues/28121)) ([e5f677b](https://github.com/Koenkk/zigbee2mqtt/commit/e5f677bdd1cc3df4d05dd1f8164220ae2258f081))
+* **ignore:** update zigbee-herdsman to 5.0.4 ([#28141](https://github.com/Koenkk/zigbee2mqtt/issues/28141)) ([9fcc41b](https://github.com/Koenkk/zigbee2mqtt/commit/9fcc41b199082e47d96de4cad996c55c39da83a5))
+* **ignore:** update zigbee-herdsman-converters to 23.70.0 ([#27905](https://github.com/Koenkk/zigbee2mqtt/issues/27905)) ([163a15d](https://github.com/Koenkk/zigbee2mqtt/commit/163a15d664432631f100814927647b918563d85b))
+* **ignore:** update zigbee-herdsman-converters to 23.70.1 ([#27916](https://github.com/Koenkk/zigbee2mqtt/issues/27916)) ([e047324](https://github.com/Koenkk/zigbee2mqtt/commit/e04732462c218cd42c2b617aefba37a5f61d1ce6))
+* **ignore:** update zigbee-herdsman-converters to 23.71.0 ([#27931](https://github.com/Koenkk/zigbee2mqtt/issues/27931)) ([93c1824](https://github.com/Koenkk/zigbee2mqtt/commit/93c1824b1d81c997f0e5a445acac421300f55758))
+* **ignore:** update zigbee-herdsman-converters to 23.72.0 ([#27943](https://github.com/Koenkk/zigbee2mqtt/issues/27943)) ([b4a9424](https://github.com/Koenkk/zigbee2mqtt/commit/b4a9424d604c47609071ef33e88ee55a55a6c8d5))
+* **ignore:** update zigbee-herdsman-converters to 24.0.0 ([#27946](https://github.com/Koenkk/zigbee2mqtt/issues/27946)) ([c465ef8](https://github.com/Koenkk/zigbee2mqtt/commit/c465ef83526c434cac6555836d82e7707072b754))
+* **ignore:** update zigbee-herdsman-converters to 24.1.0 ([#27973](https://github.com/Koenkk/zigbee2mqtt/issues/27973)) ([a837702](https://github.com/Koenkk/zigbee2mqtt/commit/a837702b2c1f517dcfa3a0f578d9b5b3700b171d))
+* **ignore:** update zigbee-herdsman-converters to 24.10.0 ([#28122](https://github.com/Koenkk/zigbee2mqtt/issues/28122)) ([ee1c884](https://github.com/Koenkk/zigbee2mqtt/commit/ee1c884031fdef516393ce68754a9dbcc8ad093d))
+* **ignore:** update zigbee-herdsman-converters to 24.11.0 ([#28143](https://github.com/Koenkk/zigbee2mqtt/issues/28143)) ([3765549](https://github.com/Koenkk/zigbee2mqtt/commit/376554943d15c45a15d30713002d825286204581))
+* **ignore:** update zigbee-herdsman-converters to 24.2.0 ([#27986](https://github.com/Koenkk/zigbee2mqtt/issues/27986)) ([6ede403](https://github.com/Koenkk/zigbee2mqtt/commit/6ede4036886066bf91953b13714a16ba96217b6d))
+* **ignore:** update zigbee-herdsman-converters to 24.3.0 ([#28015](https://github.com/Koenkk/zigbee2mqtt/issues/28015)) ([21fa5cb](https://github.com/Koenkk/zigbee2mqtt/commit/21fa5cbdeddb51d55364c4d28b887791384a951b))
+* **ignore:** update zigbee-herdsman-converters to 24.4.0 ([#28022](https://github.com/Koenkk/zigbee2mqtt/issues/28022)) ([74e9357](https://github.com/Koenkk/zigbee2mqtt/commit/74e9357a5989c6b1eeb25aa91c0da27b7b54fa67))
+* **ignore:** update zigbee-herdsman-converters to 24.5.0 ([#28045](https://github.com/Koenkk/zigbee2mqtt/issues/28045)) ([bc74d0b](https://github.com/Koenkk/zigbee2mqtt/commit/bc74d0b11b58bb2cb2bcc07f5ae9c47b1ca7a13e))
+* **ignore:** update zigbee-herdsman-converters to 24.6.0 ([#28051](https://github.com/Koenkk/zigbee2mqtt/issues/28051)) ([4bc6a59](https://github.com/Koenkk/zigbee2mqtt/commit/4bc6a59ff38f9a102259afbff2606a75409042a3))
+* **ignore:** update zigbee-herdsman-converters to 24.7.0 ([#28070](https://github.com/Koenkk/zigbee2mqtt/issues/28070)) ([81bafa5](https://github.com/Koenkk/zigbee2mqtt/commit/81bafa55201d6d7a34b364a85c19423a56eceeee))
+* **ignore:** update zigbee-herdsman-converters to 24.8.0 ([#28081](https://github.com/Koenkk/zigbee2mqtt/issues/28081)) ([caf91cd](https://github.com/Koenkk/zigbee2mqtt/commit/caf91cd7ffb8ae4961c3f43875f051b182f1a379))
+* **ignore:** update zigbee-herdsman-converters to 24.9.0 ([71cf2b4](https://github.com/Koenkk/zigbee2mqtt/commit/71cf2b41603a9923024c0472ffc1f7bfe3d14fc7))
+* **ignore:** update zigbee2mqtt-frontend to 0.9.17 ([#27917](https://github.com/Koenkk/zigbee2mqtt/issues/27917)) ([a3e7f69](https://github.com/Koenkk/zigbee2mqtt/commit/a3e7f69b3ff6173a59b4d5e2ad1f09c2c414b416))
+* **ignore:** update zigbee2mqtt-frontend to 0.9.19 ([#28021](https://github.com/Koenkk/zigbee2mqtt/issues/28021)) ([8b87682](https://github.com/Koenkk/zigbee2mqtt/commit/8b876823da7fbde4f980fefa54cec7c3fa52c423))
+* **ignore:** update zigbee2mqtt-windfront to 1.3.0 ([#27953](https://github.com/Koenkk/zigbee2mqtt/issues/27953)) ([1b37bae](https://github.com/Koenkk/zigbee2mqtt/commit/1b37baefd3e6817fc9dbf36c9ec9e8aec4481643))
+* **ignore:** update zigbee2mqtt-windfront to 1.3.1 ([#27999](https://github.com/Koenkk/zigbee2mqtt/issues/27999)) ([a51216e](https://github.com/Koenkk/zigbee2mqtt/commit/a51216e3c76335b66a9383b1734a213ad948d70a))
+* **ignore:** update zigbee2mqtt-windfront to 1.4.1 ([#28062](https://github.com/Koenkk/zigbee2mqtt/issues/28062)) ([d322dc2](https://github.com/Koenkk/zigbee2mqtt/commit/d322dc20479faffa8f923e2190c1a5f82d17d5e4))
+* **ignore:** update zigbee2mqtt-windfront to 1.5.0 ([#28082](https://github.com/Koenkk/zigbee2mqtt/issues/28082)) ([29e56ad](https://github.com/Koenkk/zigbee2mqtt/commit/29e56adc159268038727d955135d3edbedbaae8b))
+* **ignore:** update zigbee2mqtt-windfront to 1.5.1 ([#28123](https://github.com/Koenkk/zigbee2mqtt/issues/28123)) ([31d3e19](https://github.com/Koenkk/zigbee2mqtt/commit/31d3e19f3862b067555bcbc9bbcd3a5ded6df211))
+* **ignore:** update zigbee2mqtt-windfront to 1.5.2 ([#28140](https://github.com/Koenkk/zigbee2mqtt/issues/28140)) ([fe5639c](https://github.com/Koenkk/zigbee2mqtt/commit/fe5639ce40cf0a4035cd996a558c952dc065fcd0))
+* Improve startup settings validation ([#27988](https://github.com/Koenkk/zigbee2mqtt/issues/27988)) ([435a6cc](https://github.com/Koenkk/zigbee2mqtt/commit/435a6cceb9aea1ac6941c99603d7785ef91e274a))
+* log error message when external JS fails to load ([#27837](https://github.com/Koenkk/zigbee2mqtt/issues/27837)) ([f4d821d](https://github.com/Koenkk/zigbee2mqtt/commit/f4d821deca71540f830f38f631d1a3759c1d0f40))
+* Publish definition source in `bridge/devices` ([#28076](https://github.com/Koenkk/zigbee2mqtt/issues/28076)) ([65eef1b](https://github.com/Koenkk/zigbee2mqtt/commit/65eef1b6900afdf831c809047ab68e93df59b4b0))
+* Publish endpoint names in `bridge/devices` ([#28057](https://github.com/Koenkk/zigbee2mqtt/issues/28057)) ([5f9019a](https://github.com/Koenkk/zigbee2mqtt/commit/5f9019a95fb460f1dc4a31d09e2424ff56049c14))
+* Set MQTT retain and qos=1 on (re)connect ([#27983](https://github.com/Koenkk/zigbee2mqtt/issues/27983)) ([ef07505](https://github.com/Koenkk/zigbee2mqtt/commit/ef07505b31782936a3ae517688c7e1eb9e541daf))
+* Various fixes to align behaviors (+add benchmarks for dev) ([#28011](https://github.com/Koenkk/zigbee2mqtt/issues/28011)) ([db20369](https://github.com/Koenkk/zigbee2mqtt/commit/db203694477ff718386a3d97ca260dccd0dc0597))
+
+## [2.5.1](https://github.com/Koenkk/zigbee2mqtt/compare/2.5.0...2.5.1) (2025-07-02)
+
+
+### Bug Fixes
+
+* **ignore:** update zigbee-herdsman to 4.3.1 ([#27878](https://github.com/Koenkk/zigbee2mqtt/issues/27878)) ([917d852](https://github.com/Koenkk/zigbee2mqtt/commit/917d8527a5efcf349153ed71e8a44b6d6c87b398))
+* Various Windfront frontend improvements [@nerivec](https://github.com/nerivec) ([#27880](https://github.com/Koenkk/zigbee2mqtt/issues/27880)) ([4dd7dab](https://github.com/Koenkk/zigbee2mqtt/commit/4dd7dabf0803e3cad6e9b6aa1683a2ea8984fb0e))
+
+## [2.5.0](https://github.com/Koenkk/zigbee2mqtt/compare/2.4.0...2.5.0) (2025-07-01)
+
+
+### Features
+
+* New health extension & extras in `bridge/info` ([#27164](https://github.com/Koenkk/zigbee2mqtt/issues/27164)) ([cd9b752](https://github.com/Koenkk/zigbee2mqtt/commit/cd9b752ede91db1d02c567dded92c4e52c05b88d))
+
+
+### Bug Fixes
+
+* Bump Alpine to 3.22 ([#27690](https://github.com/Koenkk/zigbee2mqtt/issues/27690)) ([f6c3887](https://github.com/Koenkk/zigbee2mqtt/commit/f6c3887c812ea6e15e950e6d55e0274356f2eea5))
+* Fix devices not immediately marked as offline when timeout expires ([#27691](https://github.com/Koenkk/zigbee2mqtt/issues/27691)) ([e4b253e](https://github.com/Koenkk/zigbee2mqtt/commit/e4b253e08beb147367872aa4517df93a03ef1a4f))
+* Generate group ID if empty string given ([#27702](https://github.com/Koenkk/zigbee2mqtt/issues/27702)) ([0e66b29](https://github.com/Koenkk/zigbee2mqtt/commit/0e66b29983ae691a2dab44f6649e20a9e00a43cd))
+* **ignore:** API correctness ([#27637](https://github.com/Koenkk/zigbee2mqtt/issues/27637)) ([018fad2](https://github.com/Koenkk/zigbee2mqtt/commit/018fad27afb5861b1d9c7adff3161c926ccbbaa4))
+* **ignore:** bump @types/node from 22.15.30 to 24.0.3 ([#27745](https://github.com/Koenkk/zigbee2mqtt/issues/27745)) ([de80045](https://github.com/Koenkk/zigbee2mqtt/commit/de800450ad31e5d8ad5c342b061dc3c59f0d565e))
+* **ignore:** bump the minor-patch group across 1 directory with 4 updates ([#27858](https://github.com/Koenkk/zigbee2mqtt/issues/27858)) ([c8dc26b](https://github.com/Koenkk/zigbee2mqtt/commit/c8dc26b241ae6562271d56fe59a13f05927b2bb4))
+* **ignore:** bump the minor-patch group with 2 updates ([#27797](https://github.com/Koenkk/zigbee2mqtt/issues/27797)) ([50b0ffd](https://github.com/Koenkk/zigbee2mqtt/commit/50b0ffd7e7ef343fec983a62d2268feda28b01ba))
+* **ignore:** bump the minor-patch group with 3 updates ([#27598](https://github.com/Koenkk/zigbee2mqtt/issues/27598)) ([7e82a3d](https://github.com/Koenkk/zigbee2mqtt/commit/7e82a3d1e960d4fa2d89558b6d6a20534e7d6ecf))
+* **ignore:** bump the minor-patch group with 4 updates ([#27610](https://github.com/Koenkk/zigbee2mqtt/issues/27610)) ([ac80bb6](https://github.com/Koenkk/zigbee2mqtt/commit/ac80bb6430007e494c544089af323c3fb99c3541))
+* **ignore:** bump the minor-patch group with 6 updates ([#27678](https://github.com/Koenkk/zigbee2mqtt/issues/27678)) ([587a02f](https://github.com/Koenkk/zigbee2mqtt/commit/587a02f66319688cb93df82fde02539bce0263ea))
+* **ignore:** bump zigbee2mqtt-windfront from 1.0.5 to 1.0.6 in the minor-patch group ([#27744](https://github.com/Koenkk/zigbee2mqtt/issues/27744)) ([9776729](https://github.com/Koenkk/zigbee2mqtt/commit/977672976f06f644ed6e02e4a17c07b63873c8da))
+* **ignore:** Migrate to Biome 2 ([#27785](https://github.com/Koenkk/zigbee2mqtt/issues/27785)) ([c87d452](https://github.com/Koenkk/zigbee2mqtt/commit/c87d4524d599302a0728b85799c9bf7c0784a8f4))
+* **ignore:** update zigbee-herdsman to 4.1.1 ([#27640](https://github.com/Koenkk/zigbee2mqtt/issues/27640)) ([4b95b54](https://github.com/Koenkk/zigbee2mqtt/commit/4b95b54be7abc53a7f7a83814994f9cdde90134e))
+* **ignore:** update zigbee-herdsman to 4.1.2 ([#27729](https://github.com/Koenkk/zigbee2mqtt/issues/27729)) ([242815e](https://github.com/Koenkk/zigbee2mqtt/commit/242815e1390e9e3a5ded929e8bfc4a9a4329a526))
+* **ignore:** update zigbee-herdsman to 4.2.0 ([#27786](https://github.com/Koenkk/zigbee2mqtt/issues/27786)) ([15f3eaf](https://github.com/Koenkk/zigbee2mqtt/commit/15f3eaf96629caa5fbd7e02ae002883becc1b49f))
+* **ignore:** update zigbee-herdsman to 4.2.1 ([#27835](https://github.com/Koenkk/zigbee2mqtt/issues/27835)) ([16faef1](https://github.com/Koenkk/zigbee2mqtt/commit/16faef1511e9bfb1cf76c5faaa1008e195ef67fc))
+* **ignore:** update zigbee-herdsman to 4.3.0 ([#27853](https://github.com/Koenkk/zigbee2mqtt/issues/27853)) ([50c7d2d](https://github.com/Koenkk/zigbee2mqtt/commit/50c7d2d6adb9c9366d5c7f829003c84a140f7a19))
+* **ignore:** update zigbee-herdsman-converters to 23.54.0 ([#27600](https://github.com/Koenkk/zigbee2mqtt/issues/27600)) ([1765fe8](https://github.com/Koenkk/zigbee2mqtt/commit/1765fe8925e359b917c1e2e08d3691d4c8bdcf3f))
+* **ignore:** update zigbee-herdsman-converters to 23.55.0 ([#27618](https://github.com/Koenkk/zigbee2mqtt/issues/27618)) ([4594142](https://github.com/Koenkk/zigbee2mqtt/commit/4594142c09ee8d19af2d32238ffa58512694d2ed))
+* **ignore:** update zigbee-herdsman-converters to 23.56.0 ([#27639](https://github.com/Koenkk/zigbee2mqtt/issues/27639)) ([f637e7d](https://github.com/Koenkk/zigbee2mqtt/commit/f637e7d59cc71f32b8d04e8f4bfc414027e7d23a))
+* **ignore:** update zigbee-herdsman-converters to 23.57.0 ([#27646](https://github.com/Koenkk/zigbee2mqtt/issues/27646)) ([252bfba](https://github.com/Koenkk/zigbee2mqtt/commit/252bfbaa20beccd315592dac811cb23309cdee01))
+* **ignore:** update zigbee-herdsman-converters to 23.57.1 ([#27689](https://github.com/Koenkk/zigbee2mqtt/issues/27689)) ([56d3a8f](https://github.com/Koenkk/zigbee2mqtt/commit/56d3a8f9d8bc01e30a6e469b517545d3406941e2))
+* **ignore:** update zigbee-herdsman-converters to 23.58.0 ([#27695](https://github.com/Koenkk/zigbee2mqtt/issues/27695)) ([6a8d208](https://github.com/Koenkk/zigbee2mqtt/commit/6a8d20858ede85de72c34ce58e9df41fa2e91d0d))
+* **ignore:** update zigbee-herdsman-converters to 23.59.0 ([#27712](https://github.com/Koenkk/zigbee2mqtt/issues/27712)) ([87ff0f3](https://github.com/Koenkk/zigbee2mqtt/commit/87ff0f3711e043eb47319e9fb8abcdfa878d9868))
+* **ignore:** update zigbee-herdsman-converters to 23.60.0 ([#27752](https://github.com/Koenkk/zigbee2mqtt/issues/27752)) ([f33d360](https://github.com/Koenkk/zigbee2mqtt/commit/f33d3606be9e916989d08c7d418c4505dcbfe4ea))
+* **ignore:** update zigbee-herdsman-converters to 23.61.0 ([#27759](https://github.com/Koenkk/zigbee2mqtt/issues/27759)) ([b537f9a](https://github.com/Koenkk/zigbee2mqtt/commit/b537f9a93a61095b6b0b82d04d85f7e264aec27c))
+* **ignore:** update zigbee-herdsman-converters to 23.62.0 ([#27767](https://github.com/Koenkk/zigbee2mqtt/issues/27767)) ([281e10c](https://github.com/Koenkk/zigbee2mqtt/commit/281e10c15fa09358e999f1f6b506fe9b08295608))
+* **ignore:** update zigbee-herdsman-converters to 23.63.0 ([#27784](https://github.com/Koenkk/zigbee2mqtt/issues/27784)) ([0d5de75](https://github.com/Koenkk/zigbee2mqtt/commit/0d5de750ffed0674c5a23c2c4d8d1e954c602197))
+* **ignore:** update zigbee-herdsman-converters to 23.64.0 ([#27799](https://github.com/Koenkk/zigbee2mqtt/issues/27799)) ([b7d9c78](https://github.com/Koenkk/zigbee2mqtt/commit/b7d9c78309a8c3e3cf551948b6542d2b71b70697))
+* **ignore:** update zigbee-herdsman-converters to 23.65.0 ([#27804](https://github.com/Koenkk/zigbee2mqtt/issues/27804)) ([4190ba4](https://github.com/Koenkk/zigbee2mqtt/commit/4190ba43b43e1f688e246f9236bfe7c60230a927))
+* **ignore:** update zigbee-herdsman-converters to 23.66.0 ([#27831](https://github.com/Koenkk/zigbee2mqtt/issues/27831)) ([33234d9](https://github.com/Koenkk/zigbee2mqtt/commit/33234d9ce45323a2a10b7839c5f7aebc84a9cc32))
+* **ignore:** update zigbee-herdsman-converters to 23.67.0 ([#27842](https://github.com/Koenkk/zigbee2mqtt/issues/27842)) ([6930fa6](https://github.com/Koenkk/zigbee2mqtt/commit/6930fa6f3fce8f415302c8db32294b1a9d0ea333))
+* **ignore:** update zigbee-herdsman-converters to 23.68.0 ([#27852](https://github.com/Koenkk/zigbee2mqtt/issues/27852)) ([3ccbaf2](https://github.com/Koenkk/zigbee2mqtt/commit/3ccbaf21d227b7c4ad7952522a980a9083f06463))
+* **ignore:** update zigbee-herdsman-converters to 23.69.0 ([#27860](https://github.com/Koenkk/zigbee2mqtt/issues/27860)) ([5285b7b](https://github.com/Koenkk/zigbee2mqtt/commit/5285b7b95e3c977cca14d28444b9f4f2a9d8996c))
+* **ignore:** update zigbee2mqtt-frontend to 0.9.14 ([#27645](https://github.com/Koenkk/zigbee2mqtt/issues/27645)) ([66e1318](https://github.com/Koenkk/zigbee2mqtt/commit/66e1318a79502cb723cf88d888c9ac23daeb7fd8))
+* **ignore:** update zigbee2mqtt-frontend to 0.9.15 ([#27711](https://github.com/Koenkk/zigbee2mqtt/issues/27711)) ([8ecb9be](https://github.com/Koenkk/zigbee2mqtt/commit/8ecb9be98efb44db23f386e05509389c7d681025))
+* **ignore:** update zigbee2mqtt-frontend to 0.9.16 ([#27783](https://github.com/Koenkk/zigbee2mqtt/issues/27783)) ([7109900](https://github.com/Koenkk/zigbee2mqtt/commit/7109900bcfeff48fdea48456455cd1c6cebf380a))
+* **ignore:** update zigbee2mqtt-windfront to 1.0.5 ([#27656](https://github.com/Koenkk/zigbee2mqtt/issues/27656)) ([eaa3e45](https://github.com/Koenkk/zigbee2mqtt/commit/eaa3e458b5a8a9c5ebf31e12ae7e68fcf60f762f))
+* **ignore:** update zigbee2mqtt-windfront to 1.1.0 ([#27763](https://github.com/Koenkk/zigbee2mqtt/issues/27763)) ([cdad6cc](https://github.com/Koenkk/zigbee2mqtt/commit/cdad6ccd75200061ded795af032f0fed0bb21484))
+* Rename fix typo in backoff settings https://github.com/Koenkk/zigbee2mqtt/issues/27642 ([0181263](https://github.com/Koenkk/zigbee2mqtt/commit/0181263d32dd1099676ed92226a3fc2ee6ac701e))
+* update zigbee2mqtt-windfront to 1.0.4 ([#27641](https://github.com/Koenkk/zigbee2mqtt/issues/27641)) ([9a4ce6f](https://github.com/Koenkk/zigbee2mqtt/commit/9a4ce6fcd0fce6fea9c195ff48a41096b738dccb))
+
+## [2.4.0](https://github.com/Koenkk/zigbee2mqtt/compare/2.3.0...2.4.0) (2025-06-01)
+
+
+### Features
+
+* WindFront new frontend support ([#27489](https://github.com/Koenkk/zigbee2mqtt/issues/27489)) ([1b85968](https://github.com/Koenkk/zigbee2mqtt/commit/1b85968e5e691182305cf334836c069e70a79775))
+
+
+### Bug Fixes
+
+* API missing a few request endpoints ([#27551](https://github.com/Koenkk/zigbee2mqtt/issues/27551)) ([a5e4e9e](https://github.com/Koenkk/zigbee2mqtt/commit/a5e4e9ef61e6f9e3251de43f2c9525d94c13249d))
+* Don't copy external JS to `dist` folder ([#27397](https://github.com/Koenkk/zigbee2mqtt/issues/27397)) ([0ead302](https://github.com/Koenkk/zigbee2mqtt/commit/0ead302c0a01f8fd2356e70c853f7795cb55b1c8))
+* Drop Node 18 support, add 24 ([#27348](https://github.com/Koenkk/zigbee2mqtt/issues/27348)) ([aad87cc](https://github.com/Koenkk/zigbee2mqtt/commit/aad87cc3ec48c664ec58a02fa39c5c23a73db492))
+* Fix bind/unbind by coordinator ieeeAddr not working ([#27333](https://github.com/Koenkk/zigbee2mqtt/issues/27333)) ([d8855b8](https://github.com/Koenkk/zigbee2mqtt/commit/d8855b8e6f1abc63daf6771a9ec07279ebc168d9))
+* Fix import error on Windows (ERR_UNSUPPORTED_ESM_URL_SCHEME) ([#27519](https://github.com/Koenkk/zigbee2mqtt/issues/27519)) ([ed03c40](https://github.com/Koenkk/zigbee2mqtt/commit/ed03c40dad1a8722b24e84f4ed8613b0e37a99ea))
+* HA integration for external sensors Aqara W100 ([#27520](https://github.com/Koenkk/zigbee2mqtt/issues/27520)) ([4bf4563](https://github.com/Koenkk/zigbee2mqtt/commit/4bf45630e28e5534fe68bb4bac6b020701c0e209))
+* **ignore:** bump the minor-patch group across 1 directory with 2 updates ([#27562](https://github.com/Koenkk/zigbee2mqtt/issues/27562)) ([278e3fb](https://github.com/Koenkk/zigbee2mqtt/commit/278e3fb40e84c97ab5dce8147fab7029f5bca168))
+* **ignore:** Cleanup publish options ([#27226](https://github.com/Koenkk/zigbee2mqtt/issues/27226)) ([b7b92da](https://github.com/Koenkk/zigbee2mqtt/commit/b7b92da8ffbaa25ce5927cb6dbf12f9da593a2e0))
+* **ignore:** Fix passive states not updating in frontend ([#27532](https://github.com/Koenkk/zigbee2mqtt/issues/27532)) ([a289f98](https://github.com/Koenkk/zigbee2mqtt/commit/a289f981bf81ef0734561317628f3de2e3b38f40))
+* **ignore:** networkmap typing ([#27566](https://github.com/Koenkk/zigbee2mqtt/issues/27566)) ([621cae2](https://github.com/Koenkk/zigbee2mqtt/commit/621cae2a6398d9eeced00d499bf542a8143de456))
+* **ignore:** update zigbee-herdsman to 4.0.2 ([#27380](https://github.com/Koenkk/zigbee2mqtt/issues/27380)) ([cc3521c](https://github.com/Koenkk/zigbee2mqtt/commit/cc3521c877a2c5048666e27c05f21b5852dceb5c))
+* **ignore:** update zigbee-herdsman to 4.1.0 ([#27462](https://github.com/Koenkk/zigbee2mqtt/issues/27462)) ([3edcfd7](https://github.com/Koenkk/zigbee2mqtt/commit/3edcfd7ff6b5e19ee0ad8780655d911b37b9bcab))
+* **ignore:** update zigbee-herdsman-converters to 23.37.0 ([#27300](https://github.com/Koenkk/zigbee2mqtt/issues/27300)) ([ff823db](https://github.com/Koenkk/zigbee2mqtt/commit/ff823dbaf0b9818be83b0e3ba02073b1afcd439d))
+* **ignore:** update zigbee-herdsman-converters to 23.38.0 ([#27329](https://github.com/Koenkk/zigbee2mqtt/issues/27329)) ([164c322](https://github.com/Koenkk/zigbee2mqtt/commit/164c3222b9dd6cec12ac407145bc8e38985fa7cb))
+* **ignore:** update zigbee-herdsman-converters to 23.39.0 ([#27340](https://github.com/Koenkk/zigbee2mqtt/issues/27340)) ([1d6ba53](https://github.com/Koenkk/zigbee2mqtt/commit/1d6ba5393a1dc5626b6ca539e3ec245cc3d61a56))
+* **ignore:** update zigbee-herdsman-converters to 23.40.0 ([#27347](https://github.com/Koenkk/zigbee2mqtt/issues/27347)) ([7a4f286](https://github.com/Koenkk/zigbee2mqtt/commit/7a4f2869b9836cd9f0e037c324585bdf453e8e8c))
+* **ignore:** update zigbee-herdsman-converters to 23.40.1 ([#27358](https://github.com/Koenkk/zigbee2mqtt/issues/27358)) ([317c9b4](https://github.com/Koenkk/zigbee2mqtt/commit/317c9b4046c4e02a6bad65b1e2cb9f5e59803f24))
+* **ignore:** update zigbee-herdsman-converters to 23.41.0 ([#27371](https://github.com/Koenkk/zigbee2mqtt/issues/27371)) ([f7e5051](https://github.com/Koenkk/zigbee2mqtt/commit/f7e50519e30ca65a396b07d89c3a81b922916ac9))
+* **ignore:** update zigbee-herdsman-converters to 23.42.0 ([#27392](https://github.com/Koenkk/zigbee2mqtt/issues/27392)) ([edcfe32](https://github.com/Koenkk/zigbee2mqtt/commit/edcfe325725aab283753b10f72521cb3f4b0dca4))
+* **ignore:** update zigbee-herdsman-converters to 23.43.0 ([#27394](https://github.com/Koenkk/zigbee2mqtt/issues/27394)) ([e061126](https://github.com/Koenkk/zigbee2mqtt/commit/e0611269f37aedec70ebfe17f75e44cbd2ce619d))
+* **ignore:** update zigbee-herdsman-converters to 23.44.0 ([#27404](https://github.com/Koenkk/zigbee2mqtt/issues/27404)) ([21c9faf](https://github.com/Koenkk/zigbee2mqtt/commit/21c9faffafafbbf6f52f12ecd20bead82bf20777))
+* **ignore:** update zigbee-herdsman-converters to 23.45.0 ([#27422](https://github.com/Koenkk/zigbee2mqtt/issues/27422)) ([8c3252c](https://github.com/Koenkk/zigbee2mqtt/commit/8c3252c2136b6c7e92c5c63ccfbb3af7a943f818))
+* **ignore:** update zigbee-herdsman-converters to 23.46.0 ([#27444](https://github.com/Koenkk/zigbee2mqtt/issues/27444)) ([7449c23](https://github.com/Koenkk/zigbee2mqtt/commit/7449c2357c2b19fa94f6bb111783e723e0a746f5))
+* **ignore:** update zigbee-herdsman-converters to 23.47.0 ([#27463](https://github.com/Koenkk/zigbee2mqtt/issues/27463)) ([693f0d0](https://github.com/Koenkk/zigbee2mqtt/commit/693f0d0a35231b529261fe1652bb6e355d5854fe))
+* **ignore:** update zigbee-herdsman-converters to 23.48.0 ([#27470](https://github.com/Koenkk/zigbee2mqtt/issues/27470)) ([1303340](https://github.com/Koenkk/zigbee2mqtt/commit/1303340aaf1aede9b6f4042d7a3780407a7d42e5))
+* **ignore:** update zigbee-herdsman-converters to 23.49.0 ([#27479](https://github.com/Koenkk/zigbee2mqtt/issues/27479)) ([ea49d1a](https://github.com/Koenkk/zigbee2mqtt/commit/ea49d1ae446a422ebd480b630a51b2e6f8921276))
+* **ignore:** update zigbee-herdsman-converters to 23.50.0 ([#27521](https://github.com/Koenkk/zigbee2mqtt/issues/27521)) ([1960e02](https://github.com/Koenkk/zigbee2mqtt/commit/1960e026d20cefc8c64d0a47e32f0bea075f24f6))
+* **ignore:** update zigbee-herdsman-converters to 23.50.1 ([#27531](https://github.com/Koenkk/zigbee2mqtt/issues/27531)) ([00dda24](https://github.com/Koenkk/zigbee2mqtt/commit/00dda245e49761afe155d0920059893448af8506))
+* **ignore:** update zigbee-herdsman-converters to 23.51.0 ([#27540](https://github.com/Koenkk/zigbee2mqtt/issues/27540)) ([f5920fd](https://github.com/Koenkk/zigbee2mqtt/commit/f5920fd53be777a289fa480cf1ef62bd1701aba3))
+* **ignore:** update zigbee-herdsman-converters to 23.52.0 ([#27559](https://github.com/Koenkk/zigbee2mqtt/issues/27559)) ([6ed18c7](https://github.com/Koenkk/zigbee2mqtt/commit/6ed18c757dd81899d5a8dcf9f912927dfbdde95d))
+* **ignore:** update zigbee-herdsman-converters to 23.52.1 ([#27563](https://github.com/Koenkk/zigbee2mqtt/issues/27563)) ([711b456](https://github.com/Koenkk/zigbee2mqtt/commit/711b456b068ef86c1add5d9cc16770f20a495622))
+* **ignore:** update zigbee-herdsman-converters to 23.53.0 ([#27572](https://github.com/Koenkk/zigbee2mqtt/issues/27572)) ([e0b0248](https://github.com/Koenkk/zigbee2mqtt/commit/e0b02481729916daf8a7ff02ddc61dbb717cc271))
+* **ignore:** update zigbee2mqtt-frontend to 0.9.11 ([#27301](https://github.com/Koenkk/zigbee2mqtt/issues/27301)) ([3cb63aa](https://github.com/Koenkk/zigbee2mqtt/commit/3cb63aa9229a3b4a0f099ce3f8481badf241e202))
+* **ignore:** update zigbee2mqtt-frontend to 0.9.12 ([#27379](https://github.com/Koenkk/zigbee2mqtt/issues/27379)) ([615c53c](https://github.com/Koenkk/zigbee2mqtt/commit/615c53c93c8cda90836d9edf98f54d5e589610b8))
+* **ignore:** update zigbee2mqtt-frontend to 0.9.13 ([#27382](https://github.com/Koenkk/zigbee2mqtt/issues/27382)) ([f656d96](https://github.com/Koenkk/zigbee2mqtt/commit/f656d9629c405d32067ccbbf411b1c5d6255e4ff))
+* **ignore:** update zigbee2mqtt-windfront to 1.0.2 ([#27567](https://github.com/Koenkk/zigbee2mqtt/issues/27567)) ([5e44cf7](https://github.com/Koenkk/zigbee2mqtt/commit/5e44cf77b3a4c664be4b97a95455a39a18bd8632))
+* Improve update script ([#27308](https://github.com/Koenkk/zigbee2mqtt/issues/27308)) ([3cbcc4a](https://github.com/Koenkk/zigbee2mqtt/commit/3cbcc4a0abbe1cb09096d0b989abba48acea8772))
+* Only send JSON state over WebSocket ([#27225](https://github.com/Koenkk/zigbee2mqtt/issues/27225)) ([39e4468](https://github.com/Koenkk/zigbee2mqtt/commit/39e4468308c1909f03ecd068f5c7da23b040f80b))
+* Rerun onboarding if Z2M start failed after previous onboarding ([#27386](https://github.com/Koenkk/zigbee2mqtt/issues/27386)) ([d697c29](https://github.com/Koenkk/zigbee2mqtt/commit/d697c29c7be5e7e49d82d25f355a26875ac383a3))
+* Trim name on rename ([#27332](https://github.com/Koenkk/zigbee2mqtt/issues/27332)) ([69364c9](https://github.com/Koenkk/zigbee2mqtt/commit/69364c958f9f2b7430bfb5a072ffe5267bfcc378))
+
+## [2.3.0](https://github.com/Koenkk/zigbee2mqtt/compare/2.2.1...2.3.0) (2025-05-01)
+
+
+### Features
+
+* Allow scheduling OTA on device request ([#26823](https://github.com/Koenkk/zigbee2mqtt/issues/26823)) ([6e34607](https://github.com/Koenkk/zigbee2mqtt/commit/6e346073e75685eed52da0d2e229ef68e073c76d))
+* Availability improvements ([#26811](https://github.com/Koenkk/zigbee2mqtt/issues/26811)) ([8df5a48](https://github.com/Koenkk/zigbee2mqtt/commit/8df5a484fc3dd3881da217605426e80e017ff467))
+
+
+### Bug Fixes
+
+* Add icon example to settings schema ([#27194](https://github.com/Koenkk/zigbee2mqtt/issues/27194)) ([4acbdd7](https://github.com/Koenkk/zigbee2mqtt/commit/4acbdd7685a6cd3b6db99859b2ccd220aa60c3a2))
+* Add interview state ([#27163](https://github.com/Koenkk/zigbee2mqtt/issues/27163)) ([69f9002](https://github.com/Koenkk/zigbee2mqtt/commit/69f9002e316bdb3d1489d1434d5e53d0f9efaf84))
+* Do not call start() on extensions twice when starting ([#27032](https://github.com/Koenkk/zigbee2mqtt/issues/27032)) ([7fb10b1](https://github.com/Koenkk/zigbee2mqtt/commit/7fb10b1dcb5bce3485c53c331d6671dd81082209))
+* Don't allow publishing wildcards in MQTT topic ([#27025](https://github.com/Koenkk/zigbee2mqtt/issues/27025)) ([850f082](https://github.com/Koenkk/zigbee2mqtt/commit/850f0820ac2eb8666b7fa91e0129815e1a67c27c))
+* Guard against ZHC throwing ([#27093](https://github.com/Koenkk/zigbee2mqtt/issues/27093)) ([e3d214b](https://github.com/Koenkk/zigbee2mqtt/commit/e3d214ba9c66503ab023cce219e462b3da2f10ab))
+* **ignore:** Add missing API request endpoints ([#27242](https://github.com/Koenkk/zigbee2mqtt/issues/27242)) ([5304b0c](https://github.com/Koenkk/zigbee2mqtt/commit/5304b0ceb713c534c8700d12e33d1f8dd8242eaf))
+* **ignore:** API exporting issues ([#27211](https://github.com/Koenkk/zigbee2mqtt/issues/27211)) ([9a9f8d1](https://github.com/Koenkk/zigbee2mqtt/commit/9a9f8d143839e039fe50594848d658f630396752))
+* **ignore:** API typing fixes. ([#27266](https://github.com/Koenkk/zigbee2mqtt/issues/27266)) ([c36a177](https://github.com/Koenkk/zigbee2mqtt/commit/c36a1779169ecf75d37d933f32bae75799630365))
+* **ignore:** Group API proper typing ([#27243](https://github.com/Koenkk/zigbee2mqtt/issues/27243)) ([7cbf31a](https://github.com/Koenkk/zigbee2mqtt/commit/7cbf31a1296722a25b20fea561c2fedf04f22861))
+* **ignore:** partial cleanup for biome move ([#27076](https://github.com/Koenkk/zigbee2mqtt/issues/27076)) ([fc31e0a](https://github.com/Koenkk/zigbee2mqtt/commit/fc31e0af0a3c1592c2be9057a66287c60fa28a75))
+* **ignore:** update dependencies ([#27022](https://github.com/Koenkk/zigbee2mqtt/issues/27022)) ([d3bf771](https://github.com/Koenkk/zigbee2mqtt/commit/d3bf771de0365a2fb060d81ef07daccc6151abbf))
+* **ignore:** update dependencies ([#27094](https://github.com/Koenkk/zigbee2mqtt/issues/27094)) ([b4ce65b](https://github.com/Koenkk/zigbee2mqtt/commit/b4ce65bb41853ef177d910f7cb03131e861a0475))
+* **ignore:** update zigbee-herdsman to 3.5.0 ([#27000](https://github.com/Koenkk/zigbee2mqtt/issues/27000)) ([23e71aa](https://github.com/Koenkk/zigbee2mqtt/commit/23e71aab14536f4f38f12c3c8cb96eb1cd7ccb60))
+* **ignore:** update zigbee-herdsman to 3.5.1 ([#27024](https://github.com/Koenkk/zigbee2mqtt/issues/27024)) ([6949bbb](https://github.com/Koenkk/zigbee2mqtt/commit/6949bbb8838802573d2d1fd573fdba67132be446))
+* **ignore:** update zigbee-herdsman to 3.5.2 ([#27147](https://github.com/Koenkk/zigbee2mqtt/issues/27147)) ([130d041](https://github.com/Koenkk/zigbee2mqtt/commit/130d041f75121918dfd605aa0959e20718c392ab))
+* **ignore:** update zigbee-herdsman to 4.0.0 ([dfeaf22](https://github.com/Koenkk/zigbee2mqtt/commit/dfeaf22f703712e32dd1e27c96de7a374bc620c5))
+* **ignore:** update zigbee-herdsman-converters to 23.21.0 ([#27001](https://github.com/Koenkk/zigbee2mqtt/issues/27001)) ([20be405](https://github.com/Koenkk/zigbee2mqtt/commit/20be4054c163c0b8fe420de606c163076be8c926))
+* **ignore:** update zigbee-herdsman-converters to 23.22.0 ([#27023](https://github.com/Koenkk/zigbee2mqtt/issues/27023)) ([2297b81](https://github.com/Koenkk/zigbee2mqtt/commit/2297b8164094b648678c52884b7e20b62ccbe93c))
+* **ignore:** update zigbee-herdsman-converters to 23.23.0 ([#27036](https://github.com/Koenkk/zigbee2mqtt/issues/27036)) ([17adc44](https://github.com/Koenkk/zigbee2mqtt/commit/17adc44a63c1bc237101c02b6f780b37f578903c))
+* **ignore:** update zigbee-herdsman-converters to 23.24.0 ([#27061](https://github.com/Koenkk/zigbee2mqtt/issues/27061)) ([8e547d0](https://github.com/Koenkk/zigbee2mqtt/commit/8e547d06ec9981d9bfa95a51e12620a9e4a88c39))
+* **ignore:** update zigbee-herdsman-converters to 23.25.0 ([#27075](https://github.com/Koenkk/zigbee2mqtt/issues/27075)) ([b8cc120](https://github.com/Koenkk/zigbee2mqtt/commit/b8cc120da3f29d8d4d4393d565540f2d24a3db8e))
+* **ignore:** update zigbee-herdsman-converters to 23.26.0 ([06b53be](https://github.com/Koenkk/zigbee2mqtt/commit/06b53be5d891e01b498342e01502296dabeffa02))
+* **ignore:** update zigbee-herdsman-converters to 23.27.0 ([#27121](https://github.com/Koenkk/zigbee2mqtt/issues/27121)) ([b694dc1](https://github.com/Koenkk/zigbee2mqtt/commit/b694dc1525608d1d9394a405193aae88f34d2ada))
+* **ignore:** update zigbee-herdsman-converters to 23.28.0 ([#27130](https://github.com/Koenkk/zigbee2mqtt/issues/27130)) ([8a9f631](https://github.com/Koenkk/zigbee2mqtt/commit/8a9f63197319aad59e3028c86e4bb3da6b3e6a01))
+* **ignore:** update zigbee-herdsman-converters to 23.29.0 ([#27137](https://github.com/Koenkk/zigbee2mqtt/issues/27137)) ([8be1ae1](https://github.com/Koenkk/zigbee2mqtt/commit/8be1ae16ab5c47f5aaec28a6dc328c3d3d80d409))
+* **ignore:** update zigbee-herdsman-converters to 23.30.0 ([#27154](https://github.com/Koenkk/zigbee2mqtt/issues/27154)) ([ecc4696](https://github.com/Koenkk/zigbee2mqtt/commit/ecc46961446d17de540e48c76ab5b7c26f6c8c18))
+* **ignore:** update zigbee-herdsman-converters to 23.31.0 ([#27162](https://github.com/Koenkk/zigbee2mqtt/issues/27162)) ([8195b2d](https://github.com/Koenkk/zigbee2mqtt/commit/8195b2dd4ab514ba4ba944499ce71e66c41d6855))
+* **ignore:** update zigbee-herdsman-converters to 23.32.0 ([#27178](https://github.com/Koenkk/zigbee2mqtt/issues/27178)) ([faa6ad9](https://github.com/Koenkk/zigbee2mqtt/commit/faa6ad9ce883644eada82c04a9c11d41e62b4799))
+* **ignore:** update zigbee-herdsman-converters to 23.33.0 ([#27202](https://github.com/Koenkk/zigbee2mqtt/issues/27202)) ([c1b62e8](https://github.com/Koenkk/zigbee2mqtt/commit/c1b62e83ef22ae5880e833b645586a19bba661af))
+* **ignore:** update zigbee-herdsman-converters to 23.34.0 ([#27224](https://github.com/Koenkk/zigbee2mqtt/issues/27224)) ([a513516](https://github.com/Koenkk/zigbee2mqtt/commit/a5135168c81ae9e78eb84e66f2c4556a3e426442))
+* **ignore:** update zigbee-herdsman-converters to 23.35.0 ([#27253](https://github.com/Koenkk/zigbee2mqtt/issues/27253)) ([97dbe1e](https://github.com/Koenkk/zigbee2mqtt/commit/97dbe1e8af826c115d591712447031321f68cb60))
+* **ignore:** update zigbee-herdsman-converters to 23.36.0 ([#27276](https://github.com/Koenkk/zigbee2mqtt/issues/27276)) ([961a82e](https://github.com/Koenkk/zigbee2mqtt/commit/961a82e213889bee221abec0015ed45e171c6227))
+* **ignore:** update zigbee2mqtt-frontend to 0.9.10 ([#27191](https://github.com/Koenkk/zigbee2mqtt/issues/27191)) ([3ad20dd](https://github.com/Koenkk/zigbee2mqtt/commit/3ad20ddcdc2995b4a0522b55adeaa25701e279fc))
+* **ignore:** update zigbee2mqtt-frontend to 0.9.8 ([#27018](https://github.com/Koenkk/zigbee2mqtt/issues/27018)) ([d27ff76](https://github.com/Koenkk/zigbee2mqtt/commit/d27ff76921471ba6d88bfc14fa828665efaad5dd))
+* **ignore:** update zigbee2mqtt-frontend to 0.9.9 ([#27120](https://github.com/Koenkk/zigbee2mqtt/issues/27120)) ([0c0e5a3](https://github.com/Koenkk/zigbee2mqtt/commit/0c0e5a3794260782ccee759d131762c8f148c0f5))
+* Migrate to Biome ([#27150](https://github.com/Koenkk/zigbee2mqtt/issues/27150)) ([6fbb8b5](https://github.com/Koenkk/zigbee2mqtt/commit/6fbb8b5ca2d3d98240f23e0208edb2fd05826daa))
+* OnEvent fixes ([#27063](https://github.com/Koenkk/zigbee2mqtt/issues/27063)) ([80502da](https://github.com/Koenkk/zigbee2mqtt/commit/80502da80f38bcbcd5ad9e0c83a0d1d77a269394))
+* Use Alpine 3.21 for arm v6 and v7 ([#25417](https://github.com/Koenkk/zigbee2mqtt/issues/25417)) ([1e2ad28](https://github.com/Koenkk/zigbee2mqtt/commit/1e2ad28267030097cc9e2d53edc0cea17d328220))
+* Use Map for State ([#27105](https://github.com/Koenkk/zigbee2mqtt/issues/27105)) ([36e2baf](https://github.com/Koenkk/zigbee2mqtt/commit/36e2baf081242c609907d616b2945a9ead9d6fdd))
+
+## [2.2.1](https://github.com/Koenkk/zigbee2mqtt/compare/2.2.0...2.2.1) (2025-04-04)
+
+
+### Bug Fixes
+
+* Fix issue with some settings when migrating from 1.x.x to 2.2.x ([#26947](https://github.com/Koenkk/zigbee2mqtt/issues/26947)) ([9e481fe](https://github.com/Koenkk/zigbee2mqtt/commit/9e481fe5e57a8e664dd58cff7765b5365630c7c1))
+* Fix settings being overwriting when env var is set to a ref ([#26988](https://github.com/Koenkk/zigbee2mqtt/issues/26988)) ([d6a5128](https://github.com/Koenkk/zigbee2mqtt/commit/d6a5128aa819a85e2a06e57307329d2b35938397))
+* **ignore:** update zigbee-herdsman-converters to 23.19.0 ([#26938](https://github.com/Koenkk/zigbee2mqtt/issues/26938)) ([0b7d003](https://github.com/Koenkk/zigbee2mqtt/commit/0b7d0039f709215ac1a4895f15f06db41b4d4998))
+* **ignore:** update zigbee-herdsman-converters to 23.19.1 ([#26961](https://github.com/Koenkk/zigbee2mqtt/issues/26961)) ([e90afb2](https://github.com/Koenkk/zigbee2mqtt/commit/e90afb286a15c5416fd1126864acdfc4c03c3a64))
+* **ignore:** update zigbee-herdsman-converters to 23.20.0 ([#26978](https://github.com/Koenkk/zigbee2mqtt/issues/26978)) ([37927e6](https://github.com/Koenkk/zigbee2mqtt/commit/37927e698abcb242965423e9ee37623255feadab))
+* **ignore:** update zigbee-herdsman-converters to 23.20.1 ([#26989](https://github.com/Koenkk/zigbee2mqtt/issues/26989)) ([9d0ee03](https://github.com/Koenkk/zigbee2mqtt/commit/9d0ee03f38ee6881dce3b17c219a6580303607ef))
+* **ignore:** update zigbee2mqtt-frontend to 0.9.6 ([#26959](https://github.com/Koenkk/zigbee2mqtt/issues/26959)) ([fb4d01e](https://github.com/Koenkk/zigbee2mqtt/commit/fb4d01ebced7046919d6657c7609a196d39a1a6c))
+* **ignore:** update zigbee2mqtt-frontend to 0.9.7 ([#26976](https://github.com/Koenkk/zigbee2mqtt/issues/26976)) ([89cdb1f](https://github.com/Koenkk/zigbee2mqtt/commit/89cdb1f180bb343b56a50c94dc6a23dda1345582))
+
+## [2.2.0](https://github.com/Koenkk/zigbee2mqtt/compare/2.1.3...2.2.0) (2025-04-01)
+
+
+### Features
+
+* Frontend: support filtering notifications ([#26805](https://github.com/Koenkk/zigbee2mqtt/issues/26805)) ([f872a51](https://github.com/Koenkk/zigbee2mqtt/commit/f872a5180c5618b7d3e7c0d11f1283a454dcbc6b))
+* Onboarding ([#26608](https://github.com/Koenkk/zigbee2mqtt/issues/26608)) ([05d6f08](https://github.com/Koenkk/zigbee2mqtt/commit/05d6f08a0dd6a5097b7d19b8de3b39e37e9a8533))
+* Support Zigbee on Host adapter ([#26742](https://github.com/Koenkk/zigbee2mqtt/issues/26742)) ([92955c0](https://github.com/Koenkk/zigbee2mqtt/commit/92955c02a4de09cbed79249db8bf0e6529423b93))
+* Use dynamic import for external JS ([#26522](https://github.com/Koenkk/zigbee2mqtt/issues/26522)) ([badf107](https://github.com/Koenkk/zigbee2mqtt/commit/badf1079919baa06f160a42c34e9f742a9b584c9))
+
+
+### Bug Fixes
+
+* Add device name to no converter available error message ([#26867](https://github.com/Koenkk/zigbee2mqtt/issues/26867)) ([267c399](https://github.com/Koenkk/zigbee2mqtt/commit/267c3990474dcc646e6987a108867a54b8b940db))
+* Check if new commits are available in update.sh ([#26631](https://github.com/Koenkk/zigbee2mqtt/issues/26631)) ([1b6ad46](https://github.com/Koenkk/zigbee2mqtt/commit/1b6ad46462681b8f223a6de54c5996d0e8f66f64))
+* Fix bridge offline message format for frontend ([#26707](https://github.com/Koenkk/zigbee2mqtt/issues/26707)) ([e398500](https://github.com/Koenkk/zigbee2mqtt/commit/e3985002c2bf374c2edd82e95aaa2da7c920b464))
+* General cleanup ([#26595](https://github.com/Koenkk/zigbee2mqtt/issues/26595)) ([8775ceb](https://github.com/Koenkk/zigbee2mqtt/commit/8775ceb0c1d2bac552a345751935d0191410bfa3))
+* **gnore:** Onboarding fixes ([#26824](https://github.com/Koenkk/zigbee2mqtt/issues/26824)) ([f2a1c9a](https://github.com/Koenkk/zigbee2mqtt/commit/f2a1c9a2be052ec46d845299d73ff1495d4ea4e1))
+* Home Assistant: fix electrical measurements sensors category ([#26769](https://github.com/Koenkk/zigbee2mqtt/issues/26769)) ([747f6ac](https://github.com/Koenkk/zigbee2mqtt/commit/747f6ac4767522a51fb5e5cc0b796b3a92243476))
+* **ignore:** fix `EACCES: permission denied, mkdir '/app/dist/external_converters'` ([7a1621a](https://github.com/Koenkk/zigbee2mqtt/commit/7a1621a9060cd0109643655df2b2833e046158fa))
+* **ignore:** Fix HA addon onboarding ([#26862](https://github.com/Koenkk/zigbee2mqtt/issues/26862)) ([341c453](https://github.com/Koenkk/zigbee2mqtt/commit/341c453657d74aef61e4a44b24d081fab9671d39))
+* **ignore:** Fix tests failing when zhc is linked via `pnpm link` ([#26630](https://github.com/Koenkk/zigbee2mqtt/issues/26630)) ([ad32fec](https://github.com/Koenkk/zigbee2mqtt/commit/ad32fec1d02f2d43b7dc18bf38bbd14f7c97ffde))
+* **ignore:** Fix update check ([#26723](https://github.com/Koenkk/zigbee2mqtt/issues/26723)) ([fb48bd0](https://github.com/Koenkk/zigbee2mqtt/commit/fb48bd0cb9a0311302d82a7f1b9cec21a585799e))
+* **ignore:** Make update check less verbose ([#26774](https://github.com/Koenkk/zigbee2mqtt/issues/26774)) ([6e781ea](https://github.com/Koenkk/zigbee2mqtt/commit/6e781eafaefa54fad24ed857e1f96261ff3bebb7))
+* **ignore:** Module `NodeNext` ([#26719](https://github.com/Koenkk/zigbee2mqtt/issues/26719)) ([5db1150](https://github.com/Koenkk/zigbee2mqtt/commit/5db115057ef733a33575c889e981696d2b9e74b9))
+* **ignore:** Move to `Node16` `module` ([#26704](https://github.com/Koenkk/zigbee2mqtt/issues/26704)) ([ea5e0d4](https://github.com/Koenkk/zigbee2mqtt/commit/ea5e0d47a599ac66dcf4671e7a8b0687d8a08b85))
+* **ignore:** Move to Node16 module ([#26717](https://github.com/Koenkk/zigbee2mqtt/issues/26717)) ([be722a0](https://github.com/Koenkk/zigbee2mqtt/commit/be722a0500892e6787d669ceb10c7d0bfc1c7e4c))
+* **ignore:** Reduce chaining in `homeassistant.ts` ([#26582](https://github.com/Koenkk/zigbee2mqtt/issues/26582)) ([4fa794a](https://github.com/Koenkk/zigbee2mqtt/commit/4fa794a6392917d0140b94257bb7cd155fc25936))
+* **ignore:** Remove uncessary extensions spread ([#26581](https://github.com/Koenkk/zigbee2mqtt/issues/26581)) ([1fe2d8d](https://github.com/Koenkk/zigbee2mqtt/commit/1fe2d8dae6ace27c4b297b7943ac5501c096e8ab))
+* **ignore:** update dependencies ([#26554](https://github.com/Koenkk/zigbee2mqtt/issues/26554)) ([11fb858](https://github.com/Koenkk/zigbee2mqtt/commit/11fb858ff2819319f8aa4bd8a6b2f25944619a8e))
+* **ignore:** update dependencies ([#26662](https://github.com/Koenkk/zigbee2mqtt/issues/26662)) ([fb98166](https://github.com/Koenkk/zigbee2mqtt/commit/fb9816659bec15d0a9a39f73d4900fc7586a378e))
+* **ignore:** update dependencies ([#26751](https://github.com/Koenkk/zigbee2mqtt/issues/26751)) ([e602dc8](https://github.com/Koenkk/zigbee2mqtt/commit/e602dc849a1d17b9097ce06015ba587c59ba5006))
+* **ignore:** update dependencies ([#26833](https://github.com/Koenkk/zigbee2mqtt/issues/26833)) ([93d0ee4](https://github.com/Koenkk/zigbee2mqtt/commit/93d0ee44ba4445711b7e43ab4bfa06e8ac266d68))
+* **ignore:** update dependencies ([#26911](https://github.com/Koenkk/zigbee2mqtt/issues/26911)) ([e02bbdc](https://github.com/Koenkk/zigbee2mqtt/commit/e02bbdcf0bbf8577ab6e138c915f7e2ef1a32482))
+* **ignore:** update zigbee-herdsman to 3.3.0 ([#26628](https://github.com/Koenkk/zigbee2mqtt/issues/26628)) ([ed7e7c7](https://github.com/Koenkk/zigbee2mqtt/commit/ed7e7c7e530010aeb44eb71e50f31145c7285c26))
+* **ignore:** update zigbee-herdsman to 3.3.1 ([#26674](https://github.com/Koenkk/zigbee2mqtt/issues/26674)) ([a5195a6](https://github.com/Koenkk/zigbee2mqtt/commit/a5195a6eee9a3e852709c4b979c965dee33f2b54))
+* **ignore:** update zigbee-herdsman to 3.3.2 ([#26702](https://github.com/Koenkk/zigbee2mqtt/issues/26702)) ([8378949](https://github.com/Koenkk/zigbee2mqtt/commit/8378949e1d9cdfb3d33bc771dc61594ca7ef3c05))
+* **ignore:** update zigbee-herdsman to 3.4.0 ([#26744](https://github.com/Koenkk/zigbee2mqtt/issues/26744)) ([e5a80e3](https://github.com/Koenkk/zigbee2mqtt/commit/e5a80e3b1bf8ab5f693d248f2b6a90481bdb10fc))
+* **ignore:** update zigbee-herdsman to 3.4.1 ([#26779](https://github.com/Koenkk/zigbee2mqtt/issues/26779)) ([46fd043](https://github.com/Koenkk/zigbee2mqtt/commit/46fd04364ded0b6f7c9fcea6f33a2b523971b389))
+* **ignore:** update zigbee-herdsman to 3.4.10 ([#26908](https://github.com/Koenkk/zigbee2mqtt/issues/26908)) ([b52cfd8](https://github.com/Koenkk/zigbee2mqtt/commit/b52cfd87c3deedfa0d1d391ce4f6f64083389559))
+* **ignore:** update zigbee-herdsman to 3.4.11 ([#26924](https://github.com/Koenkk/zigbee2mqtt/issues/26924)) ([9fe38b1](https://github.com/Koenkk/zigbee2mqtt/commit/9fe38b1677681b1f3b47ac6d9876fa7305572244))
+* **ignore:** update zigbee-herdsman to 3.4.2 ([#26789](https://github.com/Koenkk/zigbee2mqtt/issues/26789)) ([582bf7d](https://github.com/Koenkk/zigbee2mqtt/commit/582bf7d2c6a21003e09892b569ef5fb115f5d1ab))
+* **ignore:** update zigbee-herdsman to 3.4.3 ([#26802](https://github.com/Koenkk/zigbee2mqtt/issues/26802)) ([4f2b052](https://github.com/Koenkk/zigbee2mqtt/commit/4f2b052016f4d313dfc43d35aca986b682c173b0))
+* **ignore:** update zigbee-herdsman to 3.4.4 ([#26821](https://github.com/Koenkk/zigbee2mqtt/issues/26821)) ([0714582](https://github.com/Koenkk/zigbee2mqtt/commit/0714582eb975c39ef0fb5205d7f2c76ce7de2a05))
+* **ignore:** update zigbee-herdsman to 3.4.5 ([#26826](https://github.com/Koenkk/zigbee2mqtt/issues/26826)) ([2b90d7b](https://github.com/Koenkk/zigbee2mqtt/commit/2b90d7b3b974353c312dc00c26b6223be74e1272))
+* **ignore:** update zigbee-herdsman to 3.4.6 ([#26834](https://github.com/Koenkk/zigbee2mqtt/issues/26834)) ([9e0c84b](https://github.com/Koenkk/zigbee2mqtt/commit/9e0c84beed18d13ec310d91b89e35eba46fe3817))
+* **ignore:** update zigbee-herdsman to 3.4.7 ([#26859](https://github.com/Koenkk/zigbee2mqtt/issues/26859)) ([440e3a0](https://github.com/Koenkk/zigbee2mqtt/commit/440e3a00942dc8bb7a7b9b66efd825e15dccad6c))
+* **ignore:** update zigbee-herdsman to 3.4.8 ([#26866](https://github.com/Koenkk/zigbee2mqtt/issues/26866)) ([f824295](https://github.com/Koenkk/zigbee2mqtt/commit/f824295b7efefb78d6f803a4291fb2a485694c96))
+* **ignore:** update zigbee-herdsman to 3.4.9 ([#26877](https://github.com/Koenkk/zigbee2mqtt/issues/26877)) ([0a41af5](https://github.com/Koenkk/zigbee2mqtt/commit/0a41af5dd23d1806d703b878feaba25d90c2d016))
+* **ignore:** update zigbee-herdsman-converters to 23.10.0 ([#26792](https://github.com/Koenkk/zigbee2mqtt/issues/26792)) ([52c255b](https://github.com/Koenkk/zigbee2mqtt/commit/52c255bcc2a37a7238afe675f7c521c0834e2d9d))
+* **ignore:** update zigbee-herdsman-converters to 23.11.0 ([#26820](https://github.com/Koenkk/zigbee2mqtt/issues/26820)) ([5288549](https://github.com/Koenkk/zigbee2mqtt/commit/5288549744795296a9919828b1a85b1223edd755))
+* **ignore:** update zigbee-herdsman-converters to 23.12.0 ([#26835](https://github.com/Koenkk/zigbee2mqtt/issues/26835)) ([53e8226](https://github.com/Koenkk/zigbee2mqtt/commit/53e8226f0aff0cdfba76f6f30672c0bd3d72d52d))
+* **ignore:** update zigbee-herdsman-converters to 23.13.0 ([#26861](https://github.com/Koenkk/zigbee2mqtt/issues/26861)) ([c5c7f70](https://github.com/Koenkk/zigbee2mqtt/commit/c5c7f70ad6aaca083c4edb4dba783e60f8ec17a5))
+* **ignore:** update zigbee-herdsman-converters to 23.14.0 ([#26886](https://github.com/Koenkk/zigbee2mqtt/issues/26886)) ([6a65769](https://github.com/Koenkk/zigbee2mqtt/commit/6a657690604daacc4a2cc1afa8407fd0d4dc9eaf))
+* **ignore:** update zigbee-herdsman-converters to 23.15.0 ([#26900](https://github.com/Koenkk/zigbee2mqtt/issues/26900)) ([516425b](https://github.com/Koenkk/zigbee2mqtt/commit/516425b44b7f395db7bbed93699b989d6a8276be))
+* **ignore:** update zigbee-herdsman-converters to 23.16.0 ([#26918](https://github.com/Koenkk/zigbee2mqtt/issues/26918)) ([6e6a989](https://github.com/Koenkk/zigbee2mqtt/commit/6e6a989159383a3534ce6d12ea8c9bdc9092d2bc))
+* **ignore:** update zigbee-herdsman-converters to 23.17.0 ([#26925](https://github.com/Koenkk/zigbee2mqtt/issues/26925)) ([ea04f19](https://github.com/Koenkk/zigbee2mqtt/commit/ea04f197090e3a3bc52dc4eb4ecde65146484bfb))
+* **ignore:** update zigbee-herdsman-converters to 23.18.0 ([#26933](https://github.com/Koenkk/zigbee2mqtt/issues/26933)) ([69f0840](https://github.com/Koenkk/zigbee2mqtt/commit/69f0840feb2f8a5332148cfe271d16e413a02ebf))
+* **ignore:** update zigbee-herdsman-converters to 23.3.0 ([#26598](https://github.com/Koenkk/zigbee2mqtt/issues/26598)) ([3941692](https://github.com/Koenkk/zigbee2mqtt/commit/3941692665d96fee575995bb6a372bfb92e0a466))
+* **ignore:** update zigbee-herdsman-converters to 23.4.0 ([#26629](https://github.com/Koenkk/zigbee2mqtt/issues/26629)) ([c603f42](https://github.com/Koenkk/zigbee2mqtt/commit/c603f42c889b5508a56f0f43df7d09dba909b0cd))
+* **ignore:** update zigbee-herdsman-converters to 23.6.0 ([#26691](https://github.com/Koenkk/zigbee2mqtt/issues/26691)) ([06ba62b](https://github.com/Koenkk/zigbee2mqtt/commit/06ba62b8331d8d5db1696c47bd3b643449584b16))
+* **ignore:** update zigbee-herdsman-converters to 23.7.0 ([#26733](https://github.com/Koenkk/zigbee2mqtt/issues/26733)) ([8d2ef6d](https://github.com/Koenkk/zigbee2mqtt/commit/8d2ef6df06bbfcc856a91ef592e8ac54f46a705c))
+* **ignore:** update zigbee-herdsman-converters to 23.8.0 ([#26761](https://github.com/Koenkk/zigbee2mqtt/issues/26761)) ([325199d](https://github.com/Koenkk/zigbee2mqtt/commit/325199d4455adb32f912687827ed01d89e009bc1))
+* **ignore:** update zigbee2mqtt-frontend to 0.9.5 ([#26814](https://github.com/Koenkk/zigbee2mqtt/issues/26814)) ([9792466](https://github.com/Koenkk/zigbee2mqtt/commit/9792466aac8b94747fe41fe47db766b7a7e93367))
+* Implement systemd-notify directly ([#26456](https://github.com/Koenkk/zigbee2mqtt/issues/26456)) ([bfeac07](https://github.com/Koenkk/zigbee2mqtt/commit/bfeac07c4c38fb55db99d5f8204e85ec54552564))
+* Use dynamic import for optional extensions ([#26735](https://github.com/Koenkk/zigbee2mqtt/issues/26735)) ([db578d9](https://github.com/Koenkk/zigbee2mqtt/commit/db578d9d1180c01c14f1b4707e779c28961eb5b8))
+* Write `ZIGBEE2MQTT_CONFIG_*` envs to yaml as overrides ([#26653](https://github.com/Koenkk/zigbee2mqtt/issues/26653)) ([f6f7ba6](https://github.com/Koenkk/zigbee2mqtt/commit/f6f7ba68c9dd84ccdd82df0769b197756e42bbf7))
+
+## [2.1.3](https://github.com/Koenkk/zigbee2mqtt/compare/2.1.2...2.1.3) (2025-03-02)
+
+
+### Bug Fixes
+
+* Home Assistant: fix brightness only lights ([#26560](https://github.com/Koenkk/zigbee2mqtt/issues/26560)) ([7e7057e](https://github.com/Koenkk/zigbee2mqtt/commit/7e7057eccd1fe638dd73b4a4f303c6612b73c89d))
+
+## [2.1.2](https://github.com/Koenkk/zigbee2mqtt/compare/2.1.1...2.1.2) (2025-03-01)
+
+
+### Bug Fixes
+
+* Add Home Assistant device class to external_temperature_input entity ([#26535](https://github.com/Koenkk/zigbee2mqtt/issues/26535)) ([e8031ef](https://github.com/Koenkk/zigbee2mqtt/commit/e8031efd2d95658c5f3fe72ee6e2f95dd584b5e8))
+* Allow configuring number of folders of old logs to keep ([#26398](https://github.com/Koenkk/zigbee2mqtt/issues/26398)) ([845e03e](https://github.com/Koenkk/zigbee2mqtt/commit/845e03e48acf1367feadeaae986f3c987bbc164d))
+* Fix Docker build hanging ([#26547](https://github.com/Koenkk/zigbee2mqtt/issues/26547)) ([e050e20](https://github.com/Koenkk/zigbee2mqtt/commit/e050e209b0d273cad6ad0efcf20761f33963da7b))
+* Fix HA MQTT dict entry indicating that an update is progress ([#26267](https://github.com/Koenkk/zigbee2mqtt/issues/26267)) ([b35cdc3](https://github.com/Koenkk/zigbee2mqtt/commit/b35cdc347423b219722c9f9dd0d2a82ded8eb24f))
+* Home Assistant: add `brightness` to `supported_color_modes` ([#26545](https://github.com/Koenkk/zigbee2mqtt/issues/26545)) ([063aba1](https://github.com/Koenkk/zigbee2mqtt/commit/063aba1b6c72901ed2d51a367485092691c358da))
+* Home Assistant: add `is_updating` attribute ([#26231](https://github.com/Koenkk/zigbee2mqtt/issues/26231)) ([1eda69a](https://github.com/Koenkk/zigbee2mqtt/commit/1eda69a50a8f92c3471acdbdc82b41055d5992f2))
+* Home Assistant: add missing `device_class` for some `current` and `power` entities ([#26324](https://github.com/Koenkk/zigbee2mqtt/issues/26324)) ([1e656c2](https://github.com/Koenkk/zigbee2mqtt/commit/1e656c2114d58b96fd7b7750e2e7d255a9175653))
+* Home Assistant: support speed-controlled fans  ([#24483](https://github.com/Koenkk/zigbee2mqtt/issues/24483)) ([7ce5b58](https://github.com/Koenkk/zigbee2mqtt/commit/7ce5b581aa57d828043a1ca75ef7efe7b7bf1619))
+* **ignore:** Add `publish` to `meta` of toZigbee converters ([#26490](https://github.com/Koenkk/zigbee2mqtt/issues/26490)) ([07145ac](https://github.com/Koenkk/zigbee2mqtt/commit/07145accbae6c481f6d6740e66e27ab1baf5eb6d))
+* **ignore:** remove obsolete @types/eslint__js ([d522d2c](https://github.com/Koenkk/zigbee2mqtt/commit/d522d2cd18b8cb77fa50cd457823cfa573622cb7))
+* **ignore:** update dependencies ([#26266](https://github.com/Koenkk/zigbee2mqtt/issues/26266)) ([3e3ceff](https://github.com/Koenkk/zigbee2mqtt/commit/3e3cefff1b7f85f59b6bf529f6593339498561a1))
+* **ignore:** update dependencies ([#26383](https://github.com/Koenkk/zigbee2mqtt/issues/26383)) ([758c566](https://github.com/Koenkk/zigbee2mqtt/commit/758c56647d353e81ea22a34c2fa2665ed76dc149))
+* **ignore:** update dependencies ([#26478](https://github.com/Koenkk/zigbee2mqtt/issues/26478)) ([d2166f2](https://github.com/Koenkk/zigbee2mqtt/commit/d2166f2f4fa1e1e286face994ec4825a70144908))
+* **ignore:** update zigbee-herdsman to 3.2.6 ([#26303](https://github.com/Koenkk/zigbee2mqtt/issues/26303)) ([49fe147](https://github.com/Koenkk/zigbee2mqtt/commit/49fe1479213c928786c64adeb3031ca6fe91250d))
+* **ignore:** update zigbee-herdsman to 3.2.7 ([#26498](https://github.com/Koenkk/zigbee2mqtt/issues/26498)) ([4e650b7](https://github.com/Koenkk/zigbee2mqtt/commit/4e650b72cd187488893213018b619e933835a58e))
+* **ignore:** update zigbee-herdsman-converters to 21.32.0 ([#26245](https://github.com/Koenkk/zigbee2mqtt/issues/26245)) ([8542b35](https://github.com/Koenkk/zigbee2mqtt/commit/8542b35706cefc87c9ec9dccb2980302ea25f100))
+* **ignore:** update zigbee-herdsman-converters to 21.33.0 ([#26258](https://github.com/Koenkk/zigbee2mqtt/issues/26258)) ([97c7485](https://github.com/Koenkk/zigbee2mqtt/commit/97c74852c95536945e33d0388dc5fcd0b132cd7e))
+* **ignore:** update zigbee-herdsman-converters to 21.34.0 ([#26285](https://github.com/Koenkk/zigbee2mqtt/issues/26285)) ([7a0964e](https://github.com/Koenkk/zigbee2mqtt/commit/7a0964ebc905903b4ca5b168d9bd1041b004b4cf))
+* **ignore:** update zigbee-herdsman-converters to 21.35.0 ([#26305](https://github.com/Koenkk/zigbee2mqtt/issues/26305)) ([30d13d6](https://github.com/Koenkk/zigbee2mqtt/commit/30d13d6e5ee9678f7da812bd287128824a535d48))
+* **ignore:** update zigbee-herdsman-converters to 21.36.0 ([#26333](https://github.com/Koenkk/zigbee2mqtt/issues/26333)) ([ba76533](https://github.com/Koenkk/zigbee2mqtt/commit/ba76533c2f241c8362f43ad07d10b2fe084479a0))
+* **ignore:** update zigbee-herdsman-converters to 21.37.0 ([#26367](https://github.com/Koenkk/zigbee2mqtt/issues/26367)) ([dec5ca8](https://github.com/Koenkk/zigbee2mqtt/commit/dec5ca8b3a3703e6289652192657af9a035fe026))
+* **ignore:** update zigbee-herdsman-converters to 21.38.0 ([#26400](https://github.com/Koenkk/zigbee2mqtt/issues/26400)) ([93af062](https://github.com/Koenkk/zigbee2mqtt/commit/93af062a9b84358c866a5a1191ae5895fc6e866f))
+* **ignore:** update zigbee-herdsman-converters to 22.0.1 ([#26418](https://github.com/Koenkk/zigbee2mqtt/issues/26418)) ([7d63a9a](https://github.com/Koenkk/zigbee2mqtt/commit/7d63a9a0f29445044bcfe0f3a4b629266db37654))
+* **ignore:** update zigbee-herdsman-converters to 22.1.0 ([#26445](https://github.com/Koenkk/zigbee2mqtt/issues/26445)) ([40f4147](https://github.com/Koenkk/zigbee2mqtt/commit/40f41477e776b4e75434251d03bf2844fceb7b13))
+* **ignore:** update zigbee-herdsman-converters to 22.2.0 ([#26469](https://github.com/Koenkk/zigbee2mqtt/issues/26469)) ([67e1a02](https://github.com/Koenkk/zigbee2mqtt/commit/67e1a0252517da28629a4c97b4dd610624d451a1))
+* **ignore:** update zigbee-herdsman-converters to 23.0.0 ([44f9fe7](https://github.com/Koenkk/zigbee2mqtt/commit/44f9fe7a1494a9450e247ad353ce788c621f901c))
+* **ignore:** update zigbee-herdsman-converters to 23.1.0 ([#26509](https://github.com/Koenkk/zigbee2mqtt/issues/26509)) ([db7b51a](https://github.com/Koenkk/zigbee2mqtt/commit/db7b51ac801829801656d978aff2605d8bd7b56a))
+* **ignore:** update zigbee-herdsman-converters to 23.1.1 ([#26510](https://github.com/Koenkk/zigbee2mqtt/issues/26510)) ([102857a](https://github.com/Koenkk/zigbee2mqtt/commit/102857a7fec60e3f65887d92b6fe7a2d81add110))
+* **ignore:** update zigbee-herdsman-converters to 23.2.0 ([#26549](https://github.com/Koenkk/zigbee2mqtt/issues/26549)) ([9f72c5c](https://github.com/Koenkk/zigbee2mqtt/commit/9f72c5c4555bda5b347a6a5406f619b9668813ec))
+* Make compatible with pnpm 10 ([#26546](https://github.com/Koenkk/zigbee2mqtt/issues/26546)) ([29d25ae](https://github.com/Koenkk/zigbee2mqtt/commit/29d25aed66a66912fb55ede8751ba8056efb673f))
+* Support FreeBSD for `update.sh` ([#26261](https://github.com/Koenkk/zigbee2mqtt/issues/26261)) ([5e55ef0](https://github.com/Koenkk/zigbee2mqtt/commit/5e55ef045427f78b410e3d292387c3592366f698))
+
 ## [2.1.1](https://github.com/Koenkk/zigbee2mqtt/compare/2.1.0...2.1.1) (2025-02-06)
 
 

CONTRIBUTING.md

@@ -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 `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`.
+- 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: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).

README.md

@@ -5,33 +5,27 @@
     <br>
     <br>
     <div style="display: flex;">
-        <a href="https://github.com/Koenkk/zigbee2mqtt/actions?query=workflow%3Aci">
-            <img src="https://github.com/koenkk/zigbee2mqtt/workflows/ci/badge.svg">
-        </a>
         <a href="https://github.com/Koenkk/zigbee2mqtt/releases">
             <img src="https://img.shields.io/github/release/koenkk/zigbee2mqtt.svg">
         </a>
+        <a href="https://www.npmjs.com/package/zigbee2mqtt">
+            <img src="https://img.shields.io/npm/v/zigbee2mqtt">
+        </a>
+        <a href="https://github.com/Koenkk/zigbee2mqtt/actions/workflows/ci.yml">
+            <img src="https://github.com/Koenkk/zigbee2mqtt/actions/workflows/ci.yml/badge.svg">
+        </a>
+        <a href="https://github.com/Koenkk/zigbee2mqtt/actions/workflows/github-code-scanning/codeql">
+            <img src="https://github.com/Koenkk/zigbee2mqtt/actions/workflows/github-code-scanning/codeql/badge.svg">
+        </a>
+        <a href="https://discord.gg/dadfWYE">
+            <img src="https://img.shields.io/discord/556563650429583360.svg">
+        </a>
         <a href="https://github.com/Koenkk/zigbee2mqtt/stargazers">
             <img src="https://img.shields.io/github/stars/koenkk/zigbee2mqtt.svg">
         </a>
         <a href="https://www.paypal.me/koenkk">
             <img src="https://img.shields.io/badge/donate-PayPal-blue.svg">
         </a>
-        <a href="https://discord.gg/dadfWYE">
-            <img src="https://img.shields.io/discord/556563650429583360.svg">
-        </a>
-        <a href="http://zigbee2mqtt.discourse.group/">
-            <img src="https://img.shields.io/discourse/https/zigbee2mqtt.discourse.group/status.svg">
-        </a>
-        <a>
-            <img src="https://img.shields.io/badge/Coverage-100%25-brightgreen.svg">
-        </a>
-        <a href="https://www.codacy.com/manual/Koenkk/zigbee2mqtt?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=Koenkk/zigbee2mqtt&amp;utm_campaign=Badge_Grade">
-            <img src="https://api.codacy.com/project/badge/Grade/24f1e0fe39f04daa810e8a1416693d3f">
-        </a>
-        <a href="https://www.npmjs.com/package/zigbee2mqtt">
-            <img src="https://img.shields.io/npm/v/zigbee2mqtt">
-        </a>
     </div>
     <h1>Zigbee2MQTT  🌉 🐝</h1>
     <p>
@@ -52,62 +46,70 @@ If you aren't familiar with **Zigbee** terminology make sure you [read this](htt
 
 Zigbee2MQTT integrates well with (almost) every home automation solution because it uses MQTT. However the following integrations are worth mentioning:
 
-<img align="left" height="100px" width="100px" src="https://user-images.githubusercontent.com/7738048/40914297-49e6e560-6800-11e8-8904-36cce896e5a8.png">
-
 ### [Home Assistant](https://www.home-assistant.io/)
 
-- [Home Assistant OS](https://www.home-assistant.io/installation/): Using [the official addon](https://github.com/zigbee2mqtt/hassio-zigbee2mqtt)
-- Other installation: using instructions [here](https://www.zigbee2mqtt.io/guide/usage/integrations/home_assistant.html)
+<img align="left" height="75px" width="75px" src="https://user-images.githubusercontent.com/7738048/40914297-49e6e560-6800-11e8-8904-36cce896e5a8.png">
 
-<br>
+<br clear="right">
 
-<img align="left" height="100px" width="100px" src="https://etc.athom.com/logo/white/256.png">
+[Home Assistant OS](https://www.home-assistant.io/installation/) using [the official addon](https://github.com/zigbee2mqtt/hassio-zigbee2mqtt) ([other installations](https://www.zigbee2mqtt.io/guide/usage/integrations/home_assistant.html))
+
+<br clear="both">
 
 ### [Homey](https://homey.app/)
 
-- Integration implemented in the [Homey App](https://homey.app/nl-nl/app/com.gruijter.zigbee2mqtt/)
-- Documentation and support in the [Homey Forum](https://community.homey.app/t/83214)
+<img align="left" height="75px" width="75px" src="https://etc.athom.com/logo/white/256.png">
 
-<br>
+<br clear="right">
 
-<img align="left" height="100px" width="100px" src="https://user-images.githubusercontent.com/2734836/47615848-b8dd8700-dabd-11e8-9d77-175002dd8987.png">
+Integration implemented in the [Homey App](https://homey.app/nl-nl/app/com.gruijter.zigbee2mqtt/) ([documentation & support](https://community.homey.app/t/83214))
+
+<br clear="both">
 
 ### [Domoticz](https://www.domoticz.com/)
 
-- Integration implemented in Domoticz ([documentation](https://www.domoticz.com/wiki/Zigbee2MQTT)).
+<img align="left" height="75px" width="75px" src="https://user-images.githubusercontent.com/2734836/47615848-b8dd8700-dabd-11e8-9d77-175002dd8987.png">
 
-<br>
+<br clear="right">
 
-<img align="left" height="100px" width="100px" src="./images/gladys-assistant-logo.jpg">
+Integration implemented in Domoticz ([documentation](https://www.domoticz.com/wiki/Zigbee2MQTT)).
+
+<br clear="both">
 
 ### [Gladys Assistant](https://gladysassistant.com/)
 
-- Integration implemented natively in Gladys Assistant ([documentation](https://gladysassistant.com/docs/integrations/zigbee2mqtt/)).
+<img align="left" height="75px" width="75px" src="./images/gladys-assistant-logo.jpg">
 
-<br>
+<br clear="right">
 
-<img align="left" height="100px" width="100px" src="https://forum.iobroker.net/assets/uploads/system/site-logo.png">
+Integration implemented natively in Gladys Assistant ([documentation](https://gladysassistant.com/docs/integrations/zigbee2mqtt/)).
+
+<br clear="both">
 
 ### [IoBroker](https://www.iobroker.net/)
 
-- Integration implemented in IoBroker ([documentation](https://github.com/o0shojo0o/ioBroker.zigbee2mqtt)).
+<img align="left" height="75px" width="75px" src="https://forum.iobroker.net/assets/uploads/system/site-logo.png">
 
-<br>
+<br clear="right">
+
+Integration implemented in IoBroker ([documentation](https://github.com/o0shojo0o/ioBroker.zigbee2mqtt)).
+
+<br clear="both">
 
 ## Architecture
 
-![Architecture](images/architecture.png)
+![Architecture](images/architecture-new.png)
 
 ### Internal Architecture
 
-Zigbee2MQTT is made up of three modules, each developed in its own Github project. Starting from the hardware (adapter) and moving up; [zigbee-herdsman](https://github.com/koenkk/zigbee-herdsman) connects to your Zigbee adapter and makes an API available to the higher levels of the stack. For e.g. Texas Instruments hardware, zigbee-herdsman uses the [TI zStack monitoring and test API](https://github.com/koenkk/zigbee-herdsman/raw/master/docs/Z-Stack%20Monitor%20and%20Test%20API.pdf) to communicate with the adapter. Zigbee-herdsman handles the core Zigbee communication. The module [zigbee-herdsman-converters](https://github.com/koenkk/zigbee-herdsman-converters) handles the mapping from individual device models to the Zigbee clusters they support. [Zigbee clusters](https://github.com/Koenkk/zigbee-herdsman/blob/master/docs/07-5123-08-Zigbee-Cluster-Library.pdf) are the layers of the Zigbee protocol on top of the base protocol that define things like how lights, sensors and switches talk to each other over the Zigbee network. Finally, the Zigbee2MQTT module drives zigbee-herdsman and maps the zigbee messages to MQTT messages. Zigbee2MQTT also keeps track of the state of the system. It uses a `database.db` file to store this state; a text file with a JSON database of connected devices and their capabilities. Zigbee2MQTT provides a [web-based interface](https://github.com/nurikk/zigbee2mqtt-frontend) that allows monitoring and configuration.
+Zigbee2MQTT is made up of three modules, each developed in its own Github project. Starting from the hardware (adapter) and moving up; [zigbee-herdsman](https://github.com/koenkk/zigbee-herdsman) connects to your adapter to handle Zigbee communication and makes an API available to the higher levels of the stack. For e.g. Texas Instruments hardware, zigbee-herdsman uses the [TI zStack monitoring and test API](https://github.com/Koenkk/zigbee-herdsman/wiki/References#texas-instruments-zstack) to communicate with the adapter. The module [zigbee-herdsman-converters](https://github.com/koenkk/zigbee-herdsman-converters) handles the mapping from individual device models to the Zigbee clusters they support. [Zigbee clusters](https://github.com/Koenkk/zigbee-herdsman/wiki/References#csa-zigbee-alliance-spec) are the layers of the Zigbee protocol on top of the base protocol that define things like how lights, sensors and switches talk to each other over the Zigbee network. Finally, the Zigbee2MQTT module drives zigbee-herdsman and maps the zigbee messages to MQTT messages. Zigbee2MQTT also keeps track of the state of the system. It uses a `database.db` file to store this state; a text file with a JSON database of connected devices and their capabilities. Zigbee2MQTT provides several web-based interfaces ([zigbee2mqtt-frontend](https://github.com/nurikk/zigbee2mqtt-frontend), [zigbee2mqtt-windfront](https://github.com/Nerivec/zigbee2mqtt-windfront)) that allows monitoring and configuration.
 
 ### Developing
 
-Zigbee2MQTT uses TypeScript (partially for now). Therefore after making changes to files in the `lib/` directory you need to recompile Zigbee2MQTT. This can be done by executing `pnpm run build`. For faster development instead of running `pnpm run build` you can run `pnpm run build-watch` in another terminal session, this will recompile as you change files.
+Zigbee2MQTT uses TypeScript. Therefore after making changes to files in the `lib/` directory you need to recompile Zigbee2MQTT. This can be done by executing `pnpm run build`. For faster development instead of running `pnpm run build` you can run `pnpm run build:watch` in another terminal session, this will recompile as you change files.
 
 Before running any of the commands, you'll first need to run `pnpm install --include=dev`.
-Before submitting changes run `pnpm run test:coverage`, `pnpm run pretty:check` and `pnpm run eslint`
+Before submitting changes run `pnpm run check:w` then `pnpm run test:coverage`.
 
 ## Supported devices
 

biome.json

@@ -0,0 +1,94 @@
+{
+    "$schema": "https://biomejs.dev/schemas/2.3.8/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"
+                    }
+                }
+            }
+        }
+    ]
+}

cli.js

@@ -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");

docker/Dockerfile

@@ -1,14 +1,6 @@
 ARG TARGETPLATFORM
 
-# Need to use Alpine 3.18.4 which uses Node 18 for arm/v6 and arm/v7, otherwise the build hangs.
-# See https://github.com/nodejs/docker-node/issues/2077
-FROM alpine:3.18.4 AS linux-arm-alpine
-FROM alpine:3.21 AS linux-arm64-alpine
-FROM alpine:3.21 AS linux-amd64-alpine
-FROM alpine:3.21 AS linux-riscv64-alpine
-FROM alpine:3.21 AS linux-386-alpine
-
-FROM linux-${TARGETARCH}-alpine AS base
+FROM alpine:3.22 AS base
 
 ENV NODE_ENV=production
 WORKDIR /app
@@ -18,12 +10,19 @@ RUN apk add --no-cache tzdata eudev tini nodejs
 FROM base AS deps
 
 COPY package.json pnpm-lock.yaml ./
+
 # Make and such are needed to compile serialport for riscv64
-RUN apk add make gcc g++ python3 linux-headers npm && \
-    npm install -g pnpm && \
-    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` && \
+# Install pnpm, configure a tmp-based store, then use it under a cache mount so each arch gets its own store
+# NOTE: We do not install devDependencies here (the --prod argument in pnpm install) as we use an already
+#       built artifact (./dist directory) from previous GitHub runner stages.  Omitting devDependencies here
+#       saves storage as this node_modules/ is being copied straight to the release stage later.
+RUN --mount=type=cache,id=pnpm-store,target=/tmp/pnpm-store \
+    apk add --no-cache make gcc g++ python3 linux-headers npm jq && \
+    npm install -g $(jq -r '.packageManager' package.json) && \
+    pnpm config set store-dir /tmp/pnpm-store && \
+    pnpm install --frozen-lockfile --prod --no-optional && \
+    # force serialport to rebuild on current platform instead of using prebuilds
+    rm -rf $(find ./node_modules/.pnpm/ -wholename "*/@serialport/bindings-cpp/prebuilds" -type d) && \
     pnpm rebuild @serialport/bindings-cpp
 
 # Release
@@ -53,5 +52,8 @@ RUN mkdir /app/data
 ARG COMMIT
 RUN echo "$COMMIT" > dist/.hash
 
+# Expose the default frontend port (see lib/util/settings.ts defaults.frontend.port)
+EXPOSE 8080
+
 ENTRYPOINT ["docker-entrypoint.sh"]
 CMD [ "/sbin/tini", "--", "node", "index.js"]

docker/docker-compose.yml

@@ -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

docker/docker-entrypoint.sh

@@ -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 "$@"

eslint.config.mjs

@@ -1,32 +0,0 @@
-// @ts-check
-
-import eslint from '@eslint/js';
-import eslintConfigPrettier from 'eslint-config-prettier';
-import tseslint from 'typescript-eslint';
-
-export default tseslint.config(
-    eslint.configs.recommended,
-    ...tseslint.configs.recommended,
-    {
-        languageOptions: {
-            parserOptions: {
-                project: true,
-            },
-        },
-        rules: {
-            '@typescript-eslint/await-thenable': 'error',
-            '@typescript-eslint/ban-ts-comment': 'error',
-            '@typescript-eslint/explicit-function-return-type': 'error',
-            '@typescript-eslint/no-explicit-any': 'error',
-            '@typescript-eslint/no-unused-vars': 'error',
-            'array-bracket-spacing': ['error', 'never'],
-            '@typescript-eslint/return-await': ['error', 'always'],
-            'object-curly-spacing': ['error', 'never'],
-            '@typescript-eslint/no-floating-promises': 'error',
-        },
-    },
-    {
-        ignores: ['dist/', '**/*.js', '**/*.mjs'],
-    },
-    eslintConfigPrettier,
-);

index.js

@@ -1,30 +1,29 @@
-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;
-let watchdog = process.env.Z2M_WATCHDOG != undefined;
+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];
 
-if (watchdog && process.env.Z2M_WATCHDOG !== 'default') {
-    if (/^(?:(?:[0-9]*[.])?[0-9]+)+(?:,?(?:[0-9]*[.])?[0-9]+)*$/.test(process.env.Z2M_WATCHDOG)) {
-        watchdogDelays = process.env.Z2M_WATCHDOG.split(',').map((v) => parseFloat(v) * 60000);
+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');
+const hashFile = path.join(__dirname, "dist", ".hash");
 
 async function triggerWatchdog(code) {
     const delay = watchdogDelays[watchdogCount];
@@ -58,10 +57,16 @@ async function exit(code, restart = false) {
 }
 
 async function currentHash() {
-    const git = require('git-last-commit');
+    return await new Promise((resolve) => {
+        exec("git rev-parse --short=8 HEAD", (error, stdout) => {
+            const commitHash = stdout.trim();
 
-    return new Promise((resolve) => {
-        git.getLastCommit((err, commit) => (err ? resolve('unknown') : resolve(commit.shortHash)));
+            if (error || commitHash === "") {
+                resolve("unknown");
+            } else {
+                resolve(commitHash);
+            }
+        });
     });
 }
 
@@ -72,30 +77,30 @@ async function writeHash() {
 }
 
 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;
+        const mb600 = 629145600;
 
-        if (_600mb > os.totalmem() && !env.NODE_OPTIONS) {
+        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('pnpm 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();
             }
         });
@@ -104,58 +109,41 @@ 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`}.`);
+    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`);
-    }
-
-    // Validate settings
-    const settings = require('./dist/util/settings');
-
-    settings.reRead();
-
     // gc
     {
-        const settingsMigration = require('./dist/util/settingsMigration');
+        const version = engines.node;
 
-        settingsMigration.migrateIfNecessary();
-    }
-
-    const errors = settings.validate();
-
-    if (errors.length > 0) {
-        unsolicitedStop = false;
-
-        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`);
         }
 
-        console.log(`\nIf you don't know how to solve this, read https://www.zigbee2mqtt.io/guide/configuration`);
-        console.log(`\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n\n`);
+        const {onboard} = require("./dist/util/onboarding");
 
-        return exit(1);
+        const success = await onboard();
+
+        if (!success) {
+            unsolicitedStop = false;
+
+            return await exit(1);
+        }
     }
 
-    const {Controller} = require('./dist/controller');
+    const {Controller} = require("./dist/controller");
     controller = new Controller(restart, exit);
 
     await controller.start();
@@ -184,17 +172,17 @@ async function handleQuit() {
     }
 }
 
-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};
 }

lib/controller.ts

@@ -1,79 +1,42 @@
-import type {IClientPublishOptions} from 'mqtt';
-import type * as SdNotify from 'sd-notify';
-
-import type {Zigbee2MQTTAPI} from './types/api';
-
-import assert from 'node:assert';
-
-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';
-import ExtensionAvailability from './extension/availability';
-import ExtensionBind from './extension/bind';
-import ExtensionBridge from './extension/bridge';
-import ExtensionConfigure from './extension/configure';
-import ExtensionExternalConverters from './extension/externalConverters';
-import ExtensionExternalExtensions from './extension/externalExtensions';
+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 ExtensionGroups from './extension/groups';
-import ExtensionHomeAssistant from './extension/homeassistant';
-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 from './mqtt';
-import State from './state';
-import logger from './util/logger';
-import * as settings from './util/settings';
-import utils from './util/utils';
-import Zigbee from './zigbee';
-
-type SdNotifyType = typeof SdNotify;
-
-const AllExtensions = [
-    ExtensionPublish,
-    ExtensionReceive,
-    ExtensionNetworkMap,
-    ExtensionHomeAssistant,
-    ExtensionConfigure,
-    ExtensionBridge,
-    ExtensionGroups,
-    ExtensionBind,
-    ExtensionOnEvent,
-    ExtensionOTAUpdate,
-    ExtensionExternalConverters,
-    ExtensionFrontend,
-    ExtensionExternalExtensions,
-    ExtensionAvailability,
-];
-
-type ExtensionArgs = [
-    Zigbee,
-    MQTT,
-    State,
-    PublishEntityState,
-    EventBus,
-    enableDisableExtension: (enable: boolean, name: string) => Promise<void>,
-    restartCallback: () => Promise<void>,
-    addExtension: (extension: Extension) => Promise<void>,
-];
+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;
+    public readonly eventBus: EventBus;
+    public readonly zigbee: Zigbee;
+    public readonly state: State;
+    public readonly mqtt: Mqtt;
     private restartCallback: () => Promise<void>;
     private exitCallback: (code: number, restart: boolean) => Promise<void>;
-    private extensions: Extension[];
-    private extensionArgs: ExtensionArgs;
-    private sdNotify: SdNotifyType | undefined;
+    public readonly extensions: Set<Extension>;
+    public readonly extensionArgs: ConstructorParameters<typeof Extension>;
+    private sdNotify: Awaited<ReturnType<typeof initSdNotify>>;
 
     constructor(restartCallback: () => Promise<void>, exitCallback: (code: number, restart: boolean) => Promise<void>) {
         logger.init();
@@ -81,7 +44,7 @@ export class Controller {
         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;
@@ -98,7 +61,7 @@ export class Controller {
             this.addExtension,
         ];
 
-        this.extensions = [
+        this.extensions = new Set([
             new ExtensionExternalConverters(...this.extensionArgs),
             new ExtensionOnEvent(...this.extensionArgs),
             new ExtensionBridge(...this.extensionArgs),
@@ -111,47 +74,44 @@ export class Controller {
             new ExtensionOTAUpdate(...this.extensionArgs),
             new ExtensionExternalExtensions(...this.extensionArgs),
             new ExtensionAvailability(...this.extensionArgs),
-        ];
-
-        if (settings.get().frontend.enabled) {
-            this.extensions.push(new ExtensionFrontend(...this.extensionArgs));
-        }
-
-        if (settings.get().homeassistant.enabled) {
-            this.extensions.push(new ExtensionHomeAssistant(...this.extensionArgs));
-        }
+            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})`);
 
-        try {
-            this.sdNotify = process.env.NOTIFY_SOCKET ? await import('sd-notify') : undefined;
-            logger.debug('sd-notify loaded');
-            /* v8 ignore start */
-        } catch {
-            logger.debug('sd-notify is not installed');
-        }
-        /* v8 ignore stop */
-
         // Start zigbee
         try {
             await this.zigbee.start();
             this.eventBus.onAdapterDisconnected(this, this.onZigbeeAdapterDisconnected);
         } catch (error) {
-            logger.error('Failed to start zigbee-herdsman');
+            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',
+                "Check https://www.zigbee2mqtt.io/guide/installation/20_zigbee2mqtt-fails-to-start_crashes-runtime.html for possible solutions",
             );
-            logger.error('Exiting...');
+            logger.error("Exiting...");
+            // biome-ignore lint/style/noNonNullAssertion: always Error
             logger.error((error as Error).stack!);
 
             /* 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');
+            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 */
 
@@ -164,8 +124,9 @@ export class Controller {
         for (const device of this.zigbee.devicesIterator(utils.deviceNotCoordinator)) {
             // `definition` validated by `isSupported`
             const model = device.isSupported
-                ? `${device.definition!.model} - ${device.definition!.vendor} ${device.definition!.description}`
-                : 'Not supported';
+                ? // 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++;
@@ -182,72 +143,173 @@ export class Controller {
             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 this.zigbee.devicesAndGroupsIterator()) {
                 if (this.state.exists(entity)) {
-                    await 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));
 
-        logger.info(`Zigbee2MQTT started!`);
+        logger.info("Zigbee2MQTT started!");
 
-        const watchdogInterval = this.sdNotify?.watchdogInterval() || 0;
-        if (watchdogInterval > 0) {
-            this.sdNotify?.startWatchdogMode(Math.floor(watchdogInterval / 2));
-        }
-        this.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 stop(restart = false): Promise<void> {
-        this.sdNotify?.stopping(process.pid);
+    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, code = 0): Promise<void> {
+        this.sdNotify?.notifyStopping();
+
+        let localCode = 0;
+        for (const extension of this.extensions) {
+            try {
+                await extension.stop();
+            } catch (error) {
+                logger.error(`Failed to stop '${extension.constructor.name}' (${(error as Error).stack})`);
+                localCode = 1;
+            }
+        }
 
-        // Call extensions
-        await this.callExtensions('stop', this.extensions);
         this.eventBus.removeListeners(this);
 
         // Wrap-up
         this.state.stop();
         await this.mqtt.disconnect();
-        let code = 0;
 
         try {
             await this.zigbee.stop();
-            logger.info('Stopped Zigbee2MQTT');
+            logger.info("Stopped Zigbee2MQTT");
         } catch (error) {
-            logger.error(`Failed to stop Zigbee2MQTT (${(error as Error).message})`);
-            code = 1;
+            logger.error(`Failed to stop Zigbee2MQTT (${(error as Error).stack})`);
+            localCode = 1;
         }
 
-        this.sdNotify?.stopWatchdogMode();
-        return await this.exit(code, restart);
+        this.sdNotify?.stop();
+        return await this.exit(code !== 0 ? code : localCode, restart);
     }
 
     async exit(code: number, restart = false): Promise<void> {
@@ -256,12 +318,12 @@ export class Controller {
     }
 
     @bind async onZigbeeAdapterDisconnected(): Promise<void> {
-        logger.error('Adapter disconnected, stopping');
-        await this.stop();
+        logger.error("Adapter disconnected, stopping");
+        await this.stop(false, 2);
     }
 
     @bind async publishEntityState(entity: Group | Device, payload: KeyValue, stateChangeReason?: StateChangeReason): Promise<void> {
-        let message: Zigbee2MQTTAPI['{friendlyName}'] = {...payload};
+        let message: Zigbee2MQTTAPI["{friendlyName}"] = {...payload};
 
         // Update state cache with new state.
         const newState = this.state.set(entity, payload, stateChangeReason);
@@ -271,14 +333,19 @@ export class Controller {
             message = newState;
         }
 
-        const options: IClientPublishOptions = {
-            retain: utils.getObjectProperty(entity.options, 'retain', false),
-            qos: utils.getObjectProperty(entity.options, 'qos', 0),
+        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<number | false>(entity.options, "retention", false);
 
         if (retention !== false) {
-            options.properties = {messageExpiryInterval: retention};
+            options.clientOptions.properties = {messageExpiryInterval: retention};
         }
 
         if (entity.isDevice() && settings.get().mqtt.include_device_information) {
@@ -299,13 +366,13 @@ export class Controller {
                 // Manufacturer name can contain \u0000, remove this.
                 // https://github.com/home-assistant/core/issues/85691
                 /* v8 ignore next */
-                manufacturerName: entity.zh.manufacturerName?.split('\u0000')[0],
+                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);
         }
 
@@ -323,11 +390,11 @@ export class Controller {
 
         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);
             }
         }
@@ -335,25 +402,25 @@ export class Controller {
         this.eventBus.emitPublishEntityState({entity, message, stateChangeReason, payload});
     }
 
-    async iteratePayloadAttributeOutput(topicRoot: string, payload: KeyValue, options: IClientPublishOptions): 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) {
@@ -361,14 +428,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) {
-                logger.error(`Failed to call '${extension.constructor.name}' '${method}' (${(error as Error).stack})`);
-            }
-        }
-    }
 }

lib/eventBus.ts

@@ -1,6 +1,6 @@
-import events from 'node:events';
+import events from "node:events";
 
-import logger from './util/logger';
+import logger from "./util/logger";
 
 type ListenerKey = object;
 
@@ -8,8 +8,8 @@ interface EventBusMap {
     adapterDisconnected: [];
     permitJoinChanged: [data: eventdata.PermitJoinChanged];
     publishAvailability: [];
-    deviceRenamed: [data: eventdata.EntityRenamed];
-    deviceRemoved: [data: eventdata.EntityRemoved];
+    entityRenamed: [data: eventdata.EntityRenamed];
+    entityRemoved: [data: eventdata.EntityRemoved];
     lastSeenChanged: [data: eventdata.LastSeenChanged];
     deviceNetworkAddressChanged: [data: eventdata.DeviceNetworkAddressChanged];
     deviceAnnounce: [data: eventdata.DeviceAnnounce];
@@ -34,159 +34,207 @@ type EventBusListener<K> = K extends keyof EventBusMap
         : never
     : never;
 
+type Stats = {
+    devices: Map<
+        string, // IEEE address
+        {
+            lastSeenChanges?: {messages: number; first: number};
+            leaveCounts: number;
+            networkAddressChanges: number;
+        }
+    >;
+    mqtt: {
+        published: number;
+        received: number;
+    };
+};
+
 export default class EventBus {
-    private callbacksByExtension: {[s: string]: {event: keyof EventBusMap; callback: EventBusListener<keyof EventBusMap>}[]} = {};
+    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);
+        this.on("permitJoinChanged", callback, key);
     }
 
     public emitEntityRenamed(data: eventdata.EntityRenamed): void {
-        this.emitter.emit('deviceRenamed', data);
+        this.emitter.emit("entityRenamed", data);
     }
     public onEntityRenamed(key: ListenerKey, callback: (data: eventdata.EntityRenamed) => void): void {
-        this.on('deviceRenamed', callback, key);
+        this.on("entityRenamed", callback, key);
     }
 
     public emitEntityRemoved(data: eventdata.EntityRemoved): void {
-        this.emitter.emit('deviceRemoved', data);
+        this.emitter.emit("entityRemoved", data);
     }
     public onEntityRemoved(key: ListenerKey, callback: (data: eventdata.EntityRemoved) => void): void {
-        this.on('deviceRemoved', callback, key);
+        this.on("entityRemoved", 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);
+        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);
     }
 
     public emitExposesAndDevicesChanged(device: Device): void {
@@ -195,8 +243,8 @@ export default class EventBus {
     }
 
     private on<K extends keyof EventBusMap>(event: K, callback: EventBusListener<K>, key: ListenerKey): void {
-        if (!this.callbacksByExtension[key.constructor.name]) {
-            this.callbacksByExtension[key.constructor.name] = [];
+        if (!this.callbacksByExtension.has(key.constructor.name)) {
+            this.callbacksByExtension.set(key.constructor.name, []);
         }
 
         const wrappedCallback = async (...args: never[]): Promise<void> => {
@@ -204,15 +252,23 @@ export default class EventBus {
                 await callback(...args);
             } catch (error) {
                 logger.error(`EventBus error '${key.constructor.name}/${event}': ${(error as Error).message}`);
+                // biome-ignore lint/style/noNonNullAssertion: always Error
                 logger.debug((error as Error).stack!);
             }
         };
 
-        this.callbacksByExtension[key.constructor.name].push({event, callback: 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);
+            }
+        }
     }
 }

lib/extension/availability.ts

@@ -1,67 +1,129 @@
-import type {Zigbee2MQTTAPI} from 'lib/types/api';
+import assert from "node:assert";
+import bind from "bind-decorator";
+import debounce from "debounce";
+import type * as zhc from "zigbee-herdsman-converters";
+import type {Zigbee2MQTTAPI} from "../types/api";
 
-import assert from 'node:assert';
-
-import bind from 'bind-decorator';
-import debounce from 'debounce';
-
-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';
+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'},
+    {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 type = this.isActiveDevice(device) ? 'active' : 'passive';
+        return utils.minutes(this.isActiveDevice(device) ? settings.get().availability.active.timeout : settings.get().availability.passive.timeout);
+    }
 
-        return utils.minutes(settings.get().availability[type].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()) {
-            return Date.now() - (entity.zh.lastSeen ?? /* v8 ignore next */ 0) < this.getTimeout(entity);
-        } else {
-            const membersDevices = entity.membersDevices();
-            return membersDevices.length === 0 || membersDevices.some((d) => this.availabilityCache[d.ieeeAddr]);
+            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): void {
-        clearTimeout(this.timers[device.ieeeAddr]);
+    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)) {
-            // 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));
+            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 {
-            this.timers[device.ieeeAddr] = setTimeout(() => this.publishAvailability(device, true), this.getTimeout(device) + utils.seconds(1));
+            this.timers.set(
+                device.ieeeAddr,
+                setTimeout(this.publishAvailability.bind(this, 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().catch(utils.noop);
@@ -69,7 +131,7 @@ export default class Availability extends Extension {
 
     private removeFromPingQueue(device: Device): void {
         const index = this.pingQueue.findIndex((d) => d.ieeeAddr === device.ieeeAddr);
-        if (index != -1) {
+        if (index !== -1) {
             this.pingQueue.splice(index, 1);
         }
     }
@@ -81,8 +143,8 @@ export default class Availability extends Extension {
 
         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 = 1; i <= attempts; i++) {
@@ -90,7 +152,7 @@ export default class Availability extends Extension {
                 // Enable recovery if device is marked as available and first ping fails.
                 await device.zh.ping(!available || i !== 2);
 
-                pingedSuccessfully = true;
+                pingSuccess = true;
 
                 logger.debug(`Successfully pinged '${device.name}' (attempt ${i}/${attempts})`);
                 break;
@@ -109,8 +171,21 @@ export default class Availability extends Extension {
             return;
         }
 
-        await 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
@@ -123,21 +198,21 @@ export default class Availability extends Extension {
 
     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, async (data) => {
             if (utils.isAvailabilityEnabledForEntity(data.entity, settings.get())) {
-                await this.mqtt.publish(`${data.from}/availability`, '', {retain: true, qos: 1});
+                await this.mqtt.publish(`${data.from}/availability`, "", {clientOptions: {retain: true, qos: 1}});
                 await this.publishAvailability(data.entity, false, true);
             }
         });
-
-        this.eventBus.onEntityRemoved(this, (data) => data.type == 'device' && clearTimeout(this.timers[data.id]));
-        this.eventBus.onDeviceLeave(this, (data) => clearTimeout(this.timers[data.ieeeAddr]));
+        this.eventBus.onEntityRemoved(this, (data) => data.entity.isDevice() && this.clearTimer(data.entity.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.onGroupMembersChanged(this, (data) => this.publishAvailability(data.group, false));
+
         // Publish initial availability
         await this.publishAvailabilityForAllEntities();
 
@@ -154,7 +229,7 @@ export default class Availability extends Extension {
         }
     }
 
-    @bind private async publishAvailabilityForAllEntities(): Promise<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);
@@ -175,19 +250,19 @@ export default class Availability extends Extension {
 
         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: Zigbee2MQTTAPI['{friendlyName}/availability'] = {state: available ? 'online' : 'offline'};
-        this.availabilityCache[entity.ID] = available;
-        await this.mqtt.publish(topic, JSON.stringify(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()) {
             for (const group of this.zigbee.groupsIterator()) {
@@ -202,7 +277,7 @@ export default class Availability extends Extension {
         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.resetTimer(data.device, true);
             await this.publishAvailability(data.device, false);
         }
     }
@@ -211,7 +286,7 @@ export default class Availability extends Extension {
         this.stopped = true;
         this.pingQueue = [];
 
-        for (const t of Object.values(this.timers)) {
+        for (const [, t] of this.timers) {
             clearTimeout(t);
         }
 
@@ -223,41 +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`);
+        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;
+                    // 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);
                     }
-
-                    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),
-                        mapped: device.definition!,
-                        endpoint_name: undefined,
-                        options,
-                        state,
-                        device: device.zh,
-                    };
-
-                    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));
+                }, utils.seconds(2)),
+            );
         }
 
-        this.retrieveStateDebouncers[device.ieeeAddr]?.();
+        this.retrieveStateDebouncers.get(device.ieeeAddr)?.();
     }
 }

lib/extension/bind.ts

@@ -1,46 +1,42 @@
-import type {Zigbee2MQTTAPI, Zigbee2MQTTResponseEndpoints} from 'lib/types/api';
+import assert from "node:assert";
+import bind from "bind-decorator";
+import debounce from "debounce";
+import stringify from "json-stable-stringify-without-jsonify";
+import {Zcl} from "zigbee-herdsman";
+import type {TClusterAttributeKeys} from "zigbee-herdsman/dist/zspec/zcl/definition/clusters-types";
+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, {DEFAULT_BIND_GROUP_ID} from "../util/utils";
+import Extension from "./extension";
 
-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 {ClusterName} from 'zigbee-herdsman/dist/zspec/zcl/definition/tstype';
-
-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 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',
+    "genScenes",
+    "genOnOff",
+    "genLevelCtrl",
+    "lightingColorCtrl",
+    "closuresWindowCovering",
+    "hvacThermostat",
+    "msIlluminanceMeasurement",
+    "msTemperatureMeasurement",
+    "msRelativeHumidity",
+    "msSoilMoisture",
+    "msCO2",
 ];
 
 // See zigbee-herdsman-converters
-const DEFAULT_BIND_GROUP = {type: 'group_number', ID: 901, name: 'default_bind_group'};
+const DEFAULT_BIND_GROUP = {type: "group_number", ID: DEFAULT_BIND_GROUP_ID, name: "default_bind_group"};
 const DEFAULT_REPORT_CONFIG = {minimumReportInterval: 5, maximumReportInterval: 3600, reportableChange: 1};
 
 const getColorCapabilities = async (endpoint: zh.Endpoint): Promise<{colorTemperature: boolean; colorXY: boolean}> => {
-    if (endpoint.getClusterAttributeValue('lightingColorCtrl', 'colorCapabilities') == null) {
-        await endpoint.read('lightingColorCtrl', ['colorCapabilities']);
+    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,
@@ -48,73 +44,53 @@ const getColorCapabilities = async (endpoint: zh.Endpoint): Promise<{colorTemper
     };
 };
 
-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}],
+const REPORT_CLUSTERS = {
+    genOnOff: [{attribute: "onOff" as const, ...DEFAULT_REPORT_CONFIG, minimumReportInterval: 0, reportableChange: 0}],
+    genLevelCtrl: [{attribute: "currentLevel" as const, ...DEFAULT_REPORT_CONFIG}],
     lightingColorCtrl: [
         {
-            attribute: 'colorTemperature',
+            attribute: "colorTemperature" as const,
             ...DEFAULT_REPORT_CONFIG,
-            condition: async (endpoint): Promise<boolean> => (await getColorCapabilities(endpoint)).colorTemperature,
+            condition: async (endpoint: zh.Endpoint): Promise<boolean> => (await getColorCapabilities(endpoint)).colorTemperature,
         },
         {
-            attribute: 'currentX',
+            attribute: "currentX" as const,
             ...DEFAULT_REPORT_CONFIG,
-            condition: async (endpoint): Promise<boolean> => (await getColorCapabilities(endpoint)).colorXY,
+            condition: async (endpoint: zh.Endpoint): Promise<boolean> => (await getColorCapabilities(endpoint)).colorXY,
         },
         {
-            attribute: 'currentY',
+            attribute: "currentY" as const,
             ...DEFAULT_REPORT_CONFIG,
-            condition: async (endpoint): Promise<boolean> => (await getColorCapabilities(endpoint)).colorXY,
+            condition: async (endpoint: zh.Endpoint): Promise<boolean> => (await getColorCapabilities(endpoint)).colorXY,
         },
     ],
     closuresWindowCovering: [
-        {attribute: 'currentPositionLiftPercentage', ...DEFAULT_REPORT_CONFIG},
-        {attribute: 'currentPositionTiltPercentage', ...DEFAULT_REPORT_CONFIG},
+        {attribute: "currentPositionLiftPercentage" as const, ...DEFAULT_REPORT_CONFIG},
+        {attribute: "currentPositionTiltPercentage" as const, ...DEFAULT_REPORT_CONFIG},
     ],
 };
 
-type PollOnMessage = {
-    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 POLL_ON_MESSAGE: Readonly<PollOnMessage> = [
+const POLL_ON_MESSAGE = [
     {
         // 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: {}},
+                {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: {}}],
+            genScenes: [{type: "commandRecall", data: {}}],
         },
         // Read the following attributes
-        read: {cluster: 'genLevelCtrl', attributes: ['currentLevel']},
+        read: {cluster: "genLevelCtrl" as const, attributes: ["currentLevel"] as TClusterAttributeKeys<"genLevelCtrl">},
         // When the bound devices/members of group have the following manufacturerIDs
         manufacturerIDs: [
             Zcl.ManufacturerCode.SIGNIFY_NETHERLANDS_B_V,
@@ -124,29 +100,29 @@ const POLL_ON_MESSAGE: Readonly<PollOnMessage> = [
             Zcl.ManufacturerCode.TELINK_MICRO,
             Zcl.ManufacturerCode.BUSCH_JAEGER_ELEKTRO,
         ],
-        manufacturerNames: ['GLEDOPTO', 'Trust International B.V.\u0000'],
+        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: {}},
+                {type: "commandOn", data: {}},
+                {type: "commandOff", data: {}},
+                {type: "commandOffWithEffect", data: {}},
+                {type: "commandToggle", data: {}},
             ],
-            genScenes: [{type: 'commandRecall', 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" as const, attributes: ["onOff"] as TClusterAttributeKeys<"genOnOff">},
         manufacturerIDs: [
             Zcl.ManufacturerCode.SIGNIFY_NETHERLANDS_B_V,
             Zcl.ManufacturerCode.ATMEL,
@@ -155,27 +131,27 @@ const POLL_ON_MESSAGE: Readonly<PollOnMessage> = [
             Zcl.ManufacturerCode.TELINK_MICRO,
             Zcl.ManufacturerCode.BUSCH_JAEGER_ELEKTRO,
         ],
-        manufacturerNames: ['GLEDOPTO', 'Trust International B.V.\u0000'],
+        manufacturerNames: ["GLEDOPTO", "Trust International B.V.\u0000"],
     },
     {
         cluster: {
-            genScenes: [{type: 'commandRecall', data: {}}],
+            genScenes: [{type: "commandRecall", data: {}}],
         },
         read: {
-            cluster: 'lightingColorCtrl',
-            attributes: [] as string[],
+            cluster: "lightingColorCtrl" as const,
+            attributes: [] as TClusterAttributeKeys<"lightingColorCtrl">,
             // 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[]> => {
+            attributesForEndpoint: async (endpoint: zh.Endpoint): Promise<TClusterAttributeKeys<"lightingColorCtrl">> => {
                 const supportedAttrs = await getColorCapabilities(endpoint);
-                const readAttrs: string[] = [];
+                const readAttrs: TClusterAttributeKeys<"lightingColorCtrl"> = [];
 
                 if (supportedAttrs.colorXY) {
-                    readAttrs.push('currentX', 'currentY');
+                    readAttrs.push("currentX", "currentY");
                 }
 
                 if (supportedAttrs.colorTemperature) {
-                    readAttrs.push('colorTemperature');
+                    readAttrs.push("colorTemperature");
                 }
 
                 return readAttrs;
@@ -189,15 +165,15 @@ const POLL_ON_MESSAGE: Readonly<PollOnMessage> = [
             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';
+    type: "bind" | "unbind";
     sourceKey?: string;
     sourceEndpointKey?: string | number;
-    targetKey?: string;
+    targetKey?: string | number;
     targetEndpointKey?: string | number;
     clusters?: string[];
     skipDisableReporting: boolean;
@@ -208,8 +184,10 @@ interface ParsedMQTTMessage {
 }
 
 export default class Bind extends Extension {
+    #topicRegex = new RegExp(`^${settings.get().mqtt.base_topic}/bridge/request/device/(bind|unbind|binds/clear)`);
     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);
@@ -219,28 +197,31 @@ export default class Bind extends Extension {
     private parseMQTTMessage(
         data: eventdata.MQTTMessage,
     ): [raw: KeyValue | undefined, parsed: ParsedMQTTMessage | undefined, error: string | undefined] {
-        if (data.topic.match(TOPIC_REGEX)) {
-            const type = data.topic.endsWith('unbind') ? 'unbind' : 'bind';
+        if (data.topic.match(this.#topicRegex)) {
+            const type = data.topic.endsWith("unbind") ? "unbind" : "bind";
             let skipDisableReporting = false;
-            const message = JSON.parse(data.message) as Zigbee2MQTTAPI['bridge/request/device/bind'];
+            const message = JSON.parse(data.message) as Zigbee2MQTTAPI["bridge/request/device/bind"];
 
-            if (typeof message !== 'object' || message.from == undefined || message.to == undefined) {
-                return [message, {type, skipDisableReporting}, `Invalid payload`];
+            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 sourceEndpointKey = message.from_endpoint ?? "default";
             const targetKey = message.to;
             const targetEndpointKey = message.to_endpoint;
             const clusters = message.clusters;
-            skipDisableReporting = message.skip_disable_reporting != undefined ? message.skip_disable_reporting : false;
+            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 ? DEFAULT_BIND_GROUP : this.zigbee.resolveEntity(message.to);
+            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`];
@@ -289,12 +270,42 @@ export default class Bind extends Extension {
                 },
                 undefined,
             ];
-        } else {
-            return [undefined, undefined, undefined];
         }
+
+        return [undefined, undefined, undefined];
     }
 
     @bind private async onMQTTMessage(data: eventdata.MQTTMessage): Promise<void> {
+        if (data.topic.endsWith("binds/clear")) {
+            const message = JSON.parse(data.message) as Zigbee2MQTTAPI["bridge/request/device/binds/clear"];
+
+            if (typeof message !== "object" || typeof message.target !== "string") {
+                await this.publishResponse("binds/clear", message, {}, "Invalid payload");
+                return;
+            }
+
+            const target = this.zigbee.resolveEntity(message.target);
+
+            if (!(target instanceof Device)) {
+                await this.publishResponse("binds/clear", message, {}, "Invalid target");
+                return;
+            }
+
+            // this list is raw (not resolved) to allow clearing any specific target (not only currently known)
+            const eui64List = message.ieee_list ?? ["0xffffffffffffffff"];
+
+            await target.zh.clearAllBindings(eui64List);
+
+            const responseData: Zigbee2MQTTAPI["bridge/response/device/binds/clear"] = {
+                target: message.target,
+                ieee_list: eui64List,
+            };
+
+            await this.publishResponse("binds/clear", message, responseData);
+            this.eventBus.emitDevicesChanged();
+            return;
+        }
+
         const [raw, parsed, error] = this.parseMQTTMessage(data);
 
         if (!raw || !parsed) {
@@ -320,10 +331,10 @@ export default class Bind extends Extension {
             resolvedBindTarget,
         } = parsed;
 
-        assert(resolvedSource, '`resolvedSource` is missing');
-        assert(resolvedTarget, '`resolvedTarget` is missing');
-        assert(resolvedSourceEndpoint, '`resolvedSourceEndpoint` is missing');
-        assert(resolvedBindTarget != undefined, '`resolvedBindTarget` is missing');
+        assert(resolvedSource, "`resolvedSource` is missing");
+        assert(resolvedTarget, "`resolvedTarget` is missing");
+        assert(resolvedSourceEndpoint, "`resolvedSourceEndpoint` is missing");
+        assert(resolvedBindTarget !== undefined, "`resolvedBindTarget` is missing");
 
         const successfulClusters: string[] = [];
         const failedClusters = [];
@@ -337,8 +348,8 @@ export default class Bind extends Extension {
 
             const anyClusterValid =
                 utils.isZHGroup(resolvedBindTarget) ||
-                typeof resolvedBindTarget === 'number' ||
-                (resolvedTarget instanceof Device && resolvedTarget.zh.type === 'Coordinator');
+                typeof resolvedBindTarget === "number" ||
+                (resolvedTarget instanceof Device && resolvedTarget.zh.type === "Coordinator");
 
             if (!anyClusterValid && utils.isZHEndpoint(resolvedBindTarget)) {
                 matchingClusters =
@@ -353,7 +364,7 @@ export default class Bind extends Extension {
                 attemptedClusters.push(cluster);
 
                 try {
-                    if (type === 'bind') {
+                    if (type === "bind") {
                         await resolvedSourceEndpoint.bind(cluster, resolvedBindTarget);
                     } else {
                         await resolvedSourceEndpoint.unbind(cluster, resolvedBindTarget);
@@ -361,7 +372,7 @@ export default class Bind extends Extension {
 
                     successfulClusters.push(cluster);
                     logger.info(
-                        `Successfully ${type === 'bind' ? 'bound' : 'unbound'} cluster '${cluster}' from '${resolvedSource.name}' to '${resolvedTarget.name}'`,
+                        `Successfully ${type === "bind" ? "bound" : "unbound"} cluster '${cluster}' from '${resolvedSource.name}' to '${resolvedTarget.name}'`,
                     );
                 } catch (error) {
                     failedClusters.push(cluster);
@@ -374,26 +385,31 @@ export default class Bind extends Extension {
             logger.error(`Nothing to ${type} from '${resolvedSource.name}' to '${resolvedTarget.name}'`);
             await this.publishResponse(parsed.type, raw, {}, `Nothing to ${type}`);
             return;
-        } else if (failedClusters.length === attemptedClusters.length) {
+        }
+
+        if (failedClusters.length === attemptedClusters.length) {
             await this.publishResponse(parsed.type, raw, {}, `Failed to ${type}`);
             return;
         }
 
-        const responseData: Zigbee2MQTTAPI['bridge/response/device/bind'] | Zigbee2MQTTAPI['bridge/response/device/unbind'] = {
-            from: sourceKey!, // valid with assert above on `resolvedSource`
-            from_endpoint: sourceEndpointKey!, // valid with assert above on `resolvedSourceEndpoint`
-            to: targetKey!, // valid with assert above on `resolvedTarget`
+        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,
         };
 
         if (successfulClusters.length !== 0) {
-            if (type === 'bind') {
+            if (type === "bind") {
                 await this.setupReporting(
                     resolvedSourceEndpoint.binds.filter((b) => successfulClusters.includes(b.cluster.name) && b.target === resolvedBindTarget),
                 );
-            } else if (typeof resolvedBindTarget !== 'number' && !skipDisableReporting) {
+            } else if (typeof resolvedBindTarget !== "number" && !skipDisableReporting) {
                 await this.disableUnnecessaryReportings(resolvedBindTarget);
             }
         }
@@ -403,7 +419,7 @@ export default class Bind extends Extension {
     }
 
     private async publishResponse<T extends Zigbee2MQTTResponseEndpoints>(
-        type: ParsedMQTTMessage['type'],
+        type: ParsedMQTTMessage["type"] | "binds/clear",
         request: KeyValue,
         data: Zigbee2MQTTAPI[T],
         error?: string,
@@ -417,7 +433,7 @@ export default class Bind extends Extension {
     }
 
     @bind async onGroupMembersChanged(data: eventdata.GroupMembersChanged): Promise<void> {
-        if (data.action === 'add') {
+        if (data.action === "add") {
             const bindsToGroup: zh.Bind[] = [];
 
             for (const device of this.zigbee.devicesIterator(utils.deviceNotCoordinator)) {
@@ -465,23 +481,25 @@ export default class Bind extends Extension {
         for (const bind of binds) {
             if (bind.cluster.name in REPORT_CLUSTERS) {
                 for (const endpoint of this.getSetupReportingEndpoints(bind, coordinatorEndpoint)) {
-                    const entity = `${this.zigbee.resolveEntity(endpoint.getDevice())!.name}/${endpoint.ID}`;
+                    // 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 = [];
 
-                        for (const c of REPORT_CLUSTERS[bind.cluster.name as ClusterName]!) {
-                            if (!c.condition || (await c.condition(endpoint))) {
-                                const i = {...c};
-                                delete i.condition;
+                        // biome-ignore lint/style/noNonNullAssertion: valid from outer `if`
+                        for (const c of REPORT_CLUSTERS[bind.cluster.name as keyof typeof REPORT_CLUSTERS]!) {
+                            if (!("condition" in c) || !c.condition || (await c.condition(endpoint))) {
+                                const {attribute, minimumReportInterval, maximumReportInterval, reportableChange} = c;
 
-                                items.push(i);
+                                items.push({attribute, minimumReportInterval, maximumReportInterval, reportableChange});
                             }
                         }
 
-                        await endpoint.configureReporting(bind.cluster.name, items);
+                        await endpoint.configureReporting(bind.cluster.name as keyof typeof REPORT_CLUSTERS, 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})`);
@@ -500,9 +518,7 @@ export default class Bind extends Extension {
 
         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);
-                }
+                allBinds.push(...endpoint.binds);
             }
         }
 
@@ -530,16 +546,16 @@ export default class Bind extends Extension {
 
                     const items = [];
 
-                    for (const item of REPORT_CLUSTERS[cluster as ClusterName]!) {
-                        if (!item.condition || (await item.condition(endpoint))) {
-                            const i = {...item};
-                            delete i.condition;
+                    // biome-ignore lint/style/noNonNullAssertion: valid from loop (pushed to array only if in)
+                    for (const item of REPORT_CLUSTERS[cluster as keyof typeof REPORT_CLUSTERS]!) {
+                        if (!("condition" in item) || !item.condition || (await item.condition(endpoint))) {
+                            const {attribute, minimumReportInterval, reportableChange} = item;
 
-                            items.push({...i, maximumReportInterval: 0xffff});
+                            items.push({attribute, minimumReportInterval, maximumReportInterval: 0xffff, reportableChange});
                         }
                     }
 
-                    await endpoint.configureReporting(cluster, items);
+                    await endpoint.configureReporting(cluster as keyof typeof REPORT_CLUSTERS, items);
                     logger.info(`Successfully disabled reporting for '${entity}' cluster '${cluster}'`);
                 } catch (error) {
                     logger.warning(`Failed to disable reporting for '${entity}' cluster '${cluster}' (${(error as Error).message})`);
@@ -560,35 +576,37 @@ export default class Bind extends Extension {
          * When we receive a message from a Hue dimmer we read the brightness from the bulb (if bound).
          */
         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)),
+            p.cluster[data.cluster as keyof (typeof p)["cluster"]]?.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.isZHEndpoint(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 (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);
+                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) {
-                    // XXX: manufacturerID/manufacturerName can be undefined and won't match `includes`, but TS enforces same-type
                     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)
                     ) {
@@ -609,9 +627,9 @@ export default class Bind extends Extension {
                             try {
                                 await endpoint.read(poll.read.cluster, readAttrs);
                             } catch (error) {
-                                logger.error(
-                                    `Failed to poll ${readAttrs} from ${this.zigbee.resolveEntity(device)!.name} (${(error as Error).message})`,
-                                );
+                                // 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);
                     }

lib/extension/bridge.ts

@@ -1,28 +1,26 @@
-import type {Zigbee2MQTTAPI, Zigbee2MQTTDevice, Zigbee2MQTTResponse, Zigbee2MQTTResponseEndpoints} from 'lib/types/api';
-
-import fs from 'node:fs';
-
-import bind from 'bind-decorator';
-import stringify from 'json-stable-stringify-without-jsonify';
-import JSZip from 'jszip';
-import objectAssignDeep from 'object-assign-deep';
-import winston from 'winston';
-import Transport from 'winston-transport';
-
-import {Zcl} from 'zigbee-herdsman';
-import * as zhc from 'zigbee-herdsman-converters';
-
-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';
-import Extension from './extension';
-
-const REQUEST_REGEX = new RegExp(`${settings.get().mqtt.base_topic}/bridge/request/(.*)`);
+import fs from "node:fs";
+import bind from "bind-decorator";
+import stringify from "json-stable-stringify-without-jsonify";
+import JSZip from "jszip";
+import objectAssignDeep from "object-assign-deep";
+import type winston from "winston";
+import Transport from "winston-transport";
+import {Zcl} from "zigbee-herdsman";
+import {InterviewState} from "zigbee-herdsman/dist/controller/model/device";
+import * as zhc from "zigbee-herdsman-converters";
+import Device from "../model/device";
+import type Group from "../model/group";
+import type {Zigbee2MQTTAPI, Zigbee2MQTTDevice, Zigbee2MQTTResponse, Zigbee2MQTTResponseEndpoints} from "../types/api";
+import data from "../util/data";
+import logger from "../util/logger";
+import * as settings from "../util/settings";
+import utils, {assertString, DEFAULT_BIND_GROUP_ID} from "../util/utils";
+import Extension from "./extension";
 
 export default class Bridge extends Extension {
+    #requestRegex = new RegExp(`${settings.get().mqtt.base_topic}/bridge/request/(.*)`);
+    // set on `start`
+    #osInfo!: Zigbee2MQTTAPI["bridge/info"]["os"];
     private zigbee2mqttVersion!: {commitHash?: string; version: string};
     private zigbeeHerdsmanVersion!: {version: string};
     private zigbeeHerdsmanConvertersVersion!: {version: string};
@@ -32,38 +30,41 @@ export default class Bridge extends Extension {
     private lastBridgeLoggingPayload?: string;
     private logTransport!: winston.transport;
     private requestLookup: {[key: string]: (message: KeyValue | string) => Promise<Zigbee2MQTTResponse<Zigbee2MQTTResponseEndpoints>>} = {
-        'device/options': this.deviceOptions,
-        'device/configure_reporting': this.deviceConfigureReporting,
-        'device/remove': this.deviceRemove,
-        'device/interview': this.deviceInterview,
-        'device/generate_external_definition': this.deviceGenerateExternalDefinition,
-        'device/rename': this.deviceRename,
-        'group/add': this.groupAdd,
-        'group/options': this.groupOptions,
-        'group/remove': this.groupRemove,
-        'group/rename': this.groupRename,
+        "device/options": this.deviceOptions,
+        /** @deprecated 3.0 */
+        "device/configure_reporting": this.deviceReportingConfigure,
+        "device/reporting/configure": this.deviceReportingConfigure,
+        "device/reporting/read": this.deviceReportingRead,
+        "device/remove": this.deviceRemove,
+        "device/interview": this.deviceInterview,
+        "device/generate_external_definition": this.deviceGenerateExternalDefinition,
+        "device/rename": this.deviceRename,
+        "group/add": this.groupAdd,
+        "group/options": this.groupOptions,
+        "group/remove": this.groupRemove,
+        "group/rename": this.groupRename,
         permit_join: this.permitJoin,
         restart: this.restart,
         backup: this.backup,
-        'touchlink/factory_reset': this.touchlinkFactoryReset,
-        'touchlink/identify': this.touchlinkIdentify,
-        'install_code/add': this.installCodeAdd,
-        'touchlink/scan': this.touchlinkScan,
+        "touchlink/factory_reset": this.touchlinkFactoryReset,
+        "touchlink/identify": this.touchlinkIdentify,
+        "install_code/add": this.installCodeAdd,
+        "touchlink/scan": this.touchlinkScan,
         health_check: this.healthCheck,
         coordinator_check: this.coordinatorCheck,
         options: this.bridgeOptions,
+        action: this.action,
     };
 
     override async start(): Promise<void> {
         const debugToMQTTFrontend = settings.get().advanced.log_debug_to_mqtt_frontend;
-        const baseTopic = settings.get().mqtt.base_topic;
 
         const bridgeLogging = (message: string, level: string, namespace: string): void => {
             const payload = stringify({message, level, namespace});
 
             if (payload !== this.lastBridgeLoggingPayload) {
                 this.lastBridgeLoggingPayload = payload;
-                void this.mqtt.publish(`bridge/logging`, payload, {}, baseTopic, true);
+                void this.mqtt.publish("bridge/logging", payload, {skipLog: true});
             }
         };
 
@@ -79,7 +80,7 @@ export default class Bridge extends Extension {
         } else {
             class EventTransport extends Transport {
                 override log(info: {message: string; level: string; namespace: string}, next: () => void): void {
-                    if (info.level !== 'debug') {
+                    if (info.level !== "debug") {
                         bridgeLogging(info.message, info.level, info.namespace);
                     }
                     next();
@@ -91,9 +92,18 @@ export default class Bridge extends Extension {
 
         logger.addTransport(this.logTransport);
 
+        const os = await import("node:os");
+        const process = await import("node:process");
+        const logicalCpuCores = os.cpus();
+        this.#osInfo = {
+            version: `${os.version()} - ${os.release()} - ${os.arch()}`,
+            node_version: process.version,
+            cpus: `${[...new Set(logicalCpuCores.map((cpu) => cpu.model))].join(" | ")} (x${logicalCpuCores.length})`,
+            memory_mb: Math.round(os.totalmem() / 1024 / 1024),
+        };
         this.zigbee2mqttVersion = await utils.getZigbee2MQTTVersion();
-        this.zigbeeHerdsmanVersion = await utils.getDependencyVersion('zigbee-herdsman');
-        this.zigbeeHerdsmanConvertersVersion = await utils.getDependencyVersion('zigbee-herdsman-converters');
+        this.zigbeeHerdsmanVersion = await utils.getDependencyVersion("zigbee-herdsman");
+        this.zigbeeHerdsmanConvertersVersion = await utils.getDependencyVersion("zigbee-herdsman-converters");
         this.coordinatorVersion = await this.zigbee.getCoordinatorVersion();
 
         this.eventBus.onEntityRenamed(this, async () => {
@@ -122,20 +132,20 @@ export default class Bridge extends Extension {
             this.lastJoinedDeviceIeeeAddr = data.device.ieeeAddr;
             await this.publishDevices();
 
-            const payload: Zigbee2MQTTAPI['bridge/event'] = {
-                type: 'device_joined',
+            const payload: Zigbee2MQTTAPI["bridge/event"] = {
+                type: "device_joined",
                 data: {friendly_name: data.device.name, ieee_address: data.device.ieeeAddr},
             };
 
-            await this.mqtt.publish('bridge/event', stringify(payload), {retain: false, qos: 0});
+            await this.mqtt.publish("bridge/event", stringify(payload));
         });
         this.eventBus.onDeviceLeave(this, async (data) => {
             await this.publishDevices();
             await this.publishDefinitions();
 
-            const payload: Zigbee2MQTTAPI['bridge/event'] = {type: 'device_leave', data: {ieee_address: data.ieeeAddr, friendly_name: data.name}};
+            const payload: Zigbee2MQTTAPI["bridge/event"] = {type: "device_leave", data: {ieee_address: data.ieeeAddr, friendly_name: data.name}};
 
-            await this.mqtt.publish('bridge/event', stringify(payload), {retain: false, qos: 0});
+            await this.mqtt.publish("bridge/event", stringify(payload));
         });
         this.eventBus.onDeviceNetworkAddressChanged(this, async () => {
             await this.publishDevices();
@@ -143,11 +153,11 @@ export default class Bridge extends Extension {
         this.eventBus.onDeviceInterview(this, async (data) => {
             await this.publishDevices();
 
-            let payload: Zigbee2MQTTAPI['bridge/event'];
+            let payload: Zigbee2MQTTAPI["bridge/event"];
 
-            if (data.status === 'successful') {
+            if (data.status === "successful") {
                 payload = {
-                    type: 'device_interview',
+                    type: "device_interview",
                     data: {
                         friendly_name: data.device.name,
                         status: data.status,
@@ -158,22 +168,22 @@ export default class Bridge extends Extension {
                 };
             } else {
                 payload = {
-                    type: 'device_interview',
+                    type: "device_interview",
                     data: {friendly_name: data.device.name, status: data.status, ieee_address: data.device.ieeeAddr},
                 };
             }
 
-            await this.mqtt.publish('bridge/event', stringify(payload), {retain: false, qos: 0});
+            await this.mqtt.publish("bridge/event", stringify(payload));
         });
         this.eventBus.onDeviceAnnounce(this, async (data) => {
             await this.publishDevices();
 
-            const payload: Zigbee2MQTTAPI['bridge/event'] = {
-                type: 'device_announce',
+            const payload: Zigbee2MQTTAPI["bridge/event"] = {
+                type: "device_announce",
                 data: {friendly_name: data.device.name, ieee_address: data.device.ieeeAddr},
             };
 
-            await this.mqtt.publish('bridge/event', stringify(payload), {retain: false, qos: 0});
+            await this.mqtt.publish("bridge/event", stringify(payload));
         });
 
         await this.publishInfo();
@@ -190,7 +200,7 @@ export default class Bridge extends Extension {
     }
 
     @bind async onMQTTMessage(data: eventdata.MQTTMessage): Promise<void> {
-        const match = data.topic.match(REQUEST_REGEX);
+        const match = data.topic.match(this.#requestRegex);
 
         if (!match) {
             return;
@@ -206,6 +216,7 @@ export default class Bridge extends Extension {
                 await this.mqtt.publish(`bridge/response/${match[1]}`, stringify(response));
             } catch (error) {
                 logger.error(`Request '${data.topic}' failed with error: '${(error as Error).message}'`);
+                // biome-ignore lint/style/noNonNullAssertion: always using Error
                 logger.debug((error as Error).stack!);
                 const response = utils.getResponse(message, {}, (error as Error).message);
                 await this.mqtt.publish(`bridge/response/${match[1]}`, stringify(response));
@@ -217,17 +228,17 @@ export default class Bridge extends Extension {
      * Requests
      */
 
-    @bind async deviceOptions(message: KeyValue | string): Promise<Zigbee2MQTTResponse<'bridge/response/device/options'>> {
-        return await this.changeEntityOptions('device', message);
+    @bind async deviceOptions(message: KeyValue | string): Promise<Zigbee2MQTTResponse<"bridge/response/device/options">> {
+        return await this.changeEntityOptions("device", message);
     }
 
-    @bind async groupOptions(message: KeyValue | string): Promise<Zigbee2MQTTResponse<'bridge/response/group/options'>> {
-        return await this.changeEntityOptions('group', message);
+    @bind async groupOptions(message: KeyValue | string): Promise<Zigbee2MQTTResponse<"bridge/response/group/options">> {
+        return await this.changeEntityOptions("group", message);
     }
 
-    @bind async bridgeOptions(message: KeyValue | string): Promise<Zigbee2MQTTResponse<'bridge/response/options'>> {
-        if (typeof message !== 'object' || typeof message.options !== 'object') {
-            throw new Error(`Invalid payload`);
+    @bind async bridgeOptions(message: KeyValue | string): Promise<Zigbee2MQTTResponse<"bridge/response/options">> {
+        if (typeof message !== "object" || typeof message.options !== "object") {
+            throw new Error("Invalid payload");
         }
 
         const newSettings = message.options as Partial<Settings>;
@@ -235,39 +246,40 @@ export default class Bridge extends Extension {
 
         // Apply some settings on-the-fly.
         if (newSettings.homeassistant) {
-            await this.enableDisableExtension(settings.get().homeassistant.enabled, 'HomeAssistant');
+            await this.enableDisableExtension(settings.get().homeassistant.enabled, "HomeAssistant");
         }
 
-        if (newSettings.advanced?.log_level != undefined) {
+        if (newSettings.advanced?.log_level != null) {
             logger.setLevel(settings.get().advanced.log_level);
         }
 
-        if (newSettings.advanced?.log_namespaced_levels != undefined) {
+        if (newSettings.advanced?.log_namespaced_levels != null) {
             logger.setNamespacedLevels(settings.get().advanced.log_namespaced_levels);
         }
 
-        if (newSettings.advanced?.log_debug_namespace_ignore != undefined) {
+        if (newSettings.advanced?.log_debug_namespace_ignore != null) {
             logger.setDebugNamespaceIgnore(settings.get().advanced.log_debug_namespace_ignore);
         }
 
-        logger.info('Successfully changed options');
+        logger.info("Successfully changed options");
         await this.publishInfo();
         return utils.getResponse(message, {restart_required: this.restartRequired});
     }
 
-    @bind async deviceRemove(message: string | KeyValue): Promise<Zigbee2MQTTResponse<'bridge/response/device/remove'>> {
-        return await this.removeEntity('device', message);
+    @bind async deviceRemove(message: string | KeyValue): Promise<Zigbee2MQTTResponse<"bridge/response/device/remove">> {
+        return await this.removeEntity("device", message);
     }
 
-    @bind async groupRemove(message: string | KeyValue): Promise<Zigbee2MQTTResponse<'bridge/response/group/remove'>> {
-        return await this.removeEntity('group', message);
+    @bind async groupRemove(message: string | KeyValue): Promise<Zigbee2MQTTResponse<"bridge/response/group/remove">> {
+        return await this.removeEntity("group", message);
     }
 
-    @bind async healthCheck(message: string | KeyValue): Promise<Zigbee2MQTTResponse<'bridge/response/health_check'>> {
+    // biome-ignore lint/suspicious/useAwait: API
+    @bind async healthCheck(message: string | KeyValue): Promise<Zigbee2MQTTResponse<"bridge/response/health_check">> {
         return utils.getResponse(message, {healthy: true});
     }
 
-    @bind async coordinatorCheck(message: string | KeyValue): Promise<Zigbee2MQTTResponse<'bridge/response/coordinator_check'>> {
+    @bind async coordinatorCheck(message: string | KeyValue): Promise<Zigbee2MQTTResponse<"bridge/response/coordinator_check">> {
         const result = await this.zigbee.coordinatorCheck();
         const missingRouters = result.missingRouters.map((d) => {
             return {ieee_address: d.ieeeAddr, friendly_name: d.name};
@@ -275,65 +287,70 @@ export default class Bridge extends Extension {
         return utils.getResponse(message, {missing_routers: missingRouters});
     }
 
-    @bind async groupAdd(message: string | KeyValue): Promise<Zigbee2MQTTResponse<'bridge/response/group/add'>> {
-        if (typeof message === 'object' && message.friendly_name === undefined) {
-            throw new Error(`Invalid payload`);
+    @bind async groupAdd(message: string | KeyValue): Promise<Zigbee2MQTTResponse<"bridge/response/group/add">> {
+        if (typeof message === "object" && message.friendly_name === undefined) {
+            throw new Error("Invalid payload");
         }
 
-        const friendlyName = typeof message === 'object' ? message.friendly_name : message;
-        const ID = typeof message === 'object' && message.id !== undefined ? message.id : null;
+        const friendlyName = typeof message === "object" ? message.friendly_name : message;
+        const ID = typeof message === "object" && message.id !== undefined ? message.id : null;
         const group = settings.addGroup(friendlyName, ID);
         this.zigbee.createGroup(group.ID);
         await this.publishGroups();
         return utils.getResponse(message, {friendly_name: group.friendly_name, id: group.ID});
     }
 
-    @bind async deviceRename(message: string | KeyValue): Promise<Zigbee2MQTTResponse<'bridge/response/device/rename'>> {
-        return await this.renameEntity('device', message);
+    @bind async deviceRename(message: string | KeyValue): Promise<Zigbee2MQTTResponse<"bridge/response/device/rename">> {
+        return await this.renameEntity("device", message);
     }
 
-    @bind async groupRename(message: string | KeyValue): Promise<Zigbee2MQTTResponse<'bridge/response/group/rename'>> {
-        return await this.renameEntity('group', message);
+    @bind async groupRename(message: string | KeyValue): Promise<Zigbee2MQTTResponse<"bridge/response/group/rename">> {
+        return await this.renameEntity("group", message);
     }
 
-    @bind async restart(message: string | KeyValue): Promise<Zigbee2MQTTResponse<'bridge/response/restart'>> {
+    // biome-ignore lint/suspicious/useAwait: API
+    @bind async restart(message: string | KeyValue): Promise<Zigbee2MQTTResponse<"bridge/response/restart">> {
         // Wait 500 ms before restarting so response can be send.
         setTimeout(this.restartCallback, 500);
-        logger.info('Restarting Zigbee2MQTT');
+        logger.info("Restarting Zigbee2MQTT");
         return utils.getResponse(message, {});
     }
 
-    @bind async backup(message: string | KeyValue): Promise<Zigbee2MQTTResponse<'bridge/response/backup'>> {
+    @bind async backup(message: string | KeyValue): Promise<Zigbee2MQTTResponse<"bridge/response/backup">> {
         await this.zigbee.backup();
         const dataPath = data.getPath();
         const files = utils
             .getAllFiles(dataPath)
             .map((f) => [f, f.substring(dataPath.length + 1)])
-            .filter((f) => !f[1].startsWith('log'));
+            .filter((f) => !f[1].startsWith("log"));
         const zip = new JSZip();
-        files.forEach((f) => zip.file(f[1], fs.readFileSync(f[0])));
-        const base64Zip = await zip.generateAsync({type: 'base64'});
+
+        for (const f of files) {
+            zip.file(f[1], fs.readFileSync(f[0]));
+        }
+
+        const base64Zip = await zip.generateAsync({type: "base64"});
         return utils.getResponse(message, {zip: base64Zip});
     }
 
-    @bind async installCodeAdd(message: KeyValue | string): Promise<Zigbee2MQTTResponse<'bridge/response/install_code/add'>> {
-        if (typeof message === 'object' && message.value === undefined) {
-            throw new Error('Invalid payload');
+    @bind async installCodeAdd(message: KeyValue | string): Promise<Zigbee2MQTTResponse<"bridge/response/install_code/add">> {
+        if (typeof message === "object" && message.value === undefined) {
+            throw new Error("Invalid payload");
         }
 
-        const value = typeof message === 'object' ? message.value : message;
+        const value = typeof message === "object" ? message.value : message;
         await this.zigbee.addInstallCode(value);
-        logger.info('Successfully added new install code');
+        logger.info("Successfully added new install code");
         return utils.getResponse(message, {value});
     }
 
-    @bind async permitJoin(message: KeyValue | string): Promise<Zigbee2MQTTResponse<'bridge/response/permit_join'>> {
+    @bind async permitJoin(message: KeyValue | string): Promise<Zigbee2MQTTResponse<"bridge/response/permit_join">> {
         let time: number | undefined;
         let device: Device | undefined;
 
-        if (typeof message === 'object') {
+        if (typeof message === "object") {
             if (message.time === undefined) {
-                throw new Error('Invalid payload');
+                throw new Error("Invalid payload");
             }
 
             time = Number.parseInt(message.time, 10);
@@ -362,9 +379,9 @@ export default class Bridge extends Extension {
         return utils.getResponse(message, response);
     }
 
-    @bind async touchlinkIdentify(message: KeyValue | string): Promise<Zigbee2MQTTResponse<'bridge/response/touchlink/identify'>> {
-        if (typeof message !== 'object' || message.ieee_address === undefined || message.channel === undefined) {
-            throw new Error('Invalid payload');
+    @bind async touchlinkIdentify(message: KeyValue | string): Promise<Zigbee2MQTTResponse<"bridge/response/touchlink/identify">> {
+        if (typeof message !== "object" || message.ieee_address === undefined || message.channel === undefined) {
+            throw new Error("Invalid payload");
         }
 
         logger.info(`Start Touchlink identify of '${message.ieee_address}' on channel ${message.channel}`);
@@ -372,11 +389,11 @@ export default class Bridge extends Extension {
         return utils.getResponse(message, {ieee_address: message.ieee_address, channel: message.channel});
     }
 
-    @bind async touchlinkFactoryReset(message: KeyValue | string): Promise<Zigbee2MQTTResponse<'bridge/response/touchlink/factory_reset'>> {
+    @bind async touchlinkFactoryReset(message: KeyValue | string): Promise<Zigbee2MQTTResponse<"bridge/response/touchlink/factory_reset">> {
         let result = false;
-        let payload: Zigbee2MQTTAPI['bridge/response/touchlink/factory_reset'] = {};
+        let payload: Zigbee2MQTTAPI["bridge/response/touchlink/factory_reset"] = {};
 
-        if (typeof message === 'object' && message.ieee_address !== undefined && message.channel !== undefined) {
+        if (typeof message === "object" && message.ieee_address !== undefined && message.channel !== undefined) {
             logger.info(`Start Touchlink factory reset of '${message.ieee_address}' on channel ${message.channel}`);
 
             result = await this.zigbee.touchlinkFactoryReset(message.ieee_address, message.channel);
@@ -385,26 +402,26 @@ export default class Bridge extends Extension {
                 channel: message.channel,
             };
         } else {
-            logger.info('Start Touchlink factory reset of first found device');
+            logger.info("Start Touchlink factory reset of first found device");
             result = await this.zigbee.touchlinkFactoryResetFirst();
         }
 
         if (result) {
-            logger.info('Successfully factory reset device through Touchlink');
+            logger.info("Successfully factory reset device through Touchlink");
             return utils.getResponse(message, payload);
-        } else {
-            logger.error('Failed to factory reset device through Touchlink');
-            throw new Error('Failed to factory reset device through Touchlink');
         }
+
+        logger.error("Failed to factory reset device through Touchlink");
+        throw new Error("Failed to factory reset device through Touchlink");
     }
 
-    @bind async touchlinkScan(message: KeyValue | string): Promise<Zigbee2MQTTResponse<'bridge/response/touchlink/scan'>> {
-        logger.info('Start Touchlink scan');
+    @bind async touchlinkScan(message: KeyValue | string): Promise<Zigbee2MQTTResponse<"bridge/response/touchlink/scan">> {
+        logger.info("Start Touchlink scan");
         const result = await this.zigbee.touchlinkScan();
         const found = result.map((r) => {
             return {ieee_address: r.ieeeAddr, channel: r.channel};
         });
-        logger.info('Finished Touchlink scan');
+        logger.info("Finished Touchlink scan");
         return utils.getResponse(message, {found});
     }
 
@@ -412,12 +429,12 @@ export default class Bridge extends Extension {
      * Utils
      */
 
-    async changeEntityOptions<T extends 'device' | 'group'>(
+    async changeEntityOptions<T extends "device" | "group">(
         entityType: T,
         message: KeyValue | string,
-    ): Promise<Zigbee2MQTTResponse<T extends 'device' ? 'bridge/response/device/options' : 'bridge/response/group/options'>> {
-        if (typeof message !== 'object' || message.id === undefined || message.options === undefined) {
-            throw new Error(`Invalid payload`);
+    ): Promise<Zigbee2MQTTResponse<T extends "device" ? "bridge/response/device/options" : "bridge/response/group/options">> {
+        if (typeof message !== "object" || message.id === undefined || message.options === undefined) {
+            throw new Error("Invalid payload");
         }
 
         const cleanup = (o: KeyValue): KeyValue => {
@@ -453,21 +470,21 @@ export default class Bridge extends Extension {
         return utils.getResponse(message, {from: oldOptions, to: newOptions, id: ID, restart_required: this.restartRequired});
     }
 
-    @bind async deviceConfigureReporting(message: string | KeyValue): Promise<Zigbee2MQTTResponse<'bridge/response/device/configure_reporting'>> {
+    @bind async deviceReportingConfigure(message: string | KeyValue): Promise<Zigbee2MQTTResponse<"bridge/response/device/reporting/configure">> {
         if (
-            typeof message !== 'object' ||
+            typeof message !== "object" ||
             message.id === undefined ||
             message.endpoint === undefined ||
             message.cluster === undefined ||
-            message.maximum_report_interval === undefined ||
-            message.minimum_report_interval === undefined ||
-            message.reportable_change === undefined ||
-            message.attribute === undefined
+            message.attribute === undefined ||
+            typeof message.maximum_report_interval !== "number" ||
+            typeof message.minimum_report_interval !== "number" ||
+            (message.reportable_change !== undefined && typeof message.reportable_change !== "number")
         ) {
-            throw new Error(`Invalid payload`);
+            throw new Error("Invalid payload");
         }
 
-        const device = this.getEntity('device', message.id);
+        const device = this.getEntity("device", message.id);
         const endpoint = device.endpoint(message.endpoint);
 
         if (!endpoint) {
@@ -505,12 +522,52 @@ export default class Bridge extends Extension {
         });
     }
 
-    @bind async deviceInterview(message: string | KeyValue): Promise<Zigbee2MQTTResponse<'bridge/response/device/interview'>> {
-        if (typeof message !== 'object' || message.id === undefined) {
-            throw new Error(`Invalid payload`);
+    @bind async deviceReportingRead(message: string | KeyValue): Promise<Zigbee2MQTTResponse<"bridge/response/device/reporting/read">> {
+        if (
+            typeof message !== "object" ||
+            message.id === undefined ||
+            message.endpoint === undefined ||
+            message.cluster === undefined ||
+            message.configs === undefined
+        ) {
+            throw new Error("Invalid payload");
         }
 
-        const device = this.getEntity('device', message.id);
+        const device = this.getEntity("device", message.id);
+        const endpoint = device.endpoint(message.endpoint);
+
+        if (!endpoint) {
+            throw new Error(`Device '${device.ID}' does not have endpoint '${message.endpoint}'`);
+        }
+
+        const response = await endpoint.readReportingConfig(
+            message.cluster,
+            message.configs,
+            message.manufacturer_code ? {manufacturerCode: message.manufacturer_code} : {},
+        );
+
+        await this.publishDevices();
+
+        const responseData: Zigbee2MQTTAPI["bridge/response/device/reporting/read"] = {
+            id: message.id,
+            endpoint: message.endpoint,
+            cluster: message.cluster,
+            configs: response,
+        };
+
+        if (message.manufacturer_code) {
+            responseData.manufacturer_code = message.manufacturer_code;
+        }
+
+        return utils.getResponse(message, responseData);
+    }
+
+    @bind async deviceInterview(message: string | KeyValue): Promise<Zigbee2MQTTResponse<"bridge/response/device/interview">> {
+        if (typeof message !== "object" || message.id === undefined) {
+            throw new Error("Invalid payload");
+        }
+
+        const device = this.getEntity("device", message.id);
         logger.info(`Interviewing '${device.name}'`);
 
         try {
@@ -530,33 +587,50 @@ export default class Bridge extends Extension {
 
     @bind async deviceGenerateExternalDefinition(
         message: string | KeyValue,
-    ): Promise<Zigbee2MQTTResponse<'bridge/response/device/generate_external_definition'>> {
-        if (typeof message !== 'object' || message.id === undefined) {
-            throw new Error(`Invalid payload`);
+    ): Promise<Zigbee2MQTTResponse<"bridge/response/device/generate_external_definition">> {
+        if (typeof message !== "object" || message.id === undefined) {
+            throw new Error("Invalid payload");
         }
 
-        const device = this.getEntity('device', message.id);
+        const device = this.getEntity("device", message.id);
         const source = await zhc.generateExternalDefinitionSource(device.zh);
 
         return utils.getResponse(message, {id: message.id, source});
     }
 
-    async renameEntity<T extends 'device' | 'group'>(
+    @bind async action(message: string | KeyValue): Promise<Zigbee2MQTTResponse<"bridge/response/action">> {
+        if (typeof message !== "object" || !message.action) {
+            throw new Error("Invalid payload");
+        }
+
+        const action = zhc.ACTIONS[message.action];
+
+        if (action === undefined) {
+            throw new Error("Invalid action");
+        }
+
+        const response = await action(this.zigbee.zhController, message.params ?? {});
+
+        return utils.getResponse(message, response);
+    }
+
+    async renameEntity<T extends "device" | "group">(
         entityType: T,
         message: string | KeyValue,
-    ): Promise<Zigbee2MQTTResponse<T extends 'device' ? 'bridge/response/device/rename' : 'bridge/response/group/rename'>> {
-        const deviceAndHasLast = entityType === 'device' && typeof message === 'object' && message.last === true;
+    ): Promise<Zigbee2MQTTResponse<T extends "device" ? "bridge/response/device/rename" : "bridge/response/group/rename">> {
+        const deviceAndHasLast = entityType === "device" && typeof message === "object" && message.last === true;
 
-        if (typeof message !== 'object' || (message.from === undefined && !deviceAndHasLast) || message.to === undefined) {
-            throw new Error(`Invalid payload`);
+        if (typeof message !== "object" || (message.from === undefined && !deviceAndHasLast) || message.to === undefined) {
+            throw new Error("Invalid payload");
         }
 
         if (deviceAndHasLast && !this.lastJoinedDeviceIeeeAddr) {
-            throw new Error('No device has joined since start');
+            throw new Error("No device has joined since start");
         }
 
         const from = deviceAndHasLast ? this.lastJoinedDeviceIeeeAddr : message.from;
-        const to = message.to;
+        assertString(message.to, "to");
+        const to = message.to.trim();
         const homeAssisantRename = message.homeassistant_rename !== undefined ? message.homeassistant_rename : false;
         const entity = this.getEntity(entityType, from);
         const oldFriendlyName = entity.options.friendly_name;
@@ -564,7 +638,7 @@ export default class Bridge extends Extension {
         settings.changeFriendlyName(from, to);
 
         // Clear retained messages
-        await this.mqtt.publish(oldFriendlyName, '', {retain: true});
+        await this.mqtt.publish(oldFriendlyName, "", {clientOptions: {retain: true}});
 
         this.eventBus.emitEntityRenamed({entity: entity, homeAssisantRename, from: oldFriendlyName, to});
 
@@ -581,31 +655,29 @@ export default class Bridge extends Extension {
         return utils.getResponse(message, {from: oldFriendlyName, to, homeassistant_rename: homeAssisantRename});
     }
 
-    async removeEntity<T extends 'device' | 'group'>(
+    async removeEntity<T extends "device" | "group">(
         entityType: T,
         message: string | KeyValue,
-    ): Promise<Zigbee2MQTTResponse<T extends 'device' ? 'bridge/response/device/remove' : 'bridge/response/group/remove'>> {
-        const ID = typeof message === 'object' ? message.id : message.trim();
+    ): Promise<Zigbee2MQTTResponse<T extends "device" ? "bridge/response/device/remove" : "bridge/response/group/remove">> {
+        const ID = typeof message === "object" ? message.id : message.trim();
         const entity = this.getEntity(entityType, ID);
+        // note: entity.name is dynamically retrieved, will change once device is removed (friendly => ieee)
         const friendlyName = entity.name;
-        const entityID = entity.ID;
-
         let block = false;
         let force = false;
-        let blockForceLog = '';
+        let blockForceLog = "";
 
-        if (entityType === 'device' && typeof message === 'object') {
+        if (entityType === "device" && typeof message === "object") {
             block = !!message.block;
             force = !!message.force;
             blockForceLog = ` (block: ${block}, force: ${force})`;
-        } else if (entityType === 'group' && typeof message === 'object') {
+        } else if (entityType === "group" && typeof message === "object") {
             force = !!message.force;
             blockForceLog = ` (force: ${force})`;
         }
 
         try {
-            logger.info(`Removing ${entityType} '${entity.name}'${blockForceLog}`);
-            const name = entity.name;
+            logger.info(`Removing ${entityType} '${friendlyName}'${blockForceLog}`);
 
             if (entity instanceof Device) {
                 if (block) {
@@ -618,8 +690,7 @@ export default class Bridge extends Extension {
                     await entity.zh.removeFromNetwork();
                 }
 
-                this.eventBus.emitEntityRemoved({id: entityID, name, type: 'device'});
-                settings.removeDevice(entityID as string);
+                settings.removeDevice(entity.ID as string);
             } else {
                 if (force) {
                     entity.zh.removeFromDatabase();
@@ -627,15 +698,17 @@ export default class Bridge extends Extension {
                     await entity.zh.removeFromNetwork();
                 }
 
-                this.eventBus.emitEntityRemoved({id: entityID, name, type: 'group'});
-                settings.removeGroup(entityID);
+                this.zigbee.removeGroupFromLookup(entity.ID);
+                settings.removeGroup(entity.ID);
             }
 
+            this.eventBus.emitEntityRemoved({entity, name: friendlyName});
+
             // Remove from state
-            this.state.remove(entityID);
+            this.state.remove(entity.ID);
 
             // Clear any retained messages
-            await this.mqtt.publish(friendlyName, '', {retain: true});
+            await this.mqtt.publish(friendlyName, "", {clientOptions: {retain: true}});
 
             logger.info(`Successfully removed ${entityType} '${friendlyName}'${blockForceLog}`);
 
@@ -645,32 +718,32 @@ export default class Bridge extends Extension {
                 // Refresh Cluster definition
                 await this.publishDefinitions();
 
-                const responseData: Zigbee2MQTTAPI['bridge/response/device/remove'] = {id: ID, block, force};
+                const responseData: Zigbee2MQTTAPI["bridge/response/device/remove"] = {id: ID, block, force};
 
                 return utils.getResponse(message, responseData);
-            } else {
-                await this.publishGroups();
-
-                const responseData: Zigbee2MQTTAPI['bridge/response/group/remove'] = {id: ID, force};
-
-                return utils.getResponse(
-                    message,
-                    // @ts-expect-error typing infer does not work here
-                    responseData,
-                );
             }
+
+            await this.publishGroups();
+
+            const responseData: Zigbee2MQTTAPI["bridge/response/group/remove"] = {id: ID, force};
+
+            return utils.getResponse(
+                message,
+                // @ts-expect-error typing infer does not work here
+                responseData,
+            );
         } catch (error) {
             throw new Error(`Failed to remove ${entityType} '${friendlyName}'${blockForceLog} (${error})`);
         }
     }
 
-    getEntity(type: 'group', ID: string): Group;
-    getEntity(type: 'device', ID: string): Device;
-    getEntity(type: 'group' | 'device', ID: string): Device | Group;
-    getEntity(type: 'group' | 'device', ID: string): Device | Group {
-        const entity = this.zigbee.resolveEntity(ID);
+    getEntity(type: "group", id: string): Group;
+    getEntity(type: "device", id: string): Device;
+    getEntity(type: "group" | "device", id: string): Device | Group;
+    getEntity(type: "group" | "device", id: string): Device | Group {
+        const entity = this.zigbee.resolveEntity(id);
         if (!entity || entity.constructor.name.toLowerCase() !== type) {
-            throw new Error(`${utils.capitalize(type)} '${ID}' does not exist`);
+            throw new Error(`${utils.capitalize(type)} '${id}' does not exist`);
         }
         return entity;
     }
@@ -683,13 +756,15 @@ export default class Bridge extends Extension {
         delete config.frontend.auth_token;
 
         const networkParams = await this.zigbee.getNetworkParameters();
-        const payload: Zigbee2MQTTAPI['bridge/info'] = {
+        const payload: Zigbee2MQTTAPI["bridge/info"] = {
+            os: this.#osInfo,
+            mqtt: this.mqtt.info,
             version: this.zigbee2mqttVersion.version,
             commit: this.zigbee2mqttVersion.commitHash,
             zigbee_herdsman_converters: this.zigbeeHerdsmanConvertersVersion,
             zigbee_herdsman: this.zigbeeHerdsmanVersion,
             coordinator: {
-                ieee_address: this.zigbee.firstCoordinatorEndpoint().getDevice().ieeeAddr,
+                ieee_address: this.zigbee.firstCoordinatorEndpoint().deviceIeeeAddress,
                 ...this.coordinatorVersion,
             },
             network: {
@@ -705,17 +780,18 @@ export default class Bridge extends Extension {
             config_schema: settings.schemaJson,
         };
 
-        await this.mqtt.publish('bridge/info', stringify(payload), {retain: true, qos: 0}, settings.get().mqtt.base_topic, true);
+        await this.mqtt.publish("bridge/info", stringify(payload), {clientOptions: {retain: true}, skipLog: true});
     }
 
     async publishDevices(): Promise<void> {
-        const devices: Zigbee2MQTTAPI['bridge/devices'] = [];
+        const devices: Zigbee2MQTTAPI["bridge/devices"] = [];
 
         for (const device of this.zigbee.devicesIterator()) {
-            const endpoints: (typeof devices)[number]['endpoints'] = {};
+            const endpoints: (typeof devices)[number]["endpoints"] = {};
 
             for (const endpoint of device.zh.endpoints) {
                 const data: (typeof endpoints)[keyof typeof endpoints] = {
+                    name: device.endpointName(endpoint),
                     scenes: utils.getScenes(endpoint),
                     bindings: [],
                     configured_reportings: [],
@@ -727,8 +803,8 @@ export default class Bridge extends Extension {
 
                 for (const bind of endpoint.binds) {
                     const target = utils.isZHEndpoint(bind.target)
-                        ? {type: 'endpoint', ieee_address: bind.target.getDevice().ieeeAddr, endpoint: bind.target.ID}
-                        : {type: 'group', id: bind.target.groupID};
+                        ? {type: "endpoint" as const, ieee_address: bind.target.deviceIeeeAddress, endpoint: bind.target.ID}
+                        : {type: "group" as const, id: bind.target.groupID};
                     data.bindings.push({cluster: bind.cluster.name, target});
                 }
 
@@ -758,52 +834,55 @@ export default class Bridge extends Extension {
                 software_build_id: device.zh.softwareBuildID,
                 date_code: device.zh.dateCode,
                 model_id: device.zh.modelID,
-                interviewing: device.zh.interviewing,
-                interview_completed: device.zh.interviewCompleted,
+                /** @deprecated interviewing and interview_completed are superceded by interview_state */
+                interviewing: device.zh.interviewState === InterviewState.InProgress,
+                interview_completed: device.zh.interviewState === InterviewState.Successful,
+                interview_state: device.zh.interviewState,
                 manufacturer: device.zh.manufacturerName,
                 endpoints,
             });
         }
 
-        await this.mqtt.publish('bridge/devices', stringify(devices), {retain: true, qos: 0}, settings.get().mqtt.base_topic, true);
+        await this.mqtt.publish("bridge/devices", stringify(devices), {clientOptions: {retain: true}, skipLog: true});
     }
 
     async publishGroups(): Promise<void> {
-        const groups: Zigbee2MQTTAPI['bridge/groups'] = [];
+        const groups: Zigbee2MQTTAPI["bridge/groups"] = [];
 
         for (const group of this.zigbee.groupsIterator()) {
             const members = [];
 
             for (const member of group.zh.members) {
-                members.push({ieee_address: member.getDevice().ieeeAddr, endpoint: member.ID});
+                members.push({ieee_address: member.deviceIeeeAddress, endpoint: member.ID});
             }
 
             groups.push({
                 id: group.ID,
-                friendly_name: group.ID === 901 ? 'default_bind_group' : group.name,
+                friendly_name: group.ID === DEFAULT_BIND_GROUP_ID ? "default_bind_group" : group.name,
                 description: group.options.description,
                 scenes: utils.getScenes(group.zh),
                 members,
             });
         }
 
-        await this.mqtt.publish('bridge/groups', stringify(groups), {retain: true, qos: 0}, settings.get().mqtt.base_topic, true);
+        await this.mqtt.publish("bridge/groups", stringify(groups), {clientOptions: {retain: true}, skipLog: true});
     }
 
     async publishDefinitions(): Promise<void> {
-        const data: Zigbee2MQTTAPI['bridge/definition'] = {
+        const data: Zigbee2MQTTAPI["bridge/definitions"] = {
             clusters: Zcl.Clusters,
             custom_clusters: {},
+            actions: Object.keys(zhc.ACTIONS),
         };
 
         for (const device of this.zigbee.devicesIterator((d) => !utils.objectIsEmpty(d.customClusters))) {
             data.custom_clusters[device.ieeeAddr] = device.customClusters;
         }
 
-        await this.mqtt.publish('bridge/definitions', stringify(data), {retain: true, qos: 0}, settings.get().mqtt.base_topic, true);
+        await this.mqtt.publish("bridge/definitions", stringify(data), {clientOptions: {retain: true}, skipLog: true});
     }
 
-    getDefinitionPayload(device: Device): Zigbee2MQTTDevice['definition'] | undefined {
+    getDefinitionPayload(device: Device): Zigbee2MQTTDevice["definition"] | undefined {
         if (!device.definition) {
             return undefined;
         }
@@ -815,11 +894,12 @@ export default class Bridge extends Extension {
 
         if (icon) {
             /* v8 ignore next */
-            icon = icon.replace('${zigbeeModel}', utils.sanitizeImageParameter(device.zh.modelID ?? ''));
-            icon = icon.replace('${model}', utils.sanitizeImageParameter(device.definition.model));
+            icon = icon.replace("$zigbeeModel", utils.sanitizeImageParameter(device.zh.modelID ?? ""));
+            icon = icon.replace("$model", utils.sanitizeImageParameter(device.definition.model));
         }
 
-        const payload: Zigbee2MQTTDevice['definition'] = {
+        const payload: Zigbee2MQTTDevice["definition"] = {
+            source: device.definition.externalConverterName ? "external" : device.definition.generated ? "generated" : "native",
             model: device.definition.model,
             vendor: device.definition.vendor,
             description: device.definition.description,

lib/extension/configure.ts

@@ -1,15 +1,12 @@
-import type {Zigbee2MQTTAPI} from 'lib/types/api';
-
-import bind from 'bind-decorator';
-import stringify from 'json-stable-stringify-without-jsonify';
-
-import * as zhc from 'zigbee-herdsman-converters';
-
-import Device from '../model/device';
-import logger from '../util/logger';
-import * as settings from '../util/settings';
-import utils from '../util/utils';
-import Extension from './extension';
+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
@@ -26,17 +23,17 @@ export default class Configure extends Extension {
             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.topic) {
-            const message = utils.parseJSON(data.message, data.message) as Zigbee2MQTTAPI['bridge/request/device/configure'];
-            const ID = typeof message === 'object' ? message.id : message;
+            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 (ID === undefined) {
-                error = `Invalid payload`;
+                error = "Invalid payload";
             } else {
                 const device = this.zigbee.resolveEntity(ID);
 
@@ -46,27 +43,27 @@ export default class Configure extends Extension {
                     error = `Device '${device.name}' cannot be configured`;
                 } else {
                     try {
-                        await this.configure(device, 'mqtt_message', true, true);
+                        await this.configure(device, "mqtt_message", true, true);
                     } catch (e) {
                         error = `Failed to configure (${(e as Error).message})`;
                     }
                 }
             }
 
-            const response = utils.getResponse<'bridge/response/device/configure'>(message, {id: ID}, error);
+            const response = utils.getResponse<"bridge/response/device/configure">(message, {id: ID}, error);
 
-            await this.mqtt.publish(`bridge/response/device/configure`, stringify(response));
+            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.devicesIterator((d) => d.type === 'Router')) {
+            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");
             }
         });
 
@@ -76,17 +73,19 @@ export default class Configure extends Extension {
                 data.device.zh.save();
             }
 
-            await 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',
+        event: "started" | "zigbee_event" | "reporting_disabled" | "mqtt_message",
         force = false,
         throwError = false,
     ): Promise<void> {
@@ -95,7 +94,7 @@ export default class Configure extends Extension {
         }
 
         if (!force) {
-            if (device.options.disabled || !device.zh.interviewCompleted) {
+            if (device.options.disabled || !device.interviewed) {
                 return;
             }
 
@@ -104,7 +103,7 @@ export default class Configure extends Extension {
             }
 
             // 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;
             }
         }

lib/extension/extension.ts

@@ -1,6 +1,6 @@
 abstract class Extension {
     protected zigbee: Zigbee;
-    protected mqtt: MQTT;
+    protected mqtt: Mqtt;
     protected state: State;
     protected publishEntityState: PublishEntityState;
     protected eventBus: EventBus;
@@ -12,7 +12,7 @@ abstract class Extension {
      * 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
@@ -22,7 +22,7 @@ abstract class Extension {
      */
     constructor(
         zigbee: Zigbee,
-        mqtt: MQTT,
+        mqtt: Mqtt,
         state: State,
         publishEntityState: PublishEntityState,
         eventBus: EventBus,
@@ -48,12 +48,13 @@ abstract class Extension {
     /**
      * 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;

lib/extension/externalConverters.ts

@@ -1,16 +1,16 @@
-import type * as zhc from 'zigbee-herdsman-converters';
+import type {ExternalDefinitionWithExtend} from "zigbee-herdsman-converters";
 
-import {addDefinition, removeExternalDefinitions} from 'zigbee-herdsman-converters';
+import {addExternalDefinition, removeExternalDefinitions} from "zigbee-herdsman-converters";
 
-import logger from '../util/logger';
-import ExternalJSExtension from './externalJS';
+import logger from "../util/logger";
+import ExternalJSExtension from "./externalJS";
 
-type ModuleExports = zhc.Definition | zhc.Definition[];
+type TModule = ExternalDefinitionWithExtend | ExternalDefinitionWithExtend[];
 
-export default class ExternalConverters extends ExternalJSExtension<ModuleExports> {
+export default class ExternalConverters extends ExternalJSExtension<TModule> {
     constructor(
         zigbee: Zigbee,
-        mqtt: MQTT,
+        mqtt: Mqtt,
         state: State,
         publishEntityState: PublishEntityState,
         eventBus: EventBus,
@@ -27,42 +27,41 @@ export default class ExternalConverters extends ExternalJSExtension<ModuleExport
             enableDisableExtension,
             restartCallback,
             addExtension,
-            'converter',
-            'external_converters',
+            "converter",
+            "external_converters",
         );
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    protected async removeJS(name: string, module: ModuleExports): Promise<void> {
+    protected async removeJS(name: string, _mod: TModule): Promise<void> {
         removeExternalDefinitions(name);
 
         await this.zigbee.resolveDevicesDefinitions(true);
     }
 
-    protected async loadJS(name: string, module: ModuleExports): Promise<void> {
+    protected async loadJS(name: string, mod: TModule, newName?: string): Promise<void> {
         try {
             removeExternalDefinitions(name);
 
-            for (const definition of this.getDefinitions(module)) {
-                definition.externalConverterName = name;
+            const definitions = Array.isArray(mod) ? mod : [mod];
 
-                addDefinition(definition);
-                logger.info(`Loaded external converter '${name}'.`);
+            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(`Failed to load external converter '${name}'`);
-            logger.error(`Check the code for syntax error and make sure it is up to date with the current Zigbee2MQTT version.`);
             logger.error(
-                `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`,
+                /* 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;
         }
     }
-
-    private getDefinitions(module: ModuleExports): zhc.Definition[] {
-        return Array.isArray(module) ? module : [module];
-    }
 }

lib/extension/externalExtensions.ts

@@ -1,15 +1,14 @@
-import type Extension from './extension';
+import logger from "../util/logger";
+import * as settings from "../util/settings";
+import type Extension from "./extension";
+import ExternalJSExtension from "./externalJS";
 
-import logger from '../util/logger';
-import * as settings from '../util/settings';
-import ExternalJSExtension from './externalJS';
+type TModule = new (...args: ConstructorParameters<typeof Extension>) => Extension;
 
-type ModuleExports = typeof Extension;
-
-export default class ExternalExtensions extends ExternalJSExtension<ModuleExports> {
+export default class ExternalExtensions extends ExternalJSExtension<TModule> {
     constructor(
         zigbee: Zigbee,
-        mqtt: MQTT,
+        mqtt: Mqtt,
         state: State,
         publishEntityState: PublishEntityState,
         eventBus: EventBus,
@@ -26,34 +25,45 @@ export default class ExternalExtensions extends ExternalJSExtension<ModuleExport
             enableDisableExtension,
             restartCallback,
             addExtension,
-            'extension',
-            'external_extensions',
+            "extension",
+            "external_extensions",
         );
     }
 
-    protected async removeJS(name: string, module: ModuleExports): Promise<void> {
-        await this.enableDisableExtension(false, module.name);
+    protected async removeJS(_name: string, mod: TModule): Promise<void> {
+        await this.enableDisableExtension(false, mod.name);
     }
 
-    protected async loadJS(name: string, module: ModuleExports): Promise<void> {
-        // stop if already started
-        await this.enableDisableExtension(false, module.name);
-        await this.addExtension(
-            // @ts-expect-error `module` is the interface, not the actual passed class
-            new module(
-                this.zigbee,
-                this.mqtt,
-                this.state,
-                this.publishEntityState,
-                this.eventBus,
-                this.enableDisableExtension,
-                this.restartCallback,
-                this.addExtension,
-                settings,
-                logger,
-            ),
-        );
+    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,
+                ),
+            );
 
-        logger.info(`Loaded external extension '${name}'.`);
+            /* 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 */
     }
 }

lib/extension/externalJS.ts

@@ -1,28 +1,29 @@
-import type {Zigbee2MQTTAPI, Zigbee2MQTTResponse} from 'lib/types/api';
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import bind from "bind-decorator";
+import stringify from "json-stable-stringify-without-jsonify";
+import type {Zigbee2MQTTAPI, Zigbee2MQTTResponse} from "../types/api";
 
-import fs from 'node:fs';
-import path from 'node:path';
-import {Context, runInNewContext} from 'node:vm';
+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";
 
-import bind from 'bind-decorator';
-import stringify from 'json-stable-stringify-without-jsonify';
-
-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 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,
+        mqtt: Mqtt,
         state: State,
         publishEntityState: PublishEntityState,
         eventBus: EventBus,
@@ -34,11 +35,41 @@ export default abstract class ExternalJSExtension<M> extends Extension {
     ) {
         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");
+                /* v8 ignore start */
+                if (fs.existsSync(nodeModulesSymlink)) {
+                    fs.unlinkSync(nodeModulesSymlink);
+                }
+                /* v8 ignore stop */
+
+                // Type `junction` is required on Windows.
+                // https://github.com/nodejs/node/issues/18518#issuecomment-513866491
+                fs.symlinkSync(nodeModulesPath, nodeModulesSymlink, /* v8 ignore next */ os.platform() === "win32" ? "junction" : "dir");
+            }
+        }
+    }
+
     override async start(): Promise<void> {
         await super.start();
         this.eventBus.onMQTTMessage(this, this.onMQTTMessage);
@@ -46,7 +77,18 @@ export default abstract class ExternalJSExtension<M> extends Extension {
         await this.publishExternalJS();
     }
 
-    private getFilePath(name: string, mkBasePath: boolean = false): string {
+    override async stop(): Promise<void> {
+        await super.stop();
+
+        // ensure "node_modules" is never followed & included in 3rd-party backup systems
+        const nodeModulesSymlink = path.join(this.basePath, "node_modules");
+
+        if (fs.existsSync(nodeModulesSymlink)) {
+            fs.unlinkSync(nodeModulesSymlink);
+        }
+    }
+
+    private getFilePath(name: string, mkBasePath = false): string {
         if (mkBasePath && !fs.existsSync(this.basePath)) {
             fs.mkdirSync(this.basePath, {recursive: true});
         }
@@ -55,17 +97,15 @@ export default abstract class ExternalJSExtension<M> extends Extension {
     }
 
     protected getFileCode(name: string): string {
-        return fs.readFileSync(path.join(this.basePath, name), 'utf8');
+        return fs.readFileSync(this.getFilePath(name), "utf8");
     }
 
     protected *getFiles(): Generator<{name: string; code: string}> {
-        if (!fs.existsSync(this.basePath)) {
-            return;
-        }
-
-        for (const fileName of fs.readdirSync(this.basePath)) {
-            if (fileName.endsWith('.js')) {
-                yield {name: fileName, code: this.getFileCode(fileName)};
+        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)};
+                }
             }
         }
     }
@@ -77,15 +117,15 @@ export default abstract class ExternalJSExtension<M> extends Extension {
             const message = utils.parseJSON(data.message, data.message);
 
             try {
-                let response;
+                let response: Awaited<ReturnType<typeof this.save | typeof this.remove>>;
 
-                if (match[1].toLowerCase() === 'save') {
+                if (match[1].toLowerCase() === "save") {
                     response = await this.save(
-                        message as Zigbee2MQTTAPI['bridge/request/converter/save'] | Zigbee2MQTTAPI['bridge/request/extension/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'],
+                        message as Zigbee2MQTTAPI["bridge/request/converter/remove"] | Zigbee2MQTTAPI["bridge/request/extension/remove"],
                     );
                 }
 
@@ -100,48 +140,50 @@ export default abstract class ExternalJSExtension<M> extends Extension {
         }
     }
 
-    protected abstract removeJS(name: string, module: M): Promise<void>;
+    protected abstract removeJS(name: string, mod: M): Promise<void>;
 
-    protected abstract loadJS(name: string, module: 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'>> {
+        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`);
+            return utils.getResponse(message, {}, "Invalid payload");
         }
 
         const {name} = message;
         const toBeRemoved = this.getFilePath(name);
 
         if (fs.existsSync(toBeRemoved)) {
-            await this.removeJS(name, this.loadModuleFromText(this.getFileCode(name), name));
+            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, {});
-        } else {
-            return utils.getResponse(message, {}, `${name} (${toBeRemoved}) doesn't exists`);
         }
+
+        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'>> {
+        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`);
+            return utils.getResponse(message, {}, "Invalid payload");
         }
 
         const {name, code} = message;
-
+        const filePath = this.getFilePath(name, true);
         try {
-            await this.loadJS(name, this.loadModuleFromText(code, name));
+            fs.writeFileSync(filePath, code, "utf8");
+            this.symlinkNodeModulesIfNecessary();
 
-            const filePath = this.getFilePath(name, true);
+            const mod = await this.importFile(filePath);
 
-            fs.writeFileSync(filePath, code, 'utf8');
+            await this.loadJS(name, mod.default, name);
             logger.info(`${name} loaded. Contents written to '${filePath}'.`);
             await this.publishExternalJS();
 
@@ -153,39 +195,45 @@ export default abstract class ExternalJSExtension<M> extends Extension {
 
     private async loadFiles(): Promise<void> {
         for (const extension of this.getFiles()) {
-            await this.loadJS(extension.name, this.loadModuleFromText(extension.code, extension.name));
+            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. (${(error as Error).message})`,
+                );
+                // 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())),
-            {
-                retain: true,
-                qos: 0,
-            },
-            settings.get().mqtt.base_topic,
-            true,
-        );
+        await this.mqtt.publish(`bridge/${this.mqttTopic}s`, stringify(Array.from(this.getFiles())), {
+            clientOptions: {retain: true},
+            skipLog: true,
+        });
     }
 
-    private loadModuleFromText(moduleCode: string, name: string): M {
-        const moduleFakePath = path.join(__dirname, '..', '..', 'data', 'extension', name);
-        const sandbox: Context = {
-            require: require,
-            module: {},
-            console,
-            setTimeout,
-            clearTimeout,
-            setInterval,
-            clearInterval,
-            setImmediate,
-            clearImmediate,
-        };
-
-        runInNewContext(moduleCode, sandbox, moduleFakePath);
-
-        return sandbox.module.exports;
+    // 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);
+        }
     }
 }

lib/extension/frontend.ts

@@ -1,48 +1,35 @@
-import type {IncomingMessage, Server, ServerResponse} from 'node:http';
-import type {Socket} from 'node:net';
+import assert from "node:assert";
+import {existsSync, readFileSync} from "node:fs";
+import type {IncomingMessage, Server, ServerResponse} from "node:http";
+import {createServer} from "node:http";
+import {createServer as createSecureServer} from "node:https";
+import type {Socket} from "node:net";
+import {posix} from "node:path";
+import {parse} from "node:url";
+import bind from "bind-decorator";
+import expressStaticGzip from "express-static-gzip";
+import finalhandler from "finalhandler";
+import stringify from "json-stable-stringify-without-jsonify";
+import WebSocket from "ws";
 
-import type {RequestHandler} from 'express-static-gzip';
-
-import assert from 'node:assert';
-import {existsSync, readFileSync} from 'node:fs';
-import {createServer} from 'node:http';
-import {createServer as createSecureServer} from 'node:https';
-import {posix} from 'node:path';
-import {parse} from 'node:url';
-
-import bind from 'bind-decorator';
-import expressStaticGzip from 'express-static-gzip';
-import finalhandler from 'finalhandler';
-import stringify from 'json-stable-stringify-without-jsonify';
-import WebSocket from 'ws';
-
-import frontend from 'zigbee2mqtt-frontend';
-
-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';
+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 {
+export class Frontend extends Extension {
     private mqttBaseTopic: string;
-    private host: string | undefined;
-    private port: number;
-    private sslCert: string | undefined;
-    private sslKey: string | undefined;
-    private authToken: string | undefined;
-    private server!: Server;
-    private fileServer!: RequestHandler;
-    private deviceIconsFileServer!: RequestHandler;
+    private server: Server | undefined;
     private wss!: WebSocket.Server;
     private baseUrl: string;
 
     constructor(
         zigbee: Zigbee,
-        mqtt: MQTT,
+        mqtt: Mqtt,
         state: State,
         publishEntityState: PublishEntityState,
         eventBus: EventBus,
@@ -54,128 +41,136 @@ export default class Frontend extends Extension {
 
         const frontendSettings = settings.get().frontend;
         assert(frontendSettings.enabled, `Frontend extension created with setting 'enabled: false'`);
-        this.host = frontendSettings.host;
-        this.port = frontendSettings.port;
-        this.sslCert = frontendSettings.ssl_cert;
-        this.sslKey = frontendSettings.ssl_key;
-        this.authToken = frontendSettings.auth_token;
         this.baseUrl = frontendSettings.base_url;
         this.mqttBaseTopic = settings.get().mqtt.base_topic;
     }
 
-    private isHttpsConfigured(): boolean {
-        if (this.sslCert && this.sslKey) {
-            if (!existsSync(this.sslCert) || !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.`);
-                return false;
-            }
-            return true;
-        }
-        return false;
-    }
-
     override async start(): Promise<void> {
-        const options = {
-            enableBrotli: true,
-            // TODO: https://github.com/Koenkk/zigbee2mqtt/issues/24654 - enable compressed index serving when express-static-gzip is fixed.
-            index: false,
-            serveStatic: {
-                index: 'index.html',
-                /* v8 ignore start */
-                setHeaders: (res: ServerResponse, path: string): void => {
-                    if (path.endsWith('index.html')) {
-                        res.setHeader('Cache-Control', 'no-store');
+        if (settings.get().frontend.disable_ui_serving) {
+            const {host, port} = settings.get().frontend;
+            this.wss = new WebSocket.Server({port, host, path: posix.join(this.baseUrl, "api")});
+
+            logger.info(
+                /* v8 ignore next */
+                `Frontend UI serving is disabled. WebSocket at: ${this.wss.options.host ?? "0.0.0.0"}:${this.wss.options.port}${this.wss.options.path}`,
+            );
+        } else {
+            const {host, port, ssl_key: sslKey, ssl_cert: sslCert} = settings.get().frontend;
+            const hasSSL = (val: string | undefined, key: string): val is string => {
+                if (val) {
+                    if (existsSync(val)) {
+                        return true;
                     }
-                },
-                /* v8 ignore stop */
-            },
-        };
-        this.fileServer = expressStaticGzip(frontend.getPath(), options);
-        this.deviceIconsFileServer = expressStaticGzip(data.joinPath('device_icons'), options);
-        this.wss = new WebSocket.Server({noServer: true, path: posix.join(this.baseUrl, 'api')});
 
-        this.wss.on('connection', this.onWebSocketConnection);
+                    logger.error(`Defined ${key} '${val}' file path does not exists, server won't be secured.`);
+                }
 
-        if (this.isHttpsConfigured()) {
-            const serverOptions = {
-                key: readFileSync(this.sslKey!), // valid from `isHttpsConfigured`
-                cert: readFileSync(this.sslCert!), // valid from `isHttpsConfigured`
+                return false;
             };
-            this.server = createSecureServer(serverOptions, this.onRequest);
-        } else {
-            this.server = createServer(this.onRequest);
+            const options: expressStaticGzip.ExpressStaticGzipOptions = {
+                enableBrotli: true,
+                serveStatic: {
+                    /* v8 ignore start */
+                    setHeaders: (res: ServerResponse, path: string): void => {
+                        if (path.endsWith("index.html")) {
+                            res.setHeader("Cache-Control", "no-store");
+                        }
+                    },
+                    /* v8 ignore stop */
+                },
+            };
+            const frontend = (await import(settings.get().frontend.package)) as typeof import("zigbee2mqtt-frontend");
+            const fileServer = expressStaticGzip(frontend.default.getPath(), options);
+            const deviceIconsFileServer = expressStaticGzip(data.joinPath("device_icons"), options);
+            const onRequest = (request: IncomingMessage, response: ServerResponse): void => {
+                const next = finalhandler(request, response);
+                // biome-ignore lint/style/noNonNullAssertion: `Only valid for request obtained from Server`
+                const newUrl = posix.relative(this.baseUrl, request.url!);
+
+                // The request url is not within the frontend base url, so the relative path starts with '..'
+                if (newUrl.startsWith(".")) {
+                    next();
+
+                    return;
+                }
+
+                // Attach originalUrl so that static-server can perform a redirect to '/' when serving the root directory.
+                // This is necessary for the browser to resolve relative assets paths correctly.
+                request.originalUrl = request.url;
+                request.url = `/${newUrl}`;
+                request.path = request.url;
+
+                if (newUrl.startsWith("device_icons/")) {
+                    request.path = request.path.replace("device_icons/", "");
+                    request.url = request.url.replace("/device_icons", "");
+
+                    deviceIconsFileServer(request, response, next);
+                } else {
+                    fileServer(request, response, next);
+                }
+            };
+
+            if (hasSSL(sslKey, "ssl_key") && hasSSL(sslCert, "ssl_cert")) {
+                const serverOptions = {key: readFileSync(sslKey), cert: readFileSync(sslCert)};
+                this.server = createSecureServer(serverOptions, onRequest);
+            } else {
+                this.server = createServer(onRequest);
+            }
+
+            this.server.on("upgrade", this.onUpgrade);
+
+            if (!host) {
+                this.server.listen(port);
+                logger.info(`Started frontend on port ${port}`);
+            } else if (host.startsWith("/")) {
+                this.server.listen(host);
+                logger.info(`Started frontend on socket ${host}`);
+            } else {
+                this.server.listen(port, host);
+                logger.info(`Started frontend on port ${host}:${port}`);
+            }
+
+            this.wss = new WebSocket.Server({noServer: true, path: posix.join(this.baseUrl, "api")});
         }
 
-        this.server.on('upgrade', this.onUpgrade);
-        this.eventBus.onMQTTMessagePublished(this, this.onMQTTPublishMessage);
+        this.wss.on("connection", this.onWebSocketConnection);
 
-        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}`);
-        } else {
-            this.server.listen(this.port, this.host);
-            logger.info(`Started frontend on port ${this.host}:${this.port}`);
-        }
+        this.eventBus.onMQTTMessagePublished(this, this.onMQTTPublishMessageOrEntityState);
+        this.eventBus.onPublishEntityState(this, this.onMQTTPublishMessageOrEntityState);
     }
 
     override async stop(): Promise<void> {
         await super.stop();
-        this.wss?.clients.forEach((client) => {
-            client.send(stringify({topic: 'bridge/state', payload: 'offline'}));
-            client.terminate();
-        });
-        this.wss?.close();
 
-        await new Promise((resolve) => this.server?.close(resolve));
-    }
+        if (this.wss) {
+            for (const client of this.wss.clients) {
+                client.send(stringify({topic: "bridge/state", payload: {state: "offline"}}));
+                client.terminate();
+            }
 
-    @bind private onRequest(request: IncomingMessage, response: ServerResponse): void {
-        const fin = finalhandler(request, response);
-        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('.')) {
-            return fin();
+            this.wss.close();
         }
 
-        // 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);
-        }
-    }
-
-    private authenticate(request: IncomingMessage, cb: (authenticate: boolean) => void): void {
-        const {query} = parse(request.url!, true);
-        cb(!this.authToken || this.authToken === query.token);
+        await new Promise((resolve) => (this.server ? this.server.close(resolve) : resolve(undefined)));
     }
 
     @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);
@@ -199,7 +194,7 @@ export default class Frontend extends Extension {
             const payload = this.state.get(device);
             const lastSeen = settings.get().advanced.last_seen;
 
-            if (lastSeen !== 'disable') {
+            if (lastSeen !== "disable") {
                 payload.last_seen = utils.formatDate(device.zh.lastSeen ?? /* v8 ignore next */ 0, lastSeen);
             }
 
@@ -211,17 +206,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);
+    @bind private onMQTTPublishMessageOrEntityState(data: eventdata.MQTTMessagePublished | eventdata.PublishEntityState): void {
+        let topic: string;
+        let payload: KeyValue | string;
 
-            for (const client of this.wss.clients) {
-                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;

lib/extension/groups.ts

@@ -1,37 +1,31 @@
-import type {Zigbee2MQTTAPI, Zigbee2MQTTResponseEndpoints} from 'lib/types/api';
-
-import assert from 'node:assert';
-
-import bind from 'bind-decorator';
-import equals from 'fast-deep-equal/es6';
-import stringify from 'json-stable-stringify-without-jsonify';
-
-import * as zhc from 'zigbee-herdsman-converters';
-
-import Device from '../model/device';
-import Group from '../model/group';
-import logger from '../util/logger';
-import * as settings from '../util/settings';
-import utils, {isLightExpose} from '../util/utils';
-import Extension from './extension';
-
-const TOPIC_REGEX = new RegExp(`^${settings.get().mqtt.base_topic}/bridge/request/group/members/(remove|add|remove_all)$`);
+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 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')),
+    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'))),
+                (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';
+    type: "remove" | "add" | "remove_all";
     resolvedGroup?: Group;
     resolvedDevice?: Device;
     resolvedEndpoint?: zh.Endpoint;
@@ -42,17 +36,19 @@ interface ParsedMQTTMessage {
 }
 
 export default class Groups extends Extension {
+    #topicRegex = new RegExp(`^${settings.get().mqtt.base_topic}/bridge/request/group/members/(remove|add|remove_all)$`);
     private lastOptimisticState: {[s: string]: KeyValue} = {};
 
+    // biome-ignore lint/suspicious/useAwait: API
     override async start(): Promise<void> {
         this.eventBus.onStateChange(this, this.onStateChange);
         this.eventBus.onMQTTMessage(this, this.onMQTTMessage);
     }
 
     @bind async onStateChange(data: eventdata.StateChange): Promise<void> {
-        const reason = 'groupOptimistic';
+        const reason = "groupOptimistic";
 
-        if (data.reason === reason || data.reason === 'publishCached') {
+        if (data.reason === reason || data.reason === "publishCached") {
             return;
         }
 
@@ -81,7 +77,7 @@ export default class Groups extends Extension {
             const groups = [];
 
             for (const group of this.zigbee.groupsIterator()) {
-                if (group.options && (group.options.optimistic == undefined || group.options.optimistic)) {
+                if (group.options && (group.options.optimistic == null || group.options.optimistic)) {
                     groups.push(group);
                 }
             }
@@ -106,7 +102,7 @@ export default class Groups extends Extension {
                 // 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;
@@ -153,15 +149,16 @@ export default class Groups extends Extension {
 
     private shouldPublishPayloadForGroup(group: Group, payload: KeyValue): boolean {
         return (
-            group.options.off_state === 'last_member_state' ||
+            group.options.off_state === "last_member_state" ||
             !payload ||
-            (payload.state !== 'OFF' && payload.state !== 'CLOSE') ||
+            (payload.state !== "OFF" && payload.state !== "CLOSE") ||
             this.areAllMembersOffOrClosed(group)
         );
     }
 
     private areAllMembersOffOrClosed(group: Group): boolean {
         for (const member of group.zh.members) {
+            // biome-ignore lint/style/noNonNullAssertion: TODO: biome migration: valid from loop?
             const device = this.zigbee.resolveEntity(member.getDevice())!;
 
             if (this.state.exists(device)) {
@@ -171,11 +168,11 @@ export default class Groups extends Extension {
                     endpointNames &&
                     endpointNames.length >= member.ID &&
                     device.definition?.meta?.multiEndpoint &&
-                    (!device.definition.meta.multiEndpointSkip || !device.definition.meta.multiEndpointSkip.includes('state'))
+                    (!device.definition.meta.multiEndpointSkip || !device.definition.meta.multiEndpointSkip.includes("state"))
                         ? `state_${endpointNames[member.ID - 1]}`
-                        : 'state';
+                        : "state";
 
-                if (state[stateKey] === 'ON' || state[stateKey] === 'OPEN') {
+                if (state[stateKey] === "ON" || state[stateKey] === "OPEN") {
                     return false;
                 }
             }
@@ -187,34 +184,39 @@ export default class Groups extends Extension {
     private parseMQTTMessage(
         data: eventdata.MQTTMessage,
     ): [raw: KeyValue | undefined, parsed: ParsedMQTTMessage | undefined, error: string | undefined] {
-        const topicRegexMatch = data.topic.match(TOPIC_REGEX);
+        const topicRegexMatch = data.topic.match(this.#topicRegex);
 
         if (topicRegexMatch) {
-            const type = topicRegexMatch[1] as 'remove' | 'add' | 'remove_all';
-            let resolvedGroup;
-            let groupKey;
+            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'];
+            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 (typeof message !== 'object' || message.device == undefined) {
-                return [message, {type, skipDisableReporting}, 'Invalid payload'];
+            if (typeof message !== "object" || message.device == null) {
+                return [message, {type, skipDisableReporting}, "Invalid payload"];
             }
 
             const deviceKey = message.device;
-            skipDisableReporting = message.skip_disable_reporting != undefined ? message.skip_disable_reporting : false;
+            skipDisableReporting = message.skip_disable_reporting != null ? message.skip_disable_reporting : false;
+
+            if (type !== "remove_all") {
+                if (!("group" in message) || message.group == null) {
+                    return [message, {type, skipDisableReporting}, "Invalid payload"];
+                }
 
-            if (type !== 'remove_all') {
                 groupKey = message.group;
 
-                if (message.group == undefined) {
-                    return [message, {type, skipDisableReporting}, `Invalid payload`];
-                }
+                const group = this.zigbee.resolveEntity(message.group);
 
-                resolvedGroup = this.zigbee.resolveEntity(message.group);
-
-                if (!resolvedGroup || !(resolvedGroup instanceof Group)) {
+                if (!group || !(group instanceof Group)) {
                     return [message, {type, skipDisableReporting}, `Group '${message.group}' does not exist`];
                 }
+
+                resolvedGroup = group;
             }
 
             const resolvedDevice = this.zigbee.resolveEntity(message.device);
@@ -223,7 +225,7 @@ export default class Groups extends Extension {
                 return [message, {type, skipDisableReporting}, `Device '${message.device}' does not exist`];
             }
 
-            const endpointKey = message.endpoint ?? 'default';
+            const endpointKey = message.endpoint ?? "default";
             const resolvedEndpoint = resolvedDevice.endpoint(message.endpoint);
 
             if (!resolvedEndpoint) {
@@ -244,9 +246,9 @@ export default class Groups extends Extension {
                 },
                 undefined,
             ];
-        } else {
-            return [undefined, undefined, undefined];
         }
+
+        return [undefined, undefined, undefined];
     }
 
     @bind private async onMQTTMessage(data: eventdata.MQTTMessage): Promise<void> {
@@ -264,47 +266,43 @@ export default class Groups extends Extension {
         const {resolvedGroup, resolvedDevice, resolvedEndpoint, type, groupKey, deviceKey, endpointKey, skipDisableReporting} = parsed;
         const changedGroups: Group[] = [];
 
-        assert(resolvedDevice, '`resolvedDevice` is missing');
-        assert(resolvedEndpoint, '`resolvedEndpoint` is missing');
+        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}'`);
+            if (type === "add") {
+                assert(resolvedGroup, "`resolvedGroup` is missing");
+                logger.info(`Adding endpoint '${resolvedEndpoint.ID}' of device '${resolvedDevice.name}' to group '${resolvedGroup.name}'`);
                 await resolvedEndpoint.addToGroup(resolvedGroup.zh);
                 changedGroups.push(resolvedGroup);
-                await this.publishResponse<'bridge/response/group/members/add'>(parsed.type, raw, {
-                    device: deviceKey!, // valid from resolved asserts
-                    endpoint: endpointKey!, // valid from resolved asserts
-                    group: groupKey!, // valid from resolved asserts
-                });
-            } else if (type === 'remove') {
-                assert(resolvedGroup, '`resolvedGroup` is missing');
-                logger.info(`Removing '${resolvedDevice.name}' from '${resolvedGroup.name}'`);
+                // 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 endpoint '${resolvedEndpoint.ID}' of device '${resolvedDevice.name}' from group '${resolvedGroup.name}'`);
                 await resolvedEndpoint.removeFromGroup(resolvedGroup.zh);
                 changedGroups.push(resolvedGroup);
-                await this.publishResponse<'bridge/response/group/members/remove'>(parsed.type, raw, {
-                    device: deviceKey!, // valid from resolved asserts
-                    endpoint: endpointKey!, // valid from resolved asserts
-                    group: groupKey!, // valid from resolved asserts
-                });
+                // 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`);
+                logger.info(`Removing endpoint '${resolvedEndpoint.ID}' of device '${resolvedDevice.name}' from all groups`);
 
                 for (const group of this.zigbee.groupsIterator((g) => g.members.includes(resolvedEndpoint))) {
                     changedGroups.push(group);
                 }
 
                 await resolvedEndpoint.removeFromAllGroups();
-                await this.publishResponse<'bridge/response/group/members/remove_all'>(parsed.type, raw, {
-                    device: deviceKey!, // valid from resolved asserts
-                    endpoint: endpointKey!, // valid from resolved asserts
-                });
+                // 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})`;
+            const errorMsg = `Failed to ${type} ${type === "add" ? "to" : "from"} group (${(e as Error).message})`;
             await this.publishResponse(parsed.type, raw, {}, errorMsg);
+            // biome-ignore lint/style/noNonNullAssertion: always Error
             logger.debug((e as Error).stack!);
             return;
         }
@@ -315,7 +313,7 @@ export default class Groups extends Extension {
     }
 
     private async publishResponse<T extends Zigbee2MQTTResponseEndpoints>(
-        type: ParsedMQTTMessage['type'],
+        type: ParsedMQTTMessage["type"],
         request: KeyValue,
         data: Zigbee2MQTTAPI[T],
         error?: string,

lib/extension/health.ts

@@ -0,0 +1,78 @@
+import * as os from "node:os";
+import * as process from "node:process";
+import type {Zigbee2MQTTAPI} from "../types/api";
+import * as settings from "../util/settings";
+import utils from "../util/utils";
+import Extension from "./extension";
+
+/** Round with 2 decimals */
+const round2 = (n: number): number => Math.round(n * 100.0) / 100.0;
+/** Round with 4 decimals */
+const round4 = (n: number): number => Math.round(n * 10000.0) / 10000.0;
+
+export default class Health extends Extension {
+    #checkTimer: NodeJS.Timeout | undefined;
+
+    override async start(): Promise<void> {
+        await super.start();
+
+        this.#checkTimer = setInterval(this.#checkHealth.bind(this), utils.minutes(settings.get().health.interval));
+    }
+
+    override async stop(): Promise<void> {
+        clearInterval(this.#checkTimer);
+        await super.stop();
+    }
+
+    clearStats(): void {
+        this.eventBus.stats.devices.clear();
+        this.eventBus.stats.mqtt.published = 0;
+        this.eventBus.stats.mqtt.received = 0;
+    }
+
+    async #checkHealth(): Promise<void> {
+        const sysMemTotalKb = os.totalmem() / 1024;
+        const sysMemFreeKb = os.freemem() / 1024;
+        const sysMemUsedKb = sysMemTotalKb - sysMemFreeKb;
+        const procMemUsedKb = process.memoryUsage().rss / 1024;
+        const healthcheck: Zigbee2MQTTAPI["bridge/health"] = {
+            response_time: Date.now(),
+            os: {
+                load_average: os.loadavg(), // will be [0,0,0] on Windows (not supported)
+                memory_used_mb: round2(sysMemUsedKb / 1024),
+                memory_percent: round4((sysMemUsedKb / sysMemTotalKb) * 100.0),
+            },
+            process: {
+                uptime_sec: Math.floor(process.uptime()),
+                memory_used_mb: round2(procMemUsedKb / 1024),
+                memory_percent: round4((procMemUsedKb / sysMemTotalKb) * 100.0),
+            },
+            mqtt: {...this.mqtt.stats, ...this.eventBus.stats.mqtt},
+            devices: {},
+        };
+
+        for (const [ieeeAddr, device] of this.eventBus.stats.devices) {
+            let messages = 0;
+            let mps = 0;
+
+            if (device.lastSeenChanges) {
+                const timeDiff = Date.now() - device.lastSeenChanges.first;
+                messages = device.lastSeenChanges.messages;
+                mps = timeDiff > 0 ? round4(messages / (timeDiff / 1000.0)) : 0;
+            }
+
+            healthcheck.devices[ieeeAddr] = {
+                messages,
+                messages_per_sec: mps,
+                leave_count: device.leaveCounts,
+                network_address_changes: device.networkAddressChanges,
+            };
+        }
+
+        if (settings.get().health.reset_on_check) {
+            this.clearStats();
+        }
+
+        await this.mqtt.publish("bridge/health", JSON.stringify(healthcheck), {clientOptions: {retain: true, qos: 1}});
+    }
+}

lib/extension/networkMap.ts

@@ -1,58 +1,59 @@
-import type {Zigbee2MQTTAPI, Zigbee2MQTTNetworkMap} from 'lib/types/api';
+import bind from "bind-decorator";
+import stringify from "json-stable-stringify-without-jsonify";
+import type {Eui64} from "zigbee-herdsman/dist/zspec/tstypes";
+import type {LQITableEntry, RoutingTableEntry} from "zigbee-herdsman/dist/zspec/zdo/definition/tstypes";
+import type {Zigbee2MQTTAPI, Zigbee2MQTTNetworkMap} from "../types/api";
+import logger from "../util/logger";
+import * as settings from "../util/settings";
+import utils from "../util/utils";
+import Extension from "./extension";
 
-import bind from 'bind-decorator';
-import stringify from 'json-stable-stringify-without-jsonify';
-
-import logger from '../util/logger';
-import * as settings from '../util/settings';
-import utils from '../util/utils';
-import Extension from './extension';
-
-const SUPPORTED_FORMATS = ['raw', 'graphviz', 'plantuml'];
+const SUPPORTED_FORMATS = ["raw", "graphviz", "plantuml"];
 
 /**
  * This extension creates a network map
  */
 export default class NetworkMap extends Extension {
-    private topic = `${settings.get().mqtt.base_topic}/bridge/request/networkmap`;
+    #topic = `${settings.get().mqtt.base_topic}/bridge/request/networkmap`;
 
+    // biome-ignore lint/suspicious/useAwait: API
     override async start(): Promise<void> {
         this.eventBus.onMQTTMessage(this, this.onMQTTMessage);
     }
 
     @bind async onMQTTMessage(data: eventdata.MQTTMessage): Promise<void> {
-        if (data.topic === this.topic) {
-            const message = utils.parseJSON(data.message, data.message) as Zigbee2MQTTAPI['bridge/request/networkmap'];
+        if (data.topic === this.#topic) {
+            const message = utils.parseJSON(data.message, data.message) as Zigbee2MQTTAPI["bridge/request/networkmap"];
 
             try {
-                const type = typeof message === 'object' ? message.type : message;
+                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(',')}`);
+                    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);
-                let responseData: Zigbee2MQTTAPI['bridge/response/networkmap'];
+                let responseData: Zigbee2MQTTAPI["bridge/response/networkmap"];
 
                 switch (type) {
-                    case 'raw': {
+                    case "raw": {
                         responseData = {type, routes, value: this.raw(topology)};
                         break;
                     }
-                    case 'graphviz': {
+                    case "graphviz": {
                         responseData = {type, routes, value: this.graphviz(topology)};
                         break;
                     }
-                    case 'plantuml': {
+                    case "plantuml": {
                         responseData = {type, routes, value: this.plantuml(topology)};
                         break;
                     }
                 }
 
-                await this.mqtt.publish('bridge/response/networkmap', stringify(utils.getResponse(message, responseData)));
+                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 as Error).message)));
+                await this.mqtt.publish("bridge/response/networkmap", stringify(utils.getResponse(message, {}, (error as Error).message)));
             }
         }
     }
@@ -64,10 +65,10 @@ export default class NetworkMap extends Extension {
     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
@@ -75,118 +76,119 @@ 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') {
+            if (node.type === "Coordinator") {
                 style = `style="bold, filled", fillcolor="${colors.fill.coordinator}", fontcolor="${colors.font.coordinator}"`;
-            } else if (node.type == 'Router') {
+            } 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}"`;
             }
 
             // 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}"`;
+            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, "");
     }
 
     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) => {
-                // Add friendly name
-                text.push(`card ${node.ieeeAddr} [`);
-                text.push(`${node.friendlyName}`);
-                text.push(`---`);
+        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("---");
 
-                // 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(',')}` : ''),
-                );
+            // Add the device short network address, ieeaddr and scan note (if any)
+            text.push(
+                `${node.ieeeAddr} (${utils.toNetworkAddressHex(node.networkAddress)})${node.failed?.length ? ` failed: ${node.failed.join(",")}` : ""}`,
+            );
 
-                // Add the device model
-                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 model
+            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;
-                if (date) {
-                    lastSeen = utils.formatDate(date, 'relative') as string;
-                }
-                text.push(`---`);
-                text.push(lastSeen);
-                text.push(`]`);
-                text.push(``);
-            });
+            // Add the device last_seen timestamp
+            let lastSeen = "unknown";
+            const date = node.type === "Coordinator" ? Date.now() : node.lastSeen;
+            if (date) {
+                lastSeen = utils.formatDate(date, "relative") as string;
+            }
+            text.push("---");
+            text.push(lastSeen);
+            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<Zigbee2MQTTNetworkMap> {
         logger.info(`Starting network scan (includeRoutes '${includeRoutes}')`);
-        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, LQITableEntry[]>();
+        const routingTables = new Map<Device, RoutingTableEntry[]>();
+        const failed = new Map<Device, string[]>();
         const requestWithRetry = async <T>(request: () => Promise<T>): Promise<T> => {
             try {
                 const result = await request();
@@ -199,43 +201,46 @@ export default class NetworkMap extends Extension {
             }
         };
 
-        for (const device of this.zigbee.devicesIterator((d) => d.type !== 'GreenPower' && d.type !== 'EndDevice')) {
+        for (const device of this.zigbee.devicesIterator((d) => d.type !== "GreenPower" && d.type !== "EndDevice")) {
             if (device.options.disabled) {
                 continue;
             }
 
-            failed.set(device, []);
+            const deviceFailures: string[] = [];
+            failed.set(device, deviceFailures);
             await utils.sleep(1); // sleep 1 second between each scan to reduce stress on network.
 
             try {
-                const result = await requestWithRetry<zh.LQI>(async () => await device.zh.lqi());
+                const result = await requestWithRetry<LQITableEntry[]>(async () => await device.zh.lqi());
                 lqis.set(device, result);
                 logger.debug(`LQI succeeded for '${device.name}'`);
             } catch (error) {
-                failed.get(device)!.push('lqi'); // set above
+                deviceFailures.push("lqi"); // set above
                 logger.error(`Failed to execute LQI for '${device.name}'`);
+                // biome-ignore lint/style/noNonNullAssertion: always Error
                 logger.debug((error as Error).stack!);
             }
 
             if (includeRoutes) {
                 try {
-                    const result = await requestWithRetry<zh.RoutingTable>(async () => await device.zh.routingTable());
+                    const result = await requestWithRetry<RoutingTableEntry[]>(async () => await device.zh.routingTable());
                     routingTables.set(device, result);
                     logger.debug(`Routing table succeeded for '${device.name}'`);
                 } catch (error) {
-                    failed.get(device)!.push('routingTable'); // set above
+                    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: 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')) {
+        for (const device of this.zigbee.devicesIterator((d) => d.type !== "GreenPower")) {
             if (device.options.disabled) {
                 continue;
             }
@@ -249,10 +254,10 @@ export default class NetworkMap extends Extension {
                       supports: Array.from(
                           new Set(
                               device.exposes().map((e) => {
-                                  return e.name ?? `${e.type} (${e.features?.map((f) => f.name).join(', ')})`;
+                                  return e.name ?? `${e.type} (${e.features?.map((f) => f.name).join(", ")})`;
                               }),
                           ),
-                      ).join(', '),
+                      ).join(", "),
                   }
                 : undefined;
 
@@ -263,49 +268,54 @@ export default class NetworkMap extends Extension {
                 networkAddress: device.zh.networkAddress,
                 manufacturerName: device.zh.manufacturerName,
                 modelID: device.zh.modelID,
-                failed: failed.get(device)!,
+                failed: failed.get(device),
                 lastSeen: device.zh.lastSeen,
                 definition,
             });
         }
 
         // Add links
-        for (const [device, lqi] of lqis) {
-            for (const neighbor of lqi.neighbors) {
+        for (const [device, table] of lqis) {
+            for (const neighbor of table) {
                 if (neighbor.relationship > 3) {
                     // Relationship is not active, skip it
                     continue;
                 }
 
+                let neighborEui64 = neighbor.eui64;
+
                 // Some Xiaomi devices return 0x00 as the neighbor ieeeAddr (obviously not correct).
                 // Determine the correct ieeeAddr based on the networkAddress.
-                if (neighbor.ieeeAddr === '0x0000000000000000') {
-                    const neighborDevice = this.zigbee.deviceByNetworkAddress(neighbor.networkAddress);
+                if (neighborEui64 === "0x0000000000000000") {
+                    const neighborDevice = this.zigbee.deviceByNetworkAddress(neighbor.nwkAddress);
 
                     if (neighborDevice) {
-                        neighbor.ieeeAddr = neighborDevice.ieeeAddr;
+                        neighborEui64 = neighborDevice.ieeeAddr as Eui64;
                     }
                 }
 
-                const link: Zigbee2MQTTNetworkMap['links'][number] = {
-                    source: {ieeeAddr: neighbor.ieeeAddr, networkAddress: neighbor.networkAddress},
+                const link: Zigbee2MQTTNetworkMap["links"][number] = {
+                    source: {ieeeAddr: neighborEui64, networkAddress: neighbor.nwkAddress},
                     target: {ieeeAddr: device.ieeeAddr, networkAddress: device.zh.networkAddress},
-                    linkquality: neighbor.linkquality,
-                    depth: neighbor.depth,
-                    routes: [],
-                    // DEPRECATED:
-                    sourceIeeeAddr: neighbor.ieeeAddr,
-                    targetIeeeAddr: device.ieeeAddr,
-                    sourceNwkAddr: neighbor.networkAddress,
-                    lqi: neighbor.linkquality,
+                    deviceType: neighbor.deviceType,
+                    rxOnWhenIdle: neighbor.rxOnWhenIdle,
                     relationship: neighbor.relationship,
+                    permitJoining: neighbor.permitJoining,
+                    depth: neighbor.depth,
+                    lqi: neighbor.lqi,
+                    routes: [],
+                    // below are @deprecated
+                    sourceIeeeAddr: neighborEui64,
+                    targetIeeeAddr: device.ieeeAddr,
+                    sourceNwkAddr: neighbor.nwkAddress,
+                    linkquality: neighbor.lqi,
                 };
 
                 const routingTable = routingTables.get(device);
 
                 if (routingTable) {
-                    for (const entry of routingTable.table) {
-                        if (entry.status === 'ACTIVE' && entry.nextHop === neighbor.networkAddress) {
+                    for (const entry of routingTable) {
+                        if (entry.nextHopAddress === neighbor.nwkAddress) {
                             link.routes.push(entry);
                         }
                     }

lib/extension/onEvent.ts

@@ -1,53 +1,86 @@
-import * as zhc from 'zigbee-herdsman-converters';
+import {onEvent, type OnEvent as ZhcOnEvent} from "zigbee-herdsman-converters";
 
-import utils from '../util/utils';
-import Extension from './extension';
+import utils from "../util/utils";
+import Extension from "./extension";
 
 /**
  * This extension calls the zigbee-herdsman-converters onEvent.
  */
 export default class OnEvent extends Extension {
-    override async start(): Promise<void> {
-        for (const device of this.zigbee.devicesIterator(utils.deviceNotCoordinator)) {
-            this.callOnEvent(device, 'start', {}).catch(utils.noop);
-        }
+    readonly #startCalled: Set<string> = new Set();
 
-        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, async (data) => {
-            if (data.entity.isDevice()) {
-                await this.callOnEvent(data.entity, 'deviceOptionsChanged', data).then(() => this.eventBus.emitDevicesChanged());
-            }
-        });
+    #getOnEventBaseData(device: Device): ZhcOnEvent.BaseData {
+        const deviceExposesChanged = (): void => this.eventBus.emitExposesAndDevicesChanged(device);
+        const state = this.state.get(device);
+        const options = device.options as KeyValue;
+        return {deviceExposesChanged, device: device.zh, state, options};
     }
 
-    private convertData(data: KeyValue): KeyValue {
-        return {...data, device: data.device.zh};
+    // biome-ignore lint/suspicious/useAwait: API
+    override async start(): Promise<void> {
+        for (const device of this.zigbee.devicesIterator(utils.deviceNotCoordinator)) {
+            // don't await, in case of repeated failures this would hold startup
+            this.callOnEvent(device, {type: "start", data: this.#getOnEventBaseData(device)}).catch(utils.noop);
+        }
+
+        this.eventBus.onDeviceJoined(this, async (data) => {
+            await this.callOnEvent(data.device, {type: "deviceJoined", data: this.#getOnEventBaseData(data.device)});
+        });
+        this.eventBus.onDeviceLeave(this, async (data) => {
+            if (data.device) {
+                await this.callOnEvent(data.device, {type: "stop", data: {ieeeAddr: data.device.ieeeAddr}});
+            }
+        });
+        this.eventBus.onEntityRemoved(this, async (data) => {
+            if (data.entity.isDevice()) {
+                await this.callOnEvent(data.entity, {type: "stop", data: {ieeeAddr: data.entity.ieeeAddr}});
+            }
+        });
+        this.eventBus.onDeviceInterview(this, async (data) => {
+            await this.callOnEvent(data.device, {type: "deviceInterview", data: {...this.#getOnEventBaseData(data.device), status: data.status}});
+        });
+        this.eventBus.onDeviceAnnounce(this, async (data) => {
+            await this.callOnEvent(data.device, {type: "deviceAnnounce", data: this.#getOnEventBaseData(data.device)});
+        });
+        this.eventBus.onDeviceNetworkAddressChanged(this, async (data) => {
+            await this.callOnEvent(data.device, {type: "deviceNetworkAddressChanged", data: this.#getOnEventBaseData(data.device)});
+        });
+        this.eventBus.onEntityOptionsChanged(this, async (data) => {
+            if (data.entity.isDevice()) {
+                await this.callOnEvent(data.entity, {
+                    type: "deviceOptionsChanged",
+                    data: {...this.#getOnEventBaseData(data.entity), from: data.from, to: data.to},
+                });
+                this.eventBus.emitDevicesChanged();
+            }
+        });
     }
 
     override async stop(): Promise<void> {
         await super.stop();
 
         for (const device of this.zigbee.devicesIterator(utils.deviceNotCoordinator)) {
-            await this.callOnEvent(device, 'stop', {});
+            await this.callOnEvent(device, {type: "stop", data: {ieeeAddr: device.ieeeAddr}});
         }
     }
 
-    private async callOnEvent(device: Device, type: zhc.OnEventType, data: KeyValue): Promise<void> {
-        if (device.options.disabled) return;
-        const state = this.state.get(device);
-        const deviceExposesChanged = (): void => this.eventBus.emitExposesAndDevicesChanged(data.device);
+    private async callOnEvent(device: Device, event: ZhcOnEvent.Event): Promise<void> {
+        if (device.options.disabled) {
+            return;
+        }
 
-        await zhc.onEvent(type, data, device.zh, {deviceExposesChanged});
+        if (event.type === "start") {
+            this.#startCalled.add(device.ieeeAddr);
+        } else if (event.type !== "stop" && !this.#startCalled.has(device.ieeeAddr) && device.definition?.onEvent) {
+            this.#startCalled.add(device.ieeeAddr);
+            await device.definition.onEvent({type: "start", data: this.#getOnEventBaseData(device)});
+        }
 
-        if (device.definition?.onEvent) {
-            const options: KeyValue = device.options;
-            await device.definition.onEvent(type, data, device.zh, options, state, {deviceExposesChanged});
+        await onEvent(event);
+        await device.definition?.onEvent?.(event);
+
+        if (event.type === "stop") {
+            this.#startCalled.delete(device.ieeeAddr);
         }
     }
 }

lib/extension/otaUpdate.ts

@@ -1,24 +1,21 @@
-import type {Zigbee2MQTTAPI} from 'lib/types/api';
-import type {Ota} 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";
 
-import assert from 'node:assert';
-import path from 'node:path';
+type UpdateState = "updating" | "idle" | "available" | "scheduled";
 
-import bind from 'bind-decorator';
-import stringify from 'json-stable-stringify-without-jsonify';
-
-import {Zcl} from 'zigbee-herdsman';
-import {ota} from 'zigbee-herdsman-converters';
-
-import Device from '../model/device';
-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';
-
-type UpdateState = 'updating' | 'idle' | 'available';
-interface UpdatePayload {
+export interface UpdatePayload {
     update: {
         progress?: number;
         remaining?: number;
@@ -28,12 +25,17 @@ interface UpdatePayload {
     };
 }
 
-const topicRegex = new RegExp(`^${settings.get().mqtt.base_topic}/bridge/request/device/ota_update/(update|check)/?(downgrade)?`, 'i');
-
 export default class OTAUpdate extends Extension {
-    private inProgress = new Set();
-    private lastChecked: {[s: string]: number} = {};
+    #topicRegex = new RegExp(
+        `^${settings.get().mqtt.base_topic}/bridge/request/device/ota_update/(update|check|schedule|unschedule)/?(downgrade)?`,
+        "i",
+    );
+    private inProgress = new Set<string>();
+    private lastChecked = new Map<string, number>();
+    private scheduledUpgrades = new Set<string>();
+    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);
@@ -61,8 +63,8 @@ export default class OTAUpdate extends Extension {
             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";
             }
         }
     }
@@ -77,60 +79,145 @@ export default class OTAUpdate extends Extension {
     }
 
     @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;
+        if (data.device.definition.ota) {
+            if (this.scheduledUpgrades.has(data.device.ieeeAddr) || this.scheduledDowngrades.has(data.device.ieeeAddr)) {
+                this.inProgress.add(data.device.ieeeAddr);
 
-        if (data.device.definition.ota && !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[data.device.ieeeAddr] !== undefined
-                    ? Date.now() - this.lastChecked[data.device.ieeeAddr] > updateCheckInterval
-                    : true;
-            if (!check) return;
+                logger.info(`Updating '${data.device.name}' to latest firmware`);
 
-            this.lastChecked[data.device.ieeeAddr] = Date.now();
-            let availableResult: Ota.UpdateAvailableResult | undefined;
+                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)}%`;
 
-            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})`);
+                            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
             }
 
-            await this.publishEntityState(data.device, this.getEntityPublishPayload(data.device, availableResult ?? 'idle'));
+            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;
+                }
+
+                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 stop the client from requesting OTAs
-        const endpoint = data.device.zh.endpoints.find((e) => e.supportsOutputCluster('genOta')) || data.endpoint;
+        const endpoint = data.device.zh.endpoints.find((e) => e.supportsOutputCluster("genOta")) || data.endpoint;
         await endpoint.commandResponse(
-            'genOta',
-            'queryNextImageResponse',
+            "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',
+        sendPolicy?: "immediate",
     ): Promise<{softwareBuildID: string; dateCode: string} | undefined> {
         try {
-            const endpoint = device.zh.endpoints.find((e) => e.supportsInputCluster('genBasic'));
+            const endpoint = device.zh.endpoints.find((e) => e.supportsInputCluster("genBasic"));
             assert(endpoint);
-            const result = await endpoint.read('genBasic', ['dateCode', 'swBuildId'], {sendPolicy});
+            const result = await endpoint.read("genBasic", ["dateCode", "swBuildId"], {sendPolicy});
             return {softwareBuildID: result.swBuildId, dateCode: result.dateCode};
         } catch {
             return undefined;
@@ -146,9 +233,9 @@ export default class OTAUpdate extends Extension {
         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,
+                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,
             },
         };
 
@@ -164,21 +251,24 @@ export default class OTAUpdate extends Extension {
     }
 
     @bind async onMQTTMessage(data: eventdata.MQTTMessage): Promise<void> {
-        const topicMatch = data.topic.match(topicRegex);
+        const topicMatch = data.topic.match(this.#topicRegex);
 
         if (!topicMatch) {
             return;
         }
 
         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'];
-        const ID = (typeof message === 'object' && message['id'] !== undefined ? message.id : message) as string;
+            | 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 = topicMatch[1];
-        const downgrade = Boolean(topicMatch[2]);
+        const type = topicMatch[1] as "check" | "update" | "schedule" | "unschedule";
+        const downgrade = topicMatch[2] === "downgrade";
         let error: string | undefined;
         let errorStack: string | undefined;
 
@@ -187,83 +277,148 @@ export default class OTAUpdate extends Extension {
         } else if (!device.definition || !device.definition.ota) {
             error = `Device '${device.name}' does not support OTA updates`;
         } 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}'`);
 
-                try {
-                    const availableResult = await ota.isUpdateAvailable(device.zh, device.otaExtraMetas, undefined, downgrade);
-                    const msg = `${availableResult.available ? 'Update' : 'No update'} available for '${device.name}'`;
-                    logger.info(msg);
+                    try {
+                        const availableResult = await ota.isUpdateAvailable(device.zh, device.otaExtraMetas, undefined, downgrade);
 
-                    await this.publishEntityState(device, this.getEntityPublishPayload(device, availableResult));
+                        logger.info(`${availableResult.available ? "Update" : "No update"} available for '${device.name}'`);
 
-                    this.lastChecked[device.ieeeAddr] = Date.now();
-                    const response = utils.getResponse<'bridge/response/device/ota_update/check'>(message, {
-                        id: ID,
-                        update_available: availableResult.available,
-                    });
+                        await this.publishEntityState(device, this.getEntityPublishPayload(device, availableResult));
+                        this.lastChecked.set(device.ieeeAddr, Date.now());
 
-                    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 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;
+                    }
+
+                    break;
                 }
-            } else {
-                // type === 'update'
-                const msg = `Updating '${device.name}' to ${downgrade ? 'previous' : 'latest'} firmware`;
-                logger.info(msg);
 
-                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)}%`;
+                case "update": {
+                    this.inProgress.add(device.ieeeAddr);
 
-                        if (remaining) {
-                            msg += `, ≈ ${Math.round(remaining / 60)} minutes remaining`;
+                    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`);
+                    }
+
+                    logger.info(`Updating '${device.name}' to ${downgrade ? "previous" : "latest"} firmware`);
+
+                    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}),
+                        );
 
-                        await this.publishEntityState(device, this.getEntityPublishPayload(device, 'updating', progress, remaining ?? undefined));
-                    });
+                        const firmwareTo = await this.readSoftwareBuildIDAndDateCode(device);
 
-                    logger.info(`Finished update of '${device.name}'`);
-                    this.removeProgressAndRemainingFromState(device);
-                    await this.publishEntityState(
-                        device,
-                        this.getEntityPublishPayload(device, {available: false, currentFileVersion: fileVersion, otaFileVersion: fileVersion}),
-                    );
+                        logger.info(() => `Device '${device.name}' was updated from '${stringify(firmwareFrom)}' to '${stringify(firmwareTo)}'`);
 
-                    const firmwareTo = await this.readSoftwareBuildIDAndDateCode(device);
+                        /**
+                         * 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();
 
-                    logger.info(() => `Device '${device.name}' was updated from '${stringify(firmwareFrom)}' to '${stringify(firmwareTo)}'`);
+                        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,
+                        });
 
-                    /**
-                     * 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();
+                        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;
 
-                    const response = utils.getResponse<'bridge/response/device/ota_update/update'>(message, {
+                        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`);
+                        }
+
+                        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`);
+                        }
+
+                        this.scheduledUpgrades.add(device.ieeeAddr);
+                    }
+
+                    logger.info(`Scheduled '${device.name}' to ${downgrade ? "downgrade" : "upgrade"} firmware on next request from device`);
+
+                    await this.publishEntityState(device, this.getEntityPublishPayload(device, "scheduled", undefined, undefined));
+
+                    const response = utils.getResponse<"bridge/response/device/ota_update/schedule">(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;
+                    await this.mqtt.publish("bridge/response/device/ota_update/schedule", stringify(response));
 
-                    this.removeProgressAndRemainingFromState(device);
-                    await this.publishEntityState(device, this.getEntityPublishPayload(device, 'available'));
+                    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;
                 }
             }
 

lib/extension/publish.ts

@@ -1,40 +1,41 @@
-import type * as zhc from 'zigbee-herdsman-converters';
+import bind from "bind-decorator";
+import stringify from "json-stable-stringify-without-jsonify";
+import type * as zhc from "zigbee-herdsman-converters";
 
-import bind from 'bind-decorator';
-import stringify from 'json-stable-stringify-without-jsonify';
-
-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';
+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";
 
+// TODO: get rid of this, use class member
 let topicGetSetRegex: RegExp;
-// Used by `publish.test.js` to reload regex when changing `mqtt.base_topic`.
+// Used by `publish.test.ts` to reload regex when changing `mqtt.base_topic`.
 export const loadTopicGetSetRegex = (): void => {
     topicGetSetRegex = new RegExp(`^${settings.get().mqtt.base_topic}/(?!bridge)(.+?)/(get|set)(?:/(.+))?$`);
 };
-loadTopicGetSetRegex();
 
-const STATE_VALUES: ReadonlyArray<string> = ['on', 'off', 'toggle', 'open', 'close', 'stop', 'lock', 'unlock'];
-const SCENE_CONVERTER_KEYS: ReadonlyArray<string> = ['scene_store', 'scene_add', 'scene_remove', 'scene_remove_all', 'scene_rename'];
+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 | undefined;
     attribute: string;
-    type: 'get' | 'set';
+    type: "get" | "set";
 }
 
 export default class Publish extends Extension {
+    // biome-ignore lint/suspicious/useAwait: API
     override async start(): Promise<void> {
+        loadTopicGetSetRegex();
         this.eventBus.onMQTTMessage(this, this.onMQTTMessage);
     }
 
     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)
@@ -53,7 +54,7 @@ export default class Publish extends Extension {
 
         // 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 | undefined {
@@ -67,11 +68,7 @@ export default class Publish extends Extension {
             try {
                 return JSON.parse(data.message);
             } catch {
-                if (STATE_VALUES.includes(data.message.toLowerCase())) {
-                    return {state: data.message};
-                } else {
-                    return undefined;
-                }
+                return STATE_VALUES.includes(data.message.toLowerCase()) ? {state: data.message} : undefined;
             }
         }
     }
@@ -86,10 +83,9 @@ export default class Publish extends Extension {
             const hasColorTemp = message.color_temp !== undefined;
             const hasColor = message.color !== undefined;
             const hasBrightness = message.brightness !== undefined;
-            const isOn = entityState.state === 'ON' ? true : false;
-            if (isOn && (hasColorTemp || hasColor) && !hasBrightness) {
+            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");
             }
         }
     }
@@ -139,9 +135,8 @@ export default class Publish extends Extension {
         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)!)]),
-                  )
+                ? // 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);
 
@@ -157,8 +152,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[]} = {};
@@ -176,7 +171,7 @@ export default class Publish extends Extension {
         };
 
         const endpointNames = re instanceof Device ? re.getEndpointNames() : [];
-        const propertyEndpointRegex = new RegExp(`^(.*?)_(${endpointNames.join('|')})$`);
+        const propertyEndpointRegex = new RegExp(`^(.*?)_(${endpointNames.join("|")})$`);
         let scenesChanged = false;
 
         for (const entry of entries) {
@@ -192,8 +187,7 @@ export default class Publish extends Extension {
             if (re instanceof Device && propertyEndpointMatch) {
                 endpointName = propertyEndpointMatch[2];
                 key = propertyEndpointMatch[1];
-                // endpointName is always matched to an existing endpoint of the device
-                // since `propertyEndpointRegex` only contains valid endpoints for this device.
+                // 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;
             }
@@ -205,19 +199,19 @@ export default class Publish extends Extension {
                     (!c.key || c.key.includes(key)) && (re instanceof Group || !c.endpoints || (endpointName && c.endpoints.includes(endpointName))),
             );
 
-            if (parsedTopic.type === 'set' && converter && 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.isZHEndpoint(localTarget) && re.endpointName(localTarget)) {
+            if (!Number.isNaN(Number(endpointName)) && re.isDevice() && utils.isZHEndpoint(localTarget) && re.endpointName(localTarget)) {
                 endpointName = re.endpointName(localTarget);
             }
 
@@ -231,6 +225,8 @@ export default class Publish extends Extension {
                 state: entityState,
                 membersState,
                 mapped: definition,
+                /* v8 ignore next */
+                publish: (payload: KeyValue) => this.publishEntityState(re, payload),
             };
 
             // Strip endpoint name from meta.message properties.
@@ -245,12 +241,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.optimistic === undefined || entitySettings.optimistic;
 
-                    if (result && result.state && optimistic) {
+                    if (result?.state && optimistic) {
                         const msg = result.state;
 
                         if (endpointName) {
@@ -266,12 +262,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)) {
+                            // biome-ignore lint/style/noNonNullAssertion: might be a bit much assumed here?
                             addToToPublish(this.zigbee.resolveEntity(ieeeAddr)!, state);
                         }
                     }
-                } 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 {
@@ -281,6 +278,7 @@ export default class Publish extends Extension {
             } catch (error) {
                 const message = `Publish '${parsedTopic.type}' '${key}' to '${re.name}' failed: '${error}'`;
                 logger.error(message);
+                // biome-ignore lint/style/noNonNullAssertion: always Error
                 logger.debug((error as Error).stack!);
             }
 
@@ -304,9 +302,9 @@ export default class Publish extends Extension {
 
     private getDefinitionConverters(definition: zhc.Definition | zhc.Definition[]): ReadonlyArray<zhc.Tz.Converter> {
         if (Array.isArray(definition)) {
-            return definition.length ? Array.from(new Set(definition.map((d) => d.toZigbee).flat())) : [];
-        } else {
-            return definition?.toZigbee;
+            return definition.length ? Array.from(new Set(definition.flatMap((d) => d.toZigbee))) : [];
         }
+
+        return definition?.toZigbee;
     }
 }

lib/extension/receive.ts

@@ -1,30 +1,32 @@
-import assert from 'node:assert';
+import assert from "node:assert";
 
-import bind from 'bind-decorator';
-import debounce from 'debounce';
-import stringify from 'json-stable-stringify-without-jsonify';
-import throttle from 'throttleit';
+import 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 * 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';
+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 throttlers: {[s: string]: {publish: PublishEntityState}} = {};
 
+    // 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
@@ -33,8 +35,8 @@ export default class Receive extends Extension {
         if (
             data.entity.isDevice() &&
             this.debouncers[data.entity.ieeeAddr] &&
-            data.stateChangeReason !== 'publishDebounce' &&
-            data.stateChangeReason !== 'lastSeenChanged'
+            data.stateChangeReason !== "publishDebounce" &&
+            data.stateChangeReason !== "lastSeenChanged"
         ) {
             for (const key of Object.keys(data.payload)) {
                 delete this.debouncers[data.entity.ieeeAddr].payload[key];
@@ -47,7 +49,7 @@ export default class Receive extends Extension {
             this.debouncers[device.ieeeAddr] = {
                 payload: {},
                 publish: debounce(async () => {
-                    await this.publishEntityState(device, this.debouncers[device.ieeeAddr].payload, 'publishDebounce');
+                    await this.publishEntityState(device, this.debouncers[device.ieeeAddr].payload, "publishDebounce");
                     this.debouncers[device.ieeeAddr].payload = {};
                 }, time * 1000),
             };
@@ -81,7 +83,7 @@ export default class Receive extends Extension {
         // 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');
+        await this.throttlers[device.ieeeAddr].publish(device, payload, "publishThrottle");
     }
 
     // if debounce_ignore are specified (Array of strings)
@@ -90,13 +92,12 @@ export default class Receive extends Extension {
     // otherwise payload is conflicted
     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;
     }
@@ -105,9 +106,9 @@ export default class Receive extends Extension {
         /* v8 ignore next */
         if (!data.device) return;
 
-        if (!data.device.definition || data.device.zh.interviewing) {
-            logger.debug(`Skipping message, still interviewing`);
-            await 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;
         }
 
@@ -117,13 +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)) {
+        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);
+            await utils.publishLastSeen({device: data.device, reason: "messageEmitted"}, settings.get(), true, this.publishEntityState);
             return;
         }
 
@@ -135,7 +136,7 @@ export default class Receive extends Extension {
         const publish = async (payload: KeyValue): Promise<void> => {
             assert(data.device.definition);
             const options: KeyValue = data.device.options;
-            zhc.postProcessConvertedFromZigbeeMessage(data.device.definition, payload, options);
+            zhc.postProcessConvertedFromZigbeeMessage(data.device.definition, payload, options, data.device.zh);
 
             if (settings.get().advanced.elapsed) {
                 const now = Date.now();
@@ -174,6 +175,7 @@ export default class Receive extends Extension {
                 /* 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 */
@@ -182,7 +184,7 @@ export default class Receive extends Extension {
         if (!utils.objectIsEmpty(payload)) {
             await publish(payload);
         } else {
-            await 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);
         }
     }
 }

lib/model/device.ts

@@ -1,17 +1,17 @@
-import assert from 'node:assert';
+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 zhc from 'zigbee-herdsman-converters';
-import {access, Numeric} from 'zigbee-herdsman-converters';
-import {CustomClusters} from 'zigbee-herdsman/dist/zspec/zcl/definition/tstype';
+import * as settings from "../util/settings";
 
-import * as settings from '../util/settings';
-
-const LINKQUALITY = new Numeric('linkquality', access.STATE)
-    .withUnit('lqi')
-    .withDescription('Link quality (signal strength)')
+const LINKQUALITY = new Numeric("linkquality", access.STATE)
+    .withUnit("lqi")
+    .withDescription("Link quality (signal strength)")
     .withValueMin(0)
     .withValueMax(255)
-    .withCategory('diagnostic');
+    .withCategory("diagnostic");
 
 export default class Device {
     public zh: zh.Device;
@@ -21,6 +21,7 @@ export default class Device {
     get ieeeAddr(): string {
         return this.zh.ieeeAddr;
     }
+    // biome-ignore lint/style/useNamingConvention: API
     get ID(): string {
         return this.zh.ieeeAddr;
     }
@@ -29,16 +30,19 @@ export default class Device {
         return {...settings.get().device_options, ...deviceOptions};
     }
     get name(): string {
-        return this.zh.type === 'Coordinator' ? 'Coordinator' : this.options?.friendly_name;
+        return this.zh.type === "Coordinator" ? "Coordinator" : this.options?.friendly_name;
     }
     get isSupported(): boolean {
-        return this.zh.type === 'Coordinator' || Boolean(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 : {};
+        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) {
@@ -47,8 +51,8 @@ export default class Device {
 
     exposes(): zhc.Expose[] {
         const exposes: zhc.Expose[] = [];
-        assert(this.definition, 'Cannot retreive exposes before definition is resolved');
-        if (typeof this.definition.exposes == 'function') {
+        assert(this.definition, "Cannot retreive exposes before definition is resolved");
+        if (typeof this.definition.exposes === "function") {
             const options: KeyValue = this.options;
             exposes.push(...this.definition.exposes(this.zh, options));
         } else {
@@ -58,71 +62,63 @@ export default class Device {
         return exposes;
     }
 
-    async resolveDefinition(ignoreCache: boolean = false): Promise<void> {
-        if (!this.zh.interviewing && (!this.definition || this._definitionModelID !== this.zh.modelID || ignoreCache)) {
+    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 | undefined {
-        let endpoint: zh.Endpoint | undefined;
-
-        if (key == null || key == '') {
-            key = 'default';
+        if (!key) {
+            key = "default";
+        } else if (!Number.isNaN(Number(key))) {
+            return this.zh.getEndpoint(Number(key));
         }
 
-        if (!isNaN(Number(key))) {
-            endpoint = this.zh.getEndpoint(Number(key));
-        } else if (this.definition?.endpoint) {
-            const ID = this.definition?.endpoint?.(this.zh)[key];
+        if (this.definition?.endpoint) {
+            const ID = this.definition.endpoint(this.zh)[key];
 
             if (ID) {
-                endpoint = this.zh.getEndpoint(ID);
-            } else if (key === 'default') {
-                endpoint = this.zh.endpoints[0];
-            } else {
-                return undefined;
+                return this.zh.getEndpoint(ID);
             }
-        } else {
-            if (key !== 'default') {
-                return undefined;
-            }
-
-            endpoint = this.zh.endpoints[0];
         }
 
-        return endpoint;
+        return key === "default" ? this.zh.endpoints[0] : undefined;
     }
 
     endpointName(endpoint: zh.Endpoint): string | undefined {
-        let epName = undefined;
+        let epName: string | undefined;
 
         if (this.definition?.endpoint) {
-            const mapping = this.definition?.endpoint(this.zh);
-            for (const [name, id] of Object.entries(mapping)) {
-                if (id == endpoint.ID) {
+            const mapping = this.definition.endpoint(this.zh);
+
+            for (const name in mapping) {
+                if (mapping[name] === endpoint.ID) {
                     epName = name;
+                    break;
                 }
             }
         }
 
         /* v8 ignore next */
-        return epName === 'default' ? undefined : epName;
+        return epName === "default" ? undefined : epName;
     }
 
     getEndpointNames(): string[] {
         const names: string[] = [];
 
-        for (const name in this.definition?.endpoint?.(this.zh) ?? {}) {
-            if (name !== 'default') {
-                names.push(name);
+        if (this.definition?.endpoint) {
+            for (const name in this.definition.endpoint(this.zh)) {
+                if (name !== "default") {
+                    names.push(name);
+                }
             }
         }
 

lib/model/group.ts

@@ -1,16 +1,17 @@
-import * as zhc from 'zigbee-herdsman-converters';
-
-import * as settings from '../util/settings';
+import type * as zhc from "zigbee-herdsman-converters";
+import * as settings from "../util/settings";
+import {DEFAULT_BIND_GROUP_ID} from "../util/utils";
 
 export default class Group {
     public zh: zh.Group;
     private resolveDevice: (ieeeAddr: string) => Device | undefined;
 
+    // biome-ignore lint/style/useNamingConvention: API
     get ID(): number {
         return this.zh.groupID;
     }
     get options(): GroupOptions {
-        // XXX: Group always exists in settings
+        // biome-ignore lint/style/noNonNullAssertion: Group always exists in settings
         return {...settings.getGroup(this.ID)!};
     }
     get name(): string {
@@ -22,12 +23,24 @@ export default class Group {
         this.resolveDevice = resolveDevice;
     }
 
+    ensureInSettings(): void {
+        if (this.ID !== DEFAULT_BIND_GROUP_ID && !settings.getGroup(this.ID)) {
+            settings.addGroup(this.name, this.ID.toString());
+        }
+    }
+
     hasMember(device: Device): boolean {
         return !!device.zh.endpoints.find((e) => this.zh.members.includes(e));
     }
 
-    membersDevices(): Device[] {
-        return this.zh.members.map((d) => this.resolveDevice(d.getDevice().ieeeAddr)!);
+    *membersDevices(): Generator<Device> {
+        for (const member of this.zh.members) {
+            const resolvedDevice = this.resolveDevice(member.deviceIeeeAddress);
+
+            if (resolvedDevice) {
+                yield resolvedDevice;
+            }
+        }
     }
 
     membersDefinitions(): zhc.Definition[] {

lib/mqtt.ts

@@ -1,30 +1,55 @@
-import type {IClientOptions, IClientPublishOptions, MqttClient} from 'mqtt';
+import fs from "node:fs";
+import bind from "bind-decorator";
+import type {IClientOptions, IClientPublishOptions, MqttClient} from "mqtt";
+import {connectAsync} from "mqtt";
+import type {Zigbee2MQTTAPI} from "./types/api";
 
-import type {Zigbee2MQTTAPI} from './types/api';
+import logger from "./util/logger";
+import * as settings from "./util/settings";
+import utils from "./util/utils";
 
-import fs from 'node:fs';
+const NS = "z2m:mqtt";
 
-import bind from 'bind-decorator';
-import {connectAsync} from 'mqtt';
+export interface MqttPublishOptions {
+    clientOptions: IClientPublishOptions;
+    baseTopic: string;
+    skipLog: boolean;
+    skipReceive: boolean;
+    meta: {isEntityState?: boolean};
+}
 
-import logger from './util/logger';
-import * as settings from './util/settings';
-import utils from './util/utils';
-
-const NS = 'z2m:mqtt';
-
-export default class MQTT {
-    private publishedTopics: Set<string> = new Set();
+export default class Mqtt {
+    private publishedTopics = new Set<string>();
     private connectionTimer?: NodeJS.Timeout;
     private client!: MqttClient;
     private eventBus: EventBus;
     private republishRetainedTimer?: NodeJS.Timeout;
-    public retainedMessages: {
-        [s: string]: {payload: string; options: IClientPublishOptions; skipLog: boolean; skipReceive: boolean; topic: string; base: string};
-    } = {};
+    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> {
@@ -35,8 +60,8 @@ export default class MQTT {
         const options: IClientOptions = {
             will: {
                 topic: `${settings.get().mqtt.base_topic}/bridge/state`,
-                payload: Buffer.from(JSON.stringify({state: 'offline'})),
-                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},
@@ -71,7 +96,7 @@ export default class MQTT {
             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) {
@@ -80,7 +105,7 @@ export default class MQTT {
         }
 
         if (mqttSettings.reject_unauthorized !== undefined && !mqttSettings.reject_unauthorized) {
-            logger.debug(`MQTT reject_unauthorized set false, ignoring certificate warnings.`);
+            logger.debug("MQTT reject_unauthorized set false, ignoring certificate warnings.");
             options.rejectUnauthorized = false;
         }
 
@@ -89,34 +114,34 @@ export default class MQTT {
         // https://github.com/Koenkk/zigbee2mqtt/issues/9822
         this.client.stream.setMaxListeners(0);
 
-        this.client.on('error', (err) => {
+        this.client.on("error", (err) => {
             logger.error(`MQTT error: ${err.message}`);
         });
 
-        if (mqttSettings.version != undefined && mqttSettings.version >= 5) {
-            this.client.on('disconnect', (packet) => {
+        if (mqttSettings.version != null && mqttSettings.version >= 5) {
+            this.client.on("disconnect", (packet) => {
                 logger.error(`MQTT disconnect: reason ${packet.reasonCode} (${packet.properties?.reasonString})`);
             });
         }
 
-        this.client.on('message', this.onMessage);
+        this.client.on("message", this.onMessage);
 
         await this.onConnect();
 
-        this.client.on('connect', 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, msg.base, msg.skipLog, msg.skipReceive);
+                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!');
+                logger.error("Not connected to MQTT server!");
             }
         }, utils.seconds(10));
     }
@@ -125,11 +150,11 @@ export default class MQTT {
         clearTimeout(this.connectionTimer);
         clearTimeout(this.republishRetainedTimer);
 
-        const stateData: Zigbee2MQTTAPI['bridge/state'] = {state: 'offline'};
+        const stateData: Zigbee2MQTTAPI["bridge/state"] = {state: "offline"};
 
-        await this.publish('bridge/state', JSON.stringify(stateData), {retain: true, qos: 0});
+        await this.publish("bridge/state", JSON.stringify(stateData), {clientOptions: {retain: true}});
         this.eventBus.removeListeners(this);
-        logger.info('Disconnecting from MQTT server');
+        logger.info("Disconnecting from MQTT server");
         await this.client?.endAsync();
     }
 
@@ -142,11 +167,11 @@ export default class MQTT {
     }
 
     @bind private async onConnect(): Promise<void> {
-        logger.info('Connected to MQTT server');
+        logger.info("Connected to MQTT server");
 
-        const stateData: Zigbee2MQTTAPI['bridge/state'] = {state: 'online'};
+        const stateData: Zigbee2MQTTAPI["bridge/state"] = {state: "online"};
 
-        await this.publish('bridge/state', JSON.stringify(stateData), {retain: true, qos: 0});
+        await this.publish("bridge/state", JSON.stringify(stateData), {clientOptions: {retain: true, qos: 1}});
         await this.subscribe(`${settings.get().mqtt.base_topic}/#`);
     }
 
@@ -168,54 +193,51 @@ export default class MQTT {
         return this.client && !this.client.reconnecting && !this.client.disconnecting && !this.client.disconnected;
     }
 
-    async publish(
-        topic: string,
-        payload: string,
-        options: IClientPublishOptions = {},
-        base = settings.get().mqtt.base_topic,
-        skipLog = false,
-        skipReceive = true,
-    ): Promise<void> {
-        const defaultOptions = {qos: 0 as const, 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()) {
-            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) {
+        let clientOptions: IClientPublishOptions = finalOptions.clientOptions;
+        if (settings.get().mqtt.force_disable_retain) {
+            clientOptions = {...finalOptions.clientOptions, retain: false};
+        }
+
+        if (!finalOptions.skipLog) {
             logger.info(() => `MQTT publish: topic '${topic}', payload '${payload}'`, NS);
         }
 
-        const actualOptions: IClientPublishOptions = {...defaultOptions, ...options};
-
-        if (settings.get().mqtt.force_disable_retain) {
-            actualOptions.retain = false;
-        }
-
         try {
-            await this.client.publishAsync(topic, payload, actualOptions);
+            await this.client.publishAsync(topic, payload, clientOptions);
         } catch (error) {
-            if (!skipLog) {
+            if (!finalOptions.skipLog) {
                 logger.error(`MQTT server error: ${(error as Error).message}`);
                 logger.error(`Could not send message: topic: '${topic}', payload: '${payload}`);
             }

lib/state.ts

@@ -1,39 +1,38 @@
-import fs from 'node:fs';
+import {existsSync, readFileSync, writeFileSync} from "node:fs";
 
-import objectAssignDeep from 'object-assign-deep';
+import objectAssignDeep from "object-assign-deep";
 
-import data from './util/data';
-import logger from './util/logger';
-import * as settings from './util/settings';
-import utils from './util/utils';
+import data from "./util/data";
+import logger from "./util/logger";
+import * as settings from "./util/settings";
+import utils from "./util/utils";
 
-const saveInterval = 1000 * 60 * 5; // 5 minutes
-
-const dontCacheProperties = [
-    '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
+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 readonly state = new Map<string | number, KeyValue>();
+    private readonly file = data.joinPath("state.json");
     private timer?: NodeJS.Timeout;
 
     constructor(
@@ -48,23 +47,37 @@ 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 (error) {
                 logger.debug(`Failed to load state from file ${this.file} (corrupt file?) (${(error as Error).message})`);
@@ -77,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');
+                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[entity.ID] !== undefined;
+        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): KeyValue {
-        const fromState = this.state[entity.ID] || {};
+        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);
     }
 }
 

lib/types/dom.shim.d.ts

@@ -0,0 +1,18 @@
+// minimal required because of sub-deps in mqtt >= 5.14.0 to avoid requiring `dom` type
+declare global {
+    // map to node, doesn't really matter, just needs to be there, and the right "type vs value" to avoid lib check problems
+    /** @deprecated DOM SHIM, DO NOT USE */
+    type MessagePort = import("node:worker_threads").MessagePort;
+    /** @deprecated DOM SHIM, DO NOT USE */
+    type Worker = import("node:worker_threads").Worker;
+    /** @deprecated DOM SHIM, DO NOT USE */
+    type Transferable = import("node:worker_threads").Transferable;
+    /** @deprecated DOM SHIM, DO NOT USE */
+    const addEventListener: import("node:events").EventEmitter["addListener"];
+    /** @deprecated DOM SHIM, DO NOT USE */
+    const removeEventListener: import("node:events").EventEmitter["removeListener"];
+    /** @deprecated DOM SHIM, DO NOT USE */
+    const postMessage: import("node:worker_threads").MessagePort["postMessage"];
+}
+
+export {};

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

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

lib/types/types.d.ts

@@ -1,21 +1,20 @@
-import type TypeEventBus from 'lib/eventBus';
-import type TypeExtension from 'lib/extension/extension';
-import type TypeDevice from 'lib/model/device';
-import type TypeGroup from 'lib/model/group';
-import type TypeMQTT from 'lib/mqtt';
-import type TypeState from 'lib/state';
-import type TypeZigbee from 'lib/zigbee';
-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 {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 {LogLevel} from 'lib/util/settings';
-
-type OptionalProps<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+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;
@@ -23,11 +22,12 @@ declare global {
     type Extension = TypeExtension;
 
     // Types
-    type StateChangeReason = 'publishDebounce' | 'groupOptimistic' | 'lastSeenChanged' | 'publishCached' | 'publishThrottle';
+    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 {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        // biome-ignore lint/suspicious/noExplicitAny: API
         [s: string]: any;
     }
 
@@ -36,8 +36,6 @@ declare global {
         type Endpoint = ZHModels.Endpoint;
         type Device = ZHModels.Device;
         type Group = ZHModels.Group;
-        type LQI = ZHAdapterTypes.LQI;
-        type RoutingTable = ZHAdapterTypes.RoutingTable;
         type CoordinatorVersion = ZHAdapterTypes.CoordinatorVersion;
         type NetworkParameters = ZHAdapterTypes.NetworkParameters;
         interface Bind {
@@ -48,9 +46,9 @@ declare global {
 
     namespace eventdata {
         type EntityRenamed = {entity: Device | Group; homeAssisantRename: boolean; from: string; to: string};
-        type EntityRemoved = {id: number | string; name: string; type: 'device' | 'group'};
+        type EntityRemoved = {entity: Device | Group; name: string};
         type MQTTMessage = {topic: string; message: string};
-        type MQTTMessagePublished = {topic: string; payload: string; options: {retain: boolean; qos: number}};
+        type MQTTMessagePublished = {topic: string; payload: string; options: MqttPublishOptions};
         type StateChange = {
             entity: Device | Group;
             from: KeyValue;
@@ -61,172 +59,39 @@ declare global {
         type PermitJoinChanged = ZHEvents.PermitJoinChangedPayload;
         type LastSeenChanged = {
             device: Device;
-            reason: 'deviceAnnounce' | 'networkAddress' | 'deviceJoined' | 'messageEmitted' | 'messageNonEmitted';
+            reason: "deviceAnnounce" | "networkAddress" | "deviceJoined" | "messageEmitted" | "messageNonEmitted";
         };
         type DeviceNetworkAddressChanged = {device: Device};
         type DeviceAnnounce = {device: Device};
-        type DeviceInterview = {device: Device; status: 'started' | 'successful' | 'failed'};
+        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 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; rawData: Buffer};
         };
         type ScenesChanged = {entity: Device | Group};
     }
 
     // Settings
-    interface Settings {
-        version?: number;
-        homeassistant: {
-            enabled: boolean;
-            discovery_topic: string;
-            status_topic: string;
-            experimental_event_entities: boolean;
-            legacy_action_sensor: boolean;
-        };
-        availability: {
-            enabled: boolean;
-            active: {timeout: 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';
-            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;
-            auth_token?: string;
-            host?: string;
-            port: number;
-            base_url: string;
-            url?: string;
-            ssl_cert?: string;
-            ssl_key?: string;
-        };
-        devices: {[s: string]: DeviceOptions};
-        groups: {[s: string]: Omit<GroupOptions, '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;
-            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;
-        };
-    }
+    type Settings = Zigbee2MQTTSettings;
 
-    interface DeviceOptions {
-        disabled?: boolean;
-        retention?: number;
-        availability?: boolean | {timeout: 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;
-    }
+    type DeviceOptions = Zigbee2MQTTDeviceOptions;
 
     interface DeviceOptionsWithId extends DeviceOptions {
         ID: string;
     }
 
-    interface GroupOptions {
-        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;
-    }
+    type GroupOptions = Zigbee2MQTTGroupOptions;
 }

lib/types/unix-dgram.d.ts

@@ -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;
+}

lib/types/zigbee2mqtt-frontend.d.ts

@@ -1,16 +1,14 @@
-declare module 'zigbee2mqtt-frontend' {
-    export function getPath(): string;
+declare module "zigbee2mqtt-frontend" {
+    const frontend: {
+        getPath: () => string;
+    };
+
+    export default frontend;
 }
 
-declare module 'http' {
+declare module "http" {
     interface IncomingMessage {
         originalUrl?: string;
         path?: string;
     }
 }
-
-declare module 'express-static-gzip' {
-    import {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;
-}

lib/util/data.ts

@@ -1,7 +1,7 @@
-import path from 'node:path';
+import path from "node:path";
 
 function setPath(): string {
-    return process.env.ZIGBEE2MQTT_DATA ? process.env.ZIGBEE2MQTT_DATA : path.normalize(path.join(__dirname, '..', '..', 'data'));
+    return process.env.ZIGBEE2MQTT_DATA ? process.env.ZIGBEE2MQTT_DATA : path.normalize(path.join(__dirname, "..", "..", "data"));
 }
 
 let dataPath = setPath();
@@ -18,4 +18,5 @@ function _testReload(): void {
     dataPath = setPath();
 }
 
+// biome-ignore lint/style/useNamingConvention: test
 export default {joinPath, getPath, _testReload};

lib/util/logger.ts

@@ -1,14 +1,12 @@
-import assert from 'node:assert';
-import fs from 'node:fs';
-import path from 'node:path';
+import assert from "node:assert";
+import fs from "node:fs";
+import path from "node:path";
 
-import moment from 'moment';
-import {rimrafSync} from 'rimraf';
-import winston from 'winston';
+import {rimrafSync} from "rimraf";
+import winston from "winston";
+import * as settings from "./settings";
 
-import * as settings from './settings';
-
-const NAMESPACE_SEPARATOR = ':';
+const NAMESPACE_SEPARATOR = ":";
 
 class Logger {
     // @ts-expect-error initalized in `init`
@@ -31,26 +29,27 @@ class Logger {
         // 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);
+        const timestamp = new Date().toISOString().slice(0, 19).replace("T", ".").replace(/:/g, "-");
+        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(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);
+        assert(settings.LOG_LEVELS.includes(this.level), `'${this.level}' is not valid log_level, use one of '${settings.LOG_LEVELS.join(", ")}'`);
 
         this.logger = winston.createLogger({
-            level: 'debug',
-            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: settings.get().advanced.timestamp_format}),
+            ),
             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(
@@ -60,7 +59,7 @@ class Logger {
                     ? 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.colorize({colors: {debug: "blue", info: "green", warning: "yellow", error: "red"}}),
                           winston.format.printf((info) => {
                               return `[${info.timestamp}] ${info.level}: \t${info.message}`;
                           }),
@@ -68,15 +67,15 @@ class Logger {
             }),
         );
 
-        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
             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;
+                const current = settings.get().advanced.log_directory.replace("%TIMESTAMP%", "current");
+                const actual = `./${timestamp}`;
 
                 /* v8 ignore start */
                 if (fs.existsSync(current)) {
@@ -108,18 +107,17 @@ class Logger {
         }
 
         /* v8 ignore start */
-        if (this.output.includes('syslog')) {
-            logging += `, syslog`;
-            // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-unused-expressions
-            require('winston-syslog').Syslog;
+        if (this.output.includes("syslog")) {
+            logging += ", syslog";
+            require("winston-syslog").Syslog;
 
             const options: KeyValue = {
-                app_name: 'Zigbee2MQTT',
+                app_name: "Zigbee2MQTT",
                 format: winston.format.printf((info) => info.message as string),
                 ...settings.get().advanced.log_syslog,
             };
 
-            if (options['type'] !== undefined) {
+            if (options.type !== undefined) {
                 options.type = options.type.toString();
             }
 
@@ -146,11 +144,15 @@ class Logger {
     }
 
     public getDebugNamespaceIgnore(): string {
-        return this.debugNamespaceIgnoreRegex?.toString().slice(1, -1) /* remove slashes */ ?? '';
+        return (
+            this.debugNamespaceIgnoreRegex
+                ?.toString()
+                .slice(1, -1) /* remove slashes */ ?? ""
+        );
     }
 
     public setDebugNamespaceIgnore(value: string): void {
-        this.debugNamespaceIgnoreRegex = value != '' ? new RegExp(value) : undefined;
+        this.debugNamespaceIgnoreRegex = value !== "" ? new RegExp(value) : undefined;
     }
 
     public getLevel(): settings.LogLevel {
@@ -178,11 +180,13 @@ class Logger {
     private cacheNamespacedLevel(namespace: string): string {
         let cached = namespace;
 
-        while (this.cachedNamespacedLevels[namespace] == undefined) {
+        while (this.cachedNamespacedLevels[namespace] === undefined) {
             const sep = cached.lastIndexOf(NAMESPACE_SEPARATOR);
 
             if (sep === -1) {
-                return (this.cachedNamespacedLevels[namespace] = this.level);
+                this.cachedNamespacedLevels[namespace] = this.level;
+
+                return this.level;
             }
 
             cached = cached.slice(0, sep);
@@ -201,30 +205,30 @@ class Logger {
         }
     }
 
-    public error(messageOrLambda: string | (() => string), namespace: string = 'z2m'): void {
-        this.log('error', messageOrLambda, namespace);
+    public error(messageOrLambda: string | (() => string), namespace = "z2m"): void {
+        this.log("error", messageOrLambda, namespace);
     }
 
-    public warning(messageOrLambda: string | (() => string), namespace: string = 'z2m'): void {
-        this.log('warning', messageOrLambda, namespace);
+    public warning(messageOrLambda: string | (() => string), namespace = "z2m"): void {
+        this.log("warning", messageOrLambda, namespace);
     }
 
-    public info(messageOrLambda: string | (() => string), namespace: string = 'z2m'): void {
-        this.log('info', messageOrLambda, namespace);
+    public info(messageOrLambda: string | (() => string), namespace = "z2m"): void {
+        this.log("info", messageOrLambda, namespace);
     }
 
-    public debug(messageOrLambda: string | (() => string), namespace: string = 'z2m'): void {
+    public debug(messageOrLambda: string | (() => string), namespace = "z2m"): void {
         if (this.debugNamespaceIgnoreRegex?.test(namespace)) {
             return;
         }
 
-        this.log('debug', messageOrLambda, namespace);
+        this.log("debug", messageOrLambda, namespace);
     }
 
     // Cleanup any old log directory.
     private cleanup(): void {
-        if (settings.get().advanced.log_directory.includes('%TIMESTAMP%')) {
-            const rootDirectory = path.join(this.directory, '..');
+        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);
@@ -232,11 +236,12 @@ 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);
-            });
+            }
         }
     }
 
@@ -252,10 +257,10 @@ class Logger {
                 // @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();
             });

lib/util/onboarding.ts

@@ -0,0 +1,611 @@
+import {existsSync, mkdirSync} from "node:fs";
+import {createServer} from "node:http";
+import {parse} from "node:querystring";
+import {findAllDevices} from "zigbee-herdsman/dist/adapter/adapterDiscovery";
+import data from "./data";
+import * as settings from "./settings";
+import {YAMLFileException} from "./yaml";
+
+type OnboardSettings = {
+    mqtt_base_topic?: string;
+    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" : ""}
+                    ${process.env.ZIGBEE2MQTT_CONFIG_SERIAL_RTSCTS ? "disabled" : ""}>
+                    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">
+                    <input
+                        type="checkbox"
+                        id="homeassistant_enabled"
+                        name="homeassistant_enabled"
+                        ${currentSettings.homeassistant?.enabled ? "checked" : ""}
+                        ${process.env.ZIGBEE2MQTT_CONFIG_HOMEASSISTANT_ENABLED ? "disabled" : ""}>
+                    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, 10), 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, 10), serverUrl.hostname, () => {
+            console.error(`Failure page is available at ${serverUrl.href}`);
+        });
+    });
+
+    await new Promise((resolve) => server?.close(resolve));
+}
+
+async function onSettingsErrors(errors: string[]): Promise<void> {
+    let pErrors = "";
+
+    console.error("\n\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+    console.error("            READ THIS CAREFULLY\n");
+    console.error("Refusing to start because configuration is not valid, found the following errors:");
+
+    for (const error of errors) {
+        console.error(`- ${error}`);
+
+        pErrors += `<p>- ${escapeHtml(error)}</p>`;
+    }
+
+    console.error("\nIf you don't know how to solve this, read https://www.zigbee2mqtt.io/guide/configuration");
+    console.error("\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n\n");
+
+    if (!process.env.Z2M_ONBOARD_NO_SERVER && !process.env.Z2M_ONBOARD_NO_FAILURE_PAGE) {
+        await startFailureServer(pErrors);
+    }
+}
+
+export async function onboard(): Promise<boolean> {
+    if (!existsSync(data.getPath())) {
+        mkdirSync(data.getPath(), {recursive: true});
+    }
+
+    const confExists = existsSync(data.joinPath("configuration.yaml"));
+
+    if (confExists) {
+        // initial caching, ensure file is valid yaml first
+        try {
+            settings.getPersistedSettings();
+        } catch (error) {
+            await onSettingsErrors(
+                error instanceof YAMLFileException
+                    ? [`Your configuration file: '${error.file}' is invalid (use https://jsonformatter.org/yaml-validator to find and fix the issue)`]
+                    : [`${error}`],
+            );
+
+            return false;
+        }
+
+        // migrate first
+        const {migrateIfNecessary} = await import("./settingsMigration.js");
+
+        migrateIfNecessary();
+
+        // make sure existing settings are valid before applying envs
+        const errors = settings.validateNonRequired();
+
+        if (errors.length > 0) {
+            await onSettingsErrors(errors);
+
+            return false;
+        }
+
+        // trigger initial writing of `ZIGBEE2MQTT_CONFIG_*` ENVs
+        settings.write();
+    } else {
+        settings.writeMinimalDefaults();
+    }
+
+    // use `configuration.yaml` file to detect "brand new install"
+    // 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) {
+        await onSettingsErrors(errors);
+
+        return false;
+    }
+
+    return true;
+}

lib/util/sd-notify.ts

@@ -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 => {},
+    };
+}

lib/util/settings.schema.json

@@ -67,7 +67,28 @@
                             "title": "Timeout",
                             "requiresRestart": true,
                             "default": 10,
+                            "minimum": 1,
                             "description": "Time after which an active device will be marked as offline in minutes"
+                        },
+                        "max_jitter": {
+                            "type": "number",
+                            "title": "Max jitter",
+                            "default": 30000,
+                            "minimum": 1000,
+                            "description": "Maximum jitter (in msec) allowed on timeout to avoid availability pings trying to trigger around the same time"
+                        },
+                        "backoff": {
+                            "type": "boolean",
+                            "title": "Backoff",
+                            "description": "Enable timeout backoff on failed availability pings (x1.5, x3, x6, x12...)",
+                            "default": true
+                        },
+                        "pause_on_backoff_gt": {
+                            "type": "number",
+                            "title": "Pause on backoff greater than",
+                            "default": 0,
+                            "minimum": 0,
+                            "description": "Pause availability pings when backoff reaches over this limit until a new Zigbee message is received from the device. A value of zero disables pausing."
                         }
                     },
                     "required": ["timeout"]
@@ -83,6 +104,7 @@
                             "title": "Timeout",
                             "requiresRestart": true,
                             "default": 1500,
+                            "minimum": 1,
                             "description": "Time after which an passive device will be marked as offline in minutes"
                         }
                     },
@@ -218,8 +240,8 @@
                     "default": false
                 },
                 "adapter": {
-                    "type": ["string"],
-                    "enum": ["deconz", "zstack", "zigate", "ezsp", "ember", "zboss"],
+                    "type": "string",
+                    "enum": ["deconz", "zstack", "zigate", "ezsp", "ember", "zboss", "zoh"],
                     "title": "Adapter",
                     "requiresRestart": true,
                     "description": "Adapter type, not needed unless you are experiencing problems"
@@ -228,8 +250,8 @@
                     "type": "number",
                     "title": "Baudrate",
                     "requiresRestart": true,
-                    "description": "Baud rate speed for serial port, this can be anything firmware support but default is 115200 for Z-Stack and EZSP, 38400 for Deconz, however note that some EZSP firmware need 57600",
-                    "examples": [38400, 57600, 115200]
+                    "description": "Baud rate speed for the serial port. This must match what the firmware on your adapter supports (most commonly 115200).",
+                    "examples": [115200, 921600, 460800, 230400, 57600, 38400]
                 },
                 "rtscts": {
                     "type": "boolean",
@@ -271,13 +293,16 @@
                                     "type": "object",
                                     "properties": {
                                         "enddevice": {
-                                            "type": "string"
+                                            "type": "string",
+                                            "default": "#fff8ce"
                                         },
                                         "coordinator": {
-                                            "type": "string"
+                                            "type": "string",
+                                            "default": "#e04e5d"
                                         },
                                         "router": {
-                                            "type": "string"
+                                            "type": "string",
+                                            "default": "#4ea3e0"
                                         }
                                     }
                                 },
@@ -285,13 +310,16 @@
                                     "type": "object",
                                     "properties": {
                                         "enddevice": {
-                                            "type": "string"
+                                            "type": "string",
+                                            "default": "#000000"
                                         },
                                         "coordinator": {
-                                            "type": "string"
+                                            "type": "string",
+                                            "default": "#ffffff"
                                         },
                                         "router": {
-                                            "type": "string"
+                                            "type": "string",
+                                            "default": "#ffffff"
                                         }
                                     }
                                 },
@@ -299,10 +327,12 @@
                                     "type": "object",
                                     "properties": {
                                         "active": {
-                                            "type": "string"
+                                            "type": "string",
+                                            "default": "#009900"
                                         },
                                         "inactive": {
-                                            "type": "string"
+                                            "type": "string",
+                                            "default": "#994444"
                                         }
                                     }
                                 }
@@ -320,7 +350,8 @@
                     "type": "number",
                     "title": "Update check interval",
                     "description": "Your device may request a check for a new firmware update. This value determines how frequently third party servers may actually be contacted to look for firmware updates. The value is set in minutes, and the default is 1 day.",
-                    "default": 1440
+                    "default": 1440,
+                    "minimum": 1
                 },
                 "disable_automatic_update_check": {
                     "type": "boolean",
@@ -365,6 +396,14 @@
                     "default": false,
                     "requiresRestart": true
                 },
+                "package": {
+                    "type": "string",
+                    "enum": ["zigbee2mqtt-windfront", "zigbee2mqtt-frontend"],
+                    "title": "Package",
+                    "default": "zigbee2mqtt-windfront",
+                    "requiresRestart": true,
+                    "description": "Package used for the frontend"
+                },
                 "port": {
                     "type": "number",
                     "title": "Port",
@@ -410,6 +449,20 @@
                     "description": "Base URL for the frontend. If hosted under a subpath, e.g. 'http://localhost:8080/z2m', set this to '/z2m'",
                     "default": "/",
                     "requiresRestart": true
+                },
+                "notification_filter": {
+                    "title": "Notification Filter",
+                    "description": "Hide frontend notifications matching specified regex strings. Example: 'z2m: Failed to ping.*'",
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                },
+                "disable_ui_serving": {
+                    "type": ["boolean", "null"],
+                    "title": "Disable UI serving",
+                    "description": "If true, the frontend UI is not served, only the WebSocket is maintained by Zigbee2MQTT (you are required to serve a standalone UI yourself as needed).",
+                    "requiresRestart": true
                 }
             },
             "required": []
@@ -473,7 +526,8 @@
                         "enum": ["console", "file", "syslog"]
                     },
                     "title": "Log output",
-                    "description": "Output location of the log, leave empty to suppress logging"
+                    "description": "Output location of the log, leave empty to suppress logging",
+                    "default": ["console", "file"]
                 },
                 "log_directory": {
                     "type": "string",
@@ -488,7 +542,7 @@
                     "requiresRestart": true,
                     "description": "Log file name, can also contain timestamp",
                     "examples": ["zigbee2mqtt_%TIMESTAMP%.log"],
-                    "default": "log.txt"
+                    "default": "log.log"
                 },
                 "log_level": {
                     "type": "string",
@@ -509,7 +563,14 @@
                     "title": "Log Namespaced Levels",
                     "description": "Set individual log levels for certain namespaces",
                     "default": {},
-                    "examples": [{"z2m:mqtt": "warning"}, {"zh:ember:uart:ash": "info"}]
+                    "examples": [
+                        {
+                            "z2m:mqtt": "warning"
+                        },
+                        {
+                            "zh:ember:uart:ash": "info"
+                        }
+                    ]
                 },
                 "log_debug_to_mqtt_frontend": {
                     "type": "boolean",
@@ -525,6 +586,14 @@
                     "default": "",
                     "examples": ["^zhc:legacy:fz:(tuya|moes)", "^zhc:legacy:fz:(tuya|moes)|^zh:ember:uart:|^zh:controller"]
                 },
+                "log_directories_to_keep": {
+                    "type": "number",
+                    "title": "Number of past log folders to keep",
+                    "description": "Number of log directories to keep before deleting the oldest one",
+                    "default": 10,
+                    "minimum": 5,
+                    "maximum": 1000
+                },
                 "log_syslog": {
                     "requiresRestart": true,
                     "oneOf": [
@@ -604,12 +673,15 @@
                         },
                         {
                             "type": "number",
-                            "title": "Pan ID (number)"
+                            "title": "Pan ID (number)",
+                            "minimum": 1,
+                            "maximum": 65534
                         }
                     ],
                     "title": "Pan ID",
                     "requiresRestart": true,
-                    "description": "ZigBee pan ID, changing requires re-pairing all devices!"
+                    "description": "Zigbee pan ID, changing requires re-pairing all devices!",
+                    "default": 6754
                 },
                 "ext_pan_id": {
                     "oneOf": [
@@ -627,14 +699,15 @@
                     ],
                     "title": "Ext Pan ID",
                     "requiresRestart": true,
-                    "description": "Zigbee extended pan ID, changing requires re-pairing all devices!"
+                    "description": "Zigbee extended pan ID, changing requires re-pairing all devices!",
+                    "default": [221, 221, 221, 221, 221, 221, 221, 221]
                 },
                 "channel": {
                     "type": "number",
                     "minimum": 11,
                     "maximum": 26,
                     "default": 11,
-                    "title": "ZigBee channel",
+                    "title": "Zigbee channel",
                     "requiresRestart": true,
                     "description": "Zigbee channel, changing might require re-pairing some devices! (Note: use a ZLL channel: 11, 15, 20, or 25 to avoid problems)",
                     "examples": [15, 20, 25]
@@ -645,6 +718,7 @@
                     "type": ["number", "null"],
                     "minimum": 1,
                     "maximum": 64,
+                    "default": null,
                     "description": "Adapter concurrency (e.g. 2 for CC2531 or 16 for CC26X2R1) (default: null, uses recommended value)"
                 },
                 "adapter_delay": {
@@ -653,6 +727,7 @@
                     "title": "Adapter delay",
                     "minimum": 0,
                     "maximum": 1000,
+                    "default": null,
                     "description": "Adapter delay"
                 },
                 "cache_state": {
@@ -702,14 +777,16 @@
                     ],
                     "title": "Network key",
                     "requiresRestart": true,
-                    "description": "Network encryption key, changing requires re-pairing all devices!"
+                    "description": "Network encryption key, changing requires re-pairing all devices!",
+                    "default": [1, 3, 5, 7, 9, 11, 13, 15, 0, 2, 4, 6, 8, 10, 12, 13]
                 },
                 "timestamp_format": {
                     "type": "string",
                     "title": "Timestamp format",
                     "requiresRestart": true,
-                    "description": "Log timestamp format",
-                    "examples": ["YYYY-MM-DD HH:mm:ss"]
+                    "description": "Log timestamp format (see https://github.com/taylorhakes/fecha?tab=readme-ov-file#formatting-tokens for all supported tokens)",
+                    "default": "YYYY-MM-DD HH:mm:ss",
+                    "examples": ["YYYY-MM-DD HH:mm:ss.SSS"]
                 },
                 "transmit_power": {
                     "type": ["number", "null"],
@@ -723,9 +800,32 @@
                     "type": "string",
                     "enum": ["attribute_and_json", "attribute", "json"],
                     "title": "MQTT output type",
-                    "description": "Examples when 'state' of a device is published json: topic: 'zigbee2mqtt/my_bulb' payload '{\"state\": \"ON\"}' attribute: topic 'zigbee2mqtt/my_bulb/state' payload 'ON' attribute_and_json: both json and attribute (see above)"
+                    "description": "Examples when 'state' of a device is published json: topic: 'zigbee2mqtt/my_bulb' payload '{\"state\": \"ON\"}' attribute: topic 'zigbee2mqtt/my_bulb/state' payload 'ON' attribute_and_json: both json and attribute (see above)",
+                    "default": "json"
                 }
             }
+        },
+        "health": {
+            "title": "Health",
+            "description": "Periodically check the health of Zigbee2MQTT",
+            "type": "object",
+            "properties": {
+                "interval": {
+                    "type": "number",
+                    "title": "Interval",
+                    "description": "Interval between checks in minutes",
+                    "default": 10,
+                    "minimum": 1,
+                    "requiresRestart": true
+                },
+                "reset_on_check": {
+                    "type": "boolean",
+                    "title": "Reset on check",
+                    "description": "If true, will reset stats every time the health check is executed (only applicable to stats that can be reset).",
+                    "default": false
+                }
+            },
+            "required": []
         }
     },
     "required": ["mqtt"],
@@ -756,7 +856,8 @@
                     "description": "Sets the MQTT Message Expiry in seconds, Make sure to set mqtt.version to 5"
                 },
                 "qos": {
-                    "type": "number",
+                    "type": ["number"],
+                    "enum": [0, 1, 2],
                     "title": "QoS",
                     "description": "QoS level for MQTT messages of this device"
                 },
@@ -817,14 +918,14 @@
                 "icon": {
                     "type": "string",
                     "title": "Icon",
-                    "description": "The user-defined device icon for the frontend. It can be a full URL link to an image (e.g. https://SOME.SITE/MODEL123.jpg) or a path to a local file inside the `device_icons` directory."
+                    "description": "The user-defined device icon for the frontend. It can be a full URL link to an image (e.g. https://SOME.SITE/MODEL123.jpg) or a path to a local file inside the `device_icons` directory (e.g. device_icons/MODEL123.png)."
                 },
                 "homeassistant": {
                     "type": ["object", "null"],
                     "title": "Home Assistant",
                     "properties": {
                         "name": {
-                            "type": "string",
+                            "type": ["string", "null"],
                             "title": "Home Assistant name",
                             "description": "Name of the device in Home Assistant"
                         }
@@ -846,13 +947,16 @@
                     "type": "boolean"
                 },
                 "qos": {
-                    "type": "number"
+                    "type": ["number"],
+                    "enum": [0, 1, 2],
+                    "title": "QoS",
+                    "description": "QoS level for MQTT messages of this group"
                 },
                 "off_state": {
                     "type": ["string"],
                     "enum": ["all_members_off", "last_member_state"],
                     "title": "Group off state",
-                    "default": "auto",
+                    "default": "all_members_off",
                     "requiresRestart": true,
                     "description": "Control when to publish state OFF or CLOSE for a group. 'all_members_off': only publish state OFF/CLOSE when all group members are in state OFF/CLOSE,  'last_member_state': publish state OFF whenever one of its members changes to OFF"
                 },

lib/util/settings.ts

@@ -1,56 +1,58 @@
-import path from 'node:path';
-
-import Ajv, {ValidateFunction} from 'ajv';
-import objectAssignDeep from 'object-assign-deep';
-
-import data from './data';
-import schemaJson from './settings.schema.json';
-import utils from './utils';
-import yaml, {YAMLFileException} from './yaml';
+import path from "node:path";
+import type {ValidateFunction} from "ajv";
+import Ajv from "ajv";
+import objectAssignDeep from "object-assign-deep";
+import data from "./data";
+import schemaJson from "./settings.schema.json";
+import utils from "./utils";
+import yaml from "./yaml";
 
 export {schemaJson};
 // When updating also update:
 // - https://github.com/Koenkk/zigbee2mqtt/blob/dev/data/configuration.example.yaml#L2
-// - https://github.com/zigbee2mqtt/hassio-zigbee2mqtt/blob/master/common/rootfs/docker-entrypoint.sh#L54
 export const CURRENT_VERSION = 4;
 /** NOTE: by order of priority, lower index is lower level (more important) */
-export const LOG_LEVELS: readonly string[] = ['error', 'warning', 'info', 'debug'] as const;
-export type LogLevel = 'error' | 'warning' | 'info' | 'debug';
+export const LOG_LEVELS: readonly string[] = ["error", "warning", "info", "debug"] as const;
+export type LogLevel = "error" | "warning" | "info" | "debug";
 
-const CONFIG_FILE_PATH = data.joinPath('configuration.yaml');
-const NULLABLE_SETTINGS = ['homeassistant'];
-const ajvSetting = new Ajv({allErrors: true}).addKeyword('requiresRestart').compile(schemaJson);
-const ajvRestartRequired = new Ajv({allErrors: true}).addKeyword({keyword: 'requiresRestart', validate: (s: unknown) => !s}).compile(schemaJson);
+const CONFIG_FILE_PATH = data.joinPath("configuration.yaml");
+const NULLABLE_SETTINGS = ["homeassistant"];
+const ajvSetting = new Ajv({allErrors: true}).addKeyword("requiresRestart").compile(schemaJson);
+const ajvRestartRequired = new Ajv({allErrors: true}).addKeyword({keyword: "requiresRestart", validate: (s: unknown) => !s}).compile(schemaJson);
 const ajvRestartRequiredDeviceOptions = new Ajv({allErrors: true})
-    .addKeyword({keyword: 'requiresRestart', validate: (s: unknown) => !s})
+    .addKeyword({keyword: "requiresRestart", validate: (s: unknown) => !s})
     .compile(schemaJson.definitions.device);
 const ajvRestartRequiredGroupOptions = new Ajv({allErrors: true})
-    .addKeyword({keyword: 'requiresRestart', validate: (s: unknown) => !s})
+    .addKeyword({keyword: "requiresRestart", validate: (s: unknown) => !s})
     .compile(schemaJson.definitions.group);
-export const defaults: RecursivePartial<Settings> = {
+export const defaults = {
     homeassistant: {
         enabled: false,
-        discovery_topic: 'homeassistant',
-        status_topic: 'homeassistant/status',
+        discovery_topic: "homeassistant",
+        status_topic: "homeassistant/status",
         legacy_action_sensor: false,
         experimental_event_entities: false,
     },
     availability: {
         enabled: false,
-        active: {timeout: 10},
+        active: {timeout: 10, max_jitter: 30000, backoff: true, pause_on_backoff_gt: 0},
         passive: {timeout: 1500},
     },
     frontend: {
         enabled: false,
+        package: "zigbee2mqtt-windfront",
         port: 8080,
-        base_url: '/',
+        base_url: "/",
     },
     mqtt: {
-        base_topic: 'zigbee2mqtt',
+        base_topic: "zigbee2mqtt",
         include_device_information: false,
         force_disable_retain: false,
         // 1MB = roughly 3.5KB per device * 300 devices for `/bridge/devices`
         maximum_packet_size: 1048576,
+        keepalive: 60,
+        reject_unauthorized: true,
+        version: 4,
     },
     serial: {
         disable_led: false,
@@ -61,18 +63,18 @@ export const defaults: RecursivePartial<Settings> = {
         graphviz: {
             colors: {
                 fill: {
-                    enddevice: '#fff8ce',
-                    coordinator: '#e04e5d',
-                    router: '#4ea3e0',
+                    enddevice: "#fff8ce",
+                    coordinator: "#e04e5d",
+                    router: "#4ea3e0",
                 },
                 font: {
-                    coordinator: '#ffffff',
-                    router: '#ffffff',
-                    enddevice: '#000000',
+                    coordinator: "#ffffff",
+                    router: "#ffffff",
+                    enddevice: "#000000",
                 },
                 line: {
-                    active: '#009900',
-                    inactive: '#994444',
+                    active: "#009900",
+                    inactive: "#994444",
                 },
             },
         },
@@ -88,14 +90,15 @@ export const defaults: RecursivePartial<Settings> = {
         log_rotation: true,
         log_console_json: false,
         log_symlink_current: false,
-        log_output: ['console', 'file'],
-        log_directory: path.join(data.getPath(), 'log', '%TIMESTAMP%'),
-        log_file: 'log.log',
-        log_level: /* v8 ignore next */ process.env.DEBUG ? 'debug' : 'info',
+        log_output: ["console", "file"],
+        log_directory: path.join(data.getPath(), "log", "%TIMESTAMP%"),
+        log_file: "log.log",
+        log_level: /* v8 ignore next */ process.env.DEBUG ? "debug" : "info",
         log_namespaced_levels: {},
         log_syslog: {},
         log_debug_to_mqtt_frontend: false,
-        log_debug_namespace_ignore: '',
+        log_debug_namespace_ignore: "",
+        log_directories_to_keep: 10,
         pan_id: 0x1a62,
         ext_pan_id: [0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd],
         channel: 11,
@@ -104,13 +107,17 @@ export const defaults: RecursivePartial<Settings> = {
         cache_state: true,
         cache_state_persistent: true,
         cache_state_send_on_startup: true,
-        last_seen: 'disable',
+        last_seen: "disable",
         elapsed: false,
         network_key: [1, 3, 5, 7, 9, 11, 13, 15, 0, 2, 4, 6, 8, 10, 12, 13],
-        timestamp_format: 'YYYY-MM-DD HH:mm:ss',
-        output: 'json',
+        timestamp_format: "YYYY-MM-DD HH:mm:ss",
+        output: "json",
     },
-};
+    health: {
+        interval: 10,
+        reset_on_check: false,
+    },
+} satisfies RecursivePartial<Settings>;
 
 let _settings: Partial<Settings> | undefined;
 let _settingsWithDefaults: Settings | undefined;
@@ -136,16 +143,64 @@ function parseValueRef(text: string): {filename: string; key: string} | null {
     if (match) {
         let filename = match[1];
         // This is mainly for backward compatibility.
-        if (!filename.endsWith('.yaml') && !filename.endsWith('.yml')) {
-            filename += '.yaml';
+        if (!filename.endsWith(".yaml") && !filename.endsWith(".yml")) {
+            filename += ".yaml";
         }
         return {filename, key: match[2]};
-    } else {
-        return null;
+    }
+
+    return null;
+}
+
+export function writeMinimalDefaults(): void {
+    const minimal = {
+        version: CURRENT_VERSION,
+        mqtt: {
+            base_topic: defaults.mqtt.base_topic,
+            server: "mqtt://localhost:1883",
+        },
+        serial: {},
+        advanced: {
+            log_level: defaults.advanced.log_level,
+            channel: defaults.advanced.channel,
+            network_key: "GENERATE",
+            pan_id: "GENERATE",
+            ext_pan_id: "GENERATE",
+        },
+        frontend: {
+            enabled: defaults.frontend.enabled,
+            port: defaults.frontend.port,
+        },
+        homeassistant: {
+            enabled: defaults.homeassistant.enabled,
+        },
+    } as Partial<Settings>;
+
+    applyEnvironmentVariables(minimal);
+    yaml.writeIfChanged(CONFIG_FILE_PATH, minimal);
+
+    _settings = read();
+
+    loadSettingsWithDefaults();
+}
+
+export function setOnboarding(value: boolean): void {
+    const settings = getPersistedSettings();
+
+    if (value) {
+        if (!settings.onboarding) {
+            settings.onboarding = value;
+
+            write();
+        }
+    } else if (settings.onboarding) {
+        delete settings.onboarding;
+
+        write();
     }
 }
 
-function write(): void {
+export function write(): void {
     const settings = getPersistedSettings();
     const toWrite: KeyValue = objectAssignDeep({}, settings);
 
@@ -153,25 +208,25 @@ function write(): void {
     const actual = yaml.read(CONFIG_FILE_PATH);
 
     // In case the setting is defined in a separate file (e.g. !secret network_key) update it there.
-    for (const path of [
-        ['mqtt', 'server'],
-        ['mqtt', 'user'],
-        ['mqtt', 'password'],
-        ['advanced', 'network_key'],
-        ['frontend', 'auth_token'],
+    for (const [ns, key] of [
+        ["mqtt", "server"],
+        ["mqtt", "user"],
+        ["mqtt", "password"],
+        ["advanced", "network_key"],
+        ["frontend", "auth_token"],
     ]) {
-        if (actual[path[0]] && actual[path[0]][path[1]]) {
-            const ref = parseValueRef(actual[path[0]][path[1]]);
+        if (actual[ns]?.[key]) {
+            const ref = parseValueRef(actual[ns][key]);
             if (ref) {
-                yaml.updateIfChanged(data.joinPath(ref.filename), ref.key, toWrite[path[0]][path[1]]);
-                toWrite[path[0]][path[1]] = actual[path[0]][path[1]];
+                yaml.updateIfChanged(data.joinPath(ref.filename), ref.key, toWrite[ns][key]);
+                toWrite[ns][key] = actual[ns][key];
             }
         }
     }
 
     // Write devices/groups to separate file if required.
-    const writeDevicesOrGroups = (type: 'devices' | 'groups'): void => {
-        if (typeof actual[type] === 'string' || (Array.isArray(actual[type]) && actual[type].length > 0)) {
+    const writeDevicesOrGroups = (type: "devices" | "groups"): void => {
+        if (typeof actual[type] === "string" || (Array.isArray(actual[type]) && actual[type].length > 0)) {
             const fileToWrite = Array.isArray(actual[type]) ? actual[type][0] : actual[type];
             const content = objectAssignDeep({}, settings[type]);
 
@@ -190,8 +245,11 @@ function write(): void {
         }
     };
 
-    writeDevicesOrGroups('devices');
-    writeDevicesOrGroups('groups');
+    writeDevicesOrGroups("devices");
+    writeDevicesOrGroups("groups");
+
+    applyEnvironmentVariables(toWrite);
+
     yaml.writeIfChanged(CONFIG_FILE_PATH, toWrite);
 
     _settings = read();
@@ -200,47 +258,24 @@ function write(): void {
 }
 
 export function validate(): string[] {
-    try {
-        getPersistedSettings();
-    } catch (error) {
-        if (error instanceof YAMLFileException) {
-            return [`Your YAML file: '${error.file}' is invalid (use https://jsonformatter.org/yaml-validator to find and fix the issue)`];
-        }
-
-        return [`${error}`];
-    }
+    getPersistedSettings();
 
     if (!ajvSetting(_settings)) {
-        // When `ajvSetting()` return false it always has `errors`.
+        // biome-ignore lint/style/noNonNullAssertion: When `ajvSetting()` return false it always has `errors`
         return ajvSetting.errors!.map((v) => `${v.instancePath.substring(1)} ${v.message}`);
     }
 
     const errors = [];
 
-    if (
-        _settings.advanced &&
-        _settings.advanced.network_key &&
-        typeof _settings.advanced.network_key === 'string' &&
-        _settings.advanced.network_key !== 'GENERATE'
-    ) {
+    if (_settings.advanced?.network_key && typeof _settings.advanced.network_key === "string" && _settings.advanced.network_key !== "GENERATE") {
         errors.push(`advanced.network_key: should be array or 'GENERATE' (is '${_settings.advanced.network_key}')`);
     }
 
-    if (
-        _settings.advanced &&
-        _settings.advanced.pan_id &&
-        typeof _settings.advanced.pan_id === 'string' &&
-        _settings.advanced.pan_id !== 'GENERATE'
-    ) {
+    if (_settings.advanced?.pan_id && typeof _settings.advanced.pan_id === "string" && _settings.advanced.pan_id !== "GENERATE") {
         errors.push(`advanced.pan_id: should be number or 'GENERATE' (is '${_settings.advanced.pan_id}')`);
     }
 
-    if (
-        _settings.advanced &&
-        _settings.advanced.ext_pan_id &&
-        typeof _settings.advanced.ext_pan_id === 'string' &&
-        _settings.advanced.ext_pan_id !== 'GENERATE'
-    ) {
+    if (_settings.advanced?.ext_pan_id && typeof _settings.advanced.ext_pan_id === "string" && _settings.advanced.ext_pan_id !== "GENERATE") {
         errors.push(`advanced.ext_pan_id: should be array or 'GENERATE' (is '${_settings.advanced.ext_pan_id}')`);
     }
 
@@ -250,23 +285,25 @@ export function validate(): string[] {
         if (names.includes(e.friendly_name)) errors.push(`Duplicate friendly_name '${e.friendly_name}' found`);
         errors.push(...utils.validateFriendlyName(e.friendly_name));
         names.push(e.friendly_name);
-        if ('icon' in e && e.icon && !e.icon.startsWith('http://') && !e.icon.startsWith('https://') && !e.icon.startsWith('device_icons/')) {
+        if ("icon" in e && e.icon && !e.icon.startsWith("http://") && !e.icon.startsWith("https://") && !e.icon.startsWith("device_icons/")) {
             errors.push(`Device icon of '${e.friendly_name}' should start with 'device_icons/', got '${e.icon}'`);
         }
-        if (e.qos != null && ![0, 1, 2].includes(e.qos)) {
-            errors.push(`QOS for '${e.friendly_name}' not valid, should be 0, 1 or 2 got ${e.qos}`);
-        }
     };
 
     const settingsWithDefaults = get();
 
-    Object.values(settingsWithDefaults.devices).forEach((d) => check(d));
-    Object.values(settingsWithDefaults.groups).forEach((g) => check(g));
+    for (const key in settingsWithDefaults.devices) {
+        check(settingsWithDefaults.devices[key]);
+    }
+
+    for (const key in settingsWithDefaults.groups) {
+        check(settingsWithDefaults.groups[key]);
+    }
 
     if (settingsWithDefaults.mqtt.version !== 5) {
         for (const device of Object.values(settingsWithDefaults.devices)) {
             if (device.retention) {
-                errors.push('MQTT retention requires protocol version 5');
+                errors.push("MQTT retention requires protocol version 5");
             }
         }
     }
@@ -274,13 +311,25 @@ export function validate(): string[] {
     return errors;
 }
 
+export function validateNonRequired(): string[] {
+    getPersistedSettings();
+
+    if (!ajvSetting(_settings)) {
+        // biome-ignore lint/style/noNonNullAssertion: When `ajvSetting()` return false it always has `errors`
+        const errors = ajvSetting.errors!.filter((e) => e.keyword !== "required");
+
+        return errors.map((v) => `${v.instancePath.substring(1)} ${v.message}`);
+    }
+
+    return [];
+}
+
 function read(): Partial<Settings> {
     const s = yaml.read(CONFIG_FILE_PATH) as Partial<Settings>;
-    applyEnvironmentVariables(s);
 
     // Read !secret MQTT username and password if set
     const interpretValue = <T>(value: T): T => {
-        if (typeof value === 'string') {
+        if (typeof value === "string") {
             const ref = parseValueRef(value);
             if (ref) {
                 return yaml.read(data.joinPath(ref.filename))[ref.key];
@@ -310,8 +359,8 @@ function read(): Partial<Settings> {
     }
 
     // Read devices/groups configuration from separate file if specified.
-    const readDevicesOrGroups = (type: 'devices' | 'groups'): void => {
-        if (typeof s[type] === 'string' || (Array.isArray(s[type]) && Array(s[type]).length > 0)) {
+    const readDevicesOrGroups = (type: "devices" | "groups"): void => {
+        if (typeof s[type] === "string" || (Array.isArray(s[type]) && Array(s[type]).length > 0)) {
             const files: string[] = Array.isArray(s[type]) ? s[type] : [s[type]];
             s[type] = {};
             for (const file of files) {
@@ -322,8 +371,8 @@ function read(): Partial<Settings> {
         }
     };
 
-    readDevicesOrGroups('devices');
-    readDevicesOrGroups('groups');
+    readDevicesOrGroups("devices");
+    readDevicesOrGroups("groups");
 
     return s;
 }
@@ -331,10 +380,10 @@ function read(): Partial<Settings> {
 function applyEnvironmentVariables(settings: Partial<Settings>): void {
     const iterate = (obj: KeyValue, path: string[]): void => {
         for (const key in obj) {
-            if (key !== 'type') {
-                if (key !== 'properties' && obj[key]) {
-                    const type = (obj[key].type || 'object').toString();
-                    const envPart = path.reduce((acc, val) => `${acc}${val}_`, '');
+            if (key !== "type") {
+                if (key !== "properties" && obj[key]) {
+                    const type = (obj[key].type || "object").toString();
+                    const envPart = path.reduce((acc, val) => `${acc}${val}_`, "");
                     const envVariableName = `ZIGBEE2MQTT_CONFIG_${envPart}${key}`.toUpperCase();
                     const envVariable = process.env[envVariableName];
 
@@ -346,32 +395,32 @@ function applyEnvironmentVariables(settings: Partial<Settings>): void {
                             return acc[val];
                         }, settings);
 
-                        if (type.indexOf('object') >= 0 || type.indexOf('array') >= 0) {
+                        if (type.indexOf("object") >= 0 || type.indexOf("array") >= 0) {
                             try {
                                 setting[key as keyof Settings] = JSON.parse(envVariable);
                             } catch {
-                                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                                // biome-ignore lint/suspicious/noExplicitAny: auto-parsing
                                 setting[key as keyof Settings] = envVariable as any;
                             }
-                        } else if (type.indexOf('number') >= 0) {
-                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        } else if (type.indexOf("number") >= 0) {
+                            // biome-ignore lint/suspicious/noExplicitAny: auto-parsing
                             setting[key as keyof Settings] = ((envVariable as unknown as number) * 1) as any;
-                        } else if (type.indexOf('boolean') >= 0) {
-                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                            setting[key as keyof Settings] = (envVariable.toLowerCase() === 'true') as any;
+                        } else if (type.indexOf("boolean") >= 0) {
+                            // biome-ignore lint/suspicious/noExplicitAny: auto-parsing
+                            setting[key as keyof Settings] = (envVariable.toLowerCase() === "true") as any;
                         } else {
-                            if (type.indexOf('string') >= 0) {
-                                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                            if (type.indexOf("string") >= 0) {
+                                // biome-ignore lint/suspicious/noExplicitAny: auto-parsing
                                 setting[key as keyof Settings] = envVariable as any;
                             }
                         }
                     }
                 }
 
-                if (typeof obj[key] === 'object' && obj[key]) {
+                if (typeof obj[key] === "object" && obj[key]) {
                     const newPath = [...path];
 
-                    if (key !== 'properties' && key !== 'oneOf' && !Number.isInteger(Number(key))) {
+                    if (key !== "properties" && key !== "oneOf" && !Number.isInteger(Number(key))) {
                         newPath.push(key);
                     }
 
@@ -402,11 +451,12 @@ export function get(): Settings {
         loadSettingsWithDefaults();
     }
 
+    // biome-ignore lint/style/noNonNullAssertion: just loaded
     return _settingsWithDefaults!;
 }
 
 export function set(path: string[], value: string | number | boolean | KeyValue): void {
-    /* eslint-disable-next-line */
+    // biome-ignore lint/suspicious/noExplicitAny: auto-parsing
     let settings: any = getPersistedSettings();
 
     for (let i = 0; i < path.length; i++) {
@@ -425,18 +475,18 @@ export function set(path: string[], value: string | number | boolean | KeyValue)
     write();
 }
 
-export function apply(settings: Record<string, unknown>, throwOnError: boolean = true): boolean {
+export function apply(settings: Record<string, unknown>, throwOnError = true): boolean {
     getPersistedSettings(); // Ensure _settings is initialized.
     // @ts-expect-error noMutate not typed properly
     const newSettings = objectAssignDeep.noMutate(_settings, settings);
 
     utils.removeNullPropertiesFromObject(newSettings, NULLABLE_SETTINGS);
-    ajvSetting(newSettings);
 
-    if (throwOnError) {
-        const errors = ajvSetting.errors && ajvSetting.errors.filter((e) => e.keyword !== 'required');
+    if (!ajvSetting(newSettings) && throwOnError) {
+        // biome-ignore lint/style/noNonNullAssertion: When `ajvSetting()` return false it always has `errors`
+        const errors = ajvSetting.errors!.filter((e) => e.keyword !== "required");
 
-        if (errors?.length) {
+        if (errors.length) {
             const error = errors[0];
             throw new Error(`${error.instancePath.substring(1)} ${error.message}`);
         }
@@ -447,7 +497,7 @@ export function apply(settings: Record<string, unknown>, throwOnError: boolean =
 
     ajvRestartRequired(settings);
 
-    const restartRequired = Boolean(ajvRestartRequired.errors && !!ajvRestartRequired.errors.find((e) => e.keyword === 'requiresRestart'));
+    const restartRequired = Boolean(ajvRestartRequired.errors && !!ajvRestartRequired.errors.find((e) => e.keyword === "requiresRestart"));
 
     return restartRequired;
 }
@@ -505,9 +555,9 @@ function getDeviceThrowIfNotExists(IDorName: string): DeviceOptionsWithId {
     return device;
 }
 
-export function addDevice(ID: string): DeviceOptionsWithId {
-    if (getDevice(ID)) {
-        throw new Error(`Device '${ID}' already exists`);
+export function addDevice(id: string): DeviceOptionsWithId {
+    if (getDevice(id)) {
+        throw new Error(`Device '${id}' already exists`);
     }
 
     const settings = getPersistedSettings();
@@ -516,19 +566,20 @@ export function addDevice(ID: string): DeviceOptionsWithId {
         settings.devices = {};
     }
 
-    settings.devices[ID] = {friendly_name: ID};
+    settings.devices[id] = {friendly_name: id};
     write();
 
-    return getDevice(ID)!; // valid from creation above
+    // biome-ignore lint/style/noNonNullAssertion: valid from creation above
+    return getDevice(id)!;
 }
 
-export function blockDevice(ID: string): void {
+export function blockDevice(id: string): void {
     const settings = getPersistedSettings();
     if (!settings.blocklist) {
         settings.blocklist = [];
     }
 
-    settings.blocklist.push(ID);
+    settings.blocklist.push(id);
     write();
 }
 
@@ -539,7 +590,7 @@ export function removeDevice(IDorName: string): void {
     write();
 }
 
-export function addGroup(name: string, ID?: string): GroupOptions {
+export function addGroup(name: string, id?: string): GroupOptions {
     utils.validateFriendlyName(name, true);
 
     if (getGroup(name) || getDevice(name)) {
@@ -551,32 +602,34 @@ export function addGroup(name: string, ID?: string): GroupOptions {
         settings.groups = {};
     }
 
-    if (ID == undefined) {
+    if (id == null || (typeof id === "string" && id.trim() === "")) {
         // look for free ID
-        ID = '1';
+        id = "1";
 
-        while (settings.groups[ID]) {
-            ID = (Number.parseInt(ID) + 1).toString();
+        while (settings.groups[id]) {
+            id = (Number.parseInt(id, 10) + 1).toString();
         }
     } else {
         // ensure provided ID is not in use
-        ID = ID.toString();
+        id = id.toString();
 
-        if (settings.groups[ID]) {
-            throw new Error(`Group ID '${ID}' is already in use`);
+        if (settings.groups[id]) {
+            throw new Error(`Group ID '${id}' is already in use`);
         }
     }
 
-    settings.groups[ID] = {friendly_name: name};
+    settings.groups[id] = {friendly_name: name};
     write();
 
-    return getGroup(ID)!; // valid from creation above
+    // biome-ignore lint/style/noNonNullAssertion: valid from creation above
+    return getGroup(id)!;
 }
 
 export function removeGroup(IDorName: string | number): void {
-    const groupID = getGroupThrowIfNotExists(IDorName.toString()).ID!;
+    const groupID = getGroupThrowIfNotExists(IDorName.toString()).ID;
     const settings = getPersistedSettings();
 
+    // biome-ignore lint/style/noNonNullAssertion: throwing above if not valid
     delete settings.groups![groupID];
     write();
 }
@@ -589,15 +642,19 @@ export function changeEntityOptions(IDorName: string, newOptions: KeyValue): boo
     const device = getDevice(IDorName);
 
     if (device) {
-        objectAssignDeep(settings.devices![device.ID], newOptions);
-        utils.removeNullPropertiesFromObject(settings.devices![device.ID], NULLABLE_SETTINGS);
+        // biome-ignore lint/style/noNonNullAssertion: valid from above
+        const settingsDevice = settings.devices![device.ID];
+        objectAssignDeep(settingsDevice, newOptions);
+        utils.removeNullPropertiesFromObject(settingsDevice, NULLABLE_SETTINGS);
         validator = ajvRestartRequiredDeviceOptions;
     } else {
         const group = getGroup(IDorName);
 
         if (group) {
-            objectAssignDeep(settings.groups![group.ID], newOptions);
-            utils.removeNullPropertiesFromObject(settings.groups![group.ID], NULLABLE_SETTINGS);
+            // biome-ignore lint/style/noNonNullAssertion: valid from above
+            const settingsGroup = settings.groups![group.ID];
+            objectAssignDeep(settingsGroup, newOptions);
+            utils.removeNullPropertiesFromObject(settingsGroup, NULLABLE_SETTINGS);
             validator = ajvRestartRequiredGroupOptions;
         } else {
             throw new Error(`Device or group '${IDorName}' does not exist`);
@@ -607,7 +664,7 @@ export function changeEntityOptions(IDorName: string, newOptions: KeyValue): boo
     write();
     validator(newOptions);
 
-    const restartRequired = Boolean(validator.errors && !!validator.errors.find((e) => e.keyword === 'requiresRestart'));
+    const restartRequired = Boolean(validator.errors && !!validator.errors.find((e) => e.keyword === "requiresRestart"));
 
     return restartRequired;
 }
@@ -622,11 +679,13 @@ export function changeFriendlyName(IDorName: string, newName: string): void {
     const device = getDevice(IDorName);
 
     if (device) {
+        // biome-ignore lint/style/noNonNullAssertion: valid from above
         settings.devices![device.ID].friendly_name = newName;
     } else {
         const group = getGroup(IDorName);
 
         if (group) {
+            // biome-ignore lint/style/noNonNullAssertion: valid from above
             settings.groups![group.ID].friendly_name = newName;
         } else {
             throw new Error(`Device or group '${IDorName}' does not exist`);

lib/util/settingsMigration.ts

@@ -1,8 +1,8 @@
-import {copyFileSync, writeFileSync} from 'node:fs';
+import {copyFileSync, writeFileSync} from "node:fs";
 
-import data from './data';
-import * as settings from './settings';
-import utils from './utils';
+import data from "./data";
+import * as settings from "./settings";
+import utils from "./utils";
 
 interface SettingsMigration {
     path: string[];
@@ -10,7 +10,7 @@ interface SettingsMigration {
     noteIf?: (previousValue: unknown) => boolean;
 }
 
-interface SettingsAdd extends Omit<SettingsMigration, 'noteIf'> {
+interface SettingsAdd extends Omit<SettingsMigration, "noteIf"> {
     value: unknown;
 }
 
@@ -25,16 +25,16 @@ interface SettingsTransfer extends SettingsMigration {
     newPath: string[];
 }
 
-interface SettingsCustomHandler extends Omit<SettingsMigration, 'path'> {
+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];
+const SUPPORTED_VERSIONS: Settings["version"][] = [undefined, 2, 3, settings.CURRENT_VERSION];
 
 function backupSettings(version: number): void {
-    const filePath = data.joinPath('configuration.yaml');
+    const filePath = data.joinPath("configuration.yaml");
 
-    copyFileSync(filePath, filePath.replace('.yaml', `_backup_v${version}.yaml`));
+    copyFileSync(filePath, filePath.replace(".yaml", `_backup_v${version}.yaml`));
 }
 
 /**
@@ -46,8 +46,8 @@ function backupSettings(version: number): void {
  * @param createPathIfNotExist
  * @returns Returns true if value was set, false if not.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function setValue(currentSettings: any, path: string[], value: unknown, createPathIfNotExist: boolean = false): boolean {
+// 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];
 
@@ -82,7 +82,7 @@ function setValue(currentSettings: any, path: string[], value: unknown, createPa
  *   - true if path was valid
  *   - the value at path
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
+// 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];
@@ -90,14 +90,14 @@ function getValue(currentSettings: any, path: string[]): [validPath: boolean, va
 
         if (i === path.length - 1) {
             return [value !== undefined, value];
-        } else {
-            if (!value) {
-                // invalid path
-                break;
-            }
-
-            currentSettings = value;
         }
+
+        if (!value) {
+            // invalid path
+            break;
+        }
+
+        currentSettings = value;
     }
 
     return [false, undefined];
@@ -122,7 +122,7 @@ function addValue(currentSettings: Partial<Settings>, addition: SettingsAdd): vo
 function removeValue(currentSettings: Partial<Settings>, removal: SettingsRemove): [validPath: boolean, previousValue: unknown] {
     const [validPath, previousValue] = getValue(currentSettings, removal.path);
 
-    if (validPath && previousValue != undefined) {
+    if (validPath && previousValue != null) {
         setValue(currentSettings, removal.path, undefined);
     }
 
@@ -137,7 +137,7 @@ function removeValue(currentSettings: Partial<Settings>, removal: SettingsRemove
  */
 function changeValue(currentSettings: Partial<Settings>, change: SettingsChange): [validPath: boolean, previousValue: unknown, changed: boolean] {
     const [validPath, previousValue] = getValue(currentSettings, change.path);
-    let changed: boolean = false;
+    let changed = false;
 
     if (validPath && previousValue !== change.newValue) {
         if (!change.previousValueAnyOf || change.previousValueAnyOf.includes(previousValue)) {
@@ -166,10 +166,10 @@ function transferValue(
 ): [validPath: boolean, previousValue: unknown, transfered: boolean] {
     const [validPath, previousValue] = getValue(currentSettings, transfer.path);
     const [destValidPath, destValue] = getValue(currentSettings, transfer.newPath);
-    const transfered = validPath && previousValue != undefined && (!destValidPath || destValue == undefined || Array.isArray(destValue));
+    const transfered = validPath && previousValue != null && (!destValidPath || destValue == null || Array.isArray(destValue));
 
     // no point in set if already undefined
-    if (validPath && previousValue != undefined) {
+    if (validPath && previousValue != null) {
         setValue(currentSettings, transfer.path, undefined);
     }
 
@@ -185,7 +185,7 @@ function transferValue(
 }
 
 const noteIfWasTrue = (previousValue: unknown): boolean => previousValue === true;
-const noteIfWasDefined = (previousValue: unknown): boolean => previousValue != undefined;
+const noteIfWasDefined = (previousValue: unknown): boolean => previousValue != null;
 const noteIfWasNonEmptyArray = (previousValue: unknown): boolean => Array.isArray(previousValue) && previousValue.length > 0;
 
 function migrateToTwo(
@@ -198,82 +198,82 @@ function migrateToTwo(
 ): void {
     transfers.push(
         {
-            path: ['advanced', 'homeassistant_discovery_topic'],
-            note: `HA discovery_topic was moved from advanced.homeassistant_discovery_topic to homeassistant.discovery_topic.`,
+            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'],
+            newPath: ["homeassistant", "discovery_topic"],
         },
         {
-            path: ['advanced', 'homeassistant_status_topic'],
-            note: `HA status_topic was moved from advanced.homeassistant_status_topic to homeassistant.status_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'],
+            newPath: ["homeassistant", "status_topic"],
         },
         {
-            path: ['advanced', 'baudrate'],
-            note: `Baudrate was moved from advanced.baudrate to serial.baudrate.`,
+            path: ["advanced", "baudrate"],
+            note: "Baudrate was moved from advanced.baudrate to serial.baudrate.",
             noteIf: noteIfWasDefined,
-            newPath: ['serial', 'baudrate'],
+            newPath: ["serial", "baudrate"],
         },
         {
-            path: ['advanced', 'rtscts'],
-            note: `RTSCTS was moved from advanced.rtscts to serial.rtscts.`,
+            path: ["advanced", "rtscts"],
+            note: "RTSCTS was moved from advanced.rtscts to serial.rtscts.",
             noteIf: noteIfWasDefined,
-            newPath: ['serial', 'rtscts'],
+            newPath: ["serial", "rtscts"],
         },
         {
-            path: ['experimental', 'transmit_power'],
-            note: `Transmit power was moved from experimental.transmit_power to advanced.transmit_power.`,
+            path: ["experimental", "transmit_power"],
+            note: "Transmit power was moved from experimental.transmit_power to advanced.transmit_power.",
             noteIf: noteIfWasDefined,
-            newPath: ['advanced', 'transmit_power'],
+            newPath: ["advanced", "transmit_power"],
         },
         {
-            path: ['experimental', 'output'],
-            note: `Output was moved from experimental.output to advanced.output.`,
+            path: ["experimental", "output"],
+            note: "Output was moved from experimental.output to advanced.output.",
             noteIf: noteIfWasDefined,
-            newPath: ['advanced', 'output'],
+            newPath: ["advanced", "output"],
         },
         {
-            path: ['ban'],
-            note: `ban was renamed to passlist.`,
+            path: ["ban"],
+            note: "ban was renamed to passlist.",
             noteIf: noteIfWasDefined,
-            newPath: ['blocklist'],
+            newPath: ["blocklist"],
         },
         {
-            path: ['whitelist'],
-            note: `whitelist was renamed to passlist.`,
+            path: ["whitelist"],
+            note: "whitelist was renamed to passlist.",
             noteIf: noteIfWasDefined,
-            newPath: ['passlist'],
+            newPath: ["passlist"],
         },
     );
 
     changes.push({
-        path: ['advanced', 'log_level'],
+        path: ["advanced", "log_level"],
         note: `Log level 'warn' has been renamed to 'warning'.`,
-        noteIf: (previousValue): boolean => previousValue === 'warn',
-        previousValueAnyOf: ['warn'],
-        newValue: 'warning',
+        noteIf: (previousValue): boolean => previousValue === "warn",
+        previousValueAnyOf: ["warn"],
+        newValue: "warning",
     });
 
     additions.push({
-        path: ['version'],
-        note: `Migrated settings to version 2`,
+        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.`,
+        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).`,
+        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.`,
+        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,
     };
 
@@ -281,94 +281,94 @@ function migrateToTwo(
         haLegacyTriggers,
         haLegacyEntityAttrs,
         {
-            path: ['advanced', 'homeassistant_legacy_triggers'],
+            path: ["advanced", "homeassistant_legacy_triggers"],
             note: haLegacyTriggers.note,
             noteIf: haLegacyTriggers.noteIf,
         },
         {
-            path: ['advanced', 'homeassistant_legacy_entity_attributes'],
+            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.`,
+            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'],
+            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.`,
+            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"})`,
+            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)`,
+            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)`,
+            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`,
+            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`,
+            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`,
+            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`,
+            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`,
+            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.`,
+            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.`,
+            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.`,
+            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)`;
+    const noteEntityOptionsRetrieveState = "Retrieve state option ((devices|groups).xyz.retrieve_state setting)";
 
     for (const deviceKey in currentSettings.devices) {
         removals.push({
-            path: ['devices', deviceKey, 'retrieve_state'],
+            path: ["devices", deviceKey, "retrieve_state"],
             note: noteEntityOptionsRetrieveState,
             noteIf: noteIfWasTrue,
         });
@@ -376,13 +376,13 @@ function migrateToTwo(
 
     for (const groupKey in currentSettings.groups) {
         removals.push({
-            path: ['groups', groupKey, 'retrieve_state'],
+            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.`,
+            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,
         });
     }
@@ -391,7 +391,7 @@ function migrateToTwo(
 }
 
 function migrateToThree(
-    currentSettings: Partial<Settings>,
+    _currentSettings: Partial<Settings>,
     transfers: SettingsTransfer[],
     changes: SettingsChange[],
     additions: SettingsAdd[],
@@ -400,18 +400,18 @@ function migrateToThree(
 ): void {
     transfers.push();
     changes.push({
-        path: ['version'],
-        note: `Migrated settings to version 3`,
+        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 changeToObject = (currentSettings: Partial<Settings>, path: string[]): ReturnType<SettingsCustomHandler["execute"]> => {
         const [validPath, previousValue] = getValue(currentSettings, path);
 
         if (validPath) {
-            if (typeof previousValue === 'boolean') {
+            if (typeof previousValue === "boolean") {
                 setValue(currentSettings, path, {enabled: previousValue});
             } else {
                 setValue(currentSettings, path, {enabled: true, ...(previousValue as object)});
@@ -425,23 +425,23 @@ function migrateToThree(
         {
             note: `Property 'homeassistant' is now always an object.`,
             noteIf: () => true,
-            execute: (currentSettings) => changeToObject(currentSettings, ['homeassistant']),
+            execute: (currentSettings) => changeToObject(currentSettings, ["homeassistant"]),
         },
         {
             note: `Property 'frontend' is now always an object.`,
             noteIf: () => true,
-            execute: (currentSettings) => changeToObject(currentSettings, ['frontend']),
+            execute: (currentSettings) => changeToObject(currentSettings, ["frontend"]),
         },
         {
             note: `Property 'availability' is now always an object.`,
             noteIf: () => true,
-            execute: (currentSettings) => changeToObject(currentSettings, ['availability']),
+            execute: (currentSettings) => changeToObject(currentSettings, ["availability"]),
         },
     );
 }
 
 function migrateToFour(
-    currentSettings: Partial<Settings>,
+    _currentSettings: Partial<Settings>,
     transfers: SettingsTransfer[],
     changes: SettingsChange[],
     additions: SettingsAdd[],
@@ -450,15 +450,15 @@ function migrateToFour(
 ): void {
     transfers.push();
     changes.push({
-        path: ['version'],
-        note: `Migrated settings to version 4`,
+        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']);
+    const saveBase64DeviceIconsAsImage = (currentSettings: Partial<Settings>): ReturnType<SettingsCustomHandler["execute"]> => {
+        const [validPath, previousValue] = getValue(currentSettings, ["devices"]);
         let changed = false;
 
         if (validPath) {
@@ -475,7 +475,7 @@ function migrateToFour(
     };
 
     customHandlers.push({
-        note: `Device icons are now saved as images.`,
+        note: "Device icons are now saved as images.",
         noteIf: () => true,
         execute: (currentSettings) => saveBase64DeviceIconsAsImage(currentSettings),
     });
@@ -491,22 +491,26 @@ function migrateToFour(
  * Should allow the most flexibility whenever combination of migrations is necessary (e.g. Transfer + Change)
  */
 export function migrateIfNecessary(): void {
-    let currentSettings = settings.getPersistedSettings();
+    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(',')}.`,
+            `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;
 
-    // when same version as current, nothing left to do
+    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: Set<string> = new Set();
+        const migrationNotes = new Set<string>();
         const transfers: SettingsTransfer[] = [];
         const changes: SettingsChange[] = [];
         const additions: SettingsAdd[] = [];
@@ -516,17 +520,17 @@ export function migrateIfNecessary(): void {
         backupSettings(currentSettings.version || 1);
 
         // each version should only bump to the next version so as to gradually migrate if necessary
-        if (currentSettings.version == undefined) {
+        if (currentSettings.version == null) {
             // migrating from 1 (`version` did not exist) to 2
-            migrationNotesFileName = 'migration-1-to-2.log';
+            migrationNotesFileName = "migration-1-to-2.log";
 
             migrateToTwo(currentSettings, transfers, changes, additions, removals, customHandlers);
         } else if (currentSettings.version === 2) {
-            migrationNotesFileName = 'migration-2-to-3.log';
+            migrationNotesFileName = "migration-2-to-3.log";
 
             migrateToThree(currentSettings, transfers, changes, additions, removals, customHandlers);
         } else if (currentSettings.version === 3) {
-            migrationNotesFileName = 'migration-3-to-4.log';
+            migrationNotesFileName = "migration-3-to-4.log";
 
             migrateToFour(currentSettings, transfers, changes, additions, removals, customHandlers);
         }
@@ -535,7 +539,7 @@ export function migrateIfNecessary(): void {
             const [validPath, previousValue, transfered] = transferValue(currentSettings, transfer);
 
             if (validPath && (!transfer.noteIf || transfer.noteIf(previousValue))) {
-                migrationNotes.add(`[${transfered ? 'TRANSFER' : 'REMOVAL'}] ${transfer.note}`);
+                migrationNotes.add(`[${transfered ? "TRANSFER" : "REMOVAL"}] ${transfer.note}`);
             }
         }
 
@@ -570,17 +574,16 @@ export function migrateIfNecessary(): void {
         }
 
         if (migrationNotesFileName && migrationNotes.size > 0) {
-            migrationNotes.add(`For more details, see https://github.com/Koenkk/zigbee2mqtt/discussions/24198`);
+            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');
+            writeFileSync(migrationNotesFilePath, Array.from(migrationNotes).join("\r\n\r\n"), "utf8");
 
             console.log(`Migration notes written in ${migrationNotesFilePath}`);
         }
-
-        // don't throw to allow stepping through versions (validates against current schema)
-        settings.apply(currentSettings as unknown as Record<string, unknown>, false);
-        settings.reRead();
-        currentSettings = settings.getPersistedSettings();
     }
+
+    // don't throw, onboarding will validate at end of process
+    settings.apply(currentSettings as unknown as Record<string, unknown>, false);
+    settings.reRead();
 }

lib/util/utils.ts

@@ -1,21 +1,22 @@
-import type {Zigbee2MQTTAPI, Zigbee2MQTTResponse, Zigbee2MQTTResponseEndpoints, Zigbee2MQTTScene} from 'lib/types/api';
-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 assert from 'node:assert';
-import crypto from 'node:crypto';
-import fs from 'node:fs';
-import path from 'node:path';
+import data from "./data";
 
-import equals from 'fast-deep-equal/es6';
-import humanizeDuration from 'humanize-duration';
+const BASE64_IMAGE_REGEX = /data:image\/(?<extension>.+);base64,(?<data>.+)/;
 
-import data from './data';
-
-const BASE64_IMAGE_REGEX = new RegExp(`data:image/(?<extension>.+);base64,(?<data>.+)`);
+export const DEFAULT_BIND_GROUP_ID = 901;
 
 function pad(num: number): string {
     const norm = Math.floor(Math.abs(num));
-    return (norm < 10 ? '0' : '') + norm;
+    return (norm < 10 ? "0" : "") + norm;
 }
 
 // construct a local ISO8601 string (instead of UTC-based)
@@ -24,82 +25,68 @@ function pad(num: number): string {
 //  - 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 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: undefined};
+        return {version, commitHash};
     }
 
     return await new Promise((resolve) => {
-        const version = packageJSON.version;
+        exec("git rev-parse --short=8 HEAD", (error, stdout) => {
+            commitHash = stdout.trim();
 
-        git.getLastCommit((err: Error, commit: {shortHash: string}) => {
-            let commitHash = undefined;
-
-            if (err) {
+            if (error || commitHash === "") {
                 try {
-                    commitHash = fs.readFileSync(path.join(__dirname, '..', '..', 'dist', '.hash'), 'utf-8');
-                    /* v8 ignore start */
+                    commitHash = fs.readFileSync(path.join(__dirname, "..", "..", "dist", ".hash"), "utf-8");
                 } catch {
-                    commitHash = 'unknown';
+                    commitHash = "unknown";
                 }
-                /* v8 ignore stop */
-            } else {
-                commitHash = commit.shortHash;
             }
 
-            commitHash = commitHash.trim();
             resolve({commitHash, version});
         });
     });
 }
 
 async function getDependencyVersion(depend: string): Promise<{version: string}> {
-    const packageJsonPath = require.resolve(`${depend}/package.json`);
-    const version = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8')).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;
+    for (const _k in object) return false;
     return true;
 }
 
@@ -135,27 +122,27 @@ function getResponse<T extends Zigbee2MQTTResponseEndpoints>(
     if (error !== undefined) {
         const response: Zigbee2MQTTResponse<T> = {
             data: {}, // always return an empty `data` payload on error
-            status: 'error',
+            status: "error",
             error: error,
         };
 
-        if (typeof request === 'object' && request.transaction !== undefined) {
-            response.transaction = request.transaction;
-        }
-
-        return response;
-    } else {
-        const response: Zigbee2MQTTResponse<T> = {
-            data, // valid from error check
-            status: 'ok',
-        };
-
-        if (typeof request === 'object' && request.transaction !== undefined) {
+        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 {
@@ -182,7 +169,7 @@ function removeNullPropertiesFromObject(obj: KeyValue, ignoreKeys: string[] = []
 
         if (value == null) {
             delete obj[key];
-        } else if (typeof value === 'object') {
+        } else if (typeof value === "object") {
             removeNullPropertiesFromObject(value, ignoreKeys);
         }
     }
@@ -190,7 +177,7 @@ function removeNullPropertiesFromObject(obj: KeyValue, ignoreKeys: string[] = []
 
 function toNetworkAddressHex(value: number): string {
     const hex = value.toString(16);
-    return `0x${'0'.repeat(4 - hex.length)}${hex}`;
+    return `0x${"0".repeat(4 - hex.length)}${hex}`;
 }
 
 function charRange(start: string, stop: string): number[] {
@@ -201,7 +188,7 @@ function charRange(start: string, stop: string): number[] {
     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++) {
@@ -215,25 +202,32 @@ function containsControlCharacter(str: string): boolean {
 
 function getAllFiles(path_: string): string[] {
     const result = [];
-    for (let item of fs.readdirSync(path_)) {
-        item = path.join(path_, item);
-        if (fs.lstatSync(item).isFile()) {
-            result.push(item);
+
+    for (const item of fs.readdirSync(path_, {withFileTypes: true})) {
+        if (item.isSymbolicLink()) {
+            continue;
+        }
+
+        const fileName = path.join(path_, item.name);
+
+        if (fs.lstatSync(fileName).isFile()) {
+            result.push(fileName);
         } else {
-            result.push(...getAllFiles(item));
+            result.push(...getAllFiles(fileName));
         }
     }
+
     return result;
 }
 
 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}')`);
     }
 
@@ -249,10 +243,7 @@ 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 {
@@ -261,22 +252,24 @@ function isAvailabilityEnabledForEntity(entity: Device | Group, settings: Settin
     }
 
     if (entity.isGroup()) {
-        return !entity.membersDevices().some((d) => !isAvailabilityEnabledForEntity(d, settings));
+        for (const memberDevice of entity.membersDevices()) {
+            if (!isAvailabilityEnabledForEntity(memberDevice, settings)) {
+                return false;
+            }
+        }
+
+        return true;
     }
 
     if (entity.options.availability != null) {
         return !!entity.options.availability;
     }
 
-    if (!settings.availability.enabled) {
-        return false;
-    }
-
-    return true;
+    return settings.availability.enabled;
 }
 
 function isZHEndpoint(obj: unknown): obj is zh.Endpoint {
-    return obj?.constructor.name.toLowerCase() === 'endpoint';
+    return obj?.constructor.name.toLowerCase() === "endpoint";
 }
 
 function flatten<Type>(arr: Type[][]): Type[] {
@@ -288,12 +281,12 @@ 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";
 }
 
-const hours = (hours: number): number => 1000 * 60 * 60 * hours;
-const minutes = (minutes: number): number => 1000 * 60 * minutes;
-const seconds = (seconds: number): number => 1000 * seconds;
+export const hours = (hours: number): number => 1000 * 60 * 60 * hours;
+export const minutes = (minutes: number): number => 1000 * 60 * minutes;
+export const seconds = (seconds: number): number => 1000 * seconds;
 
 async function publishLastSeen(
     data: eventdata.LastSeenChanged,
@@ -308,9 +301,9 @@ async function publishLastSeen(
      * - 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) {
-        await 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");
     }
 }
 
@@ -325,31 +318,37 @@ function filterProperties(filter: string[] | undefined, data: KeyValue): void {
 }
 
 export function isNumericExpose(expose: zhc.Expose): expose is zhc.Numeric {
-    return expose?.type === 'numeric';
+    return expose?.type === "numeric";
 }
 
 export function assertEnumExpose(expose: zhc.Expose): asserts expose is zhc.Enum {
-    assert(expose?.type === 'enum');
+    assert(expose?.type === "enum");
 }
 
 export function assertNumericExpose(expose: zhc.Expose): asserts expose is zhc.Numeric {
-    assert(expose?.type === 'numeric');
+    assert(expose?.type === "numeric");
 }
 
 export function assertBinaryExpose(expose: zhc.Expose): asserts expose is zhc.Binary {
-    assert(expose?.type === 'binary');
+    assert(expose?.type === "binary");
 }
 
 export function isEnumExpose(expose: zhc.Expose): expose is zhc.Enum {
-    return expose?.type === 'enum';
+    return expose?.type === "enum";
 }
 
 export function isBinaryExpose(expose: zhc.Expose): expose is zhc.Binary {
-    return expose?.type === 'binary';
+    return expose?.type === "binary";
 }
 
 export function isLightExpose(expose: zhc.Expose): expose is zhc.Light {
-    return expose.type === '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[] {
@@ -359,9 +358,9 @@ function getScenes(entity: zh.Endpoint | zh.Group): Zigbee2MQTTScene[] {
 
     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}`};
             }
@@ -372,7 +371,7 @@ function getScenes(entity: zh.Endpoint | zh.Group): Zigbee2MQTTScene[] {
 }
 
 function deviceNotCoordinator(device: zh.Device): boolean {
-    return device.type !== 'Coordinator';
+    return device.type !== "Coordinator";
 }
 
 function matchBase64File(value: string | undefined): {extension: string; data: string} | false {
@@ -387,11 +386,11 @@ function matchBase64File(value: string | undefined): {extension: string; data: s
 }
 
 function saveBase64DeviceIcon(base64Match: {extension: string; data: string}): string {
-    const md5Hash = crypto.createHash('md5').update(base64Match.data).digest('hex');
+    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'});
+    fs.writeFileSync(file, base64Match.data, {encoding: "base64"});
     return fileSettings;
 }
 

lib/util/yaml.ts

@@ -1,8 +1,8 @@
-import assert from 'node:assert';
-import fs from 'node:fs';
+import assert from "node:assert";
+import fs from "node:fs";
 
-import equals from 'fast-deep-equal/es6';
-import yaml, {YAMLException} from 'js-yaml';
+import equals from "fast-deep-equal/es6";
+import yaml, {YAMLException} from "js-yaml";
 
 export class YAMLFileException extends YAMLException {
     file: string;
@@ -10,7 +10,7 @@ export class YAMLFileException extends YAMLException {
     constructor(error: YAMLException, file: string) {
         super(error.reason, error.mark);
 
-        this.name = 'YAMLFileException';
+        this.name = "YAMLFileException";
         this.cause = error.cause;
         this.message = error.message;
         this.stack = error.stack;
@@ -20,8 +20,8 @@ export class YAMLFileException extends YAMLException {
 
 function read(file: string): KeyValue {
     try {
-        const result = yaml.load(fs.readFileSync(file, 'utf8'));
-        assert(result instanceof Object);
+        const result = yaml.load(fs.readFileSync(file, "utf8"));
+        assert(result instanceof Object, `The content of ${file} is expected to be an object`);
         return result as KeyValue;
     } catch (error) {
         if (error instanceof YAMLException) {

lib/zigbee.ts

@@ -1,48 +1,49 @@
-import type {Events as ZHEvents} from 'zigbee-herdsman';
+import {randomInt} from "node:crypto";
+import bind from "bind-decorator";
+import stringify from "json-stable-stringify-without-jsonify";
+import type {Events as ZHEvents} from "zigbee-herdsman";
+import {Controller} from "zigbee-herdsman";
+import type {StartResult} from "zigbee-herdsman/dist/adapter/tstype";
+import Device from "./model/device";
+import Group from "./model/group";
+import data from "./util/data";
+import logger from "./util/logger";
+import * as settings from "./util/settings";
+import utils from "./util/utils";
 
-import {randomInt} from 'node:crypto';
-
-import bind from 'bind-decorator';
-import stringify from 'json-stable-stringify-without-jsonify';
-
-import {Controller} from 'zigbee-herdsman';
-
-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 = new RegExp(`^(.+?)(?:/([^/]+))?$`);
+const entityIDRegex = /^(.+?)(?:\/([^/]+))?$/;
 
 export default class Zigbee {
-    // @ts-expect-error initialized in start
-    private herdsman: Controller;
+    #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');
+    get zhController() {
+        return this.#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: panId === 'GENERATE' ? this.generatePanID() : panId,
-                extendedPanID: extPanId === 'GENERATE' ? this.generateExtPanID() : extPanId,
+                panID: panId === "GENERATE" ? this.generatePanID() : panId,
+                extendedPanID: extPanId === "GENERATE" ? this.generateExtPanID() : extPanId,
                 channelList: [settings.get().advanced.channel],
-                networkKey: networkKey === 'GENERATE' ? this.generateNetworkKey() : networkKey,
+                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,
@@ -63,35 +64,39 @@ export default class Zigbee {
                 `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();
+            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;
         }
 
+        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.#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) => {
+        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) => {
+        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);
             /* v8 ignore next */ if (!device) return; // Prevent potential race
             await device.resolveDefinition();
@@ -99,35 +104,35 @@ export default class Zigbee {
             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);
             /* 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) => {
+        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['groupID'] !== undefined ? ` 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});
         });
 
         logger.info(`zigbee-herdsman started (${startResult})`);
         logger.info(`Coordinator firmware version: '${stringify(await this.getCoordinatorVersion())}'`);
-        logger.debug(`Zigbee network parameters: ${stringify(await this.herdsman.getNetworkParameters())}`);
+        logger.debug(`Zigbee network parameters: ${stringify(await this.#herdsman.getNetworkParameters())}`);
 
         for (const device of this.devicesIterator(utils.deviceNotCoordinator)) {
             // If a passlist is used, all other device will be removed from the network.
@@ -157,20 +162,19 @@ export default class Zigbee {
 
     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) {
+                // 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, ` +
-                        `please follow https://www.zigbee2mqtt.io/advanced/support-new-devices/01_support_new_devices.html`,
+                    `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'
@@ -180,120 +184,131 @@ export default class Zigbee {
 
     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);
+        settings.set(["advanced", "pan_id"], panID);
         return panID;
     }
 
     async getCoordinatorVersion(): Promise<zh.CoordinatorVersion> {
-        return await this.herdsman.getCoordinatorVersion();
+        return await this.#herdsman.getCoordinatorVersion();
     }
 
     isStopping(): boolean {
-        return this.herdsman.isStopping();
+        return this.#herdsman.isStopping();
     }
 
     async backup(): Promise<void> {
-        return await this.herdsman.backup();
+        return await this.#herdsman.backup();
     }
 
     async coordinatorCheck(): Promise<{missingRouters: Device[]}> {
-        const check = await this.herdsman.coordinatorCheck();
+        const check = await this.#herdsman.coordinatorCheck();
+        // biome-ignore lint/style/noNonNullAssertion: assumed valid
         return {missingRouters: check.missingRouters.map((d) => this.resolveDevice(d.ieeeAddr)!)};
     }
 
     async getNetworkParameters(): Promise<zh.NetworkParameters> {
-        return await this.herdsman.getNetworkParameters();
+        return await this.#herdsman.getNetworkParameters();
     }
 
     async stop(): Promise<void> {
-        logger.info('Stopping zigbee-herdsman...');
-        await this.herdsman.stop();
-        logger.info('Stopped zigbee-herdsman');
+        logger.info("Stopping zigbee-herdsman...");
+        await this.#herdsman.stop();
+        logger.info("Stopped zigbee-herdsman");
     }
 
     getPermitJoin(): boolean {
-        return this.herdsman.getPermitJoin();
+        return this.#herdsman.getPermitJoin();
     }
 
     getPermitJoinEnd(): number | undefined {
-        return this.herdsman.getPermitJoinEnd();
+        return this.#herdsman.getPermitJoinEnd();
     }
 
     async permitJoin(time: number, device?: Device): Promise<void> {
         if (time > 0) {
-            logger.info(`Zigbee: allowing new devices to join${device ? ` via ${device.name}` : ''}.`);
+            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.");
         }
 
-        await this.herdsman.permitJoin(time, device?.zh);
+        await this.#herdsman.permitJoin(time, device?.zh);
     }
 
-    async resolveDevicesDefinitions(ignoreCache: boolean = false): Promise<void> {
+    async resolveDevicesDefinitions(ignoreCache = false): Promise<void> {
         for (const device of this.devicesIterator(utils.deviceNotCoordinator)) {
             await device.resolveDefinition(ignoreCache);
         }
     }
 
     @bind private resolveDevice(ieeeAddr: string): Device | undefined {
-        if (!this.deviceLookup[ieeeAddr]) {
-            const device = this.herdsman.getDeviceByIeeeAddr(ieeeAddr);
+        if (!this.deviceLookup.has(ieeeAddr)) {
+            const device = this.#herdsman.getDeviceByIeeeAddr(ieeeAddr);
             if (device) {
-                this.deviceLookup[ieeeAddr] = new Device(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 {
-        const group = this.herdsman.getGroupByID(Number(groupID));
-        if (group && !this.groupLookup[groupID]) {
-            this.groupLookup[groupID] = new Group(group, this.resolveDevice);
+    private resolveGroup(groupID: number): Group | undefined {
+        if (!this.groupLookup.has(groupID)) {
+            const group = this.#herdsman.getGroupByID(groupID);
+
+            if (group) {
+                this.groupLookup.set(groupID, new Group(group, this.resolveDevice));
+            }
         }
 
-        return this.groupLookup[groupID];
+        const group = this.groupLookup.get(groupID);
+
+        if (group) {
+            group.ensureInSettings();
+            return group;
+        }
     }
 
     resolveEntity(key: string | number | zh.Device): Device | Group | undefined {
-        if (typeof key === 'object') {
+        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);
-            }
+        if (typeof key === "string" && (key.toLowerCase() === "coordinator" || key === this.coordinatorIeeeAddr)) {
+            return this.resolveDevice(this.coordinatorIeeeAddr);
+        }
 
-            const groupSettings = settings.getGroup(key);
+        const settingsDevice = settings.getDevice(key.toString());
 
-            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 (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 | undefined; 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)
@@ -301,14 +316,14 @@ 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 entityName = id;
+        let deviceOrGroup = this.resolveEntity(id);
         let endpointNameOrID: string | undefined;
 
         // 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);
 
             if (match) {
                 // Get the resulting IDs from the match
@@ -327,34 +342,39 @@ export default class Zigbee {
     }
 
     firstCoordinatorEndpoint(): zh.Endpoint {
-        return this.herdsman.getDevicesByType('Coordinator')[0].endpoints[0];
+        return this.#herdsman.getDevicesByType("Coordinator")[0].endpoints[0];
     }
 
     *devicesAndGroupsIterator(
         devicePredicate?: (value: zh.Device) => boolean,
         groupPredicate?: (value: zh.Group) => boolean,
     ): Generator<Device | Group> {
-        for (const device of this.herdsman.getDevicesIterator(devicePredicate)) {
+        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)) {
-            yield this.resolveGroup(group.groupID);
+        for (const group of this.#herdsman.getGroupsIterator(groupPredicate)) {
+            // biome-ignore lint/style/noNonNullAssertion: assumed valid
+            yield this.resolveGroup(group.groupID)!;
         }
     }
 
     *groupsIterator(predicate?: (value: zh.Group) => boolean): Generator<Group> {
-        for (const group of this.herdsman.getGroupsIterator(predicate)) {
-            yield this.resolveGroup(group.groupID);
+        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)) {
+        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;
@@ -363,54 +383,60 @@ 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 await this.herdsman.touchlinkFactoryResetFirst();
+        return await this.#herdsman.touchlink.factoryResetFirst();
     }
 
     async touchlinkFactoryReset(ieeeAddr: string, channel: number): Promise<boolean> {
-        return await this.herdsman.touchlinkFactoryReset(ieeeAddr, channel);
+        return await this.#herdsman.touchlink.factoryReset(ieeeAddr, channel);
     }
 
     async addInstallCode(installCode: string): Promise<void> {
-        await this.herdsman.addInstallCode(installCode);
+        await this.#herdsman.addInstallCode(installCode);
     }
 
     async touchlinkIdentify(ieeeAddr: string, channel: number): Promise<void> {
-        await this.herdsman.touchlinkIdentify(ieeeAddr, channel);
+        await this.#herdsman.touchlink.identify(ieeeAddr, channel);
     }
 
     async touchlinkScan(): Promise<{ieeeAddr: string; channel: number}[]> {
-        return await this.herdsman.touchlinkScan();
+        return await this.#herdsman.touchlink.scan();
     }
 
-    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 | undefined {
-        const device = this.herdsman.getDeviceByNetworkAddress(networkAddress);
+        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);
+    }
+
+    removeGroupFromLookup(id: number): void {
+        this.groupLookup.delete(id);
     }
 }

package.json

@@ -1,15 +1,16 @@
 {
     "name": "zigbee2mqtt",
-    "version": "2.1.1",
+    "version": "2.7.1",
     "description": "Zigbee to MQTT bridge using Zigbee-herdsman",
     "main": "index.js",
-    "packageManager": "pnpm@9.15.4",
+    "types": "dist/types/api.d.ts",
+    "packageManager": "pnpm@10.18.3",
     "repository": {
         "type": "git",
         "url": "git+https://github.com/Koenkk/zigbee2mqtt.git"
     },
     "engines": {
-        "node": "^18 || ^20 || ^22 || ^23"
+        "node": "^20.15.0 || ^22.2.0 || ^24"
     },
     "keywords": [
         "xiaomi",
@@ -22,14 +23,15 @@
     ],
     "scripts": {
         "build": "tsc && node index.js writehash",
-        "build-watch": "tsc --watch",
-        "eslint": "eslint --max-warnings=0",
-        "pretty:write": "prettier --write .",
-        "pretty:check": "prettier --check .",
+        "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",
+        "bench": "vitest bench --run --config ./test/vitest.config.mts",
         "prepack": "pnpm run clean && pnpm run build",
         "clean": "rimraf coverage dist tsconfig.tsbuildinfo"
     },
@@ -42,62 +44,59 @@
     "dependencies": {
         "ajv": "^8.17.1",
         "bind-decorator": "^1.0.11",
-        "debounce": "^2.2.0",
-        "express-static-gzip": "^2.2.0",
+        "debounce": "^3.0.0",
+        "express-static-gzip": "^3.0.0",
         "fast-deep-equal": "^3.1.3",
-        "finalhandler": "^1.3.1",
-        "git-last-commit": "^1.0.1",
-        "humanize-duration": "^3.32.1",
+        "finalhandler": "^2.1.1",
+        "humanize-duration": "^3.33.1",
         "js-yaml": "^4.1.0",
         "json-stable-stringify-without-jsonify": "^1.0.1",
         "jszip": "^3.10.1",
-        "moment": "^2.30.1",
-        "mqtt": "^5.10.3",
+        "mqtt": "^5.14.1",
         "object-assign-deep": "^0.4.0",
-        "rimraf": "^6.0.1",
-        "semver": "^7.7.0",
+        "rimraf": "^6.1.2",
+        "semver": "^7.7.3",
         "source-map-support": "^0.5.21",
         "throttleit": "^2.1.0",
-        "winston": "^3.17.0",
+        "winston": "^3.18.3",
         "winston-syslog": "^2.7.1",
         "winston-transport": "^4.9.0",
-        "ws": "^8.18.0",
-        "zigbee-herdsman": "3.2.5",
-        "zigbee-herdsman-converters": "21.31.0",
-        "zigbee2mqtt-frontend": "0.9.4"
+        "ws": "^8.18.1",
+        "zigbee-herdsman": "7.0.4",
+        "zigbee-herdsman-converters": "25.83.1",
+        "zigbee2mqtt-frontend": "0.9.21",
+        "zigbee2mqtt-windfront": "2.4.2"
     },
     "devDependencies": {
-        "@eslint/core": "^0.11.0",
-        "@eslint/js": "^9.19.0",
-        "@ianvs/prettier-plugin-sort-imports": "^4.4.1",
-        "@types/eslint__js": "^8.42.3",
+        "@biomejs/biome": "^2.3.8",
         "@types/finalhandler": "^1.2.3",
         "@types/humanize-duration": "^3.27.4",
         "@types/js-yaml": "^4.0.9",
-        "@types/node": "^22.13.0",
+        "@types/node": "^24.10.1",
         "@types/object-assign-deep": "^0.4.3",
-        "@types/readable-stream": "4.0.18",
-        "@types/sd-notify": "^2.8.2",
-        "@types/serve-static": "^1.15.7",
-        "@types/ws": "8.5.14",
-        "@vitest/coverage-v8": "^3.0.4",
-        "eslint": "^9.19.0",
-        "eslint-config-prettier": "^10.0.1",
-        "prettier": "^3.4.2",
-        "tmp": "^0.2.3",
-        "typescript": "^5.7.3",
-        "typescript-eslint": "^8.22.0",
-        "vitest": "^3.0.4"
+        "@types/readable-stream": "4.0.22",
+        "@types/serve-static": "^2.2.0",
+        "@types/ws": "8.18.1",
+        "@vitest/coverage-v8": "^3.1.1",
+        "tmp": "^0.2.5",
+        "typescript": "^5.9.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": {
-        "sd-notify": "^2.8.0"
+        "unix-dgram": "^2.0.7"
     }
 }

scripts/generateChangelog.js

@@ -1,150 +0,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 z2mTillVersion = process.argv[2];
-const zhcTillVersion = process.argv[3];
-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'),
-    },
-];
-
-const releaseRe = /## \[(.+)\]/;
-const changes = {features: [], fixes: [], detect: [], add: [], error: [], frontend: []};
-let context = null;
-const changeRe = [
-    /^\* (\*\*(.+):\*\*)?(.+)\((\[#\d+\]\(.+\))\) \(\[.+\]\(https:.+\/(.+)\)\)$/,
-    /^\* (\*\*(.+):\*\*)?(.+)(https:\/\/github\.com.+) \(\[.+\]\(https:.+\/(.+)\)\)$/,
-    /^\* (\*\*(.+):\*\*)?(.+)() \(\[.+\]\(https:.+\/(.+)\)\)$/,
-];
-const frontendChangeRe = /^\* (\*\*.+:\*\* )()?(.+) \(\[.+\]\(https:.+\/()(.+)\)\)(.+)?$/;
-
-let commitUserLookup = {};
-const commitUserFile = path.join(__dirname, 'commit-user-lookup.json');
-if (fs.existsSync(commitUserFile)) {
-    commitUserLookup = JSON.parse(fs.readFileSync(commitUserFile, 'utf8'));
-}
-
-const whiteLabels = zhc.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);
-        const changeMatch = changelog.isFrontend ? line.match(frontendChangeRe) : changeRe.map((re) => line.match(re)).find((e) => e);
-        if (releaseMatch) {
-            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 (changeMatch) {
-            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;
-            const messages = [];
-            let message = changeMatch[3].trim();
-            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(capitalizeFirstChar(message));
-            } else {
-                const otherUser = message.match(/\[@(.+)\]\(https:\/\/github.com\/.+\)/) || message.match(/@(.+)/);
-                if (otherUser) {
-                    user = otherUser[1];
-                    message = message.replace(otherUser[0], '');
-                }
-
-                if (localContext === 'add') {
-                    for (const model of message.split(',')) {
-                        const definition = zhc.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)`);
-                        }
-                    }
-                } else {
-                    messages.push(capitalizeFirstChar(message));
-                }
-
-                let issue = changeMatch[4].trim();
-                if (issue && !issue.startsWith('[#')) issue = `[#${issue.split('/').pop()}](${issue})`;
-                if (!issue) {
-                    issue = '_NO_ISSUE_';
-                    localContext = 'error';
-                }
-
-                messages.forEach((m) => changes[localContext].push(`- ${issue} ${m} (@${user})`));
-            }
-        } else if (line === '# Changelog' || line === '### ⚠ BREAKING CHANGES' || !line) {
-            continue;
-        } else {
-            changes['error'].push(`- Unmatched line: ${line}`);
-        }
-    }
-}
-
-let result = '';
-const names = [
-    ['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`;
-    }
-    changes[name[0]].forEach((e) => (result += `${e}\n`));
-    result += '\n';
-}
-
-fs.writeFileSync(commitUserFile, JSON.stringify(commitUserLookup), 'utf-8');
-
-console.log(result.trim());

scripts/generateChangelog.mjs

@@ -0,0 +1,185 @@
+import {execSync} from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import zhc from "zigbee-herdsman-converters";
+import definitionIndex from "zigbee-herdsman-converters/devices/index";
+
+const z2mTillVersion = process.argv[2];
+const zhcTillVersion = process.argv[3];
+const zhTillVersion = process.argv[4];
+const frontendTillVersion = process.argv[5];
+const windfrontTillVersion = process.argv[6];
+
+const changelogs = [
+    {
+        tillVersion: z2mTillVersion,
+        project: "koenkk/zigbee2mqtt",
+        contents: fs.readFileSync(path.join(import.meta.dirname, "..", "CHANGELOG.md"), "utf-8").split("\n"),
+    },
+    {
+        tillVersion: zhcTillVersion,
+        project: "koenkk/zigbee-herdsman-converters",
+        contents: fs
+            .readFileSync(path.join(import.meta.dirname, "..", "node_modules", "zigbee-herdsman-converters", "CHANGELOG.md"), "utf-8")
+            .split("\n"),
+    },
+    {
+        tillVersion: zhTillVersion,
+        project: "koenkk/zigbee-herdsman",
+        contents: fs.readFileSync(path.join(import.meta.dirname, "..", "node_modules", "zigbee-herdsman", "CHANGELOG.md"), "utf-8").split("\n"),
+    },
+    {
+        tillVersion: frontendTillVersion,
+        project: "nurikk/zigbee2mqtt-frontend",
+        isFrontend: true,
+        contents: fs.readFileSync(path.join(import.meta.dirname, "..", "node_modules", "zigbee2mqtt-frontend", "CHANGELOG.md"), "utf-8").split("\n"),
+    },
+    {
+        tillVersion: windfrontTillVersion,
+        project: "Nerivec/zigbee2mqtt-windfront",
+    },
+];
+
+const releaseRe = /## \[(.+)\]/;
+const windfrontChangeRe = /^\* (feat|fix): (.+?)(?: by @([^\s]+) in (https:\/\/github\.com\/Nerivec\/zigbee2mqtt-windfront\/pull\/(\d+)))?$/gm;
+const changes = {features: [], fixes: [], detect: [], add: [], error: [], frontend: [], windfront: []};
+let context = null;
+const changeRe = [
+    /^\* (\*\*(.+):\*\*)?(.+)\((\[#\d+\]\(.+\))\) \(\[.+\]\(https:.+\/(.+)\)\)$/,
+    /^\* (\*\*(.+):\*\*)?(.+)(https:\/\/github\.com.+) \(\[.+\]\(https:.+\/(.+)\)\)$/,
+    /^\* (\*\*(.+):\*\*)?(.+)() \(\[.+\]\(https:.+\/(.+)\)\)$/,
+];
+const frontendChangeRe = /^\* (\*\*.+:\*\* )()?(.+) \(\[.+\]\(https:.+\/()(.+)\)\)(.+)?$/;
+
+let commitUserLookup = {};
+const commitUserFile = path.join(import.meta.dirname, "commit-user-lookup.json");
+if (fs.existsSync(commitUserFile)) {
+    commitUserLookup = JSON.parse(fs.readFileSync(commitUserFile, "utf8"));
+}
+
+const definitions = definitionIndex.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) {
+    if (changelog.project === "Nerivec/zigbee2mqtt-windfront") {
+        const releaseRsp = await fetch("https://api.github.com/repos/Nerivec/zigbee2mqtt-windfront/releases");
+        const releases = await releaseRsp.json();
+        for (const release of releases) {
+            if (release.name === `v${windfrontTillVersion}`) {
+                break;
+            }
+
+            let match = windfrontChangeRe.exec(release.body);
+            while (match !== null) {
+                const [, type, message, user, prLink, prId] = match;
+                const entry = `- ${prId && prLink ? `[#${prId}](${prLink}) ` : ""}${type}: ${message} ${user ? `(@${user.split("[")[0]})` : ""}`;
+                changes.windfront.push(entry);
+                match = windfrontChangeRe.exec(release.body);
+            }
+        }
+    } else {
+        for (const line of changelog.contents) {
+            const releaseMatch = line.match(releaseRe);
+            const changeMatch = changelog.isFrontend ? line.match(frontendChangeRe) : changeRe.map((re) => line.match(re)).find((e) => e);
+            if (releaseMatch) {
+                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 (changeMatch) {
+                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;
+                const messages = [];
+                let message = changeMatch[3].trim();
+                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(capitalizeFirstChar(message));
+                } else {
+                    const otherUser = message.match(/\[@(.+)\]\(https:\/\/github.com\/.+\)/) || message.match(/@(.+)/);
+                    if (otherUser) {
+                        user = otherUser[1];
+                        message = message.replace(otherUser[0], "");
+                    }
+
+                    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)`);
+                            }
+                        }
+                    } else {
+                        messages.push(capitalizeFirstChar(message));
+                    }
+
+                    let issue = changeMatch[4].trim();
+                    if (issue && !issue.startsWith("[#")) issue = `[#${issue.split("/").pop()}](${issue})`;
+                    if (!issue) {
+                        issue = "_NO_ISSUE_";
+                        localContext = "error";
+                    }
+
+                    for (const message of messages) {
+                        changes[localContext].push(`- ${issue} ${message} (@${user})`);
+                    }
+                }
+            } else if (line === "# Changelog" || line === "### ⚠ BREAKING CHANGES" || !line) {
+                // continue;
+            } else {
+                changes.error.push(`- Unmatched line: ${line}`);
+            }
+        }
+    }
+}
+
+let result = "";
+const names = [
+    ["features", "Improvements"],
+    ["fixes", "Fixes"],
+    ["windfront", "Windfront"],
+    ["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`;
+    }
+
+    for (const change of changes[name[0]]) {
+        result += `${change}\n`;
+    }
+
+    result += "\n";
+}
+
+fs.writeFileSync(commitUserFile, JSON.stringify(commitUserLookup), "utf-8");
+
+console.log(result.trim());

scripts/issueBot.mjs

@@ -0,0 +1,149 @@
+import {execSync} from "node:child_process";
+
+export async function newDeviceSupport(github, _core, context, zhcDir) {
+    const issue = context.payload.issue;
+    // Hide previous bot comments
+    const comments = await github.rest.issues.listComments({
+        owner: context.repo.owner,
+        repo: context.repo.repo,
+        issue_number: issue.number,
+    });
+
+    for (const comment of comments.data) {
+        if (comment.user.type === "Bot" && comment.user.login === "github-actions[bot]") {
+            await github.graphql(`mutation {
+    minimizeComment(input: {subjectId: "${comment.node_id}", classifier: OUTDATED}) {
+        clientMutationId
+    }
+}`);
+        }
+    }
+
+    const titleAndBody = `${issue.title}\n\n${issue.body ?? ""}`;
+
+    // Check if Tuya manufacturer name is already supported.
+    const tuyaManufacturerNameRe = /['"](_T\w+_(\w+))['"]/g;
+    const tuyaManufacturerNames = Array.from(titleAndBody.matchAll(tuyaManufacturerNameRe), (m) => [m[1], m[2]]);
+    console.log("Found tuyaManufacturerNames", tuyaManufacturerNames);
+    if (tuyaManufacturerNames.length > 0) {
+        for (const [fullName, partialName] of tuyaManufacturerNames) {
+            const fullMatch = (() => {
+                try {
+                    return execSync(`grep -r --include="*.ts" "${fullName}" "${zhcDir}"`, {encoding: "utf8"});
+                } catch {
+                    return undefined;
+                }
+            })();
+
+            console.log(`Checking full match for '${fullName}', result: '${fullMatch}'`);
+            if (fullMatch) {
+                await github.rest.issues.createComment({
+                    owner: context.repo.owner,
+                    repo: context.repo.repo,
+                    issue_number: issue.number,
+                    body: `👋 Hi there! The Tuya device with manufacturer name \`${fullName}\` is already supported in the latest dev branch.
+See this [guide](https://www.zigbee2mqtt.io/advanced/more/switch-to-dev-branch.html) on how to update, after updating you can remove your external converter.
+
+In case you created the external converter with the goal to extend or fix an issue with the out-of-the-box support, please submit a pull request.
+For instructions on how to create a pull request see the [docs](https://www.zigbee2mqtt.io/advanced/support-new-devices/01_support_new_devices.html#_4-create-a-pull-request).
+If you need help with the process, feel free to ask here and we'll be happy to assist.`,
+                });
+                await github.rest.issues.update({
+                    owner: context.repo.owner,
+                    repo: context.repo.repo,
+                    issue_number: issue.number,
+                    state: "closed",
+                });
+
+                return;
+            }
+
+            const partialMatch = (() => {
+                try {
+                    return execSync(`grep -r --include="*.ts" "${partialName}" "${zhcDir}"`, {encoding: "utf8"});
+                } catch {
+                    return undefined;
+                }
+            })();
+
+            console.log(`Checking partial match for '${partialName}', result: '${partialMatch}'`);
+            if (partialMatch) {
+                const candidates = Array.from(partialMatch.matchAll(tuyaManufacturerNameRe), (m) => m[1]);
+
+                await github.rest.issues.createComment({
+                    owner: context.repo.owner,
+                    repo: context.repo.repo,
+                    issue_number: issue.number,
+                    body: `👋 Hi there! A similar Tuya device of which the manufacturer name also ends with \`_${partialName}\` is already supported.
+This means the device can probably be easily be supported by re-using the existing converter.
+
+I found the following matches: ${candidates.map((c) => `\`${c}\``).join(", ")}
+Try to stop Z2M, change all occurrences of \`${fullName}\` in the \`data/database.db\` to one of the matches above and start Z2M.
+
+Let us know if it works so we can support this device out-of-the-box!`,
+                });
+
+                return;
+            }
+        }
+    } else {
+        // Check if zigbee model is already supported.
+        const zigbeeModelRe = /zigbeeModel: \[['"](.+)['"]\]/g;
+        const zigbeeModels = Array.from(titleAndBody.matchAll(zigbeeModelRe), (m) => m[1]);
+
+        if (zigbeeModels.length > 0) {
+            for (const zigbeeModel of zigbeeModels) {
+                const fullMatch = (() => {
+                    try {
+                        return execSync(`grep -r --include="*.ts" '"${zigbeeModel}"' "${zhcDir}"`, {encoding: "utf8"});
+                    } catch {
+                        return undefined;
+                    }
+                })();
+
+                if (fullMatch) {
+                    await github.rest.issues.createComment({
+                        owner: context.repo.owner,
+                        repo: context.repo.repo,
+                        issue_number: issue.number,
+                        body: `👋 Hi there! The device with zigbee model \`${zigbeeModel}\` is already supported in the latest dev branch.
+See this [guide](https://www.zigbee2mqtt.io/advanced/more/switch-to-dev-branch.html) on how to update, after updating you can remove your external converter.
+
+In case you created the external converter with the goal to extend or fix an issue with the out-of-the-box support, please submit a pull request.
+For instructions on how to create a pull request see the [docs](https://www.zigbee2mqtt.io/advanced/support-new-devices/01_support_new_devices.html#_4-create-a-pull-request).
+
+If you need help with the process, feel free to ask here and we'll be happy to assist.`,
+                    });
+                    await github.rest.issues.update({
+                        owner: context.repo.owner,
+                        repo: context.repo.repo,
+                        issue_number: issue.number,
+                        state: "closed",
+                    });
+
+                    return;
+                }
+            }
+        }
+    }
+
+    // Create a request to pull request comment
+    await github.rest.issues.createComment({
+        owner: context.repo.owner,
+        repo: context.repo.repo,
+        issue_number: issue.number,
+        body: `🙏 Thank you for creating this issue and sharing your external converter!
+
+In case all features work, please submit a pull request on this repository so the device can be supported out-of-the-box with the next release.
+For instructions on how to create a pull request see the [docs](https://www.zigbee2mqtt.io/advanced/support-new-devices/01_support_new_devices.html#_4-create-a-pull-request).
+
+If **NOT** all features work, please follow the [How To Support new devices](https://www.zigbee2mqtt.io/advanced/support-new-devices/01_support_new_devices.html).
+${
+    tuyaManufacturerNames.length > 0
+        ? "Since this is a Tuya also consider [How To Support new Tuya devices](https://www.zigbee2mqtt.io/advanced/support-new-devices/02_support_new_tuya_devices.html)."
+        : ""
+}
+
+If you need help with the process, feel free to ask here and we'll be happy to assist.`,
+    });
+}

scripts/testExternalConverter.js

@@ -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: {},

scripts/zStackEraseAllNvMem.js

@@ -1,7 +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) {
@@ -13,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) {
@@ -23,10 +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)})`);
@@ -39,13 +39,13 @@ class ZStackNvMemEraser {
     async clearAllNvMemItems() {
         let maxNvMemId;
         switch (this.version.product) {
-            case ZnpVersion.zStack12:
+            case ZnpVersion.ZStack12:
                 maxNvMemId = 0x0302;
                 break;
-            case ZnpVersion.zStack30x:
+            case ZnpVersion.ZStack30x:
                 maxNvMemId = 0x033f;
                 break;
-            case ZnpVersion.zStack3x0:
+            case ZnpVersion.ZStack3x0:
                 maxNvMemId = 0x032f;
                 break;
         }
@@ -54,23 +54,23 @@ class ZStackNvMemEraser {
         console.log(`Clearing all NVMEM items, from 0 to ${maxNvMemId}`);
         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}, undefined, undefined, [
+                    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}, undefined, undefined, [
+                    await this.znp.request(Subsystem.SYS, "nvDelete", {sysid: NvSystemIds.ZSTACK, itemid: id, subid: 0}, undefined, undefined, [
                         ZnpCommandStatus.SUCCESS,
                         ZnpCommandStatus.NV_ITEM_INITIALIZED,
                     ]);
@@ -82,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);
 }
 

test/assets/external_converters/cjs/mock-external-converter-multiple.js

@@ -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;

test/assets/external_converters/cjs/mock-external-converter.js

@@ -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;

test/assets/external_converters/mjs/mock-external-converter-multiple.mjs

@@ -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: [],
+    },
+];

test/assets/external_converters/mjs/mock-external-converter.mjs

@@ -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()],
+};

test/assets/external_converters/mock-external-converter-multiple.js

@@ -1,24 +0,0 @@
-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;

test/assets/external_converters/mock-external-converter.js

@@ -1,12 +0,0 @@
-const mockDevice = {
-    mock: true,
-    zigbeeModel: ['external_converter_device'],
-    vendor: 'external',
-    model: 'external_converter_device',
-    description: 'external',
-    fromZigbee: [],
-    toZigbee: [],
-    exposes: [],
-};
-
-module.exports = mockDevice;

test/assets/external_extensions/cjs/example2Extension.js

@@ -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;

test/assets/external_extensions/cjs/exampleExtension.js

@@ -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;

test/assets/external_extensions/example2Extension.js

@@ -1,16 +0,0 @@
-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;

test/assets/external_extensions/exampleExtension.js

@@ -1,16 +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', 'call from start');
-    }
-
-    stop() {
-        this.mqtt.publish('example/extension', 'call from stop');
-    }
-}
-
-module.exports = Example;

test/assets/external_extensions/mjs/example2Extension.mjs

@@ -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");
+    }
+}

test/assets/external_extensions/mjs/exampleExtension.mjs

@@ -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}`);
+    }
+}

test/benchOptions.ts

@@ -0,0 +1,14 @@
+import {hrtime} from "node:process";
+import type {bench} from "vitest";
+
+export const BENCH_OPTIONS: NonNullable<Parameters<typeof bench>[2]> = {
+    throws: true,
+    warmupTime: 1000,
+    now: () => Number(hrtime.bigint()) / 1e6,
+    setup: (_task, mode) => {
+        // Run the garbage collector before warmup at each cycle
+        if (mode === "warmup" && typeof globalThis.gc === "function") {
+            globalThis.gc();
+        }
+    },
+};

test/controller.bench.ts

@@ -0,0 +1,662 @@
+import {existsSync, mkdirSync} from "node:fs";
+import stringify from "json-stable-stringify-without-jsonify";
+import {bench, describe, vi} from "vitest";
+import {type Controller, Zcl, Zdo, ZSpec} from "zigbee-herdsman";
+import type Adapter from "zigbee-herdsman/dist/adapter/adapter";
+import type {ZclPayload} from "zigbee-herdsman/dist/adapter/events";
+import {Device, InterviewState} from "zigbee-herdsman/dist/controller/model/device";
+import {Endpoint} from "zigbee-herdsman/dist/controller/model/endpoint";
+import Entity from "zigbee-herdsman/dist/controller/model/entity";
+import {Group} from "zigbee-herdsman/dist/controller/model/group";
+import type {DeviceType} from "zigbee-herdsman/dist/controller/tstype";
+import {Foundation} from "zigbee-herdsman/dist/zspec/zcl/definition/foundation";
+import type {RequestToResponseMap} from "zigbee-herdsman/dist/zspec/zdo/definition/tstypes";
+import data from "../lib/util/data";
+import {BENCH_OPTIONS} from "./benchOptions";
+
+vi.doMock("zigbee-herdsman", async (importOriginal) => {
+    const actual = await importOriginal<typeof import("zigbee-herdsman")>();
+    class MockHerdsman {
+        on: Controller["on"] = vi.fn();
+        start: Controller["start"] = async () => "resumed" as const;
+        stop: Controller["stop"] = async () => {};
+        isStopping: Controller["isStopping"] = () => false;
+        getCoordinatorVersion: Controller["getCoordinatorVersion"] = async () =>
+            Promise.resolve({
+                type: "Dummy",
+                meta: {revision: "9.9.9"},
+            });
+        getNetworkParameters: Controller["getNetworkParameters"] = async () => Promise.resolve({...NETWORK_PARAMS});
+        getPermitJoin: Controller["getPermitJoin"] = () => false;
+        getPermitJoinEnd: Controller["getPermitJoinEnd"] = () => undefined;
+        getDeviceByIeeeAddr: Controller["getDeviceByIeeeAddr"] = (ieeeAddr) => ZH_DEVICES.find((device) => device.ieeeAddr === ieeeAddr);
+        getGroupByID: Controller["getGroupByID"] = (id) => ZH_GROUPS.find((group) => group.groupID === id);
+        getDevicesByType: Controller["getDevicesByType"] = (type) => ZH_DEVICES.filter((device) => device.type === type);
+        getDeviceByNetworkAddress: Controller["getDeviceByNetworkAddress"] = (networkAddress) =>
+            ZH_DEVICES.find((device) => device.networkAddress === networkAddress);
+        *getDevicesIterator(predicate: ((device: Device) => boolean) | undefined) {
+            for (const device of ZH_DEVICES) {
+                if (!predicate || predicate(device)) {
+                    yield device;
+                }
+            }
+        }
+        *getGroupsIterator(predicate: ((group: Group) => boolean) | undefined) {
+            for (const group of ZH_GROUPS) {
+                if (!predicate || predicate(group)) {
+                    yield group;
+                }
+            }
+        }
+    }
+
+    return {
+        ...actual,
+        Controller: MockHerdsman,
+    };
+});
+
+process.env.ZIGBEE2MQTT_DATA = "data-bench";
+data._testReload();
+
+if (!existsSync(data.getPath())) {
+    mkdirSync(data.getPath(), {recursive: true});
+}
+
+const createEndpoint = (id: number, ieeeAddr: string, networkAddress: number) => {
+    const ep = Endpoint.create(
+        id,
+        id === ZSpec.GP_ENDPOINT ? ZSpec.GP_PROFILE_ID : ZSpec.HA_PROFILE_ID,
+        id === ZSpec.GP_ENDPOINT ? 0x66 : 0x65,
+        id === ZSpec.GP_ENDPOINT ? [Zcl.Clusters.greenPower.ID] : [Zcl.Clusters.genBasic.ID, Zcl.Clusters.genOnOff.ID],
+        id === ZSpec.GP_ENDPOINT ? [Zcl.Clusters.greenPower.ID] : [Zcl.Clusters.genBasic.ID],
+        networkAddress,
+        ieeeAddr,
+    );
+    ep.save = () => {};
+
+    return ep;
+};
+// `Device.create` requires `Database`, bypass it by using the private constructor directly
+const createDevice = (
+    dbId: number,
+    type: DeviceType,
+    ieeeAddr: string,
+    networkAddress: number,
+    manufacturerID: number | undefined,
+    manufacturerName: string | undefined,
+    powerSource: string | undefined,
+    modelID: string | undefined,
+): Device => {
+    const haEp = createEndpoint(ZSpec.HA_ENDPOINT, ieeeAddr, networkAddress);
+    const ep2 = createEndpoint(2, ieeeAddr, networkAddress);
+    const endpoints = [haEp, ep2];
+
+    if (type === "Coordinator" || type === "Router") {
+        const gpEp = createEndpoint(ZSpec.GP_ENDPOINT, ieeeAddr, networkAddress);
+
+        endpoints.push(gpEp);
+    }
+
+    // @ts-expect-error mocking private
+    const device = new Device(
+        dbId,
+        type,
+        ieeeAddr,
+        networkAddress,
+        manufacturerID,
+        endpoints,
+        manufacturerName,
+        powerSource,
+        modelID,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        InterviewState.Successful,
+        {},
+        undefined,
+        undefined,
+        0,
+        undefined,
+    );
+
+    // in-memory only
+    device.save = () => {};
+
+    return device;
+};
+// `Group.create` requires `Database`, bypass it by using the private constructor directly
+const createGroup = (dbId: number, id: number): Group => {
+    // @ts-expect-error mocking private
+    const group = new Group(dbId, id, [], {});
+
+    // in-memory only
+    group.save = () => {};
+
+    return group;
+};
+
+const COORD_IEEE = "0x0101010101010101";
+const EXT_PAN_ID = [0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd];
+const NETWORK_PARAMS = {
+    panID: 0x1a62,
+    extendedPanID: `0x${Buffer.from(EXT_PAN_ID).toString("hex")}`,
+    channel: 11,
+    nwkUpdateID: 1,
+};
+const NETWORK_KEY = [1, 3, 5, 7, 9, 11, 13, 15, 0, 2, 4, 6, 8, 10, 12, 13];
+const ZH_DEVICES: Device[] = [];
+const ZH_GROUPS: Group[] = [];
+const MANY_DEVICES = 100;
+
+const initDevices = () => {
+    ZH_DEVICES.splice(0, ZH_DEVICES.length);
+
+    ZH_DEVICES.push(
+        createDevice(
+            0,
+            "Coordinator",
+            COORD_IEEE,
+            ZSpec.COORDINATOR_ADDRESS,
+            Zcl.ManufacturerCode.SILICON_LABORATORIES,
+            undefined,
+            undefined,
+            undefined,
+        ),
+    );
+    ZH_DEVICES.push(
+        createDevice(1, "Router", "0xf1f1f1f1f1f1f1f1", 0x0001, Zcl.ManufacturerCode.INNR_LIGHTING_BV, "Innr", "Mains (single phase)", "AE 262"),
+    );
+    ZH_DEVICES.push(
+        createDevice(2, "EndDevice", "0xe2e2e2e2e2e2e2e2", 0x0002, Zcl.ManufacturerCode.TUYA_GLOBAL_INC, "_TYZB01_kvwjujy9", "Battery", "TS0222"),
+    );
+    ZH_DEVICES.push(createDevice(3, "GreenPower", "0x00000000015d3d3d", 0x0003, undefined, undefined, undefined, "GreenPower_7"));
+    // these have configure, without setTimeout, they hammer really badly (# of fn calls), so, only one of each
+    ZH_DEVICES.push(
+        createDevice(
+            4,
+            "Router",
+            "0xd3d3d3d3d3d3d3d3",
+            0x0004,
+            Zcl.ManufacturerCode.LEDVANCE_GMBH,
+            "LEDVANCE",
+            "Mains (single phase)",
+            "PLUG OUTDOOR EU T",
+        ),
+    );
+    ZH_DEVICES.push(
+        createDevice(5, "Router", "0xc4c4c4c4c4c4c4c4", 0x0005, Zcl.ManufacturerCode.INOVELLI, "Inovelli", "Mains (single phase)", "VZM35-SN"),
+    );
+    ZH_DEVICES.push(
+        createDevice(
+            6,
+            "Router",
+            "0xb5b5b5b5b5b5b5b5",
+            0x0006,
+            Zcl.ManufacturerCode.SILICON_LABORATORIES,
+            "SMLIGHT",
+            "Mains (single phase)",
+            "SLZB-06Mg24",
+        ),
+    );
+    ZH_DEVICES.push(
+        createDevice(
+            7,
+            "Router",
+            "0xa6a6a6a6a6a6a6a6",
+            0x0007,
+            Zcl.ManufacturerCode.TUYA_GLOBAL_INC,
+            "_TZE200_p0gzbqct",
+            "Mains (single phase)",
+            "TS0601",
+        ),
+    );
+};
+
+const initGroups = () => {
+    ZH_GROUPS.splice(0, ZH_GROUPS.length);
+
+    ZH_GROUPS.push(createGroup(0, 1));
+};
+
+const addManyDevices = () => {
+    for (let i = 0; i < MANY_DEVICES; i++) {
+        const ieee = `0xf1f1f1f1f1f1f1${i.toString(16).padStart(2, "0")}`;
+
+        // device without `configure` (too many calls otherwise)
+        ZH_DEVICES.push(createDevice(1, "Router", ieee, 0x0008 + i, Zcl.ManufacturerCode.INNR_LIGHTING_BV, "Innr", "Mains (single phase)", "AE 262"));
+    }
+};
+
+const getMidDeviceIeee = () =>
+    `0xf1f1f1f1f1f1f1${Math.floor(MANY_DEVICES / 2)
+        .toString(16)
+        .padStart(2, "0")}`;
+
+Device.byIeeeAddr = (ieeeAddr, _includeDeleted) => ZH_DEVICES.find((device) => device.ieeeAddr === ieeeAddr);
+Device.byType = (type) => ZH_DEVICES.filter((device) => device.type === type);
+
+const adapter = {
+    sendZclFrameToEndpoint: async (
+        _ieeeAddr: string,
+        networkAddress: number,
+        endpoint: number,
+        zclFrame: Zcl.Frame,
+        _timeout: number,
+        disableResponse: boolean,
+        _disableRecovery: boolean,
+        sourceEndpoint?: number,
+    ): Promise<ZclPayload | undefined> => {
+        const payload: {[key: string]: unknown}[] = [];
+
+        if (!disableResponse) {
+            if (zclFrame.header.isGlobal) {
+                switch (zclFrame.command.ID) {
+                    case Foundation.read.ID: {
+                        for (const attr of zclFrame.payload) {
+                            const attribute = zclFrame.cluster.getAttribute(attr.attrId);
+
+                            if (attribute && attribute.type !== Zcl.DataType.NO_DATA && attribute.type < Zcl.DataType.OCTET_STR) {
+                                payload.push({
+                                    attrId: attr.attrId,
+                                    dataType: attribute.type,
+                                    attrData: 1,
+                                    status: 0,
+                                });
+                            }
+                        }
+
+                        const messageContents = Zcl.Frame.create(
+                            0,
+                            Zcl.Direction.SERVER_TO_CLIENT,
+                            true,
+                            undefined,
+                            10,
+                            Foundation.readRsp.ID,
+                            zclFrame.cluster.ID,
+                            payload,
+                            {},
+                        ).toBuffer();
+
+                        return await Promise.resolve({
+                            clusterID: zclFrame.cluster.ID,
+                            header: Zcl.Header.fromBuffer(messageContents),
+                            address: networkAddress,
+                            data: messageContents,
+                            endpoint: sourceEndpoint ?? 1,
+                            linkquality: 200,
+                            groupID: 0,
+                            wasBroadcast: false,
+                            destinationEndpoint: endpoint,
+                        });
+                    }
+                    case Foundation.configReport.ID: {
+                        for (const item of zclFrame.payload) {
+                            payload.push({attrId: item.attrId, status: 0, direction: 1});
+                        }
+
+                        const messageContents = Zcl.Frame.create(
+                            0,
+                            Zcl.Direction.SERVER_TO_CLIENT,
+                            true,
+                            undefined,
+                            10,
+                            Foundation.configReportRsp.ID,
+                            zclFrame.cluster.ID,
+                            payload,
+                            {},
+                        ).toBuffer();
+
+                        return await Promise.resolve({
+                            clusterID: zclFrame.cluster.ID,
+                            header: Zcl.Header.fromBuffer(messageContents),
+                            address: networkAddress,
+                            data: messageContents,
+                            endpoint: sourceEndpoint ?? 1,
+                            linkquality: 200,
+                            groupID: 0,
+                            wasBroadcast: false,
+                            destinationEndpoint: endpoint,
+                        });
+                    }
+                }
+            }
+        }
+
+        return await Promise.resolve(undefined);
+    },
+    sendZclFrameToGroup: async (_groupID: number, _zclFrame: Zcl.Frame, _sourceEndpoint?: number): Promise<void> => await Promise.resolve(),
+    sendZdo: async (
+        _ieeeAddress: string,
+        _networkAddress: number,
+        clusterId: Zdo.ClusterId,
+        _payload: Buffer,
+        _disableResponse: boolean,
+    ): Promise<RequestToResponseMap[keyof RequestToResponseMap] | undefined> => {
+        switch (clusterId) {
+            case Zdo.ClusterId.BIND_REQUEST:
+            case Zdo.ClusterId.UNBIND_REQUEST: {
+                return await Promise.resolve([Zdo.Status.SUCCESS, undefined]);
+            }
+        }
+
+        return await Promise.resolve(undefined);
+    },
+};
+
+Entity.injectAdapter(adapter as Adapter);
+
+// use plain type to avoid early import that otherwise messes with data path
+let controller: import("../lib/controller.js").Controller;
+const origSetImmediate = global.setImmediate;
+const origSetTimeout = global.setTimeout;
+
+const mockGlobalThis = () => {
+    const setImmediateProms: (void | Promise<void>)[] = [];
+    const setTimeoutProms: (void | Promise<void>)[] = [];
+
+    // @ts-expect-error mock
+    globalThis.setImmediate = (callback: () => void) => {
+        setImmediateProms.push(callback());
+    };
+    // @ts-expect-error mock
+    globalThis.setTimeout = (callback: () => void) => {
+        setTimeoutProms.push(callback());
+    };
+
+    return {setImmediateProms, setTimeoutProms};
+};
+
+const unmockGlobalThis = () => {
+    globalThis.setImmediate = origSetImmediate;
+    globalThis.setTimeout = origSetTimeout;
+};
+
+const settle = async (mockedGlobal: ReturnType<typeof mockGlobalThis>) => {
+    await Promise.allSettled(mockedGlobal.setImmediateProms);
+    await Promise.allSettled(mockedGlobal.setTimeoutProms);
+    await new Promise((resolve) => origSetImmediate(resolve));
+};
+
+const initSettings = async (pathValuePairs?: [string[], string | number | boolean][]) => {
+    const settings = await import("../lib/util/settings.js");
+
+    settings.writeMinimalDefaults();
+    // disable logging, too much influence on perf
+    settings.set(["advanced", "log_level"], "error");
+    settings.set(["advanced", "log_output"], []);
+    settings.set(["advanced", "pan_id"], NETWORK_PARAMS.panID);
+    settings.set(["advanced", "ext_pan_id"], EXT_PAN_ID);
+    settings.set(["advanced", "network_key"], NETWORK_KEY);
+
+    if (pathValuePairs) {
+        for (const [path, value] of pathValuePairs) {
+            settings.set(path, value);
+        }
+    }
+};
+
+const initController = async () => {
+    const {Controller} = await import("../lib/controller.js");
+
+    controller = new Controller(
+        async () => {},
+        async () => {},
+    );
+
+    // all dummies, can trigger `controller.mqtt.onMessage(topic, message)` as needed
+    // @ts-expect-error mocking private
+    controller.mqtt.client = {
+        options: {
+            protocolVersion: 5,
+            protocol: "mqtt",
+            host: "localhost",
+            port: 1883,
+        },
+        queue: [],
+        reconnecting: false,
+        disconnecting: false,
+        disconnected: false,
+        endAsync: async () => {},
+        // @ts-expect-error Z2M does not make use of return
+        publishAsync: async () => {},
+    };
+    controller.mqtt.connect = async () => {
+        // @ts-expect-error private
+        await controller.mqtt.onConnect();
+    };
+    controller.mqtt.subscribe = async () => {};
+    controller.mqtt.unsubscribe = async () => {};
+
+    // will be in-memory only
+    controller.state.start = () => {};
+    controller.state.stop = () => {};
+};
+
+describe("Controller with dummy zigbee/mqtt", () => {
+    bench(
+        "[defaults] start & stop controller",
+        async () => {
+            initDevices();
+            initGroups();
+            await initSettings();
+            await initController();
+            const mockedGlobal = mockGlobalThis();
+
+            await controller.start();
+            await settle(mockedGlobal);
+
+            if ((await controller.zigbee.getCoordinatorVersion()).type !== "Dummy") {
+                throw new Error("Invalid");
+            }
+
+            await controller.stop();
+            unmockGlobalThis();
+        },
+        BENCH_OPTIONS,
+    );
+
+    bench(
+        "[HA] start & stop controller",
+        async () => {
+            initDevices();
+            initGroups();
+            await initSettings([[["homeassistant", "enabled"], true]]);
+            await initController();
+            const mockedGlobal = mockGlobalThis();
+
+            await controller.start();
+            controller.mqtt.onMessage("homeassistant/status", Buffer.from("online", "utf8"));
+            await settle(mockedGlobal);
+
+            if ((await controller.zigbee.getCoordinatorVersion()).type !== "Dummy") {
+                throw new Error("Invalid");
+            }
+
+            await controller.stop();
+            unmockGlobalThis();
+        },
+        BENCH_OPTIONS,
+    );
+
+    describe("defaults runtime", () => {
+        const setup: NonNullable<Parameters<typeof bench>[2]>["setup"] = async (task, mode) => {
+            BENCH_OPTIONS.setup!(task, mode);
+            initDevices();
+            initGroups();
+            await initSettings();
+            await initController();
+            const mockedGlobal = mockGlobalThis();
+
+            await controller.start();
+            await settle(mockedGlobal);
+        };
+        const teardown = async () => {
+            await controller.stop();
+            unmockGlobalThis();
+        };
+
+        bench(
+            "[defaults] receive device message",
+            async () => {
+                const mockedGlobal = mockGlobalThis();
+
+                controller.eventBus.emitDeviceMessage({
+                    type: "attributeReport",
+                    device: controller.zigbee.resolveEntity("0xf1f1f1f1f1f1f1f1"),
+                    endpoint: ZSpec.HA_ENDPOINT,
+                    linkquality: 200,
+                    groupID: 0,
+                    cluster: "genOnOff",
+                    data: {onOff: 1},
+                    meta: {},
+                });
+                await settle(mockedGlobal);
+            },
+            {...BENCH_OPTIONS, setup, teardown},
+        );
+
+        bench(
+            "[defaults] receive MQTT message",
+            async () => {
+                const mockedGlobal = mockGlobalThis();
+
+                controller.mqtt.onMessage("zigbee2mqtt/0xf1f1f1f1f1f1f1f1/set", Buffer.from(`{"state": "OFF"}`, "utf8"));
+                await settle(mockedGlobal);
+            },
+            {...BENCH_OPTIONS, setup, teardown},
+        );
+
+        bench(
+            "[defaults] add group member",
+            async () => {
+                const mockedGlobal = mockGlobalThis();
+
+                controller.eventBus.emitMQTTMessage({
+                    topic: "zigbee2mqtt/bridge/request/group/members/add",
+                    message: stringify({
+                        device: "0xf1f1f1f1f1f1f1f1",
+                        group: `${ZH_GROUPS[0].groupID}`,
+                        endpoint: ZSpec.HA_ENDPOINT,
+                    }),
+                });
+
+                await settle(mockedGlobal);
+
+                if (ZH_GROUPS[0].members.length !== 1) {
+                    throw new Error("Invalid state");
+                }
+            },
+            {...BENCH_OPTIONS, setup, teardown},
+        );
+    });
+
+    describe("defaults/stress runtime", () => {
+        const setup: NonNullable<Parameters<typeof bench>[2]>["setup"] = async (task, mode) => {
+            BENCH_OPTIONS.setup!(task, mode);
+            initDevices();
+            initGroups();
+            addManyDevices();
+            await initSettings();
+            await initController();
+            const mockedGlobal = mockGlobalThis();
+
+            await controller.start();
+            await settle(mockedGlobal);
+        };
+
+        const teardown = async () => {
+            await controller.stop();
+            unmockGlobalThis();
+        };
+
+        // this is mostly just to confirm the number of devices does not influence the processing (much)
+        bench(
+            "[defaults/stress] receive device message",
+            async () => {
+                const mockedGlobal = mockGlobalThis();
+
+                controller.eventBus.emitDeviceMessage({
+                    type: "attributeReport",
+                    device: controller.zigbee.resolveEntity(getMidDeviceIeee()),
+                    endpoint: ZSpec.HA_ENDPOINT,
+                    linkquality: 200,
+                    groupID: 0,
+                    cluster: "genOnOff",
+                    data: {onOff: 1},
+                    meta: {},
+                });
+                await settle(mockedGlobal);
+            },
+            {...BENCH_OPTIONS, setup, teardown},
+        );
+    });
+
+    describe("HA runtime", () => {
+        const setup: NonNullable<Parameters<typeof bench>[2]>["setup"] = async (task, mode) => {
+            BENCH_OPTIONS.setup!(task, mode);
+            initDevices();
+            initGroups();
+            await initSettings([[["homeassistant", "enabled"], true]]);
+            await initController();
+            const mockedGlobal = mockGlobalThis();
+
+            await controller.start();
+            controller.mqtt.onMessage("homeassistant/status", Buffer.from("online", "utf8"));
+            await settle(mockedGlobal);
+        };
+
+        const teardown = async () => {
+            await controller.stop();
+            unmockGlobalThis();
+        };
+
+        bench(
+            "[HA] receive device message",
+            async () => {
+                const mockedGlobal = mockGlobalThis();
+
+                controller.eventBus.emitDeviceMessage({
+                    type: "attributeReport",
+                    device: controller.zigbee.resolveEntity("0xf1f1f1f1f1f1f1f1"),
+                    endpoint: ZSpec.HA_ENDPOINT,
+                    linkquality: 200,
+                    groupID: 0,
+                    cluster: "genOnOff",
+                    data: {onOff: 1},
+                    meta: {},
+                });
+                await settle(mockedGlobal);
+            },
+            {...BENCH_OPTIONS, setup, teardown},
+        );
+
+        bench(
+            "[HA] receive MQTT message",
+            async () => {
+                const mockedGlobal = mockGlobalThis();
+
+                controller.mqtt.onMessage("zigbee2mqtt/0xf1f1f1f1f1f1f1f1/set", Buffer.from(`{"state": "OFF"}`, "utf8"));
+                await settle(mockedGlobal);
+            },
+            {...BENCH_OPTIONS, setup, teardown},
+        );
+
+        bench(
+            "[HA] receive MQTT discovery message",
+            async () => {
+                const mockedGlobal = mockGlobalThis();
+
+                controller.mqtt.onMessage(
+                    "homeassistant/sensor/0xe2e2e2e2e2e2e2e2/update/config",
+                    Buffer.from(stringify({availability: [{topic: "zigbee2mqtt/bridge/state", value_template: "{{ value_json.state }}"}]}), "utf8"),
+                );
+                await settle(mockedGlobal);
+            },
+            {...BENCH_OPTIONS, setup, teardown},
+        );
+    });
+});