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

package/dist/index.d.ts

@@ -1,6 +1,128 @@
-import { EventEmitter } from 'events';
+import { EventEmitter } from 'node:events';
 import { types } from 'mediasoup';
 
+/** The lifecycle events a sink emits. */
+type SinkEvents = {
+    /**
+     * `end()` was called: the sink accepts no more writes. **Required**: a sink emits it
+     * synchronously, once, from `end()` — it is how its registry removes it and frees its id.
+     */
+    ended: [];
+    /** The destination is fully written and closed (e.g. a file flushed and its fd closed). */
+    close: [];
+    /** The destination failed. */
+    error: [Error];
+    /** All queued data was flushed (before `close`). */
+    finish: [];
+    /** The buffer drained after backpressure; safe to write more. */
+    drain: [];
+};
+/** What a registry passes to a sink's constructor. Implementations extend it with their own settings. */
+type SinkSettings = {
+    /** Unique per observer. The registry generates one (uuid v4) when it is omitted. */
+    id: string;
+};
+/**
+ * A destination for records. It is **object-mode** and agnostic about what passes through it:
+ * `write` receives the record itself, and the implementation decides how to serialize it (JSON
+ * line, protobuf, a remote payload, …). `JsonlFileSink` and `InMemorySink` are the built-in
+ * implementations; `ClientSampleSink` is `Sink<ClientSample>`.
+ *
+ * Create sinks with a registry's `create(SinkClass, settings)`, which constructs
+ * `new SinkClass({ ...settings, id })` and registers it on the object that owns its lifecycle.
+ * `end()` closes a sink and — through the `ended` event — removes it from its registry; the owner
+ * ends whatever is left when it closes.
+ *
+ * An implementation typically `extends EventEmitter implements Sink<T>`, and must:
+ * - emit `ended` synchronously, once, from `end()` (and make a second `end()` a no-op);
+ * - refuse writes after `end()` (return `false`);
+ * - emit `close` when the destination is ready, and `error` when it fails.
+ */
+interface Sink<T = unknown> {
+    readonly id: string;
+    /** Accept one record. `false` once ended (nothing written), or on backpressure. */
+    write(record: T): boolean;
+    /** No more writes; emit `ended`, then flush and emit `close`. Idempotent. */
+    end(): void;
+    on(event: keyof SinkEvents, listener: (...args: any[]) => void): this;
+    once(event: keyof SinkEvents, listener: (...args: any[]) => void): this;
+    off(event: keyof SinkEvents, listener: (...args: any[]) => void): this;
+}
+
+/** A sink class `SinkRegistry.create` can construct: its constructor takes one settings object (with `id`). */
+type SinkConstructor = new (settings: any) => Sink<any>;
+/** The settings `create` takes for `SinkClass`: its constructor's, with `id` optional. */
+type SinkCreateSettings<C extends SinkConstructor> = Omit<ConstructorParameters<C>[0], 'id'> & {
+    id?: string;
+};
+/**
+ * The sinks of one object, ended by that object's lifecycle. `create(SinkClass, settings)` builds a
+ * sink and registers it; `sink.end()` closes it and removes it; the owner calls `clear()` when it
+ * closes, ending whatever is left.
+ *
+ * Registries form a tree like the issue registries: `observer.sinks` is the parent of every
+ * `observedCall.sinks` and `observedMediasoupRouter.sinks`. **A sink id is unique per observer**:
+ * `create` refuses an id that any registry of the tree holds. Each registry sees its own sinks and
+ * its descendants', so `get`, `write` and `clear` on a parent reach a child's sinks too.
+ *
+ * A client's sample sink is the one under its client id in its call's registry.
+ */
+declare class SinkRegistry {
+    readonly parent?: SinkRegistry | undefined;
+    private readonly _sinks;
+    constructor(parent?: SinkRegistry | undefined);
+    /** Number of open sinks in this registry and its descendants. */
+    get size(): number;
+    keys(): IterableIterator<string>;
+    values(): IterableIterator<Sink<any>>;
+    get<T extends Sink<any> = Sink>(id: string): T | undefined;
+    /**
+     * 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<C extends SinkConstructor>(SinkClass: C, settings: SinkCreateSettings<C>): InstanceType<C> | undefined;
+    /** Write `record` to the sink `id`. `false` when there is no such sink, or on backpressure. */
+    write(id: string, record: unknown): boolean;
+    /** End every sink of this registry and of its descendants. */
+    clear(): void;
+    /** This registry and its ancestors, up to the root. */
+    private _lineage;
+}
+
+/** The settings of `createExtensionStats` on an observer, a call or a mediasoup router. */
+type CreateExtensionStatsSettings<C extends SinkConstructor> = {
+    /** Unique per observer: it is also the id of the sink that receives the stats. */
+    id: string;
+    /** What `sinks.create` takes; the sink is created under `id` (an `id` in its settings is ignored). */
+    createSink?: [SinkClass: C, settings: Omit<SinkCreateSettings<C>, 'id'>];
+};
+/**
+ * The extension stats of one object — `observer.extensionStats`, `observedCall.extensionStats`,
+ * `observedMediasoupRouter.extensionStats`: the last data per id (`values`), written to the
+ * object's sink with the same id. The owner closes it when it closes.
+ */
+declare class ExtensionStatsRegistry {
+    /** The owner's id (call id, router id, or `observer`), used in log messages. */
+    readonly id: string;
+    private readonly _sinks;
+    /** The last data accepted for each extension stats id. */
+    readonly values: Map<string, unknown>;
+    closed: boolean;
+    constructor(
+    /** The owner's id (call id, router id, or `observer`), used in log messages. */
+    id: string, _sinks: SinkRegistry);
+    /**
+     * 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(): void;
+    create<C extends SinkConstructor>(settings: CreateExtensionStatsSettings<C>): InstanceType<C> | undefined;
+    accept(id: string, data: unknown): void;
+    get<T>(id: string): T | undefined;
+}
+
 declare const schemaVersion = "3.7.0";
 /**
 * The WebRTC app provided custom stats payload
@@ -1479,6 +1601,16 @@ declare class ObservedMediaSource implements MediaSourceStats {
     frames?: number | undefined;
     framesPerSecond?: number | undefined;
     attachments?: Record<string, unknown> | undefined;
+    /** Increase of `totalAudioEnergy` in this tick (audio only). */
+    deltaTotalAudioEnergy: number;
+    /** Increase of `totalSamplesDuration` in this tick, in seconds (audio only). */
+    deltaTotalSamplesDuration: number;
+    /**
+     * 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?: number;
     constructor(timestamp: number, id: string, kind: MediaKind, _peerConnection: ObservedPeerConnection);
     get visited(): boolean;
     getPeerConnection(): ObservedPeerConnection;
@@ -1932,6 +2064,67 @@ declare function mannKendall(values: number[], alpha?: number): MannKendallResul
  * recomputing every pair from scratch) doesn't have to reimplement the normal approximation.
  */
 declare function mannKendallVerdict(s: number, variance: number, alpha?: number): Pick<MannKendallResult, 'z' | 'pValue' | 'trend'>;
+/**
+ * Estimates the p-th percentile (0..1) of the values counted in `histogram`, whose bucket `i`
+ * holds the values in `[i * bucketWidth, (i + 1) * bucketWidth)`. Interpolates linearly inside
+ * the bucket the rank falls in, so the error is at most one bucket width. With `openEnded`, the
+ * last bucket holds every value above its lower bound, and a percentile falling in it is reported
+ * as `max`. With `min`/`max` (the observed extremes), the bucket holding them is narrowed to the
+ * observed range before interpolating, so the estimate never leaves `[min, max]`. `undefined` for an
+ * empty histogram.
+ */
+declare function percentileOfHistogram(histogram: readonly number[], bucketWidth: number, p: number, options?: {
+    min?: number;
+    max?: number;
+    openEnded?: boolean;
+}): number | undefined;
+
+declare enum ClientMetaTypes {
+    MEDIA_CONSTRAINT = "MEDIA_CONSTRAINT",
+    MEDIA_DEVICE = "MEDIA_DEVICE",
+    MEDIA_DEVICES_SUPPORTED_CONSTRAINTS = "MEDIA_DEVICES_SUPPORTED_CONSTRAINTS",
+    USER_MEDIA_ERROR = "USER_MEDIA_ERROR",
+    LOCAL_SDP = "LOCAL_SDP",
+    AUDIO_INPUT_DEVICE = "AUDIO_INPUT_DEVICE",
+    OPERATION_SYSTEM = "OPERATION_SYSTEM",
+    ENGINE = "ENGINE",
+    PLATFORM = "PLATFORM",
+    BROWSER = "BROWSER"
+}
+type MediaDeviceInfo = {
+    deviceId: string;
+    label: string;
+    kind: string;
+    groupId: string;
+};
+/**
+ * Payload of `AUDIO_INPUT_DEVICE`: which device an outbound audio track captures from. Sent by the
+ * client once per track, when it is first monitored.
+ */
+type AudioInputDevice = {
+    peerConnectionId: string;
+    trackId: string;
+    /** `MediaStreamTrack.label`; empty when capture permission was not yet granted. */
+    label: string;
+    deviceId?: string;
+    groupId?: string;
+};
+type Browser = {
+    name: string;
+    version: string;
+};
+type Platform = {
+    name: string;
+    version: string;
+};
+type Engine = {
+    name: string;
+    version: string;
+};
+type OperationSystem = {
+    name: string;
+    version: string;
+};
 
 /** The per-receiver view the aggregator builds for one subscribed track. */
 type PublishedTrackReceivingDistributionEntry = {
@@ -1983,6 +2176,20 @@ declare class ObservedOutboundTrack implements OutboundTrackSample {
     remoteFractionLost?: number | undefined;
     remoteRttInMs?: number | undefined;
     qualityLimitationReason?: string | undefined;
+    /**
+     * 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?: number;
+    rmsAudioLevelSource?: 'media-source' | 'receivers';
+    /**
+     * 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?: number;
     constructor(timestamp: number, id: string, kind: MediaKind, _peerConnection: ObservedPeerConnection, _outboundRtps?: ObservedOutboundRtp[] | undefined, _mediaSource?: ObservedMediaSource | undefined);
     get score(): number | undefined;
     get visited(): boolean;
@@ -1990,7 +2197,10 @@ declare class ObservedOutboundTrack implements OutboundTrackSample {
     getPeerConnection(): ObservedPeerConnection;
     getOutboundRtps(): ObservedOutboundRtp[] | undefined;
     getMediaSource(): ObservedMediaSource | undefined;
+    /** The capture device behind this track, when the client sent `AUDIO_INPUT_DEVICE` metadata for it. */
+    get audioInputDevice(): AudioInputDevice | undefined;
     update(stats: OutboundTrackSample): void;
+    private _updateAudioLevel;
     private createReceivingDistribution;
 }
 
@@ -2146,6 +2356,15 @@ declare class ObservedInboundRtp implements InboundRtpStats {
     deltaFecPacketsReceived: number;
     deltaFecPacketsDiscarded: number;
     deltaPausesDuration: number;
+    deltaTotalAudioEnergy: number;
+    deltaTotalSamplesDuration: number;
+    /**
+     * 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?: number;
     /**
      * 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
@@ -2447,40 +2666,6 @@ declare class ObservedPeerConnection extends EventEmitter {
     private _notify;
 }
 
-declare enum ClientMetaTypes {
-    MEDIA_CONSTRAINT = "MEDIA_CONSTRAINT",
-    MEDIA_DEVICE = "MEDIA_DEVICE",
-    MEDIA_DEVICES_SUPPORTED_CONSTRAINTS = "MEDIA_DEVICES_SUPPORTED_CONSTRAINTS",
-    USER_MEDIA_ERROR = "USER_MEDIA_ERROR",
-    LOCAL_SDP = "LOCAL_SDP",
-    OPERATION_SYSTEM = "OPERATION_SYSTEM",
-    ENGINE = "ENGINE",
-    PLATFORM = "PLATFORM",
-    BROWSER = "BROWSER"
-}
-type MediaDeviceInfo = {
-    deviceId: string;
-    label: string;
-    kind: string;
-    groupId: string;
-};
-type Browser = {
-    name: string;
-    version: string;
-};
-type Platform = {
-    name: string;
-    version: string;
-};
-type Engine = {
-    name: string;
-    version: string;
-};
-type OperationSystem = {
-    name: string;
-    version: string;
-};
-
 /**
  * Turning a correlation into a **conclusion**.
  *
@@ -2962,52 +3147,38 @@ declare function isClientIssueResolutionEntry(issue: ClientIssue): boolean;
 /** Strip the `-resolved` suffix, so both entries of a lifecycle share one logical type. */
 declare function baseIssueType(type: string): string;
 
-/** The lifecycle events a sink may emit (a subset of Node's writable-stream events). */
-type ClientSampleSinkEvents = {
-    /** The destination is fully written and closed (e.g. a file flushed and its fd closed). */
-    close: [];
-    /** The destination failed. */
-    error: [Error];
-    /** `end()` was processed and all queued data was flushed (before `close`). */
-    finish: [];
-    /** The buffer drained after backpressure; safe to write more. */
-    drain: [];
+type JsonlFileSinkOptions<T = ClientSample> = Partial<SinkSettings> & {
+    /** Absolute or relative file path to append JSONL lines to. */
+    path: string;
+    /** Optional custom serializer; defaults to `JSON.stringify`. */
+    serializeSample?: (record: T) => string;
 };
-declare interface ClientSampleSink {
-    on<E extends keyof ClientSampleSinkEvents>(event: E, listener: (...args: ClientSampleSinkEvents[E]) => void): this;
-    once<E extends keyof ClientSampleSinkEvents>(event: E, listener: (...args: ClientSampleSinkEvents[E]) => void): this;
-    off<E extends keyof ClientSampleSinkEvents>(event: E, listener: (...args: ClientSampleSinkEvents[E]) => void): this;
-    emit<E extends keyof ClientSampleSinkEvents>(event: E, ...args: ClientSampleSinkEvents[E]): boolean;
-}
 /**
- * A per-client destination for accepted samples — a typed `EventEmitter` base class. One sink is
- * created per `ObservedClient` (via `ObserverConfig.createClientSink`). It is **object-mode**:
- * `write` receives the `ClientSample` itself, so each sink decides how to serialize it (JSON
- * line, protobuf, msgpack, a remote payload, …).
- *
- * The library calls `write(sample)` synchronously per accepted sample (not awaited), `end()`s the
- * sink when the client closes, and attaches an `error` listener so a failing sink can't crash the
- * process. The application — which created the sink — listens for `close` (destination ready,
- * e.g. a file flushed and its fd closed) and `error`.
- *
- * Subclass this and implement `write`/`end` (and `emit` your lifecycle events). Built-in sinks
- * (`JsonlFileSink`, `InMemorySink`) and their factories are exported from the package root.
+ * A sink that serializes each record to a JSON line and appends it to a file. Defaults to client
+ * samples, but takes any record type: `sinks.create(JsonlFileSink<PipeTransportStats[]>, { id, path })`. It wraps an
+ * `fs.WriteStream` and re-emits its lifecycle events, so `close` fires once the file is flushed
+ * and its descriptor is closed (file ready) and `error` surfaces file errors.
  */
-declare abstract class ClientSampleSink extends EventEmitter {
-    /** Accept one sample; the sink serializes it however it likes. `false` signals backpressure. */
-    abstract write(sample: ClientSample): boolean;
-    /** Finish writing; the sink flushes and (if applicable) emits `close`. */
-    abstract end(): void;
+declare interface JsonlFileSink {
+    on<E extends keyof SinkEvents>(event: E, listener: (...args: SinkEvents[E]) => void): this;
+    once<E extends keyof SinkEvents>(event: E, listener: (...args: SinkEvents[E]) => void): this;
+    off<E extends keyof SinkEvents>(event: E, listener: (...args: SinkEvents[E]) => void): this;
+    emit<E extends keyof SinkEvents>(event: E, ...args: SinkEvents[E]): boolean;
 }
-/**
- * Produces a sink for a newly-created client, or `undefined` for no sink. Receives the
- * client id and its (already-created) parent call, so the destination can be derived
- * from `callId` / `clientId`.
- */
-type ClientSampleSinkFactory = (params: {
-    clientId: string;
-    observedCall: ObservedCall;
-}) => ClientSampleSink | undefined;
+declare class JsonlFileSink<T = ClientSample> extends EventEmitter implements Sink<T> {
+    readonly id: string;
+    /** The file this sink writes to. Read it (e.g. in a `close` handler) to upload/move the file. */
+    readonly path: string;
+    private readonly _stream;
+    private readonly _serializeSample;
+    private _ended;
+    constructor(options: JsonlFileSinkOptions<T>);
+    get ended(): boolean;
+    write(record: T): boolean;
+    end(): void;
+}
+/** Build a JSONL file sink for a single path. */
+declare function createJsonlFileSink<T = ClientSample>(options: JsonlFileSinkOptions<T>): JsonlFileSink<T>;
 
 /** mediasoup `TransportTuple` (the selected local/remote address pair of a transport). */
 type TransportTuple = {
@@ -3259,13 +3430,19 @@ declare class ObservedMediasoupRouter<AppData extends Record<string, unknown> =
     readonly sample: MediasoupRouterSample;
     readonly webrtcTransportIds: Set<string>;
     closed: boolean;
+    readonly sinks: SinkRegistry;
+    readonly extensionStats: ExtensionStatsRegistry;
     private readonly _transportSamples;
     private readonly _producerSamples;
     private readonly _consumerSamples;
     private readonly _dataProducerSamples;
     private readonly _dataConsumerSamples;
     private readonly _enrich?;
-    constructor(settings: ObservedMediasoupRouterSettings<AppData>);
+    /**
+     * @param parentSinks the parent of `sinks`: `observer.sinks`, passed by
+     * `Observer.createObservedMediasoupRouter`. Internal; a router constructed directly has none.
+     */
+    constructor(settings: ObservedMediasoupRouterSettings<AppData>, parentSinks?: SinkRegistry);
     get id(): string;
     get attachments(): Record<string, unknown>;
     getTransportSample(id: string): MediasoupTransportSample | undefined;
@@ -3290,6 +3467,9 @@ declare class ObservedMediasoupRouter<AppData extends Record<string, unknown> =
      */
     snapshot(): MediasoupRouterSample;
     close(): void;
+    createExtensionStats<C extends SinkConstructor>(settings: CreateExtensionStatsSettings<C>): InstanceType<C> | undefined;
+    acceptExtensionStats(id: string, data: unknown): void;
+    getExtensionStats<T>(id: string): T | undefined;
     addTransport: (transport: types.Transport) => void;
     addWebRtcTransport(transport: types.WebRtcTransport): void;
     addPlainTransport(transport: types.PlainTransport): void;
@@ -3385,7 +3565,7 @@ type ObserverEvents = {
     }];
     'client-added': [ObservedClientScope];
     'client-sink-created': [ObservedClientScope & {
-        sink: ClientSampleSink;
+        sink: JsonlFileSink;
     }];
     'client-updated': [ObservedClientScope & {
         sample: ClientSample;
@@ -3648,6 +3828,31 @@ declare class ObservedClientIssueRegistry {
     clear(): void;
 }
 
+/** Width of one `rttHistogram` bucket. */
+declare const RTT_HISTOGRAM_BUCKET_WIDTH_IN_MS = 20;
+/** Number of `rttHistogram` buckets: 0–960 ms in 20 ms steps, plus one bucket for 980 ms and above. */
+declare const RTT_HISTOGRAM_NUMBER_OF_BUCKETS = 50;
+/** Width of one `scoreHistogram` bucket. Scores are 0..5. */
+declare const SCORE_HISTOGRAM_BUCKET_WIDTH = 1;
+/** Number of `scoreHistogram` buckets: [0, 1), [1, 2), [2, 3), [3, 4) and [4, 5]. */
+declare const SCORE_HISTOGRAM_NUMBER_OF_BUCKETS = 5;
+/** Session RTT distribution of a client, in milliseconds, estimated from `rttHistogram`. */
+type RttSummary = {
+    p50: number | undefined;
+    p75: number | undefined;
+    p95: number | undefined;
+    p99: number | undefined;
+    avg: number | undefined;
+};
+/** Session score distribution of a client, estimated from `scoreHistogram`. */
+type ScoreSummary = {
+    p5: number | undefined;
+    p25: number | undefined;
+    p50: number | undefined;
+    p75: number | undefined;
+    p95: number | undefined;
+    avg: number | undefined;
+};
 type ObservedClientSettings<AppData extends Record<string, unknown> = Record<string, unknown>> = {
     clientId: string;
     appData?: AppData;
@@ -3669,8 +3874,6 @@ declare class ObservedClient<AppData extends Record<string, unknown> = Record<st
     readonly call: ObservedCall;
     readonly clientId: string;
     readonly observedPeerConnections: Map<string, ObservedPeerConnection>;
-    /** Per-client sink (from `ObserverConfig.createClientSink`), if any. */
-    readonly sink?: ClientSampleSink;
     /** Ancestry base shared by all Observer-bus events originating at this client. */
     readonly eventScope: ObservedClientScope;
     readonly calculatedScore: CalculatedScore;
@@ -3707,10 +3910,6 @@ declare class ObservedClient<AppData extends Record<string, unknown> = Record<st
     deltaOutboundPacketsSent: number;
     deltaTransportSentBytes: number;
     deltaTransportReceivedBytes: number;
-    deltaRttLt50Measurements: number;
-    deltaRttLt150Measurements: number;
-    deltaRttLt300Measurements: number;
-    deltaRttGtOrEq300Measurements: number;
     currentMaxRttInMs?: number;
     currentMinRttInMs?: number;
     currentAvgRttInMs?: number;
@@ -3726,7 +3925,67 @@ declare class ObservedClient<AppData extends Record<string, unknown> = Record<st
     deltaNumberOfIssues: number;
     totalScoreSum: number;
     numberOfScoreMeasurements: number;
+    minScore?: number;
+    maxScore?: number;
+    /**
+     * 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.
+     */
+    readonly scoreHistogram: number[];
+    /** Issues raised over the session, counted as in `issueHistogram`. */
+    totalNumberOfIssues: number;
+    /**
+     * 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`.
+     */
+    readonly issueHistogram: Record<string, number>;
+    totalRttSumInMs: number;
+    numberOfRttMeasurements: number;
+    maxRttInMs?: number;
+    minRttInMs?: number;
+    /**
+     * 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.
+     */
+    readonly rttHistogram: number[];
+    private _rttSummary?;
+    private _scoreSummary?;
+    totalInboundPacketsLost: number;
+    totalInboundPacketsReceived: number;
+    totalOutboundPacketsSent: number;
+    totalReceivedAudioBytes: number;
+    totalReceivedVideoBytes: number;
+    totalSentAudioBytes: number;
+    totalSentVideoBytes: number;
+    totalTransportReceivedBytes: number;
+    totalTransportSentBytes: number;
+    totalDataChannelBytesReceived: number;
+    totalDataChannelBytesSent: number;
+    totalDataChannelMessagesReceived: number;
+    totalDataChannelMessagesSent: number;
+    /** Highest `sendingAudioBitrate + sendingVideoBitrate` of any sample, in bits per second. */
+    peakSendingBitrate: number;
+    /** Highest `receivingAudioBitrate + receivingVideoBitrate` of any sample, in bits per second. */
+    peakReceivingBitrate: number;
+    numberOfSamplesOverUdp: number;
+    numberOfSamplesOverTcp: number;
+    numberOfSamplesOverTurnUdp: number;
+    numberOfSamplesOverTurnTcp: number;
+    numberOfSamplesWithUnknownPath: number;
+    numberOfPublicAddressChanges: number;
     readonly mediaDevices: MediaDeviceInfo[];
+    /**
+     * 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`.
+     */
+    readonly audioInputDevices: Map<string, AudioInputDevice>;
     /**
      * 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).
@@ -3739,16 +3998,31 @@ declare class ObservedClient<AppData extends Record<string, unknown> = Record<st
     readonly activeIssues: ObservedClientIssueRegistry;
     private _pendingInjections;
     private _activeSample?;
-    /** Peer connections the client reported closed (`PEER_CONNECTION_CLOSED`), closed once the current sample is applied. */
     private readonly _peerConnectionsToClose;
-    /** Ids of peer connections closed by the client; late stats for them are ignored rather than resurrecting them. */
     private readonly _closedPeerConnectionIds;
     private closeTimer?;
     constructor(settings: ObservedClientSettings<AppData>, call: ObservedCall, activeIssues: ObservedClientIssueRegistry);
     /** 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(): Sink<ClientSample> | undefined;
     get publicAddresses(): string[];
     get numberOfPeerConnections(): number;
     get score(): number | undefined;
+    /**
+     * 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(): Readonly<RttSummary>;
+    /**
+     * Percentiles (error at most one score point) and mean of every score of the session. Cached until
+     * the next score.
+     */
+    get scoreSummary(): Readonly<ScoreSummary>;
+    private _addScoreMeasurement;
+    private _addRttMeasurement;
     close(): void;
     accept(sample: ClientSample, context?: AcceptContext): void;
     injectMetaData(metaData: ClientMetaData): void;
@@ -5219,6 +5493,105 @@ declare class UnconsumedTrackDetector implements Detector {
     close(): void;
 }
 
+declare const 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.
+     */
+    readonly audioEchoSuspected: "AUDIO_ECHO_SUSPECTED";
+};
+type AudioEchoDetectorConfig = {
+    /**
+     * Width of one comparison bucket in ms, on the observer clock. Default `5_000`, the usual
+     * client-monitor sampling period. Each track contributes the level of the last tick seen in the
+     * bucket, so a bucket narrower than the clients' sampling period is mostly empty.
+     */
+    bucketMs: number;
+    /** Buckets kept per track, and so the stretch the verdict is taken over. Default `24` (two minutes at 5 s). */
+    windowBuckets: number;
+    /**
+     * RMS level (0..1) above which a bucket counts as someone speaking. Default `0.01` (-40 dBFS):
+     * speech after AGC sits around 0.03–0.1, a quiet room's noise floor well below 0.003.
+     */
+    activeRmsLevel: number;
+    /**
+     * Buckets in which the loudest *other* participant spoke, required before a track is judged.
+     * Default `8`. With fewer, a couple of overlapping sentences look like an echo.
+     */
+    minSourceActiveBuckets: number;
+    /**
+     * Share of those buckets in which the suspect track was active too. Default `0.8`. On its own this
+     * is not evidence — two people talking over each other in the same 5 s score high — which is why
+     * {@link minCorrelation} has to hold as well.
+     */
+    minFollowRatio: number;
+    /**
+     * Pearson correlation, over those same buckets, between the suspect's level and the loudest other
+     * participant's level, both in dB. Default `0.6`. This is the discriminating signal: an echo is
+     * louder when the source is louder, two independent speakers are not.
+     */
+    minCorrelation: number;
+    /** Re-arm time per suspect track in ms. Default `120_000`. */
+    cooldownMs: number;
+    /**
+     * The client issue type the loopback-device check raises, `'loopback-audio-input'` from
+     * client-monitor-js. Only read, never required: when it is open on the suspect track the finding
+     * says so, because it names the cause.
+     */
+    loopbackAudioInputIssueType: string;
+};
+/**
+ * Answers **"is someone sending the others' voices back into the call?"** — the echo one participant
+ * causes and everyone else hears, which no endpoint can see about itself.
+ *
+ * Every outbound audio track's level is taken once per tick: `ObservedOutboundTrack.rmsAudioLevel`,
+ * the publisher's own media-source level where the browser reports it, otherwise the median of what
+ * its receivers heard. Levels are bucketed on the observer clock, and each track is compared with
+ * the **loudest other participant** in the same bucket rather than with every participant in turn,
+ * which keeps a tick linear in the number of publishers.
+ *
+ * A track is suspected when, over the buckets in which someone else was speaking:
+ *
+ * - it was active in at least `minFollowRatio` of them, **and**
+ * - its level in dB correlates with theirs at `minCorrelation` or above.
+ *
+ * Ordinary turn-taking fails the first test (the listener is quiet while the other talks); cross-talk
+ * passes the first and fails the second (two independent voices do not rise and fall together). The
+ * echoing participant's own speech does not hurt: it fills buckets in which the others are quiet,
+ * and those are not scored.
+ *
+ * An echo and its source correlate in both directions, so when the source rarely has the floor to
+ * themselves both tracks pass. Only one is reported: the one with the client's `loopback-audio-input`
+ * issue open, else the one that follows the other more reliably, else the quieter one — flagged
+ * `ambiguousDirection` in that last case.
+ *
+ * The source is reported as the participant most often loudest in those buckets. When the suspect
+ * track also has the client's `loopback-audio-input` issue open, the finding says so: that names
+ * the cause, where the correlation alone only shows the effect.
+ *
+ * **Limits.** The comparison is at the clients' sampling granularity (5 s by default), so it catches
+ * sustained echo — a loopback device, speakers into a laptop mic without AEC — and misses faint or
+ * intermittent echo. Clients sample on their own schedules, so the buckets of two participants are
+ * offset by up to one sampling period; `minSourceActiveBuckets` is what absorbs that. For Firefox
+ * publishers the level comes from receivers, which needs a `RemoteTrackResolver`; without one those
+ * tracks carry no level and are never judged.
+ */
+declare class AudioEchoDetector implements Detector {
+    private readonly call;
+    static readonly NAME: "audio-echo-detector";
+    readonly name: "audio-echo-detector";
+    private readonly _config;
+    private readonly _series;
+    private readonly _lastRaisedAt;
+    private _lastEvaluatedBucket?;
+    constructor(call: ObservedCall, config?: Partial<AudioEchoDetectorConfig>);
+    close(): void;
+    update(): void;
+    private _collect;
+    private _evaluate;
+}
+
 /**
  * Detectors that reason **across calls**, created once on the observer.
  *
@@ -5247,6 +5620,7 @@ type AvailableCallScopeDetectorsConfigs = {
     [CallConcurrentIssueDetector.NAME]: CallConcurrentIssueDetectorConfig;
     [IssueFanOutDetector.NAME]: IssueFanOutDetectorConfig;
     [PublisherFaultCorroborationDetector.NAME]: PublisherFaultCorroborationDetectorConfig;
+    [AudioEchoDetector.NAME]: AudioEchoDetectorConfig;
 };
 type AvailableDetectorsConfigs = AvailableObserverScopeDetectorsConfigs | AvailableCallScopeDetectorsConfigs;
 declare class Detectors {
@@ -5446,6 +5820,8 @@ declare class ObservedCall<AppData extends Record<string, unknown> = Record<stri
     readonly settings: Pick<ObservedCallSettings, 'closeCallIfEmptyForMs' | 'autoUpdateOnClientUpdate'>;
     /** Ancestry base shared by all Observer-bus events originating at this call. */
     readonly eventScope: ObservedCallScope;
+    readonly sinks: SinkRegistry;
+    readonly extensionStats: ExtensionStatsRegistry;
     private closeTimer?;
     constructor(settings: ObservedCallSettings<AppData>, observer: Observer, activeIssuesRegistry: ActiveIssuesRegistry);
     get numberOfClients(): number;
@@ -5498,6 +5874,9 @@ declare class ObservedCall<AppData extends Record<string, unknown> = Record<stri
      */
     addIssue(issue: Omit<CallIssue, 'scope'>): void;
     close(): void;
+    createExtensionStats<C extends SinkConstructor>(settings: CreateExtensionStatsSettings<C>): InstanceType<C> | undefined;
+    acceptExtensionStats(id: string, data: unknown): void;
+    getExtensionStats<T>(id: string): T | undefined;
     getObservedClient<ClientAppData extends Record<string, unknown> = Record<string, unknown>>(clientId: string): ObservedClient<ClientAppData> | undefined;
     createObservedClient<ClientAppData extends Record<string, unknown> = Record<string, unknown>>(settings: ObservedClientSettings<ClientAppData>, acceptCtx?: AcceptContext): ObservedClient<ClientAppData> | undefined;
     getOrCreateObservedClient<ClientAppData extends Record<string, unknown> = Record<string, unknown>>(settings: ObservedClientSettings<ClientAppData>, acceptCtx?: AcceptContext): ObservedClient<ClientAppData> | undefined;
@@ -6219,11 +6598,38 @@ type ObserverConfig<AppData extends Record<string, unknown> = Record<string, unk
     /** Same as `createCallAppData`, for clients. Receives the (already-created) parent call. */
     createClientAppData?: ClientAppDataFactory;
     /**
-     * Optional factory invoked when a client is created, producing a per-client sink that
-     * receives every sample the client accepts (or `undefined` for no sink). The destination
-     * can be derived from `callId` / `clientId`.
+     * Write every sample a client accepts to a JSONL file: return the file path for a newly-created
+     * client, or `undefined` for no file. The directory must exist. The `JsonlFileSink` is added to
+     * `observedCall.sinks` under the client id and is ended when the client closes; `client-sink-created`
+     * announces it, so a `close` handler can upload or move the file once it is flushed.
+     *
+     * For any other destination, add your own sink under the client id instead, e.g. on
+     * `client-added`: `observedCall.sinks.create(MySink, { id: observedClient.clientId, ... })`.
+     *
+     * Replaces `createClientSink` (removed in 1.3.0), and with it `createJsonlFileSinkFactory`.
+     * To migrate:
+     *
+     * ```ts
+     * // before (1.2): JSONL files
+     * new Observer({ createClientSink: createJsonlFileSinkFactory({ directory: './stats' }) });
+     * // after: return the path; `${callId}__${clientId}.jsonl` was the factory's default file name
+     * new Observer({
+     *   createClientJsonlSink: ({ observedCall, clientId }) => path.join('./stats', `${observedCall.callId}__${clientId}.jsonl`),
+     * });
+     *
+     * // before (1.2): any other sink
+     * new Observer({ createClientSink: ({ clientId, observedCall }) => new HttpSink(url(observedCall, clientId)) });
+     * // after: create it under the client id when the client is added (HttpSink implements
+     * // `ClientSampleSink`, takes `SinkSettings & { ... }` and emits `ended` from `end()`)
+     * observer.on('client-added', ({ observedCall, observedClient }) => {
+     *   observedCall.sinks.create(HttpSink, { id: observedClient.clientId, url: url(observedCall, observedClient.clientId) });
+     * });
+     * ```
      */
-    createClientSink?: ClientSampleSinkFactory;
+    createClientJsonlSink?: (params: {
+        observedCall: ObservedCall;
+        clientId: string;
+    }) => string | undefined;
     /**
      * Optional factory invoked when a call is created, producing the call's `RemoteTrackResolver`
      * (or `undefined` for none). Use the built-ins
@@ -6242,6 +6648,8 @@ declare class Observer<AppData extends Record<string, unknown> = Record<string,
     readonly observedTURN: ObservedTURN;
     readonly observedCalls: Map<string, ObservedCall<Record<string, unknown>>>;
     readonly observedMediasoupRouters: Map<string, ObservedMediasoupRouter<Record<string, unknown>>>;
+    readonly sinks: SinkRegistry;
+    readonly extensionStats: ExtensionStatsRegistry;
     /** Ancestry base shared by all Observer-bus events originating at the observer. */
     readonly eventScope: ObserverEventBase;
     readonly config: ObserverConfig<AppData>;
@@ -6292,7 +6700,7 @@ declare class Observer<AppData extends Record<string, unknown> = Record<string,
      * });
      * ```
      */
-    readonly callDetectorConfigs: Map<keyof AvailableCallScopeDetectorsConfigs, Partial<UnconsumedTrackDetectorConfig | TrackDeliveryMismatchDetectorConfig | CallConcurrentIssueDetectorConfig | IssueFanOutDetectorConfig | PublisherFaultCorroborationDetectorConfig>>;
+    readonly callDetectorConfigs: Map<keyof AvailableCallScopeDetectorsConfigs, Partial<UnconsumedTrackDetectorConfig | TrackDeliveryMismatchDetectorConfig | CallConcurrentIssueDetectorConfig | IssueFanOutDetectorConfig | PublisherFaultCorroborationDetectorConfig | AudioEchoDetectorConfig>>;
     /**
      * Owns every call's summary: the resolved `config.callSummary`, the bus subscriptions that keep
      * the summaries current (one per event type, not one per call), and the summaries themselves.
@@ -6392,6 +6800,9 @@ declare class Observer<AppData extends Record<string, unknown> = Record<string,
         matchPeerConnectionByWebRtcTransportId?: boolean;
     }): ObservedMediasoupRouter<Record<string, unknown>> | undefined;
     close(): void;
+    createExtensionStats<C extends SinkConstructor>(settings: CreateExtensionStatsSettings<C>): InstanceType<C> | undefined;
+    acceptExtensionStats(id: string, data: unknown): void;
+    getExtensionStats<T>(id: string): T | undefined;
     accept(sample: ClientSample, context?: AcceptContext): void;
     update(): void;
     /**
@@ -6785,52 +7196,38 @@ declare function createLogger(moduleName: string): Logger;
  */
 declare function setObserverLogger(logger: ObserverLogger): void;
 
-type JsonlFileSinkOptions = {
-    /** Absolute or relative file path to append JSONL lines to. */
-    path: string;
-    /** Optional custom serializer; defaults to `JSON.stringify`. */
-    serializeSample?: (sample: ClientSample) => string;
-};
-/**
- * A sink that serializes each sample to a JSON line and appends it to a file. It wraps an
- * `fs.WriteStream` and re-emits its lifecycle events, so `close` fires once the file is flushed
- * and its descriptor is closed (file ready) and `error` surfaces file errors.
- */
-declare class JsonlFileSink extends ClientSampleSink {
-    /** The file this sink writes to. Read it (e.g. in a `close` handler) to upload/move the file. */
-    readonly path: string;
-    private readonly _stream;
-    private readonly _serializeSample;
-    constructor(options: JsonlFileSinkOptions);
-    write(sample: ClientSample): boolean;
-    end(): void;
-}
-/** Build a JSONL file sink for a single path. */
-declare function createJsonlFileSink(options: JsonlFileSinkOptions): ClientSampleSink;
-type JsonlFileSinkFactoryOptions = {
-    /** Directory the per-client files are written into (must exists). */
-    directory: string;
-    /** Builds the file name from the call/client ids. Defaults to `${callId}__${clientId}.jsonl`. */
-    getFileName?: (params: {
-        callId: string;
-        clientId: string;
-    }) => string;
-    /** Optional custom serializer; defaults to `JSON.stringify`. */
-    serializeSample?: (sample: ClientSample) => string;
-};
+/** The lifecycle events a client sample sink may emit. Same as {@link SinkEvents}. */
+type ClientSampleSinkEvents = SinkEvents;
 /**
- * Convenience factory that writes one JSONL file per client, with the path derived from
- * `callId` / `clientId`. Plug into `ObserverConfig.createClientSink`.
+ * A per-client destination for accepted samples. Create one under the client id with
+ * `observedCall.sinks.create(MySink, { id: clientId, ... })`, or let
+ * `ObserverConfig.createClientJsonlSink` create a `JsonlFileSink` there.
+ *
+ * The library calls `write(sample)` synchronously per accepted sample (not awaited) and `end()`s
+ * the sink when the client closes; the registry attaches an `error` listener so a failing sink
+ * can't crash the process. Because `write` isn't awaited, backpressure and batching are the sink's
+ * concern.
  */
-declare function createJsonlFileSinkFactory(options: JsonlFileSinkFactoryOptions): ClientSampleSinkFactory;
+type ClientSampleSink = Sink<ClientSample>;
 
+declare interface InMemorySink {
+    on<E extends keyof SinkEvents>(event: E, listener: (...args: SinkEvents[E]) => void): this;
+    once<E extends keyof SinkEvents>(event: E, listener: (...args: SinkEvents[E]) => void): this;
+    off<E extends keyof SinkEvents>(event: E, listener: (...args: SinkEvents[E]) => void): this;
+    emit<E extends keyof SinkEvents>(event: E, ...args: SinkEvents[E]): boolean;
+}
 /**
- * A `ClientSampleSink` that collects the accepted sample objects into an array. Useful for
- * tests and offline replay. Emits `close` on `end()`.
+ * A client sample sink that collects the accepted sample objects into an array. Useful for tests
+ * and offline replay. Emits `ended` and `close` on `end()`.
  */
-declare class InMemorySink extends ClientSampleSink {
+declare class InMemorySink extends EventEmitter implements Sink<ClientSample> {
+    readonly id: string;
     readonly samples: ClientSample[];
-    constructor(samples?: ClientSample[]);
+    private _ended;
+    constructor(settings?: Partial<SinkSettings> & {
+        samples?: ClientSample[];
+    });
+    get ended(): boolean;
     write(sample: ClientSample): boolean;
     end(): void;
 }
@@ -6839,4 +7236,4 @@ declare function createInMemorySink(samples?: ClientSample[]): InMemorySink;
 declare function createDefaultMediasoupRemoteTrackResolverFactory(): RemoteTrackResolverFactory;
 declare function createP2pRemoteTrackResolverFactory(): RemoteTrackResolverFactory;
 
-export { type AcceptContext, type AcceptMiddleware, type AcceptMiddlewarePayload, type ActiveClientIssue, type ActiveIssueTracker, ActiveIssuesRegistry, type AvailableCallScopeDetectorsConfigs, type AvailableDetectorsConfigs, type AvailableObserverScopeDetectorsConfigs, type AvailableValidatorConfigs, CODEC_MISMATCH_ISSUE, type CalculatedScore, type CallAppDataFactory, CallConcurrentIssueDetector, type CallConcurrentIssueDetectorConfig, type CallConcurrentIssueGroup, CallConcurrentIssueTypes, type CallHealth, CallHealthAggregator, type CallIssue, type CallIssueSpread, type CallScopedEventName, type CallSummary, type CallSummaryClients, CallSummaryCollector, type CallSummaryConfig, type CallSummaryEnricher, type CallSummaryEnrichers, type CallSummaryScores, type CallSummarySection, type CallSummaryTruncation, type CallSummaryTurnServers, type CertificateStats, type ClientAppDataFactory, type ClientEvent, ClientEventTypes, type ClientHealth, type ClientHealthThresholds, type ClientIssue, type ClientLocation, type ClientLocationResolver, type ClientMetaData, ClientMetaTypes, type ClientPopulation, type ClientPopulationAxis, ClientPopulationIssueDetector, type ClientPopulationIssueDetectorConfig, ClientPopulationIssueTypes, type ClientSample, ClientSampleSink, type ClientSampleSinkEvents, type ClientSampleSinkFactory, type CodecConsistencyReportPayload, CodecConsistencyValidator, type CodecConsistencyValidatorConfig, type CodecEvidence, type CodecStats, type CorroboratedPublisherFault, type DataChannelStats, type Detector, Detectors, type ExtensionStat, GEOHASH_CELL_SIZES, type IceCandidatePairStats, type IceCandidateStats, type IceTransportStats, InMemorySink, type InboundRtpStats, type InboundTrackSample, type Issue, type IssueBase, type IssueConclusion, IssueFanOutDetector, type IssueFanOutDetectorConfig, IssueFanOutTypes, type IssueFaultDomain, JsonlFileSink, type JsonlFileSinkFactoryOptions, type JsonlFileSinkOptions, LOWEST_COMMON_DENOMINATOR_ISSUE, type Logger, type MannKendallResult, type MediaKind, type MediaPlayoutStats, type MediaSourceStats, type MediasoupConsumerSample, type MediasoupConsumerSampleEvent, type MediasoupDataConsumerSample, type MediasoupDataProducerSample, type MediasoupDirectTransportSample, type MediasoupDirectTransportSampleEventMap, type MediasoupPipeTransportSample, type MediasoupPipeTransportSampleEventMap, type MediasoupPlainTransportSample, type MediasoupPlainTransportSampleEventMap, type MediasoupProducerSample, type MediasoupProducerSampleEvent, type MediasoupRouterSample, type MediasoupSampleEnricher, type MediasoupTransportSample, type MediasoupWebRtcTransportSample, type MediasoupWebRtcTransportSampleEventMap, type Middleware, MiddlewareProcessor, ObservedCall, type ObservedCallScope, type ObservedCallSettings, ObservedCertificate, ObservedClient, ObservedClientIssueRegistry, type ObservedClientScope, type ObservedClientSettings, ObservedCodec, ObservedDataChannel, ObservedIceCandidate, ObservedIceCandidatePair, ObservedIceTransport, ObservedInboundRtp, ObservedInboundTrack, ObservedMediaPlayout, ObservedMediaSource, ObservedMediasoupRouter, type ObservedMediasoupRouterEvents, type ObservedMediasoupRouterScope, type ObservedMediasoupRouterSettings, ObservedOutboundRtp, ObservedOutboundTrack, ObservedPeerConnection, type ObservedPeerConnectionScope, ObservedPeerConnectionTransport, ObservedRemoteInboundRtp, ObservedRemoteOutboundRtp, ObservedTURN, type ObservedTURNEventMap, ObservedTurnServer, Observer, ObserverConcurrentIssueDetector, type ObserverConcurrentIssueDetectorConfig, type ObserverConcurrentIssueGroup, ObserverConcurrentIssueTypes, type ObserverEventBase, type ObserverEvents, type ObserverIssue, type ObserverIssueSpread, type ObserverLogger, type OutboundRtpStats, type OutboundTrackSample, type PageHinkleyResult, type PeerConnectionSample, type PeerConnectionTransportStats, type PsnrSum, PublisherFaultCorroborationDetector, type PublisherFaultCorroborationDetectorConfig, PublisherFaultTypes, type QualityLimitationDurations, RESOLVED_ISSUE_SUFFIX, type RemoteInboundRtpStats, type RemoteOutboundRtpStats, type RemoteTrackLinkEvidence, RemoteTrackResolver, type RemoteTrackResolverFactory, type RemoteTrackResolverReportPayload, RemoteTrackResolverValidator, type RemoteTrackResolverValidatorConfig, type RemoteTrackResolvers, type ResolvedActiveClientIssue, type RunningValidator, type SampleRejectedReason, type ScoreCalculator, SfuCongestionDetector, type SfuCongestionDetectorBucket, type SfuCongestionDetectorConfig, type SfuCongestionDetectorEvaluation, type SfuCongestionDetectorReport, type SimulcastReceiverEvidence, type SimulcastReceiverReportPayload, SimulcastReceiverValidator, type SimulcastReceiverValidatorConfig, SlidingWindow, type SlidingWindowEntry, type StatsSummary, TrackDeliveryMismatchDetector, type TrackDeliveryMismatchDetectorConfig, TrackDeliveryMismatchTypes, TrendTester, type TrendTesterConfig, type TurnServerHealth, TurnServerHealthDetector, type TurnServerHealthDetectorConfig, TurnServerHealthTypes, TurnServerOutageDetector, type TurnServerOutageDetectorConfig, TurnServerOutageTypes, UNRESOLVED_TRACK_LINKS_ISSUE, UnconsumedTrackDetector, type UnconsumedTrackDetectorConfig, UnconsumedTrackTypes, type ValidationReport, type Validator, type ValidatorName, baseIssueType, concludeCallIssue, concludeObserverIssue, correlation, counterDelta, createCallSummary, createDefaultMediasoupRemoteTrackResolverFactory, createInMemorySink, createJsonlFileSink, createJsonlFileSinkFactory, createLogger, createP2pRemoteTrackResolverFactory, defaultCallSummaryConfig, defaultClientHealthThresholds, geohash, isClientIssueResolutionEntry, isPublicIpAddress, issuePayloadAsString, mannKendall, mannKendallVerdict, median, medianAbsoluteDeviation, pageHinkley, percentile, percentileOfSorted, robustZScore, schemaVersion, setObserverLogger, summarize };
+export { type AcceptContext, type AcceptMiddleware, type AcceptMiddlewarePayload, type ActiveClientIssue, type ActiveIssueTracker, ActiveIssuesRegistry, AudioEchoDetector, type AudioEchoDetectorConfig, AudioEchoTypes, type AudioInputDevice, type AvailableCallScopeDetectorsConfigs, type AvailableDetectorsConfigs, type AvailableObserverScopeDetectorsConfigs, type AvailableValidatorConfigs, CODEC_MISMATCH_ISSUE, type CalculatedScore, type CallAppDataFactory, CallConcurrentIssueDetector, type CallConcurrentIssueDetectorConfig, type CallConcurrentIssueGroup, CallConcurrentIssueTypes, type CallHealth, CallHealthAggregator, type CallIssue, type CallIssueSpread, type CallScopedEventName, type CallSummary, type CallSummaryClients, CallSummaryCollector, type CallSummaryConfig, type CallSummaryEnricher, type CallSummaryEnrichers, type CallSummaryScores, type CallSummarySection, type CallSummaryTruncation, type CallSummaryTurnServers, type CertificateStats, type ClientAppDataFactory, type ClientEvent, ClientEventTypes, type ClientHealth, type ClientHealthThresholds, type ClientIssue, type ClientLocation, type ClientLocationResolver, type ClientMetaData, ClientMetaTypes, type ClientPopulation, type ClientPopulationAxis, ClientPopulationIssueDetector, type ClientPopulationIssueDetectorConfig, ClientPopulationIssueTypes, type ClientSample, type ClientSampleSink, type ClientSampleSinkEvents, type CodecConsistencyReportPayload, CodecConsistencyValidator, type CodecConsistencyValidatorConfig, type CodecEvidence, type CodecStats, type CorroboratedPublisherFault, type CreateExtensionStatsSettings, type DataChannelStats, type Detector, Detectors, type ExtensionStat, ExtensionStatsRegistry, GEOHASH_CELL_SIZES, type IceCandidatePairStats, type IceCandidateStats, type IceTransportStats, InMemorySink, type InboundRtpStats, type InboundTrackSample, type Issue, type IssueBase, type IssueConclusion, IssueFanOutDetector, type IssueFanOutDetectorConfig, IssueFanOutTypes, type IssueFaultDomain, JsonlFileSink, type JsonlFileSinkOptions, LOWEST_COMMON_DENOMINATOR_ISSUE, type Logger, type MannKendallResult, type MediaKind, type MediaPlayoutStats, type MediaSourceStats, type MediasoupConsumerSample, type MediasoupConsumerSampleEvent, type MediasoupDataConsumerSample, type MediasoupDataProducerSample, type MediasoupDirectTransportSample, type MediasoupDirectTransportSampleEventMap, type MediasoupPipeTransportSample, type MediasoupPipeTransportSampleEventMap, type MediasoupPlainTransportSample, type MediasoupPlainTransportSampleEventMap, type MediasoupProducerSample, type MediasoupProducerSampleEvent, type MediasoupRouterSample, type MediasoupSampleEnricher, type MediasoupTransportSample, type MediasoupWebRtcTransportSample, type MediasoupWebRtcTransportSampleEventMap, type Middleware, MiddlewareProcessor, ObservedCall, type ObservedCallScope, type ObservedCallSettings, ObservedCertificate, ObservedClient, ObservedClientIssueRegistry, type ObservedClientScope, type ObservedClientSettings, ObservedCodec, ObservedDataChannel, ObservedIceCandidate, ObservedIceCandidatePair, ObservedIceTransport, ObservedInboundRtp, ObservedInboundTrack, ObservedMediaPlayout, ObservedMediaSource, ObservedMediasoupRouter, type ObservedMediasoupRouterEvents, type ObservedMediasoupRouterScope, type ObservedMediasoupRouterSettings, ObservedOutboundRtp, ObservedOutboundTrack, ObservedPeerConnection, type ObservedPeerConnectionScope, ObservedPeerConnectionTransport, ObservedRemoteInboundRtp, ObservedRemoteOutboundRtp, ObservedTURN, type ObservedTURNEventMap, ObservedTurnServer, Observer, ObserverConcurrentIssueDetector, type ObserverConcurrentIssueDetectorConfig, type ObserverConcurrentIssueGroup, ObserverConcurrentIssueTypes, type ObserverEventBase, type ObserverEvents, type ObserverIssue, type ObserverIssueSpread, type ObserverLogger, type OutboundRtpStats, type OutboundTrackSample, type PageHinkleyResult, type PeerConnectionSample, type PeerConnectionTransportStats, type PsnrSum, PublisherFaultCorroborationDetector, type PublisherFaultCorroborationDetectorConfig, PublisherFaultTypes, type QualityLimitationDurations, RESOLVED_ISSUE_SUFFIX, RTT_HISTOGRAM_BUCKET_WIDTH_IN_MS, RTT_HISTOGRAM_NUMBER_OF_BUCKETS, type RemoteInboundRtpStats, type RemoteOutboundRtpStats, type RemoteTrackLinkEvidence, RemoteTrackResolver, type RemoteTrackResolverFactory, type RemoteTrackResolverReportPayload, RemoteTrackResolverValidator, type RemoteTrackResolverValidatorConfig, type RemoteTrackResolvers, type ResolvedActiveClientIssue, type RttSummary, type RunningValidator, SCORE_HISTOGRAM_BUCKET_WIDTH, SCORE_HISTOGRAM_NUMBER_OF_BUCKETS, type SampleRejectedReason, type ScoreCalculator, type ScoreSummary, SfuCongestionDetector, type SfuCongestionDetectorBucket, type SfuCongestionDetectorConfig, type SfuCongestionDetectorEvaluation, type SfuCongestionDetectorReport, type SimulcastReceiverEvidence, type SimulcastReceiverReportPayload, SimulcastReceiverValidator, type SimulcastReceiverValidatorConfig, type Sink, type SinkConstructor, type SinkCreateSettings, type SinkEvents, SinkRegistry, type SinkSettings, SlidingWindow, type SlidingWindowEntry, type StatsSummary, TrackDeliveryMismatchDetector, type TrackDeliveryMismatchDetectorConfig, TrackDeliveryMismatchTypes, TrendTester, type TrendTesterConfig, type TurnServerHealth, TurnServerHealthDetector, type TurnServerHealthDetectorConfig, TurnServerHealthTypes, TurnServerOutageDetector, type TurnServerOutageDetectorConfig, TurnServerOutageTypes, UNRESOLVED_TRACK_LINKS_ISSUE, UnconsumedTrackDetector, type UnconsumedTrackDetectorConfig, UnconsumedTrackTypes, type ValidationReport, type Validator, type ValidatorName, baseIssueType, concludeCallIssue, concludeObserverIssue, correlation, counterDelta, createCallSummary, createDefaultMediasoupRemoteTrackResolverFactory, createInMemorySink, createJsonlFileSink, createLogger, createP2pRemoteTrackResolverFactory, defaultCallSummaryConfig, defaultClientHealthThresholds, geohash, isClientIssueResolutionEntry, isPublicIpAddress, issuePayloadAsString, mannKendall, mannKendallVerdict, median, medianAbsoluteDeviation, pageHinkley, percentile, percentileOfHistogram, percentileOfSorted, robustZScore, schemaVersion, setObserverLogger, summarize };