@weasel-js/labkit 1.6.0 → 1.6.1

package/dist/_dts/{CanvasStackContext-DQgcH1ny.d.ts → CanvasStackContext-Wo6OwIVM.d.ts}

@@ -1,6 +1,6 @@
 import * as react from 'react';
 import { RefObject } from 'react';
-import { m as ViewTransform, W as WorldFrame } from './frac-DTRq7Xpb.js';
+import { b as ViewTransform, W as WorldFrame } from './types-B7yBTTF9.js';
 
 /** One layer of a canvas stack: its id, whether it is currently shown, and how
  *  it paints itself. */

package/dist/_dts/FloatingPanel-7j0IcXwz.d.ts

@@ -0,0 +1,30 @@
+import react__default, { ReactNode } from 'react';
+import { Corner } from 'windease';
+
+/** Props for `<FloatingPanel>`. */
+interface FloatingPanelProps {
+    children: ReactNode;
+    /** Corner it rests in before it has ever been dragged. Default `'bottom-left'`. */
+    anchor?: Corner;
+    /** Corners that may capture it. Default: all four. */
+    snapCorners?: readonly Corner[];
+    /** Pixels in from a corner when snapped. Default 12. */
+    inset?: number;
+    /** Name to remember its position under, through `usePersistedState` — so it
+     *  is remembered only inside a lab or a `<Persistence>`. Omit to forget on
+     *  reload. */
+    persist?: string;
+    className?: string;
+}
+/**
+ * A draggable box that floats over its offset parent and snaps to its corners.
+ *
+ * Drives windease's `floatingStrategy` as a pure function rather than mounting a
+ * windease container: a lab overlay has one item and no zone tree, so the node
+ * model would be all cost. Pointer handling is therefore this component's, and
+ * windease's own affordance rendering never participates.
+ */
+declare function FloatingPanel({ children, anchor, snapCorners, inset, persist, className, }: FloatingPanelProps): react__default.JSX.Element;
+
+export { FloatingPanel as a };
+export type { FloatingPanelProps as F };

package/dist/_dts/{LayerList.d-2c9yup5Y.d.ts → LayerList.d-BoELAMsM.d.ts}

@@ -1,4 +1,4 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
 import { ReactNode } from 'react';
 import { S as StanceProps } from './PrefsRow.d-DFpPIeIC.js';
 
@@ -77,7 +77,7 @@ declare function moveLayers(items: LayerListItem[], move: LayerMove): LayerListI
  * card whose controls fold away; either can nest child layers. Selection,
  * visibility, removal and an add palette are each on when their handler is given.
  */
-declare function LayerList(props: LayerListProps): react_jsx_runtime.JSX.Element;
+declare function LayerList(props: LayerListProps): react.JSX.Element;
 
 export { LayerList as L, moveLayers as m };
 export type { LayerListItem as a, LayerListProps as b, LayerMove as c };

package/dist/_dts/{index-DINmCuLA.d.ts → PropertyField.d-D0ndfIIt.d.ts}

@@ -1,11 +1,33 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as react from 'react';
 import { ReactNode } from 'react';
-import { S as StanceProps } from './PrefsRow.d-DFpPIeIC.js';
 import { ToolPrefNumberFormat, FillStyle, PaintKind } from '@weasel-js/core';
-import { U as UnitTable } from './number.d-OeQYQoUO.js';
-import { R as ResolvedConfig, b as ConfigField, C as ControlRenderer } from './types-B7y8hX1D.js';
-import './inDialog-D5ZKGjiD.js';
+import { S as StanceProps } from './PrefsRow.d-DFpPIeIC.js';
+
+/**
+ * Display-formatter for numbers. Use this anywhere a number is shown to
+ * a user. The whole point: negative values get prefixed with the real
+ * MINUS SIGN (U+2212) instead of the ASCII HYPHEN-MINUS (U+002D) that
+ * `toLocaleString` and template literals produce by default.
+ *
+ * U+2212 is the same visual width as `+` and reads as a sign rather
+ * than a hyphen — columns of signed numbers align cleanly and the
+ * glyph doesn't get confused with a bullet or list dash.
+ */
+declare const MINUS_SIGN = "\u2212";
+/**
+ * Formats a number for display, substituting {@link MINUS_SIGN} for the ASCII
+ * hyphen `toLocaleString` emits. Non-finite values stringify as-is.
+ */
+declare function formatNumber(value: number, options?: Intl.NumberFormatOptions): string;
+/** One unit's conversion into the shown unit: a bare factor, or a scale that
+ *  also moves zero. Structurally the kit's `UnitEntry`, kept local so this
+ *  formatting helper stays free of the scene vocabulary. */
+type UnitTableEntry = number | {
+    factor: number;
+    offset?: number;
+};
+/** Suffixes a person may type, each mapped to its conversion. */
+type UnitTable = Record<string, UnitTableEntry>;
 
 /**
  * How much room a container gives its rows — gaps, padding, and field height,
@@ -56,7 +78,7 @@ interface PropertyPanelProps extends PropertyMetricProps, StanceProps {
  * is; the theme's `--wzl-panel-*` and `--wzl-stance-*` slots decide how each looks. A stanced
  * panel's title takes the row-label recipe rather than the display title.
  */
-declare function PropertyPanel({ title, actions, selectable, children, className, density, align, stance, tone, }: PropertyPanelProps): react_jsx_runtime.JSX.Element;
+declare function PropertyPanel({ title, actions, selectable, children, className, density, align, stance, tone, }: PropertyPanelProps): react.JSX.Element;
 /** How a property list packs its rows into two columns. */
 type PropertyListPack = 'auto-color' | 'pairs' | 'one-up';
 /** Props for `<PropertyList>`. */
@@ -91,7 +113,7 @@ interface PropertySpanProps {
  * `<Subpanel>`. `<PropertyRow span>` covers the row case; this covers
  * everything else a consumer puts in the grid.
  */
-declare function PropertySpan({ children, className }: PropertySpanProps): react_jsx_runtime.JSX.Element;
+declare function PropertySpan({ children, className }: PropertySpanProps): react.JSX.Element;
 /** Which control shape a row holds, which decides its intrinsic layout. */
 type PropertyRowVariant = 'default' | 'color' | 'checkbox';
 /** Whether a row's label sits above its control or beside it. */
@@ -146,7 +168,7 @@ interface PropertyRowProps extends PropertyMetricProps {
 }
 /** The label-plus-control frame `<PropertyField>` draws its rows in. Use it
  *  directly for a control no field kind covers. */
-declare function PropertyRow({ label, readout, description, variant, layout, span, children, htmlFor, group, className, density, align, auto, onAutoChange, chrome, }: PropertyRowProps): react_jsx_runtime.JSX.Element;
+declare function PropertyRow({ label, readout, description, variant, layout, span, children, htmlFor, group, className, density, align, auto, onAutoChange, chrome, }: PropertyRowProps): react.JSX.Element;
 
 /**
  * Which controls a field is drawn with.
@@ -367,7 +389,7 @@ type DistributiveOmit<U, K extends PropertyKey> = U extends unknown ? Omit<U, K>
  * `onChange` when given both. `mixed` and `unset` show a field whose sources
  * disagree, or agree on holding nothing.
  */
-declare function PropertyField<T extends string = string>(props: PropertyFieldProps<T>): react_jsx_runtime.JSX.Element;
+declare function PropertyField<T extends string = string>(props: PropertyFieldProps<T>): react.JSX.Element;
 /**
  * The control for one field, with no row around it — for a cell that shares
  * a row with others, or a surface that draws its own row. Keyed by `kind`
@@ -376,78 +398,7 @@ declare function PropertyField<T extends string = string>(props: PropertyFieldPr
  * A slider brings its readout beside the track. Several elements come back
  * as siblings rather than wrapped, so the surrounding row lays them out.
  */
-declare function PropertyControl<T extends string = string>(typed: PropertyControlProps<T>): react_jsx_runtime.JSX.Element;
-
-/** How a panel packs its rows into the two-column property grid.
- *   - `'auto'`: narrow controls (numbers, checkboxes, dropdowns, colors) sit
- *     two per row; the ones that need the width — text, sliders, segmented
- *     toggles — span it.
- *   - `'pairs'`: every row pairs. A control that needs the full width says so
- *     itself, with `<PropertyRow span>`.
- *   - `'one-up'`: one control per row, colors excepted.
- */
-type ControlPack = 'auto' | 'pairs' | 'one-up';
-interface ControlPanelProps<TC extends Record<string, unknown>> extends StanceProps {
-    /** The instrument's resolved config schema. */
-    schema?: ResolvedConfig;
-    /** @deprecated Pass `schema`. A field list is adapted into one internally. */
-    fields?: ConfigField[];
-    config: TC;
-    /** Writes one value. The path is dotted for a leaf inside an `f.group`, and
-     *  the bare key for one at the root. */
-    setConfig: (path: string, value: unknown) => void;
-    /**
-     * Control overrides and app-defined kinds, PrefsForm-style. Keys are config
-     * paths (checked first) or leaf kinds. A renderer returning `null` collapses
-     * the row; entries override the built-in rows on collision.
-     */
-    renderers?: Record<string, ControlRenderer>;
-    /** How rows pack into the two-column grid. Defaults to `'pairs'`. */
-    pack?: ControlPack;
-    /**
-     * Where a row's label sits relative to its control. Unset takes each row's
-     * own orientation — `block` (label above, which is what leaves a paired row
-     * room for its value) for most, `inline` for colors and checkboxes.
-     */
-    layout?: PropertyRowLayout;
-    /** Room the rows get. Passed straight to the property list. */
-    density?: PropertyDensity;
-    /** Cross-axis alignment of an inline row's label and control. */
-    align?: PropertyAlign;
-    /**
-     * Fold each section away behind a twisty, starting `'open'` or `'closed'`.
-     * Unset draws the heading alone, as the panel always has — unless a section
-     * in the schema declares how it opens, which makes that section foldable on
-     * its own and outranks this for that one section.
-     */
-    collapse?: 'open' | 'closed';
-    /**
-     * Which sections are folded, keyed as `onCollapse` reports them. Given, the
-     * panel keeps no state of its own: every toggle arrives at `onCollapse`
-     * instead, which is where a lab that remembers a trial's sections writes
-     * them.
-     */
-    collapsed?: Readonly<Record<string, boolean>>;
-    /** A fold moved. The key is a section's label — prefixed by its group's
-     *  dotted path when the section sits inside one — or a group's own path. */
-    onCollapse?: (key: string, collapsed: boolean) => void;
-    /** Dotted paths currently unpinned. A row in this set hides its control and
-     *  reads out `auto`, and clicking its label writes the sentinel back through
-     *  `setConfig`. Omitted, the panel keeps the set itself: the labels still
-     *  toggle and the sentinel never reaches `setConfig`, which would otherwise
-     *  store it as the row's value. */
-    auto?: ReadonlySet<string>;
-    /** Draw leaves marked `hidden`. */
-    showHidden?: boolean;
-    /** Heads the panel. With `title`, `stance` or `tone` given, the rows sit in a
-     *  `<PropertyPanel>` carrying them; with none, they are the bare list. */
-    title?: ReactNode;
-    className?: string;
-}
-/** Render an instrument's config schema as a stack of controls, each writing
- *  back through `setConfig`. Built on the property rows, so a lab's controls
- *  are the same aligned, themed rows the rest of the kit uses. */
-declare function ControlPanel<TC extends Record<string, unknown>>({ schema, fields, config, setConfig, renderers, pack, layout, density, align, collapse, collapsed, onCollapse, auto: given, showHidden, title, stance, tone, className, }: ControlPanelProps<TC>): react_jsx_runtime.JSX.Element;
+declare function PropertyControl<T extends string = string>(typed: PropertyControlProps<T>): react.JSX.Element;
 
-export { ControlPanel as C, PropertyControl as b, PropertyField as d, PropertyList as f, PropertyPanel as i, PropertyRow as k, PropertySpan as o };
-export type { PropertyMetricProps as P, PropertyListPack as a, PropertyControlProps as c, PropertyFieldProps as e, PropertyListProps as g, PropertyOption as h, PropertyPanelProps as j, PropertyRowLayout as l, PropertyRowProps as m, PropertyRowVariant as n, PropertySpanProps as p };
+export { MINUS_SIGN as M, PropertyControl as b, PropertyField as d, PropertyList as f, PropertyPanel as i, PropertyRow as k, PropertySpan as o, formatNumber as s };
+export type { PropertyMetricProps as P, PropertyListPack as a, PropertyControlProps as c, PropertyFieldProps as e, PropertyListProps as g, PropertyOption as h, PropertyPanelProps as j, PropertyRowLayout as l, PropertyRowProps as m, PropertyRowVariant as n, PropertySpanProps as p, PropertyAlign as q, PropertyDensity as r };

package/dist/_dts/{Select.d-BchGMC2Y.d.ts → Select.d-Cr8-zoup.d.ts}

@@ -1,4 +1,3 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as react from 'react';
 import { ReactNode, ButtonHTMLAttributes, ReactElement } from 'react';
 import { S as StanceProps } from './PrefsRow.d-DFpPIeIC.js';
@@ -239,7 +238,7 @@ interface IconProps {
  *  in; reach for this when the glyph is chosen at runtime. */
 declare function Icon({ name, className, size, label, filled, fillOpacity, }: IconProps & {
     name: IconName;
-}): react_jsx_runtime.JSX.Element;
+}): react.JSX.Element;
 
 /** The tooltip fields a segmented bar's item carries. */
 interface SegmentTooltipFields {
@@ -407,7 +406,7 @@ type FieldProps = {
  * compose Field internally. Use Field directly when you need a custom
  * control to sit in the same visual rhythm.
  */
-declare function Field({ orientation, className, children }: FieldProps): react_jsx_runtime.JSX.Element;
+declare function Field({ orientation, className, children }: FieldProps): react.JSX.Element;
 /**
  * The class names {@link Field} paints its slots with, so a control composing
  * its own layout can match the same form-row rhythm.
@@ -553,7 +552,7 @@ type SelectProps<T extends Key = string> = Omit<SelectProps$1<object>, 'children
  * `aria-label` or a string `label`, as `Button` does; `tooltip` replaces that
  * text.
  */
-declare function Select<T extends Key = string>(props: SelectProps<T>): react_jsx_runtime.JSX.Element;
+declare function Select<T extends Key = string>(props: SelectProps<T>): react.JSX.Element;
 /** Props for {@link SelectItem}, on top of React Aria's `ListBoxItem` props. */
 type SelectItemProps = Omit<ListBoxItemProps, 'className' | 'children'> & {
     children?: ReactNode;
@@ -564,7 +563,7 @@ type SelectItemProps = Omit<ListBoxItemProps, 'className' | 'children'> & {
  * selected. A string child supplies its own `textValue`; anything richer must
  * pass one so type-to-select and screen readers have something to read.
  */
-declare function SelectItem({ children, className, textValue, ...rest }: SelectItemProps): react_jsx_runtime.JSX.Element;
+declare function SelectItem({ children, className, textValue, ...rest }: SelectItemProps): react.JSX.Element;
 
 export { Button as B, Select as S, ToggleBar as T, Icon as d, Input as e, Field as m, ICON_PATHS as o, SelectItem as q, fieldClasses as t };
 export type { FieldOrientation as F, IconProps as I, OverlayPortalProps as O, WithoutPortalTarget as W, ButtonProps as a, ButtonSize as b, ButtonVariant as c, InputProps as f, SelectProps as g, ToggleBarItem as h, ToggleBarProps as i, ToggleBarSize as j, ToggleBarVariant as k, SegmentTooltipFields as l, FieldProps as n, IconName as p, SelectItemProps as r, SelectOption as s };

package/dist/_dts/{usePanZoom-Bq73pwFe.d.ts → Stage-DWBBi8IU.d.ts}

@@ -1,7 +1,75 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import { ReactNode, WheelEvent, PointerEvent as PointerEvent$1 } from 'react';
-import { m as ViewTransform, b as WorldSpec, V as ViewportSize, n as Point, W as WorldFrame } from './frac-DTRq7Xpb.js';
-import { C as CanvasLayerDescriptor } from './CanvasStackContext-DQgcH1ny.js';
+import * as react from 'react';
+import { RefObject, ReactNode } from 'react';
+import { ViewApi } from '@weasel-js/core';
+import { W as WorldFrame, P as Point, b as ViewTransform, l as WorldSpec, V as ViewportSize } from './types-B7yBTTF9.js';
+import { C as CanvasLayerDescriptor } from './CanvasStackContext-Wo6OwIVM.js';
+
+/** The view id the stage publishes its pointer under. */
+declare const STAGE_VIEW_ID = "stage";
+/**
+ * A camera, as the things that sit beside it read it: an overview, a loupe, a
+ * linked cursor. Points are *frame-local* — the world with `y` multiplied by
+ * `frame.yDir` — which is the space `view` works in.
+ */
+interface CameraContextValue {
+    /** The camera as a weasel `ViewApi`, clamped to its zoom range. */
+    view: ViewApi;
+    frame: WorldFrame;
+    /** The element the camera's dispatcher listens on. */
+    element: () => HTMLElement | null;
+    /** The content's own rect, frame-local, when it has one — a `<Stage>`'s. */
+    content?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+/** The camera around the caller, or `null` outside one. */
+declare const CameraContext: react.Context<CameraContextValue | null>;
+/** Set by a host that already provides one input scope for everything inside
+ *  it — a trial — so the camera, the loupe and an overview share it. */
+declare const CameraScopeContext: react.Context<boolean>;
+/**
+ * The actions and deps a camera routes through: the ones a trial provides, or
+ * an isolated set of its own. Isolated, because an actions registry holds one
+ * dispatcher, and a camera must not take input from a canvas beside it. The
+ * pointer store is the exception — one already in scope is kept, since sharing
+ * it is the point.
+ */
+declare function CameraScope({ children }: {
+    children: ReactNode;
+}): react.JSX.Element;
+/** Options for {@link useCameraView}. */
+interface CameraViewOptions {
+    view: ViewTransform;
+    onViewChange: (v: ViewTransform) => void;
+    frame: WorldFrame;
+    hostRef: RefObject<HTMLElement | null>;
+    minZoom?: number;
+    maxZoom?: number;
+}
+/**
+ * A labkit camera as a stable `ViewApi`. Its zoom range is widened to keep the
+ * opening zoom reachable — captured once, so a zoom-out cannot shrink the
+ * range and strand the opening view behind it.
+ */
+declare function useCameraView({ view, onViewChange, frame, hostRef, minZoom, maxZoom, }: CameraViewOptions): ViewApi;
+/** Props for `<CameraInput>`. */
+interface CameraInputProps {
+    hostRef: RefObject<HTMLElement | null>;
+    camera: ViewApi;
+    frame: WorldFrame;
+    /** A primary-button press released without crossing the drag threshold, at
+     *  the world point it landed on. */
+    onTap?: (world: Point) => void;
+}
+/**
+ * Mounts the dispatcher on `hostRef` and routes the camera's gestures through
+ * it. Render it inside a `<CameraScope>`; with no actions registry in scope it
+ * renders nothing.
+ */
+declare function CameraInput(props: CameraInputProps): react.JSX.Element | null;
 
 /** Props for `<CanvasStack>`. */
 interface CanvasStackProps {
@@ -24,8 +92,9 @@ interface CanvasStackProps {
 }
 /** 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;
+ *  Handles sizing and device pixel ratio; pan and zoom route through weasel's
+ *  gesture dispatcher (`<CameraInput>`). */
+declare function CanvasStack({ layers, view: viewProp, onViewChange, worldSpec, minZoom, maxZoom, width, height, className, onResize, onHitTest, children, }: CanvasStackProps): react.JSX.Element;
 
 /** Bounds and coordinate system a {@link zoomAt} works in. */
 interface ZoomAtOptions {
@@ -82,36 +151,12 @@ interface StageProps {
 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
+ * `<CanvasStack>` is for layers drawn to a canvas. Pan and zoom route through
+ * weasel's gesture dispatcher (`<CameraInput>`). 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;
-
-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;
+declare function Stage({ size, view: viewProp, onViewChange, minZoom, maxZoom, onResize, hostRef, overlay, children, }: StageProps): react.JSX.Element;
 
-export { CanvasStack as C, Stage as S, centerOn as c, fitStage as f, screenToWorld as s, usePanZoom as u, worldToScreen as w, zoomAt as z };
-export type { PanZoomHandlers as P, UsePanZoomOptions as U, ZoomAtOptions as Z, CanvasStackProps as a, StageProps as b };
+export { CameraContext as C, STAGE_VIEW_ID as S, CameraInput as b, CameraScope as d, CameraScopeContext as e, CanvasStack as g, Stage as i, centerOn as k, fitStage as l, screenToWorld as s, useCameraView as u, worldToScreen as w, zoomAt as z };
+export type { ZoomAtOptions as Z, CameraContextValue as a, CameraInputProps as c, CameraViewOptions as f, CanvasStackProps as h, StageProps as j };

package/dist/_dts/{index-B0--8PEM.d.ts → index-CKyX0ME_.d.ts}

@@ -1,6 +1,5 @@
-import { C as ControlRenderer, d as ConfigRule } from './types-B7y8hX1D.js';
-import { O as Instrument, as as TrialChromeContext, R as TrialContribution, T as TrialRecord, t as InstrumentList, g as SavedSnapshot, s as LabMode, aq as ToolSlotContext, a6 as ContributionBase, ar as ToolbarItem, ap as ToolItem, aj as SidebarSection, am as StatusReadout, K as TrialTool, af as RegionContribution, ak as SidebarSlotContext } from './frac-DTRq7Xpb.js';
-import * as react_jsx_runtime from 'react/jsx-runtime';
+import { d as ControlRenderer, c as ConfigRule } from './types-DTuViBvc.js';
+import { R as Instrument, ax as TrialChromeContext, Y as TrialContribution, T as TrialRecord, t as InstrumentList, f as SavedSnapshot, s as LabMode, av as ToolSlotContext, a9 as ContributionBase, aw as ToolbarItem, au as ToolItem, ao as SidebarSection, ar as StatusReadout, O as TrialTool, ak as RegionContribution, ap as SidebarSlotContext } from './types-B7yBTTF9.js';
 import * as react from 'react';
 import { ReactNode } from 'react';
 
@@ -142,15 +141,15 @@ interface LabRegionProps {
     contributions: readonly LabContribution[];
 }
 /** The lab's action bar, in the shell header beside the title. */
-declare function LabHeaderRegion({ contributions }: LabRegionProps): react_jsx_runtime.JSX.Element;
+declare function LabHeaderRegion({ contributions }: LabRegionProps): react.JSX.Element;
 /** The lab's sidebar sections. Fold state is a lab-scoped persisted value, so it
  *  survives a reload in a stored lab and lasts the session in an unstored one. */
-declare function LabSidebarRegion({ contributions }: LabRegionProps): react_jsx_runtime.JSX.Element;
+declare function LabSidebarRegion({ contributions }: LabRegionProps): react.JSX.Element;
 /** The lab's aside sections, on the far side of the workspace from the sidebar.
  *  Fold state persists the way the sidebar's does. */
-declare function LabAsideRegion({ contributions }: LabRegionProps): react_jsx_runtime.JSX.Element;
+declare function LabAsideRegion({ contributions }: LabRegionProps): react.JSX.Element;
 /** The lab's readouts, in the shell footer below the workspace. */
-declare function LabFooterRegion({ contributions }: LabRegionProps): react_jsx_runtime.JSX.Element;
+declare function LabFooterRegion({ contributions }: LabRegionProps): react.JSX.Element;
 
 /**
  * Concatenate contribution bundles into one list, preserving order — order
@@ -183,7 +182,7 @@ interface PaletteRegionProps<TCtx extends ToolSlotContext = TrialChromeContext>
 /** A tool strip: a trial's, or the lab's. Selection lives in whichever tool
  *  slot the context carries; this region only reflects it. An item carrying
  *  `onActivate` is a command instead — it presses, and never latches. */
-declare function PaletteRegion<TCtx extends ToolSlotContext = TrialChromeContext>({ contributions, ctx, region, }: PaletteRegionProps<TCtx>): react_jsx_runtime.JSX.Element | null;
+declare function PaletteRegion<TCtx extends ToolSlotContext = TrialChromeContext>({ contributions, ctx, region, }: PaletteRegionProps<TCtx>): react.JSX.Element | null;
 
 /** Props for `<SidebarRegion>`. */
 interface SidebarRegionProps<TCtx extends SidebarSlotContext = TrialChromeContext> {
@@ -196,7 +195,7 @@ interface SidebarRegionProps<TCtx extends SidebarSlotContext = TrialChromeContex
  *  trial's, or the lab's. A section the trial has torn out is not rendered
  *  here — `Trial` portals its body into the workspace instead. A context with
  *  no `undockPanel` offers no tear-out. */
-declare function SidebarRegion<TCtx extends SidebarSlotContext = TrialChromeContext>({ contributions, ctx, region, }: SidebarRegionProps<TCtx>): react_jsx_runtime.JSX.Element | null;
+declare function SidebarRegion<TCtx extends SidebarSlotContext = TrialChromeContext>({ contributions, ctx, region, }: SidebarRegionProps<TCtx>): react.JSX.Element | null;
 
 /** Props for `<StatusRegion>`. */
 interface StatusRegionProps<TCtx = TrialChromeContext> {
@@ -206,7 +205,7 @@ interface StatusRegionProps<TCtx = TrialChromeContext> {
     region?: string;
 }
 /** Lays a bar's readouts out. */
-declare function StatusRegion<TCtx = TrialChromeContext>({ contributions, ctx, region, }: StatusRegionProps<TCtx>): react_jsx_runtime.JSX.Element | null;
+declare function StatusRegion<TCtx = TrialChromeContext>({ contributions, ctx, region, }: StatusRegionProps<TCtx>): react.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'`
@@ -220,7 +219,7 @@ interface TitleBarRegionProps {
     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;
+declare function TitleBarRegion({ contributions, ctx, placement }: TitleBarRegionProps): react.JSX.Element | null;
 
 /** Props for `<ToolbarRegion>`. */
 interface ToolbarRegionProps<TCtx = TrialChromeContext> {
@@ -232,7 +231,7 @@ interface ToolbarRegionProps<TCtx = TrialChromeContext> {
     label?: string;
 }
 /** Lays a bar's contributions out, grouped by their `group`. */
-declare function ToolbarRegion<TCtx = TrialChromeContext>({ contributions, ctx, region, label, }: ToolbarRegionProps<TCtx>): react_jsx_runtime.JSX.Element | null;
+declare function ToolbarRegion<TCtx = TrialChromeContext>({ contributions, ctx, region, label, }: ToolbarRegionProps<TCtx>): react.JSX.Element | null;
 
 /** Props for `<ViewportRegion>`. */
 interface ViewportRegionProps {
@@ -243,7 +242,7 @@ interface ViewportRegionProps {
  * 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;
+declare function ViewportRegion({ contributions, ctx }: ViewportRegionProps): react.JSX.Element | null;
 
 export { resetTrial as B, suppressContributions as C, toolContributions as D, useLabChromeContext as E, useLabContext as F, PaletteRegion as P, SidebarRegion as S, ViewportRegion as V, LabAsideRegion as a, LabContext as c, LabFooterRegion as e, LabHeaderRegion as f, LabSidebarRegion as i, StatusRegion as l, TitleBarRegion as n, ToolbarRegion as p, addTrial as s, builtinContributions as t, cloneTrial as u, closeTrial as v, contributionsIn as w, labContributions as x, mergeContributions as y, reorderTrials as z };
 export type { AddTrialOptions as A, LabContribution as L, TitleBarPlacement as T, LabChromeContext as b, LabContextValue as d, LabRegion as g, LabRegionProps as h, PaletteRegionProps as j, SidebarRegionProps as k, StatusRegionProps as m, TitleBarRegionProps as o, ToolbarRegionProps as q, ViewportRegionProps as r };