@rapidmx/meet-plugin 0.6.0 → 0.8.1

package/apps/shared/relay/AudioSender.ts

@@ -0,0 +1,194 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz. All rights reserved.
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+import { resumeAudioContext } from "./audioResume.js";
+import { KIND_AUDIO } from "./frames.js";
+import type {
+    AudioContextLike,
+    AudioDataLike,
+    AudioNodeLike,
+    EncodedChunkLike,
+    EncoderLike,
+    GainLike,
+    ScriptProcessorLike,
+} from "./relayEnv.js";
+import { safeClose, type SenderDeps } from "./senderCommon.js";
+
+export const AUDIO_SAMPLE_RATE = 48_000;
+/** Frames per `ScriptProcessorNode` callback: about 43 ms, a compromise between latency and how often the main
+ * thread is interrupted. */
+export const AUDIO_PROCESS_FRAMES = 2048;
+export const AUDIO_BITRATE = 24_000;
+/** The Opus frame duration in microseconds (20 ms). */
+export const AUDIO_FRAME_DURATION_US = 20_000;
+/** Skip a block instead of queueing it when the encoder is this far behind. */
+export const AUDIO_MAX_ENCODE_QUEUE = 8;
+
+/**
+ * Captures one microphone track and publishes it as Opus.
+ *
+ * There is exactly one capture path, chosen for being testable and available everywhere the relay is: an
+ * `AudioContext` at 48 kHz, a `MediaStreamAudioSourceNode` on the track, and a `ScriptProcessorNode` that receives
+ * the raw PCM. (`ScriptProcessorNode` is deprecated in favour of `AudioWorklet`, but it needs no separate module
+ * file to load, which a plugin bundle has no good place for, and every browser still supports it.) The processor's
+ * output is routed through a zero-gain node to the destination, because browsers only run a processor that is
+ * connected to the destination, and the gain stops the microphone playing back locally.
+ *
+ * It encodes only while sending is active, a track is set and the socket can take the frames, and rebuilds the graph
+ * when the track is replaced. The encoder is created lazily and discarded on any error, so a coder that died is
+ * replaced at the next block rather than being repaired inside its own error callback.
+ */
+export class AudioSender {
+    private active = false;
+    private track: MediaStreamTrack | null = null;
+    private attachedTrack: MediaStreamTrack | null = null;
+
+    private ctx: AudioContextLike | undefined;
+    private source: AudioNodeLike | undefined;
+    private processor: ScriptProcessorLike | undefined;
+    private gain: GainLike | undefined;
+    private stopResume: (() => void) | undefined;
+    private encoder: EncoderLike<AudioDataLike> | undefined;
+    private baseMs = 0;
+    private samples = 0;
+
+    constructor(private readonly deps: SenderDeps) {}
+
+    setActive(active: boolean): void {
+        this.active = active;
+        this.sync();
+    }
+
+    setTrack(track: MediaStreamTrack | null): void {
+        this.track = track;
+        this.sync();
+    }
+
+    /** Brings the capture graph in line with (`active`, `track`): torn down when either is missing, rebuilt when
+     * the track changed, untouched otherwise. */
+    private sync(): void {
+        const wanted = this.active ? this.track : null;
+        if (wanted === this.attachedTrack) {
+            return;
+        }
+        this.detach();
+        if (wanted) {
+            this.attach(wanted);
+        }
+    }
+
+    private attach(track: MediaStreamTrack): void {
+        const env = this.deps.env;
+        this.attachedTrack = track;
+        this.baseMs = env.now();
+        this.samples = 0;
+        try {
+            const ctx = env.createAudioContext(AUDIO_SAMPLE_RATE);
+            this.ctx = ctx;
+            const source = ctx.createMediaStreamSource(env.createMediaStream([track]));
+            this.source = source;
+            const processor = ctx.createScriptProcessor(AUDIO_PROCESS_FRAMES, 1, 1);
+            this.processor = processor;
+            const gain = ctx.createGain();
+            gain.gain.value = 0;
+            this.gain = gain;
+            processor.onaudioprocess = (event) => this.process(event.inputBuffer.getChannelData(0));
+            source.connect(processor);
+            processor.connect(gain);
+            gain.connect(ctx.destination);
+            this.stopResume = resumeAudioContext(ctx, env.document);
+        } catch {
+            // No usable AudioContext (or a browser that refuses one): audio simply isn't relayed.
+            this.detach();
+        }
+    }
+
+    private detach(): void {
+        this.attachedTrack = null;
+        this.stopResume?.();
+        this.stopResume = undefined;
+        if (this.processor) {
+            this.processor.onaudioprocess = null;
+        }
+        this.source?.disconnect();
+        this.processor?.disconnect();
+        this.gain?.disconnect();
+        this.source = this.processor = this.gain = undefined;
+        const ctx = this.ctx;
+        this.ctx = undefined;
+        // `close()` rejects for a context that is already closed; nothing to do about it.
+        ctx?.close().catch(() => undefined);
+        this.discardEncoder();
+    }
+
+    private discardEncoder(): void {
+        const encoder = this.encoder;
+        this.encoder = undefined;
+        safeClose(encoder);
+    }
+
+    private process(input: Float32Array): void {
+        const samples = input.length;
+        const timestampUs = Math.round((this.samples * 1_000_000) / AUDIO_SAMPLE_RATE);
+        this.samples += samples;
+        if (!this.deps.canSend()) {
+            return;
+        }
+        const encoder = this.encoder ?? this.createEncoder();
+        if (!encoder || encoder.encodeQueueSize > AUDIO_MAX_ENCODE_QUEUE) {
+            return;
+        }
+        let audio: AudioDataLike | undefined;
+        try {
+            // The browser reuses `input` for the next block, so the encoder gets its own copy.
+            audio = this.deps.env.createAudioData({
+                format: "f32-planar",
+                sampleRate: AUDIO_SAMPLE_RATE,
+                numberOfFrames: samples,
+                numberOfChannels: 1,
+                timestamp: timestampUs,
+                data: new Float32Array(input),
+            });
+            encoder.encode(audio);
+        } catch {
+            this.discardEncoder();
+        } finally {
+            audio?.close();
+        }
+    }
+
+    private createEncoder(): EncoderLike<AudioDataLike> | undefined {
+        let encoder: EncoderLike<AudioDataLike> | undefined;
+        try {
+            encoder = this.deps.env.createAudioEncoder({
+                output: (chunk) => this.onChunk(chunk),
+                error: () => {
+                    // Only the current encoder's failure matters; a stale one was already replaced.
+                    if (this.encoder === encoder) {
+                        this.discardEncoder();
+                    }
+                },
+            });
+            encoder.configure({
+                codec: "opus",
+                sampleRate: AUDIO_SAMPLE_RATE,
+                numberOfChannels: 1,
+                bitrate: AUDIO_BITRATE,
+                opus: { frameDuration: AUDIO_FRAME_DURATION_US },
+            });
+        } catch {
+            safeClose(encoder);
+            return undefined;
+        }
+        this.encoder = encoder;
+        return encoder;
+    }
+
+    private onChunk(chunk: EncodedChunkLike): void {
+        const bytes = new Uint8Array(chunk.byteLength);
+        chunk.copyTo(bytes);
+        // Every Opus packet decodes on its own, so each is flagged as a key frame.
+        this.deps.publish(KIND_AUDIO, true, bytes, this.baseMs + chunk.timestamp / 1000);
+    }
+}

package/apps/shared/relay/RelayClient.ts

@@ -0,0 +1,262 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz. All rights reserved.
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+/**
+ * The WebSocket to the server's media relay - the transport under the last-resort tier of a call, used for a pair of
+ * participants whose WebRTC connection could not be made to work at all.
+ *
+ * ## Wire protocol (fixed by the server)
+ *
+ * - The first message is text JSON `{"op":"hello","v":1,"peer":"<peerId>"}`; the server answers `{"op":"ready","v":1}`,
+ * plus `"maxMessageBytes"` - the largest client-to-server message it accepts - on a current server (absent on an
+ * older one, which accepts `MAX_MESSAGE_BYTES`). Nothing else may be sent before `ready`.
+ * - `{"op":"want","peers":[...]}` REPLACES the set of senders this socket receives from (the server accepts at most
+ * `MAX_WANTED_PEERS`). It has to be re-sent after every reconnect, because the server's set dies with the socket.
+ * - A binary message from the client is an opaque payload of at most `maxMessageBytes`. The server forwards it to
+ * every socket that wants this sender as `[1 byte N][N bytes UTF-8 sender peer id][payload]`, stamping the sender
+ * itself so a peer cannot speak as another.
+ * - Binary messages may be dropped under backpressure and the socket may close at any moment, so this client
+ * reconnects with exponential backoff and treats every media send as best effort.
+ *
+ * Authentication is the `jwt` cookie already in place (see `GuestSignalingClient`), so this client sets no cookie.
+ */
+import { DEFAULT_MESSAGE_BYTES } from "./frames.js";
+import type { RelaySocket } from "./relayEnv.js";
+
+/** The largest binary message an older server accepts - it closes the socket on a larger one (uWS's default limit).
+ * Assumed until the server's `ready` announces a different `maxMessageBytes`. */
+export const MAX_MESSAGE_BYTES = DEFAULT_MESSAGE_BYTES;
+/** A `maxMessageBytes` below this is not believed (nothing useful fits), and one above
+ * `MAX_NEGOTIATED_MESSAGE_BYTES` is clamped to it. */
+export const MIN_NEGOTIATED_MESSAGE_BYTES = 1024;
+export const MAX_NEGOTIATED_MESSAGE_BYTES = 1024 * 1024;
+/** The most senders the server lets one socket `want`. */
+export const MAX_WANTED_PEERS = 32;
+/** A media send is dropped, not queued, while more than this many bytes are still waiting to leave - the
+ * connection is slower than the media, and queueing would only add latency to the frames that are still fresh. */
+export const MAX_BUFFERED_BYTES = 256 * 1024;
+/** Reconnect delay: about a second after the first failure, doubling to a ceiling, jittered so a server restart
+ * doesn't bring every client back in the same instant. */
+export const RELAY_BACKOFF_BASE_MS = 1_000;
+export const RELAY_BACKOFF_MAX_MS = 15_000;
+/** How long a socket may take to become `ready` before it is abandoned and retried (a server that accepts the
+ * upgrade but never answers the hello would otherwise hang the tier forever). */
+export const RELAY_HANDSHAKE_TIMEOUT_MS = 10_000;
+
+const SOCKET_OPEN = 1;
+
+export interface RelayClientOptions {
+    url: string;
+    peerId: string;
+    createSocket: (url: string) => RelaySocket;
+    random: () => number;
+    /** Called with the sender's peer id (as stamped by the server) and the original payload. */
+    onMedia: (peerId: string, payload: Uint8Array) => void;
+}
+
+/** Views `data` as bytes when it is binary (an `ArrayBuffer` or a typed array), else `undefined`. Uses
+ * `Object.prototype.toString` rather than `instanceof` so it works for a buffer from another realm too. */
+function toBytes(data: unknown): Uint8Array | undefined {
+    if (ArrayBuffer.isView(data)) {
+        return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    }
+    if (Object.prototype.toString.call(data) === "[object ArrayBuffer]") {
+        return new Uint8Array(data as ArrayBuffer);
+    }
+    return undefined;
+}
+
+export class RelayClient {
+    private socket: RelaySocket | undefined;
+    private closed = false;
+    private started = false;
+    private isReady = false;
+    private messageLimit = MAX_MESSAGE_BYTES;
+    private attempt = 0;
+    private wanted: string[] = [];
+    private reconnectTimer: ReturnType<typeof setTimeout> | undefined;
+    private handshakeTimer: ReturnType<typeof setTimeout> | undefined;
+    private readonly decoder = new TextDecoder();
+
+    constructor(private readonly options: RelayClientOptions) {}
+
+    /** True once the server has answered the hello on the current socket, i.e. media may be sent. */
+    get ready(): boolean {
+        return this.isReady;
+    }
+
+    /** The largest message `sendMedia()` will send: what the server announced in `ready` (validated and clamped), or
+     * `MAX_MESSAGE_BYTES` before that, without one, and again after every disconnect until the next `ready`. The
+     * frame fragmenter sizes its fragments from this. */
+    get maxMessageBytes(): number {
+        return this.messageLimit;
+    }
+
+    /** Opens the socket (and keeps it open, reconnecting as needed) until `close()`. Idempotent. */
+    start(): void {
+        if (this.started || this.closed) {
+            return;
+        }
+        this.started = true;
+        this.openSocket();
+    }
+
+    /** Replaces the set of senders to receive from. Sent now if the socket is ready, and again after each reconnect. */
+    setWanted(peers: Iterable<string>): void {
+        this.wanted = [...peers].slice(0, MAX_WANTED_PEERS);
+        if (this.isReady) {
+            this.sendText({ op: "want", peers: this.wanted });
+        }
+    }
+
+    /** Sends one media message. Returns whether it was handed to the socket - `false` (dropped) when the socket is
+     * not ready, is backed up, or the message is too large for the server to accept. */
+    sendMedia(bytes: Uint8Array): boolean {
+        const socket = this.socket;
+        if (
+            !socket ||
+            !this.isReady ||
+            socket.readyState !== SOCKET_OPEN ||
+            socket.bufferedAmount > MAX_BUFFERED_BYTES ||
+            bytes.length > this.messageLimit
+        ) {
+            return false;
+        }
+        try {
+            socket.send(bytes);
+            return true;
+        } catch {
+            // The close that follows a dead socket reconnects.
+            return false;
+        }
+    }
+
+    /** Closes the socket and stops reconnecting for good. Idempotent. */
+    close(): void {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        this.isReady = false;
+        this.messageLimit = MAX_MESSAGE_BYTES;
+        clearTimeout(this.reconnectTimer);
+        clearTimeout(this.handshakeTimer);
+        this.reconnectTimer = this.handshakeTimer = undefined;
+        this.detach();
+    }
+
+    private openSocket(): void {
+        let socket: RelaySocket;
+        try {
+            socket = this.options.createSocket(this.options.url);
+        } catch {
+            this.scheduleReconnect();
+            return;
+        }
+        this.socket = socket;
+        socket.binaryType = "arraybuffer";
+        socket.onopen = () => this.sendText({ op: "hello", v: 1, peer: this.options.peerId });
+        socket.onmessage = (event) => this.handleMessage(socket, event.data);
+        socket.onclose = () => this.handleClose(socket);
+        socket.onerror = () => undefined;
+        this.handshakeTimer = setTimeout(() => {
+            this.handshakeTimer = undefined;
+            // Give up on this attempt as if the socket had closed; the close event of a socket we abandon is ignored.
+            this.handleClose(socket);
+        }, RELAY_HANDSHAKE_TIMEOUT_MS);
+    }
+
+    private handleMessage(socket: RelaySocket, data: unknown): void {
+        if (socket !== this.socket) {
+            return;
+        }
+        if (typeof data === "string") {
+            this.handleText(data);
+            return;
+        }
+        const bytes = toBytes(data);
+        if (!bytes || !this.isReady) {
+            return;
+        }
+        const idLength = bytes.length > 0 ? bytes[0] : 0;
+        if (idLength === 0 || bytes.length < 1 + idLength) {
+            return;
+        }
+        // A malformed id decodes to replacement characters, which match no receiver, so it needs no separate check.
+        const peerId = this.decoder.decode(bytes.subarray(1, 1 + idLength));
+        this.options.onMedia(peerId, bytes.subarray(1 + idLength));
+    }
+
+    private handleText(text: string): void {
+        let message: unknown;
+        try {
+            message = JSON.parse(text);
+        } catch {
+            return;
+        }
+        if (!message || typeof message !== "object" || (message as { op?: unknown }).op !== "ready" || this.isReady) {
+            return;
+        }
+        this.isReady = true;
+        this.attempt = 0;
+        const announced = (message as { maxMessageBytes?: unknown }).maxMessageBytes;
+        if (typeof announced === "number" && Number.isInteger(announced) && announced >= MIN_NEGOTIATED_MESSAGE_BYTES) {
+            this.messageLimit = Math.min(announced, MAX_NEGOTIATED_MESSAGE_BYTES);
+        }
+        clearTimeout(this.handshakeTimer);
+        this.handshakeTimer = undefined;
+        // The server's wanted set is per socket, so it starts empty on every (re)connect.
+        this.sendText({ op: "want", peers: this.wanted });
+    }
+
+    private handleClose(socket: RelaySocket): void {
+        if (socket !== this.socket) {
+            return;
+        }
+        this.isReady = false;
+        // The next server might be a different one (a rolling upgrade), so the limit is learned afresh.
+        this.messageLimit = MAX_MESSAGE_BYTES;
+        clearTimeout(this.handshakeTimer);
+        this.handshakeTimer = undefined;
+        this.detach();
+        this.scheduleReconnect();
+    }
+
+    /** Detaches and closes the current socket, if any, so its late events can't reach this client. */
+    private detach(): void {
+        const socket = this.socket;
+        this.socket = undefined;
+        if (!socket) {
+            return;
+        }
+        socket.onopen = socket.onmessage = socket.onclose = socket.onerror = null;
+        try {
+            socket.close(1000, "closing");
+        } catch {
+            // Already gone.
+        }
+    }
+
+    private scheduleReconnect(): void {
+        const ceiling = Math.min(RELAY_BACKOFF_MAX_MS, RELAY_BACKOFF_BASE_MS * 2 ** Math.min(this.attempt, 10));
+        const delay = ceiling / 2 + (this.options.random() * ceiling) / 2;
+        this.attempt += 1;
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = undefined;
+            this.openSocket();
+        }, delay);
+    }
+
+    private sendText(message: object): void {
+        const socket = this.socket;
+        if (!socket || socket.readyState !== SOCKET_OPEN) {
+            return;
+        }
+        try {
+            socket.send(JSON.stringify(message));
+        } catch {
+            // The close that follows a dead socket reconnects and re-sends.
+        }
+    }
+}

package/apps/shared/relay/RelayReceiver.ts

@@ -0,0 +1,72 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz. All rights reserved.
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+import { AudioPlayer } from "./AudioPlayer.js";
+import { decodeFragment, FrameReassembler, KIND_AUDIO } from "./frames.js";
+import type { AudioContextLike, RelayEnv } from "./relayEnv.js";
+import { VideoPlayer } from "./VideoPlayer.js";
+
+/** The canvas is sized to the first decoded picture; until then it is this size. */
+const INITIAL_CANVAS_WIDTH = 320;
+const INITIAL_CANVAS_HEIGHT = 240;
+/** The frame rate `captureStream()` samples the canvas at, matching what the sender produces. */
+const CAPTURE_FPS = 15;
+
+/**
+ * One remote participant as seen through the relay: reassembles their fragments, decodes them, and exposes the result
+ * as an ordinary `MediaStream` (`stream`) so the UI plays a relayed peer exactly like a WebRTC one.
+ *
+ * The stream exists, with both tracks, from construction - silent and blank until media arrives - so the caller can
+ * attach it to an element straight away and never has to swap a stream in later. Audio goes through a
+ * `MediaStreamAudioDestinationNode` on the shared playback context; video is drawn to a canvas and captured.
+ */
+export class RelayReceiver {
+    readonly stream: MediaStream;
+    private readonly audioFrames = new FrameReassembler();
+    private readonly videoFrames = new FrameReassembler();
+    private readonly audio: AudioPlayer;
+    private readonly video: VideoPlayer | undefined;
+
+    constructor(
+        env: RelayEnv,
+        playbackContext: AudioContextLike,
+    ) {
+        const destination = playbackContext.createMediaStreamDestination();
+        this.audio = new AudioPlayer(env, playbackContext, destination);
+
+        const canvas = env.createCanvas();
+        canvas.width = INITIAL_CANVAS_WIDTH;
+        canvas.height = INITIAL_CANVAS_HEIGHT;
+        const context = canvas.getContext("2d");
+        this.video = context ? new VideoPlayer(env, canvas, context) : undefined;
+
+        this.stream = env.createMediaStream([...destination.stream.getAudioTracks(), ...canvas.captureStream(CAPTURE_FPS).getVideoTracks()]);
+    }
+
+    /** Handles one relayed payload from this sender (a media fragment). Anything malformed is ignored. */
+    handleMedia(payload: Uint8Array): void {
+        const fragment = decodeFragment(payload);
+        if (!fragment) {
+            return;
+        }
+        const frame = (fragment.kind === KIND_AUDIO ? this.audioFrames : this.videoFrames).push(fragment);
+        if (!frame) {
+            return;
+        }
+        if (frame.kind === KIND_AUDIO) {
+            this.audio.push(frame);
+        } else {
+            this.video?.push(frame);
+        }
+    }
+
+    /** Releases the decoders and ends the stream's tracks. */
+    close(): void {
+        this.audio.close();
+        this.video?.close();
+        for (const track of this.stream.getTracks()) {
+            track.stop();
+        }
+    }
+}

package/apps/shared/relay/RelaySender.ts

@@ -0,0 +1,74 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz. All rights reserved.
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+import { AudioSender } from "./AudioSender.js";
+import { DEFAULT_MESSAGE_BYTES, fragmentFrame, type FrameKind, KIND_AUDIO, KIND_VIDEO } from "./frames.js";
+import type { RelayEnv } from "./relayEnv.js";
+import type { PublishFrame } from "./senderCommon.js";
+import { VideoSender } from "./VideoSender.js";
+
+const SEQ_MODULUS = 0x10000;
+
+/** Numbers and fragments the frames of one sender. The counters belong to the transport rather than to a capture
+ * session, so stopping and restarting sending never resets `seq` - a receiver still holding the old value would
+ * otherwise treat the restarted stream as older than what it has already seen. */
+export class FramePublisher {
+    private readonly seqs: Record<FrameKind, number> = { [KIND_AUDIO]: 0, [KIND_VIDEO]: 0 };
+
+    /** `send` returns whether one message was accepted by the socket. */
+    /** `maxMessageBytes` is the largest message the socket may send right now (it changes when the server's `ready`
+     * announces a limit), so it is read for every frame rather than fixed at construction. */
+    constructor(
+        private readonly send: (message: Uint8Array) => boolean,
+        private readonly maxMessageBytes: () => number = () => DEFAULT_MESSAGE_BYTES,
+    ) {}
+
+    /** Fragments and sends one frame, stopping at the first fragment the socket refuses (the rest could not be
+     * used without it). Returns whether the whole frame went out. */
+    publish: PublishFrame = (kind, keyFrame, data, timestampMs) => {
+        const seq = this.seqs[kind];
+        this.seqs[kind] = (seq + 1) % SEQ_MODULUS;
+        const fragments = fragmentFrame(kind, keyFrame, seq, timestampMs, data, this.maxMessageBytes());
+        if (fragments.length === 0) {
+            return false;
+        }
+        for (const fragment of fragments) {
+            if (!this.send(fragment)) {
+                return false;
+            }
+        }
+        return true;
+    };
+}
+
+export interface RelaySenderOptions {
+    env: RelayEnv;
+    send: (message: Uint8Array) => boolean;
+    canSend: () => boolean;
+    /** The socket's current message limit; defaults to what an older server accepts. */
+    maxMessageBytes?: () => number;
+}
+
+/** The publishing half of the relay: the two capture paths plus the frame numbering they share. */
+export class RelaySender {
+    private readonly audio: AudioSender;
+    private readonly video: VideoSender;
+
+    constructor(options: RelaySenderOptions) {
+        const deps = { env: options.env, publish: new FramePublisher(options.send, options.maxMessageBytes).publish, canSend: options.canSend };
+        this.audio = new AudioSender(deps);
+        this.video = new VideoSender(deps);
+    }
+
+    /** Starts or stops encoding whatever tracks are set. Stopping releases the encoders and audio nodes. */
+    setActive(active: boolean): void {
+        this.audio.setActive(active);
+        this.video.setActive(active);
+    }
+
+    /** `null` sends nothing for that kind. Safe before or after `setActive`. */
+    setTrack(kind: "audio" | "video", track: MediaStreamTrack | null): void {
+        (kind === "audio" ? this.audio : this.video).setTrack(track);
+    }
+}