@q9labsai/chalk-client 5.3.0 → 5.4.0

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

@@ -1,3 +1,7 @@
+import {
+  withRequestContext
+} from "./chunk-N4IPKRS6.js";
+
 // src/media/receive-stall.ts
 var RECEIVE_STALL_WINDOW_MS = 7e3;
 var RECEIVE_STARTUP_GRACE_MS = 2e4;
@@ -46,6 +50,10 @@ 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();
@@ -60,10 +68,12 @@ var ReceiveStallRecovery = class {
     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);
   }
@@ -81,17 +91,47 @@ var ReceiveStallRecovery = class {
       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);
   }
-  canRebuild() {
-    return this.#active.length > 0 && this.#active.every((id) => this.#stalled.has(id) && (this.#attempts.get(id) ?? 0) < MAX_RECEIVE_REBUILDS);
+  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) this.#attempts.set(id, (this.#attempts.get(id) ?? 0) + 1);
+    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();
@@ -103,36 +143,48 @@ var ReceiveStallRecovery = class {
     this.#active = active.map((publication) => publication.publicationId);
     const samples = active.flatMap((publication) => receivePacketSample(connection, report, publication) ?? []);
     const { stalled, advanced, resumed } = this.#detector.sample(now, samples);
-    for (const id of resumed) this.#attempts.delete(id);
+    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));
-    this.#stalled = new Set(stalled);
+    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, advanced, newlyStalled };
+    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 = `${publication.participantId}\0${publication.source}`;
+    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.#attempts.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((sum, row) => sum + row.packetsReceived, 0) };
+  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 ?? [];
@@ -166,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);
@@ -318,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();
@@ -379,8 +837,12 @@ var EMPTY_REMOTE = Object.freeze([]);
 var EMPTY_RECEIVE_STALLS = Object.freeze([]);
 var INVALID_PUBLICATION_SIGNATURE = "\0invalid";
 var CONNECTION_TIMEOUT_MS = 8e3;
+var RECOVERY_BACKOFF_MS = [1e3, 2e3, 4e3, 5e3];
+var RECOVERY_HEALTHY_RESET_MS = 1e4;
 var NEGOTIATION_TIMEOUT_MS = 35e3;
 var PEER_OPERATION_TIMEOUT_MS = 8e3;
+var VIEWER_LAYER_BATCH_SIZE = 16;
+var VIEWER_LAYER_UPDATE_INTERVAL_MS = 5e3;
 var CAPTURE_REUSE_WINDOW_MS = 2e4;
 var CloudflareSFUClient = class {
   #localListeners = /* @__PURE__ */ new Set();
@@ -397,6 +859,8 @@ var CloudflareSFUClient = class {
   #locallyPausedSources = /* @__PURE__ */ new Map();
   #localTracks = /* @__PURE__ */ new Map();
   #ownedPublications = /* @__PURE__ */ new Set();
+  #localRecoveries = /* @__PURE__ */ new Map();
+  #recentRecoveries = /* @__PURE__ */ new Map();
   #remoteTracks = /* @__PURE__ */ new Map();
   #bootstrap;
   #connection;
@@ -405,10 +869,14 @@ var CloudflareSFUClient = class {
   #retiredLocalConnection = null;
   #retiredLocalCause = "forced_pause";
   #replacementCause;
+  #replacement = null;
   #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();
@@ -428,6 +896,7 @@ var CloudflareSFUClient = class {
   #receivingInitial = false;
   #stopped = false;
   #transport;
+  #callStats = createCallStatsCollector({ upload: async (stats2) => this.#transport?.uploadCallStats?.(stats2, false) });
   constructor(options) {
     validateClientOptions(options);
     this.#participantId = options.participantId;
@@ -460,6 +929,12 @@ var CloudflareSFUClient = class {
     this.#remotePullRetries.delete(publicationId);
     this.remotePublicationsChanged();
   }
+  localPublicationWithdrawn(publicationId) {
+    const owned = [...this.#ownedPublications].find((publication) => publication.lifecycle.kind === "confirmed" && publication.lifecycle.handle.publicationId === publicationId && publication.state.providerPublicationId === publicationId);
+    const state = owned?.state;
+    if (!state || !state.desiredEnabled || this.#localTracks.get(state.source) !== state) return;
+    this.#beginLocalRecovery(state, publicationId, false);
+  }
   remoteParticipantsChanged(participantIds) {
     this.#remoteParticipantIds = new Set(participantIds);
     this.#remoteParticipantRevision++;
@@ -497,11 +972,13 @@ var CloudflareSFUClient = class {
       };
       track.addEventListener("ended", state.endedListener);
     }
+    this.#dropLocalRecovery(source);
     this.#localTracks.set(source, state);
     this.#publishSnapshot();
     this.#emitLocal();
   }
   async clearPreparedLocalTrack(source, options = {}) {
+    this.#dropLocalRecovery(source);
     const state = this.#localTracks.get(source);
     if (!state) return;
     if (state.clearing) return state.clearing;
@@ -514,6 +991,7 @@ var CloudflareSFUClient = class {
   }
   async #clearPreparedTrack(state, stopTrack = true) {
     const source = state.source;
+    this.#dropLocalRecovery(source);
     if (source === "screen" || source === "screen_audio") {
       try {
         this.#pauseLocalSource(source, "capture_cleanup");
@@ -564,6 +1042,7 @@ var CloudflareSFUClient = class {
       const transport = this.#requireTransport();
       const authoritative = await this.#signal(() => transport.listPublications());
       this.#requireGeneration(generation);
+      this.#republishUnlistedLocalPublications(authoritative);
       await this.#reconcileRemotePublications(authoritative, generation);
       this.#requireGeneration(generation);
       if (!this.#remotePullIncomplete) this.#pollFailures = 0;
@@ -574,6 +1053,161 @@ var CloudflareSFUClient = class {
       this.#finishPublicationPoll(generation);
     }
   }
+  // The registry drops a publication when listeners keep failing to pull it.
+  // A publisher that still believes it is sending must publish again, so
+  // listeners get a new publication ID instead of retrying a dead one.
+  #republishUnlistedLocalPublications(authoritative) {
+    const unlisted = [...this.#localTracks.values()].filter((state) => state.enabled && state.desiredEnabled && state.providerPublicationId !== null && !authoritative.publications.some((publication) => publication.publicationId === state.providerPublicationId));
+    for (const state of unlisted) this.#beginLocalRecovery(state, state.providerPublicationId, true);
+  }
+  #beginLocalRecovery(state, deadPublicationId, relist) {
+    if (!this.#canBeginLocalRecovery(state)) return;
+    const now = Date.now();
+    const delayMs = this.#recoveryStartDelay(state.source, now);
+    const recovery = { state, deadPublicationId, relist, retiring: false, attempt: 0, timer: void 0, running: false };
+    this.#localRecoveries.set(state.source, recovery);
+    this.#scheduleLocalRecovery(recovery, delayMs);
+  }
+  #canBeginLocalRecovery(state) {
+    return state.enabled && state.desiredEnabled && !this.#stopped && !this.#locallyPausedSources.has(state.source) && !this.#localRecoveries.has(state.source);
+  }
+  #recoveryStartDelay(source, now) {
+    const recent = this.#recentRecoveries.get(source);
+    if (!recent || now - recent.healthySince >= RECOVERY_HEALTHY_RESET_MS) {
+      this.#recentRecoveries.set(source, { count: 0, healthySince: now });
+      return 0;
+    }
+    this.#recentRecoveries.set(source, { count: recent.count + 1, healthySince: now });
+    return recoveryBackoffMs(recent.count);
+  }
+  #scheduleLocalRecovery(recovery, delayMs) {
+    recovery.timer = globalThis.setTimeout(() => {
+      recovery.timer = void 0;
+      if (this.#localRecoveries.get(recovery.state.source) !== recovery) return;
+      void this.#runLocalRecovery(recovery.state.source);
+    }, delayMs);
+  }
+  #canRecover(recovery) {
+    return this.#localRecoveries.get(recovery.state.source) === recovery && !this.#stopped && !this.#locallyPausedSources.has(recovery.state.source) && this.#localTracks.get(recovery.state.source) === recovery.state;
+  }
+  async #runLocalRecovery(source) {
+    const recovery = this.#localRecoveries.get(source);
+    if (!recovery || recovery.running || this.#discardUnrecoverableIntent(recovery)) return;
+    recovery.running = true;
+    try {
+      await this.#attemptLocalRecovery(recovery);
+    } catch (error) {
+      await this.#retryLocalRecovery(recovery, error);
+    } finally {
+      recovery.running = false;
+    }
+  }
+  async #attemptLocalRecovery(recovery) {
+    if (!await this.#relistLocalRecoveryIfNeeded(recovery) || !this.#canContinueLocalRecovery(recovery)) {
+      this.#dropLocalRecovery(recovery.state.source, recovery);
+      return;
+    }
+    this.#retireDeadLocalPublication(recovery);
+    if (await this.#retireLocalRecoveryIfNeeded(recovery)) return;
+    const published = await this.#enablePreparedTrack(recovery.state);
+    if (this.#discardUnrecoverableIntent(recovery)) return;
+    if (!this.#settleLocalRecovery(recovery, published)) this.#scheduleLocalRecoveryRetry(recovery);
+  }
+  async #relistLocalRecoveryIfNeeded(recovery) {
+    const { state, deadPublicationId } = recovery;
+    if (!recovery.relist || deadPublicationId === null) return true;
+    const authoritative = await this.#signal(() => this.#requireTransport().listPublications());
+    if (!this.#canRecover(recovery) || state.providerPublicationId !== deadPublicationId || !state.desiredEnabled) return false;
+    if (authoritative.publications.some((publication) => publication.publicationId === deadPublicationId)) {
+      this.#dropLocalRecovery(state.source, recovery);
+      return false;
+    }
+    recovery.relist = false;
+    return true;
+  }
+  #canContinueLocalRecovery(recovery) {
+    if (!this.#canRecover(recovery) || recovery.retiring) return this.#canRecover(recovery);
+    if (recovery.deadPublicationId !== null && recovery.state.providerPublicationId !== recovery.deadPublicationId) return false;
+    return recovery.state.desiredEnabled;
+  }
+  #retireDeadLocalPublication(recovery) {
+    if (recovery.retiring || recovery.deadPublicationId === null || recovery.state.providerPublicationId !== recovery.deadPublicationId) return;
+    recovery.retiring = true;
+    this.#pauseLocalSource(recovery.state.source, "discovery_absent", { group: false });
+  }
+  async #retireLocalRecoveryIfNeeded(recovery) {
+    if (!this.#hasRetiringLocalPublications(recovery.state.source)) return false;
+    await this.#retireLocalRecoveryPublications(recovery.state.source);
+    return this.#discardUnrecoverableIntent(recovery);
+  }
+  async #retryLocalRecovery(recovery, error) {
+    if (this.#discardUnrecoverableIntent(recovery)) return;
+    this.#reportLocalRecoveryError(error);
+    await this.#replaceConnectionForLocalRecovery(error);
+    this.#scheduleLocalRecoveryRetry(recovery);
+  }
+  #discardUnrecoverableIntent(recovery) {
+    if (this.#canRecover(recovery)) return false;
+    this.#dropLocalRecovery(recovery.state.source, recovery);
+    return true;
+  }
+  #settleLocalRecovery(recovery, published) {
+    const source = recovery.state.source;
+    if (!published && this.#locallyPausedSources.has(source)) {
+      this.#dropLocalRecovery(source, recovery);
+      return true;
+    }
+    const publicationId = recovery.state.providerPublicationId;
+    if (!published || publicationId === null || publicationId === recovery.deadPublicationId) return false;
+    const recent = this.#recentRecoveries.get(source);
+    if (recent) this.#recentRecoveries.set(source, { ...recent, healthySince: Date.now() });
+    this.#dropLocalRecovery(source, recovery);
+    return true;
+  }
+  #reportLocalRecoveryError(error) {
+    if (error instanceof AggregateError) {
+      for (const cause of error.errors) this.#reportError(cause);
+      return;
+    }
+    this.#reportError(error);
+  }
+  async #replaceConnectionForLocalRecovery(error) {
+    const failures = error instanceof AggregateError ? error.errors : [error];
+    if (!this.#replaceMediaConnection || failures.length === 0 || !failures.every((failure) => this.#isRetryableConnectionFailure(failure))) return;
+    const generation = this.#generation;
+    try {
+      await this.#replaceMediaConnectionForRecovery(generation, "local_signaling_failure");
+    } catch {
+      return;
+    }
+    try {
+      await this.#republishPreparedTracksAfterRecovery(generation);
+    } catch (republishError) {
+      this.#reportLocalRecoveryError(republishError);
+    }
+  }
+  #scheduleLocalRecoveryRetry(recovery) {
+    if (!this.#canRecover(recovery)) {
+      this.#dropLocalRecovery(recovery.state.source, recovery);
+      return;
+    }
+    this.#scheduleLocalRecovery(recovery, recoveryBackoffMs(recovery.attempt++));
+  }
+  #hasRetiringLocalPublications(source) {
+    return [...this.#ownedPublications].some((publication) => publication.state.source === source && publication.lifecycle.kind === "retiring" && publication.lifecycle.handle !== null);
+  }
+  #retireLocalRecoveryPublications(source) {
+    return this.#retireOwnedPublications(() => {
+    }, { sources: [source], goneIsComplete: true });
+  }
+  #dropLocalRecovery(source, expected) {
+    for (const item of localSourceGroup(source)) {
+      const recovery = this.#localRecoveries.get(item);
+      if (!recovery || expected && recovery !== expected) continue;
+      if (recovery.timer !== void 0) globalThis.clearTimeout(recovery.timer);
+      this.#localRecoveries.delete(item);
+    }
+  }
   #finishPublicationPoll(generation) {
     if (generation !== this.#generation) return;
     this.#polling = false;
@@ -589,9 +1223,11 @@ var CloudflareSFUClient = class {
     return this.#enablePublicationTarget({ ...target, source: "screen_audio" });
   }
   async #pausePublicationTarget(target) {
+    this.#dropLocalRecovery(target.source);
     const resolved = resolveMediaTarget(this.#participantId, this.#stopped, this.#localTracks, target);
     if (resolved.kind === "result" && resolved.result.outcome !== "satisfied") return resolved.result;
     const outcome = resolved.kind === "state" && resolved.value.enabled ? "confirmed" : "satisfied";
+    this.#dropLocalRecovery(target.source);
     if (target.source !== "screen" && this.#locallyPausedSources.get(target.source) === "capture_cleanup") {
       await this.pauseLocalCapture(target.source);
       return { outcome, errorCode: null };
@@ -604,6 +1240,25 @@ var CloudflareSFUClient = class {
       return mediaTargetFailure(error);
     }
   }
+  async #waitForReplacementBeforeEnable(state, generation, replacement) {
+    if (replacement?.generation !== generation) return null;
+    state.desiredEnabled = true;
+    await replacement.promise.catch(() => {
+    });
+    if (this.#locallyPausedSources.has(state.source)) return { outcome: "terminal_failure", errorCode: "local_source_paused" };
+    if (!state.desiredEnabled) return { outcome: "satisfied", errorCode: null };
+    state.track.enabled = true;
+    return null;
+  }
+  #postReplacementEnableOutcome(state, generation, replacement) {
+    if (this.#locallyPausedSources.has(state.source)) return { outcome: "terminal_failure", errorCode: "local_source_paused" };
+    if (replacement?.generation === generation && !state.desiredEnabled) return { outcome: "satisfied", errorCode: null };
+    if (state.enabled) {
+      state.track.enabled = true;
+      return { outcome: "satisfied", errorCode: null };
+    }
+    return null;
+  }
   async #enablePublicationTarget(target) {
     const generation = this.#generation;
     const resolved = resolveMediaTarget(this.#participantId, this.#stopped, this.#localTracks, target);
@@ -611,9 +1266,12 @@ var CloudflareSFUClient = class {
     const state = resolved.value;
     if (this.#locallyPausedSources.has(target.source)) return { outcome: "terminal_failure", errorCode: "local_source_paused" };
     try {
+      const replacement = this.#replacement;
+      const replacementOutcome = await this.#waitForReplacementBeforeEnable(state, generation, replacement);
+      if (replacementOutcome) return replacementOutcome;
       await this.#retireUnavailableLocalPublication(state);
-      if (this.#locallyPausedSources.has(target.source)) return { outcome: "terminal_failure", errorCode: "local_source_paused" };
-      if (state.enabled) return { outcome: "satisfied", errorCode: null };
+      const postReplacementOutcome = this.#postReplacementEnableOutcome(state, generation, replacement);
+      if (postReplacementOutcome) return postReplacementOutcome;
       if (!await this.#enablePreparedTrack(state)) return { outcome: "terminal_failure", errorCode: "local_source_paused" };
       return { outcome: "confirmed", errorCode: null };
     } catch (error) {
@@ -622,12 +1280,14 @@ var CloudflareSFUClient = class {
     }
   }
   async pauseLocalCapture(source) {
+    this.#dropLocalRecovery(source);
     this.#locallyPausedSources.set(source, "capture_cleanup");
     const state = this.#localTracks.get(source);
     if (state) await this.#disablePreparedTrack(state);
   }
   setLocalSourceIntent(source, enabled, cause = "forced_pause") {
     const sources = localSourceGroup(source);
+    if (!enabled) this.#dropLocalRecovery(source);
     for (const item of sources) {
       if (enabled) this.#locallyPausedSources.delete(item);
       else this.#locallyPausedSources.set(item, cause);
@@ -681,13 +1341,16 @@ var CloudflareSFUClient = class {
     if (!publicationId) return;
     const authoritative = await this.#signal(() => this.#requireTransport().listPublications());
     if (authoritative.publications.some((publication) => publication.publicationId === publicationId)) return;
-    if (state.providerPublicationId === publicationId) {
-      this.#pauseLocalSource(state.source, "discovery_absent");
-      await this.#retireOwnedPublications();
+    if (state.providerPublicationId !== publicationId || this.#localRecoveries.has(state.source)) return;
+    if (state.enabled && state.desiredEnabled) {
+      this.#beginLocalRecovery(state, publicationId, true);
+      return;
     }
+    this.#pauseLocalSource(state.source, "discovery_absent");
+    await this.#retireOwnedPublications(void 0, { goneIsComplete: true });
   }
-  #pauseLocalSource(source, cause = "forced_pause") {
-    const sources = localSourceGroup(source);
+  #pauseLocalSource(source, cause = "forced_pause", options = {}) {
+    const sources = options.group === false ? [source] : localSourceGroup(source);
     for (const publication of this.#ownedPublications) {
       if (!sources.includes(publication.state.source)) continue;
       this.#markPublicationRetiring(publication, cause);
@@ -700,25 +1363,36 @@ var CloudflareSFUClient = class {
     this.#publishSnapshot();
     this.#emitLocal();
   }
-  #retireOwnedPublications(reportFailure = this.#reportError.bind(this)) {
-    const publications = [...this.#ownedPublications].filter((item) => item.lifecycle.kind === "retiring" && item.lifecycle.handle);
-    const retirement = (async () => {
-      const errors = [];
-      for (const publication of publications) {
-        try {
-          await this.#serializeSDP(() => this.#closeOwnedPublication(publication), true);
-        } catch (error) {
-          errors.push(error);
-          if (!this.#stopped) reportFailure(error);
-        }
-      }
-      if (this.#stopped && this.#ownedPublications.size === 0) this.#transport = void 0;
-      if (errors.length) throw new AggregateError(errors, "Media retirement failed");
-    })();
+  #retireOwnedPublications(reportFailure = this.#reportError.bind(this), options) {
+    const publications = this.#retiringOwnedPublications(options?.sources);
+    const retirement = this.#runOwnedRetirement(publications, reportFailure, options?.goneIsComplete === true);
     void retirement.catch(() => {
     });
     return this.#retirement = retirement;
   }
+  #retiringOwnedPublications(sources) {
+    return [...this.#ownedPublications].filter((item) => item.lifecycle.kind === "retiring" && item.lifecycle.handle && (!sources || sources.includes(item.state.source)));
+  }
+  async #runOwnedRetirement(publications, reportFailure, goneIsComplete) {
+    const errors = [];
+    for (const publication of publications) {
+      try {
+        await this.#serializeSDP(() => this.#closeOwnedPublication(publication), true);
+      } catch (error) {
+        if (goneIsComplete && this.#retireGonePublication(publication, error)) continue;
+        errors.push(error);
+        if (!this.#stopped) reportFailure(error);
+      }
+    }
+    if (this.#stopped && this.#ownedPublications.size === 0) this.#transport = void 0;
+    if (errors.length) throw new AggregateError(errors, "Media retirement failed");
+  }
+  #retireGonePublication(publication, error) {
+    if (!isGonePublicationFailure(error)) return false;
+    publication.lifecycle = { kind: "retired" };
+    this.#ownedPublications.delete(publication);
+    return true;
+  }
   #markPublicationRetiring(publication, cause = "publish_failure") {
     const phase = publication.lifecycle;
     if (phase.kind === "pending" || phase.kind === "confirmed") publication.lifecycle = { kind: "retiring", handle: phase.kind === "confirmed" ? phase.handle : null, detached: false, cause };
@@ -820,7 +1494,11 @@ 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);
+    for (const source of [...this.#localRecoveries.keys()]) this.#dropLocalRecovery(source);
+    this.#recentRecoveries.clear();
     this.#subscribedPublicationIds.clear();
     this.#generation++;
     this.#connectionEpoch++;
@@ -1111,7 +1789,7 @@ var CloudflareSFUClient = class {
     const now = Date.now();
     return [...desired].filter(([key, publication]) => {
       if (this.#remoteTracks.get(key)?.publicationId === publication.publicationId) {
-        if (!this.#receiveProgress.canRebuild() || !this.#replaceMediaConnection) return false;
+        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;
@@ -1143,12 +1821,9 @@ var CloudflareSFUClient = class {
   }
   async #pullWithRecovery(desired, cursor, generation) {
     const pending = this.#pendingRemotePulls(desired);
-    const receiveStalled = pending.some((publication) => this.#receiveProgress.isStalled(publication.publicationId));
-    const publications = receiveStalled ? [...desired.values()] : pending;
-    if (receiveStalled) {
-      if (!this.#replaceMediaConnection || !this.#receiveProgress.reserveRebuild()) return [];
-      return this.#retryRemotePullOnReplacement(publications, cursor, generation, "receive_stalled");
-    }
+    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) {
@@ -1160,6 +1835,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;
@@ -1298,6 +2013,55 @@ var CloudflareSFUClient = class {
     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");
   }
@@ -1309,7 +2073,7 @@ var CloudflareSFUClient = class {
     const { stalled, advanced } = this.#receiveProgress.sample(performance.now(), connection, report, this.#remoteTracks.values());
     for (const publicationId of advanced) this.#remotePullRetries.delete(publicationId);
     this.#publishSnapshot();
-    if (!this.#receiveProgress.canRebuild()) return;
+    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);
     }
@@ -1411,6 +2175,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 () => {
@@ -1424,6 +2189,8 @@ var CloudflareSFUClient = class {
         const report = await connection.getStats();
         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);
@@ -1436,6 +2203,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);
@@ -1468,35 +2236,49 @@ var CloudflareSFUClient = class {
     this.#replacementCause = void 0;
     return this.#requireTransport().addTracks({ ...input, replacementCause });
   }
-  async #replaceMediaConnectionForRecovery(generation, cause) {
+  #replaceMediaConnectionForRecovery(generation, cause) {
     this.#requireGeneration(generation);
+    if (this.#replacement?.generation === generation) return this.#replacement.promise;
     if (!this.#replaceMediaConnection || this.#replacementAttemptedGeneration === generation) {
-      throw new CloudflareSFUError("A fresh Cloudflare SFU connection is unavailable", "signaling_failed");
+      return Promise.reject(new CloudflareSFUError("A fresh Cloudflare SFU connection is unavailable", "signaling_failed"));
     }
     this.#replacementAttemptedGeneration = generation;
     const replaceMediaConnection = this.#replaceMediaConnection;
-    const bootstrap = await replaceMediaConnection();
-    this.#requireGeneration(generation);
-    validateBootstrap(bootstrap);
-    if (bootstrap.connectionId === this.#bootstrap.connectionId) {
-      throw new CloudflareSFUError("Participant access did not replace the Cloudflare SFU connection", "signaling_failed");
-    }
-    this.#fenceLocalPublications();
-    const connectionEpoch = ++this.#connectionEpoch;
-    this.#disposeConnection(false);
-    this.#clearRemoteTracks();
-    this.#cursor = null;
-    this.#bootstrap = bootstrap;
-    this.#rebuildPeerConnection(bootstrap, generation, connectionEpoch);
-    this.#replacementCause = cause;
-    this.#retiredLocalConnection = null;
-    this.#negotiatedGeneration = null;
-    for (const state of this.#localTracks.values()) {
-      state.transceiver = null;
-      state.enabled = false;
-      state.providerPublicationId = null;
-    }
-    this.remotePublicationsChanged();
+    const promise = Promise.resolve().then(async () => {
+      const bootstrap = await replaceMediaConnection();
+      this.#requireGeneration(generation);
+      validateBootstrap(bootstrap);
+      if (bootstrap.connectionId === this.#bootstrap.connectionId) {
+        throw new CloudflareSFUError("Participant access did not replace the Cloudflare SFU connection", "signaling_failed");
+      }
+      this.#fenceLocalPublications();
+      const connectionEpoch = ++this.#connectionEpoch;
+      this.#disposeConnection(false);
+      this.#clearRemoteTracks();
+      this.#cursor = null;
+      this.#bootstrap = bootstrap;
+      this.#rebuildPeerConnection(bootstrap, generation, connectionEpoch);
+      this.#replacementCause = cause;
+      this.#retiredLocalConnection = null;
+      this.#negotiatedGeneration = null;
+      for (const state of this.#localTracks.values()) {
+        state.transceiver = null;
+        state.enabled = false;
+        state.providerPublicationId = null;
+      }
+      this.remotePublicationsChanged();
+    });
+    const replacement = { generation, promise };
+    this.#replacement = replacement;
+    void promise.then(
+      () => {
+        if (this.#replacement === replacement) this.#replacement = null;
+      },
+      () => {
+        if (this.#replacement === replacement) this.#replacement = null;
+      }
+    );
+    return promise;
   }
   async #republishPreparedTracksAfterRecovery(generation) {
     const enabled = [...this.#localTracks.values()].filter((state) => state.desiredEnabled && state.track.readyState !== "ended");
@@ -1516,11 +2298,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");
@@ -1528,7 +2311,7 @@ var CloudflareSFUClient = class {
     }
   }
   #disposeConnection(stopSenders) {
-    this.#receiveProgress.clear();
+    this.#receiveProgress.replaced();
     if (!stopSenders) this.#setPhase("recovering", null);
     this.#disposeConnectionObservation?.();
     this.#disposeConnectionObservation = void 0;
@@ -1775,9 +2558,19 @@ async function createLocalOffer(connection) {
 function localSourceGroup(source) {
   return source === "screen" ? [source, "screen_audio"] : [source];
 }
+function recoveryBackoffMs(attempt) {
+  return RECOVERY_BACKOFF_MS[Math.min(attempt, RECOVERY_BACKOFF_MS.length - 1)] ?? RECOVERY_BACKOFF_MS[RECOVERY_BACKOFF_MS.length - 1];
+}
+function isGonePublicationFailure(error) {
+  const failures = error instanceof AggregateError ? error.errors : [error];
+  return failures.length > 0 && failures.every((failure) => failure instanceof CloudflareSFUError && (failure.options.status === 404 || failure.options.status === 410));
+}
 function isRateLimited(error) {
   return error instanceof CloudflareSFUError && error.options.status === 429;
 }
+function unwrapAggregateErrors(error) {
+  return error instanceof AggregateError ? error.errors.flatMap(unwrapAggregateErrors) : [error];
+}
 function retryableRemotePull(error) {
   if (!(error instanceof CloudflareSFUError)) return false;
   if (error.code === "signaling_failed") return error.options.retryableConnection === true || error.options.status === 429;
@@ -1792,23 +2585,32 @@ function simulcastUnsupported(error) {
 function mediaTargetFailure(error) {
   const code = error instanceof CloudflareSFUError ? error.code : "media_failed";
   const ambiguous = code === "signaling_timeout" || code === "negotiation_timeout";
-  return { outcome: ambiguous ? "ambiguous" : "retryable_failure", errorCode: code };
+  const failures = unwrapAggregateErrors(error);
+  const terminal = failures.length > 0 && failures.every((failure) => failure instanceof CloudflareSFUError && failure.code === "signaling_failed" && typeof failure.options.status === "number" && failure.options.retryableConnection !== true && !isRateLimited(failure));
+  return { outcome: ambiguous ? "ambiguous" : terminal ? "terminal_failure" : "retryable_failure", errorCode: code };
 }
 
 // src/media/transport.ts
 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}`, {
@@ -1858,15 +2660,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 {
@@ -1931,6 +2752,7 @@ function describeMediaCaptureError(cause) {
 }
 
 export {
+  setVideoRenderSize,
   CloudflareSFUError,
   parseCloudflareSFUPublicationID,
   requireDescription,