@q9labsai/chalk-client 5.3.1 → 5.4.0

package/dist/{chunk-2CEMOTZF.js → chunk-TA2BJXI7.js}

@@ -10,7 +10,7 @@ import {
   describeMediaCaptureError,
   grantedMediaFromStream,
   markMediaFailure
-} from "./chunk-O5JB5XVX.js";
+} from "./chunk-UVWRTXNO.js";
 import {
   ChatAttachmentMimeTypeSchema,
   ChatReactionSetFrameSchema,
@@ -24,7 +24,7 @@ import {
   formatSyncConnectDiagnostic,
   scheduleSyncDialDeadline,
   syncConnectFailureCode
-} from "./chunk-FD7ZSDTM.js";
+} from "./chunk-XF567GPH.js";
 import {
   withRequestContext
 } from "./chunk-N4IPKRS6.js";
@@ -2712,6 +2712,7 @@ function bindConnectionMediaClient(client, restart) {
     ...client.remoteParticipantsChanged ? { remoteParticipantsChanged: client.remoteParticipantsChanged.bind(client) } : {},
     ...client.remotePublicationsChanged ? { remotePublicationsChanged: client.remotePublicationsChanged.bind(client) } : {},
     ...client.remotePublicationResumed ? { remotePublicationResumed: client.remotePublicationResumed.bind(client) } : {},
+    ...client.localPublicationWithdrawn ? { localPublicationWithdrawn: client.localPublicationWithdrawn.bind(client) } : {},
     start: client.start.bind(client),
     stop: client.stop.bind(client),
     restart,
@@ -5051,7 +5052,10 @@ var MediaControllerRuntime = class {
   #sources = { microphone: sourceWorker(true), camera: sourceWorker(true), screen: sourceWorker(false) };
   #syncLive = false;
   #disposed = false;
+  /** The wanted-on sources when recovery began, with the intent revision each one had then. */
   #recovering = null;
+  /** The Sync client's last proof of contact when the current recovery began: where its drop is measured from. */
+  #proof = null;
   #pendingSources = /* @__PURE__ */ new Map();
   #pendingCaptures = /* @__PURE__ */ new Set();
   #readinessChecks = /* @__PURE__ */ new Set();
@@ -5537,7 +5541,10 @@ var MediaControllerRuntime = class {
     return state.desired.enabled && state.forcedRevision !== state.desired.revision;
   }
   #resetObservations() {
-    if (this.#connection.getSnapshot().state !== "reconnecting") this.#recovering = null;
+    if (this.#connection.getSnapshot().state !== "reconnecting") {
+      this.#recovering = null;
+      this.#proof = null;
+    }
     for (const source of MEDIA_SOURCES) {
       const state = this.#sources[source];
       state.result = { revision: state.desired.revision, status: "confirmed" };
@@ -5629,7 +5636,7 @@ var MediaControllerRuntime = class {
     if (!resumed) return;
     if (this.#ports) {
       const snapshot = this.#ports.sync.getSnapshot();
-      this.#pauseRecoveredIntents(this.#ports, snapshot);
+      this.#applyRecoveryRule(this.#ports, snapshot);
       this.#oweOffsSyncStillShows(snapshot);
     }
     this.#resumePendingActions();
@@ -6149,16 +6156,59 @@ var MediaControllerRuntime = class {
   #rememberRecoveryIntents() {
     for (const state of Object.values(this.#sources)) if (state.capturePause === "announced") state.capturePause = "pending";
     if (!this.#ports) return;
+    if (this.#recovering === null) this.#proof = this.#ports.sync.link?.proof() ?? null;
     this.#recovering ??= new Map(MEDIA_SOURCES.filter((source) => this.#sources[source].desired.enabled).map((source) => [source, this.#sources[source].desired.revision]));
   }
-  #pauseRecoveredIntents(ports, snapshot) {
-    const recovering = this.#recovering;
+  /**
+   * The rule depends on what the connected Sync advertised. Sync's snapshot items carry `off_reason` only when its welcome said
+   * `media_off_reason`, and only then can recovery tell a host stop from a publication that is merely missing. Without it the rule
+   * is the one this SDK had before: a wanted-on source whose own item is missing or not enabled is paused (#597).
+   */
+  #applyRecoveryRule(ports, snapshot) {
+    const recovering = this.#recovering ?? /* @__PURE__ */ new Map();
+    const proof = this.#proof;
     this.#recovering = null;
-    for (const [source, revision] of recovering ?? []) {
-      const current = snapshot.media?.items.find((item) => item.participantId === snapshot.participantId && item.source === source);
-      if (!current?.enabled) this.#pausePublication(ports, source, revision, "sync_recovery_loss");
+    this.#proof = null;
+    if (ports.sync.offReasonNegotiated?.() === true) this.#pauseOnEvidence(ports, snapshot, recovering, ports.sync.link?.longSince(proof) ?? true);
+    else this.#pauseWhenSyncLostIt(ports, snapshot, recovering);
+  }
+  #pauseWhenSyncLostIt(ports, snapshot, recovering) {
+    for (const [source, revision] of recovering) {
+      if (!ownProjection(snapshot, source)?.enabled) this.#pausePublication(ports, source, revision, "sync_recovery_loss");
     }
   }
+  /**
+   * A wanted-on source is paused when Sync's item says the host stopped it after the user's intent (`off_reason: "host"` with a newer
+   * `off_revision`; a replayed stop event reaches `#subscribePauses` the same way). This holds for every source that is wanted on when
+   * the snapshot arrives, including one the user turned on after recovery began, and for every source recovery began with. With no such
+   * evidence the drop decides, whatever Sync lists: the source stays wanted-on after a drop proven short and turns off, like a tap, after
+   * any other. The drop cutoff applies only to the intent the source had when recovery began (`recovering`), so a newer intent from the
+   * user is left alone.
+   */
+  #pauseOnEvidence(ports, snapshot, recovering, longDrop) {
+    for (const source of MEDIA_SOURCES) {
+      const intentRevision = recovering.get(source);
+      if (intentRevision === void 0 && !this.#sources[source].desired.enabled) continue;
+      const item = ownProjection(snapshot, source);
+      const stopRevision = this.#hostStopNewerThanIntent(source, item);
+      if (stopRevision !== null) this.#pauseForHostStop(ports, source, stopRevision);
+      else if (longDrop && intentRevision !== void 0 && this.#sources[source].desired.revision === intentRevision) this.#turnOffLikeATap(source);
+    }
+  }
+  #hostStopNewerThanIntent(source, item) {
+    if (item?.offReason !== "host" || item.offRevision === void 0) return null;
+    return item.offRevision > this.#sources[source].desired.controlRevision ? item.offRevision : null;
+  }
+  #pauseForHostStop(ports, source, stopRevision) {
+    const state = this.#sources[source];
+    state.serverSequence = Math.max(state.serverSequence, stopRevision);
+    this.#pausePublication(ports, source, state.desired.revision, "moderation_pause");
+  }
+  // The intent becomes off exactly as a tap makes it, so the UI shows it off and the user can tap to turn it on.
+  #turnOffLikeATap(source) {
+    this.#recordIntent(source, false);
+    this.#sources[source].offDebt = "owed";
+  }
   #subscribeSync(ports) {
     return ports.sync.subscribe((snapshot) => {
       this.#removeRequestsFromMissingParticipants(snapshot);

package/dist/{chunk-O5JB5XVX.js → chunk-UVWRTXNO.js}

@@ -837,6 +837,8 @@ var EMPTY_REMOTE = Object.freeze([]);
 var EMPTY_RECEIVE_STALLS = Object.freeze([]);
 var INVALID_PUBLICATION_SIGNATURE = "\0invalid";
 var CONNECTION_TIMEOUT_MS = 8e3;
+var RECOVERY_BACKOFF_MS = [1e3, 2e3, 4e3, 5e3];
+var RECOVERY_HEALTHY_RESET_MS = 1e4;
 var NEGOTIATION_TIMEOUT_MS = 35e3;
 var PEER_OPERATION_TIMEOUT_MS = 8e3;
 var VIEWER_LAYER_BATCH_SIZE = 16;
@@ -857,6 +859,8 @@ var CloudflareSFUClient = class {
   #locallyPausedSources = /* @__PURE__ */ new Map();
   #localTracks = /* @__PURE__ */ new Map();
   #ownedPublications = /* @__PURE__ */ new Set();
+  #localRecoveries = /* @__PURE__ */ new Map();
+  #recentRecoveries = /* @__PURE__ */ new Map();
   #remoteTracks = /* @__PURE__ */ new Map();
   #bootstrap;
   #connection;
@@ -865,6 +869,7 @@ var CloudflareSFUClient = class {
   #retiredLocalConnection = null;
   #retiredLocalCause = "forced_pause";
   #replacementCause;
+  #replacement = null;
   #cursor = null;
   #remotePullIncomplete = false;
   #remotePullRetries = /* @__PURE__ */ new Map();
@@ -924,6 +929,12 @@ var CloudflareSFUClient = class {
     this.#remotePullRetries.delete(publicationId);
     this.remotePublicationsChanged();
   }
+  localPublicationWithdrawn(publicationId) {
+    const owned = [...this.#ownedPublications].find((publication) => publication.lifecycle.kind === "confirmed" && publication.lifecycle.handle.publicationId === publicationId && publication.state.providerPublicationId === publicationId);
+    const state = owned?.state;
+    if (!state || !state.desiredEnabled || this.#localTracks.get(state.source) !== state) return;
+    this.#beginLocalRecovery(state, publicationId, false);
+  }
   remoteParticipantsChanged(participantIds) {
     this.#remoteParticipantIds = new Set(participantIds);
     this.#remoteParticipantRevision++;
@@ -961,11 +972,13 @@ var CloudflareSFUClient = class {
       };
       track.addEventListener("ended", state.endedListener);
     }
+    this.#dropLocalRecovery(source);
     this.#localTracks.set(source, state);
     this.#publishSnapshot();
     this.#emitLocal();
   }
   async clearPreparedLocalTrack(source, options = {}) {
+    this.#dropLocalRecovery(source);
     const state = this.#localTracks.get(source);
     if (!state) return;
     if (state.clearing) return state.clearing;
@@ -978,6 +991,7 @@ var CloudflareSFUClient = class {
   }
   async #clearPreparedTrack(state, stopTrack = true) {
     const source = state.source;
+    this.#dropLocalRecovery(source);
     if (source === "screen" || source === "screen_audio") {
       try {
         this.#pauseLocalSource(source, "capture_cleanup");
@@ -1028,6 +1042,7 @@ var CloudflareSFUClient = class {
       const transport = this.#requireTransport();
       const authoritative = await this.#signal(() => transport.listPublications());
       this.#requireGeneration(generation);
+      this.#republishUnlistedLocalPublications(authoritative);
       await this.#reconcileRemotePublications(authoritative, generation);
       this.#requireGeneration(generation);
       if (!this.#remotePullIncomplete) this.#pollFailures = 0;
@@ -1038,6 +1053,161 @@ var CloudflareSFUClient = class {
       this.#finishPublicationPoll(generation);
     }
   }
+  // The registry drops a publication when listeners keep failing to pull it.
+  // A publisher that still believes it is sending must publish again, so
+  // listeners get a new publication ID instead of retrying a dead one.
+  #republishUnlistedLocalPublications(authoritative) {
+    const unlisted = [...this.#localTracks.values()].filter((state) => state.enabled && state.desiredEnabled && state.providerPublicationId !== null && !authoritative.publications.some((publication) => publication.publicationId === state.providerPublicationId));
+    for (const state of unlisted) this.#beginLocalRecovery(state, state.providerPublicationId, true);
+  }
+  #beginLocalRecovery(state, deadPublicationId, relist) {
+    if (!this.#canBeginLocalRecovery(state)) return;
+    const now = Date.now();
+    const delayMs = this.#recoveryStartDelay(state.source, now);
+    const recovery = { state, deadPublicationId, relist, retiring: false, attempt: 0, timer: void 0, running: false };
+    this.#localRecoveries.set(state.source, recovery);
+    this.#scheduleLocalRecovery(recovery, delayMs);
+  }
+  #canBeginLocalRecovery(state) {
+    return state.enabled && state.desiredEnabled && !this.#stopped && !this.#locallyPausedSources.has(state.source) && !this.#localRecoveries.has(state.source);
+  }
+  #recoveryStartDelay(source, now) {
+    const recent = this.#recentRecoveries.get(source);
+    if (!recent || now - recent.healthySince >= RECOVERY_HEALTHY_RESET_MS) {
+      this.#recentRecoveries.set(source, { count: 0, healthySince: now });
+      return 0;
+    }
+    this.#recentRecoveries.set(source, { count: recent.count + 1, healthySince: now });
+    return recoveryBackoffMs(recent.count);
+  }
+  #scheduleLocalRecovery(recovery, delayMs) {
+    recovery.timer = globalThis.setTimeout(() => {
+      recovery.timer = void 0;
+      if (this.#localRecoveries.get(recovery.state.source) !== recovery) return;
+      void this.#runLocalRecovery(recovery.state.source);
+    }, delayMs);
+  }
+  #canRecover(recovery) {
+    return this.#localRecoveries.get(recovery.state.source) === recovery && !this.#stopped && !this.#locallyPausedSources.has(recovery.state.source) && this.#localTracks.get(recovery.state.source) === recovery.state;
+  }
+  async #runLocalRecovery(source) {
+    const recovery = this.#localRecoveries.get(source);
+    if (!recovery || recovery.running || this.#discardUnrecoverableIntent(recovery)) return;
+    recovery.running = true;
+    try {
+      await this.#attemptLocalRecovery(recovery);
+    } catch (error) {
+      await this.#retryLocalRecovery(recovery, error);
+    } finally {
+      recovery.running = false;
+    }
+  }
+  async #attemptLocalRecovery(recovery) {
+    if (!await this.#relistLocalRecoveryIfNeeded(recovery) || !this.#canContinueLocalRecovery(recovery)) {
+      this.#dropLocalRecovery(recovery.state.source, recovery);
+      return;
+    }
+    this.#retireDeadLocalPublication(recovery);
+    if (await this.#retireLocalRecoveryIfNeeded(recovery)) return;
+    const published = await this.#enablePreparedTrack(recovery.state);
+    if (this.#discardUnrecoverableIntent(recovery)) return;
+    if (!this.#settleLocalRecovery(recovery, published)) this.#scheduleLocalRecoveryRetry(recovery);
+  }
+  async #relistLocalRecoveryIfNeeded(recovery) {
+    const { state, deadPublicationId } = recovery;
+    if (!recovery.relist || deadPublicationId === null) return true;
+    const authoritative = await this.#signal(() => this.#requireTransport().listPublications());
+    if (!this.#canRecover(recovery) || state.providerPublicationId !== deadPublicationId || !state.desiredEnabled) return false;
+    if (authoritative.publications.some((publication) => publication.publicationId === deadPublicationId)) {
+      this.#dropLocalRecovery(state.source, recovery);
+      return false;
+    }
+    recovery.relist = false;
+    return true;
+  }
+  #canContinueLocalRecovery(recovery) {
+    if (!this.#canRecover(recovery) || recovery.retiring) return this.#canRecover(recovery);
+    if (recovery.deadPublicationId !== null && recovery.state.providerPublicationId !== recovery.deadPublicationId) return false;
+    return recovery.state.desiredEnabled;
+  }
+  #retireDeadLocalPublication(recovery) {
+    if (recovery.retiring || recovery.deadPublicationId === null || recovery.state.providerPublicationId !== recovery.deadPublicationId) return;
+    recovery.retiring = true;
+    this.#pauseLocalSource(recovery.state.source, "discovery_absent", { group: false });
+  }
+  async #retireLocalRecoveryIfNeeded(recovery) {
+    if (!this.#hasRetiringLocalPublications(recovery.state.source)) return false;
+    await this.#retireLocalRecoveryPublications(recovery.state.source);
+    return this.#discardUnrecoverableIntent(recovery);
+  }
+  async #retryLocalRecovery(recovery, error) {
+    if (this.#discardUnrecoverableIntent(recovery)) return;
+    this.#reportLocalRecoveryError(error);
+    await this.#replaceConnectionForLocalRecovery(error);
+    this.#scheduleLocalRecoveryRetry(recovery);
+  }
+  #discardUnrecoverableIntent(recovery) {
+    if (this.#canRecover(recovery)) return false;
+    this.#dropLocalRecovery(recovery.state.source, recovery);
+    return true;
+  }
+  #settleLocalRecovery(recovery, published) {
+    const source = recovery.state.source;
+    if (!published && this.#locallyPausedSources.has(source)) {
+      this.#dropLocalRecovery(source, recovery);
+      return true;
+    }
+    const publicationId = recovery.state.providerPublicationId;
+    if (!published || publicationId === null || publicationId === recovery.deadPublicationId) return false;
+    const recent = this.#recentRecoveries.get(source);
+    if (recent) this.#recentRecoveries.set(source, { ...recent, healthySince: Date.now() });
+    this.#dropLocalRecovery(source, recovery);
+    return true;
+  }
+  #reportLocalRecoveryError(error) {
+    if (error instanceof AggregateError) {
+      for (const cause of error.errors) this.#reportError(cause);
+      return;
+    }
+    this.#reportError(error);
+  }
+  async #replaceConnectionForLocalRecovery(error) {
+    const failures = error instanceof AggregateError ? error.errors : [error];
+    if (!this.#replaceMediaConnection || failures.length === 0 || !failures.every((failure) => this.#isRetryableConnectionFailure(failure))) return;
+    const generation = this.#generation;
+    try {
+      await this.#replaceMediaConnectionForRecovery(generation, "local_signaling_failure");
+    } catch {
+      return;
+    }
+    try {
+      await this.#republishPreparedTracksAfterRecovery(generation);
+    } catch (republishError) {
+      this.#reportLocalRecoveryError(republishError);
+    }
+  }
+  #scheduleLocalRecoveryRetry(recovery) {
+    if (!this.#canRecover(recovery)) {
+      this.#dropLocalRecovery(recovery.state.source, recovery);
+      return;
+    }
+    this.#scheduleLocalRecovery(recovery, recoveryBackoffMs(recovery.attempt++));
+  }
+  #hasRetiringLocalPublications(source) {
+    return [...this.#ownedPublications].some((publication) => publication.state.source === source && publication.lifecycle.kind === "retiring" && publication.lifecycle.handle !== null);
+  }
+  #retireLocalRecoveryPublications(source) {
+    return this.#retireOwnedPublications(() => {
+    }, { sources: [source], goneIsComplete: true });
+  }
+  #dropLocalRecovery(source, expected) {
+    for (const item of localSourceGroup(source)) {
+      const recovery = this.#localRecoveries.get(item);
+      if (!recovery || expected && recovery !== expected) continue;
+      if (recovery.timer !== void 0) globalThis.clearTimeout(recovery.timer);
+      this.#localRecoveries.delete(item);
+    }
+  }
   #finishPublicationPoll(generation) {
     if (generation !== this.#generation) return;
     this.#polling = false;
@@ -1053,9 +1223,11 @@ var CloudflareSFUClient = class {
     return this.#enablePublicationTarget({ ...target, source: "screen_audio" });
   }
   async #pausePublicationTarget(target) {
+    this.#dropLocalRecovery(target.source);
     const resolved = resolveMediaTarget(this.#participantId, this.#stopped, this.#localTracks, target);
     if (resolved.kind === "result" && resolved.result.outcome !== "satisfied") return resolved.result;
     const outcome = resolved.kind === "state" && resolved.value.enabled ? "confirmed" : "satisfied";
+    this.#dropLocalRecovery(target.source);
     if (target.source !== "screen" && this.#locallyPausedSources.get(target.source) === "capture_cleanup") {
       await this.pauseLocalCapture(target.source);
       return { outcome, errorCode: null };
@@ -1068,6 +1240,25 @@ var CloudflareSFUClient = class {
       return mediaTargetFailure(error);
     }
   }
+  async #waitForReplacementBeforeEnable(state, generation, replacement) {
+    if (replacement?.generation !== generation) return null;
+    state.desiredEnabled = true;
+    await replacement.promise.catch(() => {
+    });
+    if (this.#locallyPausedSources.has(state.source)) return { outcome: "terminal_failure", errorCode: "local_source_paused" };
+    if (!state.desiredEnabled) return { outcome: "satisfied", errorCode: null };
+    state.track.enabled = true;
+    return null;
+  }
+  #postReplacementEnableOutcome(state, generation, replacement) {
+    if (this.#locallyPausedSources.has(state.source)) return { outcome: "terminal_failure", errorCode: "local_source_paused" };
+    if (replacement?.generation === generation && !state.desiredEnabled) return { outcome: "satisfied", errorCode: null };
+    if (state.enabled) {
+      state.track.enabled = true;
+      return { outcome: "satisfied", errorCode: null };
+    }
+    return null;
+  }
   async #enablePublicationTarget(target) {
     const generation = this.#generation;
     const resolved = resolveMediaTarget(this.#participantId, this.#stopped, this.#localTracks, target);
@@ -1075,9 +1266,12 @@ var CloudflareSFUClient = class {
     const state = resolved.value;
     if (this.#locallyPausedSources.has(target.source)) return { outcome: "terminal_failure", errorCode: "local_source_paused" };
     try {
+      const replacement = this.#replacement;
+      const replacementOutcome = await this.#waitForReplacementBeforeEnable(state, generation, replacement);
+      if (replacementOutcome) return replacementOutcome;
       await this.#retireUnavailableLocalPublication(state);
-      if (this.#locallyPausedSources.has(target.source)) return { outcome: "terminal_failure", errorCode: "local_source_paused" };
-      if (state.enabled) return { outcome: "satisfied", errorCode: null };
+      const postReplacementOutcome = this.#postReplacementEnableOutcome(state, generation, replacement);
+      if (postReplacementOutcome) return postReplacementOutcome;
       if (!await this.#enablePreparedTrack(state)) return { outcome: "terminal_failure", errorCode: "local_source_paused" };
       return { outcome: "confirmed", errorCode: null };
     } catch (error) {
@@ -1086,12 +1280,14 @@ var CloudflareSFUClient = class {
     }
   }
   async pauseLocalCapture(source) {
+    this.#dropLocalRecovery(source);
     this.#locallyPausedSources.set(source, "capture_cleanup");
     const state = this.#localTracks.get(source);
     if (state) await this.#disablePreparedTrack(state);
   }
   setLocalSourceIntent(source, enabled, cause = "forced_pause") {
     const sources = localSourceGroup(source);
+    if (!enabled) this.#dropLocalRecovery(source);
     for (const item of sources) {
       if (enabled) this.#locallyPausedSources.delete(item);
       else this.#locallyPausedSources.set(item, cause);
@@ -1145,13 +1341,16 @@ var CloudflareSFUClient = class {
     if (!publicationId) return;
     const authoritative = await this.#signal(() => this.#requireTransport().listPublications());
     if (authoritative.publications.some((publication) => publication.publicationId === publicationId)) return;
-    if (state.providerPublicationId === publicationId) {
-      this.#pauseLocalSource(state.source, "discovery_absent");
-      await this.#retireOwnedPublications();
+    if (state.providerPublicationId !== publicationId || this.#localRecoveries.has(state.source)) return;
+    if (state.enabled && state.desiredEnabled) {
+      this.#beginLocalRecovery(state, publicationId, true);
+      return;
     }
+    this.#pauseLocalSource(state.source, "discovery_absent");
+    await this.#retireOwnedPublications(void 0, { goneIsComplete: true });
   }
-  #pauseLocalSource(source, cause = "forced_pause") {
-    const sources = localSourceGroup(source);
+  #pauseLocalSource(source, cause = "forced_pause", options = {}) {
+    const sources = options.group === false ? [source] : localSourceGroup(source);
     for (const publication of this.#ownedPublications) {
       if (!sources.includes(publication.state.source)) continue;
       this.#markPublicationRetiring(publication, cause);
@@ -1164,25 +1363,36 @@ var CloudflareSFUClient = class {
     this.#publishSnapshot();
     this.#emitLocal();
   }
-  #retireOwnedPublications(reportFailure = this.#reportError.bind(this)) {
-    const publications = [...this.#ownedPublications].filter((item) => item.lifecycle.kind === "retiring" && item.lifecycle.handle);
-    const retirement = (async () => {
-      const errors = [];
-      for (const publication of publications) {
-        try {
-          await this.#serializeSDP(() => this.#closeOwnedPublication(publication), true);
-        } catch (error) {
-          errors.push(error);
-          if (!this.#stopped) reportFailure(error);
-        }
-      }
-      if (this.#stopped && this.#ownedPublications.size === 0) this.#transport = void 0;
-      if (errors.length) throw new AggregateError(errors, "Media retirement failed");
-    })();
+  #retireOwnedPublications(reportFailure = this.#reportError.bind(this), options) {
+    const publications = this.#retiringOwnedPublications(options?.sources);
+    const retirement = this.#runOwnedRetirement(publications, reportFailure, options?.goneIsComplete === true);
     void retirement.catch(() => {
     });
     return this.#retirement = retirement;
   }
+  #retiringOwnedPublications(sources) {
+    return [...this.#ownedPublications].filter((item) => item.lifecycle.kind === "retiring" && item.lifecycle.handle && (!sources || sources.includes(item.state.source)));
+  }
+  async #runOwnedRetirement(publications, reportFailure, goneIsComplete) {
+    const errors = [];
+    for (const publication of publications) {
+      try {
+        await this.#serializeSDP(() => this.#closeOwnedPublication(publication), true);
+      } catch (error) {
+        if (goneIsComplete && this.#retireGonePublication(publication, error)) continue;
+        errors.push(error);
+        if (!this.#stopped) reportFailure(error);
+      }
+    }
+    if (this.#stopped && this.#ownedPublications.size === 0) this.#transport = void 0;
+    if (errors.length) throw new AggregateError(errors, "Media retirement failed");
+  }
+  #retireGonePublication(publication, error) {
+    if (!isGonePublicationFailure(error)) return false;
+    publication.lifecycle = { kind: "retired" };
+    this.#ownedPublications.delete(publication);
+    return true;
+  }
   #markPublicationRetiring(publication, cause = "publish_failure") {
     const phase = publication.lifecycle;
     if (phase.kind === "pending" || phase.kind === "confirmed") publication.lifecycle = { kind: "retiring", handle: phase.kind === "confirmed" ? phase.handle : null, detached: false, cause };
@@ -1287,6 +1497,8 @@ var CloudflareSFUClient = class {
     const transport = this.#transport;
     void this.#callStats.flush(async (stats2) => transport?.uploadCallStats?.(stats2, true));
     this.#receiveProgress.expect([], this.#participantId);
+    for (const source of [...this.#localRecoveries.keys()]) this.#dropLocalRecovery(source);
+    this.#recentRecoveries.clear();
     this.#subscribedPublicationIds.clear();
     this.#generation++;
     this.#connectionEpoch++;
@@ -2024,35 +2236,49 @@ var CloudflareSFUClient = class {
     this.#replacementCause = void 0;
     return this.#requireTransport().addTracks({ ...input, replacementCause });
   }
-  async #replaceMediaConnectionForRecovery(generation, cause) {
+  #replaceMediaConnectionForRecovery(generation, cause) {
     this.#requireGeneration(generation);
+    if (this.#replacement?.generation === generation) return this.#replacement.promise;
     if (!this.#replaceMediaConnection || this.#replacementAttemptedGeneration === generation) {
-      throw new CloudflareSFUError("A fresh Cloudflare SFU connection is unavailable", "signaling_failed");
+      return Promise.reject(new CloudflareSFUError("A fresh Cloudflare SFU connection is unavailable", "signaling_failed"));
     }
     this.#replacementAttemptedGeneration = generation;
     const replaceMediaConnection = this.#replaceMediaConnection;
-    const bootstrap = await replaceMediaConnection();
-    this.#requireGeneration(generation);
-    validateBootstrap(bootstrap);
-    if (bootstrap.connectionId === this.#bootstrap.connectionId) {
-      throw new CloudflareSFUError("Participant access did not replace the Cloudflare SFU connection", "signaling_failed");
-    }
-    this.#fenceLocalPublications();
-    const connectionEpoch = ++this.#connectionEpoch;
-    this.#disposeConnection(false);
-    this.#clearRemoteTracks();
-    this.#cursor = null;
-    this.#bootstrap = bootstrap;
-    this.#rebuildPeerConnection(bootstrap, generation, connectionEpoch);
-    this.#replacementCause = cause;
-    this.#retiredLocalConnection = null;
-    this.#negotiatedGeneration = null;
-    for (const state of this.#localTracks.values()) {
-      state.transceiver = null;
-      state.enabled = false;
-      state.providerPublicationId = null;
-    }
-    this.remotePublicationsChanged();
+    const promise = Promise.resolve().then(async () => {
+      const bootstrap = await replaceMediaConnection();
+      this.#requireGeneration(generation);
+      validateBootstrap(bootstrap);
+      if (bootstrap.connectionId === this.#bootstrap.connectionId) {
+        throw new CloudflareSFUError("Participant access did not replace the Cloudflare SFU connection", "signaling_failed");
+      }
+      this.#fenceLocalPublications();
+      const connectionEpoch = ++this.#connectionEpoch;
+      this.#disposeConnection(false);
+      this.#clearRemoteTracks();
+      this.#cursor = null;
+      this.#bootstrap = bootstrap;
+      this.#rebuildPeerConnection(bootstrap, generation, connectionEpoch);
+      this.#replacementCause = cause;
+      this.#retiredLocalConnection = null;
+      this.#negotiatedGeneration = null;
+      for (const state of this.#localTracks.values()) {
+        state.transceiver = null;
+        state.enabled = false;
+        state.providerPublicationId = null;
+      }
+      this.remotePublicationsChanged();
+    });
+    const replacement = { generation, promise };
+    this.#replacement = replacement;
+    void promise.then(
+      () => {
+        if (this.#replacement === replacement) this.#replacement = null;
+      },
+      () => {
+        if (this.#replacement === replacement) this.#replacement = null;
+      }
+    );
+    return promise;
   }
   async #republishPreparedTracksAfterRecovery(generation) {
     const enabled = [...this.#localTracks.values()].filter((state) => state.desiredEnabled && state.track.readyState !== "ended");
@@ -2332,9 +2558,19 @@ async function createLocalOffer(connection) {
 function localSourceGroup(source) {
   return source === "screen" ? [source, "screen_audio"] : [source];
 }
+function recoveryBackoffMs(attempt) {
+  return RECOVERY_BACKOFF_MS[Math.min(attempt, RECOVERY_BACKOFF_MS.length - 1)] ?? RECOVERY_BACKOFF_MS[RECOVERY_BACKOFF_MS.length - 1];
+}
+function isGonePublicationFailure(error) {
+  const failures = error instanceof AggregateError ? error.errors : [error];
+  return failures.length > 0 && failures.every((failure) => failure instanceof CloudflareSFUError && (failure.options.status === 404 || failure.options.status === 410));
+}
 function isRateLimited(error) {
   return error instanceof CloudflareSFUError && error.options.status === 429;
 }
+function unwrapAggregateErrors(error) {
+  return error instanceof AggregateError ? error.errors.flatMap(unwrapAggregateErrors) : [error];
+}
 function retryableRemotePull(error) {
   if (!(error instanceof CloudflareSFUError)) return false;
   if (error.code === "signaling_failed") return error.options.retryableConnection === true || error.options.status === 429;
@@ -2349,7 +2585,9 @@ function simulcastUnsupported(error) {
 function mediaTargetFailure(error) {
   const code = error instanceof CloudflareSFUError ? error.code : "media_failed";
   const ambiguous = code === "signaling_timeout" || code === "negotiation_timeout";
-  return { outcome: ambiguous ? "ambiguous" : "retryable_failure", errorCode: code };
+  const failures = unwrapAggregateErrors(error);
+  const terminal = failures.length > 0 && failures.every((failure) => failure instanceof CloudflareSFUError && failure.code === "signaling_failed" && typeof failure.options.status === "number" && failure.options.retryableConnection !== true && !isRateLimited(failure));
+  return { outcome: ambiguous ? "ambiguous" : terminal ? "terminal_failure" : "retryable_failure", errorCode: code };
 }
 
 // src/media/transport.ts