@matterbridge/core 3.10.8-dev-20260831-e73fc65 → 3.10.8-dev-20260901-c4963a1

package/dist/behaviors/doorLockServer.js

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

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

@@ -1,4 +1,4 @@
-import { type WindowCoveringBaseServer, WindowCoveringServer } from '@matter/node/behaviors/window-covering';
+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 +7,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 +18,14 @@ export declare class MatterbridgeWindowCoveringServer extends MatterbridgeWindow
     stopMotion(): Promise<void>;
     goToLiftPercentage(request: WindowCovering.GoToLiftPercentageRequest): Promise<void>;
     goToTiltPercentage(request: WindowCovering.GoToTiltPercentageRequest): Promise<void>;
-    handleMovement(): void;
+}
+export declare namespace MatterbridgeWindowCoveringServer {
+    class Internal extends WindowCoveringBaseServer.Internal {
+        liftMovementTimer?: NodeJS.Timeout;
+        tiltMovementTimer?: NodeJS.Timeout;
+    }
+    class State extends WindowCoveringBaseServer.State {
+        movementDuration: number;
+    }
 }
 export {};

package/dist/behaviors/windowCoveringServer.js

@@ -1,4 +1,4 @@
-import { WindowCoveringServer } from '@matter/node/behaviors/window-covering';
+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 +8,77 @@ 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) {
+        clearTimeout(this.internal.liftMovementTimer);
+        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.liftMovementTimer = setTimeout(() => {
+            this.internal.liftMovementTimer = undefined;
+            void this.#completeLiftMovement(targetPercent100ths);
+        }, this.state.movementDuration);
+    }
+    #completeLiftMovement = async (targetPercent100ths) => {
+        const windowCovering = this.endpoint;
+        await windowCovering.setAttribute(WindowCovering, 'currentPositionLiftPercent100ths', targetPercent100ths);
+        const tilt = windowCovering.getAttribute(WindowCovering, 'operationalStatus')?.tilt ?? WindowCovering.MovementStatus.Stopped;
+        await windowCovering.setAttribute(WindowCovering, 'operationalStatus', { global: tilt, lift: WindowCovering.MovementStatus.Stopped, tilt });
+    };
+    #startTiltMovement(targetPercent100ths) {
+        clearTimeout(this.internal.tiltMovementTimer);
+        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.tiltMovementTimer = setTimeout(() => {
+            this.internal.tiltMovementTimer = undefined;
+            void this.#completeTiltMovement(targetPercent100ths);
+        }, this.state.movementDuration);
+    }
+    #completeTiltMovement = async (targetPercent100ths) => {
+        const windowCovering = this.endpoint;
+        await windowCovering.setAttribute(WindowCovering, 'currentPositionTiltPercent100ths', targetPercent100ths);
+        const lift = windowCovering.getAttribute(WindowCovering, 'operationalStatus')?.lift ?? WindowCovering.MovementStatus.Stopped;
+        await windowCovering.setAttribute(WindowCovering, 'operationalStatus', { global: lift, lift, tilt: WindowCovering.MovementStatus.Stopped });
+    };
     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 +87,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 +106,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 +125,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)}`);
+        clearTimeout(this.internal.liftMovementTimer);
+        this.internal.liftMovementTimer = undefined;
+        clearTimeout(this.internal.tiltMovementTimer);
+        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 +151,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 +168,21 @@ 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)}`);
-    }
-    handleMovement() {
+        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})`);
     }
 }
+(function (MatterbridgeWindowCoveringServer) {
+    class Internal extends WindowCoveringBaseServer.Internal {
+        liftMovementTimer;
+        tiltMovementTimer;
+    }
+    MatterbridgeWindowCoveringServer.Internal = Internal;
+    class State extends WindowCoveringBaseServer.State {
+        movementDuration = 0;
+    }
+    MatterbridgeWindowCoveringServer.State = State;
+})(MatterbridgeWindowCoveringServer || (MatterbridgeWindowCoveringServer = {}));

package/dist/demoDevices.js

@@ -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';
@@ -348,11 +349,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 +448,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 +464,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/matterNode.js

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

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

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

@@ -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/package.json

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