@matterbridge/core 3.10.9-dev-20260908-a3f4064 → 3.10.9-dev-20260910-ca91bcb

package/dist/behaviors/cameraAvSettingsUserLevelManagementServer.d.ts

@@ -0,0 +1,24 @@
+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 { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+declare const MatterbridgeCameraAvSettingsUserLevelManagementServer_base: import("@matter/node").ClusterBehavior.Type<typeof CameraAvSettingsUserLevelManagementServer, import("@matter/types").ClusterType.WithSupportedFeatures<CameraAvSettingsUserLevelManagement, {
+    digitalPtz: false;
+    mechanicalPan: true;
+    mechanicalPresets: false;
+    mechanicalTilt: true;
+    mechanicalZoom: true;
+}>, import("@matter/types").ClusterType.Concrete, new () => {}, "cameraAvSettingsUserLevelManagement">;
+export declare class MatterbridgeCameraAvSettingsUserLevelManagementServer extends MatterbridgeCameraAvSettingsUserLevelManagementServer_base {
+    mptzSetPosition(request: CameraAvSettingsUserLevelManagement.MptzSetPositionRequest): void;
+    mptzRelativeMove(request: CameraAvSettingsUserLevelManagement.MptzRelativeMoveRequest): void;
+}
+export interface CameraAvSettingsUserLevelManagementClusterOptions {
+    panMin: number;
+    panMax: number;
+    tiltMin: number;
+    tiltMax: number;
+    zoomMax: number;
+    mptzPosition: CameraAvSettingsUserLevelManagement.Mptz;
+}
+export declare function createDefaultCameraAvSettingsUserLevelManagementClusterServer(endpoint: MatterbridgeEndpoint, options: CameraAvSettingsUserLevelManagementClusterOptions): MatterbridgeEndpoint;
+export {};

package/dist/behaviors/cameraAvSettingsUserLevelManagementServer.js

@@ -0,0 +1,53 @@
+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 { emitCommand } from '../matterbridgeEndpointHelpers.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) {
+    mptzSetPosition(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        const { pan, tilt, zoom } = request;
+        if (pan === undefined && tilt === undefined && zoom === undefined) {
+            throw new StatusResponseError(`MatterbridgeCameraAvSettingsUserLevelManagementServer: mptzSetPosition requires at least one of pan, tilt or zoom to be present (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.InvalidCommand);
+        }
+        if (pan !== undefined && (pan < this.state.panMin || pan > this.state.panMax)) {
+            throw new StatusResponseError(`MatterbridgeCameraAvSettingsUserLevelManagementServer: pan ${pan} is outside of the supported range [${this.state.panMin}, ${this.state.panMax}] (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.ConstraintError);
+        }
+        if (tilt !== undefined && (tilt < this.state.tiltMin || tilt > this.state.tiltMax)) {
+            throw new StatusResponseError(`MatterbridgeCameraAvSettingsUserLevelManagementServer: tilt ${tilt} is outside of the supported range [${this.state.tiltMin}, ${this.state.tiltMax}] (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.ConstraintError);
+        }
+        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 = {
+            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})`);
+        emitCommand(this.endpoint, CameraAvSettingsUserLevelManagementServer.id, 'mptzSetPosition', request, this.context);
+    }
+    mptzRelativeMove(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        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);
+        }
+        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})`);
+        emitCommand(this.endpoint, CameraAvSettingsUserLevelManagementServer.id, 'mptzRelativeMove', request, this.context);
+    }
+}
+export function createDefaultCameraAvSettingsUserLevelManagementClusterServer(endpoint, options) {
+    endpoint.behaviors.require(MatterbridgeCameraAvSettingsUserLevelManagementServer.with(CameraAvSettingsUserLevelManagement.Feature.MechanicalPan, CameraAvSettingsUserLevelManagement.Feature.MechanicalTilt, CameraAvSettingsUserLevelManagement.Feature.MechanicalZoom), {
+        ...options,
+        movementState: CameraAvSettingsUserLevelManagement.PhysicalMovement.Idle,
+    });
+    return endpoint;
+}

package/dist/behaviors/cameraAvStreamManagementServer.d.ts

@@ -0,0 +1,80 @@
+import { CameraAvStreamManagementServer } from '@matter/node/behaviors/camera-av-stream-management';
+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, {
+    audio: true;
+    highDynamicRange: false;
+    imageControl: true;
+    localStorage: false;
+    nightVision: false;
+    onScreenDisplay: false;
+    privacy: false;
+    snapshot: true;
+    speaker: false;
+    video: true;
+    watermark: false;
+}>, import("@matter/types").ClusterType.Concrete, new () => {}, "cameraAvStreamManagement">;
+export declare class MatterbridgeCameraAvStreamManagementServer extends MatterbridgeCameraAvStreamManagementServer_base {
+    #private;
+    initialize(): void;
+    setStreamPriorities(request: CameraAvStreamManagement.SetStreamPrioritiesRequest): void;
+    videoStreamAllocate(request: CameraAvStreamManagement.VideoStreamAllocateRequest): CameraAvStreamManagement.VideoStreamAllocateResponse;
+    videoStreamDeallocate(request: CameraAvStreamManagement.VideoStreamDeallocateRequest): void;
+    audioStreamAllocate(request: CameraAvStreamManagement.AudioStreamAllocateRequest): CameraAvStreamManagement.AudioStreamAllocateResponse;
+    audioStreamDeallocate(request: CameraAvStreamManagement.AudioStreamDeallocateRequest): void;
+    snapshotStreamAllocate(request: CameraAvStreamManagement.SnapshotStreamAllocateRequest): Promise<CameraAvStreamManagement.SnapshotStreamAllocateResponse>;
+    snapshotStreamDeallocate(request: CameraAvStreamManagement.SnapshotStreamDeallocateRequest): Promise<void>;
+    captureSnapshot(request: CameraAvStreamManagement.CaptureSnapshotRequest): CameraAvStreamManagement.CaptureSnapshotResponse;
+}
+export interface CameraAvStreamManagementClusterOptions {
+    maxContentBufferSize: number;
+    maxNetworkBandwidth: number;
+    supportedStreamUsages: StreamUsage[];
+    streamUsagePriorities: StreamUsage[];
+    maxConcurrentEncoders: number;
+    maxEncodedPixelRate: number;
+    videoSensorParams: CameraAvStreamManagement.VideoSensorParams;
+    minViewportResolution: CameraAvStreamManagement.VideoResolution;
+    rateDistortionTradeOffPoints: CameraAvStreamManagement.RateDistortionTradeOffPoints[];
+    currentFrameRate: number;
+    viewport: Viewport;
+    microphoneCapabilities: CameraAvStreamManagement.AudioCapabilities;
+    snapshotCapabilities: CameraAvStreamManagement.SnapshotCapabilities[];
+}
+export declare function createDefaultCameraAvStreamManagementClusterServer(endpoint: MatterbridgeEndpoint, options: CameraAvStreamManagementClusterOptions): MatterbridgeEndpoint;
+export interface AudioCameraAvStreamManagementClusterOptions {
+    maxContentBufferSize: number;
+    maxNetworkBandwidth: number;
+    supportedStreamUsages: StreamUsage[];
+    streamUsagePriorities: StreamUsage[];
+    microphoneCapabilities: CameraAvStreamManagement.AudioCapabilities;
+}
+export declare function createDefaultAudioCameraAvStreamManagementClusterServer(endpoint: MatterbridgeEndpoint, options: AudioCameraAvStreamManagementClusterOptions): MatterbridgeEndpoint;
+export interface IntercomCameraAvStreamManagementClusterOptions {
+    maxContentBufferSize: number;
+    maxNetworkBandwidth: number;
+    supportedStreamUsages: StreamUsage[];
+    streamUsagePriorities: StreamUsage[];
+    microphoneCapabilities: CameraAvStreamManagement.AudioCapabilities;
+    speakerCapabilities: CameraAvStreamManagement.AudioCapabilities;
+    twoWayTalkSupport: CameraAvStreamManagement.TwoWayTalkSupportType;
+}
+export declare function createDefaultIntercomCameraAvStreamManagementClusterServer(endpoint: MatterbridgeEndpoint, options: IntercomCameraAvStreamManagementClusterOptions): MatterbridgeEndpoint;
+export interface SnapshotCameraAvStreamManagementClusterOptions {
+    maxConcurrentEncoders: number;
+    maxEncodedPixelRate: number;
+    maxContentBufferSize: number;
+    snapshotCapabilities: CameraAvStreamManagement.SnapshotCapabilities[];
+    maxNetworkBandwidth: number;
+    supportedStreamUsages: StreamUsage[];
+    streamUsagePriorities: StreamUsage[];
+}
+export declare function createDefaultSnapshotCameraAvStreamManagementClusterServer(endpoint: MatterbridgeEndpoint, options: SnapshotCameraAvStreamManagementClusterOptions): MatterbridgeEndpoint;
+export {};

package/dist/behaviors/cameraAvStreamManagementServer.js

@@ -0,0 +1,414 @@
+import { readFileSync } from 'node:fs';
+import { CameraAvStreamManagementServer } from '@matter/node/behaviors/camera-av-stream-management';
+import { Status, StatusResponseError, StreamUsage, ThreeLevelAuto } from '@matter/types';
+import { CameraAvStreamManagement } from '@matter/types/clusters/camera-av-stream-management';
+import { emitCommand } from '../matterbridgeEndpointHelpers.js';
+import { MatterbridgeServer } from './matterbridgeServer.js';
+const DEFAULT_CAMERA_COLOR_TEST_RESOLUTION = '640x480';
+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];
+}
+export class MatterbridgeCameraAvStreamManagementServer extends CameraAvStreamManagementServer.with(CameraAvStreamManagement.Feature.Video, CameraAvStreamManagement.Feature.Audio, CameraAvStreamManagement.Feature.Snapshot, CameraAvStreamManagement.Feature.ImageControl) {
+    #isAutoAllocateSkipped() {
+        return process.env.MATTERBRIDGE_SKIP_AUTO_ALLOCATE_CAMERA_AV_STREAM_MANAGEMENT === '1';
+    }
+    initialize() {
+        if (this.#isAutoAllocateSkipped())
+            return;
+        if (this.features.video && this.state.allocatedVideoStreams.length === 0 && this.state.rateDistortionTradeOffPoints.length > 0 && this.state.streamUsagePriorities.length > 0) {
+            const { rateDistortionTradeOffPoints } = this.state;
+            let largestTradeOffPoint = rateDistortionTradeOffPoints[0];
+            for (const point of rateDistortionTradeOffPoints) {
+                if (point.resolution.width * point.resolution.height > largestTradeOffPoint.resolution.width * largestTradeOffPoint.resolution.height)
+                    largestTradeOffPoint = point;
+            }
+            const { codec, resolution, minBitRate } = largestTradeOffPoint;
+            this.state.allocatedVideoStreams = [
+                {
+                    videoStreamId: 0,
+                    streamUsage: this.state.streamUsagePriorities[0],
+                    videoCodec: codec,
+                    minFrameRate: 1,
+                    maxFrameRate: this.state.videoSensorParams.maxFps,
+                    minResolution: this.state.minViewportResolution,
+                    maxResolution: resolution,
+                    minBitRate,
+                    maxBitRate: minBitRate * 4,
+                    keyFrameInterval: 4000,
+                    ...(this.features.watermark ? { watermarkEnabled: false } : {}),
+                    ...(this.features.onScreenDisplay ? { osdEnabled: false } : {}),
+                    referenceCount: 0,
+                },
+            ];
+        }
+        if (this.features.audio &&
+            this.state.allocatedAudioStreams.length === 0 &&
+            this.state.microphoneCapabilities.supportedCodecs.length > 0 &&
+            this.state.streamUsagePriorities.length > 0) {
+            const { microphoneCapabilities } = this.state;
+            this.state.allocatedAudioStreams = [
+                {
+                    audioStreamId: 0,
+                    streamUsage: this.state.streamUsagePriorities[0],
+                    audioCodec: microphoneCapabilities.supportedCodecs[0],
+                    channelCount: microphoneCapabilities.maxNumberOfChannels,
+                    sampleRate: microphoneCapabilities.supportedSampleRates[0],
+                    bitRate: 32_000,
+                    bitDepth: microphoneCapabilities.supportedBitDepths[0],
+                    referenceCount: 0,
+                },
+            ];
+        }
+        if (this.features.snapshot && this.state.allocatedSnapshotStreams.length === 0 && this.state.snapshotCapabilities.length > 0) {
+            const { snapshotCapabilities } = this.state;
+            let smallestCapability = snapshotCapabilities[0];
+            let largestCapability = snapshotCapabilities[0];
+            for (const capability of snapshotCapabilities) {
+                if (capability.resolution.width * capability.resolution.height < smallestCapability.resolution.width * smallestCapability.resolution.height)
+                    smallestCapability = capability;
+                if (capability.resolution.width * capability.resolution.height > largestCapability.resolution.width * largestCapability.resolution.height)
+                    largestCapability = capability;
+            }
+            this.state.allocatedSnapshotStreams = [
+                {
+                    snapshotStreamId: 0,
+                    imageCodec: largestCapability.imageCodec,
+                    frameRate: largestCapability.maxFrameRate,
+                    minResolution: smallestCapability.resolution,
+                    maxResolution: largestCapability.resolution,
+                    quality: 90,
+                    referenceCount: 0,
+                    encodedPixels: false,
+                    hardwareEncoder: false,
+                    ...(this.features.watermark ? { watermarkEnabled: false } : {}),
+                    ...(this.features.onScreenDisplay ? { osdEnabled: false } : {}),
+                },
+            ];
+        }
+    }
+    setStreamPriorities(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        if ((this.features.snapshot && this.state.allocatedSnapshotStreams.length > 0) ||
+            (this.features.video && this.state.allocatedVideoStreams.length > 0) ||
+            (this.features.audio && this.state.allocatedAudioStreams.length > 0)) {
+            throw new StatusResponseError(`MatterbridgeCameraAvStreamManagementServer: setStreamPriorities cannot be invoked while snapshot, video or audio streams are allocated (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.InvalidInState);
+        }
+        if (!request.streamPriorities.every((usage) => this.state.supportedStreamUsages.includes(usage))) {
+            throw new StatusResponseError(`MatterbridgeCameraAvStreamManagementServer: streamPriorities shall only contain entries found in supportedStreamUsages (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.DynamicConstraintError);
+        }
+        if (new Set(request.streamPriorities).size !== request.streamPriorities.length) {
+            throw new StatusResponseError(`MatterbridgeCameraAvStreamManagementServer: streamPriorities shall not contain duplicate values (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.AlreadyExists);
+        }
+        device.log.info(`MatterbridgeCameraAvStreamManagementServer: setting stream priorities to [${request.streamPriorities.join(', ')}] (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        this.state.streamUsagePriorities = request.streamPriorities;
+        emitCommand(this.endpoint, CameraAvStreamManagementServer.id, 'setStreamPriorities', request, this.context);
+    }
+    videoStreamAllocate(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        if (request.streamUsage === StreamUsage.Internal) {
+            throw new StatusResponseError(`MatterbridgeCameraAvStreamManagementServer: stream usage Internal is not allowed for VideoStreamAllocate (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.ConstraintError);
+        }
+        if (!this.state.streamUsagePriorities.includes(request.streamUsage)) {
+            throw new StatusResponseError(`MatterbridgeCameraAvStreamManagementServer: stream usage ${request.streamUsage} is not present in streamUsagePriorities (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.InvalidInState);
+        }
+        if (!VIDEO_CODECS.includes(request.videoCodec)) {
+            throw new StatusResponseError(`MatterbridgeCameraAvStreamManagementServer: videoCodec ${request.videoCodec} is not a valid VideoCodecEnum value (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.ConstraintError);
+        }
+        if (request.minFrameRate > request.maxFrameRate) {
+            throw new StatusResponseError(`MatterbridgeCameraAvStreamManagementServer: minFrameRate ${request.minFrameRate} must not be greater than MaxFrameRate ${request.maxFrameRate} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.ConstraintError);
+        }
+        if (request.minBitRate > request.maxBitRate) {
+            throw new StatusResponseError(`MatterbridgeCameraAvStreamManagementServer: minBitRate ${request.minBitRate} must not be greater than MaxBitRate ${request.maxBitRate} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.ConstraintError);
+        }
+        const matchesTradeOffPoint = this.state.rateDistortionTradeOffPoints.some((point) => point.codec === request.videoCodec &&
+            point.resolution.width >= request.minResolution.width &&
+            point.resolution.width <= request.maxResolution.width &&
+            point.resolution.height >= request.minResolution.height &&
+            point.resolution.height <= request.maxResolution.height &&
+            point.minBitRate <= request.maxBitRate);
+        if (!matchesTradeOffPoint || request.maxFrameRate > this.state.videoSensorParams.maxFps) {
+            throw new StatusResponseError(`MatterbridgeCameraAvStreamManagementServer: videoStreamAllocate requested parameters do not match any entry in rateDistortionTradeOffPoints or exceed videoSensorParams (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.DynamicConstraintError);
+        }
+        const existingStream = this.state.allocatedVideoStreams.find((stream) => stream.streamUsage === request.streamUsage &&
+            stream.videoCodec === request.videoCodec &&
+            stream.minFrameRate === request.minFrameRate &&
+            stream.maxFrameRate === request.maxFrameRate &&
+            stream.minResolution.width === request.minResolution.width &&
+            stream.minResolution.height === request.minResolution.height &&
+            stream.maxResolution.width === request.maxResolution.width &&
+            stream.maxResolution.height === request.maxResolution.height &&
+            stream.minBitRate === request.minBitRate &&
+            stream.maxBitRate === request.maxBitRate &&
+            stream.keyFrameInterval === request.keyFrameInterval);
+        if (existingStream) {
+            device.log.info(`MatterbridgeCameraAvStreamManagementServer: reused video stream ${existingStream.videoStreamId} for usage ${request.streamUsage} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+            emitCommand(this.endpoint, CameraAvStreamManagementServer.id, 'videoStreamAllocate', request, this.context);
+            return { videoStreamId: existingStream.videoStreamId };
+        }
+        if (this.state.allocatedVideoStreams.length >= this.state.maxConcurrentEncoders) {
+            throw new StatusResponseError(`MatterbridgeCameraAvStreamManagementServer: videoStreamAllocate would exceed maxConcurrentEncoders (${this.state.maxConcurrentEncoders}) (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.ResourceExhausted);
+        }
+        let videoStreamId = 0;
+        for (const stream of this.state.allocatedVideoStreams) {
+            videoStreamId = Math.max(videoStreamId, stream.videoStreamId + 1);
+        }
+        this.state.allocatedVideoStreams = [
+            ...this.state.allocatedVideoStreams,
+            {
+                videoStreamId,
+                streamUsage: request.streamUsage,
+                videoCodec: request.videoCodec,
+                minFrameRate: request.minFrameRate,
+                maxFrameRate: request.maxFrameRate,
+                minResolution: request.minResolution,
+                maxResolution: request.maxResolution,
+                minBitRate: request.minBitRate,
+                maxBitRate: request.maxBitRate,
+                keyFrameInterval: request.keyFrameInterval,
+                watermarkEnabled: request.watermarkEnabled,
+                osdEnabled: request.osdEnabled,
+                referenceCount: 0,
+            },
+        ];
+        device.log.info(`MatterbridgeCameraAvStreamManagementServer: allocated video stream ${videoStreamId} for usage ${request.streamUsage} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        emitCommand(this.endpoint, CameraAvStreamManagementServer.id, 'videoStreamAllocate', request, this.context);
+        return { videoStreamId };
+    }
+    videoStreamDeallocate(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        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);
+        }
+        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})`);
+        emitCommand(this.endpoint, CameraAvStreamManagementServer.id, 'videoStreamDeallocate', request, this.context);
+    }
+    audioStreamAllocate(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        if (request.streamUsage === StreamUsage.Internal) {
+            throw new StatusResponseError(`MatterbridgeCameraAvStreamManagementServer: stream usage Internal is not allowed for AudioStreamAllocate (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.ConstraintError);
+        }
+        if (!this.state.streamUsagePriorities.includes(request.streamUsage)) {
+            throw new StatusResponseError(`MatterbridgeCameraAvStreamManagementServer: stream usage ${request.streamUsage} is not present in streamUsagePriorities (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.InvalidInState);
+        }
+        if (!AUDIO_CODECS.includes(request.audioCodec)) {
+            throw new StatusResponseError(`MatterbridgeCameraAvStreamManagementServer: audioCodec ${request.audioCodec} is not a valid AudioCodecEnum value (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.ConstraintError);
+        }
+        if (!AUDIO_STREAM_BIT_DEPTHS.includes(request.bitDepth)) {
+            throw new StatusResponseError(`MatterbridgeCameraAvStreamManagementServer: bitDepth ${request.bitDepth} is not one of ${AUDIO_STREAM_BIT_DEPTHS.join(', ')} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.ConstraintError);
+        }
+        const { microphoneCapabilities } = this.state;
+        if (!microphoneCapabilities.supportedCodecs.includes(request.audioCodec) ||
+            request.channelCount < 1 ||
+            request.channelCount > microphoneCapabilities.maxNumberOfChannels ||
+            !microphoneCapabilities.supportedSampleRates.includes(request.sampleRate) ||
+            !microphoneCapabilities.supportedBitDepths.includes(request.bitDepth)) {
+            throw new StatusResponseError(`MatterbridgeCameraAvStreamManagementServer: audioStreamAllocate requested audioCodec, channelCount, sampleRate or bitDepth is not supported by microphoneCapabilities (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.DynamicConstraintError);
+        }
+        const existingStream = this.state.allocatedAudioStreams.find((stream) => stream.streamUsage === request.streamUsage &&
+            stream.audioCodec === request.audioCodec &&
+            stream.channelCount === request.channelCount &&
+            stream.sampleRate === request.sampleRate &&
+            stream.bitRate === request.bitRate &&
+            stream.bitDepth === request.bitDepth);
+        if (existingStream) {
+            device.log.info(`MatterbridgeCameraAvStreamManagementServer: reused audio stream ${existingStream.audioStreamId} for usage ${request.streamUsage} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+            emitCommand(this.endpoint, CameraAvStreamManagementServer.id, 'audioStreamAllocate', request, this.context);
+            return { audioStreamId: existingStream.audioStreamId };
+        }
+        let audioStreamId = 0;
+        for (const stream of this.state.allocatedAudioStreams) {
+            audioStreamId = Math.max(audioStreamId, stream.audioStreamId + 1);
+        }
+        this.state.allocatedAudioStreams = [
+            ...this.state.allocatedAudioStreams,
+            {
+                audioStreamId,
+                streamUsage: request.streamUsage,
+                audioCodec: request.audioCodec,
+                channelCount: request.channelCount,
+                sampleRate: request.sampleRate,
+                bitRate: request.bitRate,
+                bitDepth: request.bitDepth,
+                referenceCount: 0,
+            },
+        ];
+        device.log.info(`MatterbridgeCameraAvStreamManagementServer: allocated audio stream ${audioStreamId} for usage ${request.streamUsage} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        emitCommand(this.endpoint, CameraAvStreamManagementServer.id, 'audioStreamAllocate', request, this.context);
+        return { audioStreamId };
+    }
+    audioStreamDeallocate(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        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);
+        }
+        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})`);
+        emitCommand(this.endpoint, CameraAvStreamManagementServer.id, 'audioStreamDeallocate', request, this.context);
+    }
+    async snapshotStreamAllocate(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        const { minResolution, maxResolution } = request;
+        const matchesCapability = this.state.snapshotCapabilities.some((capability) => capability.resolution.width >= minResolution.width &&
+            capability.resolution.width <= maxResolution.width &&
+            capability.resolution.height >= minResolution.height &&
+            capability.resolution.height <= maxResolution.height);
+        if (!matchesCapability) {
+            throw new StatusResponseError(`MatterbridgeCameraAvStreamManagementServer: snapshotStreamAllocate requested minResolution/maxResolution range does not match any entry in snapshotCapabilities (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.DynamicConstraintError);
+        }
+        const existingStream = this.state.allocatedSnapshotStreams.find((stream) => stream.imageCodec === request.imageCodec &&
+            stream.frameRate === request.maxFrameRate &&
+            stream.quality === request.quality &&
+            stream.watermarkEnabled === request.watermarkEnabled &&
+            stream.osdEnabled === request.osdEnabled &&
+            stream.minResolution.width <= request.maxResolution.width &&
+            stream.maxResolution.width >= request.minResolution.width &&
+            stream.minResolution.height <= request.maxResolution.height &&
+            stream.maxResolution.height >= request.minResolution.height);
+        if (existingStream) {
+            this.state.allocatedSnapshotStreams = this.state.allocatedSnapshotStreams.map((stream) => stream.snapshotStreamId === existingStream.snapshotStreamId
+                ? {
+                    snapshotStreamId: stream.snapshotStreamId,
+                    imageCodec: stream.imageCodec,
+                    frameRate: stream.frameRate,
+                    minResolution: request.minResolution,
+                    maxResolution: request.maxResolution,
+                    quality: stream.quality,
+                    referenceCount: stream.referenceCount,
+                    encodedPixels: stream.encodedPixels,
+                    hardwareEncoder: stream.hardwareEncoder,
+                    watermarkEnabled: stream.watermarkEnabled,
+                    osdEnabled: stream.osdEnabled,
+                }
+                : stream);
+            device.log.info(`MatterbridgeCameraAvStreamManagementServer: reused snapshot stream ${existingStream.snapshotStreamId} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+            emitCommand(this.endpoint, CameraAvStreamManagementServer.id, 'snapshotStreamAllocate', request, this.context);
+            return { snapshotStreamId: existingStream.snapshotStreamId };
+        }
+        let snapshotStreamId = 0;
+        for (const stream of this.state.allocatedSnapshotStreams) {
+            snapshotStreamId = Math.max(snapshotStreamId, stream.snapshotStreamId + 1);
+        }
+        this.state.allocatedSnapshotStreams = [
+            ...this.state.allocatedSnapshotStreams,
+            {
+                snapshotStreamId,
+                imageCodec: request.imageCodec,
+                frameRate: request.maxFrameRate,
+                minResolution: request.minResolution,
+                maxResolution: request.maxResolution,
+                quality: request.quality,
+                referenceCount: 0,
+                encodedPixels: false,
+                hardwareEncoder: false,
+                watermarkEnabled: request.watermarkEnabled,
+                osdEnabled: request.osdEnabled,
+            },
+        ];
+        device.log.info(`MatterbridgeCameraAvStreamManagementServer: allocated snapshot stream ${snapshotStreamId} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        emitCommand(this.endpoint, CameraAvStreamManagementServer.id, 'snapshotStreamAllocate', request, this.context);
+        return { snapshotStreamId };
+    }
+    async snapshotStreamDeallocate(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        if (!this.state.allocatedSnapshotStreams.some((stream) => stream.snapshotStreamId === request.snapshotStreamId)) {
+            throw new StatusResponseError(`MatterbridgeCameraAvStreamManagementServer: snapshot stream ${request.snapshotStreamId} is not present in allocatedSnapshotStreams (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.NotFound);
+        }
+        this.state.allocatedSnapshotStreams = this.state.allocatedSnapshotStreams.filter((stream) => stream.snapshotStreamId !== request.snapshotStreamId);
+        device.log.info(`MatterbridgeCameraAvStreamManagementServer: deallocated snapshot stream ${request.snapshotStreamId} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        emitCommand(this.endpoint, CameraAvStreamManagementServer.id, 'snapshotStreamDeallocate', request, this.context);
+    }
+    captureSnapshot(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        const { snapshotStreamId } = request;
+        const stream = this.state.allocatedSnapshotStreams.find((s) => snapshotStreamId === null || s.snapshotStreamId === snapshotStreamId);
+        if (!stream) {
+            throw new StatusResponseError(`MatterbridgeCameraAvStreamManagementServer: snapshot stream ${snapshotStreamId ?? 'auto'} is not present in allocatedSnapshotStreams (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.NotFound);
+        }
+        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);
+        emitCommand(this.endpoint, CameraAvStreamManagementServer.id, 'captureSnapshot', request, this.context);
+        return {
+            data,
+            imageCodec: CameraAvStreamManagement.ImageCodec.Jpeg,
+            resolution,
+        };
+    }
+}
+export function createDefaultCameraAvStreamManagementClusterServer(endpoint, options) {
+    endpoint.behaviors.require(MatterbridgeCameraAvStreamManagementServer.with(CameraAvStreamManagement.Feature.Video, CameraAvStreamManagement.Feature.Audio, CameraAvStreamManagement.Feature.Snapshot, CameraAvStreamManagement.Feature.ImageControl), {
+        ...options,
+        hardPrivacyModeOn: false,
+        statusLightEnabled: false,
+        statusLightBrightness: ThreeLevelAuto.Auto,
+        allocatedVideoStreams: [],
+        allocatedAudioStreams: [],
+        allocatedSnapshotStreams: [],
+        microphoneMuted: false,
+        microphoneVolumeLevel: 128,
+        microphoneMaxLevel: 254,
+        microphoneMinLevel: 0,
+        microphoneAgcEnabled: false,
+        imageRotation: 0,
+        imageFlipVertical: false,
+        imageFlipHorizontal: false,
+    });
+    return endpoint;
+}
+export function createDefaultAudioCameraAvStreamManagementClusterServer(endpoint, options) {
+    endpoint.behaviors.require(MatterbridgeCameraAvStreamManagementServer.with(CameraAvStreamManagement.Feature.Audio), {
+        ...options,
+        hardPrivacyModeOn: false,
+        statusLightEnabled: false,
+        allocatedAudioStreams: [],
+        microphoneMuted: false,
+        microphoneVolumeLevel: 128,
+        microphoneMaxLevel: 254,
+        microphoneMinLevel: 0,
+        microphoneAgcEnabled: false,
+    });
+    return endpoint;
+}
+export function createDefaultIntercomCameraAvStreamManagementClusterServer(endpoint, options) {
+    endpoint.behaviors.require(MatterbridgeCameraAvStreamManagementServer.with(CameraAvStreamManagement.Feature.Audio, CameraAvStreamManagement.Feature.Speaker), {
+        ...options,
+        hardPrivacyModeOn: false,
+        statusLightEnabled: false,
+        allocatedAudioStreams: [],
+        microphoneMuted: false,
+        microphoneVolumeLevel: 128,
+        microphoneMaxLevel: 254,
+        microphoneMinLevel: 0,
+        microphoneAgcEnabled: false,
+        speakerMuted: false,
+        speakerVolumeLevel: 128,
+        speakerMaxLevel: 254,
+        speakerMinLevel: 0,
+    });
+    return endpoint;
+}
+export function createDefaultSnapshotCameraAvStreamManagementClusterServer(endpoint, options) {
+    endpoint.behaviors.require(MatterbridgeCameraAvStreamManagementServer.with(CameraAvStreamManagement.Feature.Snapshot), {
+        maxContentBufferSize: options.maxContentBufferSize,
+        maxNetworkBandwidth: options.maxNetworkBandwidth,
+        supportedStreamUsages: options.supportedStreamUsages,
+        streamUsagePriorities: options.streamUsagePriorities,
+        maxConcurrentEncoders: options.maxConcurrentEncoders,
+        maxEncodedPixelRate: options.maxEncodedPixelRate,
+        snapshotCapabilities: options.snapshotCapabilities,
+        allocatedSnapshotStreams: [],
+    });
+    return endpoint;
+}

package/dist/behaviors/chimeServer.d.ts

@@ -0,0 +1,12 @@
+import { ChimeServer } from '@matter/node/behaviors/chime';
+import type { Chime } from '@matter/types/clusters/chime';
+import type { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export type ChimeId = number;
+declare const ChimeServerBase: import("@matter/node").ClusterBehavior.Type<typeof ChimeServer, import("@matter/types").ClusterType.WithEnabledAttributes<import("@matter/types").ClusterType.WithEnabledEvents<Chime, "chimeStartedPlaying">, never>, import("@matter/types").ClusterType.Concrete, new () => {}, "chime">;
+export declare class MatterbridgeChimeServer extends ChimeServerBase {
+    #private;
+    initialize(): void;
+    playChimeSound(request: Chime.PlayChimeSoundRequest): Promise<void>;
+}
+export declare function createDefaultChimeClusterServer(endpoint: MatterbridgeEndpoint, installedChimeSounds: Chime.ChimeSound[], selectedChime: ChimeId, enabled?: boolean): MatterbridgeEndpoint;
+export {};

package/dist/behaviors/chimeServer.js

@@ -0,0 +1,37 @@
+import { ChimeServer } from '@matter/node/behaviors/chime';
+import { Status, StatusResponseError } from '@matter/types';
+import { emitCommand } from '../matterbridgeEndpointHelpers.js';
+import { MatterbridgeServer } from './matterbridgeServer.js';
+const ChimeServerBase = ChimeServer.enable({ events: { chimeStartedPlaying: true } });
+export class MatterbridgeChimeServer extends ChimeServerBase {
+    initialize() {
+        this.reactTo(this.events.selectedChime$Changing, this.#assertSelectedChime);
+    }
+    #assertSelectedChime(chimeId) {
+        if (!this.state.installedChimeSounds.some((chimeSound) => chimeSound.chimeId === chimeId)) {
+            throw new StatusResponseError(`MatterbridgeChimeServer: chime sound ${chimeId} is not present in installedChimeSounds (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.NotFound);
+        }
+    }
+    async playChimeSound(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer);
+        if (!this.state.enabled) {
+            device.log.debug(`MatterbridgeChimeServer: playChimeSound called but chime is disabled (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+            return;
+        }
+        const chimeId = request.chimeId ?? this.state.selectedChime;
+        if (!this.state.installedChimeSounds.some((chimeSound) => chimeSound.chimeId === chimeId)) {
+            throw new StatusResponseError(`MatterbridgeChimeServer: chime sound ${chimeId} is not present in installedChimeSounds (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`, Status.NotFound);
+        }
+        device.log.info(`MatterbridgeChimeServer: playing chime sound with chimeId ${chimeId} (endpoint ${this.endpoint.maybeId}.${this.endpoint.maybeNumber})`);
+        this.events.chimeStartedPlaying.emit({ chimeId }, this.context);
+        emitCommand(this.endpoint, ChimeServer.id, 'playChimeSound', request, this.context);
+    }
+}
+export function createDefaultChimeClusterServer(endpoint, installedChimeSounds, selectedChime, enabled = true) {
+    endpoint.behaviors.require(MatterbridgeChimeServer, {
+        installedChimeSounds,
+        selectedChime,
+        enabled,
+    });
+    return endpoint;
+}

package/dist/behaviors/clients.d.ts

@@ -0,0 +1,4 @@
+import type { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export declare function addChimeClient(endpoint: MatterbridgeEndpoint): MatterbridgeEndpoint;
+export declare function addWebRtcTransportRequestorClient(endpoint: MatterbridgeEndpoint): MatterbridgeEndpoint;
+export declare function addWebRtcTransportProviderClient(endpoint: MatterbridgeEndpoint): MatterbridgeEndpoint;