@matterbridge/core 3.10.15-dev-20261020-1bd3061 → 3.11.0-dev-20261022-eb1098c

package/dist/backend.js

@@ -329,7 +329,7 @@ export class Backend extends EventEmitter {
     }
     async getApiSettings() {
         const start = performance.now();
-        const response = await this.server.fetch({ type: 'matterbridge_apisettings', src: 'frontend', dst: 'matterbridge', params: undefined });
+        const response = await this.server.fetch({ type: 'matterbridge_apisettings', src: 'frontend', dst: 'matterbridge', params: {} });
         if (this.diagnostic)
             writeDiagnostic('Backend', `getApiSettings() took ${(performance.now() - start).toFixed(2)} ms`);
         return response.result.data;

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/behaviors/cameraAvStreamManagementServer.js

@@ -42,8 +42,6 @@ export class MatterbridgeCameraAvStreamManagementServer extends MatterbridgeCame
                     minBitRate,
                     maxBitRate: minBitRate * 4,
                     keyFrameInterval: 4000,
-                    ...(this.features.watermark ? { watermarkEnabled: false } : {}),
-                    ...(this.features.onScreenDisplay ? { osdEnabled: false } : {}),
                     referenceCount: 0,
                 },
             ];
@@ -87,8 +85,6 @@ export class MatterbridgeCameraAvStreamManagementServer extends MatterbridgeCame
                     referenceCount: 0,
                     encodedPixels: false,
                     hardwareEncoder: false,
-                    ...(this.features.watermark ? { watermarkEnabled: false } : {}),
-                    ...(this.features.onScreenDisplay ? { osdEnabled: false } : {}),
                 },
             ];
         }

package/dist/behaviors/colorControlServer.d.ts

@@ -2,7 +2,19 @@ import type { MaybePromise } from '@matter/general';
 import { ColorControlServer } from '@matter/node/behaviors/color-control';
 import { ColorControl } from '@matter/types/clusters/color-control';
 import type { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
-declare const MatterbridgeColorControlServer_base: import("@matter/node").ClusterBehavior.Type<typeof ColorControlServer, import("@matter/types").ClusterType.WithSupportedFeatures<ColorControl, {
+declare const MatterbridgeColorControlServer_base: import("@matter/node").ClusterBehavior.Type<typeof ColorControlServer, import("@matter/types").ClusterType.WithSupportedFeatures<import("@matter/types").ClusterType.WithSupportedFeatures<import("@matter/types").ClusterType.WithSupportedFeatures<ColorControl, {
+    colorLoop: true;
+    colorTemperature: true;
+    enhancedHue: true;
+    hueSaturation: true;
+    xy: true;
+}>, {
+    colorLoop: false;
+    colorTemperature: false;
+    enhancedHue: false;
+    hueSaturation: false;
+    xy: false;
+}>, {
     colorLoop: false;
     colorTemperature: true;
     enhancedHue: true;

package/dist/behaviors/doorLockServer.d.ts

@@ -1,7 +1,35 @@
 import { DoorLockServer } from '@matter/node/behaviors/door-lock';
 import { DoorLock } from '@matter/types/clusters/door-lock';
 import type { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
-declare const MatterbridgeDoorLockServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/node").ClusterBehavior.Type<typeof DoorLockServer, import("@matter/types").ClusterType.WithSupportedFeatures<DoorLock, {
+declare const MatterbridgeDoorLockServer_base: import("@matter/node").ClusterBehavior.Type<import("@matter/node").ClusterBehavior.Type<typeof DoorLockServer, import("@matter/types").ClusterType.WithSupportedFeatures<import("@matter/types").ClusterType.WithSupportedFeatures<import("@matter/types").ClusterType.WithSupportedFeatures<DoorLock, {
+    aliroBleuwb: false;
+    aliroProvisioning: false;
+    credentialOverTheAirAccess: true;
+    doorPositionSensor: true;
+    faceCredentials: true;
+    fingerCredentials: true;
+    holidaySchedules: true;
+    pinCredential: true;
+    rfidCredential: true;
+    unbolting: true;
+    user: true;
+    weekDayAccessSchedules: true;
+    yearDayAccessSchedules: true;
+}>, {
+    aliroBleuwb: false;
+    aliroProvisioning: false;
+    credentialOverTheAirAccess: false;
+    doorPositionSensor: false;
+    faceCredentials: false;
+    fingerCredentials: false;
+    holidaySchedules: false;
+    pinCredential: false;
+    rfidCredential: false;
+    unbolting: false;
+    user: false;
+    weekDayAccessSchedules: false;
+    yearDayAccessSchedules: false;
+}>, {
     aliroBleuwb: false;
     aliroProvisioning: false;
     credentialOverTheAirAccess: false;
@@ -15,7 +43,35 @@ declare const MatterbridgeDoorLockServer_base: import("@matter/node").ClusterBeh
     user: true;
     weekDayAccessSchedules: true;
     yearDayAccessSchedules: true;
-}>, import("@matter/types").ClusterType.Concrete, typeof import("@matter/node/behaviors/door-lock").DoorLockBaseServer.Internal, "doorLock">, import("@matter/types").ClusterType.WithEnabledAttributes<import("@matter/types").ClusterType.WithEnabledEvents<import("@matter/types").ClusterType.WithSupportedFeatures<DoorLock, {
+}>, import("@matter/types").ClusterType.Concrete, typeof import("@matter/node/behaviors/door-lock").DoorLockBaseServer.Internal, "doorLock">, import("@matter/types").ClusterType.WithEnabledAttributes<import("@matter/types").ClusterType.WithEnabledEvents<import("@matter/types").ClusterType.WithSupportedFeatures<import("@matter/types").ClusterType.WithSupportedFeatures<import("@matter/types").ClusterType.WithSupportedFeatures<DoorLock, {
+    aliroBleuwb: false;
+    aliroProvisioning: false;
+    credentialOverTheAirAccess: true;
+    doorPositionSensor: true;
+    faceCredentials: true;
+    fingerCredentials: true;
+    holidaySchedules: true;
+    pinCredential: true;
+    rfidCredential: true;
+    unbolting: true;
+    user: true;
+    weekDayAccessSchedules: true;
+    yearDayAccessSchedules: true;
+}>, {
+    aliroBleuwb: false;
+    aliroProvisioning: false;
+    credentialOverTheAirAccess: false;
+    doorPositionSensor: false;
+    faceCredentials: false;
+    fingerCredentials: false;
+    holidaySchedules: false;
+    pinCredential: false;
+    rfidCredential: false;
+    unbolting: false;
+    user: false;
+    weekDayAccessSchedules: false;
+    yearDayAccessSchedules: false;
+}>, {
     aliroBleuwb: false;
     aliroProvisioning: false;
     credentialOverTheAirAccess: false;

package/dist/behaviors/smokeCoAlarmServer.d.ts

@@ -2,7 +2,13 @@ import { type Timer } from '@matter/general';
 import { SmokeCoAlarmServer } from '@matter/node/behaviors/smoke-co-alarm';
 import { SmokeCoAlarm } from '@matter/types/clusters/smoke-co-alarm';
 import type { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
-declare const MatterbridgeSmokeCoAlarmServer_base: import("@matter/node").ClusterBehavior.Type<typeof SmokeCoAlarmServer, import("@matter/types").ClusterType.WithSupportedFeatures<SmokeCoAlarm, {
+declare const MatterbridgeSmokeCoAlarmServer_base: import("@matter/node").ClusterBehavior.Type<typeof SmokeCoAlarmServer, import("@matter/types").ClusterType.WithSupportedFeatures<import("@matter/types").ClusterType.WithSupportedFeatures<import("@matter/types").ClusterType.WithSupportedFeatures<SmokeCoAlarm, {
+    coAlarm: true;
+    smokeAlarm: true;
+}>, {
+    coAlarm: false;
+    smokeAlarm: false;
+}>, {
     coAlarm: true;
     smokeAlarm: true;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "smokeCoAlarm">;

package/dist/behaviors/thermostatServer.d.ts

@@ -1,7 +1,29 @@
 import { ThermostatServer } from '@matter/node/behaviors/thermostat';
 import { Thermostat } from '@matter/types/clusters/thermostat';
 import type { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
-declare const MatterbridgeThermostatServer_base: import("@matter/node").ClusterBehavior.Type<typeof ThermostatServer, import("@matter/types").ClusterType.WithSupportedFeatures<Thermostat, {
+declare const MatterbridgeThermostatServer_base: import("@matter/node").ClusterBehavior.Type<typeof ThermostatServer, import("@matter/types").ClusterType.WithSupportedFeatures<import("@matter/types").ClusterType.WithSupportedFeatures<import("@matter/types").ClusterType.WithSupportedFeatures<Thermostat, {
+    autoMode: true;
+    cooling: true;
+    events: false;
+    heating: true;
+    localTemperatureNotExposed: false;
+    matterScheduleConfiguration: false;
+    occupancy: true;
+    presets: true;
+    setback: false;
+    thermostatSuggestions: false;
+}>, {
+    autoMode: false;
+    cooling: false;
+    events: false;
+    heating: false;
+    localTemperatureNotExposed: false;
+    matterScheduleConfiguration: false;
+    occupancy: false;
+    presets: false;
+    setback: false;
+    thermostatSuggestions: false;
+}>, {
     autoMode: true;
     cooling: true;
     events: false;

package/dist/behaviors/windowCoveringServer.d.ts

@@ -2,7 +2,17 @@ import { type Timer } from '@matter/general';
 import { WindowCoveringBaseServer, WindowCoveringServer } from '@matter/node/behaviors/window-covering';
 import { WindowCovering } from '@matter/types/clusters/window-covering';
 import type { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
-declare const MatterbridgeWindowCoveringServer_base: import("@matter/node").ClusterBehavior.Type<typeof WindowCoveringServer, import("@matter/types").ClusterType.WithSupportedFeatures<WindowCovering, {
+declare const MatterbridgeWindowCoveringServer_base: import("@matter/node").ClusterBehavior.Type<typeof WindowCoveringServer, import("@matter/types").ClusterType.WithSupportedFeatures<import("@matter/types").ClusterType.WithSupportedFeatures<import("@matter/types").ClusterType.WithSupportedFeatures<WindowCovering, {
+    lift: true;
+    positionAwareLift: true;
+    positionAwareTilt: true;
+    tilt: true;
+}>, {
+    lift: false;
+    positionAwareLift: false;
+    positionAwareTilt: false;
+    tilt: false;
+}>, {
     lift: true;
     positionAwareLift: true;
     positionAwareTilt: true;

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;
@@ -787,7 +802,7 @@ async function handleMeterIdentificationTestEventTrigger(eventTrigger) {
 }
 const commodityMeteringFakeValues = {
     maximumMeteredQuantities: 8,
-    meteredQuantity: [{ tariffComponentIDs: [1], quantity: 1_234 }],
+    meteredQuantity: [{ tariffComponentIds: [1], quantity: 1_234 }],
     meteredQuantityTimestamp: Math.floor(Date.now() / 1000),
     tariffUnit: TariffUnit.KWh,
 };
@@ -843,8 +858,8 @@ const commodityTariffTariffComponents = [
     },
 ];
 const commodityTariffTariffPeriods = [
-    { label: 'Morning', dayEntryIDs: [1], tariffComponentIDs: [100] },
-    { label: 'Afternoon', dayEntryIDs: [2], tariffComponentIDs: [101] },
+    { label: 'Morning', dayEntryIds: [1], tariffComponentIds: [100] },
+    { label: 'Afternoon', dayEntryIds: [2], tariffComponentIds: [101] },
 ];
 const commodityTariffClearedValues = {
     tariffInfo: null,
@@ -870,12 +885,12 @@ let commodityTariffEntryIndex = 0;
 function buildCommodityTariffFakeValues(dayOffset, entryIndex) {
     const anchor = Math.floor(Date.now() / 86_400_000) * 86_400;
     const tariffStartDate = anchor - 365 * 86_400;
-    const dayOf = (offset) => ({ date: anchor + offset * 86_400, dayType: CommodityTariff.DayType.Standard, dayEntryIDs: [1, 2] });
+    const dayOf = (offset) => ({ date: anchor + offset * 86_400, dayType: CommodityTariff.DayType.Standard, dayEntryIds: [1, 2] });
     const entryDate = (offset, idx) => anchor + offset * 86_400 + commodityTariffDayEntries[idx].startTime * 60;
     const nextEntry = entryIndex === commodityTariffDayEntries.length - 1 ? { offset: dayOffset + 1, idx: 0 } : { offset: dayOffset, idx: entryIndex + 1 };
     const tariffComponentsFor = (dayEntryId) => commodityTariffTariffPeriods
-        .filter((period) => period.dayEntryIDs.includes(dayEntryId))
-        .flatMap((period) => period.tariffComponentIDs)
+        .filter((period) => period.dayEntryIds.includes(dayEntryId))
+        .flatMap((period) => period.tariffComponentIds)
         .map((id) => commodityTariffTariffComponents.find((component) => component.tariffComponentId === id))
         .filter((component) => component !== undefined);
     return {
@@ -888,9 +903,9 @@ function buildCommodityTariffFakeValues(dayOffset, entryIndex) {
         tariffUnit: TariffUnit.KWh,
         startDate: tariffStartDate,
         dayEntries: commodityTariffDayEntries,
-        dayPatterns: [{ dayPatternId: commodityTariffDayPatternId, daysOfWeek: commodityTariffAllDaysOfWeek, dayEntryIDs: [1, 2] }],
-        calendarPeriods: [{ startDate: tariffStartDate, dayPatternIDs: [commodityTariffDayPatternId] }],
-        individualDays: [{ date: anchor - 30 * 86_400, dayType: CommodityTariff.DayType.Holiday, dayEntryIDs: [1, 2] }],
+        dayPatterns: [{ dayPatternId: commodityTariffDayPatternId, daysOfWeek: commodityTariffAllDaysOfWeek, dayEntryIds: [1, 2] }],
+        calendarPeriods: [{ startDate: tariffStartDate, dayPatternIds: [commodityTariffDayPatternId] }],
+        individualDays: [{ date: anchor - 30 * 86_400, dayType: CommodityTariff.DayType.Holiday, dayEntryIds: [1, 2] }],
         currentDay: dayOf(dayOffset),
         nextDay: dayOf(dayOffset + 1),
         currentDayEntry: commodityTariffDayEntries[entryIndex],
@@ -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/dist/devices/electricalUtilityMeter.js

@@ -46,8 +46,8 @@ export class MatterbridgeCommodityTariffServer extends CommodityTariffServer.wit
         if (!tariffComponent) {
             throw new StatusResponse.NotFoundError(`MatterbridgeCommodityTariffServer: no TariffComponent with id ${request.tariffComponentId} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         }
-        const period = (this.state.tariffPeriods ?? []).find((p) => p.tariffComponentIDs.includes(request.tariffComponentId));
-        const response = { label: period?.label ?? null, dayEntryIDs: period?.dayEntryIDs ?? [], tariffComponent };
+        const period = (this.state.tariffPeriods ?? []).find((p) => p.tariffComponentIds.includes(request.tariffComponentId));
+        const response = { label: period?.label ?? null, dayEntryIds: period?.dayEntryIds ?? [], tariffComponent };
         this.endpoint.emitCommand(CommodityTariff, 'getTariffComponent', request, this.context);
         return response;
     }

package/dist/devices/roboticVacuumCleaner.js

@@ -240,7 +240,8 @@ export class MatterbridgeRvcOperationalStateServer extends MatterbridgeRvcOperat
         if (this.state.operationalState === RvcOperationalState.OperationalState.Paused) {
             return { commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateDetails: 'Already paused' } };
         }
-        if (this.state.operationalState !== RvcOperationalState.OperationalState.Running && this.state.operationalState !== RvcOperationalState.OperationalState.SeekingCharger) {
+        if (this.state.operationalState !== RvcOperationalState.OperationalState.Running &&
+            this.state.operationalState !== RvcOperationalState.OperationalState.SeekingCharger) {
             return {
                 commandResponseState: { errorStateId: OperationalState.ErrorState.CommandInvalidInState, errorStateDetails: 'Not Pause-compatible in the current operational state' },
             };

package/dist/frontend.d.ts

@@ -27,10 +27,6 @@ export declare class Frontend extends EventEmitter<FrontendEvents> {
     private readonly debug;
     private readonly verbose;
     private readonly diagnostic;
-    readonly readOnly: boolean;
-    restartRequired: boolean;
-    fixedRestartRequired: boolean;
-    updateRequired: boolean;
     constructor(matterbridge: Matterbridge);
     destroy(): void;
     private broadcastMsgHandler;