@observertc/observer-js 1.1.0 → 1.2.0-rc.1

package/dist/index.js

@@ -31,6 +31,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   ActiveIssuesRegistry: () => ActiveIssuesRegistry,
+  AudioEchoDetector: () => AudioEchoDetector,
+  AudioEchoTypes: () => AudioEchoTypes,
   CODEC_MISMATCH_ISSUE: () => CODEC_MISMATCH_ISSUE,
   CallConcurrentIssueDetector: () => CallConcurrentIssueDetector,
   CallConcurrentIssueTypes: () => CallConcurrentIssueTypes,
@@ -40,9 +42,9 @@ __export(src_exports, {
   ClientMetaTypes: () => ClientMetaTypes,
   ClientPopulationIssueDetector: () => ClientPopulationIssueDetector,
   ClientPopulationIssueTypes: () => ClientPopulationIssueTypes,
-  ClientSampleSink: () => ClientSampleSink,
   CodecConsistencyValidator: () => CodecConsistencyValidator,
   Detectors: () => Detectors,
+  ExtensionStatsRegistry: () => ExtensionStatsRegistry,
   GEOHASH_CELL_SIZES: () => GEOHASH_CELL_SIZES,
   InMemorySink: () => InMemorySink,
   IssueFanOutDetector: () => IssueFanOutDetector,
@@ -78,10 +80,15 @@ __export(src_exports, {
   PublisherFaultCorroborationDetector: () => PublisherFaultCorroborationDetector,
   PublisherFaultTypes: () => PublisherFaultTypes,
   RESOLVED_ISSUE_SUFFIX: () => RESOLVED_ISSUE_SUFFIX,
+  RTT_HISTOGRAM_BUCKET_WIDTH_IN_MS: () => RTT_HISTOGRAM_BUCKET_WIDTH_IN_MS,
+  RTT_HISTOGRAM_NUMBER_OF_BUCKETS: () => RTT_HISTOGRAM_NUMBER_OF_BUCKETS,
   RemoteTrackResolver: () => RemoteTrackResolver,
   RemoteTrackResolverValidator: () => RemoteTrackResolverValidator,
+  SCORE_HISTOGRAM_BUCKET_WIDTH: () => SCORE_HISTOGRAM_BUCKET_WIDTH,
+  SCORE_HISTOGRAM_NUMBER_OF_BUCKETS: () => SCORE_HISTOGRAM_NUMBER_OF_BUCKETS,
   SfuCongestionDetector: () => SfuCongestionDetector,
   SimulcastReceiverValidator: () => SimulcastReceiverValidator,
+  SinkRegistry: () => SinkRegistry,
   SlidingWindow: () => SlidingWindow,
   TrackDeliveryMismatchDetector: () => TrackDeliveryMismatchDetector,
   TrackDeliveryMismatchTypes: () => TrackDeliveryMismatchTypes,
@@ -102,7 +109,6 @@ __export(src_exports, {
   createDefaultMediasoupRemoteTrackResolverFactory: () => createDefaultMediasoupRemoteTrackResolverFactory,
   createInMemorySink: () => createInMemorySink,
   createJsonlFileSink: () => createJsonlFileSink,
-  createJsonlFileSinkFactory: () => createJsonlFileSinkFactory,
   createLogger: () => createLogger,
   createP2pRemoteTrackResolverFactory: () => createP2pRemoteTrackResolverFactory,
   defaultCallSummaryConfig: () => defaultCallSummaryConfig,
@@ -117,6 +123,7 @@ __export(src_exports, {
   medianAbsoluteDeviation: () => medianAbsoluteDeviation,
   pageHinkley: () => pageHinkley,
   percentile: () => percentile,
+  percentileOfHistogram: () => percentileOfHistogram,
   percentileOfSorted: () => percentileOfSorted,
   robustZScore: () => robustZScore,
   schemaVersion: () => schemaVersion,
@@ -164,18 +171,189 @@ function createLogger(moduleName) {
     }
   }();
 }
-function setObserverLogger(logger11) {
-  mainLogger = logger11;
+function setObserverLogger(logger13) {
+  mainLogger = logger13;
 }
 
 // src/ObservedCall.ts
-var import_events3 = require("events");
+var import_node_events4 = require("events");
+
+// src/sinks/SinkRegistry.ts
+var import_uuid = require("uuid");
+var logger = createLogger("SinkRegistry");
+var SinkRegistry = class {
+  constructor(parent) {
+    this.parent = parent;
+  }
+  parent;
+  // This registry's sinks and its descendants'.
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  _sinks = /* @__PURE__ */ new Map();
+  /** Number of open sinks in this registry and its descendants. */
+  get size() {
+    return this._sinks.size;
+  }
+  keys() {
+    return this._sinks.keys();
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  values() {
+    return this._sinks.values();
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  get(id) {
+    return this._sinks.get(id);
+  }
+  /**
+   * Construct `new SinkClass(settings)` and register it. The id (`settings.id`, generated when
+   * omitted) is checked first, so nothing is constructed — no file is opened — when it is taken:
+   * `undefined` is returned and a warning logged.
+   */
+  create(SinkClass, settings) {
+    const lineage = this._lineage();
+    const id = settings.id ?? (0, import_uuid.v4)();
+    if (lineage[lineage.length - 1]._sinks.has(id)) {
+      logger.warn("Sink id %s is already in use; sink ids must be unique per observer. No sink was created", id);
+      return void 0;
+    }
+    const sink = new SinkClass({ ...settings, id });
+    const onError = (err) => logger.warn("Sink %s failed: %o", id, err);
+    sink.on("error", onError);
+    sink.once("close", () => sink.off("error", onError));
+    sink.once("ended", () => {
+      for (const registry of lineage) {
+        if (registry._sinks.get(id) === sink) registry._sinks.delete(id);
+      }
+    });
+    for (const registry of lineage) registry._sinks.set(id, sink);
+    return sink;
+  }
+  /** Write `record` to the sink `id`. `false` when there is no such sink, or on backpressure. */
+  write(id, record) {
+    const sink = this._sinks.get(id);
+    if (!sink) {
+      logger.debug("No sink %s; record dropped", id);
+      return false;
+    }
+    return sink.write(record);
+  }
+  /** End every sink of this registry and of its descendants. */
+  clear() {
+    for (const sink of [...this._sinks.values()]) {
+      try {
+        sink.end();
+      } catch (err) {
+        logger.warn("Sink %s failed to end: %o", sink.id, err);
+      }
+    }
+  }
+  /** This registry and its ancestors, up to the root. */
+  _lineage() {
+    return [this, ...this.parent?._lineage() ?? []];
+  }
+};
+
+// src/sinks/ExtensionStatsRegistry.ts
+var logger2 = createLogger("ExtensionStats");
+var ExtensionStatsRegistry = class {
+  constructor(id, _sinks) {
+    this.id = id;
+    this._sinks = _sinks;
+  }
+  id;
+  _sinks;
+  /** The last data accepted for each extension stats id. */
+  values = /* @__PURE__ */ new Map();
+  closed = false;
+  /**
+   * Refuse further `create` / `accept`, and end the extension stats' sinks (the sinks whose id is
+   * an extension stats id). Other sinks of the owner, e.g. client sample sinks, are left to the
+   * owner's `sinks.clear()`. Called by the owner when it closes.
+   */
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    for (const id of this.values.keys()) {
+      this._sinks.get(id)?.end();
+    }
+  }
+  create(settings) {
+    if (this.closed) {
+      logger2.warn("Attempted to create extension stats %s on closed %s", settings.id, this.id);
+      return void 0;
+    }
+    if (this.values.has(settings.id)) {
+      logger2.warn("Extension stats with id %s already exists on %s", settings.id, this.id);
+      return void 0;
+    }
+    this.values.set(settings.id, void 0);
+    if (!settings.createSink) return void 0;
+    const [SinkClass, sinkSettings] = settings.createSink;
+    this._sinks.get(settings.id)?.end();
+    return this._sinks.create(SinkClass, { ...sinkSettings, id: settings.id });
+  }
+  accept(id, data) {
+    if (this.closed) {
+      logger2.debug("Extension stats %s dropped: %s is closed", id, this.id);
+      return;
+    }
+    this.values.set(id, data);
+    try {
+      this._sinks.get(id)?.write(data);
+    } catch (err) {
+      logger2.warn("Failed to write extension stats %s to sink: %o", id, err);
+    }
+  }
+  get(id) {
+    return this.values.get(id);
+  }
+};
+
+// src/sinks/JsonlFileSink.ts
+var fs = __toESM(require("fs"));
+var import_node_events = require("events");
+var JsonlFileSink = class extends import_node_events.EventEmitter {
+  id;
+  /** The file this sink writes to. Read it (e.g. in a `close` handler) to upload/move the file. */
+  path;
+  _stream;
+  _serializeSample;
+  _ended = false;
+  constructor(options) {
+    super();
+    this.id = options.id ?? options.path;
+    this.path = options.path;
+    this._stream = fs.createWriteStream(this.path, { flags: "a" });
+    this._stream.on("close", () => this.emit("close"));
+    this._stream.on("finish", () => this.emit("finish"));
+    this._stream.on("drain", () => this.emit("drain"));
+    this._stream.on("error", (err) => this.emit("error", err));
+    this._serializeSample = options.serializeSample ?? ((record) => JSON.stringify(record));
+  }
+  get ended() {
+    return this._ended;
+  }
+  write(record) {
+    if (this._ended) return false;
+    return this._stream.write(`${this._serializeSample(record)}
+`);
+  }
+  end() {
+    if (this._ended) return;
+    this._ended = true;
+    this.emit("ended");
+    this._stream.end();
+  }
+};
+function createJsonlFileSink(options) {
+  return new JsonlFileSink(options);
+}
 
 // src/ObservedClient.ts
-var import_events2 = require("events");
+var import_node_events3 = require("events");
 
 // src/ObservedPeerConnection.ts
-var import_events = require("events");
+var import_node_events2 = require("events");
 
 // src/utils/stats.ts
 function percentile(values, p) {
@@ -230,6 +408,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;
@@ -262,8 +444,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);
@@ -315,6 +497,25 @@ 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 lower = Math.max(index * bucketWidth, options.min ?? -Infinity);
+    const upper = Math.min((index + 1) * bucketWidth, options.max ?? Infinity);
+    return lower + (rank - cumulative) / count * Math.max(0, upper - lower);
+  }
+  return options.max;
+}
 
 // src/ObservedInboundRtp.ts
 var ObservedInboundRtp = class {
@@ -425,6 +626,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
@@ -510,6 +720,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) {
@@ -539,6 +752,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) {
@@ -596,6 +812,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;
@@ -1250,6 +1469,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;
@@ -1263,6 +1492,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;
@@ -1661,6 +1898,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;
   }
@@ -1681,6 +1932,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;
@@ -1712,8 +1967,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;
@@ -1769,14 +2046,14 @@ var ObservedOutboundTrack = class {
 
 // src/ObservedPeerConnection.ts
 var ascending2 = (a, b) => a - b;
-var logger = createLogger("ObservedPeerConnection");
+var logger3 = createLogger("ObservedPeerConnection");
 function publicAddressOfLocalCandidate(candidate) {
   if (!candidate) return void 0;
   if (candidate.candidateType !== "relay" && isPublicIpAddress(candidate.address)) return candidate.address;
   if (isPublicIpAddress(candidate.relatedAddress)) return candidate.relatedAddress;
   return void 0;
 }
-var ObservedPeerConnection = class extends import_events.EventEmitter {
+var ObservedPeerConnection = class extends import_node_events2.EventEmitter {
   constructor(peerConnectionId, client) {
     super();
     this.peerConnectionId = peerConnectionId;
@@ -2358,7 +2635,7 @@ var ObservedPeerConnection = class extends import_events.EventEmitter {
     let observedCertificate = this.observedCertificates.get(stats.id);
     if (!observedCertificate) {
       if (!stats.timestamp || !stats.id || !stats.fingerprint) {
-        return logger.warn(
+        return logger3.warn(
           `ObservedPeerConnection received an invalid CertificateStats (missing timestamp OR id OR fingerprint field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`,
           stats
         );
@@ -2377,7 +2654,7 @@ var ObservedPeerConnection = class extends import_events.EventEmitter {
     let observedCodec = this.observedCodecs.get(stats.id);
     if (!observedCodec) {
       if (!stats.timestamp || !stats.id || !stats.mimeType) {
-        return logger.warn(
+        return logger3.warn(
           `ObservedPeerConnection received an invalid CodecStats (missing timestamp OR id OR mimeType field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`,
           stats
         );
@@ -2396,7 +2673,7 @@ var ObservedPeerConnection = class extends import_events.EventEmitter {
     let observedDataChannel = this.observedDataChannels.get(stats.id);
     if (!observedDataChannel) {
       if (!stats.timestamp || !stats.id) {
-        return logger.warn(
+        return logger3.warn(
           `ObservedPeerConnection received an invalid DataChannelStats (missing timestamp OR id field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`,
           stats
         );
@@ -2415,7 +2692,7 @@ var ObservedPeerConnection = class extends import_events.EventEmitter {
     let observedIceCandidate = this.observedIceCandidates.get(stats.id);
     if (!observedIceCandidate) {
       if (!stats.timestamp || !stats.id) {
-        return logger.warn(
+        return logger3.warn(
           `ObservedPeerConnection received an invalid IceCandidateStats (missing timestamp OR id field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`,
           stats
         );
@@ -2434,7 +2711,7 @@ var ObservedPeerConnection = class extends import_events.EventEmitter {
     let observedIceCandidatePair = this.observedIceCandidatesPair.get(stats.id);
     if (!observedIceCandidatePair) {
       if (!stats.timestamp || !stats.id) {
-        return logger.warn(
+        return logger3.warn(
           `ObservedPeerConnection received an invalid IceCandidateStats (missing timestamp OR id field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`,
           stats
         );
@@ -2453,7 +2730,7 @@ var ObservedPeerConnection = class extends import_events.EventEmitter {
     let observedIceTransport = this.observedIceTransports.get(stats.id);
     if (!observedIceTransport) {
       if (!stats.timestamp || !stats.id) {
-        return logger.warn(
+        return logger3.warn(
           `ObservedPeerConnection received an invalid IceCandidateStats (missing timestamp OR id field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`,
           stats
         );
@@ -2472,7 +2749,7 @@ var ObservedPeerConnection = class extends import_events.EventEmitter {
     let observedInboundRtp = this.observedInboundRtps.get(stats.ssrc);
     if (!observedInboundRtp) {
       if (!stats.timestamp || !stats.id || !stats.ssrc || !stats.kind || !stats.trackIdentifier) {
-        return logger.warn(
+        return logger3.warn(
           `ObservedPeerConnection received an invalid InboundRtpStats (missing timestamp OR id OR ssrc OR kind OR trackIdentifier field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`,
           stats
         );
@@ -2498,7 +2775,7 @@ var ObservedPeerConnection = class extends import_events.EventEmitter {
     let observedInboundTrack = this.observedInboundTracks.get(stats.id);
     if (!observedInboundTrack) {
       if (!stats.timestamp || !stats.id || !stats.kind) {
-        return logger.warn(
+        return logger3.warn(
           `ObservedPeerConnection received an invalid InboundTrackSample (missing timestamp OR id OR kind field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`,
           stats
         );
@@ -2526,7 +2803,7 @@ var ObservedPeerConnection = class extends import_events.EventEmitter {
     let observedMediaPlayout = this.observedMediaPlayouts.get(stats.id);
     if (!observedMediaPlayout) {
       if (!stats.timestamp || !stats.id || !stats.kind) {
-        return logger.warn(
+        return logger3.warn(
           `ObservedPeerConnection received an invalid InboundRtpStats (missing timestamp OR id OR kind OR trackIdentifier field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`,
           stats
         );
@@ -2550,7 +2827,7 @@ var ObservedPeerConnection = class extends import_events.EventEmitter {
     let observedMediaSource = this.observedMediaSources.get(stats.id);
     if (!observedMediaSource) {
       if (!stats.timestamp || !stats.id || !stats.kind) {
-        return logger.warn(
+        return logger3.warn(
           `ObservedPeerConnection received an invalid InboundRtpStats (missing timestamp OR id OR kind field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`,
           stats
         );
@@ -2574,7 +2851,7 @@ var ObservedPeerConnection = class extends import_events.EventEmitter {
     let observedOutboundRtp = this.observedOutboundRtps.get(stats.ssrc);
     if (!observedOutboundRtp) {
       if (!stats.timestamp || !stats.id || !stats.ssrc || !stats.kind) {
-        return logger.warn(
+        return logger3.warn(
           `ObservedPeerConnection received an invalid OutboundRtpStats (missing timestamp OR id OR ssrc OR kind field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`,
           stats
         );
@@ -2599,7 +2876,7 @@ var ObservedPeerConnection = class extends import_events.EventEmitter {
     let observedOutboundTrack = this.observedOutboundTracks.get(stats.id);
     if (!observedOutboundTrack) {
       if (!stats.timestamp || !stats.id || !stats.kind) {
-        return logger.warn(
+        return logger3.warn(
           `ObservedPeerConnection received an invalid OutboundTrackSample (missing timestamp OR id OR kind field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`,
           stats
         );
@@ -2627,7 +2904,7 @@ var ObservedPeerConnection = class extends import_events.EventEmitter {
     let observedPeerConnectionTransport = this.observedPeerConnectionTransports.get(stats.id);
     if (!observedPeerConnectionTransport) {
       if (!stats.timestamp || !stats.id) {
-        return logger.warn(
+        return logger3.warn(
           `ObservedPeerConnection received an invalid PeerConnectionTransportStats (missing timestamp OR id field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`,
           stats
         );
@@ -2646,7 +2923,7 @@ var ObservedPeerConnection = class extends import_events.EventEmitter {
     let observedRemoteInboundRtp = this.observedRemoteInboundRtps.get(stats.ssrc);
     if (!observedRemoteInboundRtp) {
       if (!stats.timestamp || !stats.id || !stats.ssrc || !stats.kind) {
-        return logger.warn(
+        return logger3.warn(
           `ObservedPeerConnection received an invalid RemoteInboundRtpStats (missing timestamp OR id OR ssrc OR kind field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`,
           stats
         );
@@ -2671,7 +2948,7 @@ var ObservedPeerConnection = class extends import_events.EventEmitter {
     let observedRemoteOutboundRtp = this.observedRemoteOutboundRtps.get(stats.ssrc);
     if (!observedRemoteOutboundRtp) {
       if (!stats.timestamp || !stats.id || !stats.ssrc || !stats.kind) {
-        return logger.warn(
+        return logger3.warn(
           `ObservedPeerConnection received an invalid RemoteOutboundRtpStats (missing timestamp OR id OR ssrc OR kind field). PeerConnectionId: ${this.peerConnectionId} ClientId: ${this.client.clientId}, CallId: ${this.client.call.callId}`,
           stats
         );
@@ -2753,6 +3030,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";
@@ -2770,31 +3048,27 @@ function baseIssueType(type) {
 }
 
 // src/ObservedClient.ts
-var logger2 = createLogger("ObservedClient");
-var ObservedClient = class extends import_events2.EventEmitter {
+var logger4 = 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 import_node_events3.EventEmitter {
   constructor(settings, call, activeIssues) {
     super();
     this.call = call;
     this.setMaxListeners(Infinity);
     this.eventScope = { observer: call.observer, observedCall: call, observedClient: this };
-    this.sink = call.observer.config.createClientSink?.({ clientId: settings.clientId, observedCall: call });
     this.clientId = settings.clientId;
     this.appData = settings.appData ?? {};
     this.settings = {
       closeClientIfIdleForMs: settings.closeClientIfIdleForMs
     };
-    if (this.sink) {
-      const onError = (err) => logger2.warn("ClientSampleSink error for client %s: %o", this.clientId, err);
-      this.sink.once("close", () => this.sink?.off("error", onError));
-      this.sink.on("error", onError);
-    }
     this.activeIssues = activeIssues;
   }
   call;
   clientId;
   observedPeerConnections = /* @__PURE__ */ new Map();
-  /** Per-client sink (from `ObserverConfig.createClientSink`), if any. */
-  sink;
   /** Ancestry base shared by all Observer-bus events originating at this client. */
   eventScope;
   calculatedScore = {
@@ -2835,10 +3109,6 @@ var ObservedClient = class extends import_events2.EventEmitter {
   deltaOutboundPacketsSent = 0;
   deltaTransportSentBytes = 0;
   deltaTransportReceivedBytes = 0;
-  deltaRttLt50Measurements = 0;
-  deltaRttLt150Measurements = 0;
-  deltaRttLt300Measurements = 0;
-  deltaRttGtOrEq300Measurements = 0;
   currentMaxRttInMs;
   currentMinRttInMs;
   currentAvgRttInMs;
@@ -2854,8 +3124,73 @@ var ObservedClient = class extends import_events2.EventEmitter {
   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).
@@ -2868,12 +3203,17 @@ var ObservedClient = class extends import_events2.EventEmitter {
   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. */
+  /**
+   * The sink this client's samples are written to: whatever is registered under its client id in
+   * `call.sinks` (the `createClientJsonlSink` file, or a sink the application added), if any.
+   */
+  get sink() {
+    return this.call.sinks.get(this.clientId);
+  }
   get publicAddresses() {
     const result = /* @__PURE__ */ new Set();
     for (const observedPeerConnection of this.observedPeerConnections.values()) {
@@ -2887,6 +3227,61 @@ var ObservedClient = class extends import_events2.EventEmitter {
   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) {
@@ -2913,12 +3308,12 @@ var ObservedClient = class extends import_events2.EventEmitter {
     try {
       this.sink?.end();
     } catch (err) {
-      logger2.warn("ClientSampleSink.end failed for client %s: %o", this.clientId, err);
+      logger4.warn("Sink end failed for client %s: %o", this.clientId, err);
     }
   }
   accept(sample, context) {
     if (this.closed) {
-      logger2.warn("Attempted to accept a sample on a closed client %s", this.clientId);
+      logger4.warn("Attempted to accept a sample on a closed client %s", this.clientId);
       return;
     }
     if (this.closeTimer) {
@@ -2930,6 +3325,10 @@ var ObservedClient = class extends import_events2.EventEmitter {
     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;
@@ -2946,10 +3345,6 @@ var ObservedClient = class extends import_events2.EventEmitter {
     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;
@@ -3021,6 +3416,18 @@ var ObservedClient = class extends import_events2.EventEmitter {
       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;
@@ -3028,17 +3435,9 @@ var ObservedClient = class extends import_events2.EventEmitter {
         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) {
@@ -3048,6 +3447,7 @@ var ObservedClient = class extends import_events2.EventEmitter {
     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;
@@ -3063,15 +3463,34 @@ var ObservedClient = class extends import_events2.EventEmitter {
       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(() => {
@@ -3084,7 +3503,7 @@ var ObservedClient = class extends import_events2.EventEmitter {
     try {
       this.sink?.write(sample);
     } catch (err) {
-      logger2.warn("ClientSampleSink.write failed for client %s: %o", this.clientId, err);
+      logger4.warn("Sink write failed for client %s: %o", this.clientId, err);
     }
   }
   injectMetaData(metaData) {
@@ -3162,6 +3581,13 @@ var ObservedClient = class extends import_events2.EventEmitter {
         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 });
   }
@@ -3182,6 +3608,11 @@ var ObservedClient = class extends import_events2.EventEmitter {
     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);
@@ -3255,10 +3686,10 @@ var ObservedClient = class extends import_events2.EventEmitter {
             this._notify("client-rejoined", { ...this.eventScope, timestamp: event.timestamp });
           } else {
             this.joinedAt = event.timestamp;
-            logger2.warn(`Client ${this.clientId} joinedAt timestamp was updated to ${event.timestamp}. the joined event will not be emitted.`);
+            logger4.warn(`Client ${this.clientId} joinedAt timestamp was updated to ${event.timestamp}. the joined event will not be emitted.`);
           }
         }
-        logger2.debug("Client %s joined at %o", this.clientId, event);
+        logger4.debug("Client %s joined at %o", this.clientId, event);
         break;
       }
       case "CLIENT_LEFT" /* CLIENT_LEFT */: {
@@ -3268,10 +3699,10 @@ var ObservedClient = class extends import_events2.EventEmitter {
             this.emit("left");
             this._notify("client-left", { ...this.eventScope });
           } else {
-            logger2.warn(`Client ${this.clientId} leftAt timestamp was already set`);
+            logger4.warn(`Client ${this.clientId} leftAt timestamp was already set`);
           }
         }
-        logger2.debug("Client %s left at %o", this.clientId, event);
+        logger4.debug("Client %s left at %o", this.clientId, event);
         break;
       }
       case "PEER_CONNECTION_OPENED" /* PEER_CONNECTION_OPENED */: {
@@ -3283,7 +3714,7 @@ var ObservedClient = class extends import_events2.EventEmitter {
           } else if (postBuffer) {
             postBuffer.push(event);
           } else {
-            logger2.warn("Received PEER_CONNECTION_OPENED event without a corresponding observedPeerConnection: %o", event);
+            logger4.warn("Received PEER_CONNECTION_OPENED event without a corresponding observedPeerConnection: %o", event);
           }
         }
         break;
@@ -3300,7 +3731,7 @@ var ObservedClient = class extends import_events2.EventEmitter {
           } else if (postBuffer) {
             postBuffer.push(event);
           } else {
-            logger2.warn("Received PEER_CONNECTION_CLOSED event without a corresponding observedPeerConnection: %o", event);
+            logger4.warn("Received PEER_CONNECTION_CLOSED event without a corresponding observedPeerConnection: %o", event);
           }
         }
         break;
@@ -3315,7 +3746,7 @@ var ObservedClient = class extends import_events2.EventEmitter {
           } else if (postBuffer) {
             postBuffer.push(event);
           } else {
-            logger2.warn("Received MEDIA_TRACK_ADDED event without a corresponding observedPeerConnection or observedTrack: %o", event);
+            logger4.warn("Received MEDIA_TRACK_ADDED event without a corresponding observedPeerConnection or observedTrack: %o", event);
           }
         }
         break;
@@ -3330,7 +3761,7 @@ var ObservedClient = class extends import_events2.EventEmitter {
           } else if (postBuffer) {
             postBuffer.push(event);
           } else {
-            logger2.warn("Received MEDIA_TRACK_REMOVED event without a corresponding observedPeerConnection or observedTrack: %o", event);
+            logger4.warn("Received MEDIA_TRACK_REMOVED event without a corresponding observedPeerConnection or observedTrack: %o", event);
           }
         }
         break;
@@ -3345,7 +3776,7 @@ var ObservedClient = class extends import_events2.EventEmitter {
           } else if (postBuffer) {
             postBuffer.push(event);
           } else {
-            logger2.warn("Received DATA_CHANNEL_OPENED event without a corresponding observedPeerConnection or observedDataChannel: %o", event);
+            logger4.warn("Received DATA_CHANNEL_OPENED event without a corresponding observedPeerConnection or observedDataChannel: %o", event);
           }
         }
         break;
@@ -3360,7 +3791,7 @@ var ObservedClient = class extends import_events2.EventEmitter {
           } else if (postBuffer) {
             postBuffer.push(event);
           } else {
-            logger2.warn("Received DATA_CHANNEL_CLOSE event without a corresponding observedPeerConnection or observedDataChannel: %o", event);
+            logger4.warn("Received DATA_CHANNEL_CLOSE event without a corresponding observedPeerConnection or observedDataChannel: %o", event);
           }
         }
         break;
@@ -3380,7 +3811,7 @@ var ObservedClient = class extends import_events2.EventEmitter {
           } else if (postBuffer) {
             postBuffer.push(event);
           } else {
-            logger2.warn("Received MEDIA_TRACK_MUTED event without a corresponding observedPeerConnection or observedTrack: %o", event);
+            logger4.warn("Received MEDIA_TRACK_MUTED event without a corresponding observedPeerConnection or observedTrack: %o", event);
           }
         }
         break;
@@ -3400,7 +3831,7 @@ var ObservedClient = class extends import_events2.EventEmitter {
           } else if (postBuffer) {
             postBuffer.push(event);
           } else {
-            logger2.warn("Received MEDIA_TRACK_UNMUTED event without a corresponding observedPeerConnection or observedTrack: %o", event);
+            logger4.warn("Received MEDIA_TRACK_UNMUTED event without a corresponding observedPeerConnection or observedTrack: %o", event);
           }
         }
         break;
@@ -3415,7 +3846,7 @@ var ObservedClient = class extends import_events2.EventEmitter {
           } else if (postBuffer) {
             postBuffer.push(event);
           } else {
-            logger2.warn("Received ICE_CONNECTION_STATE_CHANGED event without a corresponding observedPeerConnection: %o", event);
+            logger4.warn("Received ICE_CONNECTION_STATE_CHANGED event without a corresponding observedPeerConnection: %o", event);
           }
         }
         break;
@@ -3430,7 +3861,7 @@ var ObservedClient = class extends import_events2.EventEmitter {
           } else if (postBuffer) {
             postBuffer.push(event);
           } else {
-            logger2.warn("Received ICE_GATHERING_STATE_CHANGED event without a corresponding observedPeerConnection: %o", event);
+            logger4.warn("Received ICE_GATHERING_STATE_CHANGED event without a corresponding observedPeerConnection: %o", event);
           }
         }
         break;
@@ -3445,7 +3876,7 @@ var ObservedClient = class extends import_events2.EventEmitter {
           } else if (postBuffer) {
             postBuffer.push(event);
           } else {
-            logger2.warn("Received PEER_CONNECTION_STATE_CHANGED event without a corresponding observedPeerConnection: %o", event);
+            logger4.warn("Received PEER_CONNECTION_STATE_CHANGED event without a corresponding observedPeerConnection: %o", event);
           }
         }
         break;
@@ -3464,11 +3895,11 @@ var ObservedClient = class extends import_events2.EventEmitter {
     let observedPeerConnection = this.observedPeerConnections.get(sample.peerConnectionId);
     if (!observedPeerConnection) {
       if (this._closedPeerConnectionIds.has(sample.peerConnectionId)) {
-        logger2.debug("Ignoring stats of peer connection %s, already closed by client %s", sample.peerConnectionId, this.clientId);
+        logger4.debug("Ignoring stats of peer connection %s, already closed by client %s", sample.peerConnectionId, this.clientId);
         return void 0;
       }
       if (!sample.peerConnectionId) {
-        return logger2.warn(
+        return logger4.warn(
           `ObservedClient received an invalid PeerConnectionSample (missing peerConnectionId field). ClientId: ${this.clientId}, CallId: ${this.call.callId}`,
           sample
         ), void 0;
@@ -3528,7 +3959,7 @@ var ObservedClient = class extends import_events2.EventEmitter {
     try {
       this.sink?.write(finalSample);
     } catch (err) {
-      logger2.warn("ClientSampleSink.write failed during injection flush for client %s: %o", this.clientId, err);
+      logger4.warn("Sink write failed during injection flush for client %s: %o", this.clientId, err);
     }
   }
   /** Emit an Observer-bus event scoped to this client (or a peer connection under it). */
@@ -3556,7 +3987,7 @@ var DefaultCallScoreCalculator = class {
 };
 
 // src/detectors/Detectors.ts
-var logger3 = createLogger("Detectors");
+var logger5 = createLogger("Detectors");
 var Detectors = class {
   _detectors;
   constructor(...detectors) {
@@ -3637,7 +4068,7 @@ var Detectors = class {
       try {
         detector.update();
       } catch (err) {
-        logger3.warn(`Error updating detector ${detector?.name}`, err);
+        logger5.warn(`Error updating detector ${detector?.name}`, err);
       }
     }
   }
@@ -3650,7 +4081,7 @@ var Detectors = class {
     try {
       detector.close?.();
     } catch (err) {
-      logger3.warn(`Error closing detector ${detector?.name}`, err);
+      logger5.warn(`Error closing detector ${detector?.name}`, err);
     }
   }
 };
@@ -4453,9 +4884,172 @@ 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 import_events3.EventEmitter {
+var logger6 = createLogger("ObservedCall");
+var ObservedCall = class extends import_node_events4.EventEmitter {
   constructor(settings, observer, activeIssuesRegistry) {
     super();
     this.observer = observer;
@@ -4463,6 +5057,8 @@ var ObservedCall = class extends import_events3.EventEmitter {
     this.setMaxListeners(Infinity);
     this.eventScope = { observer: this.observer, observedCall: this };
     this.callId = settings.callId;
+    this.sinks = new SinkRegistry(this.observer.sinks);
+    this.extensionStats = new ExtensionStatsRegistry(this.callId, this.sinks);
     this.appData = settings.appData ?? {};
     this.scoreCalculator = new DefaultCallScoreCalculator(this);
     this.detectors = new Detectors();
@@ -4511,10 +5107,6 @@ var ObservedCall = class extends import_events3.EventEmitter {
   numberOfDataChannels = 0;
   maxNumberOfClients = 0;
   deltaNumberOfIssues = 0;
-  // public deltaRttLt50Measurements = 0;
-  // public deltaRttLt150Measurements = 0;
-  // public deltaRttLt300Measurements = 0;
-  // public deltaRttGtOrEq300Measurements = 0;
   appData;
   closed = false;
   startedAt;
@@ -4523,6 +5115,8 @@ var ObservedCall = class extends import_events3.EventEmitter {
   settings;
   /** Ancestry base shared by all Observer-bus events originating at this call. */
   eventScope;
+  sinks;
+  extensionStats;
   closeTimer;
   get numberOfClients() {
     return this.observedClients.size;
@@ -4560,8 +5154,12 @@ var ObservedCall = class extends import_events3.EventEmitter {
         detector = new PublisherFaultCorroborationDetector(this, config);
         break;
       }
+      case AudioEchoDetector.NAME: {
+        detector = new AudioEchoDetector(this, config);
+        break;
+      }
       default: {
-        logger4.warn("Unknown detector name %s; skipping", name);
+        logger6.warn("Unknown detector name %s; skipping", name);
         return this;
       }
     }
@@ -4631,6 +5229,8 @@ var ObservedCall = class extends import_events3.EventEmitter {
       if (client.joinedAt) minSampleTimestamps = Math.min(minSampleTimestamps ?? client.joinedAt, client.joinedAt);
       if (client.leftAt) maxSampleTimestamps = Math.max(maxSampleTimestamps ?? client.leftAt, client.leftAt);
     }
+    this.extensionStats.close();
+    this.sinks.clear();
     if (this.startedAt === void 0) this.startedAt = minSampleTimestamps;
     if (this.endedAt === void 0) this.endedAt = maxSampleTimestamps;
     this.closedAt = Date.now();
@@ -4643,17 +5243,26 @@ var ObservedCall = class extends import_events3.EventEmitter {
     this.emit("close");
     this._notify("call-closed", { ...this.eventScope });
   }
+  createExtensionStats(settings) {
+    return this.extensionStats.create(settings);
+  }
+  acceptExtensionStats(id, data) {
+    this.extensionStats.accept(id, data);
+  }
+  getExtensionStats(id) {
+    return this.extensionStats.get(id);
+  }
   getObservedClient(clientId) {
     if (this.closed || !this.observedClients.has(clientId)) return;
     return this.observedClients.get(clientId);
   }
   createObservedClient(settings, acceptCtx) {
     if (this.closed) {
-      logger4.warn("Attempted to create a client (clientId: %s) on a closed call %s", settings.clientId, this.callId);
+      logger6.warn("Attempted to create a client (clientId: %s) on a closed call %s", settings.clientId, this.callId);
       return void 0;
     }
     if (this.observedClients.has(settings.clientId)) {
-      logger4.warn("Client with id %s already exists in call %s; returning the existing instance", settings.clientId, this.callId);
+      logger6.warn("Client with id %s already exists in call %s; returning the existing instance", settings.clientId, this.callId);
       return this.observedClients.get(settings.clientId);
     }
     const clientSettings = {
@@ -4703,10 +5312,17 @@ var ObservedCall = class extends import_events3.EventEmitter {
       clearTimeout(this.closeTimer);
       this.closeTimer = void 0;
     }
+    const jsonlPath = this.observer.config.createClientJsonlSink?.({ observedCall: this, clientId: settings.clientId });
+    let jsonlSink;
+    if (jsonlPath !== void 0 && this.observer.sinks.get(settings.clientId)) {
+      logger6.warn("No sample file for client %s in call %s: sink id %s is already in use", settings.clientId, this.callId, settings.clientId);
+    } else if (jsonlPath !== void 0) {
+      jsonlSink = this.sinks.create(JsonlFileSink, { id: settings.clientId, path: jsonlPath });
+    }
     this.emit("newclient", result);
     this._notify("client-added", { ...this.eventScope, observedClient: result });
-    if (result.sink) {
-      this._notify("client-sink-created", { ...this.eventScope, observedClient: result, sink: result.sink });
+    if (jsonlSink) {
+      this._notify("client-sink-created", { ...this.eventScope, observedClient: result, sink: jsonlSink });
     }
     if (wasEmpty) {
       this.emit("not-empty");
@@ -4759,10 +5375,10 @@ var ObservedCall = class extends import_events3.EventEmitter {
 };
 
 // src/Observer.ts
-var import_events6 = require("events");
+var import_node_events7 = require("events");
 
 // src/ObservedTURN.ts
-var import_events4 = require("events");
+var import_node_events5 = require("events");
 
 // src/ObservedTurnServer.ts
 var ObservedTurnServer = class {
@@ -4822,8 +5438,8 @@ var ObservedTurnServer = class {
 };
 
 // src/ObservedTURN.ts
-var logger5 = createLogger("ObservedTURN");
-var ObservedTURN = class extends import_events4.EventEmitter {
+var logger7 = createLogger("ObservedTURN");
+var ObservedTURN = class extends import_node_events5.EventEmitter {
   totalBytesSent = 0;
   totalBytesReceived = 0;
   totalPacketsSent = 0;
@@ -4852,12 +5468,12 @@ var ObservedTURN = class extends import_events4.EventEmitter {
   addPeerConnection(peerConnection) {
     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;
+      return logger7.warn(`Expected exactly one TURN pair, but found for peerconnection ${peerConnection.peerConnectionId}`, turnPairs.length), void 0;
     }
     const candidatePair = turnPairs[0];
     const rawUrl = candidatePair.getLocalCandidate()?.url;
     if (!rawUrl) {
-      return logger5.warn(`No local candidate URL found for peerconnection ${peerConnection.peerConnectionId}`), void 0;
+      return logger7.warn(`No local candidate URL found for peerconnection ${peerConnection.peerConnectionId}`), void 0;
     }
     const turnServerUrl = rawUrl.split("?")[0];
     let turnServer = this.servers.get(turnServerUrl);
@@ -4933,14 +5549,16 @@ var MiddlewareProcessor = class {
 };
 
 // src/ObservedMediasoupRouter.ts
-var import_events5 = require("events");
-var logger6 = createLogger("ObservedMediasoupRouter");
-var ObservedMediasoupRouter = class extends import_events5.EventEmitter {
+var import_node_events6 = require("events");
+var logger8 = createLogger("ObservedMediasoupRouter");
+var ObservedMediasoupRouter = class extends import_node_events6.EventEmitter {
   router;
   appData;
   sample;
   webrtcTransportIds = /* @__PURE__ */ new Set();
   closed = false;
+  sinks;
+  extensionStats;
   // 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();
@@ -4949,11 +5567,17 @@ var ObservedMediasoupRouter = class extends import_events5.EventEmitter {
   _dataProducerSamples = /* @__PURE__ */ new Map();
   _dataConsumerSamples = /* @__PURE__ */ new Map();
   _enrich;
-  constructor(settings) {
+  /**
+   * @param parentSinks the parent of `sinks`: `observer.sinks`, passed by
+   * `Observer.createObservedMediasoupRouter`. Internal; a router constructed directly has none.
+   */
+  constructor(settings, parentSinks) {
     super();
     this.router = settings.router;
     this.appData = settings.appData ?? {};
     this._enrich = settings.enrich;
+    this.sinks = new SinkRegistry(parentSinks);
+    this.extensionStats = new ExtensionStatsRegistry(this.router.id, this.sinks);
     this.sample = {
       routerId: this.router.id,
       attachments: settings.attachments ?? {},
@@ -5022,8 +5646,19 @@ var ObservedMediasoupRouter = class extends import_events5.EventEmitter {
     if (this.closed) return;
     this.closed = true;
     if (this.sample.closedAt === void 0) this.sample.closedAt = Date.now();
+    this.extensionStats.close();
+    this.sinks.clear();
     this.emit("close");
   }
+  createExtensionStats(settings) {
+    return this.extensionStats.create(settings);
+  }
+  acceptExtensionStats(id, data) {
+    this.extensionStats.accept(id, data);
+  }
+  getExtensionStats(id) {
+    return this.extensionStats.get(id);
+  }
   addTransport = (transport) => {
     let transportType = transport.type;
     if (!transportType) {
@@ -5032,7 +5667,7 @@ var ObservedMediasoupRouter = class extends import_events5.EventEmitter {
       else if (transport.constructor.name === "PipeTransport") transportType = "pipe";
       else if (transport.constructor.name === "DirectTransport") transportType = "direct";
     }
-    if (!transportType) return logger6.warn(`Unknown transport type for transport ${transport.id}: ${transport.constructor.name}`);
+    if (!transportType) return logger8.warn(`Unknown transport type for transport ${transport.id}: ${transport.constructor.name}`);
     switch (transportType) {
       case "webrtc":
         return this.addWebRtcTransport(transport);
@@ -5043,7 +5678,7 @@ var ObservedMediasoupRouter = class extends import_events5.EventEmitter {
       case "direct":
         return this.addDirectTransport(transport);
       default:
-        return logger6.warn(`Unsupported transport type for transport ${transport.id}: ${transportType}`);
+        return logger8.warn(`Unsupported transport type for transport ${transport.id}: ${transportType}`);
     }
   };
   addWebRtcTransport(transport) {
@@ -5285,7 +5920,7 @@ var ObservedMediasoupRouter = class extends import_events5.EventEmitter {
       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);
+      logger8.warn("Mediasoup sample enricher threw for router %s: %o", this.id, err);
     }
   }
   _attachTransportObserverListeners(transport, transportSample, onClose) {
@@ -5310,7 +5945,7 @@ var ObservedMediasoupRouter = class extends import_events5.EventEmitter {
 };
 
 // src/issues/ActiveIssuesRegistry.ts
-var logger7 = createLogger("ActiveIssuesRegistry");
+var logger9 = createLogger("ActiveIssuesRegistry");
 var ActiveIssuesRegistry = class {
   constructor(parent) {
     this.parent = parent;
@@ -5396,7 +6031,7 @@ var ActiveIssuesRegistry = class {
     try {
       apply(target);
     } catch (err) {
-      logger7.warn("An issue tracker threw while being notified; continuing with the rest. %o", err);
+      logger9.warn("An issue tracker threw while being notified; continuing with the rest. %o", err);
     }
   }
 };
@@ -5425,7 +6060,7 @@ function createCallSummary(callId, config) {
 }
 
 // src/summaries/CallSummaryCollector.ts
-var logger8 = createLogger("CallSummaryCollector");
+var logger10 = createLogger("CallSummaryCollector");
 var CallSummaryCollector = class {
   constructor(_observer, _config) {
     this._observer = _observer;
@@ -5500,7 +6135,7 @@ var CallSummaryCollector = class {
       try {
         handler(summary, scratch, ...args);
       } catch (err) {
-        logger8.warn("A call-summary handler for %s threw; continuing. %o", event, err);
+        logger10.warn("A call-summary handler for %s threw; continuing. %o", event, err);
       }
     };
     this._observer.on(event, listener);
@@ -5925,7 +6560,7 @@ function geohash(location, precision = 3) {
 }
 
 // src/detectors/ClientPopulationIssueDetector.ts
-var logger9 = createLogger("ClientPopulationIssueDetector");
+var logger11 = createLogger("ClientPopulationIssueDetector");
 var ClientPopulationIssueTypes = {
   /** One issue type is concentrated on one client population while the rest of the fleet is fine. */
   clientPopulationIssue: "CLIENT_POPULATION_ISSUE"
@@ -5947,7 +6582,7 @@ var ClientPopulationIssueDetector = class _ClientPopulationIssueDetector {
       ...config
     };
     if (this._config.groupBy === "location" && !this._config.resolveClientLocation) {
-      logger9.warn(
+      logger11.warn(
         "%s is configured with groupBy: 'location' but no resolveClientLocation, so no client can be placed and nothing will ever be detected",
         this.name
       );
@@ -6781,11 +7416,13 @@ function mediaKindOf(mimeType) {
 }
 
 // src/Observer.ts
-var logger10 = createLogger("Observer");
-var Observer = class extends import_events6.EventEmitter {
+var logger12 = createLogger("Observer");
+var Observer = class extends import_node_events7.EventEmitter {
   observedTURN = new ObservedTURN();
   observedCalls = /* @__PURE__ */ new Map();
   observedMediasoupRouters = /* @__PURE__ */ new Map();
+  sinks = new SinkRegistry();
+  extensionStats = new ExtensionStatsRegistry("observer", this.sinks);
   /** Ancestry base shared by all Observer-bus events originating at the observer. */
   eventScope = { observer: this };
   config;
@@ -6900,7 +7537,7 @@ var Observer = class extends import_events6.EventEmitter {
         break;
       }
       default: {
-        logger10.warn("Unknown detector name %s; skipping", name);
+        logger12.warn("Unknown detector name %s; skipping", name);
         return this;
       }
     }
@@ -6985,7 +7622,7 @@ var Observer = class extends import_events6.EventEmitter {
         break;
     }
     if (!validator) {
-      logger10.warn("Unknown validator name %s; skipping", name);
+      logger12.warn("Unknown validator name %s; skipping", name);
       return this;
     }
     this.validators.add(validator);
@@ -7016,7 +7653,7 @@ var Observer = class extends import_events6.EventEmitter {
       try {
         validator.cancel(reason);
       } catch (err) {
-        logger10.warn("Error cancelling validator %s: %o", validator.name, err);
+        logger12.warn("Error cancelling validator %s: %o", validator.name, err);
       }
     }
     return matching.length;
@@ -7032,11 +7669,11 @@ var Observer = class extends import_events6.EventEmitter {
    */
   createObservedCall(settings, acceptCtx) {
     if (this.closed) {
-      logger10.warn("Attempted to create a call (callId: %s) on a closed observer", settings.callId);
+      logger12.warn("Attempted to create a call (callId: %s) on a closed observer", settings.callId);
       return void 0;
     }
     if (this.observedCalls.has(settings.callId)) {
-      logger10.warn("Observed Call with id %s already exists; returning the existing instance", settings.callId);
+      logger12.warn("Observed Call with id %s already exists; returning the existing instance", settings.callId);
       return this.observedCalls.get(settings.callId);
     }
     const callSettings = {
@@ -7074,14 +7711,14 @@ var Observer = class extends import_events6.EventEmitter {
   }
   createObservedMediasoupRouter(settings) {
     if (this.closed) {
-      logger10.warn("Attempted to create mediasoup router (id: %d) on a closed observer", settings.router.id);
+      logger12.warn("Attempted to create mediasoup router (id: %d) on a closed observer", settings.router.id);
       return void 0;
     }
     if (this.observedMediasoupRouters.has(settings.router.id)) {
-      logger10.warn("Observed Mediasoup Router (id %s) already exists; returning the existing instance", settings.router.id);
+      logger12.warn("Observed Mediasoup Router (id %s) already exists; returning the existing instance", settings.router.id);
       return this.observedMediasoupRouters.get(settings.router.id);
     }
-    const observedMediasoupRouter = new ObservedMediasoupRouter(settings);
+    const observedMediasoupRouter = new ObservedMediasoupRouter(settings, this.sinks);
     const observedMediasoupRouterScope = {
       observedMediasoupRouter,
       observer: this
@@ -7109,7 +7746,7 @@ var Observer = class extends import_events6.EventEmitter {
   }
   close() {
     if (this.closed) {
-      return logger10.debug("Attempted to close twice");
+      return logger12.debug("Attempted to close twice");
     }
     this.closed = true;
     for (const call of [...this.observedCalls.values()]) call.close();
@@ -7118,8 +7755,19 @@ var Observer = class extends import_events6.EventEmitter {
     this.validators.clear();
     this.callSummaryCollector?.close();
     this.activeIssuesRegistry.clear();
+    this.extensionStats.close();
+    this.sinks.clear();
     this._notify("observer-closed", { ...this.eventScope });
   }
+  createExtensionStats(settings) {
+    return this.extensionStats.create(settings);
+  }
+  acceptExtensionStats(id, data) {
+    this.extensionStats.accept(id, data);
+  }
+  getExtensionStats(id) {
+    return this.extensionStats.get(id);
+  }
   accept(sample, context) {
     if (this.closed) {
       return this._notify("sample-rejected", { ...this.eventScope, reason: "observer-closed", sample });
@@ -7127,7 +7775,7 @@ var Observer = class extends import_events6.EventEmitter {
     try {
       this.acceptMiddlewares.process({ sample, context });
     } catch (err) {
-      logger10.warn("An accept middleware threw; dropping the sample. %o", err);
+      logger12.warn("An accept middleware threw; dropping the sample. %o", err);
     }
     if (!sample.callId) {
       this._notify("sample-rejected", { ...this.eventScope, reason: "missing-callId", sample });
@@ -7167,7 +7815,7 @@ var Observer = class extends import_events6.EventEmitter {
       try {
         validator.update();
       } catch (err) {
-        logger10.warn("Error running validator %s: %o", validator.name, err);
+        logger12.warn("Error running validator %s: %o", validator.name, err);
       }
     }
     this._notify("observer-updated", { ...this.eventScope });
@@ -7403,67 +8051,34 @@ var TrendTester = class {
   }
 };
 
-// src/sinks/ClientSampleSink.ts
-var import_events7 = require("events");
-var ClientSampleSink = class extends import_events7.EventEmitter {
-};
-
-// src/sinks/JsonlFileSink.ts
-var fs = __toESM(require("fs"));
-var path = __toESM(require("path"));
-var JsonlFileSink = class extends ClientSampleSink {
-  /** The file this sink writes to. Read it (e.g. in a `close` handler) to upload/move the file. */
-  path;
-  _stream;
-  _serializeSample;
-  constructor(options) {
-    super();
-    this.path = options.path;
-    this._stream = fs.createWriteStream(this.path, { flags: "a" });
-    this._stream.on("close", () => this.emit("close"));
-    this._stream.on("finish", () => this.emit("finish"));
-    this._stream.on("drain", () => this.emit("drain"));
-    this._stream.on("error", (err) => this.emit("error", err));
-    this._serializeSample = options.serializeSample ?? ((sample) => JSON.stringify(sample));
-  }
-  write(sample) {
-    return this._stream.write(`${this._serializeSample(sample)}
-`);
-  }
-  end() {
-    this._stream.end();
-  }
-};
-function createJsonlFileSink(options) {
-  return new JsonlFileSink(options);
-}
-function createJsonlFileSinkFactory(options) {
-  return ({ clientId, observedCall }) => {
-    const filename = options.getFileName?.({ callId: observedCall.callId, clientId }) ?? `${observedCall.callId}__${clientId}.jsonl`;
-    return createJsonlFileSink({
-      path: path.join(options.directory, filename),
-      serializeSample: options.serializeSample
-    });
-  };
-}
-
 // src/sinks/InMemorySink.ts
-var InMemorySink = class extends ClientSampleSink {
-  constructor(samples = []) {
+var import_node_events8 = require("events");
+var InMemorySink = class extends import_node_events8.EventEmitter {
+  id;
+  samples;
+  _ended = false;
+  constructor(settings = {}) {
     super();
-    this.samples = samples;
+    this.id = settings.id ?? "in-memory";
+    this.samples = settings.samples ?? [];
+  }
+  get ended() {
+    return this._ended;
   }
-  samples;
   write(sample) {
+    if (this._ended) return false;
     this.samples.push(sample);
     return true;
   }
   end() {
+    if (this._ended) return;
+    this._ended = true;
+    this.emit("ended");
     this.emit("close");
   }
 };
 function createInMemorySink(samples) {
-  return new InMemorySink(samples);
+  return new InMemorySink({ samples });
 }
 
 // src/resolvers/RemoteTrackResolver.ts
@@ -7641,6 +8256,8 @@ function createP2pRemoteTrackResolverFactory() {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ActiveIssuesRegistry,
+  AudioEchoDetector,
+  AudioEchoTypes,
   CODEC_MISMATCH_ISSUE,
   CallConcurrentIssueDetector,
   CallConcurrentIssueTypes,
@@ -7650,9 +8267,9 @@ function createP2pRemoteTrackResolverFactory() {
   ClientMetaTypes,
   ClientPopulationIssueDetector,
   ClientPopulationIssueTypes,
-  ClientSampleSink,
   CodecConsistencyValidator,
   Detectors,
+  ExtensionStatsRegistry,
   GEOHASH_CELL_SIZES,
   InMemorySink,
   IssueFanOutDetector,
@@ -7688,10 +8305,15 @@ function createP2pRemoteTrackResolverFactory() {
   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,
+  SinkRegistry,
   SlidingWindow,
   TrackDeliveryMismatchDetector,
   TrackDeliveryMismatchTypes,
@@ -7712,7 +8334,6 @@ function createP2pRemoteTrackResolverFactory() {
   createDefaultMediasoupRemoteTrackResolverFactory,
   createInMemorySink,
   createJsonlFileSink,
-  createJsonlFileSinkFactory,
   createLogger,
   createP2pRemoteTrackResolverFactory,
   defaultCallSummaryConfig,
@@ -7727,6 +8348,7 @@ function createP2pRemoteTrackResolverFactory() {
   medianAbsoluteDeviation,
   pageHinkley,
   percentile,
+  percentileOfHistogram,
   percentileOfSorted,
   robustZScore,
   schemaVersion,