@relaymessenger/livekit 0.1.0-staging.15 → 0.1.0-staging.17

package/dist/transport.js

@@ -1,1303 +0,0 @@
-import { RemoteVideoTrack, } from "./video.js";
-export { LocalVideoTrack, RemoteVideoTrack, VideoBufferType, VideoCodec, VideoFrame, VideoRotation, VideoSource, VideoStream, } from "./video.js";
-/** Opus's native rate and Relay's wire channel count. */
-export const DEFAULT_INBOUND_AUDIO = Object.freeze({
-    sampleRate: 48_000,
-    channelCount: 2,
-});
-const INBOUND_SAMPLE_RATES = new Set([8_000, 12_000, 16_000, 24_000, 48_000]);
-const DEFAULT_ICE_GATHERING_TIMEOUT_MS = 10_000;
-const AUDIO_SLICE_MS = 10;
-const STALL_CHECK_MS = 500;
-const STALL_AFTER_MS = 2_000;
-/**
- * Restart rule, copied from PartyTracks and Cloudflare (PROTOCOL.md section 4):
- * not `connected` 5 s after the SFU answer (Cloudflare's echo example waits
- * 5000 ms; SFU operations block up to 5 s awaiting `connected`), `failed`, or
- * `disconnected` for 7 s (PartyTracks.ts `timeoutSeconds = 7`). Backoff 250 ms
- * x1.1 per attempt, capped at 10 s (PartyTracks `retryWithBackoff`
- * `backoffFactor: 1.1`, rxjs-helpers.ts defaults). werift never reports
- * `failed` on a session whose checks go unanswered (ice.js:983-986), so the
- * 5 s timer is the trigger that fires in practice.
- */
-export const RESTART_CONNECT_TIMEOUT_MS = 5_000;
-export const RESTART_DISCONNECTED_MS = 7_000;
-export const RESTART_INITIAL_DELAY_MS = 250;
-export const RESTART_BACKOFF_FACTOR = 1.1;
-export const RESTART_MAX_DELAY_MS = 10_000;
-/**
- * Backoff before restart number `attempt` (1-based) counted since the last
- * session that connected. PartyTracks passes `resetOnSuccess: true` to rxjs
- * `retry` (rxjs-helpers.ts:18, :39); this transport reads "success" as a
- * session reaching `connected`.
- */
-export const restartDelayMs = (attempt) => Math.min(RESTART_INITIAL_DELAY_MS * RESTART_BACKOFF_FACTOR ** (attempt - 1), RESTART_MAX_DELAY_MS);
-const ACTIVE_CALL_STATUSES = new Set(["ringing", "in-progress"]);
-export class RelayCallTransportError extends Error {
-    code;
-    constructor(message, code) {
-        super(message);
-        this.name = "RelayCallTransportError";
-        if (code !== undefined)
-            this.code = code;
-    }
-}
-const DEFAULT_PEER_CONFIG = { iceServers: [], iceTransportPolicy: "all" };
-/**
- * Cloudflare Realtime's echo example builds its peer with exactly this list
- * (cloudflare/realtime-examples echo/index.html `createPeerConnection`).
- */
-const DEFAULT_ICE_SERVERS = [{ urls: "stun:stun.cloudflare.com:3478" }];
-const loadWebRTCFactory = async (engine) => {
-    if (engine === "werift") {
-        const { createWeriftWebRTCFactory } = await import("./engine-werift.js");
-        return createWeriftWebRTCFactory();
-    }
-    const wrtc = await import("@roamhq/wrtc");
-    return {
-        createPeerConnection: (config = DEFAULT_PEER_CONFIG) => new wrtc.RTCPeerConnection({
-            bundlePolicy: "max-bundle",
-            iceServers: config.iceServers,
-            iceTransportPolicy: config.iceTransportPolicy,
-        }),
-        createAudioSource: () => new WrtcAudioSource(new wrtc.nonstandard.RTCAudioSource()),
-        createAudioSink: (track) => new wrtc.nonstandard.RTCAudioSink(track),
-    };
-};
-/** `candidate:<foundation> <component> <transport> <priority> <address> <port> typ <type> ...` (RFC 5245 §15.1). */
-const parseCandidate = (line) => {
-    const match = /candidate:\S+\s+\d+\s+(\S+)\s+\d+\s+\S+\s+(\d+)\s+typ\s+(\S+)/i.exec(line);
-    if (!match)
-        return undefined;
-    return { transport: match[1].toLowerCase(), port: Number(match[2]), type: match[3].toLowerCase() };
-};
-const seconds = (milliseconds) => `${(milliseconds / 1000).toFixed(1)}s`;
-const summarizeIce = (diagnostics) => {
-    const { local, remote, transitions, connected } = diagnostics;
-    const localPart = `local: host ${local.host}, srflx ${local.srflx}, relay ${local.relay}`
-        + (local.other ? `, other ${local.other}` : "")
-        + (diagnostics.selectedPair ? `, pair ${diagnostics.selectedPair}` : "");
-    const remotePart = remote.length
-        ? `remote: ${remote.map((candidate) => `${candidate.transport} ${candidate.port}`).join(", ")}`
-        : "remote: none";
-    const states = [];
-    let lastGathering = "new";
-    for (const transition of transitions) {
-        if (transition.kind === "gathering") {
-            states.push(`${lastGathering}\u2192${transition.state} ${seconds(transition.atMs)}`);
-            lastGathering = transition.state;
-        }
-        else if (transition.kind === "ice") {
-            states.push(`ice ${transition.state} ${seconds(transition.atMs)}`);
-        }
-        else {
-            states.push(`${transition.state} ${seconds(transition.atMs)}`);
-        }
-    }
-    if (!connected)
-        states.push("no connected");
-    return `${localPart}; ${remotePart}; states: ${states.join(", ")}`;
-};
-const span = (first, last) => first === undefined || last === undefined ? "no packets" : `first ${seconds(first)} last ${seconds(last)}`;
-const summarizeInbound = (inbound) => `in: ${inbound.rtpPackets} rtp, ${inbound.decodeFailures} bad, ${inbound.frames} frames, `
-    + `${span(inbound.firstPacketAtMs, inbound.lastPacketAtMs)}, ${inbound.recentRtpPackets}/5s`;
-const summarizeOutbound = (outbound) => `out: ${outbound.frames} frames, ${outbound.opusPackets} opus, ${outbound.rtpPackets} rtp, `
-    + `silence ${outbound.silencePackets}, `
-    + `${span(outbound.firstPacketAtMs, outbound.lastPacketAtMs)}, ${outbound.recentRtpPackets}/5s, `
-    + `queue ${outbound.queued}, pacer ${outbound.pacerAlive === undefined ? "n/a" : outbound.pacerAlive ? "alive" : "idle"}`;
-const summarizeRoom = (room) => {
-    const parts = [`${room.roomStates} roomState`, `${room.offers} offer`];
-    if (room.endedReason !== undefined)
-        parts.push(`ended ${room.endedReason}`);
-    if (room.errors.length)
-        parts.push(`error ${room.errors.map((text) => JSON.stringify(text)).join(", ")}`);
-    return `room: ${parts.join(", ")}`;
-};
-const summarize = (diagnostics) => `${summarizeIce(diagnostics)}; ${summarizeInbound(diagnostics.inbound)}; `
-    + `${summarizeOutbound(diagnostics.outbound)}; ${summarizeRoom(diagnostics.room)}`
-    + (diagnostics.restarts ? `; restarts ${diagnostics.restarts}` : "");
-const copyIceServers = (servers) => servers.map((server) => ({
-    urls: Array.isArray(server.urls) ? [...server.urls] : server.urls,
-    ...(server.username === undefined ? {} : { username: server.username }),
-    ...(server.credential === undefined ? {} : { credential: server.credential }),
-}));
-const cloneSamples = (samples) => {
-    const copy = new Int16Array(samples.length);
-    copy.set(samples);
-    return copy;
-};
-/**
- * `@roamhq/wrtc`'s `RTCAudioSource` plays each 10 ms slice through libwebrtc's
- * own clock and exposes no queue, so this wrapper estimates it from wall time:
- * queued = accepted since the run started minus the time elapsed. Best effort;
- * the werift engine (the default) reports its real queue.
- *
- * It sends no silence of its own. The source has no timer: `onData` hands the
- * slice to the track's sinks and returns (`RTCAudioSource::OnData` ->
- * `PushData`, node-webrtc src/interfaces/rtc_audio_source.cc and
- * rtc_audio_source.hh, the repository @roamhq/wrtc 0.10.0 is published
- * from), so libwebrtc receives audio only while the caller writes it, and
- * this wrapper has no `start()`. What libwebrtc puts on the wire between
- * writes was not measured; a caller of this
- * engine that needs the track to carry data between utterances writes
- * silence itself.
- */
-class WrtcAudioSource {
-    #inner;
-    #runStartedAt = 0;
-    #runAcceptedMs = 0;
-    constructor(inner) {
-        this.#inner = inner;
-    }
-    createTrack() {
-        return this.#inner.createTrack();
-    }
-    onData(data) {
-        const now = Date.now();
-        if (this.queuedMs() === 0) {
-            this.#runStartedAt = now;
-            this.#runAcceptedMs = 0;
-        }
-        this.#runAcceptedMs += (data.numberOfFrames / data.sampleRate) * 1_000;
-        this.#inner.onData(data);
-    }
-    queuedMs() {
-        if (this.#runAcceptedMs === 0)
-            return 0;
-        return Math.max(0, this.#runAcceptedMs - (Date.now() - this.#runStartedAt));
-    }
-    async waitForDrain() {
-        const remaining = this.queuedMs();
-        if (remaining > 0)
-            await delay(remaining);
-    }
-    clear() {
-        // libwebrtc keeps slices already handed over; only the estimate can be reset.
-        this.#runAcceptedMs = 0;
-    }
-}
-/** werift's `close()` is async; a rejection there must not become an unhandled one. */
-const closePeer = (peer) => {
-    try {
-        void Promise.resolve(peer.close()).catch(() => undefined);
-    }
-    catch { /* already closed */ }
-};
-const delay = (milliseconds) => new Promise((resolve) => {
-    const timer = setTimeout(resolve, milliseconds);
-    timer.unref?.();
-});
-/**
- * Provider-neutral Node WebRTC bridge for Relay Call rooms.
- *
- * The class owns Relay media negotiation internally. Higher-level adapters only
- * exchange PCM16 frames and call lifecycle events. When an SFU session never
- * connects or dies, the transport builds a new peer connection on a new
- * session (PROTOCOL.md section 4); the audio source and the `audio` events
- * carry on across the swap, so adapters only hear silence.
- */
-export class RelayCallTransport {
-    #room;
-    #providedFactory;
-    #engine;
-    #iceGatheringTimeoutMs;
-    #sessionConnectTimeoutMs;
-    /** `undefined`: the application passed none, so the room's servers are used. */
-    #iceServers;
-    #iceTransportPolicy;
-    #inboundAudio;
-    #onWarning;
-    #connectStartedAt = 0;
-    #inboundFrames = 0;
-    #outboundFrames = 0;
-    #roomStates = 0;
-    #roomOffers = 0;
-    #endedReason;
-    #roomErrors = [];
-    /** Engine stats frozen when media shuts down, so diagnostics survive the call's end. */
-    #finalSinkStats;
-    #finalSourceStats;
-    /** Inbound counts from sinks of peers already replaced by a restart. */
-    #retiredSinkStats;
-    #stallTimer;
-    #stallSince;
-    #stallWarned = false;
-    #iceLocal = { host: 0, srflx: 0, relay: 0, other: 0 };
-    #iceRemote = [];
-    #selectedPair;
-    #iceTransitions = [];
-    #listeners = new Map();
-    #factory;
-    #peer;
-    /** Bumped for every peer built; work started for an older peer stops when it sees a newer one. */
-    #peerGeneration = 0;
-    /** The current peer has reached `connected` since it was built. */
-    #peerConnected = false;
-    #audioSource;
-    #localTrack;
-    /** Set while an offer waits for its first local candidate. */
-    #firstLocalCandidate;
-    #remoteSink;
-    /** The track `#remoteSink` decodes; a repeated `ontrack` for it keeps the sink. */
-    #remoteSinkTrack;
-    #publishTransceiver;
-    #publishFrame;
-    #initialAnswerSdp;
-    #negotiationTail = Promise.resolve();
-    #restarts = 0;
-    /** Restarts since the last `connected`; sets the backoff. */
-    #failedAttempts = 0;
-    #restartPending = false;
-    #wakeRestart;
-    #connectTimer;
-    #disconnectTimer;
-    #callStatus;
-    #remoteVideo = false;
-    #personConnected = false;
-    #peerAudioArrived = false;
-    #peerAudioReady = false;
-    #peerAudioWaiters = new Set();
-    #ended = false;
-    #audioGeneration = 0;
-    /** `waitForPlayout()` callers released early by `clearAudio()` or `close()`. */
-    #playoutWaiters = new Set();
-    #reportedConnected = false;
-    #readySettled = false;
-    #readyResolve;
-    #readyReject;
-    #ready;
-    #handlersAttached = false;
-    /** Releases a peer build waiting on the room's first `iceServers` or `roomState`. */
-    #roomIceServersWaiter;
-    #closed = false;
-    #muted = false;
-    /** The published camera: one per call, kept across restarts (PROTOCOL.md section 1). */
-    #video;
-    #videoTransceiver;
-    #remoteVideoTrack;
-    /** The engine track the current video receiver reads. */
-    #remoteVideoEngineTrack;
-    /** An add-track offer is out; a pull offer that crosses it waits for its answer. */
-    #addTrackPending = false;
-    #deferredOffer;
-    #lastAnswerSdp;
-    constructor(options) {
-        if (!options.callId.trim())
-            throw new Error("callId is required.");
-        this.#room = options.roomClient ?? options.relay.calls.room(options.callId, options.room);
-        this.#providedFactory = options.webRTC;
-        this.#engine = options.engine ?? "werift";
-        this.#onWarning = options.onWarning ?? (() => undefined);
-        if (this.#engine !== "werift" && this.#engine !== "wrtc") {
-            throw new Error('engine must be "werift" or "wrtc".');
-        }
-        const inbound = options.inboundAudio ?? DEFAULT_INBOUND_AUDIO;
-        if (!INBOUND_SAMPLE_RATES.has(inbound.sampleRate)) {
-            throw new Error("inboundAudio.sampleRate must be 8000, 12000, 16000, 24000 or 48000.");
-        }
-        if (inbound.channelCount !== 1 && inbound.channelCount !== 2) {
-            throw new Error("inboundAudio.channelCount must be 1 or 2.");
-        }
-        const isDefaultInbound = inbound.sampleRate === DEFAULT_INBOUND_AUDIO.sampleRate
-            && inbound.channelCount === DEFAULT_INBOUND_AUDIO.channelCount;
-        if (!options.webRTC && this.#engine === "wrtc" && !isDefaultInbound) {
-            // `@roamhq/wrtc`'s nonstandard RTCAudioSink hands over libwebrtc's own
-            // PCM and takes no format; honouring another one would mean resampling here.
-            throw new Error('The "wrtc" engine cannot decode to inboundAudio; use the "werift" engine.');
-        }
-        this.#inboundAudio = { sampleRate: inbound.sampleRate, channelCount: inbound.channelCount };
-        this.#iceGatheringTimeoutMs = options.iceGatheringTimeoutMs ?? DEFAULT_ICE_GATHERING_TIMEOUT_MS;
-        this.#sessionConnectTimeoutMs = options.sessionConnectTimeoutMs
-            ?? options.mediaConnectTimeoutMs
-            ?? options.connectionTimeoutMs
-            ?? RESTART_CONNECT_TIMEOUT_MS;
-        const policy = options.iceTransportPolicy ?? "all";
-        if (policy !== "all" && policy !== "relay") {
-            throw new Error('iceTransportPolicy must be "all" or "relay".');
-        }
-        this.#iceTransportPolicy = policy;
-        const iceServers = options.iceServers;
-        this.#iceServers = iceServers === undefined || typeof iceServers === "function"
-            ? iceServers
-            : copyIceServers(iceServers);
-        if (!Number.isFinite(this.#iceGatheringTimeoutMs) || this.#iceGatheringTimeoutMs <= 0) {
-            throw new Error("iceGatheringTimeoutMs must be greater than zero.");
-        }
-        if (!Number.isFinite(this.#sessionConnectTimeoutMs) || this.#sessionConnectTimeoutMs <= 0) {
-            throw new Error("sessionConnectTimeoutMs must be greater than zero.");
-        }
-        this.#ready = new Promise((resolve, reject) => {
-            this.#readyResolve = resolve;
-            this.#readyReject = reject;
-        });
-        void this.#ready.catch(() => undefined);
-    }
-    on(event, listener) {
-        let listeners = this.#listeners.get(event);
-        if (!listeners) {
-            listeners = new Set();
-            this.#listeners.set(event, listeners);
-        }
-        listeners.add(listener);
-        return this;
-    }
-    off(event, listener) {
-        this.#listeners.get(event)?.delete(listener);
-        return this;
-    }
-    /**
-     * Join the room, publish, and resolve on the first `connected`. Dead SFU
-     * sessions are replaced as they are found (PROTOCOL.md section 4), with no
-     * overall deadline: this rejects only when the Call ends, the room or
-     * transport closes, the room reports an error, or `signal` aborts (which
-     * also closes the transport).
-     */
-    async connect(options = {}) {
-        if (this.#closed)
-            throw new Error("Relay Call transport is closed.");
-        const { signal } = options;
-        const aborted = () => new RelayCallTransportError("Relay Call connect was aborted.", "aborted");
-        if (signal?.aborted)
-            throw aborted();
-        const abort = () => {
-            this.#rejectReady(aborted());
-            this.close();
-        };
-        signal?.addEventListener("abort", abort, { once: true });
-        try {
-            await this.#connect();
-        }
-        finally {
-            signal?.removeEventListener("abort", abort);
-        }
-    }
-    async #connect() {
-        this.#attachRoomHandlers();
-        await this.#room.connect();
-        if (this.#factory) {
-            await this.#ready;
-            return;
-        }
-        this.#factory = this.#providedFactory ?? await loadWebRTCFactory(this.#engine);
-        this.#audioSource = this.#factory.createAudioSource();
-        this.#localTrack = this.#audioSource.createTrack();
-        if (this.#localTrack.kind !== "audio") {
-            throw new RelayCallTransportError("The WebRTC binding created a non-audio Relay track.");
-        }
-        this.#connectStartedAt = Date.now();
-        try {
-            await this.#startPeer();
-            await this.#ready;
-        }
-        catch (error) {
-            this.close();
-            throw error;
-        }
-    }
-    /** Replace only the room signaling socket and replay the identical publication. */
-    async reconnect() {
-        if (this.#closed)
-            throw new Error("Relay Call transport is closed.");
-        if (!this.#publishFrame)
-            throw new Error("Relay Call transport is not connected.");
-        await this.#room.reconnect();
-        this.#room.send(this.#publishFrame);
-    }
-    /**
-     * ICE candidates, state transitions, packet counts in both directions,
-     * room frame counts and restarts recorded for this call, with a one-line summary.
-     */
-    diagnostics() {
-        const snapshot = {
-            local: { ...this.#iceLocal },
-            remote: this.#iceRemote.map((candidate) => ({ ...candidate })),
-            transitions: this.#iceTransitions.map((transition) => ({ ...transition })),
-            selectedPair: this.#selectedPair,
-            connected: this.#peerConnected,
-            inbound: this.#inboundDiagnostics(),
-            outbound: this.#outboundDiagnostics(),
-            room: {
-                roomStates: this.#roomStates,
-                offers: this.#roomOffers,
-                endedReason: this.#endedReason,
-                errors: [...this.#roomErrors],
-            },
-            restarts: this.#restarts,
-        };
-        return { ...snapshot, summary: summarize(snapshot) };
-    }
-    #sinceConnect(epochMs) {
-        return epochMs === undefined ? undefined : epochMs - this.#connectStartedAt;
-    }
-    /** The live sink's counts added to those of sinks retired by restarts. */
-    #sinkStats() {
-        const current = this.#remoteSink?.stats?.();
-        const retired = this.#retiredSinkStats;
-        if (!retired)
-            return current;
-        if (!current)
-            return { ...retired, recentRtpPackets: 0 };
-        return {
-            rtpPackets: retired.rtpPackets + current.rtpPackets,
-            decodeFailures: retired.decodeFailures + current.decodeFailures,
-            firstRtpAt: retired.firstRtpAt ?? current.firstRtpAt,
-            lastRtpAt: current.lastRtpAt ?? retired.lastRtpAt,
-            recentRtpPackets: current.recentRtpPackets,
-        };
-    }
-    #inboundDiagnostics() {
-        const stats = this.#finalSinkStats ?? this.#sinkStats();
-        return {
-            rtpPackets: stats?.rtpPackets ?? 0,
-            decodeFailures: stats?.decodeFailures ?? 0,
-            frames: this.#inboundFrames,
-            firstPacketAtMs: this.#sinceConnect(stats?.firstRtpAt),
-            lastPacketAtMs: this.#sinceConnect(stats?.lastRtpAt),
-            recentRtpPackets: stats?.recentRtpPackets ?? 0,
-        };
-    }
-    #outboundDiagnostics() {
-        const stats = this.#audioSource?.stats?.() ?? this.#finalSourceStats;
-        return {
-            frames: this.#outboundFrames,
-            opusPackets: stats?.opusPackets ?? 0,
-            rtpPackets: stats?.rtpPackets ?? 0,
-            silencePackets: stats?.silencePackets ?? 0,
-            firstPacketAtMs: this.#sinceConnect(stats?.firstRtpAt),
-            lastPacketAtMs: this.#sinceConnect(stats?.lastRtpAt),
-            recentRtpPackets: stats?.recentRtpPackets ?? 0,
-            queued: stats?.queued ?? 0,
-            pacerAlive: stats?.pacerAlive,
-        };
-    }
-    /**
-     * Outbound stall guard: audio is queued for the pacer but no RTP packet has
-     * left for 2 s while connected. Warns once with the summary; restarts nothing.
-     */
-    #checkStall() {
-        if (this.#stallWarned || !this.#reportedConnected)
-            return;
-        const stats = this.#audioSource?.stats?.();
-        if (!stats || stats.queued === 0) {
-            this.#stallSince = undefined;
-            return;
-        }
-        const now = Date.now();
-        const idleSince = stats.lastRtpAt ?? (this.#stallSince ??= now);
-        if (now - idleSince < STALL_AFTER_MS)
-            return;
-        this.#stallWarned = true;
-        this.#stopStallGuard();
-        this.#onWarning(`Relay outbound audio stalled (${this.diagnostics().summary})`);
-    }
-    #startStallGuard() {
-        if (this.#stallTimer)
-            return;
-        this.#stallTimer = setInterval(() => this.#checkStall(), STALL_CHECK_MS);
-        this.#stallTimer.unref?.();
-    }
-    #stopStallGuard() {
-        if (!this.#stallTimer)
-            return;
-        clearInterval(this.#stallTimer);
-        this.#stallTimer = undefined;
-    }
-    /**
-     * Feed interleaved PCM16 audio into Relay. Frames are split into 10 ms WebRTC
-     * source slices and handed to the engine at once; the engine's 20 ms pump
-     * paces the wire, so adapters may push faster than real time (LiveKit's
-     * `AudioSource.captureFrame` shape). Resolves once the slices are queued;
-     * `waitForPlayout()` tells when they have left.
-     */
-    writeAudio(frame) {
-        if (this.#closed)
-            return Promise.reject(new Error("Relay Call transport is closed."));
-        if (!this.#audioSource)
-            return Promise.reject(new Error("Relay Call transport is not connected."));
-        if (!Number.isInteger(frame.sampleRate) || frame.sampleRate <= 0 || frame.sampleRate % 100 !== 0) {
-            return Promise.reject(new Error("Relay audio sampleRate must be a positive multiple of 100."));
-        }
-        if (!Number.isInteger(frame.channelCount) || frame.channelCount <= 0) {
-            return Promise.reject(new Error("Relay audio channelCount must be a positive integer."));
-        }
-        if (frame.samples.length % frame.channelCount !== 0) {
-            return Promise.reject(new Error("Relay audio samples must contain complete interleaved frames."));
-        }
-        const captured = {
-            samples: cloneSamples(frame.samples),
-            sampleRate: frame.sampleRate,
-            channelCount: frame.channelCount,
-        };
-        this.#writeAudio(captured, this.#audioGeneration);
-        return Promise.resolve();
-    }
-    /** Milliseconds of audio accepted by `writeAudio` but not yet written to RTP. */
-    queuedAudioMs() {
-        return this.#audioSource?.queuedMs?.() ?? 0;
-    }
-    /**
-     * Resolves when every accepted slice has been written to RTP and the engine's
-     * pump is idle; immediately when nothing is queued; early on `clearAudio()`
-     * or `close()` (the caller reads `queuedAudioMs()` to learn what was dropped).
-     */
-    waitForPlayout() {
-        const source = this.#audioSource;
-        if (!source || this.#closed || this.queuedAudioMs() === 0)
-            return Promise.resolve();
-        return new Promise((resolve) => {
-            const release = () => {
-                this.#playoutWaiters.delete(release);
-                resolve();
-            };
-            this.#playoutWaiters.add(release);
-            const drained = source.waitForDrain?.() ?? Promise.resolve();
-            drained.then(release, release);
-        });
-    }
-    /** Drop outgoing PCM that has not reached RTP and release `waitForPlayout()` callers. */
-    clearAudio() {
-        this.#audioGeneration += 1;
-        this.#audioSource?.clear?.();
-        this.#releasePlayoutWaiters();
-    }
-    /**
-     * Resolves once `peerAudio` has fired (at once if it already has). Rejects
-     * after `timeoutMs`, or when the Call ends or the transport closes first.
-     */
-    waitForPeerAudio(timeoutMs) {
-        if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
-            return Promise.reject(new Error("waitForPeerAudio timeoutMs must be greater than zero."));
-        }
-        if (this.#peerAudioReady)
-            return Promise.resolve();
-        if (this.#closed || this.#ended) {
-            return Promise.reject(new RelayCallTransportError("Relay Call ended before the person's audio arrived."));
-        }
-        return new Promise((resolve, reject) => {
-            const waiter = {
-                resolve: () => { clearTimeout(timer); this.#peerAudioWaiters.delete(waiter); resolve(); },
-                reject: (error) => { clearTimeout(timer); this.#peerAudioWaiters.delete(waiter); reject(error); },
-            };
-            const timer = setTimeout(() => waiter.reject(new RelayCallTransportError(`Timed out waiting for the person's audio (${this.diagnostics().summary})`)), timeoutMs);
-            timer.unref?.();
-            this.#peerAudioWaiters.add(waiter);
-        });
-    }
-    #checkPeerAudio() {
-        if (this.#peerAudioReady || !this.#peerAudioArrived || !this.#personConnected)
-            return;
-        this.#peerAudioReady = true;
-        for (const waiter of [...this.#peerAudioWaiters])
-            waiter.resolve();
-        this.#emit("peerAudio");
-    }
-    #rejectPeerAudio(error) {
-        for (const waiter of [...this.#peerAudioWaiters])
-            waiter.reject(error);
-    }
-    setMuted(muted) {
-        this.#muted = muted;
-        this.#room.userUpdate({ muted });
-    }
-    /**
-     * Publish the camera (LiveKit `LocalParticipant.publishTrack`). The first
-     * call adds a `video` track to the SFU session with an add-track offer, then
-     * announces `userUpdate { video: true }`; later calls, after
-     * `unpublishTrack`, only resume sending and announce it again
-     * (PROTOCOL.md sections 1-2). Requires `connect()` and the werift engine.
-     */
-    async publishTrack(track, options = {}) {
-        if (this.#closed || this.#ended)
-            throw new Error("Relay Call transport is closed.");
-        if (!this.#factory || !this.#reportedConnected)
-            throw new Error("Relay Call transport is not connected.");
-        if (this.#video) {
-            if (this.#video.track !== track)
-                throw new RelayCallTransportError("A Relay call publishes one video track.");
-            this.#video.sender.setEnabled(true);
-            this.#room.userUpdate({ muted: this.#muted, video: true });
-            return;
-        }
-        const factory = this.#factory;
-        if (!factory.createVideoSender) {
-            throw new RelayCallTransportError('This engine cannot send video; use the "werift" engine.');
-        }
-        const sender = await factory.createVideoSender(options);
-        if (this.#closed || this.#ended) {
-            sender.close();
-            throw new Error("Relay Call transport is closed.");
-        }
-        const detach = track.source._attach((frame, timestampUs, rotation) => sender.capture(frame, timestampUs, rotation));
-        this.#video = { track, sender, detach };
-        await this.#negotiate(async () => {
-            // No peer: a restart is pending, and the next peer publishes video with audio.
-            const peer = this.#peer;
-            if (!peer)
-                return;
-            this.#addVideoTransceiver(peer);
-            await this.#publishLocalAudio(peer, false);
-            this.#addTrackPending = this.#peer === peer;
-        });
-        this.#room.userUpdate({ muted: this.#muted, video: true });
-    }
-    /**
-     * Stop sending the camera and announce `userUpdate { video: false }`. The
-     * track stays negotiated on the SFU (PROTOCOL.md section 1), so a later
-     * `publishTrack` with the same track resumes it without renegotiating.
-     */
-    async unpublishTrack(track) {
-        if (!this.#video || this.#video.track !== track)
-            return;
-        this.#video.sender.setEnabled(false);
-        if (!this.#closed && !this.#ended)
-            this.#room.userUpdate({ muted: this.#muted, video: false });
-    }
-    /** The person's video track, once it has reached this peer. */
-    get remoteVideoTrack() {
-        return this.#remoteVideoTrack;
-    }
-    /** Frame, packet and keyframe counters for both video directions. */
-    videoStats() {
-        return { outbound: this.#video?.sender.stats(), inbound: this.#remoteVideoTrack?.stats() };
-    }
-    /** Runs `work` in the negotiation queue and hands its result or error to the caller. */
-    #negotiate(work) {
-        const run = this.#negotiationTail.then(work);
-        this.#negotiationTail = run.then(() => undefined, () => undefined);
-        return run;
-    }
-    #addVideoTransceiver(peer) {
-        const video = this.#video;
-        if (!video)
-            return;
-        this.#videoTransceiver = peer.addTransceiver(video.sender.track, { direction: "sendonly" });
-        video.sender.bind(this.#videoTransceiver, peer);
-    }
-    end() {
-        this.#room.end();
-    }
-    close() {
-        if (this.#closed)
-            return;
-        this.#closed = true;
-        this.#rejectReady(new RelayCallTransportError("Relay Call transport closed before media connected."));
-        this.#rejectPeerAudio(new RelayCallTransportError("Relay Call transport closed before the person's audio arrived."));
-        this.#audioGeneration += 1;
-        this.#shutdownMedia();
-        this.#releasePlayoutWaiters();
-        this.#roomIceServersWaiter?.();
-        this.#room.close();
-    }
-    /**
-     * Build a peer connection around the one local track and publish it. The
-     * first peer sends a plain `offer`; every later one is a restart onto a new
-     * SFU session (`restart: true`) with ICE servers fetched again.
-     */
-    async #startPeer() {
-        const factory = this.#factory;
-        const track = this.#localTrack;
-        if (!factory || !track)
-            throw new Error("Relay Call transport is not connected.");
-        const restarts = this.#restarts;
-        const generation = ++this.#peerGeneration;
-        const iceServers = this.#iceServers === undefined
-            ? copyIceServers(await this.#roomIceServers())
-            : typeof this.#iceServers === "function"
-                ? copyIceServers(await this.#iceServers({ restarts }))
-                : copyIceServers(this.#iceServers);
-        if (this.#closed || this.#ended || generation !== this.#peerGeneration)
-            return;
-        const peer = factory.createPeerConnection({ iceServers, iceTransportPolicy: this.#iceTransportPolicy });
-        this.#peer = peer;
-        this.#peerConnected = false;
-        this.#initialAnswerSdp = undefined;
-        this.#publishTransceiver = peer.addTransceiver(track, { direction: "sendonly" });
-        this.#addVideoTransceiver(peer);
-        this.#observeIce(peer);
-        peer.onconnectionstatechange = () => {
-            if (this.#peer !== peer)
-                return;
-            this.#recordTransition("connection", peer.connectionState);
-            this.#connectionStateChanged(peer);
-        };
-        peer.ontrack = (event) => {
-            if (this.#peer === peer)
-                this.#remoteTrack(event.track, event.transceiver);
-        };
-        await this.#publishLocalAudio(peer, restarts > 0);
-    }
-    /**
-     * Sends the offer without waiting for ICE gathering, as Cloudflare's echo
-     * example does (`setLocalDescription(offer)`, then `tracks/new` at once): the
-     * SFU is ICE-lite and learns this peer's address from its connectivity
-     * checks. werift's `setLocalDescription` resolves only after every host,
-     * STUN and TURN candidate has settled (peerConnection.js `await
-     * this.gatherCandidates()`; ice.js `await Promise.allSettled(candidatePromises)`),
-     * which took 6.6 s on a staging call on 2026-09-22, so the offer leaves as
-     * soon as the description is applied and the first local candidate exists.
-     */
-    async #publishLocalAudio(peer, restart) {
-        const offer = await peer.createOffer();
-        await this.#applyLocalOffer(peer, offer);
-        if (this.#peer !== peer)
-            return;
-        const description = this.#localDescription(peer, "offer");
-        const mid = this.#publishTransceiver?.mid;
-        if (!mid)
-            throw new RelayCallTransportError("Relay audio publication has no WebRTC MID.");
-        const videoMid = this.#video ? this.#videoTransceiver?.mid : undefined;
-        if (this.#video && !videoMid)
-            throw new RelayCallTransportError("Relay video publication has no WebRTC MID.");
-        this.#publishFrame = {
-            type: "offer",
-            session_description: description,
-            tracks: videoMid ? [{ mid, name: "audio" }, { mid: videoMid, name: "video" }] : [{ mid, name: "audio" }],
-            ...(restart ? { restart: true } : {}),
-        };
-        this.#room.send(this.#publishFrame);
-    }
-    /**
-     * The room's latest servers (PROTOCOL.md section 6). Relay sends
-     * `iceServers` after it accepts `join` and before the first `roomState`, so
-     * a `roomState` with no `iceServers` before it means a room that sends none:
-     * Cloudflare's STUN server is used. Otherwise waits for whichever arrives
-     * first, or for the room to close, end or fail.
-     */
-    async #roomIceServers() {
-        const settled = () => {
-            if (this.#room.iceServers)
-                return this.#room.iceServers;
-            if (this.#room.state || this.#closed || this.#ended)
-                return DEFAULT_ICE_SERVERS;
-            return undefined;
-        };
-        const now = settled();
-        if (now)
-            return now;
-        await new Promise((resolve) => {
-            const events = ["iceServers", "roomState", "ended", "error", "close"];
-            const done = () => {
-                for (const event of events)
-                    this.#room.off(event, done);
-                this.#roomIceServersWaiter = undefined;
-                resolve();
-            };
-            for (const event of events)
-                this.#room.on(event, done);
-            this.#roomIceServersWaiter = done;
-        });
-        return settled() ?? DEFAULT_ICE_SERVERS;
-    }
-    #attachRoomHandlers() {
-        if (this.#handlersAttached)
-            return;
-        this.#handlersAttached = true;
-        this.#room.on("answer", (frame) => {
-            this.#queueNegotiation(() => this.#serverAnswer(frame));
-        });
-        this.#room.on("offer", (frame) => {
-            this.#roomOffers += 1;
-            this.#queueNegotiation(() => this.#serverOffer(frame));
-        });
-        this.#room.on("roomState", (frame) => {
-            this.#roomStates += 1;
-            this.#callStatus = frame.call?.status;
-            // A Call has exactly one agent; the transport is that agent, so the
-            // person is the other participant.
-            const person = frame.participants?.find((participant) => participant.kind === "user");
-            const video = person?.video === true;
-            const videoChanged = video !== this.#remoteVideo;
-            this.#remoteVideo = video;
-            this.#personConnected = person?.connected === true;
-            this.#emit("roomState", frame);
-            if (videoChanged)
-                this.#emit("remoteVideo", video);
-            this.#checkPeerAudio();
-        });
-        this.#room.on("error", (error) => {
-            if (error instanceof Error) {
-                this.#rejectReady(error);
-                this.#emit("error", error);
-            }
-            else
-                this.#serverError(error);
-        });
-        this.#room.on("ended", (frame) => {
-            this.#ended = true;
-            this.#endedReason = frame.reason;
-            this.#rejectReady(new RelayCallTransportError(`Relay Call ended before media connected (${frame.reason}).`));
-            this.#rejectPeerAudio(new RelayCallTransportError(`Relay Call ended before the person's audio arrived (${frame.reason}).`));
-            this.clearAudio();
-            this.#shutdownMedia();
-            this.#emit("ended", frame);
-        });
-        this.#room.on("close", (event) => {
-            if (!this.#reportedConnected) {
-                this.#rejectReady(new RelayCallTransportError(`Relay Call room closed before media connected (${event.code}).`));
-            }
-            this.#emit("close", event);
-        });
-    }
-    #queueNegotiation(work) {
-        const run = this.#negotiationTail.then(work);
-        this.#negotiationTail = run.catch((error) => {
-            const parsed = error instanceof Error ? error : new Error(String(error));
-            this.#rejectReady(parsed);
-            this.#emit("error", parsed);
-        });
-    }
-    async #serverAnswer(frame) {
-        // No peer: the answer is for a session a restart already replaced.
-        const peer = this.#peer;
-        if (!peer)
-            return;
-        const sdp = frame.session_description.sdp;
-        // Reconnecting the signaling socket replays the exact initial offer. Relay
-        // returns its cached answer; applying that answer again in stable state is
-        // invalid WebRTC signaling, so recognize and ignore the replay.
-        if (peer.signalingState === "stable" && (this.#initialAnswerSdp === sdp || this.#lastAnswerSdp === sdp))
-            return;
-        const initial = this.#initialAnswerSdp === undefined;
-        if (initial)
-            this.#recordRemoteCandidates(sdp);
-        await peer.setRemoteDescription(frame.session_description);
-        if (this.#peer !== peer)
-            return;
-        this.#initialAnswerSdp ??= sdp;
-        this.#lastAnswerSdp = sdp;
-        if (initial && !this.#peerConnected)
-            this.#armConnectTimer(peer);
-        if (this.#addTrackPending) {
-            this.#addTrackPending = false;
-            const deferred = this.#deferredOffer;
-            this.#deferredOffer = undefined;
-            if (deferred)
-                await this.#serverOffer(deferred);
-        }
-    }
-    async #serverOffer(frame) {
-        const peer = this.#peer;
-        // A pull offer that crosses this participant's add-track offer is for the
-        // live session: it is answered once the add-track answer is applied.
-        if (peer && this.#addTrackPending) {
-            this.#deferredOffer = frame;
-            return;
-        }
-        // A pull offer that arrives while this participant's restart offer is
-        // unanswered was sent for the replaced session: the room clears those
-        // pulls on restart and pulls again after the new session connects.
-        if (!peer || peer.signalingState === "have-local-offer")
-            return;
-        // `video` m-lines are answered receive-only; `#remoteTrack` decodes them
-        // when the engine has video.
-        await peer.setRemoteDescription(frame.session_description);
-        const answer = await peer.createAnswer();
-        await peer.setLocalDescription(answer);
-        if (this.#peer !== peer)
-            return;
-        this.#room.send({ type: "answer", session_description: this.#localDescription(peer, "answer") });
-    }
-    #serverError(frame) {
-        this.#roomErrors.push(frame.message);
-        const error = new RelayCallTransportError(frame.message, frame.code);
-        this.#rejectReady(error);
-        this.#emit("error", error);
-    }
-    #connectionStateChanged(peer) {
-        const state = peer.connectionState;
-        if (state === "connected") {
-            this.#clearTimer("connect");
-            this.#clearTimer("disconnect");
-            if (this.#peerConnected)
-                return;
-            this.#peerConnected = true;
-            this.#failedAttempts = 0;
-            void this.#readSelectedPair(peer);
-            // The SFU will not pull a track that has carried no RTP, so the source
-            // sends silence from here on until it is closed.
-            this.#audioSource?.start?.();
-            try {
-                // Sent for every new session: the room re-pulls a restarted participant's
-                // tracks once it reports `connected` (PROTOCOL.md section 2).
-                this.#room.connected();
-                if (!this.#reportedConnected) {
-                    this.#reportedConnected = true;
-                    this.#resolveReady();
-                    this.#startStallGuard();
-                    this.#emit("connected");
-                }
-            }
-            catch (error) {
-                const parsed = error instanceof Error ? error : new Error(String(error));
-                this.#rejectReady(parsed);
-                this.#emit("error", parsed);
-            }
-        }
-        else if (state === "failed") {
-            this.#requestRestart("failed", peer);
-        }
-        else if (state === "disconnected") {
-            if (this.#disconnectTimer)
-                return;
-            this.#disconnectTimer = setTimeout(() => {
-                this.#disconnectTimer = undefined;
-                if (peer.connectionState !== "connected")
-                    this.#requestRestart("disconnected", peer);
-            }, RESTART_DISCONNECTED_MS);
-            this.#disconnectTimer.unref?.();
-        }
-    }
-    #armConnectTimer(peer) {
-        this.#clearTimer("connect");
-        this.#connectTimer = setTimeout(() => {
-            this.#connectTimer = undefined;
-            if (!this.#peerConnected)
-                this.#requestRestart("timeout", peer);
-        }, this.#sessionConnectTimeoutMs);
-        this.#connectTimer.unref?.();
-    }
-    #clearTimer(which) {
-        if (which === "connect") {
-            clearTimeout(this.#connectTimer);
-            this.#connectTimer = undefined;
-        }
-        else {
-            clearTimeout(this.#disconnectTimer);
-            this.#disconnectTimer = undefined;
-        }
-    }
-    #callActive() {
-        if (this.#closed || this.#ended)
-            return false;
-        return this.#callStatus === undefined || ACTIVE_CALL_STATUSES.has(this.#callStatus);
-    }
-    /**
-     * Retire `peer` now, wait the backoff, then publish from a new peer on a new
-     * session. Unlimited while the Call is ringing or in progress; stops on
-     * `ended`, a terminal status, or `close()`.
-     */
-    #requestRestart(reason, peer) {
-        if (this.#restartPending || peer !== this.#peer || !this.#callActive())
-            return;
-        const summary = this.diagnostics().summary;
-        this.#restartPending = true;
-        this.#restarts += 1;
-        this.#failedAttempts += 1;
-        const restarts = this.#restarts;
-        const delayMs = restartDelayMs(this.#failedAttempts);
-        this.#retirePeer();
-        this.#queueNegotiation(async () => {
-            await this.#restartBackoff(delayMs);
-            this.#restartPending = false;
-            if (!this.#callActive())
-                return;
-            try {
-                await this.#startPeer();
-            }
-            catch (error) {
-                if (!this.#callActive())
-                    return;
-                const parsed = error instanceof Error ? error : new Error(String(error));
-                this.#emit("error", new RelayCallTransportError(`Relay WebRTC restart ${restarts} failed: ${parsed.message}`, "restart_failed"));
-                this.#requestRestart("error", this.#peer);
-                return;
-            }
-            if (this.#peer)
-                this.#emit("restarted", { reason, summary, restarts, delayMs });
-        });
-    }
-    #restartBackoff(milliseconds) {
-        return new Promise((resolve) => {
-            const wake = () => {
-                clearTimeout(timer);
-                if (this.#wakeRestart === wake)
-                    this.#wakeRestart = undefined;
-                resolve();
-            };
-            const timer = setTimeout(wake, milliseconds);
-            timer.unref?.();
-            this.#wakeRestart = wake;
-        });
-    }
-    /** Close the current peer and its sink; the audio source and local track stay for the next peer. */
-    #retirePeer() {
-        this.#clearTimer("connect");
-        this.#clearTimer("disconnect");
-        const peer = this.#peer;
-        this.#peer = undefined;
-        this.#peerConnected = false;
-        this.#publishTransceiver = undefined;
-        this.#videoTransceiver = undefined;
-        this.#initialAnswerSdp = undefined;
-        this.#lastAnswerSdp = undefined;
-        this.#addTrackPending = false;
-        this.#deferredOffer = undefined;
-        this.#remoteVideoTrack?._detach();
-        this.#remoteVideoEngineTrack = undefined;
-        if (this.#remoteSink) {
-            this.#retiredSinkStats = this.#sinkStats();
-            this.#remoteSink.stop();
-            this.#remoteSink = undefined;
-            this.#remoteSinkTrack = undefined;
-        }
-        if (!peer)
-            return;
-        peer.onconnectionstatechange = null;
-        peer.ontrack = null;
-        peer.onicecandidate = null;
-        peer.onicegatheringstatechange = null;
-        peer.oniceconnectionstatechange = null;
-        closePeer(peer);
-    }
-    /**
-     * werift fires `ontrack` again for every sending m-line on each
-     * `setRemoteDescription` (transceiverManager.js `setRemoteRTP`), so a pull
-     * offer that adds the person's video re-announces the audio track already
-     * decoded. That track keeps its sink, decoder and packet counts; a different
-     * audio track retires the old sink's counts into the call totals, as a restart does.
-     */
-    #remoteTrack(track, transceiver) {
-        if (track.kind === "video") {
-            this.#subscribeRemoteVideo(track, transceiver);
-            return;
-        }
-        if (track.kind !== "audio" || !this.#factory)
-            return;
-        if (this.#remoteSink && this.#remoteSinkTrack === track)
-            return;
-        if (this.#remoteSink) {
-            this.#retiredSinkStats = this.#sinkStats();
-            this.#remoteSink.stop();
-        }
-        const sink = this.#factory.createAudioSink(track, this.#inboundAudio);
-        this.#remoteSink = sink;
-        this.#remoteSinkTrack = track;
-        sink.ondata = (data) => {
-            if (this.#closed || this.#remoteSink !== sink)
-                return;
-            const channelCount = data.channelCount ?? 1;
-            if (data.bitsPerSample !== undefined && data.bitsPerSample !== 16) {
-                this.#emit("error", new RelayCallTransportError(`Relay WebRTC delivered unsupported ${data.bitsPerSample}-bit audio.`));
-                return;
-            }
-            this.#inboundFrames += 1;
-            this.#emit("audio", {
-                samples: cloneSamples(data.samples),
-                sampleRate: data.sampleRate,
-                channelCount,
-            });
-            if (!this.#peerAudioArrived) {
-                this.#peerAudioArrived = true;
-                this.#checkPeerAudio();
-            }
-        };
-    }
-    /**
-     * One `RemoteVideoTrack` per call; each new session's receiver is attached
-     * to it. werift fires `ontrack` again for every sending m-line on each
-     * `setRemoteDescription` (transceiverManager.js `setRemoteRTP`), so the
-     * track already being decoded keeps its receiver.
-     */
-    #subscribeRemoteVideo(track, transceiver) {
-        const factory = this.#factory;
-        if (!factory?.createVideoReceiver || this.#closed)
-            return;
-        if (this.#remoteVideoEngineTrack === track)
-            return;
-        this.#remoteVideoEngineTrack = track;
-        const receiver = factory.createVideoReceiver(track, transceiver);
-        const existing = this.#remoteVideoTrack;
-        const remote = existing ?? new RemoteVideoTrack();
-        this.#remoteVideoTrack = remote;
-        remote._attach(receiver);
-        if (!existing)
-            this.#emit("trackSubscribed", remote);
-    }
-    #writeAudio(frame, generation) {
-        const source = this.#audioSource;
-        if (!source || generation !== this.#audioGeneration)
-            return;
-        const samplesPerChannel = (frame.sampleRate * AUDIO_SLICE_MS) / 1000;
-        const sliceSamples = samplesPerChannel * frame.channelCount;
-        for (let offset = 0; offset < frame.samples.length; offset += sliceSamples) {
-            if (this.#closed || generation !== this.#audioGeneration)
-                return;
-            const remaining = Math.min(sliceSamples, frame.samples.length - offset);
-            const samples = new Int16Array(sliceSamples);
-            samples.set(frame.samples.subarray(offset, offset + remaining));
-            source.onData({
-                samples,
-                sampleRate: frame.sampleRate,
-                bitsPerSample: 16,
-                channelCount: frame.channelCount,
-                numberOfFrames: samplesPerChannel,
-            });
-            this.#outboundFrames += 1;
-        }
-    }
-    #releasePlayoutWaiters() {
-        for (const release of [...this.#playoutWaiters])
-            release();
-    }
-    /**
-     * Resolves once the offer is applied and has a first local candidate, or
-     * once `setLocalDescription` resolves (W3C engines resolve before gathering),
-     * whichever comes first.
-     */
-    async #applyLocalOffer(peer, offer) {
-        const applied = peer.setLocalDescription(offer);
-        let settled = false;
-        applied.catch((error) => {
-            if (!settled || this.#peer !== peer)
-                return;
-            const parsed = error instanceof Error ? error : new Error(String(error));
-            this.#rejectReady(parsed);
-            this.#emit("error", parsed);
-        });
-        try {
-            await new Promise((resolve, reject) => {
-                const timeout = setTimeout(() => {
-                    cleanup();
-                    reject(new RelayCallTransportError("Timed out gathering Relay WebRTC ICE candidates."));
-                }, this.#iceGatheringTimeoutMs);
-                timeout.unref?.();
-                const cleanup = () => {
-                    clearTimeout(timeout);
-                    if (this.#firstLocalCandidate === done)
-                        this.#firstLocalCandidate = undefined;
-                };
-                const done = () => {
-                    cleanup();
-                    resolve();
-                };
-                this.#firstLocalCandidate = done;
-                applied.then(done, (error) => {
-                    cleanup();
-                    reject(error);
-                });
-            });
-        }
-        finally {
-            settled = true;
-        }
-    }
-    /**
-     * werift emits these as W3C-style handler calls (peerConnection.js:314-341:
-     * `onicegatheringstatechange`, `oniceconnectionstatechange`,
-     * `onconnectionstatechange`, `onicecandidate` with `{ candidate }`).
-     */
-    #observeIce(peer) {
-        peer.onicecandidate = (event) => {
-            const line = event?.candidate?.candidate;
-            if (!line)
-                return;
-            const type = parseCandidate(line)?.type;
-            if (type === "host" || type === "srflx" || type === "relay")
-                this.#iceLocal[type] += 1;
-            else
-                this.#iceLocal.other += 1;
-            if (this.#peer === peer && peer.localDescription)
-                this.#firstLocalCandidate?.();
-        };
-        peer.onicegatheringstatechange = () => this.#recordTransition("gathering", peer.iceGatheringState);
-        peer.oniceconnectionstatechange = () => {
-            if (peer.iceConnectionState !== undefined)
-                this.#recordTransition("ice", peer.iceConnectionState);
-        };
-    }
-    /**
-     * W3C stats path: `transport.selectedCandidatePairId` -> `candidate-pair`
-     * -> `local-candidate.candidateType` (werift transport/dtls.js and
-     * transport/ice.js `getStats`); a nominated, succeeded pair when the
-     * transport names none.
-     */
-    async #readSelectedPair(peer) {
-        let report;
-        try {
-            report = await peer.getStats?.();
-        }
-        catch {
-            return;
-        }
-        if (!report || this.#peer !== peer)
-            return;
-        const stats = new Map();
-        report.forEach((stat) => stats.set(String(stat.id), stat));
-        const all = [...stats.values()];
-        const selectedId = all.find((stat) => stat.type === "transport" && stat.selectedCandidatePairId)
-            ?.selectedCandidatePairId;
-        const pair = selectedId !== undefined
-            ? stats.get(String(selectedId))
-            : all.find((stat) => stat.type === "candidate-pair" && stat.nominated === true && stat.state === "succeeded");
-        const local = pair ? stats.get(String(pair.localCandidateId)) : undefined;
-        if (typeof local?.candidateType !== "string")
-            return;
-        this.#selectedPair = `${local.candidateType} ${typeof local.protocol === "string" ? local.protocol : "?"}`;
-    }
-    #recordTransition(kind, state) {
-        this.#iceTransitions.push({ kind, state, atMs: Date.now() - this.#connectStartedAt });
-    }
-    #recordRemoteCandidates(sdp) {
-        for (const line of sdp.split(/\r?\n/)) {
-            if (!line.startsWith("a=candidate:"))
-                continue;
-            const parsed = parseCandidate(line);
-            if (parsed)
-                this.#iceRemote.push({ transport: parsed.transport, port: parsed.port });
-        }
-    }
-    #resolveReady() {
-        if (this.#readySettled)
-            return;
-        this.#readySettled = true;
-        this.#readyResolve?.();
-    }
-    #rejectReady(error) {
-        if (this.#readySettled)
-            return;
-        this.#readySettled = true;
-        this.#readyReject?.(error);
-    }
-    #localDescription(peer, type) {
-        const local = peer.localDescription;
-        if (!local || local.type !== type || !local.sdp) {
-            throw new RelayCallTransportError(`Relay WebRTC did not produce a complete ${type} SDP.`);
-        }
-        return { type, sdp: local.sdp };
-    }
-    #shutdownMedia() {
-        this.#stopStallGuard();
-        this.#clearTimer("connect");
-        this.#clearTimer("disconnect");
-        this.#wakeRestart?.();
-        this.#finalSinkStats ??= this.#sinkStats();
-        this.#finalSourceStats ??= this.#audioSource?.stats?.();
-        this.#remoteSink?.stop();
-        this.#remoteSink = undefined;
-        this.#remoteSinkTrack = undefined;
-        this.#localTrack?.stop();
-        this.#localTrack = undefined;
-        if (this.#video) {
-            this.#video.detach();
-            this.#video.sender.close();
-        }
-        const remoteVideo = this.#remoteVideoTrack;
-        if (remoteVideo) {
-            remoteVideo._end();
-            this.#emit("trackUnsubscribed", remoteVideo);
-        }
-        if (this.#peer)
-            closePeer(this.#peer);
-        this.#peer = undefined;
-        this.#audioSource = undefined;
-    }
-    #emit(event, ...args) {
-        for (const listener of this.#listeners.get(event) ?? []) {
-            try {
-                listener(...args);
-            }
-            catch { /* adapters own listener failures */ }
-        }
-    }
-}
-//# sourceMappingURL=transport.js.map