@camstack/ui-library 1.2.244 → 1.2.246

package/dist/composites/accelerator-label.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The ONE name of an inference accelerator, everywhere it is shown: the step
+ * matrix's column headers, the load-balancing rows, the camera assignments
+ * table, Model Studio's device chips. Four pages had drifted into four
+ * spellings of the same device — the Mac mini's Neural Engine read "Coreml All"
+ * in the step matrix and "Apple ANE" on Load balancing.
+ */
+/** What naming needs from a device row (`NodeInferenceDevice` satisfies it). */
+export interface AcceleratorIdentity {
+    readonly key: string;
+    readonly backend: string;
+    readonly device: string;
+}
+/** "Intel NPU", "Apple Neural Engine", "Coral Edge TPU", "CPU" — Auto tune's names too. */
+export declare function acceleratorLabel(device: AcceleratorIdentity): string;
+/** "NPU", "ANE", "Coral", "CPU" — chips and tabs. */
+export declare function acceleratorShortLabel(device: AcceleratorIdentity): string;

package/dist/composites/agent-step-editor.d.ts

@@ -1,30 +1,55 @@
-import { PipelineAddonSchema, AgentAddonConfig, CameraStepOverridePatch } from '@camstack/types';
+import { AgentAddonConfig, ConfigField, PipelineAddonSchema } from '@camstack/types';
 import { RootModelInfo } from './root-model-source';
-export type EditorMode = 'agent' | 'device';
+/**
+ * A step's node-local fields: the catalog schema minus the knobs the CLUSTER
+ * owns (`clusterStepSettingFieldsFor`). Those still exist on the schema so the
+ * runner can hydrate `child.settings`, but writing them per node or per camera
+ * would be a second store the overlay silently ignores.
+ */
+export declare function stepLocalFields(addon: PipelineAddonSchema): readonly ConfigField[];
+/**
+ * The model a step's settings are read and written for — what a model-bound
+ * field (D738) binds to. While the ROOT supplies the step's fine label (D741),
+ * that is the root model: the step's threshold then gates the root's label, on
+ * the root's score scale. Otherwise the step's own model: its pin, else the
+ * model the row really runs (`effectiveModelId` — the device's hardware-aware
+ * default when unpinned), else the step's flat catalog default.
+ */
+export declare function settingsModelIdFor(addon: PipelineAddonSchema, modelId: string | undefined, settings: Readonly<Record<string, unknown>> | undefined, rootModel: RootModelInfo | undefined): string;
+/**
+ * Shown in place of the model picker while the root model supplies the step:
+ * the step's own model is kept, not changed, for when the root cannot.
+ */
+export declare function RootSuppliedModelNote({ rootModel, stepModelId, }: {
+    readonly rootModel: RootModelInfo;
+    readonly stepModelId: string | undefined;
+}): import("react").JSX.Element;
 export interface AgentStepEditorProps {
-    readonly mode: EditorMode;
     readonly addon: PipelineAddonSchema;
-    /** L1 base — always visible as the "inherited" baseline. */
+    /** The node's base for the step — the controlled value. */
     readonly agentDefault: AgentAddonConfig;
-    readonly agentNodeId: string;
-    /** Device mode only — current L2.5 patch for (agent, addon). */
-    readonly currentPatch?: CameraStepOverridePatch | null;
     readonly onChangeAgentConfig?: (next: AgentAddonConfig) => void;
-    readonly onChangePatch?: (next: CameraStepOverridePatch | null) => void;
     readonly engineFormat: string;
     /**
      * The model this step would ACTUALLY run when nothing is explicitly pinned —
-     * the tail of the effective-model chain AFTER base/override (detector row:
-     * device.defaultModelId; else the step's catalog format-default). Used ONLY as
-     * the picker's DISPLAY seed so an un-pinned cell pre-selects the same
-     * family/size/resolution/variant the cell shows — it is NEVER written into the
-     * draft, so opening + saving an un-pinned cell still leaves it inheriting.
+     * the tail of the effective-model chain (detector row: device.defaultModelId;
+     * else the step's catalog format-default). Used ONLY as the picker's DISPLAY
+     * seed so an un-pinned row pre-selects the model it runs — it is NEVER
+     * written into the draft, so opening + saving an un-pinned row still leaves
+     * it inheriting.
      */
     readonly effectiveModelId?: string;
     /**
-     * The ROOT detection model this column runs (D730). When it can supply the
-     * edited step, the editor offers "Use the root model"; absent ⇒ no offer.
+     * The ROOT detection model this accelerator runs (D730). When it can supply
+     * the edited step, the editor offers "Use the root model"; absent ⇒ no offer.
      */
     readonly rootModel?: RootModelInfo;
 }
-export declare function AgentStepEditor(props: AgentStepEditorProps): import("react").JSX.Element;
+/**
+ * AgentStepEditor — one step on ONE accelerator: its model and its settings,
+ * as a single node-level layer. Model Studio's "settings for this installed
+ * model" dialog uses it. The pipeline pages use the step matrix's panel, which lays
+ * the same parts out across accelerators and layers (D754/D757); the settings
+ * form here is that panel's `LayeredSettingsForm` with one layer.
+ */
+export declare function AgentStepEditor({ addon, agentDefault, onChangeAgentConfig, engineFormat, effectiveModelId, rootModel, }: AgentStepEditorProps): import("react").JSX.Element;

package/dist/composites/device-step-matrix.d.ts

@@ -1,37 +1,37 @@
-import { StepTreeNode } from './step-tree-master';
+import { ReactNode } from 'react';
+import { StepTreeNode } from './step-tree';
 import { AgentColumn, CellState, MatrixSelectedCell } from './pipeline-matrix-shared';
 export type { AgentColumn, CellState, MatrixSelectedCell } from './pipeline-matrix-shared';
-/**
- * Per-camera gate state for a step (node-independent). `zone-driven` steps
- * (package-detection) sit OUTSIDE the gate — a badge, never a switch.
- */
-export type StepGate = {
-    readonly kind: 'gate';
-    readonly effectiveOn: boolean;
-    readonly defaultOn: boolean;
-    readonly explicit: boolean;
-} | {
-    readonly kind: 'zone-driven';
-};
 export interface DeviceStepMatrixProps {
     readonly tree: readonly StepTreeNode[];
     readonly agents: readonly AgentColumn[];
-    readonly gateFor: (addonId: string) => StepGate;
     readonly getCellState: (addonId: string, agent: AgentColumn) => CellState;
-    readonly onCellClick: (addonId: string, agent: AgentColumn) => void;
+    /** `viaKeyboard`: opened with Enter / Space (a host moves focus into its panel). */
+    readonly onCellClick: (addonId: string, agent: AgentColumn, viaKeyboard?: boolean) => void;
     readonly selectedCell: MatrixSelectedCell | null;
-    /** `next: null` resets the gate to the catalog default (inherit). */
-    readonly onSetGate: (addonId: string, next: boolean | null) => void;
-    readonly gateBusy?: boolean;
     /** Single-node fallback (B): which node the one column shows. */
     readonly fallbackNodeId: string | null;
     readonly onFallbackNodeChange: (nodeId: string) => void;
-    /**
-     * Hide the col-1 gate entirely (per-node BASE view). When set, col-1 renders
-     * ONLY the step label — no gate/zone control — and its header reads "Step"
-     * instead of "Step · gate". Enablement in that view is per-camera, so the
-     * node-level matrix carries no gate. Default (absent/false) is unchanged.
-     */
-    readonly hideGate?: boolean;
+    /** A step's header was activated — open the step on the selected accelerator. */
+    readonly onStepClick?: (addonId: string, viaKeyboard?: boolean) => void;
+    /** A badge beside a step's name (the camera's gate). */
+    readonly stepBadge?: (addonId: string) => ReactNode;
+    /** Width a docked panel covers at the viewport's right edge; 0 = none. */
+    readonly reserveRightPx?: number;
+    /** Accessible name of the grid. */
+    readonly label?: string;
 }
-export declare function DeviceStepMatrix({ tree, agents, gateFor, getCellState, onCellClick, selectedCell, onSetGate, gateBusy, fallbackNodeId, onFallbackNodeChange, hideGate, }: DeviceStepMatrixProps): import("react").JSX.Element;
+/** Imperative focus, so a closing panel can hand focus back to its cell. */
+export interface DeviceStepMatrixHandle {
+    /** `columnKey` = `agentColumnKey(column)`; `null` = the step's header. */
+    readonly focusCell: (addonId: string, columnKey: string | null) => void;
+}
+/** Where a key press moves the roving focus in a `rows × cols` grid. */
+export declare function nextGridPosition(key: string, pos: {
+    readonly r: number;
+    readonly c: number;
+}, rows: number, cols: number): {
+    readonly r: number;
+    readonly c: number;
+} | null;
+export declare const DeviceStepMatrix: import('react').ForwardRefExoticComponent<DeviceStepMatrixProps & import('react').RefAttributes<DeviceStepMatrixHandle>>;

package/dist/composites/index.d.ts

@@ -1,9 +1,10 @@
 export { AddonGlobalSettingsForm } from './addon-global-settings-form';
 export type { AddonPageProps } from './addon-page-props';
-export type { AgentStepEditorProps, EditorMode } from './agent-step-editor';
-export { AgentStepEditor } from './agent-step-editor';
+export { type AcceleratorIdentity, acceleratorLabel, acceleratorShortLabel, } from './accelerator-label';
+export type { AgentStepEditorProps } from './agent-step-editor';
+export { AgentStepEditor, RootSuppliedModelNote, settingsModelIdFor, stepLocalFields, } from './agent-step-editor';
 export type { RootModelInfo } from './root-model-source';
-export { rootSourceState } from './root-model-source';
+export { RootModelSourceControl, rootSourceState, withUseRootModel } from './root-model-source';
 export * from './app-shell';
 export type { AudioClassification, AudioClassificationListProps } from './audio-classification-list';
 export { AudioClassificationList } from './audio-classification-list';
@@ -102,8 +103,8 @@ export type { DeviceSelectCandidate, SuggestedPartition, SuggestionFleetDevice,
 export { deviceMatchesFilter, deviceOptionLabel, devicesToOptions, filterDeviceOptions, partitionSuggested, sameLocationSuggestions, selectedDeviceOptions, } from './device-select-filter';
 export type { DeviceSelectorTab, SelectorDevice } from './device-selector-picker';
 export { DeviceSelectorPicker, describeDeviceSelector, deviceTypeLabel, tabForSelector, } from './device-selector-picker';
-export type { DeviceStepMatrixProps, StepGate } from './device-step-matrix';
-export { DeviceStepMatrix } from './device-step-matrix';
+export type { DeviceStepMatrixHandle, DeviceStepMatrixProps } from './device-step-matrix';
+export { DeviceStepMatrix, nextGridPosition } from './device-step-matrix';
 export { DiscoveryPanel } from './discovery-panel';
 export type { DoorbellRecentPanelProps } from './doorbell-recent-panel';
 export { DoorbellRecentPanel } from './doorbell-recent-panel';
@@ -145,14 +146,12 @@ export type { PhaseIconProps } from './phase-icon';
 export { PhaseIcon } from './phase-icon';
 export type { PipelineBuilderProps } from './pipeline-builder';
 export { PipelineBuilder } from './pipeline-builder';
-export type { AgentColumnGroup, AgentColumnIdentity, MatrixSelectedCell, } from './pipeline-matrix-shared';
+export type { AgentColumn, AgentColumnGroup, AgentColumnIdentity, CellState, MatrixSelectedCell, } from './pipeline-matrix-shared';
 export { agentColumnKey, groupAgentColumns, shouldUseSingleNode } from './pipeline-matrix-shared';
 export type { PipelineRuntimeOption } from './pipeline-runtime-selector';
 export { PipelineRuntimeSelector } from './pipeline-runtime-selector';
 export type { PipelineStepDisplayConfig, PipelineStepProps } from './pipeline-step';
 export { ConfigSchemaField, PipelineStep } from './pipeline-step';
-export type { AgentColumn, CellState, PipelineTreeMatrixProps } from './pipeline-tree-matrix';
-export { PipelineTreeMatrix } from './pipeline-tree-matrix';
 export * from './provider-badge';
 export type { PTZOverlayProps } from './ptz-overlay';
 export { PTZOverlay } from './ptz-overlay';
@@ -168,8 +167,6 @@ export type { ScopeAccess } from './scope-picker';
 export { ScopePicker, validateScopes } from './scope-picker';
 export type { SettingRowElements, SettingRowProps } from './setting-row';
 export { SettingRow } from './setting-row';
-export type { SlideOverPanelProps } from './slide-over-panel';
-export { SlideOverPanel } from './slide-over-panel';
 export type { SnapshotButtonProps, SnapshotButtonTrpc } from './snapshot-button';
 export { SnapshotButton } from './snapshot-button';
 export * from './stat-card';
@@ -178,8 +175,9 @@ export { StateValuesStream } from './state-values-stream';
 export * from './status-badge';
 export type { StepTimingsProps } from './step-timings';
 export { StepTimings } from './step-timings';
-export type { StepDotState, StepTreeMasterProps, StepTreeNode } from './step-tree-master';
-export { buildStepTreeFromSchema, StepTreeMaster } from './step-tree-master';
+export * from './step-inspector';
+export type { StepTreeNode } from './step-tree';
+export { buildStepTreeFromSchema } from './step-tree';
 export type { StreamBrokerSelectorProps } from './stream-broker-selector';
 export { StreamBrokerSelector } from './stream-broker-selector';
 export type { StreamChoice, StreamPanelProps, StreamStats } from './stream-panel';

package/dist/composites/model-bound-slider.d.ts

@@ -8,8 +8,15 @@ export interface ModelBoundSliderProps {
     readonly settings: Readonly<Record<string, unknown>> | undefined;
     readonly disabled: boolean;
     readonly onChangeSettings: (next: Record<string, unknown>) => void;
+    /**
+     * Hide the source label + "Reset to model default" row. A layered editor
+     * (the step inspector, D754) draws its own provenance line naming every
+     * layer — this row could only name the model's, and its reset would remove
+     * the value from the merged view, not from the layer being edited.
+     */
+    readonly hideSourceRow?: boolean;
 }
-export declare function ModelBoundSlider({ field, modelId, settings, disabled, onChangeSettings, }: ModelBoundSliderProps): import("react").JSX.Element;
+export declare function ModelBoundSlider({ field, modelId, settings, disabled, onChangeSettings, hideSourceRow, }: ModelBoundSliderProps): import("react").JSX.Element;
 /** The keys of the model-bound fields of a schema, groups flattened. */
 export declare function modelBoundKeysOf(fields: readonly ConfigField[]): string[];
 export interface ResetModelDefaultsButtonProps {

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

@@ -1,50 +1,15 @@
-import { PipelineSchema, PipelineTemplate } from '@camstack/types';
+import { PipelineSchema } from '@camstack/types';
 import { PipelineStepDisplayConfig } from './pipeline-step';
 export interface PipelineBuilderProps {
     readonly schema: PipelineSchema;
     readonly steps: readonly PipelineStepDisplayConfig[];
     readonly onChange: (steps: readonly PipelineStepDisplayConfig[]) => void;
-    readonly templates: readonly PipelineTemplate[];
-    readonly selectedTemplateId: string | null;
-    readonly onSelectTemplate: (id: string | null) => void;
-    readonly onSaveTemplate: (name: string, steps: readonly PipelineStepDisplayConfig[]) => void;
-    readonly onUpdateTemplate: (id: string, steps: readonly PipelineStepDisplayConfig[]) => void;
-    readonly onDeleteTemplate: (id: string) => void;
     readonly readOnly?: boolean;
     /** Addon IDs to exclude from the pipeline (e.g. 'motion-detection' for benchmark) */
     readonly excludeAddons?: readonly string[];
-    /** Hide the template bar (save/load/delete) */
-    readonly hideTemplates?: boolean;
     /** Only show enabled steps (hide disabled addons and placeholders) */
     readonly showOnlyEnabled?: boolean;
     /** Show "Slot: ..." labels above step groups (default: false) */
     readonly showSlotLabels?: boolean;
-    /**
-     * Toggle mode passed through to every `PipelineStep`:
-     *  - `'simple'` (default) — single on/off switch, edits `step.enabled` directly.
-     *  - `'threeState'` — segmented `[Inherit | On | Off]` control that emits
-     *    override changes via `onOverrideChange` (per addonId). `step.enabled`
-     *    still reflects the effective state (agent default OR override).
-     */
-    readonly toggleMode?: 'simple' | 'threeState';
-    /** Current override map keyed on `addonId` when `toggleMode === 'threeState'`. */
-    readonly overrides?: Readonly<Record<string, boolean>>;
-    /** Fires when the user flips a per-addon 3-state toggle. `null` = inherit. */
-    readonly onOverrideChange?: (addonId: string, next: boolean | null) => void;
-    /** Agent default enabled state per addonId, shown as annotation in `'threeState'` mode. */
-    readonly inheritedEnabledByAddon?: Readonly<Record<string, boolean>>;
-    /**
-     * Hide the Model dropdown + dynamic configSchema controls on every
-     * step (passes through to `PipelineStep.hideModelAndSettings`). Used
-     * on the camera page where these knobs are agent-level.
-     */
-    readonly hideModelAndSettings?: boolean;
-    /**
-     * Adds an "Auto (node default)" option to every step's Model dropdown
-     * and preserves an absent/sentinel selection instead of auto-correcting
-     * it to a concrete model. Passed through to `PipelineStep.allowAutoModel`
-     * — see that prop's doc for why this defaults to `false`.
-     */
-    readonly allowAutoModel?: boolean;
 }
-export declare function PipelineBuilder({ schema, steps, onChange, templates, selectedTemplateId, onSelectTemplate, onSaveTemplate, onUpdateTemplate, onDeleteTemplate, readOnly, excludeAddons, hideTemplates, showOnlyEnabled, showSlotLabels, toggleMode, overrides, onOverrideChange, inheritedEnabledByAddon, hideModelAndSettings, allowAutoModel, }: PipelineBuilderProps): import("react").JSX.Element;
+export declare function PipelineBuilder({ schema, steps, onChange, readOnly, excludeAddons, showOnlyEnabled, showSlotLabels, }: PipelineBuilderProps): import("react").JSX.Element;

package/dist/composites/pipeline-matrix-shared.d.ts

@@ -1,6 +1,6 @@
 import { ReactNode } from 'react';
 import { PipelineSlot } from '@camstack/types';
-import { StepTreeNode } from './step-tree-master';
+import { StepTreeNode } from './step-tree';
 export interface AgentColumn {
     readonly agentNodeId: string;
     readonly engineLabel: string;
@@ -14,6 +14,12 @@ export interface AgentColumn {
     readonly deviceKey?: string;
     /** Short human label for the device sub-column header (e.g. "Intel NPU"). */
     readonly deviceLabel?: string;
+    /** The node's display name for the group header (defaults to `agentNodeId`). */
+    readonly nodeLabel?: string;
+    /** A third header line — the model this accelerator elects for detection. */
+    readonly detail?: string;
+    /** The accelerator is switched off: shown, marked, and never a dispatch target. */
+    readonly disabled?: boolean;
 }
 /**
  * Stable column identity. Plain per-node columns key by `agentNodeId` (so the
@@ -164,6 +170,10 @@ export declare function ClassChips({ inputs, outputs, }: {
  * the first column; each device's real format is shown per sub-column instead
  * ("Coral Edge TPU · tflite").
  */
+/** The per-accelerator lines of a column header: name, format, model, off. */
+export declare function AgentColumnLines({ column }: {
+    readonly column: AgentColumn;
+}): import("react").JSX.Element;
 export declare function GroupedAgentHeader({ group }: {
     readonly group: AgentColumnGroup;
 }): import("react").JSX.Element;

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

@@ -22,54 +22,14 @@ export interface PipelineStepProps {
     readonly onChange: (updated: PipelineStepDisplayConfig) => void;
     readonly onDelete?: (addonId: string) => void;
     readonly readOnly?: boolean;
-    /**
-     * Toggle mode:
-     *  - `'simple'` (default) — header shows a single on/off switch that drives
-     *    `step.enabled` directly. Used on the agent page (`NodePipelineTab`)
-     *    where toggling IS the final state.
-     *  - `'threeState'` — header shows a 3-button segmented control
-     *    `[Inherit | On | Off]`. `overrideState` is the current override value
-     *    (`true` / `false` / `null` for inherit). When the override changes,
-     *    `onOverrideChange` fires. `step.enabled` still renders the effective
-     *    state (inherited agent default OR override). Used on the camera page
-     *    where the user edits a SPARSE override over the agent baseline.
-     */
-    readonly toggleMode?: 'simple' | 'threeState';
-    /**
-     * 3-state override value when `toggleMode === 'threeState'`. `null` or
-     * `undefined` means "inherit" (no override active). Ignored in `'simple'` mode.
-     */
-    readonly overrideState?: boolean | null;
-    /** Fired when the user flips the 3-state toggle in `'threeState'` mode. */
-    readonly onOverrideChange?: (next: boolean | null) => void;
-    /** Agent's default enabled value, shown as an annotation in `'threeState'` mode. */
-    readonly inheritedEnabled?: boolean;
-    /**
-     * Hide the Model dropdown + dynamic configSchema controls inside the
-     * expanded config panel. Used on the camera page where the step's
-     * model + settings are agent-level — a camera can land on any agent,
-     * so exposing agent-level knobs here would be misleading. Agent I/O
-     * tags and the step name stay visible.
-     */
-    readonly hideModelAndSettings?: boolean;
-    /**
-     * Adds an "Auto (node default)" option (sentinel value `''`) to the
-     * Model dropdown, and skips the auto-correct-to-a-concrete-model effect
-     * for that sentinel. Off by default — only the wholesale per-agent
-     * override editor (`PipelineEditorField`) opts in, since that's the
-     * only place an absent `modelId` is a meaningful, persistable "Auto"
-     * selection (steps loaded from `CameraPipelineConfig['steps']`, whose
-     * wire schema allows an absent `modelId`). Other `PipelineBuilder`
-     * consumers (e.g. the benchmark tab) always work with concrete model
-     * ids and are unaffected by leaving this off.
-     */
-    readonly allowAutoModel?: boolean;
 }
-export declare function PipelineStep({ step, schema, allSchemas: _allSchemas, depth: _depth, onChange, onDelete: _onDelete, readOnly, toggleMode, overrideState, onOverrideChange, inheritedEnabled, hideModelAndSettings, allowAutoModel, }: PipelineStepProps): import("react").JSX.Element;
-export declare function ConfigSchemaField({ field, allFields, step, disabled, onChange, }: {
+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;

package/dist/composites/step-inspector/accelerator-tabs.d.ts

@@ -0,0 +1,12 @@
+export interface AcceleratorTabItem {
+    readonly id: string;
+    readonly label: string;
+    /** The camera overrides something on this accelerator. */
+    readonly marked?: boolean;
+}
+export interface AcceleratorTabsProps {
+    readonly items: readonly AcceleratorTabItem[];
+    readonly selectedId: string | null;
+    readonly onSelect: (id: string) => void;
+}
+export declare function AcceleratorTabs({ items, selectedId, onSelect }: AcceleratorTabsProps): import("react").JSX.Element;

package/dist/composites/step-inspector/gate-control.d.ts

@@ -0,0 +1,20 @@
+/** The per-camera gate of a step. */
+export type StepGate = {
+    readonly kind: 'gate';
+    readonly effectiveOn: boolean;
+    readonly defaultOn: boolean;
+    readonly explicit: boolean;
+} | {
+    readonly kind: 'zone-driven';
+};
+export interface GateControlProps {
+    readonly gate: StepGate;
+    readonly busy?: boolean;
+    /** `null` = back to the catalog default. */
+    readonly onSet: (next: boolean | null) => void;
+}
+export declare function GateControl({ gate, busy, onSet }: GateControlProps): import("react").JSX.Element;
+/** The gate as a short list-row badge. */
+export declare function GateBadge({ gate }: {
+    readonly gate: StepGate;
+}): import("react").JSX.Element;

package/dist/composites/step-inspector/index.d.ts

@@ -0,0 +1,10 @@
+export { AcceleratorTabs, type AcceleratorTabItem, type AcceleratorTabsProps, } from './accelerator-tabs';
+export { GateBadge, GateControl, type GateControlProps, type StepGate } from './gate-control';
+export { LayeredSettingsForm, type LayeredSettingsFormProps, type LayerLabels, type SettingsTarget, stepFieldDomId, } from './layered-settings-form';
+export { bindsToModel, defaultOfField, formatSettingValue, isValueField, type ValueField, } from './setting-values';
+export { SegmentedChoice, type SegmentedChoiceOption, type SegmentedChoiceProps, } from './segmented-choice';
+export { BackToStepsButton, dockBox, STEP_DOCK_WIDTH_PX, StepDetailDock, type StepDetailDockProps, } from './step-detail-dock';
+export { type SaveBarState, StepInspectorPanel, type StepInspectorPanelProps, } from './step-inspector-panel';
+export { modelRowsAreFoldable, StepModelList, type StepModelListItem, } from './step-model-list';
+export { type ModelRowSource, StepModelRow, type StepModelRowProps } from './step-model-row';
+export { searchSteps, type StepSearchHit, type StepSearchRow } from './step-search';

package/dist/composites/step-inspector/layered-settings-form.d.ts

@@ -0,0 +1,38 @@
+import { ReactNode } from 'react';
+import { ConfigField, PipelineAddonSchema, StepSettingSource, StepSettingsLayers } from '@camstack/types';
+import { RootModelInfo } from '../root-model-source';
+/** The layer an inspector edits. */
+export type SettingsTarget = Exclude<StepSettingSource, 'default'>;
+/** How each stored layer is named on screen. A layer without a label is not shown. */
+export interface LayerLabels {
+    readonly accelerator?: string;
+    readonly camera?: string;
+    readonly node: string;
+}
+export interface LayeredSettingsFormProps {
+    readonly addon: PipelineAddonSchema;
+    /** The step's node-local fields (cluster-owned knobs already removed). */
+    readonly fields: readonly ConfigField[];
+    /** The stored layers as they apply on the viewed accelerator. */
+    readonly layers: StepSettingsLayers;
+    readonly target: SettingsTarget;
+    readonly labels: LayerLabels;
+    /** The model a model-bound value is judged against and bound to (D738/D741). */
+    readonly modelId: string;
+    /** The edited layer's next bag. */
+    readonly onChangeLayer: (next: Record<string, unknown>) => void;
+    /** The root model of the viewed accelerator — offers "Use the root model" (D730). */
+    readonly rootModel?: RootModelInfo;
+    /** Fields the edited layer stores at exactly the value below it (a legacy full copy). */
+    readonly pinnedKeys?: readonly string[];
+    /** An extra control under one field ("Apply to all accelerators"). */
+    readonly fieldActions?: (key: string, source: StepSettingSource) => ReactNode;
+    /** Controls on the section header ("Follow the node", a scope switch). */
+    readonly headerActions?: ReactNode;
+    /** A field to bring into view and highlight (a search hit). */
+    readonly highlightKey?: string | null;
+    readonly disabled?: boolean;
+}
+/** DOM id of a field's box — the target of a search hit. */
+export declare function stepFieldDomId(key: string): string;
+export declare function LayeredSettingsForm({ addon, fields, layers, target, labels, modelId, onChangeLayer, rootModel, pinnedKeys, fieldActions, headerActions, highlightKey, disabled, }: LayeredSettingsFormProps): import("react").JSX.Element;

package/dist/composites/step-inspector/segmented-choice.d.ts

@@ -0,0 +1,11 @@
+export interface SegmentedChoiceOption<T extends string> {
+    readonly value: T;
+    readonly label: string;
+}
+export interface SegmentedChoiceProps<T extends string> {
+    readonly label: string;
+    readonly options: readonly SegmentedChoiceOption<T>[];
+    readonly value: T;
+    readonly onChange: (next: T) => void;
+}
+export declare function SegmentedChoice<T extends string>({ label, options, value, onChange, }: SegmentedChoiceProps<T>): import("react").JSX.Element;

package/dist/composites/step-inspector/setting-values.d.ts

@@ -0,0 +1,19 @@
+import { ConfigField } from '@camstack/types';
+/** A field that stores a value (not a separator, an info block or a group). */
+export type ValueField = Exclude<ConfigField, {
+    readonly type: 'separator' | 'info' | 'group';
+}>;
+export declare function isValueField(field: ConfigField): field is ValueField;
+/** True for a D738 field whose value is stored with the model it was made for. */
+export declare function bindsToModel(field: ConfigField): boolean;
+/**
+ * What runs when no layer stores the field: the running model's default for a
+ * model-bound field that the model declares one for (D738), else the field's
+ * own default. `fromModel` says which.
+ */
+export declare function defaultOfField(field: ValueField, modelId: string): {
+    readonly value: unknown;
+    readonly fromModel: boolean;
+};
+/** One stored value as the operator reads it (`0.65`, `on`, `Person, Vehicle`, `—`). */
+export declare function formatSettingValue(field: ValueField, value: unknown): string;

package/dist/composites/step-inspector/step-detail-dock.d.ts

@@ -0,0 +1,33 @@
+import { ReactNode, RefObject } from 'react';
+/** Width of the desktop dock — what the matrix keeps clear of it. */
+export declare const STEP_DOCK_WIDTH_PX = 432;
+/** The dock's viewport box, from its scroll container's box. */
+export declare function dockBox(input: {
+    readonly scroller: {
+        readonly top: number;
+        readonly bottom: number;
+        readonly right: number;
+    };
+    readonly viewportWidth: number;
+    readonly widthPx: number;
+}): {
+    readonly top: number;
+    readonly height: number;
+    readonly right: number;
+    readonly width: number;
+};
+export interface StepDetailDockProps {
+    readonly open: boolean;
+    /** An element inside the page's scroll container (the matrix) — the dock measures from it. */
+    readonly anchor: RefObject<HTMLElement | null>;
+    /** The phone sheet was dismissed (Escape, back). */
+    readonly onClose: () => void;
+    /** Accessible name of the dock region. */
+    readonly label: string;
+    readonly children: ReactNode;
+}
+export declare function StepDetailDock({ open, anchor, onClose, label, children }: StepDetailDockProps): import("react").JSX.Element | null;
+/** "‹ Steps" — the phone sheet's way back to the matrix. */
+export declare function BackToStepsButton({ onClick }: {
+    readonly onClick: () => void;
+}): import("react").JSX.Element;

package/dist/composites/step-inspector/step-inspector-panel.d.ts

@@ -0,0 +1,26 @@
+import { ReactNode } from 'react';
+export interface SaveBarState {
+    readonly dirtyCount: number;
+    readonly saving: boolean;
+    /** The last save's outcome, cleared by the next edit. */
+    readonly status: 'saved' | 'error' | null;
+    readonly error?: string;
+    readonly onSave: () => void;
+    readonly onDiscard: () => void;
+}
+export interface StepInspectorPanelProps {
+    readonly title: string;
+    readonly subtitle?: ReactNode;
+    /** Right of the title (the gate). */
+    readonly headerActions?: ReactNode;
+    /** Under the title (the accelerator tabs). */
+    readonly headerExtra?: ReactNode;
+    /** Left of the title (the phone's "‹ Steps"). */
+    readonly leading?: ReactNode;
+    readonly saveBar?: SaveBarState;
+    /** Escape inside the panel — the host returns focus to the step list. */
+    readonly onEscape?: () => void;
+    readonly children: ReactNode;
+    readonly className?: string;
+}
+export declare const StepInspectorPanel: import('react').ForwardRefExoticComponent<StepInspectorPanelProps & import('react').RefAttributes<HTMLHeadingElement>>;

package/dist/composites/step-inspector/step-model-list.d.ts

@@ -0,0 +1,9 @@
+import { StepModelRowProps } from './step-model-row';
+export interface StepModelListItem extends StepModelRowProps {
+    readonly id: string;
+}
+/** True when the rows can be summarised: nothing pinned here, edited, or noted. */
+export declare function modelRowsAreFoldable(rows: readonly StepModelListItem[]): boolean;
+export declare function StepModelList({ rows }: {
+    readonly rows: readonly StepModelListItem[];
+}): import("react").JSX.Element;

package/dist/composites/step-inspector/step-model-row.d.ts

@@ -0,0 +1,27 @@
+import { ReactNode } from 'react';
+import { PipelineAddonSchema } from '@camstack/types';
+/** Where the row's model is decided. */
+export type ModelRowSource = 'camera' | 'node' | 'default' | 'cluster';
+export interface StepModelRowProps {
+    readonly label: string;
+    readonly format: string;
+    /** The model this accelerator runs (`undefined` = nothing runs here). */
+    readonly modelId: string | undefined;
+    readonly source: ModelRowSource;
+    readonly sourceLabel: string;
+    readonly models: PipelineAddonSchema['models'];
+    readonly defaultModelId?: string;
+    readonly expanded: boolean;
+    readonly onToggle: () => void;
+    readonly onChangeModel: (modelId: string) => void;
+    /** Present only when the edited layer pins a model here. */
+    readonly onReset?: () => void;
+    readonly resetLabel?: string;
+    /** Why the step does not run its own model here (no build, root-supplied, jump). */
+    readonly note?: ReactNode;
+    /** Extra control shown with the picker ("Run on"). */
+    readonly extra?: ReactNode;
+    readonly changed?: boolean;
+    readonly disabled?: boolean;
+}
+export declare function StepModelRow({ label, format, modelId, source, sourceLabel, models, defaultModelId, expanded, onToggle, onChangeModel, onReset, resetLabel, note, extra, changed, disabled, }: StepModelRowProps): import("react").JSX.Element;

package/dist/composites/step-inspector/step-search.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The step matrix's filter (`/`): a step matches by its name, or by any of its
+ * field labels — so a question about a knob ("face size", "person") finds the
+ * step that owns it, and says which field it matched.
+ */
+export interface StepSearchRow {
+    readonly addonId: string;
+    readonly name: string;
+    /** Every field label of the step, cluster-owned ones included. */
+    readonly fieldLabels: readonly string[];
+}
+export interface StepSearchHit {
+    readonly addonId: string;
+    /** The field label the query matched; absent for a name match. */
+    readonly matchedField?: string;
+}
+/** Steps matching `query` (all tokens in the name, or all in one field label). Empty query = all. */
+export declare function searchSteps(rows: readonly StepSearchRow[], query: string): readonly StepSearchHit[];