@matterbridge/core 3.10.8-dev-20260901-c4963a1 → 3.10.8-dev-20260902-361500d

package/dist/behaviors/windowCoveringServer.d.ts

@@ -1,3 +1,4 @@
+import { type Timer } from '@matter/general';
 import { WindowCoveringBaseServer, WindowCoveringServer } from '@matter/node/behaviors/window-covering';
 import { WindowCovering } from '@matter/types/clusters/window-covering';
 declare const MatterbridgeWindowCoveringServer_base: import("@matter/node").ClusterBehavior.Type<typeof WindowCoveringServer, import("@matter/types").ClusterType.WithSupportedFeatures<WindowCovering, {
@@ -18,11 +19,14 @@ export declare class MatterbridgeWindowCoveringServer extends MatterbridgeWindow
     stopMotion(): Promise<void>;
     goToLiftPercentage(request: WindowCovering.GoToLiftPercentageRequest): Promise<void>;
     goToTiltPercentage(request: WindowCovering.GoToTiltPercentageRequest): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
 }
 export declare namespace MatterbridgeWindowCoveringServer {
     class Internal extends WindowCoveringBaseServer.Internal {
-        liftMovementTimer?: NodeJS.Timeout;
-        tiltMovementTimer?: NodeJS.Timeout;
+        liftMovementTimer?: Timer;
+        liftMovementTarget: number;
+        tiltMovementTimer?: Timer;
+        tiltMovementTarget: number;
     }
     class State extends WindowCoveringBaseServer.State {
         movementDuration: number;

package/dist/behaviors/windowCoveringServer.js

@@ -1,3 +1,4 @@
+import { Millis, Time } from '@matter/general';
 import { WindowCoveringBaseServer, WindowCoveringServer } from '@matter/node/behaviors/window-covering';
 import { WindowCovering } from '@matter/types/clusters/window-covering';
 import { MatterbridgeServer } from './matterbridgeServer.js';
@@ -35,7 +36,7 @@ export class MatterbridgeWindowCoveringServer extends WindowCoveringServer.with(
         this.state.operationalStatus.global = lift === WindowCovering.MovementStatus.Stopped ? tilt : lift;
     }
     #startLiftMovement(targetPercent100ths) {
-        clearTimeout(this.internal.liftMovementTimer);
+        this.internal.liftMovementTimer?.stop();
         this.internal.liftMovementTimer = undefined;
         if (this.state.movementDuration <= 0)
             return;
@@ -44,19 +45,17 @@ export class MatterbridgeWindowCoveringServer extends WindowCoveringServer.with(
         this.#updateGlobalOperationalStatus();
         if (status === WindowCovering.MovementStatus.Stopped)
             return;
-        this.internal.liftMovementTimer = setTimeout(() => {
-            this.internal.liftMovementTimer = undefined;
-            void this.#completeLiftMovement(targetPercent100ths);
-        }, this.state.movementDuration);
-    }
-    #completeLiftMovement = async (targetPercent100ths) => {
-        const windowCovering = this.endpoint;
-        await windowCovering.setAttribute(WindowCovering, 'currentPositionLiftPercent100ths', targetPercent100ths);
-        const tilt = windowCovering.getAttribute(WindowCovering, 'operationalStatus')?.tilt ?? WindowCovering.MovementStatus.Stopped;
-        await windowCovering.setAttribute(WindowCovering, 'operationalStatus', { global: tilt, lift: WindowCovering.MovementStatus.Stopped, tilt });
-    };
+        this.internal.liftMovementTarget = targetPercent100ths;
+        this.internal.liftMovementTimer = Time.getTimer('WindowCovering lift movement complete', Millis(this.state.movementDuration), this.callback(this.#completeLiftMovement, { lock: true })).start();
+    }
+    #completeLiftMovement() {
+        this.internal.liftMovementTimer = undefined;
+        this.state.currentPositionLiftPercent100ths = this.internal.liftMovementTarget;
+        this.state.operationalStatus.lift = WindowCovering.MovementStatus.Stopped;
+        this.#updateGlobalOperationalStatus();
+    }
     #startTiltMovement(targetPercent100ths) {
-        clearTimeout(this.internal.tiltMovementTimer);
+        this.internal.tiltMovementTimer?.stop();
         this.internal.tiltMovementTimer = undefined;
         if (this.state.movementDuration <= 0)
             return;
@@ -65,17 +64,15 @@ export class MatterbridgeWindowCoveringServer extends WindowCoveringServer.with(
         this.#updateGlobalOperationalStatus();
         if (status === WindowCovering.MovementStatus.Stopped)
             return;
-        this.internal.tiltMovementTimer = setTimeout(() => {
-            this.internal.tiltMovementTimer = undefined;
-            void this.#completeTiltMovement(targetPercent100ths);
-        }, this.state.movementDuration);
-    }
-    #completeTiltMovement = async (targetPercent100ths) => {
-        const windowCovering = this.endpoint;
-        await windowCovering.setAttribute(WindowCovering, 'currentPositionTiltPercent100ths', targetPercent100ths);
-        const lift = windowCovering.getAttribute(WindowCovering, 'operationalStatus')?.lift ?? WindowCovering.MovementStatus.Stopped;
-        await windowCovering.setAttribute(WindowCovering, 'operationalStatus', { global: lift, lift, tilt: WindowCovering.MovementStatus.Stopped });
-    };
+        this.internal.tiltMovementTarget = targetPercent100ths;
+        this.internal.tiltMovementTimer = Time.getTimer('WindowCovering tilt movement complete', Millis(this.state.movementDuration), this.callback(this.#completeTiltMovement, { lock: true })).start();
+    }
+    #completeTiltMovement() {
+        this.internal.tiltMovementTimer = undefined;
+        this.state.currentPositionTiltPercent100ths = this.internal.tiltMovementTarget;
+        this.state.operationalStatus.tilt = WindowCovering.MovementStatus.Stopped;
+        this.#updateGlobalOperationalStatus();
+    }
     async upOrOpen() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`MatterbridgeWindowCoveringServer: opening cover (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
@@ -127,9 +124,9 @@ export class MatterbridgeWindowCoveringServer extends WindowCoveringServer.with(
         });
         device.log.debug(`MatterbridgeWindowCoveringServer: stopMotion called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.stopMotion();
-        clearTimeout(this.internal.liftMovementTimer);
+        this.internal.liftMovementTimer?.stop();
         this.internal.liftMovementTimer = undefined;
-        clearTimeout(this.internal.tiltMovementTimer);
+        this.internal.tiltMovementTimer?.stop();
         this.internal.tiltMovementTimer = undefined;
         if (this.state.movementDuration > 0) {
             if (this.features.positionAwareLift)
@@ -174,11 +171,20 @@ export class MatterbridgeWindowCoveringServer extends WindowCoveringServer.with(
             this.#startTiltMovement(this.state.targetPositionTiltPercent100ths);
         device.log.debug(`MatterbridgeWindowCoveringServer: goToTiltPercentage result target ${this.state.targetPositionTiltPercent100ths} current ${this.state.currentPositionTiltPercent100ths} status global ${this.getMovementStatusLabel(this.state.operationalStatus.global)} lift ${this.getMovementStatusLabel(this.state.operationalStatus.lift)} tilt ${this.getMovementStatusLabel(this.state.operationalStatus.tilt)} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
     }
+    async [Symbol.asyncDispose]() {
+        this.internal.liftMovementTimer?.stop();
+        this.internal.liftMovementTimer = undefined;
+        this.internal.tiltMovementTimer?.stop();
+        this.internal.tiltMovementTimer = undefined;
+        await super[Symbol.asyncDispose]?.();
+    }
 }
 (function (MatterbridgeWindowCoveringServer) {
     class Internal extends WindowCoveringBaseServer.Internal {
         liftMovementTimer;
+        liftMovementTarget = 0;
         tiltMovementTimer;
+        tiltMovementTarget = 0;
     }
     MatterbridgeWindowCoveringServer.Internal = Internal;
     class State extends WindowCoveringBaseServer.State {

package/dist/demoDevices.js

@@ -1,6 +1,6 @@
 import { readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
-import { ClosureCoveringTag, ClosurePanelTag, ClosureTag, ClosureWindowTag, CommodityTariffChronologyTag, CommodityTariffCommodityTag, CommodityTariffFlowTag, CommonNumberTag, CommonPositionTag, ElectricalMeasurementTag, PowerSourceTag, RefrigeratorTag, } from '@matter/node';
+import { ClosureCoveringTag, ClosurePanelTag, ClosureTag, ClosureWindowTag, CommodityTariffChronologyTag, CommodityTariffCommodityTag, CommodityTariffFlowTag, CommonNumberTag, CommonPositionTag, ElectricalMeasurementTag, PowerSourceTag, RefrigeratorTag, SwitchesTag, } from '@matter/node';
 import { AirQuality } from '@matter/types/clusters/air-quality';
 import { ClosureDimension } from '@matter/types/clusters/closure-dimension';
 import { DoorLock } from '@matter/types/clusters/door-lock';
@@ -267,8 +267,33 @@ export async function createDemoDevices(matterbridge) {
     ep = new MatterbridgeEndpoint([getSupportedDeviceType('PumpController'), bridgedNode, powerSource], { id: 'PumpController', number: EndpointNumber(6_05) });
     ep.createDefaultPowerSourceWiredClusterServer();
     await registerDevice(ep, 'Pump Controller', 'SWITCH-06-05');
-    ep = new MatterbridgeEndpoint([getSupportedDeviceType('GenericSwitch'), bridgedNode, powerSource], { id: 'GenericSwitch', number: EndpointNumber(6_06) });
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('Aggregator'), bridgedNode, powerSource], { id: 'GenericSwitch', number: EndpointNumber(6_06) });
     ep.createDefaultPowerSourceBatteryClusterServer();
+    await ep.addFixedLabel('composed', 'GenericSwitch');
+    ep.addChildDeviceType('Button1', getSupportedDeviceType('GenericSwitch'), {
+        number: EndpointNumber(6_06_1),
+        tagList: [getSemtag(SwitchesTag.On), getSemtag(CommonNumberTag.One)],
+    })
+        .createDefaultMomentarySwitchClusterServer()
+        .addRequiredClusters();
+    ep.addChildDeviceType('Button2', getSupportedDeviceType('GenericSwitch'), {
+        number: EndpointNumber(6_06_2),
+        tagList: [getSemtag(SwitchesTag.Off), getSemtag(CommonNumberTag.Two)],
+    })
+        .createDefaultMomentarySwitchClusterServer()
+        .addRequiredClusters();
+    ep.addChildDeviceType('Button3', getSupportedDeviceType('GenericSwitch'), {
+        number: EndpointNumber(6_06_3),
+        tagList: [getSemtag(SwitchesTag.Up), getSemtag(CommonNumberTag.Three)],
+    })
+        .createDefaultMomentarySwitchClusterServer()
+        .addRequiredClusters();
+    ep.addChildDeviceType('Button4', getSupportedDeviceType('GenericSwitch'), {
+        number: EndpointNumber(6_06_4),
+        tagList: [getSemtag(SwitchesTag.Down), getSemtag(CommonNumberTag.Four)],
+    })
+        .createDefaultMomentarySwitchClusterServer()
+        .addRequiredClusters();
     await registerDevice(ep, 'Generic Switch', 'SWITCH-06-06');
     ep = new MatterbridgeEndpoint([getSupportedDeviceType('ContactSensor'), bridgedNode, powerSource], { id: 'ContactSensor', number: EndpointNumber(7_01) });
     ep.createDefaultPowerSourceBatteryClusterServer();

package/dist/devices/closure.d.ts

@@ -1,4 +1,4 @@
-import type { MaybePromise } from '@matter/general';
+import { type MaybePromise, type Timer } from '@matter/general';
 import { ClosureControlServer } from '@matter/node/behaviors/closure-control';
 import { type EndpointNumber } from '@matter/types';
 import { ClosureControl } from '@matter/types/clusters/closure-control';
@@ -18,24 +18,28 @@ declare const MatterbridgeClosureControlServerBase: import("@matter/node").Clust
     ventilation: false;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "closureControl">;
 export declare class MatterbridgeClosureControlServer extends MatterbridgeClosureControlServerBase {
+    #private;
     readonly state: MatterbridgeClosureControlServer.State;
     protected internal: MatterbridgeClosureControlServer.Internal;
     initialize(): MaybePromise;
     moveTo: (request: ClosureControl.MoveToRequest) => Promise<void>;
-    private completeMoveTo;
     stop: () => Promise<void>;
     calibrate: () => Promise<void>;
-    private completeCalibrate;
+    [Symbol.asyncDispose](): Promise<void>;
 }
 export declare namespace MatterbridgeClosureControlServer {
     class Internal extends MatterbridgeClosureControlServerBase.Internal {
-        movementTimer?: NodeJS.Timeout;
-        calibrateTimer?: NodeJS.Timeout;
+        movementTimer?: Timer;
+        movementTargetState: ClosureControl.OverallTargetState;
+        movementPreviousState: ClosureControl.OverallCurrentState;
+        calibrateTimer?: Timer;
     }
     class State extends MatterbridgeClosureControlServerBase.State {
         movementDuration: number;
         calibrationDuration: number;
         signaturePosition: number;
+        ventilationPosition: number;
+        pedestrianPosition: number;
     }
 }
 export interface ClosureOptions {
@@ -51,6 +55,8 @@ export interface ClosureOptions {
     movementDuration?: number;
     calibrationDuration?: number;
     signaturePosition?: number;
+    ventilationPosition?: number;
+    pedestrianPosition?: number;
     motionLatching?: boolean;
     speed?: boolean;
     ventilation?: boolean;
@@ -64,10 +70,17 @@ export declare class Closure extends MatterbridgeEndpoint {
     constructor(name: string, serial: string, options?: ClosureOptions);
     getMainState(): ClosureControl.MainState | undefined;
     getSignaturePosition(): number | undefined;
+    getVentilationPosition(): number | undefined;
+    getPedestrianPosition(): number | undefined;
     setState(currentState: ClosureControl.OverallCurrentState, targetState: ClosureControl.OverallTargetState, mainState?: ClosureControl.MainState, countdownTime?: number, currentErrorList?: ClosureControl.ClosureError[]): Promise<void>;
     setFullyClosed(): Promise<void>;
     setFullOpened(): Promise<void>;
     setPartiallyOpened(): Promise<void>;
+    setOpenedAtSignature(): Promise<void>;
+    setOpenedForVentilation(): Promise<void>;
+    setOpenedForPedestrian(): Promise<void>;
+    targetPositionToCurrentPosition(position: ClosureControl.TargetPosition): ClosureControl.CurrentPosition;
+    targetPositionToTargetPercent(position: ClosureControl.TargetPosition): number;
     triggerOperationalError(errorState?: ClosureControl.ClosureError[]): Promise<void>;
     triggerMovementCompleted(): Promise<void>;
     triggerSecureStateChanged(secureValue: boolean): Promise<void>;

package/dist/devices/closure.js

@@ -1,3 +1,4 @@
+import { Millis, Time } from '@matter/general';
 import { ClosureTag } from '@matter/node';
 import { ClosureControlServer } from '@matter/node/behaviors/closure-control';
 import { StatusResponse } from '@matter/types';
@@ -73,25 +74,24 @@ export class MatterbridgeClosureControlServer extends MatterbridgeClosureControl
             (!this.features.motionLatching || nextTarget.latch === undefined || nextTarget.latch === currentState.latch) &&
             (!this.features.speed || nextTarget.speed === currentState.speed);
         this.state.mainState = isAtTarget ? ClosureControl.MainState.Stopped : ClosureControl.MainState.Moving;
-        clearTimeout(this.internal.movementTimer);
+        this.internal.movementTimer?.stop();
+        this.internal.movementTimer = undefined;
         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);
+            this.internal.movementTargetState = nextTarget;
+            this.internal.movementPreviousState = currentState;
+            this.internal.movementTimer = Time.getTimer('ClosureControl movement complete', Millis(this.state.movementDuration), this.callback(this.#completeMoveTo, { lock: true })).start();
         }
     };
-    completeMoveTo = async (targetState, previousState) => {
-        const closure = this.endpoint;
+    #completeMoveTo() {
+        this.internal.movementTimer = undefined;
+        const targetState = this.internal.movementTargetState;
+        const previousState = this.internal.movementPreviousState;
         let position = previousState.position;
         if (targetState.position !== undefined && targetState.position !== null) {
             const mappedPosition = targetToCurrentPosition[targetState.position];
@@ -100,17 +100,25 @@ export class MatterbridgeClosureControlServer extends MatterbridgeClosureControl
         }
         const latch = targetState.latch ?? previousState.latch;
         const secureState = this.features.motionLatching ? latch === true : position === ClosureControl.CurrentPosition.FullyClosed;
-        await closure.setState({
+        this.state.countdownTime = 0;
+        this.state.mainState = ClosureControl.MainState.Stopped;
+        this.state.currentErrorList = [];
+        this.state.overallCurrentState = {
             position,
             ...(this.features.motionLatching ? { latch } : null),
             ...(this.features.speed ? { speed: targetState.speed } : null),
             secureState,
-        }, targetState, ClosureControl.MainState.Stopped, 0);
+        };
+        this.state.overallTargetState = {
+            position: targetState.position,
+            ...(this.features.motionLatching ? { latch: targetState.latch } : null),
+            ...(this.features.speed ? { speed: targetState.speed } : null),
+        };
         if (secureState !== previousState.secureState) {
-            await closure.triggerSecureStateChanged(secureState);
+            this.events.secureStateChanged.emit({ secureValue: secureState }, this.context);
         }
-        await closure.triggerMovementCompleted();
-    };
+        this.events.movementCompleted.emit(undefined, this.context);
+    }
     stop = async () => {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`Stop (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
@@ -121,9 +129,9 @@ export class MatterbridgeClosureControlServer extends MatterbridgeClosureControl
             attributes: this.state,
             endpoint: this.endpoint,
         });
-        clearTimeout(this.internal.movementTimer);
+        this.internal.movementTimer?.stop();
         this.internal.movementTimer = undefined;
-        clearTimeout(this.internal.calibrateTimer);
+        this.internal.calibrateTimer?.stop();
         this.internal.calibrateTimer = undefined;
         if ([ClosureControl.MainState.Moving, ClosureControl.MainState.WaitingForMotion, ClosureControl.MainState.Calibrating].includes(this.state.mainState)) {
             this.state.mainState = ClosureControl.MainState.Stopped;
@@ -147,27 +155,33 @@ export class MatterbridgeClosureControlServer extends MatterbridgeClosureControl
             throw new StatusResponse.InvalidInStateError('ClosureControl.calibrate is only allowed while Stopped or SetupRequired');
         }
         this.state.mainState = ClosureControl.MainState.Calibrating;
-        clearTimeout(this.internal.calibrateTimer);
+        this.internal.calibrateTimer?.stop();
         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);
+            this.internal.calibrateTimer = Time.getTimer('ClosureControl calibrate complete', Millis(this.state.calibrationDuration), this.callback(this.#completeCalibrate, { lock: true })).start();
         }
     };
-    completeCalibrate = async () => {
-        const closure = this.endpoint;
-        await closure.setAttribute(ClosureControl, 'countdownTime', 0);
-        await closure.setAttribute(ClosureControl, 'mainState', ClosureControl.MainState.Stopped);
-    };
+    #completeCalibrate() {
+        this.internal.calibrateTimer = undefined;
+        this.state.countdownTime = 0;
+        this.state.mainState = ClosureControl.MainState.Stopped;
+    }
+    async [Symbol.asyncDispose]() {
+        this.internal.movementTimer?.stop();
+        this.internal.movementTimer = undefined;
+        this.internal.calibrateTimer?.stop();
+        this.internal.calibrateTimer = undefined;
+        await super[Symbol.asyncDispose]?.();
+    }
 }
 (function (MatterbridgeClosureControlServer) {
     class Internal extends MatterbridgeClosureControlServerBase.Internal {
         movementTimer;
+        movementTargetState = {};
+        movementPreviousState = { position: ClosureControl.CurrentPosition.FullyClosed, secureState: true };
         calibrateTimer;
     }
     MatterbridgeClosureControlServer.Internal = Internal;
@@ -175,12 +189,14 @@ export class MatterbridgeClosureControlServer extends MatterbridgeClosureControl
         movementDuration = 0;
         calibrationDuration = 0;
         signaturePosition = 50_00;
+        ventilationPosition = 50_00;
+        pedestrianPosition = 50_00;
     }
     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, overallTargetState, latchControlModes, movementDuration = 0, calibrationDuration = 0, signaturePosition = 50_00, motionLatching = false, speed = false, ventilation = false, pedestrian = false, calibration = false, id, number, tagList = [getSemtag(ClosureTag.Covering)], } = options;
+        const { identifyTime = 0, identifyType = Identify.IdentifyType.None, powerSourceType = 'Wired', countdownTime = 0, mainState = ClosureControl.MainState.Stopped, currentErrorList = [], overallCurrentState, overallTargetState, latchControlModes, movementDuration = 0, calibrationDuration = 0, signaturePosition = 50_00, ventilationPosition = 50_00, pedestrianPosition = 50_00, motionLatching = false, speed = false, 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,
@@ -223,6 +239,8 @@ export class Closure extends MatterbridgeEndpoint {
             movementDuration,
             calibrationDuration,
             signaturePosition,
+            ventilationPosition,
+            pedestrianPosition,
         };
         this.behaviors.require(MatterbridgeClosureControlServer.with(ClosureControl.Feature.Positioning, ...(motionLatching ? [ClosureControl.Feature.MotionLatching] : []), ...(speed ? [ClosureControl.Feature.Speed] : []), ...(calibration ? [ClosureControl.Feature.Calibration] : []), ...(ventilation ? [ClosureControl.Feature.Ventilation] : []), ...(pedestrian ? [ClosureControl.Feature.Pedestrian] : [])), closureControlOptions);
     }
@@ -232,23 +250,31 @@ export class Closure extends MatterbridgeEndpoint {
     getSignaturePosition() {
         return this.getAttribute(MatterbridgeClosureControlServer, 'signaturePosition');
     }
+    getVentilationPosition() {
+        return this.getAttribute(MatterbridgeClosureControlServer, 'ventilationPosition');
+    }
+    getPedestrianPosition() {
+        return this.getAttribute(MatterbridgeClosureControlServer, 'pedestrianPosition');
+    }
     async setState(currentState, targetState, mainState = ClosureControl.MainState.Stopped, countdownTime = 0, currentErrorList = []) {
-        const featureMap = this.getAttribute(ClosureControl.id, 'featureMap');
-        const supportsMotionLatching = featureMap?.motionLatching === true;
-        const supportsSpeed = featureMap?.speed === true;
+        const features = this.featuresOf(MatterbridgeClosureControlServer.id);
+        const supportsCurrentPosition = (currentState.position !== ClosureControl.CurrentPosition.OpenedForVentilation || features.ventilation) &&
+            (currentState.position !== ClosureControl.CurrentPosition.OpenedForPedestrian || features.pedestrian);
+        const supportsTargetPosition = (targetState.position !== ClosureControl.TargetPosition.MoveToVentilationPosition || features.ventilation) &&
+            (targetState.position !== ClosureControl.TargetPosition.MoveToPedestrianPosition || features.pedestrian);
         await this.setAttribute(ClosureControl, 'countdownTime', countdownTime);
         await this.setAttribute(ClosureControl, 'mainState', mainState);
         await this.setAttribute(ClosureControl, 'currentErrorList', currentErrorList);
         await this.setAttribute(ClosureControl, 'overallCurrentState', {
-            position: currentState.position,
-            ...(supportsMotionLatching ? { latch: currentState.latch } : null),
-            ...(supportsSpeed ? { speed: currentState.speed } : null),
+            ...(supportsCurrentPosition ? { position: currentState.position } : null),
+            ...(features.motionLatching ? { latch: currentState.latch } : null),
+            ...(features.speed ? { speed: currentState.speed } : null),
             secureState: currentState.secureState,
         });
         await this.setAttribute(ClosureControl, 'overallTargetState', {
-            position: targetState.position,
-            ...(supportsMotionLatching ? { latch: targetState.latch } : null),
-            ...(supportsSpeed ? { speed: targetState.speed } : null),
+            ...(supportsTargetPosition ? { position: targetState.position } : null),
+            ...(features.motionLatching ? { latch: targetState.latch } : null),
+            ...(features.speed ? { speed: targetState.speed } : null),
         });
     }
     async setFullyClosed() {
@@ -287,6 +313,64 @@ export class Closure extends MatterbridgeEndpoint {
             speed: ThreeLevelAuto.Auto,
         });
     }
+    async setOpenedAtSignature() {
+        await this.setState({
+            position: ClosureControl.CurrentPosition.OpenedAtSignature,
+            latch: false,
+            speed: ThreeLevelAuto.Auto,
+            secureState: false,
+        }, {
+            position: ClosureControl.TargetPosition.MoveToSignaturePosition,
+            latch: false,
+            speed: ThreeLevelAuto.Auto,
+        });
+    }
+    async setOpenedForVentilation() {
+        await this.setState({
+            position: ClosureControl.CurrentPosition.OpenedForVentilation,
+            latch: false,
+            speed: ThreeLevelAuto.Auto,
+            secureState: false,
+        }, {
+            position: ClosureControl.TargetPosition.MoveToVentilationPosition,
+            latch: false,
+            speed: ThreeLevelAuto.Auto,
+        });
+    }
+    async setOpenedForPedestrian() {
+        await this.setState({
+            position: ClosureControl.CurrentPosition.OpenedForPedestrian,
+            latch: false,
+            speed: ThreeLevelAuto.Auto,
+            secureState: false,
+        }, {
+            position: ClosureControl.TargetPosition.MoveToPedestrianPosition,
+            latch: false,
+            speed: ThreeLevelAuto.Auto,
+        });
+    }
+    targetPositionToCurrentPosition(position) {
+        if (position === ClosureControl.TargetPosition.MoveToFullyClosed)
+            return ClosureControl.CurrentPosition.FullyClosed;
+        if (position === ClosureControl.TargetPosition.MoveToFullyOpen)
+            return ClosureControl.CurrentPosition.FullyOpened;
+        if (position === ClosureControl.TargetPosition.MoveToPedestrianPosition)
+            return ClosureControl.CurrentPosition.OpenedForPedestrian;
+        if (position === ClosureControl.TargetPosition.MoveToVentilationPosition)
+            return ClosureControl.CurrentPosition.OpenedForVentilation;
+        return ClosureControl.CurrentPosition.OpenedAtSignature;
+    }
+    targetPositionToTargetPercent(position) {
+        if (position === ClosureControl.TargetPosition.MoveToFullyOpen)
+            return 0;
+        if (position === ClosureControl.TargetPosition.MoveToFullyClosed)
+            return 100_00;
+        if (position === ClosureControl.TargetPosition.MoveToPedestrianPosition)
+            return this.getPedestrianPosition() ?? 50_00;
+        if (position === ClosureControl.TargetPosition.MoveToVentilationPosition)
+            return this.getVentilationPosition() ?? 50_00;
+        return this.getSignaturePosition() ?? 50_00;
+    }
     async triggerOperationalError(errorState = []) {
         await this.setAttribute(ClosureControl, 'mainState', ClosureControl.MainState.Error);
         await this.setAttribute(ClosureControl, 'currentErrorList', errorState);

package/dist/devices/closurePanel.d.ts

@@ -1,4 +1,4 @@
-import type { MaybePromise } from '@matter/general';
+import { type MaybePromise, type Timer } from '@matter/general';
 import { ClosureDimensionServer } from '@matter/node/behaviors/closure-dimension';
 import { ClosureDimension } from '@matter/types/clusters/closure-dimension';
 import type { EndpointNumber } from '@matter/types/datatype';
@@ -15,17 +15,19 @@ declare const MatterbridgeClosureDimensionServerBase: import("@matter/node").Clu
     unit: false;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "closureDimension">;
 export declare class MatterbridgeClosureDimensionServer extends MatterbridgeClosureDimensionServerBase {
+    #private;
     readonly state: MatterbridgeClosureDimensionServer.State;
     protected internal: MatterbridgeClosureDimensionServer.Internal;
     initialize(): MaybePromise;
     setTarget: (request: ClosureDimension.SetTargetRequest) => Promise<void>;
     step: (request: ClosureDimension.StepRequest) => Promise<void>;
-    private scheduleMovement;
-    private completeMovement;
+    [Symbol.asyncDispose](): Promise<void>;
 }
 export declare namespace MatterbridgeClosureDimensionServer {
     class Internal extends MatterbridgeClosureDimensionServerBase.Internal {
-        movementTimer?: NodeJS.Timeout;
+        movementTimer?: Timer;
+        movementTargetState: ClosureDimension.DimensionState;
+        movementPreviousState: ClosureDimension.DimensionState;
     }
     class State extends MatterbridgeClosureDimensionServerBase.State {
         movementDuration: number;

package/dist/devices/closurePanel.js

@@ -1,3 +1,4 @@
+import { Millis, Time } from '@matter/general';
 import { ClosureControlServer } from '@matter/node/behaviors/closure-control';
 import { ClosureDimensionServer } from '@matter/node/behaviors/closure-dimension';
 import { StatusResponse } from '@matter/types';
@@ -71,7 +72,7 @@ export class MatterbridgeClosureDimensionServer extends MatterbridgeClosureDimen
         if (matchesCurrentState)
             return;
         this.state.targetState = nextTarget;
-        this.scheduleMovement(nextTarget, currentState);
+        this.#scheduleMovement(nextTarget, currentState);
     };
     step = async (request) => {
         const device = this.endpoint.stateOf(MatterbridgeServer);
@@ -121,35 +122,41 @@ export class MatterbridgeClosureDimensionServer extends MatterbridgeClosureDimen
             ...(this.features.speed && request.speed !== undefined ? { speed: request.speed } : null),
         };
         this.state.targetState = nextTarget;
-        this.scheduleMovement(nextTarget, currentState);
+        this.#scheduleMovement(nextTarget, currentState);
     };
-    scheduleMovement(targetState, currentState) {
-        clearTimeout(this.internal.movementTimer);
-        if (currentState === null || this.state.movementDuration <= 0) {
-            this.internal.movementTimer = undefined;
+    #scheduleMovement(targetState, currentState) {
+        this.internal.movementTimer?.stop();
+        this.internal.movementTimer = undefined;
+        if (currentState === null || this.state.movementDuration <= 0)
             return;
-        }
-        const previousState = currentState;
-        this.internal.movementTimer = setTimeout(() => {
-            this.internal.movementTimer = undefined;
-            void this.completeMovement(targetState, previousState);
-        }, this.state.movementDuration);
+        this.internal.movementTargetState = targetState;
+        this.internal.movementPreviousState = currentState;
+        this.internal.movementTimer = Time.getTimer('ClosureDimension movement complete', Millis(this.state.movementDuration), this.callback(this.#completeMovement, { lock: true })).start();
     }
-    completeMovement = async (targetState, previousState) => {
-        const endpoint = this.endpoint;
+    #completeMovement() {
+        this.internal.movementTimer = undefined;
+        const targetState = this.internal.movementTargetState;
+        const previousState = this.internal.movementPreviousState;
         const position = targetState.position ?? previousState.position;
         const latch = targetState.latch ?? previousState.latch;
         const speed = targetState.speed ?? previousState.speed;
-        await endpoint.setAttribute(ClosureDimensionServer, 'currentState', {
+        this.state.currentState = {
             position,
             ...(this.features.motionLatching ? { latch } : null),
             ...(this.features.speed ? { speed } : null),
-        });
-    };
+        };
+    }
+    async [Symbol.asyncDispose]() {
+        this.internal.movementTimer?.stop();
+        this.internal.movementTimer = undefined;
+        await super[Symbol.asyncDispose]?.();
+    }
 }
 (function (MatterbridgeClosureDimensionServer) {
     class Internal extends MatterbridgeClosureDimensionServerBase.Internal {
         movementTimer;
+        movementTargetState = {};
+        movementPreviousState = {};
     }
     MatterbridgeClosureDimensionServer.Internal = Internal;
     class State extends MatterbridgeClosureDimensionServerBase.State {

package/dist/devices/electricalUtilityMeter.d.ts

@@ -62,6 +62,21 @@ export interface ElectricalEnergyTariffOptions {
     currentPrice?: CommodityPrice.CommodityPriceStruct | null;
     localGenerationAvailable?: boolean | null;
     currentConditions?: ElectricalGridConditions.ElectricalGridConditionsStruct | null;
+    startDate?: number | null;
+    dayEntries?: CommodityTariff.DayEntry[] | null;
+    dayPatterns?: CommodityTariff.DayPattern[] | null;
+    calendarPeriods?: CommodityTariff.CalendarPeriod[] | null;
+    individualDays?: CommodityTariff.Day[] | null;
+    currentDay?: CommodityTariff.Day | null;
+    nextDay?: CommodityTariff.Day | null;
+    currentDayEntry?: CommodityTariff.DayEntry | null;
+    currentDayEntryDate?: number | null;
+    nextDayEntry?: CommodityTariff.DayEntry | null;
+    nextDayEntryDate?: number | null;
+    tariffComponents?: CommodityTariff.TariffComponent[] | null;
+    tariffPeriods?: CommodityTariff.TariffPeriod[] | null;
+    currentTariffComponents?: CommodityTariff.TariffComponent[] | null;
+    nextTariffComponents?: CommodityTariff.TariffComponent[] | null;
     tagList?: Semtag[];
 }
 export declare class ElectricalUtilityMeter extends MatterbridgeEndpoint {

package/dist/devices/electricalUtilityMeter.js

@@ -106,7 +106,7 @@ export class ElectricalUtilityMeter extends MatterbridgeEndpoint {
         return tariff;
     }
     configureElectricalEnergyTariffClusters(endpoint, options) {
-        const { tariffLabel = null, providerName = null, tariffUnit = TariffUnit.KWh, currency = null, currentPrice = null, localGenerationAvailable = null, currentConditions = null, } = options;
+        const { tariffLabel = null, providerName = null, tariffUnit = TariffUnit.KWh, currency = null, currentPrice = null, localGenerationAvailable = null, currentConditions = null, startDate = null, dayEntries = null, dayPatterns = null, calendarPeriods = null, individualDays = null, currentDay = null, nextDay = null, currentDayEntry = null, currentDayEntryDate = null, nextDayEntry = null, nextDayEntryDate = null, tariffComponents = null, tariffPeriods = null, currentTariffComponents = null, nextTariffComponents = null, } = options;
         endpoint.behaviors.require(MatterbridgeCommodityPriceServer, {
             tariffUnit,
             currency,
@@ -125,21 +125,21 @@ export class ElectricalUtilityMeter extends MatterbridgeEndpoint {
         endpoint.behaviors.require(MatterbridgeCommodityTariffServer, {
             tariffInfo,
             tariffUnit: tariffInfo === null ? null : tariffUnit,
-            startDate: null,
-            dayEntries: null,
-            dayPatterns: null,
-            calendarPeriods: null,
-            individualDays: null,
-            tariffComponents: null,
-            tariffPeriods: null,
-            currentDay: null,
-            nextDay: null,
-            currentDayEntry: null,
-            currentDayEntryDate: null,
-            nextDayEntry: null,
-            nextDayEntryDate: null,
-            currentTariffComponents: null,
-            nextTariffComponents: null,
+            startDate: tariffInfo === null ? null : startDate,
+            dayEntries: tariffInfo === null ? null : dayEntries,
+            dayPatterns: tariffInfo === null ? null : dayPatterns,
+            calendarPeriods: tariffInfo === null ? null : calendarPeriods,
+            individualDays: tariffInfo === null ? null : individualDays,
+            tariffComponents: tariffInfo === null ? null : tariffComponents,
+            tariffPeriods: tariffInfo === null ? null : tariffPeriods,
+            currentDay: tariffInfo === null ? null : currentDay,
+            nextDay: tariffInfo === null ? null : nextDay,
+            currentDayEntry: tariffInfo === null ? null : currentDayEntry,
+            currentDayEntryDate: tariffInfo === null ? null : currentDayEntryDate,
+            nextDayEntry: tariffInfo === null ? null : nextDayEntry,
+            nextDayEntryDate: tariffInfo === null ? null : nextDayEntryDate,
+            currentTariffComponents: tariffInfo === null ? null : currentTariffComponents,
+            nextTariffComponents: tariffInfo === null ? null : nextTariffComponents,
         });
         endpoint.behaviors.require(ElectricalGridConditionsServer, { localGenerationAvailable, currentConditions });
     }

package/dist/matterbridgeEndpointHelpers.js

@@ -208,7 +208,7 @@ export function featuresFor(endpoint, cluster) {
     const supportedBehavior = endpoint.behaviors.supported[lowercaseFirstLetter(behaviorId)];
     if (!supportedBehavior || !ClusterBehavior.isType(supportedBehavior))
         return {};
-    return supportedBehavior.features ?? {};
+    return supportedBehavior.features;
 }
 export async function internalFor(endpoint, cluster) {
     const behaviorId = getBehavior(endpoint, cluster)?.id;

package/dist/matterbridgeFactory.d.ts

@@ -9,4 +9,5 @@ export declare function snakeCase(name: string): string;
 export declare function pascalCase(name: string): string;
 export declare function camelCase(name: string): string;
 export declare function getServerBehaviorFromClusterId(clusterId: ClusterId, features?: Record<string, boolean> | string[]): Promise<Behavior.Type | undefined>;
+export declare function getClientBehaviorFromClusterId(clusterId: ClusterId): Promise<Behavior.Type | undefined>;
 export declare function createClusterServer(endpoint: MatterbridgeEndpoint, clusterId: ClusterId, options?: CreateClusterServerOptions): Promise<MatterbridgeEndpoint>;

package/dist/matterbridgeFactory.js

@@ -1,4 +1,4 @@
-import { ClusterBehavior } from '@matter/node';
+import { ClusterBehavior, isClientBehavior } from '@matter/node';
 import { getClusterNameById } from '@matter/types/cluster';
 import { logModuleLoaded } from '@matterbridge/utils/loader';
 import { db, hk } from 'node-ansi-logger';
@@ -44,7 +44,7 @@ export async function getServerBehaviorFromClusterId(clusterId, features) {
         return undefined;
     }
     const base = mod[`${name}Server`];
-    if (!base || !ClusterBehavior.isType(base))
+    if (!base || !ClusterBehavior.isType(base) || isClientBehavior(base))
         return undefined;
     const featureNames = (Array.isArray(features)
         ? features
@@ -53,6 +53,22 @@ export async function getServerBehaviorFromClusterId(clusterId, features) {
             .map(([key]) => key)).map((key) => pascalCase(key));
     return featureNames.length > 0 ? base.with(...featureNames) : base;
 }
+export async function getClientBehaviorFromClusterId(clusterId) {
+    const name = getClusterNameById(clusterId);
+    if (name.includes('Unknown cluster'))
+        return undefined;
+    let mod;
+    try {
+        mod = (await import(`@matter/node/behaviors/${snakeCase(name)}`));
+    }
+    catch {
+        return undefined;
+    }
+    const base = mod[`${name}Client`];
+    if (!base || !ClusterBehavior.isType(base) || !isClientBehavior(base))
+        return undefined;
+    return base;
+}
 export async function createClusterServer(endpoint, clusterId, options) {
     const type = await getServerBehaviorFromClusterId(clusterId, options?.features);
     if (!type) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.10.8-dev-20260901-c4963a1",
+  "version": "3.10.8-dev-20260902-361500d",
   "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.8-dev-20260901-c4963a1",
-    "@matterbridge/thread": "3.10.8-dev-20260901-c4963a1",
-    "@matterbridge/types": "3.10.8-dev-20260901-c4963a1",
-    "@matterbridge/utils": "3.10.8-dev-20260901-c4963a1",
+    "@matterbridge/dgram": "3.10.8-dev-20260902-361500d",
+    "@matterbridge/thread": "3.10.8-dev-20260902-361500d",
+    "@matterbridge/types": "3.10.8-dev-20260902-361500d",
+    "@matterbridge/utils": "3.10.8-dev-20260902-361500d",
     "escape-html": "1.0.3",
     "express": "5.2.1",
     "express-rate-limit": "8.7.0",