@camstack/ui-library 1.2.256 → 1.2.258

package/dist/composites/cap-settings/privacy-mask-audio.d.ts

@@ -1,59 +1,59 @@
 /**
- * The camera's MICROPHONE, as the privacy-mask panel controls it
- * ([D113](../../../../../docs/decisions/adr-0113.md) phase 3, the
- * `device-audio` row).
- *
- * | Function | Authority read | Authority written |
- * | --- | --- | --- |
- * | `device-audio` | `privacyMask.getOptions().supportsAudioMute` + `getStatus().audioEnabled` | `privacyMask.setAudioEnabled` |
- *
- * The cap already owns both privacy planes — what the camera does not film and
- * what it does not hear — so the microphone belongs in this panel and nowhere
- * else. It had no surface at all outside the aggregate switch group; without
- * this it would have become unwritable the day the group is deleted, on the one
- * authority whose store is the CAMERA and which therefore cannot be repaired
- * from the hub's own state.
- *
- * **The microphone is not part of the mask draft.** It has its own mutation
- * (`setAudioEnabled`, deliberately not a field on `PrivacyMaskPatch`) and it is
- * written immediately and read back, exactly as the switch that preceded it
- * did. Folding it into Save would mean a Save of the ZONES also rewrote the
- * microphone — two unrelated facts behind one button.
- *
- * Three answers, and collapsing any two loses a real distinction:
- *  - options unread → `null` (UNKNOWN — never "the camera has no microphone")
- *  - `supportsAudioMute: false` → not supported (no control at all)
- *  - supported but `audioEnabled: null` → UNKNOWN, never `false`
- */
+* The camera's MICROPHONE, as the privacy-mask panel controls it
+* ([D113](../../../../../docs/decisions/adr-0113.md) phase 3, the
+* `device-audio` row).
+*
+* | Function | Authority read | Authority written |
+* | --- | --- | --- |
+* | `device-audio` | `privacyMask.getOptions().supportsAudioMute` + `getStatus().audioEnabled` | `privacyMask.setAudioEnabled` |
+*
+* The cap already owns both privacy planes — what the camera does not film and
+* what it does not hear — so the microphone belongs in this panel and nowhere
+* else. It had no surface at all outside the aggregate switch group; without
+* this it would have become unwritable the day the group is deleted, on the one
+* authority whose store is the CAMERA and which therefore cannot be repaired
+* from the hub's own state.
+*
+* **The microphone is not part of the mask draft.** It has its own mutation
+* (`setAudioEnabled`, deliberately not a field on `PrivacyMaskPatch`) and it is
+* written immediately and read back, exactly as the switch that preceded it
+* did. Folding it into Save would mean a Save of the ZONES also rewrote the
+* microphone — two unrelated facts behind one button.
+*
+* Three answers, and collapsing any two loses a real distinction:
+*  - options unread → `null` (UNKNOWN — never "the camera has no microphone")
+*  - `supportsAudioMute: false` → not supported (no control at all)
+*  - supported but `audioEnabled: null` → UNKNOWN, never `false`
+*/
 export interface CameraMicrophoneState {
-    readonly label: string;
-    /** Does this camera expose a microphone switch that can actually be written? */
-    readonly supported: boolean;
-    /** `null` = nothing answered. Never coerced — "off" and "unknown" differ. */
-    readonly on: boolean | null;
-    /** A control is only offered when the plane is supported AND its state known. */
-    readonly available: boolean;
-    /** What the operator loses while it is off. */
-    readonly costWhenOff: string;
+	readonly label: string;
+	/** Does this camera expose a microphone switch that can actually be written? */
+	readonly supported: boolean;
+	/** `null` = nothing answered. Never coerced — "off" and "unknown" differ. */
+	readonly on: boolean | null;
+	/** A control is only offered when the plane is supported AND its state known. */
+	readonly available: boolean;
+	/** What the operator loses while it is off. */
+	readonly costWhenOff: string;
 }
 export interface CameraMicrophoneInput {
-    /** `getOptions().supportsAudioMute`; `null` when the read failed. */
-    readonly supportsAudioMute: boolean | null;
-    /** `getStatus().audioEnabled`; `null` when unknown or unread. */
-    readonly audioEnabled: boolean | null;
-    /** The value an in-flight write asked for; `null` when nothing is in flight. */
-    readonly pendingOn?: boolean | null;
+	/** `getOptions().supportsAudioMute`; `null` when the read failed. */
+	readonly supportsAudioMute: boolean | null;
+	/** `getStatus().audioEnabled`; `null` when unknown or unread. */
+	readonly audioEnabled: boolean | null;
+	/** The value an in-flight write asked for; `null` when nothing is in flight. */
+	readonly pendingOn?: boolean | null;
 }
 export declare const CAMERA_MICROPHONE_LABEL = "Microphone";
 export declare function resolveCameraMicrophone(input: CameraMicrophoneInput): CameraMicrophoneState;
 /** The write ONE toggle implies, in the cap's own vocabulary. */
 export interface CameraMicrophoneWrite {
-    readonly enabled: boolean;
+	readonly enabled: boolean;
 }
 /**
- * Polarity here is straight-through (`enabled` means "capturing sound"), which
- * is exactly why it is still pinned by a test: the sibling rows in this
- * refactor (`broker-audio`, `notifications`) both INVERT, and a reader who has
- * just come from one of those is one keystroke from making this one match.
- */
+* Polarity here is straight-through (`enabled` means "capturing sound"), which
+* is exactly why it is still pinned by a test: the sibling rows in this
+* refactor (`broker-audio`, `notifications`) both INVERT, and a reader who has
+* just come from one of those is one keystroke from making this one match.
+*/
 export declare function cameraMicrophoneWrite(state: CameraMicrophoneState): CameraMicrophoneWrite | null;

package/dist/composites/cap-settings/recording-config-form.d.ts

@@ -1,4 +1,4 @@
-import { RecordingBand, RecordingBandMode, RecordingConfig, RecordingStorageMode, RecordingTriggers, RecordingRetention, CamProfile } from '@camstack/types';
+import type { RecordingBand, RecordingBandMode, RecordingConfig, RecordingStorageMode, RecordingTriggers, RecordingRetention, CamProfile } from "@camstack/types";
 /** Every weekday — the `days` of a band that covers the whole week. */
 export declare const ALL_WEEKDAYS: readonly number[];
 /** The full-day span of an always-on band (`HH:MM`, 23:59 = end of day). */
@@ -13,37 +13,37 @@ export declare function removeBandAt(bands: readonly RecordingBand[], index: num
 /** Does this band cover the whole week, all day? (the Base-tab shape) */
 export declare function isAlwaysBand(band: RecordingBand): boolean;
 /**
- * A config is "advanced" when its bands cannot be expressed by the Base tab —
- * i.e. more than one band, or a single band restricted in time or weekday. Such
- * a config opens directly in the Advanced band table so nothing is silently
- * flattened by the simpler form.
- */
+* A config is "advanced" when its bands cannot be expressed by the Base tab —
+* i.e. more than one band, or a single band restricted in time or weekday. Such
+* a config opens directly in the Advanced band table so nothing is silently
+* flattened by the simpler form.
+*/
 export declare function isAdvancedConfig(cfg: RecordingConfig): boolean;
 /**
- * The editable shape of the Basic recording form: a storage mode plus the
- * `events` parameters. It compiles to exactly ONE always-on band (or none, when
- * `off`) — bands are the only thing that reaches the wire.
- */
+* The editable shape of the Basic recording form: a storage mode plus the
+* `events` parameters. It compiles to exactly ONE always-on band (or none, when
+* `off`) — bands are the only thing that reaches the wire.
+*/
 export interface RecordingFormState {
-    readonly mode: RecordingStorageMode;
-    readonly profiles?: readonly CamProfile[];
-    readonly segmentSeconds?: number;
-    readonly triggers: RecordingTriggers;
-    readonly postBufferSec?: number;
-    readonly retention?: RecordingRetention;
+	readonly mode: RecordingStorageMode;
+	readonly profiles?: readonly CamProfile[];
+	readonly segmentSeconds?: number;
+	readonly triggers: RecordingTriggers;
+	readonly postBufferSec?: number;
+	readonly retention?: RecordingRetention;
 }
 /**
- * Read a persisted config into the Basic form state. `mode` is DERIVED from the
- * bands by the same function the recorder stamps `config.mode` with; the
- * `events` parameters come from the first events band, so re-opening the form
- * shows what is actually recorded.
- */
+* Read a persisted config into the Basic form state. `mode` is DERIVED from the
+* bands by the same function the recorder stamps `config.mode` with; the
+* `events` parameters come from the first events band, so re-opening the form
+* shows what is actually recorded.
+*/
 export declare function formStateFromConfig(cfg: RecordingConfig): RecordingFormState;
 /**
- * Serialize the Basic form state to the wire config: one always-on band of the
- * chosen mode, none when `off`. `enabled` follows the mode; `mode` itself is
- * NOT sent — the recorder stamps it as the derived summary of the bands.
- */
+* Serialize the Basic form state to the wire config: one always-on band of the
+* chosen mode, none when `off`. `enabled` follows the mode; `mode` itself is
+* NOT sent — the recorder stamps it as the derived summary of the bands.
+*/
 export declare function configFromFormState(state: RecordingFormState): RecordingConfig;
 /** The Base tab's bands: one always-on band of the chosen mode (none = off). */
 export declare function bandsFromFormState(state: RecordingFormState): RecordingBand[];

package/dist/composites/cap-settings/recording-spans.d.ts

@@ -1,22 +1,22 @@
 export interface AvailabilityRange {
-    readonly profile: string;
-    readonly startMs: number;
-    readonly endMs: number;
+	readonly profile: string;
+	readonly startMs: number;
+	readonly endMs: number;
 }
 export interface PlaybackSpan {
-    readonly startMs: number;
-    readonly endMs: number;
+	readonly startMs: number;
+	readonly endMs: number;
 }
 /**
- * Merge availability ranges (across every profile) into the union of distinct
- * time windows, ascending by start. Overlapping or touching intervals coalesce;
- * zero/negative-length inputs are dropped. Newest-first ordering is the caller's
- * concern (it reverses for display).
- */
+* Merge availability ranges (across every profile) into the union of distinct
+* time windows, ascending by start. Overlapping or touching intervals coalesce;
+* zero/negative-length inputs are dropped. Newest-first ordering is the caller's
+* concern (it reverses for display).
+*/
 export declare function mergeAvailabilitySpans(ranges: readonly AvailabilityRange[]): PlaybackSpan[];
 /**
- * Pick the right unit for a byte count and render it with a sensible number of
- * significant digits (binary prefixes, matching recording sizes elsewhere).
- * KB and up render one decimal under 100, none above; bytes never get a decimal.
- */
+* Pick the right unit for a byte count and render it with a sensible number of
+* significant digits (binary prefixes, matching recording sizes elsewhere).
+* KB and up render one decimal under 100, none above; bytes never get a decimal.
+*/
 export declare function formatBytes(bytes: number): string;

package/dist/composites/cap-settings/recording-timeline-model.d.ts

@@ -1,91 +1,91 @@
-import { PlaybackSpan } from './recording-spans';
+import type { PlaybackSpan } from "./recording-spans";
 /** Fixed heatmap bucket size: 15 minutes → 96 buckets over 24h. */
 export declare const BUCKET_MS: number;
 /** Event kinds the timeline understands. */
-export type TimelineKind = 'motion' | 'object' | 'audio';
+export type TimelineKind = "motion" | "object" | "audio";
 export interface DensityBucket {
-    readonly index: number;
-    readonly startMs: number;
-    readonly endMs: number;
-    readonly counts: Readonly<Record<TimelineKind, number>>;
-    readonly total: number;
-    /** Highest-count kind, or null when the bucket is empty. */
-    readonly dominant: TimelineKind | null;
+	readonly index: number;
+	readonly startMs: number;
+	readonly endMs: number;
+	readonly counts: Readonly<Record<TimelineKind, number>>;
+	readonly total: number;
+	/** Highest-count kind, or null when the bucket is empty. */
+	readonly dominant: TimelineKind | null;
 }
 /** Row returned by the server `getEventDensity` call (one per non-empty bucket). */
 export interface EventDensityRow {
-    readonly bucketStart: number;
-    readonly motion: number;
-    readonly object: number;
-    readonly audio: number;
+	readonly bucketStart: number;
+	readonly motion: number;
+	readonly object: number;
+	readonly audio: number;
 }
 /**
- * Convert server-side density rows into `DensityBucket[]` for the timeline
- * heatmap. Rows with total === 0 are skipped (defensive; server already omits
- * them). Returns a sparse, ascending-by-index array — EventHeatmap positions
- * each bar by `b.startMs` rather than array index, so gaps are fine.
- */
+* Convert server-side density rows into `DensityBucket[]` for the timeline
+* heatmap. Rows with total === 0 are skipped (defensive; server already omits
+* them). Returns a sparse, ascending-by-index array — EventHeatmap positions
+* each bar by `b.startMs` rather than array index, so gaps are fine.
+*/
 export declare function densityRowsToBuckets(rows: readonly EventDensityRow[], windowFrom: number, bucketMs: number): DensityBucket[];
 export interface SeekTarget {
-    readonly fromMs: number;
-    readonly toMs: number;
+	readonly fromMs: number;
+	readonly toMs: number;
 }
 /**
- * Resolve a playback window for a click at `clickMs` against recorded `spans`.
- * Inside a span → play from the click to that span's end. In a gap / outside →
- * snap to the WHOLE nearest span. No spans → null (nothing to play).
- * `spans` are expected ascending by start (as `mergeAvailabilitySpans` returns).
- */
+* Resolve a playback window for a click at `clickMs` against recorded `spans`.
+* Inside a span → play from the click to that span's end. In a gap / outside →
+* snap to the WHOLE nearest span. No spans → null (nothing to play).
+* `spans` are expected ascending by start (as `mergeAvailabilitySpans` returns).
+*/
 export declare function seekTargetForSpans(clickMs: number, spans: readonly PlaybackSpan[]): SeekTarget | null;
 /**
- * Position `ms` inside the window `[fromMs, toMs]` as a clamped percentage
- * (0–100). A zero/negative-width window yields 0. Callers use this for `left:`.
- */
+* Position `ms` inside the window `[fromMs, toMs]` as a clamped percentage
+* (0–100). A zero/negative-width window yields 0. Callers use this for `left:`.
+*/
 export declare function pctForMs(ms: number, fromMs: number, toMs: number): number;
 /** A [fromMs, toMs) window spanning (at most) one calendar day. */
 export interface DayWindow {
-    readonly fromMs: number;
-    readonly toMs: number;
+	readonly fromMs: number;
+	readonly toMs: number;
 }
 /**
- * Build a DayWindow for the given calendar `date` using local time.
- * For any day strictly in the past: `fromMs` = local midnight, `toMs` =
- * next local midnight (exactly 24 h).
- * For today (or any future day that contains `nowMs`): `toMs = nowMs` so the
- * window never extends into the future.
- */
+* Build a DayWindow for the given calendar `date` using local time.
+* For any day strictly in the past: `fromMs` = local midnight, `toMs` =
+* next local midnight (exactly 24 h).
+* For today (or any future day that contains `nowMs`): `toMs = nowMs` so the
+* window never extends into the future.
+*/
 export declare function dayWindow(date: Date, nowMs: number): DayWindow;
 /** Available zoom levels in ms, from widest (24h) to narrowest (15 min). */
 export declare const ZOOM_LEVELS: readonly number[];
 /**
- * Produce a `levelMs`-wide window whose RIGHT edge stays anchored at
- * `rightEdgeMs` (clamped within `dayBounds`), rather than centring on the view
- * midpoint. On today's timeline the view's right edge is "now", so zooming this
- * way keeps the most recent footage pinned to the right instead of drifting to
- * a midday range that no longer contains now. Panning then moves back/forward.
- *
- * Falls back to `dayBounds` when `levelMs` meets or exceeds the day span (can't
- * show a wider window than the day holds — e.g. early morning with little
- * elapsed time).
- */
+* Produce a `levelMs`-wide window whose RIGHT edge stays anchored at
+* `rightEdgeMs` (clamped within `dayBounds`), rather than centring on the view
+* midpoint. On today's timeline the view's right edge is "now", so zooming this
+* way keeps the most recent footage pinned to the right instead of drifting to
+* a midday range that no longer contains now. Panning then moves back/forward.
+*
+* Falls back to `dayBounds` when `levelMs` meets or exceeds the day span (can't
+* show a wider window than the day holds — e.g. early morning with little
+* elapsed time).
+*/
 export declare function zoomWindowAnchoredRight(dayBounds: DayWindow, levelMs: number, rightEdgeMs: number): DayWindow;
 /**
- * Shift `win` by `deltaMs`, preserving width, clamped within `dayBounds`.
- */
+* Shift `win` by `deltaMs`, preserving width, clamped within `dayBounds`.
+*/
 export declare function panWindow(win: DayWindow, dayBounds: DayWindow, deltaMs: number): DayWindow;
 /**
- * Choose a sensible heatmap bucket size for a visible span of `spanMs`,
- * targeting ~96-120 buckets. Always picks from `BUCKET_CANDIDATES`.
- */
+* Choose a sensible heatmap bucket size for a visible span of `spanMs`,
+* targeting ~96-120 buckets. Always picks from `BUCKET_CANDIDATES`.
+*/
 export declare function bucketMsForSpan(spanMs: number): number;
 /** One labelled tick on the time axis. */
 export interface AxisTick {
-    readonly pct: number;
-    readonly label: string;
+	readonly pct: number;
+	readonly label: string;
 }
 /**
- * Produce `count` evenly-spaced axis ticks spanning [fromMs, toMs].
- * - `pct` is via pctForMs (first=0, last=100).
- * - `label` is a localised HH:MM clock string.
- */
+* Produce `count` evenly-spaced axis ticks spanning [fromMs, toMs].
+* - `pct` is via pctForMs (first=0, last=100).
+* - `label` is a localised HH:MM clock string.
+*/
 export declare function axisTicks(fromMs: number, toMs: number, count: number): AxisTick[];

package/dist/composites/cap-settings/scene-monitor-copy.d.ts

@@ -1,69 +1,78 @@
-import { SceneMonitor } from '@camstack/types';
+/**
+* Pure sentence builders for the scene editor.
+*
+* Split out of the component because these are the whole point of the card and
+* they are the part that can be wrong: this feature's failure mode is SILENCE
+* that reads as "nothing has happened", and the difference between a
+* five-minute fix and a session of guessing is one sentence naming which
+* lighting the scene has never been captured in.
+*/
+import type { SceneMonitor } from "@camstack/types";
 /** The lighting variants an operator is OFFERED. The resolver can also report
- *  `night`, `dawn` and `dusk`; those are shown when present but never demanded,
- *  because most installs only ever see day and IR. */
+*  `night`, `dawn` and `dusk`; those are shown when present but never demanded,
+*  because most installs only ever see day and IR. */
 export declare const SCENE_CAPTURE_VARIANTS: readonly ["day", "ir"];
 export type SceneCaptureVariant = (typeof SCENE_CAPTURE_VARIANTS)[number];
 /**
- * The one variant that is genuinely optional.
- *
- * Nobody stands outside at 22:00 to photograph a wheelie bin in infrared, and
- * plenty of scenes are daytime questions that never need a night reference at
- * all. Every sentence about IR in this file is written from that premise: a
- * missing night reference is a CHOICE the scene accommodates, never a fault it
- * reports. The engine backs that up — under the default
- * `onUncoveredCondition: 'skip'` the night checks are simply not made.
- */
+* The one variant that is genuinely optional.
+*
+* Nobody stands outside at 22:00 to photograph a wheelie bin in infrared, and
+* plenty of scenes are daytime questions that never need a night reference at
+* all. Every sentence about IR in this file is written from that premise: a
+* missing night reference is a CHOICE the scene accommodates, never a fault it
+* reports. The engine backs that up — under the default
+* `onUncoveredCondition: 'skip'` the night checks are simply not made.
+*/
 export declare const SCENE_OPTIONAL_VARIANT: SceneCaptureVariant;
 export declare const VARIANT_LABEL: Readonly<Record<string, string>>;
 export declare function variantLabel(condition: string): string;
 /**
- * "Daylight ✓ · Night (IR) ✗ — optional; checks in night (ir) are skipped."
- *
- * Converts the silent cross-condition fallback this engine used to have into an
- * operator-visible fact. Without it, a scene with only a daylight reference
- * simply stops answering after sunset and nothing anywhere says why.
- *
- * It used to end *"reports 'can't tell' in night (ir)"*, which was accurate and
- * read as a defect: the operator saw a ✗ and a complaint for a scene that was
- * configured exactly as they meant it. The missing half is now named as what it
- * is — the part you do not have to do — and the sentence says what actually
- * happens instead, which differs by the scene's own policy.
- */
+* "Daylight ✓ · Night (IR) ✗ — optional; checks in night (ir) are skipped."
+*
+* Converts the silent cross-condition fallback this engine used to have into an
+* operator-visible fact. Without it, a scene with only a daylight reference
+* simply stops answering after sunset and nothing anywhere says why.
+*
+* It used to end *"reports 'can't tell' in night (ir)"*, which was accurate and
+* read as a defect: the operator saw a ✗ and a complaint for a scene that was
+* configured exactly as they meant it. The missing half is now named as what it
+* is — the part you do not have to do — and the sentence says what actually
+* happens instead, which differs by the scene's own policy.
+*/
 export declare function coverageLine(monitor: SceneMonitor): string;
 /**
- * The calm sentence for a scene that is sitting the current light out — `null`
- * whenever it is checking normally.
- *
- * Separate from {@link statusLine} because it is not a verdict and must not
- * read like one. A paused scene has not failed, has not lost its flag, and
- * needs nothing from the operator; the only thing worth saying is which light
- * it is waiting out and that it will pick itself back up.
- */
+* The calm sentence for a scene that is sitting the current light out — `null`
+* whenever it is checking normally.
+*
+* Separate from {@link statusLine} because it is not a verdict and must not
+* read like one. A paused scene has not failed, has not lost its flag, and
+* needs nothing from the operator; the only thing worth saying is which light
+* it is waiting out and that it will pick itself back up.
+*/
 export declare function suspensionLine(monitor: SceneMonitor): string | null;
 /**
- * The one line under a scene's name. It answers, in order: can it judge, what
- * does it say, and how long has it said it.
- */
+* The one line under a scene's name. It answers, in order: can it judge, what
+* does it say, and how long has it said it.
+*/
 export declare function statusLine(monitor: SceneMonitor, now: number): string;
 /** The badge word. `latched` wins over `verdict`, because the latch is the
- *  thing the operator asked to be told and it outlives the live state.
- *
- *  A scene sitting out an uncovered light reads `Paused`, in the NEUTRAL tone —
- *  never `alarm`, and never the `danger` variant the page maps that to. A
- *  missing IR reference must not be able to paint a red badge on a scene that
- *  is doing exactly what it was configured to do. */
+*  thing the operator asked to be told and it outlives the live state.
+*
+*  A scene sitting out an uncovered light reads `Paused`, in the NEUTRAL tone —
+*  never `alarm`, and never the `danger` variant the page maps that to. A
+*  missing IR reference must not be able to paint a red badge on a scene that
+*  is doing exactly what it was configured to do. */
 export declare function badgeFor(monitor: SceneMonitor): {
-    text: string;
-    tone: 'alarm' | 'ok' | 'unknown';
+	text: string;
+	tone: "alarm" | "ok" | "unknown";
 };
 /** A rect covering most of the frame is dominated by weather, sky and parked
- *  cars: the bin is 2 % of the pixels and CLIP will not notice it leaving. The
- *  failure is silent INSENSITIVITY, which is the worst kind — hence a warning
- *  rather than a refusal. */
-export declare const ROI_AREA_WARN_FRACTION = 0.4;
+*  cars: the bin is 2 % of the pixels and CLIP will not notice it leaving. The
+*  failure is silent INSENSITIVITY, which is the worst kind — hence a warning
+*  rather than a refusal. */
+export declare const ROI_AREA_WARN_FRACTION = .4;
 export declare function roiTooLarge(roi: {
-    width: number;
-    height: number;
+	width: number;
+	height: number;
 }): boolean;
 export declare function humanDuration(ms: number): string;

package/dist/composites/client-network-sample.d.ts

@@ -1,56 +1,56 @@
 /**
- * What the player reports to the broker every ~2 s
- * (`networkQuality.reportClientStats`), as a pure step over two `getStats`
- * readings — so the two ways it used to lie can be pinned (D635 round 3):
- *
- * - Across a PC swap (a tier change's make-before-break) the byte baseline was
- *   the OLD connection's, so the new PC's first reading clamped to 0 kbps; and
- *   while a renegotiation was in flight the reporter read a closing PC. Both
- *   zeros were matched by the broker against real sends (review I1). A new PC
- *   now re-baselines, and nothing is reported while renegotiating.
- * - The downlink probe never reached the broker unless it justified a climb.
- *   The sample now carries the latest probe whatever it read, with its age
- *   (review I4), so "measured slow" is no longer indistinguishable from
- *   "failed".
- */
+* What the player reports to the broker every ~2 s
+* (`networkQuality.reportClientStats`), as a pure step over two `getStats`
+* readings — so the two ways it used to lie can be pinned (D635 round 3):
+*
+* - Across a PC swap (a tier change's make-before-break) the byte baseline was
+*   the OLD connection's, so the new PC's first reading clamped to 0 kbps; and
+*   while a renegotiation was in flight the reporter read a closing PC. Both
+*   zeros were matched by the broker against real sends (review I1). A new PC
+*   now re-baselines, and nothing is reported while renegotiating.
+* - The downlink probe never reached the broker unless it justified a climb.
+*   The sample now carries the latest probe whatever it read, with its age
+*   (review I4), so "measured slow" is no longer indistinguishable from
+*   "failed".
+*/
 /** Client-observed network conditions. Matches the `networkQuality.reportClientStats`
- *  mutation input (minus `deviceId`, which the caller adds). */
+*  mutation input (minus `deviceId`, which the caller adds). */
 export interface ClientNetworkSample {
-    readonly rttMs: number;
-    readonly jitterMs: number;
-    readonly estimatedBandwidthKbps: number;
-    readonly packetLossPercent: number;
-    /** Latest `/adaptive-probe` reading, Mbps, whatever it read; absent = never / failed. */
-    readonly downlinkMbps?: number;
-    /** Age of that reading now, ms. */
-    readonly downlinkAgeMs?: number;
+	readonly rttMs: number;
+	readonly jitterMs: number;
+	readonly estimatedBandwidthKbps: number;
+	readonly packetLossPercent: number;
+	/** Latest `/adaptive-probe` reading, Mbps, whatever it read; absent = never / failed. */
+	readonly downlinkMbps?: number;
+	/** Age of that reading now, ms. */
+	readonly downlinkAgeMs?: number;
 }
 /** One inbound-video `getStats` reading, and the connection it came from. */
 export interface InboundReading {
-    /** The RTCPeerConnection read — identity only. */
-    readonly pc: object;
-    readonly lost: number;
-    readonly recv: number;
-    readonly bytes: number;
-    /** getStats timestamp, ms. */
-    readonly ts: number;
-    readonly rttS: number;
-    readonly jitterS: number;
+	/** The RTCPeerConnection read — identity only. */
+	readonly pc: object;
+	readonly lost: number;
+	readonly recv: number;
+	readonly bytes: number;
+	/** getStats timestamp, ms. */
+	readonly ts: number;
+	readonly rttS: number;
+	readonly jitterS: number;
 }
 /** The latest probe as the player holds it. */
 export interface ProbeReading {
-    readonly mbps: number;
-    readonly ageMs: number;
+	readonly mbps: number;
+	readonly ageMs: number;
 }
 export interface SampleContext {
-    /** A renegotiation (tier change) is in flight: the PC being read is on its way out. */
-    readonly renegotiating: boolean;
-    readonly probe: ProbeReading | null;
+	/** A renegotiation (tier change) is in flight: the PC being read is on its way out. */
+	readonly renegotiating: boolean;
+	readonly probe: ProbeReading | null;
 }
 export interface SampleStep {
-    /** The reading to diff the next one against; null = start over. */
-    readonly baseline: InboundReading | null;
-    /** What to report now; null = report nothing this window. */
-    readonly sample: ClientNetworkSample | null;
+	/** The reading to diff the next one against; null = start over. */
+	readonly baseline: InboundReading | null;
+	/** What to report now; null = report nothing this window. */
+	readonly sample: ClientNetworkSample | null;
 }
 export declare function nextClientSample(prev: InboundReading | null, cur: InboundReading, ctx: SampleContext): SampleStep;