@weasel-js/labkit 1.0.4 → 1.2.0

package/src/{workspace/Workspace.stories.tsx → trial/Trial.stories.tsx}

@@ -4,8 +4,9 @@ import { LabContext, type LabContextValue } from '../lab/LabContext';
 import { noneAdapter } from '../state/adapters';
 import { LabStoreContext } from '../state/context';
 import { createLabStore } from '../state/store';
-import type { WorkspaceRecord } from '../state/types';
-import { WorkspaceChrome } from './WorkspaceChrome';
+import type { TrialRecord } from '../state/types';
+import { DEFAULT_VIEW } from '../state/view';
+import { TrialChrome } from './TrialChrome';
 
 const noop = () => {};
 
@@ -16,7 +17,7 @@ const stub: Instrument = {
   render: () => <div className="lk-stub-display">stub experiment area</div>,
 };
 
-const record: WorkspaceRecord = {
+const record: TrialRecord = {
   id: 'ws-demo',
   instrumentName: 'Stub',
   config: {},
@@ -29,12 +30,12 @@ function Harness() {
   const store = createLabStore({ storageKey: 'sb', storage: noneAdapter });
   const lab: LabContextValue = {
     instruments: [stub],
-    workspaces: [record],
-    addWorkspace: noop,
-    cloneWorkspace: noop,
-    closeWorkspace: noop,
-    resetWorkspace: noop,
-    reorderWorkspaces: noop,
+    trials: [record],
+    addTrial: noop,
+    cloneTrial: noop,
+    closeTrial: noop,
+    resetTrial: noop,
+    reorderTrials: noop,
     savedSnapshots: [],
     saveSnapshot: noop,
     loadSnapshot: noop,
@@ -46,21 +47,22 @@ function Harness() {
     <LabStoreContext.Provider value={{ store }}>
       <LabContext.Provider value={lab}>
         <div style={{ height: '500px' }}>
-          <WorkspaceChrome
-            workspaceId="ws-demo"
-            record={record}
-            instrument={stub}
-            isLastWorkspace={true}
-          >
+          <TrialChrome trialId="ws-demo" record={record} instrument={stub} isLastTrial={true}>
             {stub.render({
               state: {},
               config: {},
               setState: () => {},
               setConfig: () => {},
-              workspace: { id: 'ws-demo', zoom: 1, setZoom: () => {} },
+              trial: {
+                id: 'ws-demo',
+                view: DEFAULT_VIEW,
+                setView: () => {},
+                zoom: 1,
+                setZoom: () => {},
+              },
               emit: () => {},
             })}
-          </WorkspaceChrome>
+          </TrialChrome>
         </div>
       </LabContext.Provider>
     </LabStoreContext.Provider>
@@ -68,7 +70,7 @@ function Harness() {
 }
 
 const meta: Meta<typeof Harness> = {
-  title: 'labkit/Workspace/Workspace',
+  title: 'labkit/Trial/Trial',
   component: Harness,
   parameters: { layout: 'fullscreen' },
 };

package/src/{workspace/Workspace.test.tsx → trial/Trial.test.tsx}

@@ -6,14 +6,14 @@ import { Lab } from '../lab/Lab';
 import { LabContext, type LabContextValue } from '../lab/LabContext';
 import { LabStoreContext } from '../state/context';
 import { createLabStore } from '../state/store';
-import type { WorkspaceRecord } from '../state/types';
+import type { TrialRecord } from '../state/types';
 import { DefaultToolbar } from './DefaultToolbar';
-import type { WorkspaceToolbarContext } from './slotTypes';
-import { WorkspaceChrome } from './WorkspaceChrome';
+import type { TrialToolbarContext } from './slotTypes';
+import { TrialChrome } from './TrialChrome';
 
-function makeCtx(overrides: Partial<WorkspaceToolbarContext> = {}): WorkspaceToolbarContext {
+function makeCtx(overrides: Partial<TrialToolbarContext> = {}): TrialToolbarContext {
   return {
-    workspaceId: 'ws-1',
+    trialId: 'ws-1',
     instrumentName: 'Stub',
     hasUndo: false,
     canUndo: false,
@@ -32,7 +32,7 @@ function makeCtx(overrides: Partial<WorkspaceToolbarContext> = {}): WorkspaceToo
     clone: vi.fn(),
     reset: vi.fn(),
     close: vi.fn(),
-    isLastWorkspace: false,
+    isLastTrial: false,
     ...overrides,
   };
 }
@@ -43,8 +43,8 @@ describe('<DefaultToolbar>', () => {
     expect(screen.getByRole('button', { name: /close/i })).toBeInTheDocument();
   });
 
-  it('disables close when isLastWorkspace is true', () => {
-    render(<DefaultToolbar ctx={makeCtx({ isLastWorkspace: true })} />);
+  it('disables close when isLastTrial is true', () => {
+    render(<DefaultToolbar ctx={makeCtx({ isLastTrial: true })} />);
     expect(screen.getByRole('button', { name: /close/i })).toBeDisabled();
   });
 
@@ -79,7 +79,7 @@ describe('<DefaultToolbar>', () => {
         {
           id: 's1',
           name: 'First',
-          workspaceId: 'ws-1',
+          trialId: 'ws-1',
           instrumentName: 'Stub',
           config: {},
           state: {},
@@ -99,7 +99,7 @@ const stubInstrument: Instrument = {
   render: () => null,
 };
 
-const stubRecord: WorkspaceRecord = {
+const stubRecord: TrialRecord = {
   id: 'ws-1',
   instrumentName: 'Stub',
   config: {},
@@ -108,7 +108,7 @@ const stubRecord: WorkspaceRecord = {
   undoStack: { past: [], future: [] },
 };
 
-type ChromeProps = Parameters<typeof WorkspaceChrome>[0];
+type ChromeProps = Parameters<typeof TrialChrome>[0];
 
 function ChromeHarness({
   children,
@@ -121,12 +121,12 @@ function ChromeHarness({
   });
   const labCtx: LabContextValue = {
     instruments: [stubInstrument],
-    workspaces: [stubRecord],
-    addWorkspace: vi.fn(),
-    cloneWorkspace: vi.fn(),
-    closeWorkspace: vi.fn(),
-    resetWorkspace: vi.fn(),
-    reorderWorkspaces: vi.fn(),
+    trials: [stubRecord],
+    addTrial: vi.fn(),
+    cloneTrial: vi.fn(),
+    closeTrial: vi.fn(),
+    resetTrial: vi.fn(),
+    reorderTrials: vi.fn(),
     savedSnapshots: [],
     saveSnapshot: vi.fn(),
     loadSnapshot: vi.fn(),
@@ -138,21 +138,21 @@ function ChromeHarness({
   return (
     <LabStoreContext.Provider value={{ store }}>
       <LabContext.Provider value={labCtx}>
-        <WorkspaceChrome
-          workspaceId="ws-1"
+        <TrialChrome
+          trialId="ws-1"
           record={stubRecord}
           instrument={stubInstrument}
-          isLastWorkspace={false}
+          isLastTrial={false}
           {...props}
         >
           {children ?? <div data-testid="content">content</div>}
-        </WorkspaceChrome>
+        </TrialChrome>
       </LabContext.Provider>
     </LabStoreContext.Provider>
   );
 }
 
-describe('<WorkspaceChrome>', () => {
+describe('<TrialChrome>', () => {
   it('renders children in the content area', () => {
     render(<ChromeHarness />);
     expect(screen.getByTestId('content')).toBeInTheDocument();
@@ -172,16 +172,16 @@ describe('<WorkspaceChrome>', () => {
   it('Cmd+S triggers saveSnapshot', () => {
     const saveSnapshot = vi.fn();
     render(<ChromeHarness labOverrides={{ saveSnapshot }} />);
-    const region = screen.getByRole('region', { name: /workspace/i });
+    const region = screen.getByRole('region', { name: /trial/i });
     fireEvent.keyDown(region, { key: 's', metaKey: true });
     expect(saveSnapshot).toHaveBeenCalledWith('ws-1', undefined);
   });
 });
 
-describe('<Lab> + WorkspaceChrome integration', () => {
-  it('Lab provides context for nested WorkspaceChrome', () => {
+describe('<Lab> + TrialChrome integration', () => {
+  it('Lab provides context for nested TrialChrome', () => {
     render(<Lab instruments={[stubInstrument]} defaultInstrument="Stub" />);
-    // Lab seeds a workspace; no chrome rendered without children — sanity check Lab mounts.
+    // Lab seeds a trial; no chrome rendered without children — sanity check Lab mounts.
     expect(document.querySelector('.lk-lab')).toBeTruthy();
   });
 });

package/src/{workspace/Workspace.tsx → trial/Trial.tsx}

@@ -9,64 +9,63 @@ import type {
   LayerDescriptor,
   PaletteItem,
   RenderContext,
-  ViewTransform,
 } from '../instrument/types';
+import { useJob } from '../job/useJob';
 import { useLabContext } from '../lab/LabContext';
 import { LayerList } from '../layers/LayerList';
 import { LabStoreContext } from '../state/context';
 import type { LabStore } from '../state/store';
-import type { WorkspaceRecord } from '../state/types';
+import type { TrialRecord } from '../state/types';
+import { as2DView, DEFAULT_VIEW } from '../state/view';
 import { createEventBus, type EventBus } from '../undo/eventBus';
 import { pushSnapshot, redo as undoRedo, undo as undoUndo } from '../undo/undoStack';
-import type { UndoBindings } from './WorkspaceChrome';
-import { WorkspaceChrome } from './WorkspaceChrome';
+import type { UndoBindings } from './TrialChrome';
+import { TrialChrome } from './TrialChrome';
 
-/** Props for `<Workspace>`. */
-export interface WorkspaceProps {
+/** Props for `<Trial>`. */
+export interface TrialProps {
   id: string;
 }
 
-/** Renders one workspace from the lab store: looks up its record and
- *  instrument, and mounts the instrument inside the workspace chrome. */
-export function Workspace({ id }: WorkspaceProps) {
+/** Renders one trial from the lab store: looks up its record and
+ *  instrument, and mounts the instrument inside the trial chrome. */
+export function Trial({ id }: TrialProps) {
   const lab = useLabContext();
   const storeCtx = useContext(LabStoreContext);
-  if (!storeCtx) throw new Error('[labkit] <Workspace> requires <LabStoreProvider>');
-  const record = useStore(storeCtx.store, (s) => s.workspaces.find((w) => w.id === id));
+  if (!storeCtx) throw new Error('[labkit] <Trial> requires <LabStoreProvider>');
+  const record = useStore(storeCtx.store, (s) => s.trials.find((w) => w.id === id));
   if (!record) {
-    return <div className="lk-workspace lk-workspace--unknown">Workspace not found: {id}</div>;
+    return <div className="lk-trial lk-trial--unknown">Trial not found: {id}</div>;
   }
   const instrument = lab.instruments.find((i) => i.name === record.instrumentName);
   if (!instrument) {
     return (
-      <div className="lk-workspace lk-workspace--unknown">
-        Unknown instrument: {record.instrumentName}
-      </div>
+      <div className="lk-trial lk-trial--unknown">Unknown instrument: {record.instrumentName}</div>
     );
   }
   return (
-    <WorkspaceRuntime
+    <TrialRuntime
       record={record}
       instrument={instrument}
       store={storeCtx.store}
-      isLast={lab.workspaces.length <= 1}
+      isLast={lab.trials.length <= 1}
     />
   );
 }
 
-interface WorkspaceRuntimeProps {
-  record: WorkspaceRecord;
+interface TrialRuntimeProps {
+  record: TrialRecord;
   instrument: Instrument;
   store: LabStore;
   isLast: boolean;
 }
 
-function WorkspaceRuntime({ record, instrument, store, isLast }: WorkspaceRuntimeProps) {
+function TrialRuntime({ record, instrument, store, isLast }: TrialRuntimeProps) {
   const canvasContainerRef = useRef<HTMLDivElement | null>(null);
-  const updateWorkspaceState = useStore(store, (s) => s.updateWorkspaceState);
-  const updateWorkspaceConfig = useStore(store, (s) => s.updateWorkspaceConfig);
-  const updateWorkspaceView = useStore(store, (s) => s.updateWorkspaceView);
-  const updateWorkspaceUndoStack = useStore(store, (s) => s.updateWorkspaceUndoStack);
+  const updateTrialState = useStore(store, (s) => s.updateTrialState);
+  const updateTrialConfig = useStore(store, (s) => s.updateTrialConfig);
+  const updateTrialView = useStore(store, (s) => s.updateTrialView);
+  const updateTrialUndoStack = useStore(store, (s) => s.updateTrialUndoStack);
 
   const busRef = useRef<EventBus | null>(null);
   if (busRef.current === null) busRef.current = createEventBus();
@@ -81,39 +80,59 @@ function WorkspaceRuntime({ record, instrument, store, isLast }: WorkspaceRuntim
 
   const snapshotIfNeeded = (event: string): void => {
     if (!undoCap || !undoEvents.has(event)) return;
-    const current = store.getState().workspaces.find((w) => w.id === record.id);
+    const current = store.getState().trials.find((w) => w.id === record.id);
     if (!current) return;
     const snap = structuredClone(current.state);
-    updateWorkspaceUndoStack(record.id, (prev) => pushSnapshot(prev, snap, maxDepth));
+    updateTrialUndoStack(record.id, (prev) => pushSnapshot(prev, snap, maxDepth));
   };
 
-  const setView = (v: ViewTransform): void => updateWorkspaceView(record.id, v);
+  const setView = (v: unknown): void => updateTrialView(record.id, v);
+
+  // `CanvasStack` and the zoom controls are 2D; a trial holding another view shape
+  // gets the default here and simply never renders them.
+  const view2d = as2DView(record.view);
+
+  const jobCap = instrument.job;
+  // Hooks cannot be conditional, so a trial without the capability still calls
+  // this — with a runner that yields nothing and is never started.
+  const job = useJob({
+    capability: jobCap ?? { run: async function* () {}, onItem: (_i, st) => st },
+    config: record.config,
+    state: record.state,
+    setState: (next) => updateTrialState(record.id, next as never),
+  });
 
   const renderCtx: RenderContext<unknown, unknown> = {
     state: record.state,
     config: record.config,
     setState: (next) => {
       snapshotIfNeeded('state.change');
-      updateWorkspaceState(record.id, next);
+      updateTrialState(record.id, next);
       bus.emit('state.change');
     },
     setConfig: (key, value) => {
       const evt = `config.change:${String(key)}`;
       snapshotIfNeeded('config.change');
       snapshotIfNeeded(evt);
-      updateWorkspaceConfig(record.id, key as never, value as never);
+      updateTrialConfig(record.id, key as never, value as never);
       bus.emit('config.change');
       bus.emit(evt);
     },
-    workspace: {
+    trial: {
       id: record.id,
-      zoom: record.view.zoom,
-      setZoom: (z) => updateWorkspaceView(record.id, { ...record.view, zoom: z }),
+      view: record.view,
+      setView,
+      zoom: view2d?.zoom ?? 1,
+      setZoom: (z) => {
+        if (!view2d) return;
+        updateTrialView(record.id, { ...view2d, zoom: z });
+      },
     },
     emit: (event) => {
       snapshotIfNeeded(event);
       bus.emit(event);
     },
+    job: jobCap ? job : undefined,
   };
 
   const undoBindings: UndoBindings | undefined = undoCap
@@ -123,14 +142,14 @@ function WorkspaceRuntime({ record, instrument, store, isLast }: WorkspaceRuntim
         undo: () => {
           const result = undoUndo(record.undoStack, structuredClone(record.state));
           if (!result) return;
-          updateWorkspaceState(record.id, result.snapshot as never);
-          updateWorkspaceUndoStack(record.id, result.stack);
+          updateTrialState(record.id, result.snapshot as never);
+          updateTrialUndoStack(record.id, result.stack);
         },
         redo: () => {
           const result = undoRedo(record.undoStack, structuredClone(record.state));
           if (!result) return;
-          updateWorkspaceState(record.id, result.snapshot as never);
-          updateWorkspaceUndoStack(record.id, result.stack);
+          updateTrialState(record.id, result.snapshot as never);
+          updateTrialUndoStack(record.id, result.stack);
         },
       }
     : undefined;
@@ -144,8 +163,13 @@ function WorkspaceRuntime({ record, instrument, store, isLast }: WorkspaceRuntim
     return ordered.map((layer) => ({
       id: layer.id,
       visible: layerVisibility[layer.id] !== false,
-      render: (ctx, view) =>
-        layer.draw(ctx, { state: record.state, config: record.config, zoom: view.zoom }),
+      render: (ctx, view) => {
+        // Camera applied here, so a layer draws in world coordinates. `zoom`
+        // stays in the args for line widths, which must not scale with it.
+        ctx.translate(view.pan.x, view.pan.y);
+        ctx.scale(view.zoom, view.zoom);
+        layer.draw(ctx, { state: record.state, config: record.config, zoom: view.zoom });
+      },
     }));
   }, [instrument.canvas, record.state, record.config, layerVisibility, layerOrder]);
 
@@ -157,12 +181,12 @@ function WorkspaceRuntime({ record, instrument, store, isLast }: WorkspaceRuntim
   const dragDropResult = useDragDrop({
     capability: instrument.dragDrop ?? { palette: [], onDrop: (_p, _i, s) => s },
     canvasContainerRef,
-    view: record.view,
+    view: view2d ?? DEFAULT_VIEW,
     state: record.state,
     config: record.config,
     setState: (next) => {
       snapshotIfNeeded('canvas.itemAdded');
-      updateWorkspaceState(record.id, next as never);
+      updateTrialState(record.id, next as never);
     },
     emit: (evt) => {
       snapshotIfNeeded(evt);
@@ -206,10 +230,16 @@ function WorkspaceRuntime({ record, instrument, store, isLast }: WorkspaceRuntim
     body = (
       <div
         ref={canvasContainerRef}
-        className="lk-workspace__canvas-host"
+        className="lk-trial__canvas-host"
         style={{ width: '100%', height: '100%', position: 'relative' }}
       >
-        <CanvasStack layers={layersWithFeedback} view={record.view} onViewChange={setView} />
+        <CanvasStack
+          layers={layersWithFeedback}
+          view={view2d ?? DEFAULT_VIEW}
+          onViewChange={setView}
+        >
+          {instrument.render(renderCtx)}
+        </CanvasStack>
         <DragOverlay drag={dragDropResult.drag} />
       </div>
     );
@@ -239,11 +269,12 @@ function WorkspaceRuntime({ record, instrument, store, isLast }: WorkspaceRuntim
     ) : null;
 
   return (
-    <WorkspaceChrome
-      workspaceId={record.id}
+    <TrialChrome
+      job={jobCap ? job : undefined}
+      trialId={record.id}
       record={record}
       instrument={instrument}
-      isLastWorkspace={isLast}
+      isLastTrial={isLast}
       undoBindings={undoBindings}
       sidebarExtras={
         <>
@@ -253,6 +284,6 @@ function WorkspaceRuntime({ record, instrument, store, isLast }: WorkspaceRuntim
       }
     >
       {body}
-    </WorkspaceChrome>
+    </TrialChrome>
   );
 }

package/src/{workspace/WorkspaceChrome.tsx → trial/TrialChrome.tsx}

@@ -1,9 +1,11 @@
 import { type KeyboardEvent, type ReactNode, useContext, useMemo } from 'react';
 import { useStore } from 'zustand/react';
 import type { Instrument } from '../instrument/types';
+import type { JobHandle } from '../job/types';
 import { useLabContext } from '../lab/LabContext';
 import { LabStoreContext } from '../state/context';
-import type { WorkspaceRecord } from '../state/types';
+import type { TrialRecord } from '../state/types';
+import { as2DView } from '../state/view';
 import { DefaultSidebar } from './DefaultSidebar';
 import { DefaultStatusBar } from './DefaultStatusBar';
 import { DefaultToolbar } from './DefaultToolbar';
@@ -11,9 +13,9 @@ import type {
   SidebarSlot,
   StatusBarSlot,
   ToolbarSlot,
-  WorkspaceSidebarContext,
-  WorkspaceStatusBarContext,
-  WorkspaceToolbarContext,
+  TrialSidebarContext,
+  TrialStatusBarContext,
+  TrialToolbarContext,
 } from './slotTypes';
 
 export interface UndoBindings {
@@ -23,16 +25,18 @@ export interface UndoBindings {
   redo: () => void;
 }
 
-/** Props for `<WorkspaceChrome>`. */
-export interface WorkspaceChromeProps {
-  workspaceId: string;
-  record: WorkspaceRecord;
+/** Props for `<TrialChrome>`. */
+export interface TrialChromeProps {
+  trialId: string;
+  record: TrialRecord;
   instrument: Instrument;
-  isLastWorkspace: boolean;
+  isLastTrial: boolean;
   toolbar?: ToolbarSlot;
   sidebar?: SidebarSlot;
   statusBar?: StatusBarSlot;
   undoBindings?: UndoBindings;
+  /** Supplied when the instrument declares a `job`. */
+  job?: JobHandle;
   sidebarExtras?: ReactNode;
   children: ReactNode;
 }
@@ -40,56 +44,62 @@ export interface WorkspaceChromeProps {
 /** The frame around a running instrument — toolbar, sidebar, status bar —
  *  each replaceable by a slot. Assembles the slot contexts and wires the undo
  *  keyboard shortcuts. */
-export function WorkspaceChrome({
-  workspaceId,
+export function TrialChrome({
+  trialId,
   record,
   instrument,
-  isLastWorkspace,
+  isLastTrial,
   toolbar,
   sidebar,
   statusBar,
   undoBindings,
+  job,
   sidebarExtras,
   children,
-}: WorkspaceChromeProps) {
+}: TrialChromeProps) {
   const lab = useLabContext();
   const storeCtx = useContext(LabStoreContext);
-  if (!storeCtx) throw new Error('[labkit] WorkspaceChrome requires <LabStoreProvider>');
-  const updateWorkspaceView = useStore(storeCtx.store, (s) => s.updateWorkspaceView);
-  const updateWorkspaceConfig = useStore(storeCtx.store, (s) => s.updateWorkspaceConfig);
-  const updateWorkspaceState = useStore(storeCtx.store, (s) => s.updateWorkspaceState);
+  if (!storeCtx) throw new Error('[labkit] TrialChrome requires <LabStoreProvider>');
+  const updateTrialView = useStore(storeCtx.store, (s) => s.updateTrialView);
+  const updateTrialConfig = useStore(storeCtx.store, (s) => s.updateTrialConfig);
+  const updateTrialState = useStore(storeCtx.store, (s) => s.updateTrialState);
 
-  const toolbarCtx = useMemo<WorkspaceToolbarContext>(() => {
+  // The trial view is opaque to labkit, so the zoom chrome asks for the 2D shape
+  // and goes inert when the trial holds something else — an orbit, say.
+  const view2d = as2DView(record.view);
+
+  const toolbarCtx = useMemo<TrialToolbarContext>(() => {
     const setZoom = (z: number): void => {
-      updateWorkspaceView(workspaceId, { ...record.view, zoom: z });
+      if (!view2d) return;
+      updateTrialView(trialId, { ...view2d, zoom: z });
     };
     return {
-      workspaceId,
+      trialId,
       instrumentName: record.instrumentName,
       hasUndo: instrument.undo != null,
       canUndo: undoBindings?.canUndo ?? false,
       canRedo: undoBindings?.canRedo ?? false,
       undo: undoBindings?.undo ?? (() => {}),
       redo: undoBindings?.redo ?? (() => {}),
-      zoom: record.view.zoom,
+      zoom: view2d?.zoom ?? 1,
       setZoom,
-      zoomIn: () => setZoom(record.view.zoom * 1.25),
-      zoomOut: () => setZoom(record.view.zoom * 0.8),
+      zoomIn: () => setZoom((view2d?.zoom ?? 1) * 1.25),
+      zoomOut: () => setZoom((view2d?.zoom ?? 1) * 0.8),
       resetZoom: () => setZoom(1),
       hasCanvas: instrument.canvas != null,
-      savedSnapshots: lab.savedSnapshots.filter((s) => s.workspaceId === workspaceId),
-      saveSnapshot: (name) => lab.saveSnapshot(workspaceId, name),
-      loadSnapshot: (snapshotId) => lab.loadSnapshot(workspaceId, snapshotId),
-      clone: () => lab.cloneWorkspace(workspaceId),
-      reset: () => lab.resetWorkspace(workspaceId),
-      close: () => lab.closeWorkspace(workspaceId),
-      isLastWorkspace,
+      savedSnapshots: lab.savedSnapshots.filter((s) => s.trialId === trialId),
+      saveSnapshot: (name) => lab.saveSnapshot(trialId, name),
+      loadSnapshot: (snapshotId) => lab.loadSnapshot(trialId, snapshotId),
+      clone: () => lab.cloneTrial(trialId),
+      reset: () => lab.resetTrial(trialId),
+      close: () => lab.closeTrial(trialId),
+      isLastTrial,
     };
-  }, [workspaceId, record, instrument, lab, isLastWorkspace, updateWorkspaceView, undoBindings]);
+  }, [trialId, record, instrument, lab, isLastTrial, updateTrialView, undoBindings, view2d]);
 
-  const sidebarCtx = useMemo<WorkspaceSidebarContext>(
+  const sidebarCtx = useMemo<TrialSidebarContext>(
     () => ({
-      workspaceId,
+      trialId,
       instrumentName: record.instrumentName,
       configFields: instrument.configSchema?.() ?? [],
       config: record.config,
@@ -100,21 +110,21 @@ export function WorkspaceChrome({
             `[labkit] setConfig: unknown key "${key}" for instrument "${record.instrumentName}"`,
           );
         }
-        updateWorkspaceConfig(workspaceId, key as never, value as never);
+        updateTrialConfig(trialId, key as never, value as never);
         if (instrument.onConfigChange) {
           const nextConfig = { ...prevConfig, [key]: value };
           const nextState = instrument.onConfigChange(nextConfig, prevConfig, record.state);
-          updateWorkspaceState(workspaceId, nextState as never);
+          updateTrialState(trialId, nextState as never);
         }
       },
     }),
-    [workspaceId, record, instrument, updateWorkspaceConfig, updateWorkspaceState],
+    [trialId, record, instrument, updateTrialConfig, updateTrialState],
   );
 
-  const statusCtx: WorkspaceStatusBarContext = {
-    workspaceId,
+  const statusCtx: TrialStatusBarContext = {
+    trialId,
     instrumentName: record.instrumentName,
-    zoom: record.view.zoom,
+    zoom: view2d ? view2d.zoom : null,
   };
 
   const handleKeyDown = (e: KeyboardEvent<HTMLDivElement>): void => {
@@ -132,21 +142,38 @@ export function WorkspaceChrome({
 
   return (
     <section
-      className="lk-workspace"
-      aria-label={`Workspace ${record.instrumentName}`}
+      className="lk-trial"
+      aria-label={`Trial ${record.instrumentName}`}
       onKeyDown={handleKeyDown}
     >
-      <div className="lk-workspace__toolbar">
+      <div className="lk-trial__toolbar">
         {toolbar ? toolbar(toolbarCtx) : <DefaultToolbar ctx={toolbarCtx} />}
       </div>
-      <div className="lk-workspace__body">
-        <div className="lk-workspace__sidebar">
+      <div className="lk-trial__body">
+        <div className="lk-trial__sidebar">
           {sidebar ? sidebar(sidebarCtx) : <DefaultSidebar ctx={sidebarCtx} />}
           {sidebarExtras}
         </div>
-        <div className="lk-workspace__content">{children}</div>
+        <div className="lk-trial__content">{children}</div>
       </div>
-      <div className="lk-workspace__status">
+      <div className="lk-trial__status">
+        {job ? (
+          <div className="lk-trial__job">
+            <span className="lk-trial__job-count">
+              {job.done}
+              {job.total === null ? '' : ` / ${job.total}`}
+            </span>
+            {job.failures.length > 0 ? (
+              <span className="lk-trial__job-failures">{job.failures.length} failed</span>
+            ) : null}
+            {job.error ? <span className="lk-trial__job-error">{job.error}</span> : null}
+            {job.status === 'running' ? (
+              <button type="button" className="lk-trial__job-cancel" onClick={job.cancel}>
+                Cancel
+              </button>
+            ) : null}
+          </div>
+        ) : null}
         {statusBar ? statusBar(statusCtx) : <DefaultStatusBar ctx={statusCtx} />}
       </div>
     </section>