@camstack/ui-library 1.2.256 → 1.2.258

package/dist/lib/index.d.ts

@@ -1,21 +1,21 @@
-export { cn } from './cn';
-export { formatLastSeen } from './format-last-seen';
-export { formatControlDateTime } from './format-control-datetime';
-export type { ControlDateTimeFormat } from './format-control-datetime';
-export { formatNumeric } from './format-numeric';
-export { resolveSensorDisplay } from './resolve-sensor-display';
-export type { SensorDisplayInput, ResolvedSensorDisplay } from './resolve-sensor-display';
-export { isAbsentProvider } from './cap-error';
-export * from './responsive';
-export { mirror } from './pipeline-mirror';
-export type { MirrorSource, MirrorInput, MirrorOutcome, MirrorResultEntry, } from './pipeline-mirror';
-export { PHASE_CONFIG, getPhaseVisual } from './phase-config';
-export type { PhaseVisual } from './phase-config';
-export { createSharedContext } from './shared-context';
-export { ensureMfHostInit } from './mf-runtime-init';
-export { hubOrigin, hubPath, hubUrl, hubWsUrl, mountPath, resetHubMountForTests, routerBasename, } from './hub-mount';
-export { serializeRecordedCommand, parseRecordedServerMessage, RECORDED_PLAYBACK_MODES, } from './recorded-control-protocol';
-export type { RecordedControlCommand, RecordedPlaybackMode, RecordedServerMessage, } from './recorded-control-protocol';
-export { scrubReducer, initialScrubState, shouldEmit, shouldCommit, cursorFractionFor, makeScrubBridge, useScrubController, COMMIT_DEDUPE_TOLERANCE_MS, COMMIT_DEDUPE_WINDOW_MS, } from './scrub-controller';
-export type { ScrubSource, ScrubState, ScrubAction, ScrubController, PlaybackControlSink, LastCommit, } from './scrub-controller';
-export { applyFleetQueryDefaults, FLEET_LIST_QUERY_KEY, FLEET_LIST_STALE_TIME_MS, FLEET_LIST_GC_TIME_MS, } from './fleet-query-defaults';
+export { cn } from "./cn";
+export { formatLastSeen } from "./format-last-seen";
+export { formatControlDateTime } from "./format-control-datetime";
+export type { ControlDateTimeFormat } from "./format-control-datetime";
+export { formatNumeric } from "./format-numeric";
+export { resolveSensorDisplay } from "./resolve-sensor-display";
+export type { SensorDisplayInput, ResolvedSensorDisplay } from "./resolve-sensor-display";
+export { isAbsentProvider } from "./cap-error";
+export * from "./responsive";
+export { mirror } from "./pipeline-mirror";
+export type { MirrorSource, MirrorInput, MirrorOutcome, MirrorResultEntry } from "./pipeline-mirror";
+export { PHASE_CONFIG, getPhaseVisual } from "./phase-config";
+export type { PhaseVisual } from "./phase-config";
+export { createSharedContext } from "./shared-context";
+export { ensureMfHostInit } from "./mf-runtime-init";
+export { hubOrigin, hubPath, hubUrl, hubWsUrl, mountPath, resetHubMountForTests, routerBasename } from "./hub-mount";
+export { serializeRecordedCommand, parseRecordedServerMessage, RECORDED_PLAYBACK_MODES } from "./recorded-control-protocol";
+export type { RecordedControlCommand, RecordedPlaybackMode, RecordedServerMessage } from "./recorded-control-protocol";
+export { scrubReducer, initialScrubState, shouldEmit, shouldCommit, cursorFractionFor, makeScrubBridge, useScrubController, COMMIT_DEDUPE_TOLERANCE_MS, COMMIT_DEDUPE_WINDOW_MS } from "./scrub-controller";
+export type { ScrubSource, ScrubState, ScrubAction, ScrubController, PlaybackControlSink, LastCommit } from "./scrub-controller";
+export { applyFleetQueryDefaults, FLEET_LIST_QUERY_KEY, FLEET_LIST_STALE_TIME_MS, FLEET_LIST_GC_TIME_MS } from "./fleet-query-defaults";

package/dist/lib/phase-config.d.ts

@@ -1,15 +1,28 @@
-import { CameraPhase } from '@camstack/types';
+/**
+* phase-config — canonical visual config for CameraPhase values.
+*
+* Single source of truth for label, color classes, dot class, and
+* lucide icon name. Every UI surface (PhaseBadge, CameraStatusStrip,
+* CameraAssignmentsTable, DeviceDetail, OverviewTab, NodeLiveTab)
+* imports from here instead of hardcoding phase → style mappings.
+*
+* Icon components are NOT imported here (would pull lucide-react into
+* the config module). Consumers import the icon by name themselves:
+*   `import { [cfg.icon] } from 'lucide-react'`
+* or use the provided `PhaseIcon` component from `./phase-icon.tsx`.
+*/
+import type { CameraPhase } from "@camstack/types";
 export interface PhaseVisual {
-    /** Human-readable label (e.g. "Active", "Load-Shed"). */
-    readonly label: string;
-    /** Tailwind text color class (e.g. "text-success"). */
-    readonly textColor: string;
-    /** Tailwind border+bg classes for pill/badge containers. */
-    readonly badgeClass: string;
-    /** Tailwind class for the status dot (circle indicator). */
-    readonly dotClass: string;
-    /** Lucide icon name to use for this phase. */
-    readonly icon: 'Activity' | 'Eye' | 'AlertTriangle' | 'PauseCircle' | 'PowerOff';
+	/** Human-readable label (e.g. "Active", "Load-Shed"). */
+	readonly label: string;
+	/** Tailwind text color class (e.g. "text-success"). */
+	readonly textColor: string;
+	/** Tailwind border+bg classes for pill/badge containers. */
+	readonly badgeClass: string;
+	/** Tailwind class for the status dot (circle indicator). */
+	readonly dotClass: string;
+	/** Lucide icon name to use for this phase. */
+	readonly icon: "Activity" | "Eye" | "AlertTriangle" | "PauseCircle" | "PowerOff";
 }
 export declare const PHASE_CONFIG: Record<CameraPhase, PhaseVisual>;
 /** Look up phase config with a safe fallback to `watching` for unknown values. */

package/dist/lib/pipeline-mirror.d.ts

@@ -1,23 +1,23 @@
-import { AgentAddonConfig, CameraStepOverridePatch, PipelineSchema } from '@camstack/types';
+import type { AgentAddonConfig, CameraStepOverridePatch, PipelineSchema } from "@camstack/types";
 export interface MirrorSource {
-    readonly nodeId: string;
-    readonly engine: {
-        readonly format: string;
-    };
-    readonly defaults: Readonly<Record<string, AgentAddonConfig>>;
+	readonly nodeId: string;
+	readonly engine: {
+		readonly format: string;
+	};
+	readonly defaults: Readonly<Record<string, AgentAddonConfig>>;
 }
 export interface MirrorInput {
-    readonly source: MirrorSource;
-    readonly target: MirrorSource;
-    readonly catalog: PipelineSchema;
-    readonly addonIds: readonly string[];
+	readonly source: MirrorSource;
+	readonly target: MirrorSource;
+	readonly catalog: PipelineSchema;
+	readonly addonIds: readonly string[];
 }
-export type MirrorOutcome = 'exact' | 'mapped' | 'skip';
+export type MirrorOutcome = "exact" | "mapped" | "skip";
 export interface MirrorResultEntry {
-    readonly addonId: string;
-    readonly outcome: MirrorOutcome;
-    readonly modelId: string | null;
-    readonly reason?: string;
-    readonly patch: CameraStepOverridePatch | null;
+	readonly addonId: string;
+	readonly outcome: MirrorOutcome;
+	readonly modelId: string | null;
+	readonly reason?: string;
+	readonly patch: CameraStepOverridePatch | null;
 }
 export declare function mirror(input: MirrorInput): readonly MirrorResultEntry[];

package/dist/lib/recorded-control-protocol.d.ts

@@ -1,61 +1,59 @@
 /**
- * Client-side wire codec for the `camstack-control` RTCDataChannel (R9).
- *
- * Mirrors the broker's `control-protocol.ts`
- * (packages/addon-pipeline/src/stream-broker/recorded/control-protocol.ts):
- * client→server commands drive the per-viewer `TimelineSession` /
- * `RecordedFeeder` (frame-push recorded playback on the SAME WebRTC session
- * as live video); server→client messages report playback state + a ~1 Hz
- * position. Shapes are re-declared here (not imported) because ui-library
- * cannot depend on an addon package — the embed SPA does the same.
- *
- * Parsing is defensive: a malformed frame returns `null`, never throws, so a
- * bad datachannel message can't take down the player.
- */
+* Client-side wire codec for the `camstack-control` RTCDataChannel (R9).
+*
+* Mirrors the broker's `control-protocol.ts`
+* (packages/addon-pipeline/src/stream-broker/recorded/control-protocol.ts):
+* client→server commands drive the per-viewer `TimelineSession` /
+* `RecordedFeeder` (frame-push recorded playback on the SAME WebRTC session
+* as live video); server→client messages report playback state + a ~1 Hz
+* position. Shapes are re-declared here (not imported) because ui-library
+* cannot depend on an addon package — the embed SPA does the same.
+*
+* Parsing is defensive: a malformed frame returns `null`, never throws, so a
+* bad datachannel message can't take down the player.
+*/
 export type RecordedControlCommand = {
-    readonly t: 'playRecorded';
-    readonly deviceId: number;
-    readonly epoch: number;
-    readonly profile: string;
+	readonly t: "playRecorded";
+	readonly deviceId: number;
+	readonly epoch: number;
+	readonly profile: string;
 } | {
-    readonly t: 'seek';
-    readonly epoch: number;
+	readonly t: "seek";
+	readonly epoch: number;
 } | {
-    readonly t: 'scrubCommit';
-    readonly epoch: number;
+	readonly t: "scrubCommit";
+	readonly epoch: number;
 } | {
-    readonly t: 'setRate';
-    readonly rate: 0 | 1;
+	readonly t: "setRate";
+	readonly rate: 0 | 1;
 } | {
-    readonly t: 'goLive';
+	readonly t: "goLive";
 } | {
-    readonly t: 'setProfile';
-    readonly profile: string;
+	readonly t: "setProfile";
+	readonly profile: string;
 };
 /** Serialize a command for `RTCDataChannel.send` (matches the server schema). */
 export declare function serializeRecordedCommand(cmd: RecordedControlCommand): string;
 /**
- * Playback mode reported by the server session. `live` = the shared live feed
- * owns the track; every other value describes the recorded feeder.
- */
+* Playback mode reported by the server session. `live` = the shared live feed
+* owns the track; every other value describes the recorded feeder.
+*/
 export declare const RECORDED_PLAYBACK_MODES: readonly ["live", "loading", "playing", "paused", "gap", "ended", "error"];
 export type RecordedPlaybackMode = (typeof RECORDED_PLAYBACK_MODES)[number];
-export type RecordedServedProfile = 'high' | 'mid' | 'low';
+export type RecordedServedProfile = "high" | "mid" | "low";
 export type RecordedServerMessage = {
-    readonly kind: 'state';
-    readonly state: RecordedPlaybackMode;
+	readonly kind: "state";
+	readonly state: RecordedPlaybackMode;
 } | {
-    readonly kind: 'position';
-    readonly epochMs: number;
-}
-/** The tier actually playing, next to the one the client asked for. */
- | {
-    readonly kind: 'servedProfile';
-    readonly profile: RecordedServedProfile;
-    readonly requested: string;
+	readonly kind: "position";
+	readonly epochMs: number;
+} | {
+	readonly kind: "servedProfile";
+	readonly profile: RecordedServedProfile;
+	readonly requested: string;
 };
 /**
- * Parse a raw server→client control frame. Returns `null` on any malformed
- * payload (bad JSON, unknown discriminator, wrong field types).
- */
+* Parse a raw server→client control frame. Returns `null` on any malformed
+* payload (bad JSON, unknown discriminator, wrong field types).
+*/
 export declare function parseRecordedServerMessage(raw: string): RecordedServerMessage | null;

package/dist/lib/resolve-sensor-display.d.ts

@@ -1,25 +1,41 @@
-import { DeviceDisplayOverride, RoleDisplayDefault } from '@camstack/types';
+/**
+* Shared, pure resolution of a sensor's DISPLAY unit + precision + value
+* transform. One function so the two renderers (`SensorValueAtom`,
+* `SensorHeroCard`) can never diverge — they duplicated this precedence before.
+*
+* Resolution order (device override → role default → live slice →
+* ROLE_DESCRIPTOR canonicalUnit). `??` everywhere, never `||`: `precision: 0`
+* is a legal override and must win over a slice `precision: 2`.
+*
+* Conversion happens at RENDER only — storage stays in source units. An
+* override unit converts the raw slice value ONLY when it shares a dimension
+* with the source unit (`canConvertUnit`); on refusal the display falls back to
+* identity + the SOURCE unit so a unit label and its value math can never
+* disagree. Precision applies AFTER conversion (by construction — the caller
+* runs `formatNumeric(toDisplayValue(raw), precision)`).
+*/
+import type { DeviceDisplayOverride, RoleDisplayDefault } from "@camstack/types";
 export interface SensorDisplayInput {
-    /** Per-device override from the row (`DeviceInfo.display`). */
-    readonly display?: DeviceDisplayOverride;
-    /** Cap name for `perCap` refinement (e.g. 'numeric-sensor'); undefined skips it. */
-    readonly capName?: string;
-    /** Role default (`roleDisplayDefaults[device.role]`). */
-    readonly roleDefault?: RoleDisplayDefault;
-    /** Live slice unit (the unit the raw VALUE is actually in, for generic sensors). */
-    readonly sliceUnit?: string;
-    /** Live slice precision. */
-    readonly slicePrecision?: number;
-    /** ROLE_DESCRIPTOR canonical unit fallback (typed roles). */
-    readonly canonicalUnit?: string;
+	/** Per-device override from the row (`DeviceInfo.display`). */
+	readonly display?: DeviceDisplayOverride;
+	/** Cap name for `perCap` refinement (e.g. 'numeric-sensor'); undefined skips it. */
+	readonly capName?: string;
+	/** Role default (`roleDisplayDefaults[device.role]`). */
+	readonly roleDefault?: RoleDisplayDefault;
+	/** Live slice unit (the unit the raw VALUE is actually in, for generic sensors). */
+	readonly sliceUnit?: string;
+	/** Live slice precision. */
+	readonly slicePrecision?: number;
+	/** ROLE_DESCRIPTOR canonical unit fallback (typed roles). */
+	readonly canonicalUnit?: string;
 }
 export interface ResolvedSensorDisplay {
-    /** Display unit — `''` when none resolves anywhere. */
-    readonly unit: string;
-    /** Display precision (int 0-10) or undefined for auto-format. */
-    readonly precision: number | undefined;
-    /** Convert a raw slice value into the display unit. Identity unless an
-     *  override unit differs from the source unit AND both share a dimension. */
-    readonly toDisplayValue: (raw: number) => number;
+	/** Display unit — `''` when none resolves anywhere. */
+	readonly unit: string;
+	/** Display precision (int 0-10) or undefined for auto-format. */
+	readonly precision: number | undefined;
+	/** Convert a raw slice value into the display unit. Identity unless an
+	*  override unit differs from the source unit AND both share a dimension. */
+	readonly toDisplayValue: (raw: number) => number;
 }
 export declare function resolveSensorDisplay(input: SensorDisplayInput): ResolvedSensorDisplay;

package/dist/lib/responsive.d.ts

@@ -1,40 +1,40 @@
 /**
- * Responsive design tokens — three-tier system.
- *
- * The admin-ui targets three width tiers; every component should pick
- * the right token from this file instead of hand-coding breakpoints.
- * Adopting the tokens uniformly is what makes the app feel consistent
- * across operator devices (mobile / tablet / desktop) and what unlocks
- * targeted tuning (e.g. shrink every label by 1px in one place).
- *
- * Tier definitions (Tailwind breakpoints):
- *
- *   • **L1 — Compact** (`< 640px`, default = mobile portrait)
- *     Single column, tight padding, smallest text, icon-only buttons
- *     where labels can be inferred. The operator can still see every
- *     stat / action — no horizontal scroll, no clipped text. The user
- *     directive: "molta informazione in poco spazio quando la width è
- *     bassa." [a lot of information in little space when the width is low.]
- *
- *   • **L2 — Standard** (`sm` — `640–1023px`, tablet + small laptop)
- *     2-column grids, side panels become visible, button labels return.
- *     Targets ~768px–1024px viewports — the most common operator sizes.
- *
- *   • **L3 — Spacious** (`lg+` — `≥ 1024px`, desktop)
- *     4-column grids, generous padding, full-width header text,
- *     side-by-side composite layouts. The operator has elbow room.
- *
- * Conventions:
- *   - **Always start from L1** — the bare class is always the compact
- *     variant, then `sm:` adds room at 640px, `lg:` at 1024px. No
- *     desktop-first breakpoints; no max-width queries.
- *   - **Token strings are static** — kept as `as const` so callers can
- *     compose them via `cn()` / template literals without running a
- *     class generator at runtime.
- *   - **Pair the token with a comment** — the comment in the file
- *     names every breakpoint it crosses, so a reader can predict the
- *     layout without going to Tailwind docs.
- */
+* Responsive design tokens — three-tier system.
+*
+* The admin-ui targets three width tiers; every component should pick
+* the right token from this file instead of hand-coding breakpoints.
+* Adopting the tokens uniformly is what makes the app feel consistent
+* across operator devices (mobile / tablet / desktop) and what unlocks
+* targeted tuning (e.g. shrink every label by 1px in one place).
+*
+* Tier definitions (Tailwind breakpoints):
+*
+*   • **L1 — Compact** (`< 640px`, default = mobile portrait)
+*     Single column, tight padding, smallest text, icon-only buttons
+*     where labels can be inferred. The operator can still see every
+*     stat / action — no horizontal scroll, no clipped text. The user
+*     directive: "molta informazione in poco spazio quando la width è
+*     bassa." [a lot of information in little space when the width is low.]
+*
+*   • **L2 — Standard** (`sm` — `640–1023px`, tablet + small laptop)
+*     2-column grids, side panels become visible, button labels return.
+*     Targets ~768px–1024px viewports — the most common operator sizes.
+*
+*   • **L3 — Spacious** (`lg+` — `≥ 1024px`, desktop)
+*     4-column grids, generous padding, full-width header text,
+*     side-by-side composite layouts. The operator has elbow room.
+*
+* Conventions:
+*   - **Always start from L1** — the bare class is always the compact
+*     variant, then `sm:` adds room at 640px, `lg:` at 1024px. No
+*     desktop-first breakpoints; no max-width queries.
+*   - **Token strings are static** — kept as `as const` so callers can
+*     compose them via `cn()` / template literals without running a
+*     class generator at runtime.
+*   - **Pair the token with a comment** — the comment in the file
+*     names every breakpoint it crosses, so a reader can predict the
+*     layout without going to Tailwind docs.
+*/
 /** Container padding for a card-style section (header + body). */
 export declare const SECTION_CARD: "rounded-lg border border-border bg-surface overflow-hidden";
 /** Header strip inside a card (between border-b lines). */
@@ -56,32 +56,32 @@ export declare const SPLIT_PANEL_OUTER: "flex flex-col-reverse md:flex-row";
 /** Sidebar narrow lane in a SPLIT_PANEL_OUTER layout. */
 export declare const SPLIT_PANEL_SIDE: "w-full md:w-44 lg:w-52 md:flex-shrink-0 border-b md:border-b-0 md:border-l border-border";
 /**
- * The tier boundary at which a settings label/value row stops stacking.
- *
- * Below it (L1 — compact) the row is ONE column: label on its own line, value
- * on the next at full width. Above it the row is label-left / value-right as
- * before. The two-column form needs `SETTING_ROW_LABEL`'s lane plus a readable
- * value beside it; a phone has neither, and the failure mode is not "cramped"
- * but "the value is the part that gets cut" — the one thing the operator
- * opened the page to read.
- */
+* The tier boundary at which a settings label/value row stops stacking.
+*
+* Below it (L1 — compact) the row is ONE column: label on its own line, value
+* on the next at full width. Above it the row is label-left / value-right as
+* before. The two-column form needs `SETTING_ROW_LABEL`'s lane plus a readable
+* value beside it; a phone has neither, and the failure mode is not "cramped"
+* but "the value is the part that gets cut" — the one thing the operator
+* opened the page to read.
+*/
 export declare const SETTING_ROW_STACK_BREAKPOINT: "sm";
 /** Outer row: single column at L1, label/value columns from `sm` up. */
 export declare const SETTING_ROW: "flex min-w-0 flex-col gap-0.5 py-1.5 sm:flex-row sm:items-center";
 /** Label lane. Full width (and free to wrap) at L1; a fixed lane from `sm` up. */
 export declare const SETTING_ROW_LABEL: "min-w-0 text-[11px] leading-tight text-foreground-subtle sm:w-32 sm:shrink-0 sm:pr-2";
 /**
- * Value lane — the value text plus its trailing affordances (copy / reveal).
- * `w-full` at L1 so the value owns the whole row once the label is above it;
- * `sm:flex-1` makes it share the row again from `sm` up.
- */
+* Value lane — the value text plus its trailing affordances (copy / reveal).
+* `w-full` at L1 so the value owns the whole row once the label is above it;
+* `sm:flex-1` makes it share the row again from `sm` up.
+*/
 export declare const SETTING_ROW_VALUE: "flex w-full min-w-0 items-center gap-1 sm:flex-1";
 /**
- * The value text itself. `break-all` lets an opaque token (a key, a URL) wrap
- * at L1 instead of being cut mid-word; `sm:truncate` restores the single-line
- * desktop form, where the row is wide enough for truncation to be a choice
- * rather than data loss.
- */
+* The value text itself. `break-all` lets an opaque token (a key, a URL) wrap
+* at L1 instead of being cut mid-word; `sm:truncate` restores the single-line
+* desktop form, where the row is wide enough for truncation to be a choice
+* rather than data loss.
+*/
 export declare const SETTING_ROW_VALUE_TEXT: "min-w-0 break-all text-xs text-foreground sm:truncate";
 /** Section header label (uppercase tracking-wider). */
 export declare const TEXT_SECTION_LABEL: "text-[10px] sm:text-[11px] font-semibold text-foreground uppercase tracking-wider";

package/dist/lib/scrub-controller.d.ts

@@ -1,115 +1,112 @@
-export type ScrubSource = 'timeline' | 'heatmap';
+export type ScrubSource = "timeline" | "heatmap";
 export interface ScrubState {
-    readonly scrubbing: boolean;
-    readonly scrubEpoch: number | null;
-    readonly playheadEpoch: number | null;
-    readonly lastSource: ScrubSource | null;
+	readonly scrubbing: boolean;
+	readonly scrubEpoch: number | null;
+	readonly playheadEpoch: number | null;
+	readonly lastSource: ScrubSource | null;
 }
 export declare const initialScrubState: ScrubState;
 export type ScrubAction = {
-    readonly type: 'begin';
-    readonly source: ScrubSource;
+	readonly type: "begin";
+	readonly source: ScrubSource;
 } | {
-    readonly type: 'update';
-    readonly epoch: number;
-    readonly source: ScrubSource;
+	readonly type: "update";
+	readonly epoch: number;
+	readonly source: ScrubSource;
 } | {
-    readonly type: 'end';
-    readonly epoch: number;
-    readonly source: ScrubSource;
+	readonly type: "end";
+	readonly epoch: number;
+	readonly source: ScrubSource;
 } | {
-    readonly type: 'seek';
-    readonly epoch: number;
-    readonly source: ScrubSource;
+	readonly type: "seek";
+	readonly epoch: number;
+	readonly source: ScrubSource;
 } | {
-    readonly type: 'playhead';
-    readonly epoch: number;
+	readonly type: "playhead";
+	readonly epoch: number;
 } | {
-    readonly type: 'reset';
+	readonly type: "reset";
 };
 export declare function scrubReducer(state: ScrubState, action: ScrubAction): ScrubState;
 /**
- * Throttle decision for continuous `update` emits (default ~70 ms).
- * Returns true when enough time has elapsed since the last emit.
- */
+* Throttle decision for continuous `update` emits (default ~70 ms).
+* Returns true when enough time has elapsed since the last emit.
+*/
 export declare function shouldEmit(lastEmitMs: number, now: number, throttleMs?: number): boolean;
 /** The last committed target (epoch + wall-clock of the commit). */
 export interface LastCommit {
-    readonly epoch: number;
-    readonly at: number;
+	readonly epoch: number;
+	readonly at: number;
 }
 /** Epochs within this many ms of the last commit count as the SAME target. */
 export declare const COMMIT_DEDUPE_TOLERANCE_MS = 750;
 /** Only dedupe against a commit made within this recent window. */
-export declare const COMMIT_DEDUPE_WINDOW_MS = 2000;
+export declare const COMMIT_DEDUPE_WINDOW_MS = 2e3;
 /**
- * Decide whether a `seek`/`scrubCommit` should actually hit the playback sink.
- * Each commit reloads the server feeder (loading→playing) and visibly stutters
- * playback; firing the same (or a near-identical) target twice in quick
- * succession produces a redundant reload. Drop a commit only when it targets
- * essentially the SAME epoch as the last commit AND that commit was recent — a
- * genuinely different target, or a re-seek to the same spot after the window,
- * always commits.
- */
+* Decide whether a `seek`/`scrubCommit` should actually hit the playback sink.
+* Each commit reloads the server feeder (loading→playing) and visibly stutters
+* playback; firing the same (or a near-identical) target twice in quick
+* succession produces a redundant reload. Drop a commit only when it targets
+* essentially the SAME epoch as the last commit AND that commit was recent — a
+* genuinely different target, or a re-seek to the same spot after the window,
+* always commits.
+*/
 export declare function shouldCommit(last: LastCommit | null, epoch: number, now: number, toleranceMs?: number, windowMs?: number): boolean;
 /**
- * The active cursor position (scrub target while scrubbing, else playhead)
- * expressed as a 0..1 fraction across the day window.
- * Returns null when no position is known or the day window is degenerate.
- */
+* The active cursor position (scrub target while scrubbing, else playhead)
+* expressed as a 0..1 fraction across the day window.
+* Returns null when no position is known or the day window is degenerate.
+*/
 export declare function cursorFractionFor(state: ScrubState, day: {
-    readonly from: number;
-    readonly to: number;
+	readonly from: number;
+	readonly to: number;
 }): number | null;
 /**
- * Generic, always-active playback control surface the scrub controller
- * drives. `scrubStart`/`scrubTo` are CLIENT-SIDE hooks (the wire protocol has
- * no per-move scrub message — a future WebCodecs preview consumes them);
- * `scrubCommit`/`seek` reach the server feeder.
- */
+* Generic, always-active playback control surface the scrub controller
+* drives. `scrubStart`/`scrubTo` are CLIENT-SIDE hooks (the wire protocol has
+* no per-move scrub message — a future WebCodecs preview consumes them);
+* `scrubCommit`/`seek` reach the server feeder.
+*/
 export interface PlaybackControlSink {
-    scrubStart(): void;
-    scrubTo(epochMs: number): void;
-    scrubCommit(epochMs: number): void;
-    seek(epochMs: number): void;
+	scrubStart(): void;
+	scrubTo(epochMs: number): void;
+	scrubCommit(epochMs: number): void;
+	seek(epochMs: number): void;
 }
 /** A mutable holder, structurally compatible with React's `MutableRefObject`. */
 export interface MutableRef<T> {
-    current: T;
+	current: T;
 }
 /** The gesture callbacks the hook exposes (everything except `state`). */
-type ScrubBridge = Omit<ScrubController, 'state'>;
+type ScrubBridge = Omit<ScrubController, "state">;
 /**
- * Builds the always-active bridge callbacks from a sink, a dispatch, and the
- * throttle ref. Pure (no React) so it can be unit-tested directly: the hook
- * just wraps the result in `useMemo`.
- *
- * Every gesture drives the sink immediately — there is no VOD-active gate.
- */
-export declare function makeScrubBridge(sink: PlaybackControlSink, dispatch: (action: ScrubAction) => void, lastEmitRef: MutableRef<number>, lastCommitRef?: MutableRef<LastCommit | null>, 
-/** Reports whether the PLAYER is currently on the live edge (not in recorded
- *  mode). Used to bypass commit-dedupe on the live→recorded transition. */
-isPlayerLive?: () => boolean): ScrubBridge;
+* Builds the always-active bridge callbacks from a sink, a dispatch, and the
+* throttle ref. Pure (no React) so it can be unit-tested directly: the hook
+* just wraps the result in `useMemo`.
+*
+* Every gesture drives the sink immediately — there is no VOD-active gate.
+*/
+export declare function makeScrubBridge(sink: PlaybackControlSink, dispatch: (action: ScrubAction) => void, lastEmitRef: MutableRef<number>, lastCommitRef?: MutableRef<LastCommit | null>, isPlayerLive?: () => boolean): ScrubBridge;
 export interface ScrubController {
-    readonly state: ScrubState;
-    readonly beginScrub: (source: ScrubSource) => void;
-    readonly updateScrub: (epoch: number, source: ScrubSource) => void;
-    readonly endScrub: (epoch: number, source: ScrubSource) => void;
-    readonly seek: (epoch: number, source: ScrubSource) => void;
-    readonly setPlayhead: (epoch: number) => void;
-    readonly reset: () => void;
+	readonly state: ScrubState;
+	readonly beginScrub: (source: ScrubSource) => void;
+	readonly updateScrub: (epoch: number, source: ScrubSource) => void;
+	readonly endScrub: (epoch: number, source: ScrubSource) => void;
+	readonly seek: (epoch: number, source: ScrubSource) => void;
+	readonly setPlayhead: (epoch: number) => void;
+	readonly reset: () => void;
 }
 /**
- * Owns the shared scrub position and bridges it to a playback control sink.
- *
- * The bridge is always active: any gesture (drag or tap) drives the sink
- * immediately. There is no VOD-active gate — the timeline always drives
- * playback while frame-push mode is on.
- *
- * @param sink Always-active playback control surface (e.g. the datachannel)
- * @param isPlayerLive Synchronous getter for "is the player on the live
- *   edge?" — lets a live→recorded commit bypass dedupe so the seek always
- *   reaches the server.
- */
+* Owns the shared scrub position and bridges it to a playback control sink.
+*
+* The bridge is always active: any gesture (drag or tap) drives the sink
+* immediately. There is no VOD-active gate — the timeline always drives
+* playback while frame-push mode is on.
+*
+* @param sink Always-active playback control surface (e.g. the datachannel)
+* @param isPlayerLive Synchronous getter for "is the player on the live
+*   edge?" — lets a live→recorded commit bypass dedupe so the seek always
+*   reaches the server.
+*/
 export declare function useScrubController(sink: PlaybackControlSink, isPlayerLive?: () => boolean): ScrubController;
 export {};