@q9labsai/chalk-client 4.1.16 → 5.0.0

package/dist/{chunk-O7WTAXAY.js → chunk-O2NOZKJP.js}

@@ -1,11 +1,3 @@
-import {
-  journeyHeaders
-} from "./chunk-HW5TTZL2.js";
-import {
-  recordReconnect,
-  traceReconnect
-} from "./chunk-RCDXIDCN.js";
-
 // src/media/camera-uplink.ts
 var CameraUplinkPolicy = class {
   #healthySamples = 0;
@@ -46,14 +38,6 @@ function subscribeSnapshot(listeners, listener) {
     listeners.delete(listener);
   };
 }
-function observePublications(listeners, listener, project) {
-  const publication = () => listener(project());
-  listeners.add(publication);
-  listener(project());
-  return () => {
-    listeners.delete(publication);
-  };
-}
 
 // src/media/target.ts
 function resolveMediaTarget(participantId, stopped, tracks, target) {
@@ -203,8 +187,6 @@ var CloudflareSFUClient = class {
   #localListeners = /* @__PURE__ */ new Set();
   #onError;
   #onRemoteTrack;
-  #recordReconnect;
-  #onRtcSummary;
   #onScreenEnded;
   #participantId;
   #peerConnectionFactory;
@@ -225,11 +207,17 @@ var CloudflareSFUClient = class {
   #cursor = null;
   #remotePullIncomplete = false;
   #remotePullRetryAfter = /* @__PURE__ */ new Map();
+  #remoteParticipantIds = null;
+  #remoteParticipantRevision = 0;
+  #subscribedPublicationIds = /* @__PURE__ */ new Set();
   #generation = 0;
   #negotiatedGeneration = null;
   #replacementAttemptedGeneration = null;
+  #remoteRecoveryGeneration = null;
   #polling = false;
   #pollAfterCurrent = false;
+  #pollFailures = 0;
+  #pollFailedPull = false;
   #pollTimer;
   #sdpTail = Promise.resolve();
   #snapshot;
@@ -245,8 +233,6 @@ var CloudflareSFUClient = class {
     this.#replaceMediaConnection = options.replaceMediaConnection;
     this.#onError = options.onError;
     this.#onRemoteTrack = options.onRemoteTrack;
-    this.#onRtcSummary = options.onRtcSummary;
-    this.#recordReconnect = options.recordReconnect;
     this.#onScreenEnded = options.onScreenEnded;
     this.#peerConnectionFactory = options.peerConnectionFactory;
     this.#connection = this.#createPeerConnection(options.bootstrap);
@@ -269,8 +255,13 @@ var CloudflareSFUClient = class {
     this.#remotePullRetryAfter.delete(publicationId);
     this.remotePublicationsChanged();
   }
+  remoteParticipantsChanged(participantIds) {
+    this.#remoteParticipantIds = new Set(participantIds);
+    this.#remoteParticipantRevision++;
+    this.#remotePullIncomplete = true;
+    this.remotePublicationsChanged();
+  }
   remotePublicationsChanged() {
-    recordReconnect(this.#recordReconnect, "remote_publications_changed");
     if (this.#polling) {
       this.#pollAfterCurrent = true;
       return;
@@ -308,6 +299,17 @@ var CloudflareSFUClient = class {
   async clearPreparedLocalTrack(source) {
     const state = this.#localTracks.get(source);
     if (!state) return;
+    if (source === "screen_audio") {
+      try {
+        await this.#retireLocalPublication(source);
+      } finally {
+        this.#removeOwnedLocalTrack(state);
+        this.#localTracks.delete(source);
+        this.#publishSnapshot();
+        this.#emitLocal();
+      }
+      return;
+    }
     if (state.enabled) await this.#setPreparedTrackEnabled(state, false);
     if (state.transceiver) this.#reusableLocalTransceivers.set(source, state.transceiver);
     if (state.providerPublicationId) this.#reusableLocalPublicationIds.set(source, state.providerPublicationId);
@@ -324,7 +326,7 @@ var CloudflareSFUClient = class {
     const generation = this.#generation;
     this.#setPhase("connecting", null);
     await this.#activatePreparedTracks(
-      [...this.#localTracks.values()].filter((state) => state.source !== "screen"),
+      [...this.#localTracks.values()].filter((state) => state.source === "microphone" || state.source === "camera"),
       generation
     );
   }
@@ -332,26 +334,35 @@ var CloudflareSFUClient = class {
     if (!this.#started || this.#stopped || this.#polling) return;
     this.#polling = true;
     const generation = this.#generation;
+    this.#pollFailedPull = false;
     try {
       const transport = this.#requireTransport();
-      const authoritative = await traceReconnect(this.#recordReconnect, "list_publications", () => transport.listPublications());
+      const authoritative = await (() => transport.listPublications())();
       this.#requireGeneration(generation);
       await this.#reconcileRemotePublications(authoritative, generation);
+      this.#requireGeneration(generation);
+      if (!this.#remotePullIncomplete) this.#pollFailures = 0;
     } catch (error) {
       if (generation === this.#generation && !this.#stopped) this.#reportError(error);
       throw error;
     } finally {
-      if (generation === this.#generation) {
-        this.#polling = false;
-        if (this.#pollAfterCurrent) {
-          this.#pollAfterCurrent = false;
-          this.#clearPoll();
-          this.#schedulePoll(0);
-        }
-      }
+      this.#finishPublicationPoll(generation);
     }
   }
+  #finishPublicationPoll(generation) {
+    if (generation !== this.#generation) return;
+    this.#polling = false;
+    if (!this.#pollAfterCurrent) return;
+    this.#pollAfterCurrent = false;
+    this.#clearPoll();
+    this.#schedulePoll(0);
+  }
   async setLocalPublicationTarget(target) {
+    const result = await this.#setSinglePublicationTarget(target);
+    if (target.source !== "screen" || !this.#localTracks.has("screen_audio") || result.outcome !== "confirmed" && result.outcome !== "satisfied") return result;
+    return this.#setSinglePublicationTarget({ ...target, source: "screen_audio" });
+  }
+  async #setSinglePublicationTarget(target) {
     const resolved = resolveMediaTarget(this.#participantId, this.#stopped, this.#localTracks, target);
     if (resolved.kind === "result") return resolved.result;
     const state = resolved.value;
@@ -371,6 +382,7 @@ var CloudflareSFUClient = class {
     return target.enabled && this.#locallyPausedSources.has(target.source);
   }
   setLocalSourceIntent(source, enabled) {
+    if (source === "screen") this.setLocalSourceIntent("screen_audio", enabled);
     if (enabled) {
       this.#locallyPausedSources.delete(source);
       return;
@@ -384,6 +396,7 @@ var CloudflareSFUClient = class {
   async closeForcedLocalPublication(source) {
     this.setLocalSourceIntent(source, false);
     await this.#retireLocalPublication(source);
+    if (source === "screen") await this.#retireLocalPublication("screen_audio");
     if (!this.#replaceMediaConnection) return;
     const generation = this.#generation;
     await this.#serializeSDP(async () => {
@@ -402,7 +415,7 @@ var CloudflareSFUClient = class {
   async #retireUnavailableLocalPublication(state) {
     const publicationId = state.providerPublicationId;
     if (!publicationId) return;
-    const authoritative = await traceReconnect(this.#recordReconnect, "list_publications", () => this.#requireTransport().listPublications());
+    const authoritative = await (() => this.#requireTransport().listPublications())();
     if (authoritative.publications.some((publication) => publication.publicationId === publicationId)) return;
     if (state.providerPublicationId === publicationId) await this.#retireLocalPublication(state.source);
   }
@@ -430,8 +443,8 @@ var CloudflareSFUClient = class {
       const mid = requireTransceiverMid(transceiver);
       await this.#boundPeerOperation(transceiver.sender.replaceTrack(null));
       transceiver.stop();
-      const offer = await traceReconnect(this.#recordReconnect, "create_offer", () => connection.createOffer());
-      await traceReconnect(this.#recordReconnect, "set_local_description", () => connection.setLocalDescription(offer));
+      const offer = await (() => connection.createOffer())();
+      await (() => connection.setLocalDescription(offer))();
       try {
         const response = await this.#requireTransport().closeTracks({
           connectionId,
@@ -461,7 +474,6 @@ var CloudflareSFUClient = class {
     this.#requireActive();
     const options = "connectionId" in input ? { bootstrap: input } : input;
     validateBootstrap(options.bootstrap);
-    recordReconnect(this.#recordReconnect, "media_rebuild_start");
     const generation = ++this.#generation;
     const connectionEpoch = ++this.#connectionEpoch;
     this.#polling = false;
@@ -478,20 +490,19 @@ var CloudflareSFUClient = class {
     if (options.bootstrap.connectionId !== this.#bootstrap.connectionId) this.#started = false;
     this.#bootstrap = options.bootstrap;
     if (options.transport) this.#transport = options.transport;
-    this.#connection = this.#createPeerConnection(options.bootstrap);
-    this.#observeConnection(this.#connection, generation, connectionEpoch);
+    this.#rebuildPeerConnection(options.bootstrap, generation, connectionEpoch);
     for (const state of this.#localTracks.values()) {
       state.transceiver = null;
       state.enabled = false;
     }
     const enabled = [...this.#localTracks.values()].filter((state) => state.desiredEnabled && state.track.readyState !== "ended");
-    this.#setPhase("recovering", null);
     await this.#activatePreparedTracks(enabled, generation);
   }
   async #activatePreparedTracks(states, generation) {
     try {
       await this.#publishPreparedTracks(states, generation);
       this.#requireGeneration(generation);
+      if (this.#remoteRecoveryGeneration !== generation) this.#replacementAttemptedGeneration = null;
       this.#started = true;
       this.#setPhase("live", null);
       this.#schedulePoll(0);
@@ -503,6 +514,7 @@ var CloudflareSFUClient = class {
   stop() {
     if (this.#stopped) return;
     this.#stopped = true;
+    this.#subscribedPublicationIds.clear();
     this.#generation++;
     this.#connectionEpoch++;
     this.#clearPoll();
@@ -557,6 +569,7 @@ var CloudflareSFUClient = class {
     const generation = this.#generation;
     try {
       await this.#publishPreparedTracks([state], generation);
+      if (this.#remoteRecoveryGeneration !== generation) this.#replacementAttemptedGeneration = null;
     } catch (error) {
       state.desiredEnabled = false;
       state.enabled = false;
@@ -580,7 +593,6 @@ var CloudflareSFUClient = class {
     if (states.length === 0) return;
     await this.#serializeSDP(async () => {
       const pending = await this.#prepareConnectionForPublication(states, generation);
-      this.#replacementAttemptedGeneration = null;
       try {
         await this.#publishPreparedTracksSerialized(pending, generation, this.#connection, this.#bootstrap.connectionId);
       } catch (error) {
@@ -600,7 +612,7 @@ var CloudflareSFUClient = class {
       await this.#replaceDormantConnectionBeforeNegotiation(generation);
       return states;
     }
-    const authoritative = await traceReconnect(this.#recordReconnect, "list_publications", () => this.#requireTransport().listPublications());
+    const authoritative = await (() => this.#requireTransport().listPublications())();
     this.#pauseUnavailableOtherSources(authoritative.publications, states);
     this.#replacementAttemptedGeneration = null;
     await this.#replaceMediaConnectionForRecovery(generation);
@@ -664,8 +676,8 @@ var CloudflareSFUClient = class {
   async #negotiateLocalPublications(connection, connectionId, publications, generation) {
     let offer;
     try {
-      offer = await traceReconnect(this.#recordReconnect, "create_offer", () => connection.createOffer());
-      await traceReconnect(this.#recordReconnect, "set_local_description", () => connection.setLocalDescription(offer));
+      offer = await (() => connection.createOffer())();
+      await (() => connection.setLocalDescription(offer))();
     } catch (error) {
       const cameras = publications.filter(({ state, transceiver }) => state.source === "camera" && transceiver.sender.getParameters().encodings.length > 1);
       if (!simulcastUnsupported(error) || cameras.length === 0) throw error;
@@ -677,8 +689,8 @@ var CloudflareSFUClient = class {
         publication.transceiver = connection.addTransceiver(publication.state.track, { direction: "sendonly" });
         publication.state.transceiver = publication.transceiver;
       }
-      offer = await traceReconnect(this.#recordReconnect, "create_offer", () => connection.createOffer());
-      await traceReconnect(this.#recordReconnect, "set_local_description", () => connection.setLocalDescription(offer));
+      offer = await (() => connection.createOffer())();
+      await (() => connection.setLocalDescription(offer))();
     }
     const tracks = publications.map(
       ({ state, transceiver, trackName }) => ({
@@ -688,7 +700,7 @@ var CloudflareSFUClient = class {
         source: state.source
       })
     );
-    const response = await traceReconnect(this.#recordReconnect, "publish_tracks", () => this.#requireTransport().addTracks({ connectionId, ...providerDescription(requireDescription(offer)), tracks }));
+    const response = await (() => this.#requireTransport().addTracks({ connectionId, ...providerDescription(requireDescription(offer)), tracks }))();
     this.#requireGeneration(generation);
     await this.#applyProviderDescription(response, connection);
     return response;
@@ -734,12 +746,12 @@ var CloudflareSFUClient = class {
     }
   }
   async #reconcileRemotePublications(authoritative, generation) {
-    const cursor = this.#validatedRemotePublicationCursor(authoritative);
+    const cursor = this.#nextRemotePublicationCursor(authoritative);
     if (cursor === null) return;
-    const ordering = comparePublicationCursor(this.#cursor, cursor);
-    if (ordering === "stale" || ordering === "same" && !this.#remotePullIncomplete) 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);
     if (pulled === null) return;
     this.#requireGeneration(generation);
@@ -748,8 +760,13 @@ var CloudflareSFUClient = class {
     this.#remoteTracks.clear();
     for (const [key, publication] of next) this.#remoteTracks.set(key, publication);
     this.#cursor = cursor;
-    this.#remotePullIncomplete = [...desired].some(([key, publication]) => next.get(key)?.publicationId !== publication.publicationId);
-    for (const publication of pulled) this.#invokeListener(() => this.#onRemoteTrack?.(publication));
+    this.#remotePullIncomplete = participantRevision !== this.#remoteParticipantRevision || next.size !== desired.size;
+    if (!this.#remotePullIncomplete) this.#remoteRecoveryGeneration = null;
+    if (!this.#remotePullIncomplete && this.#hasLiveRemoteTracks()) this.#replacementAttemptedGeneration = null;
+    for (const publication of pulled) {
+      this.#subscribedPublicationIds.add(publication.publicationId);
+      this.#invokeListener(() => this.#onRemoteTrack?.(publication));
+    }
     this.#publishSnapshot();
     this.#emitRemote();
   }
@@ -758,31 +775,40 @@ var CloudflareSFUClient = class {
     for (const publicationId of this.#remotePullRetryAfter.keys()) {
       if (!desiredIds.has(publicationId)) this.#remotePullRetryAfter.delete(publicationId);
     }
+    for (const publicationId of this.#subscribedPublicationIds) {
+      if (!desiredIds.has(publicationId)) this.#subscribedPublicationIds.delete(publicationId);
+    }
     const now = Date.now();
     return [...desired].filter(([key, publication]) => {
       if (this.#remoteTracks.get(key)?.publicationId === publication.publicationId) return false;
       const remaining = (this.#remotePullRetryAfter.get(publication.publicationId) ?? 0) - now;
-      if (remaining > 0) recordReconnect(this.#recordReconnect, "remote_pull_deferred", { remaining_ms: remaining, source: publication.source });
       return remaining <= 0;
     }).map(([, publication]) => publication);
   }
-  #validatedRemotePublicationCursor(authoritative) {
+  #nextRemotePublicationCursor(authoritative) {
     if (this.#cursor?.signature === INVALID_PUBLICATION_SIGNATURE && this.#cursor.incarnation === authoritative.incarnation && this.#cursor.sequence === authoritative.sequence) return null;
+    let cursor;
     try {
-      return validatePublicationSnapshot(authoritative);
+      cursor = validatePublicationSnapshot(authoritative);
     } catch (error) {
       this.#quarantineInvalidRemotePublicationCursor(authoritative);
       throw error;
     }
+    const ordering = comparePublicationCursor(this.#cursor, cursor);
+    return ordering === "stale" || ordering === "same" && !this.#remotePullIncomplete ? null : cursor;
   }
   #desiredRemotePublications(authoritative, cursor) {
     try {
-      return desiredRemotePublications(authoritative.publications, this.#participantId);
+      const publications = authoritative.publications.filter((publication) => this.#canSubscribeToRemotePublication(publication));
+      return desiredRemotePublications(publications, this.#participantId);
     } catch (error) {
       this.#observeRemotePublicationCursor(cursor);
       throw error;
     }
   }
+  #canSubscribeToRemotePublication(publication) {
+    return this.#remoteParticipantIds === null || this.#remoteParticipantIds.has(publication.participantId) || this.#subscribedPublicationIds.has(publication.publicationId);
+  }
   async #pullWithRecovery(publications, cursor, generation) {
     try {
       return await this.#pull(publications, generation);
@@ -796,12 +822,13 @@ var CloudflareSFUClient = class {
     }
   }
   #canReplaceConnectionAfterRemotePull(error, generation) {
-    return error instanceof CloudflareSFUError && error.code === "signaling_failed" && !this.#hasLiveRemoteTracks() && this.#replaceMediaConnection !== void 0 && this.#replacementAttemptedGeneration !== generation;
+    return this.#isRetryableConnectionFailure(error) && !this.#hasLiveRemoteTracks() && this.#replaceMediaConnection !== void 0 && this.#replacementAttemptedGeneration !== generation;
   }
   #hasLiveRemoteTracks() {
     return [...this.#remoteTracks.values()].some((publication) => publication.track.readyState === "live");
   }
   async #retryRemotePullOnReplacement(publications, cursor, generation) {
+    this.#remoteRecoveryGeneration = generation;
     try {
       await this.#replaceMediaConnectionForRecovery(generation);
       await this.#republishPreparedTracksAfterRecovery(generation);
@@ -813,6 +840,44 @@ var CloudflareSFUClient = class {
     }
   }
   async #pull(publications, generation) {
+    const eligible = publications.filter((publication) => this.#canSubscribeToRemotePublication(publication));
+    try {
+      return await this.#pullBatch(eligible, generation);
+    } catch (error) {
+      this.#requireGeneration(generation);
+      if (eligible.length <= 1 || !retryableRemotePull(error) || isRateLimited(error) || this.#canReplaceConnectionAfterRemotePull(error, generation) || error instanceof CloudflareSFUError && (error.options.status === 404 || error.options.status === 410)) {
+        this.#deferRemotePulls(eligible, error);
+        throw error;
+      }
+    }
+    return this.#pullIndividually(eligible, generation);
+  }
+  async #pullIndividually(eligible, generation) {
+    const pulled = [];
+    let failure;
+    for (const [index, publication] of eligible.entries()) {
+      if (!this.#canSubscribeToRemotePublication(publication)) continue;
+      try {
+        pulled.push(...await this.#pullBatch([publication], generation));
+      } catch (error) {
+        this.#requireGeneration(generation);
+        this.#deferRemotePulls([publication], error);
+        this.#reportError(error);
+        if (failure === void 0 || retryableRemotePull(error)) failure = error;
+        if (isRateLimited(error)) {
+          this.#deferRemotePulls(eligible.slice(index + 1), error);
+          break;
+        }
+      }
+    }
+    if (failure && pulled.length === 0) throw failure;
+    return pulled;
+  }
+  #deferRemotePulls(publications, error) {
+    const retryAfter = retryableRemotePull(error) ? Date.now() + 15e3 : Number.POSITIVE_INFINITY;
+    for (const publication of publications) this.#remotePullRetryAfter.set(publication.publicationId, retryAfter);
+  }
+  async #pullBatch(publications, generation) {
     if (publications.length === 0) return [];
     return this.#serializeSDP(async () => {
       const connection = this.#connection;
@@ -836,7 +901,7 @@ var CloudflareSFUClient = class {
       connection.addEventListener("track", onTrack);
       try {
         this.#requireGeneration(generation);
-        const response = await traceReconnect(this.#recordReconnect, "pull_tracks", () => this.#requireTransport().addTracks({ connectionId, tracks: requested, allowPartialRemoteTracks: true }));
+        const response = await (() => this.#requireTransport().addTracks({ connectionId, tracks: requested, allowPartialRemoteTracks: true }))();
         this.#requireGeneration(generation);
         this.#recordRemotePullErrors(publications, response.trackErrors ?? []);
         const responseTracks = response.tracks ?? [];
@@ -846,7 +911,7 @@ var CloudflareSFUClient = class {
         if (matched.length === 0) return [];
         await this.#waitForConnection(connection, generation);
         this.#negotiatedGeneration = generation;
-        await traceReconnect(this.#recordReconnect, "remote_track_arrival", () => waitFor(() => responseTracks.every((track) => track.mid !== void 0 && received.has(track.mid)), 5e3));
+        await (() => waitFor(() => responseTracks.every((track) => track.mid !== void 0 && received.has(track.mid)), 5e3))();
         this.#requireGeneration(generation);
         return matched.map(({ publication, mid }) => {
           const track = received.get(mid);
@@ -871,26 +936,24 @@ 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 delay = 750;
+      const delay = 15e3;
       this.#remotePullRetryAfter.set(publication.publicationId, Date.now() + delay);
-      recordReconnect(this.#recordReconnect, "remote_pull_backoff", { delay_ms: delay, retry_kind: failure.code === "empty_track_error" ? "empty_track" : "provider_error", source: publication.source });
       this.#reportError(new CloudflareSFUError(`Cloudflare SFU remote track failed: ${failure.code}`, "media_failed", { providerCode: failure.code }));
     }
   }
   async #completeRenegotiation(response, connection, connectionId, generation) {
     if (!response.requiresImmediateRenegotiation) return;
     await this.#applyProviderDescription(response, connection);
-    const answer = await traceReconnect(this.#recordReconnect, "create_answer", () => connection.createAnswer());
-    await traceReconnect(this.#recordReconnect, "set_local_answer", () => connection.setLocalDescription(answer));
-    await traceReconnect(this.#recordReconnect, "renegotiate", () => this.#requireTransport().renegotiate({ connectionId, ...providerDescription(requireDescription(answer)) }));
+    const answer = await (() => connection.createAnswer())();
+    await (() => connection.setLocalDescription(answer))();
+    await (() => this.#requireTransport().renegotiate({ connectionId, ...providerDescription(requireDescription(answer)) }))();
     this.#requireGeneration(generation);
   }
   async #applyProviderDescription(response, connection = this.#connection) {
-    await traceReconnect(this.#recordReconnect, "set_remote_description", () => connection.setRemoteDescription(requireSFUDescription(response.sessionDescription)));
+    await (() => connection.setRemoteDescription(requireSFUDescription(response.sessionDescription)))();
   }
   #serializeSDP(operation) {
     const generation = this.#generation;
-    const queuedAt = performance.now();
     let expired = false;
     let timer;
     const timeout = new CloudflareSFUError("Cloudflare SFU negotiation timed out. Try again.", "negotiation_timeout");
@@ -903,7 +966,6 @@ var CloudflareSFUClient = class {
     });
     const run = () => {
       if (expired || generation !== this.#generation) throw timeout;
-      recordReconnect(this.#recordReconnect, "sdp_queue", { duration_ms: performance.now() - queuedAt });
       return operation();
     };
     const pending = this.#sdpTail.then(run, run);
@@ -944,18 +1006,14 @@ var CloudflareSFUClient = class {
     this.#setFailure(error, "media_failed");
   }
   #waitForConnection(connection, generation) {
-    return traceReconnect(
-      this.#recordReconnect,
-      "connection_ready",
-      () => waitFor(
-        () => {
-          this.#requireGeneration(generation);
-          return connectionIsLive(connection);
-        },
-        CONNECTION_TIMEOUT_MS,
-        "Timed out waiting for the Cloudflare SFU peer connection"
-      )
-    );
+    return (() => waitFor(
+      () => {
+        this.#requireGeneration(generation);
+        return connectionIsLive(connection);
+      },
+      CONNECTION_TIMEOUT_MS,
+      "Timed out waiting for the Cloudflare SFU peer connection"
+    ))();
   }
   #cameraSimulcastSender(state) {
     if (!state?.enabled) return void 0;
@@ -1018,84 +1076,16 @@ var CloudflareSFUClient = class {
     };
     const capture = () => {
       if (disposed || generation !== this.#generation || connectionEpoch !== this.#connectionEpoch || this.#stopped) return;
-      recordReconnect(this.#recordReconnect, "rtc_state", { connection_state: connection.connectionState, ice_connection_state: connection.iceConnectionState, signaling_state: connection.signalingState });
       observe();
-      const recorder = this.#onRtcSummary;
-      if (recorder) {
-        let stats;
-        try {
-          stats = Promise.resolve(connection.getStats());
-        } catch {
-          stats = Promise.reject(new Error("RTC stats are unavailable"));
-        }
-        void stats.then((report) => {
-          if (disposed || generation !== this.#generation || connectionEpoch !== this.#connectionEpoch || this.#stopped) return;
-          recorder(rtcConnectionState(connection), rtcStats(report));
-        }).catch(() => void 0);
-      }
       if (connection.connectionState === "closed") dispose();
     };
     this.#disposeConnectionObservation = dispose;
     cameraTimer = globalThis.setTimeout(adaptCamera, 1e3);
-    if (this.#recordReconnect) this.#sampleRecoveryTraffic(connection, generation, connectionEpoch);
     connection.addEventListener("connectionstatechange", capture);
     connection.addEventListener("iceconnectionstatechange", capture);
     connection.addEventListener("signalingstatechange", capture);
     capture();
   }
-  #sampleRecoveryTraffic(connection, generation, connectionEpoch) {
-    const traffic = /* @__PURE__ */ new Map();
-    let dtlsState;
-    const current = () => generation === this.#generation && connectionEpoch === this.#connectionEpoch && !this.#stopped && connection.connectionState !== "closed" && connection.connectionState !== "failed";
-    const sample = async () => {
-      if (!current()) return;
-      try {
-        const report = await connection.getStats();
-        if (!current()) return;
-        const now = performance.now();
-        report.forEach((entry) => {
-          if (entry.type === "transport") {
-            const nextState = rtcString(entry, "dtlsState");
-            if (nextState !== dtlsState) recordReconnect(this.#recordReconnect, "dtls_state", { dtls_state: nextState ?? "unknown" });
-            dtlsState = nextState;
-          }
-          this.#observeRecoveryTraffic(entry, traffic, now);
-        });
-      } catch {
-        if (current()) recordReconnect(this.#recordReconnect, "rtc_stats_unavailable");
-      }
-      if (current()) globalThis.setTimeout(() => void sample(), 250);
-    };
-    void sample();
-  }
-  #observeRecoveryTraffic(entry, traffic, now) {
-    if (entry.type !== "inbound-rtp" && entry.type !== "outbound-rtp") return;
-    const direction = entry.type === "inbound-rtp" ? "inbound" : "outbound";
-    const kind = rtcString(entry, "kind") ?? "unknown";
-    const previous = traffic.get(entry.id);
-    const next = previous ?? {
-      packets: { count: 0, lastProgress: now, stalled: false },
-      frames: { count: 0, lastProgress: now, stalled: false }
-    };
-    const packets = recoveryTrafficCount(entry, direction, "packet");
-    const frames = recoveryTrafficCount(entry, direction, "frame");
-    this.#observeTrafficCounter(next.packets, { count: packets, now, direction, kind, unit: "packet", existed: previous !== void 0 });
-    this.#observeTrafficCounter(next.frames, { count: frames, now, direction, kind, unit: "frame", existed: previous !== void 0 });
-    traffic.set(entry.id, next);
-  }
-  #observeTrafficCounter(progress, sample) {
-    const attributes = { direction: sample.direction, kind: sample.kind };
-    if (sample.count > progress.count) {
-      if (progress.count === 0) recordReconnect(this.#recordReconnect, `first_${sample.unit}`, attributes);
-      else if (progress.stalled) recordReconnect(this.#recordReconnect, sample.unit === "packet" ? "rtp_resumed" : "frame_resumed", attributes);
-      progress.lastProgress = sample.now;
-      progress.stalled = false;
-    } else if (trafficStalled(progress, sample)) {
-      progress.stalled = true;
-      recordReconnect(this.#recordReconnect, sample.unit === "packet" ? "rtp_stall" : "frame_stall", attributes);
-    }
-    progress.count = sample.count;
-  }
   async #replaceDormantConnectionBeforeNegotiation(generation) {
     if (!this.#started || this.#negotiatedGeneration === generation || this.#replacementAttemptedGeneration === generation || !this.#replaceMediaConnection) return;
     await this.#replaceMediaConnectionForRecovery(generation);
@@ -1107,7 +1097,7 @@ var CloudflareSFUClient = class {
     }
     this.#replacementAttemptedGeneration = generation;
     const replaceMediaConnection = this.#replaceMediaConnection;
-    const bootstrap = await traceReconnect(this.#recordReconnect, "replace_access", replaceMediaConnection);
+    const bootstrap = await replaceMediaConnection();
     this.#requireGeneration(generation);
     validateBootstrap(bootstrap);
     if (bootstrap.connectionId === this.#bootstrap.connectionId) {
@@ -1120,16 +1110,14 @@ var CloudflareSFUClient = class {
     this.#clearRemoteTracks();
     this.#cursor = null;
     this.#bootstrap = bootstrap;
-    this.#connection = this.#createPeerConnection(bootstrap);
+    this.#rebuildPeerConnection(bootstrap, generation, connectionEpoch);
     this.#retiredLocalConnection = null;
     this.#negotiatedGeneration = null;
-    this.#observeConnection(this.#connection, generation, connectionEpoch);
     for (const state of this.#localTracks.values()) {
       state.transceiver = null;
       state.enabled = false;
       state.providerPublicationId = null;
     }
-    this.#setPhase("recovering", null);
     this.remotePublicationsChanged();
   }
   async #republishPreparedTracksAfterRecovery(generation) {
@@ -1152,7 +1140,17 @@ var CloudflareSFUClient = class {
     const create = this.#peerConnectionFactory ?? ((configuration) => new RTCPeerConnection(configuration));
     return create({ iceServers: [{ urls: bootstrap.stunServer }], bundlePolicy: "max-bundle" });
   }
+  #rebuildPeerConnection(bootstrap, generation, connectionEpoch) {
+    try {
+      this.#connection = this.#createPeerConnection(bootstrap);
+      this.#observeConnection(this.#connection, generation, connectionEpoch);
+    } catch (error) {
+      this.#setFailure(error, "media_failed");
+      throw error;
+    }
+  }
   #disposeConnection(stopSenders) {
+    if (!stopSenders) this.#setPhase("recovering", null);
     this.#disposeConnectionObservation?.();
     this.#disposeConnectionObservation = void 0;
     if (stopSenders) {
@@ -1198,15 +1196,27 @@ var CloudflareSFUClient = class {
         this.#schedulePoll();
         return;
       }
+      let nextDelay = this.#pollIntervalMs;
       try {
         await this.refreshRemotePublications();
+        if (this.#remotePullIncomplete) nextDelay = this.#incompletePullDelay();
       } catch {
+        if (this.#pollFailedPull && this.#remotePullIncomplete) nextDelay = this.#incompletePullDelay();
+        else {
+          this.#pollFailures = Math.min(this.#pollFailures + 1, 6);
+          nextDelay = Math.min(this.#pollIntervalMs, (500 + Math.random() * 500) * 2 ** (this.#pollFailures - 1));
+        }
       } finally {
-        this.#schedulePoll(this.#remotePullIncomplete ? 750 : this.#pollIntervalMs);
+        this.#schedulePoll(nextDelay);
       }
     }, delayMs);
   }
+  #incompletePullDelay() {
+    this.#pollFailures = Math.min(this.#pollFailures + 1, 6);
+    return Math.min(this.#pollIntervalMs, 750 * 2 ** (this.#pollFailures - 1));
+  }
   #clearPoll() {
+    this.#pollFailures = 0;
     if (this.#pollTimer !== void 0) globalThis.clearTimeout(this.#pollTimer);
     this.#pollTimer = void 0;
   }
@@ -1291,76 +1301,11 @@ function validateClientOptions(options) {
     throw new CloudflareSFUError("Cloudflare SFU polling interval is invalid", "invalid_bootstrap");
   }
 }
-function rtcConnectionState(connection) {
-  return {
-    connectionState: connection.connectionState,
-    iceConnectionState: connection.iceConnectionState,
-    signalingState: connection.signalingState
-  };
-}
-function rtcStats(report) {
-  const entries = [];
-  report.forEach((entry) => {
-    if (typeof entry.type !== "string") return;
-    entries.push({ type: entry.type, ...rtcTrafficStats(entry), ...rtcQualityStats(entry), ...rtcTransportStats(entry) });
-  });
-  return entries;
-}
-function rtcTrafficStats(entry) {
-  const bytesReceived = rtcNumber(entry, "bytesReceived");
-  const bytesSent = rtcNumber(entry, "bytesSent");
-  const packetsReceived = rtcNumber(entry, "packetsReceived");
-  const packetsSent = rtcNumber(entry, "packetsSent");
-  return {
-    ...bytesReceived !== void 0 ? { bytesReceived } : {},
-    ...bytesSent !== void 0 ? { bytesSent } : {},
-    ...packetsReceived !== void 0 ? { packetsReceived } : {},
-    ...packetsSent !== void 0 ? { packetsSent } : {}
-  };
-}
-function rtcQualityStats(entry) {
-  const kind = rtcString(entry, "kind");
-  const framesDropped = rtcNumber(entry, "framesDropped");
-  const jitter = rtcNumber(entry, "jitter");
-  const packetsLost = rtcNumber(entry, "packetsLost");
-  const roundTripTime = rtcNumber(entry, "roundTripTime");
-  return {
-    ...kind !== void 0 ? { kind } : {},
-    ...framesDropped !== void 0 ? { framesDropped } : {},
-    ...jitter !== void 0 ? { jitter } : {},
-    ...packetsLost !== void 0 ? { packetsLost } : {},
-    ...roundTripTime !== void 0 ? { roundTripTime } : {}
-  };
-}
-function rtcTransportStats(entry) {
-  const state = rtcString(entry, "state");
-  const selected = rtcBoolean(entry, "selected");
-  const nominated = rtcBoolean(entry, "nominated");
-  const dtlsState = rtcString(entry, "dtlsState");
-  return {
-    ...state !== void 0 ? { state } : {},
-    ...selected !== void 0 ? { selected } : {},
-    ...nominated !== void 0 ? { nominated } : {},
-    ...dtlsState !== void 0 ? { dtlsState } : {}
-  };
-}
-function rtcString(value, property) {
-  const candidate = Reflect.get(value, property);
-  return typeof candidate === "string" ? candidate : void 0;
-}
-function rtcNumber(value, property) {
-  const candidate = Reflect.get(value, property);
-  return typeof candidate === "number" ? candidate : void 0;
-}
-function rtcBoolean(value, property) {
-  const candidate = Reflect.get(value, property);
-  return typeof candidate === "boolean" ? candidate : void 0;
-}
 function validateBootstrap(bootstrap) {
   if (!bootstrap.connectionId.trim() || !bootstrap.stunServer.trim()) throw new CloudflareSFUError("Cloudflare SFU bootstrap is incomplete", "invalid_bootstrap");
 }
 function validateTrackSource(source, track) {
-  const valid = source === "microphone" ? track.kind === "audio" : track.kind === "video";
+  const valid = source === "microphone" || source === "screen_audio" ? track.kind === "audio" : track.kind === "video";
   if (!valid) throw new CloudflareSFUError(`The prepared ${source} track has an incompatible kind`, "media_failed");
 }
 function desiredRemotePublications(publications, participantId) {
@@ -1437,8 +1382,13 @@ function remotePublicationEqual(left, right) {
 function providerDescription(description) {
   return { sessionDescription: description };
 }
+function isRateLimited(error) {
+  return error instanceof CloudflareSFUError && error.options.status === 429;
+}
 function retryableRemotePull(error) {
-  return error instanceof CloudflareSFUError && ["signaling_failed", "signaling_timeout", "media_failed", "negotiation_timeout"].includes(error.code);
+  if (!(error instanceof CloudflareSFUError)) return false;
+  if (error.code === "signaling_failed") return error.options.retryableConnection === true || error.options.status === 429;
+  return ["signaling_timeout", "media_failed", "negotiation_timeout"].includes(error.code);
 }
 function firefoxCameraSimulcastUnsupported() {
   return typeof navigator !== "undefined" && /\bFirefox\/\d+/i.test(navigator.userAgent);
@@ -1451,13 +1401,6 @@ function mediaTargetFailure(error) {
   const ambiguous = code === "signaling_timeout" || code === "negotiation_timeout";
   return { outcome: ambiguous ? "ambiguous" : "retryable_failure", errorCode: code };
 }
-function recoveryTrafficCount(entry, direction, unit) {
-  const property = unit === "packet" ? direction === "inbound" ? "packetsReceived" : "packetsSent" : direction === "inbound" ? "framesDecoded" : "framesEncoded";
-  return rtcNumber(entry, property) ?? 0;
-}
-function trafficStalled(progress, sample) {
-  return sample.existed && !progress.stalled && sample.now - progress.lastProgress >= 1e3 && (sample.unit === "packet" || progress.count > 0);
-}
 
 // src/media/transport.ts
 var SIGNALING_TIMEOUT_MS = 8e3;
@@ -1476,7 +1419,7 @@ function createCloudflareSFUHTTPTransport(options) {
       const response = await fetch(`${mediaPath}/${path}`, {
         ...init,
         signal,
-        headers: { ...options.telemetry ? journeyHeaders(options.telemetry) : {}, Authorization: `Bearer ${token}`, "Content-Type": "application/json", ...init?.headers }
+        headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json", ...init?.headers }
       });
       if (!response.ok) {
         throw new CloudflareSFUError(`Chalk SFU signaling failed with HTTP ${response.status}`, "signaling_failed", {
@@ -1553,416 +1496,6 @@ function requireCredential(options) {
   throw new CloudflareSFUError("A media credential provider is required", "signaling_failed");
 }
 
-// src/media/rtk.ts
-var CloudflareRTKError = class extends Error {
-  code;
-  constructor(message, code) {
-    super(message);
-    this.name = "CloudflareRTKError";
-    this.code = code;
-  }
-};
-var EMPTY_LOCAL2 = Object.freeze([]);
-var EMPTY_REMOTE2 = Object.freeze([]);
-var CloudflareRTKClient = class {
-  #participantId;
-  #onError;
-  #onScreenEnded;
-  #clientFactory;
-  #snapshotListeners = /* @__PURE__ */ new Set();
-  #sourceOperations = /* @__PURE__ */ new Map();
-  #connection = null;
-  #localTracks = /* @__PURE__ */ new Map();
-  #connectionUnsubscribers = [];
-  #participantUnsubscribers = /* @__PURE__ */ new Map();
-  #snapshot;
-  #stopped = false;
-  #screenDisableRequested = false;
-  #initialAuthToken;
-  constructor(options) {
-    if (!options.authToken.trim()) throw new CloudflareRTKError("A RealtimeKit auth token is required", "invalid_client");
-    if (!options.participantId.trim()) throw new CloudflareRTKError("A participant ID is required", "invalid_participant");
-    this.#participantId = options.participantId;
-    this.#onError = options.onError;
-    this.#onScreenEnded = options.onScreenEnded;
-    this.#clientFactory = options.clientFactory ?? defaultClientFactory;
-    this.#snapshot = freezeSnapshot2({
-      connection: { phase: "idle", peerConnectionState: null, iceConnectionState: null },
-      cursor: null,
-      localTracks: EMPTY_LOCAL2,
-      remoteTracks: EMPTY_REMOTE2,
-      failure: null
-    });
-    this.#initialAuthToken = options.authToken;
-  }
-  getSnapshot() {
-    return this.#snapshot;
-  }
-  subscribe(listener) {
-    return subscribeSnapshot(this.#snapshotListeners, listener);
-  }
-  prepareLocalTrack(source, track) {
-    this.#requireStartable();
-    validateTrack(source, track);
-    if (this.#localTracks.has(source)) throw new CloudflareRTKError(`A ${source} track is already prepared`, "media_failed");
-    const endedListener = source === "screen" ? () => this.#onScreenEnded?.() : null;
-    if (endedListener) track.addEventListener("ended", endedListener);
-    this.#localTracks.set(source, { source, track, enabled: false, endedListener });
-    this.#publishSnapshot();
-  }
-  async clearPreparedLocalTrack(source) {
-    const state = this.#localTracks.get(source);
-    if (!state) return;
-    if (state.enabled) {
-      await this.#setSourceEnabled(state, false);
-    }
-    if (state.endedListener) state.track.removeEventListener("ended", state.endedListener);
-    this.#localTracks.delete(source);
-    this.#publishSnapshot();
-  }
-  async start(localMedia) {
-    if (this.#snapshot.connection.phase === "live") return;
-    this.#requireStartable();
-    this.#setPhase("connecting", null);
-    try {
-      const tracks = localMedia.getTracks().filter((track) => track.kind === "audio" || track.kind === "video");
-      for (const track of tracks) {
-        const source = track.kind === "audio" ? "microphone" : "camera";
-        if (!this.#localTracks.has(source)) this.#localTracks.set(source, { source, track, enabled: false, endedListener: null });
-      }
-      await this.#openConnection(this.#initialAuthToken);
-      for (const state of this.#localTracks.values()) {
-        if (state.source === "microphone" || state.source === "camera") await this.#setSourceEnabled(state, true);
-      }
-      this.#setPhase("live", null);
-    } catch (error) {
-      this.#setFailure(error);
-      this.#reportError(error);
-      throw error;
-    }
-  }
-  async setLocalPublicationTarget(target) {
-    const resolved = resolveMediaTarget(this.#participantId, this.#stopped, this.#localTracks, target);
-    if (resolved.kind === "result") return resolved.result;
-    const state = resolved.value;
-    const previous = this.#sourceOperations.get(target.source) ?? Promise.resolve();
-    const operation = previous.catch(() => void 0).then(async () => {
-      if (state.enabled === target.enabled) return "satisfied";
-      try {
-        await this.#setSourceEnabled(state, target.enabled);
-        return "confirmed";
-      } catch (error) {
-        this.#reportError(error);
-        return "retryable_failure";
-      }
-    });
-    this.#sourceOperations.set(target.source, operation);
-    try {
-      const outcome = await operation;
-      return { outcome, errorCode: outcome === "retryable_failure" ? "media_failed" : null };
-    } finally {
-      if (this.#sourceOperations.get(target.source) === operation) this.#sourceOperations.delete(target.source);
-    }
-  }
-  observeLocalPublications(listener) {
-    return observePublications(this.#snapshotListeners, listener, () => this.#projectLocalPublications());
-  }
-  observeRemotePublications(listener) {
-    return observePublications(this.#snapshotListeners, listener, () => this.#projectRemotePublications());
-  }
-  async restart(input) {
-    if (!isRTKAccess(input)) throw new CloudflareRTKError("The RealtimeKit adapter requires a Cloudflare RealtimeKit access grant", "invalid_client");
-    if (this.#stopped) throw new CloudflareRTKError("The RealtimeKit media client has stopped", "media_stopped");
-    this.#setPhase("recovering", null);
-    try {
-      await this.#closeConnection();
-      await this.#openConnection(input.clientPayload.token);
-      for (const state of this.#localTracks.values()) if (state.enabled) await this.#setSourceEnabled(state, true);
-      this.#setPhase("live", null);
-    } catch (error) {
-      this.#setFailure(error);
-      this.#reportError(error);
-      throw error;
-    }
-  }
-  stop() {
-    if (this.#stopped) return;
-    this.#stopped = true;
-    const leave = this.#closeConnection();
-    void leave.catch((error) => this.#reportError(error));
-    for (const state of this.#localTracks.values()) if (state.endedListener) state.track.removeEventListener("ended", state.endedListener);
-    this.#localTracks.clear();
-    this.#setPhase("stopped", null);
-  }
-  async #openConnection(authToken) {
-    this.#connection = await this.#clientFactory({ authToken, onError: (error) => this.#reportError(error) });
-    this.#bindConnection(this.#connection);
-    await this.#connection.join();
-  }
-  async #closeConnection() {
-    const connection = this.#connection;
-    this.#connection = null;
-    this.#unbindConnection();
-    if (connection) await connection.leave();
-  }
-  #bindConnection(connection) {
-    const selfAudio = connection.self.onAudioUpdate(() => this.#syncLocalState("microphone"));
-    const selfVideo = connection.self.onVideoUpdate(() => this.#syncLocalState("camera"));
-    const selfScreen = connection.self.onScreenShareUpdate((payload) => {
-      this.#syncLocalState("screen");
-      if (!payload.screenShareEnabled && !this.#screenDisableRequested) this.#onScreenEnded?.();
-      this.#screenDisableRequested = false;
-    });
-    const connectionLeft = connection.self.onLeft(() => {
-      if (this.#stopped) return;
-      const error = new CloudflareRTKError("The RealtimeKit connection ended unexpectedly", "media_failed");
-      this.#setFailure(error);
-      this.#reportError(error);
-    });
-    for (const participant of connection.participants.joined.list()) this.#bindParticipant(participant);
-    const participantJoined = connection.participants.joined.onJoined((participant) => {
-      this.#bindParticipant(participant);
-      this.#publishSnapshot();
-    });
-    const participantLeft = connection.participants.joined.onLeft((participant) => {
-      this.#unbindParticipant(participant.id);
-      this.#publishSnapshot();
-    });
-    this.#connectionUnsubscribers = [selfAudio, selfVideo, selfScreen, connectionLeft, participantJoined, participantLeft];
-  }
-  #unbindConnection() {
-    for (const unsubscribe of this.#connectionUnsubscribers) unsubscribe();
-    this.#connectionUnsubscribers = [];
-    for (const unsubscribers of this.#participantUnsubscribers.values()) for (const unsubscribe of unsubscribers) unsubscribe();
-    this.#participantUnsubscribers.clear();
-  }
-  #bindParticipant(participant) {
-    if (this.#participantUnsubscribers.has(participant.id)) return;
-    const unsubscribers = [participant.onAudioUpdate?.(() => this.#publishSnapshot()), participant.onVideoUpdate?.(() => this.#publishSnapshot()), participant.onScreenShareUpdate?.(() => this.#publishSnapshot())].filter((unsubscribe) => unsubscribe !== void 0);
-    this.#participantUnsubscribers.set(participant.id, unsubscribers);
-  }
-  #unbindParticipant(participantId) {
-    const unsubscribers = this.#participantUnsubscribers.get(participantId);
-    if (!unsubscribers) return;
-    for (const unsubscribe of unsubscribers) unsubscribe();
-    this.#participantUnsubscribers.delete(participantId);
-  }
-  async #setSourceEnabled(state, enabled) {
-    const connection = this.#connection;
-    if (!connection) throw new CloudflareRTKError("The RealtimeKit connection is not active", "media_stopped");
-    if (state.source === "microphone") {
-      if (enabled) await connection.self.enableAudio(state.track);
-      else await connection.self.disableAudio();
-    } else if (state.source === "camera") {
-      if (enabled) await connection.self.enableVideo(state.track);
-      else await connection.self.disableVideo();
-    } else {
-      this.#screenDisableRequested = !enabled;
-      if (enabled) await connection.self.enableScreenShare();
-      else await connection.self.disableScreenShare();
-    }
-    state.enabled = enabled;
-    state.track.enabled = enabled;
-    this.#publishSnapshot();
-  }
-  #syncLocalState(source) {
-    const state = this.#localTracks.get(source);
-    const connection = this.#connection;
-    if (!state || !connection) return;
-    state.enabled = source === "microphone" ? connection.self.audioEnabled : source === "camera" ? connection.self.videoEnabled : connection.self.screenShareEnabled;
-    state.track.enabled = state.enabled;
-    this.#publishSnapshot();
-  }
-  #publishSnapshot() {
-    this.#snapshot = freezeSnapshot2({ ...this.#snapshot, localTracks: this.#projectLocalTracks(), remoteTracks: this.#projectRemoteTracks() });
-    this.#notifyListeners();
-  }
-  #projectLocalTracks() {
-    return Object.freeze([...this.#localTracks.values()].map((state) => ({ source: state.source, enabled: state.enabled, publicationId: `${this.#participantId}:${state.source}`, track: state.track })));
-  }
-  #projectLocalPublications() {
-    return Object.freeze(this.#projectLocalTracks().map((track) => ({ participantId: this.#participantId, source: track.source, enabled: track.enabled, publicationId: track.publicationId })));
-  }
-  #projectRemotePublications() {
-    return Object.freeze(this.#projectRemoteTracks().map((track) => ({ participantId: track.participantId, source: track.source, enabled: true, publicationId: track.publicationId })));
-  }
-  #projectRemoteTracks() {
-    return projectRemoteTracks(this.#connection?.participants.joined.list() ?? []);
-  }
-  #setPhase(phase, failure) {
-    this.#snapshot = freezeSnapshot2({ ...this.#snapshot, connection: { phase, peerConnectionState: null, iceConnectionState: null }, failure });
-    this.#notifyListeners();
-  }
-  #setFailure(error) {
-    this.#setPhase("failed", { code: "media_failed", recoverable: true });
-    if (!(error instanceof CloudflareRTKError)) this.#reportError(error);
-  }
-  #requireStartable() {
-    if (this.#stopped) throw new CloudflareRTKError("The RealtimeKit media client has stopped", "media_stopped");
-  }
-  #reportError(error) {
-    try {
-      this.#onError?.(error);
-    } catch {
-    }
-  }
-  #notifyListeners() {
-    for (const listener of this.#snapshotListeners) {
-      try {
-        listener();
-      } catch (error) {
-        this.#reportError(error);
-      }
-    }
-  }
-};
-function projectRemoteTracks(participants) {
-  return Object.freeze(participants.flatMap(remoteTracksForParticipant));
-}
-function remoteTracksForParticipant(participant) {
-  const participantId = participantIdentifier(participant);
-  if (!participantId) return [];
-  const publications = [];
-  addRemotePublication(publications, participant, participantId, "microphone", participant.audioEnabled ? participant.audioTrack : null);
-  addRemotePublication(publications, participant, participantId, "camera", participant.videoEnabled ? participant.videoTrack : null);
-  addRemotePublication(publications, participant, participantId, "screen", participant.screenShareEnabled ? participant.screenShareTracks.video ?? null : null);
-  return publications;
-}
-function participantIdentifier(participant) {
-  return participant.customParticipantId?.trim() || participant.userId.trim() || participant.id.trim();
-}
-function addRemotePublication(publications, participant, participantId, source, track) {
-  if (!track) return;
-  publications.push({ participantId, source, publicationId: `${participant.id}:${source}`, track });
-}
-function validateTrack(source, track) {
-  const expectedKind = source === "microphone" ? "audio" : "video";
-  if (track.kind !== expectedKind) throw new CloudflareRTKError(`A ${source} track must be ${expectedKind}`, "invalid_target");
-}
-function isRTKAccess(value) {
-  return value.provider === "cloudflare_rtk";
-}
-function freezeSnapshot2(snapshot) {
-  const failure = snapshot.failure ? Object.freeze(snapshot.failure) : null;
-  return Object.freeze({
-    ...snapshot,
-    connection: Object.freeze(snapshot.connection),
-    localTracks: Object.freeze(snapshot.localTracks.map((track) => Object.freeze(track))),
-    remoteTracks: Object.freeze(snapshot.remoteTracks.map((track) => Object.freeze(track))),
-    failure
-  });
-}
-async function defaultClientFactory(input) {
-  const { default: RealtimeKitClient } = await import("@cloudflare/realtimekit");
-  const client = await RealtimeKitClient.init({
-    authToken: input.authToken,
-    defaults: { audio: false, video: false },
-    onError: input.onError
-  });
-  return adaptRealtimeKitClient(client);
-}
-function adaptRealtimeKitClient(client) {
-  const self = client.self;
-  return {
-    join: () => client.join(),
-    leave: () => client.leave(),
-    self: {
-      get peerId() {
-        return self.peerId;
-      },
-      get audioEnabled() {
-        return self.audioEnabled;
-      },
-      get videoEnabled() {
-        return self.videoEnabled;
-      },
-      get screenShareEnabled() {
-        return self.screenShareEnabled;
-      },
-      get audioTrack() {
-        return self.audioTrack ?? null;
-      },
-      get videoTrack() {
-        return self.videoTrack ?? null;
-      },
-      get screenShareTracks() {
-        return {
-          ...self.screenShareTracks.audio ? { audio: self.screenShareTracks.audio } : {},
-          ...self.screenShareTracks.video ? { video: self.screenShareTracks.video } : {}
-        };
-      },
-      enableAudio: (customTrack) => self.enableAudio(customTrack),
-      enableVideo: (customTrack) => self.enableVideo(customTrack),
-      enableScreenShare: () => self.enableScreenShare(),
-      disableAudio: () => self.disableAudio(),
-      disableVideo: () => self.disableVideo(),
-      disableScreenShare: () => self.disableScreenShare(),
-      onAudioUpdate: (listener) => {
-        self.on("audioUpdate", listener);
-        return () => self.off("audioUpdate", listener);
-      },
-      onVideoUpdate: (listener) => {
-        self.on("videoUpdate", listener);
-        return () => self.off("videoUpdate", listener);
-      },
-      onScreenShareUpdate: (listener) => {
-        self.on("screenShareUpdate", listener);
-        return () => self.off("screenShareUpdate", listener);
-      },
-      onLeft: (listener) => {
-        self.on("roomLeft", listener);
-        return () => self.off("roomLeft", listener);
-      }
-    },
-    participants: {
-      joined: {
-        list: () => client.participants.joined.toArray().map(toParticipant),
-        onJoined: (listener) => {
-          const callback = (participant) => listener(toParticipant(participant));
-          client.participants.joined.on("participantJoined", callback);
-          return () => client.participants.joined.off("participantJoined", callback);
-        },
-        onLeft: (listener) => {
-          const callback = (participant) => listener(toParticipant(participant));
-          client.participants.joined.on("participantLeft", callback);
-          return () => client.participants.joined.off("participantLeft", callback);
-        }
-      }
-    }
-  };
-}
-function toParticipant(participant) {
-  return {
-    id: participant.id,
-    userId: participant.userId,
-    ...participant.customParticipantId === void 0 ? {} : { customParticipantId: participant.customParticipantId },
-    audioEnabled: participant.audioEnabled,
-    videoEnabled: participant.videoEnabled,
-    screenShareEnabled: participant.screenShareEnabled,
-    audioTrack: participant.audioTrack ?? null,
-    videoTrack: participant.videoTrack ?? null,
-    screenShareTracks: {
-      ...participant.screenShareTracks.audio ? { audio: participant.screenShareTracks.audio } : {},
-      ...participant.screenShareTracks.video ? { video: participant.screenShareTracks.video } : {}
-    },
-    onAudioUpdate: (listener) => {
-      const callback = () => listener();
-      participant.on("audioUpdate", callback);
-      return () => participant.off("audioUpdate", callback);
-    },
-    onVideoUpdate: (listener) => {
-      const callback = () => listener();
-      participant.on("videoUpdate", callback);
-      return () => participant.off("videoUpdate", callback);
-    },
-    onScreenShareUpdate: (listener) => {
-      const callback = () => listener();
-      participant.on("screenShareUpdate", callback);
-      return () => participant.off("screenShareUpdate", callback);
-    }
-  };
-}
-
 // src/media/capture-error.ts
 function describeMediaCaptureError(cause) {
   const name = typeof cause === "object" && cause !== null && "name" in cause ? cause.name : void 0;
@@ -1988,6 +1521,7 @@ function describeMediaCaptureError(cause) {
 }
 
 export {
+  describeMediaCaptureError,
   CloudflareSFUError,
   parseCloudflareSFUPublicationID,
   requireDescription,
@@ -1997,8 +1531,5 @@ export {
   publicationKey,
   waitFor,
   CloudflareSFUClient,
-  createCloudflareSFUHTTPTransport,
-  CloudflareRTKError,
-  CloudflareRTKClient,
-  describeMediaCaptureError
+  createCloudflareSFUHTTPTransport
 };