@weasel-js/routing 1.5.2 → 1.6.0

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

@@ -556,6 +556,12 @@ interface InvocationCtx {
         deltaY: number;
         deltaZ: number;
     };
+    /** One `pinch` sample: `scale` is a multiplier since the previous sample,
+     *  `rotation` degrees since it. See `PinchEvent`. */
+    pinch?: {
+        scale: number;
+        rotation: number;
+    };
     multiTouch?: {
         /** Canvas-local CSS pixels — see `MultitouchEvent.centroid`. Neither
          *  `world` nor `screen`: it is the space `zoomAt` anchors in, so passing
@@ -932,6 +938,26 @@ interface ActionPresentation {
      *  surfaces derive a label from `defaultBinding` via their own
      *  formatter. */
     shortcut?: string;
+    /** The distinct things a parametric action does, one per set of params —
+     *  `flip` flips horizontally or vertically, `reorder.forward` moves one step
+     *  or all the way. A bar, menu or palette shows one entry per variant and
+     *  triggers the action with that variant's `params`. Omitted = the action
+     *  is one entry. See `actionItems`. */
+    variants?: readonly ActionVariant[];
+}
+/**
+ * @experimental
+ * One entry a parametric action contributes to a bar, menu or palette.
+ */
+interface ActionVariant {
+    /** Unique within the action; joined to its id to make the entry's key. */
+    key: string;
+    label: string;
+    /** Falls back to the action's own `icon`. */
+    icon?: ReactNode | (() => ReactNode);
+    /** Passed to `trigger`, and matched against each binding's
+     *  `opts.params` to find the variant's shortcuts. */
+    params: Readonly<Record<string, unknown>>;
 }
 /**
  * @experimental
@@ -1059,6 +1085,27 @@ interface ActionSource {
     list(): readonly Action[];
 }
 
+/**
+ * @experimental
+ * The entries an action contributes to a bar, menu or palette — one per
+ * variant, or the action itself when it declares none.
+ */
+
+/** @experimental One renderable entry: an action, optionally with params. */
+interface ActionItem {
+    /** `action.id`, or `action.id:variant.key` — unique across a registry. */
+    key: string;
+    action: Action;
+    label: string;
+    icon?: ReactNode | (() => ReactNode);
+    /** What to pass to `trigger(action.id, params)`; absent for a plain action. */
+    params?: Readonly<Record<string, unknown>>;
+}
+/** @experimental Expand `action` into the entries a surface renders. An
+ *  action without an immediate invoker has none: `trigger` cannot start a
+ *  drag, so a button for one would do nothing. */
+declare function actionItems(action: Action): ActionItem[];
+
 /**
  * @experimental
  * Palette-side evaluation of `Action.enabled`. The dispatcher calls the
@@ -2455,4 +2502,4 @@ interface DepSchema {
 /** Every dep name declared by anything that has merged into {@link DepSchema}. */
 type DepName = keyof DepSchema;
 
-export { INGEST_STRING_MIMES as $, type ActionsRegistry as A, type BindingOpts as B, type Contribution as C, type Dispatcher as D, type Condition as E, type Conflict as F, type ContributionChrome as G, type ContributionRouting as H, DEFAULT_ALLOWED_CAPABILITIES as I, DEFAULT_DEVICE_PROFILE as J, type DebugSink as K, type DepName as L, type DetectedDeviceFacts as M, type DeviceProfile as N, type OverlayPosition as O, type DispatchLogEntry as P, type DispatcherContext as Q, type RuleCtx as R, type ScopedBinding as S, type Tool as T, type DragSample as U, type Eligibility as V, type EligibilityState as W, type GestureBinding as X, type HandleKind as Y, type HitShape as Z, type HotkeyTrigger as _, type AffordanceHit as a, isAnchorOrControl as a$, type ImmediateInvoker as a0, type InvocationCtx as a1, type Invoker as a2, type KeyBinding as a3, type MatchResult as a4, type ModeSwitchLogEntry as a5, type ModifierState as a6, NEVER as a7, type NodeId as a8, type OngoingHandle as a9, type ToolModifiers as aA, type ToolOffhandBindingSpec as aB, type ToolPresentation as aC, type ToolSlot as aD, type TraceLogEntry as aE, type UiOngoingControl as aF, type View as aG, type ViewportToolDef as aH, actionBindings as aI, buildDepsFromRequires as aJ, buildRouteRegistry as aK, buildRuleCtx as aL, buildToolOffhandBindings as aM, clientToCanvas as aN, clientToCanvasRect as aO, createDispatcher as aP, defineTool as aQ, defineViewportTool as aR, deleteScratch as aS, describeRule as aT, dlog as aU, evaluate as aV, evaluateEnabled as aW, filterEligible as aX, findConflicts as aY, getScratch as aZ, isAnchor as a_, type OngoingInvoker as aa, type OngoingOverlay as ab, type OverlayRole as ac, PREDICATE_TARGET as ad, type Point2 as ae, type PointerSession as af, type PointerSessionCallbacks as ag, type PointerSessionCancelReason as ah, type PointerSessionOptions as ai, type RegistryEntry as aj, type ResizeAnchor as ak, type ResolveAllOptions as al, type ResolveOnlyResult as am, type ResolvedCandidate as an, type Rule as ao, type ScratchKey as ap, type ScratchStore as aq, type SelectionApi as ar, type SelectionExtendKey as as, type SelectionMode as at, type Selector as au, TOOL_OFFHAND_ID as av, type ToolBounds as aw, type ToolCtx as ax, type ToolDef as ay, type ToolKeybinding as az, type DepSchema as b, isBody as b0, isControlHandle as b1, isEditableTarget as b2, isEmpty as b3, isResizeHandle as b4, isRotateHandle as b5, isSelectedBody as b6, isUnselectedBody as b7, itemsFromClipboardData as b8, itemsFromDataTransfer as b9, itemsFromFiles as ba, liveScope as bb, makeToolOffhandAction as bc, matchBest as bd, matchSorted as be, matchesKeyBinding as bf, mergeContributions as bg, offhandKeyFor as bh, openPointerSession as bi, pointerGestureId as bj, recordModeSwitch as bk, reportRouteConflicts as bl, resolveDeviceProfile as bm, resolveParams as bn, routeGestureForSpecKind as bo, routesForSpec as bp, scopeBindings as bq, scratchKey as br, setScratch as bs, specificity as bt, targetConsultsAffordance as bu, validateActionDefaultBinding as bv, validateActionId as bw, type Action as c, type AnyToolOf as d, type DepRegistry as e, DepRegistryProvider as f, useDepSource as g, useOptionalDepRegistry as h, ALWAYS as i, type ActionDeps as j, ActionDisabledReason as k, type ActionDispatch as l, type ActionEnabledResult as m, type ActionEntry as n, type ActionPresentation as o, type ActionSource as p, type ActionsProp as q, type AnyTool as r, type BindingScope as s, type BindingSource as t, useDepRegistry as u, type BodyPredicate as v, type BoundGesture as w, type Bounds as x, type BuildRuleCtxArgs as y, COARSE_TARGET_SCALE as z };
+export { type HitShape as $, type ActionsRegistry as A, type BindingOpts as B, type Contribution as C, type Dispatcher as D, type BuildRuleCtxArgs as E, COARSE_TARGET_SCALE as F, type Condition as G, type Conflict as H, type ContributionChrome as I, type ContributionRouting as J, DEFAULT_ALLOWED_CAPABILITIES as K, DEFAULT_DEVICE_PROFILE as L, type DebugSink as M, type DepName as N, type OverlayPosition as O, type DetectedDeviceFacts as P, type DeviceProfile as Q, type RuleCtx as R, type ScopedBinding as S, type Tool as T, type DispatchLogEntry as U, type DispatcherContext as V, type DragSample as W, type Eligibility as X, type EligibilityState as Y, type GestureBinding as Z, type HandleKind as _, type AffordanceHit as a, findConflicts as a$, type HotkeyTrigger as a0, INGEST_STRING_MIMES as a1, type ImmediateInvoker as a2, type InvocationCtx as a3, type Invoker as a4, type KeyBinding as a5, type MatchResult as a6, type ModeSwitchLogEntry as a7, type ModifierState as a8, NEVER as a9, type ToolDef as aA, type ToolKeybinding as aB, type ToolModifiers as aC, type ToolOffhandBindingSpec as aD, type ToolPresentation as aE, type ToolSlot as aF, type TraceLogEntry as aG, type UiOngoingControl as aH, type View as aI, type ViewportToolDef as aJ, actionBindings as aK, actionItems as aL, buildDepsFromRequires as aM, buildRouteRegistry as aN, buildRuleCtx as aO, buildToolOffhandBindings as aP, clientToCanvas as aQ, clientToCanvasRect as aR, createDispatcher as aS, defineTool as aT, defineViewportTool as aU, deleteScratch as aV, describeRule as aW, dlog as aX, evaluate as aY, evaluateEnabled as aZ, filterEligible as a_, type NodeId as aa, type OngoingHandle as ab, type OngoingInvoker as ac, type OngoingOverlay as ad, type OverlayRole as ae, PREDICATE_TARGET as af, type Point2 as ag, type PointerSession as ah, type PointerSessionCallbacks as ai, type PointerSessionCancelReason as aj, type PointerSessionOptions as ak, type RegistryEntry as al, type ResizeAnchor as am, type ResolveAllOptions as an, type ResolveOnlyResult as ao, type ResolvedCandidate as ap, type Rule as aq, type ScratchKey as ar, type ScratchStore as as, type SelectionApi as at, type SelectionExtendKey as au, type SelectionMode as av, type Selector as aw, TOOL_OFFHAND_ID as ax, type ToolBounds as ay, type ToolCtx as az, type DepSchema as b, getScratch as b0, isAnchor as b1, isAnchorOrControl as b2, isBody as b3, isControlHandle as b4, isEditableTarget as b5, isEmpty as b6, isResizeHandle as b7, isRotateHandle as b8, isSelectedBody as b9, isUnselectedBody as ba, itemsFromClipboardData as bb, itemsFromDataTransfer as bc, itemsFromFiles as bd, liveScope as be, makeToolOffhandAction as bf, matchBest as bg, matchSorted as bh, matchesKeyBinding as bi, mergeContributions as bj, offhandKeyFor as bk, openPointerSession as bl, pointerGestureId as bm, recordModeSwitch as bn, reportRouteConflicts as bo, resolveDeviceProfile as bp, resolveParams as bq, routeGestureForSpecKind as br, routesForSpec as bs, scopeBindings as bt, scratchKey as bu, setScratch as bv, specificity as bw, targetConsultsAffordance as bx, validateActionDefaultBinding as by, validateActionId as bz, type Action as c, type AnyToolOf as d, type DepRegistry as e, DepRegistryProvider as f, useDepSource as g, useOptionalDepRegistry as h, ALWAYS as i, type ActionDeps as j, ActionDisabledReason as k, type ActionDispatch as l, type ActionEnabledResult as m, type ActionEntry as n, type ActionItem as o, type ActionPresentation as p, type ActionSource as q, type ActionVariant as r, type ActionsProp as s, type AnyTool as t, useDepRegistry as u, type BindingScope as v, type BindingSource as w, type BodyPredicate as x, type BoundGesture as y, type Bounds as z };

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-D4hKg8yu.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 ActionItem, p as ActionPresentation, q as ActionSource, r as ActionVariant, s as ActionsProp, A as ActionsRegistry, a as AffordanceHit, t as AnyTool, d as AnyToolOf, B as BindingOpts, v as BindingScope, w as BindingSource, x as BodyPredicate, y as BoundGesture, z as Bounds, E as BuildRuleCtxArgs, F as COARSE_TARGET_SCALE, G as Condition, H as Conflict, C as Contribution, I as ContributionChrome, J as ContributionRouting, K as DEFAULT_ALLOWED_CAPABILITIES, L as DEFAULT_DEVICE_PROFILE, M as DebugSink, N as DepName, b as DepSchema, P as DetectedDeviceFacts, Q as DeviceProfile, U as DispatchLogEntry, D as Dispatcher, V as DispatcherContext, W as DragSample, X as Eligibility, Y as EligibilityState, Z as GestureBinding, _ as HandleKind, $ as HitShape, a0 as HotkeyTrigger, a1 as INGEST_STRING_MIMES, a2 as ImmediateInvoker, a3 as InvocationCtx, a4 as Invoker, a5 as KeyBinding, a6 as MatchResult, a7 as ModeSwitchLogEntry, a8 as ModifierState, a9 as NEVER, aa as NodeId, ab as OngoingHandle, ac as OngoingInvoker, ad as OngoingOverlay, O as OverlayPosition, ae as OverlayRole, af as PREDICATE_TARGET, ag as Point2, ah as PointerSession, ai as PointerSessionCallbacks, aj as PointerSessionCancelReason, ak as PointerSessionOptions, al as RegistryEntry, am as ResizeAnchor, an as ResolveAllOptions, ao as ResolveOnlyResult, ap as ResolvedCandidate, aq as Rule, R as RuleCtx, S as ScopedBinding, ar as ScratchKey, as as ScratchStore, at as SelectionApi, au as SelectionExtendKey, av as SelectionMode, aw as Selector, ax as TOOL_OFFHAND_ID, T as Tool, ay as ToolBounds, az as ToolCtx, aA as ToolDef, aB as ToolKeybinding, aC as ToolModifiers, aD as ToolOffhandBindingSpec, aE as ToolPresentation, aF as ToolSlot, aG as TraceLogEntry, aH as UiOngoingControl, aI as View, aJ as ViewportToolDef, aK as actionBindings, aL as actionItems, aM as buildDepsFromRequires, aN as buildRouteRegistry, aO as buildRuleCtx, aP as buildToolOffhandBindings, aQ as clientToCanvas, aR as clientToCanvasRect, aS as createDispatcher, aT as defineTool, aU as defineViewportTool, aV as deleteScratch, aW as describeRule, aX as dlog, aY as evaluate, aZ as evaluateEnabled, a_ as filterEligible, a$ as findConflicts, b0 as getScratch, b1 as isAnchor, b2 as isAnchorOrControl, b3 as isBody, b4 as isControlHandle, b5 as isEditableTarget, b6 as isEmpty, b7 as isResizeHandle, b8 as isRotateHandle, b9 as isSelectedBody, ba as isUnselectedBody, bb as itemsFromClipboardData, bc as itemsFromDataTransfer, bd as itemsFromFiles, be as liveScope, bf as makeToolOffhandAction, bg as matchBest, bh as matchSorted, bi as matchesKeyBinding, bj as mergeContributions, bk as offhandKeyFor, bl as openPointerSession, bm as pointerGestureId, bn as recordModeSwitch, bo as reportRouteConflicts, bp as resolveDeviceProfile, bq as resolveParams, br as routeGestureForSpecKind, bs as routesForSpec, bt as scopeBindings, bu as scratchKey, bv as setScratch, bw as specificity, bx as targetConsultsAffordance, by as validateActionDefaultBinding, bz as validateActionId } from './index-B_KvoXww.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,7 +1,22 @@
-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 { isDev } from './chunk-D2TZLDP5.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-D2TZLDP5.js';
 import { RESERVED_ID_PREFIXES, RESERVED_ID_NAMES } from '@weasel-js/gestures';
 
+// src/interactions/actions/actionItems.ts
+function actionItems(action) {
+  if (action.invoker?.timing !== "immediate") return [];
+  if (!action.variants?.length) {
+    return [{ key: action.id, action, label: action.label, icon: action.icon }];
+  }
+  return action.variants.map((v) => ({
+    key: `${action.id}:${v.key}`,
+    action,
+    label: v.label,
+    icon: v.icon ?? action.icon,
+    params: v.params
+  }));
+}
+
 // src/interactions/actions/action.ts
 var ActionDisabledReason = {
   SelectionRequired: "selection-required",
@@ -155,6 +170,6 @@ function deleteScratch(store, key) {
   return false;
 }
 
-export { ActionDisabledReason, defineTool, defineViewportTool, deleteScratch, evaluateEnabled, getScratch, isAnchor, isAnchorOrControl, isBody, isControlHandle, isEmpty, isResizeHandle, isRotateHandle, isSelectedBody, isUnselectedBody, mergeContributions, scratchKey, setScratch };
+export { ActionDisabledReason, actionItems, defineTool, defineViewportTool, deleteScratch, evaluateEnabled, getScratch, isAnchor, isAnchorOrControl, isBody, isControlHandle, isEmpty, isResizeHandle, isRotateHandle, isSelectedBody, isUnselectedBody, mergeContributions, scratchKey, setScratch };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

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   * `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"]}
+{"version":3,"sources":["../src/interactions/actions/actionItems.ts","../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 entries an action contributes to a bar, menu or palette — one per\n * variant, or the action itself when it declares none.\n */\nimport type { ReactNode } from 'react';\nimport type { Action } from './action';\n\n/** @experimental One renderable entry: an action, optionally with params. */\nexport interface ActionItem {\n  /** `action.id`, or `action.id:variant.key` — unique across a registry. */\n  key: string;\n  action: Action;\n  label: string;\n  icon?: ReactNode | (() => ReactNode);\n  /** What to pass to `trigger(action.id, params)`; absent for a plain action. */\n  params?: Readonly<Record<string, unknown>>;\n}\n\n/** @experimental Expand `action` into the entries a surface renders. An\n *  action without an immediate invoker has none: `trigger` cannot start a\n *  drag, so a button for one would do nothing. */\nexport function actionItems(action: Action): ActionItem[] {\n  if (action.invoker?.timing !== 'immediate') return [];\n  if (!action.variants?.length) {\n    return [{ key: action.id, action, label: action.label, icon: action.icon }];\n  }\n  return action.variants.map((v) => ({\n    key: `${action.id}:${v.key}`,\n    action,\n    label: v.label,\n    icon: v.icon ?? action.icon,\n    params: v.params,\n  }));\n}\n","/**\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  /** The distinct things a parametric action does, one per set of params —\n   *  `flip` flips horizontally or vertically, `reorder.forward` moves one step\n   *  or all the way. A bar, menu or palette shows one entry per variant and\n   *  triggers the action with that variant's `params`. Omitted = the action\n   *  is one entry. See `actionItems`. */\n  variants?: readonly ActionVariant[];\n}\n\n/**\n * @experimental\n * One entry a parametric action contributes to a bar, menu or palette.\n */\nexport interface ActionVariant {\n  /** Unique within the action; joined to its id to make the entry's key. */\n  key: string;\n  label: string;\n  /** Falls back to the action's own `icon`. */\n  icon?: ReactNode | (() => ReactNode);\n  /** Passed to `trigger`, and matched against each binding's\n   *  `opts.params` to find the variant's shortcuts. */\n  params: Readonly<Record<string, unknown>>;\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-D4hKg8yu.js';
-export { e as DepRegistry, f as DepRegistryProvider, u as useDepRegistry, g as useDepSource, h as useOptionalDepRegistry } from './index-D4hKg8yu.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-B_KvoXww.js';
+export { e as DepRegistry, f as DepRegistryProvider, u as useDepRegistry, g as useDepSource, h as useOptionalDepRegistry } from './index-B_KvoXww.js';
 import { RefObject, ReactNode, ReactElement } from 'react';
 import { BodyClassification } from '@weasel-js/gestures';
 import { PaintedCursorState } from '@weasel-js/cursor';
@@ -72,6 +72,9 @@ interface DispatcherChannels {
     pointer?: boolean;
     /** `wheel`. */
     wheel?: boolean;
+    /** WebKit's `gesturestart` / `gesturechange` / `gestureend` — Safari's
+     *  trackpad pinch, dispatched as `pinch` events. */
+    pinch?: 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
@@ -298,6 +301,35 @@ declare function useActionsRegistry(): ActionsRegistry | null;
  */
 declare function useAction(action: Action): void;
 
+/**
+ * One UI control's hold on an ongoing action — the handle a color picker, a
+ * slider or a swatch drives the action through, the way a drag drives one
+ * through a gesture.
+ *
+ * - `input(params)` opens the action on the first call and moves it on every
+ *   later one: the live preview.
+ * - `commit(params?)` moves it to `params`, if given, and ends it as one
+ *   undoable edit. With nothing open, a commit carrying params is a whole edit
+ *   on its own — a click on a swatch, a switch of paint kind.
+ * - `cancel()` ends an open edit without keeping it.
+ *
+ * All three are no-ops when no action is reachable, so a control renders the
+ * same with or without a canvas in scope.
+ */
+interface OngoingAction {
+    input(params: Record<string, unknown>): void;
+    commit(params?: Record<string, unknown>): void;
+    cancel(): void;
+}
+/**
+ * Drive the ongoing action `actionId` from a UI control: {@link OngoingAction}.
+ *
+ * An edit left open when the control unmounts, or when `actionId` changes, is
+ * committed — it is what the user was looking at when the control went away.
+ * The returned object is stable for the life of the component.
+ */
+declare function useOngoingAction(actionId: string): OngoingAction;
+
 /** Which tool is active, plus the stack of tools temporarily held active by a
  *  hotkey (space-for-hand and the like). The dispatcher reads this to decide
  *  whose bindings are in scope. */
@@ -432,4 +464,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 DispatcherChannels, 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 OngoingAction, type ToolsApi, type UseContributionsOptions, type UseGestureDispatcherOptions, type UseToolsOptions, type ViewIdResolver, useAction, useActionsRegistry, useActiveToolContext, useContributions, useGestureDispatcher, useOngoingAction, 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-H5AGTB2J.js';
+import { createDispatcher, buildDepsFromRequires, validateActionId, validateActionDefaultBinding, scopeBindings, liveScope, offhandKeyFor, makeToolOffhandAction, buildToolOffhandBindings, isDev, reportRouteConflicts, dlog, isEditableTarget, clientToCanvasRect, openPointerSession, pointerGestureId, itemsFromDataTransfer, itemsFromClipboardData } from './chunk-D2TZLDP5.js';
 import { createContext, useState, useCallback, useMemo, useContext, useRef, useEffect } from 'react';
 import { jsx, Fragment } from 'react/jsx-runtime';
 import { resolveCursorTier } from '@weasel-js/cursor';
@@ -137,6 +137,7 @@ function useGestureDispatcher(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 pinchChannel = channels?.pinch !== false;
   const contextMenuChannel = channels?.contextMenu !== false;
   const ingestChannel = channels?.ingest !== false;
   const onDoubleClickRef = useRef(onDoubleClick);
@@ -261,6 +262,14 @@ function useGestureDispatcher(opts) {
       );
       return { centroid: toCanvasLocal(centroid), spread };
     };
+    let pinchLive = false;
+    let pinchScale = 1;
+    let pinchRotation = 0;
+    const endPinch = () => {
+      pinchLive = false;
+      pinchScale = 1;
+      pinchRotation = 0;
+    };
     let multiTouchStart = null;
     const TAP_THRESHOLD_PX = 8;
     const DRAG_THRESHOLD_PX = 4;
@@ -359,6 +368,7 @@ function useGestureDispatcher(opts) {
       heldKeys.delete(e.key);
     };
     const onWindowBlur = () => {
+      endPinch();
       for (const p of [...held.values()]) p.session.cancel();
       for (const key of heldKeys) {
         const ev = {
@@ -375,6 +385,11 @@ function useGestureDispatcher(opts) {
       heldKeys.clear();
     };
     const onWheel = (e) => {
+      if (pinchLive && e.ctrlKey) {
+        e.preventDefault();
+        e.stopPropagation();
+        return;
+      }
       routeAt(null, e.clientX, e.clientY);
       const rect = canvas?.getBoundingClientRect();
       const [localX, localY] = rect ? clientToCanvasRect(rect, e.clientX, e.clientY) : [e.clientX, e.clientY];
@@ -401,6 +416,57 @@ function useGestureDispatcher(opts) {
         e.stopPropagation();
       }
     };
+    const pinchEventOf = (e, scale, rotation) => {
+      const g = e;
+      const rect = canvas?.getBoundingClientRect();
+      const cx = typeof g.clientX === "number" ? g.clientX : rect ? rect.left + rect.width / 2 : 0;
+      const cy = typeof g.clientY === "number" ? g.clientY : rect ? rect.top + rect.height / 2 : 0;
+      routeAt(null, cx, cy);
+      const [localX, localY] = rect ? clientToCanvasRect(rect, cx, cy) : [cx, cy];
+      const hitPoint = toWorld(cx, cy);
+      const affordance = target().affordanceAt?.(hitPoint) ?? void 0;
+      const body = target().classifyTarget?.(hitPoint);
+      return {
+        kind: "pinch",
+        altKey: g.altKey === true,
+        ctrlKey: g.ctrlKey === true,
+        metaKey: g.metaKey === true,
+        shiftKey: g.shiftKey === true,
+        scale,
+        rotation,
+        clientX: localX,
+        clientY: localY,
+        ...affordance !== void 0 ? { affordance } : {},
+        ...body?.body !== void 0 ? { bodyTarget: body.body } : {},
+        ...body?.kind !== void 0 ? { bodyKind: body.kind } : {}
+      };
+    };
+    const onGestureStart = (e) => {
+      endPinch();
+      const probe = pinchEventOf(e, 1, 0);
+      if (dispatcherNow().resolveOnly(probe, ctxNow()) === null) return;
+      pinchLive = true;
+      e.preventDefault();
+    };
+    const onGestureChange = (e) => {
+      const g = e;
+      const scale = typeof g.scale === "number" && g.scale > 0 ? g.scale : pinchScale;
+      const rotation = typeof g.rotation === "number" ? g.rotation : pinchRotation;
+      const step = scale / pinchScale;
+      const turn = rotation - pinchRotation;
+      pinchScale = scale;
+      pinchRotation = rotation;
+      if (dispatch(pinchEventOf(e, step, turn)) === "handled") {
+        pinchLive = true;
+        e.preventDefault();
+      } else if (pinchLive) {
+        e.preventDefault();
+      }
+    };
+    const onGestureEnd = (e) => {
+      if (pinchLive) e.preventDefault();
+      endPinch();
+    };
     const onPointerDown = (e) => {
       if ((e.button ?? 0) !== 0) return;
       if (!canvas) return;
@@ -858,6 +924,11 @@ function useGestureDispatcher(opts) {
       canvas?.addEventListener("pointermove", onHoverMove);
     }
     if (wheelChannel) canvas?.addEventListener("wheel", onWheel, { passive: false });
+    if (pinchChannel) {
+      canvas?.addEventListener("gesturestart", onGestureStart);
+      canvas?.addEventListener("gesturechange", onGestureChange);
+      canvas?.addEventListener("gestureend", onGestureEnd);
+    }
     if (contextMenuChannel) canvas?.addEventListener("contextmenu", onContextMenu);
     if (ingestChannel) {
       canvas?.addEventListener("dragenter", onDragOver);
@@ -876,6 +947,9 @@ function useGestureDispatcher(opts) {
       window.removeEventListener("keyup", scheduleHoverCursorRefresh);
       canvas?.removeEventListener("pointerleave", onHoverPointerLeave);
       canvas?.removeEventListener("wheel", onWheel);
+      canvas?.removeEventListener("gesturestart", onGestureStart);
+      canvas?.removeEventListener("gesturechange", onGestureChange);
+      canvas?.removeEventListener("gestureend", onGestureEnd);
       canvas?.removeEventListener("pointerdown", onPointerDown);
       canvas?.removeEventListener("pointermove", onHoverMove);
       canvas?.removeEventListener("contextmenu", onContextMenu);
@@ -892,7 +966,7 @@ function useGestureDispatcher(opts) {
       held.clear();
       for (const d of allDispatchers()) d.cancelAll("cancel");
     };
-  }, [enabled, keyboard, canvasRef, pointerChannel, wheelChannel, contextMenuChannel, ingestChannel]);
+  }, [enabled, keyboard, canvasRef, pointerChannel, wheelChannel, pinchChannel, contextMenuChannel, ingestChannel]);
 }
 var ActionsContext = createContext(null);
 function useMuted(base) {
@@ -1117,6 +1191,39 @@ function useAction(action) {
     return reg.register(action);
   }, [reg, action]);
 }
+function useOngoingAction(actionId) {
+  const reg = useActionsRegistry();
+  const regRef = useRef(reg);
+  regRef.current = reg;
+  const idRef = useRef(actionId);
+  idRef.current = actionId;
+  const ctrlRef = useRef(null);
+  const edit = useMemo(() => {
+    const end = (reason) => {
+      const ctrl = ctrlRef.current;
+      ctrlRef.current = null;
+      ctrl?.end(reason);
+    };
+    return {
+      input(params) {
+        if (ctrlRef.current) ctrlRef.current.update(params);
+        else ctrlRef.current = regRef.current?.begin(idRef.current, params) ?? null;
+      },
+      commit(params) {
+        if (params !== void 0) {
+          if (ctrlRef.current) ctrlRef.current.update(params);
+          else ctrlRef.current = regRef.current?.begin(idRef.current, params) ?? null;
+        }
+        end("commit");
+      },
+      cancel() {
+        end("cancel");
+      }
+    };
+  }, []);
+  useEffect(() => () => edit.commit(), [edit, actionId]);
+  return edit;
+}
 function useContributions(opts) {
   const ctx = useActiveToolContext();
   const actionsRegistry = useActionsRegistry();
@@ -1313,6 +1420,6 @@ function useTools(opts) {
   );
 }
 
-export { ActionsProvider, ActionsScope, ActiveToolContextProvider, ActiveToolContextProviderIfRoot, DepRegistryProvider, useAction, useActionsRegistry, useActiveToolContext, useContributions, useDepRegistry, useDepSource, useGestureDispatcher, useOptionalActiveToolContext, useOptionalDepRegistry, useTools };
+export { ActionsProvider, ActionsScope, ActiveToolContextProvider, ActiveToolContextProviderIfRoot, DepRegistryProvider, useAction, useActionsRegistry, useActiveToolContext, useContributions, useDepRegistry, useDepSource, useGestureDispatcher, useOngoingAction, useOptionalActiveToolContext, useOptionalDepRegistry, useTools };
 //# sourceMappingURL=react.js.map
 //# sourceMappingURL=react.js.map