@camstack/ui-library 1.2.256 → 1.2.258

package/dist/composites/scope-picker.d.ts

@@ -1,30 +1,54 @@
-import { ReactNode } from 'react';
-import { TokenScope } from '@camstack/types';
-export type ScopeAccess = 'view' | 'create' | 'delete';
+/**
+* <ScopePicker> — operator-facing editor for a `TokenScope[]` value.
+*
+* Two consumers: the user-scope editor on `/system/users` (admin grants
+* a baseline scope set to a non-admin user) and the scoped-token create
+* modal on `/system/api-keys` (a caller carves out a subset of THEIR
+* scopes for a `cst_*` token).
+*
+* Row shapes per scope `type`:
+*   - category   → target: 'device' | 'system'
+*   - capability → target: cap name from `KNOWN_CAP_NAMES`
+*   - addon      → target: addon id from `useAddonsList`
+*   - device     → a v3 `DeviceSelector` (all / ids / types / locations)
+*                  plus `includeLinked`, edited by `<DeviceSelectorPicker>`
+*
+* `access` is always 3 independent checkboxes (view / create / delete).
+*
+* `clampToParent` narrows the target dropdown + access checkboxes to
+* what the CALLER possesses. Admins pass `null` to allow everything.
+*
+* This is the RAW editor. The simple, two-question Access panel on
+* `/system/users` composes the same wire shape through `ACCESS_ROLES`; this
+* one is what an operator drops into when a grant set is not a plain role.
+*/
+import { type ReactNode } from "react";
+import { type TokenScope } from "@camstack/types";
+export type ScopeAccess = "view" | "create" | "delete";
 interface ScopePickerProps {
-    readonly value: readonly TokenScope[];
-    readonly onChange: (next: TokenScope[]) => void;
-    /**
-     * When set, the caller's own scope set. Each row's target dropdown
-     * is narrowed to entries the caller already grants, and access
-     * checkboxes are disabled for flavours the caller lacks. Admins
-     * (unscoped) should pass `null` to allow everything.
-     */
-    readonly clampToParent?: readonly TokenScope[] | null;
-    /** Optional empty-state CTA when `value.length === 0`. */
-    readonly emptyHint?: ReactNode;
+	readonly value: readonly TokenScope[];
+	readonly onChange: (next: TokenScope[]) => void;
+	/**
+	* When set, the caller's own scope set. Each row's target dropdown
+	* is narrowed to entries the caller already grants, and access
+	* checkboxes are disabled for flavours the caller lacks. Admins
+	* (unscoped) should pass `null` to allow everything.
+	*/
+	readonly clampToParent?: readonly TokenScope[] | null;
+	/** Optional empty-state CTA when `value.length === 0`. */
+	readonly emptyHint?: ReactNode;
 }
-export declare function ScopePicker({ value, onChange, clampToParent, emptyHint, }: ScopePickerProps): React.ReactElement;
+export declare function ScopePicker({ value, onChange, clampToParent, emptyHint }: ScopePickerProps): React.ReactElement;
 /**
- * Validation helper. The wire schema (`TokenScopeSchema`) requires every
- * scope to carry a usable target and `access.length >= 1`; a v3 device
- * selector additionally requires a non-empty list for every kind except
- * `all`. Use this before passing the picker output to a mutate call so the
- * user sees a clean inline error instead of a tRPC ZodError.
- *
- * An EMPTY selector list is rejected rather than silently treated as "all":
- * the schema's `.min(1)` would reject it server-side anyway, and the failure
- * mode of guessing wrong here is granting the whole fleet.
- */
+* Validation helper. The wire schema (`TokenScopeSchema`) requires every
+* scope to carry a usable target and `access.length >= 1`; a v3 device
+* selector additionally requires a non-empty list for every kind except
+* `all`. Use this before passing the picker output to a mutate call so the
+* user sees a clean inline error instead of a tRPC ZodError.
+*
+* An EMPTY selector list is rejected rather than silently treated as "all":
+* the schema's `.min(1)` would reject it server-side anyway, and the failure
+* mode of guessing wrong here is granting the whole fleet.
+*/
 export declare function validateScopes(scopes: readonly TokenScope[]): string | null;
 export {};

package/dist/composites/section-card.d.ts

@@ -1,13 +1,21 @@
-import { LucideIcon } from 'lucide-react';
-import { ReactNode } from 'react';
+/**
+* SectionCard — the app's section card: `SECTION_CARD` chrome, a
+* `SECTION_HEADER` strip with an uppercase `TEXT_SECTION_LABEL` heading, an
+* optional icon and right-aligned header actions. The body is the caller's
+* (pad it with `SECTION_BODY` or render a divided list / table edge to edge).
+* One card component for every settings-style page (device Customize, Pipeline
+* Load balancing) instead of a per-page copy. Owns no data.
+*/
+import type { LucideIcon } from "lucide-react";
+import type { ReactNode } from "react";
 export interface SectionCardProps {
-    /** The heading's DOM id; the section is labelled by it. */
-    readonly headingId: string;
-    readonly title: string;
-    readonly icon?: LucideIcon;
-    /** Controls at the right of the header (a switch, "+ Add"). */
-    readonly actions?: ReactNode;
-    readonly testId?: string;
-    readonly children: ReactNode;
+	/** The heading's DOM id; the section is labelled by it. */
+	readonly headingId: string;
+	readonly title: string;
+	readonly icon?: LucideIcon;
+	/** Controls at the right of the header (a switch, "+ Add"). */
+	readonly actions?: ReactNode;
+	readonly testId?: string;
+	readonly children: ReactNode;
 }
-export declare function SectionCard({ headingId, title, icon: Icon, actions, testId, children, }: SectionCardProps): ReactNode;
+export declare function SectionCard({ headingId, title, icon: Icon, actions, testId, children }: SectionCardProps): ReactNode;

package/dist/composites/setting-row.d.ts

@@ -1,24 +1,42 @@
-import { ReactNode } from 'react';
 /**
- * Which elements the row emits.
- *
- *   - `plain` (default) — `div` / `span`; valid anywhere.
- *   - `description` — `dt` / `dd` inside a wrapper `div`, so the row is a
- *     valid child of a `<dl>` (`KeyValueList`).
- */
-export type SettingRowElements = 'plain' | 'description';
+* SettingRow — the shared label/value row used by every settings surface.
+*
+* The row is TWO columns (label left, value right) only from
+* `SETTING_ROW_STACK_BREAKPOINT` up. Below it the row stacks: label on its own
+* line, value on the next at the full row width, wrapping rather than
+* truncating.
+*
+* That stacking is the whole point. The previous hand-rolled rows kept two
+* columns at every width, so on a phone a long label wrapped to two lines on
+* the left while its value was cut mid-word on the right — with the copy
+* button squeezed between them. The value is what an operator opens a setup
+* page to read, and it was the only part that could not be read.
+*
+* Trailing affordances (copy, reveal, a small action) go in `actions`; they
+* live inside the value lane so they stay beside the value instead of becoming
+* a third stacked line.
+*/
+import type { ReactNode } from "react";
+/**
+* Which elements the row emits.
+*
+*   - `plain` (default) — `div` / `span`; valid anywhere.
+*   - `description` — `dt` / `dd` inside a wrapper `div`, so the row is a
+*     valid child of a `<dl>` (`KeyValueList`).
+*/
+export type SettingRowElements = "plain" | "description";
 export interface SettingRowProps {
-    /** Left-hand label. Free to wrap — it is never given a fixed width at L1. */
-    readonly label: ReactNode;
-    /** The value. Wraps at L1, truncates from the stack breakpoint up. */
-    readonly children: ReactNode;
-    /** Trailing affordances (copy / reveal), kept beside the value. */
-    readonly actions?: ReactNode;
-    /** Element flavour — see `SettingRowElements`. Default `plain`. */
-    readonly elements?: SettingRowElements;
-    /** Extra classes on the outer row. */
-    readonly className?: string;
-    /** Extra classes on the value text (e.g. `font-mono`). */
-    readonly valueClassName?: string;
+	/** Left-hand label. Free to wrap — it is never given a fixed width at L1. */
+	readonly label: ReactNode;
+	/** The value. Wraps at L1, truncates from the stack breakpoint up. */
+	readonly children: ReactNode;
+	/** Trailing affordances (copy / reveal), kept beside the value. */
+	readonly actions?: ReactNode;
+	/** Element flavour — see `SettingRowElements`. Default `plain`. */
+	readonly elements?: SettingRowElements;
+	/** Extra classes on the outer row. */
+	readonly className?: string;
+	/** Extra classes on the value text (e.g. `font-mono`). */
+	readonly valueClassName?: string;
 }
-export declare function SettingRow({ label, children, actions, elements, className, valueClassName, }: SettingRowProps): ReactNode;
+export declare function SettingRow({ label, children, actions, elements, className, valueClassName }: SettingRowProps): ReactNode;

package/dist/composites/snapshot-button.d.ts

@@ -1,25 +1,29 @@
-interface QueryFn<I, O> {
-    query(input: I): Promise<O>;
+import { type JSX } from "react";
+interface QueryFn<
+	I,
+	O
+> {
+	query(input: I): Promise<O>;
 }
 export interface SnapshotButtonTrpc {
-    readonly snapshot: {
-        readonly getSnapshot: QueryFn<{
-            deviceId: number;
-            streamId?: string;
-            force?: boolean;
-        }, {
-            base64: string;
-            contentType: string;
-        } | null>;
-    };
+	readonly snapshot: {
+		readonly getSnapshot: QueryFn<{
+			deviceId: number;
+			streamId?: string;
+			force?: boolean;
+		}, {
+			base64: string;
+			contentType: string;
+		} | null>;
+	};
 }
 export interface SnapshotButtonProps {
-    readonly trpc: SnapshotButtonTrpc;
-    readonly deviceId: number;
-    readonly deviceName: string;
-    /** Visual size — `'sm'` for header / tile, `'md'` for prominent CTA. */
-    readonly size?: 'sm' | 'md';
-    readonly className?: string;
+	readonly trpc: SnapshotButtonTrpc;
+	readonly deviceId: number;
+	readonly deviceName: string;
+	/** Visual size — `'sm'` for header / tile, `'md'` for prominent CTA. */
+	readonly size?: "sm" | "md";
+	readonly className?: string;
 }
-export declare function SnapshotButton({ trpc, deviceId, deviceName, size, className, }: SnapshotButtonProps): import("react").JSX.Element;
+export declare function SnapshotButton({ trpc, deviceId, deviceName, size, className }: SnapshotButtonProps): JSX.Element;
 export {};

package/dist/composites/sort-header-button.d.ts

@@ -1,11 +1,28 @@
-import { ReactNode } from 'react';
-import { TableSortDirection } from './table-sort';
+/**
+* `<SortHeaderButton>` — the clickable inner control of a sortable column
+* `<th>`, shared by `DataTable` and the device list.
+*
+* Renders the column label plus a sort-direction indicator (`ChevronUp` for
+* asc, `ChevronDown` for desc, a faint placeholder that appears on hover
+* otherwise) and calls `onSort()` on click.
+*
+* The owning `<th>` keeps its own sizing/visibility classes AND carries
+* `aria-sort` — WAI-ARIA scopes `aria-sort` to `<th>`/`<td>`, never to an
+* inner control. This component renders only the interactive label and the
+* visual indicator.
+*
+* Non-sortable columns keep their plain static `<th>` text and never mount
+* this: a header that looks clickable and does nothing is worse than a header
+* that never invited the click.
+*/
+import type { ReactNode } from "react";
+import type { TableSortDirection } from "./table-sort";
 export interface SortHeaderButtonProps {
-    readonly label: ReactNode;
-    /** True when THIS column is the table's single sorted column. */
-    readonly active: boolean;
-    /** Direction while `active`; ignored otherwise. */
-    readonly dir: TableSortDirection;
-    readonly onSort: () => void;
+	readonly label: ReactNode;
+	/** True when THIS column is the table's single sorted column. */
+	readonly active: boolean;
+	/** Direction while `active`; ignored otherwise. */
+	readonly dir: TableSortDirection;
+	readonly onSort: () => void;
 }
 export declare function SortHeaderButton({ label, active, dir, onSort }: SortHeaderButtonProps): ReactNode;

package/dist/composites/stat-card.d.ts

@@ -1,10 +1,22 @@
+import { type ComponentType, type JSX } from "react";
 export interface StatCardProps {
-    value: string | number;
-    label: string;
-    trend?: {
-        value: number;
-        direction: 'up' | 'down';
-    };
-    className?: string;
+	value: string | number;
+	label: string;
+	/** Optional leading icon in the label row. */
+	icon?: ComponentType<{
+		className?: string;
+	}>;
+	/** Secondary line under the value (units, targets, …). */
+	subtext?: string;
+	/**
+	* Token utility for the value colour (e.g. `text-success`). Prefer a
+	* semantic token — never a palette class or hex.
+	*/
+	valueClassName?: string;
+	trend?: {
+		value: number;
+		direction: "up" | "down";
+	};
+	className?: string;
 }
-export declare function StatCard({ value, label, trend, className }: StatCardProps): import("react").JSX.Element;
+export declare function StatCard({ value, label, icon: Icon, subtext, valueClassName, trend, className }: StatCardProps): JSX.Element;

package/dist/composites/state-values-stream.d.ts

@@ -1,26 +1,51 @@
-import { LiveBuffer } from '../hooks/use-live-buffer';
+/**
+* StateValuesStream — live current-state tree for ui-library.
+*
+* Renders a single device's CURRENT runtime-state as a scrollable,
+* collapsible hierarchical tree (NOT a chronological change log).
+*
+*  - Seed: on mount, `trpc.deviceState.getAllSnapshots` returns the
+*    whole-system snapshot; we pick out this device's entry and build
+*    a `Map<capName, slice>` of its current state.
+*  - Realtime: an `EventCategory.DeviceStateChanged` tRPC subscription
+*    scoped to the device patches each cap's slice into the map in
+*    place — the matching tree node re-renders, no rows are appended.
+*  - Tree: top level = cap names (sorted, expanded by default); each
+*    cap node expands to its slice keys; nested objects/arrays expand
+*    recursively, deep nesting collapsed by default. A per-cap
+*    "updated Ns ago" indicator surfaces realtime activity.
+*  - Filter/search: cap-name multiselect popover + free-text search,
+*    both applied to the tree (filter which caps show; search matches
+*    keys/values anywhere in the slice).
+*
+* The live subscription is mounted only while this component renders,
+* so the parent can mount/unmount it on tab switches and the tRPC
+* subscription is torn down automatically when hidden.
+*/
+import { type JSX } from "react";
+import type { LiveBuffer } from "../hooks/use-live-buffer";
 export interface StateValuesStreamProps {
-    /** Device whose runtime-state we want to render. Required. */
-    readonly deviceId: number;
-    /** Initial cap-name filter — empty = all caps visible. */
-    readonly defaultCaps?: readonly string[];
-    /** Max height CSS class for the scrollable tree body. */
-    readonly maxHeight?: string;
-    /**
-     * @deprecated The State panel no longer keeps a chronological log,
-     * so there is no historical fetch to size. Accepted but ignored;
-     * retained so existing callers don't break.
-     */
-    readonly limit?: number;
-    /**
-     * @deprecated The State panel now renders a live current-state tree
-     * sourced from `deviceState.getAllSnapshots` + the realtime
-     * subscription, so there is no append-buffer to host across
-     * tab switches. Accepted but ignored; retained so `DeviceActivityPanel`
-     * (which passes a buffer) keeps type-checking without a ripple edit.
-     */
-    readonly liveBuffer?: LiveBuffer<unknown>;
-    readonly onClose?: () => void;
-    readonly className?: string;
+	/** Device whose runtime-state we want to render. Required. */
+	readonly deviceId: number;
+	/** Initial cap-name filter — empty = all caps visible. */
+	readonly defaultCaps?: readonly string[];
+	/** Max height CSS class for the scrollable tree body. */
+	readonly maxHeight?: string;
+	/**
+	* @deprecated The State panel no longer keeps a chronological log,
+	* so there is no historical fetch to size. Accepted but ignored;
+	* retained so existing callers don't break.
+	*/
+	readonly limit?: number;
+	/**
+	* @deprecated The State panel now renders a live current-state tree
+	* sourced from `deviceState.getAllSnapshots` + the realtime
+	* subscription, so there is no append-buffer to host across
+	* tab switches. Accepted but ignored; retained so `DeviceActivityPanel`
+	* (which passes a buffer) keeps type-checking without a ripple edit.
+	*/
+	readonly liveBuffer?: LiveBuffer<unknown>;
+	readonly onClose?: () => void;
+	readonly className?: string;
 }
-export declare function StateValuesStream({ deviceId, defaultCaps, maxHeight, onClose, className, }: StateValuesStreamProps): import("react").JSX.Element;
+export declare function StateValuesStream({ deviceId, defaultCaps, maxHeight, onClose, className }: StateValuesStreamProps): JSX.Element | null;

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

@@ -1,10 +1,12 @@
-type Status = 'online' | 'offline' | 'degraded' | 'unknown';
+import { type JSX } from "react";
+export type StatusBadgeStatus = "online" | "offline" | "degraded" | "unknown" | "running" | "stopped" | "error" | "idle" | "enabled" | "disabled";
 export interface StatusBadgeProps {
-    status: Status;
-    showDot?: boolean;
-    showLabel?: boolean;
-    size?: 'sm' | 'md';
-    className?: string;
+	status: StatusBadgeStatus;
+	/** Overrides the default label of `status` (e.g. a raw process state). */
+	label?: string;
+	showDot?: boolean;
+	showLabel?: boolean;
+	size?: "sm" | "md";
+	className?: string;
 }
-export declare function StatusBadge({ status, showDot, showLabel, size, className, }: StatusBadgeProps): import("react").JSX.Element;
-export {};
+export declare function StatusBadge({ status, label, showDot, showLabel, size, className }: StatusBadgeProps): JSX.Element;

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

@@ -1,20 +1,21 @@
+import { type JSX } from "react";
 /** The per-camera gate of a step. */
 export type StepGate = {
-    readonly kind: 'gate';
-    readonly effectiveOn: boolean;
-    readonly defaultOn: boolean;
-    readonly explicit: boolean;
+	readonly kind: "gate";
+	readonly effectiveOn: boolean;
+	readonly defaultOn: boolean;
+	readonly explicit: boolean;
 } | {
-    readonly kind: 'zone-driven';
+	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;
+	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;
+export declare function GateControl({ gate, busy, onSet }: GateControlProps): JSX.Element;
 /** The gate as a short list-row badge. */
 export declare function GateBadge({ gate }: {
-    readonly gate: StepGate;
-}): import("react").JSX.Element;
+	readonly gate: StepGate;
+}): JSX.Element;

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

@@ -1,8 +1,8 @@
-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 { type ModelRowSource, StepModelRow, type StepModelRowProps } from './step-model-row';
-export { searchSteps, type StepSearchHit, type StepSearchRow } from './step-search';
+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 { 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

@@ -1,38 +1,49 @@
-import { ReactNode } from 'react';
-import { ConfigField, PipelineAddonSchema, StepSettingSource, StepSettingsLayers } from '@camstack/types';
-import { RootModelInfo } from '../root-model-source';
+/**
+* LayeredSettingsForm — a detection step's settings, edited on ONE layer
+* (D754): the node base, the camera (every accelerator) or one accelerator.
+*
+* Every field shows the value that runs on the viewed accelerator, which layer
+* supplies it, the values of the other levels (so "node vs camera" is read, not
+* clicked for), and a reset that removes the field from the edited layer only.
+* A change writes the touched field alone — a model-bound field (D738) as its
+* value + binding pair — so the edited layer stays field-level and never
+* freezes the levels below it.
+*/
+import { type ReactNode, type JSX } from "react";
+import { type ConfigField, type PipelineAddonSchema, type StepSettingSource, type StepSettingsLayers } from "@camstack/types";
+import { type RootModelInfo } from "../root-model-source";
 /** The layer an inspector edits. */
-export type SettingsTarget = Exclude<StepSettingSource, 'default'>;
+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;
+	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;
+	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;
+export declare function LayeredSettingsForm({ addon, fields, layers, target, labels, modelId, onChangeLayer, rootModel, pinnedKeys, fieldActions, headerActions, highlightKey, disabled }: LayeredSettingsFormProps): JSX.Element;

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

@@ -1,11 +1,12 @@
+import { type JSX } from "react";
 export interface SegmentedChoiceOption<T extends string> {
-    readonly value: T;
-    readonly label: 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;
+	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;
+export declare function SegmentedChoice<T extends string>({ label, options, value, onChange }: SegmentedChoiceProps<T>): JSX.Element;

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

@@ -1,19 +1,24 @@
-import { ConfigField } from '@camstack/types';
+/**
+* How the step inspector names a stored setting value, and what a field falls
+* back to when no layer stores it. Pure, so the provenance line and its tests
+* agree on one spelling.
+*/
+import type { 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';
+	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.
- */
+* 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;
+	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;