@matterbridge/core 3.11.0-dev-20261021-c0f9ee2 → 3.11.0-dev-20261022-ad61eed

package/dist/behaviors/cameraAvSettingsUserLevelManagementServer.d.ts

@@ -1,3 +1,4 @@
+import { type Timer } from '@matter/general';
 import { CameraAvSettingsUserLevelManagementServer } from '@matter/node/behaviors/camera-av-settings-user-level-management';
 import { CameraAvSettingsUserLevelManagement } from '@matter/types/clusters/camera-av-settings-user-level-management';
 import type { CameraAvStreamManagement } from '@matter/types/clusters/camera-av-stream-management';
@@ -11,6 +12,7 @@ declare const MatterbridgeCameraAvSettingsUserLevelManagementServer_base: import
     mechanicalZoom: true;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "cameraAvSettingsUserLevelManagement">;
 export declare class MatterbridgeCameraAvSettingsUserLevelManagementServer extends MatterbridgeCameraAvSettingsUserLevelManagementServer_base {
+    #private;
     readonly endpoint: MatterbridgeEndpoint;
     protected internal: MatterbridgeCameraAvSettingsUserLevelManagementServer.Internal;
     initialize(): void;
@@ -26,10 +28,13 @@ export declare class MatterbridgeCameraAvSettingsUserLevelManagementServer exten
     private applyDptzViewport;
     dptzSetViewport(request: CameraAvSettingsUserLevelManagement.DptzSetViewportRequest): void;
     dptzRelativeMove(request: CameraAvSettingsUserLevelManagement.DptzRelativeMoveRequest): void;
+    [Symbol.asyncDispose](): Promise<void>;
 }
 export declare namespace MatterbridgeCameraAvSettingsUserLevelManagementServer {
     class Internal {
         lastGeneratedPresetId: number;
+        movementTimer?: Timer;
+        movementTarget?: CameraAvSettingsUserLevelManagement.Mptz;
     }
 }
 export interface CameraAvSettingsUserLevelManagementClusterOptions {

package/dist/behaviors/cameraAvSettingsUserLevelManagementServer.js

@@ -1,9 +1,11 @@
+import { Millis, Time } from '@matter/general';
 import { CameraAvSettingsUserLevelManagementServer } from '@matter/node/behaviors/camera-av-settings-user-level-management';
 import { CameraAvSettingsUserLevelManagement } from '@matter/types/clusters/camera-av-settings-user-level-management';
 import { StatusResponseError } from '@matter/types/common';
 import { Status } from '@matter/types/globals';
 import { MatterbridgeCameraAvStreamManagementServer } from './cameraAvStreamManagementServer.js';
 import { MatterbridgeServer } from './matterbridgeServer.js';
+const MPTZ_MOVEMENT_DURATION = Millis(100);
 function clamp(value, min, max) {
     return Math.min(Math.max(value, min), max);
 }
@@ -56,12 +58,14 @@ export class MatterbridgeCameraAvSettingsUserLevelManagementServer extends Camer
         if (zoom !== undefined && (zoom < 1 || zoom > this.state.zoomMax)) {
             throw new StatusResponseError(`MatterbridgeCameraAvSettingsUserLevelManagementServer: zoom ${zoom} is outside of the supported range [1, ${this.state.zoomMax}] (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.ConstraintError);
         }
-        this.state.mptzPosition = {
+        this.#assertNotMoving('mptzSetPosition');
+        const target = {
             pan: pan ?? this.state.mptzPosition.pan,
             tilt: tilt ?? this.state.mptzPosition.tilt,
             zoom: zoom ?? this.state.mptzPosition.zoom,
         };
-        device.log.info(`MatterbridgeCameraAvSettingsUserLevelManagementServer: set mechanical PTZ position to pan ${this.state.mptzPosition.pan}°, tilt ${this.state.mptzPosition.tilt}°, zoom ${this.state.mptzPosition.zoom} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        device.log.info(`MatterbridgeCameraAvSettingsUserLevelManagementServer: set mechanical PTZ position to pan ${target.pan}°, tilt ${target.tilt}°, zoom ${target.zoom} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        this.#startMovement(target);
         this.endpoint.emitCommand(CameraAvSettingsUserLevelManagement, 'mptzSetPosition', request, this.context);
     }
     mptzRelativeMove(request) {
@@ -69,12 +73,13 @@ export class MatterbridgeCameraAvSettingsUserLevelManagementServer extends Camer
         if (request.panDelta === undefined && request.tiltDelta === undefined && request.zoomDelta === undefined) {
             throw new StatusResponseError(`MatterbridgeCameraAvSettingsUserLevelManagementServer: mptzRelativeMove requires at least one of panDelta, tiltDelta or zoomDelta to be present (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.InvalidCommand);
         }
+        this.#assertNotMoving('mptzRelativeMove');
         const current = this.state.mptzPosition;
         const pan = request.panDelta === undefined ? current.pan : clamp((current.pan ?? 0) + request.panDelta, this.state.panMin, this.state.panMax);
         const tilt = request.tiltDelta === undefined ? current.tilt : clamp((current.tilt ?? 0) + request.tiltDelta, this.state.tiltMin, this.state.tiltMax);
         const zoom = request.zoomDelta === undefined ? current.zoom : clamp((current.zoom ?? 1) + request.zoomDelta, 1, this.state.zoomMax);
-        this.state.mptzPosition = { pan, tilt, zoom };
         device.log.info(`MatterbridgeCameraAvSettingsUserLevelManagementServer: moved mechanical PTZ position by pan ${request.panDelta ?? 0}°, tilt ${request.tiltDelta ?? 0}°, zoom ${request.zoomDelta ?? 0} to pan ${pan}°, tilt ${tilt}°, zoom ${zoom} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        this.#startMovement({ pan, tilt, zoom });
         this.endpoint.emitCommand(CameraAvSettingsUserLevelManagement, 'mptzRelativeMove', request, this.context);
     }
     mptzMoveToPreset(request) {
@@ -87,10 +92,28 @@ export class MatterbridgeCameraAvSettingsUserLevelManagementServer extends Camer
         if (preset === undefined) {
             throw new StatusResponseError(`MatterbridgeCameraAvSettingsUserLevelManagementServer: presetId ${presetId} is not present in mptzPresets (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.NotFound);
         }
-        this.state.mptzPosition = preset.settings;
+        this.#assertNotMoving('mptzMoveToPreset');
         device.log.info(`MatterbridgeCameraAvSettingsUserLevelManagementServer: moved mechanical PTZ position to preset ${presetId} "${preset.name}": pan ${preset.settings.pan}°, tilt ${preset.settings.tilt}°, zoom ${preset.settings.zoom} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        this.#startMovement(preset.settings);
         this.endpoint.emitCommand(CameraAvSettingsUserLevelManagement, 'mptzMoveToPreset', request, this.context);
     }
+    #assertNotMoving(command) {
+        if (this.state.movementState === CameraAvSettingsUserLevelManagement.PhysicalMovement.Moving) {
+            throw new StatusResponseError(`MatterbridgeCameraAvSettingsUserLevelManagementServer: ${command} rejected, the camera is already moving (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.Busy);
+        }
+    }
+    #startMovement(target) {
+        this.state.movementState = CameraAvSettingsUserLevelManagement.PhysicalMovement.Moving;
+        this.internal.movementTarget = target;
+        this.internal.movementTimer = Time.getTimer('CameraAvSettingsUserLevelManagement movement complete', MPTZ_MOVEMENT_DURATION, this.callback(this.#completeMovement, { lock: true })).start();
+    }
+    #completeMovement() {
+        this.internal.movementTimer = undefined;
+        if (this.internal.movementTarget !== undefined)
+            this.state.mptzPosition = this.internal.movementTarget;
+        this.internal.movementTarget = undefined;
+        this.state.movementState = CameraAvSettingsUserLevelManagement.PhysicalMovement.Idle;
+    }
     mptzSavePreset(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         const { presetId, name } = request;
@@ -205,10 +228,17 @@ export class MatterbridgeCameraAvSettingsUserLevelManagementServer extends Camer
         device.log.info(`MatterbridgeCameraAvSettingsUserLevelManagementServer: moved the viewport of video stream ${videoStreamId} by deltaX ${deltaX ?? 0}, deltaY ${deltaY ?? 0}, zoomDelta ${zoomDelta ?? 0} to (${viewport.x1}, ${viewport.y1})-(${viewport.x2}, ${viewport.y2}) (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         this.endpoint.emitCommand(CameraAvSettingsUserLevelManagement, 'dptzRelativeMove', request, this.context);
     }
+    async [Symbol.asyncDispose]() {
+        this.internal.movementTimer?.stop();
+        this.internal.movementTimer = undefined;
+        await super[Symbol.asyncDispose]?.();
+    }
 }
 (function (MatterbridgeCameraAvSettingsUserLevelManagementServer) {
     class Internal {
         lastGeneratedPresetId = 0;
+        movementTimer;
+        movementTarget;
     }
     MatterbridgeCameraAvSettingsUserLevelManagementServer.Internal = Internal;
 })(MatterbridgeCameraAvSettingsUserLevelManagementServer || (MatterbridgeCameraAvSettingsUserLevelManagementServer = {}));

package/dist/chipTests.js

@@ -52,6 +52,11 @@ const smokeCoAlarmHardwareFaultAlertTrigger = 0xffffffff00000093n;
 const smokeCoAlarmHardwareFaultAlertClearTrigger = 0xffffffff000000a3n;
 const smokeCoAlarmEndOfServiceAlertTrigger = 0xffffffff0000009an;
 const smokeCoAlarmEndOfServiceAlertClearTrigger = 0xffffffff000000aan;
+const smokeCoAlarmYamlCriticalBatteryAlertTrigger = 0x005c00000000009en;
+const smokeCoAlarmYamlHardwareFaultAlertTrigger = 0x005c000000000093n;
+const smokeCoAlarmYamlHardwareFaultAlertClearTrigger = 0x005c0000000000a3n;
+const smokeCoAlarmYamlEndOfServiceAlertTrigger = 0x005c00000000009an;
+const smokeCoAlarmYamlEndOfServiceAlertClearTrigger = 0x005c0000000000aan;
 const smokeCoAlarmDeviceMutedTrigger = 0x005c00000000009bn;
 const smokeCoAlarmDeviceMutedClearTrigger = 0x005c0000000000abn;
 const electricalPowerMeasurementStartFakeLoadTrigger = 0x0091000000000001n;
@@ -299,7 +304,7 @@ export function createChipTestAppPipe(matterbridge) {
                 return;
             matterbridge.log.error(`CHIP test app pipe ${chipTestAppPipePath} read error: ${error instanceof Error ? error.message : String(error)}`);
         }
-    }, 50);
+    }, 10);
     pollInterval.unref();
     const closePipeWithInterval = () => {
         clearInterval(pollInterval);
@@ -340,6 +345,11 @@ async function handleChipTestEventTrigger(eventTrigger) {
         normalizedEventTrigger !== normalizeTestEventTrigger(smokeCoAlarmHardwareFaultAlertClearTrigger) &&
         normalizedEventTrigger !== normalizeTestEventTrigger(smokeCoAlarmEndOfServiceAlertTrigger) &&
         normalizedEventTrigger !== normalizeTestEventTrigger(smokeCoAlarmEndOfServiceAlertClearTrigger) &&
+        normalizedEventTrigger !== normalizeTestEventTrigger(smokeCoAlarmYamlCriticalBatteryAlertTrigger) &&
+        normalizedEventTrigger !== normalizeTestEventTrigger(smokeCoAlarmYamlHardwareFaultAlertTrigger) &&
+        normalizedEventTrigger !== normalizeTestEventTrigger(smokeCoAlarmYamlHardwareFaultAlertClearTrigger) &&
+        normalizedEventTrigger !== normalizeTestEventTrigger(smokeCoAlarmYamlEndOfServiceAlertTrigger) &&
+        normalizedEventTrigger !== normalizeTestEventTrigger(smokeCoAlarmYamlEndOfServiceAlertClearTrigger) &&
         normalizedEventTrigger !== normalizeTestEventTrigger(smokeCoAlarmDeviceMutedTrigger) &&
         normalizedEventTrigger !== normalizeTestEventTrigger(smokeCoAlarmDeviceMutedClearTrigger)) {
         return ((await handleElectricalEnergyTestEventTrigger(normalizedEventTrigger)) ||
@@ -606,6 +616,7 @@ async function applySmokeCoAlarmTestEventTrigger(endpoint, eventTrigger, log) {
             await endpoint.triggerEvent(SmokeCoAlarm, 'lowBattery', { alarmSeverityLevel: SmokeCoAlarm.AlarmState.Warning }, log);
             return;
         case normalizeTestEventTrigger(smokeCoAlarmCriticalBatteryAlertTrigger):
+        case normalizeTestEventTrigger(smokeCoAlarmYamlCriticalBatteryAlertTrigger):
             await endpoint.setCluster(SmokeCoAlarm, { batteryAlert: SmokeCoAlarm.AlarmState.Critical, expressedState: getSmokeCoAlarmExpressedState(endpoint, { batteryAlert: SmokeCoAlarm.AlarmState.Critical }) }, log);
             await endpoint.triggerEvent(SmokeCoAlarm, 'lowBattery', { alarmSeverityLevel: SmokeCoAlarm.AlarmState.Critical }, log);
             return;
@@ -615,18 +626,22 @@ async function applySmokeCoAlarmTestEventTrigger(endpoint, eventTrigger, log) {
             await endpoint.triggerEvent(SmokeCoAlarm, 'allClear', undefined, log);
             return;
         case normalizeTestEventTrigger(smokeCoAlarmHardwareFaultAlertTrigger):
+        case normalizeTestEventTrigger(smokeCoAlarmYamlHardwareFaultAlertTrigger):
             await endpoint.setCluster(SmokeCoAlarm, { hardwareFaultAlert: true, expressedState: SmokeCoAlarm.ExpressedState.HardwareFault }, log);
             await endpoint.triggerEvent(SmokeCoAlarm, 'hardwareFault', undefined, log);
             return;
         case normalizeTestEventTrigger(smokeCoAlarmHardwareFaultAlertClearTrigger):
+        case normalizeTestEventTrigger(smokeCoAlarmYamlHardwareFaultAlertClearTrigger):
             await endpoint.setCluster(SmokeCoAlarm, { hardwareFaultAlert: false, expressedState: SmokeCoAlarm.ExpressedState.Normal }, log);
             await endpoint.triggerEvent(SmokeCoAlarm, 'allClear', undefined, log);
             return;
         case normalizeTestEventTrigger(smokeCoAlarmEndOfServiceAlertTrigger):
+        case normalizeTestEventTrigger(smokeCoAlarmYamlEndOfServiceAlertTrigger):
             await endpoint.setCluster(SmokeCoAlarm, { endOfServiceAlert: SmokeCoAlarm.EndOfService.Expired, expressedState: SmokeCoAlarm.ExpressedState.EndOfService }, log);
             await endpoint.triggerEvent(SmokeCoAlarm, 'endOfService', undefined, log);
             return;
         case normalizeTestEventTrigger(smokeCoAlarmEndOfServiceAlertClearTrigger):
+        case normalizeTestEventTrigger(smokeCoAlarmYamlEndOfServiceAlertClearTrigger):
             await endpoint.setCluster(SmokeCoAlarm, { endOfServiceAlert: SmokeCoAlarm.EndOfService.Normal, expressedState: SmokeCoAlarm.ExpressedState.Normal }, log);
             await endpoint.triggerEvent(SmokeCoAlarm, 'allClear', undefined, log);
             return;
@@ -1172,6 +1187,10 @@ async function handleChipTestAppPipeCommand(matterbridge, command) {
         case 'SimulateLongPress':
             await simulateChipTestSwitchLongPress(matterbridge, endpoint, endpointId, command);
             return;
+        case 'LongPress':
+            await endpoint.invokeBehaviorCommand(SmokeCoAlarm, 'selfTestRequest');
+            matterbridge.log.info(`CHIP test app pipe started the SmokeCoAlarm self-test on endpoint ${endpointId}`);
+            return;
         case 'SimulateLatchPosition': {
             const newPosition = command.PositionId ?? 0;
             if (endpoint.getAttribute(Switch.id, 'currentPosition', matterbridge.log) === newPosition) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.11.0-dev-20261021-c0f9ee2",
+  "version": "3.11.0-dev-20261022-ad61eed",
   "description": "Matterbridge core library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -136,10 +136,10 @@
   },
   "dependencies": {
     "@matter/main": "0.18.0",
-    "@matterbridge/dgram": "3.11.0-dev-20261021-c0f9ee2",
-    "@matterbridge/thread": "3.11.0-dev-20261021-c0f9ee2",
-    "@matterbridge/types": "3.11.0-dev-20261021-c0f9ee2",
-    "@matterbridge/utils": "3.11.0-dev-20261021-c0f9ee2",
+    "@matterbridge/dgram": "3.11.0-dev-20261022-ad61eed",
+    "@matterbridge/thread": "3.11.0-dev-20261022-ad61eed",
+    "@matterbridge/types": "3.11.0-dev-20261022-ad61eed",
+    "@matterbridge/utils": "3.11.0-dev-20261022-ad61eed",
     "escape-html": "1.0.3",
     "express": "5.3.0",
     "express-rate-limit": "8.7.1",