@matterbridge/core 3.10.10-dev-20260912-8fddbe4 → 3.10.10-dev-20260915-57739b4

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';
     }
@@ -328,7 +324,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 +360,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 +450,8 @@ export function createDefaultSnapshotCameraAvStreamManagementClusterServer(endpo
         maxEncodedPixelRate: options.maxEncodedPixelRate,
         snapshotCapabilities: options.snapshotCapabilities,
         allocatedSnapshotStreams: [],
+        snapshotSource: options.snapshotSource,
+        snapshotSourceDevice: options.snapshotSourceDevice,
     });
     return endpoint;
 }

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.js

@@ -255,8 +255,8 @@ export class MatterbridgeWebRtcTransportProviderServer extends WebRtcTransportPr
         const webRtcPeer = new WeriftWebRtcSession(webRtcSessionId, this.state.weriftOfferOptions);
         this.internal.sessions.set(webRtcSessionId, webRtcPeer);
         const sdp = await webRtcPeer.createOffer({
-            video: !!videoStreams?.length,
-            audio: !!audioStreams?.length,
+            offerVideo: !!videoStreams?.length,
+            offerAudio: !!audioStreams?.length,
             videoResolution: this.state.weriftOfferOptions.videoResolution ?? this.#resolveVideoResolution(videoStreams),
         });
         if (requestorEndpoint) {
@@ -324,8 +324,8 @@ export class MatterbridgeWebRtcTransportProviderServer extends WebRtcTransportPr
         const webRtcPeer = this.internal.sessions.get(webRtcSessionId) ?? new WeriftWebRtcSession(webRtcSessionId, this.state.weriftOfferOptions);
         this.internal.sessions.set(webRtcSessionId, webRtcPeer);
         const sdp = await webRtcPeer.createAnswer(request.sdp, {
-            video: !!session.videoStreams?.length,
-            audio: !!session.audioStreams?.length,
+            offerVideo: !!session.videoStreams?.length,
+            offerAudio: !!session.audioStreams?.length,
             videoResolution: this.state.weriftOfferOptions.videoResolution ?? this.#resolveVideoResolution(session.videoStreams),
         });
         const requestorEndpoint = await this.#resolvePeerRequestorEndpoint(session.peerNodeId, session.fabricIndex, session.peerEndpointId);
@@ -407,7 +407,7 @@ export class MatterbridgeWebRtcTransportProviderServer extends WebRtcTransportPr
 }
 (function (MatterbridgeWebRtcTransportProviderServer) {
     class State extends WebRtcTransportProviderServer.State {
-        weriftOfferOptions = { video: true, audio: true, videoSource: 'none', audioSource: 'none' };
+        weriftOfferOptions = { offerVideo: true, offerAudio: true, videoSource: 'none', audioSource: 'none' };
     }
     MatterbridgeWebRtcTransportProviderServer.State = State;
     class Internal {
@@ -416,7 +416,7 @@ export class MatterbridgeWebRtcTransportProviderServer extends WebRtcTransportPr
     }
     MatterbridgeWebRtcTransportProviderServer.Internal = Internal;
 })(MatterbridgeWebRtcTransportProviderServer || (MatterbridgeWebRtcTransportProviderServer = {}));
-export function createDefaultWebRtcTransportProviderClusterServer(endpoint, weriftOfferOptions = { video: true, audio: true, videoSource: 'none', audioSource: 'none' }) {
+export function createDefaultWebRtcTransportProviderClusterServer(endpoint, weriftOfferOptions = { offerVideo: true, offerAudio: true, videoSource: 'none', audioSource: 'none' }) {
     endpoint.behaviors.require(MatterbridgeWebRtcTransportProviderServer, { currentSessions: [], weriftOfferOptions });
     return endpoint;
 }

package/dist/behaviors/weriftSession.d.ts

@@ -2,8 +2,8 @@ import { RTCPeerConnection } from 'werift';
 type VideoSource = 'none' | 'test' | 'webcam' | 'rtsp';
 type AudioSource = 'none' | 'test' | 'microphone' | 'rtsp';
 export interface WeriftOfferOptions {
-    video: boolean;
-    audio: boolean;
+    offerVideo: boolean;
+    offerAudio: boolean;
     videoSource: VideoSource;
     videoSourceDevice?: string;
     videoResolution?: string;
@@ -29,6 +29,8 @@ export declare class WeriftWebRtcSession {
     private static readonly DIAGNOSTICS_INTERVAL_MS;
     private lastDiagnosticsCounters?;
     private readonly dtlsTransportsWithStateLogging;
+    private static parseIcePortRange;
+    private static parseIceAdditionalHostAddresses;
     constructor(webRtcSessionId: number, options: WeriftOfferOptions);
     private summarizeSdp;
     private getFreeUdpPort;
@@ -40,10 +42,11 @@ export declare class WeriftWebRtcSession {
     private getConfiguredVideoResolution;
     private getConfiguredVideoSource;
     private buildFfmpegVideoInputArgs;
+    private logFfmpegStderr;
     private generateVideoTrack;
     private preferVideoCodecOnTransceivers;
     private preferAudioCodecOnTransceivers;
-    private static readonly TEST_VOICE_PATH;
+    private static readonly TEST_TONE_INPUT;
     private getConfiguredAudioSource;
     private buildFfmpegAudioInputArgs;
     private generateAudioTrack;

package/dist/behaviors/weriftSession.js

@@ -1,5 +1,4 @@
 import { createSocket } from 'node:dgram';
-import { fileURLToPath } from 'node:url';
 import { fireAndForget, getErrorMessage } from '@matterbridge/utils';
 import { AnsiLogger, MAGENTA } from 'node-ansi-logger';
 import { RTCPeerConnection, RTCRtpCodecParameters, useH264, useOPUS, usePCMU, useVP8 } from 'werift';
@@ -22,11 +21,35 @@ export class WeriftWebRtcSession {
     static DIAGNOSTICS_INTERVAL_MS = 10_000;
     lastDiagnosticsCounters;
     dtlsTransportsWithStateLogging = new Set();
+    static parseIcePortRange() {
+        const raw = process.env.MATTERBRIDGE_ICE_PORT_RANGE?.trim();
+        if (!raw)
+            return undefined;
+        const match = /^(\d{1,5})-(\d{1,5})$/.exec(raw);
+        if (!match)
+            return undefined;
+        const min = Number(match[1]);
+        const max = Number(match[2]);
+        if (min < 1024 || max > 65_535 || min >= max)
+            return undefined;
+        return [min, max];
+    }
+    static parseIceAdditionalHostAddresses() {
+        const addresses = process.env.MATTERBRIDGE_ICE_HOST_ADDRESSES?.split(',')
+            .map((address) => address.trim())
+            .filter((address) => address.length > 0) ?? [];
+        return addresses.length > 0 ? addresses : undefined;
+    }
     constructor(webRtcSessionId, options) {
         this.webRtcSessionId = webRtcSessionId;
         this.options = { ...options };
-        this.peerConnection = new RTCPeerConnection({ codecs: { audio: [useOPUS(), usePCMU()], video: [useH264(), useVP8()] } });
+        const icePortRange = WeriftWebRtcSession.parseIcePortRange();
+        const iceAdditionalHostAddresses = WeriftWebRtcSession.parseIceAdditionalHostAddresses();
+        this.peerConnection = new RTCPeerConnection({ codecs: { audio: [useOPUS(), usePCMU()], video: [useH264(), useVP8()] }, icePortRange, iceAdditionalHostAddresses });
         this.log = new AnsiLogger({ logName: `WebRTC session ${webRtcSessionId}`, logLevel: "debug", logNameColor: MAGENTA, logTimestampFormat: 4 });
+        if (icePortRange || iceAdditionalHostAddresses) {
+            this.log.debug(`ICE overrides: portRange=${icePortRange ? `${icePortRange[0]}-${icePortRange[1]}` : 'default'} additionalHostAddresses=${iceAdditionalHostAddresses?.join(', ') ?? 'none'}`);
+        }
         this.peerConnection.iceGatheringStateChange.subscribe((state) => {
             this.log.info(`ICE gathering state: ${state}`);
         });
@@ -154,19 +177,19 @@ export class WeriftWebRtcSession {
         }
     }
     buildFfmpegVideoInputArgs(videoSource) {
-        const testPatternInput = {
-            args: ['-re', '-f', 'lavfi', '-i', 'testsrc=size=640x480:rate=10'],
-            description: 'synthetic moving test pattern',
-            bitrateKbps: WeriftWebRtcSession.DEFAULT_BITRATE_KBPS,
-        };
         if (videoSource === 'test') {
+            const testPatternInput = {
+                args: ['-re', '-f', 'lavfi', '-i', 'testsrc=size=640x480:rate=10'],
+                description: 'synthetic moving test pattern',
+                bitrateKbps: WeriftWebRtcSession.DEFAULT_BITRATE_KBPS,
+            };
             this.log.debug(`Test pattern params: resolution=640x480, description="${testPatternInput.description}", bitrateKbps=${testPatternInput.bitrateKbps}`);
             return testPatternInput;
         }
         const device = this.options.videoSourceDevice;
         if (!device) {
-            this.log.warn(`options.videoSource=${videoSource} requires options.videoSourceDevice to be set; falling back to the synthetic test video`);
-            return testPatternInput;
+            this.log.error(`options.videoSource=${videoSource} requires options.videoSourceDevice to be set; not injecting a video track`);
+            return undefined;
         }
         const resolution = this.getConfiguredVideoResolution();
         const bitrateKbps = this.getConfiguredVideoBitrate();
@@ -185,10 +208,17 @@ export class WeriftWebRtcSession {
             case 'win32':
                 return { args: ['-f', 'dshow', '-video_size', resolution, '-framerate', '30', '-i', `video=${device}`], description, bitrateKbps };
             default:
-                this.log.warn(`Webcam capture via ffmpeg is not supported on platform "${process.platform}"; falling back to the synthetic test video`);
-                return testPatternInput;
+                this.log.error(`Webcam capture via ffmpeg is not supported on platform "${process.platform}"; not injecting a video track`);
+                return undefined;
         }
     }
+    logFfmpegStderr(generator, kind) {
+        generator.stderr?.on('data', (chunk) => {
+            const message = chunk.toString().trim();
+            if (message)
+                this.log.debug(`Ffmpeg ${kind} generator: ${message}`);
+        });
+    }
     async generateVideoTrack(codec) {
         if (this.testVideoAttached)
             return;
@@ -198,6 +228,8 @@ export class WeriftWebRtcSession {
             return;
         }
         const videoInput = this.buildFfmpegVideoInputArgs(videoSource);
+        if (!videoInput)
+            return;
         this.log.debug(`Attempting to attach ${videoInput.description} video track at ${videoInput.bitrateKbps}kbps`);
         if (!hasFfmpeg()) {
             this.log.warn('Cannot inject video stream: missing dependency ffmpeg');
@@ -230,6 +262,7 @@ export class WeriftWebRtcSession {
                 `rtp://127.0.0.1:${udpPort}`,
             ];
             const generator = runFfmpeg(ffmpegArgs);
+            this.logFfmpegStderr(generator, 'video');
             generator.once('error', (error) => {
                 this.log.warn(`Video generator failed: ${getErrorMessage(error)}`);
             });
@@ -272,7 +305,7 @@ export class WeriftWebRtcSession {
             this.log.debug(`Preferred ${mimeType.toUpperCase()} codecs on ${adjustedTransceivers} audio transceiver(s)`);
         }
     }
-    static TEST_VOICE_PATH = fileURLToPath(new URL('../../assets/test-voice.opus', import.meta.url));
+    static TEST_TONE_INPUT = 'sine=frequency=440:beep_factor=4:sample_rate=48000,volume=6dB';
     getConfiguredAudioSource() {
         const source = this.options.audioSource?.trim().toLowerCase() ?? 'none';
         switch (source) {
@@ -287,17 +320,13 @@ export class WeriftWebRtcSession {
         }
     }
     buildFfmpegAudioInputArgs(audioSource) {
-        const testVoiceInput = {
-            args: ['-re', '-stream_loop', '-1', '-i', WeriftWebRtcSession.TEST_VOICE_PATH],
-            description: 'recorded test-voice clip',
-            volumeFilter: 'volume=6dB',
-        };
-        if (audioSource === 'test')
-            return testVoiceInput;
+        if (audioSource === 'test') {
+            return { args: ['-re', '-f', 'lavfi', '-i', WeriftWebRtcSession.TEST_TONE_INPUT], description: 'synthetic test tone' };
+        }
         const device = this.options.audioSourceDevice;
         if (!device) {
-            this.log.warn(`options.audioSource=${audioSource} requires options.audioSourceDevice to be set; falling back to the recorded test-voice clip`);
-            return testVoiceInput;
+            this.log.error(`options.audioSource=${audioSource} requires options.audioSourceDevice to be set; not injecting an audio track`);
+            return undefined;
         }
         if (audioSource === 'rtsp') {
             const description = `RTSP camera audio (${device})`;
@@ -314,8 +343,8 @@ export class WeriftWebRtcSession {
             case 'win32':
                 return { args: ['-f', 'dshow', '-i', `audio=${device}`], description };
             default:
-                this.log.warn(`Microphone capture via ffmpeg is not supported on platform "${process.platform}"; falling back to the recorded test-voice clip`);
-                return testVoiceInput;
+                this.log.error(`Microphone capture via ffmpeg is not supported on platform "${process.platform}"; not injecting an audio track`);
+                return undefined;
         }
     }
     async generateAudioTrack(codec) {
@@ -327,6 +356,8 @@ export class WeriftWebRtcSession {
             return;
         }
         const audioInput = this.buildFfmpegAudioInputArgs(audioSource);
+        if (!audioInput)
+            return;
         this.log.debug(`Attempting to attach ${audioInput.description} audio track`);
         if (!hasFfmpeg()) {
             this.log.warn('Cannot inject audio stream: missing dependency ffmpeg');
@@ -349,13 +380,12 @@ export class WeriftWebRtcSession {
                 'error',
                 ...audioInput.args,
                 '-vn',
-                ...(audioInput.volumeFilter ? ['-af', audioInput.volumeFilter] : []),
                 '-c:a',
                 'libopus',
                 '-b:a',
                 '32k',
                 '-ac',
-                String(channels),
+                '1',
                 '-ar',
                 String(clockRate),
                 '-f',
@@ -365,6 +395,7 @@ export class WeriftWebRtcSession {
                 `rtp://127.0.0.1:${udpPort}`,
             ];
             const generator = runFfmpeg(ffmpegArgs);
+            this.logFfmpegStderr(generator, 'audio');
             generator.once('error', (error) => {
                 this.log.warn(`Audio generator failed: ${getErrorMessage(error)}`);
             });
@@ -403,8 +434,8 @@ export class WeriftWebRtcSession {
     async createOffer(overrides) {
         this.applyOptionOverrides(overrides);
         const options = this.options;
-        this.log.debug(`CreateOffer requested (video=${options.video}, audio=${options.audio}, videoResolution=${options.videoResolution ?? 'undefined'})`);
-        if (options.video) {
+        this.log.debug(`CreateOffer requested (offerVideo=${options.offerVideo}, offerAudio=${options.offerAudio}, videoResolution=${options.videoResolution ?? 'undefined'})`);
+        if (options.offerVideo) {
             const preferredCodec = this.getPreferredInjectableVideoCodec();
             if (preferredCodec) {
                 this.preferVideoCodecOnTransceivers(preferredCodec.mimeType.toLowerCase());
@@ -416,7 +447,7 @@ export class WeriftWebRtcSession {
             if (!this.testVideoAttached)
                 this.peerConnection.addTransceiver('video', { direction: 'sendonly' });
         }
-        if (options.audio)
+        if (options.offerAudio)
             this.peerConnection.addTransceiver('audio', { direction: 'sendonly' });
         const offer = await this.peerConnection.createOffer();
         await this.peerConnection.setLocalDescription(offer);

package/dist/chipTests.js

@@ -21,11 +21,14 @@ import { RefrigeratorAlarm } from '@matter/types/clusters/refrigerator-alarm';
 import { RvcOperationalState } from '@matter/types/clusters/rvc-operational-state';
 import { RvcRunMode } from '@matter/types/clusters/rvc-run-mode';
 import { SmokeCoAlarm } from '@matter/types/clusters/smoke-co-alarm';
+import { Switch } from '@matter/types/clusters/switch';
 import { TariffPriceType, TariffUnit } from '@matter/types/globals';
+import { wait } from '@matterbridge/utils/wait';
 import { MatterbridgeOccupancySensingServer } from './behaviors/occupancySensingServer.js';
 import { cliEmitter } from './cliEmitter.js';
 import { MatterbridgeRvcOperationalStateServer, MatterbridgeRvcRunModeServer } from './devices/roboticVacuumCleaner.js';
 import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
+import { featuresFor } from './matterbridgeEndpointHelpers.js';
 const chipTestAppPipePath = '/tmp/matterbridge-chip-test-app-pipe';
 const chipTestValidEventTrigger = 0xfffffffffff10000n;
 const smokeCoAlarmWarningSmokeAlarmTrigger = 0x005c000000000090n;
@@ -1097,10 +1100,87 @@ async function handleChipTestAppPipeCommand(matterbridge, command) {
             }
             matterbridge.log.info(`CHIP test app pipe OperationalStateChange(${command.Operation}${command.Param === undefined ? '' : `, ${command.Param}`}) applied on endpoint ${endpointId}`);
             return;
+        case 'SimulateSwitchIdle':
+            await endpoint.setAttribute(Switch.id, 'currentPosition', 0, matterbridge.log);
+            matterbridge.log.info(`CHIP test app pipe set Switch.CurrentPosition to 0 (idle) on endpoint ${endpointId}`);
+            return;
+        case 'SimulateLongPress':
+            await simulateChipTestSwitchLongPress(matterbridge, endpoint, endpointId, command);
+            return;
+        case 'SimulateLatchPosition': {
+            const newPosition = command.PositionId ?? 0;
+            if (endpoint.getAttribute(Switch.id, 'currentPosition', matterbridge.log) === newPosition) {
+                matterbridge.log.info(`CHIP test app pipe left Switch latched at position ${newPosition} on endpoint ${endpointId}`);
+                return;
+            }
+            await endpoint.setAttribute(Switch.id, 'currentPosition', newPosition, matterbridge.log);
+            await endpoint.triggerEvent(Switch.id, 'switchLatched', { newPosition }, matterbridge.log);
+            matterbridge.log.info(`CHIP test app pipe latched Switch to position ${newPosition} on endpoint ${endpointId}`);
+            return;
+        }
+        case 'SimulateMultiPress':
+            await simulateChipTestSwitchMultiPress(matterbridge, endpoint, endpointId, command);
+            return;
         default:
             matterbridge.log.warn(`Ignoring unsupported CHIP test app pipe command: ${JSON.stringify(command)}`);
     }
 }
+async function simulateChipTestSwitchLongPress(matterbridge, endpoint, endpointId, command) {
+    if (!endpoint.hasClusterServer(Switch.id)) {
+        matterbridge.log.warn(`Ignoring SimulateLongPress CHIP test app pipe command on endpoint ${endpointId} without a Switch cluster server`);
+        return;
+    }
+    const features = featuresFor(endpoint, Switch.id);
+    const newPosition = command.ButtonId ?? 1;
+    const delayMs = command.LongPressDelayMillis ?? 0;
+    const durationMs = command.LongPressDurationMillis ?? 0;
+    await endpoint.setAttribute(Switch.id, 'currentPosition', newPosition, matterbridge.log);
+    await endpoint.triggerEvent(Switch.id, 'initialPress', { newPosition }, matterbridge.log);
+    matterbridge.log.info(`CHIP test app pipe pressed Switch position ${newPosition} on endpoint ${endpointId} for ${durationMs}ms`);
+    if (features.momentarySwitchLongPress) {
+        await wait(Math.min(delayMs, durationMs));
+        await endpoint.triggerEvent(Switch.id, 'longPress', { newPosition }, matterbridge.log);
+        await wait(Math.max(durationMs - delayMs, 0));
+    }
+    else {
+        await wait(durationMs);
+    }
+    await endpoint.setAttribute(Switch.id, 'currentPosition', 0, matterbridge.log);
+    if (features.momentarySwitchLongPress) {
+        await endpoint.triggerEvent(Switch.id, 'longRelease', { previousPosition: newPosition }, matterbridge.log);
+    }
+    else if (features.momentarySwitchRelease) {
+        await endpoint.triggerEvent(Switch.id, 'shortRelease', { previousPosition: newPosition }, matterbridge.log);
+    }
+    matterbridge.log.info(`CHIP test app pipe released Switch position ${newPosition} on endpoint ${endpointId}`);
+}
+async function simulateChipTestSwitchMultiPress(matterbridge, endpoint, endpointId, command) {
+    if (!endpoint.hasClusterServer(Switch.id)) {
+        matterbridge.log.warn(`Ignoring SimulateMultiPress CHIP test app pipe command on endpoint ${endpointId} without a Switch cluster server`);
+        return;
+    }
+    const features = featuresFor(endpoint, Switch.id);
+    const newPosition = command.ButtonId ?? 1;
+    const presses = Math.max(command.MultiPressNumPresses ?? 1, 1);
+    const pressedMs = command.MultiPressPressedTimeMillis ?? 0;
+    const releasedMs = command.MultiPressReleasedTimeMillis ?? 0;
+    const multiPressMax = endpoint.getAttribute(Switch.id, 'multiPressMax', matterbridge.log) ?? command.MultiPressMax ?? presses;
+    for (let press = 1; press <= presses; press++) {
+        await endpoint.setAttribute(Switch.id, 'currentPosition', newPosition, matterbridge.log);
+        await endpoint.triggerEvent(Switch.id, 'initialPress', { newPosition }, matterbridge.log);
+        if (press > 1) {
+            await endpoint.triggerEvent(Switch.id, 'multiPressOngoing', { newPosition, currentNumberOfPressesCounted: Math.min(press, multiPressMax) }, matterbridge.log);
+        }
+        await wait(pressedMs);
+        await endpoint.setAttribute(Switch.id, 'currentPosition', 0, matterbridge.log);
+        if (features.momentarySwitchRelease) {
+            await endpoint.triggerEvent(Switch.id, 'shortRelease', { previousPosition: newPosition }, matterbridge.log);
+        }
+        await wait(releasedMs);
+    }
+    await endpoint.triggerEvent(Switch.id, 'multiPressComplete', { previousPosition: newPosition, totalNumberOfPressesCounted: Math.min(presses, multiPressMax) }, matterbridge.log);
+    matterbridge.log.info(`CHIP test app pipe completed ${presses} press(es) of Switch position ${newPosition} on endpoint ${endpointId}`);
+}
 function getChipTestEndpoint(matterbridge, endpointId) {
     const aggregatorEndpoint = matterbridge.aggregatorNode;
     if (!aggregatorEndpoint)
@@ -1127,5 +1207,14 @@ function isChipTestAppPipeCommand(value) {
         (!('SoilMoistureValue' in value) || typeof value.SoilMoistureValue === 'number') &&
         (!('Device' in value) || typeof value.Device === 'string') &&
         (!('Operation' in value) || typeof value.Operation === 'string') &&
-        (!('Param' in value) || typeof value.Param === 'number'));
+        (!('Param' in value) || typeof value.Param === 'number') &&
+        (!('ButtonId' in value) || typeof value.ButtonId === 'number') &&
+        (!('LongPressDelayMillis' in value) || typeof value.LongPressDelayMillis === 'number') &&
+        (!('LongPressDurationMillis' in value) || typeof value.LongPressDurationMillis === 'number') &&
+        (!('FeatureMap' in value) || typeof value.FeatureMap === 'number') &&
+        (!('PositionId' in value) || typeof value.PositionId === 'number') &&
+        (!('MultiPressPressedTimeMillis' in value) || typeof value.MultiPressPressedTimeMillis === 'number') &&
+        (!('MultiPressReleasedTimeMillis' in value) || typeof value.MultiPressReleasedTimeMillis === 'number') &&
+        (!('MultiPressNumPresses' in value) || typeof value.MultiPressNumPresses === 'number') &&
+        (!('MultiPressMax' in value) || typeof value.MultiPressMax === 'number'));
 }

package/dist/demoDevices.js

@@ -5,6 +5,7 @@ import { AirQuality } from '@matter/types/clusters/air-quality';
 import { ClosureDimension } from '@matter/types/clusters/closure-dimension';
 import { DoorLock } from '@matter/types/clusters/door-lock';
 import { FanControl } from '@matter/types/clusters/fan-control';
+import { Identify } from '@matter/types/clusters/identify';
 import { PowerSource } from '@matter/types/clusters/power-source';
 import { PowerTopology } from '@matter/types/clusters/power-topology';
 import { ResourceMonitoring } from '@matter/types/clusters/resource-monitoring';
@@ -14,18 +15,25 @@ import { Thermostat } from '@matter/types/clusters/thermostat';
 import { EndpointNumber } from '@matter/types/datatype';
 import { getErrorMessage } from '@matterbridge/utils/error';
 import { AirConditioner } from './devices/airConditioner.js';
+import { AudioDoorbell } from './devices/audioDoorbell.js';
 import { BasicVideoPlayer } from './devices/basicVideoPlayer.js';
 import { BatteryStorage } from './devices/batteryStorage.js';
+import { Camera } from './devices/camera.js';
+import { CameraController } from './devices/cameraController.js';
 import { CastingVideoClient } from './devices/castingVideoClient.js';
 import { CastingVideoPlayer } from './devices/castingVideoPlayer.js';
+import { Chime } from './devices/chime.js';
 import { Closure } from './devices/closure.js';
 import { ContentApp } from './devices/contentApp.js';
 import { Cooktop } from './devices/cooktop.js';
 import { Dishwasher } from './devices/dishwasher.js';
+import { Doorbell } from './devices/doorbell.js';
 import { ElectricalUtilityMeter } from './devices/electricalUtilityMeter.js';
 import { Evse } from './devices/evse.js';
 import { ExtractorHood } from './devices/extractorHood.js';
+import { FloodlightCamera } from './devices/floodlightCamera.js';
 import { HeatPump } from './devices/heatPump.js';
+import { Intercom } from './devices/intercom.js';
 import { IrrigationSystem } from './devices/irrigationSystem.js';
 import { LaundryDryer } from './devices/laundryDryer.js';
 import { LaundryWasher } from './devices/laundryWasher.js';
@@ -33,8 +41,10 @@ import { MicrowaveOven } from './devices/microwaveOven.js';
 import { Oven } from './devices/oven.js';
 import { Refrigerator } from './devices/refrigerator.js';
 import { RoboticVacuumCleaner } from './devices/roboticVacuumCleaner.js';
+import { SnapshotCamera } from './devices/snapshotCamera.js';
 import { SolarPower } from './devices/solarPower.js';
 import { Speaker } from './devices/speaker.js';
+import { VideoDoorbell } from './devices/videoDoorbell.js';
 import { VideoRemoteControl } from './devices/videoRemoteControl.js';
 import { WaterHeater } from './devices/waterHeater.js';
 import { getSupportedDeviceType } from './matterbridgeDeviceTypes.js';
@@ -95,6 +105,15 @@ const demoPluginSchema = {
         },
     },
 };
+let demoPluginConfig = {
+    name: demoPluginName,
+    type: demoPluginType,
+    version: demoPluginVersion,
+    debug: false,
+    unregisterOnShutdown: false,
+    whiteList: [],
+    blackList: [],
+};
 export async function createDemoDevices(matterbridge) {
     if (matterbridge.bridgeMode !== 'bridge') {
         matterbridge.log.error('Demo devices can only be created in bridge mode');
@@ -108,20 +127,10 @@ export async function createDemoDevices(matterbridge) {
     }
     const configFile = path.join(matterbridge.matterbridgeDirectory, `${demoPluginName}.config.json`);
     const schemaFile = path.join(matterbridge.matterbridgeDirectory, `${demoPluginName}.schema.json`);
-    const defaultConfig = {
-        name: demoPluginName,
-        type: demoPluginType,
-        version: demoPluginVersion,
-        debug: false,
-        unregisterOnShutdown: false,
-        whiteList: [],
-        blackList: [],
-    };
-    let config = defaultConfig;
     try {
         const storedConfig = JSON.parse(await readFile(configFile, 'utf8'));
-        config = {
-            ...defaultConfig,
+        demoPluginConfig = {
+            ...demoPluginConfig,
             ...storedConfig,
             name: demoPluginName,
             type: demoPluginType,
@@ -135,7 +144,7 @@ export async function createDemoDevices(matterbridge) {
             matterbridge.log.error(`Failed to read demo devices config ${configFile}: ${getErrorMessage(error)}`);
     }
     try {
-        await writeFile(configFile, JSON.stringify(config, null, 2), 'utf8');
+        await writeFile(configFile, JSON.stringify(demoPluginConfig, null, 2), 'utf8');
         await writeFile(schemaFile, JSON.stringify(demoPluginSchema, null, 2), 'utf8');
     }
     catch (error) {
@@ -152,14 +161,14 @@ export async function createDemoDevices(matterbridge) {
         enabled: false,
         private: true,
         registeredDevices: 0,
-        configJson: config,
+        configJson: demoPluginConfig,
         schemaJson: demoPluginSchema,
         hasWhiteList: true,
         hasBlackList: true,
     });
     const registerDevice = async (device, deviceName, serialNumber) => {
-        const whiteList = config.whiteList;
-        const blackList = config.blackList;
+        const whiteList = demoPluginConfig.whiteList;
+        const blackList = demoPluginConfig.blackList;
         if (blackList.includes(deviceName)) {
             matterbridge.log.info(`Skipping demo device ${deviceName} because it is in the blacklist`);
             return;
@@ -267,34 +276,42 @@ export async function createDemoDevices(matterbridge) {
     ep = new MatterbridgeEndpoint([getSupportedDeviceType('PumpController'), bridgedNode, powerSource], { id: 'PumpController', number: EndpointNumber(6_05) });
     ep.createDefaultPowerSourceWiredClusterServer();
     await registerDevice(ep, 'Pump Controller', 'SWITCH-06-05');
-    ep = new MatterbridgeEndpoint([getSupportedDeviceType('Aggregator'), bridgedNode, powerSource], { id: 'GenericSwitch', number: EndpointNumber(6_06) });
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('GenericSwitch'), bridgedNode, powerSource], { id: 'MomentarySwitch', number: EndpointNumber(6_06) });
+    ep.createDefaultPowerSourceBatteryClusterServer();
+    ep.createDefaultSwitchClusterServer();
+    await registerDevice(ep, 'Momentary Switch', 'SWITCH-06-06');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('GenericSwitch'), bridgedNode, powerSource], { id: 'LatchingSwitch', number: EndpointNumber(6_06_1) });
+    ep.createDefaultPowerSourceBatteryClusterServer();
+    ep.createDefaultLatchingSwitchClusterServer();
+    await registerDevice(ep, 'Latching Switch', 'SWITCH-06-06-1');
+    ep = new MatterbridgeEndpoint([getSupportedDeviceType('Aggregator'), bridgedNode, powerSource], { id: 'GenericSwitch', number: EndpointNumber(6_06_2) });
     ep.createDefaultPowerSourceBatteryClusterServer();
     await ep.addFixedLabel('composed', 'GenericSwitch');
     ep.addChildDeviceType('Button1', getSupportedDeviceType('GenericSwitch'), {
-        number: EndpointNumber(6_06_1),
+        number: EndpointNumber(6_06_3),
         tagList: [getSemtag(SwitchesTag.On), getSemtag(CommonNumberTag.One)],
     })
         .createDefaultMomentarySwitchClusterServer()
         .addRequiredClusters();
     ep.addChildDeviceType('Button2', getSupportedDeviceType('GenericSwitch'), {
-        number: EndpointNumber(6_06_2),
+        number: EndpointNumber(6_06_4),
         tagList: [getSemtag(SwitchesTag.Off), getSemtag(CommonNumberTag.Two)],
     })
         .createDefaultMomentarySwitchClusterServer()
         .addRequiredClusters();
     ep.addChildDeviceType('Button3', getSupportedDeviceType('GenericSwitch'), {
-        number: EndpointNumber(6_06_3),
+        number: EndpointNumber(6_06_5),
         tagList: [getSemtag(SwitchesTag.Up), getSemtag(CommonNumberTag.Three)],
     })
         .createDefaultMomentarySwitchClusterServer()
         .addRequiredClusters();
     ep.addChildDeviceType('Button4', getSupportedDeviceType('GenericSwitch'), {
-        number: EndpointNumber(6_06_4),
+        number: EndpointNumber(6_06_6),
         tagList: [getSemtag(SwitchesTag.Down), getSemtag(CommonNumberTag.Four)],
     })
         .createDefaultMomentarySwitchClusterServer()
         .addRequiredClusters();
-    await registerDevice(ep, 'Generic Switch', 'SWITCH-06-06');
+    await registerDevice(ep, 'Generic Switch', 'SWITCH-06-06-2');
     ep = new MatterbridgeEndpoint([getSupportedDeviceType('ContactSensor'), bridgedNode, powerSource], { id: 'ContactSensor', number: EndpointNumber(7_01) });
     ep.createDefaultPowerSourceBatteryClusterServer();
     ep.createDefaultBooleanStateClusterServer();
@@ -823,4 +840,83 @@ export async function createDemoDevices(matterbridge) {
         tagList: [getSemtag(ElectricalMeasurementTag.Ac), getSemtag(PowerSourceTag.Ev), getSemtag(CommodityTariffFlowTag.Import), getSemtag(CommodityTariffChronologyTag.Upcoming)],
     });
     await registerDevice(electricalUtilityMeterEvEndpoint, 'Electrical Utility Meter Ev', 'ENERGY-14-10');
+    ep = new Camera('Camera', 'CAMERA-16-01', {
+        id: 'Camera',
+        number: EndpointNumber(16_01),
+        weriftOfferOptions: { offerVideo: true, offerAudio: true, videoSource: 'test', audioSource: 'test' },
+    });
+    await registerDevice(ep, 'Camera', 'CAMERA-16-01');
+    ep = new Camera('Camera Ptz', 'CAMERA-16-01-1', {
+        id: 'CameraPtz',
+        number: EndpointNumber(16_01_1),
+        ptz: true,
+        identifyType: Identify.IdentifyType.VisibleIndicator,
+        weriftOfferOptions: { offerVideo: true, offerAudio: true, videoSource: 'test', audioSource: 'test' },
+    });
+    await registerDevice(ep, 'Camera Ptz', 'CAMERA-16-01-1');
+    ep = new FloodlightCamera('Floodlight Camera', 'CAMERA-16-02', {
+        id: 'FloodlightCamera',
+        number: EndpointNumber(16_02),
+        cameraOptions: {
+            number: EndpointNumber(16_02_1),
+            ptz: true,
+            identifyType: Identify.IdentifyType.VisibleIndicator,
+            weriftOfferOptions: { offerVideo: true, offerAudio: true, videoSource: 'test', audioSource: 'test' },
+        },
+        lightOptions: { number: EndpointNumber(16_02_2) },
+    });
+    await registerDevice(ep, 'Floodlight Camera', 'CAMERA-16-02');
+    ep = new VideoDoorbell('Video Doorbell', 'CAMERA-16-03', {
+        id: 'VideoDoorbell',
+        number: EndpointNumber(16_03),
+        cameraOptions: {
+            number: EndpointNumber(16_03_1),
+            ptz: true,
+            identifyType: Identify.IdentifyType.VisibleIndicator,
+            weriftOfferOptions: { offerVideo: true, offerAudio: true, videoSource: 'test', audioSource: 'test' },
+        },
+        doorbellOptions: { number: EndpointNumber(16_03_2) },
+    });
+    await registerDevice(ep, 'Video Doorbell', 'CAMERA-16-03');
+    ep = new Intercom('Intercom I', 'CAMERA-16-04', {
+        id: 'Intercom',
+        number: EndpointNumber(16_04),
+        identifyType: Identify.IdentifyType.VisibleIndicator,
+        weriftOfferOptions: { offerVideo: false, offerAudio: true, videoSource: 'none', audioSource: 'test' },
+    });
+    await registerDevice(ep, 'Intercom I', 'CAMERA-16-04');
+    ep = new Intercom('Intercom II', 'CAMERA-16-04-1', {
+        id: 'IntercomII',
+        number: EndpointNumber(16_04_1),
+        identifyType: Identify.IdentifyType.VisibleIndicator,
+        weriftOfferOptions: { offerVideo: false, offerAudio: true, videoSource: 'none', audioSource: 'test' },
+    });
+    await registerDevice(ep, 'Intercom II', 'CAMERA-16-04-1');
+    ep = new AudioDoorbell('Audio Doorbell', 'CAMERA-16-05', {
+        id: 'AudioDoorbell',
+        number: EndpointNumber(16_05),
+        weriftOfferOptions: { offerVideo: false, offerAudio: true, videoSource: 'none', audioSource: 'test' },
+    });
+    await registerDevice(ep, 'Audio Doorbell', 'CAMERA-16-05');
+    ep = new SnapshotCamera('Snapshot Camera', 'CAMERA-16-06', {
+        id: 'SnapshotCamera',
+        number: EndpointNumber(16_06),
+        identifyType: Identify.IdentifyType.VisibleIndicator,
+        snapshotSource: 'test',
+    });
+    await registerDevice(ep, 'Snapshot Camera', 'CAMERA-16-06');
+    ep = new Chime('Chime', 'CAMERA-16-07', {
+        id: 'Chime',
+        number: EndpointNumber(16_07),
+        identifyType: Identify.IdentifyType.AudibleBeep,
+        installedChimeSounds: [
+            { chimeId: 0, name: 'Default Chime' },
+            { chimeId: 1, name: 'Westminster' },
+        ],
+    });
+    await registerDevice(ep, 'Chime', 'CAMERA-16-07');
+    ep = new CameraController('Camera Controller', 'CAMERA-16-08', { id: 'CameraController', number: EndpointNumber(16_08) });
+    await registerDevice(ep, 'Camera Controller', 'CAMERA-16-08');
+    ep = new Doorbell('Doorbell', 'CAMERA-16-09', { id: 'Doorbell', number: EndpointNumber(16_09) });
+    await registerDevice(ep, 'Doorbell', 'CAMERA-16-09');
 }

package/dist/devices/camera/export.d.ts

@@ -0,0 +1,9 @@
+export * from '../audioDoorbell.js';
+export * from '../camera.js';
+export * from '../cameraController.js';
+export * from '../chime.js';
+export * from '../doorbell.js';
+export * from '../floodlightCamera.js';
+export * from '../intercom.js';
+export * from '../snapshotCamera.js';
+export * from '../videoDoorbell.js';

package/dist/devices/camera/export.js

@@ -0,0 +1,9 @@
+export * from '../audioDoorbell.js';
+export * from '../camera.js';
+export * from '../cameraController.js';
+export * from '../chime.js';
+export * from '../doorbell.js';
+export * from '../floodlightCamera.js';
+export * from '../intercom.js';
+export * from '../snapshotCamera.js';
+export * from '../videoDoorbell.js';

package/dist/devices/cameraController.d.ts

@@ -0,0 +1,8 @@
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+import type { MatterbridgeEndpointOptions } from '../matterbridgeEndpointTypes.js';
+export interface CameraControllerOptions extends MatterbridgeEndpointOptions {
+    powerSourceType?: 'Rechargeable' | 'Replaceable' | 'Battery' | 'Wired' | 'None';
+}
+export declare class CameraController extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, options?: CameraControllerOptions);
+}

package/dist/devices/cameraController.js

@@ -0,0 +1,35 @@
+import { addWebRtcTransportProviderClient } from '../behaviors/clients.js';
+import { createDefaultWebRtcTransportRequestorClusterServer } from '../behaviors/webRtcTransportRequestorServer.js';
+import { cameraController, powerSource } from '../matterbridgeDeviceTypes.js';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export class CameraController extends MatterbridgeEndpoint {
+    constructor(name, serial, options = {}) {
+        const { powerSourceType = 'Wired', id, number, tagList, mode } = options;
+        super(powerSourceType === 'None' ? [cameraController] : [cameraController, powerSource], {
+            id: id ?? `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`,
+            number,
+            tagList,
+            mode,
+        });
+        this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Camera Controller');
+        switch (powerSourceType) {
+            case 'Rechargeable':
+                this.createDefaultPowerSourceRechargeableBatteryClusterServer();
+                break;
+            case 'Replaceable':
+                this.createDefaultPowerSourceReplaceableBatteryClusterServer();
+                break;
+            case 'Battery':
+                this.createDefaultPowerSourceBatteryClusterServer();
+                break;
+            case 'Wired':
+                this.createDefaultPowerSourceWiredClusterServer();
+                break;
+            case 'None':
+                break;
+        }
+        createDefaultWebRtcTransportRequestorClusterServer(this);
+        addWebRtcTransportProviderClient(this);
+        this.addRequiredClusters();
+    }
+}

package/dist/devices/floodlightCamera.d.ts

@@ -1,11 +1,13 @@
 import type { Semtag } from '@matter/types';
+import type { EndpointNumber } from '@matter/types/datatype';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 import type { MatterbridgeEndpointOptions } from '../matterbridgeEndpointTypes.js';
 import type { CameraOptions } from './camera.js';
-export type FloodlightCameraCameraOptions = Omit<CameraOptions, 'id' | 'number' | 'tagList' | 'mode' | 'powerSourceType'>;
+export type FloodlightCameraCameraOptions = Omit<CameraOptions, 'id' | 'mode' | 'powerSourceType'>;
 export interface FloodlightCameraLightOptions {
     name?: string;
     tagList?: Semtag[];
+    number?: EndpointNumber;
     onOff?: boolean;
 }
 export interface FloodlightCameraOptions extends MatterbridgeEndpointOptions {
@@ -15,5 +17,5 @@ export interface FloodlightCameraOptions extends MatterbridgeEndpointOptions {
 }
 export declare class FloodlightCamera extends MatterbridgeEndpoint {
     constructor(name: string, serial: string, options?: FloodlightCameraOptions);
-    addLight(name: string, tagList?: Semtag[], onOff?: boolean): MatterbridgeEndpoint;
+    addLight(name: string, options?: FloodlightCameraLightOptions): MatterbridgeEndpoint;
 }

package/dist/devices/floodlightCamera.js

@@ -43,8 +43,8 @@ export class FloodlightCamera extends MatterbridgeEndpoint {
             { resolution: { width: 640, height: 480 }, maxFrameRate: 10, imageCodec: CameraAvStreamManagement.ImageCodec.Jpeg, requiresEncodedPixels: false },
             { resolution: { width: 1280, height: 720 }, maxFrameRate: 10, imageCodec: CameraAvStreamManagement.ImageCodec.Jpeg, requiresEncodedPixels: false },
             { resolution: { width: 1920, height: 1080 }, maxFrameRate: 10, imageCodec: CameraAvStreamManagement.ImageCodec.Jpeg, requiresEncodedPixels: false },
-        ], weriftOfferOptions, } = cameraOptions;
-        const cameraChild = this.addChildDeviceType('Camera', camera, {});
+        ], weriftOfferOptions, number: cameraNumber, tagList: cameraTagList = [], } = cameraOptions;
+        const cameraChild = this.addChildDeviceType('Camera', camera, { number: cameraNumber, ...(cameraTagList.length > 0 ? { tagList: cameraTagList } : {}) });
         cameraChild.log.logName = 'Camera';
         if (identifyType !== Identify.IdentifyType.None) {
             cameraChild.createDefaultIdentifyClusterServer(identifyTime, identifyType);
@@ -67,11 +67,12 @@ export class FloodlightCamera extends MatterbridgeEndpoint {
         createDefaultWebRtcTransportProviderClusterServer(cameraChild, weriftOfferOptions);
         addWebRtcTransportRequestorClient(cameraChild);
         cameraChild.addRequiredClusters();
-        const { name: lightName = 'Light', tagList: lightTagList = [], onOff: lightOnOff = false } = lightOptions;
-        this.addLight(lightName, lightTagList, lightOnOff);
+        const { name: lightName = 'Light', tagList: lightTagList = [], number: lightNumber, onOff: lightOnOff = false } = lightOptions;
+        this.addLight(lightName, { tagList: lightTagList, number: lightNumber, onOff: lightOnOff });
     }
-    addLight(name, tagList = [], onOff = false) {
-        const light = this.addChildDeviceType(name, onOffLight, tagList.length > 0 ? { tagList } : {});
+    addLight(name, options = {}) {
+        const { tagList = [], number, onOff = false } = options;
+        const light = this.addChildDeviceType(name, onOffLight, { number, ...(tagList.length > 0 ? { tagList } : {}) });
         light.log.logName = name;
         light.createDefaultIdentifyClusterServer();
         light.createDefaultOnOffClusterServer(onOff);

package/dist/devices/snapshotCamera.d.ts

@@ -1,6 +1,7 @@
 import { StreamUsage } from '@matter/types';
 import { CameraAvStreamManagement } from '@matter/types/clusters/camera-av-stream-management';
 import { Identify } from '@matter/types/clusters/identify';
+import { type SnapshotSource } from '../behaviors/cameraAvStreamManagementServer.js';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 import type { MatterbridgeEndpointOptions } from '../matterbridgeEndpointTypes.js';
 export interface SnapshotCameraOptions extends MatterbridgeEndpointOptions {
@@ -14,6 +15,8 @@ export interface SnapshotCameraOptions extends MatterbridgeEndpointOptions {
     maxNetworkBandwidth?: number;
     supportedStreamUsages?: StreamUsage[];
     streamUsagePriorities?: StreamUsage[];
+    snapshotSource?: SnapshotSource;
+    snapshotSourceDevice?: string;
 }
 export declare class SnapshotCamera extends MatterbridgeEndpoint {
     constructor(name: string, serial: string, options?: SnapshotCameraOptions);

package/dist/devices/snapshotCamera.js

@@ -10,7 +10,7 @@ export class SnapshotCamera extends MatterbridgeEndpoint {
             { resolution: { width: 640, height: 480 }, maxFrameRate: 10, imageCodec: CameraAvStreamManagement.ImageCodec.Jpeg, requiresEncodedPixels: false },
             { resolution: { width: 1280, height: 720 }, maxFrameRate: 10, imageCodec: CameraAvStreamManagement.ImageCodec.Jpeg, requiresEncodedPixels: false },
             { resolution: { width: 1920, height: 1080 }, maxFrameRate: 10, imageCodec: CameraAvStreamManagement.ImageCodec.Jpeg, requiresEncodedPixels: false },
-        ], maxNetworkBandwidth = 10000, supportedStreamUsages = [StreamUsage.Recording], streamUsagePriorities = [StreamUsage.Recording], id, number, tagList, mode, } = options;
+        ], maxNetworkBandwidth = 10000, supportedStreamUsages = [StreamUsage.Recording], streamUsagePriorities = [StreamUsage.Recording], snapshotSource, snapshotSourceDevice, id, number, tagList, mode, } = options;
         super(powerSourceType === 'None' ? [snapshotCamera] : [snapshotCamera, powerSource], {
             id: id ?? `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`,
             number,
@@ -45,6 +45,8 @@ export class SnapshotCamera extends MatterbridgeEndpoint {
             maxNetworkBandwidth,
             supportedStreamUsages,
             streamUsagePriorities,
+            snapshotSource,
+            snapshotSourceDevice,
         });
         this.addRequiredClusters();
     }

package/dist/devices/videoDoorbell.d.ts

@@ -1,12 +1,14 @@
 import type { Semtag } from '@matter/types';
 import { Identify } from '@matter/types/clusters/identify';
+import type { EndpointNumber } from '@matter/types/datatype';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
 import type { MatterbridgeEndpointOptions } from '../matterbridgeEndpointTypes.js';
 import type { CameraOptions } from './camera.js';
-export type VideoDoorbellCameraOptions = Omit<CameraOptions, 'id' | 'number' | 'tagList' | 'mode' | 'powerSourceType'>;
+export type VideoDoorbellCameraOptions = Omit<CameraOptions, 'id' | 'mode' | 'powerSourceType'>;
 export interface VideoDoorbellDoorbellOptions {
     name?: string;
     tagList?: Semtag[];
+    number?: EndpointNumber;
     identifyTime?: number;
     identifyType?: Identify.IdentifyType;
 }
@@ -17,5 +19,5 @@ export interface VideoDoorbellOptions extends MatterbridgeEndpointOptions {
 }
 export declare class VideoDoorbell extends MatterbridgeEndpoint {
     constructor(name: string, serial: string, options?: VideoDoorbellOptions);
-    addDoorbell(name: string, tagList?: Semtag[], identifyTime?: number, identifyType?: Identify.IdentifyType): MatterbridgeEndpoint;
+    addDoorbell(name: string, options?: VideoDoorbellDoorbellOptions): MatterbridgeEndpoint;
 }

package/dist/devices/videoDoorbell.js

@@ -43,8 +43,8 @@ export class VideoDoorbell extends MatterbridgeEndpoint {
             { resolution: { width: 640, height: 480 }, maxFrameRate: 10, imageCodec: CameraAvStreamManagement.ImageCodec.Jpeg, requiresEncodedPixels: false },
             { resolution: { width: 1280, height: 720 }, maxFrameRate: 10, imageCodec: CameraAvStreamManagement.ImageCodec.Jpeg, requiresEncodedPixels: false },
             { resolution: { width: 1920, height: 1080 }, maxFrameRate: 10, imageCodec: CameraAvStreamManagement.ImageCodec.Jpeg, requiresEncodedPixels: false },
-        ], weriftOfferOptions, } = cameraOptions;
-        const cameraChild = this.addChildDeviceType('Camera', camera, {});
+        ], weriftOfferOptions, number: cameraNumber, tagList: cameraTagList = [], } = cameraOptions;
+        const cameraChild = this.addChildDeviceType('Camera', camera, { number: cameraNumber, ...(cameraTagList.length > 0 ? { tagList: cameraTagList } : {}) });
         cameraChild.log.logName = 'Camera';
         if (cameraIdentifyType !== Identify.IdentifyType.None) {
             cameraChild.createDefaultIdentifyClusterServer(cameraIdentifyTime, cameraIdentifyType);
@@ -67,11 +67,12 @@ export class VideoDoorbell extends MatterbridgeEndpoint {
         createDefaultWebRtcTransportProviderClusterServer(cameraChild, weriftOfferOptions);
         addWebRtcTransportRequestorClient(cameraChild);
         cameraChild.addRequiredClusters();
-        const { name: doorbellName = 'Doorbell', tagList: doorbellTagList = [], identifyTime = 0, identifyType = Identify.IdentifyType.None } = doorbellOptions;
-        this.addDoorbell(doorbellName, doorbellTagList, identifyTime, identifyType);
+        const { name: doorbellName = 'Doorbell', tagList: doorbellTagList = [], number: doorbellNumber, identifyTime = 0, identifyType = Identify.IdentifyType.None } = doorbellOptions;
+        this.addDoorbell(doorbellName, { tagList: doorbellTagList, number: doorbellNumber, identifyTime, identifyType });
     }
-    addDoorbell(name, tagList = [], identifyTime = 0, identifyType = Identify.IdentifyType.None) {
-        const doorbellChild = this.addChildDeviceType(name, doorbell, tagList.length > 0 ? { tagList } : {});
+    addDoorbell(name, options = {}) {
+        const { tagList = [], number, identifyTime = 0, identifyType = Identify.IdentifyType.None } = options;
+        const doorbellChild = this.addChildDeviceType(name, doorbell, { number, ...(tagList.length > 0 ? { tagList } : {}) });
         doorbellChild.log.logName = name;
         doorbellChild.createDefaultIdentifyClusterServer(identifyTime, identifyType);
         doorbellChild.createDefaultMomentarySwitchClusterServer();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.10.10-dev-20260912-8fddbe4",
+  "version": "3.10.10-dev-20260915-57739b4",
   "description": "Matterbridge core library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -54,6 +54,10 @@
       "types": "./dist/devices/export.d.ts",
       "import": "./dist/devices/export.js"
     },
+    "./devices/camera": {
+      "types": "./dist/devices/camera/export.d.ts",
+      "import": "./dist/devices/camera/export.js"
+    },
     "./clusters": {
       "types": "./dist/clusters/export.d.ts",
       "import": "./dist/clusters/export.js"
@@ -132,14 +136,14 @@
   },
   "dependencies": {
     "@matter/main": "0.17.9",
-    "@matterbridge/dgram": "3.10.10-dev-20260912-8fddbe4",
-    "@matterbridge/thread": "3.10.10-dev-20260912-8fddbe4",
-    "@matterbridge/types": "3.10.10-dev-20260912-8fddbe4",
-    "@matterbridge/utils": "3.10.10-dev-20260912-8fddbe4",
+    "@matterbridge/dgram": "3.10.10-dev-20260915-57739b4",
+    "@matterbridge/thread": "3.10.10-dev-20260915-57739b4",
+    "@matterbridge/types": "3.10.10-dev-20260915-57739b4",
+    "@matterbridge/utils": "3.10.10-dev-20260915-57739b4",
     "escape-html": "1.0.3",
     "express": "5.2.1",
     "express-rate-limit": "8.7.0",
-    "multer": "2.3.0",
+    "multer": "2.4.0",
     "node-ansi-logger": "3.3.1",
     "node-persist-manager": "2.1.1",
     "werift": "0.24.4",