@q9labsai/chalk-client 5.2.6 → 5.3.1

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

@@ -1,3 +1,197 @@
+import {
+  withRequestContext
+} from "./chunk-N4IPKRS6.js";
+
+// src/media/receive-stall.ts
+var RECEIVE_STALL_WINDOW_MS = 7e3;
+var RECEIVE_STARTUP_GRACE_MS = 2e4;
+var MAX_SAMPLE_GAP_MS = 3e3;
+var ReceiveStallDetector = class {
+  #progress = /* @__PURE__ */ new Map();
+  #sampledAt;
+  forget(publicationId) {
+    this.#progress.delete(publicationId);
+  }
+  clear() {
+    this.#progress.clear();
+    this.#sampledAt = void 0;
+  }
+  sample(now, tracks) {
+    if (this.#sampledAt !== void 0 && (now - this.#sampledAt > MAX_SAMPLE_GAP_MS || now < this.#sampledAt)) this.clear();
+    this.#sampledAt = now;
+    const observed = new Set(tracks.map((track) => track.publicationId));
+    for (const id of this.#progress.keys()) if (!observed.has(id)) this.#progress.delete(id);
+    const observations = tracks.map((track) => ({ id: track.publicationId, outcome: this.#observeTrack(now, track) }));
+    return {
+      stalled: observations.filter((track) => track.outcome === "stalled").map((track) => track.id),
+      resumed: observations.filter((track) => track.outcome === "resumed").map((track) => track.id),
+      advanced: observations.filter((track) => track.outcome === "advanced" || track.outcome === "resumed").map((track) => track.id)
+    };
+  }
+  #observeTrack(now, { publicationId, trackId, packets }) {
+    const previous = this.#progress.get(publicationId);
+    const sameTrack = previous?.trackId === trackId;
+    if (sameTrack && previous.packets === packets) {
+      const window = previous.flowing ? RECEIVE_STALL_WINDOW_MS : RECEIVE_STARTUP_GRACE_MS;
+      return now - previous.advancedAt >= window ? "stalled" : null;
+    }
+    return this.#advanceTrack(now, { publicationId, trackId, packets }, previous);
+  }
+  #advanceTrack(now, { publicationId, trackId, packets }, previous) {
+    const advanced = previous?.trackId === trackId && packets > previous.packets;
+    const flowingSince = advanced && now - previous.advancedAt < RECEIVE_STALL_WINDOW_MS ? previous.flowingSince : now;
+    this.#progress.set(publicationId, { trackId, packets, advancedAt: now, flowing: advanced, flowingSince });
+    if (!advanced) return null;
+    return now - flowingSince >= RECEIVE_STALL_WINDOW_MS ? "resumed" : "advanced";
+  }
+};
+var MAX_RECEIVE_REBUILDS = 2;
+var MAX_RECEIVE_OBSERVATIONS = 32;
+var ReceiveStallRecovery = class {
+  #detector = new ReceiveStallDetector();
+  #attempts = /* @__PURE__ */ new Map();
+  #sources = /* @__PURE__ */ new Map();
+  #repulled = /* @__PURE__ */ new Set();
+  // Re-pulled but not yet restored. Retired receivers vanish from stats, so this cannot depend on detector samples.
+  #awaiting = /* @__PURE__ */ new Set();
+  #identities = /* @__PURE__ */ new Map();
+  #expected = /* @__PURE__ */ new Set();
+  #screens = /* @__PURE__ */ new Set();
+  #stalled = /* @__PURE__ */ new Set();
+  #active = [];
+  #observations = Object.freeze([]);
+  get observations() {
+    return this.#observations;
+  }
+  expect(publications, participantId) {
+    const enabled = publications.filter((publication) => publication.participantId !== participantId && publication.enabled);
+    this.#expected = new Set(enabled.flatMap((publication) => publication.publicationId ? [publication.publicationId] : []));
+    this.#screens = new Set(enabled.filter((publication) => publication.source === "screen").map((publication) => publication.participantId));
+    this.#pruneWithdrawn(publications);
+    this.#pruneAttempts(publications);
+    for (const publication of this.#identities.values()) {
+      if (this.#isExpected(publication)) continue;
+      this.#detector.forget(publication.publicationId);
+      this.#stalled.delete(publication.publicationId);
+      this.#awaiting.delete(publication.publicationId);
+    }
+    this.#active = [...this.#identities.values()].filter((publication) => this.#isExpected(publication)).map((publication) => publication.publicationId);
+  }
+  suspend() {
+    this.#expected.clear();
+    this.#screens.clear();
+    this.clear();
+  }
+  #pruneWithdrawn(publications) {
+    const advertised = new Set(publications.map((publication) => publication.publicationId));
+    const screens = new Set(publications.filter((publication) => publication.source === "screen").map((publication) => publication.participantId));
+    for (const [key, publication] of this.#identities) {
+      if (advertised.has(publication.publicationId) || publication.source === "screen_audio" && screens.has(publication.participantId)) continue;
+      this.#forget(publication.publicationId);
+      this.#identities.delete(key);
+    }
+  }
+  #pruneAttempts(publications) {
+    const advertised = new Set(publications.flatMap((publication) => publication.source === "screen" ? [sourceKey(publication), sourceKey({ ...publication, source: "screen_audio" })] : [sourceKey(publication)]));
+    for (const key of this.#attempts.keys()) if (!advertised.has(key)) this.#attempts.delete(key);
+  }
+  isStalled(publicationId) {
+    return this.#stalled.has(publicationId);
+  }
+  canRepull(id) {
+    return this.#stalled.has(id) && !this.#repulled.has(id);
+  }
+  reserveRepull(id) {
+    if (!this.canRepull(id)) return false;
+    this.#repulled.add(id);
+    this.#awaiting.add(id);
+    return true;
+  }
+  restarted(id) {
+    this.#detector.forget(id);
+    this.#stalled.delete(id);
+    this.#awaiting.delete(id);
+  }
+  canRebuild(id) {
+    return this.#active.some((active) => (id === void 0 || id === active) && this.#stalled.has(active) && this.#rebuildsLeft(active));
+  }
+  reserveRebuild() {
+    if (!this.canRebuild()) return false;
+    for (const id of this.#active) {
+      const source = this.#sources.get(id);
+      if (source !== void 0 && this.canRebuild(id)) this.#attempts.set(source, (this.#attempts.get(source) ?? 0) + 1);
+    }
+    return true;
+  }
+  #rebuildsLeft(id) {
+    const source = this.#sources.get(id);
+    return source !== void 0 && (this.#attempts.get(source) ?? 0) < MAX_RECEIVE_REBUILDS;
+  }
+  /** The media connection was replaced: its receivers are gone, so nothing is awaiting a restore. */
+  replaced() {
+    this.#awaiting.clear();
+    this.clear();
+  }
+  clear() {
+    this.#detector.clear();
+    this.#stalled.clear();
+    this.#active = [];
+  }
+  sample(now, connection, report, tracks) {
+    const active = [...tracks].filter((publication) => this.#isExpected(publication));
+    for (const publication of active) this.#rememberIdentity(publication);
+    this.#active = active.map((publication) => publication.publicationId);
+    const samples = active.flatMap((publication) => receivePacketSample(connection, report, publication) ?? []);
+    const { stalled, advanced, resumed } = this.#detector.sample(now, samples);
+    for (const id of resumed) {
+      const source = this.#sources.get(id);
+      if (source !== void 0) this.#attempts.delete(source);
+      this.#repulled.delete(id);
+      this.#awaiting.delete(id);
+    }
+    const newlyStalled = stalled.filter((id) => !this.#stalled.has(id));
+    const unrestored = this.#active.filter((id) => this.#awaiting.has(id) && !stalled.includes(id));
+    this.#stalled = /* @__PURE__ */ new Set([...stalled, ...unrestored]);
+    if (newlyStalled.length) this.#record(now);
+    return { stalled: [...stalled, ...unrestored], advanced, newlyStalled };
+  }
+  #isExpected(publication) {
+    return publication.source === "screen_audio" ? this.#screens.has(publication.participantId) : this.#expected.has(publication.publicationId);
+  }
+  #rememberIdentity(publication) {
+    const key = sourceKey(publication);
+    const previous = this.#identities.get(key);
+    if (previous && previous.publicationId !== publication.publicationId) this.#forget(previous.publicationId);
+    this.#identities.set(key, publication);
+    this.#sources.set(publication.publicationId, key);
+  }
+  #forget(id) {
+    this.#detector.forget(id);
+    this.#stalled.delete(id);
+    this.#awaiting.delete(id);
+    this.#repulled.delete(id);
+    this.#sources.delete(id);
+  }
+  #record(now) {
+    const observation = Object.freeze({ event: "receive_stalled", scope: this.#active.every((id) => this.#stalled.has(id)) ? "all" : "partial", observedAtMs: now, expectedTracks: this.#active.length, stalledTracks: this.#stalled.size });
+    this.#observations = Object.freeze([...this.#observations.slice(-(MAX_RECEIVE_OBSERVATIONS - 1)), observation]);
+  }
+};
+function sourceKey({ participantId, source }) {
+  return `${participantId}\0${source}`;
+}
+function receivePacketSample(connection, report, publication) {
+  const rows = [...report.values()].filter((row) => row.type === "inbound-rtp" && row.trackIdentifier === publication.track.id);
+  if (rows.some((row) => !Number.isSafeInteger(row.packetsReceived) || row.packetsReceived < 0)) return;
+  if (publication.track.kind === "audio" && !audioPacketCadenceKnown(connection, report, publication.track, rows)) return;
+  return { publicationId: publication.publicationId, trackId: publication.track.id, packets: rows.reduce((sum2, row) => sum2 + row.packetsReceived, 0) };
+}
+function audioPacketCadenceKnown(connection, report, track, rows) {
+  const negotiated = rows.length ? rows.map((row) => row.codecId ? report.get(row.codecId) : void 0) : connection.getReceivers().find((receiver) => receiver.track.id === track.id)?.getParameters().codecs ?? [];
+  const opus = negotiated.filter((codec) => codec?.mimeType?.toLowerCase() === "audio/opus");
+  return opus.length > 0 && opus.every((codec) => typeof codec.sdpFmtpLine === "string");
+}
+
 // src/media/camera-uplink.ts
 var CameraUplinkPolicy = class {
   #healthySamples = 0;
@@ -24,13 +218,223 @@ var CameraUplinkPolicy = class {
     this.#healthySamples = 0;
   }
 };
-function cameraUplinkBitrate(stats) {
-  for (const stat of stats) {
+function cameraUplinkBitrate(stats2) {
+  for (const stat of stats2) {
     if (stat.type === "candidate-pair" && stat.state === "succeeded" && (stat.nominated || stat.selected)) return stat.availableOutgoingBitrate;
   }
   return void 0;
 }
 
+// src/media/video-render-size.ts
+var sizes = /* @__PURE__ */ new WeakMap();
+function setVideoRenderSize(track, size) {
+  if (size === null) sizes.delete(track);
+  else sizes.set(track, size);
+}
+function videoRenderSize(track) {
+  return sizes.get(track);
+}
+
+// src/media/viewer-layer.ts
+var LOW_TILE_MAX_HEIGHT = 400;
+var HIGH_TILE_MIN_HEIGHT = 480;
+var BAD_LOSS = 0.05;
+var SEVERE_LOSS = 0.15;
+var SEVERE_FREEZE_SECONDS = 1;
+var GOOD_LOSS = 0.02;
+var MIN_FRAMES_PER_SECOND = 8;
+var DROP_AFTER_BAD_SAMPLES = 2;
+var RISE_AFTER_GOOD_SAMPLES = 15;
+var RISE_AFTER_TILE_GROWS_SAMPLES = 2;
+var SETTLE_SAMPLES = 2;
+var FAILED_PROBE_WITHIN_SAMPLES = 30;
+var STABLE_SAMPLES_RESETTING_BACKOFF = 60;
+var MAX_RISE_BACKOFF = 8;
+var FRAME_RATE_COMPARISON_SAMPLES = 3;
+var ViewerLayerPolicy = class {
+  #layer = "h";
+  #tileIsSmall = false;
+  #limitedByNetwork = false;
+  #badSamples = 0;
+  #goodSamples = 0;
+  #stableSamples = 0;
+  #samplesSinceRise = Number.POSITIVE_INFINITY;
+  #settling = 0;
+  #backoff = 1;
+  #frameRateProbe;
+  #senderFrameRate;
+  #unimprovedSamples = 0;
+  get layer() {
+    return this.#layer;
+  }
+  /** Drops fast, rises slowly: a failed attempt at h doubles the wait before the next one. */
+  sample(sample) {
+    this.#tileIsSmall = tileIsSmall(this.#tileIsSmall, sample.tileHeight);
+    if (this.#layer === "h" && sample.framesPerSecond !== void 0 && sample.framesPerSecond >= MIN_FRAMES_PER_SECOND) this.#senderFrameRate = void 0;
+    const checkFrameRate = this.#layer === "h" && (this.#senderFrameRate === void 0 || (sample.framesPerSecond ?? 0) < this.#senderFrameRate * 0.75);
+    const health = this.#settling > 0 ? this.#settle() : classify(sample, checkFrameRate);
+    return this.#layer === "h" ? this.#sampleHigh(health, sample) : this.#sampleLow(health, sample);
+  }
+  #settle() {
+    this.#settling--;
+    return "unknown";
+  }
+  #sampleHigh(health, sample) {
+    this.#samplesSinceRise++;
+    if (this.#tileIsSmall) return this.#drop(false);
+    if (health === "bad" || health === "severe") {
+      this.#stableSamples = 0;
+      if (health === "severe" || ++this.#badSamples >= DROP_AFTER_BAD_SAMPLES) return this.#drop(true, frameRateProbe(sample, health));
+      return this.#layer;
+    }
+    this.#badSamples = 0;
+    if (health === "good" && ++this.#stableSamples >= STABLE_SAMPLES_RESETTING_BACKOFF) this.#backoff = 1;
+    return this.#layer;
+  }
+  #sampleLow(health, sample) {
+    if (this.#tileIsSmall || health !== "good") {
+      this.#goodSamples = 0;
+      this.#unimprovedSamples = 0;
+      return this.#layer;
+    }
+    if (this.#detectSenderLimit(sample.framesPerSecond)) {
+      this.#senderFrameRate = this.#frameRateProbe;
+      this.#backoff = 1;
+      return this.#rise();
+    }
+    const needed = this.#limitedByNetwork ? RISE_AFTER_GOOD_SAMPLES * this.#backoff : RISE_AFTER_TILE_GROWS_SAMPLES;
+    if (++this.#goodSamples < needed) return this.#layer;
+    return this.#rise();
+  }
+  #detectSenderLimit(fps) {
+    if (this.#frameRateProbe !== void 0 && fps !== void 0 && fps > 0 && fps <= this.#frameRateProbe * 1.25) return ++this.#unimprovedSamples >= FRAME_RATE_COMPARISON_SAMPLES;
+    this.#unimprovedSamples = 0;
+    return false;
+  }
+  #drop(byNetwork, frameRate) {
+    this.#frameRateProbe = frameRate;
+    this.#unimprovedSamples = 0;
+    if (byNetwork) {
+      if (this.#samplesSinceRise < FAILED_PROBE_WITHIN_SAMPLES) this.#backoff = Math.min(this.#backoff * 2, MAX_RISE_BACKOFF);
+      this.#limitedByNetwork = true;
+    }
+    return this.#switchTo("l");
+  }
+  #rise() {
+    this.#limitedByNetwork = false;
+    this.#samplesSinceRise = 0;
+    return this.#switchTo("h");
+  }
+  #switchTo(layer) {
+    this.#layer = layer;
+    this.#badSamples = 0;
+    this.#goodSamples = 0;
+    this.#stableSamples = 0;
+    this.#settling = SETTLE_SAMPLES;
+    return layer;
+  }
+};
+function tileIsSmall(previous, height) {
+  if (height === void 0) return previous;
+  if (height <= LOW_TILE_MAX_HEIGHT) return true;
+  return height < HIGH_TILE_MIN_HEIGHT ? previous : false;
+}
+function isSevere({ lossFraction, freezeSeconds }) {
+  return freezeSeconds >= SEVERE_FREEZE_SECONDS || lossFraction !== void 0 && lossFraction >= SEVERE_LOSS;
+}
+function isBad({ lossFraction, framesPerSecond, newFreezes }, checkFrameRate) {
+  if (newFreezes > 0 || lossFraction !== void 0 && lossFraction >= BAD_LOSS) return true;
+  return checkFrameRate && lossFraction !== void 0 && framesPerSecond !== void 0 && framesPerSecond < MIN_FRAMES_PER_SECOND;
+}
+function frameRateProbe(sample, health) {
+  return health === "severe" || isBad(sample, false) ? void 0 : sample.framesPerSecond;
+}
+function classify(sample, checkFrameRate) {
+  if (isSevere(sample)) return "severe";
+  if (isBad(sample, checkFrameRate)) return "bad";
+  const { lossFraction, framesPerSecond } = sample;
+  if (lossFraction === void 0 || framesPerSecond === void 0) return "unknown";
+  return lossFraction < GOOD_LOSS ? "good" : "unknown";
+}
+var ViewerStatsReader = class {
+  #previous = /* @__PURE__ */ new Map();
+  read(stats2, trackId) {
+    const row = [...stats2].find((stat) => stat.type === "inbound-rtp" && stat.kind === "video" && stat.trackIdentifier === trackId);
+    const counters = row && inboundCounters(row);
+    if (!counters) return void 0;
+    const previous = this.#previous.get(trackId);
+    this.#previous.set(trackId, counters);
+    if (!previous || counters.timestamp <= previous.timestamp) return void 0;
+    const received = counters.packetsReceived - previous.packetsReceived;
+    const lost = Math.max(0, counters.packetsLost - previous.packetsLost);
+    const frames = counters.framesDecoded - previous.framesDecoded;
+    if (received < 0 || frames < 0) return void 0;
+    return {
+      lossFraction: received + lost > 0 ? lost / (received + lost) : void 0,
+      framesPerSecond: frames * 1e3 / (counters.timestamp - previous.timestamp),
+      newFreezes: Math.max(0, counters.freezeCount - previous.freezeCount),
+      freezeSeconds: Math.max(0, counters.freezeSeconds - previous.freezeSeconds)
+    };
+  }
+  forget(trackId) {
+    this.#previous.delete(trackId);
+  }
+};
+function inboundCounters(row) {
+  const { timestamp, packetsReceived, packetsLost, framesDecoded } = row;
+  if (timestamp === void 0 || packetsReceived === void 0 || packetsLost === void 0 || framesDecoded === void 0) return void 0;
+  return { timestamp, packetsReceived, packetsLost, framesDecoded, freezeCount: row.freezeCount ?? 0, freezeSeconds: row.totalFreezesDuration ?? 0 };
+}
+var RETRY_AFTER_FAILED_SWITCH_MS = 5e3;
+var MAX_RETRY_DELAY_MS = 6e4;
+var ViewerLayerSelector = class {
+  #views = /* @__PURE__ */ new Map();
+  #reader = new ViewerStatsReader();
+  sample(now, report, cameras) {
+    const rows = [...report.values()];
+    const active = new Set(cameras.map((camera) => camera.publicationId));
+    for (const [publicationId, view] of this.#views) {
+      if (!active.has(publicationId)) {
+        this.#reader.forget(view.track.id);
+        this.#views.delete(publicationId);
+      }
+    }
+    const changes = [];
+    for (const camera of cameras) {
+      const view = this.#view(camera);
+      const stats2 = this.#reader.read(rows, camera.track.id);
+      if (!stats2) continue;
+      const layer = view.policy.layer === view.applied ? view.policy.sample({ ...stats2, tileHeight: videoRenderSize(camera.track)?.height }) : view.policy.layer;
+      if (layer !== view.applied && now >= view.retryAt) changes.push({ ...camera, layer });
+    }
+    return changes;
+  }
+  applied({ publicationId, track, layer }) {
+    const view = this.#views.get(publicationId);
+    if (!view || view.track !== track) return;
+    view.applied = layer;
+    view.failures = 0;
+  }
+  failed({ publicationId, track }, now) {
+    const view = this.#views.get(publicationId);
+    if (!view || view.track !== track) return;
+    view.retryAt = now + Math.min(MAX_RETRY_DELAY_MS, RETRY_AFTER_FAILED_SWITCH_MS * 2 ** view.failures);
+    view.failures++;
+  }
+  // A re-pull of the same publication gives a new receiver, and the SFU starts it on h.
+  #view({ publicationId, track }) {
+    let view = this.#views.get(publicationId);
+    if (!view) {
+      view = { policy: new ViewerLayerPolicy(), track, applied: "h", retryAt: 0, failures: 0 };
+      this.#views.set(publicationId, view);
+    } else if (view.track !== track) {
+      this.#reader.forget(view.track.id);
+      Object.assign(view, { track, applied: "h", retryAt: 0, failures: 0 });
+    }
+    return view;
+  }
+};
+
 // src/media/observers.ts
 function subscribeSnapshot(listeners, listener) {
   listeners.add(listener);
@@ -176,6 +580,202 @@ function matchRemotePullTracks(publications, tracks) {
   });
 }
 
+// src/media/call-stats.ts
+var CALL_STATS_WINDOW_MS = 1e4;
+var CALL_STATS_UPLOAD_SAMPLES = 6;
+var CALL_STATS_MAX_BATCH = 30;
+var CALL_STATS_MAX_WINDOW_MS = 6e4;
+var CALL_STATS_CALL_CAP = 360;
+var RID_ORDER = ["h", "m", "l"];
+var MAX_ELAPSED_MS = 2147483647;
+function createCallStatsCollector(options) {
+  const now = options.now ?? (() => Date.now());
+  const startedAt = now();
+  let buffer = [];
+  let produced = 0;
+  let uploading = null;
+  let baseline = null;
+  const gauges = { rtt: newGauges(), sendJitter: newGauges(), recvJitter: newGauges() };
+  let latest = null;
+  const closeWindow = (at) => {
+    if (!baseline || !latest) return;
+    const windowMs = at - baseline.at;
+    if (windowMs < 1e3) return;
+    const sample = summarise(latest, baseline, windowMs, at - startedAt, gauges);
+    baseline = readBaseline(latest, at);
+    resetGauges(gauges);
+    if (windowMs > CALL_STATS_MAX_WINDOW_MS || produced >= CALL_STATS_CALL_CAP) return;
+    produced++;
+    buffer.push(sample);
+    if (buffer.length > CALL_STATS_MAX_BATCH) buffer = buffer.slice(-CALL_STATS_MAX_BATCH);
+  };
+  const send = (upload) => {
+    if (uploading || buffer.length === 0) return uploading ?? Promise.resolve();
+    const samples = buffer;
+    buffer = [];
+    uploading = upload({ version: 1, samples }).catch(() => {
+    }).finally(() => {
+      uploading = null;
+    });
+    return uploading;
+  };
+  return {
+    observe(report) {
+      const at = now();
+      latest = report;
+      baseline ??= readBaseline(report, at);
+      addGauges(report, gauges);
+      if (at - baseline.at >= CALL_STATS_WINDOW_MS) closeWindow(at);
+      if (buffer.length >= CALL_STATS_UPLOAD_SAMPLES) void send(options.upload);
+    },
+    async flush(upload) {
+      closeWindow(now());
+      if (uploading) await uploading;
+      await send(upload);
+    },
+    reset() {
+      baseline = null;
+      latest = null;
+      resetGauges(gauges);
+    }
+  };
+}
+function summarise(report, baseline, windowMs, elapsedMs, gauges) {
+  const delta = (type, field, kind) => sumDelta(report, baseline, type, field, kind);
+  const recvLost = delta("inbound-rtp", "packetsLost");
+  const pair = selectedPair(report);
+  const local = pair ? report.get(String(pair.localCandidateId)) : void 0;
+  const remote = pair ? report.get(String(pair.remoteCandidateId)) : void 0;
+  return {
+    elapsed_ms: Math.min(Math.round(elapsedMs), MAX_ELAPSED_MS),
+    window_ms: Math.round(windowMs),
+    connection_type: connectionType(local),
+    local_candidate_type: candidateType(local),
+    remote_candidate_type: candidateType(remote),
+    relay_protocol: relayProtocol(local),
+    rtt_ms: scaled(mean(gauges.rtt), 1e3, 6e4),
+    send_bitrate_kbps: scaled(delta("outbound-rtp", "bytesSent"), 8 / windowMs, 1e5),
+    send_loss_pct: lossPct(delta("remote-inbound-rtp", "packetsLost"), delta("outbound-rtp", "packetsSent")),
+    send_jitter_ms: scaled(mean(gauges.sendJitter), 1e3, 6e4),
+    send_layer: sendLayer(report, baseline),
+    recv_bitrate_kbps: scaled(delta("inbound-rtp", "bytesReceived"), 8 / windowMs, 1e5),
+    recv_loss_pct: lossPct(recvLost, sum(recvLost, delta("inbound-rtp", "packetsReceived"))),
+    recv_jitter_ms: scaled(mean(gauges.recvJitter), 1e3, 6e4),
+    recv_height: scaled(recvHeight(report), 1, 4320),
+    freeze_count: scaled(delta("inbound-rtp", "freezeCount", "video"), 1, 1e4),
+    freeze_ms: scaled(delta("inbound-rtp", "totalFreezesDuration", "video"), 1e3, 6e5)
+  };
+}
+function scaled(value, factor, max) {
+  return value === null ? void 0 : clampInt(value * factor, max);
+}
+function stats(report, type, kind) {
+  const found = [];
+  report.forEach((stat) => {
+    if (stat.type !== type) return;
+    if (kind && (stat.kind ?? stat.mediaType) !== kind) return;
+    found.push(stat);
+  });
+  return found;
+}
+function readBaseline(report, at) {
+  const counters = /* @__PURE__ */ new Map();
+  report.forEach((stat) => {
+    for (const field of COUNTER_FIELDS) {
+      const value = stat[field];
+      if (typeof value === "number") counters.set(`${String(stat.id)}:${field}`, value);
+    }
+  });
+  return { at, counters };
+}
+var COUNTER_FIELDS = ["packetsSent", "packetsLost", "packetsReceived", "bytesSent", "bytesReceived", "totalFreezesDuration", "freezeCount"];
+function sumDelta(report, baseline, type, field, kind) {
+  let total = 0;
+  let seen = false;
+  for (const stat of stats(report, type, kind)) {
+    const current = stat[field];
+    const before = baseline.counters.get(`${String(stat.id)}:${field}`);
+    if (typeof current !== "number" || before === void 0) continue;
+    seen = true;
+    total += Math.max(0, current - before);
+  }
+  return seen ? total : null;
+}
+function lossPct(lost, total) {
+  if (lost === null || total === null || total <= 0) return void 0;
+  return Math.min(100, Math.round(lost / total * 1e4) / 100);
+}
+function sum(a, b) {
+  return a === null || b === null ? null : a + b;
+}
+function newGauges() {
+  return { sum: 0, count: 0 };
+}
+function resetGauges(gauges) {
+  for (const gauge of Object.values(gauges)) {
+    gauge.sum = 0;
+    gauge.count = 0;
+  }
+}
+function addGauge(gauge, value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return;
+  gauge.sum += value;
+  gauge.count++;
+}
+function addGauges(report, gauges) {
+  const pair = selectedPair(report);
+  addGauge(gauges.rtt, pair?.currentRoundTripTime);
+  for (const stat of stats(report, "remote-inbound-rtp")) addGauge(gauges.sendJitter, stat.jitter);
+  for (const stat of stats(report, "inbound-rtp")) addGauge(gauges.recvJitter, stat.jitter);
+}
+function mean(gauge) {
+  return gauge.count === 0 ? null : gauge.sum / gauge.count;
+}
+function clampInt(value, max) {
+  return Math.min(max, Math.max(0, Math.round(value)));
+}
+function selectedPair(report) {
+  const transport = stats(report, "transport").find((stat) => typeof stat.selectedCandidatePairId === "string");
+  if (transport) return report.get(String(transport.selectedCandidatePairId));
+  return stats(report, "candidate-pair").find((stat) => stat.state === "succeeded" && (stat.selected === true || stat.nominated === true));
+}
+function connectionType(local) {
+  if (!local) return "unknown";
+  if (local.candidateType === "relay") return "turn";
+  if (local.protocol === "udp" || local.protocol === "tcp") return local.protocol;
+  return "unknown";
+}
+function candidateType(candidate) {
+  const type = candidate?.candidateType;
+  return type === "host" || type === "srflx" || type === "prflx" || type === "relay" ? type : void 0;
+}
+function relayProtocol(local) {
+  const protocol = local?.relayProtocol;
+  return protocol === "udp" || protocol === "tcp" || protocol === "tls" ? protocol : void 0;
+}
+function sendLayer(report, baseline) {
+  const active = /* @__PURE__ */ new Set();
+  for (const stat of stats(report, "outbound-rtp", "video")) {
+    const before = baseline.counters.get(`${String(stat.id)}:bytesSent`);
+    if (typeof stat.rid !== "string" || typeof stat.bytesSent !== "number" || before === void 0) continue;
+    if (stat.bytesSent > before) active.add(stat.rid);
+  }
+  return RID_ORDER.find((rid) => active.has(rid));
+}
+function recvHeight(report) {
+  let height = null;
+  for (const stat of stats(report, "inbound-rtp", "video")) {
+    if (typeof stat.frameHeight === "number") height = Math.max(height ?? 0, stat.frameHeight);
+  }
+  return height;
+}
+
+// src/media/ice-servers.ts
+function iceServersFor(bootstrap) {
+  if (!bootstrap.iceServers || bootstrap.iceServers.length === 0) return [{ urls: bootstrap.stunServer }];
+  return bootstrap.iceServers.map(({ urls, username, credential }) => username === void 0 || credential === void 0 ? { urls: [...urls] } : { urls: [...urls], username, credential });
+}
+
 // src/media/failure-diagnostics.ts
 var steps = /* @__PURE__ */ new WeakMap();
 var fetchFailures = /* @__PURE__ */ new WeakSet();
@@ -234,10 +834,13 @@ function classifyMediaFailure(cause, fallbackStep) {
 // src/media/client.ts
 var EMPTY_LOCAL = Object.freeze([]);
 var EMPTY_REMOTE = Object.freeze([]);
+var EMPTY_RECEIVE_STALLS = Object.freeze([]);
 var INVALID_PUBLICATION_SIGNATURE = "\0invalid";
 var CONNECTION_TIMEOUT_MS = 8e3;
 var NEGOTIATION_TIMEOUT_MS = 35e3;
 var PEER_OPERATION_TIMEOUT_MS = 8e3;
+var VIEWER_LAYER_BATCH_SIZE = 16;
+var VIEWER_LAYER_UPDATE_INTERVAL_MS = 5e3;
 var CAPTURE_REUSE_WINDOW_MS = 2e4;
 var CloudflareSFUClient = class {
   #localListeners = /* @__PURE__ */ new Set();
@@ -265,6 +868,10 @@ var CloudflareSFUClient = class {
   #cursor = null;
   #remotePullIncomplete = false;
   #remotePullRetries = /* @__PURE__ */ new Map();
+  #receiveProgress = new ReceiveStallRecovery();
+  #viewerLayerPending = /* @__PURE__ */ new Map();
+  #viewerLayerUpdating = false;
+  #viewerLayerUpdateAt = Number.NEGATIVE_INFINITY;
   #remoteParticipantIds = null;
   #remoteParticipantRevision = 0;
   #subscribedPublicationIds = /* @__PURE__ */ new Set();
@@ -281,8 +888,10 @@ var CloudflareSFUClient = class {
   #retirement = Promise.resolve();
   #snapshot;
   #started = false;
+  #receivingInitial = false;
   #stopped = false;
   #transport;
+  #callStats = createCallStatsCollector({ upload: async (stats2) => this.#transport?.uploadCallStats?.(stats2, false) });
   constructor(options) {
     validateClientOptions(options);
     this.#participantId = options.participantId;
@@ -300,6 +909,7 @@ var CloudflareSFUClient = class {
       cursor: null,
       localTracks: EMPTY_LOCAL,
       remoteTracks: EMPTY_REMOTE,
+      receiveStalls: this.#receiveProgress.observations,
       failure: null
     });
     this.#observeConnection(this.#connection, this.#generation, this.#connectionEpoch);
@@ -320,7 +930,9 @@ var CloudflareSFUClient = class {
     this.#remotePullIncomplete = true;
     this.remotePublicationsChanged();
   }
-  remotePublicationsChanged() {
+  remotePublicationsChanged(publications, projectionState = "available") {
+    if (projectionState === "unavailable") this.#receiveProgress.suspend();
+    else if (publications) this.#receiveProgress.expect(publications, this.#participantId);
     if (this.#polling) {
       this.#pollAfterCurrent = true;
       return;
@@ -385,20 +997,30 @@ var CloudflareSFUClient = class {
     this.#publishSnapshot();
     this.#emitLocal();
   }
-  async start(localMedia) {
+  async start(localMedia, beforePublish) {
     if (this.#started) return;
     this.#requireActive();
-    const tracks = localMedia.getTracks().filter((track) => track.kind === "audio" || track.kind === "video");
-    for (const track of tracks) this.prepareLocalTrack(track.kind === "audio" ? "microphone" : "camera", track);
     const generation = this.#generation;
     this.#setPhase("connecting", null);
+    if (beforePublish) {
+      this.#receivingInitial = true;
+      this.#schedulePoll(0);
+      try {
+        localMedia = await beforePublish();
+      } finally {
+        this.#receivingInitial = false;
+      }
+      if (generation !== this.#generation || this.#stopped) return;
+    }
+    const tracks = localMedia.getTracks().filter((track) => track.kind === "audio" || track.kind === "video");
+    for (const track of tracks) this.prepareLocalTrack(track.kind === "audio" ? "microphone" : "camera", track);
     await this.#activatePreparedTracks(
       [...this.#localTracks.values()].filter((state) => state.source === "microphone" || state.source === "camera"),
       generation
     );
   }
   async refreshRemotePublications() {
-    if (!this.#started || this.#stopped || this.#polling) return;
+    if (!this.#started && !this.#receivingInitial || this.#stopped || this.#polling) return;
     this.#polling = true;
     const generation = this.#generation;
     this.#pollFailedPull = false;
@@ -478,12 +1100,34 @@ var CloudflareSFUClient = class {
     return enabled ? Promise.resolve() : this.#retireOwnedPublications();
   }
   async closeForcedLocalPublication(source, cause = "forced_pause") {
+    const connection = this.#connection;
+    const generationAtClose = this.#generation;
     const sources = localSourceGroup(source);
     const ownsPublication = [...this.#ownedPublications].some((item) => sources.includes(item.state.source));
-    await this.setLocalSourceIntent(source, false, cause);
-    if (!ownsPublication || !this.#replaceMediaConnection) return;
+    const canRecover = ownsPublication && this.#replaceMediaConnection !== void 0;
+    let failedRetirement;
+    try {
+      await this.setLocalSourceIntent(source, false, cause);
+    } catch (error) {
+      if (!canRecover) throw error;
+      failedRetirement = this.#fenceFailedClose(error, connection, generationAtClose, cause);
+      if (!failedRetirement) return;
+    }
+    if (!canRecover) return;
+    await this.#restoreEnabledSourcesAfterClose(source);
+    if (this.#retirement !== failedRetirement) await this.#retirement;
+  }
+  #fenceFailedClose(error, connection, generation, cause) {
+    const failures = error instanceof AggregateError ? error.errors : [error];
+    if (!failures.every((failure) => this.#isRetryableConnectionFailure(failure))) throw error;
+    if (connection !== this.#connection || generation !== this.#generation) return;
+    this.#retiredLocalConnection = connection;
+    this.#retiredLocalCause = cause;
+    return this.#retirement;
+  }
+  #restoreEnabledSourcesAfterClose(source) {
     const generation = this.#generation;
-    await this.#serializeSDP(async () => {
+    return this.#serializeSDP(async () => {
       const existing = new Set([...this.#localTracks.values()].filter((state) => state.source !== source && state.providerPublicationId !== null));
       const states = await this.#prepareConnectionForPublication([], generation);
       await this.#publishPreparedTracksSerialized(
@@ -495,7 +1139,6 @@ var CloudflareSFUClient = class {
       this.#requireGeneration(generation);
       this.#setPhase("live", null);
     });
-    await this.#retirement;
   }
   async #retireUnavailableLocalPublication(state) {
     const publicationId = state.providerPublicationId;
@@ -641,6 +1284,9 @@ var CloudflareSFUClient = class {
       return;
     }
     this.#stopped = true;
+    const transport = this.#transport;
+    void this.#callStats.flush(async (stats2) => transport?.uploadCallStats?.(stats2, true));
+    this.#receiveProgress.expect([], this.#participantId);
     this.#subscribedPublicationIds.clear();
     this.#generation++;
     this.#connectionEpoch++;
@@ -901,9 +1547,8 @@ var CloudflareSFUClient = class {
     if (cursor === null) return;
     const participantRevision = this.#remoteParticipantRevision;
     const desired = this.#desiredRemotePublications(authoritative, cursor);
-    const toPull = this.#pendingRemotePulls(desired);
     this.#pollFailedPull = true;
-    const pulled = await this.#pullWithRecovery(toPull, cursor, generation);
+    const pulled = await this.#pullWithRecovery(desired, cursor, generation);
     if (pulled === null) return;
     this.#requireGeneration(generation);
     const next = reconcileRemoteTracks(desired, pulled, this.#remoteTracks);
@@ -931,7 +1576,9 @@ var CloudflareSFUClient = class {
     }
     const now = Date.now();
     return [...desired].filter(([key, publication]) => {
-      if (this.#remoteTracks.get(key)?.publicationId === publication.publicationId) return false;
+      if (this.#remoteTracks.get(key)?.publicationId === publication.publicationId) {
+        if (!this.#receiveProgress.canRepull(publication.publicationId) && !(this.#replaceMediaConnection && this.#receiveProgress.canRebuild(publication.publicationId))) return false;
+      }
       const remaining = (this.#remotePullRetries.get(publication.publicationId)?.retryAfter ?? 0) - now;
       return remaining <= 0;
     }).map(([, publication]) => publication);
@@ -960,7 +1607,11 @@ var CloudflareSFUClient = class {
   #canSubscribeToRemotePublication(publication) {
     return this.#remoteParticipantIds === null || this.#remoteParticipantIds.has(publication.participantId) || this.#subscribedPublicationIds.has(publication.publicationId);
   }
-  async #pullWithRecovery(publications, cursor, generation) {
+  async #pullWithRecovery(desired, cursor, generation) {
+    const pending = this.#pendingRemotePulls(desired);
+    const stalled = pending.filter((publication) => this.#receiveProgress.isStalled(publication.publicationId));
+    if (stalled.length) return this.#recoverStalledRemotePublications(stalled, desired, cursor, generation);
+    const publications = pending;
     try {
       return await this.#pull(publications, generation);
     } catch (error) {
@@ -972,6 +1623,46 @@ var CloudflareSFUClient = class {
       return this.#retryRemotePullOnReplacement(publications, cursor, generation);
     }
   }
+  async #recoverStalledRemotePublications(stalled, desired, cursor, generation) {
+    if (stalled.every((publication) => this.#receiveProgress.canRepull(publication.publicationId))) {
+      try {
+        return await this.#repullStalledRemotePublications(stalled, generation);
+      } catch (error) {
+        this.#requireGeneration(generation);
+        if (!this.#replaceMediaConnection) throw error;
+      }
+    }
+    if (!this.#replaceMediaConnection || !this.#receiveProgress.reserveRebuild()) return [];
+    return this.#retryRemotePullOnReplacement([...desired.values()], cursor, generation, "receive_stalled");
+  }
+  async #repullStalledRemotePublications(stalled, generation) {
+    for (const publication of stalled) this.#receiveProgress.reserveRepull(publication.publicationId);
+    const retired = await this.#retireStalledReceivers(stalled, generation);
+    if (!retired.length) return [];
+    const pulled = await this.#pullBatch(retired, generation);
+    if (pulled?.length !== retired.length) throw new CloudflareSFUError("Stalled receive subscriptions were not restored", "media_failed");
+    for (const publication of retired) this.#receiveProgress.restarted(publication.publicationId);
+    return pulled;
+  }
+  async #retireStalledReceivers(publications, generation) {
+    return this.#serializeSDP(async () => {
+      this.#requireGeneration(generation);
+      const stalled = publications.filter((publication) => this.#receiveProgress.isStalled(publication.publicationId));
+      if (!stalled.length) return [];
+      const connection = this.#connection;
+      const receivers = stalled.map((publication) => {
+        const remote = [...this.#remoteTracks.values()].find((track) => track.publicationId === publication.publicationId);
+        const transceiver = connection.getTransceivers().find((item) => item.receiver.track === remote?.track);
+        if (!transceiver || transceiver.mid === null) throw new CloudflareSFUError("The stalled receiver has no negotiated MID", "media_failed");
+        return { publication, transceiver, mid: transceiver.mid };
+      });
+      const connectionId = this.#bootstrap.connectionId;
+      await this.#signal(() => this.#requireTransport().closeTracks({ connectionId, receiveOnly: true, force: true, tracks: receivers.map(({ publication, mid }) => ({ mid, source: publication.source, publicationId: publication.publicationId })) }), { generation, connectionId });
+      this.#requireGeneration(generation);
+      for (const { transceiver } of receivers) transceiver.stop();
+      return stalled;
+    });
+  }
   #canReplaceConnectionAfterRemotePull(error, generation) {
     const gone = error instanceof CloudflareSFUError && (error.options.status === 404 || error.options.status === 410);
     return this.#isRetryableConnectionFailure(error) && (gone || !this.#hasLiveRemoteTracks()) && this.#replaceMediaConnection !== void 0 && this.#replacementAttemptedGeneration !== generation;
@@ -979,14 +1670,19 @@ var CloudflareSFUClient = class {
   #hasLiveRemoteTracks() {
     return [...this.#remoteTracks.values()].some((publication) => publication.track.readyState === "live");
   }
-  async #retryRemotePullOnReplacement(publications, cursor, generation) {
+  async #retryRemotePullOnReplacement(publications, cursor, generation, cause = "remote_signaling_failure") {
     this.#remoteRecoveryGeneration = generation;
+    const connection = this.#connection;
     try {
-      await this.#replaceMediaConnectionForRecovery(generation, "remote_signaling_failure");
+      await this.#replaceMediaConnectionForRecovery(generation, cause);
       await this.#republishPreparedTracksAfterRecovery(generation);
       return await this.#pull(publications, generation);
     } catch (error) {
       if (generation !== this.#generation || this.#stopped) throw error;
+      if (cause === "receive_stalled" && connection === this.#connection) {
+        this.#replacementAttemptedGeneration = null;
+        for (const publication of publications) this.#backoffRemotePull(publication.publicationId, true);
+      }
       this.#observeRemotePublicationCursor(cursor, retryableRemotePull(error));
       throw error;
     }
@@ -1029,7 +1725,7 @@ var CloudflareSFUClient = class {
     const retryAfter = retryableRemotePull(error) ? Date.now() + 15e3 : Number.POSITIVE_INFINITY;
     for (const publication of publications) {
       const failures = this.#remotePullRetries.get(publication.publicationId)?.failures ?? 0;
-      this.#remotePullRetries.set(publication.publicationId, { retryAfter, failures });
+      this.#remotePullRetries.set(publication.publicationId, { retryAfter, failures, receiveStalled: this.#remotePullRetries.get(publication.publicationId)?.receiveStalled });
     }
   }
   async #pullBatch(publications, generation) {
@@ -1056,12 +1752,17 @@ var CloudflareSFUClient = class {
       connection.addEventListener("track", onTrack);
       try {
         this.#requireGeneration(generation);
-        const response = await this.#signal(() => this.#addTracks({ connectionId, tracks: requested, allowPartialRemoteTracks: true }), { generation, connectionId });
+        const response = await this.#signal(() => this.#addTracks({ connectionId, tracks: requested, allowPartialRemoteTracks: true }), {
+          generation,
+          connectionId
+        });
         this.#requireGeneration(generation);
         this.#recordRemotePullErrors(publications, response.trackErrors ?? []);
         const responseTracks = response.tracks ?? [];
         const matched = matchRemotePullTracks(publications, responseTracks);
-        for (const { publication } of matched) this.#remotePullRetries.delete(publication.publicationId);
+        for (const { publication } of matched) {
+          if (!this.#remotePullRetries.get(publication.publicationId)?.receiveStalled) this.#remotePullRetries.delete(publication.publicationId);
+        }
         await this.#completeRenegotiation(response, connection, connectionId, generation);
         if (matched.length === 0) return [];
         await this.#waitForConnection(connection, generation);
@@ -1091,13 +1792,82 @@ var CloudflareSFUClient = class {
     for (const failure of failures) {
       const publication = requested.get(`${failure.connectionId}\0${failure.trackName}`);
       if (!publication) throw new CloudflareSFUError("Cloudflare SFU returned an unrequested remote track error", "invalid_publication");
-      const previous = this.#remotePullRetries.get(publication.publicationId) ?? { retryAfter: 0, failures: 0 };
-      const failureCount = Math.min(previous.failures + 1, 6);
-      const delay = Math.min(15e3, 750 * 2 ** (failureCount - 1));
-      this.#remotePullRetries.set(publication.publicationId, { retryAfter: Date.now() + delay, failures: failureCount });
+      this.#backoffRemotePull(publication.publicationId);
       this.#reportError(new CloudflareSFUError(`Cloudflare SFU remote track failed: ${failure.code}`, "media_failed", { providerCode: failure.code }));
     }
   }
+  #backoffRemotePull(publicationId, receiveStalled = false) {
+    const previous = this.#remotePullRetries.get(publicationId) ?? { retryAfter: 0, failures: 0 };
+    const failures = Math.min(previous.failures + 1, 6);
+    this.#remotePullRetries.set(publicationId, { retryAfter: Date.now() + Math.min(15e3, 750 * 2 ** (failures - 1)), failures, receiveStalled: receiveStalled || previous.receiveStalled });
+  }
+  #adaptViewerLayers(connection, report, selector, current) {
+    if (!this.#transport?.updateTracks || !this.#canObserveReceiveProgress(connection)) return;
+    const now = performance.now();
+    const cameras = [...this.#remoteTracks.values()].filter(({ source, track }) => source === "camera" && track.readyState === "live");
+    this.#queueViewerLayers(selector.sample(now, report, cameras));
+    if (this.#viewerLayerUpdating || now < this.#viewerLayerUpdateAt) return;
+    const batch = [...this.#viewerLayerPending.values()].flatMap((change) => {
+      const mid = connection.getTransceivers().find((transceiver) => transceiver.receiver.track === change.track)?.mid;
+      return mid === null || mid === void 0 ? [] : [{ change, mid }];
+    }).slice(0, VIEWER_LAYER_BATCH_SIZE);
+    if (!batch.length) return;
+    this.#viewerLayerUpdating = true;
+    this.#viewerLayerUpdateAt = now + VIEWER_LAYER_UPDATE_INTERVAL_MS;
+    void this.#requestViewerLayers(this.#transport, batch).then((failed) => {
+      this.#viewerLayerUpdating = false;
+      if (!current()) return;
+      for (const { change } of batch) {
+        const pending = this.#viewerLayerPending.get(change.publicationId);
+        if (pending?.track === change.track && pending.layer === change.layer) this.#viewerLayerPending.delete(change.publicationId);
+        if (failed.has(change.publicationId)) selector.failed(change, performance.now());
+        else selector.applied(change);
+      }
+    });
+  }
+  #queueViewerLayers(changes) {
+    const active = new Set(changes.map(({ publicationId }) => publicationId));
+    for (const id of this.#viewerLayerPending.keys()) if (!active.has(id)) this.#viewerLayerPending.delete(id);
+    for (const change of changes) this.#viewerLayerPending.set(change.publicationId, change);
+  }
+  // A layer switch is an optimization: when the SFU refuses it, the pulled layer keeps playing.
+  async #requestViewerLayers(transport, batch) {
+    try {
+      const response = await transport.updateTracks?.({
+        connectionId: this.#bootstrap.connectionId,
+        tracks: batch.map(({ change, mid }) => {
+          const { connectionId, trackName } = parseCloudflareSFUPublicationID(change.publicationId);
+          return { location: "remote", mid, sessionId: connectionId, trackName, simulcast: { preferredRid: change.layer, priorityOrdering: "none", ridNotAvailable: "asciibetical" } };
+        })
+      });
+      return new Set(
+        batch.filter(({ change }) => {
+          const { connectionId, trackName } = parseCloudflareSFUPublicationID(change.publicationId);
+          return response?.trackErrors?.some((error) => error.connectionId === connectionId && error.trackName === trackName);
+        }).map(({ change }) => change.publicationId)
+      );
+    } catch {
+      return new Set(batch.map(({ change }) => change.publicationId));
+    }
+  }
+  #canObserveReceiveProgress(connection) {
+    return this.#started && connectionIsLive(connection) && (typeof document === "undefined" || document.visibilityState !== "hidden");
+  }
+  #observeReceiveProgress(connection, report) {
+    if (!this.#canObserveReceiveProgress(connection)) {
+      this.#receiveProgress.clear();
+      return;
+    }
+    const { stalled, advanced } = this.#receiveProgress.sample(performance.now(), connection, report, this.#remoteTracks.values());
+    for (const publicationId of advanced) this.#remotePullRetries.delete(publicationId);
+    this.#publishSnapshot();
+    if (!stalled.some((id) => this.#receiveProgress.canRepull(id) || this.#replaceMediaConnection && this.#receiveProgress.canRebuild(id))) return;
+    for (const publicationId of stalled) {
+      if (!this.#remotePullRetries.get(publicationId)?.receiveStalled) this.#backoffRemotePull(publicationId, true);
+    }
+    this.#remotePullIncomplete = true;
+    this.remotePublicationsChanged();
+  }
   async #completeRenegotiation(response, connection, connectionId, generation) {
     if (!response.requiresImmediateRenegotiation) return;
     await this.#applyProviderDescription(response, connection);
@@ -1193,6 +1963,7 @@ var CloudflareSFUClient = class {
     let disposed = false;
     let cameraTimer;
     const cameraPolicy = new CameraUplinkPolicy();
+    const viewerLayers = new ViewerLayerSelector();
     let observedCamera;
     const current = () => !disposed && generation === this.#generation && connectionEpoch === this.#connectionEpoch && !this.#stopped && connection.connectionState !== "failed" && connection.connectionState !== "closed";
     const adaptCamera = async () => {
@@ -1203,14 +1974,14 @@ var CloudflareSFUClient = class {
           cameraPolicy.reset();
           observedCamera = state;
         }
-        const sender = this.#cameraSimulcastSender(state);
-        if (!sender) {
-          cameraPolicy.reset();
-          return;
-        }
         const report = await connection.getStats();
-        if (!current() || this.#cameraSimulcastSender(state) !== sender || connection.signalingState !== "stable") return;
-        await this.#applyCameraUplink(sender, report, cameraPolicy);
+        if (!current() || connection.signalingState !== "stable") return;
+        this.#observeReceiveProgress(connection, report);
+        this.#adaptViewerLayers(connection, report, viewerLayers, current);
+        this.#callStats.observe(report);
+        const sender = this.#cameraSimulcastSender(state);
+        if (!sender) cameraPolicy.reset();
+        else await this.#applyCameraUplink(sender, report, cameraPolicy);
       } catch {
         cameraPolicy.reset();
       } finally {
@@ -1220,6 +1991,7 @@ var CloudflareSFUClient = class {
     const dispose = () => {
       if (disposed) return;
       disposed = true;
+      this.#viewerLayerPending.clear();
       if (cameraTimer !== void 0) globalThis.clearTimeout(cameraTimer);
       connection.removeEventListener("connectionstatechange", capture);
       connection.removeEventListener("iceconnectionstatechange", capture);
@@ -1300,11 +2072,12 @@ var CloudflareSFUClient = class {
   }
   #createPeerConnection(bootstrap) {
     const create = this.#peerConnectionFactory ?? ((configuration) => new RTCPeerConnection(configuration));
-    return create({ iceServers: [{ urls: bootstrap.stunServer }], bundlePolicy: "max-bundle" });
+    return create({ iceServers: iceServersFor(bootstrap), bundlePolicy: "max-bundle" });
   }
   #rebuildPeerConnection(bootstrap, generation, connectionEpoch) {
     try {
       this.#connection = this.#createPeerConnection(bootstrap);
+      this.#callStats.reset();
       this.#observeConnection(this.#connection, generation, connectionEpoch);
     } catch (error) {
       this.#setFailure(error, "media_failed");
@@ -1312,6 +2085,7 @@ var CloudflareSFUClient = class {
     }
   }
   #disposeConnection(stopSenders) {
+    this.#receiveProgress.replaced();
     if (!stopSenders) this.#setPhase("recovering", null);
     this.#disposeConnectionObservation?.();
     this.#disposeConnectionObservation = void 0;
@@ -1349,7 +2123,7 @@ var CloudflareSFUClient = class {
     this.#emitRemote();
   }
   #schedulePoll(delayMs = this.#pollIntervalMs) {
-    if (this.#stopped || !this.#started || this.#pollTimer !== void 0) return;
+    if (this.#stopped || !this.#started && !this.#receivingInitial || this.#pollTimer !== void 0) return;
     this.#pollTimer = globalThis.setTimeout(async () => {
       this.#pollTimer = void 0;
       if (typeof document !== "undefined" && document.visibilityState === "hidden") {
@@ -1408,6 +2182,7 @@ var CloudflareSFUClient = class {
         })
       ) : EMPTY_LOCAL,
       remoteTracks: this.#remoteTracks.size ? [...this.#remoteTracks.values()] : EMPTY_REMOTE,
+      receiveStalls: this.#receiveProgress.observations,
       failure
     });
     if (snapshotEqual(this.#snapshot, next)) return;
@@ -1532,7 +2307,7 @@ function snapshotEqual(left, right) {
   return snapshotMetadataEqual(left, right) && left.localTracks.every((publication, index) => publicationEqual(publication, right.localTracks[index])) && left.remoteTracks.every((publication, index) => remotePublicationEqual(publication, right.remoteTracks[index]));
 }
 function snapshotMetadataEqual(left, right) {
-  return connectionEqual(left.connection, right.connection) && cursorEqual(left.cursor, right.cursor) && failureEqual(left.failure, right.failure) && left.localTracks.length === right.localTracks.length && left.remoteTracks.length === right.remoteTracks.length;
+  return (left.receiveStalls ?? EMPTY_RECEIVE_STALLS) === (right.receiveStalls ?? EMPTY_RECEIVE_STALLS) && connectionEqual(left.connection, right.connection) && cursorEqual(left.cursor, right.cursor) && failureEqual(left.failure, right.failure) && left.localTracks.length === right.localTracks.length && left.remoteTracks.length === right.remoteTracks.length;
 }
 function connectionEqual(left, right) {
   return left.phase === right.phase && left.peerConnectionState === right.peerConnectionState && left.iceConnectionState === right.iceConnectionState;
@@ -1581,16 +2356,23 @@ function mediaTargetFailure(error) {
 var SIGNALING_TIMEOUT_MS = 8e3;
 var CREDENTIAL_TIMEOUT_MS = 7e3;
 function createCloudflareSFUHTTPTransport(options) {
-  const fetch = options.fetch ?? globalThis.fetch;
+  const fetch = withRequestContext(options.fetch);
   const credential = requireCredential(options);
+  let lastToken = "";
   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 statsPath = `${base}/v1/tenants/${encodeURIComponent(options.tenantId)}/call-stats`;
   const timeoutMs = options.requestTimeoutMs ?? SIGNALING_TIMEOUT_MS;
   if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) throw new CloudflareSFUError("The signaling deadline is invalid", "signaling_failed");
+  const freshToken = async () => {
+    const token = await withDeadline(CREDENTIAL_TIMEOUT_MS, (signal) => credential(signal));
+    if (!token.trim()) throw new CloudflareSFUError("The media credential provider returned an empty token", "signaling_failed");
+    lastToken = token;
+    return token;
+  };
   const request = async (path, init) => {
     try {
-      const token = await withDeadline(CREDENTIAL_TIMEOUT_MS, (signal) => credential(signal));
-      if (!token.trim()) throw new CloudflareSFUError("The media credential provider returned an empty token", "signaling_failed");
+      const token = await freshToken();
       return await withDeadline(timeoutMs, async (signal) => {
         const startedAt = performance.now();
         const response = await fetch(`${mediaPath}/${path}`, {
@@ -1640,15 +2422,34 @@ function createCloudflareSFUHTTPTransport(options) {
         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
+        force: input.force,
+        ...input.receiveOnly ? { receive_only: true } : {}
       })
     }),
+    updateTracks: async (input) => request("tracks/update", {
+      method: "PUT",
+      body: JSON.stringify({ connection_id: input.connectionId, tracks: input.tracks })
+    }),
     renegotiate: async (input) => {
       await request("renegotiate", {
         method: "POST",
         body: JSON.stringify({ connection_id: input.connectionId, session_description: input.sessionDescription })
       });
     },
+    uploadCallStats: async (stats2, closing) => {
+      const token = closing ? lastToken : await freshToken();
+      if (!token) return;
+      await withDeadline(timeoutMs, async (signal) => {
+        const response = await fetch(statsPath, {
+          method: "POST",
+          signal,
+          keepalive: true,
+          headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+          body: JSON.stringify(stats2)
+        });
+        if (!response.ok) throw new CloudflareSFUError(`Chalk call stats upload failed with HTTP ${response.status}`, "signaling_failed", { status: response.status });
+      });
+    },
     listPublications: async () => {
       const response = await request("publications");
       return {
@@ -1713,6 +2514,7 @@ function describeMediaCaptureError(cause) {
 }
 
 export {
+  setVideoRenderSize,
   CloudflareSFUError,
   parseCloudflareSFUPublicationID,
   requireDescription,