@camstack/ui-library 1.2.256 → 1.2.258

package/dist/hooks/use-device-webrtc.d.ts

@@ -1,229 +1,235 @@
-import { CamProfile, WebrtcSessionDebug } from '@camstack/types';
-import { StreamChoice } from '../composites/stream-panel';
-import { ClientStreamHints, SignalingResult, ClientOfferResult } from '../composites/camera-stream-player';
-import { ApplyDownlinkProbe, DownlinkProbeAnswer } from '../composites/adaptive-downlink';
+import type { CamProfile, WebrtcSessionDebug } from "@camstack/types";
+import type { StreamChoice } from "../composites/stream-panel";
+import type { ClientStreamHints, SignalingResult, ClientOfferResult } from "../composites/camera-stream-player";
+import type { ApplyDownlinkProbe, DownlinkProbeAnswer } from "../composites/adaptive-downlink";
 /**
- * Discriminated WebRTC target — same shape as `WebrtcStreamTarget` on
- * the backend cap. The `profile` tier uses the canonical `CamProfile`
- * enum so an invalid tier is a compile error.
- */
+* Discriminated WebRTC target — same shape as `WebrtcStreamTarget` on
+* the backend cap. The `profile` tier uses the canonical `CamProfile`
+* enum so an invalid tier is a compile error.
+*/
 export type WebrtcTarget = {
-    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;
 };
 /** Mutation call shape: `.mutate(input)` → Promise. */
-interface MutateFn<I, O> {
-    mutate(input: I): Promise<O>;
+interface MutateFn<
+	I,
+	O
+> {
+	mutate(input: I): Promise<O>;
 }
 /** Query call shape: `.query(input?)` → Promise. */
-interface QueryFn<I, O> {
-    query(input: I): Promise<O>;
+interface QueryFn<
+	I,
+	O
+> {
+	query(input: I): Promise<O>;
 }
 interface StreamChoiceRow {
-    readonly id: string;
-    readonly label: string;
-    readonly target: WebrtcTarget;
-    readonly codec: string | null;
-    readonly resolution: {
-        width: number;
-        height: number;
-    } | null;
-    readonly status: string | null;
-    readonly inputFps: number | null;
-    readonly bitrateKbps: number | null;
+	readonly id: string;
+	readonly label: string;
+	readonly target: WebrtcTarget;
+	readonly codec: string | null;
+	readonly resolution: {
+		width: number;
+		height: number;
+	} | null;
+	readonly status: string | null;
+	readonly inputFps: number | null;
+	readonly bitrateKbps: number | null;
 }
 /**
- * Minimal subset of the tRPC proxy needed for WebRTC signaling.
- * Both `BackendClient.trpc` and `AddonPageProps['trpc']` satisfy this
- * at runtime.
- */
+* Minimal subset of the tRPC proxy needed for WebRTC signaling.
+* Both `BackendClient.trpc` and `AddonPageProps['trpc']` satisfy this
+* at runtime.
+*/
 export interface UseDeviceWebrtcTrpc {
-    webrtcSession: {
-        listStreams: QueryFn<{
-            deviceId: number;
-        }, readonly StreamChoiceRow[]>;
-        createSession: MutateFn<{
-            deviceId: number;
-            target: WebrtcTarget;
-            hints?: ClientStreamHints;
-        }, {
-            sessionId: string;
-            sdpOffer: string;
-        }>;
-        /**
-         * Client-offer signaling: the browser builds the SDP offer (advertising
-         * its native decode caps) and the server answers. The dual of
-         * `createSession`; lets iOS pass H.264 High/Main through untouched.
-         */
-        handleOffer: MutateFn<{
-            deviceId: number;
-            target: WebrtcTarget;
-            sdpOffer: string;
-            sessionId?: string;
-            hints?: ClientStreamHints;
-        }, {
-            sessionId: string;
-            sdpAnswer: string;
-        }>;
-        handleAnswer: MutateFn<{
-            deviceId: number;
-            sessionId: string;
-            sdpAnswer: string;
-        }, void>;
-        /** Trickle ICE — push a client candidate to the server. */
-        addIceCandidate: MutateFn<{
-            deviceId: number;
-            sessionId: string;
-            candidate: string;
-            sdpMid?: string | null;
-            sdpMLineIndex?: number | null;
-        }, void>;
-        /** Trickle ICE — poll the server's gathered candidates. */
-        getIceCandidates: QueryFn<{
-            deviceId: number;
-            sessionId: string;
-        }, {
-            candidates: {
-                candidate: string;
-                sdpMid: string | null;
-                sdpMLineIndex: number | null;
-            }[];
-            done: boolean;
-        }>;
-        closeSession: MutateFn<{
-            deviceId: number;
-            sessionId: string;
-        }, void>;
-        /**
-         * Poll the live signaling state of a session. `pendingRenegotiation`
-         * is non-null after the server swaps the broker source to a different
-         * tier (adaptive downgrade) — the client must re-offer on the same
-         * `sessionId`; `epoch` guards against acting on a stale poll twice.
-         */
-        getSessionState: QueryFn<{
-            deviceId: number;
-            sessionId: string;
-        }, {
-            pendingRenegotiation: {
-                target: WebrtcTarget;
-                epoch: number;
-            } | null;
-        }>;
-        /** The SERVER's account of a live session, for the stream-debug overlay.
-         *  Read-only; the overlay polls it at ~1 Hz only while it is visible. */
-        getSessionDebug: QueryFn<{
-            deviceId: number;
-            sessionId: string;
-        }, WebrtcSessionDebug>;
-        /**
-         * Hand the viewer's downlink probe to ONE live session (D733). Optional:
-         * a hub built before it has no such route, and the player then keeps its
-         * legacy probe climb (a second session).
-         */
-        applyDownlinkProbe?: MutateFn<{
-            deviceId: number;
-            sessionId: string;
-            downlinkMbps: number;
-        }, DownlinkProbeAnswer>;
-    };
-    pipelineOrchestrator?: {
-        getCameraMetrics: QueryFn<{
-            deviceId: number;
-        }, {
-            phase: string;
-            actualFps: number;
-            avgInferenceTimeMs: number;
-            droppedFrames: number;
-            configuredFps: number;
-        } | null>;
-    };
-    /** Optional: aggregated STUN/TURN servers (e.g. cloudflare-turn). When
-     *  present, the client uses them so it can gather a reachable relay
-     *  candidate for remote (CGNAT/mobile) viewing. */
-    turnProvider?: {
-        getTurnServers: QueryFn<void, readonly {
-            urls: string | readonly string[];
-            username?: string;
-            credential?: string;
-        }[]>;
-    };
+	webrtcSession: {
+		listStreams: QueryFn<{
+			deviceId: number;
+		}, readonly StreamChoiceRow[]>;
+		createSession: MutateFn<{
+			deviceId: number;
+			target: WebrtcTarget;
+			hints?: ClientStreamHints;
+		}, {
+			sessionId: string;
+			sdpOffer: string;
+		}>;
+		/**
+		* Client-offer signaling: the browser builds the SDP offer (advertising
+		* its native decode caps) and the server answers. The dual of
+		* `createSession`; lets iOS pass H.264 High/Main through untouched.
+		*/
+		handleOffer: MutateFn<{
+			deviceId: number;
+			target: WebrtcTarget;
+			sdpOffer: string;
+			sessionId?: string;
+			hints?: ClientStreamHints;
+		}, {
+			sessionId: string;
+			sdpAnswer: string;
+		}>;
+		handleAnswer: MutateFn<{
+			deviceId: number;
+			sessionId: string;
+			sdpAnswer: string;
+		}, void>;
+		/** Trickle ICE — push a client candidate to the server. */
+		addIceCandidate: MutateFn<{
+			deviceId: number;
+			sessionId: string;
+			candidate: string;
+			sdpMid?: string | null;
+			sdpMLineIndex?: number | null;
+		}, void>;
+		/** Trickle ICE — poll the server's gathered candidates. */
+		getIceCandidates: QueryFn<{
+			deviceId: number;
+			sessionId: string;
+		}, {
+			candidates: {
+				candidate: string;
+				sdpMid: string | null;
+				sdpMLineIndex: number | null;
+			}[];
+			done: boolean;
+		}>;
+		closeSession: MutateFn<{
+			deviceId: number;
+			sessionId: string;
+		}, void>;
+		/**
+		* Poll the live signaling state of a session. `pendingRenegotiation`
+		* is non-null after the server swaps the broker source to a different
+		* tier (adaptive downgrade) — the client must re-offer on the same
+		* `sessionId`; `epoch` guards against acting on a stale poll twice.
+		*/
+		getSessionState: QueryFn<{
+			deviceId: number;
+			sessionId: string;
+		}, {
+			pendingRenegotiation: {
+				target: WebrtcTarget;
+				epoch: number;
+			} | null;
+		}>;
+		/** The SERVER's account of a live session, for the stream-debug overlay.
+		*  Read-only; the overlay polls it at ~1 Hz only while it is visible. */
+		getSessionDebug: QueryFn<{
+			deviceId: number;
+			sessionId: string;
+		}, WebrtcSessionDebug>;
+		/**
+		* Hand the viewer's downlink probe to ONE live session (D733). Optional:
+		* a hub built before it has no such route, and the player then keeps its
+		* legacy probe climb (a second session).
+		*/
+		applyDownlinkProbe?: MutateFn<{
+			deviceId: number;
+			sessionId: string;
+			downlinkMbps: number;
+		}, DownlinkProbeAnswer>;
+	};
+	pipelineOrchestrator?: {
+		getCameraMetrics: QueryFn<{
+			deviceId: number;
+		}, {
+			phase: string;
+			actualFps: number;
+			avgInferenceTimeMs: number;
+			droppedFrames: number;
+			configuredFps: number;
+		} | null>;
+	};
+	/** Optional: aggregated STUN/TURN servers (e.g. cloudflare-turn). When
+	*  present, the client uses them so it can gather a reachable relay
+	*  candidate for remote (CGNAT/mobile) viewing. */
+	turnProvider?: {
+		getTurnServers: QueryFn<void, readonly {
+			urls: string | readonly string[];
+			username?: string;
+			credential?: string;
+		}[]>;
+	};
 }
 /** Pipeline detection metrics for a device. */
 export interface DevicePipelineMetrics {
-    readonly phase: string;
-    readonly detectionFps: number;
-    readonly avgInferenceMs: number;
-    readonly droppedFrames: number;
+	readonly phase: string;
+	readonly detectionFps: number;
+	readonly avgInferenceMs: number;
+	readonly droppedFrames: number;
 }
 export interface DeviceWebrtcResult {
-    /** Available stream choices for the dropdown (Adaptive + assigned profiles). */
-    readonly streams: readonly StreamChoice[];
-    /** Whether the device has at least one assigned profile (can stream). */
-    readonly hasWebrtc: boolean;
-    /** Live pipeline metrics (phase, detection fps, inference time). */
-    readonly pipelineMetrics: DevicePipelineMetrics | null;
-    /** Server-offer signaling: create a WebRTC session. */
-    readonly createSession: (target: WebrtcTarget, hints?: ClientStreamHints) => Promise<SignalingResult>;
-    /** Server-offer signaling: send the client's SDP answer. */
-    readonly sendAnswer: (sessionId: string, sdpAnswer: string) => Promise<void>;
-    /**
-     * Client-offer signaling (preferred for browsers): post a browser-built
-     * SDP offer and get the server's answer. The browser advertises its full
-     * H.264 decode caps in the offer, so a Main/High (incl. 4K) source passes
-     * through with no transcode — the only path that lets iOS decode High.
-     */
-    readonly handleOffer: (target: WebrtcTarget, sdpOffer: string, sessionId?: string, hints?: ClientStreamHints) => Promise<ClientOfferResult>;
-    /**
-     * Fetch the browser-side ICE servers (STUN + TURN from the `turn-provider`
-     * cap). Needed for client-offer mode, where the PeerConnection must be
-     * built with TURN BEFORE the offer is created so a remote/CGNAT viewer can
-     * gather a relay candidate. Best-effort — resolves `undefined` on failure
-     * (the player falls back to public STUN).
-     */
-    readonly getIceServers: () => Promise<readonly RTCIceServer[] | undefined>;
-    /** Trickle ICE — push a client-gathered candidate to the server. */
-    readonly addIceCandidate: (sessionId: string, candidate: RTCIceCandidateInit) => Promise<void>;
-    /** Trickle ICE — poll the server's gathered candidates for a session. */
-    readonly getIceCandidates: (sessionId: string) => Promise<{
-        candidates: RTCIceCandidateInit[];
-        done: boolean;
-    }>;
-    /** Close a WebRTC session on the server. */
-    readonly closeSession: (sessionId: string) => Promise<void>;
-    /**
-     * Poll the live signaling state of a session. After an adaptive tier
-     * switch the server returns a non-null `pendingRenegotiation` (the new
-     * target + a monotonic `epoch`); the player re-offers on the SAME
-     * `sessionId` so the session re-negotiates against the new tier. Returns
-     * `{ pendingRenegotiation: null }` for non-adaptive / steady sessions.
-     */
-    readonly getSessionState: (sessionId: string) => Promise<SessionRenegotiationState>;
-    /**
-     * The SERVER half of the stream-debug overlay for a session. Unlike
-     * `getSessionState`, a failure here THROWS rather than resolving a benign
-     * default: this is a diagnostic read, and a swallowed error would render as
-     * a confident set of unknowns with no reason attached. The overlay catches
-     * it and shows the message.
-     */
-    readonly getSessionDebug: (sessionId: string) => Promise<WebrtcSessionDebug>;
-    /**
-     * Hand the downlink probe to the session it was measured on (D733). Rejects
-     * when there is no device or the hub has no such method — the player reads
-     * a rejection as "unsupported" and falls back to its legacy climb.
-     */
-    readonly applyDownlinkProbe: ApplyDownlinkProbe;
+	/** Available stream choices for the dropdown (Adaptive + assigned profiles). */
+	readonly streams: readonly StreamChoice[];
+	/** Whether the device has at least one assigned profile (can stream). */
+	readonly hasWebrtc: boolean;
+	/** Live pipeline metrics (phase, detection fps, inference time). */
+	readonly pipelineMetrics: DevicePipelineMetrics | null;
+	/** Server-offer signaling: create a WebRTC session. */
+	readonly createSession: (target: WebrtcTarget, hints?: ClientStreamHints) => Promise<SignalingResult>;
+	/** Server-offer signaling: send the client's SDP answer. */
+	readonly sendAnswer: (sessionId: string, sdpAnswer: string) => Promise<void>;
+	/**
+	* Client-offer signaling (preferred for browsers): post a browser-built
+	* SDP offer and get the server's answer. The browser advertises its full
+	* H.264 decode caps in the offer, so a Main/High (incl. 4K) source passes
+	* through with no transcode — the only path that lets iOS decode High.
+	*/
+	readonly handleOffer: (target: WebrtcTarget, sdpOffer: string, sessionId?: string, hints?: ClientStreamHints) => Promise<ClientOfferResult>;
+	/**
+	* Fetch the browser-side ICE servers (STUN + TURN from the `turn-provider`
+	* cap). Needed for client-offer mode, where the PeerConnection must be
+	* built with TURN BEFORE the offer is created so a remote/CGNAT viewer can
+	* gather a relay candidate. Best-effort — resolves `undefined` on failure
+	* (the player falls back to public STUN).
+	*/
+	readonly getIceServers: () => Promise<readonly RTCIceServer[] | undefined>;
+	/** Trickle ICE — push a client-gathered candidate to the server. */
+	readonly addIceCandidate: (sessionId: string, candidate: RTCIceCandidateInit) => Promise<void>;
+	/** Trickle ICE — poll the server's gathered candidates for a session. */
+	readonly getIceCandidates: (sessionId: string) => Promise<{
+		candidates: RTCIceCandidateInit[];
+		done: boolean;
+	}>;
+	/** Close a WebRTC session on the server. */
+	readonly closeSession: (sessionId: string) => Promise<void>;
+	/**
+	* Poll the live signaling state of a session. After an adaptive tier
+	* switch the server returns a non-null `pendingRenegotiation` (the new
+	* target + a monotonic `epoch`); the player re-offers on the SAME
+	* `sessionId` so the session re-negotiates against the new tier. Returns
+	* `{ pendingRenegotiation: null }` for non-adaptive / steady sessions.
+	*/
+	readonly getSessionState: (sessionId: string) => Promise<SessionRenegotiationState>;
+	/**
+	* The SERVER half of the stream-debug overlay for a session. Unlike
+	* `getSessionState`, a failure here THROWS rather than resolving a benign
+	* default: this is a diagnostic read, and a swallowed error would render as
+	* a confident set of unknowns with no reason attached. The overlay catches
+	* it and shows the message.
+	*/
+	readonly getSessionDebug: (sessionId: string) => Promise<WebrtcSessionDebug>;
+	/**
+	* Hand the downlink probe to the session it was measured on (D733). Rejects
+	* when there is no device or the hub has no such method — the player reads
+	* a rejection as "unsupported" and falls back to its legacy climb.
+	*/
+	readonly applyDownlinkProbe: ApplyDownlinkProbe;
 }
 /** Live signaling state for a session — the adaptive re-offer signal. */
 export interface SessionRenegotiationState {
-    readonly pendingRenegotiation: {
-        readonly target: WebrtcTarget;
-        readonly epoch: number;
-    } | null;
+	readonly pendingRenegotiation: {
+		readonly target: WebrtcTarget;
+		readonly epoch: number;
+	} | null;
 }
 export declare function useDeviceWebrtc(trpc: UseDeviceWebrtcTrpc, deviceId: number | null, pollIntervalMs?: number): DeviceWebrtcResult;
 export {};

package/dist/hooks/use-devices.d.ts

@@ -1,13 +1,13 @@
-import { DeviceProxy, DeviceQueryFilters } from '@camstack/types';
+import type { DeviceProxy, DeviceQueryFilters } from "@camstack/types";
 /**
- * Reactive list of devices matching the optional filter set. Returns a
- * stable array reference between updates so consumers passing it as a
- * prop don't tear down memoized children.
- */
+* Reactive list of devices matching the optional filter set. Returns a
+* stable array reference between updates so consumers passing it as a
+* prop don't tear down memoized children.
+*/
 export declare function useDevices(filters?: DeviceQueryFilters): readonly DeviceProxy[];
 /**
- * Single-device variant. Returns `null` until the device is in the
- * mirror; re-renders when the device is removed (back to `null`) or
- * added.
- */
+* Single-device variant. Returns `null` until the device is in the
+* mirror; re-renders when the device is removed (back to `null`) or
+* added.
+*/
 export declare function useDevice(deviceId: number | null): DeviceProxy | null;

package/dist/hooks/use-doorbell-events.d.ts

@@ -1,20 +1,20 @@
 export interface DoorbellPressEvent {
-    readonly deviceId: number;
-    readonly timestamp: number;
+	readonly deviceId: number;
+	readonly timestamp: number;
 }
 export interface UseDoorbellEventsResult {
-    /** Most recent press, or null if none observed since mount. */
-    readonly latest: DoorbellPressEvent | null;
-    /** Recent presses, newest-first. Capped at `historyLimit`. */
-    readonly history: readonly DoorbellPressEvent[];
+	/** Most recent press, or null if none observed since mount. */
+	readonly latest: DoorbellPressEvent | null;
+	/** Recent presses, newest-first. Capped at `historyLimit`. */
+	readonly history: readonly DoorbellPressEvent[];
 }
 export interface UseDoorbellEventsOptions {
-    /**
-     * Scope the subscription to a specific deviceId. Pass `null` (or
-     * omit) to receive every press across the cluster.
-     */
-    readonly deviceId?: number | null;
-    /** Max history entries kept in memory. Defaults to 20. */
-    readonly historyLimit?: number;
+	/**
+	* Scope the subscription to a specific deviceId. Pass `null` (or
+	* omit) to receive every press across the cluster.
+	*/
+	readonly deviceId?: number | null;
+	/** Max history entries kept in memory. Defaults to 20. */
+	readonly historyLimit?: number;
 }
 export declare function useDoorbellEvents(options?: UseDoorbellEventsOptions): UseDoorbellEventsResult;

package/dist/hooks/use-event-stream.d.ts

@@ -1,5 +1,8 @@
 export declare function useEventStreamLatest<T>(category: string, filter?: (data: T) => boolean): T | null;
-export declare function useEventStreamMap<T, K extends string | number>(category: string, keyOf: (data: T) => K, filter?: (data: T) => boolean): {
-    readonly map: ReadonlyMap<K, T>;
-    readonly values: readonly T[];
+export declare function useEventStreamMap<
+	T,
+	K extends string | number
+>(category: string, keyOf: (data: T) => K, filter?: (data: T) => boolean): {
+	readonly map: ReadonlyMap<K, T>;
+	readonly values: readonly T[];
 };

package/dist/hooks/use-is-mobile.d.ts

@@ -1,8 +1,8 @@
 export declare function useIsMobile(): boolean;
 /**
- * True when the viewport is in the medium (`md`) Tailwind range —
- * 768px ≤ width < 1024px. Use to drive layouts that should pack denser
- * than full-desktop but more legibly than mobile (e.g. icons-only
- * sidebar rail, narrower stat tiles).
- */
+* True when the viewport is in the medium (`md`) Tailwind range —
+* 768px ≤ width < 1024px. Use to drive layouts that should pack denser
+* than full-desktop but more legibly than mobile (e.g. icons-only
+* sidebar rail, narrower stat tiles).
+*/
 export declare function useIsMidWidth(): boolean;

package/dist/hooks/use-live-buffer.d.ts

@@ -1,8 +1,8 @@
 export interface LiveBuffer<T> {
-    readonly entries: readonly T[];
-    /** Append one entry; oldest is evicted past `max`. */
-    readonly append: (entry: T) => void;
-    /** Replace all entries — used by Clear / scope-change resets. */
-    readonly reset: () => void;
+	readonly entries: readonly T[];
+	/** Append one entry; oldest is evicted past `max`. */
+	readonly append: (entry: T) => void;
+	/** Replace all entries — used by Clear / scope-change resets. */
+	readonly reset: () => void;
 }
 export declare function useLiveBuffer<T>(max: number): LiveBuffer<T>;

package/dist/hooks/use-live-event.d.ts

@@ -1,3 +1,3 @@
-import { SystemLiveEvent } from '@camstack/sdk';
+import type { SystemLiveEvent } from "@camstack/sdk";
 export type LiveEventCallback<TData = unknown> = (event: SystemLiveEvent<TData>) => void;
 export declare function useLiveEvent<TData = unknown>(category: string, cb: LiveEventCallback<TData>): void;

package/dist/hooks/use-navigation.d.ts

@@ -1,26 +1,26 @@
-import { NavigationActionEntry, NavigationActionId, NavigationFeatures, NavigationLightMode, NavigationStatus } from '@camstack/types';
-import { UseDeviceProxyTrpc } from './use-device-proxy';
-export type NavigationDirection = 'forward' | 'left' | 'right' | 'spin';
+import type { NavigationActionEntry, NavigationActionId, NavigationFeatures, NavigationLightMode, NavigationStatus } from "@camstack/types";
+import { type UseDeviceProxyTrpc } from "./use-device-proxy";
+export type NavigationDirection = "forward" | "left" | "right" | "spin";
 /** The cadence the robot app drives at while a direction is held. */
-export declare const NAVIGATION_DRIVE_INTERVAL_MS = 1000;
+export declare const NAVIGATION_DRIVE_INTERVAL_MS = 1e3;
 export interface UseNavigationOptions {
-    readonly enabled?: boolean;
+	readonly enabled?: boolean;
 }
 export interface UseNavigationResult {
-    readonly features: NavigationFeatures | null;
-    readonly actions: readonly NavigationActionEntry[];
-    readonly status: NavigationStatus | null;
-    /** Start nudging in a direction at 1 Hz until `stopDrive`. */
-    readonly startDrive: (direction: NavigationDirection) => void;
-    readonly stopDrive: () => Promise<void>;
-    readonly runAction: (actionId: NavigationActionId) => Promise<void>;
-    readonly playSound: (soundId: number) => Promise<void>;
-    readonly setLightOn: (on: boolean) => Promise<void>;
-    readonly setLightMode: (mode: NavigationLightMode, level?: number) => Promise<void>;
-    readonly setLightLevel: (level: number) => Promise<void>;
-    readonly busy: boolean;
-    readonly error: string | null;
-    /** True while a direction is held. */
-    readonly driving: NavigationDirection | null;
+	readonly features: NavigationFeatures | null;
+	readonly actions: readonly NavigationActionEntry[];
+	readonly status: NavigationStatus | null;
+	/** Start nudging in a direction at 1 Hz until `stopDrive`. */
+	readonly startDrive: (direction: NavigationDirection) => void;
+	readonly stopDrive: () => Promise<void>;
+	readonly runAction: (actionId: NavigationActionId) => Promise<void>;
+	readonly playSound: (soundId: number) => Promise<void>;
+	readonly setLightOn: (on: boolean) => Promise<void>;
+	readonly setLightMode: (mode: NavigationLightMode, level?: number) => Promise<void>;
+	readonly setLightLevel: (level: number) => Promise<void>;
+	readonly busy: boolean;
+	readonly error: string | null;
+	/** True while a direction is held. */
+	readonly driving: NavigationDirection | null;
 }
 export declare function useNavigation(trpc: UseDeviceProxyTrpc, deviceId: number, hookOptions?: UseNavigationOptions): UseNavigationResult;

package/dist/hooks/use-optimistic-slice.d.ts

@@ -1,18 +1,18 @@
 export interface UseOptimisticSliceOptions {
-    readonly enabled?: boolean;
-    readonly timeoutMs?: number;
+	readonly enabled?: boolean;
+	readonly timeoutMs?: number;
 }
 export interface UseOptimisticSliceResult<T> {
-    /** The slice to RENDER: the optimistic override if active, else the real slice. */
-    readonly display: T | undefined;
-    /** Apply an optimistic patch (merged onto the current display) after issuing a command. */
-    readonly applyOptimistic: (patch: Partial<T>) => void;
-    /**
-     * Revert immediately to the real slice — a real rollback, not a timer wait.
-     * Use this when the command the optimistic patch anticipated is REJECTED
-     * (the server refused it), so `display` never keeps showing a state the
-     * server never produced.
-     */
-    readonly rollback: () => void;
+	/** The slice to RENDER: the optimistic override if active, else the real slice. */
+	readonly display: T | undefined;
+	/** Apply an optimistic patch (merged onto the current display) after issuing a command. */
+	readonly applyOptimistic: (patch: Partial<T>) => void;
+	/**
+	* Revert immediately to the real slice — a real rollback, not a timer wait.
+	* Use this when the command the optimistic patch anticipated is REJECTED
+	* (the server refused it), so `display` never keeps showing a state the
+	* server never produced.
+	*/
+	readonly rollback: () => void;
 }
 export declare function useOptimisticSlice<T extends object>(realSlice: T | undefined, opts?: UseOptimisticSliceOptions): UseOptimisticSliceResult<T>;