@weasel-js/labkit 1.1.0 → 1.3.0-pre.0

package/dist/index.d.ts

@@ -1,34 +1,250 @@
 export { CanvasLayerDescriptor, CanvasStack, CanvasStackContext, CanvasStackContextValue, CanvasStackProps, screenToWorld, worldToScreen } from './canvas/index.js';
+import * as react from 'react';
+import { WheelEvent, PointerEvent, ReactNode } from 'react';
+export { PaletteRegion, PaletteRegionProps, SidebarRegion, SidebarRegionProps, StatusRegion, StatusRegionProps, TitleBarRegion, TitleBarRegionProps, ToolbarRegion, ToolbarRegionProps, ViewportRegion, ViewportRegionProps, builtinContributions, mergeContributions, suppressContributions } from './chrome/index.js';
+import { I as Instrument, a as InstrumentList, T as TrialContribution, b as TrialTool, V as ViewTransform } from './_dts/index-DgcNdEdh.js';
+export { C as CanvasCapability, c as CanvasLayer, D as DragDropCapability, d as DragFeedback, H as HitResult, e as IconComponent, L as LayerCapability, f as LayerDescriptor, P as PaletteItem, g 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/index-DgcNdEdh.js';
+import { T as ToolPrefLeaf } from './_dts/PrefsForm-BYa6cWnO.js';
+import { C as ConfigNode, A as Annotations, N as NodeOptions, a as ControlRenderer, b as ConfigOption, c as ConfigSchema, I as InferConfig, d as ConfigField, R as ResolvedConfig, e as ConfigRule, L as LeafPatch, f as ConfigRuleContext } from './_dts/types-AHlQxBNN.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-AHlQxBNN.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 } from './_dts/index-iAP6XbH3.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, V as ViewTransform } from './_dts/index-iAP6XbH3.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 * as react from 'react';
-import { ReactNode } from 'react';
-import { a as StorageAdapter, w as LabMode, T as TrialRecord, h as SavedSnapshot } from './_dts/useTrialState-DYe2vUwN.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-DYe2vUwN.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';
 
-/** 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;
+/** 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;
+}
+/**
+ * Builds an instrument's config: the values, their types, and how each is
+ * edited, in one declaration.
+ *
+ * ```ts
+ * const config = f.schema({
+ *   showGrid: f.boolean(true),
+ *   cellSize: f.number(20).range(5, 80).step(5).label('Grid spacing'),
+ * })
+ * ```
+ */
+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>>;
+};
+
+/**
+ * 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;
+
+/**
+ * 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.
+ */
+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;
+/**
+ * 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.
+ */
+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;
 
-/** 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>;
+/**
+ * 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 function useConfigSchema(instrument: Instrument<any, any, any>): ResolvedConfig;
+
+/**
+ * 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;
+
+/** 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. */
@@ -37,8 +253,12 @@ interface ValidationResult {
     errors: 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. */
+ *  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>`. */
@@ -56,11 +276,27 @@ interface LabProps {
      */
     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, children, }: LabProps): react_jsx_runtime.JSX.Element;
+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
@@ -79,12 +315,25 @@ interface LabContextValue {
     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 `<LabPalette>`. */
+interface LabPaletteProps {
+    tools: readonly TrialTool[];
+}
+/** 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 `<LabShell>`. */
 interface LabShellProps {
     title: string;
@@ -158,6 +407,14 @@ interface WorkspaceProps {
  */
 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
@@ -196,84 +453,18 @@ interface Theme {
  */
 declare const interstellarTheme: Theme;
 
-/** 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;
-    zoom: number;
-}
-/** 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;
-
-/** Props for `<DefaultSidebar>`. */
-interface DefaultSidebarProps {
-    ctx: TrialSidebarContext;
-}
-/** 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;
-
-/** Props for `<DefaultStatusBar>`. */
-interface DefaultStatusBarProps {
-    ctx: TrialStatusBarContext;
-}
-/** The status bar a trial renders when no `statusBar` slot is supplied:
- *  the instrument's name and the current zoom. */
-declare function DefaultStatusBar({ ctx }: DefaultStatusBarProps): react_jsx_runtime.JSX.Element;
-
-/** Props for `<DefaultToolbar>`. */
-interface DefaultToolbarProps {
-    ctx: TrialToolbarContext;
-}
-/** 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;
-
 /** 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;
@@ -287,17 +478,26 @@ interface TrialChromeProps {
     record: TrialRecord;
     instrument: Instrument;
     isLastTrial: boolean;
-    toolbar?: ToolbarSlot;
-    sidebar?: SidebarSlot;
-    statusBar?: StatusBarSlot;
     undoBindings?: UndoBindings;
-    sidebarExtras?: ReactNode;
+    /** Supplied when the instrument declares a `job`. */
+    job?: JobHandle;
+    /** 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, 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. */
@@ -595,5 +795,5 @@ interface ToggleRowProps<T extends string> {
  *  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, DefaultSidebar, DefaultStatusBar, DefaultToolbar, EffectCard, EffectCardList, Instrument, InstrumentList, Lab, LabContext, LabMode, LabShell, NumberRow, PropertyGroup, PropertyList, PropertyPanel, PropertyRow, SavedSnapshot, SelectRow, SliderRow, StorageAdapter, Subpanel, TextRow, ToggleRow, Trial, TrialChrome, TrialRecord, Workspace, addTrial, cloneTrial, closeTrial, defineInstrument, detectCapabilities, interstellarTheme, reorderTrials, resetTrial, useLabContext, validateConfigSchema };
-export type { CapabilityFlags, CheckboxRowProps, ColorRowProps, CurveFieldProps, CurveMark, DefaultSidebarProps, DefaultStatusBarProps, DefaultToolbarProps, EffectCardListItem, EffectCardListProps, EffectCardProps, LabContextValue, LabProps, LabShellProps, NumberRowProps, PropertyGroupProps, PropertyListPack, PropertyListProps, PropertyPanelProps, PropertyRowLayout, PropertyRowProps, PropertyRowVariant, SelectRowProps, SidebarSlot, SliderRowProps, StatusBarSlot, SubpanelProps, TextRowProps, ToggleRowProps, ToolbarSlot, TrialChromeProps, TrialProps, TrialSidebarContext, TrialStatusBarContext, TrialToolbarContext, ValidationResult, 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, 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, PropertyPanelProps, PropertyRowLayout, PropertyRowProps, PropertyRowVariant, SelectRowProps, SliderRowProps, SubpanelProps, TextRowProps, ToggleRowProps, TrialChromeProps, TrialProps, UndoBindings, UseOrbitOptions, ValidationResult, Vec3, ViewTransform2D, WorkspaceProps };