@matterbridge/core 3.10.6 → 3.10.7-dev-20260823-f911eb8

package/dist/behaviors/colorControlServer.d.ts

@@ -1,3 +1,4 @@
+import type { MaybePromise } from '@matter/general';
 import { ColorControlServer } from '@matter/node/behaviors/color-control';
 import { ColorControl } from '@matter/types/clusters/color-control';
 declare const MatterbridgeColorControlServer_base: import("@matter/node").ClusterBehavior.Type<typeof ColorControlServer, import("@matter/types").ClusterType.WithSupportedFeatures<ColorControl, {
@@ -8,6 +9,7 @@ declare const MatterbridgeColorControlServer_base: import("@matter/node").Cluste
     xy: true;
 }>, import("@matter/types").ClusterType.Concrete, typeof import("@matter/node/behaviors/color-control").ColorControlBaseServer.Internal, "colorControl">;
 export declare class MatterbridgeColorControlServer extends MatterbridgeColorControlServer_base {
+    initialize(): MaybePromise;
     moveToHue(request: ColorControl.MoveToHueRequest): Promise<void>;
     moveHue(request: ColorControl.MoveHueRequest): Promise<void>;
     stepHue(request: ColorControl.StepHueRequest): Promise<void>;

package/dist/behaviors/colorControlServer.js

@@ -2,9 +2,18 @@ import { ColorControlServer } from '@matter/node/behaviors/color-control';
 import { ColorControl } from '@matter/types/clusters/color-control';
 import { MatterbridgeServer } from './matterbridgeServer.js';
 export class MatterbridgeColorControlServer extends ColorControlServer.with(ColorControl.Feature.HueSaturation, ColorControl.Feature.Xy, ColorControl.Feature.ColorTemperature, ColorControl.Feature.EnhancedHue) {
+    initialize() {
+        if (process.env.MATTERBRIDGE_CHIP_TEST)
+            this.state.managedTransitionTimeHandling = true;
+        return super.initialize();
+    }
     async moveToHue(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Setting hue to ${request.hue} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+            await super.moveToHue(request);
+            return;
+        }
         await device.commandHandler.executeHandler('ColorControl.moveToHue', {
             command: 'moveToHue',
             request,
@@ -19,6 +28,10 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
     async moveHue(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Moving hue with mode ${request.moveMode} and rate ${request.rate} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+            await super.moveHue(request);
+            return;
+        }
         await device.commandHandler.executeHandler('ColorControl.moveHue', {
             command: 'moveHue',
             request,
@@ -33,6 +46,10 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
     async stepHue(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Stepping hue with mode ${request.stepMode} and size ${request.stepSize} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+            await super.stepHue(request);
+            return;
+        }
         await device.commandHandler.executeHandler('ColorControl.stepHue', {
             command: 'stepHue',
             request,
@@ -47,6 +64,10 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
     async enhancedMoveToHue(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Setting enhanced hue to ${request.enhancedHue} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+            await super.enhancedMoveToHue(request);
+            return;
+        }
         await device.commandHandler.executeHandler('ColorControl.enhancedMoveToHue', {
             command: 'enhancedMoveToHue',
             request,
@@ -61,6 +82,10 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
     async enhancedMoveHue(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Moving enhanced hue with mode ${request.moveMode} and rate ${request.rate} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+            await super.enhancedMoveHue(request);
+            return;
+        }
         await device.commandHandler.executeHandler('ColorControl.enhancedMoveHue', {
             command: 'enhancedMoveHue',
             request,
@@ -75,6 +100,10 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
     async enhancedStepHue(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Stepping enhanced hue with mode ${request.stepMode} and size ${request.stepSize} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+            await super.enhancedStepHue(request);
+            return;
+        }
         await device.commandHandler.executeHandler('ColorControl.enhancedStepHue', {
             command: 'enhancedStepHue',
             request,
@@ -89,6 +118,10 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
     async moveToSaturation(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Setting saturation to ${request.saturation} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+            await super.moveToSaturation(request);
+            return;
+        }
         await device.commandHandler.executeHandler('ColorControl.moveToSaturation', {
             command: 'moveToSaturation',
             request,
@@ -103,6 +136,10 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
     async moveSaturation(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Moving saturation with mode ${request.moveMode} and rate ${request.rate} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+            await super.moveSaturation(request);
+            return;
+        }
         await device.commandHandler.executeHandler('ColorControl.moveSaturation', {
             command: 'moveSaturation',
             request,
@@ -117,6 +154,10 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
     async stepSaturation(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Stepping saturation with mode ${request.stepMode} and size ${request.stepSize} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+            await super.stepSaturation(request);
+            return;
+        }
         await device.commandHandler.executeHandler('ColorControl.stepSaturation', {
             command: 'stepSaturation',
             request,
@@ -131,6 +172,10 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
     async moveToHueAndSaturation(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Setting hue to ${request.hue} and saturation to ${request.saturation} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+            await super.moveToHueAndSaturation(request);
+            return;
+        }
         await device.commandHandler.executeHandler('ColorControl.moveToHueAndSaturation', {
             command: 'moveToHueAndSaturation',
             request,
@@ -145,6 +190,10 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
     async enhancedMoveToHueAndSaturation(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Setting enhanced hue to ${request.enhancedHue} and saturation to ${request.saturation} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+            await super.enhancedMoveToHueAndSaturation(request);
+            return;
+        }
         await device.commandHandler.executeHandler('ColorControl.enhancedMoveToHueAndSaturation', {
             command: 'enhancedMoveToHueAndSaturation',
             request,
@@ -159,6 +208,10 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
     async moveToColor(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Setting color to ${request.colorX}, ${request.colorY} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+            await super.moveToColor(request);
+            return;
+        }
         await device.commandHandler.executeHandler('ColorControl.moveToColor', {
             command: 'moveToColor',
             request,
@@ -173,6 +226,10 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
     async moveColor(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Moving color with rateX ${request.rateX} and rateY ${request.rateY} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+            await super.moveColor(request);
+            return;
+        }
         await device.commandHandler.executeHandler('ColorControl.moveColor', {
             command: 'moveColor',
             request,
@@ -187,6 +244,10 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
     async stepColor(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Stepping color with stepX ${request.stepX} and stepY ${request.stepY} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+            await super.stepColor(request);
+            return;
+        }
         await device.commandHandler.executeHandler('ColorControl.stepColor', {
             command: 'stepColor',
             request,
@@ -201,6 +262,10 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
     async moveToColorTemperature(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Setting color temperature to ${request.colorTemperatureMireds} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+            await super.moveToColorTemperature(request);
+            return;
+        }
         await device.commandHandler.executeHandler('ColorControl.moveToColorTemperature', {
             command: 'moveToColorTemperature',
             request,
@@ -215,6 +280,10 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
     async moveColorTemperature(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Moving color temperature with mode ${request.moveMode} and rate ${request.rate} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+            await super.moveColorTemperature(request);
+            return;
+        }
         await device.commandHandler.executeHandler('ColorControl.moveColorTemperature', {
             command: 'moveColorTemperature',
             request,
@@ -229,6 +298,10 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
     async stepColorTemperature(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Stepping color temperature with mode ${request.stepMode} and size ${request.stepSize} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+            await super.stepColorTemperature(request);
+            return;
+        }
         await device.commandHandler.executeHandler('ColorControl.stepColorTemperature', {
             command: 'stepColorTemperature',
             request,
@@ -243,6 +316,10 @@ export class MatterbridgeColorControlServer extends ColorControlServer.with(Colo
     async stopMoveStep(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Stopping color move/step (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+            await super.stopMoveStep(request);
+            return;
+        }
         await device.commandHandler.executeHandler('ColorControl.stopMoveStep', {
             command: 'stopMoveStep',
             request,

package/dist/behaviors/levelControlServer.d.ts

@@ -1,6 +1,8 @@
+import type { MaybePromise } from '@matter/general';
 import { LevelControlServer } from '@matter/node/behaviors/level-control';
 import type { LevelControl } from '@matter/types/clusters/level-control';
 export declare class MatterbridgeLevelControlServer extends LevelControlServer {
+    initialize(): MaybePromise;
     moveToLevel(request: LevelControl.MoveToLevelRequest): Promise<void>;
     moveToLevelWithOnOff(request: LevelControl.MoveToLevelRequest): Promise<void>;
     move(request: LevelControl.MoveRequest): Promise<void>;

package/dist/behaviors/levelControlServer.js

@@ -1,9 +1,18 @@
 import { LevelControlServer } from '@matter/node/behaviors/level-control';
 import { MatterbridgeServer } from './matterbridgeServer.js';
 export class MatterbridgeLevelControlServer extends LevelControlServer {
+    initialize() {
+        if (process.env.MATTERBRIDGE_CHIP_TEST)
+            this.state.managedTransitionTimeHandling = true;
+        return super.initialize();
+    }
     async moveToLevel(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Setting level to ${request.level} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+            await super.moveToLevel(request);
+            return;
+        }
         await device.commandHandler.executeHandler('LevelControl.moveToLevel', {
             command: 'moveToLevel',
             request,
@@ -18,6 +27,10 @@ export class MatterbridgeLevelControlServer extends LevelControlServer {
     async moveToLevelWithOnOff(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Setting level to ${request.level} with transitionTime ${request.transitionTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+            await super.moveToLevelWithOnOff(request);
+            return;
+        }
         await device.commandHandler.executeHandler('LevelControl.moveToLevelWithOnOff', {
             command: 'moveToLevelWithOnOff',
             request,
@@ -32,6 +45,10 @@ export class MatterbridgeLevelControlServer extends LevelControlServer {
     async move(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Moving level with mode ${request.moveMode} and rate ${request.rate} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+            await super.move(request);
+            return;
+        }
         await device.commandHandler.executeHandler('LevelControl.move', {
             command: 'move',
             request,
@@ -46,6 +63,10 @@ export class MatterbridgeLevelControlServer extends LevelControlServer {
     async moveWithOnOff(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Moving level with mode ${request.moveMode} and rate ${request.rate} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+            await super.moveWithOnOff(request);
+            return;
+        }
         await device.commandHandler.executeHandler('LevelControl.moveWithOnOff', {
             command: 'moveWithOnOff',
             request,
@@ -60,6 +81,10 @@ export class MatterbridgeLevelControlServer extends LevelControlServer {
     async step(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Stepping level with mode ${request.stepMode} and size ${request.stepSize} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+            await super.step(request);
+            return;
+        }
         await device.commandHandler.executeHandler('LevelControl.step', {
             command: 'step',
             request,
@@ -74,6 +99,10 @@ export class MatterbridgeLevelControlServer extends LevelControlServer {
     async stepWithOnOff(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Stepping level with mode ${request.stepMode} and size ${request.stepSize} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+            await super.stepWithOnOff(request);
+            return;
+        }
         await device.commandHandler.executeHandler('LevelControl.stepWithOnOff', {
             command: 'stepWithOnOff',
             request,
@@ -88,6 +117,10 @@ export class MatterbridgeLevelControlServer extends LevelControlServer {
     async stop(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Stopping level change (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+            await super.stop(request);
+            return;
+        }
         await device.commandHandler.executeHandler('LevelControl.stop', {
             command: 'stop',
             request,
@@ -102,6 +135,10 @@ export class MatterbridgeLevelControlServer extends LevelControlServer {
     async stopWithOnOff(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Stopping level change (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+            await super.stopWithOnOff(request);
+            return;
+        }
         await device.commandHandler.executeHandler('LevelControl.stopWithOnOff', {
             command: 'stopWithOnOff',
             request,

package/dist/behaviors/onOffServer.js

@@ -5,96 +5,108 @@ export class MatterbridgeOnOffServer extends OnOffServer.with(OnOff.Feature.Ligh
     async on() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Switching device on (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        if (!process.env.MATTERBRIDGE_CHIP_TEST) {
-            await device.commandHandler.executeHandler('OnOff.on', {
-                command: 'on',
-                request: {},
-                cluster: OnOffServer.id,
-                attributes: this.state,
-                endpoint: this.endpoint,
-                context: this.context,
-            });
+        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+            await super.on();
+            return;
         }
+        await device.commandHandler.executeHandler('OnOff.on', {
+            command: 'on',
+            request: {},
+            cluster: OnOffServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
         device.log.debug(`MatterbridgeOnOffServer: on called`);
         await super.on();
     }
     async off() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Switching device off (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        if (!process.env.MATTERBRIDGE_CHIP_TEST) {
-            await device.commandHandler.executeHandler('OnOff.off', {
-                command: 'off',
-                request: {},
-                cluster: OnOffServer.id,
-                attributes: this.state,
-                endpoint: this.endpoint,
-                context: this.context,
-            });
+        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+            await super.off();
+            return;
         }
+        await device.commandHandler.executeHandler('OnOff.off', {
+            command: 'off',
+            request: {},
+            cluster: OnOffServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
         device.log.debug(`MatterbridgeOnOffServer: off called`);
         await super.off();
     }
     async toggle() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Toggle device on/off (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        if (!process.env.MATTERBRIDGE_CHIP_TEST) {
-            await device.commandHandler.executeHandler('OnOff.toggle', {
-                command: 'toggle',
-                request: {},
-                cluster: OnOffServer.id,
-                attributes: this.state,
-                endpoint: this.endpoint,
-                context: this.context,
-            });
+        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+            await super.toggle();
+            return;
         }
+        await device.commandHandler.executeHandler('OnOff.toggle', {
+            command: 'toggle',
+            request: {},
+            cluster: OnOffServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
         device.log.debug(`MatterbridgeOnOffServer: toggle called`);
         await super.toggle();
     }
     async offWithEffect(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Switching device off with effect ${request.effectIdentifier} and variant ${request.effectVariant} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        if (!process.env.MATTERBRIDGE_CHIP_TEST) {
-            await device.commandHandler.executeHandler('OnOff.offWithEffect', {
-                command: 'offWithEffect',
-                request,
-                cluster: OnOffServer.id,
-                attributes: this.state,
-                endpoint: this.endpoint,
-                context: this.context,
-            });
+        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+            await super.offWithEffect(request);
+            return;
         }
+        await device.commandHandler.executeHandler('OnOff.offWithEffect', {
+            command: 'offWithEffect',
+            request,
+            cluster: OnOffServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
         device.log.debug(`MatterbridgeOnOffServer: offWithEffect called`);
         await super.offWithEffect(request);
     }
     async onWithRecallGlobalScene() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Switching device on with recall global scene (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        if (!process.env.MATTERBRIDGE_CHIP_TEST) {
-            await device.commandHandler.executeHandler('OnOff.onWithRecallGlobalScene', {
-                command: 'onWithRecallGlobalScene',
-                request: {},
-                cluster: OnOffServer.id,
-                attributes: this.state,
-                endpoint: this.endpoint,
-                context: this.context,
-            });
+        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+            await super.onWithRecallGlobalScene();
+            return;
         }
+        await device.commandHandler.executeHandler('OnOff.onWithRecallGlobalScene', {
+            command: 'onWithRecallGlobalScene',
+            request: {},
+            cluster: OnOffServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
         device.log.debug(`MatterbridgeOnOffServer: onWithRecallGlobalScene called`);
         await super.onWithRecallGlobalScene();
     }
     async onWithTimedOff(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Switching device on with timed off control ${JSON.stringify(request.onOffControl)}, offWaitTime ${request.offWaitTime} and onTime ${request.onTime} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        if (!process.env.MATTERBRIDGE_CHIP_TEST) {
-            await device.commandHandler.executeHandler('OnOff.onWithTimedOff', {
-                command: 'onWithTimedOff',
-                request,
-                cluster: OnOffServer.id,
-                attributes: this.state,
-                endpoint: this.endpoint,
-                context: this.context,
-            });
+        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+            await super.onWithTimedOff(request);
+            return;
         }
+        await device.commandHandler.executeHandler('OnOff.onWithTimedOff', {
+            command: 'onWithTimedOff',
+            request,
+            cluster: OnOffServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+            context: this.context,
+        });
         device.log.debug(`MatterbridgeOnOffServer: onWithTimedOff called`);
         await super.onWithTimedOff(request);
     }

package/dist/chipTests.js

@@ -6,6 +6,7 @@ import { BridgedDeviceBasicInformationServer } from '@matter/node/behaviors/brid
 import { GeneralDiagnosticsServer } from '@matter/node/behaviors/general-diagnostics';
 import { Status, StatusResponseError } from '@matter/types';
 import { BooleanStateConfiguration } from '@matter/types/clusters/boolean-state-configuration';
+import { ClosureControl } from '@matter/types/clusters/closure-control';
 import { DeviceEnergyManagement } from '@matter/types/clusters/device-energy-management';
 import { ElectricalEnergyMeasurement } from '@matter/types/clusters/electrical-energy-measurement';
 import { ElectricalPowerMeasurement } from '@matter/types/clusters/electrical-power-measurement';
@@ -47,6 +48,12 @@ const deviceEnergyManagementForecastTrigger = 0x009800000000000fn;
 const deviceEnergyManagementForecastClearTrigger = 0x0098000000000010n;
 const booleanStateConfigurationSensorTrigger = 0x0080000000000000n;
 const booleanStateConfigurationSensorUntriggerTrigger = 0x0080000000000001n;
+const closureControlErrorTrigger = 0x0104000000000000n;
+const closureControlProtectedTrigger = 0x0104000000000001n;
+const closureControlDisengagedTrigger = 0x0104000000000002n;
+const closureControlSetupRequiredTrigger = 0x0104000000000003n;
+const closureControlClearTrigger = 0x0104000000000004n;
+const closureControlEndpointTriggerMask = 0x0000ffff00000000n;
 export const chipTestEnableKey = Uint8Array.from({ length: 16 }, (_, index) => index);
 const smokeCoAlarmChipTestEnableKey = Uint8Array.from([0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff]);
 let chipTestMatterbridge;
@@ -198,6 +205,14 @@ async function handleChipTestEventTrigger(eventTrigger) {
     if (eventTrigger === booleanStateConfigurationSensorTrigger || eventTrigger === booleanStateConfigurationSensorUntriggerTrigger) {
         return await handleBooleanStateConfigurationTestEventTrigger(eventTrigger);
     }
+    const closureControlTrigger = eventTrigger & ~closureControlEndpointTriggerMask;
+    if (closureControlTrigger === closureControlErrorTrigger ||
+        closureControlTrigger === closureControlProtectedTrigger ||
+        closureControlTrigger === closureControlDisengagedTrigger ||
+        closureControlTrigger === closureControlSetupRequiredTrigger ||
+        closureControlTrigger === closureControlClearTrigger) {
+        return await handleClosureControlTestEventTrigger(closureControlTrigger);
+    }
     if (eventTrigger !== smokeCoAlarmWarningSmokeAlarmTrigger &&
         eventTrigger !== smokeCoAlarmCriticalSmokeAlarmTrigger &&
         eventTrigger !== smokeCoAlarmSmokeAlarmClearTrigger &&
@@ -354,6 +369,44 @@ async function applyBooleanStateConfigurationTestEventTrigger(endpoint, eventTri
             return;
     }
 }
+async function handleClosureControlTestEventTrigger(eventTrigger) {
+    if (!chipTestMatterbridge || chipTestActiveEndpointId === undefined)
+        return false;
+    const endpoint = getChipTestEndpoint(chipTestMatterbridge, chipTestActiveEndpointId);
+    if (!endpoint || !endpoint.hasClusterServer(ClosureControl.id))
+        return false;
+    await applyClosureControlTestEventTrigger(endpoint, eventTrigger, chipTestMatterbridge.log);
+    return true;
+}
+async function applyClosureControlTestEventTrigger(endpoint, eventTrigger, log) {
+    switch (eventTrigger) {
+        case closureControlErrorTrigger: {
+            const errorState = [ClosureControl.ClosureError.PhysicallyBlocked];
+            await endpoint.setCluster(ClosureControl, { mainState: ClosureControl.MainState.Error, currentErrorList: errorState }, log);
+            await endpoint.triggerEvent(ClosureControl, 'operationalError', { errorState }, log);
+            return;
+        }
+        case closureControlProtectedTrigger:
+            await endpoint.setCluster(ClosureControl, { mainState: ClosureControl.MainState.Protected }, log);
+            return;
+        case closureControlDisengagedTrigger:
+            await endpoint.setCluster(ClosureControl, { mainState: ClosureControl.MainState.Disengaged }, log);
+            await endpoint.triggerEvent(ClosureControl, 'engageStateChanged', { engageValue: false }, log);
+            return;
+        case closureControlSetupRequiredTrigger:
+            await endpoint.setCluster(ClosureControl, { mainState: ClosureControl.MainState.SetupRequired }, log);
+            return;
+        case closureControlClearTrigger: {
+            const wasDisengaged = endpoint.getAttribute(ClosureControl.id, 'mainState') === ClosureControl.MainState.Disengaged;
+            await endpoint.setCluster(ClosureControl, { mainState: ClosureControl.MainState.Stopped, currentErrorList: [] }, log);
+            if (wasDisengaged)
+                await endpoint.triggerEvent(ClosureControl, 'engageStateChanged', { engageValue: true }, log);
+            return;
+        }
+        default:
+            return;
+    }
+}
 const electricalPowerMeasurementIdleReading = { voltage: 220_000, activeCurrent: 1_000, activePower: 220_000_000, frequency: 50_000 };
 const electricalEnergyMeasurementImportedEnergyPerTick = 278;
 const electricalEnergyMeasurementExportedEnergyPerTick = 833;

package/dist/demoDevices.js

@@ -1,4 +1,4 @@
-import { CommonNumberTag } from '@matter/node';
+import { ClosureTag, ClosureWindowTag, CommonNumberTag } from '@matter/node';
 import { AirQuality } from '@matter/types/clusters/air-quality';
 import { FanControl } from '@matter/types/clusters/fan-control';
 import { PowerSource } from '@matter/types/clusters/power-source';
@@ -32,7 +32,7 @@ export async function createDemoDevices(matterbridge) {
         description: 'Matterbridge demo devices',
         author: 'Matterbridge',
         enabled: false,
-        private: false,
+        private: true,
         registeredDevices: 0,
     });
     const registerDevice = async (device, deviceName, serialNumber) => {
@@ -201,10 +201,51 @@ export async function createDemoDevices(matterbridge) {
     await registerDevice(ep, 'Door Lock Controller', 'ENTRY-08-02');
     ep = new MatterbridgeEndpoint([getSupportedDeviceType('WindowCovering'), bridgedNode, powerSource], { id: 'WindowCovering', number: EndpointNumber(8_03) });
     await registerDevice(ep, 'Window Covering', 'ENTRY-08-03');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('WindowCovering'), bridgedNode, powerSource], { id: 'WindowCoveringTilt', number: EndpointNumber(8_03_1) });
+    ep.createDefaultLiftTiltWindowCoveringClusterServer();
+    await registerDevice(ep, 'Window Covering Tilt', 'ENTRY-08-03-1');
     ep = new MatterbridgeEndpoint([getSupportedDeviceType('WindowCoveringController'), bridgedNode, powerSource], { id: 'WindowCoveringController', number: EndpointNumber(8_04) });
     await registerDevice(ep, 'Window Covering Controller', 'ENTRY-08-04');
-    ep = new Closure('Closure', 'ENTRY-08-05', { id: 'Closure', number: EndpointNumber(8_05) });
+    ep = new Closure('Closure', 'ENTRY-08-05', { id: 'Closure', number: EndpointNumber(8_05), movementDuration: 2000, calibrationDuration: 2000 });
     await registerDevice(ep, 'Closure', 'ENTRY-08-05');
+    ep = new Closure('Closure Pedestrian', 'ENTRY-08-05-1', {
+        id: 'ClosurePedestrian',
+        number: EndpointNumber(8_05_1),
+        movementDuration: 2000,
+        calibrationDuration: 2000,
+        pedestrian: true,
+        tagList: [getSemtag(ClosureTag.Gate)],
+    });
+    await registerDevice(ep, 'Closure Pedestrian', 'ENTRY-08-05-1');
+    ep = new Closure('Closure Ventilation', 'ENTRY-08-05-2', {
+        id: 'ClosureVentilation',
+        number: EndpointNumber(8_05_2),
+        movementDuration: 2000,
+        calibrationDuration: 2000,
+        ventilation: true,
+        tagList: [getSemtag(ClosureTag.Window), getSemtag(ClosureWindowTag.Facade)],
+    });
+    await registerDevice(ep, 'Closure Ventilation', 'ENTRY-08-05-2');
+    ep = new Closure('Closure Calibrate', 'ENTRY-08-05-3', {
+        id: 'ClosureCalibrate',
+        number: EndpointNumber(8_05_3),
+        movementDuration: 2000,
+        calibrationDuration: 2000,
+        calibration: true,
+        tagList: [getSemtag(ClosureTag.GarageDoor)],
+    });
+    await registerDevice(ep, 'Closure Calibrate', 'ENTRY-08-05-3');
+    ep = new Closure('Closure Complete', 'ENTRY-08-05-4', {
+        id: 'ClosureComplete',
+        number: EndpointNumber(8_05_4),
+        movementDuration: 2000,
+        calibrationDuration: 2000,
+        ventilation: true,
+        pedestrian: true,
+        calibration: true,
+        tagList: [getSemtag(ClosureTag.Door)],
+    });
+    await registerDevice(ep, 'Closure Complete', 'ENTRY-08-05-4');
     ep = new MatterbridgeEndpoint([getSupportedDeviceType('ClosureController'), bridgedNode, powerSource], { id: 'ClosureController', number: EndpointNumber(8_07) });
     await registerDevice(ep, 'Closure Controller', 'ENTRY-08-07');
     ep = new MatterbridgeEndpoint([getSupportedDeviceType('Thermostat'), bridgedNode, powerSource], { id: 'Thermostat', number: EndpointNumber(9_01) });

package/dist/devices/closure.d.ts

@@ -5,8 +5,8 @@ import { Identify } from '@matter/types/clusters/identify';
 import type { Semtag } from '@matter/types/globals';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 import { type ClosureDimensionType, type ClosurePanelOptions } from './closurePanel.js';
-declare const MatterbridgeClosureControlServer_base: import("@matter/node").ClusterBehavior.Type<typeof ClosureControlServer, import("@matter/types").ClusterType.WithSupportedFeatures<ClosureControl, {
-    calibration: false;
+declare const MatterbridgeClosureControlServerBase: import("@matter/node").ClusterBehavior.Type<typeof ClosureControlServer, import("@matter/types").ClusterType.WithSupportedFeatures<ClosureControl, {
+    calibration: true;
     instantaneous: false;
     manuallyOperable: false;
     motionLatching: true;
@@ -16,9 +16,24 @@ declare const MatterbridgeClosureControlServer_base: import("@matter/node").Clus
     speed: true;
     ventilation: false;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "closureControl">;
-export declare class MatterbridgeClosureControlServer extends MatterbridgeClosureControlServer_base {
+export declare class MatterbridgeClosureControlServer extends MatterbridgeClosureControlServerBase {
+    readonly state: MatterbridgeClosureControlServer.State;
+    protected internal: MatterbridgeClosureControlServer.Internal;
     moveTo: (request: ClosureControl.MoveToRequest) => Promise<void>;
+    private completeMoveTo;
     stop: () => Promise<void>;
+    calibrate: () => Promise<void>;
+    private completeCalibrate;
+}
+export declare namespace MatterbridgeClosureControlServer {
+    class Internal extends MatterbridgeClosureControlServerBase.Internal {
+        movementTimer?: NodeJS.Timeout;
+        calibrateTimer?: NodeJS.Timeout;
+    }
+    class State extends MatterbridgeClosureControlServerBase.State {
+        movementDuration: number;
+        calibrationDuration: number;
+    }
 }
 export interface ClosureOptions {
     identifyTime?: number;
@@ -30,6 +45,11 @@ export interface ClosureOptions {
     overallCurrentState?: ClosureControl.OverallCurrentState;
     overallTargetState?: ClosureControl.OverallTargetState;
     latchControlModes?: ClosureControl.LatchControlModes;
+    movementDuration?: number;
+    calibrationDuration?: number;
+    ventilation?: boolean;
+    pedestrian?: boolean;
+    calibration?: boolean;
     id?: string;
     number?: EndpointNumber;
     tagList?: Semtag[];

package/dist/devices/closure.js

@@ -9,7 +9,15 @@ import { closure, closurePanel, powerSource } from '../matterbridgeDeviceTypes.j
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 import { getSemtag } from '../matterbridgeEndpointHelpers.js';
 import { createClosureDimensionClusterServer } from './closurePanel.js';
-export class MatterbridgeClosureControlServer extends ClosureControlServer.with(ClosureControl.Feature.Positioning, ClosureControl.Feature.MotionLatching, ClosureControl.Feature.Speed) {
+const targetToCurrentPosition = {
+    [ClosureControl.TargetPosition.MoveToFullyClosed]: ClosureControl.CurrentPosition.FullyClosed,
+    [ClosureControl.TargetPosition.MoveToFullyOpen]: ClosureControl.CurrentPosition.FullyOpened,
+    [ClosureControl.TargetPosition.MoveToPedestrianPosition]: ClosureControl.CurrentPosition.OpenedForPedestrian,
+    [ClosureControl.TargetPosition.MoveToVentilationPosition]: ClosureControl.CurrentPosition.OpenedForVentilation,
+    [ClosureControl.TargetPosition.MoveToSignaturePosition]: ClosureControl.CurrentPosition.OpenedAtSignature,
+};
+const MatterbridgeClosureControlServerBase = ClosureControlServer.with(ClosureControl.Feature.Positioning, ClosureControl.Feature.MotionLatching, ClosureControl.Feature.Speed, ClosureControl.Feature.Calibration);
+export class MatterbridgeClosureControlServer extends MatterbridgeClosureControlServerBase {
     moveTo = async (request) => {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`MoveTo (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
@@ -20,6 +28,15 @@ export class MatterbridgeClosureControlServer extends ClosureControlServer.with(
             attributes: this.state,
             endpoint: this.endpoint,
         });
+        if (request.position !== undefined && !(request.position in targetToCurrentPosition)) {
+            throw new StatusResponse.ConstraintErrorError('ClosureControl.moveTo Position is not a valid TargetPositionEnum value');
+        }
+        if (request.latch !== undefined && typeof request.latch !== 'boolean') {
+            throw new StatusResponse.ConstraintErrorError('ClosureControl.moveTo Latch is not a boolean value');
+        }
+        if (request.speed !== undefined && !(request.speed in ThreeLevelAuto)) {
+            throw new StatusResponse.ConstraintErrorError('ClosureControl.moveTo Speed is not a valid ThreeLevelAutoEnum value');
+        }
         if (request.position === undefined && request.latch === undefined && request.speed === undefined) {
             throw new StatusResponse.InvalidCommandError('ClosureControl.moveTo requires at least one of position, latch, or speed to be present');
         }
@@ -47,6 +64,38 @@ export class MatterbridgeClosureControlServer extends ClosureControlServer.with(
             (nextTarget.latch === undefined || nextTarget.latch === currentState.latch) &&
             nextTarget.speed === currentState.speed;
         this.state.mainState = isAtTarget ? ClosureControl.MainState.Stopped : ClosureControl.MainState.Moving;
+        clearTimeout(this.internal.movementTimer);
+        if (isAtTarget) {
+            this.internal.movementTimer = undefined;
+            this.state.countdownTime = 0;
+        }
+        else if (currentState === null || this.state.movementDuration <= 0) {
+            this.internal.movementTimer = undefined;
+        }
+        else {
+            this.state.countdownTime = this.state.movementDuration / 1000;
+            const previousState = currentState;
+            this.internal.movementTimer = setTimeout(() => {
+                this.internal.movementTimer = undefined;
+                void this.completeMoveTo(nextTarget, previousState);
+            }, this.state.movementDuration);
+        }
+    };
+    completeMoveTo = async (targetState, previousState) => {
+        const closure = this.endpoint;
+        let position = previousState.position;
+        if (targetState.position !== undefined && targetState.position !== null) {
+            const mappedPosition = targetToCurrentPosition[targetState.position];
+            if (mappedPosition !== undefined)
+                position = mappedPosition;
+        }
+        const latch = targetState.latch ?? previousState.latch;
+        const secureState = latch === true;
+        await closure.setState({ position, latch, speed: targetState.speed, secureState }, targetState, ClosureControl.MainState.Stopped, 0);
+        if (secureState !== previousState.secureState) {
+            await closure.triggerSecureStateChanged(secureState);
+        }
+        await closure.triggerMovementCompleted();
     };
     stop = async () => {
         const device = this.endpoint.stateOf(MatterbridgeServer);
@@ -58,11 +107,62 @@ export class MatterbridgeClosureControlServer extends ClosureControlServer.with(
             attributes: this.state,
             endpoint: this.endpoint,
         });
+        clearTimeout(this.internal.movementTimer);
+        this.internal.movementTimer = undefined;
+        clearTimeout(this.internal.calibrateTimer);
+        this.internal.calibrateTimer = undefined;
         if ([ClosureControl.MainState.Moving, ClosureControl.MainState.WaitingForMotion, ClosureControl.MainState.Calibrating].includes(this.state.mainState)) {
             this.state.mainState = ClosureControl.MainState.Stopped;
+            this.state.countdownTime = 0;
         }
     };
+    calibrate = async () => {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        device.log.info(`Calibrate (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        await device.commandHandler.executeHandler('ClosureControl.calibrate', {
+            command: 'calibrate',
+            request: {},
+            cluster: ClosureControlServer.id,
+            attributes: this.state,
+            endpoint: this.endpoint,
+        });
+        if (this.state.mainState === ClosureControl.MainState.Calibrating) {
+            return;
+        }
+        if (![ClosureControl.MainState.Stopped, ClosureControl.MainState.SetupRequired].includes(this.state.mainState)) {
+            throw new StatusResponse.InvalidInStateError('ClosureControl.calibrate is only allowed while Stopped or SetupRequired');
+        }
+        this.state.mainState = ClosureControl.MainState.Calibrating;
+        clearTimeout(this.internal.calibrateTimer);
+        if (this.state.calibrationDuration <= 0) {
+            this.internal.calibrateTimer = undefined;
+        }
+        else {
+            this.state.countdownTime = this.state.calibrationDuration / 1000;
+            this.internal.calibrateTimer = setTimeout(() => {
+                this.internal.calibrateTimer = undefined;
+                void this.completeCalibrate();
+            }, this.state.calibrationDuration);
+        }
+    };
+    completeCalibrate = async () => {
+        const closure = this.endpoint;
+        await closure.setAttribute(ClosureControl, 'countdownTime', 0);
+        await closure.setAttribute(ClosureControl, 'mainState', ClosureControl.MainState.Stopped);
+    };
 }
+(function (MatterbridgeClosureControlServer) {
+    class Internal extends MatterbridgeClosureControlServerBase.Internal {
+        movementTimer;
+        calibrateTimer;
+    }
+    MatterbridgeClosureControlServer.Internal = Internal;
+    class State extends MatterbridgeClosureControlServerBase.State {
+        movementDuration = 0;
+        calibrationDuration = 0;
+    }
+    MatterbridgeClosureControlServer.State = State;
+})(MatterbridgeClosureControlServer || (MatterbridgeClosureControlServer = {}));
 export class Closure extends MatterbridgeEndpoint {
     constructor(name, serial, options = {}) {
         const { identifyTime = 0, identifyType = Identify.IdentifyType.None, powerSourceType = 'Wired', countdownTime = 0, mainState = ClosureControl.MainState.Stopped, currentErrorList = [], overallCurrentState = {
@@ -74,7 +174,7 @@ export class Closure extends MatterbridgeEndpoint {
             position: ClosureControl.TargetPosition.MoveToFullyClosed,
             latch: true,
             speed: ThreeLevelAuto.Auto,
-        }, latchControlModes = { remoteLatching: true, remoteUnlatching: true }, id, number, tagList = [getSemtag(ClosureTag.Covering)], } = options;
+        }, latchControlModes = { remoteLatching: true, remoteUnlatching: true }, movementDuration = 0, calibrationDuration = 0, ventilation = false, pedestrian = false, calibration = false, id, number, tagList = [getSemtag(ClosureTag.Covering)], } = options;
         super(powerSourceType === 'None' ? [closure] : [closure, powerSource], {
             id: id ?? `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`,
             number,
@@ -98,14 +198,19 @@ export class Closure extends MatterbridgeEndpoint {
             case 'None':
                 break;
         }
-        this.behaviors.require(MatterbridgeClosureControlServer, {
+        const closureControlOptions = {
             countdownTime,
             mainState,
             currentErrorList,
             overallCurrentState,
             overallTargetState,
             latchControlModes,
-        });
+            movementDuration,
+            calibrationDuration,
+        };
+        this.behaviors.require(calibration || ventilation || pedestrian
+            ? MatterbridgeClosureControlServer.with(ClosureControl.Feature.Positioning, ClosureControl.Feature.MotionLatching, ClosureControl.Feature.Speed, ...(calibration ? [ClosureControl.Feature.Calibration] : []), ...(ventilation ? [ClosureControl.Feature.Ventilation] : []), ...(pedestrian ? [ClosureControl.Feature.Pedestrian] : []))
+            : MatterbridgeClosureControlServer, closureControlOptions);
     }
     getMainState() {
         return this.getAttribute(ClosureControlServer, 'mainState');

package/dist/frontend.js

@@ -17,6 +17,7 @@ import { SoilMeasurement } from '@matter/types/clusters/soil-measurement';
 import { ValveConfigurationAndControl } from '@matter/types/clusters/valve-configuration-and-control';
 import { CommissioningOptions } from '@matter/types/commissioning';
 import { FabricIndex } from '@matter/types/datatype';
+import { ThreeLevelAuto } from '@matter/types/globals';
 import { BroadcastServer } from '@matterbridge/thread/server';
 import { MATTER_LOGGER_FILE, MATTER_STORAGE_DIR, MATTERBRIDGE_DIAGNOSTIC_FILE, MATTERBRIDGE_HISTORY_FILE, MATTERBRIDGE_LOGGER_FILE, NODE_STORAGE_DIR, plg, } from '@matterbridge/types';
 import { isBun } from '@matterbridge/utils/bun';
@@ -1126,11 +1127,12 @@ export class Frontend extends EventEmitter {
             if (clusterName === 'doorLock' && attributeName === 'lockState')
                 attributes += `State: ${attributeValue === 1 ? 'Locked' : 'Not locked'} `;
             if (clusterName === 'closureControl' && attributeName === 'overallCurrentState' && attributeValue === null)
-                attributes += `Position: unknown Latch: unknown SecureState: unknown `;
+                attributes += `Position: unknown Latch: unknown Speed: unknown SecureState: unknown `;
             if (clusterName === 'closureControl' && attributeName === 'overallCurrentState' && isValidObject(attributeValue)) {
                 const overallCurrentState = attributeValue;
                 attributes += `Position: ${getEnumDescription(ClosureControl.CurrentPosition, overallCurrentState.position, { fallback: 'unknown' })} `;
                 attributes += `Latch: ${overallCurrentState.latch ?? 'unknown'} `;
+                attributes += `Speed: ${getEnumDescription(ThreeLevelAuto, overallCurrentState.speed, { fallback: 'unknown' })} `;
                 attributes += `SecureState: ${overallCurrentState.secureState ?? 'unknown'} `;
             }
             if (clusterName === 'thermostat' && attributeName === 'localTemperature' && isValidNumber(attributeValue))

package/dist/matterbridgeEndpointCommandHandler.d.ts

@@ -376,6 +376,13 @@ export type CommandHandlerDataMap = {
         attributes: ClusterAttributeValues<(typeof ClosureControl)['attributes']>;
         endpoint: MatterbridgeEndpoint;
     };
+    'ClosureControl.calibrate': {
+        command: 'calibrate';
+        request: {};
+        cluster: 'closureControl';
+        attributes: ClusterAttributeValues<(typeof ClosureControl)['attributes']>;
+        endpoint: MatterbridgeEndpoint;
+    };
     'setTarget': CommandHandlerData<'ClosureDimension.setTarget'>;
     'ClosureDimension.setTarget': {
         command: 'setTarget';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.10.6",
+  "version": "3.10.7-dev-20260823-f911eb8",
   "description": "Matterbridge core library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -132,10 +132,10 @@
   },
   "dependencies": {
     "@matter/main": "0.17.9",
-    "@matterbridge/dgram": "3.10.6",
-    "@matterbridge/thread": "3.10.6",
-    "@matterbridge/types": "3.10.6",
-    "@matterbridge/utils": "3.10.6",
+    "@matterbridge/dgram": "3.10.7-dev-20260823-f911eb8",
+    "@matterbridge/thread": "3.10.7-dev-20260823-f911eb8",
+    "@matterbridge/types": "3.10.7-dev-20260823-f911eb8",
+    "@matterbridge/utils": "3.10.7-dev-20260823-f911eb8",
     "escape-html": "1.0.3",
     "express": "5.2.1",
     "express-rate-limit": "8.6.2",