@matterbridge/core 3.10.5-dev-20260812-3e239dd → 3.10.5

package/dist/devices/closure.d.ts

@@ -1,5 +1,6 @@
 import { ClosureControlServer } from '@matter/node/behaviors/closure-control';
 import { ClosureControl } from '@matter/types/clusters/closure-control';
+import { Identify } from '@matter/types/clusters/identify';
 import type { Semtag } from '@matter/types/globals';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 import { type ClosureDimensionType, type ClosurePanelOptions } from './closurePanel.js';
@@ -19,6 +20,9 @@ export declare class MatterbridgeClosureControlServer extends MatterbridgeClosur
     stop: () => Promise<void>;
 }
 export interface ClosureOptions {
+    identifyTime?: number;
+    identifyType?: Identify.IdentifyType;
+    powerSourceType?: 'Rechargeable' | 'Replaceable' | 'Battery' | 'Wired' | 'None';
     countdownTime?: number;
     mainState?: ClosureControl.MainState;
     currentErrorList?: ClosureControl.ClosureError[];
@@ -30,6 +34,13 @@ export interface ClosureOptions {
 export declare class Closure extends MatterbridgeEndpoint {
     constructor(name: string, serial: string, options?: ClosureOptions);
     getMainState(): ClosureControl.MainState | undefined;
-    addPanel(name: string, tagList: Semtag[], dimensionType: ClosureDimensionType, options?: Omit<ClosurePanelOptions, 'tagList'>): MatterbridgeEndpoint;
+    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>;
+    triggerOperationalError(errorState?: ClosureControl.ClosureError[]): Promise<void>;
+    triggerMovementCompleted(): Promise<void>;
+    triggerSecureStateChanged(secureValue: boolean): Promise<void>;
+    addPanel(name: string, tagList: Semtag[], dimensionType: ClosureDimensionType, options?: ClosurePanelOptions): MatterbridgeEndpoint;
 }
 export {};

package/dist/devices/closure.js

@@ -1,9 +1,13 @@
+import { ClosureTag } from '@matter/node';
 import { ClosureControlServer } from '@matter/node/behaviors/closure-control';
+import { StatusResponse } from '@matter/types';
 import { ClosureControl } from '@matter/types/clusters/closure-control';
+import { Identify } from '@matter/types/clusters/identify';
 import { ThreeLevelAuto } from '@matter/types/globals';
 import { MatterbridgeServer } from '../behaviors/matterbridgeServer.js';
-import { closure, closurePanel } from '../matterbridgeDeviceTypes.js';
+import { closure, closurePanel, powerSource } from '../matterbridgeDeviceTypes.js';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+import { getSemtag } from '../matterbridgeEndpointHelpers.js';
 import { createClosureDimensionClusterServer } from './closurePanel.js';
 export class MatterbridgeClosureControlServer extends ClosureControlServer.with(ClosureControl.Feature.Positioning, ClosureControl.Feature.MotionLatching, ClosureControl.Feature.Speed) {
     moveTo = async (request) => {
@@ -16,6 +20,16 @@ export class MatterbridgeClosureControlServer extends ClosureControlServer.with(
             attributes: this.state,
             endpoint: this.endpoint,
         });
+        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) {
+            throw new StatusResponse.InvalidInStateError('ClosureControl.moveTo position changes require latch false while the closure is latched');
+        }
         const previousTarget = this.state.overallTargetState ?? {};
         const nextTarget = {
             ...previousTarget,
@@ -24,7 +38,10 @@ export class MatterbridgeClosureControlServer extends ClosureControlServer.with(
             speed: request?.speed ?? ThreeLevelAuto.Auto,
         };
         this.state.overallTargetState = nextTarget;
-        const currentState = this.state.overallCurrentState;
+        if (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) &&
@@ -41,35 +58,111 @@ export class MatterbridgeClosureControlServer extends ClosureControlServer.with(
             attributes: this.state,
             endpoint: this.endpoint,
         });
-        this.state.mainState = ClosureControl.MainState.Stopped;
+        if ([ClosureControl.MainState.Moving, ClosureControl.MainState.WaitingForMotion, ClosureControl.MainState.Calibrating].includes(this.state.mainState)) {
+            this.state.mainState = ClosureControl.MainState.Stopped;
+        }
     };
 }
 export class Closure extends MatterbridgeEndpoint {
     constructor(name, serial, options = {}) {
-        super([closure], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`, tagList: options.tagList });
-        this.createDefaultIdentifyClusterServer();
+        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 }, tagList = [getSemtag(ClosureTag.Covering)], } = options;
+        super(powerSourceType === 'None' ? [closure] : [closure, powerSource], {
+            id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`,
+            tagList,
+        });
+        this.createDefaultIdentifyClusterServer(identifyTime, identifyType);
         this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Closure');
+        switch (powerSourceType) {
+            case 'Rechargeable':
+                this.createDefaultPowerSourceRechargeableBatteryClusterServer();
+                break;
+            case 'Replaceable':
+                this.createDefaultPowerSourceReplaceableBatteryClusterServer();
+                break;
+            case 'Battery':
+                this.createDefaultPowerSourceBatteryClusterServer();
+                break;
+            case 'Wired':
+                this.createDefaultPowerSourceWiredClusterServer();
+                break;
+            case 'None':
+                break;
+        }
         this.behaviors.require(MatterbridgeClosureControlServer, {
-            countdownTime: options.countdownTime ?? 0,
-            mainState: options.mainState ?? ClosureControl.MainState.Stopped,
-            currentErrorList: [],
-            overallCurrentState: options.overallCurrentState ?? {
-                position: ClosureControl.CurrentPosition.FullyClosed,
-                latch: true,
-                speed: ThreeLevelAuto.Auto,
-                secureState: true,
-            },
-            overallTargetState: options.overallTargetState ?? {
-                position: ClosureControl.TargetPosition.MoveToFullyClosed,
-                latch: true,
-                speed: ThreeLevelAuto.Auto,
-            },
-            latchControlModes: options.latchControlModes ?? { remoteLatching: true, remoteUnlatching: true },
+            countdownTime,
+            mainState,
+            currentErrorList,
+            overallCurrentState,
+            overallTargetState,
+            latchControlModes,
         });
     }
     getMainState() {
         return this.getAttribute(ClosureControlServer, 'mainState');
     }
+    async setState(currentState, targetState, mainState = ClosureControl.MainState.Stopped, countdownTime = 0, currentErrorList = []) {
+        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);
+    }
+    async setFullyClosed() {
+        await this.setState({
+            position: ClosureControl.CurrentPosition.FullyClosed,
+            latch: true,
+            speed: ThreeLevelAuto.Auto,
+            secureState: true,
+        }, {
+            position: ClosureControl.TargetPosition.MoveToFullyClosed,
+            latch: true,
+            speed: ThreeLevelAuto.Auto,
+        });
+    }
+    async setFullOpened() {
+        await this.setState({
+            position: ClosureControl.CurrentPosition.FullyOpened,
+            latch: false,
+            speed: ThreeLevelAuto.Auto,
+            secureState: false,
+        }, {
+            position: ClosureControl.TargetPosition.MoveToFullyOpen,
+            latch: false,
+            speed: ThreeLevelAuto.Auto,
+        });
+    }
+    async setPartiallyOpened() {
+        await this.setState({
+            position: ClosureControl.CurrentPosition.PartiallyOpened,
+            latch: false,
+            speed: ThreeLevelAuto.Auto,
+            secureState: false,
+        }, {
+            position: null,
+            latch: false,
+            speed: ThreeLevelAuto.Auto,
+        });
+    }
+    async triggerOperationalError(errorState = []) {
+        await this.setAttribute(ClosureControl, 'mainState', ClosureControl.MainState.Error);
+        await this.setAttribute(ClosureControl, 'currentErrorList', errorState);
+        await this.triggerEvent(ClosureControl, 'operationalError', { errorState });
+    }
+    async triggerMovementCompleted() {
+        await this.triggerEvent(ClosureControl, 'movementCompleted', undefined);
+    }
+    async triggerSecureStateChanged(secureValue) {
+        await this.triggerEvent(ClosureControl, 'secureStateChanged', { secureValue });
+    }
     addPanel(name, tagList, dimensionType, options = {}) {
         const panel = this.addChildDeviceType(name, closurePanel, { tagList });
         createClosureDimensionClusterServer(panel, dimensionType, options);

package/dist/devices/closurePanel.d.ts

@@ -1,7 +1,6 @@
 import { ClosureDimensionServer } from '@matter/node/behaviors/closure-dimension';
 import { ClosureDimension } from '@matter/types/clusters/closure-dimension';
-import type { Semtag } from '@matter/types/globals';
-import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+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, {
     limitation: false;
@@ -27,10 +26,6 @@ export interface ClosurePanelOptions {
     rotationAxis?: ClosureDimension.RotationAxis;
     overflow?: ClosureDimension.Overflow;
     modulationType?: ClosureDimension.ModulationType;
-    tagList?: Semtag[];
-}
-export declare class ClosurePanel extends MatterbridgeEndpoint {
-    constructor(name: string, serial: string, dimensionType: ClosureDimensionType, options?: ClosurePanelOptions);
 }
 export declare function createClosureDimensionClusterServer(endpoint: MatterbridgeEndpoint, dimensionType: ClosureDimensionType, options: ClosurePanelOptions): MatterbridgeEndpoint;
 export {};

package/dist/devices/closurePanel.js

@@ -1,9 +1,10 @@
+import { ClosureControlServer } from '@matter/node/behaviors/closure-control';
 import { ClosureDimensionServer } from '@matter/node/behaviors/closure-dimension';
+import { StatusResponse } from '@matter/types';
+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';
-import { closurePanel } from '../matterbridgeDeviceTypes.js';
-import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 export class MatterbridgeClosureDimensionServer extends ClosureDimensionServer.with(ClosureDimension.Feature.Positioning, ClosureDimension.Feature.MotionLatching, ClosureDimension.Feature.Speed) {
     setTarget = async (request) => {
         const device = this.endpoint.stateOf(MatterbridgeServer);
@@ -15,13 +16,48 @@ export class MatterbridgeClosureDimensionServer extends ClosureDimensionServer.w
             attributes: this.state,
             endpoint: this.endpoint,
         });
+        if (request.position === undefined && request.latch === undefined && request.speed === undefined) {
+            throw new StatusResponse.InvalidCommandError('ClosureDimension.setTarget requires at least one of position, latch, or speed to be present');
+        }
+        if (request.position !== undefined && (request.position < 0 || request.position > 10000)) {
+            throw new StatusResponse.ConstraintErrorError('ClosureDimension.setTarget position must be between 0 and 10000');
+        }
+        const latchControlModes = this.state.latchControlModes;
+        if (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)) {
+            throw new StatusResponse.ConstraintErrorError('ClosureDimension.setTarget speed must be a valid ThreeLevelAutoEnum value');
+        }
+        const associatedMainState = this.endpoint.owner?.maybeStateOf(ClosureControlServer)?.mainState;
+        if (associatedMainState !== undefined &&
+            [
+                ClosureControl.MainState.Disengaged,
+                ClosureControl.MainState.Protected,
+                ClosureControl.MainState.Calibrating,
+                ClosureControl.MainState.SetupRequired,
+                ClosureControl.MainState.Error,
+            ].includes(associatedMainState)) {
+            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) {
+            throw new StatusResponse.InvalidInStateError('ClosureDimension.setTarget position changes require latch false while the closure is latched');
+        }
         const previousTarget = this.state.targetState ?? {};
+        const resolution = this.state.resolution;
         const nextTarget = {
             ...previousTarget,
-            ...(request?.position !== undefined ? { position: request.position } : null),
+            ...(request?.position !== undefined ? { position: Math.round(request.position / resolution) * resolution } : null),
             ...(request?.latch !== undefined ? { latch: request.latch } : null),
             speed: request?.speed ?? ThreeLevelAuto.Auto,
         };
+        const matchesCurrentState = currentState !== null &&
+            (nextTarget.position === undefined || nextTarget.position === currentState.position) &&
+            (nextTarget.latch === undefined || nextTarget.latch === currentState.latch) &&
+            nextTarget.speed === currentState.speed;
+        if (matchesCurrentState)
+            return;
         this.state.targetState = nextTarget;
     };
     step = async (request) => {
@@ -34,37 +70,51 @@ export class MatterbridgeClosureDimensionServer extends ClosureDimensionServer.w
             attributes: this.state,
             endpoint: this.endpoint,
         });
+        if (request.direction < ClosureDimension.StepDirection.Decrease || request.direction > ClosureDimension.StepDirection.Increase) {
+            throw new StatusResponse.ConstraintErrorError('ClosureDimension.step direction must be a valid StepDirectionEnum value');
+        }
+        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)) {
+            throw new StatusResponse.ConstraintErrorError('ClosureDimension.step speed must be a valid ThreeLevelAutoEnum value');
+        }
+        const currentState = this.state.currentState;
+        if (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;
+        if (associatedMainState !== undefined &&
+            [
+                ClosureControl.MainState.Disengaged,
+                ClosureControl.MainState.Protected,
+                ClosureControl.MainState.Calibrating,
+                ClosureControl.MainState.SetupRequired,
+                ClosureControl.MainState.Error,
+            ].includes(associatedMainState)) {
+            throw new StatusResponse.InvalidInStateError('ClosureDimension.step is not allowed while the associated ClosureControl is Disengaged, Protected, Calibrating, SetupRequired, or Error');
+        }
         const stepValue = this.state.stepValue;
         const numberOfSteps = request.numberOfSteps;
         const delta = stepValue * numberOfSteps;
         const isIncrease = request.direction === ClosureDimension.StepDirection.Increase;
-        const previousCurrent = this.state.currentState ?? {};
-        const previousTarget = this.state.targetState ?? {};
-        const currentPosition = typeof previousCurrent.position === 'number' ? previousCurrent.position : typeof previousTarget.position === 'number' ? previousTarget.position : 0;
+        const currentPosition = typeof currentState?.position === 'number' ? currentState.position : 0;
         let nextPosition = isIncrease ? currentPosition + delta : currentPosition - delta;
         nextPosition = Math.max(0, Math.min(10000, nextPosition));
-        const speed = request?.speed ?? previousCurrent.speed ?? previousTarget.speed ?? ThreeLevelAuto.Auto;
-        this.state.currentState = {
-            ...previousCurrent,
+        const previousTarget = this.state.targetState ?? {};
+        this.state.targetState = {
+            ...previousTarget,
             position: nextPosition,
-            speed,
+            ...(request.speed !== undefined ? { speed: request.speed } : null),
         };
-        this.state.targetState = { ...previousTarget, position: nextPosition, speed };
     };
 }
-export class ClosurePanel extends MatterbridgeEndpoint {
-    constructor(name, serial, dimensionType, options = {}) {
-        super([closurePanel], { id: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`, tagList: options.tagList });
-        this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Closure Panel');
-        createClosureDimensionClusterServer(this, dimensionType, options);
-    }
-}
 export function createClosureDimensionClusterServer(endpoint, dimensionType, options) {
     const commonOptions = {
         currentState: options.currentState ?? { position: 0, latch: true, speed: ThreeLevelAuto.Auto },
         targetState: options.targetState ?? { position: 0, latch: true, speed: ThreeLevelAuto.Auto },
-        resolution: options.resolution ?? 1,
-        stepValue: options.stepValue ?? 1,
+        resolution: Math.max(1, options.resolution ?? 1),
+        stepValue: Math.max(1, options.stepValue ?? 1),
         latchControlModes: options.latchControlModes ?? { remoteLatching: true, remoteUnlatching: true },
     };
     if (dimensionType === 'lift') {

package/dist/matterbridgeEndpoint.js

@@ -993,7 +993,7 @@ export class MatterbridgeEndpoint extends Endpoint {
             ...(occupied !== undefined ? { occupancy: { occupied } } : {}),
             ...(occupied !== undefined ? { externallyMeasuredOccupancy: true } : {}),
             numberOfPresets: Math.max(Array.isArray(presets) ? presets.length : 0, Array.isArray(presetTypes) ? Math.max(0, ...presetTypes.map((pt) => pt.numberOfPresets ?? 0)) : 0, 1),
-            activePresetHandle: activePresetHandle ? Uint8Array.from([activePresetHandle]) : null,
+            activePresetHandle: activePresetHandle ? Uint8Array.from(activePresetHandle) : null,
             presets: (presets ?? []).map((p) => ({
                 presetHandle: p.presetHandle ? Uint8Array.from(p.presetHandle) : null,
                 presetScenario: p.presetScenario,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.10.5-dev-20260812-3e239dd",
+  "version": "3.10.5",
   "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.5-dev-20260812-3e239dd",
-    "@matterbridge/thread": "3.10.5-dev-20260812-3e239dd",
-    "@matterbridge/types": "3.10.5-dev-20260812-3e239dd",
-    "@matterbridge/utils": "3.10.5-dev-20260812-3e239dd",
+    "@matterbridge/dgram": "3.10.5",
+    "@matterbridge/thread": "3.10.5",
+    "@matterbridge/types": "3.10.5",
+    "@matterbridge/utils": "3.10.5",
     "escape-html": "1.0.3",
     "express": "5.2.1",
     "express-rate-limit": "8.6.2",