@weasel-js/labkit 1.2.0 → 1.3.0

package/dist/index.d.ts

@@ -1,337 +1,777 @@
-export { CanvasLayerDescriptor, CanvasStack, CanvasStackContext, CanvasStackContextValue, CanvasStackProps, screenToWorld, worldToScreen } from './canvas/index.js';
+export { LayerStack, LayerStackItem, LayerStackProps } from './ui/layers/index.js';
+import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as react from 'react';
-import { WheelEvent, PointerEvent, ReactNode } from 'react';
+import { ReactNode, WheelEvent, PointerEvent } from 'react';
+export { CanvasLayerDescriptor, CanvasStack, CanvasStackContext, CanvasStackContextValue, CanvasStackProps, screenToWorld, worldToScreen } from './canvas/index.js';
+export { PaletteRegion, PaletteRegionProps, SidebarRegion, SidebarRegionProps, StatusRegion, StatusRegionProps, TitleBarRegion, TitleBarRegionProps, ToolbarRegion, ToolbarRegionProps, ViewportRegion, ViewportRegionProps, builtinContributions, mergeContributions, suppressContributions } from './chrome/index.js';
+import { I as Instrument, c as InstrumentList, T as TrialContribution, d as TrialTool, V as ViewTransform } from './_dts/types-BttTIent.js';
+export { C as CanvasCapability, e as CanvasLayer, b as DragDropCapability, D as DragFeedback, H as HitResult, f as IconComponent, L as LayerCapability, g as LayerDescriptor, P as PaletteItem, a as Point, R as RenderContext, S as SidebarSection, h as StatusReadout, i as SystemEvent, j as ToolCapability, k as ToolItem, l as ToolbarItem, m as TrialChromeContext, n as TrialRegion, U as UndoCapability, o as ViewportControl } from './_dts/types-BttTIent.js';
+import { T as ToolPrefLeaf } from './_dts/PrefsForm-BYa6cWnO.js';
+import { b as ConfigNode, A as Annotations, N as NodeOptions, c as ControlRenderer, d as ConfigOption, a as ConfigSchema, I as InferConfig, C as ConfigField, R as ResolvedConfig, e as ConfigRule, L as LeafPatch, f as ConfigRuleContext } from './_dts/types-DCGEcMO_.js';
+export { g as CheckboxField, h as ColorField, i as ConfigFieldBase, j as ConfigFieldType, k as ConfigOf, l as NodeValue, m as NumberField, S as SectionSpec, n as SelectField, o as SelectOption, p as SliderField, T as TextField } from './_dts/types-DCGEcMO_.js';
 export { ControlPanel } from './controls/index.js';
-import { C as ConfigField } from './_dts/types-x92Kfeme.js';
-export { a as CheckboxField, b as ColorField, c as ConfigFieldBase, d as ConfigFieldType, N as NumberField, S as SelectField, e as SelectOption, f as SliderField, T as TextField } from './_dts/types-x92Kfeme.js';
-import { I as Instrument, a as InstrumentList, V as ViewTransform } from './_dts/index-JFAYj5Tv.js';
-export { C as CanvasCapability, b as CanvasLayer, D as DragDropCapability, c as DragFeedback, H as HitResult, L as LayerCapability, d as LayerDescriptor, P as PaletteItem, e as Point, R as RenderContext, S as SystemEvent, U as UndoCapability } from './_dts/index-JFAYj5Tv.js';
 import { J as JobHandle } from './_dts/types-DJ79Tg5J.js';
 export { a as JobCapability, b as JobEvent, c as JobFailure, d as JobStatus } from './_dts/types-DJ79Tg5J.js';
 export { UseJobOptions, useJob } from './job/index.js';
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import { a as StorageAdapter, w as LabMode, T as TrialRecord, h as SavedSnapshot } from './_dts/useTrialState-BMNIx3Cy.js';
-export { C as CURRENT_DOCUMENT_VERSION, b as CreateLabStoreOptions, L as LabDocument, e as LabStoreContext, f as LabStoreProvider, g as LabStoreState, S as SerializedTrial, i as TrialIdContext, j as TrialIdProvider, k as TrialStateHandle, U as UndoStack, m as createMemoryAdapter, n as labDocumentKey, o as localStorageAdapter, p as noneAdapter, q as quarantineKey, s as sessionStorageAdapter, u as urlHashAdapter, r as useLabStore, t as useTrialId, v as useTrialState } from './_dts/useTrialState-BMNIx3Cy.js';
+import { a as StorageAdapter, e as LabMode, T as TrialRecord, c as SavedSnapshot } from './_dts/types-1Sdxy_Pv.js';
+export { C as CreateLabStoreOptions, L as LabDocument, b as LabStoreState, S as SerializedTrial, d as TrialStateHandle, U as UndoStack } from './_dts/types-1Sdxy_Pv.js';
 export { LayerList, LayerListProps } from './layers/index.js';
-export { FpsMeter, ScaleIndicator, ScaleIndicatorProps, Sidebar, SidebarProps, StatusBar, StatusBarProps, Toolbar, ToolbarProps } from './primitives/index.js';
+export { FloatingPanel, FloatingPanelProps, FpsMeter, JobProgress, JobProgressProps, Legend, LegendEntry, LegendMark, LegendProps, ScaleIndicator, ScaleIndicatorProps, Sidebar, SidebarProps, StatusBar, StatusBarProps, StatusBarSectionProps, Toolbar, ToolbarButtonProps, ToolbarGroupProps, ToolbarProps, ZoomControl, ZoomControlProps } from './primitives/index.js';
+export { C as CURRENT_DOCUMENT_VERSION, b as LabStoreContext, c as LabStoreProvider, T as TrialIdContext, d as TrialIdProvider, f as createMemoryAdapter, l as labDocumentKey, g as localStorageAdapter, n as noneAdapter, q as quarantineKey, s as sessionStorageAdapter, u as urlHashAdapter, h as useLabStore, i as useTrialId, j as useTrialState } from './_dts/useTrialState-CsGMjhu9.js';
 export { Box, Rect, SurfaceContext, SurfaceFrame, SurfaceHandle, UseTiledSurfaceOptions, composeRects, rectsEqual, toDeviceRect, useSurface, useSurfaceOptional, useSurfaceTile, useTiledSurface } from './surface/index.js';
-export { LayerStack, LayerStackItem, LayerStackProps } from './ui/layers/index.js';
 export { EventBus, EventListener, clearUndo, createEventBus, emptyStack, pushSnapshot, redo, undo } from './undo/index.js';
+import 'windease';
 import 'zustand/vanilla';
 
-/** A point in the space the instrument works in. */
-interface Vec3 {
+/** An annotation drawn over a curve plot: a shaded band across a range of x,
+ *  or a vertical line at one x. */
+type CurveMark = {
+    kind: 'band';
+    x: [number, number];
+    color?: string;
+} | {
+    kind: 'line';
     x: number;
-    y: number;
-    z: number;
-}
-/** An orbit camera as a trial view: where it looks from, and what it looks at.
- *  labkit does not turn this into a matrix — the host's renderer does. */
-interface OrbitView {
-    yaw: number;
-    pitch: number;
-    distance: number;
-    target: Vec3;
-}
-/** Just short of the pole. At exactly ±PI/2 the azimuth is undefined and the
- *  camera rolls, which reads as the model jumping rather than as a limit. */
-declare const PITCH_LIMIT: number;
-declare function clampPitch(pitch: number): number;
-declare function wrapYaw(yaw: number): number;
-/** The view a drag of (dx, dy) from `start` produces. Absolute against the drag
- *  start, so it can be re-applied any number of times without compounding. */
-declare function orbitAfterDrag(start: OrbitView, dx: number, dy: number): OrbitView;
-/** Multiplicative, so one notch covers the same proportion of the distance
- *  whether the camera is near or far. */
-declare function orbitAfterWheel(view: OrbitView, deltaY: number, minDistance: number, maxDistance: number): OrbitView;
-interface UseOrbitOptions {
-    view: OrbitView;
-    onViewChange: (v: OrbitView) => void;
-    /** Restored on double-click. Defaults to the view the hook first saw. */
-    home?: OrbitView;
-    minDistance?: number;
-    maxDistance?: number;
-}
-interface OrbitHandlers {
-    onWheel: (e: WheelEvent<HTMLElement>) => void;
-    onPointerDown: (e: PointerEvent<HTMLElement>) => void;
-    onPointerMove: (e: PointerEvent<HTMLElement>) => void;
-    onPointerUp: (e: PointerEvent<HTMLElement>) => void;
-    onDoubleClick: () => void;
-    isDragging: () => boolean;
+    color?: string;
+};
+/** Props for `<CurveField>`. */
+interface CurveFieldProps {
+    /** Flat [x0, y0, x1, y1, …] — matches how curve-as-array configs
+     *  serialize in JSON snapshots. */
+    values: number[];
+    min: number;
+    max: number;
+    step: number;
+    /** Plot width in CSS px. Caller sizes (typically uses a ResizeObserver). */
+    width: number;
+    /** Plot height in CSS px. Default 110. */
+    height?: number;
+    /** Flat default curve. When provided, a Reset button restores it. */
+    defaults?: readonly number[];
+    onChange: (next: number[]) => void;
+    /** Optional vertical marks overlaid on the plot (e.g. landmarks). */
+    marks?: readonly CurveMark[];
 }
-/** Pointer gestures over an orbit view: drag to turn, wheel or pinch to dolly,
- *  double-click to go home. The 3D peer of `usePanZoom`. */
-declare function useOrbit({ view, onViewChange, home, minDistance, maxDistance, }: UseOrbitOptions): OrbitHandlers;
-
-/** Which optional capabilities an instrument declared — what the trial
- *  consults to decide which chrome to show. */
-interface CapabilityFlags {
-    hasCanvas: boolean;
-    hasLayers: boolean;
-    hasDragDrop: boolean;
-    hasUndo: boolean;
-}
-/** Read an instrument's declared capabilities off its definition. */
-declare function detectCapabilities(instrument: Instrument<unknown, unknown>): CapabilityFlags;
-
-/** Identity at runtime; exists so an instrument's state and config types are
- *  inferred from the spec rather than having to be written out. */
-declare function defineInstrument<TS, TC>(spec: Instrument<TS, TC>): Instrument<TS, TC>;
+/**
+ * A function-domain (y = f(x), x ∈ [0,1]) curve editor with per-stop
+ * numeric readouts and flip buttons. Wraps weasel-ui's
+ * `CurveEditor`; consumers wanting the raw editor (2D paths,
+ * custom anchors) should import that instead.
+ */
+declare function CurveField({ values, min, max, step, width, height, defaults, onChange, marks, }: CurveFieldProps): react_jsx_runtime.JSX.Element;
 
-/** Whether a config schema is usable, and every problem found rather than
- *  just the first. */
-interface ValidationResult {
-    valid: boolean;
-    errors: string[];
+/** Props for `<Subpanel>`. */
+interface SubpanelProps {
+    title: ReactNode;
+    children: ReactNode;
+    className?: string;
 }
-/** Check a config schema for the mistakes that would otherwise surface as a
- *  silently broken control: empty or duplicate keys, unknown field types, and
- *  fields whose own constraints do not hold. */
-declare function validateConfigSchema(fields: ConfigField[]): ValidationResult;
-
-/** Props for `<Lab>`. */
-interface LabProps {
-    instruments: InstrumentList;
-    defaultInstrument: string;
-    storage?: StorageAdapter | null;
-    storageKey?: string;
-    mode?: LabMode;
+/** A typographic divider inside a property list: a small title flanked by a
+ *  rule. Purely a heading — use `<PropertyGroup>` for a bordered section. */
+declare function Subpanel({ title, children, className }: SubpanelProps): react_jsx_runtime.JSX.Element;
+/** Props for `<EffectCard>`. */
+interface EffectCardProps {
+    /** Card title rendered in the title bar (e.g. effect kind label or a select). */
+    title: ReactNode;
+    /** Optional badge/chip displayed before the remove button (e.g. primary value summary). */
+    primary?: ReactNode;
+    /** Optional accent color in any CSS color form. Sets --wzl-effect-card-accent on the card. */
+    accent?: string;
+    /** Optional ordinal badge that doubles as the drag handle (used by tail cards in SB). */
+    index?: number;
+    expanded?: boolean;
+    onToggleExpanded?: () => void;
+    onRemove?: () => void;
     /**
-     * Optional list of CSS colors used to compose the interstellar theme's
-     * cosmic backdrop. Each color becomes one radial-gradient blob on the
-     * dark void base. Order maps to a fixed spread of positions; extras wrap
-     * around. Ignored unless the resolved mode is dark.
+     * Drag-handle wiring. When provided, an inline handle (⋮⋮ icon or `index`)
+     * activates HTML5 drag on press. Consumer owns the drag/drop coordination —
+     * see EffectCardList for the batteries-included wrapper.
      */
-    nebula?: readonly string[];
-    title?: string;
+    draggable?: boolean;
+    onPressHandle?: () => void;
+    onReleaseHandle?: () => void;
+    onDragStart?: (e: React.DragEvent<HTMLDivElement>) => void;
+    onDragEnd?: (e: React.DragEvent<HTMLDivElement>) => void;
+    onDragOver?: (e: React.DragEvent<HTMLDivElement>) => void;
+    onDragLeave?: (e: React.DragEvent<HTMLDivElement>) => void;
+    onDrop?: (e: React.DragEvent<HTMLDivElement>) => void;
+    dragging?: boolean;
     children?: ReactNode;
+    className?: string;
 }
-/** The lab runtime: creates the store, provides it, and renders one trial
- *  per record in a grid. Each trial runs one of `instruments`. */
-declare function Lab({ instruments, defaultInstrument, storage, storageKey, mode, nebula, title, children, }: LabProps): react_jsx_runtime.JSX.Element;
-
-/** Lab-wide state and commands: the available instruments, the open
- *  trials and the operations over them, saved snapshots, and the color
- *  mode. */
-interface LabContextValue {
-    instruments: InstrumentList;
-    trials: TrialRecord[];
-    addTrial: (instrumentName: string) => void;
-    cloneTrial: (id: string) => void;
-    closeTrial: (id: string) => void;
-    resetTrial: (id: string) => void;
-    reorderTrials: (ids: readonly string[]) => void;
-    savedSnapshots: SavedSnapshot[];
-    saveSnapshot: (trialId: string, name?: string) => void;
-    loadSnapshot: (trialId: string, snapshotId: string) => void;
-    deleteSnapshot: (snapshotId: string) => void;
-    mode: LabMode;
-    setMode: (m: LabMode) => void;
+/** An accented, collapsible card for one item in a list of like things —
+ *  effects, layers, tails. The accent color rebinds the theme accent token
+ *  within the card, so its controls pick it up too. */
+declare function EffectCard({ title, primary, accent, index, expanded, onToggleExpanded, onRemove, draggable, onPressHandle, onReleaseHandle, onDragStart, onDragEnd, onDragOver, onDragLeave, onDrop, dragging, children, className, }: EffectCardProps): react_jsx_runtime.JSX.Element;
+/** The minimum an item must carry to appear in an `<EffectCardList>`. */
+interface EffectCardListItem {
+    id: string | number;
 }
-/** Context carrying the surrounding lab. Prefer `useLabContext`. */
-declare const LabContext: react.Context<LabContextValue | null>;
-/** The surrounding lab. Throws outside a `<Lab>`. */
-declare function useLabContext(): LabContextValue;
+/** Props for `<EffectCardList>`. */
+interface EffectCardListProps<T extends EffectCardListItem> {
+    items: ReadonlyArray<T>;
+    renderItem: (item: T, helpers: {
+        isExpanded: boolean;
+        isDragging: boolean;
+        toggleExpanded: () => void;
+        cardProps: Pick<EffectCardProps, 'expanded' | 'dragging' | 'draggable' | 'onToggleExpanded' | 'onPressHandle' | 'onReleaseHandle' | 'onDragStart' | 'onDragEnd' | 'onDragOver' | 'onDragLeave' | 'onDrop'>;
+    }) => ReactNode;
+    onReorder: (sourceId: T['id'], targetId: T['id'], position: 'before' | 'after') => void;
+    /** Optional rendered when the list is empty. */
+    empty?: ReactNode;
+    /** IDs to render expanded on first mount. Defaults to all collapsed. */
+    defaultExpandedIds?: ReadonlyArray<T['id']>;
+}
+/** A drag-reorderable list of `<EffectCard>`s. Owns the expanded and dragging
+ *  state and hands it back to `renderItem`, so the caller only supplies each
+ *  card's contents. */
+declare function EffectCardList<T extends EffectCardListItem>({ items, renderItem, onReorder, empty, defaultExpandedIds, }: EffectCardListProps<T>): react_jsx_runtime.JSX.Element;
 
-/** Props for `<LabShell>`. */
-interface LabShellProps {
-    title: string;
+/** Props for `<PropertyGroup>`. */
+interface PropertyGroupProps {
+    /** Title rendered between two rules at the top of the group. */
+    title: ReactNode;
+    /** When true the group renders nothing — useful for conditional sections. */
+    hidden?: boolean;
     children: ReactNode;
-    /** Optional content rendered into the header (e.g., action buttons). */
-    header?: ReactNode;
-    /** Optional content rendered into the footer. */
-    footer?: ReactNode;
-    /** Color mode. "auto" (default) follows prefers-color-scheme. */
-    mode?: LabMode;
+    className?: string;
+    /**
+     * How rows pack into the 2-column grid.
+     *   - `'auto-color'` (default): only color rows pair side-by-side; everything
+     *     else spans the full width.
+     *   - `'pairs'`: every row auto-places into the 2-column grid two-per-row.
+     */
+    pack?: 'auto-color' | 'pairs';
 }
-/** Page frame for a lab: a titled header, a body, and an optional footer,
- *  themed for the resolved color mode. Presentational only — use `<Lab>` when
- *  the trial runtime is wanted too. */
-declare function LabShell({ title, children, header, footer, mode }: LabShellProps): react_jsx_runtime.JSX.Element;
+/**
+ * Visually-bordered group inside a PropertyList. Use to scope a set of
+ * related rows under a heading (e.g. "Aqua", "Bevel", "Dome" sections
+ * inside a fill effect's controls).
+ */
+declare function PropertyGroup({ title, hidden, children, className, pack, }: PropertyGroupProps): react_jsx_runtime.JSX.Element | null;
 
-/** A tile's persisted extent, keyed by the id its caller gave it. Grid resizes
- *  write `span`; `size` is here because a strategy swap would write that. */
-type TrialLayout = Record<string, {
-    size?: {
-        w?: number;
-        h?: number;
-    };
-    span?: {
-        cols?: number;
-        rows?: number;
-    };
-}>;
-interface WorkspaceProps {
+/** Props for `<PropertyPanel>`. */
+interface PropertyPanelProps {
+    title?: ReactNode;
+    children: ReactNode;
+    className?: string;
+}
+/** A titled panel holding property rows — the sidebar container the rest of
+ *  this module's components fill. */
+declare function PropertyPanel({ title, children, className }: PropertyPanelProps): react_jsx_runtime.JSX.Element;
+/** How a property list packs its rows into two columns. */
+type PropertyListPack = 'auto-color' | 'pairs';
+/** Props for `<PropertyList>`. */
+interface PropertyListProps {
     children: ReactNode;
+    className?: string;
     /**
-     * Stable id per child, positionally matched. Supply these whenever a tile
-     * can be closed from the middle: without them a tile is identified by its
-     * position, so closing one shifts every id after it and the panes inherit
-     * each other's dragged extents. `layout` and `reorderable` both key off
-     * these, so neither means much without them.
+     * How rows pack into the 2-column grid.
+     *   - `'auto-color'` (default): only color rows pair side-by-side; everything
+     *     else spans the full width. Right for sparse top-level panels.
+     *   - `'pairs'`: every row auto-places into the 2-column grid two-per-row.
+     *     Headers and subpanels still span the full width; wrap any other
+     *     full-width child in `<PropertySpan>`. Right for dense effect bodies.
      */
-    ids?: readonly string[];
-    /** Draggable seams between tiles. Off by default — an even tiling is the
-     *  behavior every existing caller has. */
-    resizable?: boolean;
-    /** Let a tile be dragged to a new position. Off by default. The grid never
-     *  reorders `children` itself: it reports the order a drop would produce and
-     *  the caller commits it. */
-    reorderable?: boolean;
-    /** The full id list a drop would produce, in its new order. */
-    onReorder?: (ids: string[]) => void;
-    /** Extents from a previous session, applied to tiles as they register. */
-    layout?: TrialLayout;
-    /** Fires when a tile's extent changes. Persist it and hand it back as
-     *  `layout` to make a resize survive a reload. */
-    onLayoutChange?: (layout: TrialLayout) => void;
-    gap?: number;
-    padding?: number;
+    pack?: PropertyListPack;
+}
+/**
+ * Grid container for PropertyRows. Use standalone for chrome-less layouts, or
+ * nest inside <PropertyPanel/> for the standard glass card.
+ */
+declare function PropertyList({ children, className, pack }: PropertyListProps): react_jsx_runtime.JSX.Element;
+/** Props for `<PropertySpan>`. */
+interface PropertySpanProps {
+    children: ReactNode;
+    className?: string;
+}
+/**
+ * Wrapper that makes an arbitrary child span both columns of a
+ * `<PropertyList pack="pairs">`, a `<PropertyGroup pack="pairs">` body, or a
+ * `<Subpanel>`. `<PropertyRow span>` covers the row case; this covers
+ * everything else a consumer puts in the grid.
+ */
+declare function PropertySpan({ children, className }: PropertySpanProps): react_jsx_runtime.JSX.Element;
+/** Which control shape a row holds, which decides its intrinsic layout. */
+type PropertyRowVariant = 'default' | 'color' | 'checkbox';
+/** Whether a row's label sits above its control or beside it. */
+type PropertyRowLayout = 'block' | 'inline';
+/** Props for `<PropertyRow>`. */
+interface PropertyRowProps {
+    label: ReactNode;
+    /** Right-aligned readout shown next to the label (e.g. current value). */
+    readout?: ReactNode;
     /**
-     * Fixed tiling extent. Omit in an app — the grid measures its own box. Supply
-     * it where nothing measures, notably jsdom: at a zero measurement the grid
-     * renders no tiles at all.
+     * Help text for the row, shown in a tooltip off an ⓘ affordance beside the
+     * label. Empty or absent renders no affordance.
      */
-    viewport?: {
-        w: number;
-        h: number;
-    };
+    description?: string;
+    variant?: PropertyRowVariant;
+    /**
+     * Label position relative to the control. "block" (default) stacks
+     * label above control; "inline" places the label to the left.
+     * Color and checkbox variants are always inline by their own nature.
+     */
+    layout?: PropertyRowLayout;
+    /**
+     * Take the full width of the enclosing grid. Only has an effect inside a
+     * `<PropertyList pack="pairs">` or a `<Subpanel>`; elsewhere rows are already
+     * full width.
+     */
+    span?: boolean;
+    children: ReactNode;
+    htmlFor?: string;
+    className?: string;
+}
+/** The label-plus-control frame every typed row below is built from. Use it
+ *  directly for a control this module does not cover. */
+declare function PropertyRow({ label, readout, description, variant, layout, span, children, htmlFor, className, }: PropertyRowProps): react_jsx_runtime.JSX.Element;
+/** Props for `<SliderRow>`. */
+interface SliderRowProps {
+    label: ReactNode;
+    value: number;
+    min: number;
+    max: number;
+    step?: number;
+    onChange: (next: number) => void;
+    /** Override how the value is rendered next to the label. Defaults to `value.toString()`. */
+    format?: (value: number) => ReactNode;
+    /**
+     * Optional suffix rendered next to the readout. A string becomes a
+     * baseline-aligned dim "word" unit (e.g. "px"); pass JSX like `<sup>°</sup>`
+     * to get the browser's native super positioning for symbol units.
+     */
+    unit?: ReactNode;
+    layout?: PropertyRowLayout;
+    description?: string;
+}
+/** A bounded number edited by dragging, with a live readout whose precision
+ *  follows `step`. */
+declare function SliderRow({ label, value, min, max, step, onChange, format, unit, layout, description, }: SliderRowProps): react_jsx_runtime.JSX.Element;
+/** Props for `<ColorRow>`. */
+interface ColorRowProps {
+    label: ReactNode;
+    value: string;
+    onChange: (next: string) => void;
+    /** 0..1 alpha. When provided, a translucent slider renders beneath the swatch. */
+    alpha?: number;
+    onAlphaChange?: (next: number) => void;
+    /**
+     * Render the alpha track as inert (dimmed, no thumb, not-allowed cursor).
+     * Use when the color's consumer drops alpha so the affordance reads dead.
+     */
+    alphaDisabled?: boolean;
+    description?: string;
+}
+/** A color swatch, optionally with an alpha slider beneath it. */
+declare function ColorRow({ label, value, onChange, alpha, onAlphaChange, alphaDisabled, description, }: ColorRowProps): react_jsx_runtime.JSX.Element;
+/** Props for `<CheckboxRow>`. */
+interface CheckboxRowProps {
+    label: ReactNode;
+    value: boolean;
+    onChange: (next: boolean) => void;
+    description?: string;
+}
+/** A boolean checkbox. */
+declare function CheckboxRow({ label, value, onChange, description }: CheckboxRowProps): react_jsx_runtime.JSX.Element;
+/** Props for `<TextRow>`. */
+interface TextRowProps {
+    label: ReactNode;
+    value: string;
+    onChange: (next: string) => void;
+    placeholder?: string;
+    maxLength?: number;
+    layout?: PropertyRowLayout;
+    description?: string;
+}
+/** A single-line text input. */
+declare function TextRow({ label, value, onChange, placeholder, maxLength, layout, description, }: TextRowProps): react_jsx_runtime.JSX.Element;
+/** Props for `<NumberRow>`. */
+interface NumberRowProps {
+    label: ReactNode;
+    value: number;
+    onChange: (next: number) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    placeholder?: string;
+    layout?: PropertyRowLayout;
+    description?: string;
+}
+/** A number typed directly. Reach for `<SliderRow>` when the range matters
+ *  more than the exact value. */
+declare function NumberRow({ label, value, onChange, min, max, step, placeholder, layout, description, }: NumberRowProps): react_jsx_runtime.JSX.Element;
+interface PropertyOption<T extends string> {
+    value: T;
+    label: ReactNode;
+}
+/** Props for `<SelectRow>`. */
+interface SelectRowProps<T extends string> {
+    label: ReactNode;
+    value: T;
+    options: ReadonlyArray<PropertyOption<T>>;
+    onChange: (next: T) => void;
+    layout?: PropertyRowLayout;
+    description?: string;
+}
+/** A dropdown over a fixed set of choices. Prefer `<ToggleRow>` when there
+ *  are only two or three and they should all stay visible. */
+declare function SelectRow<T extends string>({ label, value, options, onChange, layout, description, }: SelectRowProps<T>): react_jsx_runtime.JSX.Element;
+/** Props for `<ToggleRow>`. */
+interface ToggleRowProps<T extends string> {
+    label: ReactNode;
+    value: T;
+    options: ReadonlyArray<PropertyOption<T>>;
+    onChange: (next: T) => void;
+    layout?: PropertyRowLayout;
+    description?: string;
+}
+/** A segmented control: the same choice as a select, with every option
+ *  visible at once. */
+declare function ToggleRow<T extends string>({ label, value, options, onChange, layout, description, }: ToggleRowProps<T>): react_jsx_runtime.JSX.Element;
+
+/** A point in the space the instrument works in. */
+interface Vec3 {
+    x: number;
+    y: number;
+    z: number;
+}
+/** An orbit camera as a trial view: where it looks from, and what it looks at.
+ *  labkit does not turn this into a matrix — the host's renderer does. */
+interface OrbitView {
+    yaw: number;
+    pitch: number;
+    distance: number;
+    target: Vec3;
+}
+/** Just short of the pole. At exactly ±PI/2 the azimuth is undefined and the
+ *  camera rolls, which reads as the model jumping rather than as a limit. */
+declare const PITCH_LIMIT: number;
+declare function clampPitch(pitch: number): number;
+declare function wrapYaw(yaw: number): number;
+/** The view a drag of (dx, dy) from `start` produces. Absolute against the drag
+ *  start, so it can be re-applied any number of times without compounding. */
+declare function orbitAfterDrag(start: OrbitView, dx: number, dy: number): OrbitView;
+/** Multiplicative, so one notch covers the same proportion of the distance
+ *  whether the camera is near or far. */
+declare function orbitAfterWheel(view: OrbitView, deltaY: number, minDistance: number, maxDistance: number): OrbitView;
+interface UseOrbitOptions {
+    view: OrbitView;
+    onViewChange: (v: OrbitView) => void;
+    /** Restored on double-click. Defaults to the view the hook first saw. */
+    home?: OrbitView;
+    minDistance?: number;
+    maxDistance?: number;
+}
+interface OrbitHandlers {
+    onWheel: (e: WheelEvent<HTMLElement>) => void;
+    onPointerDown: (e: PointerEvent<HTMLElement>) => void;
+    onPointerMove: (e: PointerEvent<HTMLElement>) => void;
+    onPointerUp: (e: PointerEvent<HTMLElement>) => void;
+    onDoubleClick: () => void;
+    isDragging: () => boolean;
+}
+/** Pointer gestures over an orbit view: drag to turn, wheel or pinch to dolly,
+ *  double-click to go home. The 3D peer of `usePanZoom`. */
+declare function useOrbit({ view, onViewChange, home, minDistance, maxDistance, }: UseOrbitOptions): OrbitHandlers;
+
+/** Shared chaining surface. Every method clones, so a node can be reused as a
+ *  base for several leaves without one bleeding into the next. */
+declare abstract class BaseNode<T> implements ConfigNode<T> {
+    readonly annotations: Readonly<Annotations>;
+    readonly options: Readonly<NodeOptions>;
+    abstract readonly kind: string | null;
+    readonly default: T;
+    constructor(defaultValue: T, annotations?: Readonly<Annotations>, options?: Readonly<NodeOptions>);
+    /** Clone into the same subclass. Subclasses with extra constructor
+     *  arguments override this. */
+    protected with(annotations: Annotations, options: NodeOptions): this;
+    protected ann(patch: Annotations): this;
+    protected opt(patch: NodeOptions): this;
+    /** Human-readable label. Defaults to the key, title-cased. */
+    label(name: string): this;
+    /** Longer help text, surfaced as a tooltip on the row label. */
+    describe(description: string): this;
+    /** Omit from the panel unless it is asked to show hidden leaves. */
+    hidden(): this;
+    /** Pair with a sibling sharing this id, side-by-side on one row. */
+    pair(pair: string): this;
+    /** Render under a named section heading. */
+    section(section: string): this;
+    /** Show this row only while the predicate holds. Presentational — the value
+     *  stays in config and the instrument still reads it. */
+    showIf(predicate: (config: Record<string, unknown>) => boolean): this;
+    /** Draw this one row yourself, keeping the kind, default and validation. */
+    render(renderer: ControlRenderer): this;
+}
+declare class NumberNode extends BaseNode<number> {
+    readonly kind = "number";
+    /** Bound the value. A number with both bounds renders as a slider. */
+    range(min: number, max: number): this;
+    step(step: number): this;
+    /** Force a slider even without both bounds. */
+    slider(): this;
+    /** Force a typed input even when both bounds are set. */
+    input(): this;
+}
+declare class BooleanNode extends BaseNode<boolean> {
+    readonly kind = "boolean";
+    /** Ask for a switch. `ControlPanel` still draws a checkbox; weasel-ui's
+     *  `PrefsForm` honors the distinction. */
+    toggle(): this;
+}
+declare class StringNode extends BaseNode<string> {
+    readonly kind = "string";
+    placeholder(placeholder: string): this;
+    maxLength(maxLength: number): this;
+    /** Milliseconds to debounce live writes. 0 commits every keystroke. */
+    debounce(debounceMs: number): this;
+}
+declare class ColorNode extends BaseNode<string> {
+    readonly kind = "color";
+}
+declare class EnumNode<T extends string> extends BaseNode<T> {
+    readonly kind = "enum";
+    /** Render as a segmented control rather than a select. */
+    radio(): this;
+    /** Relabel the choices. Named `labels` rather than `options` because
+     *  `options` is the node's own extras bag. */
+    labels(options: readonly ConfigOption[]): this;
+}
+/** A leaf whose kind the rule chain decides. */
+declare class ValueNode<T> extends BaseNode<T> {
+    readonly kind: null;
+}
+/** A leaf of a kind labkit does not ship a row for. */
+declare class CustomNode<T> extends BaseNode<T> {
+    readonly kind: string;
+    constructor(kind: string, defaultValue: T, annotations?: Readonly<Annotations>, options?: Readonly<NodeOptions>);
+    protected with(annotations: Annotations, options: NodeOptions): this;
 }
 /**
- * Auto-balanced tiling of trials, `ceil(sqrt(n))` columns wide.
+ * Builds an instrument's config: the values, their types, and how each is
+ * edited, in one declaration.
  *
- * Tiles are absolutely positioned at the rects `gridStrategy` computes, not
- * laid out by CSS — `windease/styles.css` (folded into
- * `@weasel-js/labkit/styles.css`) carries the rules that positioning depends on.
+ * ```ts
+ * const config = f.schema({
+ *   showGrid: f.boolean(true),
+ *   cellSize: f.number(20).range(5, 80).step(5).label('Grid spacing'),
+ * })
+ * ```
  */
-declare function Workspace({ children, ids, resizable, reorderable, onReorder, layout, onLayoutChange, gap, padding, viewport, }: WorkspaceProps): react_jsx_runtime.JSX.Element;
+declare const f: {
+    number: (def: number) => NumberNode;
+    boolean: (def: boolean) => BooleanNode;
+    string: (def: string) => StringNode;
+    color: (def: string) => ColorNode;
+    /** A fixed set of choices. The default's literal type flows into the config
+     *  type, so `f.enum('fast', ['fast', 'accurate'])` gives
+     *  `'fast' | 'accurate'` with no `as const`. */
+    enum: <const T extends string>(def: T, options: readonly T[] | readonly ConfigOption[]) => EnumNode<T>;
+    /** A leaf with no declared kind: the rule chain decides, which is how a lab
+     *  states a convention like "every `*Color` key is a color picker". */
+    value: <T>(def: T) => ValueNode<T>;
+    /** A leaf of a kind a lab supplies the control for, through `controls`. */
+    custom: <T>(kind: string, def: T, validate?: (leaf: ToolPrefLeaf) => string[]) => CustomNode<T>;
+    /** Collect leaves into an instrument's config. */
+    schema<S extends Record<string, ConfigNode>>(nodes: S): ConfigSchema<InferConfig<S>>;
+};
 
-/** The 2D view labkit has always shipped, and what a trial gets when it names no
- *  other. Re-exported under its own name so a consumer can say which it means. */
-type ViewTransform2D = ViewTransform;
-declare const DEFAULT_VIEW: ViewTransform2D;
-/** A trial's view is opaque to labkit, so anything that needs the 2D shape — the
- *  zoom chrome, `CanvasStack` — asks for it and handles not getting it. */
-declare function as2DView(view: unknown): ViewTransform2D | null;
+/**
+ * Adapt a legacy `configSchema(): ConfigField[]` into the resolved shape, so
+ * both instrument paths reach one renderer.
+ *
+ * Rules do not run here: a hand-written `ConfigField` already states its label
+ * and control, which is everything the rule chain would have inferred.
+ */
+declare function fromConfigFields(fields: readonly ConfigField[]): ResolvedConfig;
 
-type TokenValue = string | number | readonly (string | number)[];
 /**
- * A single design token as authored, before aliases are resolved: a DTCG-shaped
- * `{ type, value }` pair where `value` may still be a `{ref}` to another token.
+ * Resolve a schema into the vocabulary weasel-ui renders, running each leaf
+ * through the consumer's rules and then labkit's own.
+ *
+ * The group is flat — every leaf is a direct child — so a leaf's path is its
+ * config key and both `ControlPanel` and `PrefsForm` address it identically.
  */
-interface RawToken {
-    readonly type: string;
-    readonly value: TokenValue;
-    /** Render the referenced color at this alpha, 0–1. */
-    readonly alpha?: number | undefined;
-    readonly description?: string | undefined;
-}
-/** A token graph flattened to one level, keyed by token name (no `--wzl-`
- *  prefix). Still unresolved — see `ResolvedTokenMap` for the output side. */
-type FlatTokens = Record<string, RawToken>;
+declare function resolveConfigSchema<TC>(schema: ConfigSchema<TC>, rules?: readonly ConfigRule[]): ResolvedConfig;
 
+/** `cellSize` -> `Cell size`. Splits camelCase without shattering acronyms. */
+declare function titleCase(key: string): string;
 /**
- * A theme: a named set of design tokens, organized into a mode-invariant layer
- * plus one layer per mode (light, dark, …), optionally extending another theme.
- * Tokens are held unresolved — aliases between them are collapsed later by
- * `resolveTheme`, so an override of a base primitive still reaches everything
- * that references it.
+ * labkit's own inference, expressed in the same vocabulary a consumer
+ * extends. Runs after the consumer's rules, so a lab always wins.
+ *
+ * If one of these ever needs something a `ConfigRule` cannot express, the
+ * seam is too weak — that is the point of writing them this way.
  */
-interface Theme {
-    readonly name: string;
-    readonly extends: Theme | null;
-    readonly defaultMode: string;
-    readonly tokens: FlatTokens;
-    readonly modes: Readonly<Record<string, FlatTokens>>;
-}
+declare const builtinRules: readonly ConfigRule[];
+/**
+ * Fold a rule chain into one leaf patch. Gap-filling: a property already
+ * settled is never overwritten, so the accumulator seeded with the author's
+ * annotations beats every rule, and earlier rules beat later ones.
+ */
+declare function applyRules(seed: LeafPatch, ctx: Omit<ConfigRuleContext, 'leaf'>, rules: readonly ConfigRule[]): LeafPatch;
 
 /**
- * labkit's theme: a cosmic dark and a warm parchment light, extending the
- * built-in weasel theme. Authored as DTCG and loaded at import time — the
- * interchange path a theme exported from a design tool would take.
+ * An instrument's controls, resolved against the surrounding lab's rules.
+ *
+ * Resolution cannot happen in `defineInstrument` — rules are lab-scoped and
+ * that runs at module load — so it happens here, at render. Both instrument
+ * paths land in the same shape, so callers never branch on which was used.
  */
-declare const interstellarTheme: Theme;
+declare function useConfigSchema(instrument: Instrument<any, any, any>): ResolvedConfig;
 
-/** What a trial hands its toolbar: which instrument is running, the undo
- *  state and commands, the zoom controls, and the snapshot commands. */
-interface TrialToolbarContext {
-    trialId: string;
-    instrumentName: string;
-    hasUndo: boolean;
-    canUndo: boolean;
-    canRedo: boolean;
-    undo: () => void;
-    redo: () => void;
-    zoom: number;
-    setZoom: (z: number) => void;
-    zoomIn: () => void;
-    zoomOut: () => void;
-    resetZoom: () => void;
-    hasCanvas: boolean;
-    savedSnapshots: SavedSnapshot[];
-    saveSnapshot: (name?: string) => void;
-    loadSnapshot: (snapshotId: string) => void;
-    clone: () => void;
-    reset: () => void;
-    close: () => void;
-    isLastTrial: boolean;
-}
-/** What a trial hands its sidebar: the instrument's config schema, its
- *  current values, and the setter. */
-interface TrialSidebarContext {
-    trialId: string;
-    instrumentName: string;
-    configFields: ConfigField[];
-    config: unknown;
-    setConfig: (key: string, value: unknown) => void;
-}
-/** What a trial hands its status bar. */
-interface TrialStatusBarContext {
-    trialId: string;
-    instrumentName: string;
-    /** Null when the trial holds a view that is not the 2D one. */
-    zoom: number | null;
-}
-/** Replaces a trial's toolbar. Receives everything the default one uses,
- *  so a custom toolbar need not reach into the store. */
-type ToolbarSlot = (ctx: TrialToolbarContext) => ReactNode;
-/** Replaces a trial's sidebar. */
-type SidebarSlot = (ctx: TrialSidebarContext) => ReactNode;
-/** Replaces a trial's status bar. */
-type StatusBarSlot = (ctx: TrialStatusBarContext) => ReactNode;
+/**
+ * Whether a leaf's row should be drawn right now.
+ *
+ * `hidden` is the leaf's own static flag; `showIf` is the schema's predicate
+ * over the live config. Both are presentational — a hidden leaf keeps its
+ * value and the instrument still reads it.
+ */
+declare function isLeafVisible(resolved: ResolvedConfig, path: string, config: Record<string, unknown>, showHidden?: boolean): boolean;
 
-/** Props for `<DefaultSidebar>`. */
-interface DefaultSidebarProps {
-    ctx: TrialSidebarContext;
+/** An instrument as it is written: either the legacy `defaultConfig` (plus an
+ *  optional `configSchema`), or a `config` schema that supplies both. */
+type InstrumentSpec<TS, TC, TItem = unknown> = Instrument<TS, TC, TItem> | (Omit<Instrument<TS, TC, TItem>, 'defaultConfig'> & {
+    config: ConfigSchema<TC>;
+});
+/**
+ * Normalizes an instrument spec, and infers its state and config types from
+ * the literal rather than making them be written out.
+ *
+ * A spec declaring `config` gets its `defaultConfig` synthesized from the
+ * schema, so nothing downstream branches on which way the config was
+ * declared. A spec written the legacy way is returned unchanged, by
+ * reference.
+ *
+ * Resolving the schema into controls does not happen here: rules are
+ * lab-scoped and this runs at module load. `useConfigSchema` does that.
+ *
+ * TypeScript infers all three type arguments or none, so a call that names
+ * `TS` and `TC` leaves `TItem` at `unknown` and a job's `onItem` needs a cast.
+ * Name the item type too, or pass no type arguments at all.
+ */
+declare function defineInstrument<TS, TC, TItem = unknown>(spec: InstrumentSpec<TS, TC, TItem>): Instrument<TS, TC, TItem>;
+
+/** Whether a config schema is usable, and every problem found rather than
+ *  just the first. */
+interface ValidationResult {
+    valid: boolean;
+    errors: string[];
 }
-/** The sidebar a trial renders when no `sidebar` slot is supplied: a
- *  control panel over the instrument's config schema. */
-declare function DefaultSidebar({ ctx }: DefaultSidebarProps): react_jsx_runtime.JSX.Element;
+/** Check a config schema for the mistakes that would otherwise surface as a
+ *  silently broken control: empty or duplicate keys, and fields whose own
+ *  constraints do not hold.
+ *
+ *  An unrecognized type is not an error — a lab supplies controls for its own
+ *  kinds through `ControlPanel`'s `renderers`, and this cannot see them. Such
+ *  a field simply has no constraints to check here. */
+declare function validateConfigSchema(fields: ConfigField[]): ValidationResult;
+
+/** Props for `<Lab>`. */
+interface LabProps {
+    instruments: InstrumentList;
+    defaultInstrument: string;
+    storage?: StorageAdapter | null;
+    storageKey?: string;
+    mode?: LabMode;
+    /**
+     * Optional list of CSS colors used to compose the interstellar theme's
+     * cosmic backdrop. Each color becomes one radial-gradient blob on the
+     * dark void base. Order maps to a fixed spread of positions; extras wrap
+     * around. Ignored unless the resolved mode is dark.
+     */
+    nebula?: readonly string[];
+    title?: string;
+    /** Rendered in the shell's footer, below the workspace. */
+    footer?: ReactNode;
+    /** Contributions added to every trial's chrome, after the instrument's own. */
+    chrome?: readonly TrialContribution[];
+    /** Built-in contribution ids to drop. Throws on an id that is not there. */
+    suppress?: readonly string[];
+    /** Tools offered lab-wide. A trial whose instrument declares none of its own
+     *  reflects and writes this slot. */
+    tools?: readonly TrialTool[];
+    /** Rules run over every instrument's config leaves, before labkit's own
+     *  inference — where a lab states a convention once instead of annotating
+     *  each field. Memoize or hoist. */
+    configRules?: readonly ConfigRule[];
+    /** Control overrides and app-defined kinds for every trial's settings panel.
+     *  Keys are config paths (checked first) or leaf kinds. Memoize or hoist. */
+    controls?: Record<string, ControlRenderer>;
+    children?: ReactNode;
+}
+/** The lab runtime: creates the store, provides it, and renders one trial
+ *  per record in a grid. Each trial runs one of `instruments`. */
+declare function Lab({ instruments, defaultInstrument, storage, storageKey, mode, nebula, title, footer, chrome, suppress, tools, configRules, controls, children, }: LabProps): react_jsx_runtime.JSX.Element;
+
+/** Lab-wide state and commands: the available instruments, the open
+ *  trials and the operations over them, saved snapshots, and the color
+ *  mode. */
+interface LabContextValue {
+    instruments: InstrumentList;
+    trials: TrialRecord[];
+    addTrial: (instrumentName: string) => void;
+    cloneTrial: (id: string) => void;
+    closeTrial: (id: string) => void;
+    resetTrial: (id: string) => void;
+    reorderTrials: (ids: readonly string[]) => void;
+    savedSnapshots: SavedSnapshot[];
+    saveSnapshot: (trialId: string, name?: string) => void;
+    loadSnapshot: (trialId: string, snapshotId: string) => void;
+    deleteSnapshot: (snapshotId: string) => void;
+    mode: LabMode;
+    setMode: (m: LabMode) => void;
+    /** Lab-wide rules run over every instrument's config leaves, before
+     *  labkit's own inference. */
+    configRules?: readonly ConfigRule[];
+    /** Lab-wide control overrides, keyed by config path or by leaf kind. */
+    controls?: Record<string, ControlRenderer>;
+}
+/** Context carrying the surrounding lab. Prefer `useLabContext`. */
+declare const LabContext: react.Context<LabContextValue | null>;
+/** The surrounding lab. Throws outside a `<Lab>`. */
+declare function useLabContext(): LabContextValue;
 
-/** Props for `<DefaultStatusBar>`. */
-interface DefaultStatusBarProps {
-    ctx: TrialStatusBarContext;
+/** Props for `<LabPalette>`. */
+interface LabPaletteProps {
+    tools: readonly TrialTool[];
 }
-/** The status bar a trial renders when no `statusBar` slot is supplied:
- *  the instrument's name, and the zoom when the trial's view has one. */
-declare function DefaultStatusBar({ ctx }: DefaultStatusBarProps): react_jsx_runtime.JSX.Element;
+/** The lab's tool strip. Writes the lab's tool slot, which every trial whose
+ *  instrument declares no tools of its own resolves to. */
+declare function LabPalette({ tools }: LabPaletteProps): react_jsx_runtime.JSX.Element;
 
-/** Props for `<DefaultToolbar>`. */
-interface DefaultToolbarProps {
-    ctx: TrialToolbarContext;
+/** Props for `<LabShell>`. */
+interface LabShellProps {
+    title: string;
+    children: ReactNode;
+    /** Optional content rendered into the header (e.g., action buttons). */
+    header?: ReactNode;
+    /** Optional content rendered into the footer. */
+    footer?: ReactNode;
+    /** Color mode. "auto" (default) follows prefers-color-scheme. */
+    mode?: LabMode;
 }
-/** The toolbar a trial renders when no `toolbar` slot is supplied. Only
- *  shows the controls the instrument's declared capabilities support. */
-declare function DefaultToolbar({ ctx }: DefaultToolbarProps): react_jsx_runtime.JSX.Element;
+/** Page frame for a lab: a titled header, a body, and an optional footer,
+ *  themed for the resolved color mode. Presentational only — use `<Lab>` when
+ *  the trial runtime is wanted too. */
+declare function LabShell({ title, children, header, footer, mode }: LabShellProps): react_jsx_runtime.JSX.Element;
+
+/** A tile's persisted extent, keyed by the id its caller gave it. Grid resizes
+ *  write `span`; `size` is here because a strategy swap would write that. */
+type TrialLayout = Record<string, {
+    size?: {
+        w?: number;
+        h?: number;
+    };
+    span?: {
+        cols?: number;
+        rows?: number;
+    };
+}>;
+interface WorkspaceProps {
+    children: ReactNode;
+    /**
+     * Stable id per child, positionally matched. Supply these whenever a tile
+     * can be closed from the middle: without them a tile is identified by its
+     * position, so closing one shifts every id after it and the panes inherit
+     * each other's dragged extents. `layout` and `reorderable` both key off
+     * these, so neither means much without them.
+     */
+    ids?: readonly string[];
+    /** Draggable seams between tiles. Off by default — an even tiling is the
+     *  behavior every existing caller has. */
+    resizable?: boolean;
+    /** Let a tile be dragged to a new position. Off by default. The grid never
+     *  reorders `children` itself: it reports the order a drop would produce and
+     *  the caller commits it. */
+    reorderable?: boolean;
+    /** The full id list a drop would produce, in its new order. */
+    onReorder?: (ids: string[]) => void;
+    /** Extents from a previous session, applied to tiles as they register. */
+    layout?: TrialLayout;
+    /** Fires when a tile's extent changes. Persist it and hand it back as
+     *  `layout` to make a resize survive a reload. */
+    onLayoutChange?: (layout: TrialLayout) => void;
+    gap?: number;
+    padding?: number;
+    /**
+     * Fixed tiling extent. Omit in an app — the grid measures its own box. Supply
+     * it where nothing measures, notably jsdom: at a zero measurement the grid
+     * renders no tiles at all.
+     */
+    viewport?: {
+        w: number;
+        h: number;
+    };
+}
+/**
+ * Auto-balanced tiling of trials, `ceil(sqrt(n))` columns wide.
+ *
+ * Tiles are absolutely positioned at the rects `gridStrategy` computes, not
+ * laid out by CSS — `windease/styles.css` (folded into
+ * `@weasel-js/labkit/styles.css`) carries the rules that positioning depends on.
+ */
+declare function Workspace({ children, ids, resizable, reorderable, onReorder, layout, onLayoutChange, gap, padding, viewport, }: WorkspaceProps): react_jsx_runtime.JSX.Element;
+
+/** The 2D view labkit has always shipped, and what a trial gets when it names no
+ *  other. Re-exported under its own name so a consumer can say which it means. */
+type ViewTransform2D = ViewTransform;
+declare const DEFAULT_VIEW: ViewTransform2D;
+/** A trial's view is opaque to labkit, so anything that needs the 2D shape — the
+ *  zoom chrome, `CanvasStack` — asks for it and handles not getting it. */
+declare function as2DView(view: unknown): ViewTransform2D | null;
+
+type TokenValue = string | number | readonly (string | number)[];
+/**
+ * A single design token as authored, before aliases are resolved: a DTCG-shaped
+ * `{ type, value }` pair where `value` may still be a `{ref}` to another token.
+ */
+interface RawToken {
+    readonly type: string;
+    readonly value: TokenValue;
+    /** Render the referenced color at this alpha, 0–1. */
+    readonly alpha?: number | undefined;
+    readonly description?: string | undefined;
+}
+/** A token graph flattened to one level, keyed by token name (no `--wzl-`
+ *  prefix). Still unresolved — see `ResolvedTokenMap` for the output side. */
+type FlatTokens = Record<string, RawToken>;
+
+/**
+ * A theme: a named set of design tokens, organized into a mode-invariant layer
+ * plus one layer per mode (light, dark, …), optionally extending another theme.
+ * Tokens are held unresolved — aliases between them are collapsed later by
+ * `resolveTheme`, so an override of a base primitive still reaches everything
+ * that references it.
+ */
+interface Theme {
+    readonly name: string;
+    readonly extends: Theme | null;
+    readonly defaultMode: string;
+    readonly tokens: FlatTokens;
+    readonly modes: Readonly<Record<string, FlatTokens>>;
+}
+
+/**
+ * labkit's theme: a cosmic dark and a warm parchment light, extending the
+ * built-in weasel theme. Authored as DTCG and loaded at import time — the
+ * interchange path a theme exported from a design tool would take.
+ */
+declare const interstellarTheme: Theme;
 
 /** Props for `<Trial>`. */
 interface TrialProps {
     id: string;
+    /** Contributions the lab adds to this trial's chrome, merged after the
+     *  instrument's own. */
+    chrome?: readonly TrialContribution[];
+    /** Built-in contribution ids to drop. Throws on an id that is not there. */
+    suppress?: readonly string[];
 }
 /** Renders one trial from the lab store: looks up its record and
  *  instrument, and mounts the instrument inside the trial chrome. */
-declare function Trial({ id }: TrialProps): react_jsx_runtime.JSX.Element;
+declare function Trial({ id, chrome, suppress }: TrialProps): react_jsx_runtime.JSX.Element;
 
 interface UndoBindings {
     canUndo: boolean;
@@ -345,19 +785,26 @@ interface TrialChromeProps {
     record: TrialRecord;
     instrument: Instrument;
     isLastTrial: boolean;
-    toolbar?: ToolbarSlot;
-    sidebar?: SidebarSlot;
-    statusBar?: StatusBarSlot;
     undoBindings?: UndoBindings;
     /** Supplied when the instrument declares a `job`. */
     job?: JobHandle;
-    sidebarExtras?: ReactNode;
+    /** Contributions the trial runtime itself adds — the drag palette and the
+     *  layer list, which depend on runtime state the instrument cannot reach. */
+    trialChrome?: readonly TrialContribution[];
+    /** Contributions from the lab, merged last. */
+    chrome?: readonly TrialContribution[];
+    /** Built-in contribution ids to drop. Throws on an id that is not there. */
+    suppress?: readonly string[];
+    /** The trial's resolved tool slot, and the setter that writes whichever
+     *  slot it resolved to. `Trial` owns the resolution. */
+    activeToolId?: string | null;
+    setActiveTool?: (id: string) => void;
     children: ReactNode;
 }
-/** The frame around a running instrument — toolbar, sidebar, status bar —
- *  each replaceable by a slot. Assembles the slot contexts and wires the undo
- *  keyboard shortcuts. */
-declare function TrialChrome({ trialId, record, instrument, isLastTrial, toolbar, sidebar, statusBar, undoBindings, job, sidebarExtras, children, }: TrialChromeProps): react_jsx_runtime.JSX.Element;
+/** The frame around a running instrument. Builds one chrome context, assembles
+ *  the contributions the instrument, the runtime and the lab declare, and hands
+ *  each region its slice. */
+declare function TrialChrome({ trialId, record, instrument, isLastTrial, undoBindings, job, trialChrome, chrome, suppress, activeToolId, setActiveTool, children, }: TrialChromeProps): react_jsx_runtime.JSX.Element;
 
 /** Append a new trial running `instrumentName`, at that instrument's
  *  default config and initial state. */
@@ -378,282 +825,5 @@ declare function resetTrial(trials: TrialRecord[], id: string, instruments: Inst
  */
 declare function reorderTrials(trials: TrialRecord[], ids: readonly string[]): TrialRecord[];
 
-/** An annotation drawn over a curve plot: a shaded band across a range of x,
- *  or a vertical line at one x. */
-type CurveMark = {
-    kind: 'band';
-    x: [number, number];
-    color?: string;
-} | {
-    kind: 'line';
-    x: number;
-    color?: string;
-};
-/** Props for `<CurveField>`. */
-interface CurveFieldProps {
-    /** Flat [x0, y0, x1, y1, …] — matches how curve-as-array configs
-     *  serialize in JSON snapshots. */
-    values: number[];
-    min: number;
-    max: number;
-    step: number;
-    /** Plot width in CSS px. Caller sizes (typically uses a ResizeObserver). */
-    width: number;
-    /** Plot height in CSS px. Default 110. */
-    height?: number;
-    /** Flat default curve. When provided, a Reset button restores it. */
-    defaults?: readonly number[];
-    onChange: (next: number[]) => void;
-    /** Optional vertical marks overlaid on the plot (e.g. landmarks). */
-    marks?: readonly CurveMark[];
-}
-/**
- * A function-domain (y = f(x), x ∈ [0,1]) curve editor with per-stop
- * numeric readouts and flip buttons. Wraps weasel-ui's
- * `CurveEditor`; consumers wanting the raw editor (2D paths,
- * custom anchors) should import it from `@weasel-js/labkit/weasel-ui`.
- */
-declare function CurveField({ values, min, max, step, width, height, defaults, onChange, marks, }: CurveFieldProps): react_jsx_runtime.JSX.Element;
-
-/** Props for `<Subpanel>`. */
-interface SubpanelProps {
-    title: ReactNode;
-    children: ReactNode;
-    className?: string;
-}
-/** A typographic divider inside a property list: a small title flanked by a
- *  rule. Purely a heading — use `<PropertyGroup>` for a bordered section. */
-declare function Subpanel({ title, children, className }: SubpanelProps): react_jsx_runtime.JSX.Element;
-/** Props for `<EffectCard>`. */
-interface EffectCardProps {
-    /** Card title rendered in the title bar (e.g. effect kind label or a select). */
-    title: ReactNode;
-    /** Optional badge/chip displayed before the remove button (e.g. primary value summary). */
-    primary?: ReactNode;
-    /** Optional accent color in any CSS color form. Sets --lk-panel-accent on the card. */
-    accent?: string;
-    /** Optional ordinal badge that doubles as the drag handle (used by tail cards in SB). */
-    index?: number;
-    expanded?: boolean;
-    onToggleExpanded?: () => void;
-    onRemove?: () => void;
-    /**
-     * Drag-handle wiring. When provided, an inline handle (⋮⋮ icon or `index`)
-     * activates HTML5 drag on press. Consumer owns the drag/drop coordination —
-     * see EffectCardList for the batteries-included wrapper.
-     */
-    draggable?: boolean;
-    onPressHandle?: () => void;
-    onReleaseHandle?: () => void;
-    onDragStart?: (e: React.DragEvent<HTMLDivElement>) => void;
-    onDragEnd?: (e: React.DragEvent<HTMLDivElement>) => void;
-    onDragOver?: (e: React.DragEvent<HTMLDivElement>) => void;
-    onDragLeave?: (e: React.DragEvent<HTMLDivElement>) => void;
-    onDrop?: (e: React.DragEvent<HTMLDivElement>) => void;
-    dragging?: boolean;
-    children?: ReactNode;
-    className?: string;
-}
-/** An accented, collapsible card for one item in a list of like things —
- *  effects, layers, tails. The accent color rebinds the theme accent token
- *  within the card, so its controls pick it up too. */
-declare function EffectCard({ title, primary, accent, index, expanded, onToggleExpanded, onRemove, draggable, onPressHandle, onReleaseHandle, onDragStart, onDragEnd, onDragOver, onDragLeave, onDrop, dragging, children, className, }: EffectCardProps): react_jsx_runtime.JSX.Element;
-/** The minimum an item must carry to appear in an `<EffectCardList>`. */
-interface EffectCardListItem {
-    id: string | number;
-}
-/** Props for `<EffectCardList>`. */
-interface EffectCardListProps<T extends EffectCardListItem> {
-    items: ReadonlyArray<T>;
-    renderItem: (item: T, helpers: {
-        isExpanded: boolean;
-        isDragging: boolean;
-        toggleExpanded: () => void;
-        cardProps: Pick<EffectCardProps, 'expanded' | 'dragging' | 'draggable' | 'onToggleExpanded' | 'onPressHandle' | 'onReleaseHandle' | 'onDragStart' | 'onDragEnd' | 'onDragOver' | 'onDragLeave' | 'onDrop'>;
-    }) => ReactNode;
-    onReorder: (sourceId: T['id'], targetId: T['id'], position: 'before' | 'after') => void;
-    /** Optional rendered when the list is empty. */
-    empty?: ReactNode;
-    /** IDs to render expanded on first mount. Defaults to all collapsed. */
-    defaultExpandedIds?: ReadonlyArray<T['id']>;
-}
-/** A drag-reorderable list of `<EffectCard>`s. Owns the expanded and dragging
- *  state and hands it back to `renderItem`, so the caller only supplies each
- *  card's contents. */
-declare function EffectCardList<T extends EffectCardListItem>({ items, renderItem, onReorder, empty, defaultExpandedIds, }: EffectCardListProps<T>): react_jsx_runtime.JSX.Element;
-
-/** Props for `<PropertyGroup>`. */
-interface PropertyGroupProps {
-    /** Title rendered between two rules at the top of the group. */
-    title: ReactNode;
-    /** When true the group renders nothing — useful for conditional sections. */
-    hidden?: boolean;
-    children: ReactNode;
-    className?: string;
-    /**
-     * How rows pack into the 2-column grid.
-     *   - `'auto-color'` (default): only color rows pair side-by-side; everything
-     *     else spans the full width.
-     *   - `'pairs'`: every row auto-places into the 2-column grid two-per-row.
-     */
-    pack?: 'auto-color' | 'pairs';
-}
-/**
- * Visually-bordered group inside a PropertyList. Use to scope a set of
- * related rows under a heading (e.g. "Aqua", "Bevel", "Dome" sections
- * inside a fill effect's controls).
- */
-declare function PropertyGroup({ title, hidden, children, className, pack, }: PropertyGroupProps): react_jsx_runtime.JSX.Element | null;
-
-/** Props for `<PropertyPanel>`. */
-interface PropertyPanelProps {
-    title?: ReactNode;
-    children: ReactNode;
-    className?: string;
-}
-/** A titled panel holding property rows — the sidebar container the rest of
- *  this module's components fill. */
-declare function PropertyPanel({ title, children, className }: PropertyPanelProps): react_jsx_runtime.JSX.Element;
-/** How a property list packs its rows into two columns. */
-type PropertyListPack = 'auto-color' | 'pairs';
-/** Props for `<PropertyList>`. */
-interface PropertyListProps {
-    children: ReactNode;
-    className?: string;
-    /**
-     * How rows pack into the 2-column grid.
-     *   - `'auto-color'` (default): only color rows pair side-by-side; everything
-     *     else spans the full width. Right for sparse top-level panels.
-     *   - `'pairs'`: every row auto-places into the 2-column grid two-per-row.
-     *     Headers, subpanels, and full-width children (`<hr>`, curve blocks)
-     *     still span via `lk-property-list__span`. Right for dense effect bodies.
-     */
-    pack?: PropertyListPack;
-}
-/**
- * Grid container for PropertyRows. Use standalone for chrome-less layouts, or
- * nest inside <PropertyPanel/> for the standard glass card.
- */
-declare function PropertyList({ children, className, pack }: PropertyListProps): react_jsx_runtime.JSX.Element;
-/** Which control shape a row holds, which decides its intrinsic layout. */
-type PropertyRowVariant = 'default' | 'color' | 'checkbox';
-/** Whether a row's label sits above its control or beside it. */
-type PropertyRowLayout = 'block' | 'inline';
-/** Props for `<PropertyRow>`. */
-interface PropertyRowProps {
-    label: ReactNode;
-    /** Right-aligned readout shown next to the label (e.g. current value). */
-    readout?: ReactNode;
-    variant?: PropertyRowVariant;
-    /**
-     * Label position relative to the control. "block" (default) stacks
-     * label above control; "inline" places the label to the left.
-     * Color and checkbox variants are always inline by their own nature.
-     */
-    layout?: PropertyRowLayout;
-    children: ReactNode;
-    htmlFor?: string;
-    className?: string;
-}
-/** The label-plus-control frame every typed row below is built from. Use it
- *  directly for a control this module does not cover. */
-declare function PropertyRow({ label, readout, variant, layout, children, htmlFor, className, }: PropertyRowProps): react_jsx_runtime.JSX.Element;
-/** Props for `<SliderRow>`. */
-interface SliderRowProps {
-    label: ReactNode;
-    value: number;
-    min: number;
-    max: number;
-    step?: number;
-    onChange: (next: number) => void;
-    /** Override how the value is rendered next to the label. Defaults to `value.toString()`. */
-    format?: (value: number) => ReactNode;
-    /**
-     * Optional suffix rendered next to the readout. A string becomes a
-     * baseline-aligned dim "word" unit (e.g. "px"); pass JSX like `<sup>°</sup>`
-     * to get the browser's native super positioning for symbol units.
-     */
-    unit?: ReactNode;
-    layout?: PropertyRowLayout;
-}
-/** A bounded number edited by dragging, with a live readout whose precision
- *  follows `step`. */
-declare function SliderRow({ label, value, min, max, step, onChange, format, unit, layout, }: SliderRowProps): react_jsx_runtime.JSX.Element;
-/** Props for `<ColorRow>`. */
-interface ColorRowProps {
-    label: ReactNode;
-    value: string;
-    onChange: (next: string) => void;
-    /** 0..1 alpha. When provided, a translucent slider renders beneath the swatch. */
-    alpha?: number;
-    onAlphaChange?: (next: number) => void;
-    /**
-     * Render the alpha track as inert (dimmed, no thumb, not-allowed cursor).
-     * Use when the color's consumer drops alpha so the affordance reads dead.
-     */
-    alphaDisabled?: boolean;
-}
-/** A color swatch, optionally with an alpha slider beneath it. */
-declare function ColorRow({ label, value, onChange, alpha, onAlphaChange, alphaDisabled, }: ColorRowProps): react_jsx_runtime.JSX.Element;
-/** Props for `<CheckboxRow>`. */
-interface CheckboxRowProps {
-    label: ReactNode;
-    value: boolean;
-    onChange: (next: boolean) => void;
-}
-/** A boolean checkbox. */
-declare function CheckboxRow({ label, value, onChange }: CheckboxRowProps): react_jsx_runtime.JSX.Element;
-/** Props for `<TextRow>`. */
-interface TextRowProps {
-    label: ReactNode;
-    value: string;
-    onChange: (next: string) => void;
-    placeholder?: string;
-    maxLength?: number;
-    layout?: PropertyRowLayout;
-}
-/** A single-line text input. */
-declare function TextRow({ label, value, onChange, placeholder, maxLength, layout }: TextRowProps): react_jsx_runtime.JSX.Element;
-/** Props for `<NumberRow>`. */
-interface NumberRowProps {
-    label: ReactNode;
-    value: number;
-    onChange: (next: number) => void;
-    min?: number;
-    max?: number;
-    step?: number;
-    placeholder?: string;
-    layout?: PropertyRowLayout;
-}
-/** A number typed directly. Reach for `<SliderRow>` when the range matters
- *  more than the exact value. */
-declare function NumberRow({ label, value, onChange, min, max, step, placeholder, layout, }: NumberRowProps): react_jsx_runtime.JSX.Element;
-interface SelectOption<T extends string> {
-    value: T;
-    label: ReactNode;
-}
-/** Props for `<SelectRow>`. */
-interface SelectRowProps<T extends string> {
-    label: ReactNode;
-    value: T;
-    options: ReadonlyArray<SelectOption<T>>;
-    onChange: (next: T) => void;
-    layout?: PropertyRowLayout;
-}
-/** A dropdown over a fixed set of choices. Prefer `<ToggleRow>` when there
- *  are only two or three and they should all stay visible. */
-declare function SelectRow<T extends string>({ label, value, options, onChange, layout, }: SelectRowProps<T>): react_jsx_runtime.JSX.Element;
-/** Props for `<ToggleRow>`. */
-interface ToggleRowProps<T extends string> {
-    label: ReactNode;
-    value: T;
-    options: ReadonlyArray<SelectOption<T>>;
-    onChange: (next: T) => void;
-    layout?: PropertyRowLayout;
-}
-/** A segmented control: the same choice as a select, with every option
- *  visible at once. */
-declare function ToggleRow<T extends string>({ label, value, options, onChange, layout, }: ToggleRowProps<T>): react_jsx_runtime.JSX.Element;
-
-export { CheckboxRow, ColorRow, ConfigField, CurveField, DEFAULT_VIEW, DefaultSidebar, DefaultStatusBar, DefaultToolbar, EffectCard, EffectCardList, Instrument, InstrumentList, JobHandle, Lab, LabContext, LabMode, LabShell, NumberRow, PITCH_LIMIT, PropertyGroup, PropertyList, PropertyPanel, PropertyRow, SavedSnapshot, SelectRow, SliderRow, StorageAdapter, Subpanel, TextRow, ToggleRow, Trial, TrialChrome, TrialRecord, ViewTransform, Workspace, addTrial, as2DView, clampPitch, cloneTrial, closeTrial, defineInstrument, detectCapabilities, interstellarTheme, orbitAfterDrag, orbitAfterWheel, reorderTrials, resetTrial, useLabContext, useOrbit, validateConfigSchema, wrapYaw };
-export type { CapabilityFlags, CheckboxRowProps, ColorRowProps, CurveFieldProps, CurveMark, DefaultSidebarProps, DefaultStatusBarProps, DefaultToolbarProps, EffectCardListItem, EffectCardListProps, EffectCardProps, LabContextValue, LabProps, LabShellProps, NumberRowProps, OrbitHandlers, OrbitView, PropertyGroupProps, PropertyListPack, PropertyListProps, PropertyPanelProps, PropertyRowLayout, PropertyRowProps, PropertyRowVariant, SelectRowProps, SidebarSlot, SliderRowProps, StatusBarSlot, SubpanelProps, TextRowProps, ToggleRowProps, ToolbarSlot, TrialChromeProps, TrialProps, TrialSidebarContext, TrialStatusBarContext, TrialToolbarContext, UseOrbitOptions, ValidationResult, Vec3, ViewTransform2D, WorkspaceProps };
+export { Annotations, CheckboxRow, ColorRow, ConfigField, ConfigNode, ConfigOption, ConfigRule, ConfigRuleContext, ConfigSchema, ControlRenderer, CurveField, DEFAULT_VIEW, EffectCard, EffectCardList, InferConfig, Instrument, InstrumentList, JobHandle, Lab, LabContext, LabMode, LabPalette, LabShell, LeafPatch, NodeOptions, NumberRow, PITCH_LIMIT, PropertyGroup, PropertyList, PropertyPanel, PropertyRow, PropertySpan, ResolvedConfig, SavedSnapshot, SelectRow, SliderRow, StorageAdapter, Subpanel, TextRow, ToggleRow, Trial, TrialChrome, TrialContribution, TrialRecord, TrialTool, ViewTransform, Workspace, addTrial, applyRules, as2DView, builtinRules, clampPitch, cloneTrial, closeTrial, defineInstrument, f, fromConfigFields, interstellarTheme, isLeafVisible, orbitAfterDrag, orbitAfterWheel, reorderTrials, resetTrial, resolveConfigSchema, titleCase, useConfigSchema, useLabContext, useOrbit, validateConfigSchema, wrapYaw };
+export type { CheckboxRowProps, ColorRowProps, CurveFieldProps, CurveMark, EffectCardListItem, EffectCardListProps, EffectCardProps, InstrumentSpec, LabContextValue, LabPaletteProps, LabProps, LabShellProps, NumberRowProps, OrbitHandlers, OrbitView, PropertyGroupProps, PropertyListPack, PropertyListProps, PropertyOption, PropertyPanelProps, PropertyRowLayout, PropertyRowProps, PropertyRowVariant, PropertySpanProps, SelectRowProps, SliderRowProps, SubpanelProps, TextRowProps, ToggleRowProps, TrialChromeProps, TrialLayout, TrialProps, UndoBindings, UseOrbitOptions, ValidationResult, Vec3, ViewTransform2D, WorkspaceProps };