@matterbridge/core 3.10.10-dev-20260914-784e019 → 3.10.10-dev-20260917-9fdf275

package/dist/behaviors/cameraAvSettingsUserLevelManagementServer.d.ts

@@ -1,17 +1,36 @@
 import { CameraAvSettingsUserLevelManagementServer } from '@matter/node/behaviors/camera-av-settings-user-level-management';
+import { type Viewport } from '@matter/types';
 import { CameraAvSettingsUserLevelManagement } from '@matter/types/clusters/camera-av-settings-user-level-management';
+import type { CameraAvStreamManagement } from '@matter/types/clusters/camera-av-stream-management';
 import type { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 declare const MatterbridgeCameraAvSettingsUserLevelManagementServer_base: import("@matter/node").ClusterBehavior.Type<typeof CameraAvSettingsUserLevelManagementServer, import("@matter/types").ClusterType.WithSupportedFeatures<CameraAvSettingsUserLevelManagement, {
-    digitalPtz: false;
+    digitalPtz: true;
     mechanicalPan: true;
-    mechanicalPresets: false;
+    mechanicalPresets: true;
     mechanicalTilt: true;
     mechanicalZoom: true;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "cameraAvSettingsUserLevelManagement">;
 export declare class MatterbridgeCameraAvSettingsUserLevelManagementServer extends MatterbridgeCameraAvSettingsUserLevelManagementServer_base {
     readonly endpoint: MatterbridgeEndpoint;
+    protected internal: MatterbridgeCameraAvSettingsUserLevelManagementServer.Internal;
+    initialize(): void;
+    protected syncDptzStreams(allocatedVideoStreams: CameraAvStreamManagement.VideoStream[]): void;
+    protected syncDptzViewport(viewport: Viewport): void;
     mptzSetPosition(request: CameraAvSettingsUserLevelManagement.MptzSetPositionRequest): void;
     mptzRelativeMove(request: CameraAvSettingsUserLevelManagement.MptzRelativeMoveRequest): void;
+    mptzMoveToPreset(request: CameraAvSettingsUserLevelManagement.MptzMoveToPresetRequest): void;
+    mptzSavePreset(request: CameraAvSettingsUserLevelManagement.MptzSavePresetRequest): void;
+    mptzRemovePreset(request: CameraAvSettingsUserLevelManagement.MptzRemovePresetRequest): void;
+    private generatePresetId;
+    private dptzStreamEntry;
+    private applyDptzViewport;
+    dptzSetViewport(request: CameraAvSettingsUserLevelManagement.DptzSetViewportRequest): void;
+    dptzRelativeMove(request: CameraAvSettingsUserLevelManagement.DptzRelativeMoveRequest): void;
+}
+export declare namespace MatterbridgeCameraAvSettingsUserLevelManagementServer {
+    class Internal {
+        lastGeneratedPresetId: number;
+    }
 }
 export interface CameraAvSettingsUserLevelManagementClusterOptions {
     panMin: number;
@@ -20,6 +39,7 @@ export interface CameraAvSettingsUserLevelManagementClusterOptions {
     tiltMax: number;
     zoomMax: number;
     mptzPosition: CameraAvSettingsUserLevelManagement.Mptz;
+    maxPresets: number;
 }
 export declare function createDefaultCameraAvSettingsUserLevelManagementClusterServer(endpoint: MatterbridgeEndpoint, options: CameraAvSettingsUserLevelManagementClusterOptions): MatterbridgeEndpoint;
 export {};

package/dist/behaviors/cameraAvSettingsUserLevelManagementServer.js

@@ -1,11 +1,45 @@
 import { CameraAvSettingsUserLevelManagementServer } from '@matter/node/behaviors/camera-av-settings-user-level-management';
 import { Status, StatusResponseError } from '@matter/types';
 import { CameraAvSettingsUserLevelManagement } from '@matter/types/clusters/camera-av-settings-user-level-management';
+import { MatterbridgeCameraAvStreamManagementServer } from './cameraAvStreamManagementServer.js';
 import { MatterbridgeServer } from './matterbridgeServer.js';
 function clamp(value, min, max) {
     return Math.min(Math.max(value, min), max);
 }
-export class MatterbridgeCameraAvSettingsUserLevelManagementServer extends CameraAvSettingsUserLevelManagementServer.with(CameraAvSettingsUserLevelManagement.Feature.MechanicalPan, CameraAvSettingsUserLevelManagement.Feature.MechanicalTilt, CameraAvSettingsUserLevelManagement.Feature.MechanicalZoom) {
+function viewportWidth(viewport) {
+    return viewport.x2 - viewport.x1;
+}
+function viewportHeight(viewport) {
+    return viewport.y2 - viewport.y1;
+}
+function sameAspectRatio(width, height, referenceWidth, referenceHeight) {
+    return width * referenceHeight === referenceWidth * height;
+}
+function viewportAt(x1, y1, width, height, sensorWidth, sensorHeight) {
+    const left = clamp(x1, 0, sensorWidth - width);
+    const top = clamp(y1, 0, sensorHeight - height);
+    return { x1: left, y1: top, x2: left + width, y2: top + height };
+}
+export class MatterbridgeCameraAvSettingsUserLevelManagementServer extends CameraAvSettingsUserLevelManagementServer.with(CameraAvSettingsUserLevelManagement.Feature.MechanicalPan, CameraAvSettingsUserLevelManagement.Feature.MechanicalTilt, CameraAvSettingsUserLevelManagement.Feature.MechanicalZoom, CameraAvSettingsUserLevelManagement.Feature.MechanicalPresets, CameraAvSettingsUserLevelManagement.Feature.DigitalPtz) {
+    initialize() {
+        const streamManagement = this.agent.get(MatterbridgeCameraAvStreamManagementServer);
+        this.syncDptzStreams(streamManagement.state.allocatedVideoStreams);
+        this.reactTo(streamManagement.events.allocatedVideoStreams$Changed, this.syncDptzStreams);
+        this.reactTo(streamManagement.events.viewport$Changed, this.syncDptzViewport);
+    }
+    syncDptzStreams(allocatedVideoStreams) {
+        const allocatedIds = allocatedVideoStreams.map((stream) => stream.videoStreamId);
+        const currentIds = this.state.dptzStreams.map((entry) => entry.videoStreamId);
+        if (allocatedIds.length === currentIds.length && allocatedIds.every((id, index) => id === currentIds[index]))
+            return;
+        const viewport = this.agent.get(MatterbridgeCameraAvStreamManagementServer).state.viewport;
+        this.state.dptzStreams = allocatedIds.map((videoStreamId) => this.state.dptzStreams.find((entry) => entry.videoStreamId === videoStreamId) ?? { videoStreamId, viewport });
+    }
+    syncDptzViewport(viewport) {
+        if (this.state.dptzStreams.length === 0)
+            return;
+        this.state.dptzStreams = this.state.dptzStreams.map((entry) => ({ videoStreamId: entry.videoStreamId, viewport }));
+    }
     mptzSetPosition(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         const { pan, tilt, zoom } = request;
@@ -42,11 +76,147 @@ export class MatterbridgeCameraAvSettingsUserLevelManagementServer extends Camer
         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.endpoint.emitCommand(CameraAvSettingsUserLevelManagement, 'mptzRelativeMove', request, this.context);
     }
+    mptzMoveToPreset(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        const { presetId } = request;
+        if (presetId < 1 || presetId > this.state.maxPresets) {
+            throw new StatusResponseError(`MatterbridgeCameraAvSettingsUserLevelManagementServer: presetId ${presetId} is outside of the supported range [1, ${this.state.maxPresets}] (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.ConstraintError);
+        }
+        const preset = this.state.mptzPresets.find((entry) => entry.presetId === presetId);
+        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;
+        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.endpoint.emitCommand(CameraAvSettingsUserLevelManagement, 'mptzMoveToPreset', request, this.context);
+    }
+    mptzSavePreset(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        const { presetId, name } = request;
+        if (name.length > 32) {
+            throw new StatusResponseError(`MatterbridgeCameraAvSettingsUserLevelManagementServer: name "${name}" exceeds the maximum length of 32 characters (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.ConstraintError);
+        }
+        if (presetId !== undefined && (presetId < 1 || presetId > this.state.maxPresets)) {
+            throw new StatusResponseError(`MatterbridgeCameraAvSettingsUserLevelManagementServer: presetId ${presetId} is outside of the supported range [1, ${this.state.maxPresets}] (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.ConstraintError);
+        }
+        if (presetId !== undefined && this.state.mptzPresets.some((entry) => entry.presetId === presetId)) {
+            this.state.mptzPresets = this.state.mptzPresets.map((entry) => (entry.presetId === presetId ? { presetId, name, settings: this.state.mptzPosition } : entry));
+            device.log.info(`MatterbridgeCameraAvSettingsUserLevelManagementServer: updated preset ${presetId} "${name}" with the current mechanical PTZ position (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+            this.endpoint.emitCommand(CameraAvSettingsUserLevelManagement, 'mptzSavePreset', request, this.context);
+            return;
+        }
+        if (this.state.mptzPresets.length >= this.state.maxPresets) {
+            throw new StatusResponseError(`MatterbridgeCameraAvSettingsUserLevelManagementServer: mptzPresets already holds the maximum of ${this.state.maxPresets} presets (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.ResourceExhausted);
+        }
+        const newPresetId = presetId ?? this.generatePresetId();
+        this.state.mptzPresets = [...this.state.mptzPresets, { presetId: newPresetId, name, settings: this.state.mptzPosition }];
+        device.log.info(`MatterbridgeCameraAvSettingsUserLevelManagementServer: saved preset ${newPresetId} "${name}" with the current mechanical PTZ position (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        this.endpoint.emitCommand(CameraAvSettingsUserLevelManagement, 'mptzSavePreset', request, this.context);
+    }
+    mptzRemovePreset(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        const { presetId } = request;
+        if (presetId < 1 || presetId > this.state.maxPresets) {
+            throw new StatusResponseError(`MatterbridgeCameraAvSettingsUserLevelManagementServer: presetId ${presetId} is outside of the supported range [1, ${this.state.maxPresets}] (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.ConstraintError);
+        }
+        if (!this.state.mptzPresets.some((entry) => entry.presetId === presetId)) {
+            throw new StatusResponseError(`MatterbridgeCameraAvSettingsUserLevelManagementServer: presetId ${presetId} is not present in mptzPresets (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.NotFound);
+        }
+        this.state.mptzPresets = this.state.mptzPresets.filter((entry) => entry.presetId !== presetId);
+        device.log.info(`MatterbridgeCameraAvSettingsUserLevelManagementServer: removed preset ${presetId} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        this.endpoint.emitCommand(CameraAvSettingsUserLevelManagement, 'mptzRemovePreset', request, this.context);
+    }
+    generatePresetId() {
+        let presetId = (this.internal.lastGeneratedPresetId % this.state.maxPresets) + 1;
+        while (this.state.mptzPresets.some((entry) => entry.presetId === presetId)) {
+            presetId = (presetId % this.state.maxPresets) + 1;
+        }
+        this.internal.lastGeneratedPresetId = presetId;
+        return presetId;
+    }
+    dptzStreamEntry(videoStreamId) {
+        const entry = this.state.dptzStreams.find((stream) => stream.videoStreamId === videoStreamId);
+        if (entry === undefined) {
+            throw new StatusResponseError(`MatterbridgeCameraAvSettingsUserLevelManagementServer: video stream ${videoStreamId} is not present in dptzStreams (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.NotFound);
+        }
+        return entry;
+    }
+    applyDptzViewport(videoStreamId, viewport) {
+        this.state.dptzStreams = this.state.dptzStreams.map((entry) => (entry.videoStreamId === videoStreamId ? { videoStreamId, viewport } : entry));
+    }
+    dptzSetViewport(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        const { videoStreamId, viewport } = request;
+        const entry = this.dptzStreamEntry(videoStreamId);
+        const { videoSensorParams, minViewportResolution } = this.agent.get(MatterbridgeCameraAvStreamManagementServer).state;
+        const width = viewportWidth(viewport);
+        const height = viewportHeight(viewport);
+        if (width < minViewportResolution.width || height < minViewportResolution.height) {
+            throw new StatusResponseError(`MatterbridgeCameraAvSettingsUserLevelManagementServer: viewport ${width}x${height} is smaller than the minimum viewport resolution ${minViewportResolution.width}x${minViewportResolution.height} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.DynamicConstraintError);
+        }
+        if (viewport.x2 > videoSensorParams.sensorWidth ||
+            viewport.y2 > videoSensorParams.sensorHeight ||
+            width > videoSensorParams.sensorWidth ||
+            height > videoSensorParams.sensorHeight) {
+            throw new StatusResponseError(`MatterbridgeCameraAvSettingsUserLevelManagementServer: viewport ${width}x${height} at (${viewport.x1}, ${viewport.y1}) does not fit the sensor ${videoSensorParams.sensorWidth}x${videoSensorParams.sensorHeight} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.DynamicConstraintError);
+        }
+        if (!sameAspectRatio(width, height, viewportWidth(entry.viewport), viewportHeight(entry.viewport))) {
+            throw new StatusResponseError(`MatterbridgeCameraAvSettingsUserLevelManagementServer: viewport ${width}x${height} does not match the aspect ratio of video stream ${videoStreamId} (${viewportWidth(entry.viewport)}x${viewportHeight(entry.viewport)}) (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.DynamicConstraintError);
+        }
+        this.applyDptzViewport(videoStreamId, viewport);
+        device.log.info(`MatterbridgeCameraAvSettingsUserLevelManagementServer: set the viewport of video stream ${videoStreamId} to (${viewport.x1}, ${viewport.y1})-(${viewport.x2}, ${viewport.y2}) (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        this.endpoint.emitCommand(CameraAvSettingsUserLevelManagement, 'dptzSetViewport', request, this.context);
+    }
+    dptzRelativeMove(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        const { videoStreamId, deltaX, deltaY, zoomDelta } = request;
+        const entry = this.dptzStreamEntry(videoStreamId);
+        const { videoSensorParams, minViewportResolution } = this.agent.get(MatterbridgeCameraAvStreamManagementServer).state;
+        const { sensorWidth, sensorHeight } = videoSensorParams;
+        const current = entry.viewport;
+        let x1 = current.x1 + (deltaX ?? 0);
+        let y1 = current.y1 + (deltaY ?? 0);
+        let width = viewportWidth(current);
+        let height = viewportHeight(current);
+        if (zoomDelta !== undefined && zoomDelta !== 0) {
+            const scaledWidth = Math.round((width * (100 - zoomDelta)) / 100);
+            const scaledHeight = Math.round((height * (100 - zoomDelta)) / 100);
+            x1 += Math.round((width - scaledWidth) / 2);
+            y1 += Math.round((height - scaledHeight) / 2);
+            width = scaledWidth;
+            height = scaledHeight;
+        }
+        const streamWidth = viewportWidth(current);
+        const streamHeight = viewportHeight(current);
+        if (!sameAspectRatio(width, height, streamWidth, streamHeight)) {
+            const clippedHeight = Math.round((width * streamHeight) / streamWidth);
+            if (clippedHeight <= height)
+                height = clippedHeight;
+            else
+                width = Math.round((height * streamWidth) / streamHeight);
+        }
+        width = Math.max(width, minViewportResolution.width);
+        height = Math.max(height, minViewportResolution.height);
+        width = Math.min(width, sensorWidth);
+        height = Math.min(height, sensorHeight);
+        const viewport = viewportAt(x1, y1, width, height, sensorWidth, sensorHeight);
+        this.applyDptzViewport(videoStreamId, viewport);
+        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);
+    }
 }
+(function (MatterbridgeCameraAvSettingsUserLevelManagementServer) {
+    class Internal {
+        lastGeneratedPresetId = 0;
+    }
+    MatterbridgeCameraAvSettingsUserLevelManagementServer.Internal = Internal;
+})(MatterbridgeCameraAvSettingsUserLevelManagementServer || (MatterbridgeCameraAvSettingsUserLevelManagementServer = {}));
 export function createDefaultCameraAvSettingsUserLevelManagementClusterServer(endpoint, options) {
-    endpoint.behaviors.require(MatterbridgeCameraAvSettingsUserLevelManagementServer.with(CameraAvSettingsUserLevelManagement.Feature.MechanicalPan, CameraAvSettingsUserLevelManagement.Feature.MechanicalTilt, CameraAvSettingsUserLevelManagement.Feature.MechanicalZoom), {
+    endpoint.behaviors.require(MatterbridgeCameraAvSettingsUserLevelManagementServer.with(CameraAvSettingsUserLevelManagement.Feature.MechanicalPan, CameraAvSettingsUserLevelManagement.Feature.MechanicalTilt, CameraAvSettingsUserLevelManagement.Feature.MechanicalZoom, CameraAvSettingsUserLevelManagement.Feature.MechanicalPresets, CameraAvSettingsUserLevelManagement.Feature.DigitalPtz), {
         ...options,
         movementState: CameraAvSettingsUserLevelManagement.PhysicalMovement.Idle,
+        mptzPresets: [],
+        dptzStreams: [],
     });
     return endpoint;
 }

package/dist/behaviors/cameraAvStreamManagementServer.d.ts

@@ -3,12 +3,8 @@ import { StreamUsage } from '@matter/types';
 import type { Viewport } from '@matter/types';
 import { CameraAvStreamManagement } from '@matter/types/clusters/camera-av-stream-management';
 import type { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
-export interface CameraColorTestJpeg {
-    data: Buffer;
-    resolution: CameraAvStreamManagement.VideoResolution;
-}
-export declare function cameraColorTestJpegForResolution(requestedResolution: CameraAvStreamManagement.VideoResolution): CameraColorTestJpeg;
-declare const MatterbridgeCameraAvStreamManagementServer_base: import("@matter/node").ClusterBehavior.Type<typeof CameraAvStreamManagementServer, import("@matter/types").ClusterType.WithSupportedFeatures<CameraAvStreamManagement, {
+export type SnapshotSource = 'test' | 'webcam' | 'rtsp';
+declare const MatterbridgeCameraAvStreamManagementServerBase: import("@matter/node").ClusterBehavior.Type<typeof CameraAvStreamManagementServer, import("@matter/types").ClusterType.WithSupportedFeatures<CameraAvStreamManagement, {
     audio: true;
     highDynamicRange: false;
     imageControl: true;
@@ -21,9 +17,10 @@ declare const MatterbridgeCameraAvStreamManagementServer_base: import("@matter/n
     video: true;
     watermark: false;
 }>, import("@matter/types").ClusterType.Concrete, new () => {}, "cameraAvStreamManagement">;
-export declare class MatterbridgeCameraAvStreamManagementServer extends MatterbridgeCameraAvStreamManagementServer_base {
+export declare class MatterbridgeCameraAvStreamManagementServer extends MatterbridgeCameraAvStreamManagementServerBase {
     #private;
     readonly endpoint: MatterbridgeEndpoint;
+    readonly state: MatterbridgeCameraAvStreamManagementServer.State;
     initialize(): void;
     setStreamPriorities(request: CameraAvStreamManagement.SetStreamPrioritiesRequest): void;
     videoStreamAllocate(request: CameraAvStreamManagement.VideoStreamAllocateRequest): CameraAvStreamManagement.VideoStreamAllocateResponse;
@@ -32,7 +29,13 @@ export declare class MatterbridgeCameraAvStreamManagementServer extends Matterbr
     audioStreamDeallocate(request: CameraAvStreamManagement.AudioStreamDeallocateRequest): void;
     snapshotStreamAllocate(request: CameraAvStreamManagement.SnapshotStreamAllocateRequest): Promise<CameraAvStreamManagement.SnapshotStreamAllocateResponse>;
     snapshotStreamDeallocate(request: CameraAvStreamManagement.SnapshotStreamDeallocateRequest): Promise<void>;
-    captureSnapshot(request: CameraAvStreamManagement.CaptureSnapshotRequest): CameraAvStreamManagement.CaptureSnapshotResponse;
+    captureSnapshot(request: CameraAvStreamManagement.CaptureSnapshotRequest): Promise<CameraAvStreamManagement.CaptureSnapshotResponse>;
+}
+export declare namespace MatterbridgeCameraAvStreamManagementServer {
+    class State extends MatterbridgeCameraAvStreamManagementServerBase.State {
+        snapshotSource?: SnapshotSource;
+        snapshotSourceDevice?: string;
+    }
 }
 export interface CameraAvStreamManagementClusterOptions {
     maxContentBufferSize: number;
@@ -76,6 +79,8 @@ export interface SnapshotCameraAvStreamManagementClusterOptions {
     maxNetworkBandwidth: number;
     supportedStreamUsages: StreamUsage[];
     streamUsagePriorities: StreamUsage[];
+    snapshotSource?: SnapshotSource;
+    snapshotSourceDevice?: string;
 }
 export declare function createDefaultSnapshotCameraAvStreamManagementClusterServer(endpoint: MatterbridgeEndpoint, options: SnapshotCameraAvStreamManagementClusterOptions): MatterbridgeEndpoint;
 export {};

package/dist/behaviors/cameraAvStreamManagementServer.js

@@ -1,24 +1,20 @@
-import { readFileSync } from 'node:fs';
 import { CameraAvStreamManagementServer } from '@matter/node/behaviors/camera-av-stream-management';
+import { WebRtcTransportProviderServer } from '@matter/node/behaviors/web-rtc-transport-provider';
 import { Status, StatusResponseError, StreamUsage, ThreeLevelAuto } from '@matter/types';
 import { CameraAvStreamManagement } from '@matter/types/clusters/camera-av-stream-management';
 import { MatterbridgeServer } from './matterbridgeServer.js';
-const DEFAULT_CAMERA_COLOR_TEST_RESOLUTION = '640x480';
+import { captureSnapshot, TEST_SNAPSHOT_SOURCE } from './snapshot.js';
 const AUDIO_STREAM_BIT_DEPTHS = [8, 16, 24, 32];
 function numericEnumValues(enumObject) {
     return Object.values(enumObject).filter((value) => typeof value === 'number');
 }
 const AUDIO_CODECS = numericEnumValues(CameraAvStreamManagement.AudioCodec);
 const VIDEO_CODECS = numericEnumValues(CameraAvStreamManagement.VideoCodec);
-const cameraColorTestJpegs = {
-    '640x480': { data: readFileSync(new URL('../../assets/camera-color-test-640-480.jpeg', import.meta.url)), resolution: { width: 640, height: 480 } },
-    '1280x720': { data: readFileSync(new URL('../../assets/camera-color-test-1280-720.jpeg', import.meta.url)), resolution: { width: 1280, height: 720 } },
-    '1920x1080': { data: readFileSync(new URL('../../assets/camera-color-test-1920-1080.jpeg', import.meta.url)), resolution: { width: 1920, height: 1080 } },
-};
-export function cameraColorTestJpegForResolution(requestedResolution) {
-    return cameraColorTestJpegs[`${requestedResolution.width}x${requestedResolution.height}`] ?? cameraColorTestJpegs[DEFAULT_CAMERA_COLOR_TEST_RESOLUTION];
+function hasWeriftOfferOptions(state) {
+    return 'weriftOfferOptions' in state && typeof state.weriftOfferOptions === 'object' && state.weriftOfferOptions !== null;
 }
-export class MatterbridgeCameraAvStreamManagementServer extends CameraAvStreamManagementServer.with(CameraAvStreamManagement.Feature.Video, CameraAvStreamManagement.Feature.Audio, CameraAvStreamManagement.Feature.Snapshot, CameraAvStreamManagement.Feature.ImageControl) {
+const MatterbridgeCameraAvStreamManagementServerBase = CameraAvStreamManagementServer.with(CameraAvStreamManagement.Feature.Video, CameraAvStreamManagement.Feature.Audio, CameraAvStreamManagement.Feature.Snapshot, CameraAvStreamManagement.Feature.ImageControl);
+export class MatterbridgeCameraAvStreamManagementServer extends MatterbridgeCameraAvStreamManagementServerBase {
     #isAutoAllocateSkipped() {
         return process.env.MATTERBRIDGE_SKIP_AUTO_ALLOCATE_CAMERA_AV_STREAM_MANAGEMENT === '1';
     }
@@ -189,6 +185,9 @@ export class MatterbridgeCameraAvStreamManagementServer extends CameraAvStreamMa
         if (!this.state.allocatedVideoStreams.some((stream) => stream.videoStreamId === request.videoStreamId)) {
             throw new StatusResponseError(`MatterbridgeCameraAvStreamManagementServer: video stream ${request.videoStreamId} is not present in allocatedVideoStreams (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.NotFound);
         }
+        if (this.state.allocatedVideoStreams.some((stream) => stream.videoStreamId === request.videoStreamId && stream.referenceCount > 0)) {
+            throw new StatusResponseError(`MatterbridgeCameraAvStreamManagementServer: video stream ${request.videoStreamId} is in use (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.InvalidInState);
+        }
         this.state.allocatedVideoStreams = this.state.allocatedVideoStreams.filter((stream) => stream.videoStreamId !== request.videoStreamId);
         device.log.info(`MatterbridgeCameraAvStreamManagementServer: deallocated video stream ${request.videoStreamId} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         this.endpoint.emitCommand(CameraAvStreamManagement, 'videoStreamDeallocate', request, this.context);
@@ -252,6 +251,9 @@ export class MatterbridgeCameraAvStreamManagementServer extends CameraAvStreamMa
         if (!this.state.allocatedAudioStreams.some((stream) => stream.audioStreamId === request.audioStreamId)) {
             throw new StatusResponseError(`MatterbridgeCameraAvStreamManagementServer: audio stream ${request.audioStreamId} is not present in allocatedAudioStreams (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.NotFound);
         }
+        if (this.state.allocatedAudioStreams.some((stream) => stream.audioStreamId === request.audioStreamId && stream.referenceCount > 0)) {
+            throw new StatusResponseError(`MatterbridgeCameraAvStreamManagementServer: audio stream ${request.audioStreamId} is in use (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.InvalidInState);
+        }
         this.state.allocatedAudioStreams = this.state.allocatedAudioStreams.filter((stream) => stream.audioStreamId !== request.audioStreamId);
         device.log.info(`MatterbridgeCameraAvStreamManagementServer: deallocated audio stream ${request.audioStreamId} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         this.endpoint.emitCommand(CameraAvStreamManagement, 'audioStreamDeallocate', request, this.context);
@@ -328,7 +330,34 @@ export class MatterbridgeCameraAvStreamManagementServer extends CameraAvStreamMa
         device.log.info(`MatterbridgeCameraAvStreamManagementServer: deallocated snapshot stream ${request.snapshotStreamId} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         this.endpoint.emitCommand(CameraAvStreamManagement, 'snapshotStreamDeallocate', request, this.context);
     }
-    captureSnapshot(request) {
+    #resolveSnapshotSource() {
+        const endpoint = `(endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`;
+        const fail = (reason) => {
+            this.endpoint.stateOf(MatterbridgeServer).log.error(`MatterbridgeCameraAvStreamManagementServer: cannot capture snapshot: ${reason} ${endpoint}`);
+            return new StatusResponseError(`MatterbridgeCameraAvStreamManagementServer: cannot capture snapshot: ${reason} ${endpoint}`, Status.Failure);
+        };
+        const sourceFor = (source, device, sourceOption, deviceOption) => {
+            if (source === 'test')
+                return TEST_SNAPSHOT_SOURCE;
+            if (device)
+                return device;
+            throw fail(`${sourceOption}=${source} requires ${deviceOption} to be set`);
+        };
+        const { snapshotSource, snapshotSourceDevice } = this.state;
+        if (snapshotSource !== undefined)
+            return sourceFor(snapshotSource, snapshotSourceDevice, 'snapshotSource', 'snapshotSourceDevice');
+        if (!this.endpoint.behaviors.has(WebRtcTransportProviderServer)) {
+            throw fail('no snapshotSource is configured and the endpoint has no WebRtcTransportProvider cluster to read the video source from');
+        }
+        const state = this.endpoint.stateOf(WebRtcTransportProviderServer);
+        if (!hasWeriftOfferOptions(state))
+            throw fail('the WebRtcTransportProvider cluster state has no weriftOfferOptions');
+        const { videoSource, videoSourceDevice } = state.weriftOfferOptions;
+        if (videoSource === 'none')
+            throw fail(`weriftOfferOptions.videoSource=${videoSource} provides no video source`);
+        return sourceFor(videoSource, videoSourceDevice, 'weriftOfferOptions.videoSource', 'videoSourceDevice');
+    }
+    async captureSnapshot(request) {
         const device = this.endpoint.stateOf(MatterbridgeServer);
         const { snapshotStreamId } = request;
         const stream = this.state.allocatedSnapshotStreams.find((s) => snapshotStreamId === null || s.snapshotStreamId === snapshotStreamId);
@@ -337,15 +366,34 @@ export class MatterbridgeCameraAvStreamManagementServer extends CameraAvStreamMa
         }
         device.log.info(`MatterbridgeCameraAvStreamManagementServer: capturing snapshot ${snapshotStreamId ?? 'auto'} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         device.log.debug(`MatterbridgeCameraAvStreamManagementServer: captureSnapshot called with snapshotStreamId ${request.snapshotStreamId} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
-        const { data, resolution } = cameraColorTestJpegForResolution(request.requestedResolution);
+        const src = this.#resolveSnapshotSource();
+        const { width, height } = request.requestedResolution;
+        let captured;
+        try {
+            captured = await captureSnapshot({ src, width, height });
+        }
+        catch (error) {
+            const message = `MatterbridgeCameraAvStreamManagementServer: snapshot capture failed: ${error instanceof Error ? error.message : String(error)} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`;
+            device.log.error(message);
+            throw new StatusResponseError(message, Status.Failure);
+        }
+        const resolution = { width: captured.width, height: captured.height === -1 ? Math.round((captured.width * height) / width) : captured.height };
+        device.log.info(`MatterbridgeCameraAvStreamManagementServer: captured snapshot ${captured.byteLength}B at ${resolution.width}x${resolution.height}, quality ${captured.quality}${captured.downgraded ? ' (downgraded)' : ''} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
         this.endpoint.emitCommand(CameraAvStreamManagement, 'captureSnapshot', request, this.context);
         return {
-            data,
+            data: captured.data,
             imageCodec: CameraAvStreamManagement.ImageCodec.Jpeg,
             resolution,
         };
     }
 }
+(function (MatterbridgeCameraAvStreamManagementServer) {
+    class State extends MatterbridgeCameraAvStreamManagementServerBase.State {
+        snapshotSource = undefined;
+        snapshotSourceDevice = undefined;
+    }
+    MatterbridgeCameraAvStreamManagementServer.State = State;
+})(MatterbridgeCameraAvStreamManagementServer || (MatterbridgeCameraAvStreamManagementServer = {}));
 export function createDefaultCameraAvStreamManagementClusterServer(endpoint, options) {
     endpoint.behaviors.require(MatterbridgeCameraAvStreamManagementServer.with(CameraAvStreamManagement.Feature.Video, CameraAvStreamManagement.Feature.Audio, CameraAvStreamManagement.Feature.Snapshot, CameraAvStreamManagement.Feature.ImageControl), {
         ...options,
@@ -408,6 +456,8 @@ export function createDefaultSnapshotCameraAvStreamManagementClusterServer(endpo
         maxEncodedPixelRate: options.maxEncodedPixelRate,
         snapshotCapabilities: options.snapshotCapabilities,
         allocatedSnapshotStreams: [],
+        snapshotSource: options.snapshotSource,
+        snapshotSourceDevice: options.snapshotSourceDevice,
     });
     return endpoint;
 }

package/dist/behaviors/colorControlServer.js

@@ -1,11 +1,25 @@
 import { ColorControlServer } from '@matter/node/behaviors/color-control';
 import { ColorControl } from '@matter/types/clusters/color-control';
-import { MatterbridgeServer } from './matterbridgeServer.js';
+import { isSoftwareUpdateBoot, MatterbridgeServer } from './matterbridgeServer.js';
 export class MatterbridgeColorControlServer extends ColorControlServer.with(ColorControl.Feature.HueSaturation, ColorControl.Feature.Xy, ColorControl.Feature.ColorTemperature, ColorControl.Feature.EnhancedHue) {
     initialize() {
         if (process.env.MATTERBRIDGE_CHIP_TEST)
             this.state.managedTransitionTimeHandling = true;
-        return super.initialize();
+        const result = super.initialize();
+        if (this.features.colorTemperature && !isSoftwareUpdateBoot(this.env)) {
+            const startUpMireds = this.state.startUpColorTemperatureMireds ?? null;
+            if (startUpMireds !== null) {
+                const crop = (mireds) => Math.min(Math.max(mireds, this.minimumColorTemperatureMireds), this.maximumColorTemperatureMireds);
+                const currentMireds = crop(this.state.colorTemperatureMireds);
+                const targetMireds = crop(startUpMireds);
+                if (targetMireds !== currentMireds) {
+                    this.state.colorMode = ColorControl.ColorMode.ColorTemperatureMireds;
+                    this.state.enhancedColorMode = ColorControl.EnhancedColorMode.ColorTemperatureMireds;
+                    this.state.colorTemperatureMireds = targetMireds;
+                }
+            }
+        }
+        return result;
     }
     async moveToHue(request) {
         if (process.env.MATTERBRIDGE_CHIP_TEST) {

package/dist/behaviors/levelControlServer.js

@@ -1,11 +1,20 @@
 import { LevelControlServer } from '@matter/node/behaviors/level-control';
 import { LevelControl } from '@matter/types/clusters/level-control';
-import { MatterbridgeServer } from './matterbridgeServer.js';
+import { isSoftwareUpdateBoot, MatterbridgeServer } from './matterbridgeServer.js';
 export class MatterbridgeLevelControlServer extends LevelControlServer {
     initialize() {
         if (process.env.MATTERBRIDGE_CHIP_TEST)
             this.state.managedTransitionTimeHandling = true;
-        return super.initialize();
+        const result = super.initialize();
+        if (this.features.lighting && !isSoftwareUpdateBoot(this.env)) {
+            const state = this.state;
+            const startUpCurrentLevel = state.startUpCurrentLevel ?? null;
+            const currentLevel = state.currentLevel;
+            const targetLevel = startUpCurrentLevel === 0 ? this.minLevel : (startUpCurrentLevel ?? currentLevel);
+            if (targetLevel !== currentLevel)
+                state.currentLevel = targetLevel;
+        }
+        return result;
     }
     async moveToLevel(request) {
         if (process.env.MATTERBRIDGE_CHIP_TEST) {

package/dist/behaviors/matterbridgeServer.d.ts

@@ -1,6 +1,8 @@
+import type { Environment } from '@matter/general';
 import { Behavior } from '@matter/node';
 import type { AnsiLogger } from 'node-ansi-logger';
 import type { CommandHandler } from '../matterbridgeEndpointCommandHandler.js';
+export declare function isSoftwareUpdateBoot(env: Environment): boolean;
 export declare class MatterbridgeServer extends Behavior {
     static readonly id = "matterbridge";
     state: MatterbridgeServer.State;

package/dist/behaviors/matterbridgeServer.js

@@ -1,4 +1,12 @@
-import { Behavior } from '@matter/node';
+import { Behavior, ServerNode } from '@matter/node';
+import { GeneralDiagnosticsBehavior } from '@matter/node/behaviors/general-diagnostics';
+import { GeneralDiagnostics } from '@matter/types/clusters/general-diagnostics';
+export function isSoftwareUpdateBoot(env) {
+    const rootEndpoint = env.get(ServerNode);
+    if (!rootEndpoint.behaviors.has(GeneralDiagnosticsBehavior))
+        return false;
+    return rootEndpoint.stateOf(GeneralDiagnosticsBehavior).bootReason === GeneralDiagnostics.BootReason.SoftwareUpdateCompleted;
+}
 export class MatterbridgeServer extends Behavior {
     static id = 'matterbridge';
     initialize() {

package/dist/behaviors/onOffServer.d.ts

@@ -1,3 +1,4 @@
+import type { MaybePromise } from '@matter/general';
 import { OnOffServer } from '@matter/node/behaviors/on-off';
 import { OnOff } from '@matter/types/clusters/on-off';
 import type { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
@@ -16,6 +17,7 @@ declare const MatterbridgeOnOffServer_base: import("@matter/node").ClusterBehavi
 }>, import("@matter/types").ClusterType.Concrete, typeof import("@matter/node/behaviors/on-off").OnOffBaseServer.Internal, "onOff">;
 export declare class MatterbridgeOnOffServer extends MatterbridgeOnOffServer_base {
     readonly endpoint: MatterbridgeEndpoint;
+    initialize(): MaybePromise;
     on(): Promise<void>;
     off(): Promise<void>;
     toggle(): Promise<void>;

package/dist/behaviors/onOffServer.js

@@ -1,7 +1,20 @@
 import { OnOffServer } from '@matter/node/behaviors/on-off';
 import { OnOff } from '@matter/types/clusters/on-off';
-import { MatterbridgeServer } from './matterbridgeServer.js';
+import { isSoftwareUpdateBoot, MatterbridgeServer } from './matterbridgeServer.js';
 export class MatterbridgeOnOffServer extends OnOffServer.with(OnOff.Feature.Lighting) {
+    initialize() {
+        const result = super.initialize();
+        if (this.features.lighting && !isSoftwareUpdateBoot(this.env)) {
+            const startUpOnOff = this.state.startUpOnOff ?? null;
+            if (startUpOnOff !== null) {
+                const currentOnOff = this.state.onOff;
+                const targetOnOff = startUpOnOff === OnOff.StartUpOnOff.Toggle ? !currentOnOff : startUpOnOff === OnOff.StartUpOnOff.On;
+                if (targetOnOff !== currentOnOff)
+                    this.state.onOff = targetOnOff;
+            }
+        }
+        return result;
+    }
     async on() {
         if (process.env.MATTERBRIDGE_CHIP_TEST) {
             await super.on();

package/dist/behaviors/snapshot.d.ts

@@ -1,3 +1,4 @@
+export declare const TEST_SNAPSHOT_SOURCE = "test";
 export interface SnapshotRequest {
     src: string;
     width: number;

package/dist/behaviors/snapshot.js

@@ -7,6 +7,7 @@ const MAX_BYTES = 64000;
 const QUALITIES = [6, 10, 14, 18, 24, 31];
 const FALLBACK_WIDTH = 640;
 const WEBCAM_WARMUP_SECONDS = 1;
+export const TEST_SNAPSHOT_SOURCE = 'test';
 const CAPTURE_TIMEOUT_MS = 10_000;
 const TERMINATION_GRACE_MS = 1_000;
 const log = new AnsiLogger({ logName: 'Snapshot', logLevel: "debug", logNameColor: MAGENTA, logTimestampFormat: 4 });
@@ -56,6 +57,10 @@ export async function captureSnapshot(request) {
     throw new Error(`Snapshot capture from ${redactedSrc} exceeds ${maxBytes}B at minimum quality/resolution (${last.length}B at quality ${lastQuality})`);
 }
 function buildInputArgs(src, width, height) {
+    if (src === TEST_SNAPSHOT_SOURCE) {
+        const size = height === -1 ? '' : `=size=${width}x${height}`;
+        return ['-f', 'lavfi', '-i', `testsrc${size}`];
+    }
     if (src.startsWith('rtsp://')) {
         return ['-rtsp_transport', 'tcp', '-i', src];
     }

package/dist/behaviors/webRtcTransportProviderServer.d.ts

@@ -24,6 +24,7 @@ export declare namespace MatterbridgeWebRtcTransportProviderServer {
     class Internal {
         nextWebRtcSessionId: number;
         sessions: Map<number, WeriftWebRtcSession>;
+        trickledSessions: Set<number>;
     }
 }
 export declare function createDefaultWebRtcTransportProviderClusterServer(endpoint: MatterbridgeEndpoint, weriftOfferOptions?: WeriftOfferOptions): MatterbridgeEndpoint;