@camstack/ui-library 1.2.256 → 1.2.258

package/dist/composites/pipeline-runtime-selector.d.ts

@@ -1,16 +1,17 @@
+import { type JSX } from "react";
 export interface PipelineRuntimeOption {
-    readonly id: string;
-    readonly label: string;
-    readonly available: boolean;
-    /** Platform score for this backend (higher = better) */
-    readonly platformScore?: number;
-    /** Whether this is the best-scored backend */
-    readonly isBest?: boolean;
+	readonly id: string;
+	readonly label: string;
+	readonly available: boolean;
+	/** Platform score for this backend (higher = better) */
+	readonly platformScore?: number;
+	/** Whether this is the best-scored backend */
+	readonly isBest?: boolean;
 }
 interface PipelineRuntimeSelectorProps {
-    readonly options: readonly PipelineRuntimeOption[];
-    readonly value: string;
-    readonly onChange: (value: string) => void;
+	readonly options: readonly PipelineRuntimeOption[];
+	readonly value: string;
+	readonly onChange: (value: string) => void;
 }
-export declare function PipelineRuntimeSelector({ options, value, onChange, }: PipelineRuntimeSelectorProps): import("react").JSX.Element;
+export declare function PipelineRuntimeSelector({ options, value, onChange }: PipelineRuntimeSelectorProps): JSX.Element;
 export {};

package/dist/composites/pipeline-step.d.ts

@@ -1,35 +1,43 @@
-import { PipelineSlot, PipelineAddonSchema, ConfigField } from '@camstack/types';
+/**
+* PipelineStep — single step card in the pipeline builder.
+*
+* Driven entirely by PipelineAddonSchema. No hardcoded addon names or models.
+* Renders: colored left border, header with I/O class tags, expandable config
+* (Model → Confidence), children recursively.
+*/
+import { type JSX } from "react";
+import type { PipelineSlot, PipelineAddonSchema, ConfigField } from "@camstack/types";
 export interface PipelineStepDisplayConfig {
-    readonly addonId: string;
-    readonly addonName: string;
-    readonly slot: PipelineSlot;
-    readonly inputClasses: readonly string[];
-    readonly outputClasses: readonly string[];
-    readonly enabled: boolean;
-    readonly modelId: string;
-    readonly children: readonly PipelineStepDisplayConfig[];
-    /** UI grouping — steps with the same group are displayed under one heading */
-    readonly group?: string;
-    /** Current values for the step's configSchema fields */
-    readonly settings?: Record<string, unknown>;
+	readonly addonId: string;
+	readonly addonName: string;
+	readonly slot: PipelineSlot;
+	readonly inputClasses: readonly string[];
+	readonly outputClasses: readonly string[];
+	readonly enabled: boolean;
+	readonly modelId: string;
+	readonly children: readonly PipelineStepDisplayConfig[];
+	/** UI grouping — steps with the same group are displayed under one heading */
+	readonly group?: string;
+	/** Current values for the step's configSchema fields */
+	readonly settings?: Record<string, unknown>;
 }
 export interface PipelineStepProps {
-    readonly step: PipelineStepDisplayConfig;
-    readonly schema: PipelineAddonSchema | null;
-    /** Full schema map so children can look up their own schema */
-    readonly allSchemas: ReadonlyMap<string, PipelineAddonSchema>;
-    readonly depth?: number;
-    readonly onChange: (updated: PipelineStepDisplayConfig) => void;
-    readonly onDelete?: (addonId: string) => void;
-    readonly readOnly?: boolean;
+	readonly step: PipelineStepDisplayConfig;
+	readonly schema: PipelineAddonSchema | null;
+	/** Full schema map so children can look up their own schema */
+	readonly allSchemas: ReadonlyMap<string, PipelineAddonSchema>;
+	readonly depth?: number;
+	readonly onChange: (updated: PipelineStepDisplayConfig) => void;
+	readonly onDelete?: (addonId: string) => void;
+	readonly readOnly?: boolean;
 }
-export declare function PipelineStep({ step, schema, allSchemas: _allSchemas, depth: _depth, onChange, onDelete: _onDelete, readOnly, }: PipelineStepProps): import("react").JSX.Element;
-export declare function ConfigSchemaField({ field, allFields, step, disabled, onChange, hideModelBoundSourceRow, }: {
-    field: ConfigField;
-    allFields: readonly ConfigField[];
-    step: PipelineStepDisplayConfig;
-    disabled: boolean;
-    onChange: (updated: PipelineStepDisplayConfig) => void;
-    /** A layered editor draws its own provenance (D754) — see `ModelBoundSlider.hideSourceRow`. */
-    hideModelBoundSourceRow?: boolean;
-}): import("react").JSX.Element;
+export declare function PipelineStep({ step, schema, allSchemas: _allSchemas, depth: _depth, onChange, onDelete: _onDelete, readOnly }: PipelineStepProps): JSX.Element | null;
+export declare function ConfigSchemaField({ field, allFields, step, disabled, onChange, hideModelBoundSourceRow }: {
+	field: ConfigField;
+	allFields: readonly ConfigField[];
+	step: PipelineStepDisplayConfig;
+	disabled: boolean;
+	onChange: (updated: PipelineStepDisplayConfig) => void;
+	/** A layered editor draws its own provenance (D754) — see `ModelBoundSlider.hideSourceRow`. */
+	hideModelBoundSourceRow?: boolean;
+}): JSX.Element | null;

package/dist/composites/placeholder-field/PlaceholderChipField.d.ts

@@ -1,29 +1,30 @@
+import { type JSX } from "react";
 export interface PlaceholderChip {
-    readonly id: string;
-    readonly label: string;
-    /** Exact text inserted at the cursor. */
-    readonly token: string;
+	readonly id: string;
+	readonly label: string;
+	/** Exact text inserted at the cursor. */
+	readonly token: string;
 }
 export interface PlaceholderChipFieldProps {
-    readonly label: string;
-    readonly value: string;
-    readonly onChange: (next: string) => void;
-    /**
-     * `undefined` = catalog has not answered: no chips, no warning (D315).
-     * `[]` = answered empty.
-     */
-    readonly chips: readonly PlaceholderChip[] | undefined;
-    readonly multiline?: boolean;
-    readonly placeholder?: string;
-    readonly disabled?: boolean;
-    readonly testId: string;
-    readonly maxLength?: number;
+	readonly label: string;
+	readonly value: string;
+	readonly onChange: (next: string) => void;
+	/**
+	* `undefined` = catalog has not answered: no chips, no warning (D315).
+	* `[]` = answered empty.
+	*/
+	readonly chips: readonly PlaceholderChip[] | undefined;
+	readonly multiline?: boolean;
+	readonly placeholder?: string;
+	readonly disabled?: boolean;
+	readonly testId: string;
+	readonly maxLength?: number;
 }
 export declare function insertAtSelection(value: string, selection: {
-    readonly start: number;
-    readonly end: number;
+	readonly start: number;
+	readonly end: number;
 }, token: string): {
-    readonly value: string;
-    readonly cursor: number;
+	readonly value: string;
+	readonly cursor: number;
 };
-export declare function PlaceholderChipField({ label, value, onChange, chips, multiline, placeholder, disabled, testId, maxLength, }: PlaceholderChipFieldProps): import("react").JSX.Element;
+export declare function PlaceholderChipField({ label, value, onChange, chips, multiline, placeholder, disabled, testId, maxLength }: PlaceholderChipFieldProps): JSX.Element;

package/dist/composites/placeholder-field/index.d.ts

@@ -1 +1 @@
-export { PlaceholderChipField, insertAtSelection, type PlaceholderChip, type PlaceholderChipFieldProps, } from './PlaceholderChipField.js';
+export { PlaceholderChipField, insertAtSelection, type PlaceholderChip, type PlaceholderChipFieldProps } from "./PlaceholderChipField.js";

package/dist/composites/provider-badge.d.ts

@@ -1,7 +1,8 @@
-import { ProviderType } from '../icons';
+import type { ProviderType } from "../icons";
+import { type JSX } from "react";
 export interface ProviderBadgeProps {
-    provider: ProviderType;
-    showLabel?: boolean;
-    className?: string;
+	provider: ProviderType;
+	showLabel?: boolean;
+	className?: string;
 }
-export declare function ProviderBadge({ provider, showLabel, className }: ProviderBadgeProps): import("react").JSX.Element;
+export declare function ProviderBadge({ provider, showLabel, className }: ProviderBadgeProps): JSX.Element;

package/dist/composites/ptz-overlay.d.ts

@@ -1,20 +1,40 @@
-import { UsePTZResult } from '../hooks/use-ptz';
+/**
+* PTZOverlay — pan / tilt / zoom controls.
+*
+* Two visual variants driven by `mode`:
+*   - `'overlay'` (default): translucent dark pill positioned bottom-
+*     right of the camera viewport. Used as `extraOverlay` on the
+*     `CameraStreamPlayer` so operators can drive PTZ without leaving
+*     the live view. Opaque background + subtle ring keeps the d-pad
+*     legible against any frame.
+*   - `'panel'`: full-bleed inside a host container (e.g. the floating
+*     PTZ panel in DeviceDetail). No absolute positioning, no inner
+*     wrapper card — the host's chrome is the only frame. Inherits the
+*     surrounding `bg-surface` so the dark theme reads consistently
+*     instead of the previous always-dark-bubble look.
+*
+* Interaction model is identical across modes: short tap fires a
+* discrete pulse (`move`); long press starts continuous motion until
+* release (`startContinuous` + `stopContinuous` on pointer up).
+*/
+import { type JSX } from "react";
+import type { UsePTZResult } from "../hooks/use-ptz";
 export interface PTZOverlayProps {
-    /** Result of `usePTZ(trpc, deviceId)`. */
-    readonly controls: UsePTZResult;
-    /**
-     * Visual variant. `'overlay'` floats over the camera viewport with
-     * a translucent dark pill; `'panel'` lays out flat inside its
-     * container with no inner chrome — use that when hosting inside a
-     * floating panel that already provides the dark surface.
-     */
-    readonly mode?: 'overlay' | 'panel';
-    /** Show the presets dropdown (default: true when presets > 0). */
-    readonly showPresets?: boolean;
-    /** Show the zoom buttons (default: true). */
-    readonly showZoom?: boolean;
-    /** Show the home button (default: true). */
-    readonly showHome?: boolean;
-    readonly className?: string;
+	/** Result of `usePTZ(trpc, deviceId)`. */
+	readonly controls: UsePTZResult;
+	/**
+	* Visual variant. `'overlay'` floats over the camera viewport with
+	* a translucent dark pill; `'panel'` lays out flat inside its
+	* container with no inner chrome — use that when hosting inside a
+	* floating panel that already provides the dark surface.
+	*/
+	readonly mode?: "overlay" | "panel";
+	/** Show the presets dropdown (default: true when presets > 0). */
+	readonly showPresets?: boolean;
+	/** Show the zoom buttons (default: true). */
+	readonly showZoom?: boolean;
+	/** Show the home button (default: true). */
+	readonly showHome?: boolean;
+	readonly className?: string;
 }
-export declare function PTZOverlay({ controls, mode, showPresets, showZoom, showHome, className, }: PTZOverlayProps): import("react").JSX.Element;
+export declare function PTZOverlay({ controls, mode, showPresets, showZoom, showHome, className }: PTZOverlayProps): JSX.Element;

package/dist/composites/qr-code.d.ts

@@ -1,12 +1,26 @@
-import { ReactElement } from 'react';
+/**
+* `QrCode` — renders a scannable QR code from an arbitrary string.
+*
+* Browser-pure: wraps `qrcode.react`'s synchronous SVG renderer.
+* The `qrcode` npm package is intentionally NOT used — it is a
+* CommonJS, Node-targeted library, and bundling it into ui-library
+* dragged `node:module` / `createRequire` into the browser output,
+* breaking every downstream browser build that consumes ui-library.
+*
+* Addon-agnostic — used by the generic device-export panel to render a
+* HAP `X-HM://…` setup URI, a pairing URL, or any other scannable
+* string an export addon surfaces via the `device-export` cap's
+* `setup.qr` field.
+*/
+import { type ReactElement } from "react";
 export interface QrCodeProps {
-    /** The string encoded into the QR. Empty/whitespace renders nothing. */
-    readonly value: string;
-    /** Rendered width/height in CSS pixels. Defaults to 192. */
-    readonly size?: number;
-    /** Extra classes merged onto the wrapper. */
-    readonly className?: string;
-    /** Accessible label for the generated QR. */
-    readonly alt?: string;
+	/** The string encoded into the QR. Empty/whitespace renders nothing. */
+	readonly value: string;
+	/** Rendered width/height in CSS pixels. Defaults to 192. */
+	readonly size?: number;
+	/** Extra classes merged onto the wrapper. */
+	readonly className?: string;
+	/** Accessible label for the generated QR. */
+	readonly alt?: string;
 }
-export declare function QrCode({ value, size, className, alt, }: QrCodeProps): ReactElement | null;
+export declare function QrCode({ value, size, className, alt }: QrCodeProps): ReactElement | null;

package/dist/composites/reconnect-schedule.d.ts

@@ -1,32 +1,32 @@
 /**
- * Reconnect schedule — the stream player's auto-retry policy as a pure
- * decision function.
- *
- * Why it exists as a module: the inline version had two silent behaviours the
- * operator ran into — exhaustion returned without a trace (the retry loop
- * just stopped, so a camera stayed dark while looking busy), and no attempt
- * was observable anywhere. Attempt in, action out: the component executes the
- * action (timer + callbacks) and can log/report every step; the backoff shape
- * and the exhaustion edge are pinned by tests.
- */
+* Reconnect schedule — the stream player's auto-retry policy as a pure
+* decision function.
+*
+* Why it exists as a module: the inline version had two silent behaviours the
+* operator ran into — exhaustion returned without a trace (the retry loop
+* just stopped, so a camera stayed dark while looking busy), and no attempt
+* was observable anywhere. Attempt in, action out: the component executes the
+* action (timer + callbacks) and can log/report every step; the backoff shape
+* and the exhaustion edge are pinned by tests.
+*/
 export interface ReconnectPolicy {
-    readonly baseDelayMs: number;
-    readonly maxDelayMs: number;
-    readonly maxAttempts: number;
+	readonly baseDelayMs: number;
+	readonly maxDelayMs: number;
+	readonly maxAttempts: number;
 }
 /** Exponential backoff, ±20% jitter, bounded attempts. The bound exists so a
- *  permanently-dead stream stops consuming signaling; the EXHAUSTED action is
- *  the caller's cue to surface a hard error (never to go silent). */
+*  permanently-dead stream stops consuming signaling; the EXHAUSTED action is
+*  the caller's cue to surface a hard error (never to go silent). */
 export declare const RECONNECT_POLICY: ReconnectPolicy;
 export type ReconnectAction = {
-    readonly kind: 'retry';
-    readonly delayMs: number;
+	readonly kind: "retry";
+	readonly delayMs: number;
 } | {
-    readonly kind: 'exhausted';
-    readonly attempts: number;
+	readonly kind: "exhausted";
+	readonly attempts: number;
 };
 /**
- * Decide what attempt number `attempt` (0-based) should do. `random` is the
- * jitter source (unit interval), injectable for tests.
- */
+* Decide what attempt number `attempt` (0-based) should do. `random` is the
+* jitter source (unit interval), injectable for tests.
+*/
 export declare function nextReconnectAction(attempt: number, random?: () => number): ReconnectAction;

package/dist/composites/resolve-step-default-model.d.ts

@@ -1,115 +1,115 @@
 /**
- * resolve-step-default-model — the ONE step-model primitive every admin-ui
- * surface that shows or edits a step's model consumes. Two questions, two
- * exported answers, no local copies:
- *
- *   - which models may this step run on this device? → `stepModelOptions`
- *     (and its boolean form `stepHasModelForFormat`);
- *   - which model does it ACTUALLY run right now?    → `resolveEffectiveStepModel`
- *     (override → base → `resolveEffectiveDefaultModel`).
- *
- * Consumers: `AgentStepEditor` (the drawer picker), `NodeDeviceStepsMatrix`
- * (per-node base), `DeviceStepOverrideTab` (per-camera override), the Models
- * page and `pipeline-mirror`. They are views of the same decision and drifted
- * apart once already — see `resolveEffectiveDefaultModel` for the bite.
- * `scripts/check-step-model-single-owner.ts` is what stops the next copy.
- *
- * The rest of this file is the pure, UI-side mirror of the runner's
- * `getDefaultModelForFormat` (`@camstack/addon-pipeline`
- * `registry/step-definitions.ts`). The steps×device matrices need to show, per
- * cell, the model a STEP would actually run on a device's engine format — but
- * that resolver lives in a self-contained addon and can't be imported here, so
- * this replicates the exact same decision from the `getSchema` catalog the
- * matrix already fetches.
- *
- * Resolution order (identical to the runner):
- *   1. the step's declared per-format default (`defaultModelIdByFormat[format]`)
- *      when it has a build for `format`;
- *   2. the step's `defaultModelId` when it has a build for `format`;
- *   3. otherwise the smallest NON-legacy model that has a `format` build;
- *   4. otherwise `defaultModelId` unchanged (no compatible build — the caller
- *      renders a "⚠ skip"/N-A cell, never this value).
- *
- * This is the STEP's default — NOT the device's `defaultModelId`, which is the
- * per-device elected OBJECT-DETECTION model and is only correct for the
- * detector row. Every other step (face detection, embedding, plate OCR, …) must
- * resolve its own catalog default here.
- */
+* resolve-step-default-model — the ONE step-model primitive every admin-ui
+* surface that shows or edits a step's model consumes. Two questions, two
+* exported answers, no local copies:
+*
+*   - which models may this step run on this device? → `stepModelOptions`
+*     (and its boolean form `stepHasModelForFormat`);
+*   - which model does it ACTUALLY run right now?    → `resolveEffectiveStepModel`
+*     (override → base → `resolveEffectiveDefaultModel`).
+*
+* Consumers: `AgentStepEditor` (the drawer picker), `NodeDeviceStepsMatrix`
+* (per-node base), `DeviceStepOverrideTab` (per-camera override), the Models
+* page and `pipeline-mirror`. They are views of the same decision and drifted
+* apart once already — see `resolveEffectiveDefaultModel` for the bite.
+* `scripts/check-step-model-single-owner.ts` is what stops the next copy.
+*
+* The rest of this file is the pure, UI-side mirror of the runner's
+* `getDefaultModelForFormat` (`@camstack/addon-pipeline`
+* `registry/step-definitions.ts`). The steps×device matrices need to show, per
+* cell, the model a STEP would actually run on a device's engine format — but
+* that resolver lives in a self-contained addon and can't be imported here, so
+* this replicates the exact same decision from the `getSchema` catalog the
+* matrix already fetches.
+*
+* Resolution order (identical to the runner):
+*   1. the step's declared per-format default (`defaultModelIdByFormat[format]`)
+*      when it has a build for `format`;
+*   2. the step's `defaultModelId` when it has a build for `format`;
+*   3. otherwise the smallest NON-legacy model that has a `format` build;
+*   4. otherwise `defaultModelId` unchanged (no compatible build — the caller
+*      renders a "⚠ skip"/N-A cell, never this value).
+*
+* This is the STEP's default — NOT the device's `defaultModelId`, which is the
+* per-device elected OBJECT-DETECTION model and is only correct for the
+* detector row. Every other step (face detection, embedding, plate OCR, …) must
+* resolve its own catalog default here.
+*/
 /**
- * The minimal per-step model catalog this resolver reads. `PipelineAddonSchema`
- * (from `pipelineExecutor.getSchema`) is structurally assignable to it — its
- * `formats` values carry `{ downloaded, sizeMB }`, a superset of `{ sizeMB }`.
- */
+* The minimal per-step model catalog this resolver reads. `PipelineAddonSchema`
+* (from `pipelineExecutor.getSchema`) is structurally assignable to it — its
+* `formats` values carry `{ downloaded, sizeMB }`, a superset of `{ sizeMB }`.
+*/
 export interface StepModelCatalog {
-    readonly models: readonly {
-        readonly id: string;
-        readonly formats: Readonly<Record<string, {
-            readonly sizeMB: number;
-        }>>;
-        readonly legacy?: boolean;
-    }[];
-    readonly defaultModelId: string;
-    readonly defaultModelIdByFormat?: Readonly<Record<string, string>>;
+	readonly models: readonly {
+		readonly id: string;
+		readonly formats: Readonly<Record<string, {
+			readonly sizeMB: number;
+		}>>;
+		readonly legacy?: boolean;
+	}[];
+	readonly defaultModelId: string;
+	readonly defaultModelIdByFormat?: Readonly<Record<string, string>>;
 }
 export declare function resolveStepDefaultModel(catalog: StepModelCatalog, format: string): string;
 /**
- * The model a matrix CELL shows as this step's effective default on `device`.
- *
- * The device's ELECTED model (`device.defaultModelId`, the per-device
- * object-detection election) applies ONLY when this step's catalog actually
- * contains it — `slot === 'detector'` alone is too wide, because
- * package-detection shares the detector slot with the root step. Bit live
- * 2026-08-08: rfdetr-package became the package step's default and every
- * matrix cell still showed the device's yolo as the "selected" model, because
- * the election was applied slot-wide. Membership is the principled gate: an
- * elected model this step cannot run is never displayed for it.
- */
+* The model a matrix CELL shows as this step's effective default on `device`.
+*
+* The device's ELECTED model (`device.defaultModelId`, the per-device
+* object-detection election) applies ONLY when this step's catalog actually
+* contains it — `slot === 'detector'` alone is too wide, because
+* package-detection shares the detector slot with the root step. Bit live
+* 2026-08-08: rfdetr-package became the package step's default and every
+* matrix cell still showed the device's yolo as the "selected" model, because
+* the election was applied slot-wide. Membership is the principled gate: an
+* elected model this step cannot run is never displayed for it.
+*/
 export declare function resolveEffectiveDefaultModel(catalog: StepModelCatalog & {
-    readonly slot?: string;
+	readonly slot?: string;
 }, device: {
-    readonly format?: string;
-    readonly defaultModelId?: string;
+	readonly format?: string;
+	readonly defaultModelId?: string;
 } | null | undefined): string | undefined;
 /**
- * The minimal model shape option-derivation needs: a per-format build map.
- * `PipelineAddonSchema['models'][number]` is structurally assignable, and the
- * generic below returns the CALLER's element type so a picker still receives
- * `name` / `group` / `sizeMB`.
- */
+* The minimal model shape option-derivation needs: a per-format build map.
+* `PipelineAddonSchema['models'][number]` is structurally assignable, and the
+* generic below returns the CALLER's element type so a picker still receives
+* `name` / `group` / `sizeMB`.
+*/
 export interface StepModelFormatBuilds {
-    readonly formats: Readonly<Record<string, unknown>>;
+	readonly formats: Readonly<Record<string, unknown>>;
 }
 /**
- * The models a step may run on an engine `format` — the ONE derivation of the
- * option list. An unknown format yields NOTHING rather than everything: a
- * picker that offered a model with no build for the device would write a pin
- * the runner cannot honour.
- */
+* The models a step may run on an engine `format` — the ONE derivation of the
+* option list. An unknown format yields NOTHING rather than everything: a
+* picker that offered a model with no build for the device would write a pin
+* the runner cannot honour.
+*/
 export declare function stepModelOptions<M extends StepModelFormatBuilds>(models: readonly M[], format: string | undefined): readonly M[];
 /** Can this step run on `format` at all? (`false` ⇒ the caller renders "⚠ skip"/"—".) */
 export declare function stepHasModelForFormat(models: readonly StepModelFormatBuilds[], format: string | undefined): boolean;
 /** The layers a surface may pin, outermost first. Both are optional per surface. */
 export interface EffectiveStepModelInput {
-    readonly catalog: StepModelCatalog & {
-        readonly slot?: string;
-    };
-    readonly device: {
-        readonly format?: string;
-        readonly defaultModelId?: string;
-    } | null | undefined;
-    /** Per-camera override (`stepOverridesByDevice[node][deviceKey][step].modelId`). */
-    readonly override?: string | undefined;
-    /** Per-(node,device) base (`inferenceDevices[node][deviceKey].steps[step].modelId`). */
-    readonly base?: string | undefined;
+	readonly catalog: StepModelCatalog & {
+		readonly slot?: string;
+	};
+	readonly device: {
+		readonly format?: string;
+		readonly defaultModelId?: string;
+	} | null | undefined;
+	/** Per-camera override (`stepOverridesByDevice[node][deviceKey][step].modelId`). */
+	readonly override?: string | undefined;
+	/** Per-(node,device) base (`inferenceDevices[node][deviceKey].steps[step].modelId`). */
+	readonly base?: string | undefined;
 }
 /**
- * The model a step ACTUALLY runs for a (device, camera) — the whole effective
- * chain in one place: per-camera override → per-(node,device) base → the
- * resolved default (`resolveEffectiveDefaultModel`).
- *
- * Every surface calls this: the matrix cell, and the drawer's picker seed. They
- * are the same number, and the only way to keep them the same number is to have
- * one function produce it. A surface that owns fewer layers omits them (the node
- * matrix passes no `override`) — it does NOT get its own resolver.
- */
+* The model a step ACTUALLY runs for a (device, camera) — the whole effective
+* chain in one place: per-camera override → per-(node,device) base → the
+* resolved default (`resolveEffectiveDefaultModel`).
+*
+* Every surface calls this: the matrix cell, and the drawer's picker seed. They
+* are the same number, and the only way to keep them the same number is to have
+* one function produce it. A surface that owns fewer layers omits them (the node
+* matrix passes no `override`) — it does NOT get its own resolver.
+*/
 export declare function resolveEffectiveStepModel(input: EffectiveStepModelInput): string | undefined;

package/dist/composites/response-log.d.ts

@@ -1,9 +1,10 @@
+import { type JSX } from "react";
 export interface ResponseLogProps {
-    readonly data: unknown;
-    readonly label?: string;
-    readonly className?: string;
+	readonly data: unknown;
+	readonly label?: string;
+	readonly className?: string;
 }
 /**
- * Expandable log box showing the raw JSON response from a pipeline run.
- */
-export declare function ResponseLog({ data, label, className }: ResponseLogProps): import("react").JSX.Element | null;
+* Expandable log box showing the raw JSON response from a pipeline run.
+*/
+export declare function ResponseLog({ data, label, className }: ResponseLogProps): JSX.Element | null;

package/dist/composites/root-model-source.d.ts

@@ -1,19 +1,30 @@
-import { RootStepSupply, RootSupplyState } from '@camstack/types';
+/**
+* "Use the root model" — the step editor's control for a step the camera's
+* ROOT detection model can supply (D730).
+*
+* The flag (`useRootModel`, in the step's own settings) is an operator INTENT
+* kept beside the step's model: checking it never changes the model, and a
+* root that cannot supply the step leaves the step running its own model while
+* the flag waits, inactive, for a root that can. Whether it is in force is
+* `resolveRootSupply` — the same function the runner decides with.
+*/
+import type { JSX } from "react";
+import { type RootStepSupply, type RootSupplyState } from "@camstack/types";
 /** The root model the edited column runs, and what it can supply. */
 export interface RootModelInfo {
-    readonly modelId: string;
-    readonly name: string;
-    readonly supplies: readonly RootStepSupply[];
+	readonly modelId: string;
+	readonly name: string;
+	readonly supplies: readonly RootStepSupply[];
 }
 /** The editor's view of the flag for one step, or `null` for a step no root can supply. */
 export declare function rootSourceState(stepId: string, settings: Readonly<Record<string, unknown>> | undefined, rootModel: RootModelInfo | undefined): RootSupplyState | null;
 /** The settings bag with the flag set — every other key untouched. */
 export declare function withUseRootModel(settings: Readonly<Record<string, unknown>> | undefined, value: boolean): Readonly<Record<string, unknown>>;
 export interface RootModelSourceControlProps {
-    readonly stepId: string;
-    readonly settings: Readonly<Record<string, unknown>> | undefined;
-    readonly rootModel: RootModelInfo | undefined;
-    readonly disabled?: boolean;
-    readonly onChange: (useRootModel: boolean) => void;
+	readonly stepId: string;
+	readonly settings: Readonly<Record<string, unknown>> | undefined;
+	readonly rootModel: RootModelInfo | undefined;
+	readonly disabled?: boolean;
+	readonly onChange: (useRootModel: boolean) => void;
 }
-export declare function RootModelSourceControl({ stepId, settings, rootModel, disabled, onChange, }: RootModelSourceControlProps): import("react").JSX.Element | null;
+export declare function RootModelSourceControl({ stepId, settings, rootModel, disabled, onChange }: RootModelSourceControlProps): JSX.Element | null;