@weasel-js/labkit 1.5.1 → 1.6.0

package/src/trial/Trial.config.test.tsx

@@ -218,7 +218,7 @@ describe('a config written as auto', () => {
     const { container } = render(<Lab instruments={[instrument]} defaultInstrument="Ghosted" />);
     expect(screen.getByRole('button', { name: /Gap/ })).toHaveAttribute('aria-pressed', 'false');
     expect(screen.getByRole('button', { name: /Width/ })).toHaveAttribute('aria-pressed', 'true');
-    // 432 / 24. A ghosted control draws what the resolver decided rather than
+    // 432 / 24. An auto row holds what the resolver decided rather than
     // the pinned 12 underneath it, and un-pinning writes back what it drew.
     expect((container.querySelector('input[type=range]') as HTMLInputElement).value).toBe('18');
   });

package/src/trial/Trial.tsx

@@ -24,9 +24,9 @@ import type {
 } from '../instrument/types';
 import { useJob } from '../job/useJob';
 import { useLabContext } from '../lab/LabContext';
-import { LayerList } from '../layers/LayerList';
 import { TrialLoupe } from '../loupe/TrialLoupe';
 import { resolveLoupe } from '../loupe/types';
+import { LayerList, type LayerListItem, moveLayers } from '../passthrough/weasel-ui';
 import { LabStoreContext, TrialIdProvider } from '../state/context';
 import type { LabStore } from '../state/store';
 import type { TrialRecord } from '../state/types';
@@ -401,6 +401,24 @@ function TrialRuntime({
     return instrument.layers.ids.map((l) => (typeof l === 'string' ? { id: l, label: l } : l));
   }, [instrument.layers]);
 
+  // In the order the canvas draws them, with the always-on layers pinned
+  // below the rest, where a drag cannot reach past them.
+  const layerItems: LayerListItem[] = useMemo(() => {
+    const ordered = layerOrder
+      ? [...layerDescriptors].sort((a, b) => layerOrder.indexOf(a.id) - layerOrder.indexOf(b.id))
+      : layerDescriptors;
+    const pinnedLast = [
+      ...ordered.filter((l) => !l.alwaysOn),
+      ...ordered.filter((l) => l.alwaysOn),
+    ];
+    return pinnedLast.map((l) => ({
+      id: l.id,
+      label: l.label,
+      locked: l.alwaysOn === true,
+      visible: l.alwaysOn === true || layerVisibility[l.id] !== false,
+    }));
+  }, [layerDescriptors, layerOrder, layerVisibility]);
+
   const dragDropResult = useDragDrop({
     capability: instrument.dragDrop ?? { palette: [], onDrop: (_p, _i, s) => s },
     canvasContainerRef,
@@ -492,7 +510,12 @@ function TrialRuntime({
         minZoom={stage.minZoom}
         maxZoom={stage.maxZoom}
         hostRef={loupeHostRef}
-        overlay={lens}
+        overlay={
+          <>
+            {stage.overlay?.(renderCtx)}
+            {lens}
+          </>
+        }
       >
         {instrument.render(renderCtx)}
       </Stage>
@@ -519,19 +542,18 @@ function TrialRuntime({
     () =>
       instrument.layers && layerDescriptors.length > 0 ? (
         <LayerList
-          layers={layerDescriptors}
-          visibility={layerVisibility}
-          onReorder={(next) => {
-            setLayerOrder(next.map((l) => l.id));
+          items={layerItems}
+          onReorder={(move) => {
+            setLayerOrder(moveLayers(layerItems, move).map((l) => l.id));
             bus.emit('layers.reorder');
           }}
-          onToggle={(lid, visible) => {
+          onVisibilityChange={(lid, visible) => {
             setLayerVisibility((prev) => ({ ...prev, [lid]: visible }));
             bus.emit('layers.toggle');
           }}
         />
       ) : null,
-    [instrument.layers, layerDescriptors, layerVisibility, bus],
+    [instrument.layers, layerDescriptors, layerItems, bus],
   );
 
   const extraChrome = useMemo<TrialContribution[]>(() => {

package/dist/_dts/index-BNdz-tNd.d.ts

@@ -1,423 +0,0 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import { ReactNode } from 'react';
-import { ToolPrefNumberFormat } from '@weasel-js/core';
-import { R as ResolvedConfig, a as ConfigField, d as ControlRenderer } from './types-DzoNY1pO.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 {
-    title?: ReactNode;
-    children: ReactNode;
-    className?: string;
-}
-/** A titled panel holding property rows — the sidebar container the rest of
- *  this module's components fill. */
-declare function PropertyPanel({ title, children, className, density, align, }: 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 function PropertyList({ children, className, pack, density, align, }: PropertyListProps): react_jsx_runtime.JSX.Element;
-/** 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. Draws
-     *  the control ghosted and colorless. */
-    auto?: boolean;
-    /** Given, the row carries a pin dot that toggles `auto`. Omitted, the row can
-     *  show an auto state but not change it. */
-    onAutoChange?: (next: boolean) => void;
-    /** Marks the row's element for a panel-level gesture handler. `PropertyRow`
-     *  does not spread unknown props, so this is declared rather than inherited. */
-    'data-auto-path'?: string;
-}
-/** The label-plus-control frame every typed row below is built from. Use it
- *  directly for a control this module does not cover. */
-declare function PropertyRow({ label, readout, description, variant, layout, span, children, htmlFor, group, className, density, align, auto, onAutoChange, 'data-auto-path': autoPath, }: PropertyRowProps): react_jsx_runtime.JSX.Element;
-/** Props for `<SliderRow>`. */
-interface SliderRowProps extends PropertyMetricProps {
-    label: ReactNode;
-    value: number;
-    min: number;
-    max: number;
-    step?: number;
-    /**
-     * The committed value. Given `onInput` as well, it fires once a drag ends
-     * or a typed readout is accepted; on its own it fires on every move, which
-     * is what a row with one callback has always done.
-     */
-    onChange: (next: number) => void;
-    /**
-     * The live value, fired continuously through a drag. 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;
-    /** Override how the value is rendered next to the label. Defaults to `value.toString()`. */
-    format?: (value: number) => ReactNode;
-    /**
-     * Static text in place of the editable readout. Use it when the row is not
-     * showing a number a caller could type back — an auto row's `auto · 18`, say,
-     * which an editable field would seed a draft with and then fail to parse.
-     */
-    readout?: ReactNode;
-    /** A named display for the value: `compact` reads `2.0M`. `format` wins when both are given. */
-    notation?: ToolPrefNumberFormat;
-    /**
-     * Optional suffix rendered next to the readout. A string becomes a
-     * baseline-aligned dim "word" unit (e.g. "px"); pass JSX like `<sup>°</sup>`
-     * to get the browser's native super positioning for symbol units.
-     */
-    unit?: ReactNode;
-    layout?: PropertyRowLayout;
-    description?: string;
-    /** 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 a pin dot — see `<PropertyRow onAutoChange>`. */
-    onAutoChange?: (next: boolean) => void;
-    /** Marks the row for a panel-level gesture handler — see `<PropertyRow data-auto-path>`. */
-    'data-auto-path'?: string;
-}
-/** A bounded number edited by dragging, with a live readout whose precision
- *  follows `step`. */
-declare function SliderRow({ label, value, min, max, step, onChange, onInput, format, readout, notation, unit, layout, description, span, density, align, auto, onAutoChange, 'data-auto-path': autoPath, }: SliderRowProps): react_jsx_runtime.JSX.Element;
-/** Props for `<ColorRow>`. */
-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.
-     */
-    alphaDisabled?: boolean;
-    /** Label beside the swatch (default) or above it. */
-    layout?: PropertyRowLayout;
-    description?: string;
-    /** Right-aligned readout shown next to the label — see `<PropertyRow readout>`. */
-    readout?: ReactNode;
-    /** 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 a pin dot — see `<PropertyRow onAutoChange>`. */
-    onAutoChange?: (next: boolean) => void;
-    /** Marks the row for a panel-level gesture handler — see `<PropertyRow data-auto-path>`. */
-    'data-auto-path'?: string;
-}
-/** A color swatch, optionally with an alpha slider beneath it. */
-declare function ColorRow({ label, readout, value, onChange, onInput, alpha, onAlphaChange, onAlphaInput, alphaDisabled, layout, description, span, density, align, auto, onAutoChange, 'data-auto-path': autoPath, }: ColorRowProps): react_jsx_runtime.JSX.Element;
-/** Props for `<CheckboxRow>`. */
-interface CheckboxRowProps extends PropertyMetricProps {
-    label: ReactNode;
-    /** Absent reads as unchecked. */
-    value: boolean | undefined;
-    onChange: (next: boolean) => void;
-    /** Label beside the box (default) or above it. */
-    layout?: PropertyRowLayout;
-    description?: string;
-    /** Right-aligned readout shown next to the label — see `<PropertyRow readout>`. */
-    readout?: ReactNode;
-    /** 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 a pin dot — see `<PropertyRow onAutoChange>`. */
-    onAutoChange?: (next: boolean) => void;
-    /** Marks the row for a panel-level gesture handler — see `<PropertyRow data-auto-path>`. */
-    'data-auto-path'?: string;
-}
-/** A boolean checkbox. */
-declare function CheckboxRow({ label, readout, value, onChange, layout, span, description, density, align, auto, onAutoChange, 'data-auto-path': autoPath, }: CheckboxRowProps): react_jsx_runtime.JSX.Element;
-/** Props for `<TextRow>`. */
-interface TextRowProps extends PropertyMetricProps {
-    label: ReactNode;
-    /** Absent reads as an empty field. */
-    value: string | null | undefined;
-    onChange: (next: string) => void;
-    placeholder?: string;
-    maxLength?: number;
-    layout?: PropertyRowLayout;
-    description?: string;
-    /** Right-aligned readout shown next to the label — see `<PropertyRow readout>`. */
-    readout?: ReactNode;
-    /** 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 a pin dot — see `<PropertyRow onAutoChange>`. */
-    onAutoChange?: (next: boolean) => void;
-    /** Marks the row for a panel-level gesture handler — see `<PropertyRow data-auto-path>`. */
-    'data-auto-path'?: string;
-}
-/** A single-line text input. */
-declare function TextRow({ label, readout, value, onChange, placeholder, maxLength, layout, description, span, density, align, auto, onAutoChange, 'data-auto-path': autoPath, }: TextRowProps): react_jsx_runtime.JSX.Element;
-/** Props for `<NumberRow>`. */
-interface NumberRowProps extends PropertyMetricProps {
-    label: ReactNode;
-    /** Absent reads as an empty field. */
-    value: number | null | undefined;
-    /**
-     * 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;
-    placeholder?: string;
-    /**
-     * Optional suffix rendered after the field. A string becomes a dim "word"
-     * unit (e.g. "px"); pass JSX like `<sup>°</sup>` for symbol units. Display
-     * only — it never participates in parsing, and the value stays a number.
-     */
-    unit?: ReactNode;
-    layout?: PropertyRowLayout;
-    description?: string;
-    /** Right-aligned readout shown next to the label — see `<PropertyRow readout>`. */
-    readout?: ReactNode;
-    /** 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 a pin dot — see `<PropertyRow onAutoChange>`. */
-    onAutoChange?: (next: boolean) => void;
-    /** Marks the row for a panel-level gesture handler — see `<PropertyRow data-auto-path>`. */
-    'data-auto-path'?: string;
-}
-/** A number typed directly. Reach for `<SliderRow>` when the range matters
- *  more than the exact value. */
-declare function NumberRow({ label, readout, value, onChange, onInput, min, max, step, placeholder, unit, layout, description, span, density, align, auto, onAutoChange, 'data-auto-path': autoPath, }: NumberRowProps): react_jsx_runtime.JSX.Element;
-interface PropertyOption<T extends string> {
-    value: T;
-    label: ReactNode;
-}
-/** Props for `<SelectRow>`. */
-interface SelectRowProps<T extends string> extends PropertyMetricProps {
-    label: ReactNode;
-    /** Absent, or not one of `options`, shows a placeholder rather than the first option. */
-    value: T | undefined;
-    options: ReadonlyArray<PropertyOption<T>>;
-    onChange: (next: T) => void;
-    /** Shown while no option is chosen. Defaults to "Choose option…". */
-    placeholder?: string;
-    layout?: PropertyRowLayout;
-    description?: string;
-    /** Right-aligned readout shown next to the label — see `<PropertyRow readout>`. */
-    readout?: ReactNode;
-    /** 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 a pin dot — see `<PropertyRow onAutoChange>`. */
-    onAutoChange?: (next: boolean) => void;
-    /** Marks the row for a panel-level gesture handler — see `<PropertyRow data-auto-path>`. */
-    'data-auto-path'?: string;
-}
-/** A dropdown over a fixed set of choices. Prefer `<ToggleRow>` when there
- *  are only two or three and they should all stay visible. */
-declare function SelectRow<T extends string>({ label, readout, value, options, onChange, placeholder, layout, description, span, density, align, auto, onAutoChange, 'data-auto-path': autoPath, }: SelectRowProps<T>): react_jsx_runtime.JSX.Element;
-/** Props for `<ToggleRow>`. */
-interface ToggleRowProps<T extends string> extends PropertyMetricProps {
-    label: ReactNode;
-    value: T;
-    options: ReadonlyArray<PropertyOption<T>>;
-    onChange: (next: T) => void;
-    layout?: PropertyRowLayout;
-    description?: string;
-    /** Right-aligned readout shown next to the label — see `<PropertyRow readout>`. */
-    readout?: ReactNode;
-    /** 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 a pin dot — see `<PropertyRow onAutoChange>`. */
-    onAutoChange?: (next: boolean) => void;
-    /** Marks the row for a panel-level gesture handler — see `<PropertyRow data-auto-path>`. */
-    'data-auto-path'?: string;
-}
-/** A segmented control: the same choice as a select, with every option
- *  visible at once. */
-declare function ToggleRow<T extends string>({ label, readout, value, options, onChange, layout, description, span, density, align, auto, onAutoChange, 'data-auto-path': autoPath, }: ToggleRowProps<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>> {
-    /** 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 draws ghosted and its
-     *  dot reads as auto, and the dot writes the sentinel back through
-     *  `setConfig`. Omitted, the panel keeps the set itself: the dots still work
-     *  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;
-    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, className, }: ControlPanelProps<TC>): react_jsx_runtime.JSX.Element;
-
-export { CheckboxRow as C, NumberRow as N, SelectRow as S, TextRow as T, ColorRow as c, ControlPanel as e, PropertyList as g, PropertyPanel as j, PropertyRow as l, PropertySpan as p, SliderRow as s, ToggleRow as v };
-export type { PropertyMetricProps as P, PropertyListPack as a, CheckboxRowProps as b, ColorRowProps as d, NumberRowProps as f, PropertyListProps as h, PropertyOption as i, PropertyPanelProps as k, PropertyRowLayout as m, PropertyRowProps as n, PropertyRowVariant as o, PropertySpanProps as q, SelectRowProps as r, SliderRowProps as t, TextRowProps as u, ToggleRowProps as w };

package/dist/chunk-7PFH3CNM.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/config/auto.ts","../src/config/path.ts","../src/config/autoConfig.ts"],"names":["n"],"mappings":"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","file":"chunk-7PFH3CNM.js","sourcesContent":["/**\n * Written at a config path to mean \"do not pin this — let the instrument\n * decide\". Accepted by `setConfig`, by a trial's `configSeed`, and by\n * `.initial()` in a schema. It is normalized into the trial's set of unpinned\n * paths on the way into the store and is never itself stored, so a serialized\n * trial contains no sentinel and the last pinned value survives.\n */\nexport const auto: unique symbol = Symbol('weasel.auto');\n\n/** The type of the `auto` sentinel, for widening a value parameter. */\nexport type Auto = typeof auto;\n\nexport function isAuto(value: unknown): value is Auto {\n  return value === auto;\n}\n","import type { PrefGroup, PrefLeaf } from '@weasel-js/ui';\n\n/**\n * Reading and writing a config tree by dotted path. A schema's leaves address\n * their values this way, so a leaf nested under `f.group` and a flat one are\n * reached by exactly the same call.\n */\n\n/** A plain object a config tree can be walked into. An array, a `Date`, a\n *  `Map` or a class instance is a leaf value: a walk that descended into one\n *  would rebuild it as a bare `{}`. */\nexport function isRecord(value: unknown): value is Record<string, unknown> {\n  if (typeof value !== 'object' || value === null) return false;\n  const proto = Object.getPrototypeOf(value);\n  return proto === Object.prototype || proto === null;\n}\n\n/** The value at a dotted path. `undefined` when a segment is missing or the\n *  walk hits something that is not a record. */\nexport function valueAtPath(config: unknown, path: string): unknown {\n  let cur = config;\n  for (const segment of path.split('.')) {\n    if (!isRecord(cur)) return undefined;\n    cur = cur[segment];\n  }\n  return cur;\n}\n\n/** Whether a dotted path is actually present, which a `undefined` value is\n *  not enough to tell you. */\nexport function hasConfigPath(config: unknown, path: string): boolean {\n  let cur = config;\n  for (const segment of path.split('.')) {\n    if (!isRecord(cur) || !(segment in cur)) return false;\n    cur = cur[segment];\n  }\n  return true;\n}\n\nfunction writeIn(node: unknown, segments: readonly string[], value: unknown): unknown {\n  const [head, ...rest] = segments;\n  if (head === undefined) return value;\n  const base = isRecord(node) ? node : {};\n  return { ...base, [head]: rest.length === 0 ? value : writeIn(base[head], rest, value) };\n}\n\n/** A copy of `config` with `value` written at a dotted path. Every record on\n *  the way down is copied and the input is left alone; a missing — or\n *  non-record — intermediate is replaced with the branch the path implies. */\nexport function withValueAtPath<T>(config: T, path: string, value: unknown): T {\n  return writeIn(config, path.split('.'), value) as T;\n}\n\n/**\n * `stored` with every gap filled from `defaults`, down the whole tree.\n *\n * This is how a config written before its schema grew a branch still loads:\n * the branch arrives at its defaults instead of `undefined`, and a key the\n * defaults no longer mention is kept rather than dropped, so nothing is lost\n * to a schema change the author has not finished making.\n */\nexport function fillConfigDefaults<T>(stored: unknown, defaults: T): T {\n  if (!isRecord(defaults)) return (stored === undefined ? defaults : stored) as T;\n  const base = isRecord(stored) ? stored : {};\n  const out: Record<string, unknown> = { ...base };\n  for (const [key, value] of Object.entries(defaults)) {\n    out[key] = fillConfigDefaults(base[key], value);\n  }\n  return out as T;\n}\n\n/** A node in a resolved schema tree, by dotted path. Structural rather than\n *  `isPrefLeaf` so this stays free of a runtime import. */\nexport function schemaNodeAtPath(group: PrefGroup, path: string): PrefLeaf | PrefGroup | undefined {\n  let node: PrefLeaf | PrefGroup | undefined = group;\n  for (const segment of path.split('.')) {\n    if (node === undefined || !('children' in node)) return undefined;\n    node = node.children[segment];\n  }\n  return node;\n}\n","import { isPrefLeaf, type PrefGroup, type PrefLeaf } from '@weasel-js/ui';\nimport { isAuto } from './auto';\nimport { isRecord, withValueAtPath } from './path';\nimport type { ResolvedConfig } from './types';\n\ntype Resolver = (config: Record<string, unknown>) => unknown;\n\n/** Reads a labkit-only extra off a resolved leaf. `PrefLeaf` has no field for\n *  these; they ride as extra keys and survive the resolve walk. */\nfunction extra<T>(leaf: PrefLeaf, key: string): T | undefined {\n  return (leaf as unknown as Record<string, T | undefined>)[key];\n}\n\n/** Every leaf in a resolved schema, in schema order, with its dotted path. */\nfunction* leaves(group: PrefGroup, at = ''): Generator<[string, PrefLeaf]> {\n  for (const [key, child] of Object.entries(group.children)) {\n    const path = at === '' ? key : `${at}.${key}`;\n    if (isPrefLeaf(child)) yield [path, child];\n    else yield* leaves(child, path);\n  }\n}\n\n/** The dotted paths a schema declares as starting auto — every leaf that said\n *  `.initial(auto)`. This is what seeds a new trial's unpinned set. */\nexport function autoPathsOf(resolved: ResolvedConfig): string[] {\n  const out: string[] = [];\n  for (const [path, leaf] of leaves(resolved.group)) {\n    if (extra<boolean>(leaf, 'unpinned')) out.push(path);\n  }\n  return out;\n}\n\n/**\n * The config an instrument reads: the stored one, with every unpinned path\n * either computed by its resolver or removed.\n *\n * Resolution is demand-driven — a resolver reading another unpinned path\n * forces that one first, whatever order the schema declared them in — so a\n * cycle is a real cycle and not an ordering accident.\n */\nexport function resolveAutoConfig<TC>(\n  resolved: ResolvedConfig,\n  config: TC,\n  autoPaths: ReadonlySet<string>,\n): TC {\n  if (autoPaths.size === 0) return config;\n\n  const resolvers = new Map<string, Resolver | undefined>();\n  for (const [path, leaf] of leaves(resolved.group)) {\n    if (autoPaths.has(path)) resolvers.set(path, extra<Resolver>(leaf, 'autoResolve'));\n  }\n  if (resolvers.size === 0) return config;\n\n  // Drop first, so a resolver reading a still-unresolved auto path sees\n  // `undefined` rather than a stale pinned value it would silently believe.\n  let out = config as unknown as Record<string, unknown>;\n  for (const path of resolvers.keys()) out = dropAtPath(out, path);\n\n  const inFlight = new Set<string>();\n  const done = new Set<string>();\n\n  const need = (path: string): void => {\n    if (done.has(path)) return;\n    if (inFlight.has(path)) {\n      throw new Error(`[labkit] auto resolver cycle at \"${path}\"`);\n    }\n    const resolve = resolvers.get(path);\n    if (!resolve) {\n      done.add(path);\n      return;\n    }\n    inFlight.add(path);\n    try {\n      // Read `out` only after the resolver has run: it forces its own\n      // dependencies, and each of those replaced `out`.\n      const value = resolve(demand(() => out, resolvers, need));\n      out = withValueAtPath(out, path, value);\n    } finally {\n      inFlight.delete(path);\n    }\n    done.add(path);\n  };\n\n  for (const path of resolvers.keys()) need(path);\n  return out as unknown as TC;\n}\n\n/**\n * The config a resolver reads. A top-level key that is itself unpinned is\n * forced before it is handed back, which is what makes declaration order\n * irrelevant and turns a genuine loop into a named error.\n *\n * Only top-level keys are trapped: a resolver reaching `c.grid.size` gets the\n * already-dropped branch, and a nested auto path it depends on resolves by\n * schema order alone.\n */\nfunction demand(\n  read: () => Record<string, unknown>,\n  resolvers: ReadonlyMap<string, Resolver | undefined>,\n  need: (path: string) => void,\n): Record<string, unknown> {\n  return new Proxy(read(), {\n    get(_target, key) {\n      if (typeof key === 'string' && resolvers.has(key)) need(key);\n      return Reflect.get(read(), key);\n    },\n    has(_target, key) {\n      return Reflect.has(read(), key);\n    },\n    ownKeys() {\n      return Reflect.ownKeys(read());\n    },\n    getOwnPropertyDescriptor(_target, key) {\n      return Reflect.getOwnPropertyDescriptor(read(), key);\n    },\n  });\n}\n\n/** A copy of `config` with the dotted path removed, copying every record on\n *  the way down. A path that is not there comes back unchanged. */\nfunction dropAtPath(config: Record<string, unknown>, path: string): Record<string, unknown> {\n  const [head, ...rest] = path.split('.');\n  if (head === undefined || !(head in config)) return config;\n  if (rest.length === 0) {\n    const { [head]: _dropped, ...kept } = config;\n    return kept;\n  }\n  const child = config[head];\n  if (!isRecord(child)) return config;\n  return { ...config, [head]: dropAtPath(child, rest.join('.')) };\n}\n\n/**\n * What writing `value` at `path` makes of a trial's raw config and its set of\n * unpinned paths. `auto` pins nothing and joins the set; any other value is\n * written and leaves it. Both the store and the chrome go through this, so\n * they cannot disagree about what a write meant.\n */\nexport function applyConfigWrite<TC>(\n  config: TC,\n  autoPaths: readonly string[],\n  path: string,\n  value: unknown,\n): { config: TC; autoPaths: readonly string[] } {\n  if (isAuto(value)) {\n    if (autoPaths.includes(path)) return { config, autoPaths };\n    return { config, autoPaths: [...autoPaths, path] };\n  }\n  return {\n    config: withValueAtPath(config, path, value),\n    autoPaths: autoPaths.includes(path) ? autoPaths.filter((p) => p !== path) : autoPaths,\n  };\n}\n"]}