npm - @matterbridge/core - Versions diffs - 3.10.8-dev-20260831-e73fc65 → 3.10.8-dev-20260901-971f7bf - Mend

@matterbridge/core 3.10.8-dev-20260831-e73fc65 → 3.10.8-dev-20260901-971f7bf

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (17) hide show

package/dist/behaviors/doorLockServer.js +2 -3
package/dist/behaviors/thermostatServer.js +19 -19
package/dist/behaviors/windowCoveringServer.d.ts +17 -3
package/dist/behaviors/windowCoveringServer.js +120 -18
package/dist/demoDevices.js +45 -8
package/dist/devices/closure.d.ts +11 -0
package/dist/devices/closure.js +80 -10
package/dist/devices/electricalUtilityMeter.d.ts +15 -0
package/dist/devices/electricalUtilityMeter.js +16 -16
package/dist/matterNode.js +10 -1
package/dist/matterbridge.js +10 -1
package/dist/matterbridgeEndpoint.d.ts +3 -2
package/dist/matterbridgeEndpoint.js +36 -8
package/dist/matterbridgeEndpointHelpers.js +1 -1
package/dist/matterbridgeFactory.d.ts +1 -0
package/dist/matterbridgeFactory.js +18 -2
package/package.json +5 -5

package/dist/behaviors/doorLockServer.js CHANGED Viewed

@@ -122,11 +122,10 @@ export class MatterbridgeDoorLockServer extends DoorLockServer.with(DoorLock.Fea
             context: this.context,
         });
         device.log.debug(`MatterbridgeDoorLockServer: setCredential called for userIndex ${request.userIndex} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        const auth = this.auth;
-        if (auth.isDuplicateCredential(request.credential.credentialType, request.credentialData, request.credential.credentialIndex)) {
+        if (this.auth.isDuplicateCredential(request.credential.credentialType, request.credentialData, request.credential.credentialIndex)) {
             throw new DoorLock.DuplicateError(`MatterbridgeDoorLockServer: credential data duplicates another credential of the same type (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         }
-        if (request.operationType === DoorLock.DataOperationType.Add && auth.findCredential(request.credential.credentialType, request.credential.credentialIndex)) {
+        if (request.operationType === DoorLock.DataOperationType.Add && this.auth.findCredential(request.credential.credentialType, request.credential.credentialIndex)) {
             throw new DoorLock.OccupiedError(`MatterbridgeDoorLockServer: add operation targets an occupied credential index (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         }
         return await super.setCredential(request);

package/dist/behaviors/thermostatServer.js CHANGED Viewed

@@ -1,6 +1,6 @@
 import { Bytes } from '@matter/general';
 import { ThermostatServer } from '@matter/node/behaviors/thermostat';
-import { StatusResponse } from '@matter/types';
+import { Status, StatusResponseError } from '@matter/types';
 import { Thermostat } from '@matter/types/clusters/thermostat';
 import { MatterbridgeServer } from './matterbridgeServer.js';
 export class MatterbridgeThermostatServer extends ThermostatServer.with(Thermostat.Feature.Cooling, Thermostat.Feature.Heating, Thermostat.Feature.AutoMode, Thermostat.Feature.Presets, Thermostat.Feature.MatterScheduleConfiguration, Thermostat.Feature.ThermostatSuggestions) {
@@ -30,18 +30,18 @@ export class MatterbridgeThermostatServer extends ThermostatServer.with(Thermost
             return;
         const device = this.endpoint.stateOf(MatterbridgeServer);
         if (remainingSuggestions.length !== currentSuggestions.length) {
-            device.log.info(`Removing ${currentSuggestions.length - remainingSuggestions.length} thermostat suggestion(s) referencing removed preset(s) (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+            device.log.info(`MatterbridgeThermostatServer: removing ${currentSuggestions.length - remainingSuggestions.length} thermostat suggestion(s) referencing removed preset(s) (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
             this.state.thermostatSuggestions = remainingSuggestions;
         }
         if (clearCurrentSuggestion) {
-            device.log.info(`Clearing current thermostat suggestion referencing a removed preset (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+            device.log.info(`MatterbridgeThermostatServer: clearing current thermostat suggestion referencing a removed preset (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
             this.state.currentThermostatSuggestion = null;
             this.state.thermostatSuggestionNotFollowingReason = null;
         }
     }
     async setpointRaiseLower(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Setting setpoint by ${request.amount} in mode ${request.mode} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.log.info(`MatterbridgeThermostatServer: setting setpoint by ${request.amount} in mode ${request.mode} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('Thermostat.setpointRaiseLower', {
             command: 'setpointRaiseLower',
             request,
@@ -51,13 +51,13 @@ export class MatterbridgeThermostatServer extends ThermostatServer.with(Thermost
             context: this.context,
         });
         const lookupSetpointAdjustMode = ['Heat', 'Cool', 'Both'];
-        device.log.debug(`MatterbridgeThermostatServer: setpointRaiseLower called with mode: ${lookupSetpointAdjustMode[request.mode]} amount: ${request.amount / 10}`);
+        device.log.debug(`MatterbridgeThermostatServer: setpointRaiseLower called with mode: ${lookupSetpointAdjustMode[request.mode]} amount: ${request.amount / 10} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.setpointRaiseLower(request);
     }
     async setActivePresetRequest(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         const presetHandle = request.presetHandle ? `0x${Buffer.from(request.presetHandle).toString('hex')}` : 'null';
-        device.log.info(`Setting preset to ${presetHandle} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.log.info(`MatterbridgeThermostatServer: setting preset to ${presetHandle} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('Thermostat.setActivePresetRequest', {
             command: 'setActivePresetRequest',
             request,
@@ -66,15 +66,15 @@ export class MatterbridgeThermostatServer extends ThermostatServer.with(Thermost
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeThermostatServer: setActivePresetRequest called with presetHandle: ${presetHandle}`);
+        device.log.debug(`MatterbridgeThermostatServer: setActivePresetRequest called with presetHandle: ${presetHandle} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.setActivePresetRequest(request);
         const activePresetHandle = this.state.activePresetHandle ? `0x${Buffer.from(this.state.activePresetHandle).toString('hex')}` : 'null';
-        device.log.debug(`MatterbridgeThermostatServer: setActivePresetRequest completed with activePresetHandle: ${activePresetHandle} occupiedHeatingSetpoint: ${this.state.occupiedHeatingSetpoint} occupiedCoolingSetpoint: ${this.state.occupiedCoolingSetpoint}`);
+        device.log.debug(`MatterbridgeThermostatServer: setActivePresetRequest completed with activePresetHandle: ${activePresetHandle} occupiedHeatingSetpoint: ${this.state.occupiedHeatingSetpoint} occupiedCoolingSetpoint: ${this.state.occupiedCoolingSetpoint} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
     }
     async setActiveScheduleRequest(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         const scheduleHandle = `0x${Buffer.from(request.scheduleHandle).toString('hex')}`;
-        device.log.info(`Setting schedule to ${scheduleHandle} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.log.info(`MatterbridgeThermostatServer: setting schedule to ${scheduleHandle} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('Thermostat.setActiveScheduleRequest', {
             command: 'setActiveScheduleRequest',
             request,
@@ -85,10 +85,10 @@ export class MatterbridgeThermostatServer extends ThermostatServer.with(Thermost
         });
         const schedule = this.state.schedules.find((s) => s.scheduleHandle !== null && Bytes.areEqual(s.scheduleHandle, request.scheduleHandle));
         if (schedule === undefined) {
-            throw new StatusResponse.InvalidCommandError('Requested ScheduleHandle not found');
+            throw new StatusResponseError(`MatterbridgeThermostatServer: requested ScheduleHandle not found (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.InvalidCommand);
         }
         this.state.activeScheduleHandle = Uint8Array.from(request.scheduleHandle);
-        device.log.debug(`MatterbridgeThermostatServer: setActiveScheduleRequest completed with activeScheduleHandle: ${scheduleHandle}`);
+        device.log.debug(`MatterbridgeThermostatServer: setActiveScheduleRequest completed with activeScheduleHandle: ${scheduleHandle} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
     }
     removeExpiredThermostatSuggestions() {
         const now = Math.floor(Date.now() / 1000);
@@ -112,7 +112,7 @@ export class MatterbridgeThermostatServer extends ThermostatServer.with(Thermost
     async addThermostatSuggestion(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         const presetHandle = `0x${Buffer.from(request.presetHandle).toString('hex')}`;
-        device.log.info(`Adding thermostat suggestion for preset ${presetHandle} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.log.info(`MatterbridgeThermostatServer: adding thermostat suggestion for preset ${presetHandle} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('Thermostat.addThermostatSuggestion', {
             command: 'addThermostatSuggestion',
             request,
@@ -122,17 +122,17 @@ export class MatterbridgeThermostatServer extends ThermostatServer.with(Thermost
             context: this.context,
         });
         if (this.state.presets.find((p) => p.presetHandle !== null && Bytes.areEqual(p.presetHandle, request.presetHandle)) === undefined) {
-            throw new StatusResponse.NotFoundError('Requested PresetHandle not found');
+            throw new StatusResponseError(`MatterbridgeThermostatServer: requested PresetHandle not found (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.NotFound);
         }
         this.removeExpiredThermostatSuggestions();
         this.reEvaluateCurrentThermostatSuggestion();
         if (this.state.thermostatSuggestions.length >= this.state.maxThermostatSuggestions) {
-            throw new StatusResponse.ResourceExhaustedError('Maximum number of thermostat suggestions reached');
+            throw new StatusResponseError(`MatterbridgeThermostatServer: maximum number of thermostat suggestions reached (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.ResourceExhausted);
         }
         const currentTime = Math.floor(Date.now() / 1000);
         const effectiveTime = request.effectiveTime ?? currentTime;
         if (effectiveTime > currentTime + 24 * 60 * 60) {
-            throw new StatusResponse.InvalidCommandError('EffectiveTime cannot be more than 24 hours in the future');
+            throw new StatusResponseError(`MatterbridgeThermostatServer: requested EffectiveTime is more than 24 hours in the future (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.InvalidCommand);
         }
         const usedUniqueIds = new Set(this.state.thermostatSuggestions.map((s) => s.uniqueId));
         let uniqueId = 0;
@@ -146,12 +146,12 @@ export class MatterbridgeThermostatServer extends ThermostatServer.with(Thermost
         };
         this.state.thermostatSuggestions = [...this.state.thermostatSuggestions, suggestion];
         this.reEvaluateCurrentThermostatSuggestion();
-        device.log.debug(`MatterbridgeThermostatServer: addThermostatSuggestion completed with uniqueId: ${uniqueId}`);
+        device.log.debug(`MatterbridgeThermostatServer: addThermostatSuggestion completed with uniqueId: ${uniqueId} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         return { uniqueId };
     }
     async removeThermostatSuggestion(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Removing thermostat suggestion ${request.uniqueId} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.log.info(`MatterbridgeThermostatServer: removing thermostat suggestion ${request.uniqueId} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('Thermostat.removeThermostatSuggestion', {
             command: 'removeThermostatSuggestion',
             request,
@@ -162,11 +162,11 @@ export class MatterbridgeThermostatServer extends ThermostatServer.with(Thermost
         });
         const suggestion = this.state.thermostatSuggestions.find((s) => s.uniqueId === request.uniqueId);
         if (suggestion === undefined) {
-            throw new StatusResponse.NotFoundError('Requested UniqueID not found');
+            throw new StatusResponseError(`MatterbridgeThermostatServer: requested UniqueID not found (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.NotFound);
         }
         this.state.thermostatSuggestions = this.state.thermostatSuggestions.filter((s) => s.uniqueId !== request.uniqueId);
         this.removeExpiredThermostatSuggestions();
         this.reEvaluateCurrentThermostatSuggestion();
-        device.log.debug(`MatterbridgeThermostatServer: removeThermostatSuggestion completed for uniqueId: ${request.uniqueId}`);
+        device.log.debug(`MatterbridgeThermostatServer: removeThermostatSuggestion completed for uniqueId: ${request.uniqueId} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
     }
 }

package/dist/behaviors/windowCoveringServer.d.ts CHANGED Viewed

@@ -1,4 +1,5 @@
-import { type WindowCoveringBaseServer, WindowCoveringServer } from '@matter/node/behaviors/window-covering';
+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, {
     lift: true;
@@ -7,7 +8,9 @@ declare const MatterbridgeWindowCoveringServer_base: import("@matter/node").Clus
     tilt: true;
 }>, import("@matter/types").ClusterType.Concrete, typeof WindowCoveringBaseServer.Internal, "windowCovering">;
 export declare class MatterbridgeWindowCoveringServer extends MatterbridgeWindowCoveringServer_base {
-    protected internal: WindowCoveringBaseServer.Internal;
+    #private;
+    readonly state: MatterbridgeWindowCoveringServer.State;
+    protected internal: MatterbridgeWindowCoveringServer.Internal;
     lookupMovementStatus: string[];
     private getMovementStatusLabel;
     initialize(): void;
@@ -16,6 +19,17 @@ export declare class MatterbridgeWindowCoveringServer extends MatterbridgeWindow
     stopMotion(): Promise<void>;
     goToLiftPercentage(request: WindowCovering.GoToLiftPercentageRequest): Promise<void>;
     goToTiltPercentage(request: WindowCovering.GoToTiltPercentageRequest): Promise<void>;
-    handleMovement(): void;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+export declare namespace MatterbridgeWindowCoveringServer {
+    class Internal extends WindowCoveringBaseServer.Internal {
+        liftMovementTimer?: Timer;
+        liftMovementTarget: number;
+        tiltMovementTimer?: Timer;
+        tiltMovementTarget: number;
+    }
+    class State extends WindowCoveringBaseServer.State {
+        movementDuration: number;
+    }
 }
 export {};

package/dist/behaviors/windowCoveringServer.js CHANGED Viewed

@@ -1,4 +1,5 @@
-import { WindowCoveringServer } from '@matter/node/behaviors/window-covering';
+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';
 export class MatterbridgeWindowCoveringServer extends WindowCoveringServer.with(WindowCovering.Feature.Lift, WindowCovering.Feature.PositionAwareLift, WindowCovering.Feature.Tilt, WindowCovering.Feature.PositionAwareTilt) {
@@ -8,13 +9,73 @@ export class MatterbridgeWindowCoveringServer extends WindowCoveringServer.with(
     }
     initialize() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Initializing MatterbridgeWindowCoveringServer (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.log.info(`MatterbridgeWindowCoveringServer: initializing (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         this.internal.disableOperationalModeHandling = true;
+        if (process.env.MATTERBRIDGE_CHIP_TEST) {
+            this.state.movementDuration = 3000;
+        }
         super.initialize();
+        if (this.features.positionAwareLift)
+            this.reactTo(this.events.currentPositionLiftPercent100ths$Changing, this.#syncLiftCurrentPositionPercentage);
+        if (this.features.positionAwareTilt)
+            this.reactTo(this.events.currentPositionTiltPercent100ths$Changing, this.#syncTiltCurrentPositionPercentage);
+    }
+    #syncLiftCurrentPositionPercentage(percent100ths) {
+        this.state.currentPositionLiftPercentage = percent100ths === null ? percent100ths : Math.floor(percent100ths / 100);
+    }
+    #syncTiltCurrentPositionPercentage(percent100ths) {
+        this.state.currentPositionTiltPercentage = percent100ths === null ? percent100ths : Math.floor(percent100ths / 100);
+    }
+    #computeMovementStatus(target, current) {
+        if (current === null || target === null || current === target)
+            return WindowCovering.MovementStatus.Stopped;
+        return current < target ? WindowCovering.MovementStatus.Closing : WindowCovering.MovementStatus.Opening;
+    }
+    #updateGlobalOperationalStatus() {
+        const { lift, tilt } = this.state.operationalStatus;
+        this.state.operationalStatus.global = lift === WindowCovering.MovementStatus.Stopped ? tilt : lift;
+    }
+    #startLiftMovement(targetPercent100ths) {
+        this.internal.liftMovementTimer?.stop();
+        this.internal.liftMovementTimer = undefined;
+        if (this.state.movementDuration <= 0)
+            return;
+        const status = this.#computeMovementStatus(targetPercent100ths, this.state.currentPositionLiftPercent100ths);
+        this.state.operationalStatus.lift = status;
+        this.#updateGlobalOperationalStatus();
+        if (status === WindowCovering.MovementStatus.Stopped)
+            return;
+        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) {
+        this.internal.tiltMovementTimer?.stop();
+        this.internal.tiltMovementTimer = undefined;
+        if (this.state.movementDuration <= 0)
+            return;
+        const status = this.#computeMovementStatus(targetPercent100ths, this.state.currentPositionTiltPercent100ths);
+        this.state.operationalStatus.tilt = status;
+        this.#updateGlobalOperationalStatus();
+        if (status === WindowCovering.MovementStatus.Stopped)
+            return;
+        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(`Opening cover (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.log.info(`MatterbridgeWindowCoveringServer: opening cover (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('WindowCovering.upOrOpen', {
             command: 'upOrOpen',
             request: {},
@@ -23,13 +84,17 @@ export class MatterbridgeWindowCoveringServer extends WindowCoveringServer.with(
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeWindowCoveringServer: upOrOpen called`);
+        device.log.debug(`MatterbridgeWindowCoveringServer: upOrOpen called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.upOrOpen();
-        device.log.debug(`MatterbridgeWindowCoveringServer: upOrOpen result target ${this.state.targetPositionLiftPercent100ths} current ${this.state.currentPositionLiftPercent100ths} status global ${this.getMovementStatusLabel(this.state.operationalStatus.global)} lift ${this.getMovementStatusLabel(this.state.operationalStatus.lift)} tilt ${this.getMovementStatusLabel(this.state.operationalStatus.tilt)}`);
+        if (this.features.positionAwareLift && this.state.targetPositionLiftPercent100ths !== null)
+            this.#startLiftMovement(this.state.targetPositionLiftPercent100ths);
+        if (this.features.positionAwareTilt && this.state.targetPositionTiltPercent100ths !== null)
+            this.#startTiltMovement(this.state.targetPositionTiltPercent100ths);
+        device.log.debug(`MatterbridgeWindowCoveringServer: upOrOpen result target ${this.state.targetPositionLiftPercent100ths} current ${this.state.currentPositionLiftPercent100ths} 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 downOrClose() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Closing cover (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.log.info(`MatterbridgeWindowCoveringServer: closing cover (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('WindowCovering.downOrClose', {
             command: 'downOrClose',
             request: {},
@@ -38,13 +103,17 @@ export class MatterbridgeWindowCoveringServer extends WindowCoveringServer.with(
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeWindowCoveringServer: downOrClose called`);
+        device.log.debug(`MatterbridgeWindowCoveringServer: downOrClose called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.downOrClose();
-        device.log.debug(`MatterbridgeWindowCoveringServer: downOrClose result target ${this.state.targetPositionLiftPercent100ths} current ${this.state.currentPositionLiftPercent100ths} status global ${this.getMovementStatusLabel(this.state.operationalStatus.global)} lift ${this.getMovementStatusLabel(this.state.operationalStatus.lift)} tilt ${this.getMovementStatusLabel(this.state.operationalStatus.tilt)}`);
+        if (this.features.positionAwareLift && this.state.targetPositionLiftPercent100ths !== null)
+            this.#startLiftMovement(this.state.targetPositionLiftPercent100ths);
+        if (this.features.positionAwareTilt && this.state.targetPositionTiltPercent100ths !== null)
+            this.#startTiltMovement(this.state.targetPositionTiltPercent100ths);
+        device.log.debug(`MatterbridgeWindowCoveringServer: downOrClose result target ${this.state.targetPositionLiftPercent100ths} current ${this.state.currentPositionLiftPercent100ths} 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 stopMotion() {
         const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Stopping cover (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.log.info(`MatterbridgeWindowCoveringServer: stopping cover (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('WindowCovering.stopMotion', {
             command: 'stopMotion',
             request: {},
@@ -53,13 +122,24 @@ export class MatterbridgeWindowCoveringServer extends WindowCoveringServer.with(
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeWindowCoveringServer: stopMotion called`);
+        device.log.debug(`MatterbridgeWindowCoveringServer: stopMotion called (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.stopMotion();
-        device.log.debug(`MatterbridgeWindowCoveringServer: stopMotion result target ${this.state.targetPositionLiftPercent100ths} current ${this.state.currentPositionLiftPercent100ths} status global ${this.getMovementStatusLabel(this.state.operationalStatus.global)} lift ${this.getMovementStatusLabel(this.state.operationalStatus.lift)} tilt ${this.getMovementStatusLabel(this.state.operationalStatus.tilt)}`);
+        this.internal.liftMovementTimer?.stop();
+        this.internal.liftMovementTimer = undefined;
+        this.internal.tiltMovementTimer?.stop();
+        this.internal.tiltMovementTimer = undefined;
+        if (this.state.movementDuration > 0) {
+            if (this.features.positionAwareLift)
+                this.state.targetPositionLiftPercent100ths = this.state.currentPositionLiftPercent100ths;
+            if (this.features.positionAwareTilt)
+                this.state.targetPositionTiltPercent100ths = this.state.currentPositionTiltPercent100ths;
+            this.state.operationalStatus = { global: WindowCovering.MovementStatus.Stopped, lift: WindowCovering.MovementStatus.Stopped, tilt: WindowCovering.MovementStatus.Stopped };
+        }
+        device.log.debug(`MatterbridgeWindowCoveringServer: stopMotion result target ${this.state.targetPositionLiftPercent100ths} current ${this.state.currentPositionLiftPercent100ths} 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 goToLiftPercentage(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Setting cover lift percentage to ${request.liftPercent100thsValue} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.log.info(`MatterbridgeWindowCoveringServer: setting cover lift percentage to ${request.liftPercent100thsValue} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('WindowCovering.goToLiftPercentage', {
             command: 'goToLiftPercentage',
             request,
@@ -68,13 +148,15 @@ export class MatterbridgeWindowCoveringServer extends WindowCoveringServer.with(
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeWindowCoveringServer: goToLiftPercentage with ${request.liftPercent100thsValue}`);
+        device.log.debug(`MatterbridgeWindowCoveringServer: goToLiftPercentage with ${request.liftPercent100thsValue} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.goToLiftPercentage(request);
-        device.log.debug(`MatterbridgeWindowCoveringServer: goToLiftPercentage result target ${this.state.targetPositionLiftPercent100ths} current ${this.state.currentPositionLiftPercent100ths} status global ${this.getMovementStatusLabel(this.state.operationalStatus.global)} lift ${this.getMovementStatusLabel(this.state.operationalStatus.lift)} tilt ${this.getMovementStatusLabel(this.state.operationalStatus.tilt)}`);
+        if (this.state.targetPositionLiftPercent100ths !== null)
+            this.#startLiftMovement(this.state.targetPositionLiftPercent100ths);
+        device.log.debug(`MatterbridgeWindowCoveringServer: goToLiftPercentage result target ${this.state.targetPositionLiftPercent100ths} current ${this.state.currentPositionLiftPercent100ths} 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 goToTiltPercentage(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
-        device.log.info(`Setting cover tilt percentage to ${request.tiltPercent100thsValue} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.log.info(`MatterbridgeWindowCoveringServer: setting cover tilt percentage to ${request.tiltPercent100thsValue} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await device.commandHandler.executeHandler('WindowCovering.goToTiltPercentage', {
             command: 'goToTiltPercentage',
             request,
@@ -83,10 +165,30 @@ export class MatterbridgeWindowCoveringServer extends WindowCoveringServer.with(
             endpoint: this.endpoint,
             context: this.context,
         });
-        device.log.debug(`MatterbridgeWindowCoveringServer: goToTiltPercentage with ${request.tiltPercent100thsValue}`);
+        device.log.debug(`MatterbridgeWindowCoveringServer: goToTiltPercentage with ${request.tiltPercent100thsValue} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         await super.goToTiltPercentage(request);
-        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)}`);
+        if (this.state.targetPositionTiltPercent100ths !== null)
+            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})`);
     }
-    handleMovement() {
+    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 {
+        movementDuration = 0;
+    }
+    MatterbridgeWindowCoveringServer.State = State;
+})(MatterbridgeWindowCoveringServer || (MatterbridgeWindowCoveringServer = {}));

package/dist/demoDevices.js CHANGED Viewed

@@ -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';
@@ -10,6 +10,7 @@ import { PowerTopology } from '@matter/types/clusters/power-topology';
 import { ResourceMonitoring } from '@matter/types/clusters/resource-monitoring';
 import { RvcCleanMode } from '@matter/types/clusters/rvc-clean-mode';
 import { RvcRunMode } from '@matter/types/clusters/rvc-run-mode';
+import { Thermostat } from '@matter/types/clusters/thermostat';
 import { EndpointNumber } from '@matter/types/datatype';
 import { getErrorMessage } from '@matterbridge/utils/error';
 import { AirConditioner } from './devices/airConditioner.js';
@@ -266,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();
@@ -348,11 +374,15 @@ export async function createDemoDevices(matterbridge) {
     await registerDevice(ep, 'Door Lock User PIN Schedules', 'ENTRY-08-01-2');
     ep = new MatterbridgeEndpoint([getSupportedDeviceType('DoorLockController'), bridgedNode, powerSource], { id: 'DoorLockController', number: EndpointNumber(8_02) });
     await registerDevice(ep, 'Door Lock Controller', 'ENTRY-08-02');
-    ep = new MatterbridgeEndpoint([getSupportedDeviceType('WindowCovering'), bridgedNode, powerSource], { id: 'WindowCovering', number: EndpointNumber(8_03) });
-    await registerDevice(ep, 'Window Covering', 'ENTRY-08-03');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('WindowCovering'), bridgedNode, powerSource], { id: 'WindowCoveringLift', number: EndpointNumber(8_03) });
+    ep.createDefaultWindowCoveringClusterServer();
+    await registerDevice(ep, 'Window Covering Lift', 'ENTRY-08-03');
     ep = new MatterbridgeEndpoint([getSupportedDeviceType('WindowCovering'), bridgedNode, powerSource], { id: 'WindowCoveringTilt', number: EndpointNumber(8_03_1) });
-    ep.createDefaultLiftTiltWindowCoveringClusterServer();
+    ep.createDefaultTiltWindowCoveringClusterServer();
     await registerDevice(ep, 'Window Covering Tilt', 'ENTRY-08-03-1');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('WindowCovering'), bridgedNode, powerSource], { id: 'WindowCoveringLiftTilt', number: EndpointNumber(8_03_2) });
+    ep.createDefaultLiftTiltWindowCoveringClusterServer();
+    await registerDevice(ep, 'Window Covering LiftTilt', 'ENTRY-08-03-2');
     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', {
@@ -443,8 +473,9 @@ export async function createDemoDevices(matterbridge) {
     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) });
-    await registerDevice(ep, 'Thermostat', 'HVAC-09-01');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('Thermostat'), bridgedNode, powerSource], { id: 'ThermostatAuto', number: EndpointNumber(9_01) });
+    ep.createDefaultThermostatClusterServer(23, 21, 25, 2, 0, 47, 3, 50);
+    await registerDevice(ep, 'Thermostat Auto', 'HVAC-09-01');
     ep = new MatterbridgeEndpoint([getSupportedDeviceType('Thermostat'), bridgedNode, powerSource], { id: 'ThermostatHeating', number: EndpointNumber(9_01_1) });
     ep.createDefaultHeatingThermostatClusterServer();
     await registerDevice(ep, 'Thermostat Heating', 'HVAC-09-01-1');
@@ -458,7 +489,13 @@ export async function createDemoDevices(matterbridge) {
     ep.createDefaultSchedulesThermostatClusterServer();
     await registerDevice(ep, 'Thermostat Schedules', 'HVAC-09-01-4');
     ep = new MatterbridgeEndpoint([getSupportedDeviceType('Thermostat'), bridgedNode, powerSource], { id: 'ThermostatSuggestions', number: EndpointNumber(9_01_5) });
-    ep.createDefaultThermostatSuggestionsClusterServer();
+    ep.createDefaultThermostatSuggestionsClusterServer(23, 21, 25, 0, 0, 50, 0, 50, undefined, undefined, undefined, undefined, null, [
+        { presetHandle: Uint8Array.from([0]), presetScenario: Thermostat.PresetScenario.Occupied, name: 'Occupied', coolingSetpoint: 2500, heatingSetpoint: 2100, builtIn: true },
+        { presetHandle: Uint8Array.from([1]), presetScenario: Thermostat.PresetScenario.Unoccupied, name: 'Unoccupied', coolingSetpoint: 2700, heatingSetpoint: 1900, builtIn: true },
+    ], [
+        { presetScenario: Thermostat.PresetScenario.Occupied, numberOfPresets: 4, presetTypeFeatures: { automatic: false, supportsNames: true } },
+        { presetScenario: Thermostat.PresetScenario.Unoccupied, numberOfPresets: 4, presetTypeFeatures: { automatic: false, supportsNames: true } },
+    ]);
     await registerDevice(ep, 'Thermostat Suggestions', 'HVAC-09-01-5');
     ep = new MatterbridgeEndpoint([getSupportedDeviceType('Fan'), bridgedNode, powerSource], { id: 'Fan', number: EndpointNumber(9_02) });
     await registerDevice(ep, 'Fan OffLowMedHighAuto', 'HVAC-09-02');

package/dist/devices/closure.d.ts CHANGED Viewed

@@ -36,6 +36,8 @@ export declare namespace MatterbridgeClosureControlServer {
         movementDuration: number;
         calibrationDuration: number;
         signaturePosition: number;
+        ventilationPosition: number;
+        pedestrianPosition: number;
     }
 }
 export interface ClosureOptions {
@@ -51,6 +53,8 @@ export interface ClosureOptions {
     movementDuration?: number;
     calibrationDuration?: number;
     signaturePosition?: number;
+    ventilationPosition?: number;
+    pedestrianPosition?: number;
     motionLatching?: boolean;
     speed?: boolean;
     ventilation?: boolean;
@@ -64,10 +68,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 CHANGED Viewed

@@ -175,12 +175,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 +225,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 +236,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 +299,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/electricalUtilityMeter.d.ts CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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/matterNode.js CHANGED Viewed

@@ -407,7 +407,16 @@ export class MatterNode extends EventEmitter {
             this.log.warn(`Invalid discriminator ${discriminator} for server node ${storeId}. Discriminator must be between 0 and 4095 (0xFFF). Generating a random discriminator...`);
             discriminator = PaseClient.generateRandomDiscriminator(this.environment.get(Crypto));
         }
-        const rootEndpoint = hasParameter('root-power-source') ? ServerNode.RootEndpoint.with(PowerSourceServer.with(PowerSource.Feature.Wired)) : ServerNode.RootEndpoint;
+        let rootEndpoint;
+        if (hasParameter('root-power-source') || process.env.MATTERBRIDGE_CHIP_TEST) {
+            this.log.warn(' ****************************************************************************************');
+            this.log.warn(' * Adding the PowerSource cluster server to the root endpoint.                           *');
+            this.log.warn(' ****************************************************************************************');
+            rootEndpoint = ServerNode.RootEndpoint.with(PowerSourceServer.with(PowerSource.Feature.Wired));
+        }
+        else {
+            rootEndpoint = ServerNode.RootEndpoint;
+        }
         const serverNode = await ServerNode.create(rootEndpoint, {
             id: storeId,
             environment: this.environment,

package/dist/matterbridge.js CHANGED Viewed

@@ -1893,7 +1893,16 @@ export class Matterbridge extends EventEmitter {
             this.log.warn(`Invalid discriminator ${discriminator} for server node ${storeId}. Discriminator must be between 0 and 4095 (0xFFF). Generating a random discriminator...`);
             discriminator = PaseClient.generateRandomDiscriminator(this.environment.get(Crypto));
         }
-        let rootEndpoint = hasParameter('root-power-source') ? ServerNode.RootEndpoint.with(PowerSourceServer.with(PowerSource.Feature.Wired)) : ServerNode.RootEndpoint;
+        let rootEndpoint;
+        if (hasParameter('root-power-source') || process.env.MATTERBRIDGE_CHIP_TEST) {
+            this.log.warn(' ****************************************************************************************');
+            this.log.warn(' * Adding the PowerSource cluster server to the root endpoint.                           *');
+            this.log.warn(' ****************************************************************************************');
+            rootEndpoint = ServerNode.RootEndpoint.with(PowerSourceServer.with(PowerSource.Feature.Wired));
+        }
+        else {
+            rootEndpoint = ServerNode.RootEndpoint;
+        }
         if (process.env.MATTERBRIDGE_CHIP_TEST && fs.existsSync(path.join(path.dirname(fileURLToPath(import.meta.url)), 'chipTests.js'))) {
             this.log.warn(' ****************************************************************************************');
             this.log.warn(' * MATTERBRIDGE_CHIP_TEST environment variable is set. Running TestEventTrigger server. *');

package/dist/matterbridgeEndpoint.d.ts CHANGED Viewed

@@ -171,8 +171,9 @@ export declare class MatterbridgeEndpoint extends Endpoint {
     createCtColorControlClusterServer(colorTemperatureMireds?: number, colorTempPhysicalMinMireds?: number, colorTempPhysicalMaxMireds?: number): this;
     configureColorControlMode(colorMode: ColorControl.ColorMode): Promise<void>;
     configureEnhancedColorControlMode(colorMode: ColorControl.EnhancedColorMode): Promise<void>;
-    createDefaultWindowCoveringClusterServer(positionPercent100ths?: number, type?: WindowCovering.WindowCoveringType, endProductType?: WindowCovering.EndProductType): this;
-    createDefaultLiftTiltWindowCoveringClusterServer(positionLiftPercent100ths?: number, positionTiltPercent100ths?: number, type?: WindowCovering.WindowCoveringType, endProductType?: WindowCovering.EndProductType): this;
+    createDefaultWindowCoveringClusterServer(positionPercent100ths?: number | null, type?: WindowCovering.WindowCoveringType, endProductType?: WindowCovering.EndProductType, movementDuration?: number): this;
+    createDefaultLiftTiltWindowCoveringClusterServer(positionLiftPercent100ths?: number | null, positionTiltPercent100ths?: number | null, type?: WindowCovering.WindowCoveringType, endProductType?: WindowCovering.EndProductType, movementDuration?: number): this;
+    createDefaultTiltWindowCoveringClusterServer(positionTiltPercent100ths?: number | null, type?: WindowCovering.WindowCoveringType, endProductType?: WindowCovering.EndProductType, movementDuration?: number): this;
     setWindowCoveringTargetAsCurrentAndStopped(): Promise<void>;
     setWindowCoveringCurrentTargetStatus(current: number, target: number, status: WindowCovering.MovementStatus): Promise<void>;
     setWindowCoveringStatus(status: WindowCovering.MovementStatus): Promise<void>;

package/dist/matterbridgeEndpoint.js CHANGED Viewed

@@ -825,7 +825,7 @@ export class MatterbridgeEndpoint extends Endpoint {
             await this.setAttribute(ColorControl.id, 'enhancedColorMode', colorMode, this.log);
         }
     }
-    createDefaultWindowCoveringClusterServer(positionPercent100ths, type = WindowCovering.WindowCoveringType.Rollershade, endProductType = WindowCovering.EndProductType.RollerShade) {
+    createDefaultWindowCoveringClusterServer(positionPercent100ths = 0, type = WindowCovering.WindowCoveringType.Rollershade, endProductType = WindowCovering.EndProductType.RollerShade, movementDuration = 0) {
         this.behaviors.require(MatterbridgeWindowCoveringServer.with(WindowCovering.Feature.Lift, WindowCovering.Feature.PositionAwareLift), {
             type,
             numberOfActuationsLift: 0,
@@ -841,12 +841,14 @@ export class MatterbridgeEndpoint extends Endpoint {
             operationalStatus: { global: WindowCovering.MovementStatus.Stopped, lift: WindowCovering.MovementStatus.Stopped, tilt: WindowCovering.MovementStatus.Stopped },
             endProductType,
             mode: { motorDirectionReversed: false, calibrationMode: false, maintenanceMode: false, ledFeedback: false },
-            targetPositionLiftPercent100ths: positionPercent100ths ?? 0,
-            currentPositionLiftPercent100ths: positionPercent100ths ?? 0,
+            targetPositionLiftPercent100ths: positionPercent100ths,
+            currentPositionLiftPercent100ths: positionPercent100ths,
+            currentPositionLiftPercentage: positionPercent100ths === null ? null : Math.floor(positionPercent100ths / 100),
+            movementDuration,
         });
         return this;
     }
-    createDefaultLiftTiltWindowCoveringClusterServer(positionLiftPercent100ths, positionTiltPercent100ths, type = WindowCovering.WindowCoveringType.TiltBlindLift, endProductType = WindowCovering.EndProductType.InteriorBlind) {
+    createDefaultLiftTiltWindowCoveringClusterServer(positionLiftPercent100ths = 0, positionTiltPercent100ths = 0, type = WindowCovering.WindowCoveringType.TiltBlindLift, endProductType = WindowCovering.EndProductType.InteriorBlind, movementDuration = 0) {
         this.behaviors.require(MatterbridgeWindowCoveringServer.with(WindowCovering.Feature.Lift, WindowCovering.Feature.PositionAwareLift, WindowCovering.Feature.Tilt, WindowCovering.Feature.PositionAwareTilt), {
             type,
             numberOfActuationsLift: 0,
@@ -863,10 +865,36 @@ export class MatterbridgeEndpoint extends Endpoint {
             operationalStatus: { global: WindowCovering.MovementStatus.Stopped, lift: WindowCovering.MovementStatus.Stopped, tilt: WindowCovering.MovementStatus.Stopped },
             endProductType,
             mode: { motorDirectionReversed: false, calibrationMode: false, maintenanceMode: false, ledFeedback: false },
-            targetPositionLiftPercent100ths: positionLiftPercent100ths ?? 0,
-            currentPositionLiftPercent100ths: positionLiftPercent100ths ?? 0,
-            targetPositionTiltPercent100ths: positionTiltPercent100ths ?? 0,
-            currentPositionTiltPercent100ths: positionTiltPercent100ths ?? 0,
+            targetPositionLiftPercent100ths: positionLiftPercent100ths,
+            currentPositionLiftPercent100ths: positionLiftPercent100ths,
+            currentPositionLiftPercentage: positionLiftPercent100ths === null ? null : Math.floor(positionLiftPercent100ths / 100),
+            targetPositionTiltPercent100ths: positionTiltPercent100ths,
+            currentPositionTiltPercent100ths: positionTiltPercent100ths,
+            currentPositionTiltPercentage: positionTiltPercent100ths === null ? null : Math.floor(positionTiltPercent100ths / 100),
+            movementDuration,
+        });
+        return this;
+    }
+    createDefaultTiltWindowCoveringClusterServer(positionTiltPercent100ths = 0, type = WindowCovering.WindowCoveringType.TiltBlindTiltOnly, endProductType = WindowCovering.EndProductType.InteriorVenetianBlind, movementDuration = 0) {
+        this.behaviors.require(MatterbridgeWindowCoveringServer.with(WindowCovering.Feature.Tilt, WindowCovering.Feature.PositionAwareTilt), {
+            type,
+            numberOfActuationsTilt: 0,
+            configStatus: {
+                operational: true,
+                onlineReserved: false,
+                liftMovementReversed: false,
+                liftPositionAware: false,
+                tiltPositionAware: true,
+                liftEncoderControlled: false,
+                tiltEncoderControlled: false,
+            },
+            operationalStatus: { global: WindowCovering.MovementStatus.Stopped, lift: WindowCovering.MovementStatus.Stopped, tilt: WindowCovering.MovementStatus.Stopped },
+            endProductType,
+            mode: { motorDirectionReversed: false, calibrationMode: false, maintenanceMode: false, ledFeedback: false },
+            targetPositionTiltPercent100ths: positionTiltPercent100ths,
+            currentPositionTiltPercent100ths: positionTiltPercent100ths,
+            currentPositionTiltPercentage: positionTiltPercent100ths === null ? null : Math.floor(positionTiltPercent100ths / 100),
+            movementDuration,
         });
         return this;
     }

package/dist/matterbridgeEndpointHelpers.js CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.10.8-dev-20260831-e73fc65",
+  "version": "3.10.8-dev-20260901-971f7bf",
   "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-20260831-e73fc65",
-    "@matterbridge/thread": "3.10.8-dev-20260831-e73fc65",
-    "@matterbridge/types": "3.10.8-dev-20260831-e73fc65",
-    "@matterbridge/utils": "3.10.8-dev-20260831-e73fc65",
+    "@matterbridge/dgram": "3.10.8-dev-20260901-971f7bf",
+    "@matterbridge/thread": "3.10.8-dev-20260901-971f7bf",
+    "@matterbridge/types": "3.10.8-dev-20260901-971f7bf",
+    "@matterbridge/utils": "3.10.8-dev-20260901-971f7bf",
     "escape-html": "1.0.3",
     "express": "5.2.1",
     "express-rate-limit": "8.7.0",