@weasel-js/routing 1.10.0 → 1.11.0

package/dist/react.js

@@ -1,10 +1,10 @@
-import { createDepRegistry, createDispatcher, assembleEntries, liveScope, isDev, reportRouteConflicts, offhandKeyFor, makeToolOffhandAction, buildToolOffhandBindings, dlog, ScopeNode, isTool, DEV, publishLiveDispatch, LONG_PRESS_HAPTIC_MS, multiTouchGestureId, openPointerSession, pushOwner, evaluateEnabled, validateActionId, validateActionDefaultBinding, depNodeOf, DepNode, clientToCanvas, buildDepsFromRequires, isEditableTarget, focusedControlOwnsKey, itemsFromClipboardData, itemsFromDataTransfer, itemTypesFromDataTransfer } from './chunk-4DR6AJMN.js';
-import { createContext, useState, useContext, useEffect, useRef, useCallback, useMemo, useSyncExternalStore } from 'react';
-import { isApplePlatform, createPointerRecognizer, isInControlWithin, longPressEvents, stylusOf } from '@weasel-js/gestures';
-import { useLatest, useStableByContent, sameList } from '@weasel-js/react';
+import { createDepRegistry, createDispatcher, assembleEntries, liveScope, reportRouteConflicts, offhandKeyFor, makeToolOffhandAction, buildToolOffhandBindings, dlog, ScopeNode, tuneAction, createMenuHost, pushOwner, evaluateEnabled, tunedParams, validateActionId, validateActionDefaultBinding, isTool, depNodeOf, DepNode, buildDepsFromRequires, clientToCanvas, DEV, publishLiveDispatch, LONG_PRESS_HAPTIC_MS, multiTouchGestureId, openPointerSession, addCarrySurface, gestureIdFor, isEditableTarget, focusedControlOwnsKey, itemsFromClipboardData, itemsFromDataTransfer, itemTypesFromDataTransfer, actionCursor } from './chunk-QBQQIFPI.js';
+import { createContext, useState, useContext, useEffect, useMemo, useRef, useCallback, useSyncExternalStore } from 'react';
+import { isApplePlatform, heldPointers, createPointerRecognizer, isInControlWithin, longPressEvents, stylusOf } from '@weasel-js/gestures';
+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 {
@@ -111,6 +111,277 @@ function useDepSource(name, source) {
     return registry.register(name, () => sourceRef.current());
   }, [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());
@@ -133,7 +404,7 @@ function useToolLifecycle(opts) {
     const next = new Set(active === null ? hotkeyStack : [active, ...hotkeyStack]);
     liveRef.current = next;
     for (const id of prev) if (!next.has(id)) fire(id, "onDeactivate");
-    if (prevActiveRef.current !== active) onSwitchRef.current?.();
+    if (prevActiveRef.current !== null && prevActiveRef.current !== active) onSwitchRef.current?.();
     prevActiveRef.current = active;
     for (const id of next) if (!prev.has(id)) fire(id, "onActivate");
   });
@@ -184,6 +455,8 @@ 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 };
@@ -232,6 +505,56 @@ function dispatcherWatch(onChange) {
   };
 }
 
+// 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);
+        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
+        };
+      };
+      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 !== "move") pinned.delete(pointerId);
+        const ev = event();
+        if (stage === "drop" && !core.dispatcherNow().inFlight().has(gestureIdFor(ev))) {
+          core.routeAt(null, at.clientX, at.clientY);
+          return core.dispatch(event());
+        }
+        return core.dispatch(ev);
+      } finally {
+        core.setRoutedView(routedNow);
+      }
+    }
+  });
+}
+
 // src/interactions/dispatcher/underPointer.ts
 function underPointer(view, mods, w) {
   const affordance = view.affordanceAt?.(w) ?? void 0;
@@ -243,9 +566,13 @@ 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/contextMenu.ts
 function contextMenuInput(core, takeNativeHold) {
@@ -253,6 +580,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 = {
@@ -268,6 +596,11 @@ function contextMenuInput(core, takeNativeHold) {
   };
   return onContextMenu;
 }
+var whereOf = ({ affordance, bodyTarget, bodyKind }) => ({
+  ...affordance !== void 0 ? { affordance } : {},
+  ...bodyTarget !== void 0 ? { bodyTarget } : {},
+  ...bodyKind !== void 0 ? { bodyKind } : {}
+});
 var hoverOf = (e) => ({
   clientX: e.clientX,
   clientY: e.clientY,
@@ -304,7 +637,8 @@ function hoverCursorInput(core, paintedCursor, pointersHeld, cursorSink = () =>
     const press = { kind: "pointerdown", x: w.x, y: w.y, clientX: h.clientX, clientY: h.clientY, ...where };
     if (DEV) publishLiveDispatch(() => 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 = () => {
@@ -319,15 +653,17 @@ 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) } : {};
+    facts = { at, where };
+    dispatch({ kind: "hover", x: w.x, y: w.y, clientX: at.clientX, clientY: at.clientY, ...where, ...from });
+  };
   return {
     moved(e) {
       last = hoverOf(e);
-      if (pointersHeld() === 0) {
-        const w = toWorld(e.clientX, e.clientY);
-        const where = underPointer(target(), last, w);
-        facts = { at: last, where };
-        dispatch({ kind: "hover", x: w.x, y: w.y, clientX: e.clientX, clientY: e.clientY, ...where });
-      }
+      if (pointersHeld() === 0) hoverAt(last);
       refresh();
     },
     released(e) {
@@ -335,6 +671,12 @@ function hoverCursorInput(core, paintedCursor, pointersHeld, cursorSink = () =>
       refreshSoon();
     },
     onLeave() {
+      if (facts) {
+        const { at, where } = facts;
+        const w = toWorld(at.clientX, at.clientY);
+        dispatch({ kind: "hover", off: true, x: w.x, y: w.y, clientX: at.clientX, clientY: at.clientY, ...where, from: whereOf(where) });
+      }
+      facts = null;
       last = null;
       if (DEV) publishLiveDispatch(null);
       paintedCursor()?.clearPointer();
@@ -342,7 +684,10 @@ function hoverCursorInput(core, paintedCursor, pointersHeld, cursorSink = () =>
     },
     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 && pointersHeld() === 0) hoverAt(last);
       refreshSoon();
     },
     clear: override.clear
@@ -439,13 +784,14 @@ 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 (e.defaultPrevented || isEditableTarget(e.target) || inMenu(e.target) || focusedControlOwnsKey(e)) return;
     if (!core.holdsKeys()) return;
     if (e.repeat && heldKeys.has(physicalKey(e))) {
       e.preventDefault();
@@ -608,7 +954,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) => {
@@ -678,7 +1028,6 @@ function pointerInput(core, opts) {
       hold.routeToPress();
       return recognizer.takeHold();
     },
-    heldCount: () => recognizer.heldCount(),
     cancelHeld() {
       for (const session of [...sessions.values()]) session.cancel();
     },
@@ -754,6 +1103,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) => {
@@ -766,10 +1121,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)
@@ -783,14 +1139,101 @@ function wheelInput(core, pinchLive) {
   return onWheel;
 }
 
+// src/interactions/dispatcher/attachInput.ts
+function attachInput(canvas, src, channels) {
+  let disposed = false;
+  const redraw = dispatcherWatch(src.requestRedraw);
+  redraw.sync(src.dispatchers());
+  const core = createDispatchCore({
+    canvas,
+    root: src.root,
+    views: src.views,
+    clientToLocal: src.clientToLocal,
+    context: src.context,
+    actions: src.actions,
+    uses: () => {
+      redraw.sync(src.dispatchers());
+    },
+    disposed: () => disposed
+  });
+  const keys = keyboardInput(core);
+  const pinch = webkitPinchInput(core);
+  const ingest = ingestInput(core);
+  const held = canvas ? heldPointers(canvas) : null;
+  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,
+    hover
+  });
+  const onWindowBlur = () => {
+    pinch.end();
+    pointer.cancelHeld();
+    keys.releaseAll();
+  };
+  const listeners = listenerSet();
+  const keyCapture = channels.keyboard === "first";
+  if (channels.keyboard) {
+    listeners.on(window, "keydown", keys.onKeyDown, keyCapture);
+    listeners.on(window, "keyup", keys.onKeyUp, keyCapture);
+  }
+  listeners.on(window, "blur", onWindowBlur);
+  listeners.on(canvas, "pointerdown", () => {
+    src.actions().activate();
+  });
+  if (channels.pointer) {
+    listeners.on(window, "keydown", hover.onKey);
+    listeners.on(window, "keyup", hover.onKey);
+    listeners.on(canvas, "pointerleave", hover.onLeave);
+    listeners.on(canvas, "pointerdown", pointer.onPointerDown);
+    listeners.on(canvas, "pointermove", pointer.onHoverMove);
+    listeners.on(canvas, "dblclick", pointer.onNativeDoubleClick);
+  }
+  if (channels.wheel) {
+    listeners.on(canvas, "wheel", wheelInput(core, pinch.live), { passive: false, capture: true });
+  }
+  if (channels.pinch) {
+    listeners.on(canvas, "gesturestart", pinch.onGestureStart);
+    listeners.on(canvas, "gesturechange", pinch.onGestureChange);
+    listeners.on(canvas, "gestureend", pinch.onGestureEnd);
+  }
+  if (channels.contextMenu) {
+    listeners.on(canvas, "contextmenu", contextMenuInput(core, pointer.takeNativeHold));
+  }
+  if (channels.ingest) {
+    listeners.on(canvas, "dragenter", ingest.onDragOver);
+    listeners.on(canvas, "dragover", ingest.onDragOver);
+    listeners.on(canvas, "dragleave", ingest.onDragLeave);
+    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();
+    disposed = true;
+    pointer.dispose();
+    held?.release();
+    redraw.stop();
+    for (const d of src.dispatchers()) d.cancelAll("cancel");
+  };
+}
+
 // 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, clientToWorld, clientToLocal, requestRedraw, paintedCursor, cursorSink, getRuleCtx, onClick, onDoubleClick, views, channels, longPress, claimKeys = false, hears = "scope" } = 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 carryChannel = channels?.carry !== false;
   const onClickRef = useLatest(onClick);
   const onDoubleClickRef = useLatest(onDoubleClick);
   const activeTool = useActiveToolContext();
@@ -801,8 +1244,12 @@ function useGestureDispatcher(opts) {
     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,
@@ -818,6 +1265,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)
@@ -825,6 +1273,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,
@@ -840,85 +1289,32 @@ function useGestureDispatcher(opts) {
   }, [enabled, claimKeys, registryRef]);
   useEffect(() => {
     if (!enabled) return;
-    let disposed = false;
-    const canvas = canvasRef.current;
-    const redraw = dispatcherWatch(() => {
-      requestRedrawRef.current?.();
-    });
-    redraw.sync(allDispatchers());
-    const core = createDispatchCore({
-      canvas,
+    return attachInput(canvasRef.current, {
       root: () => rootTargetRef.current,
       views: () => viewsRef.current,
+      clientToLocal: () => clientToLocalRef.current,
       context: () => ctxRef.current,
       actions: () => registryRef.current,
-      uses: () => {
-        redraw.sync(allDispatchers());
+      dispatchers: allDispatchers,
+      requestRedraw: () => {
+        requestRedrawRef.current?.();
       },
-      disposed: () => disposed
-    });
-    const keys = keyboardInput(core);
-    const pinch = webkitPinchInput(core);
-    const ingest = ingestInput(core);
-    const hover = hoverCursorInput(core, () => cursorRef.current.painted?.(), () => pointer.heldCount(), () => cursorRef.current.sink?.());
-    const pointer = pointerInput(core, {
+      paintedCursor: () => cursorRef.current.painted?.(),
+      cursorSink: () => cursorRef.current.sink?.(),
       longPress: () => longPressRef.current,
+      kitSettings: () => kitSettingsRef.current,
       onClick: () => onClickRef.current,
       onDoubleClick: () => onDoubleClickRef.current,
-      clicks: clicksRef.current,
-      hover
+      clicks: clicksRef.current
+    }, {
+      keyboard,
+      pointer: pointerChannel,
+      wheel: wheelChannel,
+      pinch: pinchChannel,
+      contextMenu: contextMenuChannel,
+      ingest: ingestChannel,
+      carry: carryChannel
     });
-    const onWindowBlur = () => {
-      pinch.end();
-      pointer.cancelHeld();
-      keys.releaseAll();
-    };
-    const listeners = listenerSet();
-    const keyCapture = keyboard === "first";
-    if (keyboard) {
-      listeners.on(window, "keydown", keys.onKeyDown, keyCapture);
-      listeners.on(window, "keyup", keys.onKeyUp, keyCapture);
-    }
-    listeners.on(window, "blur", onWindowBlur);
-    listeners.on(canvas, "pointerdown", () => {
-      registryRef.current.activate();
-    });
-    if (pointerChannel) {
-      listeners.on(window, "keydown", hover.onKey);
-      listeners.on(window, "keyup", hover.onKey);
-      listeners.on(canvas, "pointerleave", hover.onLeave);
-      listeners.on(canvas, "pointerdown", pointer.onPointerDown);
-      listeners.on(canvas, "pointermove", pointer.onHoverMove);
-      listeners.on(canvas, "dblclick", pointer.onNativeDoubleClick);
-    }
-    if (wheelChannel) {
-      listeners.on(canvas, "wheel", wheelInput(core, pinch.live), { passive: false, capture: true });
-    }
-    if (pinchChannel) {
-      listeners.on(canvas, "gesturestart", pinch.onGestureStart);
-      listeners.on(canvas, "gesturechange", pinch.onGestureChange);
-      listeners.on(canvas, "gestureend", pinch.onGestureEnd);
-    }
-    if (contextMenuChannel) {
-      listeners.on(canvas, "contextmenu", contextMenuInput(core, pointer.takeNativeHold));
-    }
-    if (ingestChannel) {
-      listeners.on(canvas, "dragenter", ingest.onDragOver);
-      listeners.on(canvas, "dragover", ingest.onDragOver);
-      listeners.on(canvas, "dragleave", ingest.onDragLeave);
-      listeners.on(canvas, "drop", ingest.onDrop);
-      listeners.on(window, "paste", ingest.onPaste);
-    }
-    return () => {
-      listeners.removeAll();
-      canvas?.classList.remove(DROPOVER_CLASS);
-      registryRef.current.dropKeys();
-      hover.clear();
-      disposed = true;
-      pointer.dispose();
-      redraw.stop();
-      for (const d of allDispatchers()) d.cancelAll("cancel");
-    };
   }, [
     enabled,
     keyboard,
@@ -928,8 +1324,11 @@ function useGestureDispatcher(opts) {
     pinchChannel,
     contextMenuChannel,
     ingestChannel,
+    carryChannel,
     allDispatchers,
+    clientToLocalRef,
     ctxRef,
+    kitSettingsRef,
     longPressRef,
     onClickRef,
     onDoubleClickRef,
@@ -940,182 +1339,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();
-  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 a;
-    }
-    return void 0;
-  }
-  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();
-      };
-    },
-    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();
@@ -1139,7 +1392,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);
@@ -1177,7 +1431,20 @@ function useOngoingAction(actionId) {
       }
     };
   }, [regRef, idRef]);
-  useEffect(() => () => edit.commit(), [edit, actionId]);
+  const leaving = useRef(null);
+  useEffect(() => {
+    const left = leaving.current;
+    leaving.current = null;
+    if (left !== null && left !== actionId) edit.commit();
+    return () => {
+      leaving.current = actionId;
+      queueMicrotask(() => {
+        if (leaving.current !== actionId) return;
+        leaving.current = null;
+        edit.commit();
+      });
+    };
+  }, [edit, actionId]);
   return edit;
 }
 function samePos(a, b) {
@@ -1459,6 +1726,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