@weasel-js/labkit 0.8.0 → 1.0.1

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

@@ -1,6 +1,6 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { Ref } from 'react';
-import { N as Node, V as View, D as DrawCommand, S as Scene, B as Bounds, a as ViewportDims, P as PathDrawCommand } from '../_dts/DrawCommand-DACv9lhe.js';
+import { N as Node, V as View, D as DrawCommand, S as Scene, B as Bounds, a as ViewportDims, P as PathDrawCommand } from '../_dts/DrawCommand-CitWPxMY.js';
 
 /**
  * `renderSceneToCanvas` — substrate for detached, read-only scene views
@@ -55,6 +55,10 @@ interface RenderSceneToCanvasArgs<TData, TLayer extends string, TPose> {
      *  minimap's visible-window indicator. Wrapped in the same view transform
      *  as scene commands. */
     extraCommands?: DrawCommand[];
+    /** Optional per-id alpha multiplier, mirroring `<SceneCanvas>`'s scene-slot
+     *  `alphaFor`. Pass the same function the main canvas uses to keep a
+     *  scoping-dim treatment consistent across both. Defaults to `() => 1`. */
+    alphaFor?: (id: string) => number;
     /** Optional device-pixel ratio. Defaults to `window.devicePixelRatio || 1`
      *  when available, otherwise 1. Tests typically pin this to 1 or 2. */
     dpr?: number;
@@ -62,16 +66,27 @@ interface RenderSceneToCanvasArgs<TData, TLayer extends string, TPose> {
 /**
  * Build the DrawCommand list that `renderSceneToCanvas` would dispatch.
  *
- * Pure — no GL, no DOM, no side effects. Iterates `scene.renderOrder()`,
- * calls `drawOne` per node, appends any `extraCommands`, and wraps the
- * combined list in a single `{ kind: 'group', transform: viewToMat3(view) }`
- * so the output is in screen space.
+ * Pure — no GL, no DOM, no side effects. Walks the scene through
+ * `buildSceneTree` — the same walk `<SceneCanvas>`'s `buildSceneLayer` uses —
+ * appends any `extraCommands`, and wraps the result in a single
+ * `{ kind: 'group', transform: viewToMat3(view) }` so the output is in screen
+ * space. Sharing the walk is what keeps hidden layers unpainted and container
+ * clips applied here; a hand-rolled `renderOrder()` loop silently dropped both.
+ *
+ * Each node's commands additionally go through `wrapNodeOutput` — pose
+ * rotation, then the `alphaFor` multiplier — exactly as `buildSceneLayer`
+ * does, so a `drawOne` shared between the two paints the same thing in both.
+ * A `drawOne` that rotates its own output will therefore rotate twice here;
+ * emit unrotated geometry and let the pose drive it.
+ *
+ * Output shape follows `buildSceneTree`: one group per **visible** layer, in
+ * scene-layer order, each holding one group per node on that layer.
  *
  * Exported for tests and for callers that want to render into something
  * other than a real `<canvas>` (e.g. an offscreen renderer or a
  * snapshot fixture).
  */
-declare function buildSceneViewCommands<TData, TLayer extends string, TPose>(scene: Scene<TData, TLayer, TPose>, view: View, drawOne: SceneViewDrawOne<TData, TLayer, TPose>, extraCommands?: ReadonlyArray<DrawCommand>): DrawCommand[];
+declare function buildSceneViewCommands<TData, TLayer extends string, TPose>(scene: Scene<TData, TLayer, TPose>, view: View, drawOne: SceneViewDrawOne<TData, TLayer, TPose>, extraCommands?: ReadonlyArray<DrawCommand>, alphaFor?: (id: string) => number): DrawCommand[];
 /**
  * Render one frame of `scene` at `view` into `canvas`. See module docstring
  * for the design context.
@@ -110,6 +125,10 @@ interface SceneViewCanvasProps<TData, TLayer extends string, TPose> {
      *  indicator; available to other consumers that want to overlay a
      *  world-space annotation. */
     extraCommands?: ReadonlyArray<DrawCommand>;
+    /** Optional per-id alpha multiplier, mirroring `<SceneCanvas>`'s scene-slot
+     *  `alphaFor`. Pass the same function the main canvas uses to keep a
+     *  scoping-dim treatment consistent across both. Defaults to `() => 1`. */
+    alphaFor?: (id: string) => number;
     /** Optional CSS class for sizing / positioning the `<canvas>`. The kit
      *  does not emit inline styles for layout — use a class. */
     className?: string;
@@ -236,6 +255,10 @@ interface MinimapCanvasProps<TData, TLayer extends string, TPose> {
     /** Pose → AABB. Defaults to identity (`pose as Bounds`), matching
      *  `sceneAdapter` / `useSelectTool`. */
     poseBounds?: (pose: TPose) => Bounds;
+    /** Optional per-id alpha multiplier, mirroring `<SceneCanvas>`'s scene-slot
+     *  `alphaFor`. Pass the same function the main canvas uses so a
+     *  scoping-dim treatment shows up in the minimap too. */
+    alphaFor?: (id: string) => number;
     /** Visual tuning of the indicator stroke. */
     indicatorStyle?: IndicatorStyle;
     /** CSS class for sizing / positioning the canvas. */

package/dist/passthrough/weasel-canvas.js

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

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

@@ -1,7 +1,7 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as react from 'react';
-import { ReactNode, CSSProperties, ButtonHTMLAttributes, ReactElement, MutableRefObject, PointerEvent as PointerEvent$1, KeyboardEvent, RefCallback } from 'react';
-import { V as View, D as DrawCommand, O as Op, b as NodeId, c as Path, S as Scene, H as History, B as Bounds } from '../_dts/DrawCommand-DACv9lhe.js';
+import { ReactNode, CSSProperties, ButtonHTMLAttributes, ReactElement, MutableRefObject, PointerEvent as PointerEvent$1, KeyboardEvent, RefCallback, RefObject } from 'react';
+import { V as View, D as DrawCommand, O as Op, b as NodeId, c as Path, S as Scene, H as History, B as Bounds } from '../_dts/DrawCommand-CitWPxMY.js';
 import { TextFieldProps, ValidationResult, CheckboxProps as CheckboxProps$1, SwitchProps as SwitchProps$1, TabProps as TabProps$1, TabListProps as TabListProps$1, TabPanelProps as TabPanelProps$1, TabsProps as TabsProps$1, RadioProps as RadioProps$1, RadioGroupProps as RadioGroupProps$1, NumberFieldProps as NumberFieldProps$1, SelectProps as SelectProps$1, ListBoxItemProps, ComboBoxProps as ComboBoxProps$1, SliderProps as SliderProps$1, ModalOverlayProps, DialogProps as DialogProps$1 } from 'react-aria-components';
 
 /**
@@ -1157,6 +1157,31 @@ interface ModifierState {
 interface AffordanceBinding<TScratch = unknown> {
     initialScratch?: TScratch;
 }
+/**
+ * What a **registered layer's** `hitTest` returns. Extends `AffordanceBinding`
+ * so existing implementations keep typechecking; the added fields are how a
+ * consumer's own chrome says the things kit chrome says through
+ * `AffordanceRegion` — which cursor to show, and whether it owns the point
+ * outright.
+ */
+interface LayerHit<TScratch = unknown> extends AffordanceBinding<TScratch> {
+    /** CSS cursor while the pointer is over this hit. Reaches the hover-cursor
+     *  pump as `AffordanceHit.cursor`, the same path kit chrome uses. */
+    cursor?: string;
+    /** `'exclusive'` bars every binding whose target doesn't consult the
+     *  affordance. Omitted means `'shared'` — today's behavior. Same name and
+     *  meaning as `AffordanceHit.strength`, which it becomes. */
+    strength?: 'exclusive' | 'shared';
+    /** Which gestures an exclusive claim bars. Omitted bars all of them. */
+    claimedKinds?: readonly ClaimableGesture[];
+}
+/**
+ * Gesture kinds an affordance claim can bar, in the spec vocabulary bindings
+ * are written in. `'pointer'` is one token because `pointerDown` / `click` /
+ * `drag` are a single press protocol — at the event level the first two are
+ * the same `kind: 'pointerdown'`, told apart only by `stage`.
+ */
+type ClaimableGesture = 'pointer' | 'doubleClick' | 'contextMenu' | 'longPress' | 'wheel';
 
 /**
  * Canvas size in CSS pixels — passed to `draw` for layers that anchor to
@@ -1235,7 +1260,7 @@ interface RenderLayer<TData> {
     /** Chrome-caps visibility predicate. When supplied, the layer must
      *  not return a hit from any chrome element whose id reports
      *  `false`. Absent → every element is hittable. */
-    isVisible?: (id: string) => boolean) => AffordanceBinding | null;
+    isVisible?: (id: string) => boolean) => LayerHit | null;
     /**
      * Called on every pointermove when no gesture is currently captured.
      * Lets layers (e.g. HUD widgets) track hover state without participating
@@ -1829,17 +1854,28 @@ type ModSpec = Partial<{
     mod: boolean | 'optional';
     shift: boolean | 'optional';
 }>;
+/** The predicate form of {@link TargetSpec}. `hit` is the raw target
+ *  (affordance for drag, `e.target` otherwise); `bodyTarget` is the optional
+ *  body-class string ('empty' | 'selected-body' | 'unselected-body') when
+ *  `classifyTarget` is wired. Predicates that only need one of the two can
+ *  ignore the other. */
+interface TargetPredicate {
+    (hit: unknown, bodyTarget?: string): boolean;
+    /** `false` declares that the predicate reads `bodyTarget` only. An
+     *  exclusive affordance claim bars bindings whose target doesn't consult
+     *  the hit; a body predicate that declares nothing looks like it does. */
+    readsAffordance?: boolean;
+}
 /** Target selector for click and drag gesture specs. String forms are sugar
  *  for the kit-owned object-kind registry (TODO.md Tier 1 follow-up); until
  *  that ships, consumers can pass `{ kindOf: predicate }` to classify hits
- *  themselves. */
+ *  themselves.
+ *
+ *  Adding a form here is a compile error in `parseTargetSpec` until
+ *  `TargetSpecForm` grows a matching variant — which is in turn a compile
+ *  error at every site that switches on one. */
 type TargetSpec = 'empty' | 'selected-body' | 'unselected-body' | `kind:${string}` | `kind:${string}:selected` | `affordance:${string}` | {
-    /** Predicate. `hit` is the raw target (affordance for drag,
-     *  `e.target` otherwise); `bodyTarget` is the optional body-class
-     *  string ('empty' | 'selected-body' | 'unselected-body') when
-     *  `classifyTarget` is wired. Predicates that only need one of the
-     *  two can ignore the other. */
-    kindOf: (hit: unknown, bodyTarget?: string) => boolean;
+    kindOf: TargetPredicate;
 };
 /** Phase qualifier on a gesture spec. Restricts when the spec matches based
  *  on per-tool gesture-lifecycle state.
@@ -1880,6 +1916,7 @@ interface KeyHeldSpec {
 interface WheelSpec {
     kind: 'wheel';
     direction?: 'up' | 'down' | '*';
+    target?: TargetSpec;
     mods?: ModSpec;
     phase?: PhaseSpec;
 }
@@ -2022,6 +2059,15 @@ interface Point2 {
 interface AffordanceHit {
     /** Discriminator string, e.g. `'handle:bottom-right'`. */
     kind: string;
+    /** Id of whatever produced this hit — a kit affordance's `id`, or the
+     *  registered layer's id. Read only by the dispatcher's dead-claim warning today. */
+    owner?: string;
+    /** `'exclusive'` means no binding may act on this point unless its target
+     *  consults the affordance. `'shared'` (the default) competes on scope and
+     *  specificity as bindings always have. */
+    strength?: 'exclusive' | 'shared';
+    /** Which gestures an exclusive claim bars. Omitted bars all of them. */
+    claimedKinds?: readonly ClaimableGesture[];
     /** World-space fixed/pivot point. For resize: opposite corner. For rotate: pivot. */
     fixedPoint?: {
         x: number;
@@ -2349,6 +2395,20 @@ interface OngoingInvoker {
  *  the `Action` type. */
 type Invoker = ImmediateInvoker | OngoingInvoker;
 
+/**
+ * GestureBinding — connects a GestureSpec to an Action id (with per-binding
+ * options). Tools own arrays of these on their `bindings` field; ambient
+ * gesture-bindings are registered globally.
+ *
+ * See `docs/superpowers/specs/2026-05-16-registry-unification-design.md`.
+ */
+
+interface GestureBinding {
+    spec: GestureSpec;
+    actionId: string;
+    opts?: BindingOpts;
+}
+
 /**
  * Pose composition for hierarchical scene graphs.
  *
@@ -3311,20 +3371,6 @@ interface DepSchema {
  */
 type DepName = keyof DepSchema;
 
-/**
- * GestureBinding — connects a GestureSpec to an Action id (with per-binding
- * options). Tools own arrays of these on their `bindings` field; ambient
- * gesture-bindings are registered globally.
- *
- * See `docs/superpowers/specs/2026-05-16-registry-unification-design.md`.
- */
-
-interface GestureBinding {
-    spec: GestureSpec;
-    actionId: string;
-    opts?: BindingOpts;
-}
-
 type HandleKind = 'corner' | 'rotation' | 'anchor';
 type HitShape = {
     kind: 'rect';
@@ -3369,6 +3415,38 @@ interface DebugSink {
     clearSnap(): void;
 }
 
+/**
+ * When an entry's bindings are live. A set, not one value: the hand tool is
+ * palette-selectable AND engaged by holding space, and both hold at once.
+ */
+interface Eligibility {
+    /** Selectable as the focused entry — exclusive, one at a time. */
+    focus?: boolean;
+    /** Also live while this key is held. */
+    offhand?: HotkeyTrigger;
+    /** Live regardless of what is focused. */
+    always?: boolean;
+    /** Live only for input this entry's own affordances produced. */
+    claimed?: boolean;
+    /** Modality filter, applied wherever it would otherwise be live. */
+    capabilities?: CapabilityTag[];
+}
+/**
+ * A registry entry: what it contributes, and when it is eligible. Every role
+ * is optional and independent — an entry that only routes input declares only
+ * `bindings` and `actions`.
+ */
+interface Contribution {
+    id: string;
+    eligibility: Eligibility;
+    bindings?: GestureBinding[];
+    actions?: Action[];
+    overlay?: RenderLayer<unknown>;
+    presentation?: ToolPresentation;
+    /** Reflection escape hatch — the authored form, when there was one. */
+    def?: unknown;
+}
+
 /** Modifier-key snapshot at event dispatch time. `space` is included
  *  because tools commonly use space as a hotkey-slot trigger and may
  *  also want to read it as a flag mid-gesture. */
@@ -3418,6 +3496,10 @@ interface ToolCtx<TScratch = unknown> {
     debug?: DebugSink;
     scratch: TScratch;
 }
+/** Hotkey-slot trigger key. The slot is engaged while this key is held —
+ *  hence "hotkey": active as long as the key is hot. `null` (or omitted)
+ *  means the tool is not eligible for the hotkey slot. */
+type HotkeyTrigger = 'space' | 'alt' | 'ctrl' | 'meta' | 'shift';
 /** World-space AABB shape used by `previewBounds`. Alias of the kit-wide
  *  `Bounds` type — the optional `rotation` field carries through so a tool
  *  can report an oriented preview rect (e.g. mid-rotate). */
@@ -3426,8 +3508,8 @@ type ToolBounds = Bounds;
  *  tool — consumers that render a palette (`<ToolPalette>`) read these
  *  fields to display the tool; consumers that don't can ignore them.
  *
- *  Note: cursor is NOT here. The top-level `Tool.cursor` field below is
- *  already plumbed through `<Canvas>` to `style.cursor` on the host. */
+ *  Note: cursor is NOT here. `Tool.cursor` (inherited from `Contribution`)
+ *  is already plumbed through `<Canvas>` to `style.cursor` on the host. */
 interface ToolPresentation<TScratch = unknown> {
     /** Human-readable label, distinct from the `id`. Falls back to `id`. */
     label?: string;
@@ -3442,34 +3524,13 @@ interface ToolPresentation<TScratch = unknown> {
      *  derives one from `Tool.keybinding` via its own formatter. */
     shortcut?: string;
 }
-/** Full Tool record. */
-interface Tool<TScratch = unknown> {
-    id: string;
-    /**
-     * App-level capability tags for modality. The `weasel-modes` package's
-     * `eligibleForMode(mode, capabilities)` predicate consumes these to decide
-     * whether the tool is usable in the active mode. Tags are extensible
-     * strings — apps can define their own. Untagged tools are treated as
-     * ineligible by all modes except those whose `allows` list includes
-     * every implicit-or-declared tag (i.e. `normal` in the default preset).
-     */
-    capabilities?: CapabilityTag[];
-    /**
-     * Actions this tool owns and needs registered while it is in the tools
-     * registry — e.g. polygon's `polygon.adjustSides`, which its own bindings
-     * reference by id.
-     *
-     * Declared here rather than registered by the hook with `useAction`,
-     * because tool hooks run wherever the consumer calls them — for
-     * `<SceneCanvas>` that is ABOVE `<ActionsProviderIfRoot>`, where
-     * `useActionsRegistry()` returns null and `useAction` silently no-ops. The
-     * result was a binding pointing at an action id nothing had registered, so
-     * the gesture fell through to whatever matched next (polygon's
-     * wheel/arrow-key side adjustment did nothing and `nudge.*` moved the
-     * selection instead). `<ToolActionsMounter>` registers these from inside
-     * the provider.
-     */
-    actions?: Action[];
+/**
+ * The focus-declaring case of a `Contribution`: a mode the user switches
+ * into, plus the hooks that only make sense for one (`initScratch`,
+ * activate/deactivate, live preview, `cursor`). Everything else — bindings,
+ * actions, overlay, presentation — is inherited.
+ */
+interface Tool<TScratch = unknown> extends Contribution {
     /** Optional caller-supplied key. Most built-in tools have their activation
      *  key declared in `BUILTIN_SELECT_KEYS` in `useKeybindings.ts`; this field
      *  is for tools that want their activation key to be configurable by the
@@ -3479,11 +3540,9 @@ interface Tool<TScratch = unknown> {
      *  the invoker knows which tool to switch to). */
     keybinding?: ToolKeybinding;
     initScratch?: () => TScratch;
+    cursor?: string | ((ctx: ToolCtx<TScratch>) => string);
     onActivate?: (ctx: ToolCtx<TScratch>) => void;
     onDeactivate?: (ctx: ToolCtx<TScratch>) => void;
-    cursor?: string | ((ctx: ToolCtx<TScratch>) => string);
-    /** Presentation metadata for tool palettes. See `ToolPresentation`. */
-    presentation?: ToolPresentation<TScratch>;
     /** Returns the in-flight preview pose for `id` if this tool is mid-gesture
      *  on it; otherwise `null`. Lets `Canvas.helpersRef.getEffectivePose`
      *  reflect live gesture state without reaching into hook internals. The
@@ -3501,26 +3560,6 @@ interface Tool<TScratch = unknown> {
      *  consults this alongside `previewPose` to avoid double-rendering. Returns
      *  `null` when no gesture is in flight. */
     previewIds?: () => Iterable<string> | null;
-    /** Optional overlay layer rendered on top of the scene/chrome whenever
-     *  this tool is in any active slot (active, hotkey, or ambient).
-     *  The layer's `draw` function reads from this tool's scratch via React
-     *  closure (re-evaluated each render). Return early from `draw` to render
-     *  nothing — typically gated on a scratch field like
-     *  `if (!scratch.overlay) return`. */
-    overlay?: RenderLayer<unknown>;
-    /** Declarative gesture bindings — the tool's entire input surface. The
-     *  gesture dispatcher consults these at active scope while this tool is
-     *  active, and at hotkey scope while it is held. See
-     *  `docs/superpowers/specs/2026-05-16-registry-unification-design.md`. */
-    bindings?: GestureBinding[];
-    /** Reflection escape hatch: when this `Tool` was produced by `defineTool`,
-     *  the source `ToolDef` is attached here so introspection consumers
-     *  (`buildRouteRegistry`, `findConflicts`, the toolkit-builder UI, the
-     *  reflection demo) can read the authored form — `hookName` in particular,
-     *  which the runtime `Tool` doesn't carry. Tools constructed without
-     *  `defineTool` may leave this undefined. Typed as `unknown` to keep this
-     *  file from importing the routing types — consumers cast at the use site. */
-    def?: unknown;
 }
 /** Internal alias for "a Tool of any scratch type" — used in registries and
  *  dispatchers that hold tools of heterogeneous scratch shapes. `any` is
@@ -4400,6 +4439,57 @@ interface ReorderDragHandlers {
 }
 declare function useReorderDragList(opts: UseReorderDragListOptions): ReorderDragHandlers;
 
+/** The only thing the hook needs to know about a bar's items: which are
+ *  skipped by arrow navigation. */
+type RovingItem = {
+    disabled?: boolean;
+};
+type UseRovingTabIndexOptions = {
+    /** In the same order as the elements carrying `itemClassName`. */
+    items: readonly RovingItem[];
+    /** Class on the focusable element of each item, inside the container the
+     *  returned `rootRef` is attached to. Their DOM order must match `items`. */
+    itemClassName: string;
+    /** Index that carries `tabIndex=0`. Defaults to the first enabled item; a
+     *  radiogroup-style bar passes its selected index so Tab lands on the
+     *  current value. */
+    tabStopIndex?: number;
+    /** Called with the new index as arrow/Home/End focus moves, before focus
+     *  moves. This is where a selection-follows-focus bar commits the value. */
+    onNavigate?: (index: number) => void;
+    /** Space/Enter on the item at `index`. When omitted the keypress is left
+     *  alone, which on a native `<button>` produces an ordinary click. */
+    onActivate?: (index: number) => void;
+};
+type RovingTabIndex<T extends HTMLElement = HTMLDivElement> = {
+    /** Attach to the container element that holds the items. */
+    rootRef: RefObject<T | null>;
+    /** `tabIndex` value for the item at `index`. */
+    tabIndexFor: (index: number) => 0 | -1;
+    /** `onKeyDown` for the item at `index`. */
+    onKeyDown: (index: number) => (e: KeyboardEvent<HTMLElement>) => void;
+};
+/**
+ * Roving tabindex for a bar of items: one item is in the tab order, and the
+ * arrow keys move focus among the rest, skipping disabled ones and wrapping
+ * at both ends. Home and End go to the first and last enabled item. Both axes
+ * navigate, so the same bar works laid out either way.
+ *
+ * Backs `ActionsBar`, `OptionsBar`, and `ToggleBar`.
+ *
+ * **When a bar should not use this.** Only when the bar owns its items. A
+ * container of arbitrary compound controls — a number field, a select, a
+ * color field — must leave the arrow keys alone, because those controls edit
+ * their own value with them; taking the arrows over would break the control
+ * to navigate between controls. `ToolOptionsBar` is that case and keeps plain
+ * DOM tab order. A bar whose items are all simple buttons is the case this
+ * hook is for.
+ *
+ * With every item disabled there is no tab stop and the bar drops out of the
+ * tab order entirely.
+ */
+declare function useRovingTabIndex<T extends HTMLElement = HTMLDivElement>(options: UseRovingTabIndexOptions): RovingTabIndex<T>;
+
 /**
  * Display-formatter for numbers. Use this anywhere a number is shown to
  * a user. The whole point: negative values get prefixed with the real
@@ -4413,5 +4503,5 @@ declare function useReorderDragList(opts: UseReorderDragListOptions): ReorderDra
 declare const MINUS_SIGN = "\u2212";
 declare function formatNumber(value: number, options?: Intl.NumberFormatOptions): string;
 
-export { ActionBar, ActionsBar, Badge, Button, Checkbox, ComboBox, ComboBoxItem, CurveEditor, DataGrid, Dialog, EDGE_PROFILES, Field, Input, KeyCap, KeySequence, MINUS_SIGN, NumberField, OptionsBar, Plot2D, PointPlotter, Powerline, Radio, RadioGroup, RangeSlider, Select, SelectItem, Sidebar, SidebarPanel, Slider, Switch, Tab, TabList, TabPanel, Tabs, ToggleBar, ToolButton, ToolGroup, ToolPalette, chromaAt, detectPlatform, dlog, fieldClasses, formatNumber, formatShortcut, formatShortcutParts, inferKeycapKind, isDebugEnabled, keyGlyph, keySpecFromKey, keySpecsFromMods, oklchToHex, paintGradientTrack, useReorderDragList };
-export type { ActionBarProps, ActionsBarItem, ActionsBarProps, ActionsBarSize, ActionsBarVariant, AddPointMode, AnchorRenderProps, AxesSettings, BadgeProps, BadgeShape, BadgeSize, BadgeTone, BadgeVariant, BoundsCtx, BuiltInEdgeName, ButtonProps, ButtonSize, ButtonVariant, CheckboxProps, ChromaCurve, ChromaCurvePoint, ComboBoxItemProps, ComboBoxOption, ComboBoxProps, ControlPoint, CurveDomain, CurveEditorProps, DataGridColumn, DataGridProps, DialogProps, EdgeCap, EdgeProfile, EndpointMode, FieldOrientation, FieldProps, FillSettings, GradientTrackOpts, GridSettings, InputProps, InterpolationMode, KeyCapProps, KeyCapVariant, KeySequenceProps, KeySpec$1 as KeySpec, KeycapKind, LayerListItem, LogicalMod, LogicalModSpec, NumberFieldProps, OptionsBarItem, OptionsBarProps, OptionsBarSize, OptionsBarVariant, Platform, Plot2DCoords, Plot2DHandle, Plot2DProps, PointPlotterProps, PowerlineProps, PowerlineSegment, RadioGroupProps, RadioProps, RangeSliderProps, ReorderDragHandlers, ReorderDragState, SelectItemProps, SelectOption, SelectProps, SidebarPanelProps, SidebarProps, SliderProps, SwitchProps, TabListProps, TabPanelProps, TabProps, TabsProps, Thumb, ThumbRenderCtx, ThumbShape, ToggleBarItem, ToggleBarProps, ToggleBarSize, ToggleBarVariant, ToolButtonProps, ToolGroupProps, ToolPaletteProps, TrackCtx, UseReorderDragListOptions };
+export { ActionBar, ActionsBar, Badge, Button, Checkbox, ComboBox, ComboBoxItem, CurveEditor, DataGrid, Dialog, EDGE_PROFILES, Field, Input, KeyCap, KeySequence, MINUS_SIGN, NumberField, OptionsBar, Plot2D, PointPlotter, Powerline, Radio, RadioGroup, RangeSlider, Select, SelectItem, Sidebar, SidebarPanel, Slider, Switch, Tab, TabList, TabPanel, Tabs, ToggleBar, ToolButton, ToolGroup, ToolPalette, chromaAt, detectPlatform, dlog, fieldClasses, formatNumber, formatShortcut, formatShortcutParts, inferKeycapKind, isDebugEnabled, keyGlyph, keySpecFromKey, keySpecsFromMods, oklchToHex, paintGradientTrack, useReorderDragList, useRovingTabIndex };
+export type { ActionBarProps, ActionsBarItem, ActionsBarProps, ActionsBarSize, ActionsBarVariant, AddPointMode, AnchorRenderProps, AxesSettings, BadgeProps, BadgeShape, BadgeSize, BadgeTone, BadgeVariant, BoundsCtx, BuiltInEdgeName, ButtonProps, ButtonSize, ButtonVariant, CheckboxProps, ChromaCurve, ChromaCurvePoint, ComboBoxItemProps, ComboBoxOption, ComboBoxProps, ControlPoint, CurveDomain, CurveEditorProps, DataGridColumn, DataGridProps, DialogProps, EdgeCap, EdgeProfile, EndpointMode, FieldOrientation, FieldProps, FillSettings, GradientTrackOpts, GridSettings, InputProps, InterpolationMode, KeyCapProps, KeyCapVariant, KeySequenceProps, KeySpec$1 as KeySpec, KeycapKind, LayerListItem, LogicalMod, LogicalModSpec, NumberFieldProps, OptionsBarItem, OptionsBarProps, OptionsBarSize, OptionsBarVariant, Platform, Plot2DCoords, Plot2DHandle, Plot2DProps, PointPlotterProps, PowerlineProps, PowerlineSegment, RadioGroupProps, RadioProps, RangeSliderProps, ReorderDragHandlers, ReorderDragState, RovingItem, RovingTabIndex, SelectItemProps, SelectOption, SelectProps, SidebarPanelProps, SidebarProps, SliderProps, SwitchProps, TabListProps, TabPanelProps, TabProps, TabsProps, Thumb, ThumbRenderCtx, ThumbShape, ToggleBarItem, ToggleBarProps, ToggleBarSize, ToggleBarVariant, ToolButtonProps, ToolGroupProps, ToolPaletteProps, TrackCtx, UseReorderDragListOptions, UseRovingTabIndexOptions };

package/dist/passthrough/weasel-ui.js

@@ -1,4 +1,4 @@
-export { m as ActionBar, s5 as ActionsBar, Ft as Badge, a as Button, o3 as Checkbox, p4 as ComboBox, m2 as ComboBoxItem, F as CurveEditor, l as DataGrid, c2 as Dialog, qe as EDGE_PROFILES, n as Field, u2 as Input, s2 as KeyCap, c as KeySequence, a2 as MINUS_SIGN, f3 as NumberField, s4 as OptionsBar, _ as Plot2D, n4 as PointPlotter, r as Powerline, u3 as Radio, l2 as RadioGroup, l3 as RangeSlider, p3 as Select, h as SelectItem, n2 as Sidebar, o4 as SidebarPanel, f2 as Slider, a3 as Switch, c3 as Tab, s6 as TabList, l4 as TabPanel, o6 as Tabs, s3 as ToggleBar, o5 as ToolButton, n3 as ToolGroup, _2 as ToolPalette, Re as chromaAt, u as detectPlatform, p as dlog, r2 as fieldClasses, o2 as formatNumber, d2 as formatShortcut, u4 as formatShortcutParts, o as inferKeycapKind, f as isDebugEnabled, e as keyGlyph, p2 as keySpecFromKey, d as keySpecsFromMods, Le as oklchToHex, Ie as paintGradientTrack, s as useReorderDragList } from '../chunk-FBZCQXI2.js';
-import '../chunk-6V7ROR7G.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, l as DataGrid, c2 as Dialog, qe as EDGE_PROFILES, n as Field, u2 as Input, s2 as KeyCap, c as KeySequence, a2 as MINUS_SIGN, f3 as NumberField, r2 as OptionsBar, _ as Plot2D, n4 as PointPlotter, r4 as Powerline, u3 as Radio, l2 as RadioGroup, l3 as RangeSlider, p3 as Select, h as SelectItem, n2 as Sidebar, o4 as SidebarPanel, f2 as Slider, a4 as Switch, c3 as Tab, s3 as TabList, l4 as TabPanel, o6 as Tabs, r as ToggleBar, o5 as ToolButton, n3 as ToolGroup, _2 as ToolPalette, ze as chromaAt, u as detectPlatform, p as dlog, r5 as fieldClasses, o2 as formatNumber, d2 as formatShortcut, u4 as formatShortcutParts, o as inferKeycapKind, f as isDebugEnabled, e as keyGlyph, p2 as keySpecFromKey, d as keySpecsFromMods, Re as oklchToHex, p5 as paintGradientTrack, s as useReorderDragList, a3 as useRovingTabIndex } from '../chunk-NRD3TDNQ.js';
+import '../chunk-ISEK5LXT.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-eSvpwV_P.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-eSvpwV_P.js';
+import { I as InstrumentSerializers, W as WorkspaceRecord, U as UndoStack, S as StorageAdapter } from '../_dts/useExperimentState-CJn2hHzd.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-CJn2hHzd.js';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { ReactNode } from 'react';
 import 'zustand/vanilla';

package/dist/state/index.js

@@ -1,5 +1,5 @@
-import { createLabStore, LabStoreProvider, WorkspaceIdProvider } from '../chunk-SSMHPMDV.js';
-export { LabStoreContext, LabStoreProvider, WorkspaceIdContext, WorkspaceIdProvider, createLabStore, createMemoryAdapter, decodeUrlHash, deserializeWorkspaces, emptyUndoStack, encodeUrlHash, labStorageKey, localStorageAdapter, noneAdapter, serializeWorkspaces, sessionStorageAdapter, urlHashAdapter, useExperimentState, useLabStore, useWorkspaceId } from '../chunk-SSMHPMDV.js';
+import { createLabStore, LabStoreProvider, WorkspaceIdProvider } from '../chunk-53XSBIUK.js';
+export { LabStoreContext, LabStoreProvider, WorkspaceIdContext, WorkspaceIdProvider, createLabStore, createMemoryAdapter, decodeUrlHash, deserializeWorkspaces, emptyUndoStack, encodeUrlHash, labStorageKey, localStorageAdapter, noneAdapter, serializeWorkspaces, sessionStorageAdapter, urlHashAdapter, useExperimentState, useLabStore, useWorkspaceId } from '../chunk-53XSBIUK.js';
 import { useRef } from 'react';
 import { jsx } from 'react/jsx-runtime';