@observertc/observer-js 1.1.0 → 1.2.0

package/README.md

@@ -1126,6 +1126,7 @@ counters** — that is the rule the whole design hangs on:
 | `PublisherFaultCorroborationDetector` | 🔗 | call | `CORROBORATED_PUBLISHER_FAULT` |
 | `TrackDeliveryMismatchDetector` | 🔗 | call | `PUBLISHED_TRACK_NOT_DELIVERED`, `RECEIVER_TRACK_NOT_DELIVERED`, `PUBLISHER_TRACK_DRY` |
 | `UnconsumedTrackDetector` | 🔗 | call | `UNCONSUMED_PUBLISHED_TRACK` |
+| `AudioEchoDetector` | 🔗¹ | call | `AUDIO_ECHO_SUSPECTED` |
 | `ClientPopulationIssueDetector` | | **observer** | `CLIENT_POPULATION_ISSUE` |
 | `SfuCongestionDetector` | | **observer** | `sfu-congestion` |
 | `TurnServerHealthDetector` | | **observer** | `TURN_SERVER_DEGRADED` |
@@ -1168,6 +1169,16 @@ What each adds that no endpoint can know:
   from the **same SFU** — the finding's meaning is "these clients share only that server".
 - **`TrackDeliveryMismatchDetector`** — *are the two ends of a track disagreeing?*
 - **`UnconsumedTrackDetector`** — *is anyone actually subscribed?* (reads the resolver's silence)
+- **`AudioEchoDetector`** — *is someone sending the others' voices back into the call?* Compares
+  each outbound audio track's per-tick level (`ObservedOutboundTrack.rmsAudioLevel`) with the
+  loudest other participant's, bucket by bucket. An echo is active whenever the source speaks, and
+  louder when the source is louder; turn-taking fails the first test and cross-talk the second.
+  When both tracks of a pair pass, it reports the one with the client's `loopback-audio-input`
+  issue open, else the one that follows more reliably, else the quieter one (`ambiguousDirection`).
+  Works at the clients' sampling granularity, so it catches sustained echo (a `Monitor of …`
+  loopback device, speakers into an open mic) rather than faint echo.
+  ¹ The resolver is needed only for publishers whose browser reports no media-source audio level
+  (Firefox): their level is then read from what their receivers heard.
 - **`TurnServerHealthDetector`** — *does trouble cluster on one relay?*
 - **`TurnServerOutageDetector`** — covers the case the health detector structurally cannot. The
   health detector groups clients by the server relaying them and asks how many report issues — it

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { EventEmitter } from 'events';
+import { EventEmitter } from 'node:events';
 import { types } from 'mediasoup';
 
 declare const schemaVersion = "3.7.0";
@@ -1479,6 +1479,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 +1942,65 @@ 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`. The estimate is clamped to `[min, max]` when given. `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 +2052,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 +2073,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 +2232,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 +2542,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**.
  *
@@ -3648,6 +3709,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;
@@ -3707,10 +3793,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 +3808,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,9 +3881,7 @@ 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);
@@ -3749,6 +3889,18 @@ declare class ObservedClient<AppData extends Record<string, unknown> = Record<st
     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 +5371,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 +5498,7 @@ type AvailableCallScopeDetectorsConfigs = {
     [CallConcurrentIssueDetector.NAME]: CallConcurrentIssueDetectorConfig;
     [IssueFanOutDetector.NAME]: IssueFanOutDetectorConfig;
     [PublisherFaultCorroborationDetector.NAME]: PublisherFaultCorroborationDetectorConfig;
+    [AudioEchoDetector.NAME]: AudioEchoDetectorConfig;
 };
 type AvailableDetectorsConfigs = AvailableObserverScopeDetectorsConfigs | AvailableCallScopeDetectorsConfigs;
 declare class Detectors {
@@ -6292,7 +6544,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.
@@ -6839,4 +7091,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, 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, 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, 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, percentileOfHistogram, percentileOfSorted, robustZScore, schemaVersion, setObserverLogger, summarize };