@q9labsai/chalk-client 4.0.0

package/dist/chunk-PBCGWE2V.js

@@ -0,0 +1,811 @@
+// src/media/types.ts
+var CloudflareSFUError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "CloudflareSFUError";
+  }
+  code;
+};
+
+// src/media/tracks.ts
+function parseCloudflareSFUPublicationID(publicationId) {
+  if (publicationId.startsWith("chalk_pub_v1.")) return parseVersionOnePublicationReference(publicationId.slice("chalk_pub_v1.".length));
+  if (publicationId.startsWith("chalk_pub_")) throw new CloudflareSFUError("Cloudflare SFU publication ID uses an unsupported version", "invalid_publication");
+  return parseLegacyPublicationReference(publicationId);
+}
+function parseVersionOnePublicationReference(encoded) {
+  if (!encoded || !/^[A-Za-z0-9_-]+$/.test(encoded) || encoded.length % 4 === 1) {
+    throw new CloudflareSFUError("Cloudflare SFU publication ID is malformed", "invalid_publication");
+  }
+  try {
+    const standard = encoded.replaceAll("-", "+").replaceAll("_", "/");
+    const padded = standard.padEnd(standard.length + (4 - standard.length % 4) % 4, "=");
+    const binary = globalThis.atob(padded);
+    const canonical = globalThis.btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+    if (canonical !== encoded) throw new Error("non-canonical publication payload");
+    const bytes = Uint8Array.from(binary, (character) => character.charCodeAt(0));
+    const decoded = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    if (!isVersionOnePublicationPayload(decoded)) throw new Error("invalid publication payload");
+    return { connectionId: decoded.c, trackName: decoded.t };
+  } catch {
+    throw new CloudflareSFUError("Cloudflare SFU publication ID is malformed", "invalid_publication");
+  }
+}
+function isVersionOnePublicationPayload(value) {
+  if (!isRecord(value) || !hasExactKeys(value, ["c", "g", "m", "t"])) return false;
+  return isTrimmedNonEmptyString(value.c) && isTrimmedNonEmptyString(value.m) && isTrimmedNonEmptyString(value.t) && isPositiveSafeInteger(value.g);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasExactKeys(value, expected) {
+  const actual = Object.keys(value).sort();
+  return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
+}
+function isTrimmedNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0 && value.trim() === value;
+}
+function isPositiveSafeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+function parseLegacyPublicationReference(publicationId) {
+  const separator = publicationId.indexOf("|");
+  if (separator <= 0 || separator === publicationId.length - 1 || publicationId.indexOf("|", separator + 1) !== -1) {
+    throw new CloudflareSFUError("Cloudflare SFU publication ID is malformed", "invalid_publication");
+  }
+  const connectionId = publicationId.slice(0, separator);
+  const trackName = publicationId.slice(separator + 1);
+  if (connectionId.trim() !== connectionId || trackName.trim() !== trackName) throw new CloudflareSFUError("Cloudflare SFU publication ID is malformed", "invalid_publication");
+  return { connectionId, trackName };
+}
+function requireDescription(description) {
+  if (description.type !== "offer" && description.type !== "answer" || !description.sdp) {
+    throw new CloudflareSFUError("Browser SDP description is incomplete", "media_failed");
+  }
+  return { type: description.type, sdp: description.sdp };
+}
+function requireSFUDescription(description) {
+  if (!description) throw new CloudflareSFUError("Cloudflare did not return an SDP answer", "signaling_failed");
+  return description;
+}
+function validatePublicationSnapshot(snapshot) {
+  if (!Number.isSafeInteger(snapshot.incarnation) || snapshot.incarnation < 0 || !Number.isSafeInteger(snapshot.sequence) || snapshot.sequence < 0) {
+    throw new CloudflareSFUError("Cloudflare SFU publication cursor is invalid", "invalid_publication");
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const publication of snapshot.publications) {
+    if (!publication.participantId.trim() || !publication.publicationId.trim()) {
+      throw new CloudflareSFUError("Cloudflare SFU publication is incomplete", "invalid_publication");
+    }
+    const key = publicationKey(publication);
+    if (seen.has(key)) throw new CloudflareSFUError("Cloudflare SFU publication snapshot contains duplicate participant sources", "invalid_publication");
+    seen.add(key);
+    parseCloudflareSFUPublicationID(publication.publicationId);
+  }
+  return { incarnation: snapshot.incarnation, sequence: snapshot.sequence, signature: publicationSignature(snapshot.publications) };
+}
+function comparePublicationCursor(current, next) {
+  if (!current || next.incarnation > current.incarnation || next.incarnation === current.incarnation && next.sequence > current.sequence) return "newer";
+  if (next.incarnation < current.incarnation || next.sequence < current.sequence) return "stale";
+  if (next.signature !== current.signature) throw new CloudflareSFUError("Cloudflare SFU returned conflicting data for one publication cursor", "invalid_publication");
+  return "same";
+}
+function publicationKey(publication) {
+  return `${publication.participantId}\0${publication.source}`;
+}
+function publicationSignature(publications) {
+  return [...publications].sort((left, right) => publicationKey(left).localeCompare(publicationKey(right))).map((publication) => `${publicationKey(publication)}\0${publication.publicationId}`).join("
");
+}
+async function waitFor(predicate, timeoutMs, timeoutMessage = "Timed out waiting for a remote media track") {
+  const deadline = Date.now() + timeoutMs;
+  while (!predicate()) {
+    if (Date.now() >= deadline) throw new CloudflareSFUError(timeoutMessage, "media_failed");
+    await new Promise((resolve) => globalThis.setTimeout(resolve, 20));
+  }
+}
+
+// src/media/client.ts
+var EMPTY_LOCAL = Object.freeze([]);
+var EMPTY_REMOTE = Object.freeze([]);
+var CONNECTION_TIMEOUT_MS = 8e3;
+var CloudflareSFUClient = class {
+  #localListeners = /* @__PURE__ */ new Set();
+  #onError;
+  #onRemoteTrack;
+  #onScreenEnded;
+  #participantId;
+  #peerConnectionFactory;
+  #pollIntervalMs;
+  #remoteListeners = /* @__PURE__ */ new Set();
+  #snapshotListeners = /* @__PURE__ */ new Set();
+  #localTracks = /* @__PURE__ */ new Map();
+  #reusableLocalTransceivers = /* @__PURE__ */ new Map();
+  #remoteTracks = /* @__PURE__ */ new Map();
+  #bootstrap;
+  #connection;
+  #cursor = null;
+  #generation = 0;
+  #polling = false;
+  #pollTimer;
+  #sdpTail = Promise.resolve();
+  #snapshot;
+  #started = false;
+  #stopped = false;
+  #transport;
+  constructor(options) {
+    validateClientOptions(options);
+    this.#participantId = options.participantId;
+    this.#bootstrap = options.bootstrap;
+    this.#transport = options.transport;
+    this.#pollIntervalMs = options.pollIntervalMs ?? 1e3;
+    this.#onError = options.onError;
+    this.#onRemoteTrack = options.onRemoteTrack;
+    this.#onScreenEnded = options.onScreenEnded;
+    this.#peerConnectionFactory = options.peerConnectionFactory;
+    this.#connection = this.#createPeerConnection(options.bootstrap);
+    this.#snapshot = freezeSnapshot({
+      connection: { phase: "idle", peerConnectionState: this.#connection.connectionState, iceConnectionState: this.#connection.iceConnectionState },
+      cursor: null,
+      localTracks: EMPTY_LOCAL,
+      remoteTracks: EMPTY_REMOTE,
+      failure: null
+    });
+    this.#observeConnection(this.#connection, this.#generation);
+  }
+  getSnapshot() {
+    return this.#snapshot;
+  }
+  subscribe(listener) {
+    this.#snapshotListeners.add(listener);
+    return () => this.#snapshotListeners.delete(listener);
+  }
+  prepareLocalTrack(source, track) {
+    this.#requireActive();
+    validateTrackSource(source, track);
+    if (this.#localTracks.has(source)) throw new CloudflareSFUError(`A ${source} track is already prepared`, "media_failed");
+    const state = {
+      source,
+      track,
+      transceiver: this.#reusableLocalTransceivers.get(source) ?? null,
+      providerPublicationId: null,
+      pendingOperationId: null,
+      pendingTrackName: null,
+      desiredEnabled: false,
+      enabled: false,
+      endedListener: null
+    };
+    this.#reusableLocalTransceivers.delete(source);
+    if (source === "screen") {
+      state.endedListener = () => {
+        if (this.#localTracks.get("screen") === state) this.#invokeListener(() => this.#onScreenEnded?.());
+      };
+      track.addEventListener("ended", state.endedListener);
+    }
+    this.#localTracks.set(source, state);
+    this.#publishSnapshot();
+    this.#emitLocal();
+  }
+  async clearPreparedLocalTrack(source) {
+    const state = this.#localTracks.get(source);
+    if (!state) return;
+    if (state.enabled) await this.#setPreparedTrackEnabled(state, false);
+    if (state.transceiver) this.#reusableLocalTransceivers.set(source, state.transceiver);
+    this.#removeOwnedLocalTrack(state);
+    this.#localTracks.delete(source);
+    this.#publishSnapshot();
+    this.#emitLocal();
+  }
+  async start(localMedia) {
+    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);
+    await this.#activatePreparedTracks(
+      [...this.#localTracks.values()].filter((state) => state.source !== "screen"),
+      generation
+    );
+  }
+  async refreshRemotePublications() {
+    if (!this.#started || this.#stopped || this.#polling) return;
+    this.#polling = true;
+    const generation = this.#generation;
+    try {
+      const transport = this.#requireTransport();
+      const authoritative = await transport.listPublications();
+      this.#requireGeneration(generation);
+      await this.#reconcileRemotePublications(authoritative, generation);
+    } catch (error) {
+      if (generation === this.#generation && !this.#stopped) this.#reportError(error);
+      throw error;
+    } finally {
+      if (generation === this.#generation) this.#polling = false;
+    }
+  }
+  async setLocalPublicationTarget(target) {
+    if (target.participantId !== this.#participantId) return { outcome: "terminal_failure", errorCode: "invalid_participant" };
+    if (this.#stopped) return { outcome: "terminal_failure", errorCode: "media_stopped" };
+    const state = this.#localTracks.get(target.source);
+    if (!state) return { outcome: "terminal_failure", errorCode: "source_unavailable" };
+    if (state.enabled === target.enabled) return { outcome: "satisfied", errorCode: null };
+    try {
+      await this.#setPreparedTrackEnabled(state, target.enabled, target.operationId);
+      return { outcome: "confirmed", errorCode: null };
+    } catch (error) {
+      if (!this.#stopped) this.#reportError(error);
+      return { outcome: "retryable_failure", errorCode: error instanceof CloudflareSFUError ? error.code : "media_failed" };
+    }
+  }
+  observeLocalPublications(listener) {
+    this.#localListeners.add(listener);
+    this.#invokeListener(() => listener(this.#projectLocalPublications()));
+    return () => this.#localListeners.delete(listener);
+  }
+  observeRemotePublications(listener) {
+    this.#remoteListeners.add(listener);
+    this.#invokeListener(() => listener(this.#projectRemotePublications()));
+    return () => this.#remoteListeners.delete(listener);
+  }
+  async restart(input) {
+    this.#requireActive();
+    const options = "connectionId" in input ? { bootstrap: input } : input;
+    validateBootstrap(options.bootstrap);
+    const generation = ++this.#generation;
+    this.#polling = false;
+    this.#clearPoll();
+    this.#disposeConnection(false);
+    this.#reusableLocalTransceivers.clear();
+    this.#clearRemoteTracks();
+    this.#cursor = null;
+    this.#bootstrap = options.bootstrap;
+    if (options.transport) this.#transport = options.transport;
+    this.#connection = this.#createPeerConnection(options.bootstrap);
+    this.#observeConnection(this.#connection, generation);
+    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);
+      this.#started = true;
+      this.#setPhase("live", null);
+      this.#schedulePoll(0);
+    } catch (error) {
+      if (generation === this.#generation && !this.#stopped) this.#setFailure(error, "media_failed");
+      throw error;
+    }
+  }
+  stop() {
+    if (this.#stopped) return;
+    this.#stopped = true;
+    this.#generation++;
+    this.#clearPoll();
+    this.#polling = false;
+    this.#disposeConnection(true);
+    this.#reusableLocalTransceivers.clear();
+    this.#clearRemoteTracks();
+    for (const state of this.#localTracks.values()) this.#removeOwnedLocalTrack(state);
+    this.#localTracks.clear();
+    this.#transport = void 0;
+    this.#started = false;
+    this.#cursor = null;
+    this.#publishSnapshot("stopped", null);
+    this.#emitLocal();
+    this.#emitRemote();
+    this.#localListeners.clear();
+    this.#remoteListeners.clear();
+    this.#snapshotListeners.clear();
+  }
+  async #setPreparedTrackEnabled(state, enabled, operationId) {
+    if (enabled) return this.#enablePreparedTrack(state, operationId);
+    return this.#disablePreparedTrack(state);
+  }
+  async #enablePreparedTrack(state, operationId) {
+    if (operationId && state.pendingOperationId !== operationId) {
+      state.pendingOperationId = operationId;
+      state.pendingTrackName = `${state.source}-${operationId}`;
+    }
+    state.desiredEnabled = true;
+    state.track.enabled = true;
+    try {
+      await this.#publishPreparedTracks([state], this.#generation);
+    } catch (error) {
+      state.desiredEnabled = false;
+      state.enabled = false;
+      state.track.enabled = false;
+      throw error;
+    }
+  }
+  async #disablePreparedTrack(state) {
+    const transceiver = state.transceiver;
+    state.desiredEnabled = false;
+    state.track.enabled = false;
+    try {
+      if (transceiver) await transceiver.sender.replaceTrack(null);
+    } catch (error) {
+      state.desiredEnabled = true;
+      state.track.enabled = true;
+      throw error;
+    }
+    state.enabled = false;
+    state.providerPublicationId = null;
+    state.pendingOperationId = null;
+    state.pendingTrackName = null;
+    this.#publishSnapshot();
+    this.#emitLocal();
+  }
+  async #publishPreparedTracks(states, generation) {
+    if (states.length === 0) return;
+    const connection = this.#connection;
+    const bootstrap = this.#bootstrap;
+    await this.#serializeSDP(() => this.#publishPreparedTracksSerialized(states, generation, connection, bootstrap.connectionId));
+  }
+  async #publishPreparedTracksSerialized(states, generation, connection, connectionId) {
+    this.#requireGeneration(generation);
+    const pendingStates = states.filter((state) => !state.enabled);
+    if (pendingStates.length === 0) return;
+    const wasLive = connectionIsLive(connection);
+    const publications = [];
+    try {
+      for (const state of pendingStates) publications.push(await this.#prepareLocalPublication(connection, state));
+      const response = await this.#negotiateLocalPublications(connection, connectionId, publications, generation);
+      if (!wasLive) await this.#waitForConnection(connection, generation);
+      this.#requireGeneration(generation);
+      this.#confirmLocalPublications(publications, response.tracks);
+      this.#publishSnapshot();
+      this.#emitLocal();
+    } catch (error) {
+      await this.#rollbackLocalOffer(connection);
+      await this.#discardLocalPublications(publications);
+      throw error;
+    }
+  }
+  async #prepareLocalPublication(connection, state) {
+    const reusedTransceiver = state.transceiver !== null;
+    const transceiver = state.transceiver ?? connection.addTransceiver(state.track, { direction: "sendonly" });
+    if (reusedTransceiver) await transceiver.sender.replaceTrack(state.track);
+    state.transceiver = transceiver;
+    return { state, transceiver, trackName: state.pendingTrackName ?? `${state.source}-${globalThis.crypto.randomUUID()}`, reusedTransceiver };
+  }
+  async #negotiateLocalPublications(connection, connectionId, publications, generation) {
+    const offer = await connection.createOffer();
+    await connection.setLocalDescription(offer);
+    const tracks = publications.map(
+      ({ state, transceiver, trackName }) => ({
+        location: "local",
+        mid: requireTransceiverMid(transceiver),
+        trackName,
+        source: state.source
+      })
+    );
+    const response = await this.#requireTransport().addTracks({ connectionId, sessionDescription: requireDescription(offer), tracks });
+    this.#requireGeneration(generation);
+    await connection.setRemoteDescription(requireSFUDescription(response.sessionDescription));
+    return response;
+  }
+  #confirmLocalPublications(publications, tracks) {
+    for (const { state, transceiver } of publications) {
+      const authoritative = tracks?.find((track) => track.location === "local" && track.mid === transceiver.mid && track.source === state.source);
+      if (!authoritative?.publicationId) throw new CloudflareSFUError("Chalk did not return an authoritative local publication ID", "invalid_publication");
+      state.desiredEnabled = true;
+      state.enabled = true;
+      state.providerPublicationId = authoritative.publicationId;
+      state.pendingOperationId = null;
+      state.pendingTrackName = null;
+    }
+  }
+  async #discardLocalPublications(publications) {
+    for (const { state, transceiver, reusedTransceiver } of publications) {
+      if (reusedTransceiver) {
+        try {
+          await transceiver.sender.replaceTrack(null);
+        } catch (error) {
+          this.#reportError(error);
+        }
+        continue;
+      }
+      try {
+        transceiver.stop();
+      } catch (error) {
+        this.#reportError(error);
+      }
+      if (state.transceiver === transceiver) state.transceiver = null;
+    }
+  }
+  async #rollbackLocalOffer(connection) {
+    if (connection.signalingState !== "have-local-offer") return;
+    try {
+      await connection.setLocalDescription({ type: "rollback" });
+    } catch (error) {
+      this.#reportError(error);
+    }
+  }
+  async #reconcileRemotePublications(authoritative, generation) {
+    const cursor = validatePublicationSnapshot(authoritative);
+    const ordering = comparePublicationCursor(this.#cursor, cursor);
+    if (ordering !== "newer") return;
+    const desired = desiredRemotePublications(authoritative.publications, this.#participantId);
+    const toPull = [...desired].filter(([key, publication]) => this.#remoteTracks.get(key)?.publicationId !== publication.publicationId).map(([, publication]) => publication);
+    const pulled = await this.#pull(toPull, generation);
+    this.#requireGeneration(generation);
+    const next = reconcileRemoteTracks(desired, pulled, this.#remoteTracks);
+    stopReplacedRemoteTracks(this.#remoteTracks, next, this.#reportError.bind(this));
+    this.#remoteTracks.clear();
+    for (const [key, publication] of next) this.#remoteTracks.set(key, publication);
+    this.#cursor = cursor;
+    for (const publication of pulled) this.#invokeListener(() => this.#onRemoteTrack?.(publication));
+    this.#publishSnapshot();
+    this.#emitRemote();
+  }
+  async #pull(publications, generation) {
+    if (publications.length === 0) return [];
+    const connection = this.#connection;
+    const connectionId = this.#bootstrap.connectionId;
+    return this.#serializeSDP(async () => {
+      const requested = publications.map((publication) => {
+        const reference = parseCloudflareSFUPublicationID(publication.publicationId);
+        return { location: "remote", sessionId: reference.connectionId, trackName: reference.trackName };
+      });
+      const received = /* @__PURE__ */ new Map();
+      const onTrack = (event) => {
+        if (event.transceiver.mid !== null) received.set(event.transceiver.mid, event.track);
+      };
+      connection.addEventListener("track", onTrack);
+      try {
+        this.#requireGeneration(generation);
+        const response = await this.#requireTransport().addTracks({ connectionId, tracks: requested });
+        this.#requireGeneration(generation);
+        const responseTracks = response.tracks ?? [];
+        await this.#completeRenegotiation(response, connection, connectionId, generation);
+        await this.#waitForConnection(connection, generation);
+        await waitFor(() => responseTracks.every((track) => track.mid !== void 0 && received.has(track.mid)), 5e3);
+        this.#requireGeneration(generation);
+        return publications.map((publication, index) => {
+          const responseTrack = responseTracks[index];
+          const track = responseTrack?.mid === void 0 ? void 0 : received.get(responseTrack.mid);
+          if (!track) throw new CloudflareSFUError("A negotiated remote track did not arrive", "media_failed");
+          return Object.freeze({ ...publication, track });
+        });
+      } catch (error) {
+        for (const track of received.values()) safeStopTrack(track, this.#reportError.bind(this));
+        throw error;
+      } finally {
+        connection.removeEventListener("track", onTrack);
+      }
+    });
+  }
+  async #completeRenegotiation(response, connection, connectionId, generation) {
+    if (!response.requiresImmediateRenegotiation) return;
+    if (!response.sessionDescription) throw new CloudflareSFUError("Cloudflare did not return a remote-track offer", "signaling_failed");
+    await connection.setRemoteDescription(response.sessionDescription);
+    const answer = await connection.createAnswer();
+    await connection.setLocalDescription(answer);
+    await this.#requireTransport().renegotiate({ connectionId, sessionDescription: requireDescription(answer) });
+    this.#requireGeneration(generation);
+  }
+  #serializeSDP(operation) {
+    const result = this.#sdpTail.then(operation, operation);
+    this.#sdpTail = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
+  }
+  #waitForConnection(connection, generation) {
+    return waitFor(
+      () => {
+        this.#requireGeneration(generation);
+        return connectionIsLive(connection);
+      },
+      CONNECTION_TIMEOUT_MS,
+      "Timed out waiting for the Cloudflare SFU peer connection"
+    );
+  }
+  #observeConnection(connection, generation) {
+    const observe = () => {
+      if (generation !== this.#generation || this.#stopped) return;
+      const observation = observeConnectionState(connection.connectionState, connection.iceConnectionState, this.#started);
+      if (observation) this.#publishSnapshot(observation.phase, observation.failure);
+      else this.#publishSnapshot();
+    };
+    connection.addEventListener("connectionstatechange", observe);
+    connection.addEventListener("iceconnectionstatechange", observe);
+  }
+  #createPeerConnection(bootstrap) {
+    const create = this.#peerConnectionFactory ?? ((configuration) => new RTCPeerConnection(configuration));
+    return create({ iceServers: [{ urls: bootstrap.stunServer }], bundlePolicy: "max-bundle" });
+  }
+  #disposeConnection(stopSenders) {
+    if (stopSenders) {
+      for (const sender of this.#connection.getSenders()) {
+        if (sender.track) safeStopTrack(sender.track, this.#reportError.bind(this));
+      }
+    }
+    for (const transceiver of this.#connection.getTransceivers()) {
+      try {
+        transceiver.stop();
+      } catch (error) {
+        this.#reportError(error);
+      }
+    }
+    try {
+      this.#connection.close();
+    } catch (error) {
+      this.#reportError(error);
+    }
+  }
+  #removeOwnedLocalTrack(state) {
+    if (state.endedListener) state.track.removeEventListener("ended", state.endedListener);
+    safeStopTrack(state.track, this.#reportError.bind(this));
+    state.enabled = false;
+    state.desiredEnabled = false;
+    state.transceiver = null;
+    state.providerPublicationId = null;
+    state.pendingOperationId = null;
+    state.pendingTrackName = null;
+    state.endedListener = null;
+  }
+  #clearRemoteTracks() {
+    for (const publication of this.#remoteTracks.values()) safeStopTrack(publication.track, this.#reportError.bind(this));
+    this.#remoteTracks.clear();
+    this.#publishSnapshot();
+    this.#emitRemote();
+  }
+  #schedulePoll(delayMs = this.#pollIntervalMs) {
+    if (this.#stopped || !this.#started || this.#pollTimer !== void 0) return;
+    this.#pollTimer = globalThis.setTimeout(async () => {
+      this.#pollTimer = void 0;
+      try {
+        await this.refreshRemotePublications();
+      } catch {
+      } finally {
+        this.#schedulePoll();
+      }
+    }, delayMs);
+  }
+  #clearPoll() {
+    if (this.#pollTimer !== void 0) globalThis.clearTimeout(this.#pollTimer);
+    this.#pollTimer = void 0;
+  }
+  #projectLocalPublications() {
+    return [...this.#localTracks.values()].map((state) => ({
+      participantId: this.#participantId,
+      source: state.source,
+      enabled: state.enabled,
+      publicationId: state.enabled ? state.providerPublicationId : null
+    }));
+  }
+  #projectRemotePublications() {
+    return [...this.#remoteTracks.values()].map(({ participantId, source, publicationId }) => ({ participantId, source, publicationId, enabled: true }));
+  }
+  #publishSnapshot(phase = this.#snapshot.connection.phase, failure = this.#snapshot.failure) {
+    const next = freezeSnapshot({
+      connection: {
+        phase,
+        peerConnectionState: this.#connection.connectionState,
+        iceConnectionState: this.#connection.iceConnectionState
+      },
+      cursor: this.#cursor ? { incarnation: this.#cursor.incarnation, sequence: this.#cursor.sequence } : null,
+      localTracks: this.#localTracks.size ? [...this.#localTracks.values()].map(
+        (state) => Object.freeze({
+          source: state.source,
+          enabled: state.enabled,
+          publicationId: state.enabled ? state.providerPublicationId : null,
+          track: state.track
+        })
+      ) : EMPTY_LOCAL,
+      remoteTracks: this.#remoteTracks.size ? [...this.#remoteTracks.values()] : EMPTY_REMOTE,
+      failure
+    });
+    if (snapshotEqual(this.#snapshot, next)) return;
+    this.#snapshot = next;
+    for (const listener of this.#snapshotListeners) this.#invokeListener(listener);
+  }
+  #setPhase(phase, failure) {
+    this.#publishSnapshot(phase, failure);
+  }
+  #setFailure(error, fallback) {
+    const code = error instanceof CloudflareSFUError ? error.code : fallback;
+    this.#publishSnapshot("failed", { code, recoverable: code !== "invalid_bootstrap" && code !== "invalid_target" && code !== "invalid_publication" });
+    this.#reportError(error);
+  }
+  #emitLocal() {
+    const publications = this.#projectLocalPublications();
+    for (const listener of this.#localListeners) this.#invokeListener(() => listener(publications));
+  }
+  #emitRemote() {
+    const publications = this.#projectRemotePublications();
+    for (const listener of this.#remoteListeners) this.#invokeListener(() => listener(publications));
+  }
+  #invokeListener(listener) {
+    try {
+      listener();
+    } catch (error) {
+      this.#reportError(error);
+    }
+  }
+  #reportError(error) {
+    try {
+      this.#onError?.(error);
+    } catch {
+    }
+  }
+  #requireGeneration(generation) {
+    if (generation !== this.#generation || this.#stopped) throw new CloudflareSFUError("Cloudflare SFU operation belongs to a stale connection generation", "stale_generation");
+  }
+  #requireActive() {
+    if (this.#stopped) throw new CloudflareSFUError("Cloudflare SFU client is stopped", "media_failed");
+  }
+  #requireTransport() {
+    if (!this.#transport) throw new CloudflareSFUError("Cloudflare SFU signaling transport is unavailable", "signaling_failed");
+    return this.#transport;
+  }
+};
+function validateClientOptions(options) {
+  validateBootstrap(options.bootstrap);
+  if (!options.participantId.trim()) throw new CloudflareSFUError("Cloudflare SFU participant is missing", "invalid_bootstrap");
+  if (options.pollIntervalMs !== void 0 && (!Number.isFinite(options.pollIntervalMs) || options.pollIntervalMs < 0)) {
+    throw new CloudflareSFUError("Cloudflare SFU polling interval is invalid", "invalid_bootstrap");
+  }
+}
+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";
+  if (!valid) throw new CloudflareSFUError(`The prepared ${source} track has an incompatible kind`, "media_failed");
+}
+function desiredRemotePublications(publications, participantId) {
+  return new Map(publications.filter((publication) => publication.participantId !== participantId).map((publication) => [publicationKey(publication), publication]));
+}
+function reconcileRemoteTracks(desired, pulled, current) {
+  const pulledByKey = new Map(pulled.map((publication) => [publicationKey(publication), publication]));
+  return new Map(
+    [...desired].map(([key, publication]) => {
+      const track = pulledByKey.get(key) ?? current.get(key);
+      if (!track || track.publicationId !== publication.publicationId) throw new CloudflareSFUError("Cloudflare SFU did not return a requested remote track", "media_failed");
+      return [key, track];
+    })
+  );
+}
+function stopReplacedRemoteTracks(current, next, onError) {
+  for (const [key, previous] of current) {
+    if (next.get(key) !== previous) safeStopTrack(previous.track, onError);
+  }
+}
+function observeConnectionState(peerState, iceState, started) {
+  if (peerState === "failed") return { phase: "failed", failure: { code: "peer_connection_failed", recoverable: true } };
+  if (iceState === "failed") return { phase: "failed", failure: { code: "ice_connection_failed", recoverable: true } };
+  if (peerState === "disconnected" || iceState === "disconnected") return { phase: "recovering", failure: null };
+  if (started && peerState === "connected" && (iceState === "connected" || iceState === "completed")) return { phase: "live", failure: null };
+  return null;
+}
+function connectionIsLive(connection) {
+  return connection.connectionState === "connected" && (connection.iceConnectionState === "connected" || connection.iceConnectionState === "completed");
+}
+function requireTransceiverMid(transceiver) {
+  if (transceiver.mid === null) throw new CloudflareSFUError("Browser did not assign a media section", "media_failed");
+  return transceiver.mid;
+}
+function safeStopTrack(track, onError) {
+  try {
+    track.stop();
+  } catch (error) {
+    onError(error);
+  }
+}
+function freezeSnapshot(snapshot) {
+  const failure = snapshot.failure ? Object.freeze(snapshot.failure) : null;
+  return Object.freeze({
+    ...snapshot,
+    connection: Object.freeze(snapshot.connection),
+    cursor: snapshot.cursor ? Object.freeze(snapshot.cursor) : null,
+    localTracks: Object.freeze(snapshot.localTracks),
+    remoteTracks: Object.freeze(snapshot.remoteTracks),
+    failure
+  });
+}
+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;
+}
+function connectionEqual(left, right) {
+  return left.phase === right.phase && left.peerConnectionState === right.peerConnectionState && left.iceConnectionState === right.iceConnectionState;
+}
+function cursorEqual(left, right) {
+  return left?.incarnation === right?.incarnation && left?.sequence === right?.sequence;
+}
+function failureEqual(left, right) {
+  return left?.code === right?.code && left?.recoverable === right?.recoverable;
+}
+function publicationEqual(left, right) {
+  return right !== void 0 && left.source === right.source && left.enabled === right.enabled && left.publicationId === right.publicationId && left.track === right.track;
+}
+function remotePublicationEqual(left, right) {
+  return right !== void 0 && left.participantId === right.participantId && left.source === right.source && left.publicationId === right.publicationId && left.track === right.track;
+}
+
+// src/media/transport.ts
+function createCloudflareSFUHTTPTransport(options) {
+  const fetch = options.fetch ?? globalThis.fetch;
+  const credential = requireCredential(options);
+  const base = options.apiBaseURL.replace(/\/$/, "");
+  const mediaPath = `${base}/v1/tenants/${encodeURIComponent(options.tenantId)}/spaces/${encodeURIComponent(options.spaceId)}/episodes/${encodeURIComponent(options.episodeId)}/participants/${encodeURIComponent(options.participantId)}/media/sfu`;
+  const request = async (path, init) => {
+    const token = await credential();
+    if (!token.trim()) throw new CloudflareSFUError("The media credential provider returned an empty token", "signaling_failed");
+    const response = await fetch(`${mediaPath}/${path}`, {
+      ...init,
+      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");
+    return await response.json();
+  };
+  return {
+    addTracks: async (input) => {
+      const response = await request("tracks", {
+        method: "POST",
+        body: JSON.stringify({ connection_id: input.connectionId, session_description: input.sessionDescription, tracks: input.tracks })
+      });
+      return {
+        ...response,
+        tracks: response.tracks?.map(({ publication_id, ...track }) => ({ ...track, publicationId: publication_id }))
+      };
+    },
+    closeTracks: async (input) => request("tracks/close", {
+      method: "PUT",
+      body: JSON.stringify({
+        connection_id: input.connectionId,
+        session_description: input.sessionDescription,
+        tracks: input.tracks.map((track) => ({ mid: track.mid, source: track.source, publication_id: track.publicationId })),
+        force: input.force
+      })
+    }),
+    renegotiate: async (input) => {
+      await request("renegotiate", {
+        method: "POST",
+        body: JSON.stringify({ connection_id: input.connectionId, session_description: input.sessionDescription })
+      });
+    },
+    listPublications: async () => {
+      const response = await request("publications");
+      return {
+        incarnation: response.incarnation,
+        sequence: response.sequence,
+        publications: response.publications.map((publication) => ({
+          participantId: publication.participant_id ?? publication.participant_session_id ?? "",
+          source: publication.source,
+          publicationId: publication.publication_id
+        }))
+      };
+    }
+  };
+}
+function requireCredential(options) {
+  if (options.credential) return options.credential;
+  if (options.bearerToken !== void 0) return () => options.bearerToken ?? "";
+  throw new CloudflareSFUError("A media credential provider is required", "signaling_failed");
+}
+
+export {
+  CloudflareSFUError,
+  parseCloudflareSFUPublicationID,
+  requireDescription,
+  requireSFUDescription,
+  validatePublicationSnapshot,
+  comparePublicationCursor,
+  publicationKey,
+  waitFor,
+  CloudflareSFUClient,
+  createCloudflareSFUHTTPTransport
+};