@weasel-js/labkit 1.5.1 → 1.6.0

package/dist/_dts/index-DINmCuLA.d.ts

@@ -0,0 +1,453 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { S as StanceProps } from './PrefsRow.d-DFpPIeIC.js';
+import { ToolPrefNumberFormat, FillStyle, PaintKind } from '@weasel-js/core';
+import { U as UnitTable } from './number.d-OeQYQoUO.js';
+import { R as ResolvedConfig, b as ConfigField, C as ControlRenderer } from './types-B7y8hX1D.js';
+import './inDialog-D5ZKGjiD.js';
+
+/**
+ * How much room a container gives its rows — gaps, padding, and field height,
+ * moved together. Set on any container in the family; it reaches every
+ * descendant, so an inner group can differ from the panel around it.
+ */
+type PropertyDensity = 'tight' | 'normal' | 'roomy';
+/** Where an inline row's label and control sit on the row's cross axis. Set on
+ *  a container to line a whole column of them up. */
+type PropertyAlign = 'start' | 'center' | 'end' | 'baseline';
+/** Metric props every container in the family takes. Both reach descendants,
+ *  so the nearest container that states one wins. */
+interface PropertyMetricProps {
+    /** Room the rows get. Unset inherits from an outer container, else `normal`. */
+    density?: PropertyDensity;
+    /**
+     * Cross-axis alignment of an inline row's label and control. `baseline` sits
+     * the control on the label's first-line baseline, which is what lines a
+     * column of swatches up against labels of different heights. Unset keeps each
+     * variant's own alignment — a color row centers its label and swatch and
+     * sinks the pair to the row's bottom edge, which keeps a paired alpha track
+     * level with its neighbour.
+     */
+    align?: PropertyAlign;
+}
+/** Props for `<PropertyPanel>`. */
+interface PropertyPanelProps extends PropertyMetricProps, StanceProps {
+    title?: ReactNode;
+    /** Controls on the trailing edge of the title row — a switch, a clear
+     *  button. They sit outside the heading, so they neither take its type nor
+     *  join its accessible name. */
+    actions?: ReactNode;
+    /**
+     * Lets text inside the panel be selected and copied. A panel is chrome by
+     * default, so a drag across it moves a slider rather than painting a
+     * selection; a `debug` panel defaults to selectable, since what it shows —
+     * ids, keys, traces — is there to be copied.
+     */
+    selectable?: boolean;
+    children: ReactNode;
+    className?: string;
+}
+/**
+ * A titled panel holding property rows — the sidebar container the rest of
+ * this module's components fill.
+ *
+ * `stance` says what kind of content it holds and `tone` which of its peers it
+ * is; the theme's `--wzl-panel-*` and `--wzl-stance-*` slots decide how each looks. A stanced
+ * panel's title takes the row-label recipe rather than the display title.
+ */
+declare function PropertyPanel({ title, actions, selectable, children, className, density, align, stance, tone, }: PropertyPanelProps): react_jsx_runtime.JSX.Element;
+/** How a property list packs its rows into two columns. */
+type PropertyListPack = 'auto-color' | 'pairs' | 'one-up';
+/** Props for `<PropertyList>`. */
+interface PropertyListProps extends PropertyMetricProps {
+    children: ReactNode;
+    className?: string;
+    /**
+     * How rows pack into the 2-column grid.
+     *   - `'auto-color'` (default): only color rows pair side-by-side; everything
+     *     else spans the full width. Right for sparse top-level panels.
+     *   - `'pairs'`: every row auto-places into the 2-column grid two-per-row.
+     *     Headers and subpanels still span the full width; wrap any other
+     *     full-width child in `<PropertySpan>`. Right for dense effect bodies.
+     *   - `'one-up'`: every row spans the full width, color rows included. Right
+     *     for a palette — a column of swatches read as a group.
+     */
+    pack?: PropertyListPack;
+}
+/**
+ * Grid container for PropertyRows. Use standalone for chrome-less layouts, or
+ * nest inside <PropertyPanel/> for the standard glass card.
+ */
+declare const PropertyList: react.ForwardRefExoticComponent<PropertyListProps & react.RefAttributes<HTMLDivElement>>;
+/** Props for `<PropertySpan>`. */
+interface PropertySpanProps {
+    children: ReactNode;
+    className?: string;
+}
+/**
+ * Wrapper that makes an arbitrary child span both columns of a
+ * `<PropertyList pack="pairs">`, a `<PropertyGroup pack="pairs">` body, or a
+ * `<Subpanel>`. `<PropertyRow span>` covers the row case; this covers
+ * everything else a consumer puts in the grid.
+ */
+declare function PropertySpan({ children, className }: PropertySpanProps): react_jsx_runtime.JSX.Element;
+/** Which control shape a row holds, which decides its intrinsic layout. */
+type PropertyRowVariant = 'default' | 'color' | 'checkbox';
+/** Whether a row's label sits above its control or beside it. */
+type PropertyRowLayout = 'block' | 'inline';
+/** Props for `<PropertyRow>`. */
+interface PropertyRowProps extends PropertyMetricProps {
+    label: ReactNode;
+    /** Right-aligned readout shown next to the label (e.g. current value). */
+    readout?: ReactNode;
+    /**
+     * Help text for the row, shown in a tooltip off an ⓘ affordance beside the
+     * label. Empty or absent renders no affordance.
+     */
+    description?: string;
+    variant?: PropertyRowVariant;
+    /**
+     * Label position relative to the control. Unset takes the variant's own
+     * orientation: `block` — label above control — for the default variant, and
+     * `inline` for the color and checkbox variants, which read as a row.
+     */
+    layout?: PropertyRowLayout;
+    /**
+     * Take the full width of the enclosing grid. Only has an effect inside a
+     * `<PropertyList pack="pairs">` or a `<Subpanel>`; elsewhere rows are already
+     * full width.
+     */
+    span?: boolean;
+    children: ReactNode;
+    htmlFor?: string;
+    /** The control is a group of several (a segmented toggle), not one element.
+     *  The row then renders as a `<div>`: a `<label>` hands a click on its text to
+     *  its first control, which in a group means selecting the first option. Each
+     *  member has to carry its own name. */
+    group?: boolean;
+    className?: string;
+    /** The row is auto: its value is not pinned and the owner computes it. The
+     *  control is hidden — its box kept, so the row does not resize — and the
+     *  row reads out the word instead. */
+    auto?: boolean;
+    /** Given, the row's label toggles `auto` when it is clicked. Omitted, the row
+     *  can show an auto state but not change it.
+     *
+     *  The label then names that toggle, so a control passed as `children` has to
+     *  carry its own accessible name — every `<PropertyField>` does. */
+    onAutoChange?: (next: boolean) => void;
+    /**
+     * What draws the row's control. `bare` (the default) is a native input the
+     * row's stylesheet dresses; `framed` is a kit field bringing its own frame,
+     * which the row then leaves alone — see {@link PropertyFieldChrome}.
+     */
+    chrome?: PropertyFieldChrome;
+}
+/** The label-plus-control frame `<PropertyField>` draws its rows in. Use it
+ *  directly for a control no field kind covers. */
+declare function PropertyRow({ label, readout, description, variant, layout, span, children, htmlFor, group, className, density, align, auto, onAutoChange, chrome, }: PropertyRowProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Which controls a field is drawn with.
+ *
+ *   - `'bare'` (the default): native inputs the property row's own stylesheet
+ *     draws — the compact controls of an inspector sidebar or a lab panel.
+ *   - `'framed'`: the kit's field components, each bringing its own frame —
+ *     for a surface whose row does not style its controls (`SelectionPanel`,
+ *     `ToolOptionsBar`), or that needs what only they do, such as reading a
+ *     unit typed into a number (`accepts`).
+ *
+ * The two differ only where the kit still has two widgets for one job; a
+ * slider, a switch, a font picker and a paint are the same in both.
+ */
+type PropertyFieldChrome = 'bare' | 'framed';
+/** One choice of an enum field. */
+interface PropertyOption<T extends string> {
+    value: T;
+    /** The option's name. A string also names its segment for a screen reader. */
+    label: ReactNode;
+    /** What a segment shows in place of `label` when the full one would not fit
+     *  — a glyph or a letter. `label` stays the accessible name. */
+    glyph?: ReactNode;
+    /** Shown but not choosable: a value the control reports and cannot author. */
+    disabled?: boolean;
+}
+/** Props every kind of field shares. */
+interface FieldBase {
+    /** The control's accessible name. A `<PropertyField>` takes it from a string
+     *  `label` when this is omitted. */
+    name?: string;
+    /** The sources the field reads disagree — a multi-selection whose nodes
+     *  differ. The control shows no value, in whatever form it has for that. */
+    mixed?: boolean;
+    /**
+     * The sources agree on holding nothing: whatever is in effect comes from a
+     * fallback further down. The control shows no chosen value rather than
+     * inventing one, since the next edit would write the invention back.
+     */
+    unset?: boolean;
+    chrome?: PropertyFieldChrome;
+    /** Class on the control element itself. */
+    className?: string;
+    /** Id for the control element, for a `<label htmlFor>` outside it. */
+    id?: string;
+}
+/** A boolean field. */
+interface PropertyBooleanFieldProps extends FieldBase {
+    kind: 'boolean';
+    /** `checkbox` (default), `switch`, or `toggle` — a one-segment pressable bar. */
+    control?: 'checkbox' | 'switch' | 'toggle';
+    /** Absent reads as off. */
+    value: boolean | undefined;
+    onChange: (next: boolean) => void;
+    /** A `toggle`'s segment content. Defaults to the first letter of `name`. */
+    glyph?: ReactNode;
+}
+/** A number field. */
+interface PropertyNumberFieldProps extends FieldBase {
+    kind: 'number';
+    /** `input` (default) for a typed number; `slider` for a track with an
+     *  editable readout, where the range matters more than the exact value. */
+    control?: 'input' | 'slider';
+    /** Absent reads as an empty field. */
+    value: number | null | undefined;
+    /**
+     * The committed value. Given `onInput` as well, it fires once a drag ends,
+     * or on blur or Enter in a typed field; on its own it fires on every move
+     * and keystroke. A `framed` typed field commits only on blur or Enter,
+     * whichever callbacks it has.
+     */
+    onChange: (next: number) => void;
+    /** The live value, fired continuously. Pass it alongside `onChange` when the
+     *  write is expensive — cheap state here, the costly work there. */
+    onInput?: (next: number) => void;
+    /** A slider's track runs 0..100 where these are omitted. */
+    min?: number;
+    max?: number;
+    step?: number;
+    /**
+     * Suffix after the value. A string becomes a dim word unit (`px`); pass JSX
+     * like `<sup>°</sup>` for a symbol. Display only — the value stays a number.
+     */
+    unit?: ReactNode;
+    /** Units a person may type into a `framed` field, each mapped to the factor
+     *  that turns it into the unit shown: `{ mm: 0.1, cm: 1 }`. */
+    accepts?: Readonly<UnitTable>;
+    /** A slider readout's display. Defaults to the value at `step`'s precision. */
+    format?: (value: number) => ReactNode;
+    /** A named display for the value: `compact` reads `2.00M`. `format` wins. */
+    notation?: ToolPrefNumberFormat;
+    placeholder?: string;
+    /** A `framed` unitless field's stepper buttons. Default `true`. */
+    steppers?: boolean;
+}
+/** A text field. */
+interface PropertyStringFieldProps extends FieldBase {
+    kind: 'string';
+    control?: 'input' | 'textarea';
+    /** Absent reads as an empty field. */
+    value: string | null | undefined;
+    /**
+     * The committed text. On its own it fires on every keystroke. Given
+     * `onInput` as well, the field drafts: `onInput` gets each keystroke and
+     * this fires once, on blur or Enter, and only if the text changed.
+     */
+    onChange: (next: string) => void;
+    onInput?: (next: string) => void;
+    placeholder?: string;
+    maxLength?: number;
+}
+/** A choice among fixed options. */
+interface PropertyEnumFieldProps<T extends string = string> extends FieldBase {
+    kind: 'enum';
+    /**
+     * `select` (default) is a dropdown. `radio` and `toggle` show every option
+     * at once — a radio group chooses, and a toggle is a row of pressable
+     * segments. Drawn `bare`, both are segments.
+     */
+    control?: 'select' | 'radio' | 'toggle';
+    /** Absent, or not one of `options`, chooses nothing. */
+    value: T | undefined;
+    options: ReadonlyArray<PropertyOption<T>>;
+    onChange: (next: T) => void;
+    /** Shown while no option is chosen. Defaults to "Choose option…". */
+    placeholder?: string;
+}
+/** A single color. */
+interface PropertyColorFieldProps extends FieldBase {
+    kind: 'color';
+    /** `#rrggbb`, or `#rrggbbaa` when `alpha` is `true`. */
+    value: string | undefined;
+    /**
+     * The committed color. `bare`: given `onInput` as well, it fires once the
+     * picker closes; on its own it fires on every move. `framed`: it fires once
+     * per gesture, whichever callbacks it has.
+     */
+    onChange: (next: string) => void;
+    onInput?: (next: string) => void;
+    /**
+     * Offer an opacity track. `true` keeps the alpha in `value` as `#rrggbbaa`;
+     * a number is the 0..1 alpha held apart from it, reported through
+     * `onAlphaChange` / `onAlphaInput`.
+     */
+    alpha?: boolean | number;
+    onAlphaChange?: (next: number) => void;
+    onAlphaInput?: (next: number) => void;
+    /** Draw the opacity track inert, for a consumer that drops alpha. */
+    alphaDisabled?: boolean;
+}
+/** A whole paint: a solid, a gradient, a pattern, or none. */
+interface PropertyPaintFieldProps extends FieldBase {
+    kind: 'paint';
+    /** `swatch` (default) opens the editor in a popover, for a narrow slot;
+     *  `inline` draws the kind bar and its editor in place. */
+    control?: 'swatch' | 'inline';
+    /** `null` is an explicit "no paint"; `undefined` is nothing to show. */
+    value: FillStyle | null | undefined;
+    onChange: (next: FillStyle | null) => void;
+    onInput?: (next: FillStyle | null) => void;
+    /** Offer "None". Default `true`. */
+    allowNone?: boolean;
+    /** Restrict the kinds offered. Default: every registered kind. */
+    kinds?: readonly PaintKind[];
+}
+/** A font family, picked from the live font registry. */
+interface PropertyFontFamilyFieldProps extends FieldBase {
+    kind: 'font-family';
+    value: string | undefined;
+    onChange: (next: string) => void;
+    /** The weight and slant the family is drawn at, so the picker names the
+     *  variant that will actually paint. */
+    weight?: number;
+    fontStyle?: 'normal' | 'italic';
+}
+/**
+ * One field for {@link PropertyControl} and {@link PropertyField}, keyed by
+ * `kind`.
+ */
+type PropertyControlProps<T extends string = string> = PropertyBooleanFieldProps | PropertyNumberFieldProps | PropertyStringFieldProps | PropertyEnumFieldProps<T> | PropertyColorFieldProps | PropertyPaintFieldProps | PropertyFontFamilyFieldProps;
+/** Row props {@link PropertyField} adds to the field it draws. */
+interface PropertyFieldRowProps extends PropertyMetricProps {
+    label: ReactNode;
+    /**
+     * Text beside the label. On a slider it replaces the editable readout —
+     * use it when the row is not showing a number a caller could type back,
+     * such as an auto row's `auto`.
+     */
+    readout?: ReactNode;
+    description?: string;
+    layout?: PropertyRowLayout;
+    /** Take the full width of the enclosing grid — see `<PropertyRow span>`. */
+    span?: boolean;
+    /** The row is auto — see `<PropertyRow auto>`. */
+    auto?: boolean;
+    /** Toggles `auto` from the row's label — see `<PropertyRow onAutoChange>`. */
+    onAutoChange?: (next: boolean) => void;
+    /** Class on the row. `controlClassName` reaches the control. */
+    rowClassName?: string;
+    controlClassName?: string;
+}
+/** Props for {@link PropertyField}: one field, and the row around it. */
+type PropertyFieldProps<T extends string = string> = PropertyFieldRowProps & DistributiveOmit<PropertyControlProps<T>, 'className' | 'id'>;
+type DistributiveOmit<U, K extends PropertyKey> = U extends unknown ? Omit<U, K> : never;
+/**
+ * A labeled settings row for one field, its control chosen by `kind` (and
+ * `control`): `<PropertyField kind="number" control="slider" label="Blur" …>`.
+ *
+ * The row is a {@link PropertyRow}; the control is the one
+ * {@link PropertyControl} draws for the same props. Every schema-driven
+ * settings surface in the kit — `ControlPanel`, `PrefsForm`, `SelectionPanel`
+ * — draws its built-in kinds through that one mapping, so a kind's control
+ * is decided once.
+ *
+ * Callbacks follow the field's shape: a discrete control (a box, a choice)
+ * reports each pick; a continuous or typed one reports every change through
+ * `onChange` alone, or splits them into live `onInput` and settled
+ * `onChange` when given both. `mixed` and `unset` show a field whose sources
+ * disagree, or agree on holding nothing.
+ */
+declare function PropertyField<T extends string = string>(props: PropertyFieldProps<T>): react_jsx_runtime.JSX.Element;
+/**
+ * The control for one field, with no row around it — for a cell that shares
+ * a row with others, or a surface that draws its own row. Keyed by `kind`
+ * (and `control`), the same mapping {@link PropertyField} draws.
+ *
+ * A slider brings its readout beside the track. Several elements come back
+ * as siblings rather than wrapped, so the surrounding row lays them out.
+ */
+declare function PropertyControl<T extends string = string>(typed: PropertyControlProps<T>): react_jsx_runtime.JSX.Element;
+
+/** How a panel packs its rows into the two-column property grid.
+ *   - `'auto'`: narrow controls (numbers, checkboxes, dropdowns, colors) sit
+ *     two per row; the ones that need the width — text, sliders, segmented
+ *     toggles — span it.
+ *   - `'pairs'`: every row pairs. A control that needs the full width says so
+ *     itself, with `<PropertyRow span>`.
+ *   - `'one-up'`: one control per row, colors excepted.
+ */
+type ControlPack = 'auto' | 'pairs' | 'one-up';
+interface ControlPanelProps<TC extends Record<string, unknown>> extends StanceProps {
+    /** The instrument's resolved config schema. */
+    schema?: ResolvedConfig;
+    /** @deprecated Pass `schema`. A field list is adapted into one internally. */
+    fields?: ConfigField[];
+    config: TC;
+    /** 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
+     * the row; entries override the built-in rows on collision.
+     */
+    renderers?: Record<string, ControlRenderer>;
+    /** How rows pack into the two-column grid. Defaults to `'pairs'`. */
+    pack?: ControlPack;
+    /**
+     * Where a row's label sits relative to its control. Unset takes each row's
+     * own orientation — `block` (label above, which is what leaves a paired row
+     * room for its value) for most, `inline` for colors and checkboxes.
+     */
+    layout?: PropertyRowLayout;
+    /** Room the rows get. Passed straight to the property list. */
+    density?: PropertyDensity;
+    /** Cross-axis alignment of an inline row's label and control. */
+    align?: PropertyAlign;
+    /**
+     * Fold each section away behind a twisty, starting `'open'` or `'closed'`.
+     * 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 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>>;
+    /** 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;
+    /** Dotted paths currently unpinned. A row in this set hides its control and
+     *  reads out `auto`, and clicking its label writes the sentinel back through
+     *  `setConfig`. Omitted, the panel keeps the set itself: the labels still
+     *  toggle and the sentinel never reaches `setConfig`, which would otherwise
+     *  store it as the row's value. */
+    auto?: ReadonlySet<string>;
+    /** Draw leaves marked `hidden`. */
+    showHidden?: boolean;
+    /** Heads the panel. With `title`, `stance` or `tone` given, the rows sit in a
+     *  `<PropertyPanel>` carrying them; with none, they are the bare list. */
+    title?: ReactNode;
+    className?: string;
+}
+/** Render an instrument's config schema as a stack of controls, each writing
+ *  back through `setConfig`. Built on the property rows, so a lab's controls
+ *  are the same aligned, themed rows the rest of the kit uses. */
+declare function ControlPanel<TC extends Record<string, unknown>>({ schema, fields, config, setConfig, renderers, pack, layout, density, align, collapse, collapsed, onCollapse, auto: given, showHidden, title, stance, tone, className, }: ControlPanelProps<TC>): react_jsx_runtime.JSX.Element;
+
+export { ControlPanel as C, PropertyControl as b, PropertyField as d, PropertyList as f, PropertyPanel as i, PropertyRow as k, PropertySpan as o };
+export type { PropertyMetricProps as P, PropertyListPack as a, PropertyControlProps as c, PropertyFieldProps as e, PropertyListProps as g, PropertyOption as h, PropertyPanelProps as j, PropertyRowLayout as l, PropertyRowProps as m, PropertyRowVariant as n, PropertySpanProps as p };

package/dist/_dts/number.d-OeQYQoUO.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Display-formatter for numbers. Use this anywhere a number is shown to
+ * a user. The whole point: negative values get prefixed with the real
+ * MINUS SIGN (U+2212) instead of the ASCII HYPHEN-MINUS (U+002D) that
+ * `toLocaleString` and template literals produce by default.
+ *
+ * U+2212 is the same visual width as `+` and reads as a sign rather
+ * than a hyphen — columns of signed numbers align cleanly and the
+ * glyph doesn't get confused with a bullet or list dash.
+ */
+declare const MINUS_SIGN = "\u2212";
+/**
+ * Formats a number for display, substituting {@link MINUS_SIGN} for the ASCII
+ * hyphen `toLocaleString` emits. Non-finite values stringify as-is.
+ */
+declare function formatNumber(value: number, options?: Intl.NumberFormatOptions): string;
+/** One unit's conversion into the shown unit: a bare factor, or a scale that
+ *  also moves zero. Structurally the kit's `UnitEntry`, kept local so this
+ *  formatting helper stays free of the scene vocabulary. */
+type UnitTableEntry = number | {
+    factor: number;
+    offset?: number;
+};
+/** Suffixes a person may type, each mapped to its conversion. */
+type UnitTable = Record<string, UnitTableEntry>;
+
+export { MINUS_SIGN as M, formatNumber as f };
+export type { UnitTable as U };

package/dist/_dts/{types-DzoNY1pO.d.ts → types-B7y8hX1D.d.ts}

@@ -1,5 +1,5 @@
 import { ToolPrefNumberFormat, ToolPrefNumberUnit, ToolPrefLeaf, ToolPrefGroup } from '@weasel-js/core';
-import { P as PrefRenderer } from './PrefsForm.d-DPy9I8It.js';
+import { P as PrefRenderer } from './PrefsRow.d-DFpPIeIC.js';
 
 /**
  * Renders the control cell for one config leaf. Identical to weasel-ui's
@@ -111,15 +111,15 @@ interface NodeOptions extends BranchOptions {
     render?: ControlRenderer;
     /** Errors for this leaf under `config`, the instrument's whole config. */
     validate?: (leaf: ToolPrefLeaf, config: Record<string, unknown>) => string[];
-    /** Computes this leaf's value while it is auto. Attaching one is what lets
-     *  the ghosted control draw a real value and keeps the instrument off
+    /** Computes this leaf's value while it is auto. Attaching one is what gives
+     *  the row a real value to pin back to and keeps the instrument off
      *  `?? compute()`. */
     autoResolve?: (config: Record<string, unknown>) => unknown;
     /** The leaf starts auto rather than pinned at its default. Set by
      *  `.initial(auto)`. */
     unpinned?: boolean;
-    /** The leaf can never be auto: the row takes no pin dot and ignores the
-     *  gesture. For a value the instrument cannot receive as `undefined`. */
+    /** The leaf can never be auto: the row's label does not toggle. For a value
+     *  the instrument cannot receive as `undefined`. */
     manual?: boolean;
 }
 /** What a branch can say about itself, beyond its children. */
@@ -250,4 +250,4 @@ interface ColorField extends ConfigFieldBase {
  *  panel renders, and what `validateConfigSchema` checks. */
 type ConfigField = SliderField | CheckboxField | SelectField | NumberField | TextField | ColorField;
 
-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, TextField as T, ValueAtPath as V, ConfigField as a, ConfigSchema as b, ConfigRule as c, ControlRenderer as d, BranchOptions as e, CheckboxField as f, ColorField as g, ConfigBranch as h, ConfigEntry as i, ConfigFieldBase as j, ConfigFieldType as k, ConfigNode as l, ConfigOf as m, ConfigOption as n, ConfigRuleContext as o, ConfigShape as p, NodeValue as q, NumberField as r, SelectField as s, SelectOption as t, SliderField as u, SectionOption as v };
+export type { Annotations as A, BranchAnnotations as B, ControlRenderer as C, EntryValue as E, InferConfig as I, LeafPatch as L, NodeOptions as N, ResolvedConfig as R, SectionSpec as S, TextField as T, ValueAtPath as V, ConfigPath as a, ConfigField as b, ConfigSchema as c, ConfigRule as d, BranchOptions as e, CheckboxField as f, ColorField as g, ConfigBranch as h, ConfigEntry as i, ConfigFieldBase as j, ConfigFieldType as k, ConfigNode as l, ConfigOf as m, ConfigOption as n, ConfigRuleContext as o, ConfigShape as p, NodeValue as q, NumberField as r, SelectField as s, SelectOption as t, SliderField as u, SectionOption as v };

package/dist/_dts/{usePanZoom-Pzf9f2jh.d.ts → usePanZoom-Bq73pwFe.d.ts}

@@ -1,7 +1,7 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { ReactNode, WheelEvent, PointerEvent as PointerEvent$1 } from 'react';
-import { k as ViewTransform, a as WorldSpec, V as ViewportSize, l as Point, W as WorldFrame } from './frac-B4okC2lX.js';
-import { C as CanvasLayerDescriptor } from './CanvasStackContext-CJNMS6mz.js';
+import { m as ViewTransform, b as WorldSpec, V as ViewportSize, n as Point, W as WorldFrame } from './frac-DTRq7Xpb.js';
+import { C as CanvasLayerDescriptor } from './CanvasStackContext-DQgcH1ny.js';
 
 /** Props for `<CanvasStack>`. */
 interface CanvasStackProps {
@@ -88,49 +88,6 @@ declare function fitStage(size: ViewportSize, viewport: ViewportSize): ViewTrans
  */
 declare function Stage({ size, view: viewProp, onViewChange, minZoom, maxZoom, onResize, hostRef, overlay, children, }: StageProps): react_jsx_runtime.JSX.Element;
 
-/** A point in the space the instrument works in. */
-interface Vec3 {
-    x: number;
-    y: number;
-    z: number;
-}
-/** An orbit camera as a trial view: where it looks from, and what it looks at.
- *  labkit does not turn this into a matrix — the host's renderer does. */
-interface OrbitView {
-    yaw: number;
-    pitch: number;
-    distance: number;
-    target: Vec3;
-}
-/** Just short of the pole. At exactly ±PI/2 the azimuth is undefined and the
- *  camera rolls, which reads as the model jumping rather than as a limit. */
-declare const PITCH_LIMIT: number;
-declare function clampPitch(pitch: number): number;
-declare function wrapYaw(yaw: number): number;
-/** The view a drag of (dx, dy) from `start` produces. Absolute against the drag
- *  start, so it can be re-applied any number of times without compounding. */
-declare function orbitAfterDrag(start: OrbitView, dx: number, dy: number): OrbitView;
-/** Multiplicative, so one notch covers the same proportion of the distance
- *  whether the camera is near or far. */
-declare function orbitAfterWheel(view: OrbitView, deltaY: number, minDistance: number, maxDistance: number): OrbitView;
-interface UseOrbitOptions {
-    view: OrbitView;
-    onViewChange: (v: OrbitView) => void;
-    /** Restored on double-click. Defaults to the view the hook first saw. */
-    home?: OrbitView;
-    minDistance?: number;
-    maxDistance?: number;
-}
-interface OrbitHandlers {
-    onWheel: (e: WheelEvent<HTMLElement>) => void;
-    onPointerDown: (e: PointerEvent$1<HTMLElement>) => void;
-    onDoubleClick: () => void;
-    isDragging: () => boolean;
-}
-/** Pointer gestures over an orbit view: drag to turn, wheel or pinch to dolly,
- *  double-click to go home. The 3D peer of `usePanZoom`. */
-declare function useOrbit({ view, onViewChange, home, minDistance, maxDistance, }: UseOrbitOptions): OrbitHandlers;
-
 interface UsePanZoomOptions {
     view: ViewTransform;
     onViewChange: (v: ViewTransform) => void;
@@ -156,5 +113,5 @@ interface PanZoomHandlers {
 }
 declare function usePanZoom({ view, onViewChange, minZoom, maxZoom, frame, onTap, }: UsePanZoomOptions): PanZoomHandlers;
 
-export { CanvasStack as C, PITCH_LIMIT as P, Stage as S, centerOn as f, clampPitch as g, fitStage as h, orbitAfterWheel as i, usePanZoom as j, wrapYaw as k, orbitAfterDrag as o, screenToWorld as s, useOrbit as u, worldToScreen as w, zoomAt as z };
-export type { OrbitHandlers as O, UseOrbitOptions as U, Vec3 as V, ZoomAtOptions as Z, CanvasStackProps as a, OrbitView as b, PanZoomHandlers as c, StageProps as d, UsePanZoomOptions as e };
+export { CanvasStack as C, Stage as S, centerOn as c, fitStage as f, screenToWorld as s, usePanZoom as u, worldToScreen as w, zoomAt as z };
+export type { PanZoomHandlers as P, UsePanZoomOptions as U, ZoomAtOptions as Z, CanvasStackProps as a, StageProps as b };

package/dist/_dts/{useTrialState-uLlmaccn.d.ts → useTrialState-CP4jfuKl.d.ts}

@@ -1,4 +1,4 @@
-import { c as StorageAdapter, d as LabStoreState, T as TrialRecord, e as SavedSnapshot, o as LabMode, h as UndockedPanel, q as InstrumentList, s as InstrumentHooks, C as CreateLabStoreOptions, g as TrialStateHandle } from './frac-B4okC2lX.js';
+import { d as StorageAdapter, f as LabStoreState, T as TrialRecord, g as SavedSnapshot, s as LabMode, j as UndockedPanel, t as InstrumentList, v as InstrumentHooks, C as CreateLabStoreOptions, i as TrialStateHandle } from './frac-DTRq7Xpb.js';
 import * as react from 'react';
 import { ReactNode, ReactElement, Dispatch, SetStateAction } from 'react';
 import { StoreApi } from 'zustand/vanilla';

package/dist/canvas/index.d.ts

@@ -1,11 +1,12 @@
 import * as react from 'react';
-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';
-export { D as DEFAULT_FRAME, V as ViewportSize, W as WorldFrame, a as WorldSpec, b as applyCamera, r as resolveFrame } from '../_dts/frac-B4okC2lX.js';
+export { C as CanvasStack, a as CanvasStackProps, P as PanZoomHandlers, S as Stage, b as StageProps, U as UsePanZoomOptions, Z as ZoomAtOptions, c as centerOn, f as fitStage, s as screenToWorld, u as usePanZoom, w as worldToScreen, z as zoomAt } from '../_dts/usePanZoom-Bq73pwFe.js';
+export { C as CanvasLayerDescriptor, a as CanvasStackContext, b as CanvasStackContextValue, c as CanvasStackSurface } from '../_dts/CanvasStackContext-DQgcH1ny.js';
+export { D as DEFAULT_FRAME, V as ViewportSize, W as WorldFrame, b as WorldSpec, c as applyCamera, r as resolveFrame } from '../_dts/frac-DTRq7Xpb.js';
 import 'react/jsx-runtime';
-import '../_dts/types-DzoNY1pO.js';
+import '../_dts/PrefsRow.d-DFpPIeIC.js';
+import '@weasel-js/theme';
 import '@weasel-js/core';
-import '../_dts/PrefsForm.d-DPy9I8It.js';
+import '../_dts/types-B7y8hX1D.js';
 import '../_dts/types-DJ79Tg5J.js';
 
 /** Where a trial's camera takes a wheel event from outside its own element. */

package/dist/canvas/index.js

@@ -1,4 +1,4 @@
-export { CameraWheelContext, CanvasStack, PITCH_LIMIT, Stage, clampPitch, fitStage, orbitAfterDrag, orbitAfterWheel, useOrbit, usePanZoom, wrapYaw } from '../chunk-CEIUBPPW.js';
+export { CameraWheelContext, CanvasStack, Stage, fitStage, usePanZoom } from '../chunk-TT5C5S6R.js';
 export { centerOn, zoomAt } from '../chunk-H6ZAOWNE.js';
 export { DEFAULT_FRAME, applyCamera, resolveFrame, screenToWorld, worldToScreen } from '../chunk-2AYGEN57.js';
 import '../chunk-WIG6XHJ7.js';

package/dist/chrome/index.d.ts

@@ -1,8 +1,9 @@
-export { a as LabAsideRegion, b as LabChromeContext, L as LabContribution, 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, t as builtinContributions, w as contributionsIn, x as labContributions, y as mergeContributions, C as suppressContributions, D as toolContributions, E as useLabChromeContext } from '../_dts/index-CSJoj4LC.js';
-export { a3 as ContributionBase, a7 as IconComponent, ae as RegionContribution, ai as SidebarSection, aj as SidebarSlotContext, al as StatusReadout, ao as ToolItem, ap as ToolSlotContext, aq as ToolbarItem, ar as TrialChromeContext, N as TrialContribution, as as TrialRegion, au as ViewportControl } from '../_dts/frac-B4okC2lX.js';
-import '../_dts/types-DzoNY1pO.js';
+export { a as LabAsideRegion, b as LabChromeContext, L as LabContribution, 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, t as builtinContributions, w as contributionsIn, x as labContributions, y as mergeContributions, C as suppressContributions, D as toolContributions, E as useLabChromeContext } from '../_dts/index-B0--8PEM.js';
+export { a6 as ContributionBase, aa as IconComponent, af as RegionContribution, aj as SidebarSection, ak as SidebarSlotContext, am as StatusReadout, ap as ToolItem, aq as ToolSlotContext, ar as ToolbarItem, as as TrialChromeContext, R as TrialContribution, at as TrialRegion, av as ViewportControl } from '../_dts/frac-DTRq7Xpb.js';
+import '../_dts/types-B7y8hX1D.js';
 import '@weasel-js/core';
-import '../_dts/PrefsForm.d-DPy9I8It.js';
+import '../_dts/PrefsRow.d-DFpPIeIC.js';
+import '@weasel-js/theme';
 import 'react';
 import 'react/jsx-runtime';
 import '../_dts/types-DJ79Tg5J.js';