matterbridge-zigbee2mqtt 2.6.0 → 2.7.0-dev-20250711-6299fe0

package/CHANGELOG.md

@@ -21,6 +21,31 @@ New device types:
 
 If your controller has issues detecting the new device type, blacklist these devices, restart, wait 5 minutes that the controller removes them, remove the blacklist and restart again. This will create a new endpoint on the controller and the controllers will likely remove and recreate all the devices so make a backup of configurations (i.e. room assignements) and automations on the controller.
 
+## [2.7.0] - 2025-07-10
+
+### Added
+
+- [entity]: Added the ability to cache commands on a single light device or group. They will be executed in once. This helps to execute global controller scenes in large setups.
+- [composed]: Added the ability to send commands on subenpoint also for ColorControl cluster.
+
+### Changed
+
+- [package]: Updated dependencies.
+- [package]: Updated package to Automator v. 2.0.2.
+- [DevContainer]: Added support for the [**Matterbridge Plugin Dev Container**](https://github.com/Luligu/matterbridge/blob/dev/README-DEV.md#matterbridge-plugin-dev-container) with optimized named volumes for `matterbridge` and `node_modules`.
+- [GitHub]: Added GitHub issue templates for bug reports and feature requests.
+- [ESLint]: Refactored the flat config.
+- [ESLint]: Added the plugins `eslint-plugin-promise`, `eslint-plugin-jsdoc`, and `@vitest/eslint-plugin`.
+- [Jest]: Refactored the flat config.
+- [Vitest]: Added Vitest for TypeScript project testing. It will replace Jest, which does not work correctly with ESM module mocks.
+- [JSDoc]: Added missing JSDoc comments, including `@param` and `@returns` tags.
+- [CodeQL]: Added CodeQL badge in the readme.
+- [Codecov]: Added Codecov badge in the readme.
+
+<a href="https://www.buymeacoffee.com/luligugithub">
+  <img src="bmc-button.svg" alt="Buy me a coffee" width="80">
+</a>
+
 ## [2.6.0] - 2025-06-07
 
 ### Added

package/README.md

@@ -5,6 +5,8 @@
 [![Docker Version](https://img.shields.io/docker/v/luligu/matterbridge?label=docker%20version&sort=semver)](https://hub.docker.com/r/luligu/matterbridge)
 [![Docker Pulls](https://img.shields.io/docker/pulls/luligu/matterbridge.svg)](https://hub.docker.com/r/luligu/matterbridge)
 ![Node.js CI](https://github.com/Luligu/matterbridge-zigbee2mqtt/actions/workflows/build-matterbridge-plugin.yml/badge.svg)
+![CodeQL](https://github.com/Luligu/matterbridge-zigbee2mqtt/actions/workflows/codeql.yml/badge.svg)
+[![codecov](https://codecov.io/gh/Luligu/matterbridge-zigbee2mqtt/branch/main/graph/badge.svg)](https://codecov.io/gh/Luligu/matterbridge-zigbee2mqtt)
 
 [![powered by](https://img.shields.io/badge/powered%20by-matterbridge-blue)](https://www.npmjs.com/package/matterbridge)
 [![powered by](https://img.shields.io/badge/powered%20by-matter--history-blue)](https://www.npmjs.com/package/matter-history)
@@ -13,7 +15,7 @@
 
 ---
 
-Matterbridge zigbee2mqtt is a matterbridge production-level plugin that expose all zigbee2mqtt devices and groups to Matter.
+Matterbridge zigbee2mqtt is a matterbridge production-level plugin that expose all zigbee2mqtt devices and groups to Matter. Scenes are supported too.
 
 No hub or dedicated hardware needed.
 
@@ -37,7 +39,7 @@ on Windows:
 npm install -g matterbridge --omit=dev
 ```
 
-on Linux (you need the necessary permissions):
+on Linux and macOS (you need the necessary permissions):
 
 ```
 sudo npm install -g matterbridge --omit=dev
@@ -67,7 +69,7 @@ npm install -g matterbridge-zigbee2mqtt --omit=dev
 matterbridge -add matterbridge-zigbee2mqtt
 ```
 
-On linux:
+On linux and macOS:
 
 ```
 cd ~/Matterbridge
@@ -92,10 +94,10 @@ cd matterbridge-zigbee2mqtt
 npm ci
 npm run dev:link
 npm run build
-matterbridge -add .\
+matterbridge -add .
 ```
 
-On linux:
+On linux and macOS:
 
 ```
 cd ~/Matterbridge
@@ -104,7 +106,7 @@ cd matterbridge-zigbee2mqtt
 npm ci
 npm run dev:link
 npm run build
-matterbridge -add ./
+matterbridge -add .
 ```
 
 Then start Matterbridge

package/dist/entity.js

@@ -1,11 +1,11 @@
+import EventEmitter from 'node:events';
 import { airQualitySensor, colorTemperatureSwitch, dimmableSwitch, onOffSwitch, powerSource, bridgedNode, electricalSensor, onOffLight, dimmableLight, colorTemperatureLight, onOffOutlet, coverDevice, thermostatDevice, MatterbridgeEndpoint, dimmableOutlet, doorLockDevice, occupancySensor, lightSensor, contactSensor, temperatureSensor, humiditySensor, pressureSensor, genericSwitch, waterLeakDetector, rainSensor, smokeCoAlarm, extendedColorLight, } from 'matterbridge';
 import { AnsiLogger, gn, dn, ign, idn, rs, db, debugStringify, hk, zb, or, nf, CYAN, er, YELLOW } from 'matterbridge/logger';
-import { deepCopy, deepEqual, isValidNumber, kelvinToRGB, miredToKelvin } from 'matterbridge/utils';
+import { deepCopy, deepEqual, isValidNumber, isValidObject, kelvinToRGB, miredToKelvin } from 'matterbridge/utils';
 import * as color from 'matterbridge/utils';
 import { SwitchesTag, NumberTag } from 'matterbridge/matter';
 import { getClusterNameById, ClusterId } from 'matterbridge/matter/types';
 import { ElectricalEnergyMeasurement, ElectricalPowerMeasurement, OnOffCluster, LevelControlCluster, WindowCoveringCluster, DoorLockCluster, BridgedDeviceBasicInformation, OnOff, LevelControl, ColorControl, ColorControlCluster, TemperatureMeasurement, BooleanState, RelativeHumidityMeasurement, PressureMeasurement, OccupancySensing, IlluminanceMeasurement, PowerSource, WindowCovering, DoorLock, ThermostatCluster, Thermostat, AirQuality, TotalVolatileOrganicCompoundsConcentrationMeasurement, CarbonDioxideConcentrationMeasurement, CarbonMonoxideConcentrationMeasurement, FormaldehydeConcentrationMeasurement, Pm1ConcentrationMeasurement, Pm25ConcentrationMeasurement, Pm10ConcentrationMeasurement, SmokeCoAlarm, } from 'matterbridge/matter/clusters';
-import EventEmitter from 'node:events';
 export class ZigbeeEntity extends EventEmitter {
     log;
     serial = '';
@@ -26,7 +26,7 @@ export class ZigbeeEntity extends EventEmitter {
     transition = false;
     propertyMap = new Map();
     mutableDevice = new Map();
-    colorTimeout = undefined;
+    lightTimeout = undefined;
     thermostatTimeout = undefined;
     thermostatSystemModeLookup = ['off', 'auto', '', 'cool', 'heat', '', '', 'fan_only'];
     composedType = '';
@@ -50,11 +50,17 @@ export class ZigbeeEntity extends EventEmitter {
             this.en = gn;
             this.ien = ign;
         }
-        this.log = new AnsiLogger({ logName: this.entityName, logTimestampFormat: 4, logLevel: platform.debugEnabled ? "debug" : platform.log.logLevel });
+        this.log = new AnsiLogger({
+            logName: this.entityName,
+            logTimestampFormat: 4,
+            logLevel: platform.debugEnabled ? "debug" : platform.log.logLevel,
+        });
         this.log.debug(`Created MatterEntity: ${this.entityName}`);
         this.platform.z2m.on('MESSAGE-' + this.entityName, (payload) => {
             const now = Date.now();
-            if (now - this.lastSeen < 1000 * 60 && deepEqual(this.lastPayload, payload, ['linkquality', 'last_seen', ...this.ignoreFeatures]) && !Object.prototype.hasOwnProperty.call(this.lastPayload, 'action')) {
+            if (now - this.lastSeen < 1000 * 60 &&
+                deepEqual(this.lastPayload, payload, ['linkquality', 'last_seen', ...this.ignoreFeatures]) &&
+                !Object.prototype.hasOwnProperty.call(this.lastPayload, 'action')) {
                 this.log.debug(`Skipping not changed ${platform.z2mDevicesRegistered ? 'MQTT message' : 'State update'} for accessory ${this.entityName}`);
                 return;
             }
@@ -200,9 +206,9 @@ export class ZigbeeEntity extends EventEmitter {
     }
     destroy() {
         this.removeAllListeners();
-        if (this.colorTimeout)
-            clearTimeout(this.colorTimeout);
-        this.colorTimeout = undefined;
+        if (this.lightTimeout)
+            clearTimeout(this.lightTimeout);
+        this.lightTimeout = undefined;
         if (this.thermostatTimeout)
             clearTimeout(this.thermostatTimeout);
         this.thermostatTimeout = undefined;
@@ -466,7 +472,7 @@ export class ZigbeeGroup extends ZigbeeEntity {
                 platform.setSelectDeviceEntity(`group-${group.id}`, 'scenes', 'Scenes', 'component');
                 platform.registerVirtualDevice(`${platform.config.scenesPrefix ? group.friendly_name + ' ' : ''}${scene.name}`, async () => {
                     zigbeeGroup.log.info(`Triggered scene "${scene.name}" id ${scene.id} from group ${group.friendly_name}`);
-                    zigbeeGroup.publishCommand('scene_recall', group.friendly_name, { 'scene_recall': scene.id });
+                    zigbeeGroup.publishCommand('scene_recall', group.friendly_name, { scene_recall: scene.id });
                 });
             });
         }
@@ -477,6 +483,25 @@ export class ZigbeeGroup extends ZigbeeEntity {
             return zigbeeGroup;
         zigbeeGroup.mutableDevice.clear();
         zigbeeGroup.logPropertyMap();
+        let lastRequestedHue = -1;
+        let lastRequestedSaturation = -1;
+        let nextPayload = {};
+        function cachePublishLight(command = 'cachedPublishLight') {
+            clearTimeout(zigbeeGroup.lightTimeout);
+            zigbeeGroup.lightTimeout = setTimeout(() => {
+                clearTimeout(zigbeeGroup.lightTimeout);
+                zigbeeGroup.lightTimeout = undefined;
+                if (lastRequestedHue >= 0 && lastRequestedSaturation >= 0) {
+                    const rgb = color.hslColorToRgbColor((lastRequestedHue / 254) * 360, (lastRequestedSaturation / 254) * 100, 50);
+                    nextPayload['color'] = { r: rgb.r, g: rgb.g, b: rgb.b };
+                }
+                if (isValidObject(nextPayload, 1))
+                    zigbeeGroup.publishCommand(command, group.friendly_name, nextPayload);
+                nextPayload = {};
+                lastRequestedHue = -1;
+                lastRequestedSaturation = -1;
+            }, 100);
+        }
         if (isSwitch || isLight) {
             if (isSwitch && !isLight)
                 await zigbeeGroup.bridgedDevice.addFixedLabel('type', 'switch');
@@ -487,71 +512,87 @@ export class ZigbeeGroup extends ZigbeeEntity {
             });
             zigbeeGroup.bridgedDevice.addCommandHandler('on', async () => {
                 zigbeeGroup.log.debug(`Command on called for ${zigbeeGroup.ien}${group.friendly_name}${rs}${db}`);
-                zigbeeGroup.publishCommand('on', group.friendly_name, { state: 'ON' });
+                nextPayload['state'] = 'ON';
+                cachePublishLight();
             });
             zigbeeGroup.bridgedDevice.addCommandHandler('off', async () => {
                 zigbeeGroup.log.debug(`Command off called for ${zigbeeGroup.ien}${group.friendly_name}${rs}${db}`);
-                zigbeeGroup.publishCommand('off', group.friendly_name, { state: 'OFF' });
+                nextPayload['state'] = 'OFF';
+                cachePublishLight();
             });
             zigbeeGroup.bridgedDevice.addCommandHandler('toggle', async () => {
                 zigbeeGroup.log.debug(`Command toggle called for ${zigbeeGroup.ien}${group.friendly_name}${rs}${db}`);
-                zigbeeGroup.publishCommand('toggle', group.friendly_name, { state: 'TOGGLE' });
+                nextPayload['state'] = 'TOGGLE';
+                cachePublishLight();
             });
         }
         if (isLight) {
             if (useBrightness) {
-                zigbeeGroup.bridgedDevice.addCommandHandler('moveToLevel', async ({ request: { level } }) => {
-                    zigbeeGroup.log.debug(`Command moveToLevel called for ${zigbeeGroup.ien}${group.friendly_name}${rs}${db} request: ${level}`);
-                    zigbeeGroup.publishCommand('moveToLevel', group.friendly_name, { brightness: level });
+                zigbeeGroup.bridgedDevice.addCommandHandler('moveToLevel', async (data) => {
+                    zigbeeGroup.log.debug(`Command moveToLevel called for ${zigbeeGroup.ien}${group.friendly_name}${rs}${db} request: ${data.request.level}`);
+                    nextPayload['state'] = 'ON';
+                    nextPayload['brightness'] = data.request.level;
+                    if (zigbeeGroup.transition && data.request.transitionTime && data.request.transitionTime / 10 >= 1)
+                        nextPayload['transition'] = Math.round(data.request.transitionTime / 10);
+                    cachePublishLight();
                 });
-                zigbeeGroup.bridgedDevice.addCommandHandler('moveToLevelWithOnOff', async ({ request: { level } }) => {
-                    zigbeeGroup.log.debug(`Command moveToLevelWithOnOff called for ${zigbeeGroup.ien}${group.friendly_name}${rs}${db} request: ${level}`);
-                    zigbeeGroup.publishCommand('moveToLevelWithOnOff', group.friendly_name, { brightness: level });
+                zigbeeGroup.bridgedDevice.addCommandHandler('moveToLevelWithOnOff', async (data) => {
+                    zigbeeGroup.log.debug(`Command moveToLevelWithOnOff called for ${zigbeeGroup.ien}${group.friendly_name}${rs}${db} request: ${data.request.level}`);
+                    nextPayload['state'] = 'ON';
+                    nextPayload['brightness'] = data.request.level;
+                    if (zigbeeGroup.transition && data.request.transitionTime && data.request.transitionTime / 10 >= 1)
+                        nextPayload['transition'] = Math.round(data.request.transitionTime / 10);
+                    cachePublishLight();
                 });
             }
             if (useColorTemperature) {
-                zigbeeGroup.bridgedDevice.addCommandHandler('moveToColorTemperature', async ({ request: request }) => {
-                    zigbeeGroup.log.debug(`Command moveToColorTemperature called for ${zigbeeGroup.ien}${group.friendly_name}${rs}${db} request: ${request.colorTemperatureMireds}`);
+                zigbeeGroup.bridgedDevice.addCommandHandler('moveToColorTemperature', async (data) => {
+                    zigbeeGroup.log.debug(`Command moveToColorTemperature called for ${zigbeeGroup.ien}${group.friendly_name}${rs}${db} request: ${data.request.colorTemperatureMireds}`);
                     await zigbeeGroup.bridgedDevice?.setAttribute(ColorControl.Cluster.id, 'colorMode', ColorControl.ColorMode.ColorTemperatureMireds);
-                    zigbeeGroup.publishCommand('moveToColorTemperature', group.friendly_name, { color_temp: request.colorTemperatureMireds });
+                    nextPayload['state'] = 'ON';
+                    nextPayload['color_temp'] = data.request.colorTemperatureMireds;
+                    if (zigbeeGroup.transition && data.request.transitionTime && data.request.transitionTime / 10 >= 1)
+                        nextPayload['transition'] = Math.round(data.request.transitionTime / 10);
+                    cachePublishLight();
                 });
             }
             if (useColor) {
-                let lastRequestedHue = 0;
-                let lastRequestedSaturation = 0;
-                zigbeeGroup.bridgedDevice.addCommandHandler('moveToHue', async ({ request: request }) => {
-                    zigbeeGroup.log.debug(`Command moveToHue called for ${zigbeeGroup.ien}${group.friendly_name}${rs}${db} request: ${request.hue}`);
+                zigbeeGroup.bridgedDevice.addCommandHandler('moveToHue', async (data) => {
+                    zigbeeGroup.log.debug(`Command moveToHue called for ${zigbeeGroup.ien}${group.friendly_name}${rs}${db} request: ${data.request.hue}`);
                     await zigbeeGroup.bridgedDevice?.setAttribute(ColorControl.Cluster.id, 'colorMode', ColorControl.ColorMode.CurrentHueAndCurrentSaturation);
-                    lastRequestedHue = request.hue;
-                    zigbeeGroup.colorTimeout = setTimeout(() => {
-                        clearTimeout(zigbeeGroup.colorTimeout);
-                        const rgb = color.hslColorToRgbColor((request.hue / 254) * 360, (lastRequestedSaturation / 254) * 100, 50);
-                        zigbeeGroup.publishCommand('moveToHue', group.friendly_name, { color: { r: rgb.r, g: rgb.g, b: rgb.b } });
-                    }, 500);
+                    nextPayload['state'] = 'ON';
+                    lastRequestedHue = data.request.hue;
+                    if (zigbeeGroup.transition && data.request.transitionTime && data.request.transitionTime / 10 >= 1)
+                        nextPayload['transition'] = Math.round(data.request.transitionTime / 10);
+                    cachePublishLight();
                 });
-                zigbeeGroup.bridgedDevice.addCommandHandler('moveToSaturation', async ({ request: request }) => {
-                    zigbeeGroup.log.debug(`Command moveToSaturation called for ${zigbeeGroup.ien}${group.friendly_name}${rs}${db} request: ${request.saturation}`);
+                zigbeeGroup.bridgedDevice.addCommandHandler('moveToSaturation', async (data) => {
+                    zigbeeGroup.log.debug(`Command moveToSaturation called for ${zigbeeGroup.ien}${group.friendly_name}${rs}${db} request: ${data.request.saturation}`);
                     await zigbeeGroup.bridgedDevice?.setAttribute(ColorControl.Cluster.id, 'colorMode', ColorControl.ColorMode.CurrentHueAndCurrentSaturation);
-                    lastRequestedSaturation = request.saturation;
-                    zigbeeGroup.colorTimeout = setTimeout(() => {
-                        clearTimeout(zigbeeGroup.colorTimeout);
-                        const rgb = color.hslColorToRgbColor((lastRequestedHue / 254) * 360, (request.saturation / 254) * 100, 50);
-                        zigbeeGroup.publishCommand('moveToSaturation', group.friendly_name, { color: { r: rgb.r, g: rgb.g, b: rgb.b } });
-                    }, 500);
+                    nextPayload['state'] = 'ON';
+                    lastRequestedSaturation = data.request.saturation;
+                    if (zigbeeGroup.transition && data.request.transitionTime && data.request.transitionTime / 10 >= 1)
+                        nextPayload['transition'] = Math.round(data.request.transitionTime / 10);
+                    cachePublishLight();
                 });
-                zigbeeGroup.bridgedDevice.addCommandHandler('moveToHueAndSaturation', async ({ request: request }) => {
-                    zigbeeGroup.log.debug(`Command moveToHueAndSaturation called for ${zigbeeGroup.ien}${group.friendly_name}${rs}${db} request: ${request.hue}-${request.saturation}`);
+                zigbeeGroup.bridgedDevice.addCommandHandler('moveToHueAndSaturation', async (data) => {
+                    zigbeeGroup.log.debug(`Command moveToHueAndSaturation called for ${zigbeeGroup.ien}${group.friendly_name}${rs}${db} request: ${data.request.hue}-${data.request.saturation}`);
                     await zigbeeGroup.bridgedDevice?.setAttribute(ColorControl.Cluster.id, 'colorMode', ColorControl.ColorMode.CurrentHueAndCurrentSaturation);
-                    const rgb = color.hslColorToRgbColor((request.hue / 254) * 360, (request.saturation / 254) * 100, 50);
-                    zigbeeGroup.publishCommand('moveToHueAndSaturation', group.friendly_name, { color: { r: rgb.r, g: rgb.g, b: rgb.b } });
+                    nextPayload['state'] = 'ON';
+                    const rgb = color.hslColorToRgbColor((data.request.hue / 254) * 360, (data.request.saturation / 254) * 100, 50);
+                    nextPayload['color'] = { r: rgb.r, g: rgb.g, b: rgb.b };
+                    if (zigbeeGroup.transition && data.request.transitionTime && data.request.transitionTime / 10 >= 1)
+                        nextPayload['transition'] = Math.round(data.request.transitionTime / 10);
+                    cachePublishLight();
                 });
-                zigbeeGroup.bridgedDevice.addCommandHandler('moveToColor', async ({ request }) => {
-                    zigbeeGroup.log.debug(`Command moveToColor called for ${zigbeeGroup.ien}${group.friendly_name}${rs}${db} request: X: ${request.colorX} Y: ${request.colorY}`);
+                zigbeeGroup.bridgedDevice.addCommandHandler('moveToColor', async (data) => {
+                    zigbeeGroup.log.debug(`Command moveToColor called for ${zigbeeGroup.ien}${group.friendly_name}${rs}${db} request: X: ${data.request.colorX} Y: ${data.request.colorY}`);
                     await zigbeeGroup.bridgedDevice?.setAttribute(ColorControlCluster.id, 'colorMode', ColorControl.ColorMode.CurrentXAndCurrentY, zigbeeGroup.log);
-                    const payload = { color: { x: request.colorX / 65536, y: request.colorY / 65536 } };
-                    if (zigbeeGroup.transition && request.transitionTime && request.transitionTime / 10 >= 1)
-                        payload['transition'] = Math.round(request.transitionTime / 10);
-                    zigbeeGroup.publishCommand('moveToColor', group.friendly_name, payload);
+                    nextPayload['state'] = 'ON';
+                    nextPayload['color'] = { x: data.request.colorX / 65536, y: data.request.colorY / 65536 };
+                    if (zigbeeGroup.transition && data.request.transitionTime && data.request.transitionTime / 10 >= 1)
+                        nextPayload['transition'] = Math.round(data.request.transitionTime / 10);
+                    cachePublishLight();
                 });
             }
         }
@@ -693,7 +734,9 @@ export class ZigbeeDevice extends ZigbeeEntity {
         if (zigbeeDevice.platform.postfix !== '') {
             zigbeeDevice.serial = `${zigbeeDevice.serial}-${zigbeeDevice.platform.postfix}`.slice(0, 32);
         }
-        if (device.friendly_name === 'Coordinator' || (device.model_id === 'ti.router' && device.manufacturer === 'TexasInstruments') || (device.model_id.startsWith('SLZB-') && device.manufacturer === 'SMLIGHT')) {
+        if (device.friendly_name === 'Coordinator' ||
+            (device.model_id === 'ti.router' && device.manufacturer === 'TexasInstruments') ||
+            (device.model_id.startsWith('SLZB-') && device.manufacturer === 'SMLIGHT')) {
             zigbeeDevice.isRouter = true;
             platform.setSelectDevice(device.ieee_address, device.friendly_name, 'wifi');
             zigbeeDevice.bridgedDevice = new MatterbridgeEndpoint([doorLockDevice, bridgedNode, powerSource], { uniqueStorageKey: device.friendly_name }, zigbeeDevice.log.logLevel === "debug");
@@ -724,7 +767,7 @@ export class ZigbeeDevice extends ZigbeeEntity {
                     platform.setSelectDeviceEntity(device.ieee_address, 'scenes', 'Scenes', 'component');
                     platform.registerVirtualDevice(`${platform.config.scenesPrefix ? device.friendly_name + ' ' : ''}${scene.name}`, async () => {
                         zigbeeDevice.log.info(`Triggered scene "${scene.name}" id ${scene.id} from device ${device.friendly_name}`);
-                        zigbeeDevice.publishCommand('scene_recall', device.friendly_name, { 'scene_recall': scene.id });
+                        zigbeeDevice.publishCommand('scene_recall', device.friendly_name, { scene_recall: scene.id });
                     });
                 });
             });
@@ -902,7 +945,14 @@ export class ZigbeeDevice extends ZigbeeEntity {
                     }
                     const tagList = [];
                     tagList.push({ mfgCode: null, namespaceId: SwitchesTag.Custom.namespaceId, tag: SwitchesTag.Custom.tag, label: 'switch_' + count });
-                    zigbeeDevice.mutableDevice.set('switch_' + count, { tagList, deviceTypes: [genericSwitch], clusterServersIds: [...genericSwitch.requiredServerClusters], clusterServersOptions: [], clusterClientsIds: [], clusterClientsOptions: [] });
+                    zigbeeDevice.mutableDevice.set('switch_' + count, {
+                        tagList,
+                        deviceTypes: [genericSwitch],
+                        clusterServersIds: [...genericSwitch.requiredServerClusters],
+                        clusterServersOptions: [],
+                        clusterClientsIds: [],
+                        clusterClientsOptions: [],
+                    });
                 }
                 else {
                     for (let i = 0; i < zigbeeDevice.actions.length; i += 3) {
@@ -914,7 +964,14 @@ export class ZigbeeDevice extends ZigbeeEntity {
                         }
                         const tagList = [];
                         tagList.push({ mfgCode: null, namespaceId: SwitchesTag.Custom.namespaceId, tag: SwitchesTag.Custom.tag, label: 'switch_' + count });
-                        zigbeeDevice.mutableDevice.set('switch_' + count, { tagList, deviceTypes: [genericSwitch], clusterServersIds: [...genericSwitch.requiredServerClusters], clusterServersOptions: [], clusterClientsIds: [], clusterClientsOptions: [] });
+                        zigbeeDevice.mutableDevice.set('switch_' + count, {
+                            tagList,
+                            deviceTypes: [genericSwitch],
+                            clusterServersIds: [...genericSwitch.requiredServerClusters],
+                            clusterServersOptions: [],
+                            clusterClientsIds: [],
+                            clusterClientsOptions: [],
+                        });
                         count++;
                     }
                 }
@@ -928,7 +985,14 @@ export class ZigbeeDevice extends ZigbeeEntity {
             zigbeeDevice.propertyMap.set('battery_voltage', { name: 'battery_voltage', type: '', endpoint: '' });
         }
         if (!zigbeeDevice.mutableDevice.has(''))
-            zigbeeDevice.mutableDevice.set('', { tagList: [], deviceTypes: [bridgedNode, powerSource], clusterServersIds: [], clusterServersOptions: [], clusterClientsIds: [], clusterClientsOptions: [] });
+            zigbeeDevice.mutableDevice.set('', {
+                tagList: [],
+                deviceTypes: [bridgedNode, powerSource],
+                clusterServersIds: [],
+                clusterServersOptions: [],
+                clusterClientsIds: [],
+                clusterClientsOptions: [],
+            });
         const mainEndpoint = zigbeeDevice.mutableDevice.get('');
         if (!mainEndpoint)
             return zigbeeDevice;
@@ -987,7 +1051,8 @@ export class ZigbeeDevice extends ZigbeeEntity {
             zigbeeDevice.log.debug(`Device ${zigbeeDevice.ien}${zigbeeDevice.device?.friendly_name}${rs}${db} endpoint: ${ign}${endpoint === '' ? 'main' : endpoint}${rs}${db} => ` +
                 `${nf}tagList: ${debugStringify(device.tagList)} deviceTypes: ${debugStringify(device.deviceTypes)} clusterServersIds: ${debugStringify(device.clusterServersIds)}`);
         }
-        if ((mainEndpoint.deviceTypes.find((dt) => dt.code === waterLeakDetector.code) || mainEndpoint.deviceTypes.find((dt) => dt.code === rainSensor.code)) && mainEndpoint.clusterServersIds.includes(BooleanState.Cluster.id)) {
+        if ((mainEndpoint.deviceTypes.find((dt) => dt.code === waterLeakDetector.code) || mainEndpoint.deviceTypes.find((dt) => dt.code === rainSensor.code)) &&
+            mainEndpoint.clusterServersIds.includes(BooleanState.Cluster.id)) {
             zigbeeDevice.log.debug(`Configuring device ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} BooleanStateCluster cluster with`);
             zigbeeDevice.bridgedDevice.createDefaultBooleanStateClusterServer(false);
             mainEndpoint.clusterServersIds.splice(mainEndpoint.clusterServersIds.indexOf(BooleanState.Cluster.id), 1);
@@ -1054,146 +1119,226 @@ export class ZigbeeDevice extends ZigbeeEntity {
             return zigbeeDevice;
         zigbeeDevice.mutableDevice.clear();
         zigbeeDevice.logPropertyMap();
+        let lastRequestedHue = -1;
+        let lastRequestedSaturation = -1;
+        let nextPayload = {};
+        function cachePublishLight(command = 'cachedPublishLight') {
+            clearTimeout(zigbeeDevice.lightTimeout);
+            zigbeeDevice.lightTimeout = setTimeout(() => {
+                clearTimeout(zigbeeDevice.lightTimeout);
+                zigbeeDevice.lightTimeout = undefined;
+                if (lastRequestedHue >= 0 && lastRequestedSaturation >= 0) {
+                    const rgb = color.hslColorToRgbColor((lastRequestedHue / 254) * 360, (lastRequestedSaturation / 254) * 100, 50);
+                    nextPayload['color'] = { r: rgb.r, g: rgb.g, b: rgb.b };
+                }
+                if (isValidObject(nextPayload, 1))
+                    zigbeeDevice.publishCommand(command, device.friendly_name, nextPayload);
+                nextPayload = {};
+                lastRequestedHue = -1;
+                lastRequestedSaturation = -1;
+            }, 100);
+        }
         zigbeeDevice.bridgedDevice.addCommandHandler('identify', async (data) => {
-            zigbeeDevice.log.debug(`Command identify called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeNumber} request identifyTime:${data.request.identifyTime} `);
+            zigbeeDevice.log.debug(`Command identify called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeId}:${data.endpoint?.maybeNumber} request identifyTime:${data.request.identifyTime} `);
         });
         if (zigbeeDevice.bridgedDevice.hasClusterServer(OnOffCluster.id) || zigbeeDevice.hasEndpoints) {
             for (const child of zigbeeDevice.bridgedDevice.getChildEndpoints()) {
                 if (child.hasClusterServer(OnOffCluster)) {
                     child.addCommandHandler('on', async (data) => {
-                        zigbeeDevice.log.debug(`Command on called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeNumber}`);
-                        const payload = {};
-                        payload['state_' + data.endpoint.uniqueStorageKey] = 'ON';
-                        zigbeeDevice.publishCommand('on', device.friendly_name, payload);
+                        zigbeeDevice.log.debug(`Command on called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeId}:${data.endpoint?.maybeNumber}`);
+                        nextPayload['state_' + data.endpoint.uniqueStorageKey] = 'ON';
+                        cachePublishLight();
                     });
                     child.addCommandHandler('off', async (data) => {
-                        zigbeeDevice.log.debug(`Command off called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeNumber}`);
-                        const payload = {};
-                        payload['state_' + data.endpoint.uniqueStorageKey] = 'OFF';
-                        zigbeeDevice.publishCommand('off', device.friendly_name, payload);
+                        zigbeeDevice.log.debug(`Command off called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeId}:${data.endpoint?.maybeNumber}`);
+                        nextPayload['state_' + data.endpoint.uniqueStorageKey] = 'OFF';
+                        cachePublishLight();
                     });
                     child.addCommandHandler('toggle', async (data) => {
-                        zigbeeDevice.log.debug(`Command toggle called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeNumber}`);
-                        const payload = {};
-                        payload['state_' + data.endpoint.uniqueStorageKey] = 'TOGGLE';
-                        zigbeeDevice.publishCommand('toggle', device.friendly_name, payload);
+                        zigbeeDevice.log.debug(`Command toggle called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeId}:${data.endpoint?.maybeNumber}`);
+                        nextPayload['state_' + data.endpoint.uniqueStorageKey] = 'TOGGLE';
+                        cachePublishLight();
                     });
                 }
             }
             zigbeeDevice.bridgedDevice.addCommandHandler('on', async (data) => {
-                zigbeeDevice.log.debug(`Command on called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeNumber}`);
-                zigbeeDevice.publishCommand('on', device.friendly_name, { state: 'ON' });
+                zigbeeDevice.log.debug(`Command on called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeId}:${data.endpoint?.maybeNumber}`);
+                nextPayload['state'] = 'ON';
+                cachePublishLight();
             });
             zigbeeDevice.bridgedDevice.addCommandHandler('off', async (data) => {
-                zigbeeDevice.log.debug(`Command off called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeNumber}`);
-                zigbeeDevice.publishCommand('off', device.friendly_name, { state: 'OFF' });
+                zigbeeDevice.log.debug(`Command off called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeId}:${data.endpoint?.maybeNumber}`);
+                nextPayload['state'] = 'OFF';
+                cachePublishLight();
             });
             zigbeeDevice.bridgedDevice.addCommandHandler('toggle', async (data) => {
-                zigbeeDevice.log.debug(`Command toggle called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeNumber}`);
-                zigbeeDevice.publishCommand('toggle', device.friendly_name, { state: 'TOGGLE' });
+                zigbeeDevice.log.debug(`Command toggle called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeId}:${data.endpoint?.maybeNumber}`);
+                nextPayload['state'] = 'TOGGLE';
+                cachePublishLight();
             });
         }
         if (zigbeeDevice.bridgedDevice.hasClusterServer(LevelControlCluster.id) || zigbeeDevice.hasEndpoints) {
             for (const child of zigbeeDevice.bridgedDevice.getChildEndpoints()) {
                 if (child.hasClusterServer(LevelControlCluster)) {
                     child.addCommandHandler('moveToLevel', async (data) => {
-                        zigbeeDevice.log.debug(`Command moveToLevel called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeNumber} request: ${data.request.level} transition: ${data.request.transitionTime}`);
-                        const payload = {};
-                        payload['brightness_' + data.endpoint.uniqueStorageKey] = data.request.level;
+                        zigbeeDevice.log.debug(`Command moveToLevel called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeId}:${data.endpoint?.maybeNumber} request: ${data.request.level} transition: ${data.request.transitionTime}`);
+                        nextPayload['state_' + data.endpoint.uniqueStorageKey] = 'ON';
+                        nextPayload['brightness_' + data.endpoint.uniqueStorageKey] = data.request.level;
                         if (zigbeeDevice.transition && data.request.transitionTime && data.request.transitionTime / 10 >= 1)
-                            payload['transition'] = Math.round(data.request.transitionTime / 10);
-                        zigbeeDevice.publishCommand('moveToLevel', device.friendly_name, payload);
+                            nextPayload['transition'] = Math.round(data.request.transitionTime / 10);
+                        cachePublishLight();
                     });
                     child.addCommandHandler('moveToLevelWithOnOff', async (data) => {
-                        zigbeeDevice.log.debug(`Command moveToLevelWithOnOff called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeNumber} request: ${data.request.level} transition: ${data.request.transitionTime}`);
-                        const payload = {};
-                        payload['brightness_' + data.endpoint.uniqueStorageKey] = data.request.level;
+                        zigbeeDevice.log.debug(`Command moveToLevelWithOnOff called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeId}:${data.endpoint?.maybeNumber} request: ${data.request.level} transition: ${data.request.transitionTime}`);
+                        nextPayload['state_' + data.endpoint.uniqueStorageKey] = 'ON';
+                        nextPayload['brightness_' + data.endpoint.uniqueStorageKey] = data.request.level;
                         if (zigbeeDevice.transition && data.request.transitionTime && data.request.transitionTime / 10 >= 1)
-                            payload['transition'] = Math.round(data.request.transitionTime / 10);
-                        zigbeeDevice.publishCommand('moveToLevelWithOnOff', device.friendly_name, payload);
+                            nextPayload['transition'] = Math.round(data.request.transitionTime / 10);
+                        cachePublishLight();
                     });
                 }
             }
             zigbeeDevice.bridgedDevice.addCommandHandler('moveToLevel', async (data) => {
-                zigbeeDevice.log.debug(`Command moveToLevel called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeNumber} request: ${data.request.level} transition: ${data.request.transitionTime}`);
-                const payload = { brightness: data.request.level };
+                zigbeeDevice.log.debug(`Command moveToLevel called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeId}:${data.endpoint?.maybeNumber} request: ${data.request.level} transition: ${data.request.transitionTime}`);
+                nextPayload['state'] = 'ON';
+                nextPayload['brightness'] = data.request.level;
                 if (zigbeeDevice.transition && data.request.transitionTime && data.request.transitionTime / 10 >= 1)
-                    payload['transition'] = Math.round(data.request.transitionTime / 10);
-                zigbeeDevice.publishCommand('moveToLevel', device.friendly_name, payload);
+                    nextPayload['transition'] = Math.round(data.request.transitionTime / 10);
+                cachePublishLight();
             });
             zigbeeDevice.bridgedDevice.addCommandHandler('moveToLevelWithOnOff', async (data) => {
-                zigbeeDevice.log.debug(`Command moveToLevelWithOnOff called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeNumber} request: ${data.request.level} transition: ${data.request.transitionTime}`);
-                const payload = { brightness: data.request.level };
+                zigbeeDevice.log.debug(`Command moveToLevelWithOnOff called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeId}:${data.endpoint?.maybeNumber} request: ${data.request.level} transition: ${data.request.transitionTime}`);
+                nextPayload['state'] = 'ON';
+                nextPayload['brightness'] = data.request.level;
                 if (zigbeeDevice.transition && data.request.transitionTime && data.request.transitionTime / 10 >= 1)
-                    payload['transition'] = Math.round(data.request.transitionTime / 10);
-                zigbeeDevice.publishCommand('moveToLevelWithOnOff', device.friendly_name, payload);
+                    nextPayload['transition'] = Math.round(data.request.transitionTime / 10);
+                cachePublishLight();
             });
         }
-        if (zigbeeDevice.bridgedDevice.hasAttributeServer(ColorControlCluster.id, 'colorTemperatureMireds')) {
-            zigbeeDevice.bridgedDevice.addCommandHandler('moveToColorTemperature', async ({ request }) => {
-                zigbeeDevice.log.debug(`Command moveToColorTemperature called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} request: ${request.colorTemperatureMireds}`);
-                await zigbeeDevice.bridgedDevice?.setAttribute(ColorControlCluster.id, 'colorMode', ColorControl.ColorMode.ColorTemperatureMireds, zigbeeDevice.log);
-                const payload = {};
+        if (zigbeeDevice.bridgedDevice.hasAttributeServer(ColorControlCluster.id, 'colorTemperatureMireds') || zigbeeDevice.hasEndpoints) {
+            for (const child of zigbeeDevice.bridgedDevice.getChildEndpoints()) {
+                if (child.hasAttributeServer(ColorControlCluster.id, 'colorTemperatureMireds')) {
+                    child.addCommandHandler('moveToColorTemperature', async (data) => {
+                        zigbeeDevice.log.debug(`Command moveToColorTemperature called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeId}:${data.endpoint?.maybeNumber} request: ${data.request.colorTemperatureMireds} transition: ${data.request.transitionTime}`);
+                        await child.setAttribute(ColorControlCluster.id, 'colorMode', ColorControl.ColorMode.ColorTemperatureMireds, zigbeeDevice.log);
+                        nextPayload['state_' + data.endpoint.uniqueStorageKey] = 'ON';
+                        if (zigbeeDevice.propertyMap.get('color_temp')) {
+                            nextPayload['color_temp_' + data.endpoint.uniqueStorageKey] = data.request.colorTemperatureMireds;
+                            if (zigbeeDevice.transition && data.request.transitionTime && data.request.transitionTime / 10 >= 1)
+                                nextPayload['transition'] = Math.round(data.request.transitionTime / 10);
+                            cachePublishLight();
+                        }
+                        else {
+                            const rgb = kelvinToRGB(miredToKelvin(data.request.colorTemperatureMireds));
+                            nextPayload['color_' + data.endpoint.uniqueStorageKey] = { r: rgb.r, g: rgb.g, b: rgb.b };
+                            if (zigbeeDevice.transition && data.request.transitionTime && data.request.transitionTime / 10 >= 1)
+                                nextPayload['transition'] = Math.round(data.request.transitionTime / 10);
+                            cachePublishLight();
+                            zigbeeDevice.log.info(`Command moveToColorTemperature called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${nf} but color_temp property is not available. Converting ${data.request.colorTemperatureMireds} to RGB ${debugStringify(rgb)}.`);
+                        }
+                    });
+                }
+            }
+            zigbeeDevice.bridgedDevice.addCommandHandler('moveToColorTemperature', async (data) => {
+                zigbeeDevice.log.debug(`Command moveToColorTemperature called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeId}:${data.endpoint?.maybeNumber} request: ${data.request.colorTemperatureMireds} transition: ${data.request.transitionTime}`);
+                await data.endpoint?.setAttribute(ColorControlCluster.id, 'colorMode', ColorControl.ColorMode.ColorTemperatureMireds, zigbeeDevice.log);
+                nextPayload['state'] = 'ON';
                 if (zigbeeDevice.propertyMap.get('color_temp')) {
-                    payload['color_temp'] = request.colorTemperatureMireds;
+                    nextPayload['color_temp'] = data.request.colorTemperatureMireds;
+                    if (zigbeeDevice.transition && data.request.transitionTime && data.request.transitionTime / 10 >= 1)
+                        nextPayload['transition'] = Math.round(data.request.transitionTime / 10);
+                    cachePublishLight();
                 }
                 else {
-                    const rgb = kelvinToRGB(miredToKelvin(request.colorTemperatureMireds));
-                    payload['color'] = { r: rgb.r, g: rgb.g, b: rgb.b };
-                    zigbeeDevice.log.info(`Command moveToColorTemperature called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${nf} but color_temp property is not available. Converting ${request.colorTemperatureMireds} to RGB ${debugStringify(payload['color'])}.`);
+                    const rgb = kelvinToRGB(miredToKelvin(data.request.colorTemperatureMireds));
+                    nextPayload['color'] = { r: rgb.r, g: rgb.g, b: rgb.b };
+                    if (zigbeeDevice.transition && data.request.transitionTime && data.request.transitionTime / 10 >= 1)
+                        nextPayload['transition'] = Math.round(data.request.transitionTime / 10);
+                    cachePublishLight();
+                    zigbeeDevice.log.info(`Command moveToColorTemperature called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${nf} but color_temp property is not available. Converting ${data.request.colorTemperatureMireds} to RGB ${debugStringify(rgb)}.`);
                 }
-                if (zigbeeDevice.transition && request.transitionTime && request.transitionTime / 10 >= 1)
-                    payload['transition'] = Math.round(request.transitionTime / 10);
-                zigbeeDevice.publishCommand('moveToColorTemperature', device.friendly_name, payload);
             });
         }
-        if (zigbeeDevice.bridgedDevice.hasAttributeServer(ColorControlCluster.id, 'currentX')) {
-            zigbeeDevice.bridgedDevice.addCommandHandler('moveToColor', async ({ request }) => {
-                zigbeeDevice.log.debug(`Command moveToColor called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} request: X: ${request.colorX} Y: ${request.colorY}`);
-                await zigbeeDevice.bridgedDevice?.setAttribute(ColorControlCluster.id, 'colorMode', ColorControl.ColorMode.CurrentXAndCurrentY, zigbeeDevice.log);
-                const payload = { color: { x: request.colorX / 65536, y: request.colorY / 65536 } };
-                if (zigbeeDevice.transition && request.transitionTime && request.transitionTime / 10 >= 1)
-                    payload['transition'] = Math.round(request.transitionTime / 10);
-                zigbeeDevice.publishCommand('moveToColor', device.friendly_name, payload);
+        if (zigbeeDevice.bridgedDevice.hasAttributeServer(ColorControlCluster.id, 'currentX') || zigbeeDevice.hasEndpoints) {
+            for (const child of zigbeeDevice.bridgedDevice.getChildEndpoints()) {
+                if (child.hasAttributeServer(ColorControlCluster.id, 'currentX')) {
+                    child.addCommandHandler('moveToColor', async (data) => {
+                        zigbeeDevice.log.debug(`Command moveToColor called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeId}:${data.endpoint?.maybeNumber} request: X: ${data.request.colorX} Y: ${data.request.colorY} transition: ${data.request.transitionTime}`);
+                        await child.setAttribute(ColorControlCluster.id, 'colorMode', ColorControl.ColorMode.CurrentXAndCurrentY, zigbeeDevice.log);
+                        nextPayload['state_' + data.endpoint.uniqueStorageKey] = 'ON';
+                        nextPayload['color_' + data.endpoint.uniqueStorageKey] = { x: data.request.colorX / 65536, y: data.request.colorY / 65536 };
+                        if (zigbeeDevice.transition && data.request.transitionTime && data.request.transitionTime / 10 >= 1)
+                            nextPayload['transition'] = Math.round(data.request.transitionTime / 10);
+                        cachePublishLight();
+                    });
+                }
+            }
+            zigbeeDevice.bridgedDevice.addCommandHandler('moveToColor', async (data) => {
+                zigbeeDevice.log.debug(`Command moveToColor called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeId}:${data.endpoint?.maybeNumber} request: X: ${data.request.colorX} Y: ${data.request.colorY} transition: ${data.request.transitionTime}`);
+                await data.endpoint?.setAttribute(ColorControlCluster.id, 'colorMode', ColorControl.ColorMode.CurrentXAndCurrentY, zigbeeDevice.log);
+                nextPayload['state'] = 'ON';
+                nextPayload['color'] = { x: data.request.colorX / 65536, y: data.request.colorY / 65536 };
+                if (zigbeeDevice.transition && data.request.transitionTime && data.request.transitionTime / 10 >= 1)
+                    nextPayload['transition'] = Math.round(data.request.transitionTime / 10);
+                cachePublishLight();
             });
         }
-        if (zigbeeDevice.bridgedDevice.hasAttributeServer(ColorControlCluster.id, 'currentHue')) {
-            let lastRequestedHue = 0;
-            let lastRequestedSaturation = 0;
-            zigbeeDevice.bridgedDevice.addCommandHandler('moveToHue', async ({ request }) => {
-                zigbeeDevice.log.debug(`Command moveToHue called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} request: ${request.hue}`);
+        if (zigbeeDevice.bridgedDevice.hasAttributeServer(ColorControlCluster.id, 'currentHue') || zigbeeDevice.hasEndpoints) {
+            for (const child of zigbeeDevice.bridgedDevice.getChildEndpoints()) {
+                if (child.hasAttributeServer(ColorControlCluster.id, 'currentHue')) {
+                    child.addCommandHandler('moveToHue', async (data) => {
+                        zigbeeDevice.log.debug(`Command moveToHue called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeId}:${data.endpoint?.maybeNumber} request: ${data.request.hue} transition: ${data.request.transitionTime}`);
+                        await child.setAttribute(ColorControlCluster.id, 'colorMode', ColorControl.ColorMode.CurrentHueAndCurrentSaturation, zigbeeDevice.log);
+                        nextPayload['state_' + data.endpoint.uniqueStorageKey] = 'ON';
+                        lastRequestedHue = data.request.hue;
+                        if (zigbeeDevice.transition && data.request.transitionTime && data.request.transitionTime / 10 >= 1)
+                            nextPayload['transition'] = Math.round(data.request.transitionTime / 10);
+                        cachePublishLight();
+                    });
+                    child.addCommandHandler('moveToSaturation', async (data) => {
+                        zigbeeDevice.log.debug(`Command moveToSaturation called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeId}:${data.endpoint?.maybeNumber} request: ${data.request.saturation} transition: ${data.request.transitionTime}`);
+                        await child.setAttribute(ColorControlCluster.id, 'colorMode', ColorControl.ColorMode.CurrentHueAndCurrentSaturation, zigbeeDevice.log);
+                        nextPayload['state_' + data.endpoint.uniqueStorageKey] = 'ON';
+                        lastRequestedSaturation = data.request.saturation;
+                        if (zigbeeDevice.transition && data.request.transitionTime && data.request.transitionTime / 10 >= 1)
+                            nextPayload['transition'] = Math.round(data.request.transitionTime / 10);
+                        cachePublishLight();
+                    });
+                    child.addCommandHandler('moveToHueAndSaturation', async (data) => {
+                        zigbeeDevice.log.debug(`Command moveToHueAndSaturation called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeId}:${data.endpoint?.maybeNumber} request: ${data.request.hue}-${data.request.saturation} transition: ${data.request.transitionTime}`);
+                        await child.setAttribute(ColorControlCluster.id, 'colorMode', ColorControl.ColorMode.CurrentHueAndCurrentSaturation, zigbeeDevice.log);
+                        nextPayload['state_' + data.endpoint.uniqueStorageKey] = 'ON';
+                        const rgb = color.hslColorToRgbColor((data.request.hue / 254) * 360, (data.request.saturation / 254) * 100, 50);
+                        nextPayload['color_' + data.endpoint.uniqueStorageKey] = { r: rgb.r, g: rgb.g, b: rgb.b };
+                        cachePublishLight();
+                    });
+                }
+            }
+            zigbeeDevice.bridgedDevice.addCommandHandler('moveToHue', async (data) => {
+                zigbeeDevice.log.debug(`Command moveToHue called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeId}:${data.endpoint?.maybeNumber} request: ${data.request.hue} transition: ${data.request.transitionTime}`);
                 await zigbeeDevice.bridgedDevice?.setAttribute(ColorControlCluster.id, 'colorMode', ColorControl.ColorMode.CurrentHueAndCurrentSaturation, zigbeeDevice.log);
-                lastRequestedHue = request.hue;
-                zigbeeDevice.colorTimeout = setTimeout(() => {
-                    clearTimeout(zigbeeDevice.colorTimeout);
-                    const rgb = color.hslColorToRgbColor((request.hue / 254) * 360, (lastRequestedSaturation / 254) * 100, 50);
-                    const payload = { color: { r: rgb.r, g: rgb.g, b: rgb.b } };
-                    if (zigbeeDevice.transition && request.transitionTime && request.transitionTime / 10 >= 1)
-                        payload['transition'] = Math.round(request.transitionTime / 10);
-                    zigbeeDevice.publishCommand('moveToHue', device.friendly_name, payload);
-                }, 500);
+                nextPayload['state'] = 'ON';
+                lastRequestedHue = data.request.hue;
+                if (zigbeeDevice.transition && data.request.transitionTime && data.request.transitionTime / 10 >= 1)
+                    nextPayload['transition'] = Math.round(data.request.transitionTime / 10);
+                cachePublishLight();
             });
-            zigbeeDevice.bridgedDevice.addCommandHandler('moveToSaturation', async ({ request }) => {
-                zigbeeDevice.log.debug(`Command moveToSaturation called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} request: ${request.saturation}`);
+            zigbeeDevice.bridgedDevice.addCommandHandler('moveToSaturation', async (data) => {
+                zigbeeDevice.log.debug(`Command moveToSaturation called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeId}:${data.endpoint?.maybeNumber} request: ${data.request.saturation} transition: ${data.request.transitionTime}`);
                 await zigbeeDevice.bridgedDevice?.setAttribute(ColorControlCluster.id, 'colorMode', ColorControl.ColorMode.CurrentHueAndCurrentSaturation, zigbeeDevice.log);
-                lastRequestedSaturation = request.saturation;
-                zigbeeDevice.colorTimeout = setTimeout(() => {
-                    clearTimeout(zigbeeDevice.colorTimeout);
-                    const rgb = color.hslColorToRgbColor((lastRequestedHue / 254) * 360, (request.saturation / 254) * 100, 50);
-                    const payload = { color: { r: rgb.r, g: rgb.g, b: rgb.b } };
-                    if (zigbeeDevice.transition && request.transitionTime && request.transitionTime / 10 >= 1)
-                        payload['transition'] = Math.round(request.transitionTime / 10);
-                    zigbeeDevice.publishCommand('moveToSaturation', device.friendly_name, payload);
-                }, 500);
+                nextPayload['state'] = 'ON';
+                lastRequestedSaturation = data.request.saturation;
+                if (zigbeeDevice.transition && data.request.transitionTime && data.request.transitionTime / 10 >= 1)
+                    nextPayload['transition'] = Math.round(data.request.transitionTime / 10);
+                cachePublishLight();
             });
-            zigbeeDevice.bridgedDevice.addCommandHandler('moveToHueAndSaturation', async ({ request }) => {
-                zigbeeDevice.log.debug(`Command moveToHueAndSaturation called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} request: ${request.hue}-${request.saturation}`);
+            zigbeeDevice.bridgedDevice.addCommandHandler('moveToHueAndSaturation', async (data) => {
+                zigbeeDevice.log.debug(`Command moveToHueAndSaturation called for ${zigbeeDevice.ien}${device.friendly_name}${rs}${db} endpoint: ${data.endpoint?.maybeId}:${data.endpoint?.maybeNumber} request: ${data.request.hue}-${data.request.saturation} transition: ${data.request.transitionTime}`);
                 await zigbeeDevice.bridgedDevice?.setAttribute(ColorControlCluster.id, 'colorMode', ColorControl.ColorMode.CurrentHueAndCurrentSaturation, zigbeeDevice.log);
-                const rgb = color.hslColorToRgbColor((request.hue / 254) * 360, (request.saturation / 254) * 100, 50);
-                const payload = { color: { r: rgb.r, g: rgb.g, b: rgb.b } };
-                if (zigbeeDevice.transition && request.transitionTime && request.transitionTime / 10 >= 1)
-                    payload['transition'] = Math.round(request.transitionTime / 10);
-                zigbeeDevice.publishCommand('moveToHueAndSaturation', device.friendly_name, payload);
+                nextPayload['state'] = 'ON';
+                const rgb = color.hslColorToRgbColor((data.request.hue / 254) * 360, (data.request.saturation / 254) * 100, 50);
+                nextPayload['color'] = { r: rgb.r, g: rgb.g, b: rgb.b };
+                cachePublishLight();
             });
         }
         if (zigbeeDevice.bridgedDevice.hasClusterServer(WindowCoveringCluster.id)) {

package/dist/index.js

@@ -1,5 +1,4 @@
 import { ZigbeePlatform } from './platform.js';
-export * from './entity.js';
 export default function initializePlugin(matterbridge, log, config) {
     return new ZigbeePlatform(matterbridge, log, config);
 }

package/dist/platform.js

@@ -1,17 +1,15 @@
+import path from 'node:path';
 import { addVirtualDevice, MatterbridgeDynamicPlatform } from 'matterbridge';
 import { dn, gn, db, wr, zb, payloadStringify, rs, debugStringify, CYAN, er, nf } from 'matterbridge/logger';
 import { isValidNumber, isValidString, waiter } from 'matterbridge/utils';
 import { BridgedDeviceBasicInformation, DoorLock } from 'matterbridge/matter/clusters';
-import path from 'node:path';
 import { ZigbeeDevice, ZigbeeGroup } from './entity.js';
 import { Zigbee2MQTT } from './zigbee2mqtt.js';
 export class ZigbeePlatform extends MatterbridgeDynamicPlatform {
-    publishCallBack = undefined;
-    permitJoinCallBack = undefined;
     bridgedDevices = [];
     zigbeeEntities = [];
-    injectTimer;
     namePostfix = 1;
+    injectTimer;
     mqttHost = 'mqtt://localhost';
     mqttPort = 1883;
     mqttTopic = 'zigbee2mqtt';
@@ -337,20 +335,20 @@ export class ZigbeePlatform extends MatterbridgeDynamicPlatform {
     }
     async onConfigure() {
         await super.onConfigure();
-        this.log.info(`Requesting update for ${this.zigbeeEntities.length} zigbee entities.`);
+        this.log.info(`Configuring ${this.zigbeeEntities.length} zigbee entities.`);
         for (const bridgedEntity of this.zigbeeEntities) {
             await bridgedEntity.configure();
             if (bridgedEntity.isRouter && bridgedEntity.bridgedDevice) {
-                this.log.info(`Configuring router ${bridgedEntity.bridgedDevice?.deviceName}.`);
+                this.log.info(`Configuring router ${bridgedEntity.bridgedDevice.deviceName}.`);
                 if (this.z2mBridgeInfo?.permit_join) {
-                    bridgedEntity.bridgedDevice?.setAttribute(DoorLock.Cluster.id, 'lockState', DoorLock.LockState.Unlocked, this.log);
+                    bridgedEntity.bridgedDevice.setAttribute(DoorLock.Cluster.id, 'lockState', DoorLock.LockState.Unlocked, this.log);
                     if (bridgedEntity.bridgedDevice.maybeNumber)
-                        bridgedEntity.bridgedDevice?.triggerEvent(DoorLock.Cluster.id, 'lockOperation', { lockOperationType: DoorLock.LockOperationType.Unlock, operationSource: DoorLock.OperationSource.Manual, userIndex: null, fabricIndex: null, sourceNode: null }, this.log);
+                        bridgedEntity.bridgedDevice.triggerEvent(DoorLock.Cluster.id, 'lockOperation', { lockOperationType: DoorLock.LockOperationType.Unlock, operationSource: DoorLock.OperationSource.Manual, userIndex: null, fabricIndex: null, sourceNode: null }, this.log);
                 }
                 else {
-                    bridgedEntity.bridgedDevice?.setAttribute(DoorLock.Cluster.id, 'lockState', DoorLock.LockState.Locked, this.log);
+                    bridgedEntity.bridgedDevice.setAttribute(DoorLock.Cluster.id, 'lockState', DoorLock.LockState.Locked, this.log);
                     if (bridgedEntity.bridgedDevice.maybeNumber)
-                        bridgedEntity.bridgedDevice?.triggerEvent(DoorLock.Cluster.id, 'lockOperation', { lockOperationType: DoorLock.LockOperationType.Lock, operationSource: DoorLock.OperationSource.Manual, userIndex: null, fabricIndex: null, sourceNode: null }, this.log);
+                        bridgedEntity.bridgedDevice.triggerEvent(DoorLock.Cluster.id, 'lockOperation', { lockOperationType: DoorLock.LockOperationType.Lock, operationSource: DoorLock.OperationSource.Manual, userIndex: null, fabricIndex: null, sourceNode: null }, this.log);
                 }
             }
             if (bridgedEntity.isDevice && bridgedEntity.device)
@@ -398,7 +396,6 @@ export class ZigbeePlatform extends MatterbridgeDynamicPlatform {
         await super.onShutdown(reason);
         this.z2m.removeAllListeners();
         this.z2m.stop();
-        this.publishCallBack = undefined;
         this.log.debug('Shutting down zigbee2mqtt platform: ' + reason);
         for (const entity of this.zigbeeEntities) {
             entity.destroy();
@@ -413,26 +410,9 @@ export class ZigbeePlatform extends MatterbridgeDynamicPlatform {
             await this.unregisterAllDevices();
         this.log.info(`Shutdown zigbee2mqtt dynamic platform v${this.version}`);
     }
-    setPublishCallBack(onPublish) {
-        this.publishCallBack = onPublish;
-    }
-    setPermitJoinCallBack(onPermitJoin) {
-        this.permitJoinCallBack = onPermitJoin;
-    }
     async publish(topic, subTopic, message) {
-        if (this.config.type === 'MatterbridgeExtension') {
-            if (this.publishCallBack && !topic.startsWith('bridge/request'))
-                await this.publishCallBack(topic, subTopic, message);
-            if (this.permitJoinCallBack && topic.startsWith('bridge/request'))
-                await this.permitJoinCallBack('', message === '{"value":true}');
-        }
-        else {
-            await this.z2m.publish(this.z2m.mqttTopic + '/' + topic + (subTopic === '' ? '' : '/' + subTopic), message);
-            this.log.info(`MQTT publish topic: ${CYAN}${this.z2m.mqttTopic + '/' + topic + (subTopic === '' ? '' : '/' + subTopic)}${nf} payload: ${CYAN}${message}${nf}`);
-        }
-    }
-    emit(eventName, data) {
-        this.z2m.emit(eventName, data);
+        this.log.info(`MQTT publish topic: ${CYAN}${this.z2m.mqttTopic + '/' + topic + (subTopic === '' ? '' : '/' + subTopic)}${nf} payload: ${CYAN}${message}${nf}`);
+        await this.z2m.publish(this.z2m.mqttTopic + '/' + topic + (subTopic === '' ? '' : '/' + subTopic), message);
     }
     async requestDeviceUpdate(device) {
         this.log.debug(`Requesting update for ${device.friendly_name} model_id: ${device.model_id} manufacturer: ${device.manufacturer}`);

package/dist/zigbee2mqtt.js

@@ -205,6 +205,7 @@ export class Zigbee2MQTT extends EventEmitter {
                     this.log.error('Error publishing keepalive MQTT message:', error);
                 }
             }, (this.options.keepalive ?? 60) * 1000).unref();
+            return;
         })
             .catch((error) => {
             this.log.error(`Error connecting to ${this.getUrl()}: ${error.message}`);
@@ -231,6 +232,7 @@ export class Zigbee2MQTT extends EventEmitter {
                 this.mqttIsEnding = false;
                 this.mqttClient = undefined;
                 this.log.debug('Connection closed');
+                return;
             })
                 .catch((error) => {
                 this.log.error(`Error closing connection: ${error.message}`);
@@ -245,6 +247,7 @@ export class Zigbee2MQTT extends EventEmitter {
                 .then(() => {
                 this.log.debug(`Subscribe success on topic: ${topic}`);
                 this.emit('mqtt_subscribed');
+                return;
             })
                 .catch((error) => {
                 this.log.error(`Subscribe error: ${error} on topic: ${topic}`);
@@ -325,6 +328,7 @@ export class Zigbee2MQTT extends EventEmitter {
         writeFile(`${filePath}.json`, JSON.stringify(jsonData, null, 2))
             .then(() => {
             this.log.debug(`Successfully wrote to ${filePath}.json`);
+            return;
         })
             .catch((error) => {
             this.log.error(`Error writing to ${filePath}.json:`, error);
@@ -335,6 +339,7 @@ export class Zigbee2MQTT extends EventEmitter {
         writeFile(`${filePath}`, data)
             .then(() => {
             this.log.debug(`Successfully wrote to ${filePath}`);
+            return;
         })
             .catch((error) => {
             this.log.error(`Error writing to ${filePath}:`, error);

package/npm-shrinkwrap.json

@@ -1,21 +1,21 @@
 {
   "name": "matterbridge-zigbee2mqtt",
-  "version": "2.6.0",
+  "version": "2.7.0-dev-20250711-6299fe0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "matterbridge-zigbee2mqtt",
-      "version": "2.6.0",
+      "version": "2.7.0-dev-20250711-6299fe0",
       "license": "Apache-2.0",
       "dependencies": {
         "moment": "2.30.1",
-        "mqtt": "5.13.1",
-        "node-ansi-logger": "3.0.1",
-        "node-persist-manager": "1.0.8"
+        "mqtt": "5.13.2",
+        "node-ansi-logger": "3.1.1",
+        "node-persist-manager": "2.0.0"
       },
       "engines": {
-        "node": ">=18.0.0 <19.0.0 || >=20.0.0 <21.0.0 || >=22.0.0"
+        "node": ">=18.0.0 <19.0.0 || >=20.0.0 <21.0.0 || >=22.0.0 <23.0.0 || >=24.0.0 <25.0.0"
       },
       "funding": {
         "type": "buymeacoffee",
@@ -32,12 +32,12 @@
       }
     },
     "node_modules/@types/node": {
-      "version": "22.15.30",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-22.15.30.tgz",
-      "integrity": "sha512-6Q7lr06bEHdlfplU6YRbgG1SFBdlsfNC4/lX+SkhiTs0cpJkOElmWls8PxDFv4yY/xKb8Y6SO0OmSX4wgqTZbA==",
+      "version": "24.0.12",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-24.0.12.tgz",
+      "integrity": "sha512-LtOrbvDf5ndC9Xi+4QZjVL0woFymF/xSTKZKPgrrl7H7XoeDvnD+E2IclKVDyaK9UM756W/3BXqSU+JEHopA9g==",
       "license": "MIT",
       "dependencies": {
-        "undici-types": "~6.21.0"
+        "undici-types": "~7.8.0"
       }
     },
     "node_modules/@types/readable-stream": {
@@ -49,6 +49,15 @@
         "@types/node": "*"
       }
     },
+    "node_modules/@types/ws": {
+      "version": "8.18.1",
+      "resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.18.1.tgz",
+      "integrity": "sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
     "node_modules/abort-controller": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/abort-controller/-/abort-controller-3.0.0.tgz",
@@ -286,11 +295,13 @@
       }
     },
     "node_modules/mqtt": {
-      "version": "5.13.1",
-      "resolved": "https://registry.npmjs.org/mqtt/-/mqtt-5.13.1.tgz",
-      "integrity": "sha512-g+4G+ma0UeL3Pgu1y1si2NHb4VLIEUCtF789WrG99lLG0XZyoab2EJoy58YgGSg/1yFdthDBH0+4llsZZD/vug==",
+      "version": "5.13.2",
+      "resolved": "https://registry.npmjs.org/mqtt/-/mqtt-5.13.2.tgz",
+      "integrity": "sha512-21E15qjFMNEddowGtLiMw4wXfzZxd3Iv+q+zC+tJSmY0flEreNgov+8SKrYcapA+pjClaqj+IgJW0jsJsHkmVQ==",
       "license": "MIT",
       "dependencies": {
+        "@types/readable-stream": "^4.0.18",
+        "@types/ws": "^8.18.1",
         "commist": "^3.2.0",
         "concat-stream": "^2.0.0",
         "debug": "^4.4.0",
@@ -339,12 +350,13 @@
       "license": "MIT"
     },
     "node_modules/node-ansi-logger": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/node-ansi-logger/-/node-ansi-logger-3.0.1.tgz",
-      "integrity": "sha512-Nx7nkO6Sby8Eti1UFFdff3gImEC35izuvf+aRFh3mrDZ8hgXM/cZdflkpDMnDdxnabYl91LVi4RhB/dm5Yk9iA==",
-      "license": "MIT",
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/node-ansi-logger/-/node-ansi-logger-3.1.1.tgz",
+      "integrity": "sha512-tFeCSxwiRg5XaNda5nC27alzraZP76nLtUk1JDZqb9byhW4WYaSGL7/lmxFHEI16gypQDMEYljuF+wcG+cPPHw==",
+      "hasShrinkwrap": true,
+      "license": "Apache-2.0",
       "engines": {
-        "node": ">=18.0.0"
+        "node": ">=18.0.0 <19.0.0 || >=20.0.0 <21.0.0 || >=22.0.0 <23.0.0 || >=24.0.0 <25.0.0"
       },
       "funding": {
         "type": "buymeacoffee",
@@ -364,15 +376,15 @@
       }
     },
     "node_modules/node-persist-manager": {
-      "version": "1.0.8",
-      "resolved": "https://registry.npmjs.org/node-persist-manager/-/node-persist-manager-1.0.8.tgz",
-      "integrity": "sha512-J0wjdxOloD6aw4s2kljbV3nvHfguWph8LnfmTL+6MZiBsh46wjaIaZd/cHU0HWonrNfktCv7Zuvn0sEH0f2s+A==",
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/node-persist-manager/-/node-persist-manager-2.0.0.tgz",
+      "integrity": "sha512-jpgOqCCn4ZEnIr4WcvqkyyGmmLJarV6aUyBlDQdG1G84X9UUmOmI1W2OZtc9K0z375CYWhjtGEXaY7GXNiEOfA==",
       "license": "MIT",
       "dependencies": {
-        "node-persist": "^4.0.2"
+        "node-persist": "4.0.4"
       },
       "engines": {
-        "node": ">=18.0.0"
+        "node": ">=18.0.0 <19.0.0 || >=20.0.0 <21.0.0 || >=22.0.0 <23.0.0 || >=24.0.0 <25.0.0"
       },
       "funding": {
         "type": "buymeacoffee",
@@ -472,9 +484,9 @@
       }
     },
     "node_modules/socks": {
-      "version": "2.8.4",
-      "resolved": "https://registry.npmjs.org/socks/-/socks-2.8.4.tgz",
-      "integrity": "sha512-D3YaD0aRxR3mEcqnidIs7ReYJFVzWdd6fXJYUM8ixcQcJRGTka/b3saV0KflYhyVJXKhb947GndU35SxYNResQ==",
+      "version": "2.8.5",
+      "resolved": "https://registry.npmjs.org/socks/-/socks-2.8.5.tgz",
+      "integrity": "sha512-iF+tNDQla22geJdTyJB1wM/qrX9DMRwWrciEPwWLPRWAUEM8sQiyxgckLxWT1f7+9VabJS0jTGGr4QgBuvi6Ww==",
       "license": "MIT",
       "dependencies": {
         "ip-address": "^9.0.5",
@@ -522,9 +534,9 @@
       "license": "MIT"
     },
     "node_modules/undici-types": {
-      "version": "6.21.0",
-      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
-      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+      "version": "7.8.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.8.0.tgz",
+      "integrity": "sha512-9UJ2xGDvQ43tYyVMpuHlsgApydB8ZKfVYTsLDhXkFL/6gfkp+U8xTGdh8pMJv1SpZna0zxG1DwsKZsreLbXBxw==",
       "license": "MIT"
     },
     "node_modules/util-deprecate": {
@@ -568,9 +580,9 @@
       }
     },
     "node_modules/ws": {
-      "version": "8.18.2",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.2.tgz",
-      "integrity": "sha512-DMricUmwGZUVr++AEAe2uiVM7UoO9MAVZMDu05UQOaUII0lp+zOzLLU4Xqh/JvTqklB1T4uELaaPBKyjE1r4fQ==",
+      "version": "8.18.3",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz",
+      "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==",
       "license": "MIT",
       "engines": {
         "node": ">=10.0.0"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matterbridge-zigbee2mqtt",
-  "version": "2.6.0",
+  "version": "2.7.0-dev-20250711-6299fe0",
   "description": "Matterbridge zigbee2mqtt plugin",
   "author": "https://github.com/Luligu",
   "license": "Apache-2.0",
@@ -38,12 +38,12 @@
     "zigbee2mqtt"
   ],
   "engines": {
-    "node": ">=18.0.0 <19.0.0 || >=20.0.0 <21.0.0 || >=22.0.0"
+    "node": ">=18.0.0 <19.0.0 || >=20.0.0 <21.0.0 || >=22.0.0 <23.0.0 || >=24.0.0 <25.0.0"
   },
   "dependencies": {
     "moment": "2.30.1",
-    "mqtt": "5.13.1",
-    "node-ansi-logger": "3.0.1",
-    "node-persist-manager": "1.0.8"
+    "mqtt": "5.13.2",
+    "node-ansi-logger": "3.1.1",
+    "node-persist-manager": "2.0.0"
   }
 }

package/CODEOWNERS

@@ -1 +0,0 @@
-@Luligu

package/tsconfig.jest.json

@@ -1,8 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    // enable isolatedModules just for ts-jest
-    "isolatedModules": true
-  },
-  "include": ["**/*.spec.ts", "**/*.test.ts", "**/__test__/*"]
-}