@q9labsai/chalk-client 5.3.0 → 5.3.1

package/dist/{chunk-3TGVTP6Z.js → chunk-O5JB5XVX.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();
@@ -381,6 +839,8 @@ 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();
@@ -409,6 +869,9 @@ var CloudflareSFUClient = class {
   #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 +891,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;
@@ -820,6 +1284,8 @@ 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++;
@@ -1111,7 +1577,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 +1609,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 +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;
@@ -1298,6 +1801,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 +1861,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 +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 () => {
@@ -1424,6 +1977,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 +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);
@@ -1516,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");
@@ -1528,7 +2085,7 @@ var CloudflareSFUClient = class {
     }
   }
   #disposeConnection(stopSenders) {
-    this.#receiveProgress.clear();
+    this.#receiveProgress.replaced();
     if (!stopSenders) this.#setPhase("recovering", null);
     this.#disposeConnectionObservation?.();
     this.#disposeConnectionObservation = void 0;
@@ -1799,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}`, {
@@ -1858,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 {
@@ -1931,6 +2514,7 @@ function describeMediaCaptureError(cause) {
 }
 
 export {
+  setVideoRenderSize,
   CloudflareSFUError,
   parseCloudflareSFUPublicationID,
   requireDescription,