@weasel-js/labkit 0.8.0 → 1.0.0

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-BwRCZYuo.js';
 
 /**
  * `renderSceneToCanvas` — substrate for detached, read-only scene views

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-XVBXYKFJ.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 { 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-BwRCZYuo.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
@@ -1880,6 +1905,7 @@ interface KeyHeldSpec {
 interface WheelSpec {
     kind: 'wheel';
     direction?: 'up' | 'down' | '*';
+    target?: TargetSpec;
     mods?: ModSpec;
     phase?: PhaseSpec;
 }
@@ -2022,6 +2048,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 +2384,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 +3360,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 +3404,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 +3485,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 +3497,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 +3513,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 +3529,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 +3549,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

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, 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, p5 as paintGradientTrack, s as useReorderDragList } from '../chunk-FP5LYDVX.js';
+import '../chunk-XVBXYKFJ.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';