@camstack/ui-library 1.2.244 → 1.2.245

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 inspector, which lays
+ * the same parts out across accelerators and layers (D754/D756); the settings
+ * form here is that inspector'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,14 @@
-import { StepTreeNode } from './step-tree-master';
+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;
     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;
 }
-export declare function DeviceStepMatrix({ tree, agents, gateFor, getCellState, onCellClick, selectedCell, onSetGate, gateBusy, fallbackNodeId, onFallbackNodeChange, hideGate, }: DeviceStepMatrixProps): import("react").JSX.Element;
+export declare function DeviceStepMatrix({ tree, agents, getCellState, onCellClick, selectedCell, fallbackNodeId, onFallbackNodeChange, }: DeviceStepMatrixProps): import("react").JSX.Element;

package/dist/composites/index.d.ts

@@ -1,9 +1,9 @@
 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 { 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,7 +102,7 @@ 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 type { DeviceStepMatrixProps } from './device-step-matrix';
 export { DeviceStepMatrix } from './device-step-matrix';
 export { DiscoveryPanel } from './discovery-panel';
 export type { DoorbellRecentPanelProps } from './doorbell-recent-panel';
@@ -145,14 +145,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 +166,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 +174,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

@@ -19,32 +19,5 @@ export interface PipelineBuilderProps {
     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, templates, selectedTemplateId, onSelectTemplate, onSaveTemplate, onUpdateTemplate, onDeleteTemplate, readOnly, excludeAddons, hideTemplates, 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;

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,11 @@
+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 { type StepChip, StepChips } from './step-chips';
+export { BackToStepsButton, fillHeightPx, StepInspectorLayout, type StepInspectorLayoutProps, } from './step-inspector-layout';
+export { type SaveBarState, StepInspectorPanel, type StepInspectorPanelProps, } from './step-inspector-panel';
+export { searchSteps, StepList, type StepListHandle, type StepListProps, type StepListRow, } from './step-list';
+export { modelRowsAreFoldable, StepModelList, type StepModelListItem, } from './step-model-list';
+export { type ModelRowSource, StepModelRow, type StepModelRowProps } from './step-model-row';

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-chips.d.ts

@@ -0,0 +1,11 @@
+import { CellState } from '../pipeline-matrix-shared';
+export interface StepChip {
+    readonly id: string;
+    /** Accelerator short label, for the tooltip. */
+    readonly label: string;
+    readonly state: CellState;
+}
+export declare function StepChips({ chips, selectedId, }: {
+    readonly chips: readonly StepChip[];
+    readonly selectedId?: string | null;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,23 @@
+import { ReactNode } from 'react';
+/** The tallest the inspector block can be without making its scroll container scroll. */
+export declare function fillHeightPx(input: {
+    readonly scrollerHeight: number;
+    readonly paddingBottom: number;
+    readonly offsetInScroller: number;
+    readonly minPx: number;
+}): number;
+export interface StepInspectorLayoutProps {
+    readonly list: ReactNode;
+    readonly detail: ReactNode;
+    /** On a phone the detail is a sheet: open while a step is being inspected. */
+    readonly mobileDetailOpen: boolean;
+    readonly onMobileClose: () => void;
+    /** The floor of the desktop block, so a short page still shows a usable pane. */
+    readonly minHeightPx?: number;
+    readonly className?: string;
+}
+export declare function StepInspectorLayout({ list, detail, mobileDetailOpen, onMobileClose, minHeightPx, className, }: StepInspectorLayoutProps): import("react").JSX.Element;
+/** "‹ Steps" — the phone sheet's way back to the list. */
+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-list.d.ts

@@ -0,0 +1,39 @@
+import { ReactNode } from 'react';
+import { PipelineSlot } from '@camstack/types';
+export interface StepListRow {
+    readonly addonId: string;
+    readonly name: string;
+    readonly slot: PipelineSlot;
+    /** Tree depth — children indent under their parent. */
+    readonly depth: number;
+    /** Every field label of the step, for the search (including cluster-owned ones). */
+    readonly fieldLabels: readonly string[];
+    /** Right-aligned status (the camera's gate). */
+    readonly status?: ReactNode;
+    /** Second line: one chip per accelerator. */
+    readonly detail?: ReactNode;
+}
+export interface StepListProps {
+    readonly rows: readonly StepListRow[];
+    readonly selectedId: string | null;
+    /** `matchedField` = the field label a search hit matched (absent for a name match). */
+    readonly onSelect: (addonId: string, matchedField?: string) => void;
+    /** Enter / → on a row: move focus into the inspector. */
+    readonly onActivate: (addonId: string) => void;
+    /** A row was chosen — clicked, or the search hit Enter picked (on a phone: open the sheet). */
+    readonly onPick?: (addonId: string) => void;
+    readonly label: string;
+    readonly className?: string;
+}
+export interface StepListHandle {
+    /** Focus the selected row — how the inspector's Escape returns here. */
+    readonly focusSelected: () => void;
+}
+interface Hit {
+    readonly row: StepListRow;
+    readonly matchedField?: string;
+}
+/** Rows matching `query` (all tokens in the name, or all in one field label). */
+export declare function searchSteps(rows: readonly StepListRow[], query: string): readonly Hit[];
+export declare const StepList: import('react').ForwardRefExoticComponent<StepListProps & import('react').RefAttributes<StepListHandle>>;
+export {};

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-tree-master.d.ts → step-tree.d.ts}

@@ -1,5 +1,4 @@
 import { PipelineSchema, PipelineSlot } from '@camstack/types';
-export type StepDotState = 'inherit' | 'on' | 'off' | 'na';
 export interface StepTreeNode {
     readonly addonId: string;
     readonly addonName: string;
@@ -8,17 +7,6 @@ export interface StepTreeNode {
     readonly outputClasses: readonly string[];
     readonly children: readonly StepTreeNode[];
 }
-export interface StepTreeMasterProps {
-    readonly tree: readonly StepTreeNode[];
-    readonly selectedAddonId: string | null;
-    readonly onSelect: (addonId: string) => void;
-    readonly agentDots?: Readonly<Record<string, readonly {
-        readonly agentNodeId: string;
-        readonly state: StepDotState;
-    }[]>>;
-    readonly className?: string;
-}
-export declare function StepTreeMaster({ tree, selectedAddonId, onSelect, agentDots, className, }: StepTreeMasterProps): import("react").JSX.Element;
 /**
  * Helper: build a StepTreeNode[] from a `PipelineSchema` by chaining on
  * `inputClasses` ⇔ `outputClasses` compatibility. Mirrors the orchestrator