@weasel-js/labkit 1.4.4 → 1.5.1

package/src/trial/trialOps.test.ts

@@ -1,7 +1,10 @@
 import { describe, expect, it } from 'vitest';
+import { auto } from '../config/auto';
+import { f } from '../config/builder';
+import { defineInstrument } from '../instrument/defineInstrument';
 import type { Instrument } from '../instrument/types';
 import type { TrialRecord } from '../state/types';
-import { addTrial, cloneTrial, closeTrial, reorderTrials, resetTrial } from './trialOps';
+import { addTrial, cloneTrial, closeTrial, reorderTrials, resetTrial, swapTrial } from './trialOps';
 
 interface CounterState {
   count: number;
@@ -38,10 +41,22 @@ const subjectInstrument: Instrument<{ label: string }, SubjectConfig> = {
   render: () => null,
 };
 
+const schemaInstrument = defineInstrument({
+  name: 'Schemed',
+  config: f.schema({
+    cols: f.number(3).initial(auto),
+    gap: f.number(12),
+    grid: f.group({ size: f.number(4) }),
+  }),
+  initialState: () => ({}),
+  render: () => null,
+});
+
 const instruments: Instrument[] = [
   counter as Instrument,
   counterWithCanvas as Instrument,
   subjectInstrument as Instrument,
+  schemaInstrument as Instrument,
 ];
 
 function head<T>(arr: T[]): T {
@@ -107,6 +122,38 @@ describe('addTrial', () => {
     const out = addTrial([], instruments, 'Subject', { config: { subject: undefined } });
     expect(out[0]?.config).toEqual({ subject: 'none', zoom: 1 });
   });
+
+  it('opens a trial with the schema-declared auto paths already unpinned', () => {
+    const out = addTrial([], instruments, 'Schemed');
+    expect(out[0]?.auto).toEqual(['cols']);
+  });
+
+  it('honors auto in a seed config and keeps the sentinel out of the record', () => {
+    const out = addTrial([], instruments, 'Schemed', { config: { gap: auto } });
+    expect(out[0]?.auto).toContain('gap');
+    expect(out[0]?.autoSeed).toEqual(['gap']);
+    expect((out[0]?.config as { gap: number }).gap).toBe(12);
+    expect(out[0]?.configSeed).not.toHaveProperty('gap');
+  });
+
+  it('keeps a seed value that is an object but not a config branch', () => {
+    const when = new Date('2020-01-01T00:00:00Z');
+    const out = addTrial([], instruments, 'Counter', {
+      config: { at: when } as unknown as Partial<CounterConfig>,
+    });
+    expect((out[0]?.config as { at: unknown }).at).toBe(when);
+  });
+
+  it('honors auto at a nested seed path', () => {
+    const out = addTrial([], instruments, 'Schemed', { config: { grid: { size: auto } } });
+    expect(out[0]?.auto).toContain('grid.size');
+    expect((out[0]?.config as { grid: { size: number } }).grid.size).toBe(4);
+  });
+
+  it('leaves a trial with no auto field when nothing is unpinned', () => {
+    const out = addTrial([], instruments, 'Counter');
+    expect(out[0]?.auto).toBeUndefined();
+  });
 });
 
 describe('cloneTrial', () => {
@@ -187,6 +234,20 @@ describe('resetTrial', () => {
     expect(reset[0]?.state).toEqual({ label: 'ONE' });
     expect(reset[1]?.config).toEqual({ subject: 'two', zoom: 1 });
   });
+
+  it('un-pins the paths the trial opened auto again, from schema and from seed', () => {
+    const arr = addTrial([], instruments, 'Schemed', { config: { gap: auto } });
+    head(arr).auto = [];
+    const reset = resetTrial(arr, head(arr).id, instruments);
+    expect([...(reset[0]?.auto ?? [])].sort()).toEqual(['cols', 'gap']);
+  });
+
+  it('pins a path the user un-pinned that the trial did not open on', () => {
+    const arr = addTrial([], instruments, 'Schemed');
+    head(arr).auto = ['cols', 'grid.size'];
+    const reset = resetTrial(arr, head(arr).id, instruments);
+    expect(reset[0]?.auto).toEqual(['cols']);
+  });
 });
 
 describe('reorderTrials', () => {
@@ -236,3 +297,42 @@ describe('a size-aware initial view', () => {
     expect(trial?.view).toBeNull();
   });
 });
+
+describe('swapTrial', () => {
+  const instruments = [counter, subjectInstrument];
+  const three = (): TrialRecord[] =>
+    addTrial(
+      addTrial(addTrial([], instruments, 'Counter'), instruments, 'Counter'),
+      instruments,
+      'Counter',
+    );
+
+  it('puts a fresh trial of the other instrument in the same place', () => {
+    const trials = three();
+    const target = trials[1] as TrialRecord;
+    const next = swapTrial(trials, instruments, target.id, 'Subject', {
+      config: { subject: 'moon' },
+    });
+    expect(next).toHaveLength(3);
+    expect(next[0]).toBe(trials[0]);
+    expect(next[2]).toBe(trials[2]);
+    const swapped = next[1] as TrialRecord;
+    expect(swapped.id).not.toBe(target.id);
+    expect(swapped.instrumentName).toBe('Subject');
+    expect(swapped.config).toEqual({ subject: 'moon', zoom: 1 });
+    expect(swapped.state).toEqual({ label: 'MOON' });
+    expect(swapped.configSeed).toEqual({ subject: 'moon' });
+    expect(swapped.undoStack).toEqual({ past: [], future: [] });
+  });
+
+  it('keeps the width the trial’s sidebar was dragged to', () => {
+    const trials = three().map((t, i) => (i === 1 ? { ...t, sidebarWidth: 312 } : t));
+    const next = swapTrial(trials, instruments, (trials[1] as TrialRecord).id, 'Subject');
+    expect(next[1]?.sidebarWidth).toBe(312);
+  });
+
+  it('returns the list untouched for an id it does not hold', () => {
+    const trials = three();
+    expect(swapTrial(trials, instruments, 'nope', 'Subject')).toBe(trials);
+  });
+});

package/src/trial/trialOps.ts

@@ -1,7 +1,10 @@
-import { fillConfigDefaults } from '../config/path';
+import { isAuto } from '../config/auto';
+import { autoPathsOf } from '../config/autoConfig';
+import { fillConfigDefaults, isRecord } from '../config/path';
+import { unruledConfigSchema } from '../instrument/serializers';
 import type { Instrument, InstrumentList } from '../instrument/types';
-import type { TrialRecord } from '../state/types';
 import { newId } from '../state/helpers';
+import type { TrialRecord } from '../state/types';
 
 const DEFAULT_VIEW = { zoom: 1, pan: { x: 0, y: 0 } } as const;
 
@@ -14,10 +17,12 @@ function findInstrument(instruments: InstrumentList, name: string): Instrument {
 }
 
 function initialView(instrument: Instrument): TrialRecord['view'] {
-  const declared = instrument.canvas?.initialView;
+  const stage = instrument.canvas ? undefined : instrument.stage;
+  const declared = instrument.canvas?.initialView ?? stage?.initialView;
   // A function needs the canvas size, which no trial has at creation. `null`
   // is the unplaced marker; `Trial` resolves it on the first non-empty size.
-  if (typeof declared === 'function') return null;
+  // A stage that names no view is fitted, which needs that size too.
+  if (typeof declared === 'function' || (stage && declared === undefined)) return null;
   return declared ? structuredClone(declared) : { ...DEFAULT_VIEW, pan: { ...DEFAULT_VIEW.pan } };
 }
 
@@ -35,6 +40,35 @@ function seedConfig<TC>(defaults: TC, seed: Partial<TC> | undefined): TC {
   return seed ? fillConfigDefaults(seed, defaults) : defaults;
 }
 
+/** Splits a seed config into its ordinary values and the dotted paths it wrote
+ *  as `auto`, so the sentinel never reaches the record. */
+function splitAutoSeed(
+  seed: Record<string, unknown> | undefined,
+  at = '',
+): { config: Record<string, unknown>; autoPaths: string[] } {
+  const config: Record<string, unknown> = {};
+  const autoPaths: string[] = [];
+  for (const [key, value] of Object.entries(seed ?? {})) {
+    const path = at === '' ? key : `${at}.${key}`;
+    if (isAuto(value)) {
+      autoPaths.push(path);
+    } else if (isRecord(value)) {
+      const inner = splitAutoSeed(value as Record<string, unknown>, path);
+      config[key] = inner.config;
+      autoPaths.push(...inner.autoPaths);
+    } else {
+      config[key] = value;
+    }
+  }
+  return { config, autoPaths };
+}
+
+/** The paths an instrument's own schema declares as starting auto. */
+function schemaAutoPaths(instrument: Instrument): string[] {
+  const schema = unruledConfigSchema(instrument);
+  return schema ? autoPathsOf(schema) : [];
+}
+
 /** Append a new trial running `instrumentName`, at that instrument's default
  *  config — with `options.config` written over it — and the initial state
  *  that config produces. */
@@ -45,7 +79,9 @@ export function addTrial(
   options: AddTrialOptions = {},
 ): TrialRecord[] {
   const instrument = findInstrument(instruments, instrumentName);
-  const config = seedConfig(instrument.defaultConfig(), options.config);
+  const seeded = splitAutoSeed(options.config as Record<string, unknown> | undefined);
+  const autoPaths = [...new Set([...schemaAutoPaths(instrument), ...seeded.autoPaths])];
+  const config = seedConfig(instrument.defaultConfig(), seeded.config);
   const state = instrument.initialState(config);
   const record: TrialRecord = {
     id: newId(),
@@ -55,7 +91,9 @@ export function addTrial(
     view: initialView(instrument),
     undoStack: { past: [], future: [] },
   };
-  if (options.config) record.configSeed = options.config;
+  if (options.config) record.configSeed = seeded.config;
+  if (seeded.autoPaths.length > 0) record.autoSeed = seeded.autoPaths;
+  if (autoPaths.length > 0) record.auto = autoPaths;
   return [...trials, record];
 }
 
@@ -97,15 +135,37 @@ export function resetTrial(
   const instrument = findInstrument(instruments, current.instrumentName);
   const config = seedConfig(instrument.defaultConfig(), current.configSeed);
   const state = instrument.initialState(config);
+  const autoPaths = [...new Set([...schemaAutoPaths(instrument), ...(current.autoSeed ?? [])])];
+  const { auto: _unpinnedNow, ...kept } = current;
   const reset: TrialRecord = {
-    ...current,
+    ...kept,
     config,
     state,
     view: initialView(instrument),
   };
+  if (autoPaths.length > 0) reset.auto = autoPaths;
   return [...trials.slice(0, idx), reset, ...trials.slice(idx + 1)];
 }
 
+/** Put a fresh trial running `instrumentName` where trial `id` is. It gets a
+ *  new id, since the history, snapshots and marks keyed by the old one belong
+ *  to what that trial was running, but keeps the width its sidebar was
+ *  dragged to. */
+export function swapTrial(
+  trials: TrialRecord[],
+  instruments: InstrumentList,
+  id: string,
+  instrumentName: string,
+  options: AddTrialOptions = {},
+): TrialRecord[] {
+  const idx = trials.findIndex((w) => w.id === id);
+  const current = trials[idx];
+  if (!current) return trials;
+  const [record] = addTrial([], instruments, instrumentName, options) as [TrialRecord];
+  if (current.sidebarWidth !== undefined) record.sidebarWidth = current.sidebarWidth;
+  return [...trials.slice(0, idx), record, ...trials.slice(idx + 1)];
+}
+
 /**
  * Reorder to match `ids`. Ids the list doesn't mention keep their relative
  * order at the end, and ids it names that no longer exist are dropped — a

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

@@ -1,155 +0,0 @@
-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;
-    sectionId: string;
-    as: 'tile' | 'floating';
-}
-/** Undocked panels, keyed by {@link panelKey}. */
-type UndockedPanels = Record<string, UndockedPanel>;
-declare function panelKey(trialId: string, sectionId: string): string;
-declare function undockPanel(panels: UndockedPanels, trialId: string, sectionId: string, as?: UndockedPanel['as']): UndockedPanels;
-/** Dock one section back, or — with no `sectionId` — every panel the trial
- *  owns, which is what closing a trial wants. */
-declare function dockPanel(panels: UndockedPanels, trialId: string, sectionId?: string): UndockedPanels;
-
-/** A trial's undo history, as snapshots of its state either side of the
- *  present. */
-interface UndoStack {
-    past: unknown[];
-    future: unknown[];
-}
-/** The trial a per-trial call is coming from. `id` is the id `useTileId`
- *  scopes a surface tile under, so a consumer keying its own per-trial
- *  registry and labkit's tiles agree on the key. */
-interface TrialInfo<TV = unknown> {
-    id: string;
-    /** The trial's view, in whatever shape the instrument keeps it. */
-    view: TV;
-}
-/** One trial as the store holds it: which instrument it runs, that
- *  instrument's config and state, the camera, and the undo history. */
-interface TrialRecord<TS = unknown, TC = unknown, TV = unknown> {
-    id: string;
-    instrumentName: string;
-    config: TC;
-    state: TS;
-    /** Opaque to labkit: persisted, restored on Reset and handed to the instrument,
-     *  but never read into. A 3D lab puts an orbit here and keeps all three. */
-    view: TV;
-    /** The config `addTrial` opened this trial on, overlaid on the instrument's
-     *  defaults. Kept so Reset restores the trial's own subject rather than the
-     *  bare defaults. */
-    configSeed?: Partial<TC>;
-    /** This trial's own tool slot. Undefined means it reads the lab's. */
-    activeToolId?: string | null;
-    /** The extent the trial's sidebar was last dragged to, in pixels. Undefined
-     *  until someone moves the seam. */
-    sidebarWidth?: number;
-    /** What the title bar reads. Undefined — the state a trial opens in, and the
-     *  one `setTitle(null)` returns it to — means the instrument's name. */
-    title?: string | null;
-    /** Which of the trial's collapsible sections are folded, keyed as
-     *  `TrialChromeContext.collapsedSections` describes. A key that is absent
-     *  takes the section's own default. */
-    collapsedSections?: Record<string, boolean>;
-    /** The marks on this trial's annotation targets, as `AnnotationsApi.toJSON`
-     *  wrote them. Opaque here, and absent for a trial whose instrument declares
-     *  no `annotations` — or declares its own `storage`. Not in `state`, which
-     *  belongs to the instrument and is typed as such. */
-    annotations?: unknown;
-    undoStack: UndoStack;
-}
-/** A named, saved copy of a trial's config and state, restorable into any
- *  trial running the same instrument. */
-interface SavedSnapshot {
-    id: string;
-    name: string;
-    trialId: string;
-    instrumentName: string;
-    config: unknown;
-    state: unknown;
-    savedAt: number;
-}
-/** `auto` follows the OS; the other two are an explicit choice. */
-type LabMode = 'auto' | 'light' | 'dark';
-/** Everything a lab persists: its trials, its saved snapshots, and the
- *  chosen color mode. */
-interface LabStoreState {
-    trials: TrialRecord[];
-    savedSnapshots: SavedSnapshot[];
-    mode: LabMode;
-    /** The lab's tool slot — what a trial with no slot of its own resolves to. */
-    activeToolId: string | null;
-    /** Per-trial tile extents, keyed by trial id. Opaque here — the
-     *  shape belongs to whatever lays the trials out. */
-    layout: Record<string, unknown>;
-    /** Sidebar sections torn out of their trial. A panel here is not rendered in
-     *  its trial's sidebar; the workspace renders it instead. */
-    undockedPanels: UndockedPanels;
-}
-/** Where a lab persists itself. Implementations are keyed string storage and
- *  nothing more, so the same store works against localStorage, the URL hash,
- *  or memory. */
-interface StorageAdapter {
-    read(key: string): string | null;
-    write(key: string, value: string): void;
-    delete?(key: string): void;
-}
-/** What `useTrialState` hands an instrument: its state and config, with
- *  a setter for each. */
-interface TrialStateHandle<TS, TC> {
-    state: TS;
-    setState: (next: TS | ((prev: TS) => TS)) => void;
-    config: TC;
-    /** 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. */
-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. `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, config: unknown) => unknown;
-} | undefined>;
-/** A trial as it is persisted: everything but the undo history, which is
- *  session-only. */
-type SerializedTrial = Omit<TrialRecord, 'undoStack'>;
-/** Everything a lab persists, under one key, at a known version. */
-interface LabDocument {
-    version: number;
-    trials: SerializedTrial[];
-    saves: SavedSnapshot[];
-    layout: Record<string, unknown>;
-    /** Sidebar sections torn out of their trial, keyed by trial and section. */
-    undockedPanels: UndockedPanels;
-    mode: LabMode;
-}
-/** Migrates a document one version forward. Index `i` in the chain takes a
- *  version-`i` document to version `i + 1`. */
-type Migration = (doc: Record<string, unknown>) => Record<string, unknown>;
-
-export { dockPanel as g, panelKey as p, undockPanel as u };
-export type { CreateLabStoreOptions as C, InstrumentSerializers as I, LabDocument as L, Migration as M, SerializedTrial as S, TrialRecord as T, UndoStack as U, StorageAdapter as a, LabStoreState as b, SavedSnapshot as c, TrialStateHandle as d, UndockedPanel as e, UndockedPanels as f, LabMode as h, TrialInfo as i };

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

@@ -1,62 +0,0 @@
-/** 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-D6Vb3T-g.d.ts

@@ -1,99 +0,0 @@
-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';
-
-/** Persist to `localStorage` — state survives a reload and a new tab. Falls
- *  back to no-ops when storage is unavailable. */
-declare const localStorageAdapter: StorageAdapter;
-/** Persist to `sessionStorage` — state survives a reload but not a new tab. */
-declare const sessionStorageAdapter: StorageAdapter;
-/** Persist into the URL fragment, so the page's link carries its state and
- *  can be shared or bookmarked. */
-declare const urlHashAdapter: StorageAdapter;
-/** An in-memory store, discarded on reload. For tests, and for labs that
- *  should start fresh every time. */
-declare function createMemoryAdapter(): StorageAdapter;
-/** Persists nothing and reads back nothing. */
-declare const noneAdapter: StorageAdapter;
-
-/** Every mutation a lab store supports: managing trials, saving and
- *  restoring snapshots, and setting the color mode. */
-interface LabStoreActions {
-    addTrial: (record: Omit<TrialRecord, 'undoStack'>) => void;
-    removeTrial: (id: string) => void;
-    updateTrialState: <TS>(id: string, next: TS | ((prev: TS) => TS)) => 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. */
-    setTrialTitle: (id: string, title: string | null) => void;
-    /** Fold or unfold one of a trial's sections. */
-    setTrialSectionCollapsed: (id: string, key: string, collapsed: boolean) => void;
-    updateTrialAnnotations: (id: string, doc: unknown) => void;
-    updateTrialUndoStack: (id: string, next: TrialRecord['undoStack'] | ((prev: TrialRecord['undoStack']) => TrialRecord['undoStack'])) => void;
-    setTrialInstrument: (id: string, instrumentName: string) => void;
-    saveSnapshot: (trialId: string, name: string) => void;
-    loadSnapshot: (snapshotId: string, trialId: string) => void;
-    deleteSnapshot: (snapshotId: string) => void;
-    listSnapshots: (trialId?: string) => SavedSnapshot[];
-    setMode: (mode: LabMode) => void;
-    setLabTool: (id: string | null) => void;
-    setTrialTool: (trialId: string, id: string | null) => void;
-    setLayout: (layout: Record<string, unknown>) => void;
-    /** Tear a sidebar section out of its trial. Default target is a workspace tile. */
-    undockPanel: (trialId: string, sectionId: string, as?: UndockedPanel['as']) => void;
-    /** 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 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;
-
-type LabStoreCtx = {
-    store: LabStore;
-} | null;
-/** Context carrying the lab store. Prefer `useLabStore`; this is exported for
- *  code that needs to read the context without subscribing. */
-declare const LabStoreContext: react.Context<LabStoreCtx>;
-/** Provides a lab store to its subtree. */
-declare function LabStoreProvider({ store, children, }: {
-    store: LabStore;
-    children: ReactNode;
-}): ReactElement;
-/** Subscribe to the whole lab store. Throws outside a `<LabStoreProvider>`. */
-declare function useLabStore(): LabStoreState & ReturnType<LabStore['getState']>;
-/** Context carrying which trial the subtree belongs to. */
-declare const TrialIdContext: react.Context<string | null>;
-/** Names the trial its subtree belongs to, so an instrument's hooks can
- *  find their own record in the store without being passed an id. */
-declare function TrialIdProvider({ trialId, children, }: {
-    trialId: string;
-    children: ReactNode;
-}): ReactElement;
-/** The id of the trial this component is inside. Throws outside a
- *  `<TrialIdProvider>`. */
-declare function useTrialId(): string;
-
-/** Bumped whenever the persisted shape changes; every bump needs a migration. */
-declare const CURRENT_DOCUMENT_VERSION = 3;
-/** The one key a lab persists under. The `:doc` suffix keeps it out of the
- *  legacy bucket namespace, where a lab named `a:saves` would otherwise write
- *  its document over lab `a`'s saves bucket. */
-declare function labDocumentKey(storageKey: string): string;
-/** Where a document that failed to migrate is set aside, so a bad migration
- *  loses state loudly rather than silently. */
-declare function quarantineKey(storageKey: string): string;
-
-/** An instrument's own state and config, plus setters. Reads the surrounding
- *  trial id, so an instrument never has to know which trial it is
- *  running in. Throws outside a lab store and trial. */
-declare function useTrialState<TS = unknown, TC = unknown>(): TrialStateHandle<TS, TC>;
-
-export { CURRENT_DOCUMENT_VERSION as C, TrialIdContext as T, LabStoreContext as b, LabStoreProvider as c, TrialIdProvider as d, createLabStore as e, createMemoryAdapter as f, localStorageAdapter as g, useLabStore as h, useTrialId as i, useTrialState as j, labDocumentKey as l, noneAdapter as n, quarantineKey as q, sessionStorageAdapter as s, urlHashAdapter as u };
-export type { LabStore as L, LabStoreActions as a };