@observertc/observer-js 1.0.0-beta.13 → 1.0.0-beta.15

package/dist/index.mjs

@@ -37,8 +37,8 @@ function createLogger(moduleName) {
     }
   }();
 }
-function setObserverLogger(logger8) {
-  mainLogger = logger8;
+function setObserverLogger(logger9) {
+  mainLogger = logger9;
 }
 
 // src/ObservedCall.ts
@@ -50,6 +50,145 @@ import { EventEmitter as EventEmitter2 } from "events";
 // src/ObservedPeerConnection.ts
 import { EventEmitter } from "events";
 
+// src/utils/stats.ts
+function percentile(values, p) {
+  if (values.length === 0) return void 0;
+  return percentileOfSorted(values.slice().sort(ascending), p);
+}
+function median(values) {
+  return percentile(values, 0.5);
+}
+function medianAbsoluteDeviation(values) {
+  const centre = median(values);
+  if (centre === void 0) return void 0;
+  return median(values.map((value) => Math.abs(value - centre)));
+}
+function robustZScore(value, baseline) {
+  const centre = median(baseline);
+  if (centre === void 0) return void 0;
+  const mad = medianAbsoluteDeviation(baseline) ?? 0;
+  if (mad === 0) return centre < value ? Infinity : 0;
+  return (value - centre) / (1.4826 * mad);
+}
+function summarize(values) {
+  const count = values.length;
+  if (count === 0) return void 0;
+  const sorted = values.slice().sort(ascending);
+  let sum = 0;
+  for (let i = 0; i < count; i++) sum += sorted[i];
+  return {
+    count,
+    min: sorted[0],
+    max: sorted[count - 1],
+    mean: sum / count,
+    p25: percentileOfSorted(sorted, 0.25),
+    median: percentileOfSorted(sorted, 0.5),
+    p75: percentileOfSorted(sorted, 0.75),
+    p95: percentileOfSorted(sorted, 0.95)
+  };
+}
+var ascending = (a, b) => a - b;
+function percentileOfSorted(sorted, p) {
+  if (sorted.length === 1) return sorted[0];
+  const clamped = Math.min(1, Math.max(0, p));
+  const position = clamped * (sorted.length - 1);
+  const lowerIndex = Math.floor(position);
+  const upperIndex = Math.ceil(position);
+  if (lowerIndex === upperIndex) return sorted[lowerIndex];
+  const weight = position - lowerIndex;
+  return sorted[lowerIndex] * (1 - weight) + sorted[upperIndex] * weight;
+}
+function counterDelta(previous, current) {
+  if (previous === void 0 || current === void 0) return 0;
+  if (current < previous) return 0;
+  return current - previous;
+}
+function correlation(xs, ys) {
+  const n = Math.min(xs.length, ys.length);
+  if (n < 2) return 0;
+  let meanX = 0;
+  let meanY = 0;
+  for (let i = 0; i < n; i++) {
+    meanX += xs[i];
+    meanY += ys[i];
+  }
+  meanX /= n;
+  meanY /= n;
+  let covariance = 0;
+  let varianceX = 0;
+  let varianceY = 0;
+  for (let i = 0; i < n; i++) {
+    const dx = xs[i] - meanX;
+    const dy = ys[i] - meanY;
+    covariance += dx * dy;
+    varianceX += dx * dx;
+    varianceY += dy * dy;
+  }
+  if (varianceX === 0 || varianceY === 0) return 0;
+  return Math.max(0, covariance / Math.sqrt(varianceX * varianceY));
+}
+function pageHinkley(values, delta = 0, lambda = 50) {
+  const statistic = [];
+  let changePointIndex;
+  let sum = 0;
+  let cumulative = 0;
+  let runningMinimum = 0;
+  for (let i = 0; i < values.length; i++) {
+    sum += values[i];
+    const mean = sum / (i + 1);
+    cumulative += values[i] - mean - delta;
+    if (cumulative < runningMinimum) runningMinimum = cumulative;
+    const ph = cumulative - runningMinimum;
+    statistic.push(ph);
+    if (changePointIndex === void 0 && lambda < ph) changePointIndex = i;
+  }
+  return { statistic, changePointIndex, changeDetected: changePointIndex !== void 0 };
+}
+function mannKendall(values, alpha = 0.05) {
+  const n = values.length;
+  if (n < 2) return { s: 0, variance: 0, z: 0, pValue: 1, trend: "no-trend" };
+  let s = 0;
+  for (let i = 0; i < n - 1; i++) {
+    for (let j = i + 1; j < n; j++) {
+      s += Math.sign(values[j] - values[i]);
+    }
+  }
+  const tieGroupSizes = /* @__PURE__ */ new Map();
+  for (const value of values) tieGroupSizes.set(value, (tieGroupSizes.get(value) ?? 0) + 1);
+  let tieCorrection = 0;
+  for (const groupSize of tieGroupSizes.values()) {
+    if (1 < groupSize) tieCorrection += groupSize * (groupSize - 1) * (2 * groupSize + 5);
+  }
+  const variance = (n * (n - 1) * (2 * n + 5) - tieCorrection) / 18;
+  return { s, variance, ...mannKendallVerdict(s, variance, alpha) };
+}
+function mannKendallVerdict(s, variance, alpha = 0.05) {
+  let z = 0;
+  if (variance > 0) {
+    if (s > 0) z = (s - 1) / Math.sqrt(variance);
+    else if (s < 0) z = (s + 1) / Math.sqrt(variance);
+  }
+  const pValue = 2 * (1 - standardNormalCdf(Math.abs(z)));
+  const trend = z !== 0 && pValue < alpha ? z > 0 ? "increasing" : "decreasing" : "no-trend";
+  return { z, pValue, trend };
+}
+function standardNormalCdf(x) {
+  return 0.5 * (1 + erf(x / Math.SQRT2));
+}
+function erf(x) {
+  const sign = x < 0 ? -1 : 1;
+  const ax = Math.abs(x);
+  const a1 = 0.254829592;
+  const a2 = -0.284496736;
+  const a3 = 1.421413741;
+  const a4 = -1.453152027;
+  const a5 = 1.061405429;
+  const p = 0.3275911;
+  const t = 1 / (1 + p * ax);
+  const y = 1 - ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t * Math.exp(-(ax * ax));
+  return sign * y;
+}
+
 // src/ObservedInboundRtp.ts
 var ObservedInboundRtp = class {
   constructor(timestamp, id, ssrc, kind, trackIdentifier, _peerConnection) {
@@ -137,6 +276,48 @@ var ObservedInboundRtp = class {
   deltaBytesReceived = 0;
   deltaReceivedSamples = 0;
   deltaSilentConcealedSamples = 0;
+  // Per-tick, counter-reset-safe deltas of the cumulative RTCStats counters. These are what
+  // detectors need ("how many freezes/PLIs in THIS tick"), as opposed to the lifetime totals.
+  deltaConcealedSamples = 0;
+  deltaConcealmentEvents = 0;
+  deltaFreezeCount = 0;
+  deltaFreezesDuration = 0;
+  deltaPliCount = 0;
+  deltaNackCount = 0;
+  deltaFirCount = 0;
+  deltaPacketsDiscarded = 0;
+  deltaFramesDecoded = 0;
+  deltaFramesReceived = 0;
+  deltaFramesRendered = 0;
+  deltaFramesDropped = 0;
+  deltaKeyFramesDecoded = 0;
+  deltaDecodeTime = 0;
+  deltaJitterBufferDelay = 0;
+  deltaJitterBufferEmittedCount = 0;
+  deltaRetransmittedPacketsReceived = 0;
+  deltaFecPacketsReceived = 0;
+  deltaFecPacketsDiscarded = 0;
+  deltaPausesDuration = 0;
+  /**
+   * Mean jitter-buffer delay for the frames/samples emitted in this tick (seconds), derived from
+   * the cumulative `jitterBufferDelay` / `jitterBufferEmittedCount` pair — the only correct way to
+   * read those two counters.
+   */
+  jitterBufferDelayInMs;
+  /** Fraction of the samples received in this tick that were concealed (0..1). */
+  concealmentRatio;
+  /** Fraction of the frames received in this tick that were dropped before rendering (0..1). */
+  framesDroppedRatio;
+  /**
+   * `true` when the codec or decoder implementation changed in this tick.
+   *
+   * Chrome resets `packetsReceived`/`bytesReceived` on an SSRC when the codec switches
+   * (crbug.com/webrtc/5361, open since 2015), which shows up as a sawtooth spike or a negative
+   * rate. Every delta in this tick is therefore suppressed to `0` rather than reported as traffic
+   * — otherwise a room-wide codec rollout produces a synchronized fake-degradation alert across
+   * every participant at once.
+   */
+  counterResetBoundary = false;
   // Derived from the corresponding remote-outbound-rtp (sender report), when present.
   remoteRttInMs;
   remoteBytesSent;
@@ -177,31 +358,76 @@ var ObservedInboundRtp = class {
     this.remotePacketsSent = void 0;
     this.remoteTimestamp = void 0;
     this.bitrate = 0;
-    this.jitter = void 0;
     this.fractionLost = void 0;
     this.bitPerPixel = 0;
+    this.deltaConcealedSamples = 0;
+    this.deltaConcealmentEvents = 0;
+    this.deltaFreezeCount = 0;
+    this.deltaFreezesDuration = 0;
+    this.deltaPausesDuration = 0;
+    this.deltaPliCount = 0;
+    this.deltaNackCount = 0;
+    this.deltaFirCount = 0;
+    this.deltaPacketsDiscarded = 0;
+    this.deltaFramesDecoded = 0;
+    this.deltaFramesReceived = 0;
+    this.deltaFramesRendered = 0;
+    this.deltaFramesDropped = 0;
+    this.deltaKeyFramesDecoded = 0;
+    this.deltaDecodeTime = 0;
+    this.deltaJitterBufferDelay = 0;
+    this.deltaJitterBufferEmittedCount = 0;
+    this.deltaRetransmittedPacketsReceived = 0;
+    this.deltaFecPacketsReceived = 0;
+    this.deltaFecPacketsDiscarded = 0;
+    this.jitterBufferDelayInMs = void 0;
+    this.concealmentRatio = void 0;
+    this.framesDroppedRatio = void 0;
     const elapsedTimeInMs = stats.timestamp - this.timestamp;
-    if (elapsedTimeInMs) {
-      if (this.bytesReceived && stats.bytesReceived && this.bytesReceived < stats.bytesReceived) {
-        this.bitrate = (stats.bytesReceived - (this.bytesReceived ?? 0)) * 8 / elapsedTimeInMs;
-      }
-      if (this.packetsLost && stats.packetsLost && this.packetsLost < stats.packetsLost) {
-        this.deltaLostPackets = stats.packetsLost - this.packetsLost;
+    this.counterResetBoundary = this.codecId !== void 0 && stats.codecId !== void 0 && this.codecId !== stats.codecId || this.decoderImplementation !== void 0 && stats.decoderImplementation !== void 0 && this.decoderImplementation !== stats.decoderImplementation;
+    if (0 < elapsedTimeInMs && !this.counterResetBoundary) {
+      const elapsedInSeconds = elapsedTimeInMs / 1e3;
+      this.deltaBytesReceived = counterDelta(this.bytesReceived, stats.bytesReceived);
+      this.deltaLostPackets = counterDelta(this.packetsLost, stats.packetsLost);
+      this.deltaReceivedPackets = counterDelta(this.packetsReceived, stats.packetsReceived);
+      this.deltaReceivedSamples = counterDelta(this.totalSamplesReceived, stats.totalSamplesReceived);
+      this.deltaSilentConcealedSamples = counterDelta(this.silentConcealedSamples, stats.silentConcealedSamples);
+      this.deltaConcealedSamples = counterDelta(this.concealedSamples, stats.concealedSamples);
+      this.deltaConcealmentEvents = counterDelta(this.concealmentEvents, stats.concealmentEvents);
+      this.deltaFreezeCount = counterDelta(this.freezeCount, stats.freezeCount);
+      this.deltaFreezesDuration = counterDelta(this.totalFreezesDuration, stats.totalFreezesDuration);
+      this.deltaPausesDuration = counterDelta(this.totalPausesDuration, stats.totalPausesDuration);
+      this.deltaPliCount = counterDelta(this.pliCount, stats.pliCount);
+      this.deltaNackCount = counterDelta(this.nackCount, stats.nackCount);
+      this.deltaFirCount = counterDelta(this.firCount, stats.firCount);
+      this.deltaPacketsDiscarded = counterDelta(this.packetsDiscarded, stats.packetsDiscarded);
+      this.deltaFramesDecoded = counterDelta(this.framesDecoded, stats.framesDecoded);
+      this.deltaFramesReceived = counterDelta(this.framesReceived, stats.framesReceived);
+      this.deltaFramesRendered = counterDelta(this.framesRendered, stats.framesRendered);
+      this.deltaFramesDropped = counterDelta(this.framesDropped, stats.framesDropped);
+      this.deltaKeyFramesDecoded = counterDelta(this.keyFramesDecoded, stats.keyFramesDecoded);
+      this.deltaDecodeTime = counterDelta(this.totalDecodeTime, stats.totalDecodeTime);
+      this.deltaJitterBufferDelay = counterDelta(this.jitterBufferDelay, stats.jitterBufferDelay);
+      this.deltaJitterBufferEmittedCount = counterDelta(this.jitterBufferEmittedCount, stats.jitterBufferEmittedCount);
+      this.deltaRetransmittedPacketsReceived = counterDelta(this.retransmittedPacketsReceived, stats.retransmittedPacketsReceived);
+      this.deltaFecPacketsReceived = counterDelta(this.fecPacketsReceived, stats.fecPacketsReceived);
+      this.deltaFecPacketsDiscarded = counterDelta(this.fecPacketsDiscarded, stats.fecPacketsDiscarded);
+      this.bitrate = this.deltaBytesReceived * 8 / elapsedInSeconds;
+      const pixels = (stats.frameWidth ?? 0) * (stats.frameHeight ?? 0);
+      if (0 < pixels && 0 < this.deltaFramesReceived) {
+        this.bitPerPixel = this.deltaBytesReceived * 8 / (this.deltaFramesReceived * pixels);
       }
-      if (this.packetsReceived && stats.packetsReceived && this.packetsReceived < stats.packetsReceived) {
-        this.deltaReceivedPackets = stats.packetsReceived - this.packetsReceived;
-      }
-      if (this.totalSamplesReceived && stats.totalSamplesReceived && this.totalSamplesReceived < stats.totalSamplesReceived) {
-        this.deltaReceivedSamples = stats.totalSamplesReceived - this.totalSamplesReceived;
+      if (0 < this.deltaReceivedPackets || 0 < this.deltaLostPackets) {
+        this.fractionLost = this.deltaLostPackets / (this.deltaLostPackets + this.deltaReceivedPackets);
       }
-      if (this.silentConcealedSamples && stats.silentConcealedSamples && this.silentConcealedSamples < stats.silentConcealedSamples) {
-        this.deltaSilentConcealedSamples = stats.silentConcealedSamples - this.silentConcealedSamples;
+      if (0 < this.deltaJitterBufferEmittedCount) {
+        this.jitterBufferDelayInMs = this.deltaJitterBufferDelay / this.deltaJitterBufferEmittedCount * 1e3;
       }
-      if (stats.bytesReceived && this.framesReceived && stats.framesReceived && this.framesReceived < stats.framesReceived) {
-        this.bitPerPixel = (stats.bytesReceived - (this.bytesReceived ?? 0)) / (stats.framesReceived - this.framesReceived);
+      if (0 < this.deltaReceivedSamples) {
+        this.concealmentRatio = this.deltaConcealedSamples / this.deltaReceivedSamples;
       }
-      if (this.deltaLostPackets && this.deltaReceivedPackets) {
-        this.fractionLost = this.deltaLostPackets / (this.deltaLostPackets + this.deltaReceivedPackets);
+      if (0 < this.deltaFramesReceived) {
+        this.framesDroppedRatio = this.deltaFramesDropped / this.deltaFramesReceived;
       }
     }
     this.timestamp = stats.timestamp;
@@ -246,6 +472,10 @@ var ObservedInboundRtp = class {
     this.concealedSamples = stats.concealedSamples;
     this.silentConcealedSamples = stats.silentConcealedSamples;
     this.concealmentEvents = stats.concealmentEvents;
+    this.jitter = stats.jitter;
+    this.framesReceived = stats.framesReceived;
+    this.retransmittedPacketsReceived = stats.retransmittedPacketsReceived;
+    this.retransmittedBytesReceived = stats.retransmittedBytesReceived;
   }
 };
 
@@ -307,6 +537,25 @@ var ObservedOutboundRtp = class {
   bitPerPixel = 0;
   deltaPacketsSent = 0;
   deltaBytesSent = 0;
+  // Per-tick, counter-reset-safe deltas of the cumulative RTCStats counters.
+  deltaFramesSent = 0;
+  deltaFramesEncoded = 0;
+  deltaKeyFramesEncoded = 0;
+  deltaNackCount = 0;
+  deltaPliCount = 0;
+  deltaFirCount = 0;
+  deltaRetransmittedPacketsSent = 0;
+  deltaRetransmittedBytesSent = 0;
+  deltaEncodeTime = 0;
+  deltaQualityLimitationResolutionChanges = 0;
+  /**
+   * `true` when the codec, encoder implementation or scalability mode changed in this tick.
+   *
+   * Chrome resets `packetsSent`/`bytesSent` on the SSRC when the codec switches
+   * (crbug.com/webrtc/5361), producing sawtooth spikes and negative bitrates. All deltas for the
+   * tick are suppressed so a codec change is never mistaken for a traffic event.
+   */
+  counterResetBoundary = false;
   // Derived from the corresponding remote-inbound-rtp (receiver report), when present.
   remoteRttInMs;
   remoteFractionLost;
@@ -340,12 +589,24 @@ var ObservedOutboundRtp = class {
     this.packetRate = 0;
     this.deltaPacketsSent = 0;
     this.deltaBytesSent = 0;
+    this.deltaFramesSent = 0;
+    this.deltaFramesEncoded = 0;
+    this.deltaKeyFramesEncoded = 0;
+    this.deltaNackCount = 0;
+    this.deltaPliCount = 0;
+    this.deltaFirCount = 0;
+    this.deltaRetransmittedPacketsSent = 0;
+    this.deltaRetransmittedBytesSent = 0;
+    this.deltaEncodeTime = 0;
+    this.deltaQualityLimitationResolutionChanges = 0;
     this.remoteRttInMs = void 0;
     this.remoteFractionLost = void 0;
     this.remoteJitter = void 0;
     this.remotePacketsLost = void 0;
     const elapsedTimeInMs = stats.timestamp - this.timestamp;
-    if (elapsedTimeInMs) {
+    const changed = (a, b) => a !== void 0 && b !== void 0 && a !== b;
+    this.counterResetBoundary = changed(this.codecId, stats.codecId) || changed(this.encoderImplementation, stats.encoderImplementation) || changed(this.scalabilityMode, stats.scalabilityMode);
+    if (elapsedTimeInMs && !this.counterResetBoundary) {
       if (stats.packetsSent !== void 0 && this.packetsSent !== void 0 && stats.packetsSent >= this.packetsSent) {
         this.deltaPacketsSent = stats.packetsSent - this.packetsSent;
         this.packetRate = this.deltaPacketsSent / (elapsedTimeInMs / 1e3);
@@ -354,11 +615,24 @@ var ObservedOutboundRtp = class {
         this.deltaBytesSent = stats.bytesSent - this.bytesSent;
         this.bitrate = this.deltaBytesSent * 8 / (elapsedTimeInMs / 1e3);
       }
-      if (stats.headerBytesSent !== void 0 && this.headerBytesSent !== void 0) {
-        this.payloadBitrate = (this.deltaBytesSent ?? 0 - (stats.headerBytesSent - this.headerBytesSent)) * 8 / (elapsedTimeInMs / 1e3);
-      }
-      if (this.framesSent !== void 0 && stats.framesSent !== void 0) {
-        this.bitPerPixel = this.deltaBytesSent ? this.deltaBytesSent * 8 / (this.framesSent - stats.framesSent) : 0;
+      const deltaHeaderBytesSent = counterDelta(this.headerBytesSent, stats.headerBytesSent);
+      this.payloadBitrate = Math.max(0, this.deltaBytesSent - deltaHeaderBytesSent) * 8 / (elapsedTimeInMs / 1e3);
+      this.deltaFramesSent = counterDelta(this.framesSent, stats.framesSent);
+      this.deltaFramesEncoded = counterDelta(this.framesEncoded, stats.framesEncoded);
+      this.deltaKeyFramesEncoded = counterDelta(this.keyFramesEncoded, stats.keyFramesEncoded);
+      this.deltaNackCount = counterDelta(this.nackCount, stats.nackCount);
+      this.deltaPliCount = counterDelta(this.pliCount, stats.pliCount);
+      this.deltaFirCount = counterDelta(this.firCount, stats.firCount);
+      this.deltaRetransmittedPacketsSent = counterDelta(this.retransmittedPacketsSent, stats.retransmittedPacketsSent);
+      this.deltaRetransmittedBytesSent = counterDelta(this.retransmittedBytesSent, stats.retransmittedBytesSent);
+      this.deltaEncodeTime = counterDelta(this.totalEncodeTime, stats.totalEncodeTime);
+      this.deltaQualityLimitationResolutionChanges = counterDelta(
+        this.qualityLimitationResolutionChanges,
+        stats.qualityLimitationResolutionChanges
+      );
+      const pixels = (stats.frameWidth ?? 0) * (stats.frameHeight ?? 0);
+      if (0 < pixels && 0 < this.deltaFramesSent) {
+        this.bitPerPixel = this.deltaBytesSent * 8 / (this.deltaFramesSent * pixels);
       }
     }
     this.timestamp = stats.timestamp;
@@ -1081,6 +1355,10 @@ var ObservedInboundTrack = class {
   removedAt;
   muted;
   attachments;
+  degradationReasons = [];
+  get degraded() {
+    return this.degradationReasons.length > 0;
+  }
   get score() {
     return this.calculatedScore.value;
   }
@@ -1103,9 +1381,49 @@ var ObservedInboundTrack = class {
     this.timestamp = stats.timestamp;
     this.calculatedScore.value = stats.score;
     this.attachments = stats.attachments;
+    this.checkDegradation();
+  }
+  checkDegradation() {
+    const thresholds = this._peerConnection.client.call.observer.config.inboundTrackDegradationThresholds;
+    this.degradationReasons.length = 0;
+    if (!thresholds) return;
+    const reasons = [];
+    if (thresholds.deltaFreezeCount < (this._inboundRtp?.deltaFreezeCount ?? 0)) {
+      reasons.push("freezes");
+    }
+    if (thresholds.framesDroppedRatio < (this._inboundRtp?.framesDroppedRatio ?? 0)) {
+      reasons.push("frames-dropped");
+    }
+    if (thresholds.jitterBufferDelayInMs < (this._inboundRtp?.jitterBufferDelayInMs ?? 0)) {
+      reasons.push("jitter-buffer-delay");
+    }
+    if (thresholds.concealmentRatio < (this._inboundRtp?.concealmentRatio ?? 0)) {
+      reasons.push("concealment");
+    }
+    if (thresholds.rttInMs < (this._inboundRtp?.remoteRttInMs ?? 0)) {
+      reasons.push("rtt");
+    }
+    this.degradationReasons = reasons;
   }
 };
 
+// src/common/utils.ts
+function pushFinite(target, value) {
+  if (typeof value === "number" && Number.isFinite(value)) target.push(value);
+}
+function parseJsonAs(json) {
+  if (!json) return void 0;
+  try {
+    return JSON.parse(json);
+  } catch {
+    return void 0;
+  }
+}
+function parseJsonObject(json) {
+  const parsed = parseJsonAs(json);
+  return typeof parsed === "object" && parsed !== null ? parsed : void 0;
+}
+
 // src/ObservedOutboundTrack.ts
 var ObservedOutboundTrack = class {
   constructor(timestamp, id, kind, _peerConnection, _outboundRtps, _mediaSource) {
@@ -1125,6 +1443,10 @@ var ObservedOutboundTrack = class {
   _visited = false;
   appData;
   remoteInboundTracks = /* @__PURE__ */ new Set();
+  detectors = new Detectors();
+  // only set if the track is being received by at least one subscriber, otherwise undefined
+  // which means the remote track resolver has to be set up to know if the track is unconsumed or not
+  receivingDistribution;
   calculatedScore = {
     weight: 1,
     value: void 0
@@ -1133,6 +1455,12 @@ var ObservedOutboundTrack = class {
   removedAt;
   muted;
   attachments;
+  degradedReasons;
+  bitrate;
+  deltaPacketsSent;
+  remoteFractionLost;
+  remoteRttInMs;
+  qualityLimitationReason;
   get score() {
     return this.calculatedScore.value;
   }
@@ -1141,6 +1469,9 @@ var ObservedOutboundTrack = class {
     this._visited = false;
     return visited;
   }
+  get degraded() {
+    return (this.degradedReasons?.length ?? 0) > 0;
+  }
   getPeerConnection() {
     return this._peerConnection;
   }
@@ -1155,30 +1486,89 @@ var ObservedOutboundTrack = class {
     this.timestamp = stats.timestamp;
     this.calculatedScore.value = stats.score;
     this.attachments = stats.attachments;
+    this.bitrate = void 0;
+    this.deltaPacketsSent = void 0;
+    this.remoteFractionLost = void 0;
+    this.remoteRttInMs = void 0;
+    this.qualityLimitationReason = void 0;
+    for (const rtp of this._outboundRtps ?? []) {
+      this.bitrate = (this.bitrate ?? 0) + rtp.bitrate;
+      this.deltaPacketsSent = (this.deltaPacketsSent ?? 0) + rtp.deltaPacketsSent;
+      if (rtp.remoteFractionLost !== void 0) {
+        this.remoteFractionLost = Math.max(this.remoteFractionLost ?? 0, rtp.remoteFractionLost);
+      }
+      if (rtp.remoteRttInMs !== void 0) {
+        this.remoteRttInMs = Math.max(this.remoteRttInMs ?? 0, rtp.remoteRttInMs);
+      }
+      if (rtp.qualityLimitationReason && rtp.qualityLimitationReason !== "none") {
+        this.qualityLimitationReason = rtp.qualityLimitationReason;
+      }
+    }
+    const thresholds = this._peerConnection.client.call.observer.config.outboundTrackDegradationThresholds;
+    const reasons = [];
+    if (thresholds && thresholds.fractionLost < (this.remoteFractionLost ?? 0)) reasons.push("remote-fraction-lost");
+    if (thresholds && thresholds.rttInMs < (this.remoteRttInMs ?? 0)) reasons.push("remote-rtt");
+    if (this.qualityLimitationReason) reasons.push(`quality-limited-${this.qualityLimitationReason}`);
+    if (this.muted !== true && this.deltaPacketsSent === 0) reasons.push("no-packets-sent");
+    this.degradedReasons = reasons.length === 0 ? void 0 : reasons;
+    this.receivingDistribution = this.createReceivingDistribution();
+    this.detectors.update();
   }
-};
-
-// src/common/utils.ts
-function getMedian(arr, copyArrayForSorting = true) {
-  const sortedArr = copyArrayForSorting ? arr.slice().sort((a, b) => a - b) : arr.sort((a, b) => a - b);
-  const mid = Math.floor(sortedArr.length / 2);
-  if (sortedArr.length % 2 !== 0) {
-    return sortedArr[mid];
-  }
-  return (sortedArr[mid - 1] + sortedArr[mid]) / 2;
-}
-function parseJsonAs(json) {
-  if (!json) {
-    return void 0;
-  }
-  try {
-    return JSON.parse(json);
-  } catch (error) {
-    return void 0;
+  createReceivingDistribution() {
+    if (this.remoteInboundTracks.size === 0) return void 0;
+    let freezeAffected = 0;
+    let freezeTotal = 0;
+    let pliAffected = 0;
+    let pliTotal = 0;
+    let concealmentAffected = 0;
+    let numberOfReceivers = 0;
+    let numberOfDegradedReceivers = 0;
+    let numberOfHealthyReceivers = 0;
+    const bitrates = [];
+    const fractionLosts = [];
+    const jitters = [];
+    const rtts = [];
+    const jitterBufferDelays = [];
+    const concealmentRatios = [];
+    for (const inboundTrack of this.remoteInboundTracks) {
+      const inboundRtp = inboundTrack.getInboundRtp();
+      const peerConnection = inboundTrack.getPeerConnection();
+      if (!inboundRtp) continue;
+      if (0 < inboundRtp.deltaFreezeCount) freezeAffected += 1;
+      if (0 < inboundRtp.deltaPliCount) pliAffected += 1;
+      if (0 < (inboundRtp.concealmentRatio ?? 0)) concealmentAffected += 1;
+      if (inboundTrack.degraded) numberOfDegradedReceivers += 1;
+      else numberOfHealthyReceivers += 1;
+      pliTotal += inboundRtp.deltaPliCount;
+      freezeTotal += inboundRtp.deltaFreezeCount;
+      ++numberOfReceivers;
+      pushFinite(bitrates, inboundRtp.bitrate);
+      pushFinite(fractionLosts, inboundRtp.fractionLost);
+      pushFinite(jitters, inboundRtp.jitter);
+      pushFinite(rtts, peerConnection?.currentRttInMs);
+      pushFinite(jitterBufferDelays, inboundRtp.jitterBufferDelayInMs);
+      pushFinite(concealmentRatios, inboundRtp.concealmentRatio);
+    }
+    return {
+      numberOfReceivers,
+      numberOfHealthyReceivers,
+      numberOfDegradedReceivers,
+      degradedRatio: numberOfReceivers === 0 ? 0 : numberOfDegradedReceivers / numberOfReceivers,
+      bitrate: summarize(bitrates),
+      fractionLost: summarize(fractionLosts),
+      jitter: summarize(jitters),
+      rttInMs: summarize(rtts),
+      jitterBufferDelayInMs: summarize(jitterBufferDelays),
+      concealmentRatio: summarize(concealmentRatios),
+      freezes: { affectedReceivers: freezeAffected, total: freezeTotal },
+      plis: { affectedReceivers: pliAffected, total: pliTotal },
+      concealment: { affectedReceivers: concealmentAffected }
+    };
   }
-}
+};
 
 // src/ObservedPeerConnection.ts
+var ascending2 = (a, b) => a - b;
 var logger = createLogger("ObservedPeerConnection");
 var ObservedPeerConnection = class extends EventEmitter {
   constructor(peerConnectionId, client) {
@@ -1252,7 +1642,34 @@ var ObservedPeerConnection = class extends EventEmitter {
   sendingVideoBitrate = 0;
   receivingAudioBitrate = 0;
   receivingVideoBitrate = 0;
+  /**
+   * Median round-trip time of the tick, in ms.
+   *
+   * Prefers {@link rtcpRttInMs} and falls back to {@link iceRttInMs}, so within one tick it always
+   * reports **one** kind of round trip. It used to be the median of both mixed together, which was
+   * a bug: the mixing ratio changed as streams came and went, so the value moved for reasons that
+   * had nothing to do with the network.
+   */
   currentRttInMs;
+  /**
+   * RTT measured by ICE/STUN consent checks, in ms — the trip to **whatever terminates ICE**. In an
+   * SFU topology that is the SFU, so this is the client↔SFU leg, not client↔client.
+   */
+  iceRttInMs;
+  /**
+   * RTT reported by RTCP receiver reports, in ms — an **end-to-end** media-path round trip.
+   *
+   * Not the same trip as {@link iceRttInMs}; the difference between the two is roughly the far side
+   * of the SFU (see {@link sfuHopRttInMs}).
+   */
+  rtcpRttInMs;
+  /**
+   * `rtcpRttInMs - iceRttInMs`, when both are known — an estimate of everything *past* the SFU.
+   *
+   * Useful for splitting "this client's own last mile is slow" (high `iceRttInMs`) from "the path
+   * beyond the SFU is slow" (low ICE, high hop).
+   */
+  sfuHopRttInMs;
   currentJitter;
   usingTCP = false;
   usingTURN = false;
@@ -1324,9 +1741,10 @@ var ObservedPeerConnection = class extends EventEmitter {
     return this.iceTransports.map((iceTransport) => iceTransport.getSelectedCandidatePair()).filter((pair) => pair !== void 0);
   }
   get selectedIceCandiadtePairForTurn() {
-    return this.selectedIceCandidatePairs.filter(
-      (pair) => pair.getLocalCandidate()?.candidateType === "relay" && pair.getRemoteCandidate()?.url?.startsWith("turn:")
-    );
+    return this.selectedIceCandidatePairs.filter((pair) => {
+      const localCandidate = pair.getLocalCandidate();
+      return localCandidate?.candidateType === "relay" && localCandidate?.url?.startsWith("turn") === true;
+    });
   }
   close() {
     if (this.closed) return;
@@ -1402,7 +1820,8 @@ var ObservedPeerConnection = class extends EventEmitter {
     const now = Date.now();
     const elapsedTimeInMs = now - this.updated;
     const elapsedTimeInSec = elapsedTimeInMs / 1e3;
-    const rttMeasurementsInSec = [];
+    const iceRttMeasurementsInSec = [];
+    const rtcpRttMeasurementsInSec = [];
     const jitterMeasurements = [];
     if (sample.certificates) {
       for (const certificate of sample.certificates) {
@@ -1434,7 +1853,7 @@ var ObservedPeerConnection = class extends EventEmitter {
         const observedCandidatePair = this._updateIceCandidatePairStats(iceCandidatePair);
         if (!observedCandidatePair) continue;
         if (observedCandidatePair.currentRoundTripTime) {
-          rttMeasurementsInSec.push(observedCandidatePair.currentRoundTripTime);
+          iceRttMeasurementsInSec.push(observedCandidatePair.currentRoundTripTime);
         }
         if (observedCandidatePair.availableIncomingBitrate) {
           this.availableIncomingBitrate += observedCandidatePair.availableIncomingBitrate;
@@ -1511,7 +1930,7 @@ var ObservedPeerConnection = class extends EventEmitter {
         const observedRemoteInboundRtp = this._updateRemoteInboundRtpStats(remoteInboundRtp);
         if (!observedRemoteInboundRtp) continue;
         if (observedRemoteInboundRtp.roundTripTime) {
-          rttMeasurementsInSec.push(observedRemoteInboundRtp.roundTripTime);
+          rtcpRttMeasurementsInSec.push(observedRemoteInboundRtp.roundTripTime);
         }
         const observedOutboundRtp = observedRemoteInboundRtp.getOutboundRtp();
         if (observedOutboundRtp) {
@@ -1582,13 +2001,12 @@ var ObservedPeerConnection = class extends EventEmitter {
     this.sendingVideoBitrate = this.deltaSentVideoBytes * 8 / elapsedTimeInSec;
     this.receivingAudioBitrate = this.deltaReceivedAudioBytes * 8 / elapsedTimeInSec;
     this.receivingVideoBitrate = this.deltaReceivedVideoBytes * 8 / elapsedTimeInSec;
-    if (rttMeasurementsInSec.length > 0) {
-      this.currentRttInMs = getMedian(rttMeasurementsInSec, false) * 1e3;
-    } else {
-      this.currentRttInMs = void 0;
-    }
+    this.iceRttInMs = 0 < iceRttMeasurementsInSec.length ? percentileOfSorted(iceRttMeasurementsInSec.sort(ascending2), 0.5) * 1e3 : void 0;
+    this.rtcpRttInMs = 0 < rtcpRttMeasurementsInSec.length ? percentileOfSorted(rtcpRttMeasurementsInSec.sort(ascending2), 0.5) * 1e3 : void 0;
+    this.currentRttInMs = this.rtcpRttInMs ?? this.iceRttInMs;
+    this.sfuHopRttInMs = this.rtcpRttInMs !== void 0 && this.iceRttInMs !== void 0 ? Math.max(0, this.rtcpRttInMs - this.iceRttInMs) : void 0;
     if (jitterMeasurements.length > 0) {
-      this.currentJitter = getMedian(jitterMeasurements, false);
+      this.currentJitter = percentileOfSorted(jitterMeasurements.sort(ascending2), 0.5);
     } else {
       this.currentJitter = void 0;
     }
@@ -1598,12 +2016,15 @@ var ObservedPeerConnection = class extends EventEmitter {
     this.usingTCP = false;
     this.usingTURN = false;
     for (const selectedCandidatePair of selectedIceCandidatePairs) {
-      if (selectedCandidatePair.getLocalCandidate()?.protocol === "tcp") {
+      const localCandidate = selectedCandidatePair.getLocalCandidate();
+      if (localCandidate?.protocol === "tcp") {
         this.usingTCP = true;
       }
-      if (selectedCandidatePair.getLocalCandidate()?.candidateType === "relay" && selectedCandidatePair.getRemoteCandidate()?.url?.startsWith("turn:")) {
-        selectedCandidatePairForTurn.push(selectedCandidatePair);
+      if (localCandidate?.candidateType === "relay") {
         this.usingTURN = true;
+        if (localCandidate.url?.startsWith("turn")) {
+          selectedCandidatePairForTurn.push(selectedCandidatePair);
+        }
       }
       this.deltaTransportReceivedBytes += selectedCandidatePair.deltaBytesReceived;
       this.deltaTransportSentBytes += selectedCandidatePair.deltaBytesSent;
@@ -2095,10 +2516,19 @@ var ClientMetaTypes = /* @__PURE__ */ ((ClientMetaTypes2) => {
   return ClientMetaTypes2;
 })(ClientMetaTypes || {});
 
+// src/issues/ActiveClientIssue.ts
+var RESOLVED_ISSUE_SUFFIX = "-resolved";
+function isClientIssueResolutionEntry(issue) {
+  return issue.type.endsWith(RESOLVED_ISSUE_SUFFIX);
+}
+function baseIssueType(type) {
+  return type.endsWith(RESOLVED_ISSUE_SUFFIX) ? type.slice(0, -RESOLVED_ISSUE_SUFFIX.length) : type;
+}
+
 // src/ObservedClient.ts
 var logger2 = createLogger("ObservedClient");
 var ObservedClient = class extends EventEmitter2 {
-  constructor(settings, call) {
+  constructor(settings, call, activeIssues) {
     super();
     this.call = call;
     this.setMaxListeners(Infinity);
@@ -2114,6 +2544,7 @@ var ObservedClient = class extends EventEmitter2 {
       this.sink.once("close", () => this.sink?.off("error", onError));
       this.sink.on("error", onError);
     }
+    this.activeIssues = activeIssues;
   }
   call;
   clientId;
@@ -2180,7 +2611,16 @@ var ObservedClient = class extends EventEmitter2 {
   numberOfScoreMeasurements = 0;
   // public totalNumberOfIssues = 0;
   mediaDevices = [];
-  issues = [];
+  /**
+   * The client's currently **open** stateful issues, keyed by `ClientIssue.key` — the server-side
+   * mirror of the client monitor's own active-issue map (client-monitor-js >= 4.6.0).
+   *
+   * This turns point-in-time symptom reports into intervals, which is what lets detectors ask
+   * "are these clients broken *at the same time*" instead of "did they both report something
+   * recently". Entries are opened by a raise, closed by the matching `<type>-resolved` entry, and
+   * force-closed when the client closes.
+   */
+  activeIssues;
   _pendingInjections = {};
   _activeSample;
   closeTimer;
@@ -2193,6 +2633,10 @@ var ObservedClient = class extends EventEmitter2 {
   close() {
     if (this.closed) return;
     this._flushPendingInjections();
+    const activeIssues = [...this.activeIssues.values()];
+    for (const issue of activeIssues) {
+      this._resolveIssue({ key: issue.key, type: `${issue.type}${RESOLVED_ISSUE_SUFFIX}` }, "client-closed");
+    }
     this.closed = true;
     Array.from(this.observedPeerConnections.values()).forEach((peerConnection) => peerConnection.close());
     if (!this.leftAt) {
@@ -2324,10 +2768,17 @@ var ObservedClient = class extends EventEmitter2 {
       this._processClientEvent(clientEvent);
     }
     this.attachments = sample.attachments;
-    this.receivingAudioBitrate = this.deltaReceivedAudioBytes * 8 / elapsedInSeconds;
-    this.receivingVideoBitrate = this.deltaReceivedVideoBytes * 8 / elapsedInSeconds;
-    this.sendingAudioBitrate = this.deltaSentAudioBytes * 8 / elapsedInSeconds;
-    this.sendingVideoBitrate = this.deltaSentVideoBytes * 8 / elapsedInSeconds;
+    if (0 < elapsedInSeconds) {
+      this.receivingAudioBitrate = this.deltaReceivedAudioBytes * 8 / elapsedInSeconds;
+      this.receivingVideoBitrate = this.deltaReceivedVideoBytes * 8 / elapsedInSeconds;
+      this.sendingAudioBitrate = this.deltaSentAudioBytes * 8 / elapsedInSeconds;
+      this.sendingVideoBitrate = this.deltaSentVideoBytes * 8 / elapsedInSeconds;
+    } else {
+      this.receivingAudioBitrate = 0;
+      this.receivingVideoBitrate = 0;
+      this.sendingAudioBitrate = 0;
+      this.sendingVideoBitrate = 0;
+    }
     this.currentAvgRttInMs = 0 < numberOfRttMeasurements ? sumOfRtts / numberOfRttMeasurements : void 0;
     this.calculatedScore.value = sample.score;
     this.lastSampleTimestamp = sample.timestamp;
@@ -2429,13 +2880,82 @@ var ObservedClient = class extends EventEmitter2 {
     }
     this._notify("client-metadata", { ...this.eventScope, metaData: metadata });
   }
+  /**
+   * Process one `clientIssues[]` entry.
+   *
+   * Entries come in two flavours (client-monitor-js >= 4.6.0):
+   *
+   * - a **raise** — opens an {@link ActiveClientIssue} under `issue.key` and emits `client-issue`;
+   * - a **resolution** — `type` ends in `-resolved` and carries the same `key`; it closes the
+   *   matching active issue and emits `client-issue-resolved`.
+   *
+   * Keyless entries are one-shot: reported, never tracked. A re-raise of a key already active
+   * refreshes the payload rather than opening a second interval.
+   */
   addIssue(issue) {
     if (this.closed) return;
+    if (isClientIssueResolutionEntry(issue)) {
+      return this._resolveIssue(issue);
+    }
+    const now = Date.now();
+    if (issue.key) {
+      const payload = parseJsonObject(issue.payload);
+      const existing = this.activeIssues.get(issue.key);
+      if (existing) {
+        existing.payload = payload ?? existing.payload;
+      } else {
+        const active = {
+          key: issue.key,
+          type: baseIssueType(issue.type),
+          clientId: this.clientId,
+          callId: this.call.callId,
+          raisedAt: issue.timestamp ?? now,
+          observedAt: now,
+          payload,
+          peerConnectionId: typeof payload?.peerConnectionId === "string" ? payload.peerConnectionId : void 0,
+          trackId: typeof payload?.trackId === "string" ? payload.trackId : void 0
+        };
+        this.activeIssues.add(active);
+      }
+    }
     this._notify("client-issue", { ...this.eventScope, issue });
   }
   addExtensionStats(stats) {
     this._notify("client-extension-stats", { ...this.eventScope, extensionStats: stats });
   }
+  /** Close the active issue a `<type>-resolved` entry refers to, and announce the finished interval. */
+  _resolveIssue(issue, resolvedBy = "client") {
+    const now = Date.now();
+    const resolutionPayload = parseJsonObject(issue.payload);
+    const type = baseIssueType(issue.type);
+    const raisedAt = typeof resolutionPayload?.raisedAt === "number" ? resolutionPayload.raisedAt : void 0;
+    const active = issue.key ? this.activeIssues.get(issue.key) : void 0;
+    if (active) {
+      this.activeIssues.remove(active.key);
+    }
+    const resolvedAt = issue.timestamp ?? now;
+    const durationInMs = typeof resolutionPayload?.durationInMs === "number" ? resolutionPayload.durationInMs : Math.max(0, resolvedAt - (active?.raisedAt ?? raisedAt ?? resolvedAt));
+    this._notify("client-issue-resolved", {
+      ...this.eventScope,
+      resolvedIssue: {
+        key: active?.key ?? issue.key ?? `${this.clientId}:${type}:${raisedAt ?? resolvedAt}`,
+        type,
+        clientId: this.clientId,
+        callId: this.call.callId,
+        raisedAt: active?.raisedAt ?? raisedAt ?? resolvedAt,
+        observedAt: active?.observedAt ?? now,
+        payload: active?.payload,
+        peerConnectionId: active?.peerConnectionId,
+        trackId: active?.trackId,
+        resolvedAt,
+        observedResolvedAt: now,
+        durationInMs,
+        comment: typeof resolutionPayload?.comment === "string" ? resolutionPayload.comment : void 0,
+        resolutionPayload,
+        resolvedBy
+      }
+    });
+  }
   _processClientEvent(event, postBuffer) {
     switch (event.type) {
       case "CLIENT_JOINED" /* CLIENT_JOINED */: {
@@ -2738,83 +3258,6 @@ var DefaultCallScoreCalculator = class {
   }
 };
 
-// src/updaters/OnAllClientCallUpdater.ts
-var OnAllClientCallUpdater = class {
-  constructor(_observedCall) {
-    this._observedCall = _observedCall;
-    this._onNewObservedClient = this._onNewObservedClient.bind(this);
-    this._observedCall.once("close", () => {
-      this._observedCall.off("newclient", this._onNewObservedClient);
-    });
-    this._observedCall.on("newclient", this._onNewObservedClient);
-  }
-  _observedCall;
-  name = "OnAllClientCallUpdater";
-  description = "Call the update() method of the ObservedCall once all client has been updated";
-  _updatedClients = /* @__PURE__ */ new Set();
-  closed = false;
-  close() {
-    if (this.closed) return;
-    this.closed = true;
-    this._updatedClients.clear();
-  }
-  _onNewObservedClient(observedClient) {
-    if (this.closed) return;
-    const onUpdate = (...args) => this._onClientUpdate(observedClient, args[2]);
-    observedClient.once("close", () => {
-      observedClient.off("update", onUpdate);
-      this._updatedClients.delete(observedClient.clientId);
-      this._updateIfEveryClientUpdated();
-    });
-    observedClient.on("update", onUpdate);
-  }
-  _onClientUpdate(observedClient, context) {
-    if (observedClient.closed) return;
-    this._updatedClients.add(observedClient.clientId);
-    this._updateIfEveryClientUpdated(context);
-  }
-  _updateIfEveryClientUpdated(context) {
-    if (this._updatedClients.size < this._observedCall.observedClients.size) {
-      return;
-    } else if (this.closed) {
-      return;
-    }
-    this._updatedClients.clear();
-    this._observedCall.update(context);
-  }
-};
-
-// src/updaters/OnAnyClientCallUpdater.ts
-var OnAnyClientCallUpdater = class {
-  constructor(_observedCall) {
-    this._observedCall = _observedCall;
-    this._onNewObservedClient = this._onNewObservedClient.bind(this);
-    this._observedCall.once("close", () => {
-      this._observedCall.off("newclient", this._onNewObservedClient);
-    });
-    this._observedCall.on("newclient", this._onNewObservedClient);
-  }
-  _observedCall;
-  name = "OnAnyClientCallUpdater";
-  description = "Call the update() method of the ObservedCall when any of the client has been updated";
-  closed = false;
-  close() {
-    if (this.closed) return;
-    this.closed = true;
-  }
-  _onNewObservedClient(observedClient) {
-    if (this.closed) return;
-    const onUpdate = (...args) => {
-      if (this.closed) return;
-      this._observedCall.update(args[2]);
-    };
-    observedClient.once("close", () => {
-      observedClient.off("update", onUpdate);
-    });
-    observedClient.on("update", onUpdate);
-  }
-};
-
 // src/detectors/Detectors.ts
 var logger3 = createLogger("Detectors");
 var Detectors = class {
@@ -2825,11 +3268,18 @@ var Detectors = class {
   get listOfNames() {
     return this._detectors.map((d) => d.name);
   }
+  get size() {
+    return this._detectors.length;
+  }
   add(detector) {
     this._detectors.push(detector);
   }
+  get(name) {
+    return this._detectors.find((detector) => detector.name === name);
+  }
   remove(detector) {
     this._detectors = this._detectors.filter((d) => d !== detector);
+    this._close(detector);
   }
   update() {
     for (const detector of this._detectors) {
@@ -2841,128 +3291,993 @@ var Detectors = class {
     }
   }
   clear() {
+    const detectors = this._detectors;
     this._detectors = [];
+    for (const detector of detectors) this._close(detector);
+  }
+  _close(detector) {
+    try {
+      detector.close?.();
+    } catch (err) {
+      logger3.warn(`Error closing detector ${detector?.name}`, err);
+    }
   }
 };
 
-// src/ObservedCall.ts
-var logger4 = createLogger("ObservedCall");
-var ObservedCall = class extends EventEmitter3 {
-  constructor(settings, observer) {
-    super();
-    this.observer = observer;
-    this.setMaxListeners(Infinity);
-    this.eventScope = { observer: this.observer, observedCall: this };
-    this.callId = settings.callId;
-    this.appData = settings.appData ?? {};
-    this.scoreCalculator = new DefaultCallScoreCalculator(this);
-    this.detectors = new Detectors();
-    switch (settings.updatePolicy) {
-      case "update-on-any-client-updated":
-        this.updater = new OnAnyClientCallUpdater(this);
-        break;
-      case "update-when-all-client-updated":
-        this.updater = new OnAllClientCallUpdater(this);
-        break;
-      case "none":
-        break;
-    }
-    this.settings = {
-      closeCallIfEmptyForMs: settings.closeCallIfEmptyForMs
+// src/issues/ObservedClientIssueRegistry.ts
+var ObservedClientIssueRegistry = class {
+  constructor(registry) {
+    this.registry = registry;
+  }
+  registry;
+  issues = /* @__PURE__ */ new Map();
+  get size() {
+    return this.issues.size;
+  }
+  keys() {
+    return this.issues.keys();
+  }
+  values() {
+    return this.issues.values();
+  }
+  get(key) {
+    return this.issues.get(key);
+  }
+  add(issue) {
+    const existing = this.issues.get(issue.key);
+    if (existing && existing !== issue) this.registry?.delete(existing);
+    this.issues.set(issue.key, issue);
+    this.registry?.add(issue);
+    return this;
+  }
+  remove(key) {
+    const issue = this.issues.get(key);
+    if (!issue) return void 0;
+    this.issues.delete(key);
+    this.registry?.delete(issue);
+    return issue;
+  }
+  clear() {
+    for (const key of [...this.issues.keys()]) this.remove(key);
+  }
+};
+
+// src/detectors/UnconsumedTrackDetector.ts
+var UnconsumedTrackTypes = {
+  /** A track is being published to the SFU that nobody is subscribed to — pure wasted uplink. */
+  unconsumedPublishedTrack: "UNCONSUMED_PUBLISHED_TRACK"
+};
+var UnconsumedTrackDetector = class _UnconsumedTrackDetector {
+  constructor(call, config = {}) {
+    this.call = call;
+    this.config = {
+      cooldownMs: 3e5,
+      minUnconsumedDurationInMs: 3e4,
+      minBitrate: 5e4,
+      ...config
     };
   }
-  observer;
-  updater;
-  scoreCalculator;
-  detectors;
-  callId;
-  observedClients = /* @__PURE__ */ new Map();
-  clientsUsedTurn = /* @__PURE__ */ new Set();
-  calculatedScore = {
-    weight: 1,
-    value: void 0
-  };
-  remoteTrackResolver;
-  totalAddedClients = 0;
-  totalRemovedClients = 0;
-  numberOfIssues = 0;
-  numberOfPeerConnections = 0;
-  numberOfInboundRtpStreams = 0;
-  numberOfOutboundRtpStreams = 0;
-  numberOfDataChannels = 0;
-  maxNumberOfClients = 0;
-  deltaNumberOfIssues = 0;
-  // public deltaRttLt50Measurements = 0;
-  // public deltaRttLt150Measurements = 0;
-  // public deltaRttLt300Measurements = 0;
-  // public deltaRttGtOrEq300Measurements = 0;
-  appData;
-  closed = false;
-  startedAt;
-  endedAt;
-  closedAt;
-  settings;
-  /** Ancestry base shared by all Observer-bus events originating at this call. */
-  eventScope;
-  closeTimer;
-  get numberOfClients() {
-    return this.observedClients.size;
+  call;
+  static NAME = "unconsumed-track-detector";
+  name = _UnconsumedTrackDetector.NAME;
+  config;
+  /** trackId -> when it was first seen sending with no subscribers. */
+  _unconsumedSince = /* @__PURE__ */ new Map();
+  _lastRaisedAt = /* @__PURE__ */ new Map();
+  update() {
+    if (!this.call.remoteTrackResolver) return;
+    const unconsumed = this.call.unconsumedOutboundTracks;
+    if (unconsumed.size === 0) {
+      if (0 < this._unconsumedSince.size) this._unconsumedSince.clear();
+      return;
+    }
+    const now = Date.now();
+    const seen = /* @__PURE__ */ new Set();
+    for (const outboundTrack of unconsumed) {
+      const rtps = outboundTrack.getOutboundRtps() ?? [];
+      let bitrate = 0;
+      let sending = false;
+      for (let i = 0; i < rtps.length; i++) {
+        bitrate += rtps[i].bitrate;
+        if (0 < rtps[i].deltaPacketsSent) sending = true;
+      }
+      seen.add(outboundTrack.id);
+      if (!sending || bitrate < this.config.minBitrate) {
+        this._unconsumedSince.delete(outboundTrack.id);
+        continue;
+      }
+      const since = this._unconsumedSince.get(outboundTrack.id) ?? now;
+      this._unconsumedSince.set(outboundTrack.id, since);
+      const unconsumedForMs = now - since;
+      if (unconsumedForMs < this.config.minUnconsumedDurationInMs) continue;
+      if (now - (this._lastRaisedAt.get(outboundTrack.id) ?? 0) < this.config.cooldownMs) continue;
+      this._lastRaisedAt.set(outboundTrack.id, now);
+      const peerConnection = outboundTrack.getPeerConnection();
+      this.call.addIssue({
+        type: UnconsumedTrackTypes.unconsumedPublishedTrack,
+        timestamp: now,
+        payload: {
+          type: UnconsumedTrackTypes.unconsumedPublishedTrack,
+          trackId: outboundTrack.id,
+          kind: outboundTrack.kind,
+          publisherClientId: peerConnection?.client.clientId,
+          peerConnectionId: peerConnection?.peerConnectionId,
+          bitrate,
+          unconsumedForMs,
+          // what the waste costs, roughly, if it continues
+          wastedBytesPerSecond: bitrate / 8
+        }
+      });
+    }
+    for (const trackId of [...this._unconsumedSince.keys()]) {
+      if (!seen.has(trackId)) this._unconsumedSince.delete(trackId);
+    }
   }
-  get score() {
-    return this.calculatedScore.value;
+  close() {
+    this._unconsumedSince.clear();
+    this._lastRaisedAt.clear();
   }
-  /** Raise a call-level (server-side) issue; surfaced on the Observer bus as `call-issue`. */
-  addIssue(issue) {
-    if (this.closed) return;
-    this._notify("call-issue", { ...this.eventScope, issue });
+};
+
+// src/detectors/TrackDeliveryMismatchDetector.ts
+var TrackDeliveryMismatchTypes = {
+  /**
+   * The source is sending, but **none** of its subscribers are receiving → the media is being lost
+   * between the publisher and the receivers. In an SFU that means the forwarding path.
+   */
+  publishedTrackNotDelivered: "PUBLISHED_TRACK_NOT_DELIVERED",
+  /**
+   * The source is sending and most subscribers are fine, but **some** are dry → those consumers are
+   * broken individually (in mediasoup, the usual mitigation is recreating the consumer).
+   */
+  receiverTrackNotDelivered: "RECEIVER_TRACK_NOT_DELIVERED",
+  /**
+   * The source itself stopped producing, so its subscribers being dry is expected and **not** an
+   * SFU fault. Reported so the other two verdicts can be trusted as *not* being this.
+   */
+  publisherTrackDry: "PUBLISHER_TRACK_DRY"
+};
+var TrackDeliveryMismatchDetector = class _TrackDeliveryMismatchDetector {
+  constructor(call, config = {}) {
+    this.call = call;
+    this._config = {
+      dryOutboundIssueType: "dry-outbound-track",
+      dryInboundIssueType: "dry-inbound-track",
+      minReceivers: 2,
+      allReceiversRatio: 1,
+      cooldownMs: 6e4,
+      ...config
+    };
+    this.call.activeIssuesRegistry.addIssueTracker(this._config.dryOutboundIssueType, this);
+    this.call.activeIssuesRegistry.addIssueTracker(this._config.dryInboundIssueType, this);
   }
+  call;
+  static NAME = "track-delivery-mismatch-detector";
+  name = _TrackDeliveryMismatchDetector.NAME;
+  _config;
+  _lastRaisedAt = /* @__PURE__ */ new Map();
+  dryOutboundTracks = /* @__PURE__ */ new Set();
+  dryInboundTracks = /* @__PURE__ */ new Set();
   close() {
-    if (this.closed) return;
-    this.update();
-    this.closed = true;
-    this.updater?.close();
-    let minSampleTimestamps;
-    let maxSampleTimestamps;
-    for (const client of this.observedClients.values()) {
-      client.close();
-      if (client.joinedAt) minSampleTimestamps = Math.min(minSampleTimestamps ?? client.joinedAt, client.joinedAt);
-      if (client.leftAt) maxSampleTimestamps = Math.max(maxSampleTimestamps ?? client.leftAt, client.leftAt);
+    this.call.activeIssuesRegistry.removeIssueTracker(this);
+    this._lastRaisedAt.clear();
+    this.clear();
+  }
+  add(issue) {
+    if (issue.type === this._config.dryOutboundIssueType) {
+      if (issue.trackId) {
+        this.dryOutboundTracks.add(issue.trackId);
+      }
+    } else if (issue.type === this._config.dryInboundIssueType) {
+      if (issue.trackId) {
+        this.dryInboundTracks.add(issue.trackId);
+      }
     }
-    if (this.startedAt === void 0) this.startedAt = minSampleTimestamps;
-    if (this.endedAt === void 0) this.endedAt = maxSampleTimestamps;
-    this.closedAt = Date.now();
-    this.emit("close");
-    this._notify("call-closed", { ...this.eventScope });
   }
-  getObservedClient(clientId) {
-    if (this.closed || !this.observedClients.has(clientId)) return;
-    return this.observedClients.get(clientId);
+  delete(issue) {
+    if (issue.type === this._config.dryOutboundIssueType) {
+      this.dryOutboundTracks.delete(issue.trackId ?? "");
+    } else if (issue.type === this._config.dryInboundIssueType) {
+      this.dryInboundTracks.delete(issue.trackId ?? "");
+    }
+    return true;
   }
-  createObservedClient(settings) {
-    if (this.closed) {
-      logger4.warn("Attempted to create a client (clientId: %s) on a closed call %s", settings.clientId, this.callId);
-      return void 0;
+  get size() {
+    return this.dryOutboundTracks.size + this.dryInboundTracks.size;
+  }
+  clear() {
+    this.dryOutboundTracks.clear();
+    this.dryInboundTracks.clear();
+  }
+  has(issue) {
+    if (issue.type === this._config.dryOutboundIssueType) {
+      return this.dryOutboundTracks.has(issue.trackId ?? "");
+    } else if (issue.type === this._config.dryInboundIssueType) {
+      return this.dryInboundTracks.has(issue.trackId ?? "");
     }
-    if (this.observedClients.has(settings.clientId)) {
-      logger4.warn("Client with id %s already exists in call %s; returning the existing instance", settings.clientId, this.callId);
-      return this.observedClients.get(settings.clientId);
+    return false;
+  }
+  update() {
+    const now = Date.now();
+    const deliveries = /* @__PURE__ */ new Map();
+    for (const client of this.call.observedClients.values()) {
+      for (const peerConnection of client.observedPeerConnections.values()) {
+        for (const outboundTrack of peerConnection.observedOutboundTracks.values()) {
+          deliveries.set(outboundTrack.id, {
+            publisherClientId: client.clientId,
+            publisherSending: (outboundTrack.bitrate ?? 0) > 0,
+            publisherDryIssue: this.dryOutboundTracks.has(outboundTrack.id),
+            publisherBitrate: outboundTrack.bitrate ?? 0,
+            numberOfDrySubscribers: 0,
+            numberOfSubscribers: 0
+          });
+        }
+        for (const inboundTrack of peerConnection.observedInboundTracks.values()) {
+          const delivery = deliveries.get(inboundTrack.remoteOutboundTrack?.id ?? "");
+          if (!delivery) {
+            continue;
+          }
+          delivery.numberOfDrySubscribers += this.dryInboundTracks.has(inboundTrack.id) ? 1 : 0;
+          delivery.numberOfSubscribers += 1;
+        }
+      }
     }
-    if (!settings.closeClientIfIdleForMs) {
-      settings.closeClientIfIdleForMs = this.observer.config.closeClientIfIdleForMs;
+    for (const [outboundTrackId, delivery] of deliveries) {
+      if (delivery.numberOfSubscribers < this._config.minReceivers) {
+        continue;
+      }
+      if (delivery.publisherSending && delivery.numberOfDrySubscribers === 0) continue;
+      const dryRatio = delivery.numberOfDrySubscribers / delivery.numberOfSubscribers;
+      let type;
+      if (!delivery.publisherSending) {
+        type = TrackDeliveryMismatchTypes.publisherTrackDry;
+      } else if (this._config.allReceiversRatio <= dryRatio) {
+        type = TrackDeliveryMismatchTypes.publishedTrackNotDelivered;
+      } else {
+        type = TrackDeliveryMismatchTypes.receiverTrackNotDelivered;
+      }
+      const key = `${outboundTrackId}:${type}`;
+      if (now - (this._lastRaisedAt.get(key) ?? 0) < this._config.cooldownMs) continue;
+      this._lastRaisedAt.set(key, now);
+      this.call.addIssue({
+        type,
+        timestamp: now,
+        payload: {
+          type,
+          trackId: outboundTrackId,
+          publisherClientId: delivery.publisherClientId,
+          publisherSending: delivery.publisherSending,
+          publisherDryIssue: delivery.publisherDryIssue,
+          publisherBitrate: delivery.publisherBitrate,
+          numberOfSubscribers: delivery.numberOfSubscribers,
+          numberOfDrySubscribers: delivery.numberOfDrySubscribers
+        }
+      });
     }
-    if (settings.appData === void 0) {
-      settings.appData = this.observer.config.createClientAppData?.({ clientId: settings.clientId, observedCall: this });
+  }
+};
+
+// src/detectors/IssueConclusion.ts
+var families = [
+  {
+    match: (t) => t.startsWith("congestion") || t.includes("bandwidth"),
+    family: {
+      label: "congestion",
+      infrastructure: {
+        summary: "network congestion is open across independent calls at the same time",
+        recommendation: "check SFU egress bandwidth and host network saturation before looking at any single participant"
+      },
+      call: {
+        summary: "most of this call is congested at once",
+        recommendation: "check the SFU worker serving this call, and whether one publisher is saturating it"
+      }
     }
-    const result = new ObservedClient(settings, this);
-    const wasEmpty = this.observedClients.size === 0;
-    const onUpdate = () => this._onClientUpdate(result);
-    const joined = () => this._clientJoined(result);
+  },
+  {
+    match: (t) => t.startsWith("ice-") || t.includes("turn") || t === "unstable-ice-path",
+    family: {
+      label: "connectivity",
+      infrastructure: {
+        summary: "ICE connectivity is failing across independent calls at the same time",
+        recommendation: "check SFU reachability and TURN health; a worker restart shows up as a wave of DTLS-stage failures rather than pure consent loss"
+      },
+      call: {
+        summary: "this call is losing ICE connectivity broadly",
+        recommendation: "check the SFU worker and the transports belonging to this call"
+      }
+    }
+  },
+  {
+    match: (t) => t.startsWith("audio-") || t.includes("concealment") || t.includes("jitter-buffer"),
+    family: {
+      label: "audio",
+      infrastructure: {
+        summary: "audio impairment is open across independent calls at the same time",
+        recommendation: "check SFU egress and the audio forwarding path; concealment rising fleet-wide is a delivery symptom, not a device one"
+      },
+      call: {
+        summary: "audio is impaired for most of this call",
+        recommendation: "check this call's SFU worker; if only receivers are affected, the publisher's uplink is the next place to look"
+      },
+      publishedTrack: {
+        summary: "the subscribers of one published audio track are impaired while others are fine",
+        recommendation: "check that publisher's uplink and the SFU's forwarding of that producer; the receivers themselves are exonerated by the fan-out"
+      }
+    }
+  },
+  {
+    match: (t) => t.includes("video") || t.includes("freeze") || t.includes("keyframe") || t.includes("decoder"),
+    family: {
+      label: "video delivery",
+      infrastructure: {
+        summary: "video delivery is degraded across independent calls at the same time",
+        recommendation: "check SFU egress and the keyframe/PLI path; a keyframe storm fleet-wide usually means the server is dropping or not answering PLIs"
+      },
+      call: {
+        summary: "video is degraded for most of this call",
+        recommendation: "check this call's SFU worker and whether PLIs are being answered"
+      },
+      publishedTrack: {
+        summary: "the subscribers of one published video track are degraded while others are fine",
+        recommendation: "check that publisher's uplink and the forwarding of that producer; consider recreating the consumers if only some receivers are affected"
+      }
+    }
+  },
+  {
+    match: (t) => t.includes("cpu") || t.includes("overloaded") || t.includes("encoder") || t.includes("performance"),
+    family: {
+      label: "endpoint capacity",
+      // Breadth here does NOT implicate the servers. Endpoint CPU is owned by the endpoint, so the
+      // same symptom in many unrelated calls points at what those endpoints have in common —
+      // a client release, a browser update, a VDI host — not at the SFU.
+      crossCallDomain: "client-population",
+      infrastructure: {
+        summary: "endpoint CPU limitation is open across independent calls at the same time",
+        recommendation: "this is not an SFU symptom: look at what the affected clients share \u2014 a recent client release, a browser version, or shared/virtualised hardware"
+      },
+      call: {
+        summary: "most participants of this call are CPU limited",
+        recommendation: "check whether the call is asking too much of endpoints (layer count, resolution, participant grid size)"
+      }
+    }
+  }
+];
+var unknownFamily = { label: "issue" };
+function familyOf(issueType) {
+  return families.find((entry) => entry.match(issueType))?.family ?? unknownFamily;
+}
+function callConfidenceOf(spread) {
+  let confidence = 0.3;
+  if (0 < spread.totalClients) {
+    confidence += Math.min(0.3, spread.affectedClients / spread.totalClients * 0.3);
+  }
+  if (spread.onsetBurst) confidence += 0.2;
+  if (spread.publishedTrackId !== void 0) confidence += 0.1;
+  return Math.min(1, Math.round(confidence * 100) / 100);
+}
+function observerConfidenceOf(spread) {
+  let confidence = 0.3 + Math.min(0.4, Math.max(0, spread.affectedCalls - 1) * 0.1);
+  if (spread.onsetBurst) confidence += 0.2;
+  return Math.min(1, Math.round(confidence * 100) / 100);
+}
+function concludeCallIssue(spread) {
+  const family = familyOf(spread.issueType);
+  const confidence = callConfidenceOf(spread);
+  const affectedShare = 0 < spread.totalClients ? ` (${spread.affectedClients}/${spread.totalClients} clients)` : "";
+  if (spread.publishedTrackId !== void 0) {
+    const text = family.publishedTrack;
+    return {
+      faultDomain: "published-track",
+      confidence,
+      summary: text ? `${text.summary} \u2014 track ${spread.publishedTrackId}${affectedShare}` : `'${spread.issueType}' follows published track ${spread.publishedTrackId}${affectedShare}, so the fault is on that source's path rather than the receivers'`,
+      recommendation: text?.recommendation
+    };
+  }
+  if (1 < spread.affectedClients) {
+    const text = family.call;
+    return {
+      faultDomain: "call",
+      confidence,
+      summary: text ? `${text.summary}${affectedShare}` : `'${spread.issueType}' is open for ${spread.affectedClients} of ${spread.totalClients} participants of one call`,
+      recommendation: text?.recommendation
+    };
+  }
+  return {
+    faultDomain: spread.affectedClients === 1 ? "endpoint" : "unknown",
+    confidence,
+    summary: `'${spread.issueType}' affects a single endpoint; nothing is shared with the other participants`,
+    recommendation: "treat as that participant's own device or last mile"
+  };
+}
+function concludeObserverIssue(spread) {
+  const family = familyOf(spread.issueType);
+  const confidence = observerConfidenceOf(spread);
+  const affectedShare = 0 < spread.totalClients ? ` (${spread.affectedClients}/${spread.totalClients} clients)` : "";
+  if (spread.affectedCalls <= 1) {
+    return {
+      faultDomain: "call",
+      confidence,
+      summary: `'${spread.issueType}' is confined to a single call${affectedShare}; that is a meeting problem, not a fleet one`,
+      recommendation: "look at the call-scoped finding for this call rather than at the infrastructure"
+    };
+  }
+  const domain = family.crossCallDomain ?? "infrastructure";
+  const text = family.infrastructure;
+  return {
+    faultDomain: domain,
+    confidence,
+    summary: text ? `${text.summary} \u2014 ${spread.affectedCalls} of ${spread.totalCalls} calls${affectedShare}` : `'${spread.issueType}' is open in ${spread.affectedCalls} of ${spread.totalCalls} independent calls at once${affectedShare}; they share only the infrastructure`,
+    recommendation: text?.recommendation
+  };
+}
+
+// src/detectors/CallConcurrentIssueDetector.ts
+var CallConcurrentIssueTypes = {
+  /** Several participants of this call have the same issue open **at the same time**. */
+  concurrentClientIssues: "CONCURRENT_CLIENT_ISSUES",
+  /** Those issues also *began* together — the signature of one shared event. */
+  issueOnsetBurst: "ISSUE_ONSET_BURST"
+};
+var CallConcurrentIssueDetector = class _CallConcurrentIssueDetector {
+  constructor(_call, config = {}) {
+    this._call = _call;
+    this._config = {
+      issueTypes: [],
+      minClients: 3,
+      minAffectedClients: 3,
+      affectedRatioThreshold: 0.5,
+      onsetBurstWindowInMs: 2e3,
+      cooldownMs: 6e4,
+      ...config
+    };
+    for (const type of this._config.issueTypes) {
+      this._call.activeIssuesRegistry.addIssueTracker(type, this);
+    }
+  }
+  _call;
+  static NAME = "call-concurrent-issue-detector";
+  name = _CallConcurrentIssueDetector.NAME;
+  _config;
+  _lastRaisedAt = /* @__PURE__ */ new Map();
+  /** issue type -> the issues of that type currently open in this call. */
+  _byType = /* @__PURE__ */ new Map();
+  _size = 0;
+  /** The groups that qualified on the most recent `update()`. Exposed for tests/dashboards. */
+  lastGroups = [];
+  get size() {
+    return this._size;
+  }
+  has(issue) {
+    return this._byType.get(issue.type)?.has(issue) ?? false;
+  }
+  add(issue) {
+    let bucket = this._byType.get(issue.type);
+    if (!bucket) {
+      bucket = /* @__PURE__ */ new Set();
+      this._byType.set(issue.type, bucket);
+    }
+    if (bucket.has(issue)) return;
+    bucket.add(issue);
+    ++this._size;
+  }
+  delete(issue) {
+    const bucket = this._byType.get(issue.type);
+    if (!bucket?.delete(issue)) return false;
+    --this._size;
+    if (bucket.size === 0) this._byType.delete(issue.type);
+    return true;
+  }
+  clear() {
+    this._byType.clear();
+    this._size = 0;
+    this.lastGroups = [];
+  }
+  update() {
+    this.lastGroups = [];
+    if (this._size === 0) return;
+    const now = Date.now();
+    const totalClients = this._call.observedClients.size;
+    if (totalClients < this._config.minClients) return;
+    for (const [type, issues] of this._byType) {
+      const group = this._groupOf(type, issues, totalClients);
+      if (group.clientIds.length < this._config.minAffectedClients) continue;
+      if (group.affectedRatio < this._config.affectedRatioThreshold) continue;
+      this.lastGroups.push(group);
+      if (now - (this._lastRaisedAt.get(type) ?? 0) < this._config.cooldownMs) continue;
+      this._lastRaisedAt.set(type, now);
+      const burst = group.onsetSpreadInMs <= this._config.onsetBurstWindowInMs;
+      const issueType = burst ? CallConcurrentIssueTypes.issueOnsetBurst : CallConcurrentIssueTypes.concurrentClientIssues;
+      const conclusion = concludeCallIssue({
+        issueType: type,
+        affectedClients: group.clientIds.length,
+        totalClients: group.totalClients,
+        onsetBurst: burst
+      });
+      this._call.addIssue({
+        type: issueType,
+        timestamp: now,
+        payload: {
+          type: issueType,
+          issueType: type,
+          scope: "call",
+          conclusion,
+          callId: this._call.callId,
+          clients: group.totalClients,
+          affectedClients: group.clientIds.length,
+          affectedRatio: group.affectedRatio,
+          affectedClientIds: group.clientIds,
+          onsetSpreadInMs: group.onsetSpreadInMs,
+          onsetBurst: burst,
+          firstObservedAt: group.firstObservedAt
+        }
+      });
+    }
+  }
+  close() {
+    this._call.activeIssuesRegistry.removeIssueTracker(this);
+    this._lastRaisedAt.clear();
+    this.clear();
+  }
+  _groupOf(type, issues, totalClients) {
+    const clientIds = /* @__PURE__ */ new Set();
+    const list = [];
+    let earliest = Infinity;
+    let latest = -Infinity;
+    for (const issue of issues) {
+      list.push(issue);
+      clientIds.add(issue.clientId);
+      if (issue.observedAt < earliest) earliest = issue.observedAt;
+      if (latest < issue.observedAt) latest = issue.observedAt;
+    }
+    return {
+      type,
+      issues: list,
+      clientIds: [...clientIds],
+      totalClients,
+      affectedRatio: 0 < totalClients ? clientIds.size / totalClients : 0,
+      onsetSpreadInMs: latest - earliest,
+      firstObservedAt: earliest
+    };
+  }
+};
+
+// src/detectors/IssueFanOutDetector.ts
+var IssueFanOutTypes = {
+  /** Most receivers of one published track have the same issue open → the fault follows the source. */
+  publishedTrackIssueFanOut: "PUBLISHED_TRACK_ISSUE_FAN_OUT",
+  /** Exactly one receiver of a track has it → that receiver's own problem. */
+  singleReceiverIssue: "SINGLE_RECEIVER_ISSUE"
+};
+var IssueFanOutDetector = class _IssueFanOutDetector {
+  constructor(_call, config = {}) {
+    this._call = _call;
+    this._config = {
+      issueTypes: [],
+      minReceivers: 3,
+      affectedRatioThreshold: 0.6,
+      reportSingleReceiver: true,
+      cooldownMs: 6e4,
+      ...config
+    };
+    for (const type of this._config.issueTypes) {
+      this._call.activeIssuesRegistry.addIssueTracker(type, this);
+    }
+  }
+  _call;
+  static NAME = "issue-fan-out-detector";
+  name = _IssueFanOutDetector.NAME;
+  _config;
+  _lastRaisedAt = /* @__PURE__ */ new Map();
+  /** Open issues that name a track. Issues without a `trackId` cannot be attributed and are dropped. */
+  _trackIssues = /* @__PURE__ */ new Set();
+  get size() {
+    return this._trackIssues.size;
+  }
+  has(issue) {
+    return this._trackIssues.has(issue);
+  }
+  add(issue) {
+    if (issue.trackId === void 0) return;
+    this._trackIssues.add(issue);
+  }
+  delete(issue) {
+    return this._trackIssues.delete(issue);
+  }
+  clear() {
+    this._trackIssues.clear();
+  }
+  update() {
+    if (this._trackIssues.size === 0) return;
+    if (!this._call.remoteTrackResolver) return;
+    const now = Date.now();
+    const byPublisher = /* @__PURE__ */ new Map();
+    for (const issue of this._trackIssues) {
+      const publisher = this._publisherOf(issue);
+      if (!publisher) continue;
+      let byType = byPublisher.get(publisher);
+      if (!byType) {
+        byType = /* @__PURE__ */ new Map();
+        byPublisher.set(publisher, byType);
+      }
+      const clientIds = byType.get(issue.type) ?? /* @__PURE__ */ new Set();
+      clientIds.add(issue.clientId);
+      byType.set(issue.type, clientIds);
+    }
+    for (const [publisher, byType] of byPublisher) {
+      const numberOfReceivers = publisher.remoteInboundTracks.size;
+      if (numberOfReceivers === 0) continue;
+      for (const [issueType, clientIds] of byType) {
+        const affectedRatio = clientIds.size / numberOfReceivers;
+        const isFanOut = this._config.minReceivers <= numberOfReceivers && this._config.affectedRatioThreshold <= affectedRatio;
+        const isSingle = this._config.reportSingleReceiver && clientIds.size === 1 && 1 < numberOfReceivers;
+        if (!isFanOut && !isSingle) continue;
+        const key = `${publisher.id}:${issueType}`;
+        if (now - (this._lastRaisedAt.get(key) ?? 0) < this._config.cooldownMs) continue;
+        this._lastRaisedAt.set(key, now);
+        const type = isFanOut ? IssueFanOutTypes.publishedTrackIssueFanOut : IssueFanOutTypes.singleReceiverIssue;
+        const conclusion = concludeCallIssue({
+          issueType,
+          affectedClients: clientIds.size,
+          totalClients: numberOfReceivers,
+          onsetBurst: false,
+          publishedTrackId: isFanOut ? publisher.id : void 0
+        });
+        this._call.addIssue({
+          type,
+          timestamp: now,
+          payload: {
+            type,
+            issueType,
+            conclusion,
+            trackId: publisher.id,
+            kind: publisher.kind,
+            publisherClientId: publisher.getPeerConnection().client.clientId,
+            // The corroborating half: if the source's own egress looks fine while its
+            // receivers do not, the SFU/forwarding path is implicated rather than the sender.
+            publisherBitrate: publisher.bitrate,
+            publisherDegraded: publisher.degraded,
+            publisherDegradedReasons: publisher.degradedReasons,
+            receivers: numberOfReceivers,
+            affectedReceivers: clientIds.size,
+            affectedRatio,
+            affectedClientIds: [...clientIds]
+          }
+        });
+      }
+    }
+  }
+  close() {
+    this._call.activeIssuesRegistry.removeIssueTracker(this);
+    this._lastRaisedAt.clear();
+    this.clear();
+  }
+  /**
+   * Resolve the issue's `trackId` to the outbound track that published it.
+   *
+   * Looked up through the reporting client's own peer connections rather than by scanning the call:
+   * the issue names its client, so the search is bounded by that client's transports (typically one
+   * or two) instead of by the size of the meeting.
+   */
+  _publisherOf(issue) {
+    const client = this._call.observedClients.get(issue.clientId);
+    if (!client || issue.trackId === void 0) return void 0;
+    for (const peerConnection of client.observedPeerConnections.values()) {
+      const inboundTrack = peerConnection.observedInboundTracks.get(issue.trackId);
+      if (inboundTrack) return inboundTrack.remoteOutboundTrack;
+    }
+    return void 0;
+  }
+};
+
+// src/detectors/PublisherFaultCorroborationDetector.ts
+var PublisherFaultTypes = {
+  /**
+   * A publisher is reporting trouble on its own send path **while** its subscribers report trouble
+   * receiving it. Both ends agree, so the source is implicated rather than inferred.
+   */
+  corroboratedPublisherFault: "CORROBORATED_PUBLISHER_FAULT"
+};
+var PublisherFaultCorroborationDetector = class _PublisherFaultCorroborationDetector {
+  constructor(_call, config = {}) {
+    this._call = _call;
+    this._config = {
+      publisherIssueTypes: [],
+      receiverIssueTypes: [],
+      minAffectedReceivers: 2,
+      cooldownMs: 6e4,
+      ...config
+    };
+    for (const type of this._config.publisherIssueTypes) {
+      this._call.activeIssuesRegistry.addIssueTracker(type, this);
+    }
+    for (const type of this._config.receiverIssueTypes) {
+      this._call.activeIssuesRegistry.addIssueTracker(type, this);
+    }
+  }
+  _call;
+  static NAME = "publisher-fault-corroboration-detector";
+  name = _PublisherFaultCorroborationDetector.NAME;
+  _config;
+  _lastRaisedAt = /* @__PURE__ */ new Map();
+  /** Open publisher-side issues that name a track. */
+  _publisherIssues = /* @__PURE__ */ new Set();
+  /** Open receiver-side issues that name a track. */
+  _receiverIssues = /* @__PURE__ */ new Set();
+  /** The faults corroborated on the most recent `update()`. Exposed for tests/dashboards. */
+  lastFaults = [];
+  get size() {
+    return this._publisherIssues.size + this._receiverIssues.size;
+  }
+  has(issue) {
+    return this._publisherIssues.has(issue) || this._receiverIssues.has(issue);
+  }
+  add(issue) {
+    if (issue.trackId === void 0) return;
+    if (this._config.publisherIssueTypes.includes(issue.type)) this._publisherIssues.add(issue);
+    else if (this._config.receiverIssueTypes.includes(issue.type)) this._receiverIssues.add(issue);
+  }
+  delete(issue) {
+    return this._publisherIssues.delete(issue) || this._receiverIssues.delete(issue);
+  }
+  clear() {
+    this._publisherIssues.clear();
+    this._receiverIssues.clear();
+    this.lastFaults = [];
+  }
+  update() {
+    this.lastFaults = [];
+    if (this._publisherIssues.size === 0 || this._receiverIssues.size === 0) return;
+    if (!this._call.remoteTrackResolver) return;
+    const now = Date.now();
+    const suspects = /* @__PURE__ */ new Map();
+    for (const issue of this._publisherIssues) {
+      const publisher = this._outboundTrackOf(issue);
+      if (!publisher) continue;
+      const types = suspects.get(publisher) ?? /* @__PURE__ */ new Set();
+      types.add(issue.type);
+      suspects.set(publisher, types);
+    }
+    if (suspects.size === 0) return;
+    const receiverIssuesByTrackId = /* @__PURE__ */ new Map();
+    for (const issue of this._receiverIssues) {
+      const existing = receiverIssuesByTrackId.get(issue.trackId);
+      if (existing) existing.push(issue);
+      else receiverIssuesByTrackId.set(issue.trackId, [issue]);
+    }
+    for (const [publisher, publisherIssueTypes] of suspects) {
+      const receivers = publisher.remoteInboundTracks;
+      if (receivers.size === 0) continue;
+      const affectedClientIds = /* @__PURE__ */ new Set();
+      const receiverIssueTypes = /* @__PURE__ */ new Set();
+      for (const receiver of receivers) {
+        const issues = receiverIssuesByTrackId.get(receiver.id);
+        if (!issues) continue;
+        for (const issue of issues) {
+          affectedClientIds.add(issue.clientId);
+          receiverIssueTypes.add(issue.type);
+        }
+      }
+      if (affectedClientIds.size < this._config.minAffectedReceivers) continue;
+      const fault = {
+        trackId: publisher.id,
+        kind: publisher.kind,
+        publisherClientId: publisher.getPeerConnection().client.clientId,
+        publisherIssueTypes: [...publisherIssueTypes],
+        receiverIssueTypes: [...receiverIssueTypes],
+        receivers: receivers.size,
+        affectedReceivers: affectedClientIds.size,
+        affectedClientIds: [...affectedClientIds],
+        publisherBitrate: publisher.bitrate
+      };
+      this.lastFaults.push(fault);
+      if (now - (this._lastRaisedAt.get(publisher.id) ?? 0) < this._config.cooldownMs) continue;
+      this._lastRaisedAt.set(publisher.id, now);
+      this._call.addIssue({
+        type: PublisherFaultTypes.corroboratedPublisherFault,
+        timestamp: now,
+        payload: {
+          type: PublisherFaultTypes.corroboratedPublisherFault,
+          callId: this._call.callId,
+          ...fault,
+          conclusion: {
+            faultDomain: "published-track",
+            summary: `${fault.publisherClientId} reports ${fault.publisherIssueTypes.join(", ")} on track ${fault.trackId} while ${fault.affectedReceivers} of ${fault.receivers} subscribers report ${fault.receiverIssueTypes.join(", ")} \u2014 both ends agree`,
+            recommendation: "the source is implicated, not inferred: check that publisher's capture, encoder and uplink before looking at the SFU or the receivers",
+            // Higher than any single-ended finding: two independent parties, one conclusion.
+            confidence: 0.9
+          }
+        }
+      });
+    }
+  }
+  close() {
+    this._call.activeIssuesRegistry.removeIssueTracker(this);
+    this._lastRaisedAt.clear();
+    this.clear();
+  }
+  /**
+   * Resolve a publisher-side issue's `trackId` to the outbound track it is about.
+   *
+   * Looked up through the reporting client's own peer connections: the issue names its client, so
+   * the search is bounded by that client's transports rather than by the size of the call.
+   */
+  _outboundTrackOf(issue) {
+    const client = this._call.observedClients.get(issue.clientId);
+    if (!client || issue.trackId === void 0) return void 0;
+    for (const peerConnection of client.observedPeerConnections.values()) {
+      const outboundTrack = peerConnection.observedOutboundTracks.get(issue.trackId);
+      if (outboundTrack) return outboundTrack;
+    }
+    return void 0;
+  }
+};
+
+// src/ObservedCall.ts
+var logger4 = createLogger("ObservedCall");
+var ObservedCall = class extends EventEmitter3 {
+  constructor(settings, observer, activeIssuesRegistry) {
+    super();
+    this.observer = observer;
+    this.activeIssuesRegistry = activeIssuesRegistry;
+    this.setMaxListeners(Infinity);
+    this.eventScope = { observer: this.observer, observedCall: this };
+    this.callId = settings.callId;
+    this.appData = settings.appData ?? {};
+    this.scoreCalculator = new DefaultCallScoreCalculator(this);
+    this.detectors = new Detectors();
+    this.settings = {
+      closeCallIfEmptyForMs: settings.closeCallIfEmptyForMs,
+      autoUpdateOnClientUpdate: settings.autoUpdateOnClientUpdate ?? true
+    };
+  }
+  observer;
+  activeIssuesRegistry;
+  scoreCalculator;
+  detectors;
+  callId;
+  observedClients = /* @__PURE__ */ new Map();
+  clientsUsedTurn = /* @__PURE__ */ new Set();
+  calculatedScore = {
+    weight: 1,
+    value: void 0
+  };
+  remoteTrackResolver;
+  /**
+   * Published tracks that currently have **no** subscriber linked to them.
+   *
+   * Maintained by the `RemoteTrackResolver` at the exact moments a track gains or loses its last
+   * subscriber — the only moments the answer can change. `UnconsumedTrackDetector` reads this
+   * instead of walking every published track in the call, so in a healthy call (where the set is
+   * empty) it does no work at all.
+   *
+   * Empty when no resolver is configured: without links, "no subscribers" is unknowable.
+   */
+  unconsumedOutboundTracks = /* @__PURE__ */ new Set();
+  totalAddedClients = 0;
+  totalRemovedClients = 0;
+  numberOfIssues = 0;
+  numberOfPeerConnections = 0;
+  numberOfInboundRtpStreams = 0;
+  numberOfOutboundRtpStreams = 0;
+  numberOfDataChannels = 0;
+  maxNumberOfClients = 0;
+  deltaNumberOfIssues = 0;
+  // public deltaRttLt50Measurements = 0;
+  // public deltaRttLt150Measurements = 0;
+  // public deltaRttLt300Measurements = 0;
+  // public deltaRttGtOrEq300Measurements = 0;
+  appData;
+  closed = false;
+  startedAt;
+  endedAt;
+  closedAt;
+  settings;
+  /** Ancestry base shared by all Observer-bus events originating at this call. */
+  eventScope;
+  closeTimer;
+  get numberOfClients() {
+    return this.observedClients.size;
+  }
+  get score() {
+    return this.calculatedScore.value;
+  }
+  addDetector(name, config = {}) {
+    if (this.closed) return this;
+    let detector;
+    switch (name) {
+      case UnconsumedTrackDetector.NAME: {
+        detector = new UnconsumedTrackDetector(this, config);
+        break;
+      }
+      case TrackDeliveryMismatchDetector.NAME: {
+        detector = new TrackDeliveryMismatchDetector(this, config);
+        break;
+      }
+      case CallConcurrentIssueDetector.NAME: {
+        detector = new CallConcurrentIssueDetector(this, config);
+        break;
+      }
+      case IssueFanOutDetector.NAME: {
+        detector = new IssueFanOutDetector(this, config);
+        break;
+      }
+      case PublisherFaultCorroborationDetector.NAME: {
+        detector = new PublisherFaultCorroborationDetector(this, config);
+        break;
+      }
+      default: {
+        logger4.warn("Unknown detector name %s; skipping", name);
+        return this;
+      }
+    }
+    this.detectors.add(detector);
+    return this;
+  }
+  /**
+   * Raise a call-level (server-side) finding; surfaced on the Observer bus as `call-issue`.
+   *
+   * `payload` takes an **object** — it is delivered to in-process handlers, so there is nothing to
+   * serialise for. Pass a string only if you already have one.
+   */
+  addIssue(issue) {
+    if (this.closed) return;
+    this._notify("call-issue", { ...this.eventScope, issue });
+  }
+  close() {
+    if (this.closed) return;
+    this.update();
+    this.closed = true;
+    let minSampleTimestamps;
+    let maxSampleTimestamps;
+    const clients = [...this.observedClients.values()];
+    for (const client of clients) {
+      client.close();
+      if (client.joinedAt) minSampleTimestamps = Math.min(minSampleTimestamps ?? client.joinedAt, client.joinedAt);
+      if (client.leftAt) maxSampleTimestamps = Math.max(maxSampleTimestamps ?? client.leftAt, client.leftAt);
+    }
+    if (this.startedAt === void 0) this.startedAt = minSampleTimestamps;
+    if (this.endedAt === void 0) this.endedAt = maxSampleTimestamps;
+    this.closedAt = Date.now();
+    this.detectors.clear();
+    this.activeIssuesRegistry.clear();
+    this.emit("close");
+    this._notify("call-closed", { ...this.eventScope });
+  }
+  getObservedClient(clientId) {
+    if (this.closed || !this.observedClients.has(clientId)) return;
+    return this.observedClients.get(clientId);
+  }
+  createObservedClient(settings) {
+    if (this.closed) {
+      logger4.warn("Attempted to create a client (clientId: %s) on a closed call %s", settings.clientId, this.callId);
+      return void 0;
+    }
+    if (this.observedClients.has(settings.clientId)) {
+      logger4.warn("Client with id %s already exists in call %s; returning the existing instance", settings.clientId, this.callId);
+      return this.observedClients.get(settings.clientId);
+    }
+    if (!settings.closeClientIfIdleForMs) {
+      settings.closeClientIfIdleForMs = this.observer.config.closeClientIfIdleForMs;
+    }
+    if (settings.appData === void 0) {
+      settings.appData = this.observer.config.createClientAppData?.({ clientId: settings.clientId, observedCall: this });
+    }
+    const observedClientIssueRegistry = new ObservedClientIssueRegistry(this.activeIssuesRegistry);
+    const result = new ObservedClient(
+      settings,
+      this,
+      observedClientIssueRegistry
+    );
+    const wasEmpty = this.observedClients.size === 0;
+    const onUpdate = (...args) => this._onClientUpdate(result, args[2]);
+    const joined = () => this._clientJoined(result);
     const left = () => this._clientLeft(result);
     result.once("close", () => {
       result.off("update", onUpdate);
       result.off("joined", joined);
       result.off("left", left);
       this.observedClients.delete(settings.clientId);
+      this.clientsUsedTurn.delete(settings.clientId);
       if (this.observedClients.size === 0) {
         this.emit("empty");
         this._notify("call-empty", { ...this.eventScope });
@@ -3016,11 +4331,13 @@ var ObservedCall = class extends EventEmitter3 {
     this._notify("call-updated", { ...this.eventScope, context });
     this.deltaNumberOfIssues = 0;
   }
-  _onClientUpdate(client) {
+  _onClientUpdate(client, context) {
     this.deltaNumberOfIssues += client.deltaNumberOfIssues;
     this.numberOfIssues += client.deltaNumberOfIssues;
-    if (client.usingTURN) {
-      this.clientsUsedTurn.add(client.clientId);
+    if (client.usingTURN) this.clientsUsedTurn.add(client.clientId);
+    else this.clientsUsedTurn.delete(client.clientId);
+    if (this.settings.autoUpdateOnClientUpdate) {
+      this.update(context);
     }
   }
   _clientJoined(client) {
@@ -3129,21 +4446,22 @@ var ObservedTURN = class extends EventEmitter4 {
     this.numberOfClients = clientIds.size;
   }
   addPeerConnection(peerConnection) {
-    const turnPairs = peerConnection.selectedIceCandidatePairs.filter((pair) => pair.getLocalCandidate()?.candidateType === "relay" && pair.getRemoteCandidate()?.url?.startsWith("turn:"));
+    const turnPairs = peerConnection.selectedIceCandiadtePairForTurn;
     if (turnPairs.length !== 1) {
       return logger5.warn(`Expected exactly one TURN pair, but found for peerconnection ${peerConnection.peerConnectionId}`, turnPairs.length), void 0;
     }
     const candidatePair = turnPairs[0];
-    const rawUrl = candidatePair.getRemoteCandidate()?.url;
+    const rawUrl = candidatePair.getLocalCandidate()?.url;
     if (!rawUrl) {
-      return logger5.warn(`No remote candidate URL found for peerconnection ${peerConnection.peerConnectionId}`), void 0;
+      return logger5.warn(`No local candidate URL found for peerconnection ${peerConnection.peerConnectionId}`), void 0;
     }
-    const turnUrl = new URL(rawUrl);
-    const turnServerUrl = `${turnUrl.protocol}//${turnUrl.hostname}:${turnUrl.port}`;
+    const turnServerUrl = rawUrl.split("?")[0];
     let turnServer = this.servers.get(turnServerUrl);
     if (!turnServer) {
       turnServer = new ObservedTurnServer(turnServerUrl, this);
+      this.servers.set(turnServerUrl, turnServer);
     }
+    turnServer.observedPeerConnections.set(peerConnection.peerConnectionId, peerConnection);
     return turnServer;
   }
   removePeerConnection(peerConnection) {
@@ -3153,80 +4471,6 @@ var ObservedTURN = class extends EventEmitter4 {
   }
 };
 
-// src/updaters/OnAllCallObserverUpdater.ts
-var OnAllCallObserverUpdater = class {
-  constructor(observer) {
-    this.observer = observer;
-    this._onNewObservedCall = this._onNewObservedCall.bind(this);
-    this.observer.once("observer-closed", () => {
-      this.observer.off("call-added", this._onNewObservedCall);
-    });
-    this.observer.on("call-added", this._onNewObservedCall);
-  }
-  observer;
-  name = "OnAllCallObserverUpdater";
-  description = "Call Observer's update() method when all of the ObservedCalls are updated";
-  _updatedCalls = /* @__PURE__ */ new Set();
-  closed = false;
-  close() {
-    if (this.closed) return;
-    this.closed = true;
-    this._updatedCalls.clear();
-  }
-  _onNewObservedCall({ observedCall }) {
-    if (this.closed) return;
-    const onUpdate = () => this._onObservedCallUpdated(observedCall);
-    observedCall.once("close", () => {
-      observedCall.off("update", onUpdate);
-      this._updatedCalls.delete(observedCall.callId);
-      this._updateIfEveryCallUpdated();
-    });
-    observedCall.on("update", onUpdate);
-  }
-  _onObservedCallUpdated(observedCall) {
-    if (observedCall.closed) return;
-    this._updatedCalls.add(observedCall.callId);
-    this._updateIfEveryCallUpdated();
-  }
-  _updateIfEveryCallUpdated() {
-    if (this._updatedCalls.size < this.observer.observedCalls.size) return;
-    else if (this.closed) return;
-    this._updatedCalls.clear();
-    this.observer.update();
-  }
-};
-
-// src/updaters/OnAnyCallObserverUpdater.ts
-var OnAnyCallObserverUpdater = class {
-  constructor(observver) {
-    this.observver = observver;
-    this._onNewObservedCall = this._onNewObservedCall.bind(this);
-    this.observver.once("observer-closed", () => {
-      this.observver.off("call-added", this._onNewObservedCall);
-    });
-    this.observver.on("call-added", this._onNewObservedCall);
-  }
-  observver;
-  name = "OnAnyCallObserverUpdater";
-  description = "Call Observer's update() method on any of the ObservedCall is updated";
-  closed = false;
-  close() {
-    if (this.closed) return;
-    this.closed = true;
-  }
-  _onNewObservedCall({ observedCall }) {
-    if (this.closed) return;
-    const onUpdate = () => {
-      if (this.closed) return;
-      this.observver.update();
-    };
-    observedCall.once("close", () => {
-      observedCall.off("update", onUpdate);
-    });
-    observedCall.on("update", onUpdate);
-  }
-};
-
 // src/common/Middleware.ts
 var Executor = class {
   constructor(stack, finalCallback) {
@@ -3293,10 +4537,19 @@ var ObservedMediasoupRouter = class extends EventEmitter5 {
   sample;
   webrtcTransportIds = /* @__PURE__ */ new Set();
   closed = false;
+  // Id -> sample indexes over the arrays in `this.sample`, so an entity can be reached in O(1)
+  // instead of scanning (`sample.producers.find(...)`). They hold the *same* objects as the arrays.
+  _transportSamples = /* @__PURE__ */ new Map();
+  _producerSamples = /* @__PURE__ */ new Map();
+  _consumerSamples = /* @__PURE__ */ new Map();
+  _dataProducerSamples = /* @__PURE__ */ new Map();
+  _dataConsumerSamples = /* @__PURE__ */ new Map();
+  _enrich;
   constructor(settings) {
     super();
     this.router = settings.router;
     this.appData = settings.appData ?? {};
+    this._enrich = settings.enrich;
     this.sample = {
       routerId: this.router.id,
       attachments: settings.attachments ?? {},
@@ -3315,6 +4568,52 @@ var ObservedMediasoupRouter = class extends EventEmitter5 {
   get attachments() {
     return this.sample.attachments;
   }
+  /* ---------------------------------------------------------------------------------------------
+   * Reaching individual entity samples.
+   *
+   * `sample.producers` (and friends) are arrays because that is the shape you want to serialize.
+   * These accessors index the same objects by id, so annotating one entity is an O(1) lookup and a
+   * mutation, rather than a scan that silently does nothing when the id is wrong.
+   * ------------------------------------------------------------------------------------------- */
+  getTransportSample(id) {
+    return this._transportSamples.get(id);
+  }
+  getProducerSample(id) {
+    return this._producerSamples.get(id);
+  }
+  getConsumerSample(id) {
+    return this._consumerSamples.get(id);
+  }
+  getDataProducerSample(id) {
+    return this._dataProducerSamples.get(id);
+  }
+  getDataConsumerSample(id) {
+    return this._dataConsumerSamples.get(id);
+  }
+  /**
+   * Merge `attachments` into an entity's sample, whichever kind it is.
+   *
+   * Ids are unique across mediasoup entity kinds, so one method covers all of them. Returns `false`
+   * when the id is unknown — a real answer instead of failing quietly, which matters when the
+   * annotation is driven by application events that may race the mediasoup ones.
+   */
+  attachTo(id, attachments) {
+    const sample = this._transportSamples.get(id) ?? this._producerSamples.get(id) ?? this._consumerSamples.get(id) ?? this._dataProducerSamples.get(id) ?? this._dataConsumerSamples.get(id);
+    if (!sample) return false;
+    sample.attachments = { ...sample.attachments, ...attachments };
+    return true;
+  }
+  /**
+   * A **detached deep copy** of the current sample — the basis for building your own report.
+   *
+   * `this.sample` is live: its arrays grow and its `history` entries are appended as the router
+   * runs, so a report built directly on it keeps changing after you think you're done. This returns
+   * a snapshot that never moves.
+   */
+  snapshot() {
+    if (typeof structuredClone === "function") return structuredClone(this.sample);
+    return JSON.parse(JSON.stringify(this.sample));
+  }
   close() {
     if (this.closed) return;
     this.closed = true;
@@ -3352,7 +4651,7 @@ var ObservedMediasoupRouter = class extends EventEmitter5 {
       tuple: transport.iceSelectedTuple,
       history
     };
-    this.sample.transports.push(transportSample);
+    this._addTransportSample(transportSample, transport);
     this.webrtcTransportIds.add(transport.id);
     const onIceStateChange = (iceState) => history.push({ type: `icestate-changed-to-${iceState}`, timestamp: Date.now() });
     const onIceSelectedTupleChange = (tuple) => {
@@ -3386,7 +4685,7 @@ var ObservedMediasoupRouter = class extends EventEmitter5 {
       rtcpTuple: transport.rtcpTuple,
       history
     };
-    this.sample.transports.push(transportSample);
+    this._addTransportSample(transportSample, transport);
     const onTuple = (tuple) => {
       transportSample.tuple = tuple;
       if (transportSample.connectedAt === void 0) transportSample.connectedAt = Date.now();
@@ -3418,7 +4717,7 @@ var ObservedMediasoupRouter = class extends EventEmitter5 {
       tuple: transport.tuple,
       history
     };
-    this.sample.transports.push(transportSample);
+    this._addTransportSample(transportSample, transport);
     const onSctpStateChange = (sctpState) => {
       if (sctpState === "connected" && transportSample.connectedAt === void 0) transportSample.connectedAt = Date.now();
       history.push({ type: `sctpstate-changed-to-${sctpState}`, timestamp: Date.now() });
@@ -3437,7 +4736,7 @@ var ObservedMediasoupRouter = class extends EventEmitter5 {
       connectedAt: now,
       history: []
     };
-    this.sample.transports.push(transportSample);
+    this._addTransportSample(transportSample, transport);
     this._attachTransportObserverListeners(transport, transportSample);
   }
   addProducer(transport, producer) {
@@ -3459,13 +4758,14 @@ var ObservedMediasoupRouter = class extends EventEmitter5 {
       rids: producer.rtpParameters.encodings?.map((e) => e.rid).filter((r) => typeof r === "string"),
       history: []
     };
-    this.sample.producers.push(producerSample);
+    this._addProducerSample(producerSample, producer, transport);
     const onPause = () => producerSample.history.push({ type: "pause", timestamp: Date.now() });
     const onResume = () => producerSample.history.push({ type: "resume", timestamp: Date.now() });
     producer.observer.once("close", () => {
       producer.observer.off("pause", onPause);
       producer.observer.off("resume", onResume);
       producerSample.closedAt = Date.now();
+      this.emit("producer-sample-closed", { sample: producerSample, producer, transport });
     });
     producer.observer.on("pause", onPause);
     producer.observer.on("resume", onResume);
@@ -3479,7 +4779,7 @@ var ObservedMediasoupRouter = class extends EventEmitter5 {
       kind: consumer.kind,
       history: []
     };
-    this.sample.consumers.push(consumerSample);
+    this._addConsumerSample(consumerSample, consumer, transport);
     const onPause = () => consumerSample.history.push({ type: "pause", timestamp: Date.now() });
     const onResume = () => consumerSample.history.push({ type: "resume", timestamp: Date.now() });
     const onProducerPause = () => consumerSample.history.push({ type: "producerPaused", timestamp: Date.now() });
@@ -3490,6 +4790,7 @@ var ObservedMediasoupRouter = class extends EventEmitter5 {
       consumer.off("producerresume", onProducerResume);
       consumer.off("producerpause", onProducerPause);
       consumerSample.closedAt = Date.now();
+      this.emit("consumer-sample-closed", { sample: consumerSample, consumer, transport });
     });
     consumer.observer.on("pause", onPause);
     consumer.observer.on("resume", onResume);
@@ -3504,8 +4805,11 @@ var ObservedMediasoupRouter = class extends EventEmitter5 {
       label: dataProducer.label,
       protocol: dataProducer.protocol
     };
-    this.sample.dataProducers.push(dataProducerSample);
-    dataProducer.observer.once("close", () => dataProducerSample.closedAt = Date.now());
+    this._addDataProducerSample(dataProducerSample, dataProducer, transport);
+    dataProducer.observer.once("close", () => {
+      dataProducerSample.closedAt = Date.now();
+      this.emit("data-producer-sample-closed", { sample: dataProducerSample, dataProducer, transport });
+    });
   }
   addDataConsumer(transport, dataConsumer) {
     const dataConsumerSample = {
@@ -3516,8 +4820,11 @@ var ObservedMediasoupRouter = class extends EventEmitter5 {
       label: dataConsumer.label,
       protocol: dataConsumer.protocol
     };
-    this.sample.dataConsumers.push(dataConsumerSample);
-    dataConsumer.observer.once("close", () => dataConsumerSample.closedAt = Date.now());
+    this._addDataConsumerSample(dataConsumerSample, dataConsumer, transport);
+    dataConsumer.observer.once("close", () => {
+      dataConsumerSample.closedAt = Date.now();
+      this.emit("data-consumer-sample-closed", { sample: dataConsumerSample, dataConsumer, transport });
+    });
   }
   attachRouterListeners() {
     this.router.observer.once("close", () => {
@@ -3527,6 +4834,56 @@ var ObservedMediasoupRouter = class extends EventEmitter5 {
     });
     this.router.observer.on("newtransport", this.addTransport);
   }
+  /* ---------------------------------------------------------------------------------------------
+   * Registration: push into the sample array, index by id, run the enricher, announce.
+   * The order matters — enrichment lands *before* the event, so a listener always sees the
+   * declaratively-attached data and can build on it rather than race it.
+   * ------------------------------------------------------------------------------------------- */
+  _addTransportSample(sample, transport) {
+    this.sample.transports.push(sample);
+    this._transportSamples.set(sample.id, sample);
+    this._applyEnrichment(sample, this._enrich?.transport && (() => this._enrich?.transport?.(transport)));
+    this.emit("transport-sample-added", { sample, transport });
+  }
+  _addProducerSample(sample, producer, transport) {
+    this.sample.producers.push(sample);
+    this._producerSamples.set(sample.id, sample);
+    this._applyEnrichment(sample, this._enrich?.producer && (() => this._enrich?.producer?.(producer, transport)));
+    this.emit("producer-sample-added", { sample, producer, transport });
+  }
+  _addConsumerSample(sample, consumer, transport) {
+    this.sample.consumers.push(sample);
+    this._consumerSamples.set(sample.id, sample);
+    this._applyEnrichment(sample, this._enrich?.consumer && (() => this._enrich?.consumer?.(consumer, transport)));
+    this.emit("consumer-sample-added", { sample, consumer, transport });
+  }
+  _addDataProducerSample(sample, dataProducer, transport) {
+    this.sample.dataProducers.push(sample);
+    this._dataProducerSamples.set(sample.id, sample);
+    this._applyEnrichment(sample, this._enrich?.dataProducer && (() => this._enrich?.dataProducer?.(dataProducer, transport)));
+    this.emit("data-producer-sample-added", { sample, dataProducer, transport });
+  }
+  _addDataConsumerSample(sample, dataConsumer, transport) {
+    this.sample.dataConsumers.push(sample);
+    this._dataConsumerSamples.set(sample.id, sample);
+    this._applyEnrichment(sample, this._enrich?.dataConsumer && (() => this._enrich?.dataConsumer?.(dataConsumer, transport)));
+    this.emit("data-consumer-sample-added", { sample, dataConsumer, transport });
+  }
+  /**
+   * Run an enricher and merge what it returns.
+   *
+   * Takes a thunk rather than a value so the **invocation** is inside the guard — application code
+   * runs here, and a throwing enricher must not take the router's bookkeeping down with it.
+   */
+  _applyEnrichment(sample, enrich) {
+    if (!enrich) return;
+    try {
+      const attachments = enrich();
+      if (attachments) sample.attachments = { ...sample.attachments, ...attachments };
+    } catch (err) {
+      logger6.warn("Mediasoup sample enricher threw for router %s: %o", this.id, err);
+    }
+  }
   _attachTransportObserverListeners(transport, transportSample, onClose) {
     const onNewProducer = (producer) => this.addProducer(transport, producer);
     const onNewConsumer = (consumer) => this.addConsumer(transport, consumer);
@@ -3539,6 +4896,7 @@ var ObservedMediasoupRouter = class extends EventEmitter5 {
       transport.observer.off("newdataconsumer", onNewDataConsumer);
       onClose?.();
       transportSample.closedAt = Date.now();
+      this.emit("transport-sample-closed", { sample: transportSample, transport });
     });
     transport.observer.on("newproducer", onNewProducer);
     transport.observer.on("newconsumer", onNewConsumer);
@@ -3547,36 +4905,1282 @@ var ObservedMediasoupRouter = class extends EventEmitter5 {
   }
 };
 
-// src/Observer.ts
-var logger7 = createLogger("Observer");
-var Observer = class extends EventEmitter6 {
-  constructor(config = {
-    updatePolicy: "update-when-all-call-updated",
-    appData: {}
-  }) {
-    super();
-    this.config = config;
-    this.setMaxListeners(Infinity);
-    this.update = this.update.bind(this);
-    const currentUpdatePolicy = config?.updatePolicy ?? "update-when-all-call-updated";
-    switch (currentUpdatePolicy) {
-      case "update-on-any-call-updated":
-        this.updater = new OnAnyCallObserverUpdater(this);
-        break;
-      case "update-when-all-call-updated":
-        this.updater = new OnAllCallObserverUpdater(this);
-        break;
-      case "none":
-        break;
-    }
+// src/issues/ActiveIssuesRegistry.ts
+var logger7 = createLogger("ActiveIssuesRegistry");
+var ActiveIssuesRegistry = class {
+  constructor(parent) {
+    this.parent = parent;
+  }
+  parent;
+  issues = /* @__PURE__ */ new Set();
+  typesToTrackers = /* @__PURE__ */ new Map();
+  get size() {
+    return this.issues.size;
+  }
+  /**
+   * The open issues in this scope, in insertion order.
+   *
+   * Insertion order is age order (`observedAt` is assigned on insert), which is what lets a consumer
+   * stop at the first entry newer than its cutoff instead of scanning the whole set.
+   */
+  values() {
+    return this.issues.values();
+  }
+  [Symbol.iterator]() {
+    return this.issues.values();
+  }
+  has(issue) {
+    return this.issues.has(issue);
+  }
+  add(issue) {
+    if (this.issues.has(issue)) return this;
+    this.issues.add(issue);
+    this.parent?.add(issue);
+    this._trackIssue(issue);
+    return this;
   }
-  config;
-  observedTURN = new ObservedTURN();
+  delete(issue) {
+    if (!this.issues.delete(issue)) return false;
+    this.parent?.delete(issue);
+    this._untrackIssue(issue);
+    return true;
+  }
+  /** Feed `tracker` every issue of `type` as it opens and closes. One call per type; no wildcard. */
+  addIssueTracker(type, tracker) {
+    this.typesToTrackers.set(
+      type,
+      (this.typesToTrackers.get(type) ?? []).concat(tracker)
+    );
+    return this;
+  }
+  removeIssueTracker(tracker) {
+    for (const [type, trackers] of [...this.typesToTrackers]) {
+      const remaining = trackers.filter((candidate) => candidate !== tracker);
+      if (remaining.length === 0) this.typesToTrackers.delete(type);
+      else this.typesToTrackers.set(type, remaining);
+    }
+    return this;
+  }
+  /**
+   * Drop every issue in this scope, e.g. because the call closed.
+   *
+   * Deletes through {@link delete} so the parent sheds exactly this scope's issues. Tracker
+   * *registrations* survive: a detector subscribed to the observer's registry must keep receiving
+   * issues after any one call ends.
+   */
+  clear() {
+    for (const issue of [...this.issues]) this.delete(issue);
+  }
+  _trackIssue(issue) {
+    this._trackersOf(issue.type, (tracker) => tracker.add(issue));
+  }
+  _untrackIssue(issue) {
+    this._trackersOf(issue.type, (tracker) => tracker.delete(issue));
+  }
+  /**
+   * Apply `apply` to every tracker interested in `type`.
+   *
+   * A tracker throwing must not abort the fan-out: the issue has already been added to (or removed
+   * from) this registry, so a partial dispatch would leave the remaining trackers permanently out of
+   * step with it. One broken detector should not desynchronise the others.
+   */
+  _trackersOf(type, apply) {
+    const trackers = this.typesToTrackers.get(type);
+    if (trackers) for (const tracker of trackers) this._safely(tracker, apply);
+  }
+  _safely(target, apply) {
+    try {
+      apply(target);
+    } catch (err) {
+      logger7.warn("An issue tracker threw while being notified; continuing with the rest. %o", err);
+    }
+  }
+};
+
+// src/detectors/SfuCongestionDetector.ts
+var SfuCongestionDetector = class _SfuCongestionDetector {
+  constructor(_observer, config = {}) {
+    this._observer = _observer;
+    this._config = {
+      consumedClientIssueTypes: [
+        "congestion"
+      ],
+      emittedObserverIssueType: "sfu-congestion",
+      samplesSendingTimeInMs: 1e4,
+      historySize: 30,
+      minHistorySize: 5,
+      minAffectedClients: 3,
+      minAbsoluteRatioIncrease: 0.05,
+      minRelativeRatioIncrease: 2,
+      robustZThreshold: 3,
+      ...config
+    };
+    for (const issueType of this._config.consumedClientIssueTypes) {
+      this._observer.activeIssuesRegistry.addIssueTracker(issueType, this);
+    }
+    this.timer = setInterval(() => {
+      this._closeBucket(Date.now());
+      this._evaluateLatestBucket();
+    }, this._config.samplesSendingTimeInMs);
+    this.timer.unref?.();
+  }
+  _observer;
+  static NAME = "sfu-congestion-detector";
+  name = _SfuCongestionDetector.NAME;
+  _config;
+  _history = [];
+  _trackedIssues = /* @__PURE__ */ new Set();
+  timer;
+  _lastEvaluatedBucket;
+  get size() {
+    return this._trackedIssues.size;
+  }
+  /** Record the issue against the bucket currently open. The timer, not this, closes the bucket. */
+  add(issue) {
+    this._trackedIssues.add(issue);
+  }
+  /**
+   * Deliberately a no-op returning `false`.
+   *
+   * Resolutions are not interesting here. A congested client typically fixes its own symptom by
+   * dropping bitrate hard, so the issue closes within seconds — but it still *happened*, and it is
+   * evidence that the server was under pressure during this bucket. What matters is how many
+   * distinct clients reported congestion within the bucket and whether that count suddenly jumps,
+   * not how long any one client's issue stayed open.
+   *
+   * Nothing leaks: the tracked set is emptied wholesale every time a bucket closes.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  delete(_issue) {
+    return false;
+  }
+  clear() {
+    this._trackedIssues.clear();
+    this._history.length = 0;
+    this._lastEvaluatedBucket = void 0;
+  }
+  has(issue) {
+    return this._trackedIssues.has(issue);
+  }
+  close() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = void 0;
+    }
+    this._observer.activeIssuesRegistry.removeIssueTracker(this);
+    this.clear();
+  }
+  /** The completed buckets kept so far, oldest first. Read-only — for introspection/tests. */
+  get history() {
+    return this._history;
+  }
+  /**
+   * Intentionally empty — see the class description.
+   *
+   * Everything here is driven by the bucket timer, because the update tick is neither evenly spaced
+   * nor long enough for every client to have reported. Counting on it would compare windows of
+   * different lengths and call the difference a signal.
+   */
+  update() {
+  }
+  _closeBucket(observedAt) {
+    const totalClients = this._observer.numberOfClients;
+    const affectedClientIds = [...new Set(Array.from(this._trackedIssues, (issue) => issue.clientId))];
+    const affectedCallIds = [...new Set(Array.from(this._trackedIssues, (issue) => issue.callId))];
+    const congestedClients = affectedClientIds.length;
+    const congestedClientRatio = 0 < totalClients ? congestedClients / totalClients : 0;
+    this._history.push({
+      observedAt,
+      totalClients,
+      congestedClients,
+      congestedClientRatio,
+      affectedClientIds,
+      affectedCallIds
+    });
+    while (this._config.historySize < this._history.length) this._history.shift();
+    this._trackedIssues.clear();
+  }
+  /**
+   * Evaluate only the latest completed bucket (the candidate) against the buckets before it (the
+   * baseline) — never against itself. Reached once per newly-closed bucket via {@link update}; the
+   * identity check below additionally guards against evaluating the same bucket twice, in case
+   * `update()` is ever called again before the next rotation.
+   */
+  _evaluateLatestBucket() {
+    const candidate = this._history[this._history.length - 1];
+    if (candidate === this._lastEvaluatedBucket) return;
+    this._lastEvaluatedBucket = candidate;
+    const baseline = this._history.slice(0, -1);
+    const evaluation = this._evaluateBucket(candidate, baseline);
+    if (!evaluation.isCongested) return;
+    const payload = {
+      affectedCallIds: candidate.affectedCallIds,
+      affectedClientIds: candidate.affectedClientIds,
+      congestedClientRatio: candidate.congestedClientRatio,
+      totalNumberOfClients: candidate.totalClients,
+      numberOfCongestedClients: candidate.congestedClients,
+      historySize: this._history.length,
+      baselineCongestedClientRatio: evaluation.baselineCongestedClientRatio,
+      robustZ: evaluation.robustZ,
+      absoluteIncrease: evaluation.absoluteIncrease,
+      relativeIncrease: evaluation.relativeIncrease
+    };
+    this._observer.emit("observer-issue", {
+      issue: {
+        type: this._config.emittedObserverIssueType,
+        timestamp: Date.now(),
+        payload
+      },
+      observer: this._observer
+    });
+  }
+  /**
+   * Is `candidate` — the latest completed bucket — abnormally high compared with the `baseline`
+   * buckets before it?
+   *
+   * Requires both **statistical** significance (a robust z-score against a median+MAD baseline —
+   * deliberately not Mann-Kendall, which asks "is this a monotonic trend", not "is the latest point
+   * an outlier"; a single sudden spike on an otherwise flat series is exactly what should trigger
+   * here and exactly what a trend test would miss) and **practical** significance (enough affected
+   * clients, and a big enough absolute/relative jump — a statistically significant move in a tiny
+   * or trivial ratio is not worth an alert).
+   */
+  _evaluateBucket(candidate, baseline) {
+    const baselineRatios = baseline.map((bucket) => bucket.congestedClientRatio);
+    const baselineMedian = median(baselineRatios) ?? 0;
+    const robustZ = robustZScore(candidate.congestedClientRatio, baselineRatios) ?? 0;
+    const absoluteIncrease = candidate.congestedClientRatio - baselineMedian;
+    const relativeIncrease = 0 < baselineMedian ? candidate.congestedClientRatio / baselineMedian : 0 < candidate.congestedClientRatio ? Infinity : 0;
+    const isCongested = this._config.minHistorySize <= baseline.length + 1 && this._config.minAffectedClients <= candidate.congestedClients && this._config.minAbsoluteRatioIncrease <= absoluteIncrease && this._config.minRelativeRatioIncrease <= relativeIncrease && this._config.robustZThreshold <= robustZ;
+    return { isCongested, baselineCongestedClientRatio: baselineMedian, robustZ, absoluteIncrease, relativeIncrease };
+  }
+};
+
+// src/detectors/ObserverConcurrentIssueDetector.ts
+var ObserverConcurrentIssueTypes = {
+  /**
+   * The same issue is open in **several unrelated calls at once**. Those clients share no meeting,
+   * no publisher and no room — only the infrastructure serving them.
+   */
+  crossCallConcurrentIssues: "CROSS_CALL_CONCURRENT_ISSUES",
+  /** The cross-call version that also started together. The strongest "it's us" signal available. */
+  crossCallIssueOnsetBurst: "CROSS_CALL_ISSUE_ONSET_BURST"
+};
+var ObserverConcurrentIssueDetector = class _ObserverConcurrentIssueDetector {
+  constructor(_observer, config = {}) {
+    this._observer = _observer;
+    this._config = {
+      issueTypes: [],
+      minAffectedClients: 3,
+      minAffectedCalls: 2,
+      affectedCallRatioThreshold: 0,
+      onsetBurstWindowInMs: 2e3,
+      cooldownMs: 6e4,
+      ...config
+    };
+    for (const type of this._config.issueTypes) {
+      this._observer.activeIssuesRegistry.addIssueTracker(type, this);
+    }
+  }
+  _observer;
+  static NAME = "observer-concurrent-issue-detector";
+  name = _ObserverConcurrentIssueDetector.NAME;
+  _config;
+  _lastRaisedAt = /* @__PURE__ */ new Map();
+  /** issue type -> the issues of that type currently open anywhere in the fleet. */
+  _byType = /* @__PURE__ */ new Map();
+  _size = 0;
+  /** The groups that qualified on the most recent `update()`. Exposed for tests/dashboards. */
+  lastGroups = [];
+  get size() {
+    return this._size;
+  }
+  has(issue) {
+    return this._byType.get(issue.type)?.has(issue) ?? false;
+  }
+  add(issue) {
+    let bucket = this._byType.get(issue.type);
+    if (!bucket) {
+      bucket = /* @__PURE__ */ new Set();
+      this._byType.set(issue.type, bucket);
+    }
+    if (bucket.has(issue)) return;
+    bucket.add(issue);
+    ++this._size;
+  }
+  delete(issue) {
+    const bucket = this._byType.get(issue.type);
+    if (!bucket?.delete(issue)) return false;
+    --this._size;
+    if (bucket.size === 0) this._byType.delete(issue.type);
+    return true;
+  }
+  clear() {
+    this._byType.clear();
+    this._size = 0;
+    this.lastGroups = [];
+  }
+  update() {
+    this.lastGroups = [];
+    if (this._size === 0) return;
+    const now = Date.now();
+    for (const [type, issues] of this._byType) {
+      const group = this._groupOf(type, issues);
+      if (group.clientIds.length < this._config.minAffectedClients) continue;
+      if (group.callIds.length < this._config.minAffectedCalls) continue;
+      if (group.affectedCallRatio < this._config.affectedCallRatioThreshold) continue;
+      this.lastGroups.push(group);
+      if (now - (this._lastRaisedAt.get(type) ?? 0) < this._config.cooldownMs) continue;
+      this._lastRaisedAt.set(type, now);
+      const burst = group.onsetSpreadInMs <= this._config.onsetBurstWindowInMs;
+      const issueType = burst ? ObserverConcurrentIssueTypes.crossCallIssueOnsetBurst : ObserverConcurrentIssueTypes.crossCallConcurrentIssues;
+      const conclusion = concludeObserverIssue({
+        issueType: type,
+        affectedClients: group.clientIds.length,
+        totalClients: group.totalClients,
+        affectedCalls: group.callIds.length,
+        totalCalls: group.totalCalls,
+        onsetBurst: burst
+      });
+      this._observer.addIssue({
+        type: issueType,
+        timestamp: now,
+        payload: {
+          type: issueType,
+          issueType: type,
+          scope: "observer",
+          conclusion,
+          clients: group.totalClients,
+          affectedClients: group.clientIds.length,
+          affectedRatio: group.affectedRatio,
+          affectedClientIds: group.clientIds,
+          // The dimension that makes this finding what it is.
+          calls: group.totalCalls,
+          affectedCalls: group.callIds.length,
+          affectedCallRatio: group.affectedCallRatio,
+          affectedCallIds: group.callIds,
+          perCall: group.perCall,
+          onsetSpreadInMs: group.onsetSpreadInMs,
+          onsetBurst: burst,
+          firstObservedAt: group.firstObservedAt
+        }
+      });
+    }
+  }
+  close() {
+    this._observer.activeIssuesRegistry.removeIssueTracker(this);
+    this._lastRaisedAt.clear();
+    this.clear();
+  }
+  _groupOf(type, issues) {
+    const clientIds = /* @__PURE__ */ new Set();
+    const affectedByCall = /* @__PURE__ */ new Map();
+    const list = [];
+    let earliest = Infinity;
+    let latest = -Infinity;
+    for (const issue of issues) {
+      list.push(issue);
+      clientIds.add(issue.clientId);
+      let clients = affectedByCall.get(issue.callId);
+      if (!clients) {
+        clients = /* @__PURE__ */ new Set();
+        affectedByCall.set(issue.callId, clients);
+      }
+      clients.add(issue.clientId);
+      if (issue.observedAt < earliest) earliest = issue.observedAt;
+      if (latest < issue.observedAt) latest = issue.observedAt;
+    }
+    const totalClients = this._observer.numberOfClients;
+    const totalCalls = this._observer.observedCalls.size;
+    const perCall = [];
+    for (const [callId, clients] of affectedByCall) {
+      perCall.push({
+        callId,
+        affectedClients: clients.size,
+        // A call that closed while its issues were still open has no participant count left;
+        // fall back to the affected count rather than reporting a 0 denominator.
+        totalClients: this._observer.observedCalls.get(callId)?.observedClients.size ?? clients.size
+      });
+    }
+    perCall.sort((a, b) => b.affectedClients - a.affectedClients);
+    return {
+      type,
+      issues: list,
+      clientIds: [...clientIds],
+      totalClients,
+      affectedRatio: 0 < totalClients ? clientIds.size / totalClients : 0,
+      callIds: perCall.map((entry) => entry.callId),
+      totalCalls,
+      affectedCallRatio: 0 < totalCalls ? perCall.length / totalCalls : 0,
+      perCall,
+      onsetSpreadInMs: latest - earliest,
+      firstObservedAt: earliest
+    };
+  }
+};
+
+// src/detectors/ClientPopulationIssueDetector.ts
+var ClientPopulationIssueTypes = {
+  /** One issue type is concentrated on one client population while the rest of the fleet is fine. */
+  clientPopulationIssue: "CLIENT_POPULATION_ISSUE"
+};
+var ClientPopulationIssueDetector = class _ClientPopulationIssueDetector {
+  constructor(_observer, config = {}) {
+    this._observer = _observer;
+    this._config = {
+      issueTypes: [],
+      groupBy: "browser",
+      includeVersion: true,
+      minPopulationSize: 20,
+      minAffectedClients: 5,
+      affectedRatioThreshold: 0.3,
+      minRelativeRisk: 3,
+      minControlSize: 20,
+      cooldownMs: 3e5,
+      ...config
+    };
+    for (const type of this._config.issueTypes) {
+      this._observer.activeIssuesRegistry.addIssueTracker(type, this);
+    }
+  }
+  _observer;
+  static NAME = "client-population-issue-detector";
+  name = _ClientPopulationIssueDetector.NAME;
+  _config;
+  _lastRaisedAt = /* @__PURE__ */ new Map();
+  _issues = /* @__PURE__ */ new Set();
+  /** The populations that qualified on the most recent `update()`. Exposed for tests/dashboards. */
+  lastPopulations = [];
+  get size() {
+    return this._issues.size;
+  }
+  has(issue) {
+    return this._issues.has(issue);
+  }
+  add(issue) {
+    this._issues.add(issue);
+  }
+  delete(issue) {
+    return this._issues.delete(issue);
+  }
+  clear() {
+    this._issues.clear();
+    this.lastPopulations = [];
+  }
+  update() {
+    this.lastPopulations = [];
+    if (this._issues.size === 0) return;
+    const now = Date.now();
+    const populationSizes = /* @__PURE__ */ new Map();
+    for (const call of this._observer.observedCalls.values()) {
+      for (const client of call.observedClients.values()) {
+        const population = this._populationOf(client);
+        if (population === void 0) continue;
+        populationSizes.set(population, (populationSizes.get(population) ?? 0) + 1);
+      }
+    }
+    if (populationSizes.size === 0) return;
+    const affected = /* @__PURE__ */ new Map();
+    for (const issue of this._issues) {
+      const client = this._observer.observedCalls.get(issue.callId)?.observedClients.get(issue.clientId);
+      if (!client) continue;
+      const population = this._populationOf(client);
+      if (population === void 0) continue;
+      let byPopulation = affected.get(issue.type);
+      if (!byPopulation) {
+        byPopulation = /* @__PURE__ */ new Map();
+        affected.set(issue.type, byPopulation);
+      }
+      const clientIds = byPopulation.get(population) ?? /* @__PURE__ */ new Set();
+      clientIds.add(issue.clientId);
+      byPopulation.set(population, clientIds);
+    }
+    for (const [issueType, byPopulation] of affected) {
+      let totalAffected = 0;
+      for (const clientIds of byPopulation.values()) totalAffected += clientIds.size;
+      let totalClients = 0;
+      for (const size of populationSizes.values()) totalClients += size;
+      for (const [population, clientIds] of byPopulation) {
+        const clients = populationSizes.get(population) ?? clientIds.size;
+        const rollup = this._rollupOf(
+          population,
+          issueType,
+          clientIds,
+          clients,
+          totalClients - clients,
+          totalAffected - clientIds.size
+        );
+        if (rollup.clients < this._config.minPopulationSize) continue;
+        if (rollup.affectedClients < this._config.minAffectedClients) continue;
+        if (rollup.affectedRatio < this._config.affectedRatioThreshold) continue;
+        if (rollup.controlClients < this._config.minControlSize) continue;
+        if (rollup.relativeRisk < this._config.minRelativeRisk) continue;
+        this.lastPopulations.push(rollup);
+        const key = `${population}:${issueType}`;
+        if (now - (this._lastRaisedAt.get(key) ?? 0) < this._config.cooldownMs) continue;
+        this._lastRaisedAt.set(key, now);
+        this._observer.addIssue({
+          type: ClientPopulationIssueTypes.clientPopulationIssue,
+          timestamp: now,
+          payload: {
+            type: ClientPopulationIssueTypes.clientPopulationIssue,
+            ...rollup,
+            conclusion: {
+              faultDomain: "client-population",
+              summary: `'${issueType}' is ${this._riskText(rollup.relativeRisk)} more likely on ${population} than on the rest of the fleet (${rollup.affectedClients}/${rollup.clients} vs ${rollup.controlAffectedClients}/${rollup.controlClients})`,
+              recommendation: "this is not an SFU symptom \u2014 look at what those clients share: a recent release, a browser version, or shared/virtualised hardware",
+              confidence: this._confidenceOf(rollup)
+            }
+          }
+        });
+      }
+    }
+  }
+  close() {
+    this._observer.activeIssuesRegistry.removeIssueTracker(this);
+    this._lastRaisedAt.clear();
+    this.clear();
+  }
+  /** `undefined` when the client never reported this attribute — see the class description. */
+  _populationOf(client) {
+    const attribute = client[this._config.groupBy];
+    if (!attribute?.name) return void 0;
+    return this._config.includeVersion && attribute.version ? `${attribute.name} ${attribute.version}` : attribute.name;
+  }
+  _rollupOf(population, issueType, clientIds, clients, controlClients, controlAffectedClients) {
+    const affectedRatio = 0 < clients ? clientIds.size / clients : 0;
+    const controlAffectedRatio = 0 < controlClients ? controlAffectedClients / controlClients : 0;
+    return {
+      population,
+      axis: this._config.groupBy,
+      issueType,
+      clients,
+      affectedClients: clientIds.size,
+      affectedRatio,
+      affectedClientIds: [...clientIds],
+      controlClients,
+      controlAffectedClients,
+      controlAffectedRatio,
+      // A spotless control group means nobody outside this population has the problem at all.
+      // `Infinity` says that plainly rather than dividing by zero or inventing a ceiling.
+      relativeRisk: 0 < controlAffectedRatio ? affectedRatio / controlAffectedRatio : 0 < affectedRatio ? Infinity : 0
+    };
+  }
+  _riskText(relativeRisk) {
+    return Number.isFinite(relativeRisk) ? `${relativeRisk.toFixed(1)}x` : "exclusively";
+  }
+  /** Bigger populations and starker contrasts are harder to produce by chance. */
+  _confidenceOf(rollup) {
+    let confidence = 0.4;
+    if (100 <= rollup.clients) confidence += 0.2;
+    else if (50 <= rollup.clients) confidence += 0.1;
+    if (10 <= rollup.relativeRisk) confidence += 0.3;
+    else if (5 <= rollup.relativeRisk) confidence += 0.2;
+    else confidence += 0.1;
+    return Math.min(1, Math.round(confidence * 100) / 100);
+  }
+};
+
+// src/detectors/TurnServerHealthDetector.ts
+var TurnServerHealthTypes = {
+  /** One TURN server's clients are in trouble while other servers' clients are fine. */
+  turnServerDegraded: "TURN_SERVER_DEGRADED"
+};
+var TurnServerHealthDetector = class _TurnServerHealthDetector {
+  constructor(_observer, config = {}) {
+    this._observer = _observer;
+    this._config = {
+      minClientsPerServer: 5,
+      degradedRatioThreshold: 0.5,
+      // any open issue: the question is where trouble clusters, not what it is
+      issueTypes: [],
+      consecutiveTicks: 2,
+      cooldownMs: 6e4,
+      ...config
+    };
+  }
+  _observer;
+  static NAME = "turn-server-health-detector";
+  name = _TurnServerHealthDetector.NAME;
+  _config;
+  _streaks = /* @__PURE__ */ new Map();
+  _lastRaisedAt = /* @__PURE__ */ new Map();
+  /** The per-server rollup computed on the most recent `update()`. */
+  lastServers = [];
+  update() {
+    const now = Date.now();
+    const wanted = new Set(this._config.issueTypes);
+    const issuesByClientId = /* @__PURE__ */ new Map();
+    for (const issue of this._observer.activeIssuesRegistry.values()) {
+      if (0 < wanted.size && !wanted.has(issue.type)) continue;
+      const types = issuesByClientId.get(issue.clientId);
+      if (types) types.push(issue.type);
+      else issuesByClientId.set(issue.clientId, [issue.type]);
+    }
+    this.lastServers = [...this._observer.observedTURN.servers].map(([serverUrl, server]) => this._serverHealth(serverUrl, server.observedPeerConnections, issuesByClientId));
+    for (const health of this.lastServers) {
+      const serverUrl = health.serverUrl;
+      if (health.clients < this._config.minClientsPerServer || health.degradedRatio < this._config.degradedRatioThreshold) {
+        this._streaks.delete(serverUrl);
+        continue;
+      }
+      const ticks = (this._streaks.get(serverUrl) ?? 0) + 1;
+      this._streaks.set(serverUrl, ticks);
+      if (ticks < this._config.consecutiveTicks) continue;
+      if (now - (this._lastRaisedAt.get(serverUrl) ?? 0) < this._config.cooldownMs) continue;
+      this._lastRaisedAt.set(serverUrl, now);
+      const otherServers = this.lastServers.filter((server) => server.serverUrl !== serverUrl).map((server) => ({ serverUrl: server.serverUrl, clients: server.clients, degradedRatio: server.degradedRatio }));
+      this._observer.addIssue({
+        type: TurnServerHealthTypes.turnServerDegraded,
+        timestamp: now,
+        payload: { type: TurnServerHealthTypes.turnServerDegraded, ...health, otherServers }
+      });
+    }
+    for (const serverUrl of [...this._streaks.keys()]) {
+      if (!this.lastServers.some((server) => server.serverUrl === serverUrl)) this._streaks.delete(serverUrl);
+    }
+  }
+  close() {
+    this._streaks.clear();
+    this._lastRaisedAt.clear();
+    this.lastServers = [];
+  }
+  _serverHealth(serverUrl, peerConnections, issuesByClientId) {
+    const clientIds = /* @__PURE__ */ new Set();
+    const affectedClientIds = /* @__PURE__ */ new Set();
+    const typeCounts = /* @__PURE__ */ new Map();
+    for (const peerConnection of peerConnections.values()) {
+      const clientId = peerConnection.client.clientId;
+      clientIds.add(clientId);
+      const types = issuesByClientId.get(clientId);
+      if (!types) continue;
+      affectedClientIds.add(clientId);
+      for (const type of types) typeCounts.set(type, (typeCounts.get(type) ?? 0) + 1);
+    }
+    return {
+      serverUrl,
+      clients: clientIds.size,
+      degradedClients: affectedClientIds.size,
+      degradedRatio: 0 < clientIds.size ? affectedClientIds.size / clientIds.size : 0,
+      affectedClientIds: [...affectedClientIds],
+      issueTypes: [...typeCounts.entries()].sort((a, b) => b[1] - a[1]).map(([type]) => type)
+    };
+  }
+};
+
+// src/detectors/TurnServerOutageDetector.ts
+var TurnServerOutageTypes = {
+  /** One TURN server's relayed population collapsed while the rest of the fleet is fine. */
+  turnServerOutage: "TURN_SERVER_OUTAGE"
+};
+var brokenStates = /* @__PURE__ */ new Set(["disconnected", "failed", "closed"]);
+var TurnServerOutageDetector = class _TurnServerOutageDetector {
+  constructor(_observer, config = {}) {
+    this._observer = _observer;
+    this._config = {
+      minClientsAtPeak: 5,
+      // an outage is near-total by definition; partial degradation is the health detector's question
+      lossRatioThreshold: 0.8,
+      peakWindowMs: 12e4,
+      // absence without a control group is just quiet
+      requireControlGroup: true,
+      minControlGroupClients: 5,
+      controlGroupHealthyRatio: 0.7,
+      consecutiveTicks: 2,
+      // one event, not one per tick
+      cooldownMs: 3e5,
+      ...config
+    };
+  }
+  _observer;
+  static NAME = "turn-server-outage-detector";
+  name = _TurnServerOutageDetector.NAME;
+  _config;
+  /** serverUrl -> recent population observations, used to derive the windowed peak. */
+  _peaks = /* @__PURE__ */ new Map();
+  _streaks = /* @__PURE__ */ new Map();
+  _lastRaisedAt = /* @__PURE__ */ new Map();
+  update() {
+    const now = Date.now();
+    const servers = [...this._observer.observedTURN.servers];
+    const populations = /* @__PURE__ */ new Map();
+    for (const [serverUrl, server] of servers) {
+      populations.set(serverUrl, this._populationOf(server.observedPeerConnections));
+    }
+    for (const [serverUrl, population] of populations) {
+      const live = population.healthy.size;
+      const broken = population.broken.size;
+      const peak = this._recordAndPeak(serverUrl, live + broken, now);
+      if (peak < this._config.minClientsAtPeak) {
+        this._streaks.delete(serverUrl);
+        continue;
+      }
+      const lost = Math.max(0, peak - live);
+      const lossRatio = lost / peak;
+      if (lossRatio < this._config.lossRatioThreshold) {
+        this._streaks.delete(serverUrl);
+        continue;
+      }
+      const control = this._controlGroup(serverUrl, populations);
+      if (this._config.requireControlGroup) {
+        if (control.total < this._config.minControlGroupClients) {
+          this._streaks.delete(serverUrl);
+          continue;
+        }
+        if (control.healthyRatio < this._config.controlGroupHealthyRatio) {
+          this._streaks.delete(serverUrl);
+          continue;
+        }
+      }
+      const ticks = (this._streaks.get(serverUrl) ?? 0) + 1;
+      this._streaks.set(serverUrl, ticks);
+      if (ticks < this._config.consecutiveTicks) continue;
+      if (now - (this._lastRaisedAt.get(serverUrl) ?? 0) < this._config.cooldownMs) continue;
+      this._lastRaisedAt.set(serverUrl, now);
+      this._observer.addIssue({
+        type: TurnServerOutageTypes.turnServerOutage,
+        timestamp: now,
+        payload: {
+          type: TurnServerOutageTypes.turnServerOutage,
+          serverUrl,
+          peakClients: peak,
+          currentClients: live,
+          disruptedClients: broken,
+          lostClients: lost,
+          lossRatio,
+          disruptedClientIds: [...population.broken],
+          controlGroupClients: control.total,
+          controlGroupHealthyClients: control.healthy,
+          controlGroupHealthyRatio: control.healthyRatio,
+          peakWindowMs: this._config.peakWindowMs
+        }
+      });
+    }
+    for (const key of [...this._peaks.keys()]) {
+      if (populations.has(key)) continue;
+      this._peaks.delete(key);
+      this._streaks.delete(key);
+    }
+  }
+  close() {
+    this._peaks.clear();
+    this._streaks.clear();
+    this._lastRaisedAt.clear();
+  }
+  /** Distinct clients on a server, split by whether their relayed transport is actually up. */
+  _populationOf(peerConnections) {
+    const healthy = /* @__PURE__ */ new Set();
+    const broken = /* @__PURE__ */ new Set();
+    for (const peerConnection of peerConnections.values()) {
+      const clientId = peerConnection.client.clientId;
+      const isBroken = peerConnection.closed || brokenStates.has(peerConnection.iceConnectionState ?? "") || brokenStates.has(peerConnection.connectionState ?? "");
+      if (isBroken) broken.add(clientId);
+      else healthy.add(clientId);
+    }
+    for (const clientId of healthy) broken.delete(clientId);
+    return { healthy, broken };
+  }
+  /** Record this tick's population and return the peak across `peakWindowMs`. */
+  _recordAndPeak(serverUrl, clients, now) {
+    const entries = this._peaks.get(serverUrl) ?? [];
+    const cutoff = now - this._config.peakWindowMs;
+    const kept = entries.filter((e) => cutoff <= e.at);
+    kept.push({ clients, at: now });
+    this._peaks.set(serverUrl, kept);
+    return kept.reduce((max, e) => Math.max(max, e.clients), 0);
+  }
+  /**
+   * Everyone *not* relayed through `serverUrl`: clients on other TURN servers plus every client
+   * the observer knows about that isn't relayed at all. The healthy share of that group is what
+   * separates "this server broke" from "everything broke".
+   */
+  _controlGroup(serverUrl, populations) {
+    const healthy = /* @__PURE__ */ new Set();
+    const broken = /* @__PURE__ */ new Set();
+    for (const [otherUrl, population] of populations) {
+      if (otherUrl === serverUrl) continue;
+      for (const clientId of population.healthy) healthy.add(clientId);
+      for (const clientId of population.broken) broken.add(clientId);
+    }
+    const onThisServer = populations.get(serverUrl);
+    for (const call of this._observer.observedCalls.values()) {
+      for (const client of call.observedClients.values()) {
+        if (onThisServer?.healthy.has(client.clientId) || onThisServer?.broken.has(client.clientId)) continue;
+        if (broken.has(client.clientId)) continue;
+        healthy.add(client.clientId);
+      }
+    }
+    for (const clientId of healthy) broken.delete(clientId);
+    const total = healthy.size + broken.size;
+    return {
+      total,
+      healthy: healthy.size,
+      healthyRatio: 0 < total ? healthy.size / total : 0
+    };
+  }
+};
+
+// src/utils/SlidingWindow.ts
+var SlidingWindow = class {
+  constructor(windowMs, maxEntries = 1024) {
+    this.windowMs = windowMs;
+    this.maxEntries = maxEntries;
+  }
+  windowMs;
+  maxEntries;
+  _entries = [];
+  _latest = -Infinity;
+  /** Add an entry (defaults to `Date.now()`), then evict anything outside the window. */
+  add(value, timestamp = Date.now()) {
+    if (!Number.isFinite(timestamp)) return;
+    const entry = { timestamp, value };
+    const last = this._entries[this._entries.length - 1];
+    if (last === void 0 || last.timestamp <= timestamp) {
+      this._entries.push(entry);
+    } else {
+      let index = this._entries.length - 1;
+      while (0 < index && timestamp < this._entries[index - 1].timestamp) --index;
+      this._entries.splice(index, 0, entry);
+    }
+    if (this._latest < timestamp) this._latest = timestamp;
+    this._evict(timestamp);
+  }
+  /**
+   * The entries still inside the window, oldest first.
+   *
+   * A **copy** — callers routinely map/sort what they get back, and handing out the live array let
+   * them mutate the window from the outside.
+   */
+  entries(now = Date.now()) {
+    this._evict(now);
+    return [...this._entries];
+  }
+  /** The values still inside the window, oldest first. */
+  values(now = Date.now()) {
+    this._evict(now);
+    return this._entries.map((entry) => entry.value);
+  }
+  /**
+   * How many entries are inside the window as of `now`.
+   *
+   * Prefer this to `values(now).length`: counting through {@link values} allocates an array of every
+   * entry only to read its length, which on a hot path is the whole cost of the call.
+   */
+  count(now = Date.now()) {
+    this._evict(now);
+    return this._entries.length;
+  }
+  /** Retained entries, without evicting first. See {@link count} for the windowed answer. */
+  get size() {
+    return this._entries.length;
+  }
+  clear() {
+    this._entries = [];
+    this._latest = -Infinity;
+  }
+  _evict(now) {
+    if (Number.isFinite(now) && this._latest < now) this._latest = now;
+    const oldest = this._latest - this.windowMs;
+    let expired = 0;
+    while (expired < this._entries.length && this._entries[expired].timestamp < oldest) ++expired;
+    if (0 < expired) this._entries.splice(0, expired);
+    const excess = this._entries.length - this.maxEntries;
+    if (0 < excess) this._entries.splice(0, excess);
+  }
+};
+
+// src/validators/SimulcastReceiverValidator.ts
+var LOWEST_COMMON_DENOMINATOR_ISSUE = "WORST_RECEIVER_CONTAGION";
+var SimulcastReceiverValidator = class _SimulcastReceiverValidator {
+  constructor(_observer, onDone, config = {}) {
+    this._observer = _observer;
+    this.onDone = onDone;
+    this._config = {
+      minChecks: 3,
+      minReceivers: 3,
+      windowMs: 1e4,
+      minSamples: 5,
+      outlierRatioThreshold: 0.5,
+      trackingRatioThreshold: 0.8,
+      ...config
+    };
+  }
+  _observer;
+  onDone;
+  static NAME = "simulcast-receivers";
+  name = _SimulcastReceiverValidator.NAME;
+  startedAt = Date.now();
+  report = { ready: false };
+  _config;
+  _windows = /* @__PURE__ */ new Map();
+  _checks = 0;
+  _done = false;
+  /** How many times the comparison actually ran. `0` means nothing was established. */
+  get checks() {
+    return this._checks;
+  }
+  /** Give up without a verdict, freeing anything waiting on this validator. */
+  cancel(reason = "cancelled") {
+    this._finish({ verdict: "inconclusive", reason });
+  }
+  update() {
+    if (this._done) return;
+    const now = Date.now();
+    const live = /* @__PURE__ */ new Set();
+    for (const call of this._observer.observedCalls.values()) {
+      if (!call.remoteTrackResolver) continue;
+      for (const client of call.observedClients.values()) {
+        for (const peerConnection of client.observedPeerConnections.values()) {
+          for (const publisher of peerConnection.observedOutboundTracks.values()) {
+            if (publisher.kind !== "video") continue;
+            live.add(publisher.id);
+            if (this._inspect(call.callId, client.clientId, publisher, now)) return;
+          }
+        }
+      }
+    }
+    for (const trackId of [...this._windows.keys()]) {
+      if (!live.has(trackId)) this._windows.delete(trackId);
+    }
+  }
+  /** Returns `true` when a verdict was reached and the caller should stop iterating. */
+  _inspect(callId, publisherClientId, publisher, now) {
+    const publisherBitrate = publisher.bitrate;
+    if (publisherBitrate === void 0 || publisherBitrate <= 0) return false;
+    if (publisher.remoteInboundTracks.size < this._config.minReceivers) return false;
+    const receivers = [];
+    for (const receiver of publisher.remoteInboundTracks) {
+      const bitrate = receiver.getInboundRtp()?.bitrate;
+      if (bitrate === void 0 || bitrate <= 0) continue;
+      receivers.push({ clientId: receiver.getPeerConnection().client.clientId, bitrate });
+    }
+    if (receivers.length < this._config.minReceivers) return false;
+    const bitrates = receivers.map((receiver) => receiver.bitrate);
+    const worstReceiver = receivers.reduce((a, b) => a.bitrate <= b.bitrate ? a : b);
+    const worst = worstReceiver.bitrate;
+    const median2 = percentile(bitrates, 0.5) ?? worst;
+    const window = this._windowOf(publisher.id);
+    window.add({ publisher: publisherBitrate, worst, median: median2 }, now);
+    const samples = window.values(now);
+    if (samples.length < this._config.minSamples) return false;
+    const latest = samples[samples.length - 1];
+    const outlierRatio = 0 < latest.median ? latest.worst / latest.median : 1;
+    if (this._config.outlierRatioThreshold < outlierRatio) return false;
+    ++this._checks;
+    window.clear();
+    const trackingWithWorst = correlation(samples.map((s) => s.publisher), samples.map((s) => s.worst));
+    const trackingWithMedian = correlation(samples.map((s) => s.publisher), samples.map((s) => s.median));
+    const dragged = this._config.trackingRatioThreshold <= trackingWithWorst && trackingWithMedian < trackingWithWorst;
+    const evidence = {
+      callId,
+      trackId: publisher.id,
+      publisherClientId,
+      worstReceiverClientId: worstReceiver.clientId,
+      publisherBitrate,
+      worstReceiverBitrate: latest.worst,
+      medianReceiverBitrate: latest.median,
+      trackingWithWorst,
+      trackingWithMedian
+    };
+    if (dragged) {
+      this._finish({ verdict: "layer-decided-lowest-common-denominator", evidence });
+      return true;
+    }
+    if (this._config.minChecks <= this._checks) {
+      this._finish({ verdict: "layer-decided-per-receiver", evidence });
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Settle on a verdict, exactly once.
+   *
+   * The guard is not paranoia: `onDone` removes this validator from the observer, and a second call
+   * would emit a second `validation-ready` for a validator that is no longer registered — e.g. when
+   * `observer.close()` cancels a validator that decided earlier in the same tick.
+   */
+  _finish(outcome) {
+    if (this._done) return;
+    this._done = true;
+    const decidedAt = Date.now();
+    this._windows.clear();
+    this.report = {
+      ready: true,
+      decidedAt,
+      startedAt: this.startedAt,
+      checks: this._checks,
+      ...outcome
+    };
+    if (outcome.verdict === "layer-decided-lowest-common-denominator") {
+      this._observer.addIssue({
+        type: LOWEST_COMMON_DENOMINATOR_ISSUE,
+        timestamp: decidedAt,
+        payload: {
+          type: LOWEST_COMMON_DENOMINATOR_ISSUE,
+          checks: this._checks,
+          ...outcome.evidence,
+          conclusion: {
+            faultDomain: "infrastructure",
+            summary: "one bad receiver is dragging a publisher's bitrate down for everyone \u2014 the SFU is not selecting layers per consumer",
+            recommendation: "check that simulcast/SVC is enabled and layers are chosen per consumer, and that the SFU terminates receiver reports instead of forwarding them; this is a build/config property, not a transient",
+            confidence: 0.8
+          }
+        }
+      });
+    }
+    this.onDone(this.report);
+  }
+  _windowOf(trackId) {
+    let window = this._windows.get(trackId);
+    if (!window) {
+      window = new SlidingWindow(this._config.windowMs);
+      this._windows.set(trackId, window);
+    }
+    return window;
+  }
+};
+
+// src/validators/RemoteTrackResolverValidator.ts
+var UNRESOLVED_TRACK_LINKS_ISSUE = "REMOTE_TRACK_LINKS_UNRESOLVED";
+var RemoteTrackResolverValidator = class _RemoteTrackResolverValidator {
+  constructor(_observer, onDone, config = {}) {
+    this._observer = _observer;
+    this.onDone = onDone;
+    this._config = {
+      minClients: 2,
+      minInboundTracks: 2,
+      linkedRatioThreshold: 0.5,
+      minChecks: 3,
+      ...config
+    };
+  }
+  _observer;
+  onDone;
+  static NAME = "remote-track-resolver";
+  name = _RemoteTrackResolverValidator.NAME;
+  startedAt = Date.now();
+  report = { ready: false };
+  _config;
+  /** Accumulated across every eligible call seen, so one small call cannot decide alone. */
+  _eligibleCalls = 0;
+  _inboundTracks = 0;
+  _linkedInboundTracks = 0;
+  _exampleCallId;
+  _checks = 0;
+  _done = false;
+  /** How many eligible calls were actually examined. `0` means nothing was established. */
+  get checks() {
+    return this._checks;
+  }
+  cancel(reason = "cancelled") {
+    this._finish({ verdict: "inconclusive", reason });
+  }
+  update() {
+    if (this._done) return;
+    for (const call of this._observer.observedCalls.values()) {
+      if (!call.remoteTrackResolver) continue;
+      if (call.observedClients.size < this._config.minClients) continue;
+      let inboundTracks = 0;
+      let linked = 0;
+      for (const client of call.observedClients.values()) {
+        for (const peerConnection of client.observedPeerConnections.values()) {
+          for (const inboundTrack of peerConnection.observedInboundTracks.values()) {
+            ++inboundTracks;
+            if (inboundTrack.remoteOutboundTrack !== void 0) ++linked;
+          }
+        }
+      }
+      if (inboundTracks < this._config.minInboundTracks) continue;
+      ++this._checks;
+      this._eligibleCalls += 1;
+      this._inboundTracks += inboundTracks;
+      this._linkedInboundTracks += linked;
+      this._exampleCallId ??= call.callId;
+      if (0 < this._linkedInboundTracks) {
+        return this._finish({ verdict: "links-resolved", evidence: this._evidence() });
+      }
+    }
+    if (this._config.minChecks <= this._checks && this._linkedInboundTracks === 0) {
+      this._finish({ verdict: "no-links-resolved", evidence: this._evidence() });
+    }
+  }
+  _evidence() {
+    return {
+      eligibleCalls: this._eligibleCalls,
+      inboundTracks: this._inboundTracks,
+      linkedInboundTracks: this._linkedInboundTracks,
+      linkedRatio: 0 < this._inboundTracks ? this._linkedInboundTracks / this._inboundTracks : 0,
+      exampleCallId: this._exampleCallId
+    };
+  }
+  _finish(outcome) {
+    if (this._done) return;
+    this._done = true;
+    const decidedAt = Date.now();
+    this.report = {
+      ready: true,
+      decidedAt,
+      startedAt: this.startedAt,
+      checks: this._checks,
+      ...outcome
+    };
+    if (outcome.verdict === "no-links-resolved") {
+      this._observer.addIssue({
+        type: UNRESOLVED_TRACK_LINKS_ISSUE,
+        timestamp: decidedAt,
+        payload: {
+          type: UNRESOLVED_TRACK_LINKS_ISSUE,
+          checks: this._checks,
+          ...outcome.evidence,
+          conclusion: {
+            faultDomain: "infrastructure",
+            summary: "a RemoteTrackResolver is configured but has never linked a subscriber to a publisher",
+            recommendation: "check the id the resolver joins on (mediasoup producerId, or your own convention) \u2014 until it links, IssueFanOutDetector, TrackDeliveryMismatchDetector, UnconsumedTrackDetector and SimulcastReceiverValidator all silently do nothing",
+            confidence: 0.9
+          }
+        }
+      });
+    }
+    this.onDone(this.report);
+  }
+};
+
+// src/validators/CodecConsistencyValidator.ts
+var CODEC_MISMATCH_ISSUE = "CODEC_INCONSISTENCY";
+var CodecConsistencyValidator = class _CodecConsistencyValidator {
+  constructor(_observer, onDone, config = {}) {
+    this._observer = _observer;
+    this.onDone = onDone;
+    this._config = {
+      kinds: ["audio", "video"],
+      minClients: 3,
+      minChecks: 3,
+      ...config
+    };
+  }
+  _observer;
+  onDone;
+  static NAME = "codec-consistency";
+  name = _CodecConsistencyValidator.NAME;
+  startedAt = Date.now();
+  report = { ready: false };
+  _config;
+  _inspectedCallIds = /* @__PURE__ */ new Set();
+  _evidence = [];
+  _checks = 0;
+  _done = false;
+  get checks() {
+    return this._checks;
+  }
+  cancel(reason = "cancelled") {
+    this._finish({ verdict: "inconclusive", reason });
+  }
+  update() {
+    if (this._done) return;
+    for (const call of this._observer.observedCalls.values()) {
+      if (this._inspectedCallIds.has(call.callId)) continue;
+      if (call.observedClients.size < this._config.minClients) continue;
+      const tallies = this._tallyOf(call.callId);
+      if (tallies.length === 0) continue;
+      this._inspectedCallIds.add(call.callId);
+      ++this._checks;
+      this._evidence.push(...tallies);
+      const split = tallies.find((evidence) => 1 < evidence.mimeTypes.length);
+      if (split) return this._finish({ verdict: "codec-split", evidence: this._evidence });
+    }
+    if (this._checks < this._config.minChecks) return;
+    const unexpected = this._evidence.filter(
+      (evidence) => evidence.expected !== void 0 && evidence.mimeTypes[0] !== evidence.expected
+    );
+    if (0 < unexpected.length) {
+      return this._finish({ verdict: "unexpected-codec", evidence: this._evidence });
+    }
+    this._finish({ verdict: "codec-consistent", evidence: this._evidence });
+  }
+  /** One evidence entry per configured kind that the call actually carried. */
+  _tallyOf(callId) {
+    const call = this._observer.observedCalls.get(callId);
+    if (!call) return [];
+    const byKind = /* @__PURE__ */ new Map();
+    for (const client of call.observedClients.values()) {
+      for (const peerConnection of client.observedPeerConnections.values()) {
+        for (const codec of peerConnection.observedCodecs.values()) {
+          const kind = mediaKindOf(codec.mimeType);
+          if (kind === void 0 || !this._config.kinds.includes(kind)) continue;
+          const tally = byKind.get(kind) ?? { mimeTypes: /* @__PURE__ */ new Map() };
+          const clientIds = tally.mimeTypes.get(codec.mimeType) ?? /* @__PURE__ */ new Set();
+          clientIds.add(client.clientId);
+          tally.mimeTypes.set(codec.mimeType, clientIds);
+          byKind.set(kind, tally);
+        }
+      }
+    }
+    const evidence = [];
+    for (const [kind, tally] of byKind) {
+      const ranked = [...tally.mimeTypes.entries()].sort((a, b) => b[1].size - a[1].size);
+      const clients = /* @__PURE__ */ new Set();
+      for (const [, clientIds] of ranked) {
+        for (const clientId of clientIds) clients.add(clientId);
+      }
+      if (clients.size < this._config.minClients) continue;
+      evidence.push({
+        callId,
+        kind,
+        mimeTypes: ranked.map(([mimeType]) => mimeType),
+        clientsPerMimeType: ranked.map(([, clientIds]) => clientIds.size),
+        clients: clients.size,
+        expected: this._config.expected?.[kind]
+      });
+    }
+    return evidence;
+  }
+  _finish(outcome) {
+    if (this._done) return;
+    this._done = true;
+    const decidedAt = Date.now();
+    this.report = {
+      ready: true,
+      decidedAt,
+      startedAt: this.startedAt,
+      checks: this._checks,
+      ...outcome
+    };
+    if (outcome.verdict === "codec-split" || outcome.verdict === "unexpected-codec") {
+      this._observer.addIssue({
+        type: CODEC_MISMATCH_ISSUE,
+        timestamp: decidedAt,
+        payload: {
+          type: CODEC_MISMATCH_ISSUE,
+          verdict: outcome.verdict,
+          checks: this._checks,
+          evidence: outcome.evidence,
+          conclusion: {
+            faultDomain: "infrastructure",
+            summary: outcome.verdict === "codec-split" ? "participants of one call are using different codecs \u2014 an SFU that forwards without transcoding cannot serve all of them" : "the deployment is consistently negotiating a codec other than the expected one",
+            recommendation: outcome.verdict === "codec-split" ? "check codec preferences and any SDP munging; a split usually means one endpoint could not negotiate the preferred codec and the others were not renegotiated with it" : "check codec preferences and endpoint support \u2014 a silent fallback keeps working, at a higher bitrate than you budgeted for",
+            confidence: 0.85
+          }
+        }
+      });
+    }
+    this.onDone(this.report);
+  }
+};
+function mediaKindOf(mimeType) {
+  if (mimeType.startsWith("video/")) return "video";
+  if (mimeType.startsWith("audio/")) return "audio";
+  return void 0;
+}
+
+// src/Observer.ts
+var logger8 = createLogger("Observer");
+var Observer = class extends EventEmitter6 {
+  observedTURN = new ObservedTURN();
   observedCalls = /* @__PURE__ */ new Map();
   observedMediasoupRouters = /* @__PURE__ */ new Map();
-  updater;
   /** Ancestry base shared by all Observer-bus events originating at the observer. */
   eventScope = { observer: this };
+  config;
   closed = false;
   totalAddedCall = 0;
   totalRemovedCall = 0;
@@ -3588,33 +6192,179 @@ var Observer = class extends EventEmitter6 {
   numberOfPeerConnections = 0;
   /** Global, pre-dispatch middleware chain run on every accepted sample. */
   acceptMiddlewares = new MiddlewareProcessor();
+  /**
+   * Fleet-wide index of every open client issue, maintained incrementally as issues open and close.
+   * Each call's index propagates into this one, so cross-call queries cost O(matching issues) rather
+   * than a walk over every call and client. This is what observer-scoped detectors read.
+   */
+  activeIssuesRegistry = new ActiveIssuesRegistry();
+  /**
+   * Validators currently running. Each removes itself when it finishes, so this is normally empty —
+   * a validator is a one-shot check, not a permanent fixture. Start one with {@link addValidator}.
+   */
+  validators = /* @__PURE__ */ new Set();
+  /**
+   * Observer-scoped detector registry, run on every `observer.update()` — the place for findings
+   * that span **calls**, e.g. "many calls on the same SFU degraded at once". Detectors raise
+   * findings with `observer.addIssue(...)`, surfaced on the bus as `observer-issue`.
+   * (For findings within a single call use `observedCall.detectors`.)
+   *
+   * Starts **empty**. Populate it with {@link addObserverDetector}, or `detectors.add(...)` for an
+   * instance you built yourself.
+   */
+  detectors = new Detectors();
+  /**
+   * The call-scoped detectors to build on **every** call this observer creates, in registration
+   * order. Written by {@link addCallDetector}; read by `createObservedCall`.
+   *
+   * Nothing is created implicitly. There is no detector configuration in `ObserverConfig` and no
+   * default set, because a detector that nobody asked for is a detector nobody will act on: it costs
+   * time on every tick and raises findings into a handler that was not written to expect them. An
+   * application says what it wants to watch, or it watches nothing.
+   *
+   * ```ts
+   * observer.addCallDetector('call-concurrent-issue-detector', {
+   *   issueTypes: [ 'congestion', 'ice-disconnected' ],
+   * });
+   * ```
+   */
+  callDetectorConfigs = /* @__PURE__ */ new Map();
+  constructor(config = {}) {
+    super();
+    this.setMaxListeners(Infinity);
+    this.update = this.update.bind(this);
+    this.config = {
+      autoUpdateOnCallUpdate: true,
+      appData: {},
+      closeCallIfEmptyForMs: 6e4,
+      closeClientIfIdleForMs: 6e4,
+      ...config
+    };
+  }
   get numberOfCalls() {
     return this.observedCalls.size;
   }
   get appData() {
     return this.config.appData;
   }
+  addObserverDetector(name, config = {}) {
+    if (this.closed) return this;
+    let detector;
+    switch (name) {
+      case SfuCongestionDetector.NAME: {
+        detector = new SfuCongestionDetector(this, config);
+        break;
+      }
+      case ObserverConcurrentIssueDetector.NAME: {
+        detector = new ObserverConcurrentIssueDetector(this, config);
+        break;
+      }
+      case ClientPopulationIssueDetector.NAME: {
+        detector = new ClientPopulationIssueDetector(this, config);
+        break;
+      }
+      case TurnServerHealthDetector.NAME: {
+        detector = new TurnServerHealthDetector(this, config);
+        break;
+      }
+      case TurnServerOutageDetector.NAME: {
+        detector = new TurnServerOutageDetector(this, config);
+        break;
+      }
+      default: {
+        logger8.warn("Unknown detector name %s; skipping", name);
+        return this;
+      }
+    }
+    this.detectors.add(detector);
+    return this;
+  }
+  /**
+   * Enable a call-scoped detector for calls created **from now on**.
+   *
+   * This edits the config, not the live calls: calls already open keep the detector set they were
+   * built with. To add one to an existing call, use `observedCall.addDetector(...)` directly.
+   */
+  addCallDetector(name, config = {}) {
+    if (this.closed) return this;
+    this.callDetectorConfigs.set(name, config);
+    return this;
+  }
+  /** Stop building `name` on calls created from now on. Calls already open are untouched. */
+  removeCallDetector(name) {
+    this.callDetectorConfigs.delete(name);
+    return this;
+  }
+  /**
+   * Start a structural check. It runs on each `observer.update()` until it can decide, reports once
+   * on `validation-ready`, and removes itself.
+   *
+   * ```ts
+   * observer.validate('simulcast-receiver-validator', { minChecks: 5 });
+   * ```
+   *
+   * Config keys are optional and merged over that validator's defaults. Call it again — after a
+   * deploy, say — to check again; there is no revalidation timer, because a deploy rather than
+   * elapsed time is what makes a structural verdict stale.
+   */
+  addValidator(name, config = {}) {
+    if (this.closed) return this;
+    let validator;
+    const onDone = (report) => {
+      if (validator) this.validators.delete(validator);
+      this._notify("validation-ready", { ...this.eventScope, report, validator: name });
+    };
+    switch (name) {
+      case SimulcastReceiverValidator.NAME:
+        validator = new SimulcastReceiverValidator(this, onDone, config);
+        break;
+      case RemoteTrackResolverValidator.NAME:
+        validator = new RemoteTrackResolverValidator(this, onDone, config);
+        break;
+      case CodecConsistencyValidator.NAME:
+        validator = new CodecConsistencyValidator(this, onDone, config);
+        break;
+    }
+    if (!validator) {
+      logger8.warn("Unknown validator name %s; skipping", name);
+      return this;
+    }
+    this.validators.add(validator);
+    return this;
+  }
   getObservedCall(callId) {
     if (this.closed || !this.observedCalls.has(callId)) return;
     return this.observedCalls.get(callId);
   }
   createObservedCall(settings) {
     if (this.closed) {
-      logger7.warn("Attempted to create a call (callId: %s) on a closed observer", settings.callId);
+      logger8.warn("Attempted to create a call (callId: %s) on a closed observer", settings.callId);
       return void 0;
     }
     if (this.observedCalls.has(settings.callId)) {
-      logger7.warn("Observed Call with id %s already exists; returning the existing instance", settings.callId);
+      logger8.warn("Observed Call with id %s already exists; returning the existing instance", settings.callId);
       return this.observedCalls.get(settings.callId);
     }
     const callSettings = {
       ...settings,
-      updatePolicy: settings.updatePolicy ?? this.config.defaultCallUpdatePolicy,
       closeCallIfEmptyForMs: settings.closeCallIfEmptyForMs ?? this.config.closeCallIfEmptyForMs,
       appData: settings.appData ?? this.config.createCallAppData?.({ callId: settings.callId, observer: this })
     };
-    const observedCall = new ObservedCall(callSettings, this);
+    const callActiveIssuesRegistry = new ActiveIssuesRegistry(this.activeIssuesRegistry);
+    const observedCall = new ObservedCall(
+      callSettings,
+      this,
+      callActiveIssuesRegistry
+    );
     observedCall.remoteTrackResolver = this.config.createRemoteTrackResolver?.(observedCall);
+    for (const [name, detectorConfig] of this.callDetectorConfigs) {
+      observedCall.addDetector(name, detectorConfig);
+    }
+    if (this.config.autoUpdateOnCallUpdate) {
+      const onCallUpdate = () => this.update();
+      observedCall.once("close", () => observedCall.off("update", onCallUpdate));
+      observedCall.on("update", onCallUpdate);
+    }
     observedCall.once("close", () => {
       this.observedCalls.delete(observedCall.callId);
       ++this.totalRemovedCall;
@@ -3629,11 +6379,11 @@ var Observer = class extends EventEmitter6 {
   }
   createObservedMediasoupRouter(settings) {
     if (this.closed) {
-      logger7.warn("Attempted to create mediasoup router (id: %d) on a closed observer", settings.router.id);
+      logger8.warn("Attempted to create mediasoup router (id: %d) on a closed observer", settings.router.id);
       return void 0;
     }
     if (this.observedMediasoupRouters.has(settings.router.id)) {
-      logger7.warn("Observed Mediasoup Router (id %s) already exists; returning the existing instance", settings.router.id);
+      logger8.warn("Observed Mediasoup Router (id %s) already exists; returning the existing instance", settings.router.id);
       return this.observedMediasoupRouters.get(settings.router.id);
     }
     const observedMediasoupRouter = new ObservedMediasoupRouter(settings);
@@ -3664,10 +6414,14 @@ var Observer = class extends EventEmitter6 {
   }
   close() {
     if (this.closed) {
-      return logger7.debug("Attempted to close twice");
+      return logger8.debug("Attempted to close twice");
     }
     this.closed = true;
-    this.observedCalls.forEach((call) => call.close());
+    for (const call of [...this.observedCalls.values()]) call.close();
+    this.detectors.clear();
+    for (const validator of [...this.validators]) validator.cancel();
+    this.validators.clear();
+    this.activeIssuesRegistry.clear();
     this._notify("observer-closed", { ...this.eventScope });
   }
   accept(sample, context) {
@@ -3677,7 +6431,7 @@ var Observer = class extends EventEmitter6 {
     try {
       this.acceptMiddlewares.process({ sample, context });
     } catch (err) {
-      logger7.warn("An accept middleware threw; dropping the sample. %o", err);
+      logger8.warn("An accept middleware threw; dropping the sample. %o", err);
     }
     if (!sample.callId) {
       this._notify("sample-rejected", { ...this.eventScope, reason: "missing-callId", sample });
@@ -3724,14 +6478,251 @@ var Observer = class extends EventEmitter6 {
       this.numberOfClientsUsingTurn += call.clientsUsedTurn.size;
     }
     this.observedTURN.update();
+    this.detectors.update();
+    for (const validator of [...this.validators]) {
+      try {
+        validator.update();
+      } catch (err) {
+        logger8.warn("Error running validator %s: %o", validator.name, err);
+      }
+    }
     this._notify("observer-updated", { ...this.eventScope });
   }
+  /**
+   * Raise an observer-scoped (cross-call / SFU-wide) finding. Emitted on the bus as
+   * `observer-issue`. Intended for `observer.detectors`, but the application may call it too.
+   *
+   * `payload` takes an **object**; see `ObserverIssue`.
+   */
+  addIssue(issue) {
+    if (this.closed) return;
+    this._notify("observer-issue", { ...this.eventScope, issue });
+  }
   /** Emit an Observer-bus event. */
   _notify(type, ...args) {
     this.emit(type, ...args);
   }
 };
 
+// src/utils/CallHealthAggregator.ts
+var defaultClientHealthThresholds = {
+  inboundFractionLost: 0.03,
+  outboundFractionLost: 0.03,
+  rttInMs: 400,
+  freezeCount: 1,
+  concealmentRatio: 0.1
+};
+var CallHealthAggregator = class {
+  constructor(_call, thresholds = defaultClientHealthThresholds) {
+    this._call = _call;
+    this.thresholds = thresholds;
+  }
+  _call;
+  thresholds;
+  aggregate() {
+    const clients = [];
+    for (const client of this._call.observedClients.values()) {
+      clients.push(this._clientHealth(client));
+    }
+    const degraded = clients.filter((c) => c.degraded);
+    const inboundDegraded = clients.filter((c) => c.inboundDegraded);
+    const outboundDegraded = clients.filter((c) => c.outboundDegraded);
+    const collect = (pick) => summarize(clients.map(pick).filter((v) => typeof v === "number" && Number.isFinite(v)));
+    const qualityLimitation = { cpu: 0, bandwidth: 0, other: 0 };
+    for (const client of clients) {
+      if (client.qualityLimitationReasons.includes("cpu")) qualityLimitation.cpu += 1;
+      if (client.qualityLimitationReasons.includes("bandwidth")) qualityLimitation.bandwidth += 1;
+      if (client.qualityLimitationReasons.some((r) => r !== "cpu" && r !== "bandwidth")) qualityLimitation.other += 1;
+    }
+    const ratio = (n) => 0 < clients.length ? n / clients.length : 0;
+    return {
+      callId: this._call.callId,
+      clients,
+      numberOfClients: clients.length,
+      numberOfDegradedClients: degraded.length,
+      numberOfInboundDegradedClients: inboundDegraded.length,
+      numberOfOutboundDegradedClients: outboundDegraded.length,
+      degradedRatio: ratio(degraded.length),
+      inboundDegradedRatio: ratio(inboundDegraded.length),
+      outboundDegradedRatio: ratio(outboundDegraded.length),
+      rttInMs: collect((c) => c.rttInMs),
+      inboundFractionLost: collect((c) => c.inboundFractionLost),
+      concealmentRatio: collect((c) => c.concealmentRatio),
+      qualityLimitation,
+      freezes: {
+        affectedClients: clients.filter((c) => 0 < c.deltaFreezeCount).length,
+        total: clients.reduce((sum, c) => sum + c.deltaFreezeCount, 0)
+      }
+    };
+  }
+  _clientHealth(client) {
+    let deltaFreezeCount = 0;
+    let concealedSamples = 0;
+    let receivedSamples = 0;
+    let remoteLostPackets = 0;
+    let remoteSentPackets = 0;
+    const qualityLimitationReasons = /* @__PURE__ */ new Set();
+    for (const peerConnection of client.observedPeerConnections.values()) {
+      for (const rtp of peerConnection.observedInboundRtps.values()) {
+        deltaFreezeCount += rtp.deltaFreezeCount;
+        concealedSamples += rtp.deltaConcealedSamples;
+        receivedSamples += rtp.deltaReceivedSamples;
+      }
+      for (const rtp of peerConnection.observedOutboundRtps.values()) {
+        if (rtp.qualityLimitationReason && rtp.qualityLimitationReason !== "none") {
+          qualityLimitationReasons.add(rtp.qualityLimitationReason);
+        }
+        if (rtp.remoteFractionLost !== void 0) {
+          remoteLostPackets += rtp.remoteFractionLost * rtp.deltaPacketsSent;
+          remoteSentPackets += rtp.deltaPacketsSent;
+        }
+      }
+    }
+    const inboundTotal = client.deltaInboundPacketsLost + client.deltaInboundPacketsReceived;
+    const inboundFractionLost = 0 < inboundTotal ? client.deltaInboundPacketsLost / inboundTotal : void 0;
+    const outboundFractionLost = 0 < remoteSentPackets ? remoteLostPackets / remoteSentPackets : void 0;
+    const concealmentRatio = 0 < receivedSamples ? concealedSamples / receivedSamples : void 0;
+    const rttInMs = client.currentAvgRttInMs;
+    const reasons = [];
+    if (this.thresholds.inboundFractionLost < (inboundFractionLost ?? 0)) reasons.push("inbound-fraction-lost");
+    if (this.thresholds.freezeCount <= deltaFreezeCount) reasons.push("freezes");
+    if (this.thresholds.concealmentRatio < (concealmentRatio ?? 0)) reasons.push("concealment");
+    if (this.thresholds.rttInMs < (rttInMs ?? 0)) reasons.push("rtt");
+    const outboundReasons = [];
+    if (this.thresholds.outboundFractionLost < (outboundFractionLost ?? 0)) outboundReasons.push("outbound-fraction-lost");
+    if (0 < qualityLimitationReasons.size) {
+      outboundReasons.push(...[...qualityLimitationReasons].map((r) => `quality-limited-${r}`));
+    }
+    const inboundDegraded = 0 < reasons.length;
+    const outboundDegraded = 0 < outboundReasons.length;
+    return {
+      observedClient: client,
+      clientId: client.clientId,
+      inboundDegraded,
+      outboundDegraded,
+      degraded: inboundDegraded || outboundDegraded,
+      reasons: [...reasons, ...outboundReasons],
+      inboundFractionLost,
+      outboundFractionLost,
+      rttInMs,
+      deltaFreezeCount,
+      concealmentRatio,
+      qualityLimitationReasons: [...qualityLimitationReasons],
+      usingTURN: client.usingTURN,
+      usingTCP: client.usingTCP
+    };
+  }
+};
+
+// src/common/ObserverIssue.ts
+function issuePayloadOf(issue) {
+  const payload = issue.payload;
+  if (payload === void 0) return void 0;
+  return typeof payload === "string" ? parseJsonObject(payload) : payload;
+}
+function issuePayloadAsString(issue) {
+  const payload = issue.payload;
+  if (payload === void 0) return void 0;
+  if (typeof payload === "string") return payload;
+  try {
+    return JSON.stringify(payload);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/utils/TrendTester.ts
+var TrendTester = class {
+  _size;
+  _values = [];
+  _tieCounts = /* @__PURE__ */ new Map();
+  _pageHinkleyDelta;
+  _pageHinkleyLambda;
+  _mannKendallAlpha;
+  _s = 0;
+  _rejected = 0;
+  _pageHinkleyResult;
+  constructor(config = {}) {
+    this._size = Math.max(2, Math.floor(config.size ?? 30));
+    this._pageHinkleyDelta = config.pageHinkleyDelta ?? 0;
+    this._pageHinkleyLambda = config.pageHinkleyLambda ?? 50;
+    this._mannKendallAlpha = config.mannKendallAlpha ?? 0.05;
+  }
+  /** Values rejected by {@link add} for being non-finite. Non-zero means the caller has a bug. */
+  get rejected() {
+    return this._rejected;
+  }
+  /** How many values are currently in the window (`<= size`). */
+  get length() {
+    return this._values.length;
+  }
+  /** The configured window length. */
+  get size() {
+    return this._size;
+  }
+  /**
+   * Add the next value in the stream, evicting the oldest once the window is full.
+   *
+   * **Non-finite values are rejected** rather than stored, and the rejection is counted in
+   * {@link rejected}. This is not defensive noise — it is the difference between a bad reading and
+   * a bad instance. `Math.sign(NaN)` is `NaN`, so a single `NaN` would poison the incremental
+   * Mann-Kendall sum `_s` **permanently**: every later `add` and `_evictOldest` adds or subtracts
+   * `NaN`, the z-score is `NaN`, every comparison against it is `false`, and the tester silently
+   * reports `no-trend` forever after. It would also take a `NaN` key in `_tieCounts` that can never
+   * be matched on eviction, since `NaN !== NaN`.
+   *
+   * `undefined` RTT (no measurement this tick) must not be coerced to `0` and passed in either —
+   * "we didn't measure" is not "the trip took no time", and feeding zeros manufactures a downward
+   * trend. Skip the sample instead.
+   */
+  add(value) {
+    if (!Number.isFinite(value)) {
+      ++this._rejected;
+      return;
+    }
+    if (this._values.length === this._size) this._evictOldest();
+    for (let i = 0; i < this._values.length; i++) this._s += Math.sign(value - this._values[i]);
+    this._values.push(value);
+    this._bumpTie(value, 1);
+    this._pageHinkleyResult = pageHinkley(this._values, this._pageHinkleyDelta, this._pageHinkleyLambda);
+  }
+  /** The current Page-Hinkley read-out over the window. `undefined` before the first value. */
+  pageHinkley() {
+    return this._pageHinkleyResult;
+  }
+  /** The current Mann-Kendall read-out over the window. */
+  mannKendall() {
+    const n = this._values.length;
+    if (n < 2) return { s: 0, variance: 0, z: 0, pValue: 1, trend: "no-trend" };
+    let tieCorrection = 0;
+    for (const groupSize of this._tieCounts.values()) {
+      if (1 < groupSize) tieCorrection += groupSize * (groupSize - 1) * (2 * groupSize + 5);
+    }
+    const variance = (n * (n - 1) * (2 * n + 5) - tieCorrection) / 18;
+    return { s: this._s, variance, ...mannKendallVerdict(this._s, variance, this._mannKendallAlpha) };
+  }
+  /** Drop everything, e.g. after a detected change point, to start judging the trend fresh. */
+  clear() {
+    this._values.length = 0;
+    this._tieCounts.clear();
+    this._s = 0;
+    this._rejected = 0;
+    this._pageHinkleyResult = void 0;
+  }
+  /** Remove the oldest value from the window and correct `_s` for the pairs it was part of. */
+  _evictOldest() {
+    const removed = this._values.shift();
+    if (removed === void 0) return;
+    for (let i = 0; i < this._values.length; i++) this._s -= Math.sign(this._values[i] - removed);
+    this._bumpTie(removed, -1);
+  }
+  _bumpTie(value, delta) {
+    const count = (this._tieCounts.get(value) ?? 0) + delta;
+    if (count <= 0) this._tieCounts.delete(value);
+    else this._tieCounts.set(value, count);
+  }
+};
+
 // src/sinks/ClientSampleSink.ts
 import { EventEmitter as EventEmitter7 } from "events";
 var ClientSampleSink = class extends EventEmitter7 {
@@ -3795,7 +6786,7 @@ function createInMemorySink(samples) {
   return new InMemorySink(samples);
 }
 
-// src/utils/RemoteTrackResolver.ts
+// src/resolvers/RemoteTrackResolver.ts
 var RemoteTrackResolver = class {
   constructor(observedCall, resolvers) {
     this.observedCall = observedCall;
@@ -3854,10 +6845,15 @@ var RemoteTrackResolver = class {
     if (!outboundTrack) return;
     outboundTrack.remoteInboundTracks.add(inboundTrack);
     inboundTrack.remoteOutboundTrack = outboundTrack;
+    this.observedCall.unconsumedOutboundTracks.delete(outboundTrack);
   }
   _removeInboundTrack(inboundTrack) {
-    inboundTrack.remoteOutboundTrack?.remoteInboundTracks.delete(inboundTrack);
+    const outboundTrack = inboundTrack.remoteOutboundTrack;
+    outboundTrack?.remoteInboundTracks.delete(inboundTrack);
     inboundTrack.remoteOutboundTrack = void 0;
+    if (outboundTrack && outboundTrack.remoteInboundTracks.size === 0) {
+      this.observedCall.unconsumedOutboundTracks.add(outboundTrack);
+    }
     const subscriberId = this.resolvers.resolveInboundTrackSubscriberId?.(inboundTrack);
     if (subscriberId) {
       this._subscriberIdToInboundTrack.delete(subscriberId);
@@ -3867,12 +6863,14 @@ var RemoteTrackResolver = class {
     const publisherId = this.resolvers.resolveOutboundTrackPublisherId(outboundTrack);
     if (!publisherId) return;
     this._publisherIdToOutboundTrack.set(publisherId, outboundTrack);
+    this.observedCall.unconsumedOutboundTracks.add(outboundTrack);
     for (const observedClient of this.observedCall.observedClients.values()) {
       for (const observedPeerConnection of observedClient.observedPeerConnections.values()) {
         for (const inboundTrack of observedPeerConnection.observedInboundTracks.values()) {
           if (this.resolvers.resolveInboundTrackPublisherId(inboundTrack) !== publisherId) continue;
           outboundTrack.remoteInboundTracks.add(inboundTrack);
           inboundTrack.remoteOutboundTrack = outboundTrack;
+          this.observedCall.unconsumedOutboundTracks.delete(outboundTrack);
         }
       }
     }
@@ -3886,10 +6884,11 @@ var RemoteTrackResolver = class {
       inboundTrack.remoteOutboundTrack = void 0;
     }
     outboundTrack.remoteInboundTracks.clear();
+    this.observedCall.unconsumedOutboundTracks.delete(outboundTrack);
   }
 };
 
-// src/utils/RemoteTrackResolverFactories.ts
+// src/resolvers/RemoteTrackResolverFactories.ts
 function createDefaultMediasoupRemoteTrackResolverFactory() {
   return (observedCall) => new RemoteTrackResolver(observedCall, {
     resolveInboundTrackPublisherId: (inboundTrack) => inboundTrack.attachments?.producerId,
@@ -3915,15 +6914,27 @@ function createP2pRemoteTrackResolverFactory() {
   });
 }
 export {
+  ActiveIssuesRegistry,
+  CODEC_MISMATCH_ISSUE,
+  CallConcurrentIssueDetector,
+  CallConcurrentIssueTypes,
+  CallHealthAggregator,
   ClientEventTypes,
   ClientMetaTypes,
+  ClientPopulationIssueDetector,
+  ClientPopulationIssueTypes,
   ClientSampleSink,
+  CodecConsistencyValidator,
   Detectors,
   InMemorySink,
+  IssueFanOutDetector,
+  IssueFanOutTypes,
   JsonlFileSink,
+  LOWEST_COMMON_DENOMINATOR_ISSUE,
   ObservedCall,
   ObservedCertificate,
   ObservedClient,
+  ObservedClientIssueRegistry,
   ObservedCodec,
   ObservedDataChannel,
   ObservedIceCandidate,
@@ -3941,13 +6952,50 @@ export {
   ObservedRemoteInboundRtp,
   ObservedRemoteOutboundRtp,
   Observer,
+  ObserverConcurrentIssueDetector,
+  ObserverConcurrentIssueTypes,
+  PublisherFaultCorroborationDetector,
+  PublisherFaultTypes,
+  RESOLVED_ISSUE_SUFFIX,
   RemoteTrackResolver,
+  RemoteTrackResolverValidator,
+  SfuCongestionDetector,
+  SimulcastReceiverValidator,
+  SlidingWindow,
+  TrackDeliveryMismatchDetector,
+  TrackDeliveryMismatchTypes,
+  TrendTester,
+  TurnServerHealthDetector,
+  TurnServerHealthTypes,
+  TurnServerOutageDetector,
+  TurnServerOutageTypes,
+  UNRESOLVED_TRACK_LINKS_ISSUE,
+  UnconsumedTrackDetector,
+  UnconsumedTrackTypes,
+  baseIssueType,
+  concludeCallIssue,
+  concludeObserverIssue,
+  correlation,
+  counterDelta,
   createDefaultMediasoupRemoteTrackResolverFactory,
   createInMemorySink,
   createJsonlFileSink,
   createJsonlFileSinkFactory,
   createLogger,
   createP2pRemoteTrackResolverFactory,
-  setObserverLogger
+  defaultClientHealthThresholds,
+  isClientIssueResolutionEntry,
+  issuePayloadAsString,
+  issuePayloadOf,
+  mannKendall,
+  mannKendallVerdict,
+  median,
+  medianAbsoluteDeviation,
+  pageHinkley,
+  percentile,
+  percentileOfSorted,
+  robustZScore,
+  setObserverLogger,
+  summarize
 };
 //# sourceMappingURL=index.mjs.map