@weasel-js/labkit 1.0.4 → 1.1.0

package/dist/layers/index.d.ts

@@ -1,5 +1,5 @@
-import { c as LayerDescriptor } from '../_dts/index-CFlDPeZh.js';
-export { L as LayerCapability } from '../_dts/index-CFlDPeZh.js';
+import { d as LayerDescriptor } from '../_dts/index-iAP6XbH3.js';
+export { L as LayerCapability } from '../_dts/index-iAP6XbH3.js';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import 'react';
 import '../_dts/types-x92Kfeme.js';

package/dist/passthrough/weasel-canvas.js

@@ -1,3 +1,3 @@
-export { FALLBACK_FIT_VIEW, MinimapCanvas, SceneViewCanvas, buildSceneViewCommands, computeFitView2 as computeFitView, computeIndicatorCommand, renderSceneToCanvas } from '../chunk-DWV7SFKR.js';
+export { FALLBACK_FIT_VIEW, MinimapCanvas, SceneViewCanvas, buildSceneViewCommands, computeFitView2 as computeFitView, computeIndicatorCommand, renderSceneToCanvas } from '../chunk-DJLDIRFN.js';
 //# sourceMappingURL=weasel-canvas.js.map
 //# sourceMappingURL=weasel-canvas.js.map

package/dist/passthrough/weasel-ui.d.ts

@@ -1082,6 +1082,10 @@ type TrackCtx = {
  * `onInput` fires continuously through a drag; `onChange` fires once when it
  * ends and is the one to write to history.
  *
+ * `stops` are attractors: a drag that passes within a few pixels of one lands
+ * on it, and the arrow keys move stop to stop. `step` still quantizes the
+ * values between them.
+ *
  * `constraint: 'ordered'` keeps thumbs from crossing each other. Supplying
  * `onAddThumb` makes a click on empty track create a thumb, and supplying
  * `onRemoveThumb` lets a right-click or a drag off the track remove one —
@@ -1095,6 +1099,7 @@ type SliderProps<T extends Thumb = Thumb> = {
     min: number;
     max: number;
     step?: number;
+    stops?: number[];
     constraint?: 'free' | 'ordered';
     onAddThumb?: (atValue: number) => T | null;
     onRemoveThumb?: (index: number) => boolean;
@@ -1676,8 +1681,10 @@ interface InsertAdapter<TNode extends {
         dx: number;
         dy: number;
     };
-    /** Mutator wired by `insertNode`-using ops (kit-side InsertOp). */
-    insertNode(node: TNode): void;
+    /** Mutator wired by `insertNode`-using ops (kit-side InsertOp). `index`
+     *  carries the z-position a delete captured, so undo restores paint order;
+     *  see `SceneAdapter.insertNode`. */
+    insertNode(node: TNode, index?: number): void;
     /** Mutator wired by `setSelection` ops batched alongside paste. */
     setSelection(ids: string[]): void;
     /** Optional: see SceneAdapter.applyOps. */

package/dist/passthrough/weasel-ui.js

@@ -1,4 +1,4 @@
-export { m as ActionBar, r3 as ActionsBar, Ft as Badge, a as Button, o3 as Checkbox, p4 as ComboBox, m3 as ComboBoxItem, F as CurveEditor, u as DataGrid, c3 as Dialog, qe as EDGE_PROFILES, n as Field, u3 as Input, s as KeyCap, c2 as KeySequence, o2 as MINUS_SIGN, f2 as NumberField, r2 as OptionsBar, _ as Plot2D, n4 as PointPlotter, r4 as Powerline, u4 as Radio, l as RadioGroup, l2 as RangeSlider, p3 as Select, h as SelectItem, n2 as Sidebar, o4 as SidebarPanel, m2 as Slider, a3 as Switch, c4 as Tab, s3 as TabList, l3 as TabPanel, o6 as Tabs, r as ToggleBar, o5 as ToolButton, n3 as ToolGroup, _2 as ToolPalette, He as chromaAt, u2 as detectPlatform, p as dlog, r5 as fieldClasses, s2 as formatNumber, d2 as formatShortcut, u5 as formatShortcutParts, o as inferKeycapKind, f as isDebugEnabled, e as keyGlyph, p2 as keySpecFromKey, d as keySpecsFromMods, Ve as oklchToHex, p5 as paintGradientTrack, c as useReorderDragList, a2 as useRovingTabIndex } from '../chunk-BAPZPDDA.js';
-import '../chunk-DWV7SFKR.js';
+export { m as ActionBar, r3 as ActionsBar, Ft as Badge, a as Button, o3 as Checkbox, p4 as ComboBox, m2 as ComboBoxItem, F as CurveEditor, u as DataGrid, c3 as Dialog, qe as EDGE_PROFILES, n as Field, u3 as Input, s as KeyCap, c2 as KeySequence, o2 as MINUS_SIGN, f2 as NumberField, r2 as OptionsBar, _ as Plot2D, n4 as PointPlotter, r4 as Powerline, u4 as Radio, l as RadioGroup, l2 as RangeSlider, p3 as Select, h as SelectItem, n2 as Sidebar, o4 as SidebarPanel, v as Slider, a3 as Switch, c4 as Tab, s3 as TabList, l3 as TabPanel, o6 as Tabs, r as ToggleBar, o5 as ToolButton, n3 as ToolGroup, _2 as ToolPalette, He as chromaAt, u2 as detectPlatform, p as dlog, r5 as fieldClasses, s2 as formatNumber, d2 as formatShortcut, u5 as formatShortcutParts, o as inferKeycapKind, f as isDebugEnabled, e as keyGlyph, p2 as keySpecFromKey, d as keySpecsFromMods, Ve as oklchToHex, p5 as paintGradientTrack, c as useReorderDragList, a2 as useRovingTabIndex } from '../chunk-C6GJKPUI.js';
+import '../chunk-DJLDIRFN.js';
 //# sourceMappingURL=weasel-ui.js.map
 //# sourceMappingURL=weasel-ui.js.map

package/dist/state/index.d.ts

@@ -1,5 +1,5 @@
-import { I as InstrumentSerializers, W as WorkspaceRecord, U as UndoStack, S as StorageAdapter } from '../_dts/useExperimentState-D7EQnnwJ.js';
-export { C as CreateLabStoreOptions, E as ExperimentStateHandle, L as LabStore, a as LabStoreActions, b as LabStoreContext, c as LabStoreProvider, d as LabStoreState, e as SavedSnapshot, f as WorkspaceIdContext, g as WorkspaceIdProvider, h as createLabStore, i as createMemoryAdapter, l as localStorageAdapter, n as noneAdapter, s as sessionStorageAdapter, u as urlHashAdapter, j as useExperimentState, k as useLabStore, m as useWorkspaceId } from '../_dts/useExperimentState-D7EQnnwJ.js';
+import { S as SerializedTrial, I as InstrumentSerializers, T as TrialRecord, U as UndoStack, a as StorageAdapter } from '../_dts/useTrialState-DYe2vUwN.js';
+export { C as CURRENT_DOCUMENT_VERSION, b as CreateLabStoreOptions, L as LabDocument, c as LabStore, d as LabStoreActions, e as LabStoreContext, f as LabStoreProvider, g as LabStoreState, M as Migration, h as SavedSnapshot, i as TrialIdContext, j as TrialIdProvider, k as TrialStateHandle, l as createLabStore, m as createMemoryAdapter, n as labDocumentKey, o as localStorageAdapter, p as noneAdapter, q as quarantineKey, s as sessionStorageAdapter, u as urlHashAdapter, r as useLabStore, t as useTrialId, v as useTrialState } from '../_dts/useTrialState-DYe2vUwN.js';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { ReactNode } from 'react';
 import 'zustand/vanilla';
@@ -14,19 +14,19 @@ declare function encodeUrlHash(value: string): string;
 declare function decodeUrlHash(hash: string): string | null;
 /** A fresh, empty undo history. */
 declare function emptyUndoStack(): UndoStack;
-/** Serialize workspaces for storage, running each instrument's own serializer
+/** Serialize trials for storage, running each instrument's own serializer
  *  over its state. Undo history is deliberately dropped — it does not survive
  *  a reload. */
-declare function serializeWorkspaces(workspaces: WorkspaceRecord[], serializers: InstrumentSerializers): string;
-/** Rebuild workspaces from storage, running each instrument's deserializer
+declare function serializeTrials(trials: TrialRecord[], serializers: InstrumentSerializers): SerializedTrial[];
+/** Rebuild trials from storage, running each instrument's deserializer
  *  over its state and starting each with an empty undo history. Returns an
  *  empty list rather than throwing on malformed input. */
-declare function deserializeWorkspaces(raw: string, deserializers: InstrumentSerializers): WorkspaceRecord[];
+declare function deserializeTrials(records: SerializedTrial[], deserializers: InstrumentSerializers): TrialRecord[];
 
 /** Props for `<SingletonExperimentProvider>`. */
 interface SingletonExperimentProviderProps<TS, TC> {
-    /** Stable id for the synthetic workspace; also doubles as the
-     *  WorkspaceIdContext value. */
+    /** Stable id for the synthetic trial; also doubles as the
+     *  TrialIdContext value. */
     id: string;
     initialConfig: TC;
     initialState: TS;
@@ -35,12 +35,12 @@ interface SingletonExperimentProviderProps<TS, TC> {
     children: ReactNode;
 }
 /**
- * One-workspace `<Lab>` substitute for single-screen experiments. Mounts
- * a `LabStoreProvider` + `WorkspaceIdProvider` with one synthetic
- * workspace, so `useExperimentState` works without going through the
+ * One-trial `<Lab>` substitute for single-screen experiments. Mounts
+ * a `LabStoreProvider` + `TrialIdProvider` with one synthetic
+ * trial, so `useTrialState` works without going through the
  * full `<Lab instruments={...}>` runtime.
  */
 declare function SingletonExperimentProvider<TS, TC>({ id, initialConfig, initialState, storage, storageKey, children, }: SingletonExperimentProviderProps<TS, TC>): react_jsx_runtime.JSX.Element;
 
-export { InstrumentSerializers, SingletonExperimentProvider, StorageAdapter, UndoStack, WorkspaceRecord, decodeUrlHash, deserializeWorkspaces, emptyUndoStack, encodeUrlHash, labStorageKey, serializeWorkspaces };
+export { InstrumentSerializers, SerializedTrial, SingletonExperimentProvider, StorageAdapter, TrialRecord, UndoStack, decodeUrlHash, deserializeTrials, emptyUndoStack, encodeUrlHash, labStorageKey, serializeTrials };
 export type { SingletonExperimentProviderProps };

package/dist/state/index.js

@@ -1,5 +1,5 @@
-import { createLabStore, LabStoreProvider, WorkspaceIdProvider } from '../chunk-KSTEW2AF.js';
-export { LabStoreContext, LabStoreProvider, WorkspaceIdContext, WorkspaceIdProvider, createLabStore, createMemoryAdapter, decodeUrlHash, deserializeWorkspaces, emptyUndoStack, encodeUrlHash, labStorageKey, localStorageAdapter, noneAdapter, serializeWorkspaces, sessionStorageAdapter, urlHashAdapter, useExperimentState, useLabStore, useWorkspaceId } from '../chunk-KSTEW2AF.js';
+import { createLabStore, LabStoreProvider, TrialIdProvider } from '../chunk-3TYUJR7Z.js';
+export { CURRENT_DOCUMENT_VERSION, LabStoreContext, LabStoreProvider, TrialIdContext, TrialIdProvider, createLabStore, createMemoryAdapter, decodeUrlHash, deserializeTrials, emptyUndoStack, encodeUrlHash, labDocumentKey, labStorageKey, localStorageAdapter, noneAdapter, quarantineKey, serializeTrials, sessionStorageAdapter, urlHashAdapter, useLabStore, useTrialId, useTrialState } from '../chunk-3TYUJR7Z.js';
 import { useRef } from 'react';
 import { jsx } from 'react/jsx-runtime';
 
@@ -15,8 +15,8 @@ function SingletonExperimentProvider({
   const storeRef = useRef(null);
   if (storeRef.current === null) {
     const store = createLabStore({ storageKey, storage });
-    if (!store.getState().workspaces.some((w) => w.id === id)) {
-      store.getState().addWorkspace({
+    if (!store.getState().trials.some((w) => w.id === id)) {
+      store.getState().addTrial({
         id,
         instrumentName: SINGLETON_INSTRUMENT,
         config: initialConfig,
@@ -26,7 +26,7 @@ function SingletonExperimentProvider({
     }
     storeRef.current = store;
   }
-  return /* @__PURE__ */ jsx(LabStoreProvider, { store: storeRef.current, children: /* @__PURE__ */ jsx(WorkspaceIdProvider, { workspaceId: id, children }) });
+  return /* @__PURE__ */ jsx(LabStoreProvider, { store: storeRef.current, children: /* @__PURE__ */ jsx(TrialIdProvider, { trialId: id, children }) });
 }
 
 export { SingletonExperimentProvider };

package/dist/state/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/state/SingletonExperiment.tsx"],"names":[],"mappings":";;;;;AAKA,IAAM,oBAAA,GAAuB,eAAA;AAoBtB,SAAS,2BAAA,CAAoC;AAAA,EAClD,EAAA;AAAA,EACA,aAAA;AAAA,EACA,YAAA;AAAA,EACA,OAAA;AAAA,EACA,UAAA;AAAA,EACA;AACF,CAAA,EAA6C;AAC3C,EAAA,MAAM,QAAA,GAAW,OAAwB,IAAI,CAAA;AAC7C,EAAA,IAAI,QAAA,CAAS,YAAY,IAAA,EAAM;AAC7B,IAAA,MAAM,KAAA,GAAQ,cAAA,CAAe,EAAE,UAAA,EAAY,SAAS,CAAA;AACpD,IAAA,IAAI,CAAC,KAAA,CAAM,QAAA,EAAS,CAAE,UAAA,CAAW,IAAA,CAAK,CAAC,CAAA,KAAM,CAAA,CAAE,EAAA,KAAO,EAAE,CAAA,EAAG;AACzD,MAAA,KAAA,CAAM,QAAA,GAAW,YAAA,CAAa;AAAA,QAC5B,EAAA;AAAA,QACA,cAAA,EAAgB,oBAAA;AAAA,QAChB,MAAA,EAAQ,aAAA;AAAA,QACR,KAAA,EAAO,YAAA;AAAA,QACP,IAAA,EAAM,EAAE,IAAA,EAAM,CAAA,EAAG,GAAA,EAAK,EAAE,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,CAAA,EAAE;AAAE,OACtC,CAAA;AAAA,IACH;AACA,IAAA,QAAA,CAAS,OAAA,GAAU,KAAA;AAAA,EACrB;AACA,EAAA,uBACE,GAAA,CAAC,gBAAA,EAAA,EAAiB,KAAA,EAAO,QAAA,CAAS,OAAA,EAChC,8BAAC,mBAAA,EAAA,EAAoB,WAAA,EAAa,EAAA,EAAK,QAAA,EAAS,CAAA,EAClD,CAAA;AAEJ","file":"index.js","sourcesContent":["import { type ReactNode, useRef } from 'react';\nimport { LabStoreProvider, WorkspaceIdProvider } from './context';\nimport { createLabStore, type LabStore } from './store';\nimport type { StorageAdapter } from './types';\n\nconst SINGLETON_INSTRUMENT = '__singleton__';\n\n/** Props for `<SingletonExperimentProvider>`. */\nexport interface SingletonExperimentProviderProps<TS, TC> {\n  /** Stable id for the synthetic workspace; also doubles as the\n   *  WorkspaceIdContext value. */\n  id: string;\n  initialConfig: TC;\n  initialState: TS;\n  storage: StorageAdapter;\n  storageKey: string;\n  children: ReactNode;\n}\n\n/**\n * One-workspace `<Lab>` substitute for single-screen experiments. Mounts\n * a `LabStoreProvider` + `WorkspaceIdProvider` with one synthetic\n * workspace, so `useExperimentState` works without going through the\n * full `<Lab instruments={...}>` runtime.\n */\nexport function SingletonExperimentProvider<TS, TC>({\n  id,\n  initialConfig,\n  initialState,\n  storage,\n  storageKey,\n  children,\n}: SingletonExperimentProviderProps<TS, TC>) {\n  const storeRef = useRef<LabStore | null>(null);\n  if (storeRef.current === null) {\n    const store = createLabStore({ storageKey, storage });\n    if (!store.getState().workspaces.some((w) => w.id === id)) {\n      store.getState().addWorkspace({\n        id,\n        instrumentName: SINGLETON_INSTRUMENT,\n        config: initialConfig,\n        state: initialState,\n        view: { zoom: 1, pan: { x: 0, y: 0 } },\n      });\n    }\n    storeRef.current = store;\n  }\n  return (\n    <LabStoreProvider store={storeRef.current}>\n      <WorkspaceIdProvider workspaceId={id}>{children}</WorkspaceIdProvider>\n    </LabStoreProvider>\n  );\n}\n"]}
+{"version":3,"sources":["../../src/state/SingletonExperiment.tsx"],"names":[],"mappings":";;;;;AAKA,IAAM,oBAAA,GAAuB,eAAA;AAoBtB,SAAS,2BAAA,CAAoC;AAAA,EAClD,EAAA;AAAA,EACA,aAAA;AAAA,EACA,YAAA;AAAA,EACA,OAAA;AAAA,EACA,UAAA;AAAA,EACA;AACF,CAAA,EAA6C;AAC3C,EAAA,MAAM,QAAA,GAAW,OAAwB,IAAI,CAAA;AAC7C,EAAA,IAAI,QAAA,CAAS,YAAY,IAAA,EAAM;AAC7B,IAAA,MAAM,KAAA,GAAQ,cAAA,CAAe,EAAE,UAAA,EAAY,SAAS,CAAA;AACpD,IAAA,IAAI,CAAC,KAAA,CAAM,QAAA,EAAS,CAAE,MAAA,CAAO,IAAA,CAAK,CAAC,CAAA,KAAM,CAAA,CAAE,EAAA,KAAO,EAAE,CAAA,EAAG;AACrD,MAAA,KAAA,CAAM,QAAA,GAAW,QAAA,CAAS;AAAA,QACxB,EAAA;AAAA,QACA,cAAA,EAAgB,oBAAA;AAAA,QAChB,MAAA,EAAQ,aAAA;AAAA,QACR,KAAA,EAAO,YAAA;AAAA,QACP,IAAA,EAAM,EAAE,IAAA,EAAM,CAAA,EAAG,GAAA,EAAK,EAAE,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,CAAA,EAAE;AAAE,OACtC,CAAA;AAAA,IACH;AACA,IAAA,QAAA,CAAS,OAAA,GAAU,KAAA;AAAA,EACrB;AACA,EAAA,uBACE,GAAA,CAAC,gBAAA,EAAA,EAAiB,KAAA,EAAO,QAAA,CAAS,OAAA,EAChC,8BAAC,eAAA,EAAA,EAAgB,OAAA,EAAS,EAAA,EAAK,QAAA,EAAS,CAAA,EAC1C,CAAA;AAEJ","file":"index.js","sourcesContent":["import { type ReactNode, useRef } from 'react';\nimport { LabStoreProvider, TrialIdProvider } from './context';\nimport { createLabStore, type LabStore } from './store';\nimport type { StorageAdapter } from './types';\n\nconst SINGLETON_INSTRUMENT = '__singleton__';\n\n/** Props for `<SingletonExperimentProvider>`. */\nexport interface SingletonExperimentProviderProps<TS, TC> {\n  /** Stable id for the synthetic trial; also doubles as the\n   *  TrialIdContext value. */\n  id: string;\n  initialConfig: TC;\n  initialState: TS;\n  storage: StorageAdapter;\n  storageKey: string;\n  children: ReactNode;\n}\n\n/**\n * One-trial `<Lab>` substitute for single-screen experiments. Mounts\n * a `LabStoreProvider` + `TrialIdProvider` with one synthetic\n * trial, so `useTrialState` works without going through the\n * full `<Lab instruments={...}>` runtime.\n */\nexport function SingletonExperimentProvider<TS, TC>({\n  id,\n  initialConfig,\n  initialState,\n  storage,\n  storageKey,\n  children,\n}: SingletonExperimentProviderProps<TS, TC>) {\n  const storeRef = useRef<LabStore | null>(null);\n  if (storeRef.current === null) {\n    const store = createLabStore({ storageKey, storage });\n    if (!store.getState().trials.some((w) => w.id === id)) {\n      store.getState().addTrial({\n        id,\n        instrumentName: SINGLETON_INSTRUMENT,\n        config: initialConfig,\n        state: initialState,\n        view: { zoom: 1, pan: { x: 0, y: 0 } },\n      });\n    }\n    storeRef.current = store;\n  }\n  return (\n    <LabStoreProvider store={storeRef.current}>\n      <TrialIdProvider trialId={id}>{children}</TrialIdProvider>\n    </LabStoreProvider>\n  );\n}\n"]}

package/dist/styles.css

@@ -356,15 +356,15 @@
   letter-spacing: 0.01em;
   line-height: 1.2;
 }
-.lk-workspace-grid {
+.lk-workspace {
   min-height: 0;
 }
-.lk-workspace-tile {
+.lk-trial-tile {
   display: flex;
   flex-direction: column;
   height: 100%;
 }
-.lk-workspace-tile__grip {
+.lk-trial-tile__grip {
   flex: 0 0 auto;
   display: flex;
   align-items: center;
@@ -374,17 +374,17 @@
   border-radius: var(--wzl-radius-sm) var(--wzl-radius-sm) 0 0;
   background: var(--wzl-surface-sunken);
 }
-.lk-workspace-tile__grip:active {
+.lk-trial-tile__grip:active {
   cursor: grabbing;
 }
-.lk-workspace-tile__grip-dots {
+.lk-trial-tile__grip-dots {
   width: 28px;
   height: 3px;
   border-radius: 999px;
   background: var(--wzl-fg-muted);
   opacity: 0.5;
 }
-.lk-workspace-tile__body {
+.lk-trial-tile__body {
   flex: 1;
   min-height: 0;
 }
@@ -567,10 +567,18 @@
 .lk-scale-indicator-label {
   white-space: nowrap;
 }
+html:has(.lk-lab),
+body:has(.lk-lab) {
+  margin: 0;
+  height: 100%;
+}
+body:has(.lk-lab) > :has(> .lk-lab) {
+  height: 100%;
+}
 .lk-lab {
   height: 100%;
 }
-.lk-workspace {
+.lk-trial {
   display: flex;
   flex-direction: column;
   height: 100%;
@@ -579,27 +587,27 @@
   border-radius: var(--wzl-radius-md);
   overflow: hidden;
 }
-.lk-workspace__body {
+.lk-trial__body {
   display: flex;
   flex: 1;
   overflow: hidden;
 }
-.lk-workspace__sidebar {
+.lk-trial__sidebar {
   flex-shrink: 0;
 }
-.lk-workspace__content {
+.lk-trial__content {
   flex: 1;
   overflow: auto;
 }
-.lk-workspace__toolbar {
+.lk-trial__toolbar {
   flex-shrink: 0;
   border-bottom: 1px solid var(--wzl-line-subtle);
 }
-.lk-workspace__status {
+.lk-trial__status {
   flex-shrink: 0;
   border-top: 1px solid var(--wzl-line-subtle);
 }
-.lk-workspace--unknown {
+.lk-trial--unknown {
   display: flex;
   align-items: center;
   justify-content: center;

package/dist/ui/layers/index.js

@@ -1,5 +1,5 @@
-export { LayerStack } from '../../chunk-DEWXYFEU.js';
-import '../../chunk-BAPZPDDA.js';
-import '../../chunk-DWV7SFKR.js';
+export { LayerStack } from '../../chunk-NRKWVTVT.js';
+import '../../chunk-C6GJKPUI.js';
+import '../../chunk-DJLDIRFN.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/undo/index.d.ts

@@ -1,4 +1,4 @@
-export { U as UndoCapability } from '../_dts/index-CFlDPeZh.js';
+export { U as UndoCapability } from '../_dts/index-iAP6XbH3.js';
 import 'react';
 import '../_dts/types-x92Kfeme.js';
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weasel-js/labkit",
-  "version": "1.0.4",
+  "version": "1.1.0",
   "description": "React widgets for building self-contained interactive lab pages",
   "license": "MIT",
   "author": "orochi235",

package/src/canvas/AGENTS.md

@@ -32,12 +32,12 @@ interface CanvasStackProps {
 
 1. The container measures itself with `ResizeObserver` and reports `{width, height, dpr}`.
 2. `useLayerScheduler` watches `layers`, `view`, and `size`, and on any change schedules a single `requestAnimationFrame` redraw.
-3. Each layer's `render(ctx, view)` is called with a fresh transform: the canvas is sized to `width * dpr × height * dpr` so coordinates are in CSS pixels.
+3. Each layer's `render(ctx, view)` is called with a fresh transform: the canvas is sized to `width * dpr × height * dpr` so coordinates are in CSS pixels. A `CanvasLayerDescriptor` gets the whole `view` and places its own geometry; an instrument's `CanvasLayer.draw` is called with the camera already applied — see below.
 4. Layers with `visible: false` are skipped and their canvas is `display: none` (DOM is preserved to avoid remounts).
 
 ## Adding a new layer type
 
-A layer is defined by the instrument's `canvas.layers[]` (type `CanvasLayer`), then translated to a `CanvasLayerDescriptor` inside `Workspace.tsx` before being passed to `<CanvasStack>`. To add a layer, push it into `instrument.canvas.layers`:
+A layer is defined by the instrument's `canvas.layers[]` (type `CanvasLayer`), then translated to a `CanvasLayerDescriptor` inside `Trial.tsx` before being passed to `<CanvasStack>`. To add a layer, push it into `instrument.canvas.layers`:
 
 ```ts
 canvas: {
@@ -50,6 +50,10 @@ canvas: {
 }
 ```
 
+`draw` receives the context with the camera already applied, so its coordinates are world coordinates — `Trial.tsx` translates by `view.pan` and scales by `view.zoom` before calling it. `zoom` is still passed so a layer can keep line widths and handle sizes from growing: divide by it (`ctx.lineWidth = 1 / zoom`).
+
+That is the difference between the two layer types. The lower-level `CanvasLayerDescriptor.render(ctx, view)` gets the raw view and an untransformed context, which is what screen-space chrome wants.
+
 Layer order in the array = paint order (first drawn = bottom).
 
 ## Overlay (children)

package/src/dragdrop/dragDrop.test.tsx

@@ -34,19 +34,16 @@ const originalGetBoundingClientRect = HTMLElement.prototype.getBoundingClientRec
 function StateProbe({ onState }: { onState: (state: DropState) => void }) {
   const ctx = useContext(LabStoreContext);
   const ws = useStore(
-    ctx?.store ?? ({ getState: () => ({ workspaces: [] }) } as never),
-    (s) => (s as { workspaces: { state: unknown }[] }).workspaces[0],
+    ctx?.store ?? ({ getState: () => ({ trials: [] }) } as never),
+    (s) => (s as { trials: { state: unknown }[] }).trials[0],
   );
   if (ws) onState(ws.state as DropState);
   return null;
 }
 
-// biome-ignore lint/suspicious/noExplicitAny: cross-generic instrument array
-const instruments: any[] = [testInstrument];
-
 function renderLab(probe?: (state: DropState) => void) {
   return render(
-    <Lab instruments={instruments} defaultInstrument="TestDrop">
+    <Lab instruments={[testInstrument]} defaultInstrument="TestDrop">
       {probe ? <StateProbe onState={probe} /> : null}
     </Lab>,
   );
@@ -54,7 +51,7 @@ function renderLab(probe?: (state: DropState) => void) {
 
 beforeEach(() => {
   HTMLElement.prototype.getBoundingClientRect = function () {
-    if (this.classList.contains('lk-workspace__canvas-host')) {
+    if (this.classList.contains('lk-trial__canvas-host')) {
       return {
         x: 100,
         y: 100,

package/src/index.test.ts

@@ -0,0 +1,52 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { describe, expect, it } from 'vitest';
+import * as labkit from './index';
+
+/** The barrels the public surface is assembled from. Type-only exports are
+ *  erased at runtime, so the names are read out of the source rather than off
+ *  the module object. */
+const BARRELS = ['./index.ts', './lab/index.ts', './trial/index.ts', './state/index.ts'];
+
+function exportedNames(): string[] {
+  const names: string[] = [];
+  for (const barrel of BARRELS) {
+    const src = readFileSync(fileURLToPath(new URL(barrel, import.meta.url)), 'utf8');
+    for (const [, body] of src.matchAll(/export\s+(?:type\s+)?\{([^}]*)\}/g)) {
+      for (const clause of body.split(',')) {
+        const name = clause
+          .trim()
+          .split(/\s+as\s+/)
+          .pop()
+          ?.replace(/^type\s+/, '')
+          .trim();
+        if (name) names.push(name);
+      }
+    }
+  }
+  return names;
+}
+
+describe('public export surface', () => {
+  it('names the grid, not a tile, when it says Workspace', () => {
+    const offenders = exportedNames().filter(
+      (n) => n.startsWith('Workspace') && n !== 'Workspace' && n !== 'WorkspaceProps',
+    );
+    expect(offenders).toEqual([]);
+  });
+
+  it('exports no Experiment symbol that means anything per-tile', () => {
+    const offenders = exportedNames().filter(
+      (n) => n.includes('Experiment') && !n.startsWith('SingletonExperiment'),
+    );
+    expect(offenders).toEqual([]);
+  });
+
+  it('exports the tile as Trial and the area it sits in as Workspace', () => {
+    expect(labkit).toHaveProperty('Trial');
+    expect(labkit).toHaveProperty('TrialChrome');
+    expect(labkit).toHaveProperty('Workspace');
+    expect(labkit).toHaveProperty('useTrialState');
+    expect(labkit).toHaveProperty('useTrialId');
+  });
+});

package/src/index.ts

@@ -23,6 +23,7 @@ export type {
   DragFeedback,
   HitResult,
   Instrument,
+  InstrumentList,
   LayerCapability,
   LayerDescriptor,
   PaletteItem,
@@ -48,25 +49,28 @@ export {
 export {
   LabStoreContext,
   LabStoreProvider,
+  TrialIdContext,
+  TrialIdProvider,
   useLabStore,
-  useWorkspaceId,
-  WorkspaceIdContext,
-  WorkspaceIdProvider,
+  useTrialId,
 } from './state/context';
+export { CURRENT_DOCUMENT_VERSION, labDocumentKey, quarantineKey } from './state/document';
 export type {
   CreateLabStoreOptions,
-  ExperimentStateHandle,
+  LabDocument,
   LabMode,
   LabStoreState,
   SavedSnapshot,
+  SerializedTrial,
   StorageAdapter,
+  TrialRecord,
+  TrialStateHandle,
   UndoStack,
-  WorkspaceRecord,
 } from './state/types';
-export { useExperimentState } from './state/useExperimentState';
+export { useTrialState } from './state/useTrialState';
 export { interstellarTheme } from './theme/interstellar';
+export * from './trial';
 export * from './ui/layers';
 export * from './ui/properties';
 export type { EventBus, EventListener } from './undo';
 export { clearUndo, createEventBus, emptyStack, pushSnapshot, redo, undo } from './undo';
-export * from './workspace';

package/src/instrument/SineWave.smoke.test.tsx

@@ -85,7 +85,7 @@ describe('SineWave instrument smoke test', () => {
       config: SineWaveInstrument.defaultConfig(),
       setState: vi.fn(),
       setConfig: vi.fn(),
-      workspace: { id: 'w', zoom: 1, setZoom: vi.fn() },
+      trial: { id: 'w', zoom: 1, setZoom: vi.fn() },
       emit: vi.fn(),
     };
     const { container } = render(SineWaveInstrument.render(ctx) as ReactElement);

package/src/instrument/capabilityDetector.ts

@@ -1,6 +1,6 @@
 import type { Instrument } from './types';
 
-/** Which optional capabilities an instrument declared — what the workspace
+/** Which optional capabilities an instrument declared — what the trial
  *  consults to decide which chrome to show. */
 export interface CapabilityFlags {
   hasCanvas: boolean;

package/src/instrument/types.ts

@@ -2,13 +2,13 @@ import type { ReactNode } from 'react';
 import type { ConfigField } from '../controls/types';
 
 /** What an instrument's `render` is handed: its state and config, the setters
- *  for both, the workspace it is mounted in, and a way to emit named events. */
+ *  for both, the trial it is mounted in, and a way to emit named events. */
 export interface RenderContext<TS = unknown, TC = unknown> {
   state: TS;
   config: TC;
   setState: (next: TS | ((prev: TS) => TS)) => void;
   setConfig: (key: keyof TC, value: unknown) => void;
-  workspace: {
+  trial: {
     id: string;
     zoom: number;
     setZoom: (z: number) => void;
@@ -16,7 +16,11 @@ export interface RenderContext<TS = unknown, TC = unknown> {
   emit: (event: string) => void;
 }
 
-/** One 2D canvas layer of an instrument, drawn in declaration order. */
+/** One 2D canvas layer of an instrument, drawn in declaration order.
+ *
+ *  `draw` is called with the camera already applied, so it works in world
+ *  coordinates. `zoom` is passed for the things that must not scale with it —
+ *  set `ctx.lineWidth = 1 / zoom` to keep a hairline hairline. */
 export interface CanvasLayer<TS = unknown, TC = unknown> {
   id: string;
   draw: (ctx: CanvasRenderingContext2D, args: { state: TS; config: TC; zoom: number }) => void;
@@ -29,7 +33,7 @@ export interface CanvasCapability<TS = unknown, TC = unknown> {
   initialView?: { zoom: number; pan: { x: number; y: number } };
 }
 
-/** Declares which of an instrument's layers the workspace should offer
+/** Declares which of an instrument's layers the trial should offer
  *  show/hide controls for. */
 export interface LayerCapability {
   ids: string[];
@@ -59,7 +63,7 @@ export type SystemEvent = string;
 export type Point = { x: number; y: number };
 /** What a hit-test found, and where. */
 export type HitResult = { hit: boolean; layerId?: string; pointId?: string };
-/** A workspace's camera. */
+/** A trial's camera. */
 export type ViewTransform = { zoom: number; pan: Point };
 /** A layer as the layer list shows it. `alwaysOn` layers cannot be hidden. */
 export type LayerDescriptor = { id: string; label: string; alwaysOn?: boolean };
@@ -76,13 +80,15 @@ export type DragFeedback = { ok: boolean; reason?: string };
  * and `state`, what the experiment is currently doing — and renders from both.
  * The optional capability fields declare what else it wants from the runtime:
  * a canvas, a layer list, palette drag-and-drop, undo. Declaring a capability
- * is what makes the workspace provide the corresponding chrome.
+ * is what makes the trial provide the corresponding chrome.
  */
 export interface Instrument<TS = unknown, TC = unknown> {
   name: string;
   defaultConfig: () => TC;
   initialState: (config: TC) => TS;
   configSchema?: () => ConfigField[];
+  /** The instrument's DOM. With `canvas`, this renders as an overlay above the
+   *  layers rather than instead of them; return `null` for canvas only. */
   render: (ctx: RenderContext<TS, TC>) => ReactNode;
   onConfigChange?: (config: TC, prev: TC, state: TS) => TS;
   serialize?: (state: TS) => unknown;
@@ -92,3 +98,9 @@ export interface Instrument<TS = unknown, TC = unknown> {
   dragDrop?: DragDropCapability<TS, TC>;
   undo?: UndoCapability;
 }
+
+/** Instruments as a lab receives them. `any` rather than `unknown` because
+ *  parameter contravariance keeps a `defineInstrument<TS, TC>` result out of
+ *  an `Instrument<unknown, unknown>[]`; it is contained to this alias. */
+// biome-ignore lint/suspicious/noExplicitAny: see above
+export type InstrumentList = readonly Instrument<any, any>[];

package/src/lab/Lab.less

@@ -1,3 +1,19 @@
+// `height: 100%` resolves against the containing block, so the lab needs an
+// unbroken chain of sized ancestors — and a host that supplies the height but
+// not the margin reset gets a page 16px taller than the viewport, which reads
+// as a stuck canvas rather than as overflow. Scoped with `:has` so a page that
+// mounts no lab is untouched, and stopping at the lab's own parent so an
+// embedded lab cannot resize its host's layout.
+html:has(.lk-lab),
+body:has(.lk-lab) {
+  margin: 0;
+  height: 100%;
+}
+
+body:has(.lk-lab) > :has(> .lk-lab) {
+  height: 100%;
+}
+
 .lk-lab {
   height: 100%;
 }

package/src/lab/Lab.stories.tsx

@@ -31,21 +31,21 @@ export const Default: Story = {
   },
 };
 
-function AddSecondWorkspace() {
+function AddSecondTrial() {
   const ctx = useLabContext();
   // biome-ignore lint/correctness/useExhaustiveDependencies: run once on mount
   useEffect(() => {
-    if (ctx.workspaces.length < 2) ctx.addWorkspace('Stub');
+    if (ctx.trials.length < 2) ctx.addTrial('Stub');
   }, []);
   return null;
 }
 
-export const TwoWorkspaces: Story = {
+export const TwoTrials: Story = {
   args: {
     instruments: [StubInstrument],
     defaultInstrument: 'Stub',
-    title: 'Two Workspaces',
+    title: 'Two Trials',
     storage: null,
-    children: <AddSecondWorkspace />,
+    children: <AddSecondTrial />,
   },
 };