@observertc/observer-js 1.0.0-beta.12 → 1.0.0-beta.14

package/dist/index.mjs

@@ -50,6 +50,86 @@ 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;
+  const sorted = [...values].sort((a, b) => a - b);
+  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 median(values) {
+  return percentile(values, 0.5);
+}
+function summarize(values) {
+  if (values.length === 0) return void 0;
+  let min = values[0];
+  let max = values[0];
+  let sum = 0;
+  for (const value of values) {
+    if (value < min) min = value;
+    if (max < value) max = value;
+    sum += value;
+  }
+  return {
+    count: values.length,
+    min,
+    max,
+    mean: sum / values.length,
+    median: percentile(values, 0.5),
+    p75: percentile(values, 0.75),
+    p95: percentile(values, 0.95)
+  };
+}
+function counterDelta(previous, current) {
+  if (previous === void 0 || current === void 0) return 0;
+  if (current < previous) return 0;
+  return current - previous;
+}
+var SlidingWindow = class {
+  constructor(windowMs, maxEntries = 1024) {
+    this.windowMs = windowMs;
+    this.maxEntries = maxEntries;
+  }
+  windowMs;
+  maxEntries;
+  _entries = [];
+  /** Add an entry (defaults to `Date.now()`), then evict anything outside the window. */
+  add(value, timestamp = Date.now()) {
+    this._entries.push({ timestamp, value });
+    this._evict(timestamp);
+  }
+  /** The entries still inside the window, oldest first. */
+  entries(now = Date.now()) {
+    this._evict(now);
+    return this._entries;
+  }
+  /** The values still inside the window, oldest first. */
+  values(now = Date.now()) {
+    return this.entries(now).map((entry) => entry.value);
+  }
+  get size() {
+    return this._entries.length;
+  }
+  clear() {
+    this._entries = [];
+  }
+  _evict(now) {
+    const oldest = now - this.windowMs;
+    while (0 < this._entries.length && this._entries[0].timestamp < oldest) {
+      this._entries.shift();
+    }
+    while (this.maxEntries < this._entries.length) {
+      this._entries.shift();
+    }
+  }
+};
+
 // src/ObservedInboundRtp.ts
 var ObservedInboundRtp = class {
   constructor(timestamp, id, ssrc, kind, trackIdentifier, _peerConnection) {
@@ -137,6 +217,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 +299,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 +413,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 +478,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 +530,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 +556,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;
@@ -1252,7 +1467,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 +1566,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 +1645,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 +1678,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 +1755,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,11 +1826,10 @@ 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 ? getMedian(iceRttMeasurementsInSec, false) * 1e3 : void 0;
+    this.rtcpRttInMs = 0 < rtcpRttMeasurementsInSec.length ? getMedian(rtcpRttMeasurementsInSec, false) * 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);
     } else {
@@ -1598,12 +1841,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,6 +2341,24 @@ var ClientMetaTypes = /* @__PURE__ */ ((ClientMetaTypes2) => {
   return ClientMetaTypes2;
 })(ClientMetaTypes || {});
 
+// src/common/ActiveClientIssue.ts
+var RESOLVED_ISSUE_SUFFIX = "-resolved";
+function isResolutionEntry(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;
+}
+function parseIssuePayload(payload) {
+  if (!payload) return void 0;
+  try {
+    const parsed = JSON.parse(payload);
+    return parsed && typeof parsed === "object" ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
 // src/ObservedClient.ts
 var logger2 = createLogger("ObservedClient");
 var ObservedClient = class extends EventEmitter2 {
@@ -2181,6 +2445,16 @@ var ObservedClient = class extends EventEmitter2 {
   // 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 = /* @__PURE__ */ new Map();
   _pendingInjections = {};
   _activeSample;
   closeTimer;
@@ -2193,6 +2467,7 @@ var ObservedClient = class extends EventEmitter2 {
   close() {
     if (this.closed) return;
     this._flushPendingInjections();
+    this.resolveActiveIssues("client-closed");
     this.closed = true;
     Array.from(this.observedPeerConnections.values()).forEach((peerConnection) => peerConnection.close());
     if (!this.leftAt) {
@@ -2324,10 +2599,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 +2711,97 @@ 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 (isResolutionEntry(issue)) return this._resolveIssue(issue);
+    const now = Date.now();
+    if (issue.key) {
+      const payload = parseIssuePayload(issue.payload);
+      const existing = this.activeIssues.get(issue.key);
+      if (existing) {
+        existing.payload = payload ?? existing.payload;
+      } else {
+        this.activeIssues.set(issue.key, {
+          key: issue.key,
+          type: baseIssueType(issue.type),
+          clientId: this.clientId,
+          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._notify("client-issue", { ...this.eventScope, issue });
   }
   addExtensionStats(stats) {
     this._notify("client-extension-stats", { ...this.eventScope, extensionStats: stats });
   }
+  /**
+   * Close every still-open issue, e.g. because the client is going away. Emits
+   * `client-issue-resolved` for each with the given `resolvedBy`, so correlators relying on the
+   * active set don't keep a departed client's issues open forever.
+   */
+  resolveActiveIssues(resolvedBy = "client-closed") {
+    if (this.activeIssues.size === 0) return;
+    const now = Date.now();
+    for (const active of [...this.activeIssues.values()]) {
+      this.activeIssues.delete(active.key);
+      this._notify("client-issue-resolved", {
+        ...this.eventScope,
+        resolvedIssue: {
+          ...active,
+          resolvedAt: now,
+          observedResolvedAt: now,
+          durationInMs: Math.max(0, now - active.observedAt),
+          resolvedBy
+        }
+      });
+    }
+  }
+  /** Close the active issue a `<type>-resolved` entry refers to, and announce the finished interval. */
+  _resolveIssue(issue) {
+    const now = Date.now();
+    const resolutionPayload = parseIssuePayload(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.delete(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,
+        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: "client"
+      }
+    });
+  }
   _processClientEvent(event, postBuffer) {
     switch (event.type) {
       case "CLIENT_JOINED" /* CLIENT_JOINED */: {
@@ -2830,6 +3196,7 @@ var Detectors = class {
   }
   remove(detector) {
     this._detectors = this._detectors.filter((d) => d !== detector);
+    this._close(detector);
   }
   update() {
     for (const detector of this._detectors) {
@@ -2841,7 +3208,16 @@ 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);
+    }
   }
 };
 
@@ -2931,6 +3307,7 @@ var ObservedCall = class extends EventEmitter3 {
     if (this.startedAt === void 0) this.startedAt = minSampleTimestamps;
     if (this.endedAt === void 0) this.endedAt = maxSampleTimestamps;
     this.closedAt = Date.now();
+    this.detectors.clear();
     this.emit("close");
     this._notify("call-closed", { ...this.eventScope });
   }
@@ -3129,21 +3506,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) {
@@ -3293,10 +3671,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 +3702,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 +3785,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 +3819,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 +3851,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 +3870,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 +3892,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 +3913,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 +3924,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 +3939,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 +3954,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 +3968,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 +4030,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);
@@ -3588,6 +4080,13 @@ var Observer = class extends EventEmitter6 {
   numberOfPeerConnections = 0;
   /** Global, pre-dispatch middleware chain run on every accepted sample. */
   acceptMiddlewares = new MiddlewareProcessor();
+  /**
+   * Observer-scoped detector registry (ships empty), 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`.)
+   */
+  detectors = new Detectors();
   get numberOfCalls() {
     return this.observedCalls.size;
   }
@@ -3668,6 +4167,7 @@ var Observer = class extends EventEmitter6 {
     }
     this.closed = true;
     this.observedCalls.forEach((call) => call.close());
+    this.detectors.clear();
     this._notify("observer-closed", { ...this.eventScope });
   }
   accept(sample, context) {
@@ -3724,14 +4224,1335 @@ var Observer = class extends EventEmitter6 {
       this.numberOfClientsUsingTurn += call.clientsUsedTurn.size;
     }
     this.observedTURN.update();
+    this.detectors.update();
     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.
+   */
+  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/TrackDistributionAggregator.ts
+var defaultReceiverHealthThresholds = {
+  fractionLost: 0.03,
+  freezeCount: 1,
+  framesDroppedRatio: 0.05,
+  concealmentRatio: 0.1,
+  jitterBufferDelayInMs: 500,
+  rttInMs: 400
+};
+var TrackDistributionAggregator = class {
+  constructor(_call, thresholds = defaultReceiverHealthThresholds) {
+    this._call = _call;
+    this.thresholds = thresholds;
+  }
+  _call;
+  thresholds;
+  /** Aggregate every published track in the call that currently has linked subscribers. */
+  aggregate() {
+    const result = [];
+    for (const client of this._call.observedClients.values()) {
+      for (const peerConnection of client.observedPeerConnections.values()) {
+        for (const outboundTrack of peerConnection.observedOutboundTracks.values()) {
+          const distribution = this.aggregateTrack(outboundTrack);
+          if (distribution) result.push(distribution);
+        }
+      }
+    }
+    return result;
+  }
+  /** Aggregate a single published track, or `undefined` when it has no linked subscribers. */
+  aggregateTrack(outboundTrack) {
+    if (outboundTrack.remoteInboundTracks.size === 0) return void 0;
+    const publisher = this._publisherEntry(outboundTrack);
+    const receivers = [];
+    for (const inboundTrack of outboundTrack.remoteInboundTracks) {
+      receivers.push(this._receiverEntry(inboundTrack));
+    }
+    const degraded = receivers.filter((receiver) => receiver.degraded);
+    const collect = (pick) => summarize(receivers.map(pick).filter((v) => typeof v === "number" && Number.isFinite(v)));
+    return {
+      trackId: outboundTrack.id,
+      kind: outboundTrack.kind,
+      publisher,
+      receivers,
+      numberOfReceivers: receivers.length,
+      numberOfHealthyReceivers: receivers.length - degraded.length,
+      numberOfDegradedReceivers: degraded.length,
+      degradedRatio: 0 < receivers.length ? degraded.length / receivers.length : 0,
+      bitrate: collect((r) => r.bitrate),
+      fractionLost: collect((r) => r.fractionLost),
+      jitter: collect((r) => r.jitter),
+      rttInMs: collect((r) => r.rttInMs),
+      jitterBufferDelayInMs: collect((r) => r.jitterBufferDelayInMs),
+      concealmentRatio: collect((r) => r.concealmentRatio),
+      freezes: {
+        affectedReceivers: receivers.filter((r) => 0 < r.deltaFreezeCount).length,
+        total: receivers.reduce((sum, r) => sum + r.deltaFreezeCount, 0)
+      },
+      plis: {
+        affectedReceivers: receivers.filter((r) => 0 < r.deltaPliCount).length,
+        total: receivers.reduce((sum, r) => sum + r.deltaPliCount, 0)
+      },
+      concealment: {
+        affectedReceivers: receivers.filter((r) => this.thresholds.concealmentRatio <= (r.concealmentRatio ?? 0)).length
+      }
+    };
+  }
+  _publisherEntry(outboundTrack) {
+    const peerConnection = outboundTrack.getPeerConnection();
+    const rtps = outboundTrack.getOutboundRtps() ?? [];
+    let bitrate = 0;
+    let deltaPacketsSent = 0;
+    let remoteFractionLost;
+    let remoteRttInMs;
+    let qualityLimitationReason;
+    for (const rtp of rtps) {
+      bitrate += rtp.bitrate;
+      deltaPacketsSent += rtp.deltaPacketsSent;
+      if (rtp.remoteFractionLost !== void 0) {
+        remoteFractionLost = Math.max(remoteFractionLost ?? 0, rtp.remoteFractionLost);
+      }
+      if (rtp.remoteRttInMs !== void 0) {
+        remoteRttInMs = Math.max(remoteRttInMs ?? 0, rtp.remoteRttInMs);
+      }
+      if (rtp.qualityLimitationReason && rtp.qualityLimitationReason !== "none") {
+        qualityLimitationReason = rtp.qualityLimitationReason;
+      }
+    }
+    const reasons = [];
+    if (this.thresholds.fractionLost < (remoteFractionLost ?? 0)) reasons.push("remote-fraction-lost");
+    if (this.thresholds.rttInMs < (remoteRttInMs ?? 0)) reasons.push("remote-rtt");
+    if (qualityLimitationReason) reasons.push(`quality-limited-${qualityLimitationReason}`);
+    if (outboundTrack.muted !== true && deltaPacketsSent === 0) reasons.push("no-packets-sent");
+    return {
+      observedOutboundTrack: outboundTrack,
+      clientId: peerConnection?.client.clientId ?? "unknown",
+      peerConnectionId: peerConnection?.peerConnectionId ?? "unknown",
+      healthy: reasons.length === 0,
+      reasons,
+      bitrate,
+      remoteFractionLost,
+      remoteRttInMs,
+      qualityLimitationReason,
+      deltaPacketsSent
+    };
+  }
+  _receiverEntry(inboundTrack) {
+    const peerConnection = inboundTrack.getPeerConnection();
+    const rtp = inboundTrack.getInboundRtp();
+    const reasons = [];
+    const fractionLost = rtp?.fractionLost;
+    const deltaFreezeCount = rtp?.deltaFreezeCount ?? 0;
+    const framesDroppedRatio = rtp?.framesDroppedRatio;
+    const concealmentRatio = rtp?.concealmentRatio;
+    const jitterBufferDelayInMs = rtp?.jitterBufferDelayInMs;
+    const rttInMs = peerConnection?.currentRttInMs;
+    if (this.thresholds.fractionLost < (fractionLost ?? 0)) reasons.push("fraction-lost");
+    if (this.thresholds.freezeCount <= deltaFreezeCount) reasons.push("freezes");
+    if (this.thresholds.framesDroppedRatio < (framesDroppedRatio ?? 0)) reasons.push("frames-dropped");
+    if (this.thresholds.concealmentRatio < (concealmentRatio ?? 0)) reasons.push("concealment");
+    if (this.thresholds.jitterBufferDelayInMs < (jitterBufferDelayInMs ?? 0)) reasons.push("jitter-buffer-delay");
+    if (this.thresholds.rttInMs < (rttInMs ?? 0)) reasons.push("rtt");
+    return {
+      observedInboundTrack: inboundTrack,
+      clientId: peerConnection?.client.clientId ?? "unknown",
+      peerConnectionId: peerConnection?.peerConnectionId ?? "unknown",
+      degraded: 0 < reasons.length,
+      reasons,
+      bitrate: rtp?.bitrate ?? 0,
+      fractionLost,
+      jitter: rtp?.jitter,
+      rttInMs,
+      jitterBufferDelayInMs,
+      concealmentRatio,
+      framesDroppedRatio,
+      deltaFreezeCount,
+      deltaPliCount: rtp?.deltaPliCount ?? 0,
+      deltaNackCount: rtp?.deltaNackCount ?? 0,
+      deltaPacketsReceived: rtp?.deltaReceivedPackets ?? 0
+    };
+  }
+};
+
+// 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/detectors/CommonSourceDegradationDetector.ts
+var CommonSourceDegradationTypes = {
+  /** The publisher's egress looks fine, yet most subscribers are degraded → downstream/SFU suspected. */
+  publisherHealthySubscribersDegraded: "PUBLISHER_HEALTHY_SUBSCRIBERS_DEGRADED",
+  /** The publisher itself is impaired and every subscriber sees it → source-side problem. */
+  publisherDegradedForAllSubscribers: "PUBLISHER_DEGRADED_FOR_ALL_SUBSCRIBERS",
+  /** Exactly one subscriber is degraded while the rest are fine → that receiver's own problem. */
+  singleSubscriberDegraded: "SINGLE_SUBSCRIBER_DEGRADED",
+  /** Several (but not most) subscribers degraded on the same source. */
+  multipleSubscribersDegraded: "MULTIPLE_SUBSCRIBERS_DEGRADED"
+};
+var defaultConfig = {
+  minReceivers: 3,
+  degradedRatioThreshold: 0.6,
+  consecutiveTicks: 2
+};
+var CommonSourceDegradationDetector = class {
+  constructor(_call, config = {}) {
+    this._call = _call;
+    this._config = { ...defaultConfig, ...config };
+    this._aggregator = new TrackDistributionAggregator(
+      _call,
+      { ...defaultReceiverHealthThresholds, ...config.thresholds }
+    );
+  }
+  _call;
+  name = "common-source-degradation-detector";
+  _config;
+  _aggregator;
+  /** trackId -> consecutive ticks the same finding held. */
+  _streaks = /* @__PURE__ */ new Map();
+  /** The distributions computed on the most recent `update()` (handy for dashboards). */
+  lastDistributions = [];
+  update() {
+    this.lastDistributions = this._aggregator.aggregate();
+    const seen = /* @__PURE__ */ new Set();
+    for (const distribution of this.lastDistributions) {
+      seen.add(distribution.trackId);
+      const type = this._classify(distribution);
+      if (!type) {
+        this._streaks.delete(distribution.trackId);
+        continue;
+      }
+      const streak = this._streaks.get(distribution.trackId);
+      const ticks = streak?.type === type ? streak.ticks + 1 : 1;
+      this._streaks.set(distribution.trackId, { type, ticks });
+      if (ticks === this._config.consecutiveTicks) {
+        this._call.addIssue({
+          type,
+          timestamp: Date.now(),
+          payload: JSON.stringify(this._payload(distribution, type))
+        });
+      }
+    }
+    for (const trackId of [...this._streaks.keys()]) {
+      if (!seen.has(trackId)) this._streaks.delete(trackId);
+    }
+  }
+  _classify(distribution) {
+    const { numberOfReceivers, numberOfDegradedReceivers, degradedRatio, publisher } = distribution;
+    if (numberOfDegradedReceivers === 0) return void 0;
+    if (numberOfDegradedReceivers === 1 && 1 < numberOfReceivers) {
+      return CommonSourceDegradationTypes.singleSubscriberDegraded;
+    }
+    if (numberOfReceivers < this._config.minReceivers) return void 0;
+    if (this._config.degradedRatioThreshold <= degradedRatio) {
+      return publisher.healthy ? CommonSourceDegradationTypes.publisherHealthySubscribersDegraded : CommonSourceDegradationTypes.publisherDegradedForAllSubscribers;
+    }
+    return CommonSourceDegradationTypes.multipleSubscribersDegraded;
+  }
+  _payload(distribution, type) {
+    return {
+      type,
+      trackId: distribution.trackId,
+      kind: distribution.kind,
+      publisher: {
+        clientId: distribution.publisher.clientId,
+        healthy: distribution.publisher.healthy,
+        reasons: distribution.publisher.reasons,
+        bitrate: distribution.publisher.bitrate,
+        remoteFractionLost: distribution.publisher.remoteFractionLost,
+        qualityLimitationReason: distribution.publisher.qualityLimitationReason
+      },
+      receivers: distribution.numberOfReceivers,
+      degradedReceivers: distribution.numberOfDegradedReceivers,
+      degradedRatio: distribution.degradedRatio,
+      affectedClientIds: distribution.receivers.filter((r) => r.degraded).map((r) => r.clientId),
+      freezes: distribution.freezes,
+      plis: distribution.plis,
+      fractionLost: distribution.fractionLost,
+      bitrate: distribution.bitrate
+    };
+  }
+};
+
+// src/detectors/CallWideDegradationDetector.ts
+var CallWideDegradationTypes = {
+  /** Most participants degraded at once → shared cause (call/SFU/network), not individual endpoints. */
+  callWideQualityDegradation: "CALL_WIDE_QUALITY_DEGRADATION",
+  /** Most participants' **receiving** side degraded → downstream/egress suspected. */
+  callWideInboundDegradation: "CALL_WIDE_INBOUND_DEGRADATION",
+  /** Most participants' **sending** side degraded → ingress suspected. */
+  callWideOutboundDegradation: "CALL_WIDE_OUTBOUND_DEGRADATION"
+};
+var defaultConfig2 = {
+  minClients: 3,
+  degradedRatioThreshold: 0.5,
+  consecutiveTicks: 2
+};
+var CallWideDegradationDetector = class {
+  constructor(_call, config = {}) {
+    this._call = _call;
+    this._config = { ...defaultConfig2, ...config };
+    this._aggregator = new CallHealthAggregator(
+      _call,
+      { ...defaultClientHealthThresholds, ...config.thresholds }
+    );
+  }
+  _call;
+  name = "call-wide-degradation-detector";
+  _config;
+  _aggregator;
+  _streak;
+  /** The health rollup computed on the most recent `update()`. */
+  lastHealth;
+  update() {
+    const health = this._aggregator.aggregate();
+    this.lastHealth = health;
+    const type = this._classify(health);
+    if (!type) {
+      this._streak = void 0;
+      return;
+    }
+    const ticks = this._streak?.type === type ? this._streak.ticks + 1 : 1;
+    this._streak = { type, ticks };
+    if (ticks === this._config.consecutiveTicks) {
+      this._call.addIssue({
+        type,
+        timestamp: Date.now(),
+        payload: JSON.stringify(this._payload(health, type))
+      });
+    }
+  }
+  _classify(health) {
+    if (health.numberOfClients < this._config.minClients) return void 0;
+    const threshold = this._config.degradedRatioThreshold;
+    if (health.degradedRatio < threshold) return void 0;
+    if (threshold <= health.inboundDegradedRatio && health.outboundDegradedRatio < threshold) {
+      return CallWideDegradationTypes.callWideInboundDegradation;
+    }
+    if (threshold <= health.outboundDegradedRatio && health.inboundDegradedRatio < threshold) {
+      return CallWideDegradationTypes.callWideOutboundDegradation;
+    }
+    return CallWideDegradationTypes.callWideQualityDegradation;
+  }
+  _payload(health, type) {
+    return {
+      type,
+      callId: health.callId,
+      clients: health.numberOfClients,
+      degradedClients: health.numberOfDegradedClients,
+      degradedRatio: health.degradedRatio,
+      inboundDegradedRatio: health.inboundDegradedRatio,
+      outboundDegradedRatio: health.outboundDegradedRatio,
+      affectedClientIds: health.clients.filter((c) => c.degraded).map((c) => c.clientId),
+      rttInMs: health.rttInMs,
+      inboundFractionLost: health.inboundFractionLost,
+      concealmentRatio: health.concealmentRatio,
+      freezes: health.freezes,
+      qualityLimitation: health.qualityLimitation
+    };
+  }
+};
+
+// src/detectors/PliAndFreezeFanOutDetector.ts
+var PliAndFreezeFanOutTypes = {
+  /** Many receivers of the same publisher requested keyframes at once. */
+  publisherPliStorm: "PUBLISHER_PLI_STORM",
+  /** Many receivers of the same publisher froze at once. */
+  publishedVideoFrozenForMultipleReceivers: "PUBLISHED_VIDEO_FROZEN_FOR_MULTIPLE_RECEIVERS"
+};
+var defaultConfig3 = {
+  minReceivers: 3,
+  affectedRatioThreshold: 0.5,
+  windowMs: 1e4,
+  minPliCount: 5,
+  cooldownMs: 3e4
+};
+var PliAndFreezeFanOutDetector = class {
+  constructor(_call, config = {}) {
+    this._call = _call;
+    this._config = { ...defaultConfig3, ...config };
+    this._aggregator = new TrackDistributionAggregator(
+      _call,
+      { ...defaultReceiverHealthThresholds, ...config.thresholds }
+    );
+  }
+  _call;
+  name = "pli-and-freeze-fan-out-detector";
+  _config;
+  _aggregator;
+  _windows = /* @__PURE__ */ new Map();
+  update() {
+    const now = Date.now();
+    const distributions = this._aggregator.aggregate();
+    const seen = /* @__PURE__ */ new Set();
+    for (const distribution of distributions) {
+      seen.add(distribution.trackId);
+      const window = this._windowOf(distribution.trackId);
+      const pliReceivers = distribution.receivers.filter((r) => 0 < r.deltaPliCount);
+      const freezeReceivers = distribution.receivers.filter((r) => 0 < r.deltaFreezeCount);
+      if (0 < pliReceivers.length) {
+        window.pli.add({ receivers: pliReceivers.map((r) => r.clientId), count: distribution.plis.total }, now);
+      }
+      if (0 < freezeReceivers.length) {
+        window.freeze.add({ receivers: freezeReceivers.map((r) => r.clientId), count: distribution.freezes.total }, now);
+      }
+      if (distribution.numberOfReceivers < this._config.minReceivers) continue;
+      this._evaluate(distribution, window, now, "pli");
+      this._evaluate(distribution, window, now, "freeze");
+    }
+    for (const trackId of [...this._windows.keys()]) {
+      if (!seen.has(trackId)) this._windows.delete(trackId);
+    }
+  }
+  close() {
+    this._windows.clear();
+  }
+  _evaluate(distribution, window, now, kind) {
+    const samples = (kind === "pli" ? window.pli : window.freeze).values(now);
+    if (samples.length === 0) return;
+    const affected = /* @__PURE__ */ new Set();
+    let total = 0;
+    for (const sample of samples) {
+      for (const clientId of sample.receivers) affected.add(clientId);
+      total += sample.count;
+    }
+    const affectedRatio = affected.size / distribution.numberOfReceivers;
+    if (affectedRatio < this._config.affectedRatioThreshold) return;
+    if (kind === "pli" && total < this._config.minPliCount) return;
+    const type = kind === "pli" ? PliAndFreezeFanOutTypes.publisherPliStorm : PliAndFreezeFanOutTypes.publishedVideoFrozenForMultipleReceivers;
+    const lastRaisedAt = window.lastRaisedAt.get(type) ?? 0;
+    if (now - lastRaisedAt < this._config.cooldownMs) return;
+    window.lastRaisedAt.set(type, now);
+    this._call.addIssue({
+      type,
+      timestamp: now,
+      payload: JSON.stringify({
+        type,
+        trackId: distribution.trackId,
+        kind: distribution.kind,
+        publisherClientId: distribution.publisher.clientId,
+        publisherHealthy: distribution.publisher.healthy,
+        publisherReasons: distribution.publisher.reasons,
+        receivers: distribution.numberOfReceivers,
+        affectedReceivers: affected.size,
+        affectedRatio,
+        affectedClientIds: [...affected],
+        total,
+        windowMs: this._config.windowMs
+      })
+    });
+  }
+  _windowOf(trackId) {
+    let window = this._windows.get(trackId);
+    if (!window) {
+      window = {
+        pli: new SlidingWindow(this._config.windowMs),
+        freeze: new SlidingWindow(this._config.windowMs),
+        lastRaisedAt: /* @__PURE__ */ new Map()
+      };
+      this._windows.set(trackId, window);
+    }
+    return window;
+  }
+};
+
+// src/detectors/AudioImpairmentFanOutDetector.ts
+var AudioImpairmentFanOutTypes = {
+  /** Most receivers of one microphone are concealing audio → the problem follows that source. */
+  publishedAudioDegradedForMajority: "PUBLISHED_AUDIO_DEGRADED_FOR_MAJORITY",
+  /** Receivers across the call are under jitter-buffer pressure → shared delivery problem. */
+  callWideAudioJitterBufferStress: "CALL_WIDE_AUDIO_JITTER_BUFFER_STRESS"
+};
+var defaultConfig4 = {
+  minReceivers: 3,
+  affectedRatioThreshold: 0.6,
+  jitterBufferDelayInMs: 500,
+  minCallReceivers: 5,
+  consecutiveTicks: 2
+};
+var AudioImpairmentFanOutDetector = class {
+  constructor(_call, config = {}) {
+    this._call = _call;
+    this._config = { ...defaultConfig4, ...config };
+    this._aggregator = new TrackDistributionAggregator(
+      _call,
+      { ...defaultReceiverHealthThresholds, ...config.thresholds }
+    );
+  }
+  _call;
+  name = "audio-impairment-fan-out-detector";
+  _config;
+  _aggregator;
+  _trackStreaks = /* @__PURE__ */ new Map();
+  _callStreak = 0;
+  update() {
+    const now = Date.now();
+    const distributions = this._aggregator.aggregate().filter((d) => d.kind === "audio");
+    const seen = /* @__PURE__ */ new Set();
+    const callJitterBufferDelays = [];
+    let stressedReceivers = 0;
+    let totalReceivers = 0;
+    for (const distribution of distributions) {
+      seen.add(distribution.trackId);
+      for (const receiver of distribution.receivers) {
+        totalReceivers += 1;
+        if (receiver.jitterBufferDelayInMs !== void 0) {
+          callJitterBufferDelays.push(receiver.jitterBufferDelayInMs);
+          if (this._config.jitterBufferDelayInMs < receiver.jitterBufferDelayInMs) stressedReceivers += 1;
+        }
+      }
+      if (distribution.numberOfReceivers < this._config.minReceivers) {
+        this._trackStreaks.delete(distribution.trackId);
+        continue;
+      }
+      const affectedRatio = distribution.concealment.affectedReceivers / distribution.numberOfReceivers;
+      if (affectedRatio < this._config.affectedRatioThreshold) {
+        this._trackStreaks.delete(distribution.trackId);
+        continue;
+      }
+      const ticks = (this._trackStreaks.get(distribution.trackId) ?? 0) + 1;
+      this._trackStreaks.set(distribution.trackId, ticks);
+      if (ticks === this._config.consecutiveTicks) {
+        this._call.addIssue({
+          type: AudioImpairmentFanOutTypes.publishedAudioDegradedForMajority,
+          timestamp: now,
+          payload: JSON.stringify({
+            type: AudioImpairmentFanOutTypes.publishedAudioDegradedForMajority,
+            trackId: distribution.trackId,
+            publisherClientId: distribution.publisher.clientId,
+            publisherHealthy: distribution.publisher.healthy,
+            receivers: distribution.numberOfReceivers,
+            affectedReceivers: distribution.concealment.affectedReceivers,
+            affectedRatio,
+            concealmentRatio: distribution.concealmentRatio,
+            jitterBufferDelayInMs: distribution.jitterBufferDelayInMs,
+            affectedClientIds: distribution.receivers.filter((r) => this._aggregator.thresholds.concealmentRatio <= (r.concealmentRatio ?? 0)).map((r) => r.clientId)
+          })
+        });
+      }
+    }
+    for (const trackId of [...this._trackStreaks.keys()]) {
+      if (!seen.has(trackId)) this._trackStreaks.delete(trackId);
+    }
+    this._evaluateCallWide(now, totalReceivers, stressedReceivers, callJitterBufferDelays);
+  }
+  close() {
+    this._trackStreaks.clear();
+    this._callStreak = 0;
+  }
+  _evaluateCallWide(now, totalReceivers, stressedReceivers, delays) {
+    if (totalReceivers < this._config.minCallReceivers) {
+      this._callStreak = 0;
+      return;
+    }
+    const stressedRatio = stressedReceivers / totalReceivers;
+    if (stressedRatio < this._config.affectedRatioThreshold) {
+      this._callStreak = 0;
+      return;
+    }
+    this._callStreak += 1;
+    if (this._callStreak !== this._config.consecutiveTicks) return;
+    this._call.addIssue({
+      type: AudioImpairmentFanOutTypes.callWideAudioJitterBufferStress,
+      timestamp: now,
+      payload: JSON.stringify({
+        type: AudioImpairmentFanOutTypes.callWideAudioJitterBufferStress,
+        callId: this._call.callId,
+        audioReceivers: totalReceivers,
+        stressedReceivers,
+        stressedRatio,
+        jitterBufferDelayInMs: {
+          median: percentile(delays, 0.5),
+          p95: percentile(delays, 0.95)
+        }
+      })
+    });
+  }
+};
+
+// src/detectors/IceDisruptionDetector.ts
+var IceDisruptionTypes = {
+  /** Many participants lost/failed their ICE connection inside the same window. */
+  callIceDisruption: "CALL_ICE_DISRUPTION"
+};
+var defaultConfig5 = {
+  minClients: 3,
+  affectedRatioThreshold: 0.5,
+  windowMs: 1e4,
+  cooldownMs: 6e4
+};
+var disruptedStates = /* @__PURE__ */ new Set(["disconnected", "failed"]);
+var IceDisruptionDetector = class {
+  constructor(_call, config = {}) {
+    this._call = _call;
+    this._config = { ...defaultConfig5, ...config };
+    this._disruptions = new SlidingWindow(this._config.windowMs);
+    const record = ({ observedCall, observedClient, state }) => {
+      if (observedCall !== this._call) return;
+      if (!disruptedStates.has(state)) return;
+      this._disruptions.add(observedClient.clientId);
+    };
+    this._onIceStateChanged = record;
+    this._onConnectionStateChanged = record;
+    _call.observer.on("ice-connection-state-changed", this._onIceStateChanged);
+    _call.observer.on("connection-state-changed", this._onConnectionStateChanged);
+  }
+  _call;
+  name = "ice-disruption-detector";
+  _config;
+  /** clientId -> the last time that client was seen disrupted, inside the window. */
+  _disruptions;
+  _lastRaisedAt = 0;
+  _onIceStateChanged;
+  _onConnectionStateChanged;
+  update() {
+    const now = Date.now();
+    const affected = new Set(this._disruptions.values(now));
+    const numberOfClients = this._call.observedClients.size;
+    if (numberOfClients < this._config.minClients) return;
+    if (affected.size === 0) return;
+    const affectedRatio = affected.size / numberOfClients;
+    if (affectedRatio < this._config.affectedRatioThreshold) return;
+    if (now - this._lastRaisedAt < this._config.cooldownMs) return;
+    this._lastRaisedAt = now;
+    this._call.addIssue({
+      type: IceDisruptionTypes.callIceDisruption,
+      timestamp: now,
+      payload: JSON.stringify({
+        type: IceDisruptionTypes.callIceDisruption,
+        callId: this._call.callId,
+        clients: numberOfClients,
+        affectedClients: affected.size,
+        affectedRatio,
+        affectedClientIds: [...affected],
+        windowMs: this._config.windowMs
+      })
+    });
+  }
+  close() {
+    this._call.observer.off("ice-connection-state-changed", this._onIceStateChanged);
+    this._call.observer.off("connection-state-changed", this._onConnectionStateChanged);
+    this._disruptions.clear();
+  }
+};
+
+// src/detectors/TurnServerHealthDetector.ts
+var TurnServerHealthTypes = {
+  /** One TURN server's clients are degraded while other servers' clients are fine. */
+  turnServerDegraded: "TURN_SERVER_DEGRADED"
+};
+var defaultConfig6 = {
+  minClientsPerServer: 5,
+  degradedRatioThreshold: 0.5,
+  rttInMs: 400,
+  fractionLost: 0.03,
+  consecutiveTicks: 2,
+  cooldownMs: 6e4
+};
+var TurnServerHealthDetector = class {
+  constructor(_observer, config = {}) {
+    this._observer = _observer;
+    this._config = { ...defaultConfig6, ...config };
+  }
+  _observer;
+  name = "turn-server-health-detector";
+  _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();
+    this.lastServers = [...this._observer.observedTURN.servers].map(([serverUrl, server]) => this._serverHealth(serverUrl, server.observedPeerConnections));
+    for (const health of this.lastServers) {
+      const serverUrl = health.serverUrl;
+      if (health.peerConnections < this._config.minClientsPerServer) {
+        this._streaks.delete(serverUrl);
+        continue;
+      }
+      if (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 peers = this.lastServers.filter((s) => s.serverUrl !== serverUrl).map((s) => ({ serverUrl: s.serverUrl, peerConnections: s.peerConnections, degradedRatio: s.degradedRatio }));
+      this._observer.addIssue({
+        type: TurnServerHealthTypes.turnServerDegraded,
+        timestamp: now,
+        payload: JSON.stringify({ type: TurnServerHealthTypes.turnServerDegraded, ...health, otherServers: peers })
+      });
+    }
+    for (const serverUrl of [...this._streaks.keys()]) {
+      if (!this.lastServers.some((s) => s.serverUrl === serverUrl)) this._streaks.delete(serverUrl);
+    }
+  }
+  close() {
+    this._streaks.clear();
+    this._lastRaisedAt.clear();
+  }
+  _serverHealth(serverUrl, peerConnections) {
+    const rtts = [];
+    const losses = [];
+    const affectedClientIds = /* @__PURE__ */ new Set();
+    let degraded = 0;
+    for (const peerConnection of peerConnections.values()) {
+      const rttInMs = peerConnection.currentRttInMs;
+      let lostPackets = 0;
+      let receivedPackets = 0;
+      for (const rtp of peerConnection.observedInboundRtps.values()) {
+        lostPackets += rtp.deltaLostPackets;
+        receivedPackets += rtp.deltaReceivedPackets;
+      }
+      const total = lostPackets + receivedPackets;
+      const fractionLost = 0 < total ? lostPackets / total : void 0;
+      if (rttInMs !== void 0) rtts.push(rttInMs);
+      if (fractionLost !== void 0) losses.push(fractionLost);
+      if (this._config.rttInMs < (rttInMs ?? 0) || this._config.fractionLost < (fractionLost ?? 0)) {
+        degraded += 1;
+        affectedClientIds.add(peerConnection.client.clientId);
+      }
+    }
+    const count = peerConnections.size;
+    return {
+      serverUrl,
+      peerConnections: count,
+      degradedPeerConnections: degraded,
+      degradedRatio: 0 < count ? degraded / count : 0,
+      rttInMs: summarize(rtts),
+      fractionLost: summarize(losses),
+      affectedClientIds: [...affectedClientIds]
+    };
+  }
+};
+
+// src/utils/IssueRegistry.ts
+var defaultConfig7 = {
+  maxIssueAgeInMs: 12e4
+};
+var IssueRegistry = class {
+  constructor(_source, config = {}) {
+    this._source = _source;
+    this._config = { ...defaultConfig7, ...config };
+  }
+  _source;
+  _config;
+  /** Every open issue in scope, with stale entries filtered out. */
+  activeIssues(now = Date.now()) {
+    const result = [];
+    for (const client of this._clients()) {
+      for (const issue of client.activeIssues.values()) {
+        if (this._config.maxIssueAgeInMs < now - issue.observedAt) continue;
+        result.push(issue);
+      }
+    }
+    return result;
+  }
+  /** The number of clients in scope — the denominator for every ratio. */
+  get totalClients() {
+    let count = 0;
+    for (const client of this._clients()) count += 1;
+    return count;
+  }
+  /** The cohort for one issue type (empty `issues` when nobody has it open). */
+  cohortOf(type, now = Date.now()) {
+    return this._toCohort(type, this.activeIssues(now).filter((issue) => issue.type === type));
+  }
+  /** One cohort per issue type currently open somewhere in scope, largest first. */
+  cohorts(now = Date.now()) {
+    const byType = /* @__PURE__ */ new Map();
+    for (const issue of this.activeIssues(now)) {
+      const list = byType.get(issue.type);
+      if (list) list.push(issue);
+      else byType.set(issue.type, [issue]);
+    }
+    return [...byType.entries()].map(([type, issues]) => this._toCohort(type, issues)).sort((a, b) => b.clientIds.length - a.clientIds.length);
+  }
+  /**
+   * Open issues attributed to any of the given track ids — the join that turns a receiver-side
+   * issue into a statement about a **published** track (`trackId` → inbound track →
+   * `remoteOutboundTrack` → publisher).
+   */
+  byTrackIds(trackIds, now = Date.now()) {
+    const wanted = new Set(trackIds);
+    return this.activeIssues(now).filter((issue) => issue.trackId !== void 0 && wanted.has(issue.trackId));
+  }
+  /** Open issues reported by one client. */
+  byClientId(clientId, now = Date.now()) {
+    return this.activeIssues(now).filter((issue) => issue.clientId === clientId);
+  }
+  _toCohort(type, issues) {
+    const clientIds = [...new Set(issues.map((issue) => issue.clientId))];
+    const onsets = issues.map((issue) => issue.observedAt);
+    const totalClients = this.totalClients;
+    return {
+      type,
+      issues,
+      clientIds,
+      totalClients,
+      affectedRatio: 0 < totalClients ? clientIds.length / totalClients : 0,
+      onsetSpreadInMs: 0 < onsets.length ? Math.max(...onsets) - Math.min(...onsets) : 0,
+      firstObservedAt: 0 < onsets.length ? Math.min(...onsets) : 0
+    };
+  }
+  /** Works for both scopes: a call yields its clients, an observer yields every call's clients. */
+  *_clients() {
+    const source = this._source;
+    if (source.observedClients) {
+      yield* source.observedClients.values();
+    } else if (source.observedCalls) {
+      for (const call of source.observedCalls.values()) yield* call.observedClients.values();
+    }
+  }
+};
+
+// src/detectors/ConcurrentIssueDetector.ts
+var ConcurrentIssueTypes = {
+  /** Several participants have the same issue open **at the same time**. */
+  concurrentClientIssues: "CONCURRENT_CLIENT_ISSUES",
+  /** Those issues also *began* together — the signature of one infrastructure event. */
+  issueOnsetBurst: "ISSUE_ONSET_BURST"
+};
+var defaultConfig8 = {
+  issueTypes: [],
+  minClients: 3,
+  minAffectedClients: 3,
+  affectedRatioThreshold: 0.5,
+  onsetBurstWindowInMs: 2e3,
+  cooldownMs: 6e4
+};
+var ConcurrentIssueDetector = class {
+  constructor(_scope, config = {}) {
+    this._scope = _scope;
+    this._config = { ...defaultConfig8, ...config };
+    this._registry = new IssueRegistry(_scope, config.registry);
+    this._isObserverScope = _scope.observedCalls !== void 0;
+  }
+  _scope;
+  name = "concurrent-issue-detector";
+  _config;
+  _registry;
+  _lastRaisedAt = /* @__PURE__ */ new Map();
+  _isObserverScope;
+  /** The cohorts that qualified on the most recent `update()`. */
+  lastCohorts = [];
+  update() {
+    const now = Date.now();
+    const wanted = new Set(this._config.issueTypes);
+    const cohorts = this._registry.cohorts(now).filter((cohort) => wanted.size === 0 || wanted.has(cohort.type));
+    this.lastCohorts = [];
+    if (this._registry.totalClients < this._config.minClients) return;
+    for (const cohort of cohorts) {
+      if (cohort.clientIds.length < this._config.minAffectedClients) continue;
+      if (cohort.affectedRatio < this._config.affectedRatioThreshold) continue;
+      this.lastCohorts.push(cohort);
+      if (now - (this._lastRaisedAt.get(cohort.type) ?? 0) < this._config.cooldownMs) continue;
+      this._lastRaisedAt.set(cohort.type, now);
+      const burst = cohort.onsetSpreadInMs <= this._config.onsetBurstWindowInMs;
+      const type = burst ? ConcurrentIssueTypes.issueOnsetBurst : ConcurrentIssueTypes.concurrentClientIssues;
+      this._raise(type, {
+        type,
+        issueType: cohort.type,
+        scope: this._isObserverScope ? "observer" : "call",
+        clients: cohort.totalClients,
+        affectedClients: cohort.clientIds.length,
+        affectedRatio: cohort.affectedRatio,
+        affectedClientIds: cohort.clientIds,
+        onsetSpreadInMs: cohort.onsetSpreadInMs,
+        onsetBurst: burst,
+        firstObservedAt: cohort.firstObservedAt
+      }, now);
+    }
+  }
+  close() {
+    this._lastRaisedAt.clear();
+    this.lastCohorts = [];
+  }
+  _raise(type, payload, now) {
+    this._scope.addIssue({ type, timestamp: now, payload: JSON.stringify(payload) });
+  }
+};
+
+// 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 defaultConfig9 = {
+  issueTypes: [],
+  minReceivers: 3,
+  affectedRatioThreshold: 0.6,
+  reportSingleReceiver: true,
+  cooldownMs: 6e4
+};
+var IssueFanOutDetector = class {
+  constructor(_call, config = {}) {
+    this._call = _call;
+    this._config = { ...defaultConfig9, ...config };
+    this._registry = new IssueRegistry(_call, config.registry);
+    this._aggregator = new TrackDistributionAggregator(_call);
+  }
+  _call;
+  name = "issue-fan-out-detector";
+  _config;
+  _registry;
+  _aggregator;
+  _lastRaisedAt = /* @__PURE__ */ new Map();
+  update() {
+    const now = Date.now();
+    const wanted = new Set(this._config.issueTypes);
+    for (const distribution of this._aggregator.aggregate()) {
+      const receiverTrackIds = /* @__PURE__ */ new Map();
+      for (const receiver of distribution.receivers) {
+        receiverTrackIds.set(receiver.observedInboundTrack.id, receiver.clientId);
+      }
+      const issues = this._registry.byTrackIds(receiverTrackIds.keys(), now).filter((issue) => wanted.size === 0 || wanted.has(issue.type));
+      if (issues.length === 0) continue;
+      const byType = /* @__PURE__ */ new Map();
+      for (const issue of issues) {
+        const clientIds = byType.get(issue.type) ?? /* @__PURE__ */ new Set();
+        clientIds.add(issue.clientId);
+        byType.set(issue.type, clientIds);
+      }
+      for (const [issueType, clientIds] of byType) {
+        const affectedRatio = clientIds.size / distribution.numberOfReceivers;
+        const isFanOut = this._config.minReceivers <= distribution.numberOfReceivers && this._config.affectedRatioThreshold <= affectedRatio;
+        const isSingle = this._config.reportSingleReceiver && clientIds.size === 1 && 1 < distribution.numberOfReceivers;
+        if (!isFanOut && !isSingle) continue;
+        const key = `${distribution.trackId}:${issueType}`;
+        if (now - (this._lastRaisedAt.get(key) ?? 0) < this._config.cooldownMs) continue;
+        this._lastRaisedAt.set(key, now);
+        const type = isFanOut ? IssueFanOutTypes.publishedTrackIssueFanOut : IssueFanOutTypes.singleReceiverIssue;
+        this._call.addIssue({
+          type,
+          timestamp: now,
+          payload: JSON.stringify({
+            type,
+            issueType,
+            trackId: distribution.trackId,
+            kind: distribution.kind,
+            publisherClientId: distribution.publisher.clientId,
+            // The corroborating half: if the source's own egress is clean while its
+            // receivers are not, the SFU/forwarding path is implicated rather than the sender.
+            publisherHealthy: distribution.publisher.healthy,
+            publisherReasons: distribution.publisher.reasons,
+            receivers: distribution.numberOfReceivers,
+            affectedReceivers: clientIds.size,
+            affectedRatio,
+            affectedClientIds: [...clientIds],
+            // metric evidence alongside the client's verdict
+            fractionLost: distribution.fractionLost,
+            bitrate: distribution.bitrate,
+            freezes: distribution.freezes,
+            plis: distribution.plis
+          })
+        });
+      }
+    }
+  }
+  close() {
+    this._lastRaisedAt.clear();
+  }
+  /** Exposed for tests/dashboards: the distributions this detector reasons over. */
+  distributionsOf() {
+    return this._aggregator.aggregate().map((d) => d.publisher.observedOutboundTrack);
+  }
+};
+
+// src/detectors/WorstReceiverContagionDetector.ts
+var WorstReceiverContagionTypes = {
+  /**
+   * A publisher's sending bitrate is tracking its **worst** receiver — one bad downlink is
+   * dragging the quality everyone else gets.
+   */
+  worstReceiverContagion: "WORST_RECEIVER_CONTAGION"
+};
+var defaultConfig10 = {
+  minReceivers: 3,
+  windowMs: 3e4,
+  minSamples: 4,
+  trackingRatioThreshold: 0.75,
+  outlierRatioThreshold: 0.5,
+  cooldownMs: 12e4
+};
+var WorstReceiverContagionDetector = class {
+  constructor(_call, config = {}) {
+    this._call = _call;
+    this._config = { ...defaultConfig10, ...config };
+    this._aggregator = new TrackDistributionAggregator(_call);
+  }
+  _call;
+  name = "worst-receiver-contagion-detector";
+  _config;
+  _aggregator;
+  _windows = /* @__PURE__ */ new Map();
+  _lastRaisedAt = /* @__PURE__ */ new Map();
+  update() {
+    const now = Date.now();
+    const seen = /* @__PURE__ */ new Set();
+    for (const distribution of this._aggregator.aggregate()) {
+      seen.add(distribution.trackId);
+      if (distribution.numberOfReceivers < this._config.minReceivers) continue;
+      if (distribution.publisher.bitrate <= 0) continue;
+      const receiverBitrates = distribution.receivers.map((r) => r.bitrate).filter((b) => 0 < b);
+      if (receiverBitrates.length < this._config.minReceivers) continue;
+      const worst = Math.min(...receiverBitrates);
+      const median2 = percentile(receiverBitrates, 0.5) ?? worst;
+      const window = this._windowOf(distribution.trackId);
+      window.add({ publisherBitrate: distribution.publisher.bitrate, worstReceiverBitrate: worst, medianReceiverBitrate: median2 }, now);
+      const samples = window.values(now);
+      if (samples.length < this._config.minSamples) continue;
+      const latest = samples[samples.length - 1];
+      const outlierRatio = 0 < latest.medianReceiverBitrate ? latest.worstReceiverBitrate / latest.medianReceiverBitrate : 1;
+      if (this._config.outlierRatioThreshold < outlierRatio) continue;
+      const tracking = correlation(
+        samples.map((s) => s.publisherBitrate),
+        samples.map((s) => s.worstReceiverBitrate)
+      );
+      const medianTracking = correlation(
+        samples.map((s) => s.publisherBitrate),
+        samples.map((s) => s.medianReceiverBitrate)
+      );
+      if (tracking < this._config.trackingRatioThreshold) continue;
+      if (tracking <= medianTracking) continue;
+      if (now - (this._lastRaisedAt.get(distribution.trackId) ?? 0) < this._config.cooldownMs) continue;
+      this._lastRaisedAt.set(distribution.trackId, now);
+      const worstReceiver = distribution.receivers.reduce((a, b) => a.bitrate <= b.bitrate ? a : b);
+      this._call.addIssue({
+        type: WorstReceiverContagionTypes.worstReceiverContagion,
+        timestamp: now,
+        payload: JSON.stringify({
+          type: WorstReceiverContagionTypes.worstReceiverContagion,
+          trackId: distribution.trackId,
+          kind: distribution.kind,
+          publisherClientId: distribution.publisher.clientId,
+          publisherBitrate: distribution.publisher.bitrate,
+          worstReceiverClientId: worstReceiver.clientId,
+          worstReceiverBitrate: latest.worstReceiverBitrate,
+          medianReceiverBitrate: latest.medianReceiverBitrate,
+          outlierRatio,
+          trackingWithWorst: tracking,
+          trackingWithMedian: medianTracking,
+          receivers: distribution.numberOfReceivers,
+          windowMs: this._config.windowMs,
+          samples: samples.length
+        })
+      });
+    }
+    for (const trackId of [...this._windows.keys()]) {
+      if (!seen.has(trackId)) this._windows.delete(trackId);
+    }
+  }
+  close() {
+    this._windows.clear();
+    this._lastRaisedAt.clear();
+  }
+  _windowOf(trackId) {
+    let window = this._windows.get(trackId);
+    if (!window) {
+      window = new SlidingWindow(this._config.windowMs);
+      this._windows.set(trackId, window);
+    }
+    return window;
+  }
+};
+function correlation(xs, ys) {
+  const n = Math.min(xs.length, ys.length);
+  if (n < 2) return 0;
+  const meanX = xs.reduce((s, v) => s + v, 0) / n;
+  const meanY = ys.reduce((s, v) => s + v, 0) / 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));
+}
+
+// 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 defaultConfig11 = {
+  dryInboundIssueType: "dry-inbound-track",
+  dryOutboundIssueType: "dry-outbound-track",
+  minReceivers: 2,
+  allReceiversRatio: 1,
+  cooldownMs: 6e4
+};
+var TrackDeliveryMismatchDetector = class {
+  constructor(_call, config = {}) {
+    this._call = _call;
+    this._config = { ...defaultConfig11, ...config };
+    this._registry = new IssueRegistry(_call, config.registry);
+    this._aggregator = new TrackDistributionAggregator(_call);
+  }
+  _call;
+  name = "track-delivery-mismatch-detector";
+  _config;
+  _registry;
+  _aggregator;
+  _lastRaisedAt = /* @__PURE__ */ new Map();
+  update() {
+    const now = Date.now();
+    for (const distribution of this._aggregator.aggregate()) {
+      if (distribution.numberOfReceivers < this._config.minReceivers) continue;
+      const receiverTrackIds = new Set(distribution.receivers.map((r) => r.observedInboundTrack.id));
+      const dryReceiverIds = new Set(
+        this._registry.byTrackIds(receiverTrackIds, now).filter((issue) => issue.type === this._config.dryInboundIssueType).map((issue) => issue.clientId)
+      );
+      if (dryReceiverIds.size === 0) continue;
+      const publisherDryIssue = this._registry.byClientId(distribution.publisher.clientId, now).some((issue) => issue.type === this._config.dryOutboundIssueType && (issue.trackId === void 0 || issue.trackId === distribution.trackId));
+      const publisherSending = !publisherDryIssue && 0 < distribution.publisher.deltaPacketsSent;
+      const dryRatio = dryReceiverIds.size / distribution.numberOfReceivers;
+      let type;
+      if (!publisherSending) {
+        type = TrackDeliveryMismatchTypes.publisherTrackDry;
+      } else if (this._config.allReceiversRatio <= dryRatio) {
+        type = TrackDeliveryMismatchTypes.publishedTrackNotDelivered;
+      } else {
+        type = TrackDeliveryMismatchTypes.receiverTrackNotDelivered;
+      }
+      const key = `${distribution.trackId}:${type}`;
+      if (now - (this._lastRaisedAt.get(key) ?? 0) < this._config.cooldownMs) continue;
+      this._lastRaisedAt.set(key, now);
+      this._call.addIssue({
+        type,
+        timestamp: now,
+        payload: JSON.stringify({
+          type,
+          trackId: distribution.trackId,
+          kind: distribution.kind,
+          publisherClientId: distribution.publisher.clientId,
+          publisherSending,
+          publisherDryIssue,
+          publisherBitrate: distribution.publisher.bitrate,
+          publisherDeltaPacketsSent: distribution.publisher.deltaPacketsSent,
+          receivers: distribution.numberOfReceivers,
+          dryReceivers: dryReceiverIds.size,
+          dryRatio,
+          dryClientIds: [...dryReceiverIds],
+          healthyClientIds: distribution.receivers.map((r) => r.clientId).filter((clientId) => !dryReceiverIds.has(clientId))
+        })
+      });
+    }
+  }
+  close() {
+    this._lastRaisedAt.clear();
+  }
+};
+
+// 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 defaultConfig12 = {
+  minUnconsumedDurationInMs: 3e4,
+  minBitrate: 5e4,
+  cooldownMs: 3e5
+};
+var UnconsumedTrackDetector = class {
+  constructor(_call, config = {}) {
+    this._call = _call;
+    this._config = { ...defaultConfig12, ...config };
+  }
+  _call;
+  name = "unconsumed-track-detector";
+  _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 now = Date.now();
+    const seen = /* @__PURE__ */ new Set();
+    for (const client of this._call.observedClients.values()) {
+      for (const peerConnection of client.observedPeerConnections.values()) {
+        for (const outboundTrack of peerConnection.observedOutboundTracks.values()) {
+          const rtps = outboundTrack.getOutboundRtps() ?? [];
+          const bitrate = rtps.reduce((sum, rtp) => sum + rtp.bitrate, 0);
+          const sending = rtps.some((rtp) => 0 < rtp.deltaPacketsSent);
+          const consumed = 0 < outboundTrack.remoteInboundTracks.size;
+          seen.add(outboundTrack.id);
+          if (consumed || !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);
+          this._call.addIssue({
+            type: UnconsumedTrackTypes.unconsumedPublishedTrack,
+            timestamp: now,
+            payload: JSON.stringify({
+              type: UnconsumedTrackTypes.unconsumedPublishedTrack,
+              trackId: outboundTrack.id,
+              kind: outboundTrack.kind,
+              publisherClientId: 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);
+    }
+  }
+  close() {
+    this._unconsumedSince.clear();
+    this._lastRaisedAt.clear();
+  }
+};
+
 // src/sinks/ClientSampleSink.ts
 import { EventEmitter as EventEmitter7 } from "events";
 var ClientSampleSink = class extends EventEmitter7 {
@@ -3915,11 +5736,25 @@ function createP2pRemoteTrackResolverFactory() {
   });
 }
 export {
+  AudioImpairmentFanOutDetector,
+  AudioImpairmentFanOutTypes,
+  CallHealthAggregator,
+  CallWideDegradationDetector,
+  CallWideDegradationTypes,
   ClientEventTypes,
   ClientMetaTypes,
   ClientSampleSink,
+  CommonSourceDegradationDetector,
+  CommonSourceDegradationTypes,
+  ConcurrentIssueDetector,
+  ConcurrentIssueTypes,
   Detectors,
+  IceDisruptionDetector,
+  IceDisruptionTypes,
   InMemorySink,
+  IssueFanOutDetector,
+  IssueFanOutTypes,
+  IssueRegistry,
   JsonlFileSink,
   ObservedCall,
   ObservedCertificate,
@@ -3941,13 +5776,35 @@ export {
   ObservedRemoteInboundRtp,
   ObservedRemoteOutboundRtp,
   Observer,
+  PliAndFreezeFanOutDetector,
+  PliAndFreezeFanOutTypes,
+  RESOLVED_ISSUE_SUFFIX,
   RemoteTrackResolver,
+  SlidingWindow,
+  TrackDeliveryMismatchDetector,
+  TrackDeliveryMismatchTypes,
+  TrackDistributionAggregator,
+  TurnServerHealthDetector,
+  TurnServerHealthTypes,
+  UnconsumedTrackDetector,
+  UnconsumedTrackTypes,
+  WorstReceiverContagionDetector,
+  WorstReceiverContagionTypes,
+  baseIssueType,
+  counterDelta,
   createDefaultMediasoupRemoteTrackResolverFactory,
   createInMemorySink,
   createJsonlFileSink,
   createJsonlFileSinkFactory,
   createLogger,
   createP2pRemoteTrackResolverFactory,
-  setObserverLogger
+  defaultClientHealthThresholds,
+  defaultReceiverHealthThresholds,
+  isResolutionEntry,
+  median,
+  parseIssuePayload,
+  percentile,
+  setObserverLogger,
+  summarize
 };
 //# sourceMappingURL=index.mjs.map