@observertc/observer-js 1.1.0 → 1.2.0

package/dist/index.mjs

@@ -103,6 +103,10 @@ function counterDelta(previous, current) {
   if (current < previous) return 0;
   return current - previous;
 }
+function rmsAudioLevel(deltaTotalAudioEnergy, deltaTotalSamplesDuration) {
+  if (!(0 < deltaTotalSamplesDuration)) return void 0;
+  return Math.sqrt(Math.max(0, deltaTotalAudioEnergy) / deltaTotalSamplesDuration);
+}
 function correlation(xs, ys) {
   const n = Math.min(xs.length, ys.length);
   if (n < 2) return 0;
@@ -135,8 +139,8 @@ function pageHinkley(values, delta = 0, lambda = 50) {
   let runningMinimum = 0;
   for (let i = 0; i < values.length; i++) {
     sum += values[i];
-    const mean = sum / (i + 1);
-    cumulative += values[i] - mean - delta;
+    const mean2 = sum / (i + 1);
+    cumulative += values[i] - mean2 - delta;
     if (cumulative < runningMinimum) runningMinimum = cumulative;
     const ph = cumulative - runningMinimum;
     statistic.push(ph);
@@ -188,6 +192,24 @@ function erf(x) {
   const y = 1 - ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t * Math.exp(-(ax * ax));
   return sign * y;
 }
+function percentileOfHistogram(histogram, bucketWidth, p, options = {}) {
+  let total = 0;
+  for (const count of histogram) total += count;
+  if (total < 1) return void 0;
+  const rank = Math.min(Math.max(p, 0), 1) * total;
+  let cumulative = 0;
+  for (let index = 0; index < histogram.length; ++index) {
+    const count = histogram[index];
+    if (count < 1 || cumulative + count < rank) {
+      cumulative += count;
+      continue;
+    }
+    if (options.openEnded && index === histogram.length - 1 && options.max !== void 0) return options.max;
+    const estimate = index * bucketWidth + (rank - cumulative) / count * bucketWidth;
+    return Math.min(Math.max(estimate, options.min ?? estimate), options.max ?? estimate);
+  }
+  return options.max;
+}
 
 // src/ObservedInboundRtp.ts
 var ObservedInboundRtp = class {
@@ -298,6 +320,15 @@ var ObservedInboundRtp = class {
   deltaFecPacketsReceived = 0;
   deltaFecPacketsDiscarded = 0;
   deltaPausesDuration = 0;
+  deltaTotalAudioEnergy = 0;
+  deltaTotalSamplesDuration = 0;
+  /**
+   * RMS level (0..1) of the audio played out from this stream over the tick, from the two deltas
+   * above. This is the far end's outgoing level **as this receiver heard it**, which is the only
+   * send-side level available for publishers on browsers that do not report `media-source` audio
+   * levels (Firefox). `undefined` for video and for a tick with no audio accounted for.
+   */
+  rmsAudioLevel;
   /**
    * 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
@@ -383,6 +414,9 @@ var ObservedInboundRtp = class {
     this.jitterBufferDelayInMs = void 0;
     this.concealmentRatio = void 0;
     this.framesDroppedRatio = void 0;
+    this.deltaTotalAudioEnergy = 0;
+    this.deltaTotalSamplesDuration = 0;
+    this.rmsAudioLevel = void 0;
     const elapsedTimeInMs = stats.timestamp - this.timestamp;
     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) {
@@ -412,6 +446,9 @@ var ObservedInboundRtp = class {
       this.deltaRetransmittedPacketsReceived = counterDelta(this.retransmittedPacketsReceived, stats.retransmittedPacketsReceived);
       this.deltaFecPacketsReceived = counterDelta(this.fecPacketsReceived, stats.fecPacketsReceived);
       this.deltaFecPacketsDiscarded = counterDelta(this.fecPacketsDiscarded, stats.fecPacketsDiscarded);
+      this.deltaTotalAudioEnergy = counterDelta(this.totalAudioEnergy, stats.totalAudioEnergy);
+      this.deltaTotalSamplesDuration = counterDelta(this.totalSamplesDuration, stats.totalSamplesDuration);
+      this.rmsAudioLevel = rmsAudioLevel(this.deltaTotalAudioEnergy, this.deltaTotalSamplesDuration);
       this.bitrate = this.deltaBytesReceived * 8 / elapsedInSeconds;
       const pixels = (stats.frameWidth ?? 0) * (stats.frameHeight ?? 0);
       if (0 < pixels && 0 < this.deltaFramesReceived) {
@@ -469,6 +506,9 @@ var ObservedInboundRtp = class {
     this.jitterBufferEmittedCount = stats.jitterBufferEmittedCount;
     this.jitterBufferMinimumDelay = stats.jitterBufferMinimumDelay;
     this.totalSamplesReceived = stats.totalSamplesReceived;
+    this.audioLevel = stats.audioLevel;
+    this.totalAudioEnergy = stats.totalAudioEnergy;
+    this.totalSamplesDuration = stats.totalSamplesDuration;
     this.concealedSamples = stats.concealedSamples;
     this.silentConcealedSamples = stats.silentConcealedSamples;
     this.concealmentEvents = stats.concealmentEvents;
@@ -1123,6 +1163,16 @@ var ObservedMediaSource = class {
   frames;
   framesPerSecond;
   attachments;
+  /** Increase of `totalAudioEnergy` in this tick (audio only). */
+  deltaTotalAudioEnergy = 0;
+  /** Increase of `totalSamplesDuration` in this tick, in seconds (audio only). */
+  deltaTotalSamplesDuration = 0;
+  /**
+   * RMS level (0..1) of what the capture device delivered over the tick, after the browser's own
+   * processing (AEC, NS, AGC). Chrome and Safari report the inputs; Firefox does not, and there the
+   * publisher's level has to come from its receivers — see `ObservedOutboundTrack.rmsAudioLevel`.
+   */
+  rmsAudioLevel;
   get visited() {
     const visited = this._visited;
     this._visited = false;
@@ -1136,6 +1186,14 @@ var ObservedMediaSource = class {
   }
   update(stats) {
     this._visited = true;
+    this.deltaTotalAudioEnergy = 0;
+    this.deltaTotalSamplesDuration = 0;
+    this.rmsAudioLevel = void 0;
+    if (this.timestamp < stats.timestamp) {
+      this.deltaTotalAudioEnergy = counterDelta(this.totalAudioEnergy, stats.totalAudioEnergy);
+      this.deltaTotalSamplesDuration = counterDelta(this.totalSamplesDuration, stats.totalSamplesDuration);
+      this.rmsAudioLevel = rmsAudioLevel(this.deltaTotalAudioEnergy, this.deltaTotalSamplesDuration);
+    }
     this.timestamp = stats.timestamp;
     this.trackIdentifier = stats.trackIdentifier;
     this.audioLevel = stats.audioLevel;
@@ -1534,6 +1592,20 @@ var ObservedOutboundTrack = class {
   remoteFractionLost;
   remoteRttInMs;
   qualityLimitationReason;
+  /**
+   * This audio track's RMS level (0..1) over the latest tick — how loud the publisher was sending.
+   * Taken from the publisher's own `media-source` when it reports one (Chrome, Safari), otherwise
+   * the median of what its receivers heard ({@link receivedRmsAudioLevel}), which is what makes it
+   * available for Firefox publishers too. `undefined` for video, or when neither is known.
+   * {@link rmsAudioLevelSource} says which one it is.
+   */
+  rmsAudioLevel;
+  rmsAudioLevelSource;
+  /**
+   * Median RMS level (0..1) of this track across the receivers that played it out, each over its own
+   * latest tick. Needs a `RemoteTrackResolver`: without links there are no receivers to ask.
+   */
+  receivedRmsAudioLevel;
   get score() {
     return this.calculatedScore.value;
   }
@@ -1554,6 +1626,10 @@ var ObservedOutboundTrack = class {
   getMediaSource() {
     return this._mediaSource;
   }
+  /** The capture device behind this track, when the client sent `AUDIO_INPUT_DEVICE` metadata for it. */
+  get audioInputDevice() {
+    return this._peerConnection.client.audioInputDevices.get(this.id);
+  }
   update(stats) {
     this._visited = true;
     this.timestamp = stats.timestamp;
@@ -1585,8 +1661,30 @@ var ObservedOutboundTrack = class {
     if (this.muted !== true && this.deltaPacketsSent === 0) reasons.push("no-packets-sent");
     this.degradedReasons = reasons.length === 0 ? void 0 : reasons;
     this.receivingDistribution = this.createReceivingDistribution();
+    this._updateAudioLevel();
     this.detectors.update();
   }
+  _updateAudioLevel() {
+    this.rmsAudioLevel = void 0;
+    this.rmsAudioLevelSource = void 0;
+    this.receivedRmsAudioLevel = void 0;
+    if (this.kind !== "audio") return;
+    if (0 < this.remoteInboundTracks.size) {
+      const levels = [];
+      for (const inboundTrack of this.remoteInboundTracks) {
+        pushFinite(levels, inboundTrack.getInboundRtp()?.rmsAudioLevel);
+      }
+      this.receivedRmsAudioLevel = median(levels);
+    }
+    const sourceLevel = this._mediaSource?.rmsAudioLevel;
+    if (sourceLevel !== void 0) {
+      this.rmsAudioLevel = sourceLevel;
+      this.rmsAudioLevelSource = "media-source";
+    } else if (this.receivedRmsAudioLevel !== void 0) {
+      this.rmsAudioLevel = this.receivedRmsAudioLevel;
+      this.rmsAudioLevelSource = "receivers";
+    }
+  }
   createReceivingDistribution() {
     if (this.remoteInboundTracks.size === 0) return void 0;
     let freezeAffected = 0;
@@ -2626,6 +2724,7 @@ var ClientMetaTypes = /* @__PURE__ */ ((ClientMetaTypes2) => {
   ClientMetaTypes2["MEDIA_DEVICES_SUPPORTED_CONSTRAINTS"] = "MEDIA_DEVICES_SUPPORTED_CONSTRAINTS";
   ClientMetaTypes2["USER_MEDIA_ERROR"] = "USER_MEDIA_ERROR";
   ClientMetaTypes2["LOCAL_SDP"] = "LOCAL_SDP";
+  ClientMetaTypes2["AUDIO_INPUT_DEVICE"] = "AUDIO_INPUT_DEVICE";
   ClientMetaTypes2["OPERATION_SYSTEM"] = "OPERATION_SYSTEM";
   ClientMetaTypes2["ENGINE"] = "ENGINE";
   ClientMetaTypes2["PLATFORM"] = "PLATFORM";
@@ -2644,6 +2743,10 @@ function baseIssueType(type) {
 
 // src/ObservedClient.ts
 var logger2 = createLogger("ObservedClient");
+var RTT_HISTOGRAM_BUCKET_WIDTH_IN_MS = 20;
+var RTT_HISTOGRAM_NUMBER_OF_BUCKETS = 50;
+var SCORE_HISTOGRAM_BUCKET_WIDTH = 1;
+var SCORE_HISTOGRAM_NUMBER_OF_BUCKETS = 5;
 var ObservedClient = class extends EventEmitter2 {
   constructor(settings, call, activeIssues) {
     super();
@@ -2708,10 +2811,6 @@ var ObservedClient = class extends EventEmitter2 {
   deltaOutboundPacketsSent = 0;
   deltaTransportSentBytes = 0;
   deltaTransportReceivedBytes = 0;
-  deltaRttLt50Measurements = 0;
-  deltaRttLt150Measurements = 0;
-  deltaRttLt300Measurements = 0;
-  deltaRttGtOrEq300Measurements = 0;
   currentMaxRttInMs;
   currentMinRttInMs;
   currentAvgRttInMs;
@@ -2727,8 +2826,73 @@ var ObservedClient = class extends EventEmitter2 {
   deltaNumberOfIssues = 0;
   totalScoreSum = 0;
   numberOfScoreMeasurements = 0;
-  // public totalNumberOfIssues = 0;
+  minScore;
+  maxScore;
+  /**
+   * Score measurements (one per accepted sample with a score) counted into
+   * `SCORE_HISTOGRAM_NUMBER_OF_BUCKETS` buckets of `SCORE_HISTOGRAM_BUCKET_WIDTH`. Histograms of
+   * several clients can be added bucket by bucket to get the distribution of a call.
+   */
+  scoreHistogram = new Array(SCORE_HISTOGRAM_NUMBER_OF_BUCKETS).fill(0);
+  /** Issues raised over the session, counted as in `issueHistogram`. */
+  totalNumberOfIssues = 0;
+  /**
+   * Number of times each issue type was raised over the session, keyed by the base type (without
+   * the `-resolved` suffix): `client.issueHistogram['loopback-audio-input']`. A resolution entry is
+   * not counted, and neither is a re-raise of a keyed issue that is still open, so a stateful issue
+   * reported on every tick counts once per open interval. A type never raised is `undefined`.
+   */
+  issueHistogram = /* @__PURE__ */ Object.create(null);
+  // Session totals. Unlike the `delta*` and `current*` fields they are never reset, and unlike the
+  // `total*` fields of `ObservedPeerConnection` they survive a peer connection being closed.
+  // Every RTT measurement is one peer connection's `currentRttInMs` in one accepted sample.
+  totalRttSumInMs = 0;
+  numberOfRttMeasurements = 0;
+  maxRttInMs;
+  minRttInMs;
+  /**
+   * RTT measurements counted into fixed buckets of `RTT_HISTOGRAM_BUCKET_WIDTH_IN_MS`; the last bucket
+   * holds every measurement of 980 ms and above. Constant memory, so percentiles can be estimated
+   * over the whole session (see `rttSummary`) without keeping every measurement. Histograms
+   * of several clients can be added bucket by bucket to get the distribution of a call.
+   */
+  rttHistogram = new Array(RTT_HISTOGRAM_NUMBER_OF_BUCKETS).fill(0);
+  _rttSummary;
+  _scoreSummary;
+  totalInboundPacketsLost = 0;
+  totalInboundPacketsReceived = 0;
+  totalOutboundPacketsSent = 0;
+  totalReceivedAudioBytes = 0;
+  totalReceivedVideoBytes = 0;
+  totalSentAudioBytes = 0;
+  totalSentVideoBytes = 0;
+  totalTransportReceivedBytes = 0;
+  totalTransportSentBytes = 0;
+  totalDataChannelBytesReceived = 0;
+  totalDataChannelBytesSent = 0;
+  totalDataChannelMessagesReceived = 0;
+  totalDataChannelMessagesSent = 0;
+  /** Highest `sendingAudioBitrate + sendingVideoBitrate` of any sample, in bits per second. */
+  peakSendingBitrate = 0;
+  /** Highest `receivingAudioBitrate + receivingVideoBitrate` of any sample, in bits per second. */
+  peakReceivingBitrate = 0;
+  // Samples by the transport path of the selected ICE candidate pairs. A sample whose peer
+  // connections use different paths is counted under each of them, so more than one non-zero
+  // counter means the path changed or was mixed. A sample with no selected pair counts as unknown.
+  numberOfSamplesOverUdp = 0;
+  numberOfSamplesOverTcp = 0;
+  numberOfSamplesOverTurnUdp = 0;
+  numberOfSamplesOverTurnTcp = 0;
+  numberOfSamplesWithUnknownPath = 0;
+  numberOfPublicAddressChanges = 0;
   mediaDevices = [];
+  /**
+   * The capture device behind each outbound audio track, keyed by track id, from the client's
+   * `AUDIO_INPUT_DEVICE` metadata. Kept for the client's lifetime (a device switch is a new track
+   * id), so a finding raised after a track ended can still name its device. Read it per track via
+   * `ObservedOutboundTrack.audioInputDevice`.
+   */
+  audioInputDevices = /* @__PURE__ */ new Map();
   /**
    * 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).
@@ -2741,9 +2905,7 @@ var ObservedClient = class extends EventEmitter2 {
   activeIssues;
   _pendingInjections = {};
   _activeSample;
-  /** Peer connections the client reported closed (`PEER_CONNECTION_CLOSED`), closed once the current sample is applied. */
   _peerConnectionsToClose = /* @__PURE__ */ new Set();
-  /** Ids of peer connections closed by the client; late stats for them are ignored rather than resurrecting them. */
   _closedPeerConnectionIds = /* @__PURE__ */ new Set();
   closeTimer;
   /** The distinct `publicAddress`es currently known by this client's open peer connections. */
@@ -2760,6 +2922,61 @@ var ObservedClient = class extends EventEmitter2 {
   get score() {
     return this.calculatedScore.value;
   }
+  /**
+   * Percentiles (error at most one 20 ms bucket; a percentile in the overflow bucket is reported as
+   * `maxRttInMs`) and mean of every RTT measurement of the session. Cached until the next measurement.
+   */
+  get rttSummary() {
+    if (!this._rttSummary) {
+      const bounds = { min: this.minRttInMs, max: this.maxRttInMs, openEnded: true };
+      const percentile2 = (p) => percentileOfHistogram(this.rttHistogram, RTT_HISTOGRAM_BUCKET_WIDTH_IN_MS, p, bounds);
+      this._rttSummary = Object.freeze({
+        p50: percentile2(0.5),
+        p75: percentile2(0.75),
+        p95: percentile2(0.95),
+        p99: percentile2(0.99),
+        avg: 0 < this.numberOfRttMeasurements ? this.totalRttSumInMs / this.numberOfRttMeasurements : void 0
+      });
+    }
+    return this._rttSummary;
+  }
+  /**
+   * Percentiles (error at most one score point) and mean of every score of the session. Cached until
+   * the next score.
+   */
+  get scoreSummary() {
+    if (!this._scoreSummary) {
+      const bounds = { min: this.minScore, max: this.maxScore };
+      const percentile2 = (p) => percentileOfHistogram(this.scoreHistogram, SCORE_HISTOGRAM_BUCKET_WIDTH, p, bounds);
+      this._scoreSummary = Object.freeze({
+        p5: percentile2(0.05),
+        p25: percentile2(0.25),
+        p50: percentile2(0.5),
+        p75: percentile2(0.75),
+        p95: percentile2(0.95),
+        avg: 0 < this.numberOfScoreMeasurements ? this.totalScoreSum / this.numberOfScoreMeasurements : void 0
+      });
+    }
+    return this._scoreSummary;
+  }
+  _addScoreMeasurement(score) {
+    this._scoreSummary = void 0;
+    this.totalScoreSum += score;
+    ++this.numberOfScoreMeasurements;
+    if (this.maxScore === void 0 || this.maxScore < score) this.maxScore = score;
+    if (this.minScore === void 0 || score < this.minScore) this.minScore = score;
+    const bucket = Math.min(Math.max(Math.floor(score / SCORE_HISTOGRAM_BUCKET_WIDTH), 0), SCORE_HISTOGRAM_NUMBER_OF_BUCKETS - 1);
+    ++this.scoreHistogram[bucket];
+  }
+  _addRttMeasurement(rttInMs) {
+    this._rttSummary = void 0;
+    this.totalRttSumInMs += rttInMs;
+    ++this.numberOfRttMeasurements;
+    if (this.maxRttInMs === void 0 || this.maxRttInMs < rttInMs) this.maxRttInMs = rttInMs;
+    if (this.minRttInMs === void 0 || rttInMs < this.minRttInMs) this.minRttInMs = rttInMs;
+    const bucket = Math.min(Math.max(Math.floor(rttInMs / RTT_HISTOGRAM_BUCKET_WIDTH_IN_MS), 0), RTT_HISTOGRAM_NUMBER_OF_BUCKETS - 1);
+    ++this.rttHistogram[bucket];
+  }
   close() {
     if (this.closed) return;
     if (this.closeTimer) {
@@ -2803,6 +3020,10 @@ var ObservedClient = class extends EventEmitter2 {
     const elapsedInSeconds = elapsedInMs / 1e3;
     let sumOfRtts = 0;
     let numberOfRttMeasurements = 0;
+    let overUdp = false;
+    let overTcp = false;
+    let overTurnUdp = false;
+    let overTurnTcp = false;
     ++this.acceptedSamples;
     this.availableIncomingBitrate = 0;
     this.availableOutgoingBitrate = 0;
@@ -2819,10 +3040,6 @@ var ObservedClient = class extends EventEmitter2 {
     this.deltaSentVideoBytes = 0;
     this.deltaTransportReceivedBytes = 0;
     this.deltaTransportSentBytes = 0;
-    this.deltaRttLt50Measurements = 0;
-    this.deltaRttLt150Measurements = 0;
-    this.deltaRttLt300Measurements = 0;
-    this.deltaRttGtOrEq300Measurements = 0;
     this.deltaNumberOfIssues = 0;
     this.numberOfDataChannels = 0;
     this.numberOfInboundRtpStreams = 0;
@@ -2894,6 +3111,18 @@ var ObservedClient = class extends EventEmitter2 {
       if (observedPeerConnection.usingTCP) {
         this.usingTCP = true;
       }
+      for (const selectedPair of observedPeerConnection.selectedIceCandidatePairs) {
+        const localCandidate = selectedPair.getLocalCandidate();
+        if (!localCandidate) continue;
+        if (localCandidate.candidateType === "relay") {
+          if (localCandidate.relayProtocol === "tcp" || localCandidate.relayProtocol === "tls") overTurnTcp = true;
+          else overTurnUdp = true;
+        } else if (localCandidate.protocol === "tcp") {
+          overTcp = true;
+        } else {
+          overUdp = true;
+        }
+      }
       if (observedPeerConnection.currentRttInMs) {
         if (this.currentMinRttInMs === void 0 || observedPeerConnection.currentRttInMs < this.currentMinRttInMs) {
           this.currentMinRttInMs = observedPeerConnection.currentRttInMs;
@@ -2901,17 +3130,9 @@ var ObservedClient = class extends EventEmitter2 {
         if (this.currentMaxRttInMs === void 0 || observedPeerConnection.currentRttInMs > this.currentMaxRttInMs) {
           this.currentMaxRttInMs = observedPeerConnection.currentRttInMs;
         }
-        if (observedPeerConnection.currentRttInMs < 50) {
-          this.deltaRttLt50Measurements += 1;
-        } else if (observedPeerConnection.currentRttInMs < 150) {
-          this.deltaRttLt150Measurements += 1;
-        } else if (observedPeerConnection.currentRttInMs < 300) {
-          this.deltaRttLt300Measurements += 1;
-        } else if (300 <= observedPeerConnection.currentRttInMs) {
-          this.deltaRttGtOrEq300Measurements += 1;
-        }
         sumOfRtts += observedPeerConnection.currentRttInMs;
         ++numberOfRttMeasurements;
+        this._addRttMeasurement(observedPeerConnection.currentRttInMs);
       }
     }
     for (const clientEvent of clientEventsPostBuffer) {
@@ -2921,6 +3142,7 @@ var ObservedClient = class extends EventEmitter2 {
     if (latestPublicAddress !== void 0 && latestPublicAddress !== this.publicAddress) {
       const previousPublicAddress = this.publicAddress;
       this.publicAddress = latestPublicAddress;
+      if (previousPublicAddress !== void 0) ++this.numberOfPublicAddressChanges;
       this._notify("client-public-address-changed", { ...this.eventScope, publicAddress: latestPublicAddress, previousPublicAddress });
     }
     this.attachments = sample.attachments;
@@ -2936,15 +3158,34 @@ var ObservedClient = class extends EventEmitter2 {
       this.sendingVideoBitrate = 0;
     }
     this.currentAvgRttInMs = 0 < numberOfRttMeasurements ? sumOfRtts / numberOfRttMeasurements : void 0;
+    this.peakSendingBitrate = Math.max(this.peakSendingBitrate, this.sendingAudioBitrate + this.sendingVideoBitrate);
+    this.peakReceivingBitrate = Math.max(this.peakReceivingBitrate, this.receivingAudioBitrate + this.receivingVideoBitrate);
+    this.totalInboundPacketsLost += this.deltaInboundPacketsLost;
+    this.totalInboundPacketsReceived += this.deltaInboundPacketsReceived;
+    this.totalOutboundPacketsSent += this.deltaOutboundPacketsSent;
+    this.totalReceivedAudioBytes += this.deltaReceivedAudioBytes;
+    this.totalReceivedVideoBytes += this.deltaReceivedVideoBytes;
+    this.totalSentAudioBytes += this.deltaSentAudioBytes;
+    this.totalSentVideoBytes += this.deltaSentVideoBytes;
+    this.totalTransportReceivedBytes += this.deltaTransportReceivedBytes;
+    this.totalTransportSentBytes += this.deltaTransportSentBytes;
+    this.totalDataChannelBytesReceived += this.deltaDataChannelBytesReceived;
+    this.totalDataChannelBytesSent += this.deltaDataChannelBytesSent;
+    this.totalDataChannelMessagesReceived += this.deltaDataChannelMessagesReceived;
+    this.totalDataChannelMessagesSent += this.deltaDataChannelMessagesSent;
+    if (overUdp) ++this.numberOfSamplesOverUdp;
+    if (overTcp) ++this.numberOfSamplesOverTcp;
+    if (overTurnUdp) ++this.numberOfSamplesOverTurnUdp;
+    if (overTurnTcp) ++this.numberOfSamplesOverTurnTcp;
+    if (!overUdp && !overTcp && !overTurnUdp && !overTurnTcp) ++this.numberOfSamplesWithUnknownPath;
     this.calculatedScore.value = sample.score;
     this.lastSampleTimestamp = sample.timestamp;
     const elapsedTimeInMs = now - this.updated;
     this.emit("update", sample, elapsedTimeInMs, context);
     this._notify("client-updated", { ...this.eventScope, sample, elapsedTimeInMs, context });
     this.updated = now;
-    if (this.calculatedScore.value) {
-      this.totalScoreSum += this.calculatedScore.value;
-      ++this.numberOfScoreMeasurements;
+    if (typeof this.calculatedScore.value === "number" && Number.isFinite(this.calculatedScore.value)) {
+      this._addScoreMeasurement(this.calculatedScore.value);
     }
     if (this.settings.closeClientIfIdleForMs !== void 0) {
       this.closeTimer = setTimeout(() => {
@@ -3035,6 +3276,13 @@ var ObservedClient = class extends EventEmitter2 {
         this.operationSystem = parseJsonAs(metadata.payload);
         break;
       }
+      case "AUDIO_INPUT_DEVICE" /* AUDIO_INPUT_DEVICE */: {
+        const device = parseJsonAs(metadata.payload);
+        if (typeof device?.trackId === "string" && typeof device.label === "string") {
+          this.audioInputDevices.set(device.trackId, device);
+        }
+        break;
+      }
     }
     this._notify("client-metadata", { ...this.eventScope, metaData: metadata });
   }
@@ -3055,6 +3303,11 @@ var ObservedClient = class extends EventEmitter2 {
     if (isClientIssueResolutionEntry(issue)) {
       return this._resolveIssue(issue);
     }
+    if (!issue.key || !this.activeIssues.get(issue.key)) {
+      const type = baseIssueType(issue.type);
+      this.issueHistogram[type] = (this.issueHistogram[type] ?? 0) + 1;
+      ++this.totalNumberOfIssues;
+    }
     const now = Date.now();
     if (issue.key) {
       const payload = parseJsonObject(issue.payload);
@@ -4326,6 +4579,169 @@ var PublisherFaultCorroborationDetector = class _PublisherFaultCorroborationDete
   }
 };
 
+// src/detectors/AudioEchoDetector.ts
+var AudioEchoTypes = {
+  /**
+   * One participant's outgoing audio follows another participant's voice: it rises when they speak,
+   * in proportion to how loud they are. The echoing participant is sending the far end's playout
+   * back into the call — speakers into an open mic, or a loopback capture device.
+   */
+  audioEchoSuspected: "AUDIO_ECHO_SUSPECTED"
+};
+var DIRECTION_MARGIN = 0.1;
+var mean = (values) => values.reduce((sum, value) => sum + value, 0) / values.length;
+var LEVEL_FLOOR = 1e-5;
+var toDb = (level) => 20 * Math.log10(Math.max(level, LEVEL_FLOOR));
+var AudioEchoDetector = class _AudioEchoDetector {
+  constructor(call, config = {}) {
+    this.call = call;
+    this._config = {
+      bucketMs: 5e3,
+      windowBuckets: 24,
+      activeRmsLevel: 0.01,
+      minSourceActiveBuckets: 8,
+      minFollowRatio: 0.8,
+      minCorrelation: 0.6,
+      cooldownMs: 12e4,
+      loopbackAudioInputIssueType: "loopback-audio-input",
+      ...config
+    };
+  }
+  call;
+  static NAME = "audio-echo-detector";
+  name = _AudioEchoDetector.NAME;
+  _config;
+  _series = /* @__PURE__ */ new Map();
+  _lastRaisedAt = /* @__PURE__ */ new Map();
+  _lastEvaluatedBucket;
+  close() {
+    this._series.clear();
+    this._lastRaisedAt.clear();
+  }
+  update() {
+    const now = Date.now();
+    const bucket = Math.floor(now / this._config.bucketMs);
+    if (this._lastEvaluatedBucket === bucket) return;
+    const closedBucket = bucket - 1;
+    this._lastEvaluatedBucket = bucket;
+    this._collect(now, closedBucket);
+    this._evaluate(now, bucket);
+  }
+  _collect(now, bucket) {
+    for (const client of this.call.observedClients.values()) {
+      for (const peerConnection of client.observedPeerConnections.values()) {
+        for (const track of peerConnection.observedOutboundTracks.values()) {
+          if (track.kind !== "audio") continue;
+          let series = this._series.get(track.id);
+          if (!series) {
+            series = { track, clientId: client.clientId, lastTimestamp: -1, samples: [], lastSeenAt: now };
+            this._series.set(track.id, series);
+          }
+          series.lastSeenAt = now;
+          if (series.lastTimestamp === track.timestamp) continue;
+          series.lastTimestamp = track.timestamp;
+          const level = track.rmsAudioLevel;
+          if (level === void 0) continue;
+          series.samples.push({ bucket, level });
+          const oldest = bucket - this._config.windowBuckets;
+          while (series.samples.length && series.samples[0].bucket <= oldest) series.samples.shift();
+        }
+      }
+    }
+    for (const [trackId, series] of this._series) {
+      if (series.lastSeenAt !== now) this._series.delete(trackId);
+    }
+  }
+  _evaluate(now, currentBucket) {
+    if (this._series.size < 2) return;
+    const tops = /* @__PURE__ */ new Map();
+    for (const [trackId, series] of this._series) {
+      for (const { bucket, level } of series.samples) {
+        if (currentBucket <= bucket) continue;
+        const top = tops.get(bucket);
+        const entry = { id: trackId, level };
+        if (!top) tops.set(bucket, [entry, void 0]);
+        else if (top[0].level < level) tops.set(bucket, [entry, top[0]]);
+        else if (!top[1] || top[1].level < level) top[1] = entry;
+      }
+    }
+    const candidates = /* @__PURE__ */ new Map();
+    for (const [trackId, series] of this._series) {
+      const suspectDb = [];
+      const sourceDb = [];
+      const sourceCounts = /* @__PURE__ */ new Map();
+      let followed = 0;
+      for (const { bucket, level } of series.samples) {
+        const top = tops.get(bucket);
+        if (!top) continue;
+        const source = top[0].id === trackId ? top[1] : top[0];
+        if (!source || source.level < this._config.activeRmsLevel) continue;
+        if (this._config.activeRmsLevel <= level) followed += 1;
+        suspectDb.push(toDb(level));
+        sourceDb.push(toDb(source.level));
+        sourceCounts.set(source.id, (sourceCounts.get(source.id) ?? 0) + 1);
+      }
+      const sourceActiveBuckets = sourceDb.length;
+      if (sourceActiveBuckets < this._config.minSourceActiveBuckets) continue;
+      const followRatio = followed / sourceActiveBuckets;
+      if (followRatio < this._config.minFollowRatio) continue;
+      const levelCorrelation = correlation(suspectDb, sourceDb);
+      if (levelCorrelation < this._config.minCorrelation) continue;
+      const [sourceTrackId] = [...sourceCounts].reduce((a, b) => a[1] < b[1] ? b : a);
+      const client = this.call.observedClients.get(series.clientId);
+      candidates.set(trackId, {
+        trackId,
+        series,
+        sourceTrackId,
+        followRatio,
+        levelCorrelation,
+        sourceActiveBuckets,
+        // How much quieter than its source the suspect is, in dB. An echo is at most as loud as
+        // what it echoes, give or take AGC.
+        relativeLevelDb: mean(suspectDb) - mean(sourceDb),
+        loopbackAudioInput: client?.activeIssues.get(`${this._config.loopbackAudioInputIssueType}-track-${trackId}`) !== void 0
+      });
+    }
+    for (const candidate of candidates.values()) {
+      const reverse = candidates.get(candidate.sourceTrackId);
+      let ambiguousDirection = false;
+      if (reverse && reverse.sourceTrackId === candidate.trackId) {
+        if (candidate.loopbackAudioInput !== reverse.loopbackAudioInput) {
+          if (!candidate.loopbackAudioInput) continue;
+        } else if (DIRECTION_MARGIN < Math.abs(candidate.followRatio - reverse.followRatio)) {
+          if (candidate.followRatio < reverse.followRatio) continue;
+        } else {
+          ambiguousDirection = true;
+          if (reverse.relativeLevelDb < candidate.relativeLevelDb) continue;
+          if (reverse.relativeLevelDb === candidate.relativeLevelDb && reverse.trackId < candidate.trackId) continue;
+        }
+      }
+      if (now - (this._lastRaisedAt.get(candidate.trackId) ?? -Infinity) < this._config.cooldownMs) continue;
+      this._lastRaisedAt.set(candidate.trackId, now);
+      const { series } = candidate;
+      this.call.addIssue({
+        type: AudioEchoTypes.audioEchoSuspected,
+        timestamp: now,
+        payload: {
+          trackId: candidate.trackId,
+          clientId: series.clientId,
+          sourceTrackId: candidate.sourceTrackId,
+          sourceClientId: this._series.get(candidate.sourceTrackId)?.clientId,
+          followRatio: candidate.followRatio,
+          levelCorrelation: candidate.levelCorrelation,
+          relativeLevelDb: candidate.relativeLevelDb,
+          sourceActiveBuckets: candidate.sourceActiveBuckets,
+          bucketMs: this._config.bucketMs,
+          ambiguousDirection,
+          levelSource: series.track.rmsAudioLevelSource,
+          audioInputLabel: series.track.audioInputDevice?.label,
+          loopbackAudioInput: candidate.loopbackAudioInput
+        }
+      });
+    }
+  }
+};
+
 // src/ObservedCall.ts
 var logger4 = createLogger("ObservedCall");
 var ObservedCall = class extends EventEmitter3 {
@@ -4384,10 +4800,6 @@ var ObservedCall = class extends EventEmitter3 {
   numberOfDataChannels = 0;
   maxNumberOfClients = 0;
   deltaNumberOfIssues = 0;
-  // public deltaRttLt50Measurements = 0;
-  // public deltaRttLt150Measurements = 0;
-  // public deltaRttLt300Measurements = 0;
-  // public deltaRttGtOrEq300Measurements = 0;
   appData;
   closed = false;
   startedAt;
@@ -4433,6 +4845,10 @@ var ObservedCall = class extends EventEmitter3 {
         detector = new PublisherFaultCorroborationDetector(this, config);
         break;
       }
+      case AudioEchoDetector.NAME: {
+        detector = new AudioEchoDetector(this, config);
+        break;
+      }
       default: {
         logger4.warn("Unknown detector name %s; skipping", name);
         return this;
@@ -7513,6 +7929,8 @@ function createP2pRemoteTrackResolverFactory() {
 }
 export {
   ActiveIssuesRegistry,
+  AudioEchoDetector,
+  AudioEchoTypes,
   CODEC_MISMATCH_ISSUE,
   CallConcurrentIssueDetector,
   CallConcurrentIssueTypes,
@@ -7560,8 +7978,12 @@ export {
   PublisherFaultCorroborationDetector,
   PublisherFaultTypes,
   RESOLVED_ISSUE_SUFFIX,
+  RTT_HISTOGRAM_BUCKET_WIDTH_IN_MS,
+  RTT_HISTOGRAM_NUMBER_OF_BUCKETS,
   RemoteTrackResolver,
   RemoteTrackResolverValidator,
+  SCORE_HISTOGRAM_BUCKET_WIDTH,
+  SCORE_HISTOGRAM_NUMBER_OF_BUCKETS,
   SfuCongestionDetector,
   SimulcastReceiverValidator,
   SlidingWindow,
@@ -7599,6 +8021,7 @@ export {
   medianAbsoluteDeviation,
   pageHinkley,
   percentile,
+  percentileOfHistogram,
   percentileOfSorted,
   robustZScore,
   schemaVersion,