@weasel-js/labkit 1.4.2 → 1.4.4

package/README.md

@@ -13,10 +13,16 @@ algorithm and would rather not build the page around it.
 ## Install
 
 ```bash
-npm i @weasel-js/labkit
+npm i @weasel-js/labkit @weasel-js/core
 ```
 
-React 19 is a peer dependency (`react` and `react-dom`, `^19.0.0`). One
+`@weasel-js/core` is a peer dependency, pinned to the matching version. labkit
+does not ship its own copy: core keeps its content handlers, paint kinds, shape
+painters and markers in module-global registries, and two copies means anything
+registered through one is invisible to the other — a blank canvas with no error.
+Installing it alongside is what guarantees there is exactly one.
+
+React 19 is a peer dependency too (`react` and `react-dom`, `^19.0.0`). One
 stylesheet import covers everything labkit draws, including the theme tokens and
 the `@weasel-js/ui` components it passes through:
 
@@ -70,6 +76,18 @@ renders the settings panel from it. `render` returns the instrument's own DOM;
 returning `null` alongside `canvas` means the canvas layers are the whole
 picture. `storage` keeps open trials and their state across reloads.
 
+A value is addressed by its path: `bins` above sits at `config.bins` and is
+written as `setConfig('bins', 40)`. `f.group` nests one —
+`paper: f.group({ width: f.number(210) })` puts the value at
+`config.paper.width` and addresses it as `'paper.width'`, in `setConfig`, in a
+control override, and anywhere else a path is taken. `.section('Advanced')` is
+the other thing and only looks like it: it puts a heading over sibling rows and
+leaves their paths alone.
+
+A stored config missing something its schema has since gained — a whole nested
+group included — is filled from the instrument's defaults as it loads, so
+growing a schema never strands a saved trial or a snapshot.
+
 ## Capabilities
 
 A capability is a field on the instrument. Declaring it is what makes the trial

package/dist/_dts/{CanvasStackContext-kjILVnPj.d.ts → CanvasStackContext-kTEZvEgE.d.ts}

@@ -1,6 +1,6 @@
 import * as react from 'react';
 import { RefObject } from 'react';
-import { V as ViewTransform, W as WorldFrame } from './frac-A4R6v4ld.js';
+import { V as ViewTransform, W as WorldFrame } from './frac-z7ker2Vx.js';
 
 /** One layer of a canvas stack: its id, whether it is currently shown, and how
  *  it paints itself. */

package/dist/_dts/{PrefsForm.d-CgxUequc.d.ts → PrefsForm.d-DDHFANkc.d.ts}

@@ -1,5 +1,5 @@
 import { ReactNode } from 'react';
-import { T as ToolPrefLeaf } from './weasel-canvas-FJTFi3ZZ.js';
+import { ToolPrefLeaf } from '@weasel-js/core';
 
 /** What a {@link PrefRenderer} is given for the leaf it is rendering. */
 interface PrefRenderContext {

package/dist/_dts/{frac-A4R6v4ld.d.ts → frac-z7ker2Vx.d.ts}

@@ -1,8 +1,9 @@
 import { ComponentType, ReactNode, RefObject } from 'react';
-import { R as ResolvedConfig, C as ConfigField, a as ConfigSchema } from './types-lg4TSCb2.js';
-import { c as SavedSnapshot, i as TrialInfo } from './types-BbXpvQa8.js';
+import { R as ResolvedConfig, a as ConfigSchema, C as ConfigPath } from './types-B9_zrHmb.js';
+import { C as ConfigField } from './types-x92Kfeme.js';
+import { c as SavedSnapshot, i as TrialInfo } from './types-BP2OCcpg.js';
 import { J as JobHandle, a as JobCapability } from './types-DJ79Tg5J.js';
-import { S as Scene } from './weasel-canvas-FJTFi3ZZ.js';
+import { Scene } from '@weasel-js/core';
 
 /** How an instrument's world sits on the canvas, independent of the camera.
  *  The defaults reproduce the convention labkit shipped before this existed:
@@ -299,7 +300,9 @@ interface RenderContext<TS = unknown, TC = unknown> {
     state: TS;
     config: TC;
     setState: (next: TS | ((prev: TS) => TS)) => void;
-    setConfig: (key: keyof TC, value: unknown) => void;
+    /** Write one config value, by dotted path — `'grid.size'` for a leaf under
+     *  an `f.group`, `'cellSize'` for one at the root. */
+    setConfig: (path: ConfigPath<TC>, value: unknown) => void;
     /** labkit persists `view` and restores it on Reset without ever reading
      *  into it. */
     trial: TrialInfo & {
@@ -751,8 +754,9 @@ declare function roundFrac(f: FracRect): FracRect;
  *  mark stays reachable. */
 declare function fracContains(box: FracRect, pt: FracPoint, tol?: number): boolean;
 /** Whether `outer` wholly encloses `inner`. A marquee takes what it encloses,
- *  not what it grazes — brushing selection is a different gesture. */
-declare function fracIntersects(outer: FracRect, inner: FracRect): boolean;
+ *  not what it grazes — brushing selection is a different gesture, and this
+ *  answers false for two rects that merely overlap. */
+declare function fracEncloses(outer: FracRect, inner: FracRect): boolean;
 
-export { LOUPE_DEFAULTS as L, annotationsFromJSON as a3, applyCamera as a4, createAnnotationScene as a5, createAnnotationStore as a6, fracContains as a7, fracIntersects as a8, fracToWorld as a9, resolveFrame as aa, resolveLoupe as ab, roundFrac as ac, worldToFrac as ad, DEFAULT_FRAME as x };
+export { LOUPE_DEFAULTS as L, annotationsFromJSON as a3, applyCamera as a4, createAnnotationScene as a5, createAnnotationStore as a6, fracContains as a7, fracEncloses as a8, fracToWorld as a9, resolveFrame as aa, resolveLoupe as ab, roundFrac as ac, worldToFrac as ad, DEFAULT_FRAME as x };
 export type { TrialRegion as $, AnnotationData as A, LayerCapability as B, CaptureSource as C, DragFeedback as D, LayerDescriptor as E, FracPoint as F, LoupeCapability as G, HitResult as H, Instrument as I, LoupeDeclaration as J, LoupeRenderArgs as K, MarkScene as M, ResolvedLoupe as N, SidebarSection as O, PaletteItem as P, StatusReadout as Q, RenderContext as R, SerializedAnnotations as S, TrialTool as T, SystemEvent as U, ViewTransform as V, WorldFrame as W, ToolCapability as X, ToolItem as Y, ToolbarItem as Z, TrialChromeContext as _, Point as a, UndoCapability as a0, ViewportControl as a1, ViewportSize as a2, LoupePoint as ae, LoupeMode as af, DragDropCapability as b, WorldSpec as c, WorldRect as d, AnnotationMeaning as e, CaptureOptions as f, CaptureResult as g, AnnotationTarget as h, AnnotationsApi as i, AnnotationsCapability as j, AnnotationKind as k, InstrumentList as l, TrialContribution as m, Annotation as n, AnnotationInit as o, AnnotationPatch as p, AnnotationQuery as q, AnnotationStatus as r, AnnotationStoreOptions as s, AnnotationTargetInfo as t, CanvasCapability as u, CanvasLayer as v, CaptureDeps as w, FracRect as y, IconComponent as z };

package/dist/_dts/{index-CsU9WhjM.d.ts → index-Blv9uQzu.d.ts}

@@ -1,6 +1,7 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { ReactNode } from 'react';
-import { R as ResolvedConfig, C as ConfigField, c as ControlRenderer } from './types-lg4TSCb2.js';
+import { R as ResolvedConfig, c as ControlRenderer } from './types-B9_zrHmb.js';
+import { C as ConfigField } from './types-x92Kfeme.js';
 
 /**
  * How much room a container gives its rows — gaps, padding, and field height,
@@ -143,10 +144,24 @@ declare function SliderRow({ label, value, min, max, step, onChange, onInput, fo
 interface ColorRowProps extends PropertyMetricProps {
     label: ReactNode;
     value: string;
+    /**
+     * The committed color. Given `onInput` as well, it fires once the picker
+     * closes; on its own it fires on every move inside it, which is what a row
+     * with one callback has always done.
+     */
     onChange: (next: string) => void;
+    /**
+     * The live color, fired continuously while the picker is open. Pass it
+     * alongside `onChange` when the write is expensive — cheap state here, the
+     * costly work there. Mirrors `<Slider>`'s `onInput` / `onChange` pair.
+     */
+    onInput?: (next: string) => void;
     /** 0..1 alpha. When provided, a translucent slider renders beneath the swatch. */
     alpha?: number;
+    /** The committed alpha, on the same terms as `onChange`. */
     onAlphaChange?: (next: number) => void;
+    /** The live alpha, on the same terms as `onInput`. */
+    onAlphaInput?: (next: number) => void;
     /**
      * Render the alpha track as inert (dimmed, no thumb, not-allowed cursor).
      * Use when the color's consumer drops alpha so the affordance reads dead.
@@ -159,7 +174,7 @@ interface ColorRowProps extends PropertyMetricProps {
     span?: boolean;
 }
 /** A color swatch, optionally with an alpha slider beneath it. */
-declare function ColorRow({ label, value, onChange, alpha, onAlphaChange, alphaDisabled, layout, description, span, density, align, }: ColorRowProps): react_jsx_runtime.JSX.Element;
+declare function ColorRow({ label, value, onChange, onInput, alpha, onAlphaChange, onAlphaInput, alphaDisabled, layout, description, span, density, align, }: ColorRowProps): react_jsx_runtime.JSX.Element;
 /** Props for `<CheckboxRow>`. */
 interface CheckboxRowProps extends PropertyMetricProps {
     label: ReactNode;
@@ -191,7 +206,18 @@ declare function TextRow({ label, value, onChange, placeholder, maxLength, layou
 interface NumberRowProps extends PropertyMetricProps {
     label: ReactNode;
     value: number;
+    /**
+     * The committed value. Given `onInput` as well, it fires on blur or Enter;
+     * on its own it fires on every keystroke, which is what a row with one
+     * callback has always done.
+     */
     onChange: (next: number) => void;
+    /**
+     * The live value, fired per keystroke. Pass it alongside `onChange` when the
+     * write is expensive — cheap state here, the costly work there. Mirrors
+     * `<Slider>`'s `onInput` / `onChange` pair.
+     */
+    onInput?: (next: number) => void;
     min?: number;
     max?: number;
     step?: number;
@@ -209,7 +235,7 @@ interface NumberRowProps extends PropertyMetricProps {
 }
 /** A number typed directly. Reach for `<SliderRow>` when the range matters
  *  more than the exact value. */
-declare function NumberRow({ label, value, onChange, min, max, step, placeholder, unit, layout, description, span, density, align, }: NumberRowProps): react_jsx_runtime.JSX.Element;
+declare function NumberRow({ label, value, onChange, onInput, min, max, step, placeholder, unit, layout, description, span, density, align, }: NumberRowProps): react_jsx_runtime.JSX.Element;
 interface PropertyOption<T extends string> {
     value: T;
     label: ReactNode;
@@ -258,7 +284,9 @@ interface ControlPanelProps<TC extends Record<string, unknown>> {
     /** @deprecated Pass `schema`. A field list is adapted into one internally. */
     fields?: ConfigField[];
     config: TC;
-    setConfig: (key: keyof TC, value: unknown) => void;
+    /** Writes one value. The path is dotted for a leaf inside an `f.group`, and
+     *  the bare key for one at the root. */
+    setConfig: (path: string, value: unknown) => void;
     /**
      * Control overrides and app-defined kinds, PrefsForm-style. Keys are config
      * paths (checked first) or leaf kinds. A renderer returning `null` collapses
@@ -279,16 +307,21 @@ interface ControlPanelProps<TC extends Record<string, unknown>> {
     align?: PropertyAlign;
     /**
      * Fold each section away behind a twisty, starting `'open'` or `'closed'`.
-     * Unset draws the heading alone, as the panel always has.
+     * Unset draws the heading alone, as the panel always has — unless a section
+     * in the schema declares how it opens, which makes that section foldable on
+     * its own and outranks this for that one section.
      */
     collapse?: 'open' | 'closed';
     /**
-     * Which sections are folded, keyed by section label. Given, the panel keeps
-     * no state of its own: every toggle arrives at `onCollapse` instead, which
-     * is where a lab that remembers a trial's sections writes them.
+     * Which sections are folded, keyed as `onCollapse` reports them. Given, the
+     * panel keeps no state of its own: every toggle arrives at `onCollapse`
+     * instead, which is where a lab that remembers a trial's sections writes
+     * them.
      */
     collapsed?: Readonly<Record<string, boolean>>;
-    onCollapse?: (label: string, collapsed: boolean) => void;
+    /** A fold moved. The key is a section's label — prefixed by its group's
+     *  dotted path when the section sits inside one — or a group's own path. */
+    onCollapse?: (key: string, collapsed: boolean) => void;
     /** Draw leaves marked `hidden`. */
     showHidden?: boolean;
     className?: string;

package/dist/_dts/types-B9_zrHmb.d.ts

@@ -0,0 +1,166 @@
+import { ToolPrefLeaf, ToolPrefGroup } from '@weasel-js/core';
+import { P as PrefRenderer } from './PrefsForm.d-DDHFANkc.js';
+
+/**
+ * Renders the control cell for one config leaf. Identical to weasel-ui's
+ * `PrefRenderer` on purpose — aliased rather than redeclared so the two
+ * cannot drift.
+ */
+type ControlRenderer = PrefRenderer;
+/** One labeled choice in an `enum` leaf. */
+interface ConfigOption {
+    value: string;
+    label: string;
+}
+/** Everything a leaf can carry beyond its kind and default. A flat union of
+ *  every `Pref*` leaf's extras, plus labkit's own `debounceMs`. */
+interface Annotations {
+    name?: string;
+    description?: string;
+    hidden?: boolean;
+    block?: boolean;
+    pair?: string;
+    min?: number;
+    max?: number;
+    step?: number;
+    suffix?: string;
+    control?: string;
+    options?: readonly ConfigOption[];
+    placeholder?: string;
+    maxLength?: number;
+    /** Milliseconds to debounce a string leaf's live writes. Default 150. */
+    debounceMs?: number;
+}
+/** What a rule contributes. `kind` is honored only while it is still unset,
+ *  which is what makes `f.value` claimable and a kinded factory final. */
+type LeafPatch = Annotations & {
+    kind?: string;
+};
+/** What a rule is given for the leaf it is deciding about. */
+interface ConfigRuleContext {
+    /** The leaf's own key — its last path segment, and what a label is titled
+     *  from. */
+    key: string;
+    /** Dotted path within the schema, which is the path the value is written
+     *  at. Equal to `key` for a leaf sitting at the root. */
+    path: string;
+    /** The leaf's default value. A rule may read it but never change it. */
+    default: unknown;
+    /** What earlier rules and the author's own annotations have settled. */
+    leaf: Readonly<LeafPatch>;
+}
+/**
+ * Decides part of how a leaf is presented. Returns a patch, or null to
+ * abstain. Merging is gap-filling: a property already settled is never
+ * overwritten, so the author's annotations beat every rule and a consumer's
+ * rules beat labkit's built-ins.
+ */
+type ConfigRule = (ctx: ConfigRuleContext) => LeafPatch | null;
+/** A presentational bucket of nodes, rendered under one heading. Buckets
+ *  siblings: a section never nests a value, which is what separates it from
+ *  `f.group`. */
+interface SectionSpec {
+    /** Dotted path of the group whose children this buckets. `''` is the root,
+     *  which is where every section of a flat schema sits. */
+    at: string;
+    label: string;
+    /** Full dotted paths, so a section under a group names its children the way
+     *  everything else does. */
+    paths: readonly string[];
+    /** Whether the section opens folded. Set, the panel folds this section
+     *  whether or not it was given a panel-wide `collapse`; a fold the reader
+     *  has since toggled outranks it. */
+    collapsed?: boolean;
+}
+/** A schema resolved against a set of rules: the vocabulary weasel-ui renders,
+ *  plus the three things labkit keeps on the side because `PrefLeaf` has no
+ *  field for them. */
+interface ResolvedConfig {
+    /** The schema as a `PrefGroup` tree: an `f.group` is a nested group, so a
+     *  leaf's dotted path within it is the path its value is written at. */
+    group: ToolPrefGroup;
+    sections: readonly SectionSpec[];
+    showIf: ReadonlyMap<string, (config: Record<string, unknown>) => boolean>;
+    /** Node-level `.render` overrides, keyed by path. */
+    renderers: Readonly<Record<string, ControlRenderer>>;
+}
+/** How a node names the section it belongs to: the heading, and how that
+ *  section opens. Every node in one section repeats the heading; only one of
+ *  them has to say `collapsed`. */
+interface SectionOption {
+    label: string;
+    collapsed?: boolean;
+}
+/** Per-node extras that do not belong on a `PrefLeaf`. */
+interface NodeOptions extends BranchOptions {
+    render?: ControlRenderer;
+    validate?: (leaf: ToolPrefLeaf) => string[];
+}
+/** What a branch can say about itself, beyond its children. */
+interface BranchOptions {
+    section?: SectionOption;
+    /** Show this node only while the predicate holds. On a group it hides the
+     *  whole subtree; the values stay in config either way. */
+    showIf?: (config: Record<string, unknown>) => boolean;
+}
+/** A group's own annotations: what it is called and, optionally, why. */
+interface BranchAnnotations {
+    name?: string;
+    description?: string;
+}
+/** The builder's leaf: a kind (or null, to be decided by rules), a default,
+ *  an annotation bag, and the extras above. */
+interface ConfigNode<T = unknown> {
+    readonly kind: string | null;
+    readonly default: T;
+    readonly annotations: Readonly<Annotations>;
+    readonly options: Readonly<NodeOptions>;
+}
+/** The builder's branch: named children, nested as deeply as the schema
+ *  wants. A branch nests the value too — `grid: f.group({ size })` puts the
+ *  value at `grid.size`, where `.section('Grid')` would have left it at
+ *  `size`. */
+interface ConfigBranch<S extends ConfigShape = ConfigShape> {
+    readonly children: S;
+    readonly annotations: Readonly<BranchAnnotations>;
+    readonly options: Readonly<BranchOptions>;
+}
+/** Either half of a schema tree. */
+type ConfigEntry = ConfigNode | ConfigBranch;
+/** The children of a schema or a group. */
+type ConfigShape = {
+    readonly [key: string]: ConfigEntry;
+};
+/** The value type a node produces. */
+type NodeValue<N> = N extends ConfigNode<infer T> ? T : never;
+/** The value type a schema entry produces — a leaf's own, or a branch's
+ *  nested record. */
+type EntryValue<E> = E extends ConfigBranch<infer S> ? InferConfig<S> : E extends ConfigNode<infer T> ? T : never;
+/** The config type a builder shape produces. */
+type InferConfig<S> = {
+    [K in keyof S]: EntryValue<S[K]>;
+};
+/** Whether a config value has children a path can descend into. Arrays and
+ *  functions are values, not branches. */
+type Branching<V> = V extends readonly unknown[] ? false : V extends (...args: never[]) => unknown ? false : V extends object ? true : false;
+/**
+ * Every dotted path a config offers, a group's own path included. A config
+ * whose shape is not known — `unknown`, or a bare record — gives `string`,
+ * which is what keeps a generic instrument writable.
+ */
+type ConfigPath<T> = unknown extends T ? string : T extends object ? {
+    [K in keyof T & string]: Branching<T[K]> extends true ? K | `${K}.${ConfigPath<T[K]>}` : K;
+}[keyof T & string] : never;
+/** The type at a dotted path, or `unknown` where the path is not one the
+ *  config's type spells out. */
+type ValueAtPath<T, P extends string> = unknown extends T ? unknown : P extends `${infer Head}.${infer Rest}` ? Head extends keyof T ? ValueAtPath<T[Head], Rest> : unknown : P extends keyof T ? T[P] : unknown;
+/** An instrument's config, declared once. */
+interface ConfigSchema<TC> {
+    readonly nodes: ConfigShape;
+    /** The starting config — what `defaultConfig()` would have returned. */
+    defaults(): TC;
+}
+/** The config type behind a schema: `ConfigOf<typeof sceneConfig>`. */
+type ConfigOf<S> = S extends ConfigSchema<infer TC> ? TC : never;
+
+export type { Annotations as A, BranchAnnotations as B, ConfigPath as C, EntryValue as E, InferConfig as I, LeafPatch as L, NodeOptions as N, ResolvedConfig as R, SectionSpec as S, ValueAtPath as V, ConfigSchema as a, ConfigNode as b, ControlRenderer as c, ConfigOption as d, ConfigShape as e, ConfigBranch as f, BranchOptions as g, ConfigEntry as h, ConfigRule as i, ConfigRuleContext as j, ConfigOf as k, NodeValue as l };

package/dist/_dts/{types-BbXpvQa8.d.ts → types-BP2OCcpg.d.ts}

@@ -1,3 +1,5 @@
+import { C as ConfigPath, V as ValueAtPath } from './types-B9_zrHmb.js';
+
 /** A sidebar section torn out of its trial, and where it went. */
 interface UndockedPanel {
     trialId: string;
@@ -101,7 +103,9 @@ interface TrialStateHandle<TS, TC> {
     state: TS;
     setState: (next: TS | ((prev: TS) => TS)) => void;
     config: TC;
-    setConfig: (key: keyof TC, value: TC[keyof TC]) => void;
+    /** Write one config value, by dotted path — `'grid.size'` for a leaf under
+     *  an `f.group`, `'cellSize'` for one at the root. */
+    setConfig: <P extends ConfigPath<TC> & string>(path: P, value: ValueAtPath<TC, P>) => void;
 }
 /** Options for `createLabStore`. `storageKey` namespaces the keys written, so
  *  two labs on one origin do not collide. */
@@ -109,12 +113,26 @@ interface CreateLabStoreOptions {
     storageKey: string;
     storage: StorageAdapter;
     initialMode?: LabMode;
+    /** Each instrument's default config, keyed by instrument name, used to fill
+     *  the gaps in a stored one. A config saved before its schema grew a branch
+     *  arrives holding that branch's defaults rather than `undefined`, and keeps
+     *  whatever keys the schema has since stopped naming. `<Lab>` collects these
+     *  off its `instruments`. */
+    configDefaults?: Record<string, () => unknown>;
+    /** How each instrument's state survives a reload. Hydration is the first
+     *  thing `createLabStore` does, so these have to arrive with the store —
+     *  anything registered afterwards is already too late to read the document
+     *  it was built from. `<Lab>` collects them off its `instruments`. */
+    serializers?: InstrumentSerializers;
 }
 /** Per-instrument serialize/deserialize hooks, keyed by instrument name. An
- *  instrument whose state is already JSON-safe needs no entry. */
+ *  instrument whose state is already JSON-safe needs no entry. `deserialize`
+ *  is handed the config the state was saved against — a trial's own for a
+ *  reload, the snapshot's for a load — since a state rebuilt without it can
+ *  disagree with the settings sitting next to it. */
 type InstrumentSerializers = Record<string, {
     serialize?: (state: unknown) => unknown;
-    deserialize?: (data: unknown) => unknown;
+    deserialize?: (data: unknown, config: unknown) => unknown;
 } | undefined>;
 /** A trial as it is persisted: everything but the undo history, which is
  *  session-only. */

package/dist/_dts/types-x92Kfeme.d.ts

@@ -0,0 +1,62 @@
+/** Which control a config field is edited with. */
+type ConfigFieldType = 'slider' | 'checkbox' | 'select' | 'number' | 'text' | 'color';
+/** What every config field carries: the config key it writes, the label shown
+ *  beside it, and which control renders it. */
+interface ConfigFieldBase {
+    key: string;
+    label: string;
+    type: ConfigFieldType;
+}
+/** A bounded number edited by dragging. */
+interface SliderField extends ConfigFieldBase {
+    type: 'slider';
+    default: number;
+    min: number;
+    max: number;
+    step?: number;
+}
+/** A boolean. */
+interface CheckboxField extends ConfigFieldBase {
+    type: 'checkbox';
+    default: boolean;
+}
+/** One choice in a select field. */
+interface SelectOption {
+    value: string;
+    label: string;
+}
+/** A fixed set of labeled choices. */
+interface SelectField extends ConfigFieldBase {
+    type: 'select';
+    default: string;
+    options: SelectOption[];
+}
+/** A number typed directly, optionally bounded. Use a slider field instead
+ *  when the range matters more than the exact value. */
+interface NumberField extends ConfigFieldBase {
+    type: 'number';
+    default: number;
+    min?: number;
+    max?: number;
+    step?: number;
+}
+/** A free-text string. Writes are debounced so typing does not re-run the
+ *  instrument on every keystroke. */
+interface TextField extends ConfigFieldBase {
+    type: 'text';
+    default: string;
+    placeholder?: string;
+    maxLength?: number;
+    /** Milliseconds to debounce live setConfig calls. Default 150 ms. Set to 0 to disable. */
+    debounceMs?: number;
+}
+/** A color, as a CSS color string. */
+interface ColorField extends ConfigFieldBase {
+    type: 'color';
+    default: string;
+}
+/** One field of an instrument's config schema. The schema is what the control
+ *  panel renders, and what `validateConfigSchema` checks. */
+type ConfigField = SliderField | CheckboxField | SelectField | NumberField | TextField | ColorField;
+
+export type { ConfigField as C, NumberField as N, SelectField as S, TextField as T, CheckboxField as a, ColorField as b, ConfigFieldBase as c, ConfigFieldType as d, SelectOption as e, SliderField as f };

package/dist/_dts/{useTrialState-DKjqpv20.d.ts → useTrialState-D6Vb3T-g.d.ts}

@@ -1,4 +1,4 @@
-import { a as StorageAdapter, b as LabStoreState, T as TrialRecord, c as SavedSnapshot, h as LabMode, e as UndockedPanel, I as InstrumentSerializers, C as CreateLabStoreOptions, d as TrialStateHandle } from './types-BbXpvQa8.js';
+import { a as StorageAdapter, b as LabStoreState, T as TrialRecord, c as SavedSnapshot, h as LabMode, e as UndockedPanel, C as CreateLabStoreOptions, d as TrialStateHandle } from './types-BP2OCcpg.js';
 import * as react from 'react';
 import { ReactNode, ReactElement } from 'react';
 import { StoreApi } from 'zustand/vanilla';
@@ -23,7 +23,9 @@ interface LabStoreActions {
     addTrial: (record: Omit<TrialRecord, 'undoStack'>) => void;
     removeTrial: (id: string) => void;
     updateTrialState: <TS>(id: string, next: TS | ((prev: TS) => TS)) => void;
-    updateTrialConfig: <TC>(id: string, key: keyof TC, value: TC[keyof TC]) => void;
+    /** Write one config value. `path` is dotted for a value nested under an
+     *  `f.group`, and the bare key for one at the root. */
+    updateTrialConfig: (id: string, path: string, value: unknown) => void;
     updateTrialView: (id: string, view: unknown) => void;
     updateTrialSidebarWidth: (id: string, width: number) => void;
     /** Retitle a trial. `null` returns it to its instrument's name. */
@@ -46,11 +48,9 @@ interface LabStoreActions {
     /** Put one section back, or — with no `sectionId` — every panel the trial owns. */
     dockPanel: (trialId: string, sectionId?: string) => void;
 }
-/** A lab's store: its state and actions, plus the hook instruments use to
- *  register how their state is serialized. */
-type LabStore = StoreApi<LabStoreState & LabStoreActions> & {
-    registerSerializers: (s: InstrumentSerializers) => void;
-};
+/** A lab's store: its state and its actions. How each instrument's state is
+ *  serialized comes in through `CreateLabStoreOptions.serializers`. */
+type LabStore = StoreApi<LabStoreState & LabStoreActions>;
 /** Build a lab store, hydrating from storage if anything was saved under the
  *  same key. Writes back are debounced. */
 declare function createLabStore(options: CreateLabStoreOptions): LabStore;

package/dist/canvas/index.d.ts

@@ -1,13 +1,14 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { ReactNode, WheelEvent, PointerEvent as PointerEvent$1 } from 'react';
-import { V as ViewTransform, c as WorldSpec, a2 as ViewportSize, a as Point, W as WorldFrame } from '../_dts/frac-A4R6v4ld.js';
-export { x as DEFAULT_FRAME, a4 as applyCamera, aa as resolveFrame } from '../_dts/frac-A4R6v4ld.js';
-import { C as CanvasLayerDescriptor } from '../_dts/CanvasStackContext-kjILVnPj.js';
-export { a as CanvasStackContext, b as CanvasStackContextValue, c as CanvasStackSurface } from '../_dts/CanvasStackContext-kjILVnPj.js';
-import '../_dts/types-lg4TSCb2.js';
-import '../_dts/weasel-canvas-FJTFi3ZZ.js';
-import '../_dts/PrefsForm.d-CgxUequc.js';
-import '../_dts/types-BbXpvQa8.js';
+import { V as ViewTransform, c as WorldSpec, a2 as ViewportSize, a as Point, W as WorldFrame } from '../_dts/frac-z7ker2Vx.js';
+export { x as DEFAULT_FRAME, a4 as applyCamera, aa as resolveFrame } from '../_dts/frac-z7ker2Vx.js';
+import { C as CanvasLayerDescriptor } from '../_dts/CanvasStackContext-kTEZvEgE.js';
+export { a as CanvasStackContext, b as CanvasStackContextValue, c as CanvasStackSurface } from '../_dts/CanvasStackContext-kTEZvEgE.js';
+import '../_dts/types-B9_zrHmb.js';
+import '@weasel-js/core';
+import '../_dts/PrefsForm.d-DDHFANkc.js';
+import '../_dts/types-x92Kfeme.js';
+import '../_dts/types-BP2OCcpg.js';
 import '../_dts/types-DJ79Tg5J.js';
 
 /** Props for `<CanvasStack>`. */

package/dist/canvas/index.js

@@ -1,7 +1,6 @@
-export { CanvasStack, PITCH_LIMIT, clampPitch, orbitAfterDrag, orbitAfterWheel, useOrbit, usePanZoom, wrapYaw } from '../chunk-FJG4PHTL.js';
+export { CanvasStack, PITCH_LIMIT, clampPitch, orbitAfterDrag, orbitAfterWheel, useOrbit, usePanZoom, wrapYaw } from '../chunk-I6JCVE24.js';
 export { centerOn, zoomAt } from '../chunk-CTRKTLYZ.js';
 export { DEFAULT_FRAME, applyCamera, resolveFrame, screenToWorld, worldToScreen } from '../chunk-2AYGEN57.js';
 export { CanvasStackContext } from '../chunk-CQLQPQ4P.js';
-import '../chunk-54ZWZ5FQ.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/chrome/index.d.ts

@@ -1,11 +1,12 @@
-import { c as ControlRenderer } from '../_dts/types-lg4TSCb2.js';
-import { I as Instrument, _ as TrialChromeContext, m as TrialContribution } from '../_dts/frac-A4R6v4ld.js';
-export { z as IconComponent, O as SidebarSection, Q as StatusReadout, Y as ToolItem, Z as ToolbarItem, $ as TrialRegion, a1 as ViewportControl } from '../_dts/frac-A4R6v4ld.js';
+import { c as ControlRenderer } from '../_dts/types-B9_zrHmb.js';
+import { I as Instrument, _ as TrialChromeContext, m as TrialContribution } from '../_dts/frac-z7ker2Vx.js';
+export { z as IconComponent, O as SidebarSection, Q as StatusReadout, Y as ToolItem, Z as ToolbarItem, $ as TrialRegion, a1 as ViewportControl } from '../_dts/frac-z7ker2Vx.js';
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import '../_dts/weasel-canvas-FJTFi3ZZ.js';
+import '@weasel-js/core';
+import '../_dts/PrefsForm.d-DDHFANkc.js';
 import 'react';
-import '../_dts/PrefsForm.d-CgxUequc.js';
-import '../_dts/types-BbXpvQa8.js';
+import '../_dts/types-x92Kfeme.js';
+import '../_dts/types-BP2OCcpg.js';
 import '../_dts/types-DJ79Tg5J.js';
 
 /**

package/dist/chrome/index.js

@@ -1,9 +1,9 @@
-export { PaletteRegion, SidebarRegion, StatusRegion, TitleBarRegion, ToolbarRegion, ViewportRegion, builtinContributions, mergeContributions, suppressContributions } from '../chunk-W2FJR5FF.js';
-import '../chunk-UTOEDPNU.js';
-import '../chunk-XKENZTNE.js';
+export { PaletteRegion, SidebarRegion, StatusRegion, TitleBarRegion, ToolbarRegion, ViewportRegion, builtinContributions, mergeContributions, suppressContributions } from '../chunk-64ZCN3DA.js';
+import '../chunk-SMHP6XZ4.js';
+import '../chunk-U3IYHIAE.js';
+import '../chunk-E44SU6XS.js';
 import '../chunk-SBXNQW4G.js';
-import '../chunk-ISSVF5PT.js';
+import '../chunk-W3ECWC2K.js';
 import '../chunk-CQLQPQ4P.js';
-import '../chunk-54ZWZ5FQ.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map