@weasel-js/labkit 1.4.3 → 1.5.0

package/dist/index.d.ts

@@ -1,29 +1,29 @@
+export { B as Button, a as ButtonProps, b as ButtonSize, c as ButtonVariant, T as ToggleBar, d as ToggleBarItem, e as ToggleBarProps, f as ToggleBarSize, g as ToggleBarVariant } from './_dts/ToggleBar.d-DbHoWKIA.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 { ReactNode } from 'react';
-import { P as PropertyMetricProps, a as PropertyListPack } from './_dts/index-DelFfeV0.js';
-export { C as CheckboxRow, b as CheckboxRowProps, c as ColorRow, d as ColorRowProps, e as ControlPanel, N as NumberRow, f as NumberRowProps, g as PropertyList, h as PropertyListProps, i as PropertyOption, j as PropertyPanel, k as PropertyPanelProps, l as PropertyRow, m as PropertyRowLayout, n as PropertyRowProps, o as PropertyRowVariant, p as PropertySpan, q as PropertySpanProps, S as SelectRow, r as SelectRowProps, s as SliderRow, t as SliderRowProps, T as TextRow, u as TextRowProps, v as ToggleRow, w as ToggleRowProps } from './_dts/index-DelFfeV0.js';
-import { DrawCommand, SceneNode, View, Path, FillStyle, StyledRun, TextStyle, Stroke, BuiltinToolId, ToolPrefLeaf, ToolPrefGroup } from '@weasel-js/core';
-import { d as WorldRect, A as AnnotationData, e as AnnotationMeaning, M as MarkScene, C as CaptureSource, f as CaptureOptions, g as CaptureResult, h as AnnotationTarget, i as AnnotationsApi, j as AnnotationsCapability, T as TrialTool, k as AnnotationKind, V as ViewTransform, I as Instrument, l as InstrumentList, m as TrialContribution } from './_dts/frac-B5mB8LsJ.js';
-export { n as Annotation, o as AnnotationInit, p as AnnotationPatch, q as AnnotationQuery, r as AnnotationStatus, s as AnnotationStoreOptions, t as AnnotationTargetInfo, u as CanvasCapability, v as CanvasLayer, w as CaptureDeps, x as DEFAULT_FRAME, b as DragDropCapability, D as DragFeedback, F as FracPoint, y as FracRect, H as HitResult, z as IconComponent, L as LOUPE_DEFAULTS, B as LayerCapability, E as LayerDescriptor, G as LoupeCapability, J as LoupeDeclaration, K as LoupeRenderArgs, P as PaletteItem, a as Point, R as RenderContext, N as ResolvedLoupe, S as SerializedAnnotations, O as SidebarSection, Q as StatusReadout, U as SystemEvent, X as ToolCapability, Y as ToolItem, Z as ToolbarItem, _ as TrialChromeContext, $ as TrialRegion, a0 as UndoCapability, a1 as ViewportControl, a2 as ViewportSize, W as WorldFrame, c as WorldSpec, a3 as annotationsFromJSON, a4 as applyCamera, a5 as createAnnotationScene, a6 as createAnnotationStore, a7 as fracContains, a8 as fracIntersects, a9 as fracToWorld, aa as resolveFrame, ab as resolveLoupe, ac as roundFrac, ad as worldToFrac } from './_dts/frac-B5mB8LsJ.js';
-import { i as TrialInfo, a as StorageAdapter, h as LabMode, T as TrialRecord, c as SavedSnapshot } from './_dts/types-BP2OCcpg.js';
-export { C as CreateLabStoreOptions, L as LabDocument, b as LabStoreState, S as SerializedTrial, d as TrialStateHandle, U as UndoStack, e as UndockedPanel, f as UndockedPanels, g as dockPanel, p as panelKey, u as undockPanel } from './_dts/types-BP2OCcpg.js';
-export { CanvasStack, CanvasStackProps, OrbitHandlers, OrbitView, PITCH_LIMIT, PanZoomHandlers, UseOrbitOptions, UsePanZoomOptions, Vec3, ZoomAtOptions, centerOn, clampPitch, orbitAfterDrag, orbitAfterWheel, screenToWorld, useOrbit, usePanZoom, worldToScreen, wrapYaw, zoomAt } from './canvas/index.js';
-export { C as CanvasLayerDescriptor, a as CanvasStackContext, b as CanvasStackContextValue, c as CanvasStackSurface } from './_dts/CanvasStackContext-Dde8_1my.js';
-export { PaletteRegion, PaletteRegionProps, SidebarRegion, SidebarRegionProps, StatusRegion, StatusRegionProps, TitleBarPlacement, TitleBarRegion, TitleBarRegionProps, ToolbarRegion, ToolbarRegionProps, ViewportRegion, ViewportRegionProps, builtinContributions, mergeContributions, suppressContributions } from './chrome/index.js';
-import { b as ConfigNode, A as Annotations, N as NodeOptions, c as ControlRenderer, d as ConfigOption, e as ConfigShape, f as ConfigBranch, B as BranchAnnotations, g as BranchOptions, a as ConfigSchema, I as InferConfig, h as ConfigEntry, R as ResolvedConfig, i as ConfigRule, L as LeafPatch, j as ConfigRuleContext } from './_dts/types-B9_zrHmb.js';
-export { k as ConfigOf, C as ConfigPath, E as EntryValue, l as NodeValue, S as SectionSpec, V as ValueAtPath } from './_dts/types-B9_zrHmb.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 { P as PropertyMetricProps, a as PropertyListPack } from './_dts/index-retnAut7.js';
+export { C as CheckboxRow, b as CheckboxRowProps, c as ColorRow, d as ColorRowProps, e as ControlPanel, N as NumberRow, f as NumberRowProps, g as PropertyList, h as PropertyListProps, i as PropertyOption, j as PropertyPanel, k as PropertyPanelProps, l as PropertyRow, m as PropertyRowLayout, n as PropertyRowProps, o as PropertyRowVariant, p as PropertySpan, q as PropertySpanProps, S as SelectRow, r as SelectRowProps, s as SliderRow, t as SliderRowProps, T as TextRow, u as TextRowProps, v as ToggleRow, w as ToggleRowProps } from './_dts/index-retnAut7.js';
+import { DrawCommand, SceneNode, View, Path, FillStyle, StyledRun, TextStyle, Stroke, BuiltinToolId } from '@weasel-js/core';
+import { t as WorldRect, A as AnnotationData, v as AnnotationMeaning, w as MarkScene, x as CaptureSource, y as CaptureOptions, z as CaptureResult, B as AnnotationTarget, E as AnnotationsApi, F as AnnotationsCapability, G as TrialInfo, H as TrialTool, J as AnnotationKind, k as ViewTransform, K as Instrument, q as InstrumentList, o as LabMode, N as TrialContribution, c as StorageAdapter, T as TrialRecord } from './_dts/frac-8R6UmlvN.js';
+export { O as Annotation, Q as AnnotationInit, R as AnnotationPatch, X as AnnotationQuery, Y as AnnotationStatus, Z as AnnotationStoreOptions, _ as AnnotationTargetInfo, $ as CanvasCapability, a0 as CanvasLayer, a1 as CaptureDeps, a2 as ContributionBase, C as CreateLabStoreOptions, D as DEFAULT_FRAME, n as DragDropCapability, m as DragFeedback, a3 as FracPoint, a4 as FracRect, a5 as HitResult, a6 as IconComponent, a7 as LOUPE_DEFAULTS, L as LabDocument, d as LabStoreState, a8 as LayerCapability, a9 as LayerDescriptor, aa as LoupeCapability, ab as LoupeDeclaration, ac as LoupeRenderArgs, P as PaletteItem, l as Point, ad as RegionContribution, ae as RenderContext, af as ResolvedLoupe, e as SavedSnapshot, ag as SerializedAnnotations, S as SerializedTrial, ah as SidebarSection, ai as SidebarSlotContext, aj as StageCapability, ak as StatusReadout, f as StorageChange, al as SystemEvent, am as ToolCapability, an as ToolItem, ao as ToolSlotContext, ap as ToolbarItem, aq as TrialChromeContext, ar as TrialRegion, g as TrialStateHandle, as as UndoCapability, U as UndoStack, h as UndockedPanel, i as UndockedPanels, at as ViewportControl, V as ViewportSize, W as WorldFrame, a as WorldSpec, au as annotationsFromJSON, b as applyCamera, av as createAnnotationScene, aw as createAnnotationStore, j as dockPanel, ax as fracContains, ay as fracEncloses, az as fracToWorld, p as panelKey, r as resolveFrame, aA as resolveLoupe, aB as roundFrac, u as undockPanel, aC as worldToFrac } from './_dts/frac-8R6UmlvN.js';
+export { C as CanvasStack, a as CanvasStackProps, O as OrbitHandlers, b as OrbitView, P as PITCH_LIMIT, c as PanZoomHandlers, S as Stage, d as StageProps, U as UseOrbitOptions, e as UsePanZoomOptions, V as Vec3, Z as ZoomAtOptions, f as centerOn, g as clampPitch, h as fitStage, o as orbitAfterDrag, i as orbitAfterWheel, s as screenToWorld, u as useOrbit, j as usePanZoom, w as worldToScreen, k as wrapYaw, z as zoomAt } from './_dts/usePanZoom-nS798rOF.js';
+export { C as CanvasLayerDescriptor, a as CanvasStackContext, b as CanvasStackContextValue, c as CanvasStackSurface } from './_dts/CanvasStackContext-CqkxkFJW.js';
+import { L as LabContribution } from './_dts/index-B8uu2ba7.js';
+export { A as AddTrialOptions, a as LabChromeContext, b as LabContext, c as LabContextValue, d as LabFooterRegion, e as LabHeaderRegion, f as LabRegion, g as LabRegionProps, h as LabSidebarRegion, P as PaletteRegion, i as PaletteRegionProps, S as SidebarRegion, j as SidebarRegionProps, k as StatusRegion, l as StatusRegionProps, T as TitleBarPlacement, m as TitleBarRegion, n as TitleBarRegionProps, o as ToolbarRegion, p as ToolbarRegionProps, V as ViewportRegion, q as ViewportRegionProps, r as addTrial, s as builtinContributions, t as cloneTrial, u as closeTrial, v as contributionsIn, w as labContributions, x as mergeContributions, y as reorderTrials, z as resetTrial, B as suppressContributions, C as toolContributions, D as useLabChromeContext, E as useLabContext } from './_dts/index-B8uu2ba7.js';
+export { BaseNode, BooleanNode, ColorNode, CustomNode, EnumNode, GroupNode, NumberNode, StringNode, ValueNode, applyRules, builtinRules, f, fillConfigDefaults, fromConfigFields, hasConfigPath, isConfigBranch, isLeafVisible, resolveConfigSchema, schemaNodeAtPath, titleCase, useConfigSchema, valueAtPath, withValueAtPath } from './config/index.js';
+import { b as ConfigSchema, a as ConfigField, c as ConfigRule, d as ControlRenderer } from './_dts/types-Ca2LCnPq.js';
+export { A as Annotations, B as BranchAnnotations, e as BranchOptions, f as CheckboxField, g as ColorField, h as ConfigBranch, i as ConfigEntry, j as ConfigFieldBase, k as ConfigFieldType, l as ConfigNode, m as ConfigOf, n as ConfigOption, C as ConfigPath, o as ConfigRuleContext, p as ConfigShape, E as EntryValue, I as InferConfig, L as LeafPatch, N as NodeOptions, q as NodeValue, r as NumberField, R as ResolvedConfig, S as SectionSpec, s as SelectField, t as SelectOption, u as SliderField, T as TextField, V as ValueAtPath } from './_dts/types-Ca2LCnPq.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';
 export { LayerList, LayerListProps, LayerTreeNode } from './layers/index.js';
 export { CanvasLoupe, CanvasLoupeProps, DomLoupe, DomLoupeProps, LensCamera, LoupeBubble, LoupeBubbleProps, LoupeState, SourceRect, TrialLoupe, TrialLoupeProps, UseLoupeOptions, drawCanvasLens, lensCamera, lensSourceRect, sampleStack, useLoupe } from './loupe/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-D6Vb3T-g.js';
-export { Box, Rect, SurfaceCanvasContext, SurfaceContext, SurfaceFrame, SurfaceHandle, TilePainter, UseTiledSurfaceOptions, composeRects, rectsEqual, toDeviceRect, useSurface, useSurfaceCanvas, useSurfaceOptional, useSurfaceTile, useTileId, useTiledSurface } from './surface/index.js';
+import { SplitProps } from './primitives/index.js';
+export { FloatingPanel, FloatingPanelProps, FpsMeter, JobProgress, JobProgressProps, Legend, LegendEntry, LegendMark, LegendProps, ScaleIndicator, ScaleIndicatorProps, Sidebar, SidebarProps, Split, StatusBar, StatusBarProps, StatusBarSectionProps, Toolbar, ToolbarButtonProps, ToolbarGroupProps, ToolbarProps, ZoomControl, ZoomControlProps } from './primitives/index.js';
+export { C as CURRENT_DOCUMENT_VERSION, I as IndexedDbAdapterOptions, b as LabStoreContext, c as LabStoreProvider, O as OpenLabStoreOptions, d as OpenedLabStore, P as PersistedStateOptions, e as Persistence, f as PersistenceProps, R as RecordCache, g as RecordChange, T as TrialIdContext, h as TrialIdProvider, i as createIndexedDbAdapter, k as createMemoryAdapter, l as indexedDbAdapter, m as labDocumentKey, n as localStorageAdapter, o as noneAdapter, p as openLabStore, q as quarantineKey, s as sessionStorageAdapter, u as urlHashAdapter, r as useLabStore, t as usePersistedState, v as useTrialId, w as useTrialState } from './_dts/useTrialState-jcx_TdU6.js';
+export { Box, Rect, SurfaceCanvasContext, SurfaceCanvases, SurfaceClear, SurfaceContext, SurfaceFrame, SurfaceHandle, SurfaceLayer, TilePainter, UseTiledSurfaceOptions, composeRects, rectsEqual, toDeviceRect, useSurface, useSurfaceCanvas, useSurfaceOptional, useSurfaceTile, useTileId, useTiledSurface } from './surface/index.js';
 export { EventBus, EventListener, clearUndo, createEventBus, emptyStack, pushSnapshot, redo, undo } from './undo/index.js';
 import './_dts/PrefsForm.d-DDHFANkc.js';
 import 'windease';
@@ -177,7 +177,7 @@ interface PaintableMark {
 /** How a mark is drawn, as opposed to where. Resolved by the overlay from the
  *  instrument's vocabulary and the mark's own staleness. */
 interface MarkStyle {
-    /** The status's colour, or the default. */
+    /** The status's color, or the default. */
     color?: string;
     /** A mark whose stored position no longer describes the picture. Drawn
      *  dashed rather than hidden: it still describes *something*, and dropping
@@ -207,14 +207,14 @@ interface MarkDrawOptions {
     positionDependsOn?: readonly string[];
     /** The trial's config at the time of the draw. */
     config: unknown;
-    /** The instrument's vocabulary, for a status's colour. */
+    /** The instrument's vocabulary, for a status's color. */
     meaning?: AnnotationMeaning;
 }
 /**
  * How one mark is drawn — shared by the pane on screen and by an export.
  *
  * One function rather than two call sites building their own, because an
- * export that resolves a status colour or a stale dash differently from the
+ * export that resolves a status color or a stale dash differently from the
  * screen produces a picture nobody was looking at.
  */
 declare function createMarkDrawOne(opts: MarkDrawOptions): (node: SceneNode<AnnotationData, 'marks', WorldRect>, pose: WorldRect, view: View) => DrawCommand[];
@@ -377,7 +377,12 @@ type SvgPaint = {
 /** Stroke description: a paint plus structural line parameters. */
 interface SvgStroke {
     paint: SvgPaint;
-    width: number;
+    /** World units, or `{ px }` for a width that holds its rendered thickness
+     *  however the document is scaled — SVG's `vector-effect="non-scaling-stroke"`,
+     *  and the same unit system as the kit's `Stroke.width`. */
+    width: number | {
+        px: number;
+    };
     opacity?: number;
     /** `stroke-linecap`. Default per SVG spec is `'butt'`. */
     cap?: 'butt' | 'round' | 'square';
@@ -440,9 +445,12 @@ interface SvgGroupNode {
  * `dominant-baseline="text-before-edge"` so `y` is the top of the text
  * box, plus `data-weasel-width` / `data-weasel-height` so weasel's
  * explicit box dimensions round-trip losslessly. External SVG text
- * (lacking the data-* attrs) imports with estimated dimensions —
- * {@link UNBOUNDED_TEXT_WIDTH} and
+ * (lacking the data-* attrs) imports with the width the kit's text layout
+ * measures — an em-based estimate when no registered font can — and
  * `height = fontSize * lineHeight * (lineCount || 1)`.
+ *
+ * `x` here is always the box's left edge. In the SVG it is the
+ * `text-anchor` point, and the parser and serializer convert between them.
  */
 interface SvgTextNode {
     kind: 'text';
@@ -525,7 +533,7 @@ interface AnnotationOverlayProps {
     config: unknown;
     /** The trial's resolved tool slot. */
     activeToolId: string | null;
-    /** The instrument's vocabulary, for a status's colour. */
+    /** The instrument's vocabulary, for a status's color. */
     meaning?: AnnotationMeaning;
 }
 /**
@@ -570,9 +578,9 @@ interface AnnotationToolInfo {
     weaselTool: BuiltinToolId;
     kind?: AnnotationKind;
 }
-/** The palette an instrument gets for declaring `annotations`. Ids share the
- *  trial's contribution namespace with `instrument.tools`, and one tool slot
- *  holds whichever is active. */
+/** The tools a lab's rail gets when any instrument declares `annotations`.
+ *  Ids share the lab's contribution namespace with its own `tools`, and the
+ *  lab's tool slot holds whichever is active. */
 declare const ANNOTATION_TOOLS: readonly TrialTool[];
 /** What `id` drives, or undefined for a tool that is not one of these. */
 declare function annotationToolInfo(id: string | null): AnnotationToolInfo | undefined;
@@ -605,226 +613,6 @@ declare function fromWeaselView(v: View): ViewTransform;
  */
 declare function fitView(content: ContentSize, pane: PaneSize): ViewTransform;
 
-/** Whether a schema entry is a branch rather than a leaf. */
-declare function isConfigBranch(entry: ConfigEntry): entry is ConfigBranch;
-/** 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. `collapsed` opens the section
-     *  folded — say it on any one of the section's leaves. */
-    section(label: string, opts?: {
-        collapsed?: boolean;
-    }): 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;
-    /** A display suffix for the value — `'px'`, `'ms'`, `'°'`. Presentation only:
-     *  it is never parsed, and the stored value stays a plain number. */
-    suffix(suffix: string): 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;
-}
-/**
- * A branch of the schema: its children nest under its key, so a leaf inside
- * one is read and written at a dotted path. Distinct from `.section()`, which
- * puts a heading over sibling leaves and leaves their paths alone.
- */
-declare class GroupNode<S extends ConfigShape> implements ConfigBranch<S> {
-    readonly children: S;
-    readonly annotations: Readonly<BranchAnnotations>;
-    readonly options: Readonly<BranchOptions>;
-    constructor(children: S, annotations?: Readonly<BranchAnnotations>, options?: Readonly<BranchOptions>);
-    private with;
-    /** Heading for the group's rows. Defaults to the key, title-cased. */
-    label(name: string): GroupNode<S>;
-    /** Longer help text. Carried on the resolved `PrefGroup`, where weasel-ui's
-     *  `PrefsForm` draws it under the heading; `ControlPanel` has no place for
-     *  it yet and shows the heading alone. */
-    describe(description: string): GroupNode<S>;
-    /** Render this whole group under a named section heading. */
-    section(label: string, opts?: {
-        collapsed?: boolean;
-    }): GroupNode<S>;
-    /** Show this group only while the predicate holds. Presentational — every
-     *  value beneath it stays in config and the instrument still reads it. */
-    showIf(predicate: (config: Record<string, unknown>) => boolean): GroupNode<S>;
-}
-/**
- * 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'),
- *   // Nested: read and written at `grid.color`.
- *   grid: f.group({ color: f.color('#ffffff') }),
- * })
- * ```
- */
-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 branch: its children nest under this key, so `grid: f.group({ size })`
-     *  puts the value at `config.grid.size` and addresses it as `'grid.size'`.
-     *  Groups nest as deeply as the schema wants. */
-    group: <const S extends ConfigShape>(children: S) => GroupNode<S>;
-    /** 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 and groups into an instrument's config. */
-    schema<S extends ConfigShape>(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;
-
-/** The value at a dotted path. `undefined` when a segment is missing or the
- *  walk hits something that is not a record. */
-declare function valueAtPath(config: unknown, path: string): unknown;
-/** Whether a dotted path is actually present, which a `undefined` value is
- *  not enough to tell you. */
-declare function hasConfigPath(config: unknown, path: string): boolean;
-/** A copy of `config` with `value` written at a dotted path. Every record on
- *  the way down is copied and the input is left alone; a missing — or
- *  non-record — intermediate is replaced with the branch the path implies. */
-declare function withValueAtPath<T>(config: T, path: string, value: unknown): T;
-/**
- * `stored` with every gap filled from `defaults`, down the whole tree.
- *
- * This is how a config written before its schema grew a branch still loads:
- * the branch arrives at its defaults instead of `undefined`, and a key the
- * defaults no longer mention is kept rather than dropped, so nothing is lost
- * to a schema change the author has not finished making.
- */
-declare function fillConfigDefaults<T>(stored: unknown, defaults: T): T;
-/** A node in a resolved schema tree, by dotted path. Structural rather than
- *  `isPrefLeaf` so this stays free of a runtime import. */
-declare function schemaNodeAtPath(group: ToolPrefGroup, path: string): ToolPrefLeaf | ToolPrefGroup | undefined;
-
-/**
- * Resolve a schema into the vocabulary weasel-ui renders, running each leaf
- * through the consumer's rules and then labkit's own.
- *
- * The group mirrors the schema's own nesting: an `f.group` becomes a nested
- * `PrefGroup`, so a leaf's dotted path within the tree is the path its value
- * is written at, 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;
-
-/**
- * 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 the row at a dotted path should be drawn right now. A group answers
- * for its whole subtree — hiding one hides everything under it.
- *
- * `hidden` is the node'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'> & {
@@ -863,13 +651,50 @@ interface ValidationResult {
  *  a field simply has no constraints to check here. */
 declare function validateConfigSchema(fields: ConfigField[]): ValidationResult;
 
-/** Props for `<Lab>`. */
-interface LabProps {
+/** One page in a project's set of labs. */
+interface LabPage {
+    /** The page's own URL, and how the switcher knows which page is open. */
+    href: string;
+    label: string;
+}
+/** Props for `<LabSwitcher>`. */
+interface LabSwitcherProps {
+    /** The open page's title, shown as the control's own label. */
+    title: string;
+    pages: readonly LabPage[];
+    /** Defaults to the current location. Pass it in tests, or to render a
+     *  switcher for a page other than the one being viewed. */
+    path?: string;
+    className?: string;
+}
+/** Which of `pages` a path is on, or -1.
+ *
+ *  Matched on the end of the path so a query string, a trailing slash or a
+ *  leftover `.html` cannot lose it: a project whose dev server maps `/stats`
+ *  to `stats.html` serves both spellings, and a bookmark from before the URLs
+ *  lost their extension still resolves to the same page. */
+declare function currentPage(path: string, pages: readonly LabPage[]): number;
+/** A project's lab title, doubling as the way to reach its other labs.
+ *
+ *  The menu holds real anchors, not a `<select>` and not buttons. These are
+ *  separate documents, so an `href` is what gets middle-click, cmd-click and
+ *  the back button for free; a select fires a change event and can do none of
+ *  the three. The trigger is a button because it opens something rather than
+ *  going anywhere.
+ *
+ *  Pages accumulate -- a project grows a wall, a dashboard, an ingest page, a
+ *  bench -- and a tab strip is the layout that stops working first. */
+declare function LabSwitcher({ title, pages, path, className }: LabSwitcherProps): react_jsx_runtime.JSX.Element;
+
+interface LabBaseProps {
+    /** May change while mounted. An instrument that is a different object from
+     *  the last render counts as replaced and its open trials' configs are
+     *  refilled, so hoist or memoize the list. */
     instruments: InstrumentList;
     defaultInstrument: string;
-    storage?: StorageAdapter | null;
-    storageKey?: string;
     mode?: LabMode;
+    /** Rendered while a stored lab loads. Default: the lab's empty shell. */
+    fallback?: ReactNode;
     /**
      * Optional list of CSS colors used to compose the interstellar theme's
      * cosmic backdrop. Each color becomes one radial-gradient blob on the
@@ -878,12 +703,27 @@ interface LabProps {
      */
     nebula?: readonly string[];
     title?: string;
+    /** The project's other labs. Given two or more, the title becomes the way to
+     *  reach them — the same switcher `<LabShell>` renders, so a lab reached from
+     *  one is not a dead end. */
+    pages?: readonly LabPage[];
+    /** The path the switcher marks as open. Defaults to the current location. */
+    path?: 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[];
+    /** Contributions to the lab's own chrome — its header bar, its sidebar, its
+     *  tool rail and its footer — rather than to every trial's. Rendered after
+     *  `children` and `footer`, which stay the way a lab drops arbitrary content
+     *  into those same two boxes. Going from no sidebar contributions to some
+     *  remounts the workspace and every trial, dropping unpersisted trial state. */
+    labChrome?: readonly LabContribution[];
     /** Built-in contribution ids to drop. Throws on an id that is not there. */
     suppress?: readonly string[];
+    /** Offer the header's add-trial control. Default `true`; a lab that opens
+     *  trials some other way passes `false`. */
+    addTrial?: boolean;
     /** Tools offered lab-wide. A trial whose instrument declares none of its own
      *  reflects and writes this slot. */
     tools?: readonly TrialTool[];
@@ -896,75 +736,31 @@ interface LabProps {
     controls?: Record<string, ControlRenderer>;
     children?: ReactNode;
 }
-/** The lab runtime: creates the store, provides it, and renders one trial
+/** Props for `<Lab>`. With a `storageKey` the lab persists — to IndexedDB
+ *  unless `storage` names another substrate — and both are read once, at
+ *  mount. Without one, nothing persists. */
+type LabProps = LabBaseProps & ({
+    storageKey?: undefined;
+    storage?: undefined;
+} | {
+    storageKey: string;
+    storage?: StorageAdapter;
+});
+/** The lab runtime: opens 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;
-
-/** What a trial opens on beyond its instrument's own defaults. */
-interface AddTrialOptions<TC = Record<string, unknown>> {
-    /** Overlaid on `defaultConfig()` before `initialState` reads it, so a trial
-     *  opened on a subject is running that subject from its first frame. Keys
-     *  whose value is `undefined` are left to the default. */
-    config?: Partial<TC>;
-}
-/** Append a new trial running `instrumentName`, at that instrument's default
- *  config — with `options.config` written over it — and the initial state
- *  that config produces. */
-declare function addTrial(trials: TrialRecord[], instruments: InstrumentList, instrumentName: string, options?: AddTrialOptions): TrialRecord[];
-/** Insert a deep copy of a trial directly after it. The copy starts with
- *  an empty undo history — the original's is not shared. */
-declare function cloneTrial(trials: TrialRecord[], id: string): TrialRecord[];
-/** Remove a trial, unless it is the last one — a lab always has at least
- *  one. */
-declare function closeTrial(trials: TrialRecord[], id: string): TrialRecord[];
-/** Return a trial to what it opened on — its instrument's defaults under the
- *  seed `addTrial` was given — keeping its id and its place in the list. */
-declare function resetTrial(trials: TrialRecord[], id: string, instruments: InstrumentList): TrialRecord[];
-/**
- * Reorder to match `ids`. Ids the list doesn't mention keep their relative
- * order at the end, and ids it names that no longer exist are dropped — a
- * reorder that raced a close should not resurrect the closed trial.
- */
-declare function reorderTrials(trials: TrialRecord[], ids: readonly string[]): TrialRecord[];
-
-/** 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[];
-    /** Open a trial running `instrumentName`. `options.config` is written over
-     *  that instrument's defaults, which is where a trial opened on a subject
-     *  says which subject. */
-    addTrial: (instrumentName: string, options?: AddTrialOptions) => 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;
+declare function Lab(props: LabProps): react_jsx_runtime.JSX.Element;
 
 /** Props for `<LabPalette>`. */
 interface LabPaletteProps {
-    tools: readonly TrialTool[];
+    /** Tools offered lab-wide. Shorthand for one `palette` contribution each. */
+    tools?: readonly TrialTool[];
+    /** The lab's contributions; the `palette` ones are laid out here. */
+    contributions?: readonly LabContribution[];
 }
-/** 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;
+/** The lab's tool rail. Writes the lab's tool slot, which every trial whose
+ *  instrument declares no tools of its own resolves to. Renders nothing when
+ *  the lab contributes no tool rail. */
+declare function LabPalette({ tools, contributions }: LabPaletteProps): react_jsx_runtime.JSX.Element;
 
 /** Props for `<LabShell>`. */
 interface LabShellProps {
@@ -976,11 +772,17 @@ interface LabShellProps {
     footer?: ReactNode;
     /** Color mode. "auto" (default) follows prefers-color-scheme. */
     mode?: LabMode;
+    /** The project's other labs. Given two or more, the title becomes the way
+     *  to reach them; given none, it stays a plain heading. */
+    pages?: readonly LabPage[];
+    /** The path the switcher reads to mark the open page. Defaults to the
+     *  current location. */
+    path?: string;
 }
 /** 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;
+declare function LabShell({ title, children, header, footer, mode, pages, path }: 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. */
@@ -1103,7 +905,7 @@ interface TrialProps {
 declare function Trial({ id, chrome, suppress }: TrialProps): react_jsx_runtime.JSX.Element;
 
 /** Props for `<TrialBody>`. */
-interface TrialBodyProps {
+interface TrialBodyProps extends Omit<SplitProps, 'sidebar' | 'children' | 'className' | 'sidebarClassName' | 'label'> {
     /** The sidebar region's sections. */
     sidebar: ReactNode;
     /** The instrument's own output. */
@@ -1111,36 +913,9 @@ interface TrialBodyProps {
     /** Extra class on the content pane — `Trial` marks a canvas instrument's
      *  well flush. */
     contentClassName?: string;
-    /** The sidebar's current extent in pixels. Omit for an unpersisted lab: the
-     *  seam still works, its result just does not outlive the mount. */
-    width?: number;
-    /** Where the sidebar starts before anyone drags it. */
-    defaultWidth?: number;
-    minWidth?: number;
-    maxWidth?: number;
-    /** How little the instrument may be squeezed to. Reported as the seam's
-     *  reachable maximum, so the drag stops there rather than clamping silently. */
-    contentMinWidth?: number;
-    /** Fires through the drag, not on release: the pane is already there. */
-    onWidthChange?: (width: number) => void;
-    /**
-     * Fixed extent. Omit in an app — the strip measures its own box. Supply it
-     * where nothing measures, notably jsdom, or both panes lay out at zero.
-     */
-    viewport?: {
-        w: number;
-        h: number;
-    };
 }
-/**
- * A trial's sidebar and content as a two-pane strip with a draggable seam.
- *
- * The seam is `stripStrategy`'s own resize affordance, so it arrives as a
- * `role="separator"` carrying the reachable range, operable by pointer and by
- * arrows / Home / End, and clamped against the content pane's floor rather
- * than against the sidebar's alone.
- */
-declare function TrialBody({ sidebar, children, contentClassName, width, defaultWidth, minWidth, maxWidth, contentMinWidth, onWidthChange, viewport, }: TrialBodyProps): react_jsx_runtime.JSX.Element;
+/** A trial's sidebar and content as a `Split`, wearing the trial's classes. */
+declare function TrialBody({ sidebar, children, contentClassName, ...rest }: TrialBodyProps): react_jsx_runtime.JSX.Element;
 
 /** The trial's loupe as its chrome sees it: a switch and its position. */
 interface LoupeBindings {
@@ -1183,5 +958,5 @@ interface TrialChromeProps {
  *  each region its slice. */
 declare function TrialChrome({ trialId, record, instrument, isLastTrial, undoBindings, job, loupe, trialChrome, chrome, suppress, activeToolId, setActiveTool, children, }: TrialChromeProps): react_jsx_runtime.JSX.Element;
 
-export { ANNOTATION_TOOLS, ANNOTATION_WEASEL_TOOLS, AnnotationData, AnnotationKind, AnnotationMeaning, AnnotationOverlay, AnnotationTarget, AnnotationTargets, Annotations, AnnotationsApi, AnnotationsCapability, AnnotationsContext, BranchAnnotations, BranchOptions, CaptureOptions, CaptureResult, CaptureSource, ConfigBranch, ConfigEntry, ConfigField, ConfigNode, ConfigOption, ConfigRule, ConfigRuleContext, ConfigSchema, ConfigShape, ControlRenderer, CurveField, DEFAULT_VIEW, EffectCard, EffectCardList, ExportMenu, InferConfig, Instrument, InstrumentList, JobHandle, Lab, LabContext, LabMode, LabPalette, LabShell, LeafPatch, MarkList, MarkScene, NodeOptions, PropertyGroup, PropertyListPack, ResolvedConfig, SavedSnapshot, StorageAdapter, Subpanel, Trial, TrialBody, TrialChrome, TrialContribution, TrialInfo, TrialRecord, TrialTool, ViewTransform, Workspace, WorldRect, addTrial, annotationToolInfo, applyRules, as2DView, builtinRules, capturePlan, captureTarget, cloneTrial, closeTrial, composeCaptureSvg, createMarkDrawOne, defineInstrument, f, fillConfigDefaults, fitView, fromConfigFields, fromWeaselView, hasConfigPath, interstellarTheme, isConfigBranch, isLeafVisible, isStale, markCommands, markSvgNodes, reorderTrials, resetTrial, resolveConfigSchema, resolveMarkStyle, schemaNodeAtPath, seenFrom, titleCase, toWeaselView, useAnnotations, useAnnotationsOptional, useConfigSchema, useLabContext, validateConfigSchema, valueAtPath, withValueAtPath };
-export type { AddTrialOptions, AnnotationOverlayProps, AnnotationTargetsProps, AnnotationToolInfo, CaptureArgs, CapturePlan, ComposeSvgArgs, ContentSize, CurveFieldProps, CurveMark, EffectCardListItem, EffectCardListProps, EffectCardProps, InstrumentSpec, LabContextValue, LabPaletteProps, LabProps, LabShellProps, MarkDrawOptions, MarkListProps, MarkStyle, PaintableMark, PaneSize, PanelDescriptor, PropertyGroupProps, SubpanelProps, TrialBodyProps, TrialChromeProps, TrialLayout, TrialProps, UndoBindings, ValidationResult, ViewTransform2D, WorkspaceProps };
+export { ANNOTATION_TOOLS, ANNOTATION_WEASEL_TOOLS, AnnotationData, AnnotationKind, AnnotationMeaning, AnnotationOverlay, AnnotationTarget, AnnotationTargets, AnnotationsApi, AnnotationsCapability, AnnotationsContext, CaptureOptions, CaptureResult, CaptureSource, ConfigField, ConfigRule, ConfigSchema, ControlRenderer, CurveField, DEFAULT_VIEW, EffectCard, EffectCardList, ExportMenu, Instrument, InstrumentList, JobHandle, Lab, LabContribution, LabMode, LabPalette, LabShell, LabSwitcher, MarkList, MarkScene, PropertyGroup, PropertyListPack, SplitProps, StorageAdapter, Subpanel, Trial, TrialBody, TrialChrome, TrialContribution, TrialInfo, TrialRecord, TrialTool, ViewTransform, Workspace, WorldRect, annotationToolInfo, as2DView, capturePlan, captureTarget, composeCaptureSvg, createMarkDrawOne, currentPage, defineInstrument, fitView, fromWeaselView, interstellarTheme, isStale, markCommands, markSvgNodes, resolveMarkStyle, seenFrom, toWeaselView, useAnnotations, useAnnotationsOptional, validateConfigSchema };
+export type { AnnotationOverlayProps, AnnotationTargetsProps, AnnotationToolInfo, CaptureArgs, CapturePlan, ComposeSvgArgs, ContentSize, CurveFieldProps, CurveMark, EffectCardListItem, EffectCardListProps, EffectCardProps, InstrumentSpec, LabPage, LabPaletteProps, LabProps, LabShellProps, LabSwitcherProps, MarkDrawOptions, MarkListProps, MarkStyle, PaintableMark, PaneSize, PanelDescriptor, PropertyGroupProps, SubpanelProps, TrialBodyProps, TrialChromeProps, TrialLayout, TrialProps, UndoBindings, ValidationResult, ViewTransform2D, WorkspaceProps };