@weasel-js/routing 1.10.1 → 1.11.1

package/dist/react.js

@@ -1,10 +1,10 @@
-import { createDepRegistry, createDispatcher, assembleEntries, liveScope, isDev, reportRouteConflicts, offhandKeyFor, makeToolOffhandAction, buildToolOffhandBindings, dlog, ScopeNode, isTool, tuneAction, pushOwner, evaluateEnabled, validateActionId, validateActionDefaultBinding, depNodeOf, DepNode, clientToCanvas, DEV, publishLiveDispatch, LONG_PRESS_HAPTIC_MS, multiTouchGestureId, openPointerSession, buildDepsFromRequires, isEditableTarget, focusedControlOwnsKey, itemsFromClipboardData, itemsFromDataTransfer, itemTypesFromDataTransfer } from './chunk-VCEIQ64H.js';
-import { createContext, useState, useContext, useEffect, useRef, useCallback, useMemo, useSyncExternalStore } from 'react';
+import { createDepRegistry, createDispatchTrace, createDispatcher, assembleEntries, liveScope, reportRouteConflicts, offhandKeyFor, makeToolOffhandAction, buildToolOffhandBindings, dlog, ScopeNode, tuneAction, createMenuHost, pushOwner, evaluateEnabled, tunedParams, validateActionId, validateActionDefaultBinding, isTool, depNodeOf, DepNode, buildDepsFromRequires, clientToCanvas, LONG_PRESS_HAPTIC_MS, multiTouchGestureId, openPointerSession, addCarrySurface, carryGestureId, anyBinding, isEditableTarget, focusedControlOwnsKey, itemsFromClipboardData, itemsFromDataTransfer, itemTypesFromDataTransfer, actionCursor } from './chunk-KLBH7VFF.js';
+import { createContext, useState, useContext, useEffect, useMemo, useRef, useCallback, useSyncExternalStore } from 'react';
 import { isApplePlatform, heldPointers, createPointerRecognizer, isInControlWithin, longPressEvents, stylusOf } from '@weasel-js/gestures';
-import { useLatest, useStableByContent, sameList } from '@weasel-js/react';
+import { isDev, useLatest, useKitSettings, useStableByContent, sameList } from '@weasel-js/react';
 import { jsx, Fragment } from 'react/jsx-runtime';
 import { createCursorSink, resolveCursorTier } from '@weasel-js/cursor';
-import { createEmitter } from '@weasel-js/registry';
+import { deepEqual, createEmitter } from '@weasel-js/registry';
 import { activeModeOf } from '@weasel-js/modes';
 
 var ToolNode = class extends ScopeNode {
@@ -108,9 +108,280 @@ function useDepSource(name, source) {
   const registry = useDepRegistry();
   const sourceRef = useLatest(source);
   useEffect(() => {
-    return registry.register(name, () => sourceRef.current());
+    return registry.register(name, (below) => sourceRef.current(below));
   }, [name, registry, sourceRef]);
 }
+var MenuHostContext = createContext(null);
+function useMenuHost() {
+  return useContext(MenuHostContext);
+}
+function useMenus(defs, owner = null) {
+  const host = useMenuHost();
+  useEffect(() => {
+    if (!host) return;
+    const releases = defs.map((d) => host.define(d, owner));
+    return () => {
+      for (const r of releases) r();
+    };
+  }, [host, defs, owner]);
+}
+var ActionsContext = createContext(null);
+function depsFor(a, r) {
+  if (!r) return {};
+  if (a.requires) return buildDepsFromRequires(a, r);
+  return {
+    selection: r.get("selection"),
+    scene: r.get("scene"),
+    history: r.get("history"),
+    view: r.get("view"),
+    activeTool: r.get("activeTool"),
+    booleansAdapter: r.get("booleansAdapter")
+  };
+}
+var ActionsNode = class extends ScopeNode {
+  constructor(parent, descends, contextDeps) {
+    super(parent, descends);
+    this.contextDeps = contextDeps;
+    NODES.set(this.registry, this);
+  }
+  contextDeps;
+  actions = /* @__PURE__ */ new Map();
+  muted = /* @__PURE__ */ new Map();
+  tunings = /* @__PURE__ */ new Map();
+  dispatchers = [];
+  cache = null;
+  host = null;
+  /** Called on `activate`, so a scope's dep and tool nodes move with it. */
+  onActivate = [];
+  resolve(id) {
+    for (const n of this.chain()) {
+      if (n.muted.has(id)) return void 0;
+      const a = n.actions.get(id)?.at(-1);
+      if (a) return this.tuned(a);
+    }
+    return void 0;
+  }
+  /** Every tuning for `id` from the root down to here, root first. */
+  tuningsOf(id) {
+    const tunings = [];
+    for (const n of this.chain()) {
+      const stack = n.tunings.get(id);
+      if (stack) tunings.unshift(...stack);
+    }
+    return tunings;
+  }
+  /** `a` under every tuning for its id from the root down to here. */
+  tuned(a) {
+    const tunings = this.tuningsOf(a.id);
+    return tunings.length ? tuneAction(a, tunings) : a;
+  }
+  snapshot() {
+    const leaf = this.start();
+    const cached = this.cache;
+    if (cached && cached.version === this.tree.version && cached.leaf === leaf) return cached.list;
+    const ids = /* @__PURE__ */ new Set();
+    for (const n of leaf.chain()) for (const id of n.actions.keys()) ids.add(id);
+    const out = [];
+    for (const id of ids) {
+      const a = leaf.resolve(id);
+      if (a) out.push(a);
+    }
+    const list = Object.freeze(out);
+    this.cache = { version: this.tree.version, leaf, list };
+    return list;
+  }
+  deps() {
+    for (const n of this.chain()) {
+      const r = n.contextDeps();
+      if (r) return r;
+    }
+    return null;
+  }
+  /** The actions registered at this node itself, live, unmuted and tuned —
+   *  none from the scopes below it. */
+  ownActions() {
+    const out = [];
+    for (const [id, stack] of this.actions) {
+      if (stack.length > 0 && !this.muted.has(id)) out.push(this.tuned(stack.at(-1)));
+    }
+    return out;
+  }
+  /** The deps `a` is invoked with from here: the active scope's, which is
+   *  what `trigger` and `begin` run it with. */
+  depsOf(a) {
+    return depsFor(a, this.start().deps());
+  }
+  /** The menu host of this node's tree, made by its root on first ask. Rows
+   *  resolve and run against the active scope, as chrome's `trigger` does. */
+  menuHost() {
+    const root = [...this.chain()].at(-1);
+    return root.host ??= createMenuHost({
+      actions: () => root.registry.list(),
+      depsFor: (a) => root.depsOf(a),
+      trigger: (id, params) => root.registry.trigger(id, params),
+      activeTool: () => root.start().deps()?.get("activeTool")?.active ?? null
+    });
+  }
+  dispatcher() {
+    for (const n of this.chain()) {
+      const d = n.dispatchers.at(-1);
+      if (d) return d;
+    }
+    return null;
+  }
+  activate() {
+    keyHolder = this;
+    super.activate();
+    for (const f of this.onActivate) f();
+  }
+  registry = {
+    register: (action) => {
+      validateActionId(action.id);
+      validateActionDefaultBinding(action);
+      const stack = this.actions.get(action.id);
+      if (stack) stack.push(action);
+      else this.actions.set(action.id, [action]);
+      this.changed();
+      let released = false;
+      return () => {
+        if (released) return;
+        released = true;
+        const cur = this.actions.get(action.id);
+        if (!cur) return;
+        const i = cur.lastIndexOf(action);
+        if (i === -1) return;
+        cur.splice(i, 1);
+        if (cur.length === 0) {
+          queueMicrotask(() => {
+            if (cur.length === 0 && this.actions.get(action.id) === cur) this.actions.delete(action.id);
+          });
+        }
+        this.changed();
+      };
+    },
+    unregister: (id) => {
+      if (this.actions.delete(id)) this.changed();
+    },
+    mute: (id) => {
+      this.muted.set(id, (this.muted.get(id) ?? 0) + 1);
+      this.changed();
+      let released = false;
+      return () => {
+        if (released) return;
+        released = true;
+        const held = this.muted.get(id);
+        if (held === void 0) return;
+        if (held > 1) this.muted.set(id, held - 1);
+        else this.muted.delete(id);
+        this.changed();
+      };
+    },
+    tune: (id, tuning) => {
+      let stack = this.tunings.get(id);
+      if (!stack) this.tunings.set(id, stack = []);
+      const release = pushOwner(stack, tuning);
+      this.changed();
+      let released = false;
+      return () => {
+        if (released) return;
+        released = true;
+        release();
+        if (stack.length === 0) this.tunings.delete(id);
+        this.changed();
+      };
+    },
+    paramsOf: (id, given) => tunedParams(this.tuningsOf(id), given),
+    list: () => this.snapshot(),
+    trigger: (id, params) => {
+      const leaf = this.start();
+      const a = leaf.resolve(id);
+      if (!a?.invoker || a.invoker.timing !== "immediate") return false;
+      const deps = leaf.depsOf(a);
+      if (!evaluateEnabled(a, deps, pointOf(params)).enabled) return false;
+      try {
+        a.invoker.run(deps, params);
+      } catch (err) {
+        console.error(`weasel ActionsRegistry: action "${id}" threw`, err);
+      }
+      return true;
+    },
+    preview: (id, params) => {
+      const leaf = this.start();
+      const a = leaf.resolve(id);
+      if (!a?.preview) return NO_PREVIEW;
+      const deps = leaf.depsOf(a);
+      if (!evaluateEnabled(a, deps, pointOf(params)).enabled) return NO_PREVIEW;
+      let stop;
+      try {
+        stop = a.preview(deps, params);
+      } catch (err) {
+        console.error(`weasel ActionsRegistry: preview of "${id}" threw`, err);
+        return NO_PREVIEW;
+      }
+      if (typeof stop !== "function") return NO_PREVIEW;
+      let down = false;
+      return () => {
+        if (down) return;
+        down = true;
+        try {
+          stop();
+        } catch (err) {
+          console.error(`weasel ActionsRegistry: preview of "${id}" threw as it ended`, err);
+        }
+      };
+    },
+    subscribe: (listener) => this.tree.listeners.subscribe(listener),
+    setDispatcher: (d) => pushOwner(this.dispatchers, d),
+    begin: (id, params) => {
+      const leaf = this.start();
+      const a = leaf.resolve(id);
+      const disp = leaf.dispatcher();
+      if (!a || !disp) return null;
+      return disp.beginUiOngoing(id, leaf.depsOf(a), params);
+    },
+    activate: () => this.activate(),
+    isActive: () => this.isActive(),
+    holdsKeys: () => keyHolder === this,
+    dropKeys: () => {
+      if (keyHolder === this) keyHolder = null;
+    }
+  };
+};
+var NO_PREVIEW = () => {
+};
+function pointOf(params) {
+  const { worldX: x, worldY: y } = params ?? {};
+  return typeof x === "number" && typeof y === "number" ? { x, y } : void 0;
+}
+var keyHolder = null;
+var NODES = /* @__PURE__ */ new WeakMap();
+function actionsNodeOf(registry) {
+  return registry ? NODES.get(registry) ?? null : null;
+}
+function ActionsProvider({ children }) {
+  const depReg = useOptionalDepRegistry();
+  const depRegRef = useLatest(depReg);
+  const node = useMemo(() => new ActionsNode(null, true, () => depRegRef.current), [depRegRef]);
+  return /* @__PURE__ */ jsx(ActionsContext.Provider, { value: node.registry, children: /* @__PURE__ */ jsx(MenuHostContext.Provider, { value: node.menuHost(), children }) });
+}
+var IS_DEV = isDev();
+function useActionsRegistry() {
+  return useContext(ActionsContext);
+}
+function useAction(action) {
+  const reg = useActionsRegistry();
+  useEffect(() => {
+    if (!reg) {
+      if (IS_DEV) {
+        console.warn(
+          `useAction("${action.id}"): no <ActionsProvider> is in scope, so the action was not registered and its bindings will never fire.`
+        );
+      }
+      return;
+    }
+    return reg.register(action);
+  }, [reg, action]);
+}
 function useToolLifecycle(opts) {
   const { active, hotkeyStack } = opts;
   const liveRef = useRef(/* @__PURE__ */ new Set());
@@ -148,6 +419,7 @@ function useToolLifecycle(opts) {
 function createDispatchCore(src) {
   const { canvas } = src;
   let routedId = null;
+  let over = false;
   const target = () => {
     if (routedId === null) return src.root();
     return src.views()?.targets().find((t) => t.id === routedId) ?? src.root();
@@ -184,16 +456,22 @@ function createDispatchCore(src) {
       return fn ? fn(cx, cy) : { x: cx, y: cy };
     },
     toCanvasLocal: (cx, cy) => {
+      const own = src.clientToLocal();
+      if (own) return own(cx, cy);
       if (!canvas) return { x: cx, y: cy };
       const [x, y] = clientToCanvas(canvas, cx, cy);
       return { x, y };
     },
-    dispatch: (ev, on) => {
+    dispatch: (ev, on, reach) => {
       const d = on ?? dispatcherNow();
       src.uses(d);
-      return d.handleInput(ev, ctxNow());
+      return d.handleInput(ev, reach ? { ...ctxNow(), keyReach: reach } : ctxNow());
     },
     holdsKeys: () => canvas ? src.actions().holdsKeys() : src.actions().isActive(),
+    pointerOver: () => over,
+    setPointerOver: (next) => {
+      over = canvas !== null && next;
+    },
     activate: () => src.actions().activate(),
     disposed: src.disposed
   };
@@ -243,8 +521,65 @@ function underPointer(view, mods, w) {
     shiftKey: mods.shiftKey,
     ...affordance !== void 0 ? { affordance } : {},
     ...body?.body !== void 0 ? { bodyTarget: body.body } : {},
-    ...body?.kind !== void 0 ? { bodyKind: body.kind } : {}
+    ...body?.kind !== void 0 ? { bodyKind: body.kind } : {},
+    ...body?.doubleClick !== void 0 ? { doubleClickBody: doubleClickBodyOf(body.doubleClick) } : {}
+  };
+}
+function doubleClickBodyOf(named) {
+  return { bodyTarget: named.body, ...named.kind !== void 0 ? { bodyKind: named.kind } : {} };
+}
+
+// src/interactions/dispatcher/channels/carry.ts
+function carryInput(core) {
+  const { canvas } = core;
+  if (!canvas) return () => {
   };
+  const pinned = /* @__PURE__ */ new Map();
+  return addCarrySurface({
+    element: canvas,
+    receive(stage, payload, at, pointerId) {
+      if (core.disposed()) return "unhandled";
+      const event = () => {
+        const w = core.toWorld(at.clientX, at.clientY);
+        const { affordance, bodyTarget, bodyKind } = underPointer(core.target(), at, w);
+        return {
+          kind: "carry",
+          stage,
+          pointerId,
+          type: payload.type,
+          value: payload.value,
+          x: w.x,
+          y: w.y,
+          clientX: at.clientX,
+          clientY: at.clientY,
+          altKey: at.altKey,
+          ctrlKey: at.ctrlKey,
+          metaKey: at.metaKey,
+          shiftKey: at.shiftKey,
+          ...affordance !== void 0 ? { affordance } : {},
+          ...bodyTarget !== void 0 ? { bodyTarget } : {},
+          ...bodyKind !== void 0 ? { bodyKind } : {}
+        };
+      };
+      const routedNow = core.routedView();
+      try {
+        if (stage === "enter") {
+          core.routeAt(null, at.clientX, at.clientY);
+          pinned.set(pointerId, core.routedView());
+          return core.dispatch(event());
+        }
+        if (pinned.has(pointerId)) core.setRoutedView(pinned.get(pointerId));
+        if (stage === "drop" || stage === "leave") pinned.delete(pointerId);
+        if (stage !== "leave" && !core.dispatcherNow().inFlight().has(carryGestureId(pointerId))) {
+          core.routeAt(null, at.clientX, at.clientY);
+          if (stage === "move") pinned.set(pointerId, core.routedView());
+        }
+        return core.dispatch(event());
+      } finally {
+        core.setRoutedView(routedNow);
+      }
+    }
+  });
 }
 
 // src/interactions/dispatcher/channels/contextMenu.ts
@@ -253,6 +588,7 @@ function contextMenuInput(core, takeNativeHold) {
   const onContextMenu = (e) => {
     e.preventDefault();
     if (takeNativeHold()) return;
+    core.activate();
     routeAt(null, e.clientX, e.clientY);
     const w = toWorld(e.clientX, e.clientY);
     const ev = {
@@ -290,6 +626,15 @@ function hoverCursorInput(core, paintedCursor, pointersHeld, cursorSink = () =>
   };
   let last = null;
   let facts = null;
+  let heldHeard = null;
+  const hears = () => {
+    if (pointersHeld() === 0) {
+      heldHeard = null;
+      return true;
+    }
+    heldHeard ??= anyBinding(ctxNow(), (s) => s.kind === "hover" && s.held !== void 0);
+    return heldHeard;
+  };
   const resolve = () => {
     if (!canvas || !last) return;
     if (pointersHeld() > 0 || dispatcherNow().inFlight().size > 0) {
@@ -307,9 +652,10 @@ function hoverCursorInput(core, paintedCursor, pointersHeld, cursorSink = () =>
     const ctx = ctxNow();
     const d = dispatcherNow();
     const press = { kind: "pointerdown", x: w.x, y: w.y, clientX: h.clientX, clientY: h.clientY, ...where };
-    if (DEV) publishLiveDispatch(() => d.explain(press, ctx));
+    if (ctx.trace?.recording()) ctx.trace.setLive(() => d.explain(press, ctx));
     const click = { kind: "click", x: w.x, y: w.y, pressX: w.x, pressY: w.y, ...where };
-    const cursor = d.resolveOnly(press, ctx)?.action.cursor ?? dispatcherNow().resolveOnly(click, ctx)?.action.cursor;
+    const cursorOf = (r) => r ? actionCursor(r.action, r.params) : void 0;
+    const cursor = cursorOf(d.resolveOnly(press, ctx)) ?? cursorOf(dispatcherNow().resolveOnly(click, ctx));
     override.apply(cursor ?? null);
   };
   const refresh = () => {
@@ -324,19 +670,22 @@ function hoverCursorInput(core, paintedCursor, pointersHeld, cursorSink = () =>
       if (!core.disposed()) refresh();
     }, 0);
   };
+  const hoverAt = (at) => {
+    const w = toWorld(at.clientX, at.clientY);
+    const where = underPointer(target(), at, w);
+    const from = facts ? { from: whereOf(facts.where) } : {};
+    const held = pointersHeld() > 0 ? { held: true } : {};
+    facts = { at, where };
+    dispatch({ kind: "hover", x: w.x, y: w.y, clientX: at.clientX, clientY: at.clientY, ...where, ...from, ...held });
+  };
   return {
     moved(e) {
       last = hoverOf(e);
-      if (pointersHeld() === 0) {
-        const w = toWorld(e.clientX, e.clientY);
-        const where = underPointer(target(), last, w);
-        const from = facts ? { from: whereOf(facts.where) } : {};
-        facts = { at: last, where };
-        dispatch({ kind: "hover", x: w.x, y: w.y, clientX: e.clientX, clientY: e.clientY, ...where, ...from });
-      }
+      if (hears()) hoverAt(last);
       refresh();
     },
     released(e) {
+      heldHeard = null;
       last = hoverOf(e);
       refreshSoon();
     },
@@ -348,13 +697,16 @@ function hoverCursorInput(core, paintedCursor, pointersHeld, cursorSink = () =>
       }
       facts = null;
       last = null;
-      if (DEV) publishLiveDispatch(null);
+      ctxNow().trace?.setLive(null);
       paintedCursor()?.clearPointer();
       override.clear();
     },
     onKey(e) {
       if (!last) return;
+      const prev = last;
       last = { ...last, altKey: e.altKey, ctrlKey: e.ctrlKey, metaKey: e.metaKey, shiftKey: e.shiftKey };
+      const changed = prev.altKey !== last.altKey || prev.ctrlKey !== last.ctrlKey || prev.metaKey !== last.metaKey || prev.shiftKey !== last.shiftKey;
+      if (changed && hears()) hoverAt(last);
       refreshSoon();
     },
     clear: override.clear
@@ -451,22 +803,24 @@ function typedWithAltGraph(e) {
   const base = /^(?:Key|Digit)(.)$/.exec(e.code)?.[1];
   return base === void 0 || base.toLowerCase() !== e.key.toLowerCase();
 }
+var inMenu = (t) => t instanceof Element && t.closest('[role="menu"]') !== null;
 function keyboardInput(core) {
   const { dispatch, dispatcherNow } = core;
   const heldKeys = /* @__PURE__ */ new Map();
   const codeOf = (e) => e.code ? { code: e.code } : {};
   const physicalKey = (e) => e.code || e.key.toLowerCase();
   const onKeyDown = (e) => {
-    if (e.defaultPrevented || isEditableTarget(e.target) || focusedControlOwnsKey(e)) return;
-    if (!core.holdsKeys()) return;
+    if (e.defaultPrevented || isEditableTarget(e.target) || inMenu(e.target) || focusedControlOwnsKey(e)) return;
+    const reach = { held: core.holdsKeys(), over: core.pointerOver() };
+    if (!reach.held && !reach.over) return;
     if (e.repeat && heldKeys.has(physicalKey(e))) {
       e.preventDefault();
       return;
     }
-    if (press(e, { altKey: e.altKey, ctrlKey: e.ctrlKey })) return;
-    if (typedWithAltGraph(e)) press(e, { altKey: false, ctrlKey: false });
+    if (press(e, { altKey: e.altKey, ctrlKey: e.ctrlKey }, reach)) return;
+    if (typedWithAltGraph(e)) press(e, { altKey: false, ctrlKey: false }, reach);
   };
-  const press = (e, mods) => {
+  const press = (e, mods, reach) => {
     const keyEv = {
       kind: "key",
       key: e.key,
@@ -476,7 +830,7 @@ function keyboardInput(core) {
       shiftKey: e.shiftKey,
       repeat: e.repeat
     };
-    const keyResult = dispatch(keyEv);
+    const keyResult = dispatch(keyEv, void 0, reach);
     const heldEv = {
       kind: "key-held",
       key: e.key,
@@ -487,7 +841,7 @@ function keyboardInput(core) {
       shiftKey: e.shiftKey
     };
     const heldOn = dispatcherNow();
-    const heldResult = dispatch(heldEv, heldOn);
+    const heldResult = dispatch(heldEv, heldOn, reach);
     if (heldResult === "handled") {
       heldKeys.set(physicalKey(e), { key: e.key, ...codeOf(e), on: heldOn });
     }
@@ -553,6 +907,7 @@ var sampleOf = (e) => ({
   clientX: e.clientX,
   clientY: e.clientY,
   target: e.target,
+  timeStamp: e.timeStamp,
   altKey: e.altKey,
   ctrlKey: e.ctrlKey,
   metaKey: e.metaKey,
@@ -620,7 +975,11 @@ function pointerInput(core, opts) {
     clock: hold.clock,
     toWorld,
     toSurface: (p) => core.toCanvasLocal(p.x, p.y),
-    longPressMs: () => opts.longPress()?.duration,
+    longPressMs: () => opts.longPress()?.duration ?? opts.kitSettings().get("gestures.longPressMs"),
+    doubleClickMs: () => opts.kitSettings().get("gestures.doubleClickMs"),
+    doubleClickPx: () => opts.kitSettings().get("gestures.doubleClickPx"),
+    tapPx: () => opts.kitSettings().get("gestures.tapPx"),
+    dragPx: () => opts.kitSettings().get("gestures.dragPx"),
     clicks: opts.clicks,
     observer: {
       click: (world) => {
@@ -765,6 +1124,12 @@ function webkitPinchInput(core) {
 }
 
 // src/interactions/dispatcher/channels/wheel.ts
+var LINE_PX = 16;
+function pixelsPer(e, canvas) {
+  if (e.deltaMode === 1) return LINE_PX;
+  if (e.deltaMode === 2) return canvas?.clientHeight || LINE_PX * 20;
+  return 1;
+}
 function wheelInput(core, pinchLive) {
   const { routeAt, toWorld, target, dispatch } = core;
   const onWheel = (e) => {
@@ -777,10 +1142,11 @@ function wheelInput(core, pinchLive) {
     routeAt(null, e.clientX, e.clientY);
     const local = core.toCanvasLocal(e.clientX, e.clientY);
     const hitPoint = toWorld(e.clientX, e.clientY);
+    const toPx = pixelsPer(e, core.canvas);
     const ev = {
       kind: "wheel",
-      deltaX: e.deltaX,
-      deltaY: e.deltaY,
+      deltaX: e.deltaX * toPx,
+      deltaY: e.deltaY * toPx,
       clientX: local.x,
       clientY: local.y,
       ...underPointer(target(), e, hitPoint)
@@ -803,6 +1169,7 @@ function attachInput(canvas, src, channels) {
     canvas,
     root: src.root,
     views: src.views,
+    clientToLocal: src.clientToLocal,
     context: src.context,
     actions: src.actions,
     uses: () => {
@@ -817,6 +1184,7 @@ function attachInput(canvas, src, channels) {
   const hover = hoverCursorInput(core, src.paintedCursor, () => held?.count() ?? 0, src.cursorSink);
   const pointer = pointerInput(core, {
     longPress: src.longPress,
+    kitSettings: src.kitSettings,
     onClick: src.onClick,
     onDoubleClick: src.onDoubleClick,
     clicks: src.clicks,
@@ -837,6 +1205,12 @@ function attachInput(canvas, src, channels) {
   listeners.on(canvas, "pointerdown", () => {
     src.actions().activate();
   });
+  const setOver = (on) => () => {
+    core.setPointerOver(on);
+  };
+  listeners.on(canvas, "pointerenter", setOver(true));
+  listeners.on(canvas, "pointermove", setOver(true));
+  listeners.on(canvas, "pointerleave", setOver(false));
   if (channels.pointer) {
     listeners.on(window, "keydown", hover.onKey);
     listeners.on(window, "keyup", hover.onKey);
@@ -844,6 +1218,14 @@ function attachInput(canvas, src, channels) {
     listeners.on(canvas, "pointerdown", pointer.onPointerDown);
     listeners.on(canvas, "pointermove", pointer.onHoverMove);
     listeners.on(canvas, "dblclick", pointer.onNativeDoubleClick);
+  } else if (channels.hover) {
+    listeners.on(window, "keydown", hover.onKey);
+    listeners.on(window, "keyup", hover.onKey);
+    listeners.on(canvas, "pointerleave", hover.onLeave);
+    listeners.on(canvas, "pointermove", (e) => {
+      core.routeAt(null, e.clientX, e.clientY);
+      hover.moved(e);
+    });
   }
   if (channels.wheel) {
     listeners.on(canvas, "wheel", wheelInput(core, pinch.live), { passive: false, capture: true });
@@ -863,8 +1245,10 @@ function attachInput(canvas, src, channels) {
     listeners.on(canvas, "drop", ingest.onDrop);
     listeners.on(window, "paste", ingest.onPaste);
   }
+  const offCarry = channels.carry ? carryInput(core) : null;
   return () => {
     listeners.removeAll();
+    offCarry?.();
     canvas?.classList.remove(DROPOVER_CLASS);
     src.actions().dropKeys();
     hover.clear();
@@ -878,29 +1262,39 @@ function attachInput(canvas, src, channels) {
 
 // src/interactions/dispatcher/useGestureDispatcher.tsx
 function useGestureDispatcher(opts) {
-  const { canvasRef, actions, entriesById, enabled = true, keyboard = true, affordanceAt, classifyTarget, dispatcher: dispatcherOpt, clientToWorld, requestRedraw, paintedCursor, cursorSink, getRuleCtx, onClick, onDoubleClick, views, channels, longPress, claimKeys = false } = opts;
+  const { canvasRef, actions, entriesById, enabled = true, keyboard = true, affordanceAt, classifyTarget, dispatcher: dispatcherOpt, trace: traceOpt, clientToWorld, clientToLocal, requestRedraw, paintedCursor, cursorSink, getRuleCtx, onClick, onDoubleClick, views, channels, longPress, claimKeys = false, hears = "scope" } = opts;
   const pointerChannel = channels?.pointer !== false;
+  const hoverChannel = channels?.hover ?? pointerChannel;
   const wheelChannel = channels?.wheel !== false;
   const pinchChannel = channels?.pinch !== false;
   const contextMenuChannel = channels?.contextMenu !== false;
   const ingestChannel = channels?.ingest !== false;
+  const carryChannel = channels?.carry !== false;
   const onClickRef = useLatest(onClick);
   const onDoubleClickRef = useLatest(onDoubleClick);
   const activeTool = useActiveToolContext();
   const depRegistry = useDepRegistry();
   const [isMac] = useState(isApplePlatform);
+  const [ownTrace] = useState(createDispatchTrace);
+  const trace = traceOpt ?? ownTrace;
+  useEffect(() => depRegistry.register("dispatchTrace", () => trace), [depRegistry, trace]);
   const dispatcherRef = useRef(null);
   if (!dispatcherRef.current) {
     dispatcherRef.current = dispatcherOpt ?? createDispatcher();
   }
   const registryRef = useLatest(actions);
+  const heard = useMemo(() => {
+    const node = hears === "own" ? actionsNodeOf(actions) : null;
+    return node ? { list: () => node.ownActions() } : actions;
+  }, [actions, hears]);
   const ctxRef = useLatest({
-    actions,
+    actions: heard,
     depRegistry,
     activeToolId: activeTool.active,
     hotkeyStack: activeTool.hotkeyStack,
     entriesById,
-    isMac
+    isMac,
+    trace
   });
   const rootTargetRef = useLatest({
     id: null,
@@ -911,6 +1305,7 @@ function useGestureDispatcher(opts) {
     getRuleCtx
   });
   const viewsRef = useLatest(views);
+  const clientToLocalRef = useLatest(clientToLocal);
   const allDispatchers = useCallback(() => [
     rootTargetRef.current.dispatcher,
     ...(viewsRef.current?.targets() ?? []).map((t) => t.dispatcher)
@@ -918,6 +1313,7 @@ function useGestureDispatcher(opts) {
   const requestRedrawRef = useLatest(requestRedraw);
   const cursorRef = useLatest({ painted: paintedCursor, sink: cursorSink });
   const longPressRef = useLatest(longPress);
+  const kitSettingsRef = useLatest(useKitSettings());
   const clicksRef = useRef({ last: null });
   useToolLifecycle({
     entriesById,
@@ -936,6 +1332,7 @@ function useGestureDispatcher(opts) {
     return attachInput(canvasRef.current, {
       root: () => rootTargetRef.current,
       views: () => viewsRef.current,
+      clientToLocal: () => clientToLocalRef.current,
       context: () => ctxRef.current,
       actions: () => registryRef.current,
       dispatchers: allDispatchers,
@@ -945,28 +1342,35 @@ function useGestureDispatcher(opts) {
       paintedCursor: () => cursorRef.current.painted?.(),
       cursorSink: () => cursorRef.current.sink?.(),
       longPress: () => longPressRef.current,
+      kitSettings: () => kitSettingsRef.current,
       onClick: () => onClickRef.current,
       onDoubleClick: () => onDoubleClickRef.current,
       clicks: clicksRef.current
     }, {
       keyboard,
       pointer: pointerChannel,
+      hover: hoverChannel,
       wheel: wheelChannel,
       pinch: pinchChannel,
       contextMenu: contextMenuChannel,
-      ingest: ingestChannel
+      ingest: ingestChannel,
+      carry: carryChannel
     });
   }, [
     enabled,
     keyboard,
     canvasRef,
     pointerChannel,
+    hoverChannel,
     wheelChannel,
     pinchChannel,
     contextMenuChannel,
     ingestChannel,
+    carryChannel,
     allDispatchers,
+    clientToLocalRef,
     ctxRef,
+    kitSettingsRef,
     longPressRef,
     onClickRef,
     onDoubleClickRef,
@@ -977,206 +1381,36 @@ function useGestureDispatcher(opts) {
     viewsRef
   ]);
 }
-var ActionsContext = createContext(null);
-function depsFor(a, r) {
-  if (!r) return {};
-  if (a.requires) return buildDepsFromRequires(a, r);
-  return {
-    selection: r.get("selection"),
-    scene: r.get("scene"),
-    history: r.get("history"),
-    view: r.get("view"),
-    activeTool: r.get("activeTool"),
-    booleansAdapter: r.get("booleansAdapter")
-  };
-}
-var ActionsNode = class extends ScopeNode {
-  constructor(parent, descends, contextDeps) {
-    super(parent, descends);
-    this.contextDeps = contextDeps;
-    NODES.set(this.registry, this);
-  }
-  contextDeps;
-  actions = /* @__PURE__ */ new Map();
-  muted = /* @__PURE__ */ new Map();
-  tunings = /* @__PURE__ */ new Map();
-  dispatchers = [];
-  cache = null;
-  /** Called on `activate`, so a scope's dep and tool nodes move with it. */
-  onActivate = [];
-  resolve(id) {
-    for (const n of this.chain()) {
-      if (n.muted.has(id)) return void 0;
-      const a = n.actions.get(id)?.at(-1);
-      if (a) return this.tuned(a);
-    }
-    return void 0;
-  }
-  /** `a` under every tuning for its id from the root down to here. */
-  tuned(a) {
-    const tunings = [];
-    for (const n of this.chain()) {
-      const stack = n.tunings.get(a.id);
-      if (stack) tunings.unshift(...stack);
-    }
-    return tunings.length ? tuneAction(a, tunings) : a;
-  }
-  snapshot() {
-    const leaf = this.start();
-    const cached = this.cache;
-    if (cached && cached.version === this.tree.version && cached.leaf === leaf) return cached.list;
-    const ids = /* @__PURE__ */ new Set();
-    for (const n of leaf.chain()) for (const id of n.actions.keys()) ids.add(id);
-    const out = [];
-    for (const id of ids) {
-      const a = leaf.resolve(id);
-      if (a) out.push(a);
-    }
-    const list = Object.freeze(out);
-    this.cache = { version: this.tree.version, leaf, list };
-    return list;
-  }
-  deps() {
-    for (const n of this.chain()) {
-      const r = n.contextDeps();
-      if (r) return r;
-    }
-    return null;
-  }
-  dispatcher() {
-    for (const n of this.chain()) {
-      const d = n.dispatchers.at(-1);
-      if (d) return d;
-    }
-    return null;
-  }
-  activate() {
-    keyHolder = this;
-    super.activate();
-    for (const f of this.onActivate) f();
-  }
-  registry = {
-    register: (action) => {
-      validateActionId(action.id);
-      validateActionDefaultBinding(action);
-      const stack = this.actions.get(action.id);
-      if (stack) stack.push(action);
-      else this.actions.set(action.id, [action]);
-      this.changed();
-      let released = false;
-      return () => {
-        if (released) return;
-        released = true;
-        const cur = this.actions.get(action.id);
-        if (!cur) return;
-        const i = cur.lastIndexOf(action);
-        if (i === -1) return;
-        cur.splice(i, 1);
-        if (cur.length === 0) {
-          queueMicrotask(() => {
-            if (cur.length === 0 && this.actions.get(action.id) === cur) this.actions.delete(action.id);
-          });
-        }
-        this.changed();
-      };
-    },
-    unregister: (id) => {
-      if (this.actions.delete(id)) this.changed();
-    },
-    mute: (id) => {
-      this.muted.set(id, (this.muted.get(id) ?? 0) + 1);
-      this.changed();
-      let released = false;
-      return () => {
-        if (released) return;
-        released = true;
-        const held = this.muted.get(id);
-        if (held === void 0) return;
-        if (held > 1) this.muted.set(id, held - 1);
-        else this.muted.delete(id);
-        this.changed();
-      };
-    },
-    tune: (id, tuning) => {
-      let stack = this.tunings.get(id);
-      if (!stack) this.tunings.set(id, stack = []);
-      const release = pushOwner(stack, tuning);
-      this.changed();
-      let released = false;
-      return () => {
-        if (released) return;
-        released = true;
-        release();
-        if (stack.length === 0) this.tunings.delete(id);
-        this.changed();
-      };
-    },
-    list: () => this.snapshot(),
-    trigger: (id, params) => {
-      const leaf = this.start();
-      const a = leaf.resolve(id);
-      if (!a?.invoker || a.invoker.timing !== "immediate") return false;
-      const deps = depsFor(a, leaf.deps());
-      if (!evaluateEnabled(a, deps).enabled) return false;
-      try {
-        a.invoker.run(deps, params);
-      } catch (err) {
-        console.error(`weasel ActionsRegistry: action "${id}" threw`, err);
-      }
-      return true;
-    },
-    subscribe: (listener) => this.tree.listeners.subscribe(listener),
-    setDispatcher: (d) => pushOwner(this.dispatchers, d),
-    begin: (id, params) => {
-      const leaf = this.start();
-      const a = leaf.resolve(id);
-      const disp = leaf.dispatcher();
-      if (!a || !disp) return null;
-      return disp.beginUiOngoing(id, depsFor(a, leaf.deps()), params);
-    },
-    activate: () => this.activate(),
-    isActive: () => this.isActive(),
-    holdsKeys: () => keyHolder === this,
-    dropKeys: () => {
-      if (keyHolder === this) keyHolder = null;
-    }
-  };
-};
-var keyHolder = null;
-var NODES = /* @__PURE__ */ new WeakMap();
-function actionsNodeOf(registry) {
-  return registry ? NODES.get(registry) ?? null : null;
-}
-function ActionsProvider({ children }) {
-  const depReg = useOptionalDepRegistry();
-  const depRegRef = useLatest(depReg);
-  const node = useMemo(() => new ActionsNode(null, true, () => depRegRef.current), [depRegRef]);
-  return /* @__PURE__ */ jsx(ActionsContext.Provider, { value: node.registry, children });
-}
-var IS_DEV = (() => {
-  try {
-    return Boolean(import.meta.env?.DEV);
-  } catch {
-    return false;
-  }
-})();
-function useActionsRegistry() {
-  return useContext(ActionsContext);
+function useCommand(id, label, run, options) {
+  const latest = useLatest({ run, options });
+  const keys = useStableByContent(options?.keys, deepEqual);
+  const tags = useStableByContent(options?.tags, deepEqual);
+  const variants = useStableByContent(options?.variants, deepEqual);
+  const hasEnabled = options?.enabled !== void 0;
+  const hasActive = options?.active !== void 0;
+  const icon = options?.icon;
+  const action = useMemo(() => {
+    const read = () => latest.current.options;
+    const a = {
+      id,
+      label,
+      invoker: { timing: "immediate", run: (_deps, params) => latest.current.run(params) }
+    };
+    if (keys !== void 0) a.defaultBinding = bindingOf(keys);
+    if (tags !== void 0) a.tags = tags;
+    if (variants !== void 0) a.variants = variants;
+    if (hasEnabled) a.enabled = () => read()?.enabled?.() ?? true;
+    if (hasActive) a.active = () => read()?.active?.() ?? false;
+    if (icon !== void 0) a.icon = icon;
+    return a;
+  }, [id, label, icon, keys, tags, variants, hasEnabled, hasActive, latest]);
+  useAction(action);
 }
-function useAction(action) {
-  const reg = useActionsRegistry();
-  useEffect(() => {
-    if (!reg) {
-      if (IS_DEV) {
-        console.warn(
-          `useAction("${action.id}"): no <ActionsProvider> is in scope, so the action was not registered and its bindings will never fire.`
-        );
-      }
-      return;
-    }
-    return reg.register(action);
-  }, [reg, action]);
+function bindingOf(keys) {
+  if (isList(keys)) return [...keys];
+  return "spec" in keys ? [keys] : keys;
 }
+var isList = (keys) => Array.isArray(keys);
 function useNodes(descends, ownsTool, parent) {
   const parentActions = useActionsRegistry();
   const parentDeps = useOptionalDepRegistry();
@@ -1200,7 +1434,8 @@ function useNodes(descends, ownsTool, parent) {
   return nodes;
 }
 function Provide({ nodes, children }) {
-  return /* @__PURE__ */ jsx(DepRegistryContext.Provider, { value: nodes.deps.registry, children: /* @__PURE__ */ jsx(ActionsContext.Provider, { value: nodes.actions.registry, children: /* @__PURE__ */ jsx(ActiveToolNodeContext.Provider, { value: nodes.tools, children }) }) });
+  const menuHost = useContext(MenuHostContext) ?? nodes.actions.menuHost();
+  return /* @__PURE__ */ jsx(DepRegistryContext.Provider, { value: nodes.deps.registry, children: /* @__PURE__ */ jsx(ActionsContext.Provider, { value: nodes.actions.registry, children: /* @__PURE__ */ jsx(ActiveToolNodeContext.Provider, { value: nodes.tools, children: /* @__PURE__ */ jsx(MenuHostContext.Provider, { value: menuHost, children }) }) }) });
 }
 function InputScope({ yoke, children }) {
   const nodes = useNodes(false, yoke === void 0, yoke);
@@ -1533,6 +1768,6 @@ function useTools(opts) {
   );
 }
 
-export { ActionsProvider, ActiveToolContextProvider, ActiveToolContextProviderIfRoot, DepRegistryProvider, InputScope, PointerContextProvider, SelectionContextProvider, SelectionContextProviderIfRoot, Yoke, createPointerStore, useAction, useActionsRegistry, useActiveToolContext, useContributions, useDepRegistry, useDepSource, useGestureDispatcher, useOffhandAction, useOngoingAction, useOptionalActiveToolContext, useOptionalDepRegistry, usePointerContext, usePointerPosition, usePublishSelection, useSelectionContext, useTools, useYoke };
+export { ActionsProvider, ActiveToolContextProvider, ActiveToolContextProviderIfRoot, DepRegistryProvider, InputScope, PointerContextProvider, SelectionContextProvider, SelectionContextProviderIfRoot, Yoke, createPointerStore, useAction, useActionsRegistry, useActiveToolContext, useCommand, useContributions, useDepRegistry, useDepSource, useGestureDispatcher, useMenuHost, useMenus, useOffhandAction, useOngoingAction, useOptionalActiveToolContext, useOptionalDepRegistry, usePointerContext, usePointerPosition, usePublishSelection, useSelectionContext, useTools, useYoke };
 //# sourceMappingURL=react.js.map
 //# sourceMappingURL=react.js.map