@matterbridge/core 3.10.10-dev-20260914-784e019 → 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;
@@ -42,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';
@@ -178,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();
@@ -209,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;
@@ -222,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');
@@ -254,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)}`);
             });
@@ -296,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) {
@@ -311,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})`;
@@ -338,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) {
@@ -351,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');
@@ -373,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',
@@ -389,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)}`);
             });
@@ -427,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());
@@ -440,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

@@ -105,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');
@@ -118,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,
@@ -145,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) {
@@ -162,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;
@@ -277,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();
@@ -836,7 +843,7 @@ export async function createDemoDevices(matterbridge) {
     ep = new Camera('Camera', 'CAMERA-16-01', {
         id: 'Camera',
         number: EndpointNumber(16_01),
-        weriftOfferOptions: { video: true, audio: true, videoSource: 'test', audioSource: 'test' },
+        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', {
@@ -844,33 +851,58 @@ export async function createDemoDevices(matterbridge) {
         number: EndpointNumber(16_01_1),
         ptz: true,
         identifyType: Identify.IdentifyType.VisibleIndicator,
-        weriftOfferOptions: { video: true, audio: true, videoSource: 'test', audioSource: 'test' },
+        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 },
+        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 },
+        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 });
+    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 });
+    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) });
+    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', {

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterbridge/core",
-  "version": "3.10.10-dev-20260914-784e019",
+  "version": "3.10.10-dev-20260915-57739b4",
   "description": "Matterbridge core library",
   "author": "https://github.com/Luligu",
   "homepage": "https://matterbridge.io/",
@@ -136,14 +136,14 @@
   },
   "dependencies": {
     "@matter/main": "0.17.9",
-    "@matterbridge/dgram": "3.10.10-dev-20260914-784e019",
-    "@matterbridge/thread": "3.10.10-dev-20260914-784e019",
-    "@matterbridge/types": "3.10.10-dev-20260914-784e019",
-    "@matterbridge/utils": "3.10.10-dev-20260914-784e019",
+    "@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",