@matterbridge/core 3.10.9-dev-20260907-5fcc59a → 3.10.9-dev-20260910-ca91bcb

package/dist/behaviors/weriftSession.js

@@ -0,0 +1,538 @@
+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';
+import { navigator } from 'werift/nonstandard';
+import { hasFfmpeg, runFfmpeg } from './ffmpeg.js';
+export class WeriftWebRtcSession {
+    static activeSessions = new Set();
+    static exitHandlerRegistered = false;
+    peerConnection;
+    log;
+    webRtcSessionId;
+    options;
+    testVideoGenerator;
+    testVideoUdpDisposer;
+    testVideoAttached = false;
+    testAudioGenerator;
+    testAudioUdpDisposer;
+    testAudioAttached = false;
+    diagnosticsInterval;
+    static DIAGNOSTICS_INTERVAL_MS = 10_000;
+    lastDiagnosticsCounters;
+    dtlsTransportsWithStateLogging = new Set();
+    constructor(webRtcSessionId, options) {
+        this.webRtcSessionId = webRtcSessionId;
+        this.options = { ...options };
+        this.peerConnection = new RTCPeerConnection({ codecs: { audio: [useOPUS(), usePCMU()], video: [useH264(), useVP8()] } });
+        this.log = new AnsiLogger({ logName: `WebRTC session ${webRtcSessionId}`, logLevel: "debug", logNameColor: MAGENTA, logTimestampFormat: 4 });
+        this.peerConnection.iceGatheringStateChange.subscribe((state) => {
+            this.log.info(`ICE gathering state: ${state}`);
+        });
+        this.peerConnection.onIceCandidate.subscribe((candidate) => {
+            this.log.debug(candidate ? `Gathered local ICE candidate: ${candidate.candidate}` : 'ICE candidate gathering completed');
+        });
+        this.peerConnection.iceConnectionStateChange.subscribe((state) => {
+            this.log.info(`ICE connection state: ${state}`);
+            if (state === 'connected' || state === 'completed') {
+                for (const transport of this.peerConnection.iceTransports) {
+                    const pair = transport.connection.nominated;
+                    if (!pair)
+                        continue;
+                    const local = pair.localCandidate;
+                    const remote = pair.remoteCandidate;
+                    this.log.info(`Selected ICE candidate pair: local=${local.host}:${local.port} (${local.type}/${local.transport}) ` +
+                        `remote=${remote.host}:${remote.port} (${remote.type}/${remote.transport})`);
+                }
+            }
+        });
+        this.peerConnection.connectionStateChange.subscribe((state) => {
+            this.log.info(`Peer connection state: ${state}`);
+        });
+        this.log.debug(`Created RTCPeerConnection with codecs: audio=[OPUS, PCMU], video=[H264, VP8] for session ${webRtcSessionId}`);
+        this.diagnosticsInterval = setInterval(() => void this.logDiagnosticsSnapshot(), WeriftWebRtcSession.DIAGNOSTICS_INTERVAL_MS);
+        WeriftWebRtcSession.activeSessions.add(this);
+        if (!WeriftWebRtcSession.exitHandlerRegistered) {
+            WeriftWebRtcSession.exitHandlerRegistered = true;
+            process.on('exit', () => {
+                for (const session of WeriftWebRtcSession.activeSessions) {
+                    if (!session.testVideoGenerator && !session.testAudioGenerator)
+                        continue;
+                    session.log.info('Process exiting: killing leftover ffmpeg processes for this session');
+                    session.testVideoGenerator?.kill('SIGTERM');
+                    session.testAudioGenerator?.kill('SIGTERM');
+                }
+            });
+        }
+    }
+    summarizeSdp(sdp) {
+        const mediaKinds = sdp
+            .split('\n')
+            .map((line) => line.trim())
+            .filter((line) => line.startsWith('m='))
+            .map((line) => line.slice(2).split(' ')[0]);
+        return `length=${sdp.length} media=[${mediaKinds.join(',')}]`;
+    }
+    async getFreeUdpPort() {
+        return await new Promise((resolve, reject) => {
+            const socket = createSocket('udp4');
+            socket.once('error', reject);
+            socket.bind(0, '127.0.0.1', () => {
+                const port = socket.address().port;
+                this.log.debug(`Allocated free UDP port ${port}`);
+                socket.close(() => resolve(port));
+            });
+        });
+    }
+    getPreferredInjectableVideoCodec() {
+        for (const transceiver of this.peerConnection.getTransceivers()) {
+            if (transceiver.kind !== 'video')
+                continue;
+            const preferredCodec = transceiver.codecs.find((codec) => {
+                const mimeType = codec.mimeType.toLowerCase();
+                return mimeType === 'video/vp8' || mimeType === 'video/h264';
+            });
+            if (preferredCodec) {
+                this.log.debug(`Preferred injectable video codec: ${preferredCodec.mimeType}`);
+                return preferredCodec;
+            }
+        }
+        this.log.debug('No preferred injectable video codec (VP8/H264) negotiated on any video transceiver');
+        return undefined;
+    }
+    getPreferredInjectableAudioCodec() {
+        for (const transceiver of this.peerConnection.getTransceivers()) {
+            if (transceiver.kind !== 'audio')
+                continue;
+            const preferredCodec = transceiver.codecs.find((codec) => codec.mimeType.toLowerCase() === 'audio/opus');
+            if (preferredCodec) {
+                this.log.debug(`Preferred injectable audio codec: ${preferredCodec.mimeType}`);
+                return preferredCodec;
+            }
+        }
+        this.log.debug('No preferred injectable audio codec (Opus) negotiated on any audio transceiver');
+        return undefined;
+    }
+    static SUPPORTED_VIDEO_RESOLUTIONS = ['640x480', '1280x720', '1920x1080'];
+    static DEFAULT_BITRATE_KBPS = 1000;
+    getConfiguredVideoBitrate() {
+        const configured = this.options.videoBitrate;
+        if (configured === undefined)
+            return WeriftWebRtcSession.DEFAULT_BITRATE_KBPS;
+        const bitrateKbps = configured;
+        if (!Number.isFinite(bitrateKbps) || bitrateKbps <= 0) {
+            this.log.warn(`Invalid options.videoBitrate "${configured}"; falling back to ${WeriftWebRtcSession.DEFAULT_BITRATE_KBPS}kbps`);
+            return WeriftWebRtcSession.DEFAULT_BITRATE_KBPS;
+        }
+        return bitrateKbps;
+    }
+    getConfiguredVideoResolution() {
+        const [defaultResolution] = WeriftWebRtcSession.SUPPORTED_VIDEO_RESOLUTIONS;
+        const configured = this.options.videoResolution;
+        if (configured && configured !== 'auto') {
+            if (WeriftWebRtcSession.SUPPORTED_VIDEO_RESOLUTIONS.includes(configured)) {
+                this.log.debug(`Using configured options.videoResolution ${configured}`);
+                return configured;
+            }
+            this.log.warn(`Unsupported options.videoResolution "${configured}" (supported: ${WeriftWebRtcSession.SUPPORTED_VIDEO_RESOLUTIONS.join(', ')}, auto); falling back to ${defaultResolution}`);
+            return defaultResolution;
+        }
+        return defaultResolution;
+    }
+    getConfiguredVideoSource() {
+        const source = this.options.videoSource?.trim().toLowerCase() ?? 'none';
+        switch (source) {
+            case 'none':
+            case 'test':
+            case 'webcam':
+            case 'rtsp':
+                return source;
+            default:
+                this.log.warn(`Unsupported options.videoSource "${source}" (supported: test, webcam, rtsp, none); falling back to none`);
+                return 'none';
+        }
+    }
+    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') {
+            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;
+        }
+        const resolution = this.getConfiguredVideoResolution();
+        const bitrateKbps = this.getConfiguredVideoBitrate();
+        if (videoSource === 'rtsp') {
+            const description = `RTSP camera (${device}, ${resolution})`;
+            this.log.debug(`RTSP capture params: url=${device}, resolution=${resolution}, description="${description}", bitrateKbps=${bitrateKbps}`);
+            return { args: ['-rtsp_transport', 'tcp', '-i', device, '-vf', `scale=${resolution.replace('x', ':')}`], description, bitrateKbps };
+        }
+        const description = `local webcam (${device}, ${resolution})`;
+        this.log.debug(`Webcam capture params: device=${device}, resolution=${resolution}, description="${description}", bitrateKbps=${bitrateKbps}`);
+        switch (process.platform) {
+            case 'linux':
+                return { args: ['-f', 'v4l2', '-video_size', resolution, '-framerate', '30', '-i', device], description, bitrateKbps };
+            case 'darwin':
+                return { args: ['-f', 'avfoundation', '-video_size', resolution, '-framerate', '30', '-i', device], description, bitrateKbps };
+            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;
+        }
+    }
+    async generateVideoTrack(codec) {
+        if (this.testVideoAttached)
+            return;
+        const videoSource = this.getConfiguredVideoSource();
+        if (videoSource === 'none') {
+            this.log.debug('Video injection disabled by options.videoSource=none');
+            return;
+        }
+        const videoInput = this.buildFfmpegVideoInputArgs(videoSource);
+        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');
+            return;
+        }
+        const selectedMimeType = (codec?.mimeType ?? 'video/vp8').toLowerCase();
+        const selectedPayloadType = codec?.payloadType ?? 120;
+        try {
+            const udpPort = await this.getFreeUdpPort();
+            const { track, disposer } = navigator.mediaDevices.getUdpMedia({
+                port: udpPort,
+                codec: new RTCRtpCodecParameters({ mimeType: selectedMimeType, clockRate: 90000, payloadType: selectedPayloadType }),
+            });
+            this.peerConnection.addTrack(track);
+            const bitrate = `${videoInput.bitrateKbps}k`;
+            const encoderArgs = selectedMimeType === 'video/h264'
+                ? ['-c:v', 'libx264', '-preset', 'ultrafast', '-tune', 'zerolatency', '-pix_fmt', 'yuv420p', '-g', '20', '-b:v', bitrate, '-maxrate', bitrate, '-bufsize', bitrate]
+                : ['-c:v', 'libvpx', '-deadline', 'realtime', '-cpu-used', '4', '-pix_fmt', 'yuv420p', '-g', '20', '-b:v', bitrate, '-maxrate', bitrate, '-bufsize', bitrate];
+            const ffmpegArgs = [
+                '-hide_banner',
+                '-loglevel',
+                'error',
+                ...videoInput.args,
+                '-an',
+                ...encoderArgs,
+                '-f',
+                'rtp',
+                '-payload_type',
+                String(selectedPayloadType),
+                `rtp://127.0.0.1:${udpPort}`,
+            ];
+            const generator = runFfmpeg(ffmpegArgs);
+            generator.once('error', (error) => {
+                this.log.warn(`Video generator failed: ${getErrorMessage(error)}`);
+            });
+            this.testVideoUdpDisposer = disposer;
+            this.testVideoGenerator = generator;
+            this.testVideoAttached = true;
+            this.log.info(`Attached ${videoInput.description} video track (codec=${selectedMimeType}, payloadType=${selectedPayloadType}, sourcePort=${udpPort})`);
+        }
+        catch (error) {
+            this.log.warn(`Failed to attach ${videoInput.description} video track: ${getErrorMessage(error)}`);
+        }
+    }
+    preferVideoCodecOnTransceivers(mimeType) {
+        let adjustedTransceivers = 0;
+        for (const transceiver of this.peerConnection.getTransceivers()) {
+            if (transceiver.kind !== 'video')
+                continue;
+            const preferredCodecs = transceiver.codecs.filter((codec) => codec.mimeType.toLowerCase() === mimeType);
+            if (!preferredCodecs.length)
+                continue;
+            transceiver.codecs = preferredCodecs;
+            adjustedTransceivers += 1;
+        }
+        if (adjustedTransceivers > 0) {
+            this.log.debug(`Preferred ${mimeType.toUpperCase()} codecs on ${adjustedTransceivers} video transceiver(s)`);
+        }
+    }
+    preferAudioCodecOnTransceivers(mimeType) {
+        let adjustedTransceivers = 0;
+        for (const transceiver of this.peerConnection.getTransceivers()) {
+            if (transceiver.kind !== 'audio')
+                continue;
+            const preferredCodecs = transceiver.codecs.filter((codec) => codec.mimeType.toLowerCase() === mimeType);
+            if (!preferredCodecs.length)
+                continue;
+            transceiver.codecs = preferredCodecs;
+            adjustedTransceivers += 1;
+        }
+        if (adjustedTransceivers > 0) {
+            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));
+    getConfiguredAudioSource() {
+        const source = this.options.audioSource?.trim().toLowerCase() ?? 'none';
+        switch (source) {
+            case 'none':
+            case 'test':
+            case 'microphone':
+            case 'rtsp':
+                return source;
+            default:
+                this.log.warn(`Unsupported options.audioSource "${source}" (supported: test, microphone, rtsp, none); falling back to none`);
+                return 'none';
+        }
+    }
+    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;
+        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;
+        }
+        if (audioSource === 'rtsp') {
+            const description = `RTSP camera audio (${device})`;
+            this.log.debug(`RTSP audio capture params: url=${device}, description="${description}"`);
+            return { args: ['-rtsp_transport', 'tcp', '-i', device], description };
+        }
+        const description = `local microphone (${device})`;
+        this.log.debug(`Microphone capture params: device=${device}, description="${description}"`);
+        switch (process.platform) {
+            case 'linux':
+                return { args: ['-f', 'alsa', '-i', device], description };
+            case 'darwin':
+                return { args: ['-f', 'avfoundation', '-i', `:${device}`], description };
+            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;
+        }
+    }
+    async generateAudioTrack(codec) {
+        if (this.testAudioAttached)
+            return;
+        const audioSource = this.getConfiguredAudioSource();
+        if (audioSource === 'none') {
+            this.log.debug('Audio injection disabled by options.audioSource=none');
+            return;
+        }
+        const audioInput = this.buildFfmpegAudioInputArgs(audioSource);
+        this.log.debug(`Attempting to attach ${audioInput.description} audio track`);
+        if (!hasFfmpeg()) {
+            this.log.warn('Cannot inject audio stream: missing dependency ffmpeg');
+            return;
+        }
+        const selectedMimeType = codec.mimeType.toLowerCase();
+        const selectedPayloadType = codec.payloadType;
+        const clockRate = codec.clockRate;
+        const channels = codec.channels;
+        try {
+            const udpPort = await this.getFreeUdpPort();
+            const { track, disposer } = navigator.mediaDevices.getUdpMedia({
+                port: udpPort,
+                codec: new RTCRtpCodecParameters({ mimeType: selectedMimeType, clockRate, channels, payloadType: selectedPayloadType }),
+            });
+            this.peerConnection.addTrack(track);
+            const ffmpegArgs = [
+                '-hide_banner',
+                '-loglevel',
+                'error',
+                ...audioInput.args,
+                '-vn',
+                ...(audioInput.volumeFilter ? ['-af', audioInput.volumeFilter] : []),
+                '-c:a',
+                'libopus',
+                '-b:a',
+                '32k',
+                '-ac',
+                String(channels),
+                '-ar',
+                String(clockRate),
+                '-f',
+                'rtp',
+                '-payload_type',
+                String(selectedPayloadType),
+                `rtp://127.0.0.1:${udpPort}`,
+            ];
+            const generator = runFfmpeg(ffmpegArgs);
+            generator.once('error', (error) => {
+                this.log.warn(`Audio generator failed: ${getErrorMessage(error)}`);
+            });
+            this.testAudioUdpDisposer = disposer;
+            this.testAudioGenerator = generator;
+            this.testAudioAttached = true;
+            this.log.info(`Attached ${audioInput.description} audio track (codec=${selectedMimeType}, payloadType=${selectedPayloadType}, sourcePort=${udpPort})`);
+        }
+        catch (error) {
+            this.log.warn(`Failed to attach ${audioInput.description} audio track: ${getErrorMessage(error)}`);
+        }
+    }
+    cleanupTestVideoArtifacts() {
+        if (this.testVideoGenerator) {
+            this.testVideoGenerator.kill('SIGTERM');
+            this.testVideoGenerator = undefined;
+        }
+        this.testVideoUdpDisposer?.();
+        this.testVideoUdpDisposer = undefined;
+        this.testVideoAttached = false;
+    }
+    cleanupTestAudioArtifacts() {
+        if (this.testAudioGenerator) {
+            this.testAudioGenerator.kill('SIGTERM');
+            this.testAudioGenerator = undefined;
+        }
+        this.testAudioUdpDisposer?.();
+        this.testAudioUdpDisposer = undefined;
+        this.testAudioAttached = false;
+    }
+    applyOptionOverrides(overrides) {
+        if (!overrides)
+            return;
+        Object.assign(this.options, Object.fromEntries(Object.entries(overrides).filter(([, value]) => value !== undefined)));
+    }
+    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) {
+            const preferredCodec = this.getPreferredInjectableVideoCodec();
+            if (preferredCodec) {
+                this.preferVideoCodecOnTransceivers(preferredCodec.mimeType.toLowerCase());
+            }
+            else {
+                this.log.warn('No injectable video codec available on negotiated transceivers (supported: VP8, H264)');
+            }
+            await this.generateVideoTrack(preferredCodec);
+            if (!this.testVideoAttached)
+                this.peerConnection.addTransceiver('video', { direction: 'sendonly' });
+        }
+        if (options.audio)
+            this.peerConnection.addTransceiver('audio', { direction: 'sendonly' });
+        const offer = await this.peerConnection.createOffer();
+        await this.peerConnection.setLocalDescription(offer);
+        const sdp = this.peerConnection.localDescription.sdp;
+        this.log.info(`Created local SDP offer (${this.summarizeSdp(sdp)})`);
+        this.logDtlsTransportStateChanges();
+        return sdp;
+    }
+    async createAnswer(offerSdp, overrides) {
+        this.applyOptionOverrides(overrides);
+        this.log.debug(`CreateAnswer requested for remote offer (${this.summarizeSdp(offerSdp)}, videoResolution=${this.options.videoResolution ?? 'undefined'})`);
+        await this.peerConnection.setRemoteDescription({ type: 'offer', sdp: offerSdp });
+        const hasVideoTransceiver = this.peerConnection.getTransceivers().some((transceiver) => transceiver.kind === 'video');
+        this.log.debug(`Remote offer created video transceiver: ${hasVideoTransceiver}`);
+        if (hasVideoTransceiver) {
+            const preferredCodec = this.getPreferredInjectableVideoCodec();
+            if (preferredCodec) {
+                this.preferVideoCodecOnTransceivers(preferredCodec.mimeType.toLowerCase());
+            }
+            else {
+                this.log.warn('No injectable video codec available on negotiated transceivers (supported: VP8, H264)');
+            }
+            await this.generateVideoTrack(preferredCodec);
+        }
+        const hasAudioTransceiver = this.peerConnection.getTransceivers().some((transceiver) => transceiver.kind === 'audio');
+        this.log.debug(`Remote offer created audio transceiver: ${hasAudioTransceiver}`);
+        if (hasAudioTransceiver) {
+            const preferredAudioCodec = this.getPreferredInjectableAudioCodec();
+            if (preferredAudioCodec) {
+                this.preferAudioCodecOnTransceivers(preferredAudioCodec.mimeType.toLowerCase());
+                await this.generateAudioTrack(preferredAudioCodec);
+            }
+            else {
+                this.log.warn('No injectable audio codec available on negotiated transceivers (supported: Opus)');
+            }
+        }
+        for (const transceiver of this.peerConnection.getTransceivers()) {
+            transceiver.setDirection('sendonly');
+        }
+        const answer = await this.peerConnection.createAnswer();
+        await this.peerConnection.setLocalDescription(answer);
+        const sdp = this.peerConnection.localDescription.sdp;
+        this.log.info(`Created local SDP answer (${this.summarizeSdp(sdp)})`);
+        this.logDtlsTransportStateChanges();
+        return sdp;
+    }
+    async applyAnswer(answerSdp) {
+        this.log.debug(`ApplyAnswer requested (${this.summarizeSdp(answerSdp)})`);
+        await this.peerConnection.setRemoteDescription({ type: 'answer', sdp: answerSdp });
+        this.log.info(`Remote SDP answer applied (signalingState=${this.peerConnection.signalingState})`);
+        this.logDtlsTransportStateChanges();
+    }
+    async addIceCandidate(candidate, sdpMid, sdpMLineIndex) {
+        this.log.debug(`Applying ICE candidate (mid=${sdpMid ?? 'null'}, mLine=${sdpMLineIndex ?? 'null'}, endOfCandidates=${candidate.trim() === ''})`);
+        await this.peerConnection.addIceCandidate({ candidate, sdpMid: sdpMid ?? undefined, sdpMLineIndex: sdpMLineIndex ?? undefined });
+    }
+    closing = false;
+    logDtlsTransportStateChanges() {
+        for (const transport of this.peerConnection.dtlsTransports) {
+            if (this.dtlsTransportsWithStateLogging.has(transport))
+                continue;
+            this.dtlsTransportsWithStateLogging.add(transport);
+            transport.onStateChange.subscribe((state) => {
+                this.log.info(`DTLS transport state: ${state}`);
+                if ((state === 'closed' || state === 'failed') && !this.closing) {
+                    this.log.info(`Closing session ${this.webRtcSessionId}: DTLS transport reached ${state}`);
+                    fireAndForget(this.close(), this.log, `Failed to auto-close session ${this.webRtcSessionId} after DTLS transport reached ${state}`);
+                }
+            });
+        }
+    }
+    async logDiagnosticsSnapshot() {
+        const iceStates = this.peerConnection.iceTransports.map((transport) => transport.state).join(',') || 'none';
+        const dtlsStates = this.peerConnection.dtlsTransports.map((transport) => transport.state).join(',') || 'none';
+        const stats = [...(await this.peerConnection.getStats()).values()];
+        const nominatedPair = stats
+            .filter((stat) => stat.type === 'candidate-pair')
+            .map((stat) => stat)
+            .find((pair) => pair.nominated === true);
+        const outboundRtp = stats.filter((stat) => stat.type === 'outbound-rtp').map((stat) => stat);
+        const candidatePairPacketsSent = nominatedPair?.packetsSent ?? 0;
+        const candidatePairPacketsReceived = nominatedPair?.packetsReceived ?? 0;
+        const outboundRtpPacketsSent = outboundRtp.reduce((sum, stat) => sum + (stat.packetsSent ?? 0), 0);
+        const previous = this.lastDiagnosticsCounters;
+        this.lastDiagnosticsCounters = { candidatePairPacketsSent, candidatePairPacketsReceived, outboundRtpPacketsSent };
+        const delta = (current, previousValue) => previousValue === undefined ? 'n/a' : `${current - previousValue >= 0 ? '+' : ''}${current - previousValue}`;
+        const outboundRtpSummary = outboundRtp.map((stat) => `${stat.kind ?? 'unknown'}:packetsSent=${stat.packetsSent ?? 0}`).join(', ') || 'none';
+        this.log.debug([
+            'Diagnostics:',
+            `- connectionState=${this.peerConnection.connectionState}`,
+            `- iceConnectionState=${this.peerConnection.iceConnectionState}`,
+            `- iceGatheringState=${this.peerConnection.iceGatheringState}`,
+            `- signalingState=${this.peerConnection.signalingState}`,
+            `- iceTransportStates=[${iceStates}]`,
+            `- dtlsTransportStates=[${dtlsStates}]`,
+            `- nominatedPair(packetsSent=${candidatePairPacketsSent} Δ${delta(candidatePairPacketsSent, previous?.candidatePairPacketsSent)}, packetsReceived=${candidatePairPacketsReceived} Δ${delta(candidatePairPacketsReceived, previous?.candidatePairPacketsReceived)})`,
+            `- outboundRtp[${outboundRtpSummary}] (totalPacketsSent Δ${delta(outboundRtpPacketsSent, previous?.outboundRtpPacketsSent)})`,
+        ].join('\n'));
+    }
+    async close() {
+        if (this.closing)
+            return;
+        this.closing = true;
+        this.log.debug('Closing RTCPeerConnection');
+        clearInterval(this.diagnosticsInterval);
+        this.diagnosticsInterval = undefined;
+        await this.peerConnection.close();
+        this.cleanupTestVideoArtifacts();
+        this.cleanupTestAudioArtifacts();
+        WeriftWebRtcSession.activeSessions.delete(this);
+        this.log.info(`RTCPeerConnection closed (connectionState=${this.peerConnection.connectionState})`);
+    }
+    static async closeAll() {
+        for (const session of WeriftWebRtcSession.activeSessions) {
+            session.log.info(`Closing session ${session.webRtcSessionId} as part of closeAll()`);
+            await session.close();
+        }
+    }
+}

package/dist/devices/audioDoorbell.d.ts

@@ -0,0 +1,20 @@
+import { StreamUsage } from '@matter/types';
+import { CameraAvStreamManagement } from '@matter/types/clusters/camera-av-stream-management';
+import { Identify } from '@matter/types/clusters/identify';
+import type { WeriftOfferOptions } from '../behaviors/weriftSession.js';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+import type { MatterbridgeEndpointOptions } from '../matterbridgeEndpointTypes.js';
+export interface AudioDoorbellOptions extends MatterbridgeEndpointOptions {
+    identifyTime?: number;
+    identifyType?: Identify.IdentifyType;
+    powerSourceType?: 'Rechargeable' | 'Replaceable' | 'Battery' | 'Wired' | 'None';
+    maxContentBufferSize?: number;
+    maxNetworkBandwidth?: number;
+    supportedStreamUsages?: StreamUsage[];
+    streamUsagePriorities?: StreamUsage[];
+    microphoneCapabilities?: CameraAvStreamManagement.AudioCapabilities;
+    weriftOfferOptions?: WeriftOfferOptions;
+}
+export declare class AudioDoorbell extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, options?: AudioDoorbellOptions);
+}

package/dist/devices/audioDoorbell.js

@@ -0,0 +1,49 @@
+import { StreamUsage } from '@matter/types';
+import { CameraAvStreamManagement } from '@matter/types/clusters/camera-av-stream-management';
+import { Identify } from '@matter/types/clusters/identify';
+import { createDefaultAudioCameraAvStreamManagementClusterServer } from '../behaviors/cameraAvStreamManagementServer.js';
+import { addChimeClient, addWebRtcTransportRequestorClient } from '../behaviors/clients.js';
+import { createDefaultWebRtcTransportProviderClusterServer } from '../behaviors/webRtcTransportProviderServer.js';
+import { audioDoorbell, powerSource } from '../matterbridgeDeviceTypes.js';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+export class AudioDoorbell extends MatterbridgeEndpoint {
+    constructor(name, serial, options = {}) {
+        const { identifyTime = 0, identifyType = Identify.IdentifyType.None, powerSourceType = 'Wired', maxContentBufferSize = 65_536, maxNetworkBandwidth = 128_000, supportedStreamUsages = [StreamUsage.LiveView], streamUsagePriorities = supportedStreamUsages, microphoneCapabilities = { maxNumberOfChannels: 1, supportedCodecs: [CameraAvStreamManagement.AudioCodec.Opus], supportedSampleRates: [48000], supportedBitDepths: [16] }, weriftOfferOptions, id, number, tagList, mode, } = options;
+        super(powerSourceType === 'None' ? [audioDoorbell] : [audioDoorbell, powerSource], {
+            id: id ?? `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}`,
+            number,
+            tagList,
+            mode,
+        });
+        this.createDefaultIdentifyClusterServer(identifyTime, identifyType);
+        this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Audio Doorbell');
+        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;
+        }
+        this.createDefaultMomentarySwitchClusterServer();
+        createDefaultAudioCameraAvStreamManagementClusterServer(this, {
+            maxContentBufferSize,
+            maxNetworkBandwidth,
+            supportedStreamUsages,
+            streamUsagePriorities,
+            microphoneCapabilities,
+        });
+        createDefaultWebRtcTransportProviderClusterServer(this, weriftOfferOptions);
+        addChimeClient(this);
+        addWebRtcTransportRequestorClient(this);
+        this.addRequiredClusters();
+    }
+}

package/dist/devices/camera.d.ts

@@ -0,0 +1,37 @@
+import { StreamUsage } from '@matter/types';
+import type { Viewport } from '@matter/types';
+import type { CameraAvSettingsUserLevelManagement } from '@matter/types/clusters/camera-av-settings-user-level-management';
+import { CameraAvStreamManagement } from '@matter/types/clusters/camera-av-stream-management';
+import { Identify } from '@matter/types/clusters/identify';
+import type { WeriftOfferOptions } from '../behaviors/weriftSession.js';
+import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+import type { MatterbridgeEndpointOptions } from '../matterbridgeEndpointTypes.js';
+export interface CameraOptions extends MatterbridgeEndpointOptions {
+    identifyTime?: number;
+    identifyType?: Identify.IdentifyType;
+    powerSourceType?: 'Rechargeable' | 'Replaceable' | 'Battery' | 'Wired' | 'None';
+    ptz?: boolean;
+    maxContentBufferSize?: number;
+    maxNetworkBandwidth?: number;
+    supportedStreamUsages?: StreamUsage[];
+    streamUsagePriorities?: StreamUsage[];
+    maxConcurrentEncoders?: number;
+    maxEncodedPixelRate?: number;
+    videoSensorParams?: CameraAvStreamManagement.VideoSensorParams;
+    minViewportResolution?: CameraAvStreamManagement.VideoResolution;
+    rateDistortionTradeOffPoints?: CameraAvStreamManagement.RateDistortionTradeOffPoints[];
+    currentFrameRate?: number;
+    viewport?: Viewport;
+    microphoneCapabilities?: CameraAvStreamManagement.AudioCapabilities;
+    snapshotCapabilities?: CameraAvStreamManagement.SnapshotCapabilities[];
+    panMin?: number;
+    panMax?: number;
+    tiltMin?: number;
+    tiltMax?: number;
+    zoomMax?: number;
+    mptzPosition?: CameraAvSettingsUserLevelManagement.Mptz;
+    weriftOfferOptions?: WeriftOfferOptions;
+}
+export declare class Camera extends MatterbridgeEndpoint {
+    constructor(name: string, serial: string, options?: CameraOptions);
+}