@relaymessenger/livekit 0.1.0-staging.3 → 0.1.0-staging.30

package/dist/transport.js

@@ -1,705 +0,0 @@
-const DEFAULT_ICE_GATHERING_TIMEOUT_MS = 10_000;
-const DEFAULT_CONNECTION_TIMEOUT_MS = 15_000;
-const AUDIO_SLICE_MS = 10;
-const STALL_CHECK_MS = 500;
-const STALL_AFTER_MS = 2_000;
-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" };
-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}` : "");
-    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, `
-    + `${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)}`;
-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.
- */
-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;
-    }
-}
-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.
- */
-export class RelayCallTransport {
-    #room;
-    #providedFactory;
-    #engine;
-    #iceGatheringTimeoutMs;
-    #connectionTimeoutMs;
-    #peerConfig;
-    #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;
-    #stallTimer;
-    #stallSince;
-    #stallWarned = false;
-    #iceLocal = { host: 0, srflx: 0, relay: 0, other: 0 };
-    #iceRemote = [];
-    #iceTransitions = [];
-    #listeners = new Map();
-    #factory;
-    #peer;
-    #audioSource;
-    #localTrack;
-    #remoteSink;
-    #publishTransceiver;
-    #publishFrame;
-    #initialAnswerSdp;
-    #negotiationTail = Promise.resolve();
-    #audioGeneration = 0;
-    /** `waitForPlayout()` callers released early by `clearAudio()` or `close()`. */
-    #playoutWaiters = new Set();
-    #reportedConnected = false;
-    #readySettled = false;
-    #readyResolve;
-    #readyReject;
-    #ready;
-    #handlersAttached = false;
-    #closed = false;
-    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".');
-        }
-        this.#iceGatheringTimeoutMs = options.iceGatheringTimeoutMs ?? DEFAULT_ICE_GATHERING_TIMEOUT_MS;
-        this.#connectionTimeoutMs = options.mediaConnectTimeoutMs
-            ?? options.connectionTimeoutMs
-            ?? DEFAULT_CONNECTION_TIMEOUT_MS;
-        const policy = options.iceTransportPolicy ?? "all";
-        if (policy !== "all" && policy !== "relay") {
-            throw new Error('iceTransportPolicy must be "all" or "relay".');
-        }
-        this.#peerConfig = {
-            iceServers: (options.iceServers ?? []).map((server) => ({
-                urls: Array.isArray(server.urls) ? [...server.urls] : server.urls,
-                ...(server.username === undefined ? {} : { username: server.username }),
-                ...(server.credential === undefined ? {} : { credential: server.credential }),
-            })),
-            iceTransportPolicy: policy,
-        };
-        if (!Number.isFinite(this.#iceGatheringTimeoutMs) || this.#iceGatheringTimeoutMs <= 0) {
-            throw new Error("iceGatheringTimeoutMs must be greater than zero.");
-        }
-        if (!Number.isFinite(this.#connectionTimeoutMs) || this.#connectionTimeoutMs <= 0) {
-            throw new Error("mediaConnectTimeoutMs 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;
-    }
-    async connect() {
-        if (this.#closed)
-            throw new Error("Relay Call transport is closed.");
-        this.#attachRoomHandlers();
-        await this.#room.connect();
-        if (this.#peer) {
-            await this.#waitForConnection();
-            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();
-        const peer = this.#factory.createPeerConnection(this.#peerConfig);
-        this.#peer = peer;
-        this.#publishTransceiver = peer.addTransceiver(this.#localTrack, { direction: "sendonly" });
-        this.#observeIce(peer);
-        peer.onconnectionstatechange = () => {
-            this.#recordTransition("connection", peer.connectionState);
-            this.#connectionStateChanged();
-        };
-        peer.ontrack = (event) => this.#remoteTrack(event.track);
-        try {
-            await this.#publishLocalAudio();
-            await this.#waitForConnection();
-        }
-        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 and
-     * room frame counts 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 })),
-            connected: this.#reportedConnected,
-            inbound: this.#inboundDiagnostics(),
-            outbound: this.#outboundDiagnostics(),
-            room: {
-                roomStates: this.#roomStates,
-                offers: this.#roomOffers,
-                endedReason: this.#endedReason,
-                errors: [...this.#roomErrors],
-            },
-        };
-        return { ...snapshot, summary: summarize(snapshot) };
-    }
-    #sinceConnect(epochMs) {
-        return epochMs === undefined ? undefined : epochMs - this.#connectStartedAt;
-    }
-    #inboundDiagnostics() {
-        const stats = this.#remoteSink?.stats?.() ?? this.#finalSinkStats;
-        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,
-            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();
-    }
-    setMuted(muted) {
-        this.#room.userUpdate({ muted });
-    }
-    end() {
-        this.#room.end();
-    }
-    close() {
-        if (this.#closed)
-            return;
-        this.#closed = true;
-        this.#rejectReady(new RelayCallTransportError("Relay Call transport closed before media connected."));
-        this.#audioGeneration += 1;
-        this.#shutdownMedia();
-        this.#releasePlayoutWaiters();
-        this.#room.close();
-    }
-    async #publishLocalAudio() {
-        const peer = this.#requirePeer();
-        const offer = await peer.createOffer();
-        await peer.setLocalDescription(offer);
-        await this.#waitForIceGathering(peer);
-        const description = this.#localDescription("offer");
-        const mid = this.#publishTransceiver?.mid;
-        if (!mid)
-            throw new RelayCallTransportError("Relay audio publication has no WebRTC MID.");
-        this.#publishFrame = {
-            type: "offer",
-            session_description: description,
-            tracks: [{ mid, name: "audio" }],
-        };
-        this.#room.send(this.#publishFrame);
-    }
-    #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.#emit("roomState", frame);
-        });
-        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.#endedReason = frame.reason;
-            this.#rejectReady(new RelayCallTransportError(`Relay Call ended before media connected (${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) {
-        const peer = this.#requirePeer();
-        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)
-            return;
-        if (this.#initialAnswerSdp === undefined)
-            this.#recordRemoteCandidates(sdp);
-        await peer.setRemoteDescription(frame.session_description);
-        this.#initialAnswerSdp ??= sdp;
-    }
-    async #serverOffer(frame) {
-        const peer = this.#requirePeer();
-        await peer.setRemoteDescription(frame.session_description);
-        const answer = await peer.createAnswer();
-        await peer.setLocalDescription(answer);
-        await this.#waitForIceGathering(peer);
-        this.#room.send({ type: "answer", session_description: this.#localDescription("answer") });
-    }
-    #serverError(frame) {
-        this.#roomErrors.push(frame.message);
-        const error = new RelayCallTransportError(frame.message, frame.code);
-        this.#rejectReady(error);
-        this.#emit("error", error);
-    }
-    #connectionStateChanged() {
-        const state = this.#peer?.connectionState;
-        if (state === "connected" && !this.#reportedConnected) {
-            this.#reportedConnected = true;
-            try {
-                this.#room.connected();
-                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") {
-            const error = new RelayCallTransportError("Relay WebRTC connection failed.");
-            this.#rejectReady(error);
-            this.#emit("error", error);
-        }
-    }
-    #remoteTrack(track) {
-        if (track.kind !== "audio" || !this.#factory)
-            return;
-        this.#remoteSink?.stop();
-        const sink = this.#factory.createAudioSink(track);
-        this.#remoteSink = sink;
-        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,
-            });
-        };
-    }
-    #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();
-    }
-    async #waitForIceGathering(peer) {
-        if (peer.iceGatheringState === "complete")
-            return;
-        await new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                cleanup();
-                reject(new RelayCallTransportError("Timed out gathering Relay WebRTC ICE candidates."));
-            }, this.#iceGatheringTimeoutMs);
-            timeout.unref?.();
-            const changed = () => {
-                if (peer.iceGatheringState !== "complete")
-                    return;
-                cleanup();
-                resolve();
-            };
-            const cleanup = () => {
-                clearTimeout(timeout);
-                peer.removeEventListener("icegatheringstatechange", changed);
-            };
-            peer.addEventListener("icegatheringstatechange", changed);
-            changed();
-        });
-    }
-    async #waitForConnection() {
-        if (this.#reportedConnected)
-            return;
-        await new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                reject(new RelayCallTransportError(`Timed out connecting Relay WebRTC media (${this.diagnostics().summary})`));
-            }, this.#connectionTimeoutMs);
-            timeout.unref?.();
-            this.#ready.then(() => {
-                clearTimeout(timeout);
-                resolve();
-            }, (error) => {
-                clearTimeout(timeout);
-                reject(error);
-            });
-        });
-    }
-    /**
-     * 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;
-        };
-        peer.onicegatheringstatechange = () => this.#recordTransition("gathering", peer.iceGatheringState);
-        peer.oniceconnectionstatechange = () => {
-            if (peer.iceConnectionState !== undefined)
-                this.#recordTransition("ice", peer.iceConnectionState);
-        };
-    }
-    #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(type) {
-        const local = this.#requirePeer().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 };
-    }
-    #requirePeer() {
-        if (!this.#peer)
-            throw new Error("Relay Call transport is not connected.");
-        return this.#peer;
-    }
-    #shutdownMedia() {
-        this.#stopStallGuard();
-        this.#finalSinkStats ??= this.#remoteSink?.stats?.();
-        this.#finalSourceStats ??= this.#audioSource?.stats?.();
-        this.#remoteSink?.stop();
-        this.#remoteSink = undefined;
-        this.#localTrack?.stop();
-        this.#localTrack = undefined;
-        this.#peer?.close();
-        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