@matterbridge/core 3.10.8-dev-20260829-e779e7d → 3.10.8-dev-20260831-3e81235

package/dist/demoDevices.js

@@ -1,7 +1,8 @@
 import { readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
-import { 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, } 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';
 import { FanControl } from '@matter/types/clusters/fan-control';
 import { PowerSource } from '@matter/types/clusters/power-source';
@@ -354,13 +355,19 @@ export async function createDemoDevices(matterbridge) {
     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), movementDuration: 2000, calibrationDuration: 2000 });
+    ep = new Closure('Closure', 'ENTRY-08-05', {
+        id: 'Closure',
+        number: EndpointNumber(8_05),
+        movementDuration: 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,
+        motionLatching: true,
+        speed: true,
         pedestrian: true,
         tagList: [getSemtag(ClosureTag.Gate)],
     });
@@ -370,6 +377,8 @@ export async function createDemoDevices(matterbridge) {
         number: EndpointNumber(8_05_2),
         movementDuration: 2000,
         calibrationDuration: 2000,
+        motionLatching: true,
+        speed: true,
         ventilation: true,
         tagList: [getSemtag(ClosureTag.Window), getSemtag(ClosureWindowTag.Facade)],
     });
@@ -379,6 +388,8 @@ export async function createDemoDevices(matterbridge) {
         number: EndpointNumber(8_05_3),
         movementDuration: 2000,
         calibrationDuration: 2000,
+        motionLatching: true,
+        speed: true,
         calibration: true,
         tagList: [getSemtag(ClosureTag.GarageDoor)],
     });
@@ -388,12 +399,48 @@ export async function createDemoDevices(matterbridge) {
         number: EndpointNumber(8_05_4),
         movementDuration: 2000,
         calibrationDuration: 2000,
+        motionLatching: true,
+        speed: true,
         ventilation: true,
         pedestrian: true,
         calibration: true,
         tagList: [getSemtag(ClosureTag.Door)],
     });
     await registerDevice(ep, 'Closure Complete', 'ENTRY-08-05-4');
+    const closurePanelRoller = new Closure('Closure Panel Roller', 'ENTRY-08-06-1', {
+        id: 'ClosurePanelRoller',
+        number: EndpointNumber(8_06_1),
+        movementDuration: 2000,
+        signaturePosition: 50_00,
+        tagList: [getSemtag(ClosureTag.Covering)],
+    });
+    closurePanelRoller.addPanel('Roller', [getSemtag(ClosurePanelTag.Lift)], 'lift', { number: EndpointNumber(8_06_2), movementDuration: 2000 });
+    ep = closurePanelRoller;
+    await registerDevice(ep, 'Closure Panel Roller', 'ENTRY-08-06-1');
+    const closurePanelVenetian = new Closure('Closure Panel Venetian', 'ENTRY-08-06-3', {
+        id: 'ClosurePanelVenetian',
+        number: EndpointNumber(8_06_3),
+        movementDuration: 2000,
+        signaturePosition: 20_00,
+        tagList: [getSemtag(ClosureTag.Covering), getSemtag(ClosureCoveringTag.Venetian)],
+    });
+    closurePanelVenetian.addPanel('Venetian', [getSemtag(ClosurePanelTag.Tilt)], 'tilt', { number: EndpointNumber(8_06_4), movementDuration: 2000 });
+    ep = closurePanelVenetian;
+    await registerDevice(ep, 'Closure Panel Venetian', 'ENTRY-08-06-3');
+    const closurePanelSmartGlass = new Closure('Closure Panel Smart-Glass', 'ENTRY-08-06-5', {
+        id: 'ClosurePanelSmartGlass',
+        number: EndpointNumber(8_06_5),
+        movementDuration: 2000,
+        signaturePosition: 10_00,
+        tagList: [getSemtag(ClosureTag.Window)],
+    });
+    closurePanelSmartGlass.addPanel('Smart-Glass', [getSemtag(ClosurePanelTag.Lift, 'Opacity')], 'modulation', {
+        number: EndpointNumber(8_06_6),
+        modulationType: ClosureDimension.ModulationType.Opacity,
+        movementDuration: 2000,
+    });
+    ep = closurePanelSmartGlass;
+    await registerDevice(ep, 'Closure Panel Smart-Glass', 'ENTRY-08-06-5');
     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

@@ -1,3 +1,4 @@
+import type { MaybePromise } 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';
@@ -19,6 +20,7 @@ declare const MatterbridgeClosureControlServerBase: import("@matter/node").Clust
 export declare class MatterbridgeClosureControlServer extends MatterbridgeClosureControlServerBase {
     readonly state: MatterbridgeClosureControlServer.State;
     protected internal: MatterbridgeClosureControlServer.Internal;
+    initialize(): MaybePromise;
     moveTo: (request: ClosureControl.MoveToRequest) => Promise<void>;
     private completeMoveTo;
     stop: () => Promise<void>;
@@ -33,6 +35,7 @@ export declare namespace MatterbridgeClosureControlServer {
     class State extends MatterbridgeClosureControlServerBase.State {
         movementDuration: number;
         calibrationDuration: number;
+        signaturePosition: number;
     }
 }
 export interface ClosureOptions {
@@ -47,6 +50,9 @@ export interface ClosureOptions {
     latchControlModes?: ClosureControl.LatchControlModes;
     movementDuration?: number;
     calibrationDuration?: number;
+    signaturePosition?: number;
+    motionLatching?: boolean;
+    speed?: boolean;
     ventilation?: boolean;
     pedestrian?: boolean;
     calibration?: boolean;
@@ -57,6 +63,7 @@ export interface ClosureOptions {
 export declare class Closure extends MatterbridgeEndpoint {
     constructor(name: string, serial: string, options?: ClosureOptions);
     getMainState(): ClosureControl.MainState | undefined;
+    getSignaturePosition(): 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>;

package/dist/devices/closure.js

@@ -18,6 +18,13 @@ const targetToCurrentPosition = {
 };
 const MatterbridgeClosureControlServerBase = ClosureControlServer.with(ClosureControl.Feature.Positioning, ClosureControl.Feature.MotionLatching, ClosureControl.Feature.Speed, ClosureControl.Feature.Calibration);
 export class MatterbridgeClosureControlServer extends MatterbridgeClosureControlServerBase {
+    initialize() {
+        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+            this.state.movementDuration = 2000;
+            this.state.calibrationDuration = 2000;
+        }
+        return super.initialize();
+    }
     moveTo = async (request) => {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`MoveTo (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
@@ -31,38 +38,40 @@ export class MatterbridgeClosureControlServer extends MatterbridgeClosureControl
         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') {
+        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');
+        }
+        if (request.position === undefined && (!this.features.motionLatching || request.latch === undefined) && (!this.features.speed || request.speed === undefined))
+            return;
+        if (this.features.motionLatching && 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)) {
+        if (this.features.speed && 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');
-        }
         if (![ClosureControl.MainState.Moving, ClosureControl.MainState.WaitingForMotion, ClosureControl.MainState.Stopped].includes(this.state.mainState)) {
             throw new StatusResponse.InvalidInStateError('ClosureControl.moveTo is only allowed while Moving, WaitingForMotion, or Stopped');
         }
         let currentState = this.state.overallCurrentState;
-        if (currentState?.latch === true && request.position !== undefined && request.latch !== false) {
+        if (this.features.motionLatching && currentState?.latch === true && request.position !== undefined && request.latch !== false) {
             throw new StatusResponse.InvalidInStateError('ClosureControl.moveTo position changes require latch false while the closure is latched');
         }
         const previousTarget = this.state.overallTargetState ?? {};
         const nextTarget = {
             ...previousTarget,
             ...(request?.position !== undefined ? { position: request.position } : null),
-            ...(request?.latch !== undefined ? { latch: request.latch } : null),
-            speed: request?.speed ?? ThreeLevelAuto.Auto,
+            ...(this.features.motionLatching && request?.latch !== undefined ? { latch: request.latch } : null),
+            ...(this.features.speed ? { speed: request?.speed ?? ThreeLevelAuto.Auto } : null),
         };
         this.state.overallTargetState = nextTarget;
-        if (currentState !== null) {
+        if (this.features.speed && currentState !== null) {
             currentState = { ...currentState, speed: nextTarget.speed };
             this.state.overallCurrentState = currentState;
         }
         const isAtTarget = currentState !== null &&
             (nextTarget.position === undefined || nextTarget.position === currentState.position) &&
-            (nextTarget.latch === undefined || nextTarget.latch === currentState.latch) &&
-            nextTarget.speed === currentState.speed;
+            (!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);
         if (isAtTarget) {
@@ -90,8 +99,13 @@ export class MatterbridgeClosureControlServer extends MatterbridgeClosureControl
                 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);
+        const secureState = this.features.motionLatching ? latch === true : position === ClosureControl.CurrentPosition.FullyClosed;
+        await closure.setState({
+            position,
+            ...(this.features.motionLatching ? { latch } : null),
+            ...(this.features.speed ? { speed: targetState.speed } : null),
+            secureState,
+        }, targetState, ClosureControl.MainState.Stopped, 0);
         if (secureState !== previousState.secureState) {
             await closure.triggerSecureStateChanged(secureState);
         }
@@ -160,21 +174,13 @@ export class MatterbridgeClosureControlServer extends MatterbridgeClosureControl
     class State extends MatterbridgeClosureControlServerBase.State {
         movementDuration = 0;
         calibrationDuration = 0;
+        signaturePosition = 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 = {
-            position: ClosureControl.CurrentPosition.FullyClosed,
-            latch: true,
-            speed: ThreeLevelAuto.Auto,
-            secureState: true,
-        }, overallTargetState = {
-            position: ClosureControl.TargetPosition.MoveToFullyClosed,
-            latch: true,
-            speed: ThreeLevelAuto.Auto,
-        }, latchControlModes = { remoteLatching: true, remoteUnlatching: true }, movementDuration = 0, calibrationDuration = 0, 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, 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,
@@ -202,25 +208,48 @@ export class Closure extends MatterbridgeEndpoint {
             countdownTime,
             mainState,
             currentErrorList,
-            overallCurrentState,
-            overallTargetState,
-            latchControlModes,
+            overallCurrentState: {
+                position: overallCurrentState?.position ?? ClosureControl.CurrentPosition.FullyClosed,
+                ...(motionLatching ? { latch: overallCurrentState?.latch ?? true } : null),
+                ...(speed ? { speed: overallCurrentState?.speed ?? ThreeLevelAuto.Auto } : null),
+                secureState: overallCurrentState?.secureState ?? true,
+            },
+            overallTargetState: {
+                position: overallTargetState?.position ?? ClosureControl.TargetPosition.MoveToFullyClosed,
+                ...(motionLatching ? { latch: overallTargetState?.latch ?? true } : null),
+                ...(speed ? { speed: overallTargetState?.speed ?? ThreeLevelAuto.Auto } : null),
+            },
+            ...(motionLatching ? { latchControlModes: latchControlModes ?? { remoteLatching: true, remoteUnlatching: true } } : null),
             movementDuration,
             calibrationDuration,
+            signaturePosition,
         };
-        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);
+        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);
     }
     getMainState() {
         return this.getAttribute(ClosureControlServer, 'mainState');
     }
+    getSignaturePosition() {
+        return this.getAttribute(MatterbridgeClosureControlServer, 'signaturePosition');
+    }
     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;
         await this.setAttribute(ClosureControl, 'countdownTime', countdownTime);
         await this.setAttribute(ClosureControl, 'mainState', mainState);
         await this.setAttribute(ClosureControl, 'currentErrorList', currentErrorList);
-        await this.setAttribute(ClosureControl, 'overallCurrentState', currentState);
-        await this.setAttribute(ClosureControl, 'overallTargetState', targetState);
+        await this.setAttribute(ClosureControl, 'overallCurrentState', {
+            position: currentState.position,
+            ...(supportsMotionLatching ? { latch: currentState.latch } : null),
+            ...(supportsSpeed ? { 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),
+        });
     }
     async setFullyClosed() {
         await this.setState({
@@ -270,7 +299,7 @@ export class Closure extends MatterbridgeEndpoint {
         await this.triggerEvent(ClosureControl, 'secureStateChanged', { secureValue });
     }
     addPanel(name, tagList, dimensionType, options = {}) {
-        const panel = this.addChildDeviceType(name, closurePanel, { tagList });
+        const panel = this.addChildDeviceType(name, closurePanel, { number: options.number, tagList });
         createClosureDimensionClusterServer(panel, dimensionType, options);
         return panel;
     }

package/dist/devices/closurePanel.d.ts

@@ -1,8 +1,10 @@
+import type { MaybePromise } 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';
 import type { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export type ClosureDimensionType = 'lift' | 'tilt' | 'modulation';
-declare const MatterbridgeClosureDimensionServer_base: import("@matter/node").ClusterBehavior.Type<typeof ClosureDimensionServer, import("@matter/types").ClusterType.WithSupportedFeatures<ClosureDimension, {
+declare const MatterbridgeClosureDimensionServerBase: import("@matter/node").ClusterBehavior.Type<typeof ClosureDimensionServer, import("@matter/types").ClusterType.WithSupportedFeatures<ClosureDimension, {
     limitation: false;
     modulation: false;
     motionLatching: true;
@@ -12,16 +14,33 @@ declare const MatterbridgeClosureDimensionServer_base: import("@matter/node").Cl
     translation: false;
     unit: false;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "closureDimension">;
-export declare class MatterbridgeClosureDimensionServer extends MatterbridgeClosureDimensionServer_base {
+export declare class MatterbridgeClosureDimensionServer extends MatterbridgeClosureDimensionServerBase {
+    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;
+}
+export declare namespace MatterbridgeClosureDimensionServer {
+    class Internal extends MatterbridgeClosureDimensionServerBase.Internal {
+        movementTimer?: NodeJS.Timeout;
+    }
+    class State extends MatterbridgeClosureDimensionServerBase.State {
+        movementDuration: number;
+    }
 }
 export interface ClosurePanelOptions {
+    number?: EndpointNumber;
     currentState?: ClosureDimension.DimensionState;
     targetState?: ClosureDimension.DimensionState;
     resolution?: number;
     stepValue?: number;
+    motionLatching?: boolean;
+    speed?: boolean;
     latchControlModes?: ClosureDimension.LatchControlModes;
+    movementDuration?: number;
     translationDirection?: ClosureDimension.TranslationDirection;
     rotationAxis?: ClosureDimension.RotationAxis;
     overflow?: ClosureDimension.Overflow;

package/dist/devices/closurePanel.js

@@ -5,7 +5,14 @@ import { ClosureControl } from '@matter/types/clusters/closure-control';
 import { ClosureDimension } from '@matter/types/clusters/closure-dimension';
 import { ThreeLevelAuto } from '@matter/types/globals';
 import { MatterbridgeServer } from '../behaviors/matterbridgeServer.js';
-export class MatterbridgeClosureDimensionServer extends ClosureDimensionServer.with(ClosureDimension.Feature.Positioning, ClosureDimension.Feature.MotionLatching, ClosureDimension.Feature.Speed) {
+const MatterbridgeClosureDimensionServerBase = ClosureDimensionServer.with(ClosureDimension.Feature.Positioning, ClosureDimension.Feature.MotionLatching, ClosureDimension.Feature.Speed);
+export class MatterbridgeClosureDimensionServer extends MatterbridgeClosureDimensionServerBase {
+    initialize() {
+        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+            this.state.movementDuration = 2000;
+        }
+        return super.initialize();
+    }
     setTarget = async (request) => {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         device.log.info(`SetTarget (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
@@ -22,11 +29,16 @@ export class MatterbridgeClosureDimensionServer extends ClosureDimensionServer.w
         if (request.position !== undefined && (request.position < 0 || request.position > 10000)) {
             throw new StatusResponse.ConstraintErrorError('ClosureDimension.setTarget position must be between 0 and 10000');
         }
+        const hasSupportedField = request.position !== undefined || (this.features.motionLatching && request.latch !== undefined) || (this.features.speed && request.speed !== undefined);
+        if (!hasSupportedField)
+            return;
         const latchControlModes = this.state.latchControlModes;
-        if (request.latch !== undefined && ((request.latch && !latchControlModes?.remoteLatching) || (!request.latch && !latchControlModes?.remoteUnlatching))) {
+        if (this.features.motionLatching &&
+            request.latch !== undefined &&
+            ((request.latch && !latchControlModes?.remoteLatching) || (!request.latch && !latchControlModes?.remoteUnlatching))) {
             throw new StatusResponse.InvalidInStateError('ClosureDimension.setTarget latch change requires manual intervention per LatchControlModes');
         }
-        if (request.speed !== undefined && (request.speed < ThreeLevelAuto.Auto || request.speed > ThreeLevelAuto.High)) {
+        if (this.features.speed && request.speed !== undefined && (request.speed < ThreeLevelAuto.Auto || request.speed > ThreeLevelAuto.High)) {
             throw new StatusResponse.ConstraintErrorError('ClosureDimension.setTarget speed must be a valid ThreeLevelAutoEnum value');
         }
         const associatedMainState = this.endpoint.owner?.maybeStateOf(ClosureControlServer)?.mainState;
@@ -41,7 +53,7 @@ export class MatterbridgeClosureDimensionServer extends ClosureDimensionServer.w
             throw new StatusResponse.InvalidInStateError('ClosureDimension.setTarget is not allowed while the associated ClosureControl is Disengaged, Protected, Calibrating, SetupRequired, or Error');
         }
         const currentState = this.state.currentState;
-        if (request.position !== undefined && currentState?.latch === true && request.latch !== false) {
+        if (this.features.motionLatching && request.position !== undefined && currentState?.latch === true && request.latch !== false) {
             throw new StatusResponse.InvalidInStateError('ClosureDimension.setTarget position changes require latch false while the closure is latched');
         }
         const previousTarget = this.state.targetState ?? {};
@@ -49,16 +61,17 @@ export class MatterbridgeClosureDimensionServer extends ClosureDimensionServer.w
         const nextTarget = {
             ...previousTarget,
             ...(request?.position !== undefined ? { position: Math.round(request.position / resolution) * resolution } : null),
-            ...(request?.latch !== undefined ? { latch: request.latch } : null),
-            speed: request?.speed ?? ThreeLevelAuto.Auto,
+            ...(this.features.motionLatching && request?.latch !== undefined ? { latch: request.latch } : null),
+            ...(this.features.speed ? { speed: request?.speed ?? ThreeLevelAuto.Auto } : null),
         };
         const matchesCurrentState = currentState !== null &&
             (nextTarget.position === undefined || nextTarget.position === currentState.position) &&
-            (nextTarget.latch === undefined || nextTarget.latch === currentState.latch) &&
-            nextTarget.speed === currentState.speed;
+            (!this.features.motionLatching || nextTarget.latch === undefined || nextTarget.latch === currentState.latch) &&
+            (!this.features.speed || nextTarget.speed === currentState.speed);
         if (matchesCurrentState)
             return;
         this.state.targetState = nextTarget;
+        this.scheduleMovement(nextTarget, currentState);
     };
     step = async (request) => {
         const device = this.endpoint.stateOf(MatterbridgeServer);
@@ -76,11 +89,11 @@ export class MatterbridgeClosureDimensionServer extends ClosureDimensionServer.w
         if (request.numberOfSteps < 1) {
             throw new StatusResponse.ConstraintErrorError('ClosureDimension.step numberOfSteps must be at least 1');
         }
-        if (request.speed !== undefined && (request.speed < ThreeLevelAuto.Auto || request.speed > ThreeLevelAuto.High)) {
+        if (this.features.speed && request.speed !== undefined && (request.speed < ThreeLevelAuto.Auto || request.speed > ThreeLevelAuto.High)) {
             throw new StatusResponse.ConstraintErrorError('ClosureDimension.step speed must be a valid ThreeLevelAutoEnum value');
         }
         const currentState = this.state.currentState;
-        if (currentState?.latch === true) {
+        if (this.features.motionLatching && currentState?.latch === true) {
             throw new StatusResponse.InvalidInStateError('ClosureDimension.step is not allowed while the closure is latched');
         }
         const associatedMainState = this.endpoint.owner?.maybeStateOf(ClosureControlServer)?.mainState;
@@ -102,36 +115,82 @@ export class MatterbridgeClosureDimensionServer extends ClosureDimensionServer.w
         let nextPosition = isIncrease ? currentPosition + delta : currentPosition - delta;
         nextPosition = Math.max(0, Math.min(10000, nextPosition));
         const previousTarget = this.state.targetState ?? {};
-        this.state.targetState = {
+        const nextTarget = {
             ...previousTarget,
             position: nextPosition,
-            ...(request.speed !== undefined ? { speed: request.speed } : null),
+            ...(this.features.speed && request.speed !== undefined ? { speed: request.speed } : null),
         };
+        this.state.targetState = nextTarget;
+        this.scheduleMovement(nextTarget, currentState);
+    };
+    scheduleMovement(targetState, currentState) {
+        clearTimeout(this.internal.movementTimer);
+        if (currentState === null || this.state.movementDuration <= 0) {
+            this.internal.movementTimer = undefined;
+            return;
+        }
+        const previousState = currentState;
+        this.internal.movementTimer = setTimeout(() => {
+            this.internal.movementTimer = undefined;
+            void this.completeMovement(targetState, previousState);
+        }, this.state.movementDuration);
+    }
+    completeMovement = async (targetState, previousState) => {
+        const endpoint = this.endpoint;
+        const position = targetState.position ?? previousState.position;
+        const latch = targetState.latch ?? previousState.latch;
+        const speed = targetState.speed ?? previousState.speed;
+        await endpoint.setAttribute(ClosureDimensionServer, 'currentState', {
+            position,
+            ...(this.features.motionLatching ? { latch } : null),
+            ...(this.features.speed ? { speed } : null),
+        });
     };
 }
+(function (MatterbridgeClosureDimensionServer) {
+    class Internal extends MatterbridgeClosureDimensionServerBase.Internal {
+        movementTimer;
+    }
+    MatterbridgeClosureDimensionServer.Internal = Internal;
+    class State extends MatterbridgeClosureDimensionServerBase.State {
+        movementDuration = 0;
+    }
+    MatterbridgeClosureDimensionServer.State = State;
+})(MatterbridgeClosureDimensionServer || (MatterbridgeClosureDimensionServer = {}));
 export function createClosureDimensionClusterServer(endpoint, dimensionType, options) {
+    const motionLatching = options.motionLatching ?? false;
+    const speed = options.speed ?? false;
     const commonOptions = {
-        currentState: options.currentState ?? { position: 0, latch: true, speed: ThreeLevelAuto.Auto },
-        targetState: options.targetState ?? { position: 0, latch: true, speed: ThreeLevelAuto.Auto },
-        resolution: Math.max(1, options.resolution ?? 1),
-        stepValue: Math.max(1, options.stepValue ?? 1),
-        latchControlModes: options.latchControlModes ?? { remoteLatching: true, remoteUnlatching: true },
+        currentState: {
+            position: options.currentState?.position ?? 0,
+            ...(motionLatching ? { latch: options.currentState?.latch ?? true } : null),
+            ...(speed ? { speed: options.currentState?.speed ?? ThreeLevelAuto.Auto } : null),
+        },
+        targetState: {
+            position: options.targetState?.position ?? 0,
+            ...(motionLatching ? { latch: options.targetState?.latch ?? true } : null),
+            ...(speed ? { speed: options.targetState?.speed ?? ThreeLevelAuto.Auto } : null),
+        },
+        resolution: Math.max(1, options.resolution ?? 100),
+        stepValue: Math.max(1, options.stepValue ?? 100),
+        ...(motionLatching ? { latchControlModes: options.latchControlModes ?? { remoteLatching: true, remoteUnlatching: true } } : null),
+        movementDuration: options.movementDuration ?? 0,
     };
     if (dimensionType === 'lift') {
-        endpoint.behaviors.require(MatterbridgeClosureDimensionServer.with(ClosureDimension.Feature.Positioning, ClosureDimension.Feature.MotionLatching, ClosureDimension.Feature.Speed, ClosureDimension.Feature.Translation), {
+        endpoint.behaviors.require(MatterbridgeClosureDimensionServer.with(ClosureDimension.Feature.Positioning, ClosureDimension.Feature.Translation, ...(motionLatching ? [ClosureDimension.Feature.MotionLatching] : []), ...(speed ? [ClosureDimension.Feature.Speed] : [])), {
             ...commonOptions,
             translationDirection: options.translationDirection ?? ClosureDimension.TranslationDirection.Downward,
         });
     }
     else if (dimensionType === 'tilt') {
-        endpoint.behaviors.require(MatterbridgeClosureDimensionServer.with(ClosureDimension.Feature.Positioning, ClosureDimension.Feature.MotionLatching, ClosureDimension.Feature.Speed, ClosureDimension.Feature.Rotation), {
+        endpoint.behaviors.require(MatterbridgeClosureDimensionServer.with(ClosureDimension.Feature.Positioning, ClosureDimension.Feature.Rotation, ...(motionLatching ? [ClosureDimension.Feature.MotionLatching] : []), ...(speed ? [ClosureDimension.Feature.Speed] : [])), {
             ...commonOptions,
             rotationAxis: options.rotationAxis ?? ClosureDimension.RotationAxis.CenteredHorizontal,
             overflow: options.overflow ?? ClosureDimension.Overflow.NoOverflow,
         });
     }
     else {
-        endpoint.behaviors.require(MatterbridgeClosureDimensionServer.with(ClosureDimension.Feature.Positioning, ClosureDimension.Feature.MotionLatching, ClosureDimension.Feature.Speed, ClosureDimension.Feature.Modulation), {
+        endpoint.behaviors.require(MatterbridgeClosureDimensionServer.with(ClosureDimension.Feature.Positioning, ClosureDimension.Feature.Modulation, ...(motionLatching ? [ClosureDimension.Feature.MotionLatching] : []), ...(speed ? [ClosureDimension.Feature.Speed] : [])), {
             ...commonOptions,
             modulationType: options.modulationType ?? ClosureDimension.ModulationType.SlatsOrientation,
         });

package/dist/frontend.js

@@ -1131,8 +1131,10 @@ export class Frontend extends EventEmitter {
             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' })} `;
+                if (overallCurrentState.latch !== undefined)
+                    attributes += `Latch: ${overallCurrentState.latch} `;
+                if (overallCurrentState.speed !== undefined)
+                    attributes += `Speed: ${getEnumDescription(ThreeLevelAuto, overallCurrentState.speed)} `;
                 attributes += `SecureState: ${overallCurrentState.secureState ?? 'unknown'} `;
             }
             if (clusterName === 'thermostat' && attributeName === 'localTemperature' && isValidNumber(attributeValue))

package/dist/matterbridgeEndpoint.d.ts

@@ -90,7 +90,9 @@ export declare class MatterbridgeEndpoint extends Endpoint {
     getDeviceTypes(): DeviceTypeDefinition[];
     hasClusterServer(cluster: Behavior.Type | ClusterType | ClusterId | string): boolean;
     hasAttributeServer(cluster: Behavior.Type | ClusterType | ClusterId | string, attribute: string): boolean;
-    getClusterServerOptions(cluster: Behavior.Type | ClusterType | ClusterId | string): Record<string, boolean | number | bigint | string | object | null> | undefined;
+    getClusterServerOptions<T extends Behavior.Type>(cluster: T): Partial<Behavior.StateOf<T>> | undefined;
+    getClusterServerOptions<T extends ClusterType>(cluster: T): Partial<ClusterAttributesOf<T>> | undefined;
+    getClusterServerOptions(cluster: ClusterId | string): Record<string, boolean | number | bigint | string | object | null> | undefined;
     getAttribute<T extends Behavior.Type, A extends keyof Behavior.StateOf<T>>(cluster: T, attribute: A, log?: AnsiLogger): Behavior.StateOf<T>[A] | undefined;
     getAttribute<T extends ClusterType, A extends keyof ClusterAttributesOf<T>>(cluster: T, attribute: A, log?: AnsiLogger): ClusterAttributesOf<T>[A] | undefined;
     getAttribute(cluster: ClusterId | string, attribute: string, log?: AnsiLogger): any;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.10.8-dev-20260829-e779e7d",
+  "version": "3.10.8-dev-20260831-3e81235",
   "description": "Matterbridge core library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -132,16 +132,16 @@
   },
   "dependencies": {
     "@matter/main": "0.17.9",
-    "@matterbridge/dgram": "3.10.8-dev-20260829-e779e7d",
-    "@matterbridge/thread": "3.10.8-dev-20260829-e779e7d",
-    "@matterbridge/types": "3.10.8-dev-20260829-e779e7d",
-    "@matterbridge/utils": "3.10.8-dev-20260829-e779e7d",
+    "@matterbridge/dgram": "3.10.8-dev-20260831-3e81235",
+    "@matterbridge/thread": "3.10.8-dev-20260831-3e81235",
+    "@matterbridge/types": "3.10.8-dev-20260831-3e81235",
+    "@matterbridge/utils": "3.10.8-dev-20260831-3e81235",
     "escape-html": "1.0.3",
     "express": "5.2.1",
-    "express-rate-limit": "8.6.2",
-    "multer": "2.2.0",
-    "node-ansi-logger": "3.3.0",
-    "node-persist-manager": "2.1.0",
+    "express-rate-limit": "8.7.0",
+    "multer": "2.3.0",
+    "node-ansi-logger": "3.3.1",
+    "node-persist-manager": "2.1.1",
     "ws": "8.21.3"
   }
 }