scrypted-kasa 1.3.1 → 1.3.2

package/src/camera/rtsp.ts

@@ -1,270 +0,0 @@
-import { randomBytes } from 'crypto';
-import net from 'net';
-
-const RTSP_INTERLEAVED_MAGIC = 0x24; // '$'
-
-export interface RtspChannelPair {
-    rtp: number;
-    rtcp: number;
-}
-
-export interface RtspChannels {
-    video: RtspChannelPair;
-    audio: RtspChannelPair;
-}
-
-export interface RtspSendInterleaved {
-    (channel: number, packet: Buffer): boolean;
-}
-
-export interface RtspHandlerOptions {
-    sdp: string;
-    onPlay: (send: RtspSendInterleaved, channels: RtspChannels) => void;
-    onTeardown: () => void;
-    console: Console;
-}
-
-interface RtspRequest {
-    method: string;
-    uri: string;
-    headers: Map<string, string>;
-}
-
-// Minimal RTSP server-side handler for ONE TCP client. Supports the methods Scrypted (and
-// any standard RTSP client) actually uses: OPTIONS, DESCRIBE, SETUP, PLAY, PAUSE, TEARDOWN.
-// TCP-interleaved transport only — that's what Scrypted's pipeline asks for by default and
-// it sidesteps every NAT/UDP-loss complication. We build the SDP upstream and just serve it
-// on DESCRIBE; we never parse one.
-// Hard cap on Node's userland write queue (`socket.bufferSize`). If the consumer falls
-// behind by more than this, we give up rather than letting RAM grow unbounded. 2 MB at
-// 4 Mbps video is ~4 s of data — past that, the stream is unrecoverable for live
-// consumption anyway, and most receivers would resync faster from a fresh PLAY than
-// from catching up to a stale backlog. Note: this is Node's queue, not the kernel TCP
-// send buffer (SO_SNDBUF) — the kernel buffer is bounded by net.ipv4.tcp_wmem and
-// applies backpressure via TCP window before this cap would ever be hit.
-const RTSP_WRITE_BUFFER_HARD_CAP = 2 * 1024 * 1024;
-
-export function handleRtspClient(client: net.Socket, opts: RtspHandlerOptions): void {
-    const sessionId = randomBytes(8).toString('hex');
-    let videoChannels: RtspChannelPair | undefined;
-    let audioChannels: RtspChannelPair | undefined;
-    let buffered: Buffer = Buffer.alloc(0);
-    let isPlaying = false;
-    let teardownNotified = false;
-    // Drop sends while Node's userland write queue is back-pressured (client.write()
-    // returned false). Cleared on 'drain'. Without this, a slow consumer makes the queue
-    // grow unbounded — the live-video equivalent of bufferbloat.
-    let backpressured = false;
-    client.on('drain', () => {
-        backpressured = false;
-    });
-
-    const notifyTeardown = () => {
-        if (teardownNotified) return;
-        teardownNotified = true;
-        opts.onTeardown();
-    };
-
-    const send: RtspSendInterleaved = (channel, packet) => {
-        if (client.destroyed) return false;
-        // Cap check runs BEFORE the backpressured early-return: a single write that
-        // pushes bufferSize over the cap will set backpressured=true on the way out, and
-        // without the cap check up here the next send would short-circuit on the
-        // backpressure flag and never observe the oversize backlog. With the cap check
-        // first, a permanently stuck consumer (paused but not closed) gets torn down on
-        // the next send instead of holding bytes resident forever.
-        if (client.bufferSize > RTSP_WRITE_BUFFER_HARD_CAP) {
-            opts.console.warn(
-                'rtsp: client write buffer exceeded',
-                RTSP_WRITE_BUFFER_HARD_CAP,
-                'bytes — destroying client',
-            );
-            client.destroy();
-            return false;
-        }
-        if (backpressured) return false;
-        // Interleaved frame: '$' + 1-byte channel + 2-byte BE length + RTP packet bytes.
-        // Header + body in one Buffer to avoid splitting writes (a small write between the
-        // two would let an out-of-order chunk arrive in the middle of an interleaved frame).
-        const out = Buffer.allocUnsafe(4 + packet.length);
-        out[0] = RTSP_INTERLEAVED_MAGIC;
-        out[1] = channel;
-        out.writeUInt16BE(packet.length, 2);
-        packet.copy(out, 4);
-        // The destroyed check above is racy — the socket can be torn down between the
-        // check and write (different microtask), in which case write throws
-        // ERR_STREAM_DESTROYED. Catch it; the next packet's destroyed check will gate
-        // further sends.
-        try {
-            const ok = client.write(out);
-            if (!ok) backpressured = true;
-            return ok;
-        } catch {
-            return false;
-        }
-    };
-
-    const respond = (
-        cseq: string,
-        status: number,
-        statusText: string,
-        headers: Record<string, string | number> = {},
-        body?: string,
-    ) => {
-        const lines = [`RTSP/1.0 ${status} ${statusText}`, `CSeq: ${cseq}`];
-        if (body !== undefined) headers['Content-Length'] = Buffer.byteLength(body);
-        for (const [k, v] of Object.entries(headers)) lines.push(`${k}: ${v}`);
-        const message = lines.join('\r\n') + '\r\n\r\n' + (body || '');
-        client.write(message);
-    };
-
-    const handleRequest = (req: RtspRequest) => {
-        const cseq = req.headers.get('cseq') || '0';
-        switch (req.method) {
-            case 'OPTIONS':
-                respond(cseq, 200, 'OK', {
-                    Public: 'OPTIONS, DESCRIBE, SETUP, PLAY, PAUSE, TEARDOWN',
-                });
-                return;
-
-            case 'DESCRIBE':
-                respond(cseq, 200, 'OK', { 'Content-Type': 'application/sdp' }, opts.sdp);
-                return;
-
-            case 'SETUP': {
-                const transport = req.headers.get('transport') || '';
-                const m = /interleaved=(\d+)-(\d+)/i.exec(transport);
-                if (!m) {
-                    // We only support TCP-interleaved transport. UDP would require allocating
-                    // server-side ports, parsing client_port, and sending RTP via dgram —
-                    // pointless for a localhost-only stream.
-                    respond(cseq, 461, 'Unsupported Transport');
-                    return;
-                }
-                const rtp = parseInt(m[1], 10);
-                const rtcp = parseInt(m[2], 10);
-                const trackMatch = req.uri.match(/trackID=(\d+)/i);
-                const trackId = trackMatch ? parseInt(trackMatch[1], 10) : -1;
-                if (trackId === 0) videoChannels = { rtp, rtcp };
-                else if (trackId === 1) audioChannels = { rtp, rtcp };
-                else {
-                    respond(cseq, 404, 'Not Found');
-                    return;
-                }
-                respond(cseq, 200, 'OK', { Transport: transport, Session: sessionId });
-                return;
-            }
-
-            case 'PLAY':
-                if (!videoChannels || !audioChannels) {
-                    respond(cseq, 412, 'Precondition Failed');
-                    return;
-                }
-                respond(cseq, 200, 'OK', { Session: sessionId, Range: 'npt=0.000-' });
-                if (!isPlaying) {
-                    isPlaying = true;
-                    try {
-                        opts.onPlay(send, { video: videoChannels, audio: audioChannels });
-                    } catch (e) {
-                        opts.console.warn('rtsp onPlay handler error', e);
-                        client.destroy();
-                    }
-                }
-                return;
-
-            case 'PAUSE':
-                respond(cseq, 200, 'OK', { Session: sessionId });
-                return;
-
-            case 'TEARDOWN':
-                respond(cseq, 200, 'OK', { Session: sessionId });
-                client.end();
-                return;
-
-            default:
-                respond(cseq, 405, 'Method Not Allowed');
-        }
-    };
-
-    const HEADER_TERMINATOR = Buffer.from('\r\n\r\n');
-    // Caps on accumulated buffer size. Server is localhost-only, but a misbehaving or
-    // malicious client could trickle bytes without ever sending the header terminator,
-    // or advertise a giant Content-Length, forcing `buffered` to grow unbounded via
-    // Buffer.concat. Real RTSP requests for the methods we accept are well under 1 KB.
-    const RTSP_MAX_HEADER_BYTES = 8 * 1024;
-    const RTSP_MAX_BODY_BYTES = 4 * 1024;
-    client.on('data', (chunk: Buffer) => {
-        buffered = buffered.length === 0 ? chunk : Buffer.concat([buffered, chunk]);
-        // Parse messages until we run out of complete ones in the buffer.
-        while (buffered.length > 0) {
-            // Skip any interleaved frames the client might send back at us. (Standard
-            // clients don't, but defending against the bidirectional channel costs nothing
-            // and is robust against odd consumers that probe.)
-            if (buffered[0] === RTSP_INTERLEAVED_MAGIC) {
-                if (buffered.length < 4) return;
-                const len = buffered.readUInt16BE(2);
-                if (buffered.length < 4 + len) return;
-                buffered = buffered.subarray(4 + len);
-                continue;
-            }
-            const headerEndIdx = buffered.indexOf(HEADER_TERMINATOR);
-            // Apply the cap whether or not the terminator has arrived: a single oversized
-            // chunk that contains the terminator would otherwise slip past a check that
-            // only fires while we're still waiting for it.
-            const headerLen = headerEndIdx < 0 ? buffered.length : headerEndIdx;
-            if (headerLen > RTSP_MAX_HEADER_BYTES) {
-                opts.console.warn('rtsp: header section exceeded cap, dropping client');
-                client.destroy();
-                return;
-            }
-            if (headerEndIdx < 0) return;
-            const headerStr = buffered.subarray(0, headerEndIdx).toString('utf8');
-            const headerLines = headerStr.split('\r\n');
-            const requestLine = headerLines.shift() || '';
-            const [method, uri] = requestLine.split(' ');
-            // Map (not a plain object) so a malicious peer can't reach Object.prototype via
-            // a crafted header name like `__proto__`. Practical risk is tiny — the server
-            // only listens on localhost — but Map is the pattern CodeQL accepts.
-            const headers = new Map<string, string>();
-            for (const line of headerLines) {
-                const colon = line.indexOf(':');
-                if (colon < 0) continue;
-                headers.set(line.slice(0, colon).trim().toLowerCase(), line.slice(colon + 1).trim());
-            }
-            // Strict validation: parseInt('1abc', 10) === 1, which would let us buffer
-            // 1 body byte and then desync the parser on the rest. Require a pure decimal
-            // string before trusting the length.
-            const rawContentLength = headers.get('content-length');
-            if (rawContentLength !== undefined && !/^\d+$/.test(rawContentLength)) {
-                opts.console.warn('rtsp: invalid content-length', rawContentLength);
-                client.destroy();
-                return;
-            }
-            const contentLength = rawContentLength ? parseInt(rawContentLength, 10) : 0;
-            if (contentLength > RTSP_MAX_BODY_BYTES) {
-                opts.console.warn('rtsp: oversized content-length', rawContentLength);
-                client.destroy();
-                return;
-            }
-            const totalLen = headerEndIdx + HEADER_TERMINATOR.length + contentLength;
-            if (buffered.length < totalLen) return;
-            // We currently ignore request bodies — none of the methods we handle need one.
-            buffered = buffered.subarray(totalLen);
-            if (!method || !uri) {
-                opts.console.warn('rtsp: malformed request line', JSON.stringify(requestLine));
-                client.destroy();
-                return;
-            }
-            try {
-                handleRequest({ method: method.toUpperCase(), uri, headers });
-            } catch (e) {
-                opts.console.warn('rtsp handleRequest threw', e);
-                client.destroy();
-                return;
-            }
-        }
-    });
-
-    client.on('close', notifyTeardown);
-    client.on('error', notifyTeardown);
-}

package/src/camera/stream.ts

@@ -1,346 +0,0 @@
-import net from 'net';
-import { findSpsPps, KasaClient, KasaMimeG711U, KasaMimeVideo, KasaPart } from './api';
-import { G711_CLOCK_HZ, G711RtpPacketizer, H264_CLOCK_HZ, H264RtpPacketizer, nowNtp } from './rtp';
-import { handleRtspClient } from './rtsp';
-
-// Process-level cleanup registry. Scrypted runs plugins as worker threads; resources
-// owned by the host Node process (TCP servers, kasa HTTPS connections) survive worker
-// termination otherwise. Every spawnKasaStream registers its kill function and removes
-// itself on normal teardown. On worker exit, the hook nukes anything still live.
-const liveCleanups = new Set<() => void>();
-let exitHookInstalled = false;
-function installExitHook() {
-    if (exitHookInstalled) return;
-    exitHookInstalled = true;
-    process.once('exit', () => {
-        for (const cleanup of liveCleanups) {
-            try {
-                cleanup();
-            } catch {
-                /* best-effort, can't do anything from inside 'exit' */
-            }
-        }
-        liveCleanups.clear();
-    });
-}
-
-export function registerLiveCleanup(cleanup: () => void): () => void {
-    installExitHook();
-    liveCleanups.add(cleanup);
-    return () => liveCleanups.delete(cleanup);
-}
-
-// Hard ceiling on the upfront SPS/PPS scan. Real cameras emit them well under a second; if
-// we don't see them in this window the camera is misbehaving and there's no point holding
-// the call.
-const SPS_PPS_TIMEOUT_MS = 10000;
-// Belt-and-suspenders caps on the prebuffer. The timeout already bounds the wait, but a
-// camera that streams at high bitrate and never emits SPS/PPS could fill memory before the
-// timer fires. Either trip throws.
-const SPS_PPS_MAX_BUFFERED_PARTS = 1024;
-const SPS_PPS_MAX_BUFFERED_BYTES = 32 * 1024 * 1024;
-
-export interface KasaStreamOptions {
-    kasa: KasaClient;
-    console: Console;
-    // Optional cached SPS/PPS from a previous session. When present we skip the
-    // preScanSpsPps wait (which holds getVideoStream up to ~2s on KC420WS waiting for the
-    // next IDR) and start streaming live parts immediately. Cached values come from this
-    // camera's own previous bitstream so they're correct unless the encoder profile
-    // changed (resolution / bitrate setting); even when stale, the in-band SPS/PPS that
-    // arrive with the next IDR will replace them at the consumer's decoder.
-    cachedSps?: Buffer;
-    cachedPps?: Buffer;
-    // Called when we successfully scanned fresh SPS/PPS from the live bitstream. The
-    // caller persists these so subsequent sessions can use the cached path.
-    onFreshSpsPps?: (sps: Buffer, pps: Buffer) => void;
-}
-
-export interface KasaStreamHandle {
-    url: string;
-    kill(): void;
-    exited: Promise<void>;
-}
-
-// Build the SDP we serve on DESCRIBE. We embed sprop-parameter-sets so consumers can decode
-// without waiting for the next IDR — important for HomeKit's strict first-frame timeouts.
-function buildSdp(sps: Buffer, pps: Buffer): string {
-    // RFC 6184: profile-level-id is the 3 SPS bytes (profile_idc, profile-iop, level_idc)
-    // immediately following the NAL header byte, encoded as 6 hex chars.
-    const profileLevelId = sps.subarray(1, 4).toString('hex').toUpperCase();
-    const spropParameterSets = sps.toString('base64') + ',' + pps.toString('base64');
-    return (
-        [
-            'v=0',
-            'o=- 0 0 IN IP4 127.0.0.1',
-            's=Kasa',
-            'c=IN IP4 127.0.0.1',
-            't=0 0',
-            'm=video 0 RTP/AVP 96',
-            'a=rtpmap:96 H264/90000',
-            `a=fmtp:96 packetization-mode=1; profile-level-id=${profileLevelId}; sprop-parameter-sets=${spropParameterSets}`,
-            'a=control:trackID=0',
-            'm=audio 0 RTP/AVP 0',
-            'a=rtpmap:0 PCMU/8000',
-            'a=control:trackID=1',
-        ].join('\r\n') + '\r\n'
-    );
-}
-
-async function preScanSpsPps(kasa: KasaClient): Promise<{ sps: Buffer; pps: Buffer; buffered: KasaPart[] }> {
-    const buffered: KasaPart[] = [];
-    let bufferedBytes = 0;
-    const found: { sps?: Buffer; pps?: Buffer } = {};
-    const deadline = Date.now() + SPS_PPS_TIMEOUT_MS;
-    while (!found.sps || !found.pps) {
-        if (Date.now() > deadline) throw new Error('timed out waiting for H.264 SPS/PPS');
-        if (buffered.length >= SPS_PPS_MAX_BUFFERED_PARTS)
-            throw new Error(`H.264 SPS/PPS not found within ${SPS_PPS_MAX_BUFFERED_PARTS} parts`);
-        if (bufferedBytes >= SPS_PPS_MAX_BUFFERED_BYTES)
-            throw new Error(`H.264 SPS/PPS not found within ${SPS_PPS_MAX_BUFFERED_BYTES} prebuffered bytes`);
-        const part = await kasa.readPart();
-        buffered.push(part);
-        bufferedBytes += part.body.length;
-        if (part.contentType === KasaMimeVideo) findSpsPps(part.body, found);
-    }
-    return { sps: found.sps!, pps: found.pps!, buffered };
-}
-
-// Reserve a TCP port on localhost for the RTSP server. Brief TOCTOU window between close
-// and re-bind is accepted — nothing else snatches loopback ports in those few ms.
-async function reserveTcpPort(): Promise<number> {
-    return new Promise<number>((resolve, reject) => {
-        const probe = net.createServer();
-        probe.once('error', reject);
-        probe.listen(0, '127.0.0.1', () => {
-            const port = (probe.address() as net.AddressInfo).port;
-            probe.close(() => resolve(port));
-        });
-    });
-}
-
-// Compute an RTP timestamp at `clockHz` from a process.hrtime delta in nanoseconds.
-// 32-bit unsigned wrap is the RTP norm — receivers handle wrap.
-function nanosToRtp(deltaNs: bigint, clockHz: number): number {
-    // BigInt multiply keeps precision for clockHz=90000 over hours of streaming.
-    const ticks = (deltaNs * BigInt(clockHz)) / 1_000_000_000n;
-    return Number(ticks & 0xffffffffn) >>> 0;
-}
-
-// Orchestrates the kasa→consumer streaming pipeline:
-//   kasa multipart → native RTP packetizer → RTSP TCP-interleaved frames → consumer
-//
-// No ffmpeg subprocess, no UDP loopback hop, no extra forwarder layer. The kasa parts
-// already carry the codecs we serve (annex-b H.264, G.711 µ-law); ffmpeg's only job in
-// the previous design was RTP packetization, which is well-defined enough to do directly.
-//
-// Returns a handle whose `kill()` tears down everything (kasa, TCP server, active
-// client) and whose `exited` promise resolves once that teardown is done.
-export async function spawnKasaStream(opts: KasaStreamOptions): Promise<KasaStreamHandle> {
-    const { kasa, console, cachedSps, cachedPps, onFreshSpsPps } = opts;
-
-    // Fast path: caller supplied cached SPS/PPS from a previous session. Skip the scan and
-    // start streaming live parts immediately — saves the ~1-2s preScanSpsPps wait on cold
-    // starts, which dominates HomeKit's perceived stream-open latency.
-    // Validate cached buffers before trusting them. Storage corruption / schema drift /
-    // mistakenly-stored garbage would otherwise produce an SDP with an invalid
-    // profile-level-id (derived from sps[1..4]) or sprop-parameter-sets, and consumers
-    // would fail SETUP rather than recovering from in-band SPS/PPS.
-    // H.264 NAL header byte: low 5 bits = nal_unit_type. SPS = 7, PPS = 8.
-    // SPS minimum length = 4 (NAL header byte + 3 profile bytes used in the SDP).
-    const cacheValid =
-        !!cachedSps &&
-        !!cachedPps &&
-        cachedSps.length >= 4 &&
-        cachedPps.length >= 1 &&
-        (cachedSps[0] & 0x1f) === 7 &&
-        (cachedPps[0] & 0x1f) === 8;
-    if ((cachedSps || cachedPps) && !cacheValid) {
-        console.warn('[kasa-stream] cached SPS/PPS failed validation; falling back to in-band scan');
-    }
-
-    let sps: Buffer;
-    let pps: Buffer;
-    let buffered: KasaPart[];
-    if (cacheValid) {
-        sps = cachedSps!;
-        pps = cachedPps!;
-        buffered = [];
-    } else {
-        const scanned = await preScanSpsPps(kasa);
-        sps = scanned.sps;
-        pps = scanned.pps;
-        buffered = scanned.buffered;
-        try {
-            onFreshSpsPps?.(sps, pps);
-        } catch (e) {
-            console.warn('[kasa-stream] onFreshSpsPps callback threw', e);
-        }
-    }
-    const sdp = buildSdp(sps, pps);
-
-    // Packetizers carry seq + SSRC across the whole session.
-    const h264 = new H264RtpPacketizer();
-    const g711 = new G711RtpPacketizer();
-
-    // Active forwarder — populated when the RTSP client PLAYs, cleared on teardown.
-    interface ActiveForwarder {
-        send: (channel: number, packet: Buffer) => boolean;
-        videoRtp: number;
-        videoRtcp: number;
-        audioRtp: number;
-        audioRtcp: number;
-    }
-    let active: ActiveForwarder | null = null;
-
-    let tcpServer: net.Server | undefined = undefined;
-    let activeClient: net.Socket | undefined = undefined;
-    let unregisterCleanup: (() => void) | undefined = undefined;
-    let rtcpInterval: NodeJS.Timeout | undefined = undefined;
-
-    let resolveExited!: () => void;
-    const exited = new Promise<void>(r => {
-        resolveExited = r;
-    });
-
-    let killed = false;
-    const cleanupAll = () => {
-        if (killed) return;
-        killed = true;
-        try {
-            unregisterCleanup?.();
-        } catch {}
-        if (rtcpInterval) {
-            clearInterval(rtcpInterval);
-            rtcpInterval = undefined;
-        }
-        try {
-            tcpServer?.close();
-        } catch {}
-        try {
-            activeClient?.destroy();
-        } catch {}
-        try {
-            kasa.destroy();
-        } catch {}
-        active = null;
-        resolveExited();
-    };
-    unregisterCleanup = registerLiveCleanup(cleanupAll);
-
-    // Pump kasa parts directly into the active forwarder. No intermediate process, pipe,
-    // or UDP hop. Drops parts until the RTSP client PLAYs (i.e. while `active` is null —
-    // start-up race only; we don't implement PAUSE semantics, since live consumers
-    // either keep playing or TEARDOWN). Backpressure: handled inside rtsp.ts `send` —
-    // drops while Node's userland write queue is full and tears down the client if the
-    // queued bytes cross a hard cap. From here we just call send and let it decide.
-    const pump = async () => {
-        const t0 = process.hrtime.bigint();
-        const replay = buffered;
-        buffered = [];
-        // Audio RTP timestamps must advance by sample count, not wall-clock — RTP
-        // receivers use the timestamp to drive playout, and any wall-clock-derived jitter
-        // would surface as audible discontinuities. Initialize once on first audio part
-        // (using elapsed time so audio and video share a roughly aligned origin), then
-        // chain via the packetizer's return value across every subsequent part.
-        let audioTs: number | undefined;
-        const handlePart = (part: KasaPart) => {
-            if (killed) return;
-            if (!active) return;
-            const fwd = active;
-            const elapsed = process.hrtime.bigint() - t0;
-            if (part.contentType === KasaMimeVideo) {
-                const ts = nanosToRtp(elapsed, H264_CLOCK_HZ);
-                h264.packetize(part.body, ts, pkt => {
-                    if (active === fwd) fwd.send(fwd.videoRtp, pkt);
-                });
-            } else if (part.contentType === KasaMimeG711U) {
-                if (audioTs === undefined) audioTs = nanosToRtp(elapsed, G711_CLOCK_HZ);
-                audioTs = g711.packetize(part.body, audioTs, pkt => {
-                    if (active === fwd) fwd.send(fwd.audioRtp, pkt);
-                });
-            }
-        };
-
-        try {
-            for (const part of replay) handlePart(part);
-            // Release prebuffered parts (up to a few hundred KB each) — they were captured
-            // during the SPS/PPS scan and are only needed for this single replay.
-            replay.length = 0;
-            while (!killed) {
-                const part = await kasa.readPart();
-                handlePart(part);
-            }
-        } catch (e) {
-            if (!killed) console.warn('[kasa-stream] pump error', (e as Error).message);
-        } finally {
-            cleanupAll();
-        }
-    };
-    void pump();
-
-    // Bind the RTSP listener last, after all the supporting pieces are in place.
-    const rtspPort = await reserveTcpPort();
-    const url = `rtsp://127.0.0.1:${rtspPort}/kasa`;
-
-    tcpServer = net.createServer();
-
-    tcpServer.on('connection', client => {
-        // tcpServer.close() in cleanupAll only stops accepting NEW connections; an inflight
-        // accept can still fire 'connection' after we've started teardown. Reject those so
-        // the late client doesn't become activeClient and leak.
-        if (killed) {
-            client.destroy();
-            return;
-        }
-        if (activeClient) {
-            // We only serve one consumer per stream session. Reject anything else.
-            client.destroy();
-            return;
-        }
-        // RTSP-over-TCP-interleaved frames are small (~4 B header + RTP packet). Disable
-        // Nagle so frame headers don't get held up to 200 ms hoping to coalesce.
-        client.setNoDelay(true);
-        activeClient = client;
-        handleRtspClient(client, {
-            sdp,
-            console,
-            onPlay(send, channels) {
-                active = {
-                    send,
-                    videoRtp: channels.video.rtp,
-                    videoRtcp: channels.video.rtcp,
-                    audioRtp: channels.audio.rtp,
-                    audioRtcp: channels.audio.rtcp,
-                };
-                // Periodic RTCP Sender Reports. Receivers map each track's RTP timeline
-                // to wall-clock NTP via SRs to keep audio/video in sync — the prior ffmpeg
-                // pipeline emitted them, so generating a minimal SR every 5 s keeps
-                // behavior parity. A single SR per track is ~28 B; cost is negligible.
-                rtcpInterval = setInterval(() => {
-                    if (!active || killed) return;
-                    const ntp = nowNtp();
-                    const vsr = h264.senderReport(ntp);
-                    if (vsr) active.send(active.videoRtcp, vsr);
-                    const asr = g711.senderReport(ntp);
-                    if (asr) active.send(active.audioRtcp, asr);
-                }, 5000);
-            },
-            onTeardown: cleanupAll,
-        });
-    });
-
-    await new Promise<void>((resolve, reject) => {
-        tcpServer!.once('error', reject);
-        tcpServer!.listen(rtspPort, '127.0.0.1', () => {
-            tcpServer!.removeListener('error', reject);
-            resolve();
-        });
-    });
-
-    return {
-        url,
-        kill: cleanupAll,
-        exited,
-    };
-}