@weasel-js/labkit 1.4.4 → 1.5.1

package/dist/_dts/usePanZoom-Pzf9f2jh.d.ts

@@ -0,0 +1,160 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode, WheelEvent, PointerEvent as PointerEvent$1 } from 'react';
+import { k as ViewTransform, a as WorldSpec, V as ViewportSize, l as Point, W as WorldFrame } from './frac-B4okC2lX.js';
+import { C as CanvasLayerDescriptor } from './CanvasStackContext-CJNMS6mz.js';
+
+/** Props for `<CanvasStack>`. */
+interface CanvasStackProps {
+    layers: CanvasLayerDescriptor[];
+    view: ViewTransform;
+    onViewChange: (v: ViewTransform) => void;
+    /** The instrument's coordinate system. Omitted, world (0,0) sits at the
+     *  element's top-left with y running down. */
+    worldSpec?: WorldSpec;
+    minZoom?: number;
+    maxZoom?: number;
+    width?: number | string;
+    height?: number | string;
+    className?: string;
+    /** Fired whenever the stack is measured, so a consumer can place a view that
+     *  only makes sense in terms of the viewport. */
+    onResize?: (size: ViewportSize) => void;
+    onHitTest?: (worldPos: Point) => void;
+    children?: ReactNode;
+}
+/** Stacks one `<canvas>` per layer and drives them from a shared view, so a
+ *  layer that changes rarely is not redrawn with one that changes every frame.
+ *  Handles sizing, device pixel ratio, and pan/zoom. */
+declare function CanvasStack({ layers, view: viewProp, onViewChange, worldSpec, minZoom, maxZoom, width, height, className, onResize, onHitTest, children, }: CanvasStackProps): react_jsx_runtime.JSX.Element;
+
+/** Bounds and coordinate system a {@link zoomAt} works in. */
+interface ZoomAtOptions {
+    /** The instrument's coordinate system, resolved against the viewport.
+     *  Omitted, `at` is measured from the element's top-left. */
+    frame?: WorldFrame;
+    min?: number;
+    max?: number;
+}
+/**
+ * Zoom a view by `factor` about a fixed point, so whatever world coordinate
+ * `at` was over stays under it.
+ *
+ * `at` is in the element's own pixels — a cursor position, or the centre of a
+ * lens. The clamp is applied before the pan is solved, so a zoom that hits a
+ * bound still anchors on the zoom it actually reached.
+ */
+declare function zoomAt(view: ViewTransform, factor: number, at: Point, { frame, min, max }?: ZoomAtOptions): ViewTransform;
+/** The view that puts a world point at the centre of a `size` viewport, at
+ *  `zoom`. What a lens showing a region around one point renders through. */
+declare function centerOn(world: Point, zoom: number, size: ViewportSize, frame?: WorldFrame): ViewTransform;
+
+/** Project a world point into screen coordinates under a view.
+ *
+ *  `frame` is the instrument's declared coordinate system, resolved against the
+ *  viewport; omitting it gives labkit's original one — origin at the top-left,
+ *  y downward. */
+declare function worldToScreen(world: Point, view: ViewTransform, frame?: WorldFrame): Point;
+/** Unproject a screen point back to world coordinates under a view. */
+declare function screenToWorld(screen: Point, view: ViewTransform, frame?: WorldFrame): Point;
+
+/** Props for `<Stage>`. */
+interface StageProps {
+    /** The content's own size in CSS pixels, at zoom 1. */
+    size: ViewportSize;
+    view: ViewTransform;
+    onViewChange: (v: ViewTransform) => void;
+    minZoom?: number;
+    maxZoom?: number;
+    /** Fired whenever the stage's viewport is measured at a non-zero size. */
+    onResize?: (viewport: ViewportSize) => void;
+    /** Handed the viewport element, for a consumer tracking the pointer over it. */
+    hostRef?: {
+        current: HTMLDivElement | null;
+    };
+    /** Drawn over the content in viewport pixels, outside the camera. */
+    overlay?: ReactNode;
+    children?: ReactNode;
+}
+/**
+ * The camera a stage opens at: the content centered in its viewport, shrunk to
+ * fit if it has to be and never enlarged past its own size.
+ */
+declare function fitStage(size: ViewportSize, viewport: ViewportSize): ViewTransform;
+/**
+ * DOM content of a fixed size, panned and zoomed by a camera — what
+ * `<CanvasStack>` is for layers drawn to a canvas. The content is laid out at
+ * its own size and transformed, so everything inside keeps its layout and a
+ * measurement of any element in it reports where it is actually drawn.
+ */
+declare function Stage({ size, view: viewProp, onViewChange, minZoom, maxZoom, onResize, hostRef, overlay, children, }: StageProps): react_jsx_runtime.JSX.Element;
+
+/** A point in the space the instrument works in. */
+interface Vec3 {
+    x: number;
+    y: number;
+    z: number;
+}
+/** An orbit camera as a trial view: where it looks from, and what it looks at.
+ *  labkit does not turn this into a matrix — the host's renderer does. */
+interface OrbitView {
+    yaw: number;
+    pitch: number;
+    distance: number;
+    target: Vec3;
+}
+/** Just short of the pole. At exactly ±PI/2 the azimuth is undefined and the
+ *  camera rolls, which reads as the model jumping rather than as a limit. */
+declare const PITCH_LIMIT: number;
+declare function clampPitch(pitch: number): number;
+declare function wrapYaw(yaw: number): number;
+/** The view a drag of (dx, dy) from `start` produces. Absolute against the drag
+ *  start, so it can be re-applied any number of times without compounding. */
+declare function orbitAfterDrag(start: OrbitView, dx: number, dy: number): OrbitView;
+/** Multiplicative, so one notch covers the same proportion of the distance
+ *  whether the camera is near or far. */
+declare function orbitAfterWheel(view: OrbitView, deltaY: number, minDistance: number, maxDistance: number): OrbitView;
+interface UseOrbitOptions {
+    view: OrbitView;
+    onViewChange: (v: OrbitView) => void;
+    /** Restored on double-click. Defaults to the view the hook first saw. */
+    home?: OrbitView;
+    minDistance?: number;
+    maxDistance?: number;
+}
+interface OrbitHandlers {
+    onWheel: (e: WheelEvent<HTMLElement>) => void;
+    onPointerDown: (e: PointerEvent$1<HTMLElement>) => void;
+    onDoubleClick: () => void;
+    isDragging: () => boolean;
+}
+/** Pointer gestures over an orbit view: drag to turn, wheel or pinch to dolly,
+ *  double-click to go home. The 3D peer of `usePanZoom`. */
+declare function useOrbit({ view, onViewChange, home, minDistance, maxDistance, }: UseOrbitOptions): OrbitHandlers;
+
+interface UsePanZoomOptions {
+    view: ViewTransform;
+    onViewChange: (v: ViewTransform) => void;
+    /** The opening `view.zoom` always stays reachable, widening these past
+     *  whatever is passed here if it would otherwise exclude it. */
+    minZoom?: number;
+    maxZoom?: number;
+    /** The instrument's coordinate system, resolved against the viewport. The
+     *  wheel anchors in this frame; omitting it anchors at the element's
+     *  top-left, which is what labkit did before a frame could be declared. */
+    frame?: WorldFrame;
+    /** A primary-button press released without ever crossing the drag
+     *  threshold. The pointer session owns the release, so the gesture's end is
+     *  reported here rather than left for a consumer's own `onPointerUp`. */
+    onTap?: (e: PointerEvent) => void;
+}
+interface PanZoomHandlers {
+    /** Zoom about the pointer. `anchor` is the element the pointer position is
+     *  measured against, for an event whose `currentTarget` is some other box. */
+    onWheel: (e: WheelEvent<HTMLElement> | globalThis.WheelEvent, anchor?: Element) => void;
+    onPointerDown: (e: PointerEvent$1<HTMLElement>) => void;
+    isDragging: () => boolean;
+}
+declare function usePanZoom({ view, onViewChange, minZoom, maxZoom, frame, onTap, }: UsePanZoomOptions): PanZoomHandlers;
+
+export { CanvasStack as C, PITCH_LIMIT as P, Stage as S, centerOn as f, clampPitch as g, fitStage as h, orbitAfterWheel as i, usePanZoom as j, wrapYaw as k, orbitAfterDrag as o, screenToWorld as s, useOrbit as u, worldToScreen as w, zoomAt as z };
+export type { OrbitHandlers as O, UseOrbitOptions as U, Vec3 as V, ZoomAtOptions as Z, CanvasStackProps as a, OrbitView as b, PanZoomHandlers as c, StageProps as d, UsePanZoomOptions as e };

package/dist/_dts/useTrialState-uLlmaccn.d.ts

@@ -0,0 +1,212 @@
+import { c as StorageAdapter, d as LabStoreState, T as TrialRecord, e as SavedSnapshot, o as LabMode, h as UndockedPanel, q as InstrumentList, s as InstrumentHooks, C as CreateLabStoreOptions, g as TrialStateHandle } from './frac-B4okC2lX.js';
+import * as react from 'react';
+import { ReactNode, ReactElement, Dispatch, SetStateAction } from 'react';
+import { StoreApi } from 'zustand/vanilla';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+/** Persist to `localStorage`, one JSON value per record. Survives a reload and
+ *  reaches other tabs through the `storage` event. */
+declare const localStorageAdapter: StorageAdapter;
+/** Persist to `sessionStorage` — 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. Changes to the fragment made elsewhere — a pasted
+ *  link, back and forward — arrive through `hashchange`. */
+declare const urlHashAdapter: StorageAdapter;
+/** An in-memory store, discarded on reload. Values are copied in and out, as a
+ *  real substrate would. Adapters built over one shared `backing` hear each
+ *  other's writes — two tabs, for a test. */
+declare function createMemoryAdapter(backing?: Map<string, unknown>): StorageAdapter;
+/** Persists nothing and reads back nothing. */
+declare const noneAdapter: StorageAdapter;
+/** Options for `createIndexedDbAdapter`. */
+interface IndexedDbAdapterOptions {
+    /** Default `'labkit'`. */
+    database?: string;
+    /** Default `'records'`. One object store per database: a store added to a
+     *  database that already exists is not created. */
+    store?: string;
+}
+/** Persist to IndexedDB, which stores structured-clone values natively — typed
+ *  arrays, `Map`s, `Blob`s — and holds far more than localStorage. Other tabs
+ *  hear writes through a `BroadcastChannel`. The database opens on first use. */
+declare function createIndexedDbAdapter({ database, store, }?: IndexedDbAdapterOptions): StorageAdapter;
+/** IndexedDB under the default database and store. */
+declare const indexedDbAdapter: 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;
+    /** Replace the lab's instruments. Trials and saves of an instrument that is
+     *  new or a different object are brought up to date against it in the same
+     *  write; every other trial keeps its object. */
+    setInstruments: (instruments: InstrumentList) => void;
+    /** The per-instrument hooks in force now. Read them at use; never keep them. */
+    instrumentHooks: () => InstrumentHooks;
+}
+/** A lab's store: its state and its actions. How each instrument's state is
+ *  serialized comes in through `CreateLabStoreOptions.instruments`. */
+type LabStore = StoreApi<LabStoreState & LabStoreActions>;
+/** Build a lab store holding `initial`, or an empty lab. It knows nothing
+ *  about storage; `openLabStore` reads a stored lab and binds one of these to
+ *  it. */
+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 = 4;
+/** Where a version-3 lab kept its one document. Read once, to fold it into
+ *  records, then deleted. */
+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;
+
+/** One record changing, as a cache listener hears it. `value` is `undefined`
+ *  for a delete. `local` changes were made through this cache; `remote` ones
+ *  came from another writer. */
+interface RecordChange {
+    name: string;
+    value: unknown;
+    origin: 'local' | 'remote';
+}
+/**
+ * Every record under one prefix, held in memory: the only thing that talks to
+ * a `StorageAdapter`. Names are keys with the prefix removed.
+ *
+ * Writes land in memory at once and reach storage on a debounce. The newest
+ * write to a record wins: another writer's change to a record with a write
+ * still queued here is ignored, since the queued write lands after it.
+ */
+interface RecordCache {
+    readonly prefix: string;
+    /** False once writing is off — the records could not be read, or were
+     *  written by a newer labkit — so nothing here can overwrite them. */
+    readonly writable: boolean;
+    has(name: string): boolean;
+    get(name: string): unknown;
+    /** Every record whose name starts with `namePrefix`. */
+    entries(namePrefix?: string): [string, unknown][];
+    set(name: string, value: unknown): void;
+    delete(name: string): void;
+    subscribe(listener: (changes: RecordChange[]) => void): () => void;
+    /** Send queued writes now. */
+    flush(): Promise<void>;
+    /** Send queued writes and stop hearing other writers. */
+    close(): Promise<void>;
+}
+
+/** Options for `openLabStore`. `storageKey` names the lab, so two labs on one
+ *  origin keep separate records. */
+interface OpenLabStoreOptions extends Omit<CreateLabStoreOptions, 'initial'> {
+    storageKey: string;
+    storage: StorageAdapter;
+}
+/** A lab store bound to its records. */
+interface OpenedLabStore {
+    store: LabStore;
+    /** Every record of the lab, `usePersistedState` values included. */
+    records: RecordCache;
+    /** Send queued writes and stop hearing other writers. */
+    close(): Promise<void>;
+}
+/**
+ * Read a stored lab and return a store bound to it: every change to the store
+ * is written as the records it touched, and another writer's records are
+ * applied back into the store. A lab stored before records existed is folded
+ * forward on the way in.
+ */
+declare function openLabStore(options: OpenLabStoreOptions): Promise<OpenedLabStore>;
+
+/** Props for `<Persistence>`. */
+interface PersistenceProps {
+    /** Names the records, as `<Lab storageKey>` does. A lab and a
+     *  `<Persistence>` given the same key share lab-scoped values. */
+    storageKey: string;
+    /** Default: IndexedDB, or localStorage where IndexedDB will not open. */
+    storage?: StorageAdapter;
+    /** Rendered until the records have loaded. Default: nothing. */
+    fallback?: ReactNode;
+    children: ReactNode;
+}
+/** Persisted values for a page with no lab: `usePersistedState` below it keeps
+ *  what it holds across a reload. Both props are read once, at mount. */
+declare function Persistence({ storageKey, storage, fallback, children }: PersistenceProps): react_jsx_runtime.JSX.Element;
+
+/** Options for `usePersistedState`. */
+interface PersistedStateOptions {
+    /** `'trial'` — the default inside a trial — keeps a value per trial, and
+     *  closing the trial deletes it. `'lab'` shares one value across the lab. */
+    scope?: 'trial' | 'lab';
+}
+/**
+ * `useState` whose value survives a reload: a widget's open tab, a panel's
+ * position. Inside a `<Lab>`, `SingletonExperimentProvider` or `<Persistence>`
+ * the value is a record, loaded before first render and re-rendered when
+ * another tab changes it. With no provider above it, or a null `name`, it is
+ * plain `useState` — so a component can offer optional persistence and still
+ * mount anywhere.
+ *
+ * Values must be structured-clone values; the JSON-backed adapters warn about
+ * one JSON would change. Snapshots do not include them.
+ */
+declare function usePersistedState<T>(name: string | null | undefined, initial: T | (() => T), options?: PersistedStateOptions): [T, Dispatch<SetStateAction<T>>];
+
+/** 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, Persistence as e, TrialIdProvider as h, createIndexedDbAdapter as i, createLabStore as j, createMemoryAdapter as k, indexedDbAdapter as l, labDocumentKey as m, localStorageAdapter as n, noneAdapter as o, openLabStore as p, quarantineKey as q, useLabStore as r, sessionStorageAdapter as s, usePersistedState as t, urlHashAdapter as u, useTrialId as v, useTrialState as w };
+export type { IndexedDbAdapterOptions as I, LabStore as L, OpenLabStoreOptions as O, PersistedStateOptions as P, RecordCache as R, LabStoreActions as a, OpenedLabStore as d, PersistenceProps as f, RecordChange as g };

package/dist/canvas/index.d.ts

@@ -1,135 +1,24 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import { ReactNode, WheelEvent, PointerEvent as PointerEvent$1 } from 'react';
-import { V as ViewTransform, c as WorldSpec, a2 as ViewportSize, a as Point, W as WorldFrame } from '../_dts/frac-z7ker2Vx.js';
-export { x as DEFAULT_FRAME, a4 as applyCamera, aa as resolveFrame } from '../_dts/frac-z7ker2Vx.js';
-import { C as CanvasLayerDescriptor } from '../_dts/CanvasStackContext-kTEZvEgE.js';
-export { a as CanvasStackContext, b as CanvasStackContextValue, c as CanvasStackSurface } from '../_dts/CanvasStackContext-kTEZvEgE.js';
-import '../_dts/types-B9_zrHmb.js';
+import * as react from 'react';
+export { C as CanvasStack, a as CanvasStackProps, O as OrbitHandlers, b as OrbitView, P as PITCH_LIMIT, c as PanZoomHandlers, S as Stage, d as StageProps, U as UseOrbitOptions, e as UsePanZoomOptions, V as Vec3, Z as ZoomAtOptions, f as centerOn, g as clampPitch, h as fitStage, o as orbitAfterDrag, i as orbitAfterWheel, s as screenToWorld, u as useOrbit, j as usePanZoom, w as worldToScreen, k as wrapYaw, z as zoomAt } from '../_dts/usePanZoom-Pzf9f2jh.js';
+export { C as CanvasLayerDescriptor, a as CanvasStackContext, b as CanvasStackContextValue, c as CanvasStackSurface } from '../_dts/CanvasStackContext-CJNMS6mz.js';
+export { D as DEFAULT_FRAME, V as ViewportSize, W as WorldFrame, a as WorldSpec, b as applyCamera, r as resolveFrame } from '../_dts/frac-B4okC2lX.js';
+import 'react/jsx-runtime';
+import '../_dts/types-DzoNY1pO.js';
 import '@weasel-js/core';
-import '../_dts/PrefsForm.d-DDHFANkc.js';
-import '../_dts/types-x92Kfeme.js';
-import '../_dts/types-BP2OCcpg.js';
+import '../_dts/PrefsForm.d-DPy9I8It.js';
 import '../_dts/types-DJ79Tg5J.js';
 
-/** Props for `<CanvasStack>`. */
-interface CanvasStackProps {
-    layers: CanvasLayerDescriptor[];
-    view: ViewTransform;
-    onViewChange: (v: ViewTransform) => void;
-    /** The instrument's coordinate system. Omitted, world (0,0) sits at the
-     *  element's top-left with y running down. */
-    worldSpec?: WorldSpec;
-    minZoom?: number;
-    maxZoom?: number;
-    width?: number | string;
-    height?: number | string;
-    className?: string;
-    /** Fired whenever the stack is measured, so a consumer can place a view that
-     *  only makes sense in terms of the viewport. */
-    onResize?: (size: ViewportSize) => void;
-    onHitTest?: (worldPos: Point) => void;
-    children?: ReactNode;
-}
-/** Stacks one `<canvas>` per layer and drives them from a shared view, so a
- *  layer that changes rarely is not redrawn with one that changes every frame.
- *  Handles sizing, device pixel ratio, and pan/zoom. */
-declare function CanvasStack({ layers, view, onViewChange, worldSpec, minZoom, maxZoom, width, height, className, onResize, onHitTest, children, }: CanvasStackProps): react_jsx_runtime.JSX.Element;
-
-/** Bounds and coordinate system a {@link zoomAt} works in. */
-interface ZoomAtOptions {
-    /** The instrument's coordinate system, resolved against the viewport.
-     *  Omitted, `at` is measured from the element's top-left. */
-    frame?: WorldFrame;
-    min?: number;
-    max?: number;
-}
+/** Where a trial's camera takes a wheel event from outside its own element. */
+type CameraWheelSlot = {
+    current: ((e: WheelEvent) => void) | null;
+};
 /**
- * Zoom a view by `factor` about a fixed point, so whatever world coordinate
- * `at` was over stays under it.
- *
- * `at` is in the element's own pixels — a cursor position, or the centre of a
- * lens. The clamp is applied before the pan is solved, so a zoom that hits a
- * bound still anchors on the zoom it actually reached.
+ * The trial's camera, for input that lands outside it. An annotation target's
+ * input box is portalled into the surface container, so a wheel over a mark
+ * never bubbles through the stage or canvas stack it sits on; the box hands
+ * the event here instead.
  */
-declare function zoomAt(view: ViewTransform, factor: number, at: Point, { frame, min, max }?: ZoomAtOptions): ViewTransform;
-/** The view that puts a world point at the centre of a `size` viewport, at
- *  `zoom`. What a lens showing a region around one point renders through. */
-declare function centerOn(world: Point, zoom: number, size: ViewportSize, frame?: WorldFrame): ViewTransform;
-
-/** Project a world point into screen coordinates under a view.
- *
- *  `frame` is the instrument's declared coordinate system, resolved against the
- *  viewport; omitting it gives labkit's original one — origin at the top-left,
- *  y downward. */
-declare function worldToScreen(world: Point, view: ViewTransform, frame?: WorldFrame): Point;
-/** Unproject a screen point back to world coordinates under a view. */
-declare function screenToWorld(screen: Point, view: ViewTransform, frame?: WorldFrame): Point;
-
-/** A point in the space the instrument works in. */
-interface Vec3 {
-    x: number;
-    y: number;
-    z: number;
-}
-/** An orbit camera as a trial view: where it looks from, and what it looks at.
- *  labkit does not turn this into a matrix — the host's renderer does. */
-interface OrbitView {
-    yaw: number;
-    pitch: number;
-    distance: number;
-    target: Vec3;
-}
-/** Just short of the pole. At exactly ±PI/2 the azimuth is undefined and the
- *  camera rolls, which reads as the model jumping rather than as a limit. */
-declare const PITCH_LIMIT: number;
-declare function clampPitch(pitch: number): number;
-declare function wrapYaw(yaw: number): number;
-/** The view a drag of (dx, dy) from `start` produces. Absolute against the drag
- *  start, so it can be re-applied any number of times without compounding. */
-declare function orbitAfterDrag(start: OrbitView, dx: number, dy: number): OrbitView;
-/** Multiplicative, so one notch covers the same proportion of the distance
- *  whether the camera is near or far. */
-declare function orbitAfterWheel(view: OrbitView, deltaY: number, minDistance: number, maxDistance: number): OrbitView;
-interface UseOrbitOptions {
-    view: OrbitView;
-    onViewChange: (v: OrbitView) => void;
-    /** Restored on double-click. Defaults to the view the hook first saw. */
-    home?: OrbitView;
-    minDistance?: number;
-    maxDistance?: number;
-}
-interface OrbitHandlers {
-    onWheel: (e: WheelEvent<HTMLElement>) => void;
-    onPointerDown: (e: PointerEvent$1<HTMLElement>) => void;
-    onDoubleClick: () => void;
-    isDragging: () => boolean;
-}
-/** Pointer gestures over an orbit view: drag to turn, wheel or pinch to dolly,
- *  double-click to go home. The 3D peer of `usePanZoom`. */
-declare function useOrbit({ view, onViewChange, home, minDistance, maxDistance, }: UseOrbitOptions): OrbitHandlers;
-
-interface UsePanZoomOptions {
-    view: ViewTransform;
-    onViewChange: (v: ViewTransform) => void;
-    /** The opening `view.zoom` always stays reachable, widening these past
-     *  whatever is passed here if it would otherwise exclude it. */
-    minZoom?: number;
-    maxZoom?: number;
-    /** The instrument's coordinate system, resolved against the viewport. The
-     *  wheel anchors in this frame; omitting it anchors at the element's
-     *  top-left, which is what labkit did before a frame could be declared. */
-    frame?: WorldFrame;
-    /** A primary-button press released without ever crossing the drag
-     *  threshold. The pointer session owns the release, so the gesture's end is
-     *  reported here rather than left for a consumer's own `onPointerUp`. */
-    onTap?: (e: PointerEvent) => void;
-}
-interface PanZoomHandlers {
-    onWheel: (e: WheelEvent<HTMLElement>) => void;
-    onPointerDown: (e: PointerEvent$1<HTMLElement>) => void;
-    isDragging: () => boolean;
-}
-declare function usePanZoom({ view, onViewChange, minZoom, maxZoom, frame, onTap, }: UsePanZoomOptions): PanZoomHandlers;
+declare const CameraWheelContext: react.Context<CameraWheelSlot | null>;
 
-export { CanvasLayerDescriptor, CanvasStack, PITCH_LIMIT, ViewportSize, WorldFrame, WorldSpec, centerOn, clampPitch, orbitAfterDrag, orbitAfterWheel, screenToWorld, useOrbit, usePanZoom, worldToScreen, wrapYaw, zoomAt };
-export type { CanvasStackProps, OrbitHandlers, OrbitView, PanZoomHandlers, UseOrbitOptions, UsePanZoomOptions, Vec3, ZoomAtOptions };
+export { CameraWheelContext };
+export type { CameraWheelSlot };

package/dist/canvas/index.js

@@ -1,6 +1,8 @@
-export { CanvasStack, PITCH_LIMIT, clampPitch, orbitAfterDrag, orbitAfterWheel, useOrbit, usePanZoom, wrapYaw } from '../chunk-I6JCVE24.js';
-export { centerOn, zoomAt } from '../chunk-CTRKTLYZ.js';
+export { CameraWheelContext, CanvasStack, PITCH_LIMIT, Stage, clampPitch, fitStage, orbitAfterDrag, orbitAfterWheel, useOrbit, usePanZoom, wrapYaw } from '../chunk-CEIUBPPW.js';
+export { centerOn, zoomAt } from '../chunk-H6ZAOWNE.js';
 export { DEFAULT_FRAME, applyCamera, resolveFrame, screenToWorld, worldToScreen } from '../chunk-2AYGEN57.js';
+import '../chunk-WIG6XHJ7.js';
 export { CanvasStackContext } from '../chunk-CQLQPQ4P.js';
+import '../chunk-2YILQ7Y5.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/chrome/index.d.ts

@@ -1,96 +1,8 @@
-import { c as ControlRenderer } from '../_dts/types-B9_zrHmb.js';
-import { I as Instrument, _ as TrialChromeContext, m as TrialContribution } from '../_dts/frac-z7ker2Vx.js';
-export { z as IconComponent, O as SidebarSection, Q as StatusReadout, Y as ToolItem, Z as ToolbarItem, $ as TrialRegion, a1 as ViewportControl } from '../_dts/frac-z7ker2Vx.js';
-import * as react_jsx_runtime from 'react/jsx-runtime';
+export { a as LabAsideRegion, b as LabChromeContext, L as LabContribution, e as LabFooterRegion, f as LabHeaderRegion, g as LabRegion, h as LabRegionProps, i as LabSidebarRegion, P as PaletteRegion, j as PaletteRegionProps, S as SidebarRegion, k as SidebarRegionProps, l as StatusRegion, m as StatusRegionProps, T as TitleBarPlacement, n as TitleBarRegion, o as TitleBarRegionProps, p as ToolbarRegion, q as ToolbarRegionProps, V as ViewportRegion, r as ViewportRegionProps, t as builtinContributions, w as contributionsIn, x as labContributions, y as mergeContributions, C as suppressContributions, D as toolContributions, E as useLabChromeContext } from '../_dts/index-CSJoj4LC.js';
+export { a3 as ContributionBase, a7 as IconComponent, ae as RegionContribution, ai as SidebarSection, aj as SidebarSlotContext, al as StatusReadout, ao as ToolItem, ap as ToolSlotContext, aq as ToolbarItem, ar as TrialChromeContext, N as TrialContribution, as as TrialRegion, au as ViewportControl } from '../_dts/frac-B4okC2lX.js';
+import '../_dts/types-DzoNY1pO.js';
 import '@weasel-js/core';
-import '../_dts/PrefsForm.d-DDHFANkc.js';
+import '../_dts/PrefsForm.d-DPy9I8It.js';
 import 'react';
-import '../_dts/types-x92Kfeme.js';
-import '../_dts/types-BP2OCcpg.js';
+import 'react/jsx-runtime';
 import '../_dts/types-DJ79Tg5J.js';
-
-/**
- * The contributions a trial gets from what its instrument declared. This is
- * the whole "declaring a capability provides the chrome" rule — it replaces
- * the presence checks that used to be spread across the runtime.
- */
-declare function builtinContributions(instrument: Instrument, ctx: TrialChromeContext, controls?: Record<string, ControlRenderer>): TrialContribution[];
-
-/**
- * Concatenate contribution bundles into one list, preserving order — order
- * decides how a region lays its contributions out, so it is part of the
- * result, not an accident of it.
- *
- * Throws on a duplicate id rather than dropping one: a contribution silently
- * losing to a later bundle is the failure a registry exists to prevent.
- */
-declare function mergeContributions(...bundles: readonly TrialContribution[][]): TrialContribution[];
-/**
- * Drop contributions by id. Throws when an id is not present: a typo that
- * silently suppresses nothing is the same class of bug as a duplicate id
- * silently winning.
- */
-declare function suppressContributions(bundle: readonly TrialContribution[], ids: readonly string[]): TrialContribution[];
-
-/** Props for `<PaletteRegion>`. */
-interface PaletteRegionProps {
-    contributions: readonly TrialContribution[];
-    ctx: TrialChromeContext;
-}
-/** A trial's tool strip. Selection lives in the trial's or the lab's tool
- *  slot; this region only reflects it. */
-declare function PaletteRegion({ contributions, ctx }: PaletteRegionProps): react_jsx_runtime.JSX.Element | null;
-
-/** Props for `<SidebarRegion>`. */
-interface SidebarRegionProps {
-    contributions: readonly TrialContribution[];
-    ctx: TrialChromeContext;
-}
-/** Lays a trial's `sidebar` contributions out as titled, collapsible sections.
- *  A section the trial has torn out is not rendered here — `Trial` portals its
- *  body into the workspace instead. */
-declare function SidebarRegion({ contributions, ctx }: SidebarRegionProps): react_jsx_runtime.JSX.Element | null;
-
-/** Props for `<StatusRegion>`. */
-interface StatusRegionProps {
-    contributions: readonly TrialContribution[];
-    ctx: TrialChromeContext;
-}
-/** Lays a trial's `status` contributions out as readouts. */
-declare function StatusRegion({ contributions, ctx }: StatusRegionProps): react_jsx_runtime.JSX.Element | null;
-
-/** Which end of the title bar a `<TitleBarRegion>` lays out: `'lead'` renders
- *  the contributions that leave `end` unset, before the title; `'actions'`
- *  renders the ones that set it, after everything else. */
-type TitleBarPlacement = 'lead' | 'actions';
-/** Props for `<TitleBarRegion>`. */
-interface TitleBarRegionProps {
-    contributions: readonly TrialContribution[];
-    ctx: TrialChromeContext;
-    /** Defaults to `'actions'`, where the built-ins live. */
-    placement?: TitleBarPlacement;
-}
-/** Lays a trial's `titlebar` contributions out at one end of the bar. */
-declare function TitleBarRegion({ contributions, ctx, placement }: TitleBarRegionProps): react_jsx_runtime.JSX.Element | null;
-
-/** Props for `<ToolbarRegion>`. */
-interface ToolbarRegionProps {
-    contributions: readonly TrialContribution[];
-    ctx: TrialChromeContext;
-}
-/** Lays a trial's `toolbar` contributions out, grouped by their `group`. */
-declare function ToolbarRegion({ contributions, ctx }: ToolbarRegionProps): react_jsx_runtime.JSX.Element | null;
-
-/** Props for `<ViewportRegion>`. */
-interface ViewportRegionProps {
-    contributions: readonly TrialContribution[];
-    ctx: TrialChromeContext;
-}
-/**
- * Controls acting on the view of a trial. Anchored inside the content well
- * rather than in the toolbar, which acts on the trial itself.
- */
-declare function ViewportRegion({ contributions, ctx }: ViewportRegionProps): react_jsx_runtime.JSX.Element | null;
-
-export { PaletteRegion, SidebarRegion, StatusRegion, TitleBarRegion, ToolbarRegion, TrialChromeContext, TrialContribution, ViewportRegion, builtinContributions, mergeContributions, suppressContributions };
-export type { PaletteRegionProps, SidebarRegionProps, StatusRegionProps, TitleBarPlacement, TitleBarRegionProps, ToolbarRegionProps, ViewportRegionProps };