@q9labsai/chalk-client 5.2.6 → 5.3.0

package/README.md

@@ -77,7 +77,7 @@ unsubscribe();
 `SpaceSnapshot` contains these slices:
 
 - `connection`: status, live Episode summary, and the latest failure
-- `self`: local Participant identity, role, capabilities, hand state, and `can(capability)`
+- `self`: local Participant and verified person Identity, role, capabilities, hand state, and `can(capability)`
 - `participants`: roster and admission queue
 - `media`: device selection, local and remote media, screen share, and requests
 - `chat`: messages, pending sends, read receipts, unread count, and pagination

package/dist/{chunk-YIDKETOX.js → chunk-3TGVTP6Z.js}

@@ -1,3 +1,145 @@
+// src/media/receive-stall.ts
+var RECEIVE_STALL_WINDOW_MS = 7e3;
+var RECEIVE_STARTUP_GRACE_MS = 2e4;
+var MAX_SAMPLE_GAP_MS = 3e3;
+var ReceiveStallDetector = class {
+  #progress = /* @__PURE__ */ new Map();
+  #sampledAt;
+  forget(publicationId) {
+    this.#progress.delete(publicationId);
+  }
+  clear() {
+    this.#progress.clear();
+    this.#sampledAt = void 0;
+  }
+  sample(now, tracks) {
+    if (this.#sampledAt !== void 0 && (now - this.#sampledAt > MAX_SAMPLE_GAP_MS || now < this.#sampledAt)) this.clear();
+    this.#sampledAt = now;
+    const observed = new Set(tracks.map((track) => track.publicationId));
+    for (const id of this.#progress.keys()) if (!observed.has(id)) this.#progress.delete(id);
+    const observations = tracks.map((track) => ({ id: track.publicationId, outcome: this.#observeTrack(now, track) }));
+    return {
+      stalled: observations.filter((track) => track.outcome === "stalled").map((track) => track.id),
+      resumed: observations.filter((track) => track.outcome === "resumed").map((track) => track.id),
+      advanced: observations.filter((track) => track.outcome === "advanced" || track.outcome === "resumed").map((track) => track.id)
+    };
+  }
+  #observeTrack(now, { publicationId, trackId, packets }) {
+    const previous = this.#progress.get(publicationId);
+    const sameTrack = previous?.trackId === trackId;
+    if (sameTrack && previous.packets === packets) {
+      const window = previous.flowing ? RECEIVE_STALL_WINDOW_MS : RECEIVE_STARTUP_GRACE_MS;
+      return now - previous.advancedAt >= window ? "stalled" : null;
+    }
+    return this.#advanceTrack(now, { publicationId, trackId, packets }, previous);
+  }
+  #advanceTrack(now, { publicationId, trackId, packets }, previous) {
+    const advanced = previous?.trackId === trackId && packets > previous.packets;
+    const flowingSince = advanced && now - previous.advancedAt < RECEIVE_STALL_WINDOW_MS ? previous.flowingSince : now;
+    this.#progress.set(publicationId, { trackId, packets, advancedAt: now, flowing: advanced, flowingSince });
+    if (!advanced) return null;
+    return now - flowingSince >= RECEIVE_STALL_WINDOW_MS ? "resumed" : "advanced";
+  }
+};
+var MAX_RECEIVE_REBUILDS = 2;
+var MAX_RECEIVE_OBSERVATIONS = 32;
+var ReceiveStallRecovery = class {
+  #detector = new ReceiveStallDetector();
+  #attempts = /* @__PURE__ */ new Map();
+  #identities = /* @__PURE__ */ new Map();
+  #expected = /* @__PURE__ */ new Set();
+  #screens = /* @__PURE__ */ new Set();
+  #stalled = /* @__PURE__ */ new Set();
+  #active = [];
+  #observations = Object.freeze([]);
+  get observations() {
+    return this.#observations;
+  }
+  expect(publications, participantId) {
+    const enabled = publications.filter((publication) => publication.participantId !== participantId && publication.enabled);
+    this.#expected = new Set(enabled.flatMap((publication) => publication.publicationId ? [publication.publicationId] : []));
+    this.#screens = new Set(enabled.filter((publication) => publication.source === "screen").map((publication) => publication.participantId));
+    this.#pruneWithdrawn(publications);
+    for (const publication of this.#identities.values()) {
+      if (this.#isExpected(publication)) continue;
+      this.#detector.forget(publication.publicationId);
+      this.#stalled.delete(publication.publicationId);
+    }
+    this.#active = [...this.#identities.values()].filter((publication) => this.#isExpected(publication)).map((publication) => publication.publicationId);
+  }
+  suspend() {
+    this.#expected.clear();
+    this.#screens.clear();
+    this.clear();
+  }
+  #pruneWithdrawn(publications) {
+    const advertised = new Set(publications.map((publication) => publication.publicationId));
+    const screens = new Set(publications.filter((publication) => publication.source === "screen").map((publication) => publication.participantId));
+    for (const [key, publication] of this.#identities) {
+      if (advertised.has(publication.publicationId) || publication.source === "screen_audio" && screens.has(publication.participantId)) continue;
+      this.#forget(publication.publicationId);
+      this.#identities.delete(key);
+    }
+  }
+  isStalled(publicationId) {
+    return this.#stalled.has(publicationId);
+  }
+  canRebuild() {
+    return this.#active.length > 0 && this.#active.every((id) => this.#stalled.has(id) && (this.#attempts.get(id) ?? 0) < MAX_RECEIVE_REBUILDS);
+  }
+  reserveRebuild() {
+    if (!this.canRebuild()) return false;
+    for (const id of this.#active) this.#attempts.set(id, (this.#attempts.get(id) ?? 0) + 1);
+    return true;
+  }
+  clear() {
+    this.#detector.clear();
+    this.#stalled.clear();
+    this.#active = [];
+  }
+  sample(now, connection, report, tracks) {
+    const active = [...tracks].filter((publication) => this.#isExpected(publication));
+    for (const publication of active) this.#rememberIdentity(publication);
+    this.#active = active.map((publication) => publication.publicationId);
+    const samples = active.flatMap((publication) => receivePacketSample(connection, report, publication) ?? []);
+    const { stalled, advanced, resumed } = this.#detector.sample(now, samples);
+    for (const id of resumed) this.#attempts.delete(id);
+    const newlyStalled = stalled.filter((id) => !this.#stalled.has(id));
+    this.#stalled = new Set(stalled);
+    if (newlyStalled.length) this.#record(now);
+    return { stalled, advanced, newlyStalled };
+  }
+  #isExpected(publication) {
+    return publication.source === "screen_audio" ? this.#screens.has(publication.participantId) : this.#expected.has(publication.publicationId);
+  }
+  #rememberIdentity(publication) {
+    const key = `${publication.participantId}\0${publication.source}`;
+    const previous = this.#identities.get(key);
+    if (previous && previous.publicationId !== publication.publicationId) this.#forget(previous.publicationId);
+    this.#identities.set(key, publication);
+  }
+  #forget(id) {
+    this.#detector.forget(id);
+    this.#stalled.delete(id);
+    this.#attempts.delete(id);
+  }
+  #record(now) {
+    const observation = Object.freeze({ event: "receive_stalled", scope: this.#active.every((id) => this.#stalled.has(id)) ? "all" : "partial", observedAtMs: now, expectedTracks: this.#active.length, stalledTracks: this.#stalled.size });
+    this.#observations = Object.freeze([...this.#observations.slice(-(MAX_RECEIVE_OBSERVATIONS - 1)), observation]);
+  }
+};
+function receivePacketSample(connection, report, publication) {
+  const rows = [...report.values()].filter((row) => row.type === "inbound-rtp" && row.trackIdentifier === publication.track.id);
+  if (rows.some((row) => !Number.isSafeInteger(row.packetsReceived) || row.packetsReceived < 0)) return;
+  if (publication.track.kind === "audio" && !audioPacketCadenceKnown(connection, report, publication.track, rows)) return;
+  return { publicationId: publication.publicationId, trackId: publication.track.id, packets: rows.reduce((sum, row) => sum + row.packetsReceived, 0) };
+}
+function audioPacketCadenceKnown(connection, report, track, rows) {
+  const negotiated = rows.length ? rows.map((row) => row.codecId ? report.get(row.codecId) : void 0) : connection.getReceivers().find((receiver) => receiver.track.id === track.id)?.getParameters().codecs ?? [];
+  const opus = negotiated.filter((codec) => codec?.mimeType?.toLowerCase() === "audio/opus");
+  return opus.length > 0 && opus.every((codec) => typeof codec.sdpFmtpLine === "string");
+}
+
 // src/media/camera-uplink.ts
 var CameraUplinkPolicy = class {
   #healthySamples = 0;
@@ -234,6 +376,7 @@ function classifyMediaFailure(cause, fallbackStep) {
 // src/media/client.ts
 var EMPTY_LOCAL = Object.freeze([]);
 var EMPTY_REMOTE = Object.freeze([]);
+var EMPTY_RECEIVE_STALLS = Object.freeze([]);
 var INVALID_PUBLICATION_SIGNATURE = "\0invalid";
 var CONNECTION_TIMEOUT_MS = 8e3;
 var NEGOTIATION_TIMEOUT_MS = 35e3;
@@ -265,6 +408,7 @@ var CloudflareSFUClient = class {
   #cursor = null;
   #remotePullIncomplete = false;
   #remotePullRetries = /* @__PURE__ */ new Map();
+  #receiveProgress = new ReceiveStallRecovery();
   #remoteParticipantIds = null;
   #remoteParticipantRevision = 0;
   #subscribedPublicationIds = /* @__PURE__ */ new Set();
@@ -281,6 +425,7 @@ var CloudflareSFUClient = class {
   #retirement = Promise.resolve();
   #snapshot;
   #started = false;
+  #receivingInitial = false;
   #stopped = false;
   #transport;
   constructor(options) {
@@ -300,6 +445,7 @@ var CloudflareSFUClient = class {
       cursor: null,
       localTracks: EMPTY_LOCAL,
       remoteTracks: EMPTY_REMOTE,
+      receiveStalls: this.#receiveProgress.observations,
       failure: null
     });
     this.#observeConnection(this.#connection, this.#generation, this.#connectionEpoch);
@@ -320,7 +466,9 @@ var CloudflareSFUClient = class {
     this.#remotePullIncomplete = true;
     this.remotePublicationsChanged();
   }
-  remotePublicationsChanged() {
+  remotePublicationsChanged(publications, projectionState = "available") {
+    if (projectionState === "unavailable") this.#receiveProgress.suspend();
+    else if (publications) this.#receiveProgress.expect(publications, this.#participantId);
     if (this.#polling) {
       this.#pollAfterCurrent = true;
       return;
@@ -385,20 +533,30 @@ var CloudflareSFUClient = class {
     this.#publishSnapshot();
     this.#emitLocal();
   }
-  async start(localMedia) {
+  async start(localMedia, beforePublish) {
     if (this.#started) return;
     this.#requireActive();
-    const tracks = localMedia.getTracks().filter((track) => track.kind === "audio" || track.kind === "video");
-    for (const track of tracks) this.prepareLocalTrack(track.kind === "audio" ? "microphone" : "camera", track);
     const generation = this.#generation;
     this.#setPhase("connecting", null);
+    if (beforePublish) {
+      this.#receivingInitial = true;
+      this.#schedulePoll(0);
+      try {
+        localMedia = await beforePublish();
+      } finally {
+        this.#receivingInitial = false;
+      }
+      if (generation !== this.#generation || this.#stopped) return;
+    }
+    const tracks = localMedia.getTracks().filter((track) => track.kind === "audio" || track.kind === "video");
+    for (const track of tracks) this.prepareLocalTrack(track.kind === "audio" ? "microphone" : "camera", track);
     await this.#activatePreparedTracks(
       [...this.#localTracks.values()].filter((state) => state.source === "microphone" || state.source === "camera"),
       generation
     );
   }
   async refreshRemotePublications() {
-    if (!this.#started || this.#stopped || this.#polling) return;
+    if (!this.#started && !this.#receivingInitial || this.#stopped || this.#polling) return;
     this.#polling = true;
     const generation = this.#generation;
     this.#pollFailedPull = false;
@@ -478,12 +636,34 @@ var CloudflareSFUClient = class {
     return enabled ? Promise.resolve() : this.#retireOwnedPublications();
   }
   async closeForcedLocalPublication(source, cause = "forced_pause") {
+    const connection = this.#connection;
+    const generationAtClose = this.#generation;
     const sources = localSourceGroup(source);
     const ownsPublication = [...this.#ownedPublications].some((item) => sources.includes(item.state.source));
-    await this.setLocalSourceIntent(source, false, cause);
-    if (!ownsPublication || !this.#replaceMediaConnection) return;
+    const canRecover = ownsPublication && this.#replaceMediaConnection !== void 0;
+    let failedRetirement;
+    try {
+      await this.setLocalSourceIntent(source, false, cause);
+    } catch (error) {
+      if (!canRecover) throw error;
+      failedRetirement = this.#fenceFailedClose(error, connection, generationAtClose, cause);
+      if (!failedRetirement) return;
+    }
+    if (!canRecover) return;
+    await this.#restoreEnabledSourcesAfterClose(source);
+    if (this.#retirement !== failedRetirement) await this.#retirement;
+  }
+  #fenceFailedClose(error, connection, generation, cause) {
+    const failures = error instanceof AggregateError ? error.errors : [error];
+    if (!failures.every((failure) => this.#isRetryableConnectionFailure(failure))) throw error;
+    if (connection !== this.#connection || generation !== this.#generation) return;
+    this.#retiredLocalConnection = connection;
+    this.#retiredLocalCause = cause;
+    return this.#retirement;
+  }
+  #restoreEnabledSourcesAfterClose(source) {
     const generation = this.#generation;
-    await this.#serializeSDP(async () => {
+    return this.#serializeSDP(async () => {
       const existing = new Set([...this.#localTracks.values()].filter((state) => state.source !== source && state.providerPublicationId !== null));
       const states = await this.#prepareConnectionForPublication([], generation);
       await this.#publishPreparedTracksSerialized(
@@ -495,7 +675,6 @@ var CloudflareSFUClient = class {
       this.#requireGeneration(generation);
       this.#setPhase("live", null);
     });
-    await this.#retirement;
   }
   async #retireUnavailableLocalPublication(state) {
     const publicationId = state.providerPublicationId;
@@ -641,6 +820,7 @@ var CloudflareSFUClient = class {
       return;
     }
     this.#stopped = true;
+    this.#receiveProgress.expect([], this.#participantId);
     this.#subscribedPublicationIds.clear();
     this.#generation++;
     this.#connectionEpoch++;
@@ -901,9 +1081,8 @@ var CloudflareSFUClient = class {
     if (cursor === null) return;
     const participantRevision = this.#remoteParticipantRevision;
     const desired = this.#desiredRemotePublications(authoritative, cursor);
-    const toPull = this.#pendingRemotePulls(desired);
     this.#pollFailedPull = true;
-    const pulled = await this.#pullWithRecovery(toPull, cursor, generation);
+    const pulled = await this.#pullWithRecovery(desired, cursor, generation);
     if (pulled === null) return;
     this.#requireGeneration(generation);
     const next = reconcileRemoteTracks(desired, pulled, this.#remoteTracks);
@@ -931,7 +1110,9 @@ var CloudflareSFUClient = class {
     }
     const now = Date.now();
     return [...desired].filter(([key, publication]) => {
-      if (this.#remoteTracks.get(key)?.publicationId === publication.publicationId) return false;
+      if (this.#remoteTracks.get(key)?.publicationId === publication.publicationId) {
+        if (!this.#receiveProgress.canRebuild() || !this.#replaceMediaConnection) return false;
+      }
       const remaining = (this.#remotePullRetries.get(publication.publicationId)?.retryAfter ?? 0) - now;
       return remaining <= 0;
     }).map(([, publication]) => publication);
@@ -960,7 +1141,14 @@ var CloudflareSFUClient = class {
   #canSubscribeToRemotePublication(publication) {
     return this.#remoteParticipantIds === null || this.#remoteParticipantIds.has(publication.participantId) || this.#subscribedPublicationIds.has(publication.publicationId);
   }
-  async #pullWithRecovery(publications, cursor, generation) {
+  async #pullWithRecovery(desired, cursor, generation) {
+    const pending = this.#pendingRemotePulls(desired);
+    const receiveStalled = pending.some((publication) => this.#receiveProgress.isStalled(publication.publicationId));
+    const publications = receiveStalled ? [...desired.values()] : pending;
+    if (receiveStalled) {
+      if (!this.#replaceMediaConnection || !this.#receiveProgress.reserveRebuild()) return [];
+      return this.#retryRemotePullOnReplacement(publications, cursor, generation, "receive_stalled");
+    }
     try {
       return await this.#pull(publications, generation);
     } catch (error) {
@@ -979,14 +1167,19 @@ var CloudflareSFUClient = class {
   #hasLiveRemoteTracks() {
     return [...this.#remoteTracks.values()].some((publication) => publication.track.readyState === "live");
   }
-  async #retryRemotePullOnReplacement(publications, cursor, generation) {
+  async #retryRemotePullOnReplacement(publications, cursor, generation, cause = "remote_signaling_failure") {
     this.#remoteRecoveryGeneration = generation;
+    const connection = this.#connection;
     try {
-      await this.#replaceMediaConnectionForRecovery(generation, "remote_signaling_failure");
+      await this.#replaceMediaConnectionForRecovery(generation, cause);
       await this.#republishPreparedTracksAfterRecovery(generation);
       return await this.#pull(publications, generation);
     } catch (error) {
       if (generation !== this.#generation || this.#stopped) throw error;
+      if (cause === "receive_stalled" && connection === this.#connection) {
+        this.#replacementAttemptedGeneration = null;
+        for (const publication of publications) this.#backoffRemotePull(publication.publicationId, true);
+      }
       this.#observeRemotePublicationCursor(cursor, retryableRemotePull(error));
       throw error;
     }
@@ -1029,7 +1222,7 @@ var CloudflareSFUClient = class {
     const retryAfter = retryableRemotePull(error) ? Date.now() + 15e3 : Number.POSITIVE_INFINITY;
     for (const publication of publications) {
       const failures = this.#remotePullRetries.get(publication.publicationId)?.failures ?? 0;
-      this.#remotePullRetries.set(publication.publicationId, { retryAfter, failures });
+      this.#remotePullRetries.set(publication.publicationId, { retryAfter, failures, receiveStalled: this.#remotePullRetries.get(publication.publicationId)?.receiveStalled });
     }
   }
   async #pullBatch(publications, generation) {
@@ -1056,12 +1249,17 @@ var CloudflareSFUClient = class {
       connection.addEventListener("track", onTrack);
       try {
         this.#requireGeneration(generation);
-        const response = await this.#signal(() => this.#addTracks({ connectionId, tracks: requested, allowPartialRemoteTracks: true }), { generation, connectionId });
+        const response = await this.#signal(() => this.#addTracks({ connectionId, tracks: requested, allowPartialRemoteTracks: true }), {
+          generation,
+          connectionId
+        });
         this.#requireGeneration(generation);
         this.#recordRemotePullErrors(publications, response.trackErrors ?? []);
         const responseTracks = response.tracks ?? [];
         const matched = matchRemotePullTracks(publications, responseTracks);
-        for (const { publication } of matched) this.#remotePullRetries.delete(publication.publicationId);
+        for (const { publication } of matched) {
+          if (!this.#remotePullRetries.get(publication.publicationId)?.receiveStalled) this.#remotePullRetries.delete(publication.publicationId);
+        }
         await this.#completeRenegotiation(response, connection, connectionId, generation);
         if (matched.length === 0) return [];
         await this.#waitForConnection(connection, generation);
@@ -1091,13 +1289,33 @@ var CloudflareSFUClient = class {
     for (const failure of failures) {
       const publication = requested.get(`${failure.connectionId}\0${failure.trackName}`);
       if (!publication) throw new CloudflareSFUError("Cloudflare SFU returned an unrequested remote track error", "invalid_publication");
-      const previous = this.#remotePullRetries.get(publication.publicationId) ?? { retryAfter: 0, failures: 0 };
-      const failureCount = Math.min(previous.failures + 1, 6);
-      const delay = Math.min(15e3, 750 * 2 ** (failureCount - 1));
-      this.#remotePullRetries.set(publication.publicationId, { retryAfter: Date.now() + delay, failures: failureCount });
+      this.#backoffRemotePull(publication.publicationId);
       this.#reportError(new CloudflareSFUError(`Cloudflare SFU remote track failed: ${failure.code}`, "media_failed", { providerCode: failure.code }));
     }
   }
+  #backoffRemotePull(publicationId, receiveStalled = false) {
+    const previous = this.#remotePullRetries.get(publicationId) ?? { retryAfter: 0, failures: 0 };
+    const failures = Math.min(previous.failures + 1, 6);
+    this.#remotePullRetries.set(publicationId, { retryAfter: Date.now() + Math.min(15e3, 750 * 2 ** (failures - 1)), failures, receiveStalled: receiveStalled || previous.receiveStalled });
+  }
+  #canObserveReceiveProgress(connection) {
+    return this.#started && connectionIsLive(connection) && (typeof document === "undefined" || document.visibilityState !== "hidden");
+  }
+  #observeReceiveProgress(connection, report) {
+    if (!this.#canObserveReceiveProgress(connection)) {
+      this.#receiveProgress.clear();
+      return;
+    }
+    const { stalled, advanced } = this.#receiveProgress.sample(performance.now(), connection, report, this.#remoteTracks.values());
+    for (const publicationId of advanced) this.#remotePullRetries.delete(publicationId);
+    this.#publishSnapshot();
+    if (!this.#receiveProgress.canRebuild()) return;
+    for (const publicationId of stalled) {
+      if (!this.#remotePullRetries.get(publicationId)?.receiveStalled) this.#backoffRemotePull(publicationId, true);
+    }
+    this.#remotePullIncomplete = true;
+    this.remotePublicationsChanged();
+  }
   async #completeRenegotiation(response, connection, connectionId, generation) {
     if (!response.requiresImmediateRenegotiation) return;
     await this.#applyProviderDescription(response, connection);
@@ -1203,14 +1421,12 @@ var CloudflareSFUClient = class {
           cameraPolicy.reset();
           observedCamera = state;
         }
-        const sender = this.#cameraSimulcastSender(state);
-        if (!sender) {
-          cameraPolicy.reset();
-          return;
-        }
         const report = await connection.getStats();
-        if (!current() || this.#cameraSimulcastSender(state) !== sender || connection.signalingState !== "stable") return;
-        await this.#applyCameraUplink(sender, report, cameraPolicy);
+        if (!current() || connection.signalingState !== "stable") return;
+        this.#observeReceiveProgress(connection, report);
+        const sender = this.#cameraSimulcastSender(state);
+        if (!sender) cameraPolicy.reset();
+        else await this.#applyCameraUplink(sender, report, cameraPolicy);
       } catch {
         cameraPolicy.reset();
       } finally {
@@ -1312,6 +1528,7 @@ var CloudflareSFUClient = class {
     }
   }
   #disposeConnection(stopSenders) {
+    this.#receiveProgress.clear();
     if (!stopSenders) this.#setPhase("recovering", null);
     this.#disposeConnectionObservation?.();
     this.#disposeConnectionObservation = void 0;
@@ -1349,7 +1566,7 @@ var CloudflareSFUClient = class {
     this.#emitRemote();
   }
   #schedulePoll(delayMs = this.#pollIntervalMs) {
-    if (this.#stopped || !this.#started || this.#pollTimer !== void 0) return;
+    if (this.#stopped || !this.#started && !this.#receivingInitial || this.#pollTimer !== void 0) return;
     this.#pollTimer = globalThis.setTimeout(async () => {
       this.#pollTimer = void 0;
       if (typeof document !== "undefined" && document.visibilityState === "hidden") {
@@ -1408,6 +1625,7 @@ var CloudflareSFUClient = class {
         })
       ) : EMPTY_LOCAL,
       remoteTracks: this.#remoteTracks.size ? [...this.#remoteTracks.values()] : EMPTY_REMOTE,
+      receiveStalls: this.#receiveProgress.observations,
       failure
     });
     if (snapshotEqual(this.#snapshot, next)) return;
@@ -1532,7 +1750,7 @@ function snapshotEqual(left, right) {
   return snapshotMetadataEqual(left, right) && left.localTracks.every((publication, index) => publicationEqual(publication, right.localTracks[index])) && left.remoteTracks.every((publication, index) => remotePublicationEqual(publication, right.remoteTracks[index]));
 }
 function snapshotMetadataEqual(left, right) {
-  return connectionEqual(left.connection, right.connection) && cursorEqual(left.cursor, right.cursor) && failureEqual(left.failure, right.failure) && left.localTracks.length === right.localTracks.length && left.remoteTracks.length === right.remoteTracks.length;
+  return (left.receiveStalls ?? EMPTY_RECEIVE_STALLS) === (right.receiveStalls ?? EMPTY_RECEIVE_STALLS) && connectionEqual(left.connection, right.connection) && cursorEqual(left.cursor, right.cursor) && failureEqual(left.failure, right.failure) && left.localTracks.length === right.localTracks.length && left.remoteTracks.length === right.remoteTracks.length;
 }
 function connectionEqual(left, right) {
   return left.phase === right.phase && left.peerConnectionState === right.peerConnectionState && left.iceConnectionState === right.iceConnectionState;