@relaymessenger/livekit 0.1.0-staging.4 → 0.1.0-staging.6

package/dist/transport.js

@@ -5,10 +5,32 @@ export const DEFAULT_INBOUND_AUDIO = Object.freeze({
 });
 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 DEFAULT_CONNECTION_TIMEOUT_MS = 15_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) {
@@ -83,7 +105,13 @@ const summarizeRoom = (room) => {
     return `room: ${parts.join(", ")}`;
 };
 const summarize = (diagnostics) => `${summarizeIce(diagnostics)}; ${summarizeInbound(diagnostics.inbound)}; `
-    + `${summarizeOutbound(diagnostics.outbound)}; ${summarizeRoom(diagnostics.room)}`;
+    + `${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);
@@ -129,6 +157,13 @@ class WrtcAudioSource {
         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?.();
@@ -137,15 +172,19 @@ const delay = (milliseconds) => new Promise((resolve) => {
  * 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.
+ * 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;
-    #connectionTimeoutMs;
-    #peerConfig;
+    #sessionConnectTimeoutMs;
+    #iceServers;
+    #iceTransportPolicy;
     #inboundAudio;
     #onWarning;
     #connectStartedAt = 0;
@@ -158,6 +197,8 @@ export class RelayCallTransport {
     /** 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;
@@ -167,6 +208,10 @@ export class RelayCallTransport {
     #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;
     #remoteSink;
@@ -174,6 +219,20 @@ export class RelayCallTransport {
     #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();
@@ -210,26 +269,22 @@ export class RelayCallTransport {
         }
         this.#inboundAudio = { sampleRate: inbound.sampleRate, channelCount: inbound.channelCount };
         this.#iceGatheringTimeoutMs = options.iceGatheringTimeoutMs ?? DEFAULT_ICE_GATHERING_TIMEOUT_MS;
-        this.#connectionTimeoutMs = options.mediaConnectTimeoutMs
+        this.#sessionConnectTimeoutMs = options.sessionConnectTimeoutMs
+            ?? options.mediaConnectTimeoutMs
             ?? options.connectionTimeoutMs
-            ?? DEFAULT_CONNECTION_TIMEOUT_MS;
+            ?? RESTART_CONNECT_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,
-        };
+        this.#iceTransportPolicy = policy;
+        const iceServers = options.iceServers ?? [];
+        this.#iceServers = 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.#connectionTimeoutMs) || this.#connectionTimeoutMs <= 0) {
-            throw new Error("mediaConnectTimeoutMs 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;
@@ -250,13 +305,37 @@ export class RelayCallTransport {
         this.#listeners.get(event)?.delete(listener);
         return this;
     }
-    async connect() {
+    /**
+     * 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.#peer) {
-            await this.#waitForConnection();
+        if (this.#factory) {
+            await this.#ready;
             return;
         }
         this.#factory = this.#providedFactory ?? await loadWebRTCFactory(this.#engine);
@@ -266,18 +345,9 @@ export class RelayCallTransport {
             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();
+            await this.#startPeer();
+            await this.#ready;
         }
         catch (error) {
             this.close();
@@ -294,15 +364,15 @@ export class RelayCallTransport {
         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.
+     * 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 })),
-            connected: this.#reportedConnected,
+            connected: this.#peerConnected,
             inbound: this.#inboundDiagnostics(),
             outbound: this.#outboundDiagnostics(),
             room: {
@@ -311,14 +381,31 @@ export class RelayCallTransport {
                 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.#remoteSink?.stats?.() ?? this.#finalSinkStats;
+        const stats = this.#finalSinkStats ?? this.#sinkStats();
         return {
             rtpPackets: stats?.rtpPackets ?? 0,
             decodeFailures: stats?.decodeFailures ?? 0,
@@ -431,6 +518,41 @@ export class RelayCallTransport {
         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.#room.userUpdate({ muted });
     }
@@ -442,17 +564,54 @@ export class RelayCallTransport {
             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.#room.close();
     }
-    async #publishLocalAudio() {
-        const peer = this.#requirePeer();
+    /**
+     * 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 = 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.#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);
+        };
+        await this.#publishLocalAudio(peer, restarts > 0);
+    }
+    async #publishLocalAudio(peer, restart) {
         const offer = await peer.createOffer();
         await peer.setLocalDescription(offer);
         await this.#waitForIceGathering(peer);
-        const description = this.#localDescription("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.");
@@ -460,6 +619,7 @@ export class RelayCallTransport {
             type: "offer",
             session_description: description,
             tracks: [{ mid, name: "audio" }],
+            ...(restart ? { restart: true } : {}),
         };
         this.#room.send(this.#publishFrame);
     }
@@ -476,7 +636,18 @@ export class RelayCallTransport {
         });
         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) {
@@ -487,8 +658,10 @@ export class RelayCallTransport {
                 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);
@@ -509,25 +682,42 @@ export class RelayCallTransport {
         });
     }
     async #serverAnswer(frame) {
-        const peer = this.#requirePeer();
+        // 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)
             return;
-        if (this.#initialAnswerSdp === undefined)
+        const initial = this.#initialAnswerSdp === undefined;
+        if (initial)
             this.#recordRemoteCandidates(sdp);
         await peer.setRemoteDescription(frame.session_description);
+        if (this.#peer !== peer)
+            return;
         this.#initialAnswerSdp ??= sdp;
+        if (initial && !this.#peerConnected)
+            this.#armConnectTimer(peer);
     }
     async #serverOffer(frame) {
-        const peer = this.#requirePeer();
+        const peer = this.#peer;
+        // 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 by the engine and never decoded
+        // (`#remoteTrack` takes audio only).
         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") });
+        if (this.#peer !== peer)
+            return;
+        this.#room.send({ type: "answer", session_description: this.#localDescription(peer, "answer") });
     }
     #serverError(frame) {
         this.#roomErrors.push(frame.message);
@@ -535,15 +725,25 @@ export class RelayCallTransport {
         this.#rejectReady(error);
         this.#emit("error", error);
     }
-    #connectionStateChanged() {
-        const state = this.#peer?.connectionState;
-        if (state === "connected" && !this.#reportedConnected) {
-            this.#reportedConnected = true;
+    #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;
             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();
-                this.#resolveReady();
-                this.#startStallGuard();
-                this.#emit("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));
@@ -552,10 +752,113 @@ export class RelayCallTransport {
             }
         }
         else if (state === "failed") {
-            const error = new RelayCallTransportError("Relay WebRTC connection failed.");
-            this.#rejectReady(error);
-            this.#emit("error", error);
+            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.#initialAnswerSdp = undefined;
+        if (this.#remoteSink) {
+            this.#retiredSinkStats = this.#sinkStats();
+            this.#remoteSink.stop();
+            this.#remoteSink = undefined;
+        }
+        if (!peer)
+            return;
+        peer.onconnectionstatechange = null;
+        peer.ontrack = null;
+        peer.onicecandidate = null;
+        peer.onicegatheringstatechange = null;
+        peer.oniceconnectionstatechange = null;
+        closePeer(peer);
     }
     #remoteTrack(track) {
         if (track.kind !== "audio" || !this.#factory)
@@ -577,6 +880,10 @@ export class RelayCallTransport {
                 sampleRate: data.sampleRate,
                 channelCount,
             });
+            if (!this.#peerAudioArrived) {
+                this.#peerAudioArrived = true;
+                this.#checkPeerAudio();
+            }
         };
     }
     #writeAudio(frame, generation) {
@@ -628,23 +935,6 @@ export class RelayCallTransport {
             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`,
@@ -691,27 +981,26 @@ export class RelayCallTransport {
         this.#readySettled = true;
         this.#readyReject?.(error);
     }
-    #localDescription(type) {
-        const local = this.#requirePeer().localDescription;
+    #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 };
     }
-    #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.#clearTimer("connect");
+        this.#clearTimer("disconnect");
+        this.#wakeRestart?.();
+        this.#finalSinkStats ??= this.#sinkStats();
         this.#finalSourceStats ??= this.#audioSource?.stats?.();
         this.#remoteSink?.stop();
         this.#remoteSink = undefined;
         this.#localTrack?.stop();
         this.#localTrack = undefined;
-        this.#peer?.close();
+        if (this.#peer)
+            closePeer(this.#peer);
         this.#peer = undefined;
         this.#audioSource = undefined;
     }