@camstack/ui-library 1.2.256 → 1.2.258

package/dist/composites/stream-panel.d.ts

@@ -1,212 +1,223 @@
-import { ReactNode } from 'react';
-import { CamProfile, WebrtcSessionDebug, StationaryOverlayBox } from '@camstack/types';
-import { ApplyDownlinkProbe } from './adaptive-downlink';
-import { SignalingResult, ClientOfferResult, ClientStreamHints, SessionSignalingState } from './camera-stream-player';
-import { DeviceDetections } from '../hooks/use-device-detections';
 /**
- * Discriminated WebRTC target — same shape as the backend cap. The
- * `profile` tier uses the canonical `CamProfile` enum.
- */
+* StreamPanel — unified camera stream viewer with header bar, overlay toggles,
+* stream selector, pipeline phase, play/stop, and snapshot preview.
+*
+* Combines features from LiveStreamViewer (admin-ui) and PipelineTab (benchmark)
+* into a single reusable component in ui-library.
+*
+* The component is data-agnostic: callers fetch devices/streams/detections using
+* their own hooks and pass the results as props.
+*/
+import { type ReactNode, type JSX } from "react";
+import type { CamProfile, WebrtcSessionDebug } from "@camstack/types";
+import type { ApplyDownlinkProbe } from "./adaptive-downlink";
+import { type SignalingResult, type ClientOfferResult, type ClientStreamHints, type SessionSignalingState } from "./camera-stream-player";
+import type { DeviceDetections } from "../hooks/use-device-detections";
+import type { StationaryOverlayBox } from "@camstack/types";
+/**
+* Discriminated WebRTC target — same shape as the backend cap. The
+* `profile` tier uses the canonical `CamProfile` enum.
+*/
 export type StreamChoiceTarget = {
-    readonly kind: 'adaptive';
+	readonly kind: "adaptive";
 } | {
-    readonly kind: 'profile';
-    readonly profile: CamProfile;
+	readonly kind: "profile";
+	readonly profile: CamProfile;
 } | {
-    readonly kind: 'cam-stream';
-    readonly camStreamId: string;
+	readonly kind: "cam-stream";
+	readonly camStreamId: string;
 };
 export interface StreamChoice {
-    /**
-     * Stable identifier for React keys, dropdown values, and the
-     * player's `streamKey` prop. Opaque to the panel — typical values:
-     * `'adaptive'`, `'profile:high'`, `'stream:native:main'`.
-     */
-    readonly id: string;
-    /** Display label (e.g. "Adaptive", "HIGH (3840×2160)", "Native main"). */
-    readonly label: string;
-    /** Structured WebRTC target — passed verbatim to `createSession`. */
-    readonly target: StreamChoiceTarget;
-    /** Live broker status (null if unavailable). */
-    readonly status?: string | null;
-    /** Input FPS from camera (null if unavailable). */
-    readonly inputFps?: number | null;
-    /** Bitrate in kbps (null if unavailable). */
-    readonly bitrateKbps?: number | null;
+	/**
+	* Stable identifier for React keys, dropdown values, and the
+	* player's `streamKey` prop. Opaque to the panel — typical values:
+	* `'adaptive'`, `'profile:high'`, `'stream:native:main'`.
+	*/
+	readonly id: string;
+	/** Display label (e.g. "Adaptive", "HIGH (3840×2160)", "Native main"). */
+	readonly label: string;
+	/** Structured WebRTC target — passed verbatim to `createSession`. */
+	readonly target: StreamChoiceTarget;
+	/** Live broker status (null if unavailable). */
+	readonly status?: string | null;
+	/** Input FPS from camera (null if unavailable). */
+	readonly inputFps?: number | null;
+	/** Bitrate in kbps (null if unavailable). */
+	readonly bitrateKbps?: number | null;
 }
 export interface StreamStats {
-    readonly status: string;
-    readonly inputFps: number;
-    readonly uptimeMs: number;
+	readonly status: string;
+	readonly inputFps: number;
+	readonly uptimeMs: number;
 }
 export interface StreamPanelProps {
-    readonly serverUrl?: string;
-    readonly createSession?: (target: StreamChoiceTarget, hints?: ClientStreamHints) => Promise<SignalingResult>;
-    readonly sendAnswer?: (sessionId: string, sdpAnswer: string) => Promise<void>;
-    /**
-     * Client-offer signaling — PREFERRED over `createSession` for browsers.
-     * Closes over the selected target; the player builds the offer and this
-     * posts it. Lets iOS pass H.264 High/Main (incl. 4K) through untouched.
-     * Optional so non-browser callers (benchmark) can stay on server-offer.
-     */
-    readonly handleOffer?: (target: StreamChoiceTarget, sdpOffer: string, sessionId?: string) => Promise<ClientOfferResult>;
-    /** Browser-side ICE servers (STUN + TURN) for client-offer mode. */
-    readonly getIceServers?: () => Promise<readonly RTCIceServer[] | undefined>;
-    /** Trickle ICE — push a client candidate to the server (sessionId-scoped). */
-    readonly addIceCandidate?: (sessionId: string, candidate: RTCIceCandidateInit) => Promise<void>;
-    /** Trickle ICE — poll the server's gathered candidates (sessionId-scoped). */
-    readonly getIceCandidates?: (sessionId: string) => Promise<{
-        candidates: RTCIceCandidateInit[];
-        done: boolean;
-    }>;
-    readonly closeSession?: (sessionId: string) => Promise<void>;
-    /**
-     * Poll a session's live signaling state (client-offer mode). A non-null
-     * `pendingRenegotiation` after an adaptive tier switch makes the player
-     * transparently re-offer on the same session. Optional — omit to disable
-     * adaptive re-offer (steady-state behaviour is unchanged).
-     */
-    readonly getSessionState?: (sessionId: string) => Promise<SessionSignalingState>;
-    /**
-     * The server half of the stream-debug overlay. Optional, and when it is
-     * absent the overlay SAYS so rather than showing an empty section — a panel
-     * that silently omits half its answer is worse than one that admits it.
-     */
-    readonly getSessionDebug?: (sessionId: string) => Promise<WebrtcSessionDebug>;
-    /** Hand the downlink probe to the live session (D733) — one session per open. */
-    readonly applyDownlinkProbe?: ApplyDownlinkProbe;
-    /**
-     * When set, the panel switches to VOD mode: it renders an `HlsVideo`
-     * over this master `.m3u8` URL INSTEAD of the live WebRTC player, and
-     * the live signaling props are ignored. Lets the same hero player show
-     * recordings/clips (driven by the Recording tab) without a second
-     * player. Clearing it returns the panel to live mode.
-     */
-    readonly playbackUrl?: string;
-    /**
-     * What {@link playbackUrl} is. Absent means `hls` — the recorder's manifest,
-     * which is what every caller passed before native clips existed. A vendor
-     * addon's own clip is `mp4` and the hero plays it as a plain media URL
-     * (D549 22); passing it as `hls` would hand an MP4 to a manifest parser.
-     */
-    readonly playbackFormat?: 'hls' | 'mp4';
-    /** Bearer token for the admin-gated data-plane playback route (optional). */
-    readonly playbackAuthToken?: string | null;
-    /**
-     * Short label for the clip/window being played — shown in the header in
-     * place of the stream selector while in VOD mode.
-     */
-    readonly playbackLabel?: string;
-    /**
-     * Invoked when the operator clicks the (re-purposed) play/stop button
-     * while in VOD mode. The caller clears its playback request to return
-     * the panel to the live stream.
-     */
-    readonly onExitPlayback?: () => void;
-    /** Available streams. If omitted or single entry, no dropdown shown. */
-    readonly streams?: readonly StreamChoice[];
-    /** Currently active StreamChoice id. Defaults to first stream. */
-    readonly activeStreamId?: string;
-    /** Called when user selects a different stream (StreamChoice id). */
-    readonly onStreamChange?: (id: string) => void;
-    readonly deviceName?: string;
-    /** Pipeline phase from useDeviceDetections (e.g. "active", "watching") */
-    readonly phase?: string;
-    /** Pipeline metrics from useDeviceWebrtc. If provided, overrides phase and adds detection fps. */
-    readonly pipelineMetrics?: {
-        phase: string;
-        detectionFps: number;
-        avgInferenceMs: number;
-    } | null;
-    /** Detection data from useDeviceDetections hook. If omitted, no overlays. */
-    readonly detections?: DeviceDetections;
-    /** The census for this camera, normalised — from the occupancy snapshot. The
-     *  panel is data-agnostic by design, so the caller fetches it; absent means
-     *  "not fetched", and the stationary layer then draws nothing rather than
-     *  claiming an empty lot. */
-    readonly stationaryObjects?: readonly StationaryOverlayBox[];
-    /** Initial state for detection overlay (default: true) */
-    readonly defaultShowDetections?: boolean;
-    /** Initial state for motion overlay (default: false) */
-    readonly defaultShowMotion?: boolean;
-    readonly streamStats?: StreamStats;
-    /** Auto-play on mount (default: true) */
-    readonly autoPlay?: boolean;
-    /** Show play/stop toggle + snapshot preview when stopped (default: false) */
-    readonly showPlayStop?: boolean;
-    /** Snapshot source URL (data: URI). Only used when showPlayStop=true. */
-    readonly snapshotSrc?: string | null;
-    /**
-     * Optional poster (snapshot data-URL) painted by the live `<video>` until
-     * its FIRST frame decodes — a cold-start fallback only. Independent of
-     * `snapshotSrc` (which is the play/stop preview). Caller-supplied; when
-     * omitted the video simply starts black until the first frame.
-     */
-    readonly posterUrl?: string;
-    /** Whether snapshot is currently loading */
-    readonly snapshotLoading?: boolean;
-    /** Callback to refresh snapshot */
-    readonly onRefreshSnapshot?: () => void;
-    /** Show stream stats in header (fps, uptime) (default: false) */
-    readonly showStreamStats?: boolean;
-    readonly children?: ReactNode;
-    /**
-     * Extra overlay node composited on top of the video, alongside the
-     * built-in detection overlay. Used by callers to layer device-scoped
-     * controls (PTZOverlay, AudioPTT, ...) without forking the panel.
-     */
-    readonly extraOverlay?: ReactNode;
-    /**
-     * Whether the device supports PTZ. When true, the header shows a
-     * "PTZ" toggle next to detect/motion.
-     */
-    readonly ptzAvailable?: boolean;
-    /**
-     * Controlled visibility of the PTZ overlay. Drives both the
-     * header button highlight and (combined with `ptzOverlay`) overlay
-     * rendering. Caller computes the final value (e.g. OR with an
-     * external "force on" surface like a floating PTZ panel) and
-     * passes it down here.
-     */
-    readonly ptzShown?: boolean;
-    /**
-     * Overlay rendered ON the live video when `ptzShown` is true.
-     * Typically a `<PTZOverlay controls={...} mode="overlay" />` from
-     * ui-library. Combined with `extraOverlay` in the player overlay
-     * slot — both render together when active.
-     */
-    readonly ptzOverlay?: ReactNode;
-    /**
-     * Notified when the user clicks the in-header PTZ toggle. The
-     * caller updates its source of truth for `ptzShown`. No-op if
-     * omitted (button stays inert).
-     */
-    readonly onPtzToggle?: () => void;
-    /**
-     * Whether the device supports two-way audio (intercom). When true,
-     * the header shows an "Intercom" toggle next to detect/motion that
-     * lets the operator open the floating intercom panel without leaving
-     * the stream view.
-     */
-    readonly intercomAvailable?: boolean;
-    /**
-     * Controlled visibility of the intercom panel — drives the button's
-     * highlight state. The caller (which owns the floating-panel state)
-     * passes `true` while its intercom panel is open.
-     */
-    readonly intercomShown?: boolean;
-    /**
-     * Notified when the user clicks the in-header intercom toggle. The
-     * caller flips its panel state. No-op if omitted (button inert).
-     */
-    readonly onIntercomToggle?: () => void;
-    /**
-     * When true, drops the panel's outer rounded card chrome (border,
-     * rounded corners, background). Use when embedding into another
-     * surface that already provides framing — e.g. the device-detail
-     * left-column hero where the panel is one row of a larger card.
-     */
-    readonly chromeless?: boolean;
-    readonly className?: string;
+	readonly serverUrl?: string;
+	readonly createSession?: (target: StreamChoiceTarget, hints?: ClientStreamHints) => Promise<SignalingResult>;
+	readonly sendAnswer?: (sessionId: string, sdpAnswer: string) => Promise<void>;
+	/**
+	* Client-offer signaling — PREFERRED over `createSession` for browsers.
+	* Closes over the selected target; the player builds the offer and this
+	* posts it. Lets iOS pass H.264 High/Main (incl. 4K) through untouched.
+	* Optional so non-browser callers (benchmark) can stay on server-offer.
+	*/
+	readonly handleOffer?: (target: StreamChoiceTarget, sdpOffer: string, sessionId?: string) => Promise<ClientOfferResult>;
+	/** Browser-side ICE servers (STUN + TURN) for client-offer mode. */
+	readonly getIceServers?: () => Promise<readonly RTCIceServer[] | undefined>;
+	/** Trickle ICE — push a client candidate to the server (sessionId-scoped). */
+	readonly addIceCandidate?: (sessionId: string, candidate: RTCIceCandidateInit) => Promise<void>;
+	/** Trickle ICE — poll the server's gathered candidates (sessionId-scoped). */
+	readonly getIceCandidates?: (sessionId: string) => Promise<{
+		candidates: RTCIceCandidateInit[];
+		done: boolean;
+	}>;
+	readonly closeSession?: (sessionId: string) => Promise<void>;
+	/**
+	* Poll a session's live signaling state (client-offer mode). A non-null
+	* `pendingRenegotiation` after an adaptive tier switch makes the player
+	* transparently re-offer on the same session. Optional — omit to disable
+	* adaptive re-offer (steady-state behaviour is unchanged).
+	*/
+	readonly getSessionState?: (sessionId: string) => Promise<SessionSignalingState>;
+	/**
+	* The server half of the stream-debug overlay. Optional, and when it is
+	* absent the overlay SAYS so rather than showing an empty section — a panel
+	* that silently omits half its answer is worse than one that admits it.
+	*/
+	readonly getSessionDebug?: (sessionId: string) => Promise<WebrtcSessionDebug>;
+	/** Hand the downlink probe to the live session (D733) — one session per open. */
+	readonly applyDownlinkProbe?: ApplyDownlinkProbe;
+	/**
+	* When set, the panel switches to VOD mode: it renders an `HlsVideo`
+	* over this master `.m3u8` URL INSTEAD of the live WebRTC player, and
+	* the live signaling props are ignored. Lets the same hero player show
+	* recordings/clips (driven by the Recording tab) without a second
+	* player. Clearing it returns the panel to live mode.
+	*/
+	readonly playbackUrl?: string;
+	/**
+	* What {@link playbackUrl} is. Absent means `hls` — the recorder's manifest,
+	* which is what every caller passed before native clips existed. A vendor
+	* addon's own clip is `mp4` and the hero plays it as a plain media URL
+	* (D549 22); passing it as `hls` would hand an MP4 to a manifest parser.
+	*/
+	readonly playbackFormat?: "hls" | "mp4";
+	/** Bearer token for the admin-gated data-plane playback route (optional). */
+	readonly playbackAuthToken?: string | null;
+	/**
+	* Short label for the clip/window being played — shown in the header in
+	* place of the stream selector while in VOD mode.
+	*/
+	readonly playbackLabel?: string;
+	/**
+	* Invoked when the operator clicks the (re-purposed) play/stop button
+	* while in VOD mode. The caller clears its playback request to return
+	* the panel to the live stream.
+	*/
+	readonly onExitPlayback?: () => void;
+	/** Available streams. If omitted or single entry, no dropdown shown. */
+	readonly streams?: readonly StreamChoice[];
+	/** Currently active StreamChoice id. Defaults to first stream. */
+	readonly activeStreamId?: string;
+	/** Called when user selects a different stream (StreamChoice id). */
+	readonly onStreamChange?: (id: string) => void;
+	readonly deviceName?: string;
+	/** Pipeline phase from useDeviceDetections (e.g. "active", "watching") */
+	readonly phase?: string;
+	/** Pipeline metrics from useDeviceWebrtc. If provided, overrides phase and adds detection fps. */
+	readonly pipelineMetrics?: {
+		phase: string;
+		detectionFps: number;
+		avgInferenceMs: number;
+	} | null;
+	/** Detection data from useDeviceDetections hook. If omitted, no overlays. */
+	readonly detections?: DeviceDetections;
+	/** The census for this camera, normalised — from the occupancy snapshot. The
+	*  panel is data-agnostic by design, so the caller fetches it; absent means
+	*  "not fetched", and the stationary layer then draws nothing rather than
+	*  claiming an empty lot. */
+	readonly stationaryObjects?: readonly StationaryOverlayBox[];
+	/** Initial state for detection overlay (default: true) */
+	readonly defaultShowDetections?: boolean;
+	/** Initial state for motion overlay (default: false) */
+	readonly defaultShowMotion?: boolean;
+	readonly streamStats?: StreamStats;
+	/** Auto-play on mount (default: true) */
+	readonly autoPlay?: boolean;
+	/** Show play/stop toggle + snapshot preview when stopped (default: false) */
+	readonly showPlayStop?: boolean;
+	/** Snapshot source URL (data: URI). Only used when showPlayStop=true. */
+	readonly snapshotSrc?: string | null;
+	/**
+	* Optional poster (snapshot data-URL) painted by the live `<video>` until
+	* its FIRST frame decodes — a cold-start fallback only. Independent of
+	* `snapshotSrc` (which is the play/stop preview). Caller-supplied; when
+	* omitted the video simply starts black until the first frame.
+	*/
+	readonly posterUrl?: string;
+	/** Whether snapshot is currently loading */
+	readonly snapshotLoading?: boolean;
+	/** Callback to refresh snapshot */
+	readonly onRefreshSnapshot?: () => void;
+	/** Show stream stats in header (fps, uptime) (default: false) */
+	readonly showStreamStats?: boolean;
+	readonly children?: ReactNode;
+	/**
+	* Extra overlay node composited on top of the video, alongside the
+	* built-in detection overlay. Used by callers to layer device-scoped
+	* controls (PTZOverlay, AudioPTT, ...) without forking the panel.
+	*/
+	readonly extraOverlay?: ReactNode;
+	/**
+	* Whether the device supports PTZ. When true, the header shows a
+	* "PTZ" toggle next to detect/motion.
+	*/
+	readonly ptzAvailable?: boolean;
+	/**
+	* Controlled visibility of the PTZ overlay. Drives both the
+	* header button highlight and (combined with `ptzOverlay`) overlay
+	* rendering. Caller computes the final value (e.g. OR with an
+	* external "force on" surface like a floating PTZ panel) and
+	* passes it down here.
+	*/
+	readonly ptzShown?: boolean;
+	/**
+	* Overlay rendered ON the live video when `ptzShown` is true.
+	* Typically a `<PTZOverlay controls={...} mode="overlay" />` from
+	* ui-library. Combined with `extraOverlay` in the player overlay
+	* slot — both render together when active.
+	*/
+	readonly ptzOverlay?: ReactNode;
+	/**
+	* Notified when the user clicks the in-header PTZ toggle. The
+	* caller updates its source of truth for `ptzShown`. No-op if
+	* omitted (button stays inert).
+	*/
+	readonly onPtzToggle?: () => void;
+	/**
+	* Whether the device supports two-way audio (intercom). When true,
+	* the header shows an "Intercom" toggle next to detect/motion that
+	* lets the operator open the floating intercom panel without leaving
+	* the stream view.
+	*/
+	readonly intercomAvailable?: boolean;
+	/**
+	* Controlled visibility of the intercom panel — drives the button's
+	* highlight state. The caller (which owns the floating-panel state)
+	* passes `true` while its intercom panel is open.
+	*/
+	readonly intercomShown?: boolean;
+	/**
+	* Notified when the user clicks the in-header intercom toggle. The
+	* caller flips its panel state. No-op if omitted (button inert).
+	*/
+	readonly onIntercomToggle?: () => void;
+	/**
+	* When true, drops the panel's outer rounded card chrome (border,
+	* rounded corners, background). Use when embedding into another
+	* surface that already provides framing — e.g. the device-detail
+	* left-column hero where the panel is one row of a larger card.
+	*/
+	readonly chromeless?: boolean;
+	readonly className?: string;
 }
-export declare function StreamPanel({ serverUrl, createSession, sendAnswer, handleOffer, getIceServers, addIceCandidate, getIceCandidates, closeSession, getSessionState, getSessionDebug, applyDownlinkProbe, playbackUrl, playbackFormat, playbackAuthToken, onExitPlayback, posterUrl, streams, activeStreamId: controlledStreamId, onStreamChange, deviceName, phase, pipelineMetrics, detections, stationaryObjects, defaultShowDetections, defaultShowMotion, streamStats, autoPlay, showPlayStop, snapshotSrc, snapshotLoading, onRefreshSnapshot, showStreamStats, children, extraOverlay, ptzAvailable, ptzShown, ptzOverlay, onPtzToggle, intercomAvailable, intercomShown, onIntercomToggle, chromeless, className, }: StreamPanelProps): import("react").JSX.Element;
+export declare function StreamPanel({ serverUrl, createSession, sendAnswer, handleOffer, getIceServers, addIceCandidate, getIceCandidates, closeSession, getSessionState, getSessionDebug, applyDownlinkProbe, playbackUrl, playbackFormat, playbackAuthToken, onExitPlayback, posterUrl, streams, activeStreamId: controlledStreamId, onStreamChange, deviceName, phase, pipelineMetrics, detections, stationaryObjects, defaultShowDetections, defaultShowMotion, streamStats, autoPlay, showPlayStop, snapshotSrc, snapshotLoading, onRefreshSnapshot, showStreamStats, children, extraOverlay, ptzAvailable, ptzShown, ptzOverlay, onPtzToggle, intercomAvailable, intercomShown, onIntercomToggle, chromeless, className }: StreamPanelProps): JSX.Element;

package/dist/composites/table-sort.d.ts

@@ -1,77 +1,77 @@
 /**
- * Column sorting for {@link DataTable} — the ONE sort model in this library.
- *
- * The device list had the only column sort in the app
- * (`composites/device-list/sort.ts`), typed to `DeviceItemDevice` and to three
- * hard-coded column ids. Every other table in the admin UI was unsorted. This
- * module is that same behaviour, generic: `DataTable` owns the state, a column
- * opts in by declaring `sortValue`, and `device-list` keeps its domain
- * comparators while delegating the toggle here. There is no second sort.
- *
- * The three rules are inherited verbatim from the device list, because they
- * were argued there and they are the reason a sorted table stays readable:
- *
- *  1. **`null` sorts LAST in both directions.** A missing value is "unknown",
- *     not a value to reverse. Flipping the direction must never promote the
- *     rows that have nothing to say to the top.
- *  2. **Stable.** `Array.prototype.toSorted` is stable in every runtime we
- *     ship to, so rows with an equal key keep the order they arrived in —
- *     which is usually a meaningful order already (topology order, insertion
- *     order).
- *  3. **Immutable.** The input array is never touched; a `null` sort returns a
- *     fresh copy in the incoming order.
- *
- * A column with no `sortValue` renders a plain static header and can never be
- * clicked. That is deliberate and it is the point of `notSortableReason`: a
- * composite cell (a list of capabilities, an argv blob, an interactive
- * control) has no single value to order by, and inventing one — "by count",
- * "alphabetically by full path" — produces an ordering that looks
- * authoritative and means nothing.
- */
+* Column sorting for {@link DataTable} — the ONE sort model in this library.
+*
+* The device list had the only column sort in the app
+* (`composites/device-list/sort.ts`), typed to `DeviceItemDevice` and to three
+* hard-coded column ids. Every other table in the admin UI was unsorted. This
+* module is that same behaviour, generic: `DataTable` owns the state, a column
+* opts in by declaring `sortValue`, and `device-list` keeps its domain
+* comparators while delegating the toggle here. There is no second sort.
+*
+* The three rules are inherited verbatim from the device list, because they
+* were argued there and they are the reason a sorted table stays readable:
+*
+*  1. **`null` sorts LAST in both directions.** A missing value is "unknown",
+*     not a value to reverse. Flipping the direction must never promote the
+*     rows that have nothing to say to the top.
+*  2. **Stable.** `Array.prototype.toSorted` is stable in every runtime we
+*     ship to, so rows with an equal key keep the order they arrived in —
+*     which is usually a meaningful order already (topology order, insertion
+*     order).
+*  3. **Immutable.** The input array is never touched; a `null` sort returns a
+*     fresh copy in the incoming order.
+*
+* A column with no `sortValue` renders a plain static header and can never be
+* clicked. That is deliberate and it is the point of `notSortableReason`: a
+* composite cell (a list of capabilities, an argv blob, an interactive
+* control) has no single value to order by, and inventing one — "by count",
+* "alphabetically by full path" — produces an ordering that looks
+* authoritative and means nothing.
+*/
 /** Sort direction. There is no third state on the column; "unsorted" is the
- *  absence of a {@link TableSortState}. */
-export type TableSortDirection = 'asc' | 'desc';
+*  absence of a {@link TableSortState}. */
+export type TableSortDirection = "asc" | "desc";
 /** The table's single active sort. `null` at the table level = incoming order. */
 export interface TableSortState {
-    /** `DataColumn.key` of the sorted column. */
-    readonly columnKey: string;
-    readonly dir: TableSortDirection;
+	/** `DataColumn.key` of the sorted column. */
+	readonly columnKey: string;
+	readonly dir: TableSortDirection;
 }
 /**
- * What a sortable column contributes for one row.
- *
- * `null` means "this row has no value for this column" and always sorts last
- * (rule 1). It is NOT the same as `0` or `''`, which are values and sort
- * normally.
- */
+* What a sortable column contributes for one row.
+*
+* `null` means "this row has no value for this column" and always sorts last
+* (rule 1). It is NOT the same as `0` or `''`, which are values and sort
+* normally.
+*/
 export type TableSortValue = string | number | null;
 /**
- * The toggle rule, and the only copy of it.
- *
- * none → asc → desc → none, and a click on a DIFFERENT column starts that
- * column fresh at `asc`. `sameColumn` says whether the clicked column is the
- * one currently sorted; `currentDir` is its direction (`null` when nothing is
- * sorted). Returns the next direction, or `null` for "unsorted".
- *
- * Split out from {@link nextTableSort} so the device list — whose sort state
- * keys columns by `columnId`, not `columnKey` — can reuse the rule without a
- * cast and without a second copy of it.
- */
+* The toggle rule, and the only copy of it.
+*
+* none → asc → desc → none, and a click on a DIFFERENT column starts that
+* column fresh at `asc`. `sameColumn` says whether the clicked column is the
+* one currently sorted; `currentDir` is its direction (`null` when nothing is
+* sorted). Returns the next direction, or `null` for "unsorted".
+*
+* Split out from {@link nextTableSort} so the device list — whose sort state
+* keys columns by `columnId`, not `columnKey` — can reuse the rule without a
+* cast and without a second copy of it.
+*/
 export declare function nextSortDirection(sameColumn: boolean, currentDir: TableSortDirection | null): TableSortDirection | null;
 /**
- * Toggle a column's sort on header click: none → asc → desc → none.
- * Clicking a DIFFERENT column starts it fresh at `asc`.
- */
+* Toggle a column's sort on header click: none → asc → desc → none.
+* Clicking a DIFFERENT column starts it fresh at `asc`.
+*/
 export declare function nextTableSort(current: TableSortState | null, columnKey: string): TableSortState | null;
 /**
- * Return a NEW array of `rows` ordered by `sort`.
- *
- * `valueOf` is the column's `sortValue` — it is called once per row per
- * comparison, so it must be cheap (read a field, do not format a string).
- * `sort === null` ⇒ a fresh shallow copy in the incoming order.
- */
+* Return a NEW array of `rows` ordered by `sort`.
+*
+* `valueOf` is the column's `sortValue` — it is called once per row per
+* comparison, so it must be cheap (read a field, do not format a string).
+* `sort === null` ⇒ a fresh shallow copy in the incoming order.
+*/
 export declare function sortRowsByColumn<T>(rows: readonly T[], sort: TableSortState | null, valueOf: (row: T) => TableSortValue): readonly T[];
 /** The `aria-sort` value WAI-ARIA scopes to a `<th>` (never to an inner control). */
-export type AriaSortValue = 'ascending' | 'descending' | 'none';
+export type AriaSortValue = "ascending" | "descending" | "none";
 /** Derive the `<th>` `aria-sort` for `columnKey` from the table's sort state. */
 export declare function ariaSortForColumn(sort: TableSortState | null, columnKey: string): AriaSortValue;

package/dist/composites/timezone-selector.d.ts

@@ -1,18 +1,20 @@
-import { TIMEZONES, findTimezone, Timezone, TimezoneDstRule, Weekday } from '@camstack/types';
+import { TIMEZONES, findTimezone } from "@camstack/types";
+import type { Timezone, TimezoneDstRule, Weekday } from "@camstack/types";
+import { type JSX } from "react";
 export { TIMEZONES, findTimezone };
 export type { Timezone, TimezoneDstRule, Weekday };
 export interface TimezoneSelectorProps {
-    /** Currently selected IANA id (e.g. 'Europe/Rome'). */
-    readonly value: string;
-    /** Fired with the newly chosen IANA id. */
-    readonly onChange: (id: string) => void;
-    readonly disabled?: boolean;
+	/** Currently selected IANA id (e.g. 'Europe/Rome'). */
+	readonly value: string;
+	/** Fired with the newly chosen IANA id. */
+	readonly onChange: (id: string) => void;
+	readonly disabled?: boolean;
 }
 /**
- * Friendly timezone picker. Renders a native `<select>` grouped by
- * region via `<optgroup>`, sourced from the curated `TIMEZONES`
- * catalogue. The selected value is the IANA id; DST is implied by the
- * chosen zone (each option carries its standard offset + DST rule),
- * so there is no separate DST control.
- */
-export declare function TimezoneSelector({ value, onChange, disabled }: TimezoneSelectorProps): import("react").JSX.Element;
+* Friendly timezone picker. Renders a native `<select>` grouped by
+* region via `<optgroup>`, sourced from the curated `TIMEZONES`
+* catalogue. The selected value is the IANA id; DST is implied by the
+* chosen zone (each option carries its standard offset + DST rule),
+* so there is no separate DST control.
+*/
+export declare function TimezoneSelector({ value, onChange, disabled }: TimezoneSelectorProps): JSX.Element;

package/dist/composites/training/send-frame-to-training.d.ts

@@ -1,6 +1,7 @@
+import { type JSX } from "react";
 export interface SendFrameToTrainingButtonProps {
-    readonly deviceId: number;
-    /** The playhead instant, or `null` while nothing is being played back. */
-    readonly epochMs: number | null;
+	readonly deviceId: number;
+	/** The playhead instant, or `null` while nothing is being played back. */
+	readonly epochMs: number | null;
 }
-export declare function SendFrameToTrainingButton({ deviceId, epochMs }: SendFrameToTrainingButtonProps): import("react").JSX.Element | null;
+export declare function SendFrameToTrainingButton({ deviceId, epochMs }: SendFrameToTrainingButtonProps): JSX.Element | null;

package/dist/composites/training/training-collection-picker.d.ts

@@ -1,5 +1,6 @@
+import { type JSX } from "react";
 export interface TrainingCollectionPickerProps {
-    readonly value: string | null;
-    readonly onChange: (collectionId: string) => void;
+	readonly value: string | null;
+	readonly onChange: (collectionId: string) => void;
 }
-export declare function TrainingCollectionPicker({ value, onChange }: TrainingCollectionPickerProps): import("react").JSX.Element;
+export declare function TrainingCollectionPicker({ value, onChange }: TrainingCollectionPickerProps): JSX.Element;