@observertc/observer-js 1.0.0-beta.13 → 1.0.0-beta.15

package/dist/index.d.ts

@@ -52,6 +52,12 @@ type ClientIssue = {
     */
     type: string;
     /**
+    * Identity of a **stateful** issue, shared by its raise entry and its `<type>-resolved`
+    * companion, so a server can open an active issue on the raise and close it on the match
+    * (client-monitor-js >= 4.6.0, `sendResolvedIssuesToServer`). One-shot issues have no key.
+    */
+    key?: string;
+    /**
     * The value associated with the event, if applicable.
     */
     payload?: string;
@@ -1585,6 +1591,24 @@ declare class ObservedOutboundRtp implements OutboundRtpStats {
     bitPerPixel: number;
     deltaPacketsSent: number;
     deltaBytesSent: number;
+    deltaFramesSent: number;
+    deltaFramesEncoded: number;
+    deltaKeyFramesEncoded: number;
+    deltaNackCount: number;
+    deltaPliCount: number;
+    deltaFirCount: number;
+    deltaRetransmittedPacketsSent: number;
+    deltaRetransmittedBytesSent: number;
+    deltaEncodeTime: number;
+    deltaQualityLimitationResolutionChanges: number;
+    /**
+     * `true` when the codec, encoder implementation or scalability mode changed in this tick.
+     *
+     * Chrome resets `packetsSent`/`bytesSent` on the SSRC when the codec switches
+     * (crbug.com/webrtc/5361), producing sawtooth spikes and negative bitrates. All deltas for the
+     * tick are suppressed so a codec change is never mistaken for a traffic event.
+     */
+    counterResetBoundary: boolean;
     remoteRttInMs?: number;
     remoteFractionLost?: number;
     remoteJitter?: number;
@@ -1599,6 +1623,241 @@ declare class ObservedOutboundRtp implements OutboundRtpStats {
     update(stats: OutboundRtpStats): void;
 }
 
+/**
+ * Small statistics helpers used by the aggregators and detectors.
+ *
+ * Rationale: a mean is a poor summary for call telemetry — one participant with a 1500 ms RTT
+ * skews the average for nine healthy ones. Detectors should reason with medians, high percentiles
+ * and "affected ratios" instead.
+ */
+/** A distribution summary of a numeric sample set. */
+type StatsSummary = {
+    count: number;
+    min: number;
+    max: number;
+    mean: number;
+    median: number;
+    p25: number;
+    p75: number;
+    p95: number;
+};
+/**
+ * The p-th percentile (0..1) using linear interpolation between closest ranks.
+ * Returns `undefined` for an empty input.
+ */
+declare function percentile(values: number[], p: number): number | undefined;
+/** The median (50th percentile). `undefined` for an empty input. */
+declare function median(values: number[]): number | undefined;
+/**
+ * Median absolute deviation: `median(|value - median(values)|)`. A robust alternative to standard
+ * deviation for describing how spread out `values` are — one wild outlier shifts a mean-based
+ * deviation a lot, but barely moves a median. `undefined` for an empty input.
+ */
+declare function medianAbsoluteDeviation(values: number[]): number | undefined;
+/**
+ * A robust z-score: how many (MAD-based) standard deviations `value` sits above/below the median of
+ * `baseline`.
+ *
+ * Uses the median and MAD instead of the mean and standard deviation so a handful of baseline
+ * outliers can't inflate the "normal" spread and mask a genuine spike — the same reasoning behind
+ * {@link summarize}'s percentiles applies here to a single scalar spread. `1.4826` is the constant
+ * that makes MAD estimate the standard deviation of a normal distribution, so the result reads on
+ * the same scale as a classic z-score.
+ *
+ * A classic z-score divides by zero once every baseline value is identical (`MAD === 0`). Here:
+ * `value` strictly above that constant baseline reads as `Infinity` — a spike with no precedent
+ * whatsoever, however small; `value` at or below it reads as `0`, indistinguishable from the (flat)
+ * baseline rather than a division error.
+ *
+ * ### Worked example
+ *
+ * A baseline of "share of clients reporting congestion", one entry per 10 s bucket, on a healthy
+ * fleet: `[0.02, 0.01, 0.03, 0.04, 0.02]`. Median `0.02`, MAD `0.01`, so the scale is
+ * `1.4826 * 0.01 ≈ 0.0148`.
+ *
+ * ```ts
+ * robustZScore(0.03, baseline);   // ≈ 0.67  — an ordinary bucket
+ * robustZScore(0.25, baseline);   // ≈ 15.5  — a quarter of the fleet at once; nothing like it before
+ * ```
+ *
+ * Now add one bad bucket to the *baseline* — `[0.02, 0.01, 0.03, 0.04, 0.02, 0.40]`. A mean/stddev
+ * z-score would absorb it: the mean climbs to `0.087` and the stddev to `~0.14`, so a genuine `0.25`
+ * spike scores about `1.2` and looks unremarkable. **One past incident would hide the next one.**
+ * Median and MAD barely move (median `0.025`, MAD `0.01`), so `0.25` still scores `≈15.2`. That
+ * resistance is the entire reason for this function.
+ *
+ * The `Infinity` case is not an edge case in practice — it is a fleet that has been perfectly quiet:
+ *
+ * ```ts
+ * robustZScore(0.10, [ 0, 0, 0, 0, 0 ]);   // Infinity — first congestion ever seen
+ * robustZScore(0, [ 0, 0, 0, 0, 0 ]);      // 0        — still nothing happening
+ * ```
+ *
+ * `Infinity` clears any finite threshold, which is intended: "we have never seen this" *is* the
+ * strongest possible statistical statement. It is also why a caller must gate on practical
+ * significance too — see `SfuCongestionDetector`, which additionally requires a minimum number of
+ * affected clients, so a single client on a quiet fleet cannot page anyone.
+ *
+ * `undefined` when `baseline` is empty — there is nothing to compare against.
+ */
+declare function robustZScore(value: number, baseline: number[]): number | undefined;
+/** Summarize a numeric sample set. Returns `undefined` for an empty input. */
+declare function summarize(values: number[]): StatsSummary | undefined;
+/**
+ * Linear-interpolated percentile of an **already ascending** array. The building block behind
+ * {@link percentile} and {@link summarize}; exported so callers computing several percentiles over
+ * the same data can sort once themselves.
+ *
+ * Passing an unsorted array yields a meaningless number rather than an error — sort first.
+ */
+declare function percentileOfSorted(sorted: number[], p: number): number;
+/**
+ * A counter-reset-safe delta: the increase of a cumulative counter between two observations.
+ *
+ * Returns `0` when the counter went backwards (reset / SSRC reuse) or when either side is missing.
+ * NOTE the guard is `>=` on **defined** values — a previous value of `0` is a perfectly valid
+ * baseline, so `0 -> 5` correctly yields `5` (using a truthiness check here silently drops the
+ * first interval of every counter, which is exactly when the first loss/freeze event happens).
+ */
+declare function counterDelta(previous: number | undefined, current: number | undefined): number;
+/**
+ * Pearson correlation of two equal-length series, clamped to `0..1`.
+ *
+ * Negative or undefined relationships read as `0`, because every caller here asks "does A follow B?"
+ * — an inverse relationship is not a weaker yes, it is a no.
+ */
+declare function correlation(xs: number[], ys: number[]): number;
+/** Per-step result of {@link pageHinkley}. */
+type PageHinkleyResult = {
+    /**
+     * The Page-Hinkley statistic after each observation, same length as the input — one value per
+     * `values[i]`, so `statistic[i]` is "how far the cumulative deviation has grown above its own
+     * historical low, using only `values[0..i]`". Never negative (it's a gap to a *minimum*), and
+     * `0` for as long as the process looks stable.
+     */
+    statistic: number[];
+    /**
+     * Index of the **first** observation whose statistic exceeded `lambda`, else `undefined`.
+     *
+     * This is a one-shot latch over the call's whole input: once found, later observations are not
+     * re-checked, even if the statistic subsequently falls back down (e.g. after a single transient
+     * spike — see the class doc example). "Is it *still* elevated right now" is a different
+     * question, answered by looking at the *tail* of {@link statistic}, or — for a live stream — by
+     * re-running this over a recent window each time (which is what `TrendTester` does) rather than
+     * over the whole history once.
+     */
+    changePointIndex?: number;
+    /** `true` when {@link changePointIndex} is defined. */
+    changeDetected: boolean;
+};
+/**
+ * Page-Hinkley test: sequential (online) detection of a sustained **increase** in the mean of
+ * `values` — "has this metric settled onto a durably higher level", as opposed to "did one sample
+ * come in high". A single noisy point should not read as a regression; ten points that are all a
+ * bit higher than before should.
+ *
+ * ### How it works
+ *
+ * At step `i`, three numbers are tracked:
+ *
+ * 1. `mean` — the running average of `values[0..i]` (**not** a fixed baseline — it is recomputed
+ *    from everything seen so far, including `values[i]` itself, which is what makes this
+ *    *adaptive*: after a real shift, `mean` keeps drifting up to meet the new level, and the
+ *    signal below fades back out on its own rather than staying triggered forever).
+ * 2. `cumulative` — running sum of `(values[i] - mean - delta)`. Subtracting `mean` centres each
+ *    term on "surprise relative to what we've seen so far"; subtracting `delta` on top means a
+ *    small positive surprise still nets to a *negative* contribution, so it doesn't accumulate.
+ * 3. `runningMinimum` — the lowest `cumulative` has ever been.
+ *
+ * The **Page-Hinkley statistic** is `cumulative - runningMinimum`: how far the running sum has
+ * climbed above its own historical floor. Pure noise pulls `cumulative` up and down around a flat
+ * trend, so the gap to `runningMinimum` stays small. A sustained increase pushes `cumulative`
+ * mostly one direction — up — so `runningMinimum` stops updating and the gap grows every step,
+ * crossing `lambda` once the shift is large/long enough to be sure it isn't noise. That first
+ * crossing is {@link PageHinkleyResult.changePointIndex}.
+ *
+ * ### Parameters
+ *
+ * - `delta` — the **drift tolerance** (in the same units as `values`, e.g. ms of RTT): how much of
+ *   a step-to-step increase is written off as noise rather than counted towards the cumulative sum.
+ *   `0` means even a razor-thin, consistent upward creep eventually accumulates enough to trigger;
+ *   raising it requires each observation to clear that bar above the running mean before it
+ *   contributes anything (see the class doc's hand-worked example — the same jump that triggers
+ *   with `delta: 0` is completely absorbed at `delta: 10`).
+ * - `lambda` — the **detection threshold** the statistic must exceed. It is in "surprise units" (a
+ *   sum of deviations, not a single observation's units), so there's no shortcut for picking it
+ *   other than trying it against representative data — see the RTT examples in `stats.spec.ts` for
+ *   a worked comparison of a low vs. a high `lambda` on the same series. Raising it delays
+ *   detection but makes a false positive from a lucky run of noise less likely.
+ *
+ * O(n) — one pass, unlike {@link mannKendall}'s O(n²). To detect a **decrease** instead of an
+ * increase, negate `values` before calling (or negate the result's meaning if you'd rather).
+ */
+declare function pageHinkley(values: number[], delta?: number, lambda?: number): PageHinkleyResult;
+/** Result of {@link mannKendall}. */
+type MannKendallResult = {
+    /** Sum of pairwise signs (`sign(values[j] - values[i])` for every `i < j`). */
+    s: number;
+    /** Variance of {@link s}, corrected for tied values. */
+    variance: number;
+    /** Standard-normal score derived from `s`. `0` when `s` is `0` — no evidence either way. */
+    z: number;
+    /** Two-tailed p-value for the null hypothesis "no monotonic trend". */
+    pValue: number;
+    /** `'increasing'` / `'decreasing'` when significant at `alpha`, else `'no-trend'`. */
+    trend: 'increasing' | 'decreasing' | 'no-trend';
+};
+/**
+ * Mann-Kendall trend test: a non-parametric test for a **monotonic** trend in `values`, without
+ * assuming a distribution or a constant rate of change — it only asks "are later values
+ * consistently larger (or smaller) than earlier ones more often than chance would allow".
+ *
+ * Every pair `i < j` votes `+1` (`values[j] > values[i]`), `-1` (`values[j] < values[i]`) or `0`
+ * (tie); `s` is the sum of those votes. Under the null hypothesis of no trend, `s` is
+ * approximately normal with mean `0` and a known variance (corrected here for tied values), which
+ * turns `s` into a Z score and a two-tailed p-value. `trend` is only `'increasing'` / `'decreasing'`
+ * when that p-value clears `alpha` — a handful of mostly-ascending points is exactly what noise
+ * looks like half the time, and this is what keeps that from reading as a trend.
+ *
+ * O(n²) (every pair is compared); fine for the small, per-tick sample counts detectors work with,
+ * not for large historical series.
+ */
+declare function mannKendall(values: number[], alpha?: number): MannKendallResult;
+/**
+ * Turns a Mann-Kendall `s` statistic and its `variance` into a Z score, p-value and verdict — the
+ * back half of {@link mannKendall}, split out so an incremental caller that maintains `s` /
+ * `variance` itself (e.g. over a sliding window, correcting for evicted points rather than
+ * 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'>;
+
+/** The per-receiver view the aggregator builds for one subscribed track. */
+type PublishedTrackReceivingDistributionEntry = {
+    numberOfReceivers: number;
+    numberOfHealthyReceivers: number;
+    numberOfDegradedReceivers: number;
+    /** degradedReceivers / receivers (0..1); `0` when there are no receivers. */
+    degradedRatio: number;
+    /** Distribution summaries across receivers (undefined when no receiver reported the metric). */
+    bitrate?: StatsSummary;
+    fractionLost?: StatsSummary;
+    jitter?: StatsSummary;
+    rttInMs?: StatsSummary;
+    jitterBufferDelayInMs?: StatsSummary;
+    concealmentRatio?: StatsSummary;
+    /** Fan-out counters: how many receivers saw the symptom, and the total across them. */
+    freezes: {
+        affectedReceivers: number;
+        total: number;
+    };
+    plis: {
+        affectedReceivers: number;
+        total: number;
+    };
+    concealment: {
+        affectedReceivers: number;
+    };
+};
 declare class ObservedOutboundTrack implements OutboundTrackSample {
     timestamp: number;
     readonly id: string;
@@ -1609,18 +1868,28 @@ declare class ObservedOutboundTrack implements OutboundTrackSample {
     private _visited;
     appData?: Record<string, unknown>;
     readonly remoteInboundTracks: Set<ObservedInboundTrack>;
+    readonly detectors: Detectors;
+    receivingDistribution?: PublishedTrackReceivingDistributionEntry;
     readonly calculatedScore: CalculatedScore;
     addedAt?: number | undefined;
     removedAt?: number | undefined;
     muted?: boolean;
     attachments?: Record<string, unknown> | undefined;
+    degradedReasons?: string[] | undefined;
+    bitrate?: number | undefined;
+    deltaPacketsSent?: number | undefined;
+    remoteFractionLost?: number | undefined;
+    remoteRttInMs?: number | undefined;
+    qualityLimitationReason?: string | undefined;
     constructor(timestamp: number, id: string, kind: MediaKind, _peerConnection: ObservedPeerConnection, _outboundRtps?: ObservedOutboundRtp[] | undefined, _mediaSource?: ObservedMediaSource | undefined);
     get score(): number | undefined;
     get visited(): boolean;
+    get degraded(): boolean;
     getPeerConnection(): ObservedPeerConnection;
     getOutboundRtps(): ObservedOutboundRtp[] | undefined;
     getMediaSource(): ObservedMediaSource | undefined;
     update(stats: OutboundTrackSample): void;
+    private createReceivingDistribution;
 }
 
 declare class ObservedInboundTrack implements InboundTrackSample {
@@ -1638,6 +1907,8 @@ declare class ObservedInboundTrack implements InboundTrackSample {
     removedAt?: number | undefined;
     muted?: boolean;
     attachments?: Record<string, unknown> | undefined;
+    degradationReasons: string[];
+    get degraded(): boolean;
     constructor(timestamp: number, id: string, kind: MediaKind, _peerConnection: ObservedPeerConnection, _inboundRtp?: ObservedInboundRtp | undefined, _mediaPlayout?: ObservedMediaPlayout | undefined);
     get score(): number | undefined;
     get visited(): boolean;
@@ -1645,6 +1916,7 @@ declare class ObservedInboundTrack implements InboundTrackSample {
     getInboundRtp(): ObservedInboundRtp | undefined;
     getMediaPlayout(): ObservedMediaPlayout | undefined;
     update(stats: InboundTrackSample): void;
+    private checkDegradation;
 }
 
 declare class ObservedRemoteOutboundRtp implements RemoteOutboundRtpStats {
@@ -1752,6 +2024,46 @@ declare class ObservedInboundRtp implements InboundRtpStats {
     deltaBytesReceived: number;
     deltaReceivedSamples: number;
     deltaSilentConcealedSamples: number;
+    deltaConcealedSamples: number;
+    deltaConcealmentEvents: number;
+    deltaFreezeCount: number;
+    deltaFreezesDuration: number;
+    deltaPliCount: number;
+    deltaNackCount: number;
+    deltaFirCount: number;
+    deltaPacketsDiscarded: number;
+    deltaFramesDecoded: number;
+    deltaFramesReceived: number;
+    deltaFramesRendered: number;
+    deltaFramesDropped: number;
+    deltaKeyFramesDecoded: number;
+    deltaDecodeTime: number;
+    deltaJitterBufferDelay: number;
+    deltaJitterBufferEmittedCount: number;
+    deltaRetransmittedPacketsReceived: number;
+    deltaFecPacketsReceived: number;
+    deltaFecPacketsDiscarded: number;
+    deltaPausesDuration: 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
+     * read those two counters.
+     */
+    jitterBufferDelayInMs?: number;
+    /** Fraction of the samples received in this tick that were concealed (0..1). */
+    concealmentRatio?: number;
+    /** Fraction of the frames received in this tick that were dropped before rendering (0..1). */
+    framesDroppedRatio?: number;
+    /**
+     * `true` when the codec or decoder implementation changed in this tick.
+     *
+     * Chrome resets `packetsReceived`/`bytesReceived` on an SSRC when the codec switches
+     * (crbug.com/webrtc/5361, open since 2015), which shows up as a sawtooth spike or a negative
+     * rate. Every delta in this tick is therefore suppressed to `0` rather than reported as traffic
+     * — otherwise a room-wide codec rollout produces a synchronized fake-degradation alert across
+     * every participant at once.
+     */
+    counterResetBoundary: boolean;
     remoteRttInMs?: number;
     remoteBytesSent?: number;
     remotePacketsSent?: number;
@@ -1941,7 +2253,34 @@ declare class ObservedPeerConnection extends EventEmitter {
     sendingVideoBitrate: number;
     receivingAudioBitrate: number;
     receivingVideoBitrate: number;
+    /**
+     * Median round-trip time of the tick, in ms.
+     *
+     * Prefers {@link rtcpRttInMs} and falls back to {@link iceRttInMs}, so within one tick it always
+     * reports **one** kind of round trip. It used to be the median of both mixed together, which was
+     * a bug: the mixing ratio changed as streams came and went, so the value moved for reasons that
+     * had nothing to do with the network.
+     */
     currentRttInMs?: number;
+    /**
+     * RTT measured by ICE/STUN consent checks, in ms — the trip to **whatever terminates ICE**. In an
+     * SFU topology that is the SFU, so this is the client↔SFU leg, not client↔client.
+     */
+    iceRttInMs?: number;
+    /**
+     * RTT reported by RTCP receiver reports, in ms — an **end-to-end** media-path round trip.
+     *
+     * Not the same trip as {@link iceRttInMs}; the difference between the two is roughly the far side
+     * of the SFU (see {@link sfuHopRttInMs}).
+     */
+    rtcpRttInMs?: number;
+    /**
+     * `rtcpRttInMs - iceRttInMs`, when both are known — an estimate of everything *past* the SFU.
+     *
+     * Useful for splitting "this client's own last mile is slow" (high `iceRttInMs`) from "the path
+     * beyond the SFU is slow" (low ICE, high hop).
+     */
+    sfuHopRttInMs?: number;
     currentJitter?: number;
     usingTCP: boolean;
     usingTURN: boolean;
@@ -2036,6 +2375,179 @@ type OperationSystem = {
     version: string;
 };
 
+/**
+ * A finding raised **by the observer** — `observedCall.addIssue()` / `observer.addIssue()`, surfaced
+ * on the bus as `call-issue` / `observer-issue`.
+ *
+ * ### Why this is not `ClientIssue`
+ *
+ * `ClientIssue` is a **wire** type: it arrives inside a `ClientSample`, so its `payload` has to be a
+ * string. Server-raised findings were reusing it, which forced every detector to `JSON.stringify` a
+ * perfectly good object on the way out and every handler to `JSON.parse` it back on the way in —
+ * paying serialisation on a path where nothing is ever serialised, and losing type information in
+ * both directions.
+ *
+ * An observer issue goes straight to an in-process event handler, so it carries the object.
+ */
+type ObserverIssue = {
+    /** What was found, e.g. `'CROSS_CALL_ISSUE_ONSET_BURST'`. */
+    type: string;
+    /** Observer clock, when the finding was raised. */
+    timestamp: number;
+    /**
+     * The evidence behind the finding.
+     *
+     * Prefer an object — that is the point of this type. `string` is still accepted so an application
+     * can forward a payload it already has serialised (e.g. relaying a `ClientIssue`) without a
+     * pointless parse-then-restringify round trip. Use {@link issuePayloadOf} to read either form.
+     */
+    payload?: string | Record<string, unknown>;
+};
+/**
+ * The payload of an issue as an object, parsing it only if it happens to be a string.
+ *
+ * Handlers shouldn't have to care which form arrived. Returns `undefined` for a missing payload or a
+ * string that isn't valid JSON — reading evidence must never throw inside an issue handler.
+ */
+declare function issuePayloadOf(issue: Pick<ObserverIssue, 'payload'>): Record<string, unknown> | undefined;
+/**
+ * The payload as a JSON string, serialising it only if it is an object.
+ *
+ * For the boundaries that genuinely need text — a log line, an HTTP body, a message queue. Keep it at
+ * the edge rather than in the detector, so in-process handlers never pay for it.
+ */
+declare function issuePayloadAsString(issue: Pick<ObserverIssue, 'payload'>): string | undefined;
+
+/**
+ * What a validator concluded, once it is done.
+ *
+ * `S` is the validator's own payload — a discriminated union on `verdict` plus whatever evidence
+ * belongs to each outcome — so a report reads in the language of the thing being checked rather than
+ * in generic pass/fail.
+ *
+ * Note this is a plain intersection with `S`, not `{ [K in keyof S]: S[K] }`. A mapped type over a
+ * union collapses to the keys its members *share* (`keyof (A | B)` is the intersection), which would
+ * silently drop every per-verdict evidence field and leave only `verdict` behind.
+ */
+type ValidationReport<S extends Record<string, unknown> = Record<string, unknown>> = 
+/** Still running — it has not seen the conditions it needs to judge anything yet. */
+{
+    ready: false;
+}
+/** Done. `verdict` is narrowed by `S` to that validator's own vocabulary. */
+ | ({
+    ready: true;
+    verdict: string;
+    decidedAt: number;
+} & S);
+/**
+ * A **one-shot structural check**: something true of the deployment rather than of this moment.
+ *
+ * The distinction from a `Detector` is what changes over time. A detector answers "is something wrong
+ * *right now*" — congestion, a dead relay, a track nobody receives — and the answer legitimately
+ * differs every tick, so it runs every tick, forever. A validator answers "is this deployment built
+ * correctly" — does the SFU pick layers per receiver — and that only changes when you deploy. So a
+ * validator **runs until it knows, then finishes**: it calls {@link onDone} once, the observer drops
+ * it, and nothing more is computed.
+ *
+ * To check again — after a deploy, say — start a new one with `observer.addValidator(...)`. There is
+ * no revalidation timer, because a deploy, not the passage of time, is what makes a structural
+ * verdict stale.
+ *
+ * Validators are held in `observer.validators` and driven by `observer.update()`.
+ */
+interface Validator<S extends Record<string, unknown> = Record<string, unknown>> {
+    readonly name: string;
+    /**
+     * The conclusion so far. `{ ready: false }` until {@link onDone} fires — and **that is not a
+     * pass**. A validator usually needs specific conditions to occur before it can judge anything,
+     * and plenty of deployments never present them.
+     */
+    readonly report: ValidationReport<S>;
+    /** Called exactly once, when the validator finishes. The observer uses this to unregister it. */
+    onDone: (report: ValidationReport<S>) => void;
+    /** Gather evidence; decide if there is now enough. Called on every `observer.update()`. */
+    update(): void;
+    /** Give up without a verdict. Finishes with `inconclusive`, so a caller waiting on it is freed. */
+    cancel: () => void;
+}
+/**
+ * The part of a validator the observer needs in order to drive it.
+ *
+ * `Validator<S>` is invariant in `S` — `onDone` takes a `ValidationReport<S>` and `report` returns one
+ * — so a `Set<Validator>` cannot hold validators with different payloads. Driving one only needs the
+ * three members that don't mention `S`.
+ */
+type RunningValidator = Pick<Validator, 'name' | 'update' | 'cancel'>;
+
+/** The suffix client-monitor-js appends to the type of a resolution entry. */
+declare const RESOLVED_ISSUE_SUFFIX = "-resolved";
+/**
+ * A **stateful** client issue the server currently believes to be open.
+ *
+ * client-monitor-js (>= 4.6.0, `sendResolvedIssuesToServer`) puts an issue's whole lifecycle on the
+ * wire as two entries sharing a `key`:
+ *
+ * ```
+ * raise:      { type: 'stuck-decoder',          key, payload,                                timestamp: raisedAt }
+ * resolution: { type: 'stuck-decoder-resolved', key, payload: { raisedAt, comment, …final }, timestamp: resolvedAt }
+ * ```
+ *
+ * The observer opens an `ActiveClientIssue` on the raise and closes it on the matching key, which
+ * turns a stream of point-in-time symptom reports into **intervals**. That is what makes the
+ * difference between "several clients reported congestion in the last 10 seconds" (a guess built on
+ * an arbitrary window) and "several clients are congested *right now, simultaneously*" — the latter
+ * being real evidence of a shared cause.
+ *
+ * Issues still active when the client monitor closes are auto-resolved by the client, so a clean
+ * departure does not leak.
+ */
+type ActiveClientIssue = {
+    /** Identity shared by the raise and its resolution. Unique per client. */
+    key: string;
+    /** The issue type **without** the `-resolved` suffix (e.g. `'congestion'`). */
+    type: string;
+    /** The client that reported it. */
+    clientId: string;
+    /**
+     * The call that client belongs to. The dimension that separates "one bad meeting" from "our
+     * infrastructure": at observer scope, clients in *different* calls share nothing but the server.
+     */
+    callId: string;
+    /** When the client raised it (client clock). */
+    raisedAt: number;
+    /** When the observer first saw it (server clock) — skew-free, use this for cross-client timing. */
+    observedAt: number;
+    /** Parsed raise payload, when it was JSON. */
+    payload?: Record<string, unknown>;
+    /** `payload.peerConnectionId`, when present — most client detectors report it. */
+    peerConnectionId?: string;
+    /** `payload.trackId`, when present — the join key to a track (and thus to a publisher). */
+    trackId?: string;
+};
+/** A closed interval: an {@link ActiveClientIssue} plus how it ended. */
+type ResolvedActiveClientIssue = ActiveClientIssue & {
+    /** When the client resolved it (client clock). */
+    resolvedAt: number;
+    /** Observer-clock resolution time. */
+    observedResolvedAt: number;
+    /** `resolvedAt - raisedAt` as reported by the client, else derived from observer clocks. */
+    durationInMs: number;
+    /** Free-form note passed to `resolveIssue`. */
+    comment?: string;
+    /** Payload explicitly passed at resolution (the built-in detectors pass their final payload). */
+    resolutionPayload?: Record<string, unknown>;
+    /**
+     * How the interval ended: the client said so, the observer expired it, or the client left
+     * without resolving.
+     */
+    resolvedBy: 'client' | 'timeout' | 'client-closed';
+};
+/** `true` when the entry is a resolution companion rather than a raise. */
+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). */
@@ -2103,11 +2615,11 @@ type RtpCodecParameters = {
         parameter?: string;
     }[];
 };
-type SampleHistoryItem<T extends string> = Record<string, unknown> & {
+type SampleHistoryItem<T extends string> = {
     type: T;
     timestamp: number;
 };
-type MediasoupRouterSample = Record<string, unknown> & {
+type MediasoupRouterSample = {
     routerId: string;
     attachments: Record<string, unknown>;
     createdAt: number;
@@ -2151,7 +2663,9 @@ type MediasoupDirectTransportSample = {
     type: 'direct';
     history: MediasoupDirectTransportSampleEventMap[];
 };
-type MediasoupTransportSample = Record<string, unknown> & {
+type MediasoupTransportSample = {
+    /** Free-form application data. Attach anything here — see `ObservedMediasoupRouter`. */
+    attachments?: Record<string, unknown>;
     id: string;
     createdAt: number;
     connectedAt?: number;
@@ -2167,7 +2681,9 @@ type MediasoupProducerSampleEventMap = {
 type MediasoupProducerSampleEvent = {
     [K in keyof MediasoupProducerSampleEventMap]: SampleHistoryItem<K>;
 }[keyof MediasoupProducerSampleEventMap];
-type MediasoupProducerSample = Record<string, unknown> & {
+type MediasoupProducerSample = {
+    /** Free-form application data. Attach anything here — see `ObservedMediasoupRouter`. */
+    attachments?: Record<string, unknown>;
     id: string;
     transportId: string;
     createdAt: number;
@@ -2191,7 +2707,9 @@ type MediasoupConsumerSampleEventMap = {
 type MediasoupConsumerSampleEvent = {
     [K in keyof MediasoupConsumerSampleEventMap]: SampleHistoryItem<K>;
 }[keyof MediasoupConsumerSampleEventMap];
-type MediasoupConsumerSample = Record<string, unknown> & {
+type MediasoupConsumerSample = {
+    /** Free-form application data. Attach anything here — see `ObservedMediasoupRouter`. */
+    attachments?: Record<string, unknown>;
     id: string;
     producerId: string;
     transportId: string;
@@ -2200,7 +2718,9 @@ type MediasoupConsumerSample = Record<string, unknown> & {
     kind: 'audio' | 'video';
     history: MediasoupConsumerSampleEvent[];
 };
-type MediasoupDataProducerSample = Record<string, unknown> & {
+type MediasoupDataProducerSample = {
+    /** Free-form application data. Attach anything here — see `ObservedMediasoupRouter`. */
+    attachments?: Record<string, unknown>;
     id: string;
     transportId: string;
     createdAt: number;
@@ -2208,7 +2728,9 @@ type MediasoupDataProducerSample = Record<string, unknown> & {
     label: string;
     protocol: string;
 };
-type MediasoupDataConsumerSample = Record<string, unknown> & {
+type MediasoupDataConsumerSample = {
+    /** Free-form application data. Attach anything here — see `ObservedMediasoupRouter`. */
+    attachments?: Record<string, unknown>;
     id: string;
     dataProducerId: string;
     transportId: string;
@@ -2218,13 +2740,86 @@ type MediasoupDataConsumerSample = Record<string, unknown> & {
     protocol: string;
 };
 
+/**
+ * Declarative enrichment: return the `attachments` to stamp onto an entity's sample the moment it is
+ * created. Called once per entity, before the corresponding `*-sample-added` event.
+ *
+ * The mediasoup object is handed in, so the common case — mirroring mediasoup's own `appData`, where
+ * applications already keep `participantId`, `purpose` and friends — is a one-liner. Returning
+ * `undefined` attaches nothing.
+ */
+type MediasoupSampleEnricher = {
+    transport?: (transport: types.Transport) => Record<string, unknown> | undefined;
+    producer?: (producer: types.Producer, transport: types.Transport) => Record<string, unknown> | undefined;
+    consumer?: (consumer: types.Consumer, transport: types.Transport) => Record<string, unknown> | undefined;
+    dataProducer?: (dataProducer: types.DataProducer, transport: types.Transport) => Record<string, unknown> | undefined;
+    dataConsumer?: (dataConsumer: types.DataConsumer, transport: types.Transport) => Record<string, unknown> | undefined;
+};
 type ObservedMediasoupRouterSettings<AppData extends Record<string, unknown> = Record<string, unknown>> = {
     router: types.Router;
     appData?: AppData;
     attachments?: Record<string, unknown>;
+    /** Stamp `attachments` onto each entity sample as it is created. See {@link MediasoupSampleEnricher}. */
+    enrich?: MediasoupSampleEnricher;
 };
+/**
+ * Lifecycle hooks for building your own report.
+ *
+ * Each entity announces itself as `<entity>-sample-added` when it appears and
+ * `<entity>-sample-closed` when it goes away, carrying **the live sample object** plus the mediasoup
+ * object it came from. Mutating `sample.attachments` inside a handler is the intended way to extend
+ * a sample on the fly — the object you receive is the one held in `observedRouter.sample`, not a copy.
+ */
 type ObservedMediasoupRouterEvents = {
     close: [];
+    'transport-sample-added': [{
+        sample: MediasoupTransportSample;
+        transport: types.Transport;
+    }];
+    'transport-sample-closed': [{
+        sample: MediasoupTransportSample;
+        transport: types.Transport;
+    }];
+    'producer-sample-added': [{
+        sample: MediasoupProducerSample;
+        producer: types.Producer;
+        transport: types.Transport;
+    }];
+    'producer-sample-closed': [{
+        sample: MediasoupProducerSample;
+        producer: types.Producer;
+        transport: types.Transport;
+    }];
+    'consumer-sample-added': [{
+        sample: MediasoupConsumerSample;
+        consumer: types.Consumer;
+        transport: types.Transport;
+    }];
+    'consumer-sample-closed': [{
+        sample: MediasoupConsumerSample;
+        consumer: types.Consumer;
+        transport: types.Transport;
+    }];
+    'data-producer-sample-added': [{
+        sample: MediasoupDataProducerSample;
+        dataProducer: types.DataProducer;
+        transport: types.Transport;
+    }];
+    'data-producer-sample-closed': [{
+        sample: MediasoupDataProducerSample;
+        dataProducer: types.DataProducer;
+        transport: types.Transport;
+    }];
+    'data-consumer-sample-added': [{
+        sample: MediasoupDataConsumerSample;
+        dataConsumer: types.DataConsumer;
+        transport: types.Transport;
+    }];
+    'data-consumer-sample-closed': [{
+        sample: MediasoupDataConsumerSample;
+        dataConsumer: types.DataConsumer;
+        transport: types.Transport;
+    }];
 };
 declare interface ObservedMediasoupRouter {
     on<U extends keyof ObservedMediasoupRouterEvents>(event: U, listener: (...args: ObservedMediasoupRouterEvents[U]) => void): this;
@@ -2250,9 +2845,36 @@ declare class ObservedMediasoupRouter<AppData extends Record<string, unknown> =
     readonly sample: MediasoupRouterSample;
     readonly webrtcTransportIds: Set<string>;
     closed: boolean;
+    private readonly _transportSamples;
+    private readonly _producerSamples;
+    private readonly _consumerSamples;
+    private readonly _dataProducerSamples;
+    private readonly _dataConsumerSamples;
+    private readonly _enrich?;
     constructor(settings: ObservedMediasoupRouterSettings<AppData>);
     get id(): string;
     get attachments(): Record<string, unknown>;
+    getTransportSample(id: string): MediasoupTransportSample | undefined;
+    getProducerSample(id: string): MediasoupProducerSample | undefined;
+    getConsumerSample(id: string): MediasoupConsumerSample | undefined;
+    getDataProducerSample(id: string): MediasoupDataProducerSample | undefined;
+    getDataConsumerSample(id: string): MediasoupDataConsumerSample | undefined;
+    /**
+     * Merge `attachments` into an entity's sample, whichever kind it is.
+     *
+     * Ids are unique across mediasoup entity kinds, so one method covers all of them. Returns `false`
+     * when the id is unknown — a real answer instead of failing quietly, which matters when the
+     * annotation is driven by application events that may race the mediasoup ones.
+     */
+    attachTo(id: string, attachments: Record<string, unknown>): boolean;
+    /**
+     * A **detached deep copy** of the current sample — the basis for building your own report.
+     *
+     * `this.sample` is live: its arrays grow and its `history` entries are appended as the router
+     * runs, so a report built directly on it keeps changing after you think you're done. This returns
+     * a snapshot that never moves.
+     */
+    snapshot(): MediasoupRouterSample;
     close(): void;
     addTransport: (transport: types.Transport) => void;
     addWebRtcTransport(transport: types.WebRtcTransport): void;
@@ -2264,6 +2886,18 @@ declare class ObservedMediasoupRouter<AppData extends Record<string, unknown> =
     addDataProducer(transport: types.Transport, dataProducer: types.DataProducer): void;
     addDataConsumer(transport: types.Transport, dataConsumer: types.DataConsumer): void;
     private attachRouterListeners;
+    private _addTransportSample;
+    private _addProducerSample;
+    private _addConsumerSample;
+    private _addDataProducerSample;
+    private _addDataConsumerSample;
+    /**
+     * Run an enricher and merge what it returns.
+     *
+     * Takes a thunk rather than a value so the **invocation** is inside the guard — application code
+     * runs here, and a throwing enricher must not take the router's bookkeeping down with it.
+     */
+    private _applyEnrichment;
     private _attachTransportObserverListeners;
 }
 
@@ -2304,6 +2938,18 @@ type ObserverEvents = {
         reason: SampleRejectedReason;
         sample: ClientSample;
     }];
+    /** An observer-scoped (cross-call / SFU-wide) finding raised by `observer.addIssue(...)`. */
+    'observer-issue': [ObserverEventBase & {
+        issue: ObserverIssue;
+    }];
+    /**
+     * A validator decided. Fires once per settle, not per tick — the point of a validator is that it
+     * stops talking once it knows.
+     */
+    'validation-ready': [ObserverEventBase & {
+        validator: string;
+        report: ValidationReport;
+    }];
     'mediasoup-router-added': [ObservedMediasoupRouterScope];
     'mediasoup-router-removed': [ObservedMediasoupRouterScope];
     'mediasoup-router-matched-with-peer-connection': [ObservedMediasoupRouterScope & ObservedPeerConnectionScope];
@@ -2313,7 +2959,7 @@ type ObserverEvents = {
     'call-empty': [ObservedCallScope];
     'call-not-empty': [ObservedCallScope];
     'call-issue': [ObservedCallScope & {
-        issue: ClientIssue;
+        issue: ObserverIssue;
     }];
     'client-added': [ObservedClientScope];
     'client-sink-created': [ObservedClientScope & {
@@ -2332,6 +2978,14 @@ type ObserverEvents = {
     'client-issue': [ObservedClientScope & {
         issue: ClientIssue;
     }];
+    /**
+     * A stateful client issue ended — the client sent its `<type>-resolved` companion, or the
+     * observer force-closed it because the client went away. Carries the finished **interval**
+     * (`raisedAt` → `resolvedAt`, `durationInMs`).
+     */
+    'client-issue-resolved': [ObservedClientScope & {
+        resolvedIssue: ResolvedActiveClientIssue;
+    }];
     'client-metadata': [ObservedClientScope & {
         metaData: ClientMetaData;
     }];
@@ -2503,6 +3157,61 @@ type ObserverEvents = {
     }];
 };
 
+/**
+ * Something that wants to be **handed** open client issues rather than to go looking for them.
+ *
+ * Register one with `activeIssuesRegistry.addIssueTracker(type, tracker)` and it receives every
+ * issue of that type when it opens ({@link add}) and when it closes ({@link delete}). A detector
+ * implementing this pays only for the issues it actually consumes.
+ *
+ * `ActiveIssuesRegistry` implements it too, which is how a call's registry feeds the observer's.
+ */
+interface ActiveIssueTracker {
+    /** An issue of a subscribed type opened. */
+    add(issue: ActiveClientIssue): void;
+    /**
+     * An issue this tracker was given has closed.
+     *
+     * Return `true` if it was actually held. Returning `false` is legitimate and not an error — a
+     * tracker that counts *occurrences* (see `SfuCongestionDetector`) deliberately ignores
+     * resolutions, because when a symptom ended says nothing about how many endpoints reported it.
+     */
+    delete(issue: ActiveClientIssue): boolean;
+    /** How many issues this tracker currently holds. */
+    size: number;
+    /** Drop everything. Called when the owning scope closes. */
+    clear(): void;
+    has(issue: ActiveClientIssue): boolean;
+}
+
+/**
+ * One 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):
+ * a raise opens an entry, the matching `<type>-resolved` closes it, and the client's own close
+ * force-resolves whatever is left. That turns point-in-time symptom reports into **intervals**,
+ * which is what lets detectors ask "are these clients broken *at the same time*" rather than "did
+ * they both report something recently".
+ *
+ * Keyed by `key` rather than by type on purpose: one client can have several issues of the same type
+ * open at once (one per track), and they resolve independently.
+ *
+ * Every change is forwarded to the call's `ActiveIssuesRegistry`, which forwards to the observer's —
+ * so the client owns the storage and the wider scopes get their views maintained as it happens.
+ */
+declare class ObservedClientIssueRegistry {
+    private readonly registry?;
+    private readonly issues;
+    constructor(registry?: ActiveIssueTracker | undefined);
+    get size(): number;
+    keys(): IterableIterator<string>;
+    values(): IterableIterator<ActiveClientIssue>;
+    get(key: string): ActiveClientIssue | undefined;
+    add(issue: ActiveClientIssue): this;
+    remove(key: string): ActiveClientIssue | undefined;
+    clear(): void;
+}
+
 type ObservedClientSettings<AppData extends Record<string, unknown> = Record<string, unknown>> = {
     clientId: string;
     appData?: AppData;
@@ -2581,11 +3290,20 @@ declare class ObservedClient<AppData extends Record<string, unknown> = Record<st
     totalScoreSum: number;
     numberOfScoreMeasurements: number;
     readonly mediaDevices: MediaDeviceInfo[];
-    issues: ClientIssue[];
+    /**
+     * The client's currently **open** stateful issues, keyed by `ClientIssue.key` — the server-side
+     * mirror of the client monitor's own active-issue map (client-monitor-js >= 4.6.0).
+     *
+     * This turns point-in-time symptom reports into intervals, which is what lets detectors ask
+     * "are these clients broken *at the same time*" instead of "did they both report something
+     * recently". Entries are opened by a raise, closed by the matching `<type>-resolved` entry, and
+     * force-closed when the client closes.
+     */
+    readonly activeIssues: ObservedClientIssueRegistry;
     private _pendingInjections;
     private _activeSample?;
     private closeTimer?;
-    constructor(settings: ObservedClientSettings<AppData>, call: ObservedCall);
+    constructor(settings: ObservedClientSettings<AppData>, call: ObservedCall, activeIssues: ObservedClientIssueRegistry);
     get numberOfPeerConnections(): number;
     get score(): number | undefined;
     close(): void;
@@ -2596,8 +3314,22 @@ declare class ObservedClient<AppData extends Record<string, unknown> = Record<st
     injectExtensionStat(stat: ExtensionStat): void;
     injectAttachment(attachments: Record<string, unknown>): void;
     addMetadata(metadata: ClientMetaData): void;
+    /**
+     * Process one `clientIssues[]` entry.
+     *
+     * Entries come in two flavours (client-monitor-js >= 4.6.0):
+     *
+     * - a **raise** — opens an {@link ActiveClientIssue} under `issue.key` and emits `client-issue`;
+     * - a **resolution** — `type` ends in `-resolved` and carries the same `key`; it closes the
+     *   matching active issue and emits `client-issue-resolved`.
+     *
+     * Keyless entries are one-shot: reported, never tracked. A re-raise of a key already active
+     * refreshes the payload rather than opening a second interval.
+     */
     addIssue(issue: ClientIssue): void;
     addExtensionStats(stats: ExtensionStat): void;
+    /** Close the active issue a `<type>-resolved` entry refers to, and announce the finished interval. */
+    private _resolveIssue;
     private _processClientEvent;
     private _updatePeerConnection;
     private _mergePendingInjections;
@@ -2655,82 +3387,1192 @@ declare class RemoteTrackResolver {
     private _removeOutboundTrack;
 }
 
-interface Updater {
-    readonly name: string;
-    readonly description?: string;
-    close(): void;
-}
-
 interface Detector {
     readonly name: string;
     /** Called on every entity update; may raise issues via the entity it observes. */
     update(): void;
+    /**
+     * Optional teardown, called when the detector is removed from its registry (or the registry is
+     * cleared, which happens when the owning call/observer closes). Implement it when the detector
+     * subscribes to events or holds timers, so it doesn't leak.
+     */
+    close?(): void;
 }
 
-declare class Detectors {
-    private _detectors;
-    constructor(...detectors: Detector[]);
-    get listOfNames(): string[];
-    add(detector: Detector): void;
-    remove(detector: Detector): void;
-    update(): void;
+declare const CallConcurrentIssueTypes: {
+    /** Several participants of this call have the same issue open **at the same time**. */
+    readonly concurrentClientIssues: "CONCURRENT_CLIENT_ISSUES";
+    /** Those issues also *began* together — the signature of one shared event. */
+    readonly issueOnsetBurst: "ISSUE_ONSET_BURST";
+};
+type CallConcurrentIssueDetectorConfig = {
+    /**
+     * The issue types to watch. **Required, and must not be empty** — the detector subscribes to
+     * exactly these and sees nothing else.
+     */
+    issueTypes: string[];
+    /** Minimum participants in the call before a ratio is meaningful. Default `3`. */
+    minClients: number;
+    /** Minimum distinct clients sharing the open issue. Default `3`. */
+    minAffectedClients: number;
+    /** Fraction of the call's participants that must share it. Default `0.5`. */
+    affectedRatioThreshold: number;
+    /**
+     * When the onsets fall within this span (ms), the finding is escalated to `ISSUE_ONSET_BURST` —
+     * they didn't just overlap, they started together. Default `2_000`.
+     */
+    onsetBurstWindowInMs: number;
+    /** Re-arm time (ms) per issue type. Default `60_000`. */
+    cooldownMs: number;
+};
+/** What the detector currently knows about one issue type in this call. */
+type CallConcurrentIssueGroup = {
+    type: string;
+    issues: ActiveClientIssue[];
+    clientIds: string[];
+    affectedRatio: number;
+    totalClients: number;
+    /**
+     * Spread of the onsets, in **observer** time (ms) — `max(observedAt) - min(observedAt)`.
+     *
+     * Measured on the observer clock on purpose: `raisedAt` comes from each client's own clock, and
+     * comparing those across machines makes clock skew look like a shared event.
+     */
+    onsetSpreadInMs: number;
+    firstObservedAt: number;
+};
+/**
+ * Answers **"is this meeting in trouble?"** — several participants of one call with the same issue
+ * open simultaneously.
+ *
+ * The client already decides *what* is wrong for itself — `congestion`, `ice-disconnected`,
+ * `audio-concealment`, `video-decoder-overloaded` — with hysteresis and multi-signal confirmation
+ * behind each verdict. Re-deriving those server-side from raw counters would be strictly worse. What
+ * the server uniquely knows is *how many other participants of the same call are in that state right
+ * now*, which is the difference between "one person's Wi-Fi" and "this room is broken".
+ *
+ * Concurrency is judged from the **open interval set**, not a window of recent reports. A window has
+ * to guess whether a symptom is still happening; an interval is closed by the client when the episode
+ * actually ends (client-monitor-js >= 4.6.0 ships the `<type>-resolved` companion for exactly this).
+ *
+ * ```ts
+ * observedCall.addDetector('call-concurrent-issue-detector', {
+ *   issueTypes: [ 'congestion', 'ice-disconnected' ],
+ * });
+ * ```
+ *
+ * For the cross-call version of this question — which is a different question, not this one with a
+ * bigger denominator — see `ObserverConcurrentIssueDetector`.
+ */
+declare class CallConcurrentIssueDetector implements Detector, ActiveIssueTracker {
+    private readonly _call;
+    static readonly NAME: "call-concurrent-issue-detector";
+    readonly name: "call-concurrent-issue-detector";
+    private readonly _config;
+    private readonly _lastRaisedAt;
+    /** issue type -> the issues of that type currently open in this call. */
+    private readonly _byType;
+    private _size;
+    /** The groups that qualified on the most recent `update()`. Exposed for tests/dashboards. */
+    lastGroups: CallConcurrentIssueGroup[];
+    constructor(_call: ObservedCall, config?: Partial<CallConcurrentIssueDetectorConfig>);
+    get size(): number;
+    has(issue: ActiveClientIssue): boolean;
+    add(issue: ActiveClientIssue): void;
+    delete(issue: ActiveClientIssue): boolean;
     clear(): void;
+    update(): void;
+    close(): void;
+    private _groupOf;
 }
 
-type ObservedCallUpdateConfig = {
-    updatePolicy?: 'update-on-any-client-updated' | 'update-when-all-client-updated' | 'none';
+declare const ClientPopulationIssueTypes: {
+    /** One issue type is concentrated on one client population while the rest of the fleet is fine. */
+    readonly clientPopulationIssue: "CLIENT_POPULATION_ISSUE";
 };
-type ObservedCallSettings<AppData extends Record<string, unknown> = Record<string, unknown>> = ObservedCallUpdateConfig & {
-    callId: string;
-    appData?: AppData;
-    closeCallIfEmptyForMs?: number;
+/** The client attribute to group by. One axis per detector — see the class description. */
+type ClientPopulationAxis = 'browser' | 'engine' | 'platform' | 'operationSystem';
+type ClientPopulationIssueDetectorConfig = {
+    /**
+     * The issue types to watch. **Required, and must not be empty.**
+     *
+     * The types worth grouping this way are the ones an endpoint owns: `cpulimitation`,
+     * `encoder-bottleneck`, `capture-bottleneck`, `stuck-decoder`, `video-decoder-overloaded`.
+     * Grouping a *network* symptom by browser is a category error — `congestion` clusters by ISP and
+     * geography, neither of which this detector can see, and it would happily report a browser
+     * correlation that is really a "most of our users are on Chrome" artefact.
+     */
+    issueTypes: string[];
+    /** Which client attribute to group by. Default `'browser'`. */
+    groupBy: ClientPopulationAxis;
+    /**
+     * Group by `name` only, or by `name + version`. Default `true` (include version).
+     *
+     * Version is usually the point: "Chrome" is not actionable, "Chrome 141" is, because it names a
+     * thing that changed on a date. Set to `false` when comparing whole engines.
+     */
+    includeVersion: boolean;
+    /** Minimum clients in a population before its rate means anything. Default `20`. */
+    minPopulationSize: number;
+    /** Minimum affected clients in the population. Default `5`. */
+    minAffectedClients: number;
+    /** Share of the population that must be affected. Default `0.3`. */
+    affectedRatioThreshold: number;
+    /**
+     * How many times worse the suspect population must be than the rest of the fleet. Default `3`.
+     *
+     * This is the control, and it is what makes the finding mean anything. See the class description.
+     */
+    minRelativeRisk: number;
+    /** Minimum clients **outside** the suspect population before a comparison is possible. Default `20`. */
+    minControlSize: number;
+    /** Re-arm time (ms) per (population, issue type). Default `300_000`. */
+    cooldownMs: number;
 };
-type ObservedCallEvents = {
-    update: [];
-    newclient: [ObservedClient];
-    empty: [];
-    'not-empty': [];
-    close: [];
+/** The rollup for one population on one issue type. */
+type ClientPopulation = {
+    /** e.g. `'Chrome 141'`, or `'Chrome'` when `includeVersion` is off. */
+    population: string;
+    axis: ClientPopulationAxis;
+    issueType: string;
+    clients: number;
+    affectedClients: number;
+    affectedRatio: number;
+    affectedClientIds: string[];
+    /** Everyone not in this population. */
+    controlClients: number;
+    controlAffectedClients: number;
+    controlAffectedRatio: number;
+    /** `affectedRatio / controlAffectedRatio`. `Infinity` when the control group is completely clean. */
+    relativeRisk: number;
 };
-declare interface ObservedCall {
-    on<U extends keyof ObservedCallEvents>(event: U, listener: (...args: ObservedCallEvents[U]) => void): this;
-    off<U extends keyof ObservedCallEvents>(event: U, listener: (...args: ObservedCallEvents[U]) => void): this;
-    once<U extends keyof ObservedCallEvents>(event: U, listener: (...args: ObservedCallEvents[U]) => void): this;
-    emit<U extends keyof ObservedCallEvents>(event: U, ...args: ObservedCallEvents[U]): boolean;
+/**
+ * Finds an issue that is concentrated on **one kind of client** — one browser, one browser version,
+ * one OS — rather than on anything the servers own.
+ *
+ * ### Why this exists
+ *
+ * The other observer-scoped detectors all answer "who else has this open, and what do they share?"
+ * with the answer *the infrastructure*, because clients in unrelated calls share nothing else. That
+ * inference is right for network symptoms and **wrong for endpoint symptoms**, and the difference
+ * matters at 3am. `cpulimitation` opening across six unrelated calls is not an SFU event: CPU is
+ * owned by the endpoint, so what those endpoints have in common is a client release, a browser
+ * update, or a fleet of identical VDI hosts. `IssueConclusion` already says exactly this — it maps
+ * the endpoint-capacity family to a `client-population` fault domain instead of `infrastructure` —
+ * but until now nothing in the library actually computed the grouping that claim refers to. This
+ * detector is that computation.
+ *
+ * It is the one correlation in this library that is neither per-call nor per-server. A client knows
+ * its own browser and nothing about anyone else's; only something sitting above the whole fleet can
+ * notice that every complaint is coming from the same build.
+ *
+ * ### The control group is the whole point
+ *
+ * "30% of Chrome 141 users report encoder-bottleneck" is not a finding on its own. If 30% of
+ * *everyone* reports it, Chrome 141 is not the story — you have a fleet-wide problem and this
+ * detector would be pointing at the largest population rather than at a cause. Naive share-based
+ * grouping always indicts whichever browser is most popular, which is why the gate here is
+ * **relative risk**: the suspect population's rate divided by the rate among everyone else. A
+ * population only qualifies when it is `minRelativeRisk` times worse than the rest of the fleet, and
+ * only when the rest of the fleet is large enough (`minControlSize`) for "the rest of the fleet" to
+ * be a real measurement.
+ *
+ * A completely clean control group gives `Infinity`, which is honest — nobody outside this
+ * population has the problem at all — and is exactly why `minAffectedClients` and
+ * `minPopulationSize` are checked independently, so a single unlucky user on a rare browser cannot
+ * page anyone.
+ *
+ * ### One axis per detector
+ *
+ * `groupBy` takes a single attribute. Add a second instance if you want a second axis:
+ *
+ * ```ts
+ * observer.addObserverDetector('client-population-issue-detector', {
+ *   issueTypes: [ 'cpulimitation', 'encoder-bottleneck', 'stuck-decoder' ],
+ *   groupBy: 'browser',
+ * });
+ *
+ * observer.on('observer-issue', ({ issue }) => {
+ *   if (issue.type !== ClientPopulationIssueTypes.clientPopulationIssue) return;
+ *   // → { population: 'Chrome 141', issueType: 'encoder-bottleneck',
+ *   //     affectedRatio: 0.34, controlAffectedRatio: 0.02, relativeRisk: 17 }
+ * });
+ * ```
+ *
+ * Deliberately not a cross-product of every axis at once: an issue that clusters on macOS *and* on
+ * Safari is usually one fact reported twice, and a detector that emits both leaves the reader to
+ * work out which one is causal. Pick the axis you want to reason about.
+ *
+ * ### Clients that never reported their metadata
+ *
+ * `browser` / `engine` / `platform` / `operationSystem` arrive as client metadata and may be absent —
+ * a client that closed before sending them, or an application that does not collect them. Those
+ * clients are excluded from **both** the population and the control group rather than bucketed as
+ * `'unknown'`. A synthetic `'unknown'` population would be a mixture of every real one, so any rate
+ * computed for it means nothing, and leaving those clients in the control group would dilute the
+ * comparison with clients whose kind we cannot verify.
+ */
+declare class ClientPopulationIssueDetector implements Detector, ActiveIssueTracker {
+    private readonly _observer;
+    static readonly NAME: "client-population-issue-detector";
+    readonly name: "client-population-issue-detector";
+    private readonly _config;
+    private readonly _lastRaisedAt;
+    private readonly _issues;
+    /** The populations that qualified on the most recent `update()`. Exposed for tests/dashboards. */
+    lastPopulations: ClientPopulation[];
+    constructor(_observer: Observer, config?: Partial<ClientPopulationIssueDetectorConfig>);
+    get size(): number;
+    has(issue: ActiveClientIssue): boolean;
+    add(issue: ActiveClientIssue): void;
+    delete(issue: ActiveClientIssue): boolean;
+    clear(): void;
+    update(): void;
+    close(): void;
+    /** `undefined` when the client never reported this attribute — see the class description. */
+    private _populationOf;
+    private _rollupOf;
+    private _riskText;
+    /** Bigger populations and starker contrasts are harder to produce by chance. */
+    private _confidenceOf;
 }
-declare class ObservedCall<AppData extends Record<string, unknown> = Record<string, unknown>> extends EventEmitter {
-    readonly observer: Observer;
-    updater?: Updater;
-    scoreCalculator: ScoreCalculator;
-    readonly detectors: Detectors;
-    readonly callId: string;
-    readonly observedClients: Map<string, ObservedClient<Record<string, unknown>>>;
-    readonly clientsUsedTurn: Set<string>;
-    readonly calculatedScore: CalculatedScore;
-    remoteTrackResolver?: RemoteTrackResolver;
-    totalAddedClients: number;
-    totalRemovedClients: number;
-    numberOfIssues: number;
-    numberOfPeerConnections: number;
-    numberOfInboundRtpStreams: number;
-    numberOfOutboundRtpStreams: number;
-    numberOfDataChannels: number;
-    maxNumberOfClients: number;
-    deltaNumberOfIssues: number;
-    appData: AppData;
-    closed: boolean;
+
+declare const PublisherFaultTypes: {
+    /**
+     * A publisher is reporting trouble on its own send path **while** its subscribers report trouble
+     * receiving it. Both ends agree, so the source is implicated rather than inferred.
+     */
+    readonly corroboratedPublisherFault: "CORROBORATED_PUBLISHER_FAULT";
+};
+type PublisherFaultCorroborationDetectorConfig = {
+    /**
+     * Issue types raised by the **publishing** client about its own outbound path. **Required.**
+     *
+     * The natural set from client-monitor-js: `encoder-bottleneck`, `capture-bottleneck`,
+     * `dry-outbound-track`. All three mean "I am failing to produce or send this properly", which is
+     * the half of the story the receivers cannot see.
+     */
+    publisherIssueTypes: string[];
+    /**
+     * Issue types raised by the **subscribing** clients about the track they receive. **Required.**
+     *
+     * The natural set: `freezed-video-track`, `dry-inbound-track`, `video-recovery-failed`. These say
+     * "I am not getting this properly", which is the half the publisher cannot see.
+     */
+    receiverIssueTypes: string[];
+    /** Minimum subscribers of the track that must be complaining. Default `2`. */
+    minAffectedReceivers: number;
+    /** Re-arm time (ms) per published track. Default `60_000`. */
+    cooldownMs: number;
+};
+/** The two-sided evidence behind one finding. */
+type CorroboratedPublisherFault = {
+    trackId: string;
+    kind: string;
+    publisherClientId: string;
+    /** The publisher's own open issue types on this track. */
+    publisherIssueTypes: string[];
+    /** The receiver-side open issue types across this track's subscribers. */
+    receiverIssueTypes: string[];
+    receivers: number;
+    affectedReceivers: number;
+    affectedClientIds: string[];
+    publisherBitrate?: number;
+};
+/**
+ * Fires only when **both ends of one published track are complaining at the same time**: the
+ * publisher about its own send path, and its subscribers about receiving it.
+ *
+ * ### How this differs from `IssueFanOutDetector`
+ *
+ * Fan-out sees one end. It observes that most of Alice's subscribers are unhappy and *infers* that
+ * the fault is on Alice's side, because the affected clients share a publisher and nothing else. That
+ * inference is sound, and it is still a inference: the same observation is produced by the SFU
+ * mangling Alice's stream on the way out, with Alice herself perfectly healthy.
+ *
+ * This detector removes the inference. When Alice reports `encoder-bottleneck` *and* four of her six
+ * subscribers report `freezed-video-track` in the same window, there is nothing left to deduce — the
+ * source said it was struggling and the receivers confirmed the consequence. That is the strongest
+ * statement this library can make about where a fault sits, and it is only available to something
+ * holding both ends at once. Neither the publisher nor any receiver can reach this conclusion alone.
+ *
+ * Run both: fan-out is broader and catches the SFU-forwarding case where the publisher is fine;
+ * this one is narrower and, when it fires, needs no interpretation.
+ *
+ * ### Silence here is not health
+ *
+ * A quiet detector means only that the two halves have not coincided — most commonly because the
+ * publisher is genuinely fine and the fault is in forwarding, which is exactly the case `fan-out`
+ * exists to report. Do not read "no corroborated fault" as "no publisher-side problem".
+ *
+ * ```ts
+ * observedCall.addDetector('publisher-fault-corroboration-detector', {
+ *   publisherIssueTypes: [ 'encoder-bottleneck', 'capture-bottleneck', 'dry-outbound-track' ],
+ *   receiverIssueTypes: [ 'freezed-video-track', 'dry-inbound-track' ],
+ * });
+ * ```
+ *
+ * ### Requires a `RemoteTrackResolver`
+ *
+ * Matching a publisher's issue to its subscribers' issues needs the publisher↔subscriber links. With
+ * no resolver the detector does nothing rather than guessing.
+ */
+declare class PublisherFaultCorroborationDetector implements Detector, ActiveIssueTracker {
+    private readonly _call;
+    static readonly NAME: "publisher-fault-corroboration-detector";
+    readonly name: "publisher-fault-corroboration-detector";
+    private readonly _config;
+    private readonly _lastRaisedAt;
+    /** Open publisher-side issues that name a track. */
+    private readonly _publisherIssues;
+    /** Open receiver-side issues that name a track. */
+    private readonly _receiverIssues;
+    /** The faults corroborated on the most recent `update()`. Exposed for tests/dashboards. */
+    lastFaults: CorroboratedPublisherFault[];
+    constructor(_call: ObservedCall, config?: Partial<PublisherFaultCorroborationDetectorConfig>);
+    get size(): number;
+    has(issue: ActiveClientIssue): boolean;
+    add(issue: ActiveClientIssue): void;
+    delete(issue: ActiveClientIssue): boolean;
+    clear(): void;
+    update(): void;
+    close(): void;
+    /**
+     * Resolve a publisher-side issue's `trackId` to the outbound track it is about.
+     *
+     * Looked up through the reporting client's own peer connections: the issue names its client, so
+     * the search is bounded by that client's transports rather than by the size of the call.
+     */
+    private _outboundTrackOf;
+}
+
+declare const ObserverConcurrentIssueTypes: {
+    /**
+     * The same issue is open in **several unrelated calls at once**. Those clients share no meeting,
+     * no publisher and no room — only the infrastructure serving them.
+     */
+    readonly crossCallConcurrentIssues: "CROSS_CALL_CONCURRENT_ISSUES";
+    /** The cross-call version that also started together. The strongest "it's us" signal available. */
+    readonly crossCallIssueOnsetBurst: "CROSS_CALL_ISSUE_ONSET_BURST";
+};
+type ObserverConcurrentIssueDetectorConfig = {
+    /**
+     * The issue types to watch. **Required, and must not be empty** — the detector subscribes to
+     * exactly these and sees nothing else.
+     */
+    issueTypes: string[];
+    /** Minimum distinct clients sharing the open issue. Default `3`. */
+    minAffectedClients: number;
+    /**
+     * Minimum number of *distinct calls* the affected clients must span. Default `2`.
+     *
+     * This is what makes an observer-scoped finding mean something a call-scoped one doesn't. Without
+     * it, one thirty-person meeting with congestion satisfies every client-count threshold and raises
+     * a fleet-wide alert for what is really one bad room — which `CallConcurrentIssueDetector` has
+     * already reported. Requiring two or more independent calls is the difference between a
+     * coincidence and a shared cause.
+     */
+    minAffectedCalls: number;
+    /**
+     * Fraction of the calls in flight that must be affected. Default `0` — off, because absolute
+     * counts matter more than ratios here: three broken calls out of a thousand is still worth
+     * knowing about, and a ratio threshold would hide it. Raise it if you only care about fleet-wide
+     * events.
+     *
+     * Note there is deliberately **no participant ratio** at this scope. Six broken calls out of forty
+     * is a handful of clients against the whole fleet, so any meaningful client ratio would suppress
+     * exactly the finding this detector exists to produce.
+     */
+    affectedCallRatioThreshold: number;
+    /**
+     * When the onsets fall within this span (ms), the finding is escalated to
+     * `CROSS_CALL_ISSUE_ONSET_BURST`. Default `2_000`.
+     */
+    onsetBurstWindowInMs: number;
+    /** Re-arm time (ms) per issue type. Default `60_000`. */
+    cooldownMs: number;
+};
+/** What the detector currently knows about one issue type across the fleet. */
+type ObserverConcurrentIssueGroup = {
+    type: string;
+    issues: ActiveClientIssue[];
+    clientIds: string[];
+    totalClients: number;
+    affectedRatio: number;
+    callIds: string[];
+    totalCalls: number;
+    affectedCallRatio: number;
+    /** Per-call breakdown, largest first — the first question anyone asks is "which calls, how badly?". */
+    perCall: {
+        callId: string;
+        affectedClients: number;
+        totalClients: number;
+    }[];
+    /**
+     * Spread of the onsets, in **observer** time (ms). Client clocks are never compared across
+     * machines here — skew between them would masquerade as a synchronized event.
+     */
+    onsetSpreadInMs: number;
+    firstObservedAt: number;
+};
+/**
+ * Answers **"is our infrastructure in trouble?"** — the same issue open across several *unrelated*
+ * calls at the same moment.
+ *
+ * This is not the call-scoped question with a bigger denominator, which is why it is a separate
+ * detector with separate gates and its own finding types. Participant count alone is a bad fleet
+ * signal: one thirty-person meeting where everybody is congested clears every client threshold, yet
+ * it has an obvious local explanation. Clients in *different* calls share no room, no publisher and
+ * no host — only the servers and the network. When the same issue opens across several of them at
+ * once, the infrastructure is the only remaining common factor, and that is the finding worth paging
+ * someone about.
+ *
+ * ```ts
+ * observer.addObserverDetector('observer-concurrent-issue-detector', {
+ *   issueTypes: [ 'congestion', 'ice-disconnected' ],
+ *   minAffectedCalls: 3,
+ * });
+ *
+ * observer.on('observer-issue', ({ issue }) => {
+ *   if (issue.type === ObserverConcurrentIssueTypes.crossCallIssueOnsetBurst) page(issue);
+ * });
+ * // → CROSS_CALL_ISSUE_ONSET_BURST { issueType: 'congestion', calls: 40, affectedCalls: 6, … }
+ * ```
+ *
+ * Onsets are compared on the **observer clock** (`observedAt`), never on client clocks: participants
+ * degrading together within a couple of seconds is far more likely to be a deploy, a TURN failover or
+ * a link flap than a coincidence — but only if the timestamps being compared came from one clock.
+ */
+declare class ObserverConcurrentIssueDetector implements Detector, ActiveIssueTracker {
+    private readonly _observer;
+    static readonly NAME: "observer-concurrent-issue-detector";
+    readonly name: "observer-concurrent-issue-detector";
+    private readonly _config;
+    private readonly _lastRaisedAt;
+    /** issue type -> the issues of that type currently open anywhere in the fleet. */
+    private readonly _byType;
+    private _size;
+    /** The groups that qualified on the most recent `update()`. Exposed for tests/dashboards. */
+    lastGroups: ObserverConcurrentIssueGroup[];
+    constructor(_observer: Observer, config?: Partial<ObserverConcurrentIssueDetectorConfig>);
+    get size(): number;
+    has(issue: ActiveClientIssue): boolean;
+    add(issue: ActiveClientIssue): void;
+    delete(issue: ActiveClientIssue): boolean;
+    clear(): void;
+    update(): void;
+    close(): void;
+    private _groupOf;
+}
+
+declare const IssueFanOutTypes: {
+    /** Most receivers of one published track have the same issue open → the fault follows the source. */
+    readonly publishedTrackIssueFanOut: "PUBLISHED_TRACK_ISSUE_FAN_OUT";
+    /** Exactly one receiver of a track has it → that receiver's own problem. */
+    readonly singleReceiverIssue: "SINGLE_RECEIVER_ISSUE";
+};
+type IssueFanOutDetectorConfig = {
+    /**
+     * The receiver-side issue types to attribute to publishers. **Required, and must not be empty** —
+     * the detector subscribes to exactly these.
+     *
+     * There is no "all types" option. Which of a receiver's complaints are worth blaming a publisher
+     * for is application knowledge: `freezed-video-track` fanning out across a track's subscribers
+     * implicates the source, `cpulimitation` fanning out the same way implicates the receivers'
+     * hardware and would be a false accusation.
+     */
+    issueTypes: string[];
+    /** Minimum receivers of the track before a ratio is meaningful. Default `3`. */
+    minReceivers: number;
+    /** Fraction of a track's receivers that must share the issue. Default `0.6`. */
+    affectedRatioThreshold: number;
+    /** Also report the "only one receiver is affected" case. Default `true`. */
+    reportSingleReceiver: boolean;
+    /** Re-arm time (ms) per (track, issue type). Default `60_000`. */
+    cooldownMs: number;
+};
+/**
+ * Attributes **client-reported issues to the published track they are about**, then asks how far
+ * the problem fans out across that track's receivers.
+ *
+ * The join is what makes this possible: a receiver-side issue payload carries `trackId` (the client
+ * detectors report it for every track-scoped issue), the observer resolves that to an inbound track,
+ * and `RemoteTrackResolver` links the inbound track to the `remoteOutboundTrack` that published it.
+ * With the whole subscriber set of one source in hand, the verdict is straightforward and is the
+ * single most useful thing a server can say:
+ *
+ * - **most receivers of Alice's track are affected** → the fault is on Alice's path — her uplink, the
+ *   SFU's ingress, or its forwarding of that stream.
+ * - **one receiver of Alice's track is affected** → that receiver's downlink. Nothing to do with
+ *   Alice, even though the symptom is reported against her stream.
+ *
+ * Deliberately generic over the issue vocabulary: `freezed-video-track`, `keyframe-storm`,
+ * `audio-concealment`, `video-decoder-overloaded`, `stuck-decoder` and anything a custom client
+ * detector invents all fan out the same way, so one mechanism replaces a family of symptom-specific
+ * detectors.
+ *
+ * ### It walks the affected tracks, never all of them
+ *
+ * The detector is fed open issues by the call's registry and keeps only those carrying a `trackId`.
+ * Each tick it resolves *those* tracks to their publishers — never the published tracks of the call,
+ * of which there are many more and almost all of them fine. A call with nothing wrong costs one
+ * `size === 0` check.
+ *
+ * ### Requires a `RemoteTrackResolver`
+ *
+ * Without publisher↔subscriber links there is no way to know which receivers belong to one source,
+ * so the detector does nothing when the call has no resolver. It does not fall back to guessing:
+ * "one receiver of an unknown set" is not a statement worth raising.
+ */
+declare class IssueFanOutDetector implements Detector, ActiveIssueTracker {
+    private readonly _call;
+    static readonly NAME = "issue-fan-out-detector";
+    readonly name = "issue-fan-out-detector";
+    private readonly _config;
+    private readonly _lastRaisedAt;
+    /** Open issues that name a track. Issues without a `trackId` cannot be attributed and are dropped. */
+    private readonly _trackIssues;
+    constructor(_call: ObservedCall, config?: Partial<IssueFanOutDetectorConfig>);
+    get size(): number;
+    has(issue: ActiveClientIssue): boolean;
+    add(issue: ActiveClientIssue): void;
+    delete(issue: ActiveClientIssue): boolean;
+    clear(): void;
+    update(): void;
+    close(): void;
+    /**
+     * Resolve the issue's `trackId` to the outbound track that published it.
+     *
+     * Looked up through the reporting client's own peer connections rather than by scanning the call:
+     * the issue names its client, so the search is bounded by that client's transports (typically one
+     * or two) instead of by the size of the meeting.
+     */
+    private _publisherOf;
+}
+
+/**
+ * One completed sampling bucket: how many/which clients reported congestion during it.
+ *
+ * `totalClients` (and therefore `congestedClientRatio`) is a snapshot of `observer.numberOfClients`
+ * taken when the bucket closes — an approximation of "how many clients could have been congested",
+ * not a claim that every client sent exactly one sample within the bucket. Good enough for a ratio
+ * that only needs to be comparable bucket-to-bucket.
+ */
+type SfuCongestionDetectorBucket = {
+    observedAt: number;
+    totalClients: number;
+    congestedClients: number;
+    congestedClientRatio: number;
+    affectedClientIds: string[];
+    affectedCallIds: string[];
+};
+type SfuCongestionDetectorReport = {
+    affectedCallIds: string[];
+    affectedClientIds: string[];
+    congestedClientRatio: number;
+    totalNumberOfClients: number;
+    numberOfCongestedClients: number;
+    historySize: number;
+    baselineCongestedClientRatio: number;
+    robustZ: number;
+    absoluteIncrease: number;
+    relativeIncrease: number;
+};
+type SfuCongestionDetectorConfig = {
+    consumedClientIssueTypes: string[];
+    emittedObserverIssueType: string;
+    samplesSendingTimeInMs: number;
+    historySize: number;
+    minHistorySize: number;
+    minAffectedClients: number;
+    minAbsoluteRatioIncrease: number;
+    minRelativeRatioIncrease: number;
+    robustZThreshold: number;
+};
+/** The statistical/practical-significance verdict for one candidate bucket against its baseline. */
+type SfuCongestionDetectorEvaluation = {
+    isCongested: boolean;
+    baselineCongestedClientRatio: number;
+    robustZ: number;
+    absoluteIncrease: number;
+    relativeIncrease: number;
+};
+/**
+ * Detects a **shared** congestion event: many clients, across different calls, reporting congestion
+ * inside the same slice of time.
+ *
+ * Only add this when the observer's calls all come from the **same SFU** — the finding's whole
+ * meaning is "these clients have nothing in common except that server", and that is only true if the
+ * server really is the common factor.
+ *
+ * ### Why fixed-interval buckets, and not the update tick
+ *
+ * The obvious implementation counts congested clients on each `update()`. It is wrong here, for two
+ * separate reasons:
+ *
+ * - **The tick is not evenly spaced.** `update()` fires when a client is updated, so its rate is a
+ *   function of how many clients are connected and how their sampling happens to interleave. Two
+ *   counts taken from windows of different length are not comparable, and this detector's entire
+ *   job is to compare a count against earlier counts.
+ * - **Clients report on their own schedule.** A client sends a sample roughly every
+ *   `samplesSendingTimeInMs`, unsynchronised with every other client. A window shorter than that
+ *   systematically undercounts — half the congested clients simply hadn't spoken yet — and the
+ *   undercount varies with arrival phase, which is noise indistinguishable from signal.
+ *
+ * So the detector runs on a wall-clock interval and closes a bucket every
+ * `samplesSendingTimeInMs`, giving every client a fair chance to be heard in each one. Buckets are
+ * equal-length and equally lagged, which is what makes bucket-to-bucket comparison mean something.
+ * {@link update} is deliberately empty: nothing here is driven by the update tick.
+ *
+ * ### Occurrences, not intervals
+ *
+ * Unlike `ConcurrentIssueDetector`, this one ignores resolutions — see {@link delete}. It counts how
+ * many *distinct clients reported* congestion in a bucket, not how many are still congested. A
+ * client that hits congestion and immediately drops its bitrate resolves the issue within seconds
+ * and would vanish from an open-interval view, yet it is exactly the evidence wanted here.
+ */
+declare class SfuCongestionDetector implements Detector, ActiveIssueTracker {
+    private readonly _observer;
+    static readonly NAME = "sfu-congestion-detector";
+    readonly name = "sfu-congestion-detector";
+    private readonly _config;
+    private readonly _history;
+    private readonly _trackedIssues;
+    private timer;
+    private _lastEvaluatedBucket;
+    constructor(_observer: Observer, config?: Partial<SfuCongestionDetectorConfig>);
+    get size(): number;
+    /** Record the issue against the bucket currently open. The timer, not this, closes the bucket. */
+    add(issue: ActiveClientIssue): void;
+    /**
+     * Deliberately a no-op returning `false`.
+     *
+     * Resolutions are not interesting here. A congested client typically fixes its own symptom by
+     * dropping bitrate hard, so the issue closes within seconds — but it still *happened*, and it is
+     * evidence that the server was under pressure during this bucket. What matters is how many
+     * distinct clients reported congestion within the bucket and whether that count suddenly jumps,
+     * not how long any one client's issue stayed open.
+     *
+     * Nothing leaks: the tracked set is emptied wholesale every time a bucket closes.
+     */
+    delete(_issue: ActiveClientIssue): boolean;
+    clear(): void;
+    has(issue: ActiveClientIssue): boolean;
+    close(): void;
+    /** The completed buckets kept so far, oldest first. Read-only — for introspection/tests. */
+    get history(): readonly SfuCongestionDetectorBucket[];
+    /**
+     * Intentionally empty — see the class description.
+     *
+     * Everything here is driven by the bucket timer, because the update tick is neither evenly spaced
+     * nor long enough for every client to have reported. Counting on it would compare windows of
+     * different lengths and call the difference a signal.
+     */
+    update(): void;
+    private _closeBucket;
+    /**
+     * Evaluate only the latest completed bucket (the candidate) against the buckets before it (the
+     * baseline) — never against itself. Reached once per newly-closed bucket via {@link update}; the
+     * identity check below additionally guards against evaluating the same bucket twice, in case
+     * `update()` is ever called again before the next rotation.
+     */
+    private _evaluateLatestBucket;
+    /**
+     * Is `candidate` — the latest completed bucket — abnormally high compared with the `baseline`
+     * buckets before it?
+     *
+     * Requires both **statistical** significance (a robust z-score against a median+MAD baseline —
+     * deliberately not Mann-Kendall, which asks "is this a monotonic trend", not "is the latest point
+     * an outlier"; a single sudden spike on an otherwise flat series is exactly what should trigger
+     * here and exactly what a trend test would miss) and **practical** significance (enough affected
+     * clients, and a big enough absolute/relative jump — a statistically significant move in a tiny
+     * or trivial ratio is not worth an alert).
+     */
+    private _evaluateBucket;
+}
+
+declare const TrackDeliveryMismatchTypes: {
+    /**
+     * The source is sending, but **none** of its subscribers are receiving → the media is being lost
+     * between the publisher and the receivers. In an SFU that means the forwarding path.
+     */
+    readonly publishedTrackNotDelivered: "PUBLISHED_TRACK_NOT_DELIVERED";
+    /**
+     * The source is sending and most subscribers are fine, but **some** are dry → those consumers are
+     * broken individually (in mediasoup, the usual mitigation is recreating the consumer).
+     */
+    readonly receiverTrackNotDelivered: "RECEIVER_TRACK_NOT_DELIVERED";
+    /**
+     * The source itself stopped producing, so its subscribers being dry is expected and **not** an
+     * SFU fault. Reported so the other two verdicts can be trusted as *not* being this.
+     */
+    readonly publisherTrackDry: "PUBLISHER_TRACK_DRY";
+};
+type TrackDeliveryMismatchDetectorConfig = {
+    /** The receiver-side issue type meaning "no media arriving". Default `'dry-inbound-track'`. */
+    dryInboundIssueType: string;
+    /** The publisher-side issue type meaning "not producing". Default `'dry-outbound-track'`. */
+    dryOutboundIssueType: string;
+    /** Minimum subscribers before "all of them" means anything. Default `2`. */
+    minReceivers: number;
+    /** Fraction of subscribers that must be dry to call it a whole-track delivery failure. Default `1`. */
+    allReceiversRatio: number;
+    /** Re-arm time (ms) per (track, verdict). Default `60_000`. */
+    cooldownMs: number;
+};
+/**
+ * Answers **"is the media actually getting through?"** by joining the two ends of a published track.
+ *
+ * A dry track is the clearest possible symptom — no bytes are arriving — but on its own it is
+ * ambiguous, and the ambiguity is precisely what a single endpoint cannot resolve. A receiver seeing
+ * silence cannot tell whether the camera was switched off, the SFU stopped forwarding, or its own
+ * consumer wedged. All three look identical from the browser.
+ *
+ * With the publisher↔subscriber links this becomes a three-way decision:
+ *
+ * | publisher | subscribers | verdict |
+ * |---|---|---|
+ * | sending | **all** dry | `PUBLISHED_TRACK_NOT_DELIVERED` — the SFU/forwarding path |
+ * | sending | **some** dry | `RECEIVER_TRACK_NOT_DELIVERED` — those consumers (recreate them) |
+ * | dry | any dry | `PUBLISHER_TRACK_DRY` — the source stopped; not an SFU fault |
+ *
+ * The publisher side is judged from **both** signals available: its own `dry-outbound-track` issue
+ * when the client reports one, and — as the fallback, and the corroboration when it does not — the
+ * observed outbound RTP (`deltaPacketsSent`). That combination is what makes the first row
+ * trustworthy: the server can state that packets demonstrably left the publisher during the same
+ * interval in which every receiver got nothing.
+ *
+ * This is the "SFU forwarding mismatch" check, and notably it needs **no** mediasoup instrumentation
+ * — the client's own dry-track verdicts plus the resolver links are sufficient.
+ */
+declare class TrackDeliveryMismatchDetector implements Detector, ActiveIssueTracker {
+    private readonly call;
+    static readonly NAME: "track-delivery-mismatch-detector";
+    readonly name: "track-delivery-mismatch-detector";
+    private readonly _config;
+    private readonly _lastRaisedAt;
+    private readonly dryOutboundTracks;
+    private readonly dryInboundTracks;
+    constructor(call: ObservedCall, config?: Partial<TrackDeliveryMismatchDetectorConfig>);
+    close(): void;
+    add(issue: ActiveClientIssue): void;
+    delete(issue: ActiveClientIssue): boolean;
+    get size(): number;
+    clear(): void;
+    has(issue: ActiveClientIssue): boolean;
+    update(): void;
+}
+
+declare const TurnServerHealthTypes: {
+    /** One TURN server's clients are in trouble while other servers' clients are fine. */
+    readonly turnServerDegraded: "TURN_SERVER_DEGRADED";
+};
+type TurnServerHealthDetectorConfig = {
+    /** Minimum clients on a server before a ratio is meaningful. Default `5`. */
+    minClientsPerServer: number;
+    /** Fraction of a server's clients that must have an open issue. Default `0.5`. */
+    degradedRatioThreshold: number;
+    /**
+     * Which client issue types count as "in trouble". Empty (default) means **any** open issue —
+     * appropriate here, because the question is not *what* is wrong with each client but whether
+     * trouble clusters on one relay.
+     */
+    issueTypes: string[];
+    /** Consecutive ticks the condition must hold before raising. Default `2`. */
+    consecutiveTicks: number;
+    /** Re-arm time (ms) before raising again for the same server. Default `60_000`. */
+    cooldownMs: number;
+};
+/** The per-server view this detector builds. */
+type TurnServerHealth = {
+    serverUrl: string;
+    /** Distinct clients whose media is relayed through this server. */
+    clients: number;
+    /** Of those, how many currently have at least one open issue. */
+    degradedClients: number;
+    degradedRatio: number;
+    affectedClientIds: string[];
+    /** The open issue types seen on this server's clients, most common first. */
+    issueTypes: string[];
+};
+/**
+ * An **observer-level** detector that groups relayed clients by the TURN server carrying them and
+ * compares the servers against each other.
+ *
+ * Counting TURN usage is not useful on its own; knowing that `turn-eu-1` has 22 of 30 clients in
+ * trouble while `turn-eu-2` has 1 of 34 is. Because the comparison spans calls it lives on
+ * `observer.detectors` and raises `observer-issue` — one actionable alert instead of fifty
+ * per-client ones. Each finding carries the other servers' ratios as context, since "half the
+ * clients here are unhappy" only means something relative to the rest of the fleet.
+ *
+ * Whether a client is in trouble comes from **its own reported issues**, not from thresholds applied
+ * here. The client already decides that far better than a server-side rule could; the value this
+ * adds is the grouping — the dimension no endpoint can see.
+ *
+ * For a relay that has stopped serving entirely, see `TurnServerOutageDetector`: this detector needs
+ * clients *on* the server to ask how many are unhappy, and an outage takes them away.
+ */
+declare class TurnServerHealthDetector implements Detector {
+    private readonly _observer;
+    static readonly NAME = "turn-server-health-detector";
+    readonly name = "turn-server-health-detector";
+    private readonly _config;
+    private readonly _streaks;
+    private readonly _lastRaisedAt;
+    /** The per-server rollup computed on the most recent `update()`. */
+    lastServers: TurnServerHealth[];
+    constructor(_observer: Observer, config?: Partial<TurnServerHealthDetectorConfig>);
+    update(): void;
+    close(): void;
+    private _serverHealth;
+}
+
+declare const TurnServerOutageTypes: {
+    /** One TURN server's relayed population collapsed while the rest of the fleet is fine. */
+    readonly turnServerOutage: "TURN_SERVER_OUTAGE";
+};
+type TurnServerOutageDetectorConfig = {
+    /**
+     * How many clients a server must have been carrying at its peak before its collapse means
+     * anything. Below this, one or two people leaving looks like an outage. Default `5`.
+     */
+    minClientsAtPeak: number;
+    /**
+     * Fraction of the peak population that must be gone or disrupted. Default `0.8` — an outage is
+     * near-total by definition; partial degradation is `TurnServerHealthDetector`'s question.
+     */
+    lossRatioThreshold: number;
+    /**
+     * Window (ms) the peak population is measured over. Long enough to span a real outage's onset,
+     * short enough that yesterday's peak isn't held against today. Default `120_000`.
+     */
+    peakWindowMs: number;
+    /**
+     * Require a healthy **control group** — clients not relayed through this server that are still
+     * connected — before blaming the server. Without this, a call ending, a fleet-wide network
+     * event, or the observer shutting down all look exactly like a TURN outage. Default `true`.
+     */
+    requireControlGroup: boolean;
+    /** Minimum clients elsewhere before the control group is statistically worth anything. Default `5`. */
+    minControlGroupClients: number;
+    /** Fraction of the control group that must still be healthy. Default `0.7`. */
+    controlGroupHealthyRatio: number;
+    /** Consecutive ticks the condition must hold before raising. Default `2`. */
+    consecutiveTicks: number;
+    /**
+     * Re-arm time (ms) per server. Long by default (`300_000`) — an outage is one event, not one
+     * per tick, and a server that stays down would otherwise alert forever.
+     */
+    cooldownMs: number;
+};
+/**
+ * Detects a **TURN server outage** — a relay that has stopped serving — by watching its client
+ * population collapse while the rest of the fleet carries on.
+ *
+ * This is the case its sibling `TurnServerHealthDetector` structurally *cannot* see, and the
+ * distinction is worth being precise about. That detector groups clients by the server relaying them
+ * and asks how many are reporting issues. It needs clients on the server to ask the question. When a
+ * TURN server goes down completely, allocation fails: existing sessions drop, and new clients never
+ * obtain a relay candidate through it at all, so they are never attributed to it. The server's
+ * population goes to zero and the health detector falls silent for the worst possible reason — it
+ * has nobody left to ask. Degradation makes clients unhappy; an outage makes them *disappear*.
+ *
+ * So the signal here is absence, measured against the server's own recent peak:
+ *
+ * - clients gone entirely (their relayed peer connections closed, or they re-negotiated onto a
+ *   different path), plus
+ * - clients still attributed to the server whose ICE or connection state is `disconnected` /
+ *   `failed` / `closed` — the ones mid-collapse, which is what you catch if you look during the
+ *   outage rather than after it.
+ *
+ * ### The control group is the whole design
+ *
+ * Absence is a dangerous signal: a call ending, everyone going home at 6pm, a fleet-wide network
+ * event, and the observer itself shutting down all produce exactly the same collapse. The detector
+ * therefore refuses to blame a server unless clients **not** relayed through it are demonstrably
+ * still connected — `requireControlGroup`, on by default. "Everyone on `turn-eu-1` vanished" is
+ * ambiguous; "everyone on `turn-eu-1` vanished while 200 clients elsewhere are fine" is an outage.
+ *
+ * That comparison is only available to something watching every call at once, which is why this is
+ * an observer-level detector raising `observer-issue` — one alert for the fleet, not one per
+ * abandoned call.
+ *
+ * ### Caveats worth knowing before you tune it
+ *
+ * Clients that fail over cleanly to a second TURN server still count as lost here, which is
+ * correct — the server did stop serving them — but it means a well-configured fleet with automatic
+ * failover reports outages that users never felt. That is the intended behaviour: the failover
+ * worked *and* the server is down are both true, and you want to know the second one.
+ *
+ * A genuinely quiet server (last call of the day ends) is suppressed by the control group, not by
+ * the collapse test. If you run a small deployment where the control group is routinely below
+ * `minControlGroupClients`, this detector will stay quiet — prefer alerting on your TURN server's
+ * own health checks there, since a handful of clients cannot distinguish these cases.
+ */
+declare class TurnServerOutageDetector implements Detector {
+    private readonly _observer;
+    static readonly NAME = "turn-server-outage-detector";
+    readonly name = "turn-server-outage-detector";
+    private readonly _config;
+    /** serverUrl -> recent population observations, used to derive the windowed peak. */
+    private readonly _peaks;
+    private readonly _streaks;
+    private readonly _lastRaisedAt;
+    constructor(_observer: Observer, config?: Partial<TurnServerOutageDetectorConfig>);
+    update(): void;
+    close(): void;
+    /** Distinct clients on a server, split by whether their relayed transport is actually up. */
+    private _populationOf;
+    /** Record this tick's population and return the peak across `peakWindowMs`. */
+    private _recordAndPeak;
+    /**
+     * Everyone *not* relayed through `serverUrl`: clients on other TURN servers plus every client
+     * the observer knows about that isn't relayed at all. The healthy share of that group is what
+     * separates "this server broke" from "everything broke".
+     */
+    private _controlGroup;
+}
+
+declare const UnconsumedTrackTypes: {
+    /** A track is being published to the SFU that nobody is subscribed to — pure wasted uplink. */
+    readonly unconsumedPublishedTrack: "UNCONSUMED_PUBLISHED_TRACK";
+};
+type UnconsumedTrackDetectorConfig = {
+    /** How long a track must stay unconsumed while sending before reporting (ms). Default `30_000`. */
+    minUnconsumedDurationInMs: number;
+    /** Ignore tracks below this bitrate — a trickle isn't worth an alert (bps). Default `50_000`. */
+    minBitrate: number;
+    /** Re-arm time (ms) per track. Default `300_000`. */
+    cooldownMs: number;
+};
+/**
+ * Finds tracks that are **published but consumed by nobody** — uplink and SFU ingress spent on media
+ * that is never forwarded anywhere.
+ *
+ * This is the one detector that reads the resolver's *silence* as the signal: an outbound track with
+ * an empty `remoteInboundTracks` set, still pushing packets. It reads `call.unconsumedOutboundTracks`,
+ * which the resolver maintains as tracks gain and lose subscribers, so a healthy call costs one
+ * `size === 0` check rather than a walk over every published track. The usual causes are a participant
+ * publishing while everyone has them hidden or muted-in-UI, a simulcast layer no viewer's bandwidth
+ * ever selects, or an application that forgot to stop a track after the last subscriber left.
+ *
+ * It is deliberately slow to fire: `minUnconsumedDurationInMs` must elapse with the track still
+ * sending, because a brief gap between publishing and the first subscription is completely normal at
+ * join time.
+ *
+ * ### Careful: this detector is only sound with a resolver
+ *
+ * "No subscribers" and "no resolver configured" produce the identical observation — an empty link
+ * set. Without a `RemoteTrackResolver` this would report *every* published track in the call as
+ * unconsumed, so it checks `call.remoteTrackResolver` at runtime and does nothing without one.
+ */
+declare class UnconsumedTrackDetector implements Detector {
+    private readonly call;
+    static readonly NAME = "unconsumed-track-detector";
+    readonly name = "unconsumed-track-detector";
+    readonly config: UnconsumedTrackDetectorConfig;
+    /** trackId -> when it was first seen sending with no subscribers. */
+    private readonly _unconsumedSince;
+    private readonly _lastRaisedAt;
+    constructor(call: ObservedCall, config?: Partial<UnconsumedTrackDetectorConfig>);
+    update(): void;
+    close(): void;
+}
+
+/**
+ * Detectors that reason **across calls**, created once on the observer.
+ *
+ * Adding one means: give the class a `static readonly NAME`, add its entry here, and add a `case` to
+ * `Observer.addObserverDetector`. This map is what types the call site — the config is checked
+ * against the right detector and an unknown name won't compile.
+ */
+type AvailableObserverScopeDetectorsConfigs = {
+    [SfuCongestionDetector.NAME]: SfuCongestionDetectorConfig;
+    [ObserverConcurrentIssueDetector.NAME]: ObserverConcurrentIssueDetectorConfig;
+    [ClientPopulationIssueDetector.NAME]: ClientPopulationIssueDetectorConfig;
+    [TurnServerHealthDetector.NAME]: TurnServerHealthDetectorConfig;
+    [TurnServerOutageDetector.NAME]: TurnServerOutageDetectorConfig;
+};
+/**
+ * Detectors that reason **within one call**, created for every call the observer opens.
+ *
+ * Note there is no detector in both maps. "Is this meeting in trouble?" and "is our infrastructure in
+ * trouble?" are different questions with different gates and different findings, so they are separate
+ * classes — `CallConcurrentIssueDetector` and `ObserverConcurrentIssueDetector` — rather than one
+ * class branching on what it was handed.
+ */
+type AvailableCallScopeDetectorsConfigs = {
+    [UnconsumedTrackDetector.NAME]: UnconsumedTrackDetectorConfig;
+    [TrackDeliveryMismatchDetector.NAME]: TrackDeliveryMismatchDetectorConfig;
+    [CallConcurrentIssueDetector.NAME]: CallConcurrentIssueDetectorConfig;
+    [IssueFanOutDetector.NAME]: IssueFanOutDetectorConfig;
+    [PublisherFaultCorroborationDetector.NAME]: PublisherFaultCorroborationDetectorConfig;
+};
+type AvailableDetectorsConfigs = AvailableObserverScopeDetectorsConfigs | AvailableCallScopeDetectorsConfigs;
+declare class Detectors {
+    private _detectors;
+    constructor(...detectors: Detector[]);
+    get listOfNames(): string[];
+    get size(): number;
+    add(detector: Detector): void;
+    get(name: string): Detector | undefined;
+    remove(detector: Detector): void;
+    update(): void;
+    clear(): void;
+    private _close;
+}
+
+/**
+ * The set of client issues currently believed to be **open**, plus the fan-out that pushes them to
+ * whoever asked for them.
+ *
+ * ### Push, not poll
+ *
+ * A detector does not scan for the issues it cares about; it registers as an
+ * {@link ActiveIssueTracker} for the types it consumes and is handed them as they open and close.
+ * The cost of a detector is then proportional to the issues it actually receives, not to the number
+ * of participants — a healthy 500-client fleet does no work per tick.
+ *
+ * ```ts
+ * observer.activeIssuesRegistry.addIssueTracker('congestion', detector);
+ * ```
+ *
+ * There is **no wildcard**. A tracker names the types it consumes, and nothing else reaches it. "Feed
+ * me everything and I'll work out what matters" pushes the decision from the application — which
+ * knows its client build and its issue vocabulary — onto a detector that has to guess, and it makes
+ * the cost of a subscription unbounded and invisible. If a detector should watch five issue types,
+ * the caller lists five issue types.
+ *
+ * ### Two levels
+ *
+ * Every call owns a registry constructed with the observer's as its `parent`. An add or delete
+ * touches both, so a call-scoped tracker sees only that call's issues while an observer-scoped one
+ * sees the fleet — without either side iterating the other. The child keeps **its own** storage:
+ * `size` is this scope's count, and {@link clear} (called when the call closes) removes only this
+ * scope's issues from the parent and never touches the parent's tracker registrations.
+ *
+ * ### Only keyed issues arrive here
+ *
+ * An issue without a `key` has no lifecycle — nothing can ever close it — so treating it as "active"
+ * would mean holding a symptom that may have ended long ago. Keyless issues stay one-shot: emitted
+ * as `client-issue`, never registered. `client-monitor-js` >= 4.6.0 sends `key` on everything
+ * stateful.
+ */
+declare class ActiveIssuesRegistry implements ActiveIssueTracker {
+    private readonly parent?;
+    private readonly issues;
+    private readonly typesToTrackers;
+    constructor(parent?: ActiveIssueTracker | undefined);
+    get size(): number;
+    /**
+     * The open issues in this scope, in insertion order.
+     *
+     * Insertion order is age order (`observedAt` is assigned on insert), which is what lets a consumer
+     * stop at the first entry newer than its cutoff instead of scanning the whole set.
+     */
+    values(): IterableIterator<ActiveClientIssue>;
+    [Symbol.iterator](): IterableIterator<ActiveClientIssue>;
+    has(issue: ActiveClientIssue): boolean;
+    add(issue: ActiveClientIssue): this;
+    delete(issue: ActiveClientIssue): boolean;
+    /** Feed `tracker` every issue of `type` as it opens and closes. One call per type; no wildcard. */
+    addIssueTracker(type: string, tracker: ActiveIssueTracker): this;
+    removeIssueTracker(tracker: ActiveIssueTracker): this;
+    /**
+     * Drop every issue in this scope, e.g. because the call closed.
+     *
+     * Deletes through {@link delete} so the parent sheds exactly this scope's issues. Tracker
+     * *registrations* survive: a detector subscribed to the observer's registry must keep receiving
+     * issues after any one call ends.
+     */
+    clear(): void;
+    private _trackIssue;
+    private _untrackIssue;
+    /**
+     * Apply `apply` to every tracker interested in `type`.
+     *
+     * A tracker throwing must not abort the fan-out: the issue has already been added to (or removed
+     * from) this registry, so a partial dispatch would leave the remaining trackers permanently out of
+     * step with it. One broken detector should not desynchronise the others.
+     */
+    private _trackersOf;
+    private _safely;
+}
+
+type ObservedCallSettings<AppData extends Record<string, unknown> = Record<string, unknown>> = {
+    callId: string;
+    appData?: AppData;
+    closeCallIfEmptyForMs?: number;
+    /**
+     * When `true`, the call's `update()` is invoked whenever a client accepts a sample. When `false`, it is not.
+     *
+     * DEFAULT: `true` — the call is updated on every client sample, which is the most common use case.
+     */
+    autoUpdateOnClientUpdate?: boolean;
+};
+type ObservedCallEvents = {
+    update: [];
+    newclient: [ObservedClient];
+    empty: [];
+    'not-empty': [];
+    close: [];
+};
+declare interface ObservedCall {
+    on<U extends keyof ObservedCallEvents>(event: U, listener: (...args: ObservedCallEvents[U]) => void): this;
+    off<U extends keyof ObservedCallEvents>(event: U, listener: (...args: ObservedCallEvents[U]) => void): this;
+    once<U extends keyof ObservedCallEvents>(event: U, listener: (...args: ObservedCallEvents[U]) => void): this;
+    emit<U extends keyof ObservedCallEvents>(event: U, ...args: ObservedCallEvents[U]): boolean;
+}
+declare class ObservedCall<AppData extends Record<string, unknown> = Record<string, unknown>> extends EventEmitter {
+    readonly observer: Observer;
+    readonly activeIssuesRegistry: ActiveIssuesRegistry;
+    scoreCalculator: ScoreCalculator;
+    readonly detectors: Detectors;
+    readonly callId: string;
+    readonly observedClients: Map<string, ObservedClient<Record<string, unknown>>>;
+    readonly clientsUsedTurn: Set<string>;
+    readonly calculatedScore: CalculatedScore;
+    remoteTrackResolver?: RemoteTrackResolver;
+    /**
+     * Published tracks that currently have **no** subscriber linked to them.
+     *
+     * Maintained by the `RemoteTrackResolver` at the exact moments a track gains or loses its last
+     * subscriber — the only moments the answer can change. `UnconsumedTrackDetector` reads this
+     * instead of walking every published track in the call, so in a healthy call (where the set is
+     * empty) it does no work at all.
+     *
+     * Empty when no resolver is configured: without links, "no subscribers" is unknowable.
+     */
+    readonly unconsumedOutboundTracks: Set<ObservedOutboundTrack>;
+    totalAddedClients: number;
+    totalRemovedClients: number;
+    numberOfIssues: number;
+    numberOfPeerConnections: number;
+    numberOfInboundRtpStreams: number;
+    numberOfOutboundRtpStreams: number;
+    numberOfDataChannels: number;
+    maxNumberOfClients: number;
+    deltaNumberOfIssues: number;
+    appData: AppData;
+    closed: boolean;
     startedAt?: number;
     endedAt?: number;
     closedAt?: number;
-    readonly settings: Pick<ObservedCallSettings, 'closeCallIfEmptyForMs'>;
+    readonly settings: Pick<ObservedCallSettings, 'closeCallIfEmptyForMs' | 'autoUpdateOnClientUpdate'>;
     /** Ancestry base shared by all Observer-bus events originating at this call. */
     readonly eventScope: ObservedCallScope;
     private closeTimer?;
-    constructor(settings: ObservedCallSettings<AppData>, observer: Observer);
+    constructor(settings: ObservedCallSettings<AppData>, observer: Observer, activeIssuesRegistry: ActiveIssuesRegistry);
     get numberOfClients(): number;
     get score(): number | undefined;
-    /** Raise a call-level (server-side) issue; surfaced on the Observer bus as `call-issue`. */
-    addIssue(issue: ClientIssue): void;
+    addDetector<K extends keyof AvailableCallScopeDetectorsConfigs>(name: K, config?: Partial<AvailableCallScopeDetectorsConfigs[K]>): this;
+    /**
+     * Raise a call-level (server-side) finding; surfaced on the Observer bus as `call-issue`.
+     *
+     * `payload` takes an **object** — it is delivered to in-process handlers, so there is nothing to
+     * serialise for. Pass a string only if you already have one.
+     */
+    addIssue(issue: ObserverIssue): void;
     close(): void;
     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>): ObservedClient<ClientAppData> | undefined;
@@ -2759,6 +4601,378 @@ declare class MiddlewareProcessor<T> implements Processor<T> {
     process(value: T): void;
 }
 
+/** Raised once if one receiver turns out to be dragging a publisher down for everyone. */
+declare const LOWEST_COMMON_DENOMINATOR_ISSUE = "WORST_RECEIVER_CONTAGION";
+/** The measurements behind a decided verdict — everything needed to check the call yourself. */
+type SimulcastReceiverEvidence = {
+    callId: string;
+    trackId: string;
+    publisherClientId: string;
+    worstReceiverClientId: string;
+    publisherBitrate: number;
+    worstReceiverBitrate: number;
+    medianReceiverBitrate: number;
+    /** How closely the publisher's bitrate followed the **worst** receiver's, `0..1`. */
+    trackingWithWorst: number;
+    /** The same against the **median** receiver — the control. */
+    trackingWithMedian: number;
+};
+type SimulcastReceiverReportPayload = ({
+    /** The publisher held up while one receiver lagged: layers are being chosen per consumer. */
+    verdict: 'layer-decided-per-receiver';
+    evidence: SimulcastReceiverEvidence;
+} | {
+    /** The publisher tracked its worst receiver: everyone is getting the lowest common denominator. */
+    verdict: 'layer-decided-lowest-common-denominator';
+    evidence: SimulcastReceiverEvidence;
+} | {
+    /** Gave up without the conditions needed to judge. **Not a pass.** */
+    verdict: 'inconclusive';
+    reason: string;
+}) & {
+    startedAt: number;
+    /** How many times the check actually ran — i.e. how much the verdict is worth. */
+    checks: number;
+};
+type SimulcastReceiverValidatorConfig = {
+    /** Minimum receivers of a published track before the comparison means anything. */
+    minReceivers: number;
+    /** How long a track's bitrates are correlated over (ms). */
+    windowMs: number;
+    /** Samples needed inside the window before it can be judged. */
+    minSamples: number;
+    /** The worst receiver must be at most this share of the median, or there is nothing to be dragged by. */
+    outlierRatioThreshold: number;
+    /** How closely the publisher must follow the worst receiver to count as dragged. */
+    trackingRatioThreshold: number;
+    /** Clean checks required before concluding per-receiver adaptation. One could be luck. */
+    minChecks: number;
+};
+/**
+ * Answers one question: **does this SFU adapt each receiver on its own, or does one bad receiver
+ * drag the publisher down for everyone?**
+ *
+ * That is what simulcast (or SVC) exists to prevent. With several encodings available the server can
+ * hand the struggling participant a lower layer and leave everyone else alone. Without it — or with
+ * a server that relays RTCP end to end instead of terminating it, so the publisher's bandwidth
+ * estimate collapses to the minimum across all receivers — the only way to serve the slowest
+ * participant is to make the source send less, and everybody gets the lowest common denominator.
+ *
+ * The two causes are worth naming because the *observation* cannot separate them: the publisher's
+ * bitrate tracking its worst receiver looks identical either way. What the check establishes is
+ * whether per-receiver adaptation is happening at all. If the verdict is
+ * `layer-decided-lowest-common-denominator`, look at both — is simulcast/SVC actually enabled with
+ * layers selected per consumer, and is the SFU terminating receiver reports rather than forwarding
+ * them?
+ *
+ * ### The control matters more than the correlation
+ *
+ * "Publisher follows worst receiver" alone proves nothing: when the whole call degrades together,
+ * the publisher follows *everyone*, and that is ordinary adaptation working correctly. The verdict
+ * only goes against the deployment when the publisher tracks the worst receiver **more closely than
+ * it tracks the median** — the worst receiver is leading, not merely coinciding.
+ *
+ * Likewise, a window with no outlier in it is not evidence of health, it is an untested SFU: if
+ * nobody is struggling, there is nothing for per-receiver adaptation to do. Those windows are
+ * skipped and never counted in `checks`.
+ *
+ * ### Why a validator, not a detector
+ *
+ * This is a property of the SFU build and configuration, not of this moment: a server doing
+ * per-receiver layer selection at 09:00 still is at 17:00. Re-deriving it every tick cannot produce
+ * new information — it would only keep a sliding window alive per published track for the life of
+ * every call. So it decides once, reports, and releases that state.
+ *
+ * ```ts
+ * observer.on('validation-ready', ({ validator, report }) => {
+ *   if (validator !== 'simulcast-receivers' || !report.ready) return;
+ *   console.log(report.verdict);   // 'layer-decided-per-receiver' | ... | 'inconclusive'
+ * });
+ *
+ * observer.addValidator('simulcast-receivers');
+ * onDeploy(() => observer.addValidator('simulcast-receivers'));   // check again
+ * ```
+ *
+ * ### `inconclusive` is not a pass
+ *
+ * The check only runs when a publisher has several receivers and one of them is far behind the
+ * median; plenty of healthy deployments never present that. Concluding from the absence of a failure
+ * would verify nothing, so `checks` counts the times the check genuinely ran, and a validator that
+ * is cancelled (or whose observer closes) finishes `inconclusive` with the reason why.
+ */
+declare class SimulcastReceiverValidator implements Validator<SimulcastReceiverReportPayload> {
+    private readonly _observer;
+    readonly onDone: (report: ValidationReport<SimulcastReceiverReportPayload>) => void;
+    static readonly NAME: "simulcast-receivers";
+    readonly name: "simulcast-receivers";
+    readonly startedAt: number;
+    report: ValidationReport<SimulcastReceiverReportPayload>;
+    private readonly _config;
+    private readonly _windows;
+    private _checks;
+    private _done;
+    constructor(_observer: Observer, onDone: (report: ValidationReport<SimulcastReceiverReportPayload>) => void, config?: Partial<SimulcastReceiverValidatorConfig>);
+    /** How many times the comparison actually ran. `0` means nothing was established. */
+    get checks(): number;
+    /** Give up without a verdict, freeing anything waiting on this validator. */
+    cancel(reason?: string): void;
+    update(): void;
+    /** Returns `true` when a verdict was reached and the caller should stop iterating. */
+    private _inspect;
+    /**
+     * Settle on a verdict, exactly once.
+     *
+     * The guard is not paranoia: `onDone` removes this validator from the observer, and a second call
+     * would emit a second `validation-ready` for a validator that is no longer registered — e.g. when
+     * `observer.close()` cancels a validator that decided earlier in the same tick.
+     */
+    private _finish;
+    private _windowOf;
+}
+
+/** Raised once if the resolver turns out never to link anything. */
+declare const UNRESOLVED_TRACK_LINKS_ISSUE = "REMOTE_TRACK_LINKS_UNRESOLVED";
+/** What the check actually saw, whichever way it went. */
+type RemoteTrackLinkEvidence = {
+    /** Calls that presented the conditions for linking: a resolver, ≥2 clients, and inbound tracks. */
+    eligibleCalls: number;
+    /** Inbound tracks seen across those calls. */
+    inboundTracks: number;
+    /** Of those, how many were linked to the outbound track that published them. */
+    linkedInboundTracks: number;
+    /** `linkedInboundTracks / inboundTracks`. */
+    linkedRatio: number;
+    /** A call that presented the conditions, for the reader to go and look at. */
+    exampleCallId?: string;
+};
+type RemoteTrackResolverReportPayload = ({
+    /** The resolver is linking subscribers to publishers. The detectors that need links will work. */
+    verdict: 'links-resolved';
+    evidence: RemoteTrackLinkEvidence;
+} | {
+    /** Every condition for linking was met, repeatedly, and nothing was ever linked. */
+    verdict: 'no-links-resolved';
+    evidence: RemoteTrackLinkEvidence;
+} | {
+    /** Never saw a call that could have been linked. **Not a pass.** */
+    verdict: 'inconclusive';
+    reason: string;
+}) & {
+    startedAt: number;
+    /** How many times the check genuinely ran — i.e. how much the verdict is worth. */
+    checks: number;
+};
+type RemoteTrackResolverValidatorConfig = {
+    /** Participants a call needs before it can plausibly have publisher↔subscriber links. Default `2`. */
+    minClients: number;
+    /** Inbound tracks that must be present in a call before it counts as a check. Default `2`. */
+    minInboundTracks: number;
+    /** Share of inbound tracks that must be linked to conclude the resolver works. Default `0.5`. */
+    linkedRatioThreshold: number;
+    /** Eligible calls to observe before concluding either way. One could be a race. Default `3`. */
+    minChecks: number;
+};
+/**
+ * Answers one question: **is the `RemoteTrackResolver` actually linking anything?**
+ *
+ * ### Why this is worth a validator
+ *
+ * Four things in this library are built on publisher↔subscriber links —
+ * `IssueFanOutDetector`, `TrackDeliveryMismatchDetector`, `UnconsumedTrackDetector` and
+ * `SimulcastReceiverValidator`. Every one of them checks `call.remoteTrackResolver` and, finding no
+ * links, correctly does nothing rather than guessing.
+ *
+ * That is the right behaviour and it produces a nasty failure mode: a resolver wired to the wrong id
+ * field, or a mediasoup `producerId` the application never attaches, leaves all four permanently
+ * silent — and **silence is what a healthy deployment looks like too**. You would conclude your
+ * calls were clean when in fact nothing was ever examined. This check exists to make that specific
+ * mistake loud.
+ *
+ * ### `inconclusive` is not a pass
+ *
+ * A verdict is only reached from calls that *could* have been linked: a resolver configured, at
+ * least `minClients` participants, and at least `minInboundTracks` inbound tracks present. A
+ * one-to-one deployment, a lobby full of audio-only listeners, or a quiet period never presents
+ * those conditions — and concluding "resolver works" from calls that had nothing to resolve would be
+ * the very mistake this validator is here to catch. `checks` counts the eligible calls actually
+ * seen; a validator cancelled before reaching `minChecks` finishes `inconclusive` and says so.
+ *
+ * ```ts
+ * observer.on('validation-ready', ({ validator, report }) => {
+ *   if (validator !== 'remote-track-resolver' || !report.ready) return;
+ *   if (report.verdict === 'no-links-resolved') alert('resolver misconfigured — 4 detectors are inert');
+ * });
+ *
+ * observer.addValidator('remote-track-resolver');
+ * ```
+ *
+ * Run it once at start-up, and again after changing the resolver or the SFU's id scheme. Like every
+ * validator it is one-shot: the answer is a property of the wiring, not of this moment.
+ */
+declare class RemoteTrackResolverValidator implements Validator<RemoteTrackResolverReportPayload> {
+    private readonly _observer;
+    readonly onDone: (report: ValidationReport<RemoteTrackResolverReportPayload>) => void;
+    static readonly NAME: "remote-track-resolver";
+    readonly name: "remote-track-resolver";
+    readonly startedAt: number;
+    report: ValidationReport<RemoteTrackResolverReportPayload>;
+    private readonly _config;
+    /** Accumulated across every eligible call seen, so one small call cannot decide alone. */
+    private _eligibleCalls;
+    private _inboundTracks;
+    private _linkedInboundTracks;
+    private _exampleCallId?;
+    private _checks;
+    private _done;
+    constructor(_observer: Observer, onDone: (report: ValidationReport<RemoteTrackResolverReportPayload>) => void, config?: Partial<RemoteTrackResolverValidatorConfig>);
+    /** How many eligible calls were actually examined. `0` means nothing was established. */
+    get checks(): number;
+    cancel(reason?: string): void;
+    update(): void;
+    private _evidence;
+    private _finish;
+}
+
+/** Raised once if the deployment is not actually delivering the codec it thinks it is. */
+declare const CODEC_MISMATCH_ISSUE = "CODEC_INCONSISTENCY";
+/** What the check saw across a call's participants. */
+type CodecEvidence = {
+    callId: string;
+    kind: 'audio' | 'video';
+    /** Every mime type in use in that call, most common first — e.g. `[ 'video/VP8', 'video/H264' ]`. */
+    mimeTypes: string[];
+    /** How many clients used each, in the same order as {@link mimeTypes}. */
+    clientsPerMimeType: number[];
+    /** Clients considered — those that reported at least one codec of this kind. */
+    clients: number;
+    /** The codec the check was told to expect, when it was given one. */
+    expected?: string;
+};
+type CodecConsistencyReportPayload = ({
+    /** One codec per media kind, and it is the expected one if an expectation was given. */
+    verdict: 'codec-consistent';
+    evidence: CodecEvidence[];
+} | {
+    /** Participants of one call are split across different codecs. */
+    verdict: 'codec-split';
+    evidence: CodecEvidence[];
+} | {
+    /** Consistent, but not what the deployment believes it negotiated. */
+    verdict: 'unexpected-codec';
+    evidence: CodecEvidence[];
+} | {
+    /** Never saw a call with enough participants reporting codecs. **Not a pass.** */
+    verdict: 'inconclusive';
+    reason: string;
+}) & {
+    startedAt: number;
+    checks: number;
+};
+type CodecConsistencyValidatorConfig = {
+    /**
+     * The mime type you believe you are delivering, per kind — e.g.
+     * `{ video: 'video/VP8', audio: 'audio/opus' }`.
+     *
+     * Optional. Without it the check still reports a *split* (participants disagreeing with each
+     * other), which needs no expectation to be a fact. With it, the check can additionally catch the
+     * case where everyone agrees on the wrong thing — a silent fallback that nothing else notices.
+     */
+    expected?: Partial<Record<'audio' | 'video', string>>;
+    /** Which kinds to inspect. Default both. */
+    kinds: ('audio' | 'video')[];
+    /** Participants a call needs before disagreement is meaningful. Default `3`. */
+    minClients: number;
+    /** Calls to inspect before concluding. Default `3`. */
+    minChecks: number;
+};
+/**
+ * Answers: **is every participant of a call actually using the same codec — and is it the one you
+ * think you negotiated?**
+ *
+ * ### Why the server has to answer this
+ *
+ * A client knows only its own codec. It cannot tell whether it is the odd one out, and an SFU that
+ * forwards without transcoding cannot serve a call where participants disagree — so a split is a
+ * real fault with a very confusing symptom: some pairs of participants see each other and some do
+ * not, with no error anywhere. Only something holding every participant of a call at once can see
+ * the split at all.
+ *
+ * The second half is the quieter failure. A deployment configured for VP9 or AV1 will fall back to
+ * VP8 whenever one endpoint cannot negotiate the preferred codec, and nothing reports that — the
+ * call works, the bitrate is higher than it should be, and the team believes it shipped AV1 months
+ * ago. Give the check an `expected` mime type and it will say so.
+ *
+ * ### Why a validator and not a detector
+ *
+ * The answer is a property of the deployment — SDP munging, codec preferences, the SFU build — not
+ * of this moment. A deployment that negotiates VP8 at 09:00 negotiates VP8 at 17:00. Re-deriving it
+ * every tick would walk every codec of every peer connection of every call, forever, to re-learn a
+ * constant. So it decides once and stops.
+ *
+ * Start it again after a deploy, or after changing codec preferences:
+ *
+ * ```ts
+ * observer.addValidator('codec-consistency', {
+ *   expected: { video: 'video/VP9', audio: 'audio/opus' },
+ * });
+ *
+ * observer.on('validation-ready', ({ validator, report }) => {
+ *   if (validator !== 'codec-consistency' || !report.ready) return;
+ *   // 'codec-consistent' | 'codec-split' | 'unexpected-codec' | 'inconclusive'
+ * });
+ * ```
+ *
+ * ### `inconclusive` is not a pass
+ *
+ * Only calls with at least `minClients` participants *reporting codecs of that kind* count as a
+ * check. An audio-only deployment will never say anything about video, and concluding "video codecs
+ * are consistent" from calls that carried no video would verify nothing.
+ *
+ * ### Comparison is by mime type only
+ *
+ * `sdpFmtpLine` carries profile and level — `profile-level-id` for H.264, `profile-id` for VP9 — and
+ * two clients on the same mime type with different profiles are not truly interchangeable. That is
+ * deliberately out of scope: fmtp differences are common, usually benign, and would make this check
+ * noisy enough to ignore. It answers the coarse question, which is the one that is actually wrong in
+ * practice.
+ */
+declare class CodecConsistencyValidator implements Validator<CodecConsistencyReportPayload> {
+    private readonly _observer;
+    readonly onDone: (report: ValidationReport<CodecConsistencyReportPayload>) => void;
+    static readonly NAME: "codec-consistency";
+    readonly name: "codec-consistency";
+    readonly startedAt: number;
+    report: ValidationReport<CodecConsistencyReportPayload>;
+    private readonly _config;
+    private readonly _inspectedCallIds;
+    private _evidence;
+    private _checks;
+    private _done;
+    constructor(_observer: Observer, onDone: (report: ValidationReport<CodecConsistencyReportPayload>) => void, config?: Partial<CodecConsistencyValidatorConfig>);
+    get checks(): number;
+    cancel(reason?: string): void;
+    update(): void;
+    /** One evidence entry per configured kind that the call actually carried. */
+    private _tallyOf;
+    private _finish;
+}
+
+/**
+ * The validators `observer.addValidator(name, config)` knows how to build, and the config each takes.
+ *
+ * Adding one means: write the class with a `static readonly NAME`, add its entry here, and add a
+ * `case` to `addValidator`. The map is what gives the call site its types —
+ * `addValidator('simulcast-receivers', { … })` type-checks the config against the right validator,
+ * and an unknown name won't compile.
+ */
+type AvailableValidatorConfigs = {
+    [SimulcastReceiverValidator.NAME]: SimulcastReceiverValidatorConfig;
+    [RemoteTrackResolverValidator.NAME]: RemoteTrackResolverValidatorConfig;
+    [CodecConsistencyValidator.NAME]: CodecConsistencyValidatorConfig;
+};
+/** A validator name that can be started. */
+type ValidatorName = keyof AvailableValidatorConfigs;
+
 type SampleRejectedReason = 'observer-closed' | 'missing-callId' | 'missing-clientId';
 
 /**
@@ -2779,9 +4993,6 @@ type AcceptMiddlewarePayload = {
  * `next(payload)` to continue the chain. Not calling `next` **drops** the sample.
  */
 type AcceptMiddleware = Middleware<AcceptMiddlewarePayload>;
-type ObserverUpdateConfig = {
-    updatePolicy?: 'update-on-any-call-updated' | 'update-when-all-call-updated' | 'none';
-};
 /** Produces the initial `appData` for a call created without an explicit `appData`. */
 type CallAppDataFactory = (params: {
     callId: string;
@@ -2792,11 +5003,30 @@ type ClientAppDataFactory = (params: {
     clientId: string;
     observedCall: ObservedCall;
 }) => Record<string, unknown>;
-type ObserverConfig<AppData extends Record<string, unknown> = Record<string, unknown>> = ObserverUpdateConfig & {
-    defaultCallUpdatePolicy?: ObservedCallSettings['updatePolicy'];
+type ObserverConfig<AppData extends Record<string, unknown> = Record<string, unknown>> = {
     appData?: AppData;
     closeClientIfIdleForMs?: number;
     closeCallIfEmptyForMs?: number;
+    /**
+     * When `true` (the default), every call update triggers an observer-wide `update()` pass.
+     *
+     * There is deliberately no timer and no separate policy object: a call is updated when any of its
+     * clients is, and the observer is updated when any of its calls is — so the observer is updated
+     * exactly when any client anywhere is. Set to `false` only if you drive `observer.update()`
+     * yourself, and note that observer-scoped detectors and validators run *nowhere else*.
+     */
+    autoUpdateOnCallUpdate?: boolean;
+    inboundTrackDegradationThresholds?: {
+        deltaFreezeCount: number;
+        framesDroppedRatio: number;
+        jitterBufferDelayInMs: number;
+        concealmentRatio: number;
+        rttInMs: number;
+    };
+    outboundTrackDegradationThresholds?: {
+        fractionLost: number;
+        rttInMs: number;
+    };
     /**
      * Optional factory invoked when a call is created without an explicit `appData`
      * (e.g. lazily by `accept()`), so apps can enrich appData without pre-creating the
@@ -2826,13 +5056,12 @@ declare interface Observer {
     emit<U extends keyof ObserverEvents>(event: U, ...args: ObserverEvents[U]): boolean;
 }
 declare class Observer<AppData extends Record<string, unknown> = Record<string, unknown>> extends EventEmitter {
-    readonly config: ObserverConfig<AppData>;
     readonly observedTURN: ObservedTURN;
     readonly observedCalls: Map<string, ObservedCall<Record<string, unknown>>>;
     readonly observedMediasoupRouters: Map<string, ObservedMediasoupRouter<Record<string, unknown>>>;
-    updater?: Updater;
     /** Ancestry base shared by all Observer-bus events originating at the observer. */
     readonly eventScope: ObserverEventBase;
+    readonly config: ObserverConfig<AppData>;
     closed: boolean;
     totalAddedCall: number;
     totalRemovedCall: number;
@@ -2844,9 +5073,69 @@ declare class Observer<AppData extends Record<string, unknown> = Record<string,
     numberOfPeerConnections: number;
     /** Global, pre-dispatch middleware chain run on every accepted sample. */
     readonly acceptMiddlewares: MiddlewareProcessor<AcceptMiddlewarePayload>;
-    constructor(config?: ObserverConfig<AppData>);
+    /**
+     * Fleet-wide index of every open client issue, maintained incrementally as issues open and close.
+     * Each call's index propagates into this one, so cross-call queries cost O(matching issues) rather
+     * than a walk over every call and client. This is what observer-scoped detectors read.
+     */
+    readonly activeIssuesRegistry: ActiveIssuesRegistry;
+    /**
+     * Validators currently running. Each removes itself when it finishes, so this is normally empty —
+     * a validator is a one-shot check, not a permanent fixture. Start one with {@link addValidator}.
+     */
+    readonly validators: Set<RunningValidator>;
+    /**
+     * Observer-scoped detector registry, run on every `observer.update()` — the place for findings
+     * that span **calls**, e.g. "many calls on the same SFU degraded at once". Detectors raise
+     * findings with `observer.addIssue(...)`, surfaced on the bus as `observer-issue`.
+     * (For findings within a single call use `observedCall.detectors`.)
+     *
+     * Starts **empty**. Populate it with {@link addObserverDetector}, or `detectors.add(...)` for an
+     * instance you built yourself.
+     */
+    readonly detectors: Detectors;
+    /**
+     * The call-scoped detectors to build on **every** call this observer creates, in registration
+     * order. Written by {@link addCallDetector}; read by `createObservedCall`.
+     *
+     * Nothing is created implicitly. There is no detector configuration in `ObserverConfig` and no
+     * default set, because a detector that nobody asked for is a detector nobody will act on: it costs
+     * time on every tick and raises findings into a handler that was not written to expect them. An
+     * application says what it wants to watch, or it watches nothing.
+     *
+     * ```ts
+     * observer.addCallDetector('call-concurrent-issue-detector', {
+     *   issueTypes: [ 'congestion', 'ice-disconnected' ],
+     * });
+     * ```
+     */
+    readonly callDetectorConfigs: Map<keyof AvailableCallScopeDetectorsConfigs, Partial<UnconsumedTrackDetectorConfig | TrackDeliveryMismatchDetectorConfig | CallConcurrentIssueDetectorConfig | IssueFanOutDetectorConfig | PublisherFaultCorroborationDetectorConfig>>;
+    constructor(config?: Partial<ObserverConfig<AppData>>);
     get numberOfCalls(): number;
     get appData(): AppData | undefined;
+    addObserverDetector<K extends keyof AvailableObserverScopeDetectorsConfigs>(name: K, config?: Partial<AvailableObserverScopeDetectorsConfigs[K]>): this;
+    /**
+     * Enable a call-scoped detector for calls created **from now on**.
+     *
+     * This edits the config, not the live calls: calls already open keep the detector set they were
+     * built with. To add one to an existing call, use `observedCall.addDetector(...)` directly.
+     */
+    addCallDetector<K extends keyof AvailableCallScopeDetectorsConfigs>(name: K, config?: Partial<AvailableCallScopeDetectorsConfigs[K]>): this;
+    /** Stop building `name` on calls created from now on. Calls already open are untouched. */
+    removeCallDetector(name: keyof AvailableCallScopeDetectorsConfigs): this;
+    /**
+     * Start a structural check. It runs on each `observer.update()` until it can decide, reports once
+     * on `validation-ready`, and removes itself.
+     *
+     * ```ts
+     * observer.validate('simulcast-receiver-validator', { minChecks: 5 });
+     * ```
+     *
+     * Config keys are optional and merged over that validator's defaults. Call it again — after a
+     * deploy, say — to check again; there is no revalidation timer, because a deploy rather than
+     * elapsed time is what makes a structural verdict stale.
+     */
+    addValidator<K extends keyof AvailableValidatorConfigs>(name: K, config?: Partial<AvailableValidatorConfigs[K]>): this;
     getObservedCall<T extends Record<string, unknown> = Record<string, unknown>>(callId: string): ObservedCall<T> | undefined;
     createObservedCall<T extends Record<string, unknown> = Record<string, unknown>>(settings: ObservedCallSettings<T>): ObservedCall<T> | undefined;
     getOrCreateObservedCall<T extends Record<string, unknown> = Record<string, unknown>>(settings: ObservedCallSettings<T>): ObservedCall<T> | undefined;
@@ -2856,6 +5145,13 @@ declare class Observer<AppData extends Record<string, unknown> = Record<string,
     close(): void;
     accept(sample: ClientSample, context?: AcceptContext): void;
     update(): void;
+    /**
+     * Raise an observer-scoped (cross-call / SFU-wide) finding. Emitted on the bus as
+     * `observer-issue`. Intended for `observer.detectors`, but the application may call it too.
+     *
+     * `payload` takes an **object**; see `ObserverIssue`.
+     */
+    addIssue(issue: ObserverIssue): void;
     /** Emit an Observer-bus event. */
     private _notify;
 }
@@ -2894,6 +5190,367 @@ declare enum ClientEventTypes {
     DATA_CONSUMER_CLOSED = "DATA_CONSUMER_CLOSED"
 }
 
+/** Thresholds deciding when a client counts as degraded on the receiving / sending side. */
+type ClientHealthThresholds = {
+    /** Inbound loss fraction across the client's received streams (0..1). */
+    inboundFractionLost: number;
+    /** Loss fraction reported back about the client's sent streams via RTCP (0..1). */
+    outboundFractionLost: number;
+    /** Round-trip time (ms). */
+    rttInMs: number;
+    /** Freezes observed across the client's inbound video in the tick. */
+    freezeCount: number;
+    /** Concealment fraction across the client's inbound audio (0..1). */
+    concealmentRatio: number;
+};
+declare const defaultClientHealthThresholds: ClientHealthThresholds;
+/** The per-client health view, split by direction. */
+type ClientHealth = {
+    observedClient: ObservedClient;
+    clientId: string;
+    /** Receiving (download) side is impaired. */
+    inboundDegraded: boolean;
+    /** Sending (upload) side is impaired. */
+    outboundDegraded: boolean;
+    /** `inboundDegraded || outboundDegraded`. */
+    degraded: boolean;
+    reasons: string[];
+    inboundFractionLost?: number;
+    outboundFractionLost?: number;
+    rttInMs?: number;
+    deltaFreezeCount: number;
+    concealmentRatio?: number;
+    /** Quality-limitation reasons seen on this client's outbound video ('cpu' | 'bandwidth' | …). */
+    qualityLimitationReasons: string[];
+    usingTURN: boolean;
+    usingTCP: boolean;
+};
+/** Call-level rollup of the per-client health, using percentiles rather than means. */
+type CallHealth = {
+    callId: string;
+    clients: ClientHealth[];
+    numberOfClients: number;
+    numberOfDegradedClients: number;
+    numberOfInboundDegradedClients: number;
+    numberOfOutboundDegradedClients: number;
+    /** degradedClients / clients (0..1). */
+    degradedRatio: number;
+    inboundDegradedRatio: number;
+    outboundDegradedRatio: number;
+    rttInMs?: StatsSummary;
+    inboundFractionLost?: StatsSummary;
+    concealmentRatio?: StatsSummary;
+    /** How many clients reported each quality-limitation reason on their outbound video. */
+    qualityLimitation: {
+        cpu: number;
+        bandwidth: number;
+        other: number;
+    };
+    freezes: {
+        affectedClients: number;
+        total: number;
+    };
+};
+/**
+ * Aggregates a call along the **client** axis (as `TrackDistributionAggregator` does along the
+ * publisher→subscriber axis): per-client health split into sending vs receiving, plus percentile
+ * rollups and "affected ratio" counts for the whole call.
+ *
+ * Build once per call and call `aggregate()` on each `call.update()`.
+ */
+declare class CallHealthAggregator {
+    private readonly _call;
+    readonly thresholds: ClientHealthThresholds;
+    constructor(_call: ObservedCall, thresholds?: ClientHealthThresholds);
+    aggregate(): CallHealth;
+    private _clientHealth;
+}
+
+/**
+ * Turning a correlation into a **conclusion**.
+ *
+ * Every detector in this library ultimately reports the same shape of observation: *N clients have
+ * issue X open at once, and here is what they have in common*. That is useful but not yet
+ * actionable — someone still has to know that congestion spread across unrelated calls means the
+ * server, while CPU limitation spread across unrelated calls means a bad client release. This module
+ * holds that interpretation step so it is stated once, consistently, instead of being re-derived by
+ * whoever reads the alert at 3am.
+ *
+ * ### Two functions, because there are two questions
+ *
+ * A detector already knows its scope — it was constructed with an `ObservedCall` or with the
+ * `Observer`. Handing that scope back to a single generic function meant every caller supplied
+ * fields the other scope needed and its own scope ignored: a call-scoped detector passing
+ * `affectedCalls: 1, totalCalls: 1` forever, an observer-scoped one passing a participant ratio that
+ * was deliberately never read. Placeholders like that are a standing invitation to read them as if
+ * they meant something.
+ *
+ * So there are two entry points, each taking only the facts its scope actually has:
+ *
+ * - {@link concludeCallIssue} — within one call. The axis is *how much of the meeting*, and whether
+ *   the affected clients all subscribe to one published track.
+ * - {@link concludeObserverIssue} — across calls. The axis is *how many independent calls*, which is
+ *   the only thing that separates "one bad room" from "our infrastructure".
+ *
+ * Neither the issue family nor the spread concludes anything alone: congestion in one call is a
+ * meeting problem, congestion in six calls is an infrastructure problem, and the issue type is
+ * identical in both.
+ */
+/** Where the fault most likely sits, given who is affected. */
+type IssueFaultDomain = 
+/** Independent calls affected at once — they share only the servers and the network. */
+'infrastructure'
+/** One call, broadly affected — something that call shares (its SFU worker, room, or host). */
+ | 'call'
+/** The subscribers of one published track — the publisher's path or the forwarding of it. */
+ | 'published-track'
+/** A single endpoint — its own device or last mile. */
+ | 'endpoint'
+/** Independent calls affected, but by something endpoints own — a client build, not a server. */
+ | 'client-population'
+/** Not enough signal to attribute. */
+ | 'unknown';
+/** A stated verdict, attached to the raised issue payload. */
+type IssueConclusion = {
+    /** Where to look. */
+    faultDomain: IssueFaultDomain;
+    /** One line, written to be readable in an alert without opening a dashboard. */
+    summary: string;
+    /** What to check first. Omitted when the issue family is unknown to this module. */
+    recommendation?: string;
+    /**
+     * How much the spread alone justifies the verdict, `0..1`. Not a probability — a coarse ranking
+     * so alerting can threshold on it. More independent calls, or a tighter onset, means higher.
+     */
+    confidence: number;
+};
+/** The facts a **call-scoped** conclusion is drawn from. */
+type CallIssueSpread = {
+    issueType: string;
+    /** Distinct clients of this call with the issue open. */
+    affectedClients: number;
+    /** Participants in the call — the denominator. */
+    totalClients: number;
+    /** True when the onsets clustered — a shared trigger rather than drift. */
+    onsetBurst: boolean;
+    /**
+     * Set when the affected clients are the subscriber set of **one published track**.
+     *
+     * The strongest call-scoped statement available: those clients share a publisher and nothing
+     * else, so the receivers are exonerated and the source's path is implicated.
+     */
+    publishedTrackId?: string;
+};
+/** The facts an **observer-scoped** conclusion is drawn from. */
+type ObserverIssueSpread = {
+    issueType: string;
+    /** Distinct clients across the fleet with the issue open. */
+    affectedClients: number;
+    /** Clients in the fleet. Reported for context; it does not gate anything at this scope. */
+    totalClients: number;
+    /** Distinct calls containing at least one affected client. The dimension that matters here. */
+    affectedCalls: number;
+    /** Calls in flight. */
+    totalCalls: number;
+    /** True when the onsets clustered. */
+    onsetBurst: boolean;
+};
+/**
+ * Draw the conclusion for a group of clients **within one call**.
+ *
+ * Ordered most-to-least specific: a track-scoped group is a stronger statement than a call-wide one,
+ * and a single affected endpoint is not a statement about the call at all.
+ */
+declare function concludeCallIssue(spread: CallIssueSpread): IssueConclusion;
+/**
+ * Draw the conclusion for a group of clients spanning **several calls**.
+ *
+ * One affected call is not an observer-scoped finding — it has an obvious local explanation and the
+ * call-scoped detector has already reported it — so that case returns `call` and says so rather than
+ * dressing it up as a fleet event.
+ *
+ * Which domain breadth implicates depends on the family, and this is the whole reason the module
+ * exists: `congestion` across unrelated calls points at the servers, `cpulimitation` across unrelated
+ * calls points at what those *endpoints* share — a client release, a browser version, shared
+ * virtualised hardware — and pointing an SFU team at the second one wastes a night.
+ */
+declare function concludeObserverIssue(spread: ObserverIssueSpread): IssueConclusion;
+
+/** An entry retained by {@link SlidingWindow}. */
+type SlidingWindowEntry<T> = {
+    timestamp: number;
+    value: T;
+};
+/**
+ * A time-bounded buffer used by detectors that reason over a window ("N of M clients degraded within
+ * 10 s"). Entries older than `windowMs` are evicted on write and on read.
+ *
+ * ### Ordering is enforced, not assumed
+ *
+ * Eviction walks from the front and stops at the first entry still inside the window, which is only
+ * correct if entries are ordered by timestamp. Callers mostly pass `Date.now()` and are ordered by
+ * construction — but not always: a timestamp taken from a client sample, or two calls inside the
+ * same millisecond, can arrive out of order, and one such entry would park itself at the head and
+ * stop eviction *permanently*, so the window would grow without bound and keep reporting symptoms
+ * from hours ago.
+ *
+ * Rather than trust the caller, {@link add} inserts in timestamp order. Appending (the overwhelmingly
+ * common case) stays O(1); an out-of-order insert costs a short backward scan, because such entries
+ * are near the tail in practice.
+ *
+ * ### The window advances on the newest observation
+ *
+ * Eviction is relative to the largest timestamp seen, not the one just passed. A caller that reads
+ * with a `now` behind the newest entry (a replayed sample, a clock that stepped back) would
+ * otherwise un-evict nothing and, worse, a caller passing an old `now` to {@link add} would evict
+ * everything newer.
+ */
+declare class SlidingWindow<T> {
+    readonly windowMs: number;
+    /** Optional hard cap on retained entries, to bound memory on very chatty inputs. */
+    readonly maxEntries: number;
+    private _entries;
+    private _latest;
+    constructor(windowMs: number, 
+    /** Optional hard cap on retained entries, to bound memory on very chatty inputs. */
+    maxEntries?: number);
+    /** Add an entry (defaults to `Date.now()`), then evict anything outside the window. */
+    add(value: T, timestamp?: number): void;
+    /**
+     * The entries still inside the window, oldest first.
+     *
+     * A **copy** — callers routinely map/sort what they get back, and handing out the live array let
+     * them mutate the window from the outside.
+     */
+    entries(now?: number): SlidingWindowEntry<T>[];
+    /** The values still inside the window, oldest first. */
+    values(now?: number): T[];
+    /**
+     * How many entries are inside the window as of `now`.
+     *
+     * Prefer this to `values(now).length`: counting through {@link values} allocates an array of every
+     * entry only to read its length, which on a hot path is the whole cost of the call.
+     */
+    count(now?: number): number;
+    /** Retained entries, without evicting first. See {@link count} for the windowed answer. */
+    get size(): number;
+    clear(): void;
+    private _evict;
+}
+
+type TrendTesterConfig = {
+    /**
+     * How many of the most recent values to keep. The one knob that controls how far back "trend"
+     * looks, for both tests — there is deliberately no separate window per test.
+     */
+    size?: number;
+    /** Page-Hinkley's drift tolerance and detection threshold — see {@link pageHinkley}. */
+    pageHinkleyDelta?: number;
+    pageHinkleyLambda?: number;
+    /** Mann-Kendall's significance level — see {@link mannKendallVerdict}. */
+    mannKendallAlpha?: number;
+};
+/**
+ * Streaming home for `stats.ts`'s two trend tests: feed it one value at a time via {@link add}
+ * instead of re-running the batch functions over an array you manage yourself.
+ *
+ * ### The two tests answer different questions
+ *
+ * Take a client's RTT, sampled every couple of seconds. Two things can go wrong with it, and only
+ * one of them looks like a spike:
+ *
+ * - **Mann-Kendall** asks *"is this drifting?"* — a monotonic trend, regardless of shape or scale.
+ *   `40, 45, 52, 61, 70, 84 ms` is a rising path with no single dramatic step; every jump is small
+ *   and plausible on its own. Mann-Kendall counts how many later samples exceed earlier ones and
+ *   reports whether that lopsidedness could plausibly be chance. It is rank-based, so one absurd
+ *   reading (a 4000 ms outlier from a stalled event loop) moves it by exactly one pair, not by the
+ *   4000.
+ * - **Page-Hinkley** asks *"did it change, and when?"* — a step. `40, 42, 39, 41, 180, 176, 182 ms`
+ *   is not a trend at all; it is one level followed by a different level, which is what a route
+ *   change or a TURN failover looks like. It accumulates the deviation from the running mean and
+ *   fires when the cumulative excess passes `lambda`.
+ *
+ * Neither subsumes the other, which is why both live here on one window. A slow climb toward
+ * unusability shows up in Mann-Kendall and never trips Page-Hinkley; a hard failover trips
+ * Page-Hinkley immediately while Mann-Kendall may read `no-trend`, because after the step the series
+ * is flat again. `tests/trendTester.spec.ts` builds both RTT series and shows exactly this.
+ *
+ * ```ts
+ * const rtt = new TrendTester({ size: 30, mannKendallAlpha: 0.05, pageHinkleyLambda: 50 });
+ *
+ * peerConnection.on('update', () => {
+ *   if (peerConnection.currentRttInMs === undefined) return;   // no measurement is not a measurement
+ *   rtt.add(peerConnection.currentRttInMs);
+ *
+ *   if (rtt.mannKendall().trend === 'increasing') warn('RTT is drifting up');
+ *   if (rtt.pageHinkley()?.changeDetected) {
+ *     warn('RTT stepped');
+ *     rtt.clear();   // the old level is no longer the baseline — judge the new one on its own
+ *   }
+ * });
+ * ```
+ *
+ * ### Both read the same window
+ *
+ * `size` is the one knob controlling how far back either test looks. They are kept incremental
+ * differently, because they don't tolerate an evicted point the same way:
+ *
+ * - **Mann-Kendall**'s statistic is a sum over *pairs*, so evicting the oldest value only touches
+ *   the pairs it was part of — one pass over the (bounded) window corrects it in O(size) instead of
+ *   the O(size²) a full recompute costs.
+ * - **Page-Hinkley**'s statistic is a running minimum of a cumulative sum, which has no cheap
+ *   correction for "forget this one old point" — the minimum may have depended on it. It is
+ *   recomputed from the window on every {@link add} rather than hand-rolling an incremental version
+ *   that would be easy to get subtly wrong. That recompute is O(size), the same order as above.
+ *
+ * ### Non-finite input is rejected, not absorbed
+ *
+ * See {@link add}. A single `NaN` would otherwise destroy the instance permanently.
+ */
+declare class TrendTester {
+    private readonly _size;
+    private readonly _values;
+    private readonly _tieCounts;
+    private readonly _pageHinkleyDelta;
+    private readonly _pageHinkleyLambda;
+    private readonly _mannKendallAlpha;
+    private _s;
+    private _rejected;
+    private _pageHinkleyResult?;
+    constructor(config?: TrendTesterConfig);
+    /** Values rejected by {@link add} for being non-finite. Non-zero means the caller has a bug. */
+    get rejected(): number;
+    /** How many values are currently in the window (`<= size`). */
+    get length(): number;
+    /** The configured window length. */
+    get size(): number;
+    /**
+     * Add the next value in the stream, evicting the oldest once the window is full.
+     *
+     * **Non-finite values are rejected** rather than stored, and the rejection is counted in
+     * {@link rejected}. This is not defensive noise — it is the difference between a bad reading and
+     * a bad instance. `Math.sign(NaN)` is `NaN`, so a single `NaN` would poison the incremental
+     * Mann-Kendall sum `_s` **permanently**: every later `add` and `_evictOldest` adds or subtracts
+     * `NaN`, the z-score is `NaN`, every comparison against it is `false`, and the tester silently
+     * reports `no-trend` forever after. It would also take a `NaN` key in `_tieCounts` that can never
+     * be matched on eviction, since `NaN !== NaN`.
+     *
+     * `undefined` RTT (no measurement this tick) must not be coerced to `0` and passed in either —
+     * "we didn't measure" is not "the trip took no time", and feeding zeros manufactures a downward
+     * trend. Skip the sample instead.
+     */
+    add(value: number): void;
+    /** The current Page-Hinkley read-out over the window. `undefined` before the first value. */
+    pageHinkley(): PageHinkleyResult | undefined;
+    /** The current Mann-Kendall read-out over the window. */
+    mannKendall(): MannKendallResult;
+    /** Drop everything, e.g. after a detected change point, to start judging the trend fresh. */
+    clear(): void;
+    /** Remove the oldest value from the window and correct `_s` for the pairs it was part of. */
+    private _evictOldest;
+    private _bumpTie;
+}
+
 interface Logger {
     trace(...args: any[]): void;
     debug(...args: any[]): void;
@@ -2965,4 +5622,4 @@ declare function createInMemorySink(samples?: ClientSample[]): InMemorySink;
 declare function createDefaultMediasoupRemoteTrackResolverFactory(): RemoteTrackResolverFactory;
 declare function createP2pRemoteTrackResolverFactory(): RemoteTrackResolverFactory;
 
-export { type AcceptContext, type AcceptMiddleware, type AcceptMiddlewarePayload, type CallAppDataFactory, type ClientAppDataFactory, type ClientEvent, ClientEventTypes, type ClientIssue, type ClientMetaData, ClientMetaTypes, type ClientSample, ClientSampleSink, type ClientSampleSinkEvents, type ClientSampleSinkFactory, type Detector, Detectors, InMemorySink, JsonlFileSink, type JsonlFileSinkFactoryOptions, type JsonlFileSinkOptions, type Logger, 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 MediasoupTransportSample, type MediasoupWebRtcTransportSample, type MediasoupWebRtcTransportSampleEventMap, type Middleware, ObservedCall, type ObservedCallScope, ObservedCertificate, ObservedClient, type ObservedClientScope, ObservedCodec, ObservedDataChannel, ObservedIceCandidate, ObservedIceCandidatePair, ObservedIceTransport, ObservedInboundRtp, ObservedInboundTrack, ObservedMediaPlayout, ObservedMediaSource, ObservedMediasoupRouter, type ObservedMediasoupRouterEvents, type ObservedMediasoupRouterScope, type ObservedMediasoupRouterSettings, ObservedOutboundRtp, ObservedOutboundTrack, ObservedPeerConnection, type ObservedPeerConnectionScope, ObservedPeerConnectionTransport, ObservedRemoteInboundRtp, ObservedRemoteOutboundRtp, Observer, type ObserverEventBase, type ObserverEvents, type ObserverLogger, RemoteTrackResolver, type RemoteTrackResolverFactory, type RemoteTrackResolvers, type SampleRejectedReason, type ScoreCalculator, createDefaultMediasoupRemoteTrackResolverFactory, createInMemorySink, createJsonlFileSink, createJsonlFileSinkFactory, createLogger, createP2pRemoteTrackResolverFactory, setObserverLogger };
+export { type AcceptContext, type AcceptMiddleware, type AcceptMiddlewarePayload, type ActiveClientIssue, type ActiveIssueTracker, ActiveIssuesRegistry, type AvailableCallScopeDetectorsConfigs, type AvailableDetectorsConfigs, type AvailableObserverScopeDetectorsConfigs, type AvailableValidatorConfigs, CODEC_MISMATCH_ISSUE, type CallAppDataFactory, CallConcurrentIssueDetector, type CallConcurrentIssueDetectorConfig, type CallConcurrentIssueGroup, CallConcurrentIssueTypes, type CallHealth, CallHealthAggregator, type CallIssueSpread, type ClientAppDataFactory, type ClientEvent, ClientEventTypes, type ClientHealth, type ClientHealthThresholds, type ClientIssue, 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 CorroboratedPublisherFault, type Detector, Detectors, InMemorySink, type IssueConclusion, IssueFanOutDetector, type IssueFanOutDetectorConfig, IssueFanOutTypes, type IssueFaultDomain, JsonlFileSink, type JsonlFileSinkFactoryOptions, type JsonlFileSinkOptions, LOWEST_COMMON_DENOMINATOR_ISSUE, type Logger, type MannKendallResult, 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, ObservedCall, type ObservedCallScope, ObservedCertificate, ObservedClient, ObservedClientIssueRegistry, type ObservedClientScope, ObservedCodec, ObservedDataChannel, ObservedIceCandidate, ObservedIceCandidatePair, ObservedIceTransport, ObservedInboundRtp, ObservedInboundTrack, ObservedMediaPlayout, ObservedMediaSource, ObservedMediasoupRouter, type ObservedMediasoupRouterEvents, type ObservedMediasoupRouterScope, type ObservedMediasoupRouterSettings, ObservedOutboundRtp, ObservedOutboundTrack, ObservedPeerConnection, type ObservedPeerConnectionScope, ObservedPeerConnectionTransport, ObservedRemoteInboundRtp, ObservedRemoteOutboundRtp, Observer, ObserverConcurrentIssueDetector, type ObserverConcurrentIssueDetectorConfig, type ObserverConcurrentIssueGroup, ObserverConcurrentIssueTypes, type ObserverEventBase, type ObserverEvents, type ObserverIssue, type ObserverIssueSpread, type ObserverLogger, type PageHinkleyResult, PublisherFaultCorroborationDetector, type PublisherFaultCorroborationDetectorConfig, PublisherFaultTypes, RESOLVED_ISSUE_SUFFIX, 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, createDefaultMediasoupRemoteTrackResolverFactory, createInMemorySink, createJsonlFileSink, createJsonlFileSinkFactory, createLogger, createP2pRemoteTrackResolverFactory, defaultClientHealthThresholds, isClientIssueResolutionEntry, issuePayloadAsString, issuePayloadOf, mannKendall, mannKendallVerdict, median, medianAbsoluteDeviation, pageHinkley, percentile, percentileOfSorted, robustZScore, setObserverLogger, summarize };