@weasel-js/routing 1.5.0 → 1.5.2

package/dist/{index-BOlkWrA-.d.ts → index-D4hKg8yu.d.ts}

@@ -493,7 +493,7 @@ interface AffordanceHit {
  * The stylus fields are absent for mouse/touch on browsers that don't report
  * them, and for synthetic events. Consumers that want pressure-driven output
  * (e.g. `Stroke.vertexWidths` from a pencil stroke) read them off the samples
- * their `insert` dep receives — see `apps/site/demos/VertexWidthsDemo.tsx`.
+ * their `insert` dep receives — see `apps/site/demos/StrokeAndFillDemo.tsx`.
  */
 interface DragSample extends Point2 {
     /** 0..1. Mouse/touch report 0.5 while a button is held, per the spec. */
@@ -542,6 +542,10 @@ interface InvocationCtx {
          * per-sample stylus state when the browser reported it.
          * Accumulated by the dispatcher on every `pointermove` pump event.
          * Available only during `onMove` and `onEnd` calls (not on `start`).
+         *
+         * During `onMove` this is the dispatcher's live accumulator, and it grows
+         * under you — read it, don't retain it. On `onEnd` it is a snapshot, so
+         * that is where an action that keeps the trail should take it.
          * Used by `lassoSelectAction` to build its polygon vertex list and by
          * `insertAction`'s pencil kind to carry the freehand stroke.
          */
@@ -553,7 +557,11 @@ interface InvocationCtx {
         deltaZ: number;
     };
     multiTouch?: {
+        /** Canvas-local CSS pixels — see `MultitouchEvent.centroid`. Neither
+         *  `world` nor `screen`: it is the space `zoomAt` anchors in, so passing
+         *  it through `clientToWorld` removes the canvas origin twice. */
         centroid: Point2;
+        /** Distance between the two primary pointers, in CSS pixels. */
         spread: number;
         rotation: number;
         /**
@@ -565,6 +573,7 @@ interface InvocationCtx {
         pinch?: {
             startSpread: number;
             currentSpread: number;
+            /** Canvas-local, same as the enclosing `centroid`. */
             centroid: Point2;
         };
     };
@@ -972,8 +981,18 @@ interface ActionDispatch extends BindingSource {
      * synthesize it from the surrounding `DepRegistry` so predicates can
      * inspect selection / scene / etc. Predicates that don't need deps just
      * ignore the arg.
+     *
+     * `at` is the world point of the event being routed, when it has one — a
+     * click, a press, a long-press. An action that only applies somewhere
+     * (on a path segment, say) refuses other points here, so the dispatcher
+     * falls through to the next binding and hover prediction shows the
+     * action's `cursor` only where it would act. Palettes and keystrokes
+     * pass no point; treat absent as "anywhere".
      */
-    enabled?: (deps?: ActionDeps) => true | ActionDisabledReason;
+    enabled?: (deps?: ActionDeps, at?: {
+        x: number;
+        y: number;
+    }) => true | ActionDisabledReason;
     /**
      * Declarative eligibility rule, evaluated against the current
      * `RuleCtx` by the dispatcher before invoking `start()`. Omitted =
@@ -989,11 +1008,11 @@ interface ActionDispatch extends BindingSource {
     eligible?: Rule | Condition;
     /**
      * CSS cursor shown while the pointer hovers a spot where this action
-     * would win the drag. The hover-cursor pump (in `useGestureDispatcher`)
-     * runs `Dispatcher.resolveOnly` on each idle pointermove — the same
-     * match walk a real pointerdown takes — and applies the winning
-     * action's `cursor`, so the hint and the actual click target stay in
-     * sync by construction. Omitted = no override (the active tool's
+     * would win the drag — or, when the drag's winner declares no cursor,
+     * the click. The hover-cursor pump (in `useGestureDispatcher`) runs
+     * `Dispatcher.resolveOnly` on each idle pointermove — the same match
+     * walk a real press takes — and applies the winning action's `cursor`,
+     * so the hint and the actual target stay in sync by construction. Omitted = no override (the active tool's
      * `Tool.cursor` shows). Affordance hits are resolved earlier in the
      * pump via `AffordanceRegion.cursor` and never reach this field.
      *
@@ -1231,14 +1250,6 @@ interface ToolCtx<TScratch = unknown> {
      *  zoom/pan tools to convert event clientX/clientY to canvas-relative
      *  anchors. */
     canvasRect: DOMRect;
-    /** Screen-space pointer coords relative to `canvasRect`. Useful for
-     *  viewport tools that pan/zoom in screen space (e.g. hand-pan
-     *  computes deltas in pixels, not world units). Optional — populated
-     *  by the dispatcher on pointer events; absent on keyboard events. */
-    screenPoint?: {
-        x: number;
-        y: number;
-    };
     /** Optional debug sink. When `<Canvas debug={...}>` is enabled, Canvas
      *  threads its sink here so tool-internal hit math (handle hitboxes,
      *  rotation handle, etc.) lands in the same overlay as Canvas's own
@@ -1938,10 +1949,9 @@ declare function openPointerSession(origin: Element, down: PointerEvent | React.
 /** What the registry knows at dispatch time. */
 interface EligibilityState {
     focusedId: string | null;
-    heldTriggers: ReadonlySet<string>;
-    /** Ids the host reports as hotkey-engaged. A declared `offhand` registers
-     *  the binding, but `tool.offhand`'s invoker still reports engagement by
-     *  pushing an id — this retires only if that contract changes. */
+    /** Ids the host reports as hotkey-engaged. A held `offhand` trigger reaches
+     *  here the same way a palette pick does: the `tool.offhand` action pushes
+     *  the tool's id onto the active-tool context's hotkey stack. */
     engagedIds?: ReadonlySet<string>;
     /** Whether the active mode allows these capability tags. Omitted → allow. */
     allows?: (tags: readonly CapabilityTag[]) => boolean;
@@ -1983,7 +1993,9 @@ declare function mergeContributions(...bundles: readonly Contribution[][]): Cont
  */
 interface ToolDef<TScratch = void, TOverlay = unknown> {
     id: string;
-    /** Capability tags for modality eligibility. Forwarded onto `Tool.capabilities`. */
+    /** Capability tags for modality eligibility. `defineTool` forwards these
+     *  onto `Tool.eligibility.capabilities`, which is where every gate reads
+     *  them — the assembled `Tool` carries no `capabilities` of its own. */
     capabilities?: CapabilityTag[];
     /**
      * Actions this tool owns and needs registered while it is in the tools

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { i as ALWAYS, c as Action, j as ActionDeps, k as ActionDisabledReason, k as ActionDisabledReasonValue, l as ActionDispatch, m as ActionEnabledResult, n as ActionEntry, o as ActionPresentation, p as ActionSource, q as ActionsProp, A as ActionsRegistry, a as AffordanceHit, r as AnyTool, d as AnyToolOf, B as BindingOpts, s as BindingScope, t as BindingSource, v as BodyPredicate, w as BoundGesture, x as Bounds, y as BuildRuleCtxArgs, z as COARSE_TARGET_SCALE, E as Condition, F as Conflict, C as Contribution, G as ContributionChrome, H as ContributionRouting, I as DEFAULT_ALLOWED_CAPABILITIES, J as DEFAULT_DEVICE_PROFILE, K as DebugSink, L as DepName, b as DepSchema, M as DetectedDeviceFacts, N as DeviceProfile, P as DispatchLogEntry, D as Dispatcher, Q as DispatcherContext, U as DragSample, V as Eligibility, W as EligibilityState, X as GestureBinding, Y as HandleKind, Z as HitShape, _ as HotkeyTrigger, $ as INGEST_STRING_MIMES, a0 as ImmediateInvoker, a1 as InvocationCtx, a2 as Invoker, a3 as KeyBinding, a4 as MatchResult, a5 as ModeSwitchLogEntry, a6 as ModifierState, a7 as NEVER, a8 as NodeId, a9 as OngoingHandle, aa as OngoingInvoker, ab as OngoingOverlay, O as OverlayPosition, ac as OverlayRole, ad as PREDICATE_TARGET, ae as Point2, af as PointerSession, ag as PointerSessionCallbacks, ah as PointerSessionCancelReason, ai as PointerSessionOptions, aj as RegistryEntry, ak as ResizeAnchor, al as ResolveAllOptions, am as ResolveOnlyResult, an as ResolvedCandidate, ao as Rule, R as RuleCtx, S as ScopedBinding, ap as ScratchKey, aq as ScratchStore, ar as SelectionApi, as as SelectionExtendKey, at as SelectionMode, au as Selector, av as TOOL_OFFHAND_ID, T as Tool, aw as ToolBounds, ax as ToolCtx, ay as ToolDef, az as ToolKeybinding, aA as ToolModifiers, aB as ToolOffhandBindingSpec, aC as ToolPresentation, aD as ToolSlot, aE as TraceLogEntry, aF as UiOngoingControl, aG as View, aH as ViewportToolDef, aI as actionBindings, aJ as buildDepsFromRequires, aK as buildRouteRegistry, aL as buildRuleCtx, aM as buildToolOffhandBindings, aN as clientToCanvas, aO as clientToCanvasRect, aP as createDispatcher, aQ as defineTool, aR as defineViewportTool, aS as deleteScratch, aT as describeRule, aU as dlog, aV as evaluate, aW as evaluateEnabled, aX as filterEligible, aY as findConflicts, aZ as getScratch, a_ as isAnchor, a$ as isAnchorOrControl, b0 as isBody, b1 as isControlHandle, b2 as isEditableTarget, b3 as isEmpty, b4 as isResizeHandle, b5 as isRotateHandle, b6 as isSelectedBody, b7 as isUnselectedBody, b8 as itemsFromClipboardData, b9 as itemsFromDataTransfer, ba as itemsFromFiles, bb as liveScope, bc as makeToolOffhandAction, bd as matchBest, be as matchSorted, bf as matchesKeyBinding, bg as mergeContributions, bh as offhandKeyFor, bi as openPointerSession, bj as pointerGestureId, bk as recordModeSwitch, bl as reportRouteConflicts, bm as resolveDeviceProfile, bn as resolveParams, bo as routeGestureForSpecKind, bp as routesForSpec, bq as scopeBindings, br as scratchKey, bs as setScratch, bt as specificity, bu as targetConsultsAffordance, bv as validateActionDefaultBinding, bw as validateActionId } from './index-BOlkWrA-.js';
+export { i as ALWAYS, c as Action, j as ActionDeps, k as ActionDisabledReason, k as ActionDisabledReasonValue, l as ActionDispatch, m as ActionEnabledResult, n as ActionEntry, o as ActionPresentation, p as ActionSource, q as ActionsProp, A as ActionsRegistry, a as AffordanceHit, r as AnyTool, d as AnyToolOf, B as BindingOpts, s as BindingScope, t as BindingSource, v as BodyPredicate, w as BoundGesture, x as Bounds, y as BuildRuleCtxArgs, z as COARSE_TARGET_SCALE, E as Condition, F as Conflict, C as Contribution, G as ContributionChrome, H as ContributionRouting, I as DEFAULT_ALLOWED_CAPABILITIES, J as DEFAULT_DEVICE_PROFILE, K as DebugSink, L as DepName, b as DepSchema, M as DetectedDeviceFacts, N as DeviceProfile, P as DispatchLogEntry, D as Dispatcher, Q as DispatcherContext, U as DragSample, V as Eligibility, W as EligibilityState, X as GestureBinding, Y as HandleKind, Z as HitShape, _ as HotkeyTrigger, $ as INGEST_STRING_MIMES, a0 as ImmediateInvoker, a1 as InvocationCtx, a2 as Invoker, a3 as KeyBinding, a4 as MatchResult, a5 as ModeSwitchLogEntry, a6 as ModifierState, a7 as NEVER, a8 as NodeId, a9 as OngoingHandle, aa as OngoingInvoker, ab as OngoingOverlay, O as OverlayPosition, ac as OverlayRole, ad as PREDICATE_TARGET, ae as Point2, af as PointerSession, ag as PointerSessionCallbacks, ah as PointerSessionCancelReason, ai as PointerSessionOptions, aj as RegistryEntry, ak as ResizeAnchor, al as ResolveAllOptions, am as ResolveOnlyResult, an as ResolvedCandidate, ao as Rule, R as RuleCtx, S as ScopedBinding, ap as ScratchKey, aq as ScratchStore, ar as SelectionApi, as as SelectionExtendKey, at as SelectionMode, au as Selector, av as TOOL_OFFHAND_ID, T as Tool, aw as ToolBounds, ax as ToolCtx, ay as ToolDef, az as ToolKeybinding, aA as ToolModifiers, aB as ToolOffhandBindingSpec, aC as ToolPresentation, aD as ToolSlot, aE as TraceLogEntry, aF as UiOngoingControl, aG as View, aH as ViewportToolDef, aI as actionBindings, aJ as buildDepsFromRequires, aK as buildRouteRegistry, aL as buildRuleCtx, aM as buildToolOffhandBindings, aN as clientToCanvas, aO as clientToCanvasRect, aP as createDispatcher, aQ as defineTool, aR as defineViewportTool, aS as deleteScratch, aT as describeRule, aU as dlog, aV as evaluate, aW as evaluateEnabled, aX as filterEligible, aY as findConflicts, aZ as getScratch, a_ as isAnchor, a$ as isAnchorOrControl, b0 as isBody, b1 as isControlHandle, b2 as isEditableTarget, b3 as isEmpty, b4 as isResizeHandle, b5 as isRotateHandle, b6 as isSelectedBody, b7 as isUnselectedBody, b8 as itemsFromClipboardData, b9 as itemsFromDataTransfer, ba as itemsFromFiles, bb as liveScope, bc as makeToolOffhandAction, bd as matchBest, be as matchSorted, bf as matchesKeyBinding, bg as mergeContributions, bh as offhandKeyFor, bi as openPointerSession, bj as pointerGestureId, bk as recordModeSwitch, bl as reportRouteConflicts, bm as resolveDeviceProfile, bn as resolveParams, bo as routeGestureForSpecKind, bp as routesForSpec, bq as scopeBindings, br as scratchKey, bs as setScratch, bt as specificity, bu as targetConsultsAffordance, bv as validateActionDefaultBinding, bw as validateActionId } from './index-D4hKg8yu.js';
 export { ChannelRef, DescribeRouteOptions, GESTURE_DESCRIPTORS, GestureArgSpec, GestureDescriptor, GestureName, IngestItem, InputEvent, ModRequirement, ModifierKey, ParsedModifiers, ParsedRoute, PhaseAtom, PhaseContext, RESERVED_ID_NAMES, RESERVED_ID_PREFIXES, ROUTE_FIELD_DEFINITIONS, ROUTE_TERMS, RouteDescriptionPart, RouteFieldName, RouteTermLabel, canonicalModifiers, collapseShiftPairs, describeRoute, describeRouteParts, formatPhaseAtom, formatRoute, getGestureDescriptor, isKnownGestureName, matchKey, matchModifiers, matchPhase, matchSpec, matchTarget, parseRoute } from '@weasel-js/gestures';
 import '@weasel-js/modes';
 import 'react';

package/dist/index.js

@@ -1,5 +1,5 @@
-import { isDev } from './chunk-Y5FHAA4U.js';
-export { ALWAYS, COARSE_TARGET_SCALE, DEFAULT_ALLOWED_CAPABILITIES, DEFAULT_DEVICE_PROFILE, GESTURE_DESCRIPTORS, INGEST_STRING_MIMES, NEVER, PREDICATE_TARGET, RESERVED_ID_NAMES, RESERVED_ID_PREFIXES, ROUTE_FIELD_DEFINITIONS, ROUTE_TERMS, TOOL_OFFHAND_ID, actionBindings, buildDepsFromRequires, buildRouteRegistry, buildRuleCtx, buildToolOffhandBindings, canonicalModifiers, clientToCanvas, clientToCanvasRect, collapseShiftPairs, createDispatcher, describeRoute, describeRouteParts, describeRule, dlog, evaluate, filterEligible, findConflicts, formatPhaseAtom, formatRoute, getGestureDescriptor, isEditableTarget, isKnownGestureName, itemsFromClipboardData, itemsFromDataTransfer, itemsFromFiles, liveScope, makeToolOffhandAction, matchBest, matchKey, matchModifiers, matchPhase, matchSorted, matchSpec, matchTarget, matchesKeyBinding, offhandKeyFor, openPointerSession, parseRoute, pointerGestureId, recordModeSwitch, reportRouteConflicts, resolveDeviceProfile, resolveParams, routeGestureForSpecKind, routesForSpec, scopeBindings, specificity, targetConsultsAffordance, validateActionDefaultBinding, validateActionId } from './chunk-Y5FHAA4U.js';
+import { isDev } from './chunk-H5AGTB2J.js';
+export { ALWAYS, COARSE_TARGET_SCALE, DEFAULT_ALLOWED_CAPABILITIES, DEFAULT_DEVICE_PROFILE, GESTURE_DESCRIPTORS, INGEST_STRING_MIMES, NEVER, PREDICATE_TARGET, RESERVED_ID_NAMES, RESERVED_ID_PREFIXES, ROUTE_FIELD_DEFINITIONS, ROUTE_TERMS, TOOL_OFFHAND_ID, actionBindings, buildDepsFromRequires, buildRouteRegistry, buildRuleCtx, buildToolOffhandBindings, canonicalModifiers, clientToCanvas, clientToCanvasRect, collapseShiftPairs, createDispatcher, describeRoute, describeRouteParts, describeRule, dlog, evaluate, filterEligible, findConflicts, formatPhaseAtom, formatRoute, getGestureDescriptor, isEditableTarget, isKnownGestureName, itemsFromClipboardData, itemsFromDataTransfer, itemsFromFiles, liveScope, makeToolOffhandAction, matchBest, matchKey, matchModifiers, matchPhase, matchSorted, matchSpec, matchTarget, matchesKeyBinding, offhandKeyFor, openPointerSession, parseRoute, pointerGestureId, recordModeSwitch, reportRouteConflicts, resolveDeviceProfile, resolveParams, routeGestureForSpecKind, routesForSpec, scopeBindings, specificity, targetConsultsAffordance, validateActionDefaultBinding, validateActionId } from './chunk-H5AGTB2J.js';
 import { RESERVED_ID_PREFIXES, RESERVED_ID_NAMES } from '@weasel-js/gestures';
 
 // src/interactions/actions/action.ts

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/interactions/actions/action.ts","../src/interactions/actions/actionEnabled.ts","../src/interactions/dispatcher/predicates.ts","../src/contributions/merge.ts","../src/tools/defineTool.ts","../src/tools/defineViewportTool.ts","../src/interactions/scratchKey.ts"],"names":["RESERVED_ID_PREFIXES","RESERVED_ID_NAMES"],"mappings":"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","file":"index.js","sourcesContent":["/**\n * @experimental\n * The `Action` descriptor, split along the line the dispatcher reads.\n * `ActionDispatch` is everything routing consults to decide whether an action\n * runs and what happens when it does; `ActionPresentation` is what a palette,\n * menu or toolbar renders. `Action` is both.\n */\nimport type { ReactNode } from 'react';\nimport type { CursorSpec } from '@weasel-js/cursor';\nimport type { ActionDeps, Invoker } from './invoker';\nimport type { BindingSource } from './binding';\nimport type { DepName } from '../../index';\n\n/**\n * @experimental\n * Closed enum of reasons an action might report itself as disabled. The\n * consumer (palette, menu, etc.) maps these symbolic values to display\n * strings via its own label map.\n */\nexport const ActionDisabledReason = {\n  SelectionRequired: 'selection-required',\n  SceneEmpty: 'scene-empty',\n  NotApplicable: 'not-applicable',\n  /** Sentinel: the predicate threw. Surfaced by `evaluateEnabled`'s catch. */\n  PredicateThrew: 'predicate-threw',\n} as const;\n/** Why an action is unavailable right now. */\nexport type ActionDisabledReason =\n  (typeof ActionDisabledReason)[keyof typeof ActionDisabledReason];\n\n/**\n * @experimental\n * What a palette, menu or toolbar renders for an action. No part of this is\n * read during dispatch.\n */\nexport interface ActionPresentation {\n  label: string;\n  /** Inline-SVG icon for palette / toolbar surfaces. Mirrors\n   *  `ToolPresentation.icon` so a generic `<ActionBar>` can render from\n   *  action metadata the same way `<ToolPalette>` renders from tool\n   *  metadata. May be a static `ReactNode` or a function (rare; useful\n   *  for state-aware icons like a \"lock\" toggle). */\n  icon?: ReactNode | (() => ReactNode);\n  /** Grouping key for palette/menu surfaces. Free-form string; the kit\n   *  ships defaults for `'align'` (six edges/centers), `'distribute'`\n   *  (two axes), and recommends `'pathfinder'` for boolean ops. */\n  group?: string;\n  /** Display override for the keyboard shortcut. When omitted, palette\n   *  surfaces derive a label from `defaultBinding` via their own\n   *  formatter. */\n  shortcut?: string;\n}\n\n/**\n * @experimental\n * What routing consults: the bindings that reach the action, the deps its\n * invoker reads, the gates it passes, and the cursors it claims.\n */\nexport interface ActionDispatch extends BindingSource {\n  /** Names of the deps this action's invoker reads (keys of `DepSchema`).\n   *  The dispatcher (and `trigger`, when `requires` is present) resolves\n   *  each name against the `DepRegistry` at invocation time and passes the\n   *  resulting bag to the invoker. Dev builds warn when the invoker reads a\n   *  dep it didn't declare here — see `buildDepsFromRequires`. */\n  requires?: readonly DepName[];\n  /** Pluggable invocation strategy. The gesture dispatcher routes matched\n   *  bindings through `invoker.start` / `invoker.run` depending on timing.\n   *  All kit-standard descriptors ship one; consumer-supplied actions\n   *  without an invoker can still register but won't be triggered. */\n  invoker?: Invoker;\n  /** When set to `'hotkey'`, this action's `defaultBinding` rides the hotkey\n   *  `BindingScope` instead of the ambient scope — meaning it beats any\n   *  active-tool binding on the same input shape. Use for tool-switch\n   *  shortcuts and global held-key triggers. Default: ambient. */\n  scope?: 'hotkey';\n  /**\n   * @experimental\n   * Optional predicate the command palette consults when rendering. Return\n   * `true` when the action is currently triggerable. Return a reason string\n   * (e.g. `'Selection required'`) when disabled — the palette greys out\n   * the row, skips it in keyboard nav, ignores clicks, and shows the\n   * reason next to the label. Keystroke dispatch (the registered binding)\n   * is unaffected; the action's own `run` should self-guard.\n   *\n   * **Contract:** must be pure (no side effects), fast (< 4ms in dev), and\n   * must not throw. If a call throws or exceeds the budget in dev mode,\n   * `evaluateEnabled` logs a one-time warning per action id; throws are\n   * caught and treated as disabled with reason `'(predicate threw)'`.\n   *\n   * Snapshot-on-open semantics: the palette evaluates `enabled` once when\n   * opened and does NOT re-evaluate on selection changes while open. Live\n   * reactive updates are deferred — palette is short-lived.\n   *\n   * The reason set is a closed enum — to add a new reason, edit\n   * `ActionDisabledReason` and the consumer's display map.\n   *\n   * The optional `deps` argument is the same bag passed to\n   * `ImmediateInvoker.run`; callers (`evaluateEnabled` / the ActionBar) may\n   * synthesize it from the surrounding `DepRegistry` so predicates can\n   * inspect selection / scene / etc. Predicates that don't need deps just\n   * ignore the arg.\n   */\n  enabled?: (deps?: ActionDeps) => true | ActionDisabledReason;\n  /**\n   * Declarative eligibility rule, evaluated against the current\n   * `RuleCtx` by the dispatcher before invoking `start()`. Omitted =\n   * always eligible.\n   *\n   * Accepts either a fluent `Condition` (callable with `.rule`) or a\n   * raw `Rule` tree; the dispatcher normalizes via `.rule` unwrap.\n   *\n   * Prefer `capability:`-based rules (e.g. `{ capability: 'transforms-selection' }`)\n   * over `mode:` rules — capability rules survive new modes being added\n   * that allow the same capability.\n   */\n  eligible?:\n    | import('../../eligibility').Rule\n    | import('../../eligibility').Condition;\n  /**\n   * CSS cursor shown while the pointer hovers a spot where this action\n   * would win the drag. The hover-cursor pump (in `useGestureDispatcher`)\n   * runs `Dispatcher.resolveOnly` on each idle pointermove — the same\n   * match walk a real pointerdown takes — and applies the winning\n   * action's `cursor`, so the hint and the actual click target stay in\n   * sync by construction. Omitted = no override (the active tool's\n   * `Tool.cursor` shows). Affordance hits are resolved earlier in the\n   * pump via `AffordanceRegion.cursor` and never reach this field.\n   *\n   * Static value only. Prediction runs `enabled()` but cannot run the\n   * invoker, so an action that matches yet bails at `start()` (empty\n   * handle) may still show its cursor — keep `enabled` accurate for\n   * actions that declare one.\n   */\n  cursor?: CursorSpec;\n  /**\n   * CSS cursor shown while THIS action's ongoing handle is in flight —\n   * grabbing while panning, `move` while dragging a selection, `crosshair`\n   * while pulling a marquee.\n   *\n   * Separate from `cursor` because the two answer different questions:\n   * `cursor` is a prediction (\"a drag from here would pan\"), this is a state\n   * (\"you are panning\"). An action can declare either, both, or neither;\n   * with only `cursor` set, the hover hint holds for the duration of the\n   * gesture.\n   *\n   * This is where mid-gesture cursors live now. They used to come from the\n   * tool side — `ViewportToolDef.engaged.cursor` for a phase-gated string,\n   * or a function-form `Tool.cursor` reading the gesture scratch out of the\n   * tool-routing dispatcher. Both belonged to a pipeline whose whole job was\n   * being taken over by bindings, and neither could describe a cursor for an\n   * action a tool doesn't own.\n   */\n  activeCursor?: CursorSpec;\n}\n\n/**\n * @experimental\n * Single registered action. v1: one binding per action.\n */\nexport interface Action extends ActionDispatch, ActionPresentation {}\n\n/**\n * @experimental\n * The whole of an actions registry the dispatcher reads. It walks the list\n * once per event to build its actionId lookup and never mutates it, so the\n * routing side depends on this rather than on `ActionsRegistry`, whose\n * register / mute / trigger surface is the React provider's.\n */\nexport interface ActionSource {\n  list(): readonly Action[];\n}\n","/**\n * @experimental\n * Palette-side evaluation of `Action.enabled`. The dispatcher calls the\n * predicate raw as a gate; this is the surface that also enforces the\n * contract the predicate's JSDoc states — no throwing, under 4ms in dev.\n */\nimport type { ActionDeps } from './invoker';\nimport { ActionDisabledReason, type Action } from './action';\nimport { isDev } from '../../devFlag';\n\n/**\n * @experimental\n * Result of evaluating an Action's `enabled` predicate.\n */\nexport interface ActionEnabledResult {\n  enabled: boolean;\n  reason?: ActionDisabledReason;\n}\n\nconst enabledSlowWarned = new Set<string>();\nconst enabledThrewWarned = new Set<string>();\nconst ENABLED_BUDGET_MS = 4;\n/**\n * @experimental\n * Safely evaluate an action's `enabled` predicate. Returns `{enabled: true}`\n * when no predicate is supplied. Catches throws and treats them as disabled\n * with reason `'(predicate threw)'`. In dev mode, warns once per action id\n * when a single call exceeds 4ms (single frame at 240fps — generous; real\n * predicates should be sub-millisecond).\n */\nexport function evaluateEnabled(\n  action: Action,\n  deps?: ActionDeps,\n): ActionEnabledResult {\n  if (!action.enabled) return { enabled: true };\n  const dev = isDev();\n  const now = (typeof performance !== 'undefined' && typeof performance.now === 'function')\n    ? () => performance.now()\n    : () => Date.now();\n  const start = dev ? now() : 0;\n  try {\n    const result = action.enabled(deps);\n    if (dev) {\n      const elapsed = now() - start;\n      if (elapsed > ENABLED_BUDGET_MS && !enabledSlowWarned.has(action.id)) {\n        enabledSlowWarned.add(action.id);\n        console.warn(\n          `weasel actions: enabled() for action \"${action.id}\" took ${elapsed.toFixed(2)}ms ` +\n          `(budget ${ENABLED_BUDGET_MS}ms). The predicate must be pure and fast — see Action.enabled JSDoc.`,\n        );\n      }\n    }\n    if (result === true) return { enabled: true };\n    return { enabled: false, reason: result };\n  } catch (e) {\n    if (dev && !enabledThrewWarned.has(action.id)) {\n      enabledThrewWarned.add(action.id);\n      console.warn(\n        `weasel actions: enabled() for action \"${action.id}\" threw; treating as disabled. ` +\n        `The predicate must not throw — see Action.enabled JSDoc.`,\n        e,\n      );\n    }\n    return { enabled: false, reason: ActionDisabledReason.PredicateThrew };\n  }\n}\n","/**\n * Named predicates for `defaultBinding.target.kindOf`. Each matches the\n * existing `kindOf` signature `(target: unknown, bodyTarget?: string) => boolean`\n * so they drop into action descriptors without a wrapper:\n *\n *     target: { kindOf: isAnchor }\n *\n * Single source of truth for \"what does this affordance kind mean\" — adding\n * a new predicate here is what enables every action that needs the same\n * shape to read it. Drift prevention.\n */\n\n// ─── Body-class predicates (read the second arg) ───────────────────────\n\n/** A predicate that resolves from `bodyTarget` alone. The exclusive-claim\n *  filter reads `readsAffordance`: without it a body predicate looks like it\n *  consults the hit, and survives a claim that should have barred it. */\nexport type BodyPredicate = ((target: unknown, bodyTarget?: string) => boolean)\n  & { readsAffordance: false };\n\nfunction bodyPredicate(\n  fn: (target: unknown, bodyTarget?: string) => boolean,\n): BodyPredicate {\n  return Object.assign(fn, { readsAffordance: false as const });\n}\n\n/** Matches any body hit — selected or unselected node body. */\nexport const isBody: BodyPredicate = bodyPredicate((_target, bodyTarget) =>\n  bodyTarget === 'selected-body' || bodyTarget === 'unselected-body');\n\n/** Body hit specifically already in the selection. */\nexport const isSelectedBody: BodyPredicate = bodyPredicate((_target, bodyTarget) =>\n  bodyTarget === 'selected-body');\n\n/** Body hit specifically NOT in the selection. */\nexport const isUnselectedBody: BodyPredicate = bodyPredicate((_target, bodyTarget) =>\n  bodyTarget === 'unselected-body');\n\n/** Empty-canvas hit — no node beneath cursor. */\nexport const isEmpty: BodyPredicate = bodyPredicate((_target, bodyTarget) =>\n  bodyTarget === 'empty');\n\n// ─── Affordance-kind predicates (read the first arg) ───────────────────\n\nfunction kindOf(target: unknown): string | undefined {\n  if (typeof target !== 'object' || target === null) return undefined;\n  const k = (target as { kind?: unknown }).kind;\n  return typeof k === 'string' ? k : undefined;\n}\n\n/** Any corner resize handle — top-left/top-right/bottom-left/bottom-right. */\nexport const isResizeHandle = (target: unknown): boolean => {\n  const k = kindOf(target);\n  return k !== undefined && k.startsWith('handle:');\n};\n\n/** The rotate-around-center handle above the bounding box. */\nexport const isRotateHandle = (target: unknown): boolean =>\n  kindOf(target) === 'rotate-handle';\n\n/** Any path anchor (the on-curve dot). */\nexport const isAnchor = (target: unknown): boolean => {\n  const k = kindOf(target);\n  return k !== undefined && /^anchor:\\d+$/.test(k);\n};\n\n/** Either control handle (controlIn or controlOut). */\nexport const isControlHandle = (target: unknown): boolean => {\n  const k = kindOf(target);\n  return k !== undefined && /^(controlIn|controlOut):\\d+$/.test(k);\n};\n\n/** Any of the three anchor-editing affordances (anchor + both controls). */\nexport const isAnchorOrControl = (target: unknown): boolean =>\n  isAnchor(target) || isControlHandle(target);\n","import type { Contribution } from './types';\n\n/**\n * Concatenate contribution bundles into one registry, preserving order —\n * entry order decides which of two same-specificity bindings in one scope\n * tier wins, so it is part of the result, not an accident of it.\n *\n * Throws on a duplicate id rather than dropping one: a feature silently\n * losing its bindings is the failure this registry exists to make loud.\n */\nexport function mergeContributions(...bundles: readonly Contribution[][]): Contribution[] {\n  const out: Contribution[] = [];\n  const seen = new Set<string>();\n  for (const bundle of bundles) {\n    for (const entry of bundle) {\n      if (seen.has(entry.id)) {\n        throw new Error(\n          `mergeContributions: duplicate contribution id \"${entry.id}\". `\n          + `Two bundles registered the same id; rename one or merge them by hand.`,\n        );\n      }\n      seen.add(entry.id);\n      out.push(entry);\n    }\n  }\n  return out;\n}\n","// src/tools/defineTool.ts\nimport type { Tool, ToolCtx } from './types';\nimport type { ToolDef } from './routeTypes';\nimport { RESERVED_ID_NAMES, RESERVED_ID_PREFIXES } from '@weasel-js/gestures';\nimport type { CursorSpec } from '@weasel-js/cursor';\n\n/** Validate that `id` is usable as a tool / channel id in the route\n *  grammar. Rejects ids that start with a reserved sigil (would shadow\n *  future grammar extensions) and ids that collide with phase keywords\n *  (would parse as the bare-phase shorthand). */\nfunction validateId(id: string, kind: 'tool' | 'action'): void {\n  if (id.length === 0) {\n    throw new Error(`weasel: ${kind} id may not be empty`);\n  }\n  if (RESERVED_ID_PREFIXES.has(id[0]!)) {\n    throw new Error(\n      `weasel: ${kind} id \"${id}\" starts with reserved sigil \"${id[0]}\" ` +\n      `(reserved set: ${[...RESERVED_ID_PREFIXES].join(' ')})`,\n    );\n  }\n  if (RESERVED_ID_NAMES.has(id)) {\n    throw new Error(\n      `weasel: ${kind} id \"${id}\" collides with a reserved phase keyword ` +\n      `(reserved: ${[...RESERVED_ID_NAMES].join(', ')})`,\n    );\n  }\n}\n\n/**\n * Build a `Tool<TScratch>` from a declarative `ToolDef<TScratch>`.\n *\n * This used to be a translator: `ToolDef` carried `initial` / `engaged` phase\n * tables of hit-keyed route handlers, and `defineTool` compiled them into the\n * imperative `pointer` / `drag` / `keyboard` / `wheel` handlers the\n * tool-routing dispatcher called. Both ends of that are gone — tools declare\n * `bindings` and the gesture dispatcher routes them — so what remains is\n * identity plumbing plus the id check and the cursor resolver.\n *\n * It stays a function rather than becoming a spread because the id validation\n * and the `initScratch` / `cursor` defaults are worth applying uniformly, and\n * because `Tool.def` gives reflection a handle on the authored form.\n */\nexport function defineTool<TScratch = void, TOverlay = unknown>(\n  def: ToolDef<TScratch, TOverlay>,\n): Tool<TScratch, TOverlay> {\n  validateId(def.id, 'tool');\n\n  // Normalize `CursorSpec | ((ctx) => CursorSpec)` to the function form so\n  // callers have one shape to deal with. Returns '' (not undefined) so the\n  // signature satisfies `Tool.cursor: (ctx) => CursorSpec`.\n  const resolveCursor = (ctx: ToolCtx<TScratch>): CursorSpec => {\n    if (def.cursor == null) return '';\n    return typeof def.cursor === 'function' ? def.cursor(ctx) : def.cursor;\n  };\n\n  return {\n    id: def.id,\n    eligibility: {\n      focus: true,\n      capabilities: def.capabilities,\n      ...(def.hotkey ? { offhand: def.hotkey } : {}),\n    },\n    actions: def.actions,\n    def,\n    presentation: def.presentation as Tool<TScratch>['presentation'],\n    keybinding: def.keybinding,\n    onActivate: def.onActivate,\n    onDeactivate: def.onDeactivate,\n    initScratch: def.initScratch ?? (() => null as unknown as TScratch),\n    cursor: resolveCursor,\n    bindings: def.bindings,\n    overlay: def.overlay,\n    overlayPosition: def.overlayPosition,\n  };\n}\n","import type { Tool } from './types';\nimport type { ViewportToolDef } from './routeTypes';\nimport { defineTool } from './defineTool';\n\n/**\n * Define a tool that acts on the viewport rather than the scene.\n *\n * This used to do real work: `ViewportPhaseDef` was a narrowed `PhaseDef`\n * (no click routes, drag restricted to the function form), and the factory\n * lifted it back to the permissive shape before handing it to `defineTool`.\n * With phase tables gone there is no shape left to narrow — a viewport tool\n * declares `bindings` like any other, pointing at `viewport.*` actions.\n *\n * It survives as an authoring signal. `defineViewportTool` at the top of a\n * hook says \"this tool moves the camera, not the drawing\", which is worth\n * more than the type gymnastics it replaced.\n */\nexport function defineViewportTool<TScratch = void, TOverlay = unknown>(\n  def: ViewportToolDef<TScratch, TOverlay>,\n): Tool<TScratch, TOverlay> {\n  return defineTool<TScratch, TOverlay>(def);\n}\n","/**\n * Typed keys for the gesture/behavior scratch store.\n *\n * Gestures expose `ctx.scratch: Record<string, unknown>` as a per-gesture\n * mutable bag that behaviors use to stash state across `onDown` / `onMove`\n * / `onEnd` calls. The store is `unknown`-valued because behaviors are\n * tool-agnostic — a single behavior may run under different tools with\n * different scratch shapes. Without a typing convention every read site\n * has to `(ctx.scratch as <some shape>)[KEY]`, and a writer changing the\n * shape can silently break readers with no compile-time signal.\n *\n * `ScratchKey<T>` is a phantom-typed string that carries its payload type\n * via a branded interface. `getScratch` and `setScratch` use the brand to\n * narrow / constrain at the typing layer; at runtime the key is just its\n * underlying string and the store remains a plain `Record`.\n *\n * @example\n * ```ts\n * // Module-level (or behavior-level) constant, shared by writer + reader:\n * const LASSO_VERTICES = scratchKey<readonly { x: number; y: number }[]>('lasso.vertices');\n *\n * // Writer (a tool's onMove):\n * setScratch(ctx.scratch, LASSO_VERTICES, vertices);\n *\n * // Reader (a behavior's onEnd):\n * const vertices = getScratch(ctx.scratch, LASSO_VERTICES) ?? [];\n * //    ^?  readonly { x: number; y: number }[] | undefined\n * ```\n */\n\n/** Phantom-typed key for a scratch slot. The `__scratchKeyPayload` phantom\n *  field carries the value type without occupying any runtime memory. */\nexport interface ScratchKey<T> {\n  readonly name: string;\n  /** Phantom — never read at runtime. Only present so TypeScript can\n   *  recover `T` at use sites. */\n  readonly __scratchKeyPayload?: (_: T) => T;\n}\n\n/** Compatible scratch store shape. The kit's gesture context's `scratch`\n *  field already satisfies this; consumers don't need to construct one. */\nexport type ScratchStore = Record<string, unknown>;\n\n/**\n * Make a typed scratch key. Use module-level constants so the same key\n * is shared by writer and reader.\n *\n * Namespace the name by behavior or feature to avoid collisions\n * (`'behavior.field'` is a good convention). Two keys with the same\n * `name` refer to the same slot at runtime — the type parameter is a\n * compile-time contract, not a uniqueness guarantee.\n */\nexport function scratchKey<T>(name: string): ScratchKey<T> {\n  return { name };\n}\n\n/** Read a typed slot from the scratch store. Returns `undefined` if\n *  nothing has been written under the key. */\nexport function getScratch<T>(\n  store: ScratchStore,\n  key: ScratchKey<T>,\n): T | undefined {\n  return store[key.name] as T | undefined;\n}\n\n/** Write a value to a typed slot. Overwrites whatever was there. */\nexport function setScratch<T>(\n  store: ScratchStore,\n  key: ScratchKey<T>,\n  value: T,\n): void {\n  store[key.name] = value;\n}\n\n/** Remove a slot from the scratch store. Returns `true` if it was set,\n *  `false` if it wasn't. */\nexport function deleteScratch<T>(\n  store: ScratchStore,\n  key: ScratchKey<T>,\n): boolean {\n  if (Object.prototype.hasOwnProperty.call(store, key.name)) {\n    delete store[key.name];\n    return true;\n  }\n  return false;\n}\n"]}
+{"version":3,"sources":["../src/interactions/actions/action.ts","../src/interactions/actions/actionEnabled.ts","../src/interactions/dispatcher/predicates.ts","../src/contributions/merge.ts","../src/tools/defineTool.ts","../src/tools/defineViewportTool.ts","../src/interactions/scratchKey.ts"],"names":["RESERVED_ID_PREFIXES","RESERVED_ID_NAMES"],"mappings":"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","file":"index.js","sourcesContent":["/**\n * @experimental\n * The `Action` descriptor, split along the line the dispatcher reads.\n * `ActionDispatch` is everything routing consults to decide whether an action\n * runs and what happens when it does; `ActionPresentation` is what a palette,\n * menu or toolbar renders. `Action` is both.\n */\nimport type { ReactNode } from 'react';\nimport type { CursorSpec } from '@weasel-js/cursor';\nimport type { ActionDeps, Invoker } from './invoker';\nimport type { BindingSource } from './binding';\nimport type { DepName } from '../../index';\n\n/**\n * @experimental\n * Closed enum of reasons an action might report itself as disabled. The\n * consumer (palette, menu, etc.) maps these symbolic values to display\n * strings via its own label map.\n */\nexport const ActionDisabledReason = {\n  SelectionRequired: 'selection-required',\n  SceneEmpty: 'scene-empty',\n  NotApplicable: 'not-applicable',\n  /** Sentinel: the predicate threw. Surfaced by `evaluateEnabled`'s catch. */\n  PredicateThrew: 'predicate-threw',\n} as const;\n/** Why an action is unavailable right now. */\nexport type ActionDisabledReason =\n  (typeof ActionDisabledReason)[keyof typeof ActionDisabledReason];\n\n/**\n * @experimental\n * What a palette, menu or toolbar renders for an action. No part of this is\n * read during dispatch.\n */\nexport interface ActionPresentation {\n  label: string;\n  /** Inline-SVG icon for palette / toolbar surfaces. Mirrors\n   *  `ToolPresentation.icon` so a generic `<ActionBar>` can render from\n   *  action metadata the same way `<ToolPalette>` renders from tool\n   *  metadata. May be a static `ReactNode` or a function (rare; useful\n   *  for state-aware icons like a \"lock\" toggle). */\n  icon?: ReactNode | (() => ReactNode);\n  /** Grouping key for palette/menu surfaces. Free-form string; the kit\n   *  ships defaults for `'align'` (six edges/centers), `'distribute'`\n   *  (two axes), and recommends `'pathfinder'` for boolean ops. */\n  group?: string;\n  /** Display override for the keyboard shortcut. When omitted, palette\n   *  surfaces derive a label from `defaultBinding` via their own\n   *  formatter. */\n  shortcut?: string;\n}\n\n/**\n * @experimental\n * What routing consults: the bindings that reach the action, the deps its\n * invoker reads, the gates it passes, and the cursors it claims.\n */\nexport interface ActionDispatch extends BindingSource {\n  /** Names of the deps this action's invoker reads (keys of `DepSchema`).\n   *  The dispatcher (and `trigger`, when `requires` is present) resolves\n   *  each name against the `DepRegistry` at invocation time and passes the\n   *  resulting bag to the invoker. Dev builds warn when the invoker reads a\n   *  dep it didn't declare here — see `buildDepsFromRequires`. */\n  requires?: readonly DepName[];\n  /** Pluggable invocation strategy. The gesture dispatcher routes matched\n   *  bindings through `invoker.start` / `invoker.run` depending on timing.\n   *  All kit-standard descriptors ship one; consumer-supplied actions\n   *  without an invoker can still register but won't be triggered. */\n  invoker?: Invoker;\n  /** When set to `'hotkey'`, this action's `defaultBinding` rides the hotkey\n   *  `BindingScope` instead of the ambient scope — meaning it beats any\n   *  active-tool binding on the same input shape. Use for tool-switch\n   *  shortcuts and global held-key triggers. Default: ambient. */\n  scope?: 'hotkey';\n  /**\n   * @experimental\n   * Optional predicate the command palette consults when rendering. Return\n   * `true` when the action is currently triggerable. Return a reason string\n   * (e.g. `'Selection required'`) when disabled — the palette greys out\n   * the row, skips it in keyboard nav, ignores clicks, and shows the\n   * reason next to the label. Keystroke dispatch (the registered binding)\n   * is unaffected; the action's own `run` should self-guard.\n   *\n   * **Contract:** must be pure (no side effects), fast (< 4ms in dev), and\n   * must not throw. If a call throws or exceeds the budget in dev mode,\n   * `evaluateEnabled` logs a one-time warning per action id; throws are\n   * caught and treated as disabled with reason `'(predicate threw)'`.\n   *\n   * Snapshot-on-open semantics: the palette evaluates `enabled` once when\n   * opened and does NOT re-evaluate on selection changes while open. Live\n   * reactive updates are deferred — palette is short-lived.\n   *\n   * The reason set is a closed enum — to add a new reason, edit\n   * `ActionDisabledReason` and the consumer's display map.\n   *\n   * The optional `deps` argument is the same bag passed to\n   * `ImmediateInvoker.run`; callers (`evaluateEnabled` / the ActionBar) may\n   * synthesize it from the surrounding `DepRegistry` so predicates can\n   * inspect selection / scene / etc. Predicates that don't need deps just\n   * ignore the arg.\n   *\n   * `at` is the world point of the event being routed, when it has one — a\n   * click, a press, a long-press. An action that only applies somewhere\n   * (on a path segment, say) refuses other points here, so the dispatcher\n   * falls through to the next binding and hover prediction shows the\n   * action's `cursor` only where it would act. Palettes and keystrokes\n   * pass no point; treat absent as \"anywhere\".\n   */\n  enabled?: (deps?: ActionDeps, at?: { x: number; y: number }) => true | ActionDisabledReason;\n  /**\n   * Declarative eligibility rule, evaluated against the current\n   * `RuleCtx` by the dispatcher before invoking `start()`. Omitted =\n   * always eligible.\n   *\n   * Accepts either a fluent `Condition` (callable with `.rule`) or a\n   * raw `Rule` tree; the dispatcher normalizes via `.rule` unwrap.\n   *\n   * Prefer `capability:`-based rules (e.g. `{ capability: 'transforms-selection' }`)\n   * over `mode:` rules — capability rules survive new modes being added\n   * that allow the same capability.\n   */\n  eligible?:\n    | import('../../eligibility').Rule\n    | import('../../eligibility').Condition;\n  /**\n   * CSS cursor shown while the pointer hovers a spot where this action\n   * would win the drag — or, when the drag's winner declares no cursor,\n   * the click. The hover-cursor pump (in `useGestureDispatcher`) runs\n   * `Dispatcher.resolveOnly` on each idle pointermove — the same match\n   * walk a real press takes — and applies the winning action's `cursor`,\n   * so the hint and the actual target stay in sync by construction. Omitted = no override (the active tool's\n   * `Tool.cursor` shows). Affordance hits are resolved earlier in the\n   * pump via `AffordanceRegion.cursor` and never reach this field.\n   *\n   * Static value only. Prediction runs `enabled()` but cannot run the\n   * invoker, so an action that matches yet bails at `start()` (empty\n   * handle) may still show its cursor — keep `enabled` accurate for\n   * actions that declare one.\n   */\n  cursor?: CursorSpec;\n  /**\n   * CSS cursor shown while THIS action's ongoing handle is in flight —\n   * grabbing while panning, `move` while dragging a selection, `crosshair`\n   * while pulling a marquee.\n   *\n   * Separate from `cursor` because the two answer different questions:\n   * `cursor` is a prediction (\"a drag from here would pan\"), this is a state\n   * (\"you are panning\"). An action can declare either, both, or neither;\n   * with only `cursor` set, the hover hint holds for the duration of the\n   * gesture.\n   *\n   * This is where mid-gesture cursors live now. They used to come from the\n   * tool side — `ViewportToolDef.engaged.cursor` for a phase-gated string,\n   * or a function-form `Tool.cursor` reading the gesture scratch out of the\n   * tool-routing dispatcher. Both belonged to a pipeline whose whole job was\n   * being taken over by bindings, and neither could describe a cursor for an\n   * action a tool doesn't own.\n   */\n  activeCursor?: CursorSpec;\n}\n\n/**\n * @experimental\n * Single registered action. v1: one binding per action.\n */\nexport interface Action extends ActionDispatch, ActionPresentation {}\n\n/**\n * @experimental\n * The whole of an actions registry the dispatcher reads. It walks the list\n * once per event to build its actionId lookup and never mutates it, so the\n * routing side depends on this rather than on `ActionsRegistry`, whose\n * register / mute / trigger surface is the React provider's.\n */\nexport interface ActionSource {\n  list(): readonly Action[];\n}\n","/**\n * @experimental\n * Palette-side evaluation of `Action.enabled`. The dispatcher calls the\n * predicate raw as a gate; this is the surface that also enforces the\n * contract the predicate's JSDoc states — no throwing, under 4ms in dev.\n */\nimport type { ActionDeps } from './invoker';\nimport { ActionDisabledReason, type Action } from './action';\nimport { isDev } from '../../devFlag';\n\n/**\n * @experimental\n * Result of evaluating an Action's `enabled` predicate.\n */\nexport interface ActionEnabledResult {\n  enabled: boolean;\n  reason?: ActionDisabledReason;\n}\n\nconst enabledSlowWarned = new Set<string>();\nconst enabledThrewWarned = new Set<string>();\nconst ENABLED_BUDGET_MS = 4;\n/**\n * @experimental\n * Safely evaluate an action's `enabled` predicate. Returns `{enabled: true}`\n * when no predicate is supplied. Catches throws and treats them as disabled\n * with reason `'(predicate threw)'`. In dev mode, warns once per action id\n * when a single call exceeds 4ms (single frame at 240fps — generous; real\n * predicates should be sub-millisecond).\n */\nexport function evaluateEnabled(\n  action: Action,\n  deps?: ActionDeps,\n): ActionEnabledResult {\n  if (!action.enabled) return { enabled: true };\n  const dev = isDev();\n  const now = (typeof performance !== 'undefined' && typeof performance.now === 'function')\n    ? () => performance.now()\n    : () => Date.now();\n  const start = dev ? now() : 0;\n  try {\n    const result = action.enabled(deps);\n    if (dev) {\n      const elapsed = now() - start;\n      if (elapsed > ENABLED_BUDGET_MS && !enabledSlowWarned.has(action.id)) {\n        enabledSlowWarned.add(action.id);\n        console.warn(\n          `weasel actions: enabled() for action \"${action.id}\" took ${elapsed.toFixed(2)}ms ` +\n          `(budget ${ENABLED_BUDGET_MS}ms). The predicate must be pure and fast — see Action.enabled JSDoc.`,\n        );\n      }\n    }\n    if (result === true) return { enabled: true };\n    return { enabled: false, reason: result };\n  } catch (e) {\n    if (dev && !enabledThrewWarned.has(action.id)) {\n      enabledThrewWarned.add(action.id);\n      console.warn(\n        `weasel actions: enabled() for action \"${action.id}\" threw; treating as disabled. ` +\n        `The predicate must not throw — see Action.enabled JSDoc.`,\n        e,\n      );\n    }\n    return { enabled: false, reason: ActionDisabledReason.PredicateThrew };\n  }\n}\n","/**\n * Named predicates for `defaultBinding.target.kindOf`. Each matches the\n * existing `kindOf` signature `(target: unknown, bodyTarget?: string) => boolean`\n * so they drop into action descriptors without a wrapper:\n *\n *     target: { kindOf: isAnchor }\n *\n * Single source of truth for \"what does this affordance kind mean\" — adding\n * a new predicate here is what enables every action that needs the same\n * shape to read it. Drift prevention.\n */\n\n// ─── Body-class predicates (read the second arg) ───────────────────────\n\n/** A predicate that resolves from `bodyTarget` alone. The exclusive-claim\n *  filter reads `readsAffordance`: without it a body predicate looks like it\n *  consults the hit, and survives a claim that should have barred it. */\nexport type BodyPredicate = ((target: unknown, bodyTarget?: string) => boolean)\n  & { readsAffordance: false };\n\nfunction bodyPredicate(\n  fn: (target: unknown, bodyTarget?: string) => boolean,\n): BodyPredicate {\n  return Object.assign(fn, { readsAffordance: false as const });\n}\n\n/** Matches any body hit — selected or unselected node body. */\nexport const isBody: BodyPredicate = bodyPredicate((_target, bodyTarget) =>\n  bodyTarget === 'selected-body' || bodyTarget === 'unselected-body');\n\n/** Body hit specifically already in the selection. */\nexport const isSelectedBody: BodyPredicate = bodyPredicate((_target, bodyTarget) =>\n  bodyTarget === 'selected-body');\n\n/** Body hit specifically NOT in the selection. */\nexport const isUnselectedBody: BodyPredicate = bodyPredicate((_target, bodyTarget) =>\n  bodyTarget === 'unselected-body');\n\n/** Empty-canvas hit — no node beneath cursor. */\nexport const isEmpty: BodyPredicate = bodyPredicate((_target, bodyTarget) =>\n  bodyTarget === 'empty');\n\n// ─── Affordance-kind predicates (read the first arg) ───────────────────\n\nfunction kindOf(target: unknown): string | undefined {\n  if (typeof target !== 'object' || target === null) return undefined;\n  const k = (target as { kind?: unknown }).kind;\n  return typeof k === 'string' ? k : undefined;\n}\n\n/** Any corner resize handle — top-left/top-right/bottom-left/bottom-right. */\nexport const isResizeHandle = (target: unknown): boolean => {\n  const k = kindOf(target);\n  return k !== undefined && k.startsWith('handle:');\n};\n\n/** The rotate-around-center handle above the bounding box. */\nexport const isRotateHandle = (target: unknown): boolean =>\n  kindOf(target) === 'rotate-handle';\n\n/** Any path anchor (the on-curve dot). */\nexport const isAnchor = (target: unknown): boolean => {\n  const k = kindOf(target);\n  return k !== undefined && /^anchor:\\d+$/.test(k);\n};\n\n/** Either control handle (controlIn or controlOut). */\nexport const isControlHandle = (target: unknown): boolean => {\n  const k = kindOf(target);\n  return k !== undefined && /^(controlIn|controlOut):\\d+$/.test(k);\n};\n\n/** Any of the three anchor-editing affordances (anchor + both controls). */\nexport const isAnchorOrControl = (target: unknown): boolean =>\n  isAnchor(target) || isControlHandle(target);\n","import type { Contribution } from './types';\n\n/**\n * Concatenate contribution bundles into one registry, preserving order —\n * entry order decides which of two same-specificity bindings in one scope\n * tier wins, so it is part of the result, not an accident of it.\n *\n * Throws on a duplicate id rather than dropping one: a feature silently\n * losing its bindings is the failure this registry exists to make loud.\n */\nexport function mergeContributions(...bundles: readonly Contribution[][]): Contribution[] {\n  const out: Contribution[] = [];\n  const seen = new Set<string>();\n  for (const bundle of bundles) {\n    for (const entry of bundle) {\n      if (seen.has(entry.id)) {\n        throw new Error(\n          `mergeContributions: duplicate contribution id \"${entry.id}\". `\n          + `Two bundles registered the same id; rename one or merge them by hand.`,\n        );\n      }\n      seen.add(entry.id);\n      out.push(entry);\n    }\n  }\n  return out;\n}\n","// src/tools/defineTool.ts\nimport type { Tool, ToolCtx } from './types';\nimport type { ToolDef } from './routeTypes';\nimport { RESERVED_ID_NAMES, RESERVED_ID_PREFIXES } from '@weasel-js/gestures';\nimport type { CursorSpec } from '@weasel-js/cursor';\n\n/** Validate that `id` is usable as a tool / channel id in the route\n *  grammar. Rejects ids that start with a reserved sigil (would shadow\n *  future grammar extensions) and ids that collide with phase keywords\n *  (would parse as the bare-phase shorthand). */\nfunction validateId(id: string, kind: 'tool' | 'action'): void {\n  if (id.length === 0) {\n    throw new Error(`weasel: ${kind} id may not be empty`);\n  }\n  if (RESERVED_ID_PREFIXES.has(id[0]!)) {\n    throw new Error(\n      `weasel: ${kind} id \"${id}\" starts with reserved sigil \"${id[0]}\" ` +\n      `(reserved set: ${[...RESERVED_ID_PREFIXES].join(' ')})`,\n    );\n  }\n  if (RESERVED_ID_NAMES.has(id)) {\n    throw new Error(\n      `weasel: ${kind} id \"${id}\" collides with a reserved phase keyword ` +\n      `(reserved: ${[...RESERVED_ID_NAMES].join(', ')})`,\n    );\n  }\n}\n\n/**\n * Build a `Tool<TScratch>` from a declarative `ToolDef<TScratch>`.\n *\n * This used to be a translator: `ToolDef` carried `initial` / `engaged` phase\n * tables of hit-keyed route handlers, and `defineTool` compiled them into the\n * imperative `pointer` / `drag` / `keyboard` / `wheel` handlers the\n * tool-routing dispatcher called. Both ends of that are gone — tools declare\n * `bindings` and the gesture dispatcher routes them — so what remains is\n * identity plumbing plus the id check and the cursor resolver.\n *\n * It stays a function rather than becoming a spread because the id validation\n * and the `initScratch` / `cursor` defaults are worth applying uniformly, and\n * because `Tool.def` gives reflection a handle on the authored form.\n */\nexport function defineTool<TScratch = void, TOverlay = unknown>(\n  def: ToolDef<TScratch, TOverlay>,\n): Tool<TScratch, TOverlay> {\n  validateId(def.id, 'tool');\n\n  // Normalize `CursorSpec | ((ctx) => CursorSpec)` to the function form so\n  // callers have one shape to deal with. Returns '' (not undefined) so the\n  // signature satisfies `Tool.cursor: (ctx) => CursorSpec`.\n  const resolveCursor = (ctx: ToolCtx<TScratch>): CursorSpec => {\n    if (def.cursor == null) return '';\n    return typeof def.cursor === 'function' ? def.cursor(ctx) : def.cursor;\n  };\n\n  return {\n    id: def.id,\n    eligibility: {\n      focus: true,\n      capabilities: def.capabilities,\n      ...(def.hotkey ? { offhand: def.hotkey } : {}),\n    },\n    actions: def.actions,\n    def,\n    presentation: def.presentation as Tool<TScratch>['presentation'],\n    keybinding: def.keybinding,\n    onActivate: def.onActivate,\n    onDeactivate: def.onDeactivate,\n    initScratch: def.initScratch ?? (() => null as unknown as TScratch),\n    cursor: resolveCursor,\n    bindings: def.bindings,\n    overlay: def.overlay,\n    overlayPosition: def.overlayPosition,\n  };\n}\n","import type { Tool } from './types';\nimport type { ViewportToolDef } from './routeTypes';\nimport { defineTool } from './defineTool';\n\n/**\n * Define a tool that acts on the viewport rather than the scene.\n *\n * This used to do real work: `ViewportPhaseDef` was a narrowed `PhaseDef`\n * (no click routes, drag restricted to the function form), and the factory\n * lifted it back to the permissive shape before handing it to `defineTool`.\n * With phase tables gone there is no shape left to narrow — a viewport tool\n * declares `bindings` like any other, pointing at `viewport.*` actions.\n *\n * It survives as an authoring signal. `defineViewportTool` at the top of a\n * hook says \"this tool moves the camera, not the drawing\", which is worth\n * more than the type gymnastics it replaced.\n */\nexport function defineViewportTool<TScratch = void, TOverlay = unknown>(\n  def: ViewportToolDef<TScratch, TOverlay>,\n): Tool<TScratch, TOverlay> {\n  return defineTool<TScratch, TOverlay>(def);\n}\n","/**\n * Typed keys for the gesture/behavior scratch store.\n *\n * Gestures expose `ctx.scratch: Record<string, unknown>` as a per-gesture\n * mutable bag that behaviors use to stash state across `onDown` / `onMove`\n * / `onEnd` calls. The store is `unknown`-valued because behaviors are\n * tool-agnostic — a single behavior may run under different tools with\n * different scratch shapes. Without a typing convention every read site\n * has to `(ctx.scratch as <some shape>)[KEY]`, and a writer changing the\n * shape can silently break readers with no compile-time signal.\n *\n * `ScratchKey<T>` is a phantom-typed string that carries its payload type\n * via a branded interface. `getScratch` and `setScratch` use the brand to\n * narrow / constrain at the typing layer; at runtime the key is just its\n * underlying string and the store remains a plain `Record`.\n *\n * @example\n * ```ts\n * // Module-level (or behavior-level) constant, shared by writer + reader:\n * const LASSO_VERTICES = scratchKey<readonly { x: number; y: number }[]>('lasso.vertices');\n *\n * // Writer (a tool's onMove):\n * setScratch(ctx.scratch, LASSO_VERTICES, vertices);\n *\n * // Reader (a behavior's onEnd):\n * const vertices = getScratch(ctx.scratch, LASSO_VERTICES) ?? [];\n * //    ^?  readonly { x: number; y: number }[] | undefined\n * ```\n */\n\n/** Phantom-typed key for a scratch slot. The `__scratchKeyPayload` phantom\n *  field carries the value type without occupying any runtime memory. */\nexport interface ScratchKey<T> {\n  readonly name: string;\n  /** Phantom — never read at runtime. Only present so TypeScript can\n   *  recover `T` at use sites. */\n  readonly __scratchKeyPayload?: (_: T) => T;\n}\n\n/** Compatible scratch store shape. The kit's gesture context's `scratch`\n *  field already satisfies this; consumers don't need to construct one. */\nexport type ScratchStore = Record<string, unknown>;\n\n/**\n * Make a typed scratch key. Use module-level constants so the same key\n * is shared by writer and reader.\n *\n * Namespace the name by behavior or feature to avoid collisions\n * (`'behavior.field'` is a good convention). Two keys with the same\n * `name` refer to the same slot at runtime — the type parameter is a\n * compile-time contract, not a uniqueness guarantee.\n */\nexport function scratchKey<T>(name: string): ScratchKey<T> {\n  return { name };\n}\n\n/** Read a typed slot from the scratch store. Returns `undefined` if\n *  nothing has been written under the key. */\nexport function getScratch<T>(\n  store: ScratchStore,\n  key: ScratchKey<T>,\n): T | undefined {\n  return store[key.name] as T | undefined;\n}\n\n/** Write a value to a typed slot. Overwrites whatever was there. */\nexport function setScratch<T>(\n  store: ScratchStore,\n  key: ScratchKey<T>,\n  value: T,\n): void {\n  store[key.name] = value;\n}\n\n/** Remove a slot from the scratch store. Returns `true` if it was set,\n *  `false` if it wasn't. */\nexport function deleteScratch<T>(\n  store: ScratchStore,\n  key: ScratchKey<T>,\n): boolean {\n  if (Object.prototype.hasOwnProperty.call(store, key.name)) {\n    delete store[key.name];\n    return true;\n  }\n  return false;\n}\n"]}

package/dist/react.d.ts

@@ -1,5 +1,5 @@
-import { D as Dispatcher, A as ActionsRegistry, T as Tool, a as AffordanceHit, R as RuleCtx, b as DepSchema, c as Action, d as AnyToolOf, O as OverlayPosition, C as Contribution, S as ScopedBinding } from './index-BOlkWrA-.js';
-export { e as DepRegistry, f as DepRegistryProvider, u as useDepRegistry, g as useDepSource, h as useOptionalDepRegistry } from './index-BOlkWrA-.js';
+import { D as Dispatcher, A as ActionsRegistry, T as Tool, a as AffordanceHit, R as RuleCtx, b as DepSchema, c as Action, d as AnyToolOf, O as OverlayPosition, C as Contribution, S as ScopedBinding } from './index-D4hKg8yu.js';
+export { e as DepRegistry, f as DepRegistryProvider, u as useDepRegistry, g as useDepSource, h as useOptionalDepRegistry } from './index-D4hKg8yu.js';
 import { RefObject, ReactNode, ReactElement } from 'react';
 import { BodyClassification } from '@weasel-js/gestures';
 import { PaintedCursorState } from '@weasel-js/cursor';
@@ -64,6 +64,20 @@ interface ViewIdResolver {
     };
     end(pointerId: number): void;
 }
+/** Per-channel switches for the listeners `useGestureDispatcher` attaches to
+ *  the canvas element. Omitted or `true` attaches the channel. */
+interface DispatcherChannels {
+    /** `pointerdown`, hover `pointermove`, `pointerleave` — press, drag, click,
+     *  long-press, multi-touch and the hover-cursor pump. */
+    pointer?: boolean;
+    /** `wheel`. */
+    wheel?: boolean;
+    /** `contextmenu`. Off leaves the browser's native menu in place. */
+    contextMenu?: boolean;
+    /** OS drop on the element plus `paste` on the window. Off leaves the
+     *  element a non-drop-target and stops `weasel-dropover` being applied. */
+    ingest?: boolean;
+}
 /** Options for `useGestureDispatcher`: the element to listen on, the actions
  *  and tools in play, and the hooks that turn raw DOM events into the world
  *  coordinates and hit targets bindings match against. */
@@ -205,6 +219,22 @@ interface UseGestureDispatcherOptions {
      * wires this; tests / harnesses without chrome-caps state can omit it.
      */
     getRuleCtx?: () => RuleCtx | undefined;
+    /**
+     * Which of the canvas element's input channels to attach. Every one
+     * defaults to `true`; naming a channel `false` leaves its listeners
+     * unattached, so the element behaves as if the dispatcher were not there.
+     *
+     * A mount that binds two gestures should not also have to take the rest of
+     * the pipeline's side effects: `contextMenu` suppresses the native menu
+     * unconditionally, and `ingest` makes the element a valid drop target and
+     * styles it while an OS drag hovers. `@weasel-js/labkit`'s loupe mounts on
+     * a lab's own canvas host for a wheel and a held key, and turning the other
+     * three off is what keeps right-click and file drops working there.
+     *
+     * The window keyboard channel is `keyboard` instead of an entry here,
+     * because `<SceneCanvas enableKeybindings>` drives it.
+     */
+    channels?: DispatcherChannels;
     /**
      * Routing for a canvas hosting more than one view: the non-root dispatch
      * records to choose between, read fresh per event, and the resolver that
@@ -402,4 +432,4 @@ interface ContributionsApi<TOverlay = unknown> {
  */
 declare function useContributions<TOverlay = unknown>(opts: UseContributionsOptions<TOverlay>): ContributionsApi<TOverlay>;
 
-export { ActionsProvider, ActionsScope, ActiveToolContextProvider, ActiveToolContextProviderIfRoot, type ActiveToolContextProviderProps, type ActiveToolContextValue, type ContributionsApi, type DispatcherViewTarget, type ToolsApi, type UseContributionsOptions, type UseGestureDispatcherOptions, type UseToolsOptions, type ViewIdResolver, useAction, useActionsRegistry, useActiveToolContext, useContributions, useGestureDispatcher, useOptionalActiveToolContext, useTools };
+export { ActionsProvider, ActionsScope, ActiveToolContextProvider, ActiveToolContextProviderIfRoot, type ActiveToolContextProviderProps, type ActiveToolContextValue, type ContributionsApi, type DispatcherChannels, type DispatcherViewTarget, type ToolsApi, type UseContributionsOptions, type UseGestureDispatcherOptions, type UseToolsOptions, type ViewIdResolver, useAction, useActionsRegistry, useActiveToolContext, useContributions, useGestureDispatcher, useOptionalActiveToolContext, useTools };

package/dist/react.js

@@ -1,4 +1,4 @@
-import { createDispatcher, buildDepsFromRequires, validateActionId, validateActionDefaultBinding, scopeBindings, liveScope, offhandKeyFor, makeToolOffhandAction, buildToolOffhandBindings, isDev, reportRouteConflicts, dlog, isEditableTarget, clientToCanvasRect, openPointerSession, pointerGestureId, itemsFromDataTransfer, itemsFromClipboardData } from './chunk-Y5FHAA4U.js';
+import { createDispatcher, buildDepsFromRequires, validateActionId, validateActionDefaultBinding, scopeBindings, liveScope, offhandKeyFor, makeToolOffhandAction, buildToolOffhandBindings, isDev, reportRouteConflicts, dlog, isEditableTarget, clientToCanvasRect, openPointerSession, pointerGestureId, itemsFromDataTransfer, itemsFromClipboardData } from './chunk-H5AGTB2J.js';
 import { createContext, useState, useCallback, useMemo, useContext, useRef, useEffect } from 'react';
 import { jsx, Fragment } from 'react/jsx-runtime';
 import { resolveCursorTier } from '@weasel-js/cursor';
@@ -134,7 +134,11 @@ function computeMultiTouchGeometry(positions) {
   return { centroid, spread };
 }
 function useGestureDispatcher(opts) {
-  const { canvasRef, actions, toolsById, enabled = true, keyboard = true, affordanceAt, classifyTarget, dispatcher: dispatcherOpt, clientToWorld, requestRedraw, paintedCursor, getRuleCtx, onDoubleClick, views } = opts;
+  const { canvasRef, actions, toolsById, enabled = true, keyboard = true, affordanceAt, classifyTarget, dispatcher: dispatcherOpt, clientToWorld, requestRedraw, paintedCursor, getRuleCtx, onDoubleClick, views, channels } = opts;
+  const pointerChannel = channels?.pointer !== false;
+  const wheelChannel = channels?.wheel !== false;
+  const contextMenuChannel = channels?.contextMenu !== false;
+  const ingestChannel = channels?.ingest !== false;
   const onDoubleClickRef = useRef(onDoubleClick);
   onDoubleClickRef.current = onDoubleClick;
   const activeTool = useActiveToolContext();
@@ -297,8 +301,10 @@ function useGestureDispatcher(opts) {
       if (result === "unhandled") {
         dispatch({
           kind: "contextmenu",
-          worldX: down.worldX,
-          worldY: down.worldY,
+          x: down.worldX,
+          y: down.worldY,
+          clientX: down.clientX,
+          clientY: down.clientY,
           ...shared
         });
       }
@@ -448,7 +454,7 @@ function useGestureDispatcher(opts) {
           shiftKey: e.shiftKey
         }
       });
-      dispatch({ ...ev, stage: "press" });
+      if (held.size < 2) dispatch({ ...ev, stage: "press" });
       if ((e.pointerType === "touch" || e.pointerType === "pen") && held.size === 1) {
         cancelLongPress(e.pointerId);
         longPressTimers.set(
@@ -588,24 +594,25 @@ function useGestureDispatcher(opts) {
       const hoverBody = target().classifyTarget?.(w);
       const bodyTarget = hoverBody?.body;
       const bodyKind = hoverBody?.kind;
-      const predicted = dispatcherNow().resolveOnly(
-        {
-          kind: "pointerdown",
-          x: w.x,
-          y: w.y,
-          clientX: h.clientX,
-          clientY: h.clientY,
-          altKey: h.altKey,
-          ctrlKey: h.ctrlKey,
-          metaKey: h.metaKey,
-          shiftKey: h.shiftKey,
-          ...affordance !== void 0 ? { affordance } : {},
-          ...bodyTarget !== void 0 ? { bodyTarget } : {},
-          ...bodyKind !== void 0 ? { bodyKind } : {}
-        },
-        ctxNow()
-      );
-      applyHoverCursor(predicted?.action.cursor ?? null);
+      const where = {
+        altKey: h.altKey,
+        ctrlKey: h.ctrlKey,
+        metaKey: h.metaKey,
+        shiftKey: h.shiftKey,
+        ...affordance !== void 0 ? { affordance } : {},
+        ...bodyTarget !== void 0 ? { bodyTarget } : {},
+        ...bodyKind !== void 0 ? { bodyKind } : {}
+      };
+      const ctx = ctxNow();
+      const dragCursor = dispatcherNow().resolveOnly(
+        { kind: "pointerdown", x: w.x, y: w.y, clientX: h.clientX, clientY: h.clientY, ...where },
+        ctx
+      )?.action.cursor;
+      const cursor = dragCursor ?? dispatcherNow().resolveOnly(
+        { kind: "click", x: w.x, y: w.y, pressX: w.x, pressY: w.y, ...where },
+        ctx
+      )?.action.cursor;
+      applyHoverCursor(cursor ?? null);
     }
     const scheduleHoverCursorRefresh = (e) => {
       if (!lastHover) return;
@@ -691,8 +698,10 @@ function useGestureDispatcher(opts) {
           ctrlKey: e.ctrlKey,
           metaKey: e.metaKey,
           shiftKey: e.shiftKey,
-          worldX: wClick.x,
-          worldY: wClick.y,
+          x: wClick.x,
+          y: wClick.y,
+          clientX: e.clientX,
+          clientY: e.clientY,
           pressX: down.worldX,
           pressY: down.worldY,
           ...down.affordance !== void 0 ? { affordance: down.affordance } : {},
@@ -712,8 +721,10 @@ function useGestureDispatcher(opts) {
             ctrlKey: e.ctrlKey,
             metaKey: e.metaKey,
             shiftKey: e.shiftKey,
-            worldX: wClick.x,
-            worldY: wClick.y,
+            x: wClick.x,
+            y: wClick.y,
+            clientX: e.clientX,
+            clientY: e.clientY,
             ...down.affordance !== void 0 ? { affordance: down.affordance } : {},
             ...down.bodyTarget !== void 0 ? { bodyTarget: down.bodyTarget } : {},
             ...down.bodyKind !== void 0 ? { bodyKind: down.bodyKind } : {}
@@ -770,8 +781,10 @@ function useGestureDispatcher(opts) {
         ctrlKey: e.ctrlKey,
         metaKey: e.metaKey,
         shiftKey: e.shiftKey,
-        worldX: w.x,
-        worldY: w.y,
+        x: w.x,
+        y: w.y,
+        clientX: e.clientX,
+        clientY: e.clientY,
         ...affordance !== void 0 ? { affordance } : {},
         ...menuBody?.body !== void 0 ? { bodyTarget: menuBody.body } : {},
         ...menuBody?.kind !== void 0 ? { bodyKind: menuBody.kind } : {}
@@ -839,16 +852,20 @@ function useGestureDispatcher(opts) {
     window.addEventListener("blur", onWindowBlur);
     window.addEventListener("keydown", scheduleHoverCursorRefresh);
     window.addEventListener("keyup", scheduleHoverCursorRefresh);
-    canvas?.addEventListener("pointerleave", onHoverPointerLeave);
-    canvas?.addEventListener("wheel", onWheel, { passive: false });
-    canvas?.addEventListener("pointerdown", onPointerDown);
-    canvas?.addEventListener("pointermove", onHoverMove);
-    canvas?.addEventListener("contextmenu", onContextMenu);
-    canvas?.addEventListener("dragenter", onDragOver);
-    canvas?.addEventListener("dragover", onDragOver);
-    canvas?.addEventListener("dragleave", onDragLeave);
-    canvas?.addEventListener("drop", onDrop);
-    window.addEventListener("paste", onPaste);
+    if (pointerChannel) {
+      canvas?.addEventListener("pointerleave", onHoverPointerLeave);
+      canvas?.addEventListener("pointerdown", onPointerDown);
+      canvas?.addEventListener("pointermove", onHoverMove);
+    }
+    if (wheelChannel) canvas?.addEventListener("wheel", onWheel, { passive: false });
+    if (contextMenuChannel) canvas?.addEventListener("contextmenu", onContextMenu);
+    if (ingestChannel) {
+      canvas?.addEventListener("dragenter", onDragOver);
+      canvas?.addEventListener("dragover", onDragOver);
+      canvas?.addEventListener("dragleave", onDragLeave);
+      canvas?.addEventListener("drop", onDrop);
+      window.addEventListener("paste", onPaste);
+    }
     return () => {
       if (keyboard) {
         window.removeEventListener("keydown", onKeyDown);
@@ -875,7 +892,7 @@ function useGestureDispatcher(opts) {
       held.clear();
       for (const d of allDispatchers()) d.cancelAll("cancel");
     };
-  }, [enabled, keyboard, canvasRef]);
+  }, [enabled, keyboard, canvasRef, pointerChannel, wheelChannel, contextMenuChannel, ingestChannel]);
 }
 var ActionsContext = createContext(null);
 function useMuted(base) {
@@ -1026,7 +1043,6 @@ function ActionsProvider({ children }) {
               scene: r.get("scene"),
               history: r.get("history"),
               view: r.get("view"),
-              pointer: r.get("pointer"),
               activeTool: r.get("activeTool"),
               booleansAdapter: r.get("booleansAdapter")
             };
@@ -1061,7 +1077,6 @@ function ActionsProvider({ children }) {
           scene: r.get("scene"),
           history: r.get("history"),
           view: r.get("view"),
-          pointer: r.get("pointer"),
           activeTool: r.get("activeTool"),
           booleansAdapter: r.get("booleansAdapter")
         };
@@ -1102,7 +1117,6 @@ function useAction(action) {
     return reg.register(action);
   }, [reg, action]);
 }
-var NO_TRIGGERS = /* @__PURE__ */ new Set();
 function useContributions(opts) {
   const ctx = useActiveToolContext();
   const actionsRegistry = useActionsRegistry();
@@ -1141,7 +1155,7 @@ function useContributions(opts) {
     }
     return {
       ordered,
-      state: { focusedId: focusedRef.current, heldTriggers: NO_TRIGGERS, engagedIds }
+      state: { focusedId: focusedRef.current, engagedIds }
     };
   }, []);
   const scopedBindings = useCallback(() => {