@matterbridge/core 3.10.7-dev-20260822-149e3eb → 3.10.7-dev-20260823-6142c00

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/behaviors/operationalStateServer.d.ts

@@ -1,10 +1,21 @@
 import type { MaybePromise } from '@matter/general';
 import { OperationalStateServer } from '@matter/node/behaviors/operational-state';
 import { OperationalState } from '@matter/types/clusters/operational-state';
-export declare class MatterbridgeOperationalStateServer extends OperationalStateServer {
+declare const MatterbridgeOperationalStateServerBase: import("@matter/node").ClusterBehavior.Type<typeof OperationalStateServer, import("@matter/types").ClusterType.WithEnabledAttributes<import("@matter/types").ClusterType.WithEnabledEvents<OperationalState, "operationCompletion">, never>, import("@matter/types").ClusterType.Concrete, new () => {}, "operationalState">;
+export declare class MatterbridgeOperationalStateServer extends MatterbridgeOperationalStateServerBase {
+    protected internal: MatterbridgeOperationalStateServer.Internal;
     initialize(): MaybePromise;
     pause(): Promise<OperationalState.OperationalCommandResponse>;
     stop(): Promise<OperationalState.OperationalCommandResponse>;
     start(): Promise<OperationalState.OperationalCommandResponse>;
     resume(): Promise<OperationalState.OperationalCommandResponse>;
 }
+export declare namespace MatterbridgeOperationalStateServer {
+    class Internal extends MatterbridgeOperationalStateServerBase.Internal {
+        operationalStateBeforePause: OperationalState.OperationalStateEnum;
+        operationStartedAt: number | undefined;
+        pausedAccumulatedMs: number;
+        pausedSinceMs: number | undefined;
+    }
+}
+export {};

package/dist/behaviors/operationalStateServer.js

@@ -1,7 +1,8 @@
 import { OperationalStateServer } from '@matter/node/behaviors/operational-state';
 import { OperationalState } from '@matter/types/clusters/operational-state';
 import { MatterbridgeServer } from './matterbridgeServer.js';
-export class MatterbridgeOperationalStateServer extends OperationalStateServer {
+const MatterbridgeOperationalStateServerBase = OperationalStateServer.enable({ events: { operationCompletion: true } });
+export class MatterbridgeOperationalStateServer extends MatterbridgeOperationalStateServerBase {
     initialize() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.debug('MatterbridgeOperationalStateServer initialized: setting operational state to Stopped');
@@ -20,7 +21,21 @@ export class MatterbridgeOperationalStateServer extends OperationalStateServer {
             endpoint: this.endpoint,
             context: this.context,
         });
+        if (this.state.operationalState === OperationalState.OperationalStateEnum.Paused) {
+            device.log.debug('MatterbridgeOperationalStateServer: pause received while already Paused, taking no further action');
+            return {
+                commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Already paused' },
+            };
+        }
+        if (this.state.operationalState !== OperationalState.OperationalStateEnum.Running) {
+            device.log.debug(`MatterbridgeOperationalStateServer: pause received in state ${this.state.operationalState} which is not Pause-compatible`);
+            return {
+                commandResponseState: { errorStateId: OperationalState.ErrorState.CommandInvalidInState, errorStateDetails: 'Not Pause-compatible in the current operational state' },
+            };
+        }
         device.log.debug('MatterbridgeOperationalStateServer: pause called setting operational state to Paused');
+        this.internal.operationalStateBeforePause = this.state.operationalState;
+        this.internal.pausedSinceMs = Date.now();
         this.state.operationalState = OperationalState.OperationalStateEnum.Paused;
         this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' };
         return {
@@ -38,7 +53,22 @@ export class MatterbridgeOperationalStateServer extends OperationalStateServer {
             endpoint: this.endpoint,
             context: this.context,
         });
+        if (this.state.operationalState === OperationalState.OperationalStateEnum.Stopped) {
+            device.log.debug('MatterbridgeOperationalStateServer: stop received while already Stopped, taking no further action');
+            return {
+                commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Already stopped' },
+            };
+        }
         device.log.debug('MatterbridgeOperationalStateServer: stop called setting operational state to Stopped');
+        if (this.internal.pausedSinceMs !== undefined) {
+            this.internal.pausedAccumulatedMs += Date.now() - this.internal.pausedSinceMs;
+            this.internal.pausedSinceMs = undefined;
+        }
+        const totalOperationalTime = this.internal.operationStartedAt === undefined ? null : Math.round((Date.now() - this.internal.operationStartedAt) / 1000);
+        const pausedTime = this.internal.operationStartedAt === undefined ? null : Math.round(this.internal.pausedAccumulatedMs / 1000);
+        this.internal.operationStartedAt = undefined;
+        this.internal.pausedAccumulatedMs = 0;
+        this.events.operationCompletion.emit({ completionErrorCode: OperationalState.ErrorState.NoError, totalOperationalTime, pausedTime }, this.context);
         this.state.operationalState = OperationalState.OperationalStateEnum.Stopped;
         this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' };
         return {
@@ -56,7 +86,27 @@ export class MatterbridgeOperationalStateServer extends OperationalStateServer {
             endpoint: this.endpoint,
             context: this.context,
         });
+        if (this.state.operationalState === OperationalState.OperationalStateEnum.Running) {
+            device.log.debug('MatterbridgeOperationalStateServer: start received while already Running, taking no further action');
+            return {
+                commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Already running' },
+            };
+        }
+        if (this.state.operationalState === OperationalState.OperationalStateEnum.Error) {
+            device.log.debug('MatterbridgeOperationalStateServer: start received while in the Error state, unable to honor');
+            return {
+                commandResponseState: { errorStateId: OperationalState.ErrorState.UnableToStartOrResume, errorStateDetails: 'Unable to start while in the Error state' },
+            };
+        }
         device.log.debug('MatterbridgeOperationalStateServer: start called setting operational state to Running');
+        if (this.state.operationalState === OperationalState.OperationalStateEnum.Paused && this.internal.pausedSinceMs !== undefined) {
+            this.internal.pausedAccumulatedMs += Date.now() - this.internal.pausedSinceMs;
+            this.internal.pausedSinceMs = undefined;
+        }
+        else {
+            this.internal.operationStartedAt = Date.now();
+            this.internal.pausedAccumulatedMs = 0;
+        }
         this.state.operationalState = OperationalState.OperationalStateEnum.Running;
         this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' };
         return {
@@ -74,11 +124,36 @@ export class MatterbridgeOperationalStateServer extends OperationalStateServer {
             endpoint: this.endpoint,
             context: this.context,
         });
+        if (this.state.operationalState === OperationalState.OperationalStateEnum.Running) {
+            device.log.debug('MatterbridgeOperationalStateServer: resume received while already Running, taking no further action');
+            return {
+                commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Already running' },
+            };
+        }
+        if (this.state.operationalState !== OperationalState.OperationalStateEnum.Paused) {
+            device.log.debug(`MatterbridgeOperationalStateServer: resume received in state ${this.state.operationalState} which is not Resume-compatible`);
+            return {
+                commandResponseState: { errorStateId: OperationalState.ErrorState.CommandInvalidInState, errorStateDetails: 'Not Resume-compatible in the current operational state' },
+            };
+        }
         device.log.debug('MatterbridgeOperationalStateServer: resume called setting operational state to Running');
-        this.state.operationalState = OperationalState.OperationalStateEnum.Running;
+        if (this.internal.pausedSinceMs !== undefined) {
+            this.internal.pausedAccumulatedMs += Date.now() - this.internal.pausedSinceMs;
+            this.internal.pausedSinceMs = undefined;
+        }
+        this.state.operationalState = this.internal.operationalStateBeforePause;
         this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' };
         return {
             commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Fully operational' },
         };
     }
 }
+(function (MatterbridgeOperationalStateServer) {
+    class Internal extends MatterbridgeOperationalStateServerBase.Internal {
+        operationalStateBeforePause = OperationalState.OperationalStateEnum.Running;
+        operationStartedAt;
+        pausedAccumulatedMs = 0;
+        pausedSinceMs;
+    }
+    MatterbridgeOperationalStateServer.Internal = Internal;
+})(MatterbridgeOperationalStateServer || (MatterbridgeOperationalStateServer = {}));

package/dist/behaviors/valveConfigurationAndControlServer.d.ts

@@ -1,11 +1,29 @@
+import { type MaybePromise, type Timer } from '@matter/general';
 import { ValveConfigurationAndControlServer } from '@matter/node/behaviors/valve-configuration-and-control';
 import { ValveConfigurationAndControl } from '@matter/types/clusters/valve-configuration-and-control';
-declare const MatterbridgeValveConfigurationAndControlServer_base: import("@matter/node").ClusterBehavior.Type<typeof ValveConfigurationAndControlServer, import("@matter/types").ClusterType.WithSupportedFeatures<ValveConfigurationAndControl, {
+declare const MatterbridgeValveConfigurationAndControlServerBase: import("@matter/node").ClusterBehavior.Type<typeof ValveConfigurationAndControlServer, import("@matter/types").ClusterType.WithSupportedFeatures<ValveConfigurationAndControl, {
     level: true;
     timeSync: false;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "valveConfigurationAndControl">;
-export declare class MatterbridgeValveConfigurationAndControlServer extends MatterbridgeValveConfigurationAndControlServer_base {
+export declare class MatterbridgeValveConfigurationAndControlServer extends MatterbridgeValveConfigurationAndControlServerBase {
+    #private;
+    readonly state: MatterbridgeValveConfigurationAndControlServer.State;
+    protected internal: MatterbridgeValveConfigurationAndControlServer.Internal;
+    initialize(): MaybePromise;
     open(request: ValveConfigurationAndControl.OpenRequest): Promise<void>;
     close(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+export declare namespace MatterbridgeValveConfigurationAndControlServer {
+    class Internal extends MatterbridgeValveConfigurationAndControlServerBase.Internal {
+        movementTimer?: Timer;
+        movementFinalState: ValveConfigurationAndControl.ValveState;
+        movementFinalLevel: number;
+        autoCloseTimer?: Timer;
+    }
+    class State extends MatterbridgeValveConfigurationAndControlServerBase.State {
+        movementDuration: number;
+        autoClose: boolean;
+    }
 }
 export {};