@weasel-js/labkit 1.4.4 → 1.5.1

package/dist/index.d.ts

@@ -1,34 +1,47 @@
-export { LayerStack, LayerStackItem, LayerStackProps } from './ui/layers/index.js';
 import * as react_jsx_runtime from 'react/jsx-runtime';
+import { I as IconProps } from './_dts/Select.d-Gwr8fLpK.js';
+export { B as Button, a as ButtonProps, b as ButtonSize, c as ButtonVariant, d as Icon, e as Input, f as InputProps, S as Select, g as SelectProps, T as ToggleBar, h as ToggleBarItem, i as ToggleBarProps, j as ToggleBarSize, k as ToggleBarVariant } from './_dts/Select.d-Gwr8fLpK.js';
+export { LayerStack, LayerStackItem, LayerStackProps } from './ui/layers/index.js';
 import * as react from 'react';
 import { ReactNode } from 'react';
-import { P as PropertyMetricProps, a as PropertyListPack } from './_dts/index-Blv9uQzu.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-Blv9uQzu.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-z7ker2Vx.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 fracEncloses, a9 as fracToWorld, aa as resolveFrame, ab as resolveLoupe, ac as roundFrac, ad as worldToFrac } from './_dts/frac-z7ker2Vx.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-kTEZvEgE.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-BNdz-tNd.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-BNdz-tNd.js';
+import { DrawCommand, SceneNode, View, Path, FillStyle, StrokeAlign, StyledRun, TextStyle, TextVerticalAlign, 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-B4okC2lX.js';
+export { O as Annotation, Q as AnnotationInit, R as AnnotationPatch, X as AnnotationQuery, Y as AnnotationStatus, Z as AnnotationStoreOptions, _ as AnnotationTargetInfo, $ as Auto, a0 as CanvasCapability, a1 as CanvasLayer, a2 as CaptureDeps, a3 as ContributionBase, C as CreateLabStoreOptions, D as DEFAULT_FRAME, n as DragDropCapability, m as DragFeedback, a4 as FracPoint, a5 as FracRect, a6 as HitResult, a7 as IconComponent, a8 as LOUPE_DEFAULTS, L as LabDocument, d as LabStoreState, a9 as LayerCapability, aa as LayerDescriptor, ab as LoupeCapability, ac as LoupeDeclaration, ad as LoupeRenderArgs, P as PaletteItem, l as Point, ae as RegionContribution, af as RenderContext, ag as ResolvedLoupe, e as SavedSnapshot, ah as SerializedAnnotations, S as SerializedTrial, ai as SidebarSection, aj as SidebarSlotContext, ak as StageCapability, al as StatusReadout, f as StorageChange, am as SystemEvent, an as ToolCapability, ao as ToolItem, ap as ToolSlotContext, aq as ToolbarItem, ar as TrialChromeContext, as as TrialRegion, g as TrialStateHandle, at as UndoCapability, U as UndoStack, h as UndockedPanel, i as UndockedPanels, au as ViewportControl, V as ViewportSize, W as WorldFrame, a as WorldSpec, av as annotationsFromJSON, b as applyCamera, aw as auto, ax as createAnnotationScene, ay as createAnnotationStore, j as dockPanel, az as fracContains, aA as fracEncloses, aB as fracToWorld, aC as isAuto, p as panelKey, r as resolveFrame, aD as resolveLoupe, aE as roundFrac, u as undockPanel, aF as worldToFrac } from './_dts/frac-B4okC2lX.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-Pzf9f2jh.js';
+export { C as CanvasLayerDescriptor, a as CanvasStackContext, b as CanvasStackContextValue, c as CanvasStackSurface } from './_dts/CanvasStackContext-CJNMS6mz.js';
+import { L as LabContribution } from './_dts/index-CSJoj4LC.js';
+export { A as AddTrialOptions, a as LabAsideRegion, b as LabChromeContext, c as LabContext, d as LabContextValue, e as LabFooterRegion, f as LabHeaderRegion, g as LabRegion, h as LabRegionProps, i as LabSidebarRegion, P as PaletteRegion, j as PaletteRegionProps, S as SidebarRegion, k as SidebarRegionProps, l as StatusRegion, m as StatusRegionProps, T as TitleBarPlacement, n as TitleBarRegion, o as TitleBarRegionProps, p as ToolbarRegion, q as ToolbarRegionProps, V as ViewportRegion, r as ViewportRegionProps, s as addTrial, t as builtinContributions, u as cloneTrial, v as closeTrial, w as contributionsIn, x as labContributions, y as mergeContributions, z as reorderTrials, B as resetTrial, C as suppressContributions, D as toolContributions, E as useLabChromeContext, F as useLabContext } from './_dts/index-CSJoj4LC.js';
+export { BaseNode, BooleanNode, ColorNode, CustomNode, EnumNode, GroupNode, NumberNode, StringNode, ValueNode, applyRules, autoPathsOf, builtinRules, f, fillConfigDefaults, fromConfigFields, hasConfigPath, isConfigBranch, isLeafVisible, resolveAutoConfig, resolveConfigSchema, schemaNodeAtPath, titleCase, useConfigSchema, useResolvedConfig, valueAtPath, withValueAtPath } from './config/index.js';
+import { b as ConfigSchema, a as ConfigField, c as ConfigRule, d as ControlRenderer } from './_dts/types-DzoNY1pO.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-DzoNY1pO.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';
+export { CanvasLoupe, CanvasLoupeProps, DomLoupe, DomLoupeProps, LOUPE_MAGNIFY_ID, LOUPE_PEEK_ID, LensCamera, LoupeBubble, LoupeBubbleProps, LoupeGestures, LoupeGesturesProps, LoupeInputApi, LoupeState, SourceRect, TrialLoupe, TrialLoupeProps, UseLoupeOptions, createLoupeActions, drawCanvasLens, lensCamera, lensSourceRect, sampleStack, useLoupe } from './loupe/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-uLlmaccn.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';
+import { Theme } from '@weasel-js/theme';
 export { EventBus, EventListener, clearUndo, createEventBus, emptyStack, pushSnapshot, redo, undo } from './undo/index.js';
-import './_dts/PrefsForm.d-DDHFANkc.js';
+import 'react-aria-components';
+import './_dts/PrefsForm.d-DPy9I8It.js';
 import 'windease';
 import 'zustand/vanilla';
 
+declare const ResetIcon: (p: IconProps) => react_jsx_runtime.JSX.Element;
+declare const CloseIcon: (p: IconProps) => react_jsx_runtime.JSX.Element;
+declare const PlayIcon: (p: IconProps) => react_jsx_runtime.JSX.Element;
+declare const PauseIcon: (p: IconProps) => react_jsx_runtime.JSX.Element;
+declare const StopIcon: (p: IconProps) => react_jsx_runtime.JSX.Element;
+declare const StepBackIcon: (p: IconProps) => react_jsx_runtime.JSX.Element;
+declare const StepForwardIcon: (p: IconProps) => react_jsx_runtime.JSX.Element;
+declare const CollapseIcon: (p: IconProps) => react_jsx_runtime.JSX.Element;
+declare const ExpandIcon: (p: IconProps) => react_jsx_runtime.JSX.Element;
+
 /** An annotation drawn over a curve plot: a shaded band across a range of x,
  *  or a vertical line at one x. */
 type CurveMark = {
@@ -169,6 +182,81 @@ interface PropertyGroupProps extends PropertyMetricProps {
  */
 declare function PropertyGroup({ title, hidden, collapsible, defaultCollapsed, collapsed, onCollapsedChange, children, className, pack, density, align, }: PropertyGroupProps): react_jsx_runtime.JSX.Element | null;
 
+/** A design token as `TokenPanel` edits it. */
+interface TokenEntry {
+    /** The custom property, e.g. `--wzl-gray-50`. */
+    name: string;
+    /** A DTCG type name. A type the panel has no control for edits as text. */
+    type: string;
+    /** Tokens sharing a group sit together; a color group large enough draws as one row of swatches. */
+    group: string;
+    value: string;
+    /** Whether `value` overrides the token's own, which offers Reset. */
+    overridden?: boolean;
+    description?: string;
+}
+type TokenCategory = 'color' | 'type' | 'size' | 'motion' | 'depth' | 'other';
+/** A DTCG type read off the shape of a value, for a token that arrives without one. `'string'` when nothing fits. */
+declare function inferTokenType(value: string): string;
+
+type OnChange = (name: string, value: string | null) => void;
+/** Props for `<TokenPanel>`. */
+interface TokenPanelProps {
+    tokens: readonly TokenEntry[];
+    /** A token's new value, or null to drop its override. Keep it stable: rows re-render only when it or their token changes. */
+    onChange: OnChange;
+    /** Sections held closed, by category. Omit to let the panel keep that state itself. */
+    collapsed?: Readonly<Partial<Record<TokenCategory, boolean>>>;
+    onCollapsedChange?: (category: TokenCategory, collapsed: boolean) => void;
+    /** Files a token under a section. Defaults to `tokenCategory`. */
+    categorize?: (token: TokenEntry) => TokenCategory;
+    /** The fewest colors sharing a group that draw as one row of swatches. Default 3. */
+    familySize?: number;
+    /**
+     * Row layout. `tight` puts a token on one line — name, control, Reset — with the
+     * names on a fixed rail so the values read down the panel as a column, and caps
+     * the field rather than letting it span the panel. Default `normal` stacks the
+     * control under its name.
+     */
+    density?: 'tight' | 'normal';
+    className?: string;
+}
+/**
+ * Edits a set of design tokens by type: collapsible sections by category, a
+ * color group drawn as one row of swatches sized to fit, and a control for each
+ * type — a number with its unit for dimensions and durations, the nine weights
+ * for a font weight, a curve beside a `cubic-bezier()`, a swatch beside a color,
+ * and text for everything else.
+ */
+declare function TokenPanel({ tokens, onChange, collapsed, onCollapsedChange, categorize, familySize, density, className, }: TokenPanelProps): react_jsx_runtime.JSX.Element;
+
+/** Props for {@link Jog}. */
+interface JogProps {
+    /** Which step is showing, 0-based. */
+    index: number;
+    /** How many steps there are. */
+    count: number;
+    playing: boolean;
+    onPlay: (playing: boolean) => void;
+    /** Move one step, back or forward. */
+    onStep: (by: -1 | 1) => void;
+    /** Jump to a step. Left out, no scrubber is drawn. */
+    onScrub?: (index: number) => void;
+    /** What one step is called, for the spoken labels. Defaults to `Step`. */
+    unit?: string;
+    /** Drawn after the readout — a beat's caption, a snapshot's date. */
+    caption?: ReactNode;
+    className?: string;
+}
+/**
+ * Transport for something counted rather than timed: beat 3 of 24, not 4.20s of 12.00s.
+ * `<Transport>` is the continuous-time one, and wants a playhead in milliseconds, a rate and
+ * a loop, none of which a list of steps has.
+ *
+ * Named for the jog of jog/shuttle — moving one frame at a time, as against running at speed.
+ */
+declare function Jog(props: JogProps): react_jsx_runtime.JSX.Element;
+
 /** The subset of a mark's scene node this needs: where it is, and what it is. */
 interface PaintableMark {
     pose: WorldRect;
@@ -177,7 +265,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 +295,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[];
@@ -396,6 +484,10 @@ interface SvgStroke {
      * attribute may render with longer miters than the source SVG intended.
      */
     miterLimit?: number;
+    /** The kit stroke's `align`. SVG has no stroke alignment, so the serializer
+     *  writes the stroke centered and says so through `onWarn`; the parser
+     *  never sets it. */
+    align?: StrokeAlign;
     /** `marker-start` / `marker-mid` / `marker-end`, as the bare `url(#id)` key. */
     markerStart?: string;
     markerMid?: string;
@@ -431,6 +523,12 @@ interface SvgGroupNode {
     kind: 'group';
     children: SvgNode[];
     transform?: Matrix;
+    /** Clips the group's contents. Serializes to a `<clipPath>` def plus
+     *  `clip-path="url(#id)"`, and lives in the same space as `children` —
+     *  SVG applies the group's own `transform` to the clip as well.
+     *  A `<clipPath>` of more than one shape parses back as no clip: SVG
+     *  unions them and a `Path` holds one outline. */
+    clip?: Path;
     opacity?: number;
     /** Opaque per-element bag for declared namespaces. See `NamespaceMeta`. */
     meta?: NamespaceMeta;
@@ -445,9 +543,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';
@@ -461,6 +562,10 @@ interface SvgTextNode {
     runs?: StyledRun[];
     /** Node-wide typography. Defaults applied at render time via `resolveTextStyle`. */
     style?: TextStyle;
+    /** Where the laid-out text sits inside the box — `kit:text`'s
+     *  `data.verticalAlign`. SVG text has no box to align in, so this rides in
+     *  `data-weasel-vertical-align` and other readers draw the text top-aligned. */
+    verticalAlign?: TextVerticalAlign;
     /**
      * Node-wide glyph paint, the `FillStyle` / `Stroke` a kit text node holds
      * in `data.fill` / `data.stroke`. Not `SvgPaint`, which is the path
@@ -488,6 +593,12 @@ interface SvgTextNode {
  * a reference and only resolves when something downstream loads it.
  *
  * SVG's `preserveAspectRatio` is not modeled; the box is taken literally.
+ *
+ * With a `source` rect or a flip, the element is written as a `<g
+ * data-weasel-image>` holding a nested `<svg>` viewport at the box, whose
+ * `viewBox` is the source window over a unit-square `<image>` — plain SVG 1.1,
+ * which any reader crops and mirrors the same way, and which `parseSvg` reads
+ * back as one image node.
  */
 interface SvgImageNode {
     kind: 'image';
@@ -496,6 +607,20 @@ interface SvgImageNode {
     y: number;
     width: number;
     height: number;
+    /** The part of the bitmap drawn into the box, as fractions of the bitmap's
+     *  width and height from its top-left. Omitted draws the whole bitmap.
+     *  Fractions rather than bitmap pixels because this package never decodes
+     *  the image, so it cannot know its size. */
+    source?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** Mirror the drawn region within the box, as `ImageDrawCommand` does. The
+     *  box does not move. */
+    flipX?: boolean;
+    flipY?: boolean;
     /** Element-level opacity (`opacity="..."`), 0..1. */
     opacity?: number;
     /** Element-level rotation in **radians**, pivoting around the unrotated
@@ -530,7 +655,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;
 }
 /**
@@ -575,9 +700,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;
@@ -610,226 +735,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'> & {
@@ -868,13 +773,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
@@ -883,12 +825,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[];
@@ -901,110 +858,51 @@ 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): string | number | bigint | boolean | react_jsx_runtime.JSX.Element | Iterable<ReactNode> | Promise<string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | null;
 
 /** 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;
 
-/** 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;
+/** Props for `<LabRoot>`. */
+interface LabRootProps {
+    children: ReactNode;
+    /** Color mode. "auto" (default) follows prefers-color-scheme. */
+    mode?: LabMode;
+    /** Added after `lk-root` on the same element. */
     className?: string;
 }
-/** Which of `pages` a path is on, or -1.
+/** The element every labkit component expects above it: `.lk-root`, which
+ *  carries the design tokens, the font stack, the box-sizing reset and the
+ *  element defaults a lab's bare markup is styled by, plus a theme when the
+ *  app has not already applied one.
  *
- *  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;
+ *  `<LabShell>` and `<Lab>` render this themselves. Mount it by hand around a
+ *  labkit piece used on its own — a bare `<Workspace>` or `<ControlPanel>` —
+ *  or those components inherit whatever the host page happens to define.
+ *  Pair it with `import '@weasel-js/labkit/styles.css'`, which is what defines
+ *  the rules this element scopes. */
+declare function LabRoot({ children, mode, className }: LabRootProps): react_jsx_runtime.JSX.Element;
 
 /** Props for `<LabShell>`. */
 interface LabShellProps {
@@ -1026,7 +924,7 @@ interface LabShellProps {
 /** 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, pages, path }: 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. */
@@ -1090,6 +988,18 @@ interface PanelDescriptor {
 }
 declare function Workspace({ children, ids, panels, resizable, reorderable, onReorder, layout, onLayoutChange, gap, padding, viewport, }: WorkspaceProps): react_jsx_runtime.JSX.Element;
 
+/** The specimen's sections, in page order. */
+declare const SPECIMEN_SECTIONS: readonly ["Buttons & toggles", "Fields & pickers", "Panels & property rows", "Overlays & feedback", "Lists & data", "Tool chrome", "Editors & plots", "Lab chrome"];
+/**
+ * One page of the kit's controls and chrome, each in a small working state: a
+ * preview surface for a theme, where every token has something on screen that
+ * reads it. Popovers, dialogs and toasts portal into the page itself, so they
+ * take whatever theme the page is under.
+ */
+declare function Specimen({ className }: {
+    className?: string;
+}): 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;
@@ -1098,40 +1008,10 @@ declare const DEFAULT_VIEW: ViewTransform2D;
  *  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.
+ * built-in weasel theme. A pins-only theme definition: nothing in it is
+ * derived, so it loads without the engine.
  */
 declare const interstellarTheme: Theme;
 
@@ -1149,7 +1029,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. */
@@ -1157,36 +1037,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 {
@@ -1229,5 +1082,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, LabSwitcher, 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, currentPage, 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, LabPage, LabPaletteProps, LabProps, LabShellProps, LabSwitcherProps, 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, CloseIcon, CollapseIcon, ConfigField, ConfigRule, ConfigSchema, ControlRenderer, CurveField, DEFAULT_VIEW, EffectCard, EffectCardList, ExpandIcon, ExportMenu, IconProps, Instrument, InstrumentList, JobHandle, Jog, Lab, LabContribution, LabMode, LabPalette, LabRoot, LabShell, LabSwitcher, MarkList, MarkScene, PauseIcon, PlayIcon, PropertyGroup, PropertyListPack, ResetIcon, SPECIMEN_SECTIONS, Specimen, SplitProps, StepBackIcon, StepForwardIcon, StopIcon, StorageAdapter, Subpanel, TokenPanel, Trial, TrialBody, TrialChrome, TrialContribution, TrialInfo, TrialRecord, TrialTool, ViewTransform, Workspace, WorldRect, annotationToolInfo, as2DView, capturePlan, captureTarget, composeCaptureSvg, createMarkDrawOne, currentPage, defineInstrument, fitView, fromWeaselView, inferTokenType, 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, JogProps, LabPage, LabPaletteProps, LabProps, LabRootProps, LabShellProps, LabSwitcherProps, MarkDrawOptions, MarkListProps, MarkStyle, PaintableMark, PaneSize, PanelDescriptor, PropertyGroupProps, SubpanelProps, TokenCategory, TokenEntry, TokenPanelProps, TrialBodyProps, TrialChromeProps, TrialLayout, TrialProps, UndoBindings, ValidationResult, ViewTransform2D, WorkspaceProps };