@weasel-js/routing 1.9.3 → 1.9.4

package/dist/react.js

@@ -1,8 +1,8 @@
-import { createDepRegistry, createDispatcher, isTool, scopeBindings, liveScope, isDev, reportRouteConflicts, offhandKeyFor, makeToolOffhandAction, buildToolOffhandBindings, dlog, isEditableTarget, activatesFocusedControl, clientToCanvasRect, openPointerSession, LONG_PRESS_MS, publishLiveDispatch, pointerGestureId, itemsFromDataTransfer, itemsFromClipboardData, ScopeNode, pushOwner, validateActionId, validateActionDefaultBinding, depNodeOf, DepNode, buildDepsFromRequires } from './chunk-LOP2JTTA.js';
+import { createDepRegistry, createDispatcher, isTool, assembleEntries, liveScope, isDev, reportRouteConflicts, offhandKeyFor, makeToolOffhandAction, buildToolOffhandBindings, dlog, openPointerSession, LONG_PRESS_MS, publishLiveDispatch, pointerGestureId, ScopeNode, pushOwner, validateActionId, validateActionDefaultBinding, depNodeOf, DepNode, clientToCanvasRect, buildDepsFromRequires, isEditableTarget, activatesFocusedControl, itemsFromClipboardData, itemsFromDataTransfer } from './chunk-Y5RURZBH.js';
 import { createContext, useState, useContext, useEffect, useRef, useCallback, useMemo, useSyncExternalStore } from 'react';
 import { useLatest, useStableByContent, sameList } from '@weasel-js/react';
 import { jsx, Fragment } from 'react/jsx-runtime';
-import { isInControlWithin, pastDragThreshold } from '@weasel-js/gestures';
+import { isApplePlatform, isInControlWithin, pastDragThreshold } from '@weasel-js/gestures';
 import { resolveCursorTier } from '@weasel-js/cursor';
 import { activeModeOf } from '@weasel-js/modes';
 
@@ -115,19 +115,8 @@ function useDepSource(name, source) {
     return registry.register(name, () => sourceRef.current());
   }, [name, registry, sourceRef]);
 }
-var DROPOVER_CLASS = "weasel-dropover";
-function stylusOf(e) {
-  return {
-    ...typeof e.pressure === "number" ? { pressure: e.pressure } : {},
-    ...typeof e.tiltX === "number" ? { tiltX: e.tiltX } : {},
-    ...typeof e.tiltY === "number" ? { tiltY: e.tiltY } : {}
-  };
-}
-var IS_MAC = typeof navigator !== "undefined" && /mac/i.test(
-  // `||`, not `??`: jsdom (and some embedders) report an empty-string
-  // platform, which is not nullish and would swallow the UA fallback.
-  navigator.platform || navigator.userAgent
-);
+
+// src/interactions/dispatcher/dispatchCore.ts
 function withViewDeps(base, overlay) {
   return {
     register: (name, source) => base().register(name, source),
@@ -138,6 +127,297 @@ function withViewDeps(base, overlay) {
     }
   };
 }
+
+// src/interactions/dispatcher/channels/contextMenu.ts
+function contextMenuInput(core) {
+  const { routeAt, toWorld, target, dispatch } = core;
+  const onContextMenu = (e) => {
+    e.preventDefault();
+    routeAt(null, e.clientX, e.clientY);
+    const w = toWorld(e.clientX, e.clientY);
+    const affordance = target().affordanceAt?.(w) ?? void 0;
+    const menuBody = target().classifyTarget?.(w);
+    const ev = {
+      kind: "contextmenu",
+      target: e.target,
+      altKey: e.altKey,
+      ctrlKey: e.ctrlKey,
+      metaKey: e.metaKey,
+      shiftKey: e.shiftKey,
+      x: w.x,
+      y: w.y,
+      clientX: e.clientX,
+      clientY: e.clientY,
+      ...affordance !== void 0 ? { affordance } : {},
+      ...menuBody?.body !== void 0 ? { bodyTarget: menuBody.body } : {},
+      ...menuBody?.kind !== void 0 ? { bodyKind: menuBody.kind } : {}
+    };
+    dispatch(ev);
+  };
+  return onContextMenu;
+}
+
+// src/interactions/dispatcher/channels/ingest.ts
+var DROPOVER_CLASS = "weasel-dropover";
+function ingestInput(core) {
+  const { canvas, routeAt, toWorld, dispatch } = core;
+  const onDragOver = (e) => {
+    if (!e.dataTransfer) return;
+    e.preventDefault();
+    e.dataTransfer.dropEffect = "copy";
+    canvas?.classList.add(DROPOVER_CLASS);
+  };
+  const onDragLeave = () => {
+    canvas?.classList.remove(DROPOVER_CLASS);
+  };
+  const onDrop = (e) => {
+    canvas?.classList.remove(DROPOVER_CLASS);
+    const dt = e.dataTransfer;
+    if (!dt) return;
+    e.preventDefault();
+    routeAt(null, e.clientX, e.clientY);
+    const dropView = core.routedView();
+    const w = toWorld(e.clientX, e.clientY);
+    const base = {
+      altKey: e.altKey,
+      ctrlKey: e.ctrlKey,
+      metaKey: e.metaKey,
+      shiftKey: e.shiftKey
+    };
+    void itemsFromDataTransfer(dt).then((items) => {
+      if (core.disposed()) return;
+      if (items.length === 0) return;
+      const routedNow = core.routedView();
+      core.setRoutedView(dropView);
+      try {
+        dispatch({
+          kind: "drop",
+          items,
+          x: w.x,
+          y: w.y,
+          clientX: e.clientX,
+          clientY: e.clientY,
+          ...base
+        });
+      } finally {
+        core.setRoutedView(routedNow);
+      }
+    });
+  };
+  const onPaste = (e) => {
+    if (e.defaultPrevented || isEditableTarget(e.target)) return;
+    if (!core.holdsKeys()) return;
+    const cd = e.clipboardData;
+    if (!cd) return;
+    const items = itemsFromClipboardData(cd);
+    if (items.length === 0) return;
+    const result = dispatch({
+      kind: "paste",
+      items,
+      // ClipboardEvent carries no modifier state.
+      altKey: false,
+      ctrlKey: false,
+      metaKey: false,
+      shiftKey: false
+    });
+    if (result === "handled") e.preventDefault();
+  };
+  return { onDragOver, onDragLeave, onDrop, onPaste };
+}
+
+// src/interactions/dispatcher/channels/keyboard.ts
+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) || activatesFocusedControl(e)) return;
+    if (!core.holdsKeys()) return;
+    if (e.repeat && heldKeys.has(physicalKey(e))) {
+      e.preventDefault();
+      return;
+    }
+    const keyEv = {
+      kind: "key",
+      key: e.key,
+      ...codeOf(e),
+      altKey: e.altKey,
+      ctrlKey: e.ctrlKey,
+      metaKey: e.metaKey,
+      shiftKey: e.shiftKey,
+      repeat: e.repeat
+    };
+    const keyResult = dispatch(keyEv);
+    const heldEv = {
+      kind: "key-held",
+      key: e.key,
+      ...codeOf(e),
+      phase: "down",
+      altKey: e.altKey,
+      ctrlKey: e.ctrlKey,
+      metaKey: e.metaKey,
+      shiftKey: e.shiftKey
+    };
+    const heldOn = dispatcherNow();
+    const heldResult = dispatch(heldEv, heldOn);
+    if (heldResult === "handled") {
+      heldKeys.set(physicalKey(e), { key: e.key, ...codeOf(e), on: heldOn });
+    }
+    if (keyResult === "handled" || heldResult === "handled") {
+      e.preventDefault();
+    }
+  };
+  const onKeyUp = (e) => {
+    const physical = physicalKey(e);
+    const down = heldKeys.get(physical);
+    if (down === void 0) return;
+    const ev = {
+      kind: "key-held",
+      key: down.key,
+      ...down.code !== void 0 ? { code: down.code } : {},
+      phase: "up",
+      altKey: e.altKey,
+      ctrlKey: e.ctrlKey,
+      metaKey: e.metaKey,
+      shiftKey: e.shiftKey
+    };
+    heldKeys.delete(physical);
+    dispatch(ev, down.on);
+  };
+  const releaseAll = () => {
+    const releasing = [...heldKeys.values()];
+    heldKeys.clear();
+    for (const { key, code, on } of releasing) {
+      const ev = {
+        kind: "key-held",
+        key,
+        ...code !== void 0 ? { code } : {},
+        phase: "up",
+        altKey: false,
+        ctrlKey: false,
+        metaKey: false,
+        shiftKey: false
+      };
+      dispatch(ev, on);
+    }
+  };
+  return { onKeyDown, onKeyUp, releaseAll };
+}
+
+// src/interactions/dispatcher/channels/webkitPinch.ts
+function webkitPinchInput(core) {
+  const { canvas, routeAt, toWorld, target, dispatch, dispatcherNow, ctxNow } = core;
+  let pinchLive = false;
+  let pinchScale = 1;
+  let pinchRotation = 0;
+  const endPinch = () => {
+    pinchLive = false;
+    pinchScale = 1;
+    pinchRotation = 0;
+  };
+  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();
+  };
+  return { onGestureStart, onGestureChange, onGestureEnd, live: () => pinchLive, end: endPinch };
+}
+
+// src/interactions/dispatcher/channels/wheel.ts
+function wheelInput(core, pinchLive) {
+  const { canvas, routeAt, toWorld, target, dispatch } = core;
+  const onWheel = (e) => {
+    core.activate();
+    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];
+    const hitPoint = toWorld(e.clientX, e.clientY);
+    const affordance = target().affordanceAt?.(hitPoint) ?? void 0;
+    const body = target().classifyTarget?.(hitPoint);
+    const ev = {
+      kind: "wheel",
+      altKey: e.altKey,
+      ctrlKey: e.ctrlKey,
+      metaKey: e.metaKey,
+      shiftKey: e.shiftKey,
+      deltaX: e.deltaX,
+      deltaY: e.deltaY,
+      clientX: localX,
+      clientY: localY,
+      ...affordance !== void 0 ? { affordance } : {},
+      ...body?.body !== void 0 ? { bodyTarget: body.body } : {},
+      ...body?.kind !== void 0 ? { bodyKind: body.kind } : {}
+    };
+    const result = dispatch(ev);
+    if (result === "handled") {
+      e.preventDefault();
+      e.stopImmediatePropagation();
+    }
+  };
+  return onWheel;
+}
+
+// src/interactions/dispatcher/useGestureDispatcher.tsx
+function stylusOf(e) {
+  return {
+    ...typeof e.pressure === "number" ? { pressure: e.pressure } : {},
+    ...typeof e.tiltX === "number" ? { tiltX: e.tiltX } : {},
+    ...typeof e.tiltY === "number" ? { tiltY: e.tiltY } : {}
+  };
+}
+var IS_MAC = isApplePlatform();
 function computeMultiTouchGeometry(positions) {
   const pts = [...positions];
   if (pts.length < 2) {
@@ -156,7 +436,7 @@ function computeMultiTouchGeometry(positions) {
   return { centroid, spread };
 }
 function useGestureDispatcher(opts) {
-  const { canvasRef, actions, entriesById, enabled = true, keyboard = true, affordanceAt, classifyTarget, dispatcher: dispatcherOpt, clientToWorld, requestRedraw, paintedCursor, getRuleCtx, onClick, onDoubleClick, views, channels, longPress } = opts;
+  const { canvasRef, actions, entriesById, enabled = true, keyboard = true, affordanceAt, classifyTarget, dispatcher: dispatcherOpt, clientToWorld, requestRedraw, paintedCursor, getRuleCtx, onClick, onDoubleClick, views, channels, longPress, claimKeys = false } = opts;
   const pointerChannel = channels?.pointer !== false;
   const wheelChannel = channels?.wheel !== false;
   const pinchChannel = channels?.pinch !== false;
@@ -199,13 +479,21 @@ function useGestureDispatcher(opts) {
   const liveToolsRef = useRef(/* @__PURE__ */ new Set());
   const prevActiveRef = useRef(activeTool.active);
   const entriesByIdRef = useLatest(entriesById);
+  const lifecycleScratchRef = useRef(/* @__PURE__ */ new Map());
   const fireLifecycle = useCallback((id, hook) => {
+    const scratches = lifecycleScratchRef.current;
     const tool = entriesByIdRef.current.get(id);
-    if (!tool || !isTool(tool)) return;
+    if (!tool || !isTool(tool)) {
+      scratches.delete(id);
+      return;
+    }
+    if (hook === "onActivate" || !scratches.has(id)) scratches.set(id, tool.initScratch?.());
+    const scratch = scratches.get(id);
+    if (hook === "onDeactivate") scratches.delete(id);
     const fn = tool[hook];
     if (!fn) return;
     try {
-      fn({ scratch: tool.initScratch?.() });
+      fn({ scratch });
     } catch (err) {
       console.error(`weasel: tool "${id}".${hook} threw`, err);
     }
@@ -228,6 +516,9 @@ function useGestureDispatcher(opts) {
     liveToolsRef.current = /* @__PURE__ */ new Set();
     for (const id of live) fireLifecycle(id, "onDeactivate");
   }, [fireLifecycle]);
+  useEffect(() => {
+    if (enabled && claimKeys) registryRef.current.activate();
+  }, [enabled, claimKeys, registryRef]);
   useEffect(() => {
     if (!enabled) return;
     let disposed = false;
@@ -267,8 +558,29 @@ function useGestureDispatcher(opts) {
       if (before > 0 || after > 0) requestRedrawRef.current?.();
       return result;
     };
-    const heldKeys = /* @__PURE__ */ new Map();
-    const physicalKey = (e) => e.code || e.key.toLowerCase();
+    const core = {
+      canvas,
+      target,
+      routeAt,
+      routedView: () => routedId,
+      setRoutedView: (id) => {
+        routedId = id;
+      },
+      dispatcherNow,
+      ctxNow,
+      toWorld,
+      dispatch,
+      holdsKeys: () => canvas ? registryRef.current.holdsKeys() : registryRef.current.isActive(),
+      activate: () => registryRef.current.activate(),
+      disposed: () => disposed
+    };
+    const keys = keyboardInput(core);
+    const { onKeyDown, onKeyUp } = keys;
+    const pinch = webkitPinchInput(core);
+    const { onGestureStart, onGestureChange, onGestureEnd } = pinch;
+    const onWheel = wheelInput(core, pinch.live);
+    const onContextMenu = contextMenuInput(core);
+    const { onDragOver, onDragLeave, onDrop, onPaste } = ingestInput(core);
     const held = /* @__PURE__ */ new Map();
     const toCanvasLocal = (p) => {
       const rect = canvas?.getBoundingClientRect();
@@ -282,14 +594,6 @@ 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 longPressTimers = /* @__PURE__ */ new Map();
@@ -335,168 +639,23 @@ function useGestureDispatcher(opts) {
       return d.resolveOnly(evs.longpress, ctxNow()) !== null || d.resolveOnly(evs.contextmenu, ctxNow()) !== null;
     };
     const fireLongPress = (pointerId, pointerType) => {
-      const down = held.get(pointerId)?.down;
+      const rec = held.get(pointerId);
       clearPending(pointerId);
-      if (!down) return;
-      const evs = longPressEvents(down);
+      if (!rec) return;
+      const evs = longPressEvents(rec.down);
       let result = dispatch(evs.longpress);
       if (result === "unhandled") result = dispatch(evs.contextmenu);
+      if (result === "handled") rec.buffered = null;
       if (result === "handled" && longPressRef.current?.haptics !== false && (pointerType === "touch" || pointerType === "pen") && typeof navigator !== "undefined" && typeof navigator.vibrate === "function") {
         navigator.vibrate(HAPTIC_MS);
       }
     };
     const DOUBLE_CLICK_MAX_MS = 600;
     const DOUBLE_CLICK_MAX_PX = 8;
-    const onKeyDown = (e) => {
-      if (e.defaultPrevented || isEditableTarget(e.target) || activatesFocusedControl(e)) return;
-      if (!registryRef.current.isActive()) return;
-      if (e.repeat && heldKeys.has(physicalKey(e))) {
-        e.preventDefault();
-        return;
-      }
-      const keyEv = {
-        kind: "key",
-        key: e.key,
-        altKey: e.altKey,
-        ctrlKey: e.ctrlKey,
-        metaKey: e.metaKey,
-        shiftKey: e.shiftKey,
-        repeat: e.repeat
-      };
-      const keyResult = dispatch(keyEv);
-      const heldEv = {
-        kind: "key-held",
-        key: e.key,
-        phase: "down",
-        altKey: e.altKey,
-        ctrlKey: e.ctrlKey,
-        metaKey: e.metaKey,
-        shiftKey: e.shiftKey
-      };
-      const heldResult = dispatch(heldEv);
-      if (heldResult === "handled") {
-        heldKeys.set(physicalKey(e), e.key);
-      }
-      if (keyResult === "handled" || heldResult === "handled") {
-        e.preventDefault();
-      }
-    };
-    const onKeyUp = (e) => {
-      const physical = physicalKey(e);
-      const downKey = heldKeys.get(physical);
-      if (downKey === void 0) return;
-      const ev = {
-        kind: "key-held",
-        key: downKey,
-        phase: "up",
-        altKey: e.altKey,
-        ctrlKey: e.ctrlKey,
-        metaKey: e.metaKey,
-        shiftKey: e.shiftKey
-      };
-      dispatch(ev);
-      heldKeys.delete(physical);
-    };
     const onWindowBlur = () => {
-      endPinch();
+      pinch.end();
       for (const p of [...held.values()]) p.session.cancel();
-      for (const key of heldKeys.values()) {
-        const ev = {
-          kind: "key-held",
-          key,
-          phase: "up",
-          altKey: false,
-          ctrlKey: false,
-          metaKey: false,
-          shiftKey: false
-        };
-        dispatch(ev);
-      }
-      heldKeys.clear();
-    };
-    const onWheel = (e) => {
-      registryRef.current.activate();
-      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];
-      const hitPoint = toWorld(e.clientX, e.clientY);
-      const affordance = target().affordanceAt?.(hitPoint) ?? void 0;
-      const body = target().classifyTarget?.(hitPoint);
-      const ev = {
-        kind: "wheel",
-        altKey: e.altKey,
-        ctrlKey: e.ctrlKey,
-        metaKey: e.metaKey,
-        shiftKey: e.shiftKey,
-        deltaX: e.deltaX,
-        deltaY: e.deltaY,
-        clientX: localX,
-        clientY: localY,
-        ...affordance !== void 0 ? { affordance } : {},
-        ...body?.body !== void 0 ? { bodyTarget: body.body } : {},
-        ...body?.kind !== void 0 ? { bodyKind: body.kind } : {}
-      };
-      const result = dispatch(ev);
-      if (result === "handled") {
-        e.preventDefault();
-        e.stopImmediatePropagation();
-      }
-    };
-    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();
+      keys.releaseAll();
     };
     let claimedDoubleClick = false;
     const onNativeDoubleClick = (e) => {
@@ -506,7 +665,6 @@ function useGestureDispatcher(opts) {
     };
     const onPointerDown = (e) => {
       claimedDoubleClick = false;
-      registryRef.current.activate();
       if ((e.button ?? 0) !== 0) return;
       if (!canvas) return;
       if (isInControlWithin(e.target, canvas)) return;
@@ -593,10 +751,19 @@ function useGestureDispatcher(opts) {
         for (const p of held.values()) p.buffered = null;
         const { centroid, spread } = heldGeometry();
         if (!multiTouchStart) {
-          multiTouchStart = { fingers: held.size, centroid: { ...centroid } };
+          multiTouchStart = {
+            fingers: held.size,
+            centroid: { ...centroid },
+            at: /* @__PURE__ */ new Map(),
+            moved: false,
+            startedAt: performance.now()
+          };
         } else {
           multiTouchStart.fingers = held.size;
         }
+        for (const [id, p] of held) {
+          if (!multiTouchStart.at.has(id)) multiTouchStart.at.set(id, { ...p.pos });
+        }
         const mt = {
           kind: "multitouch",
           fingers: held.size,
@@ -610,10 +777,25 @@ function useGestureDispatcher(opts) {
         dispatch(mt);
       }
     };
+    const endMultiTouch = (end, fingers, mods) => {
+      dispatch({
+        kind: "multitouch",
+        fingers,
+        end,
+        altKey: mods.altKey,
+        ctrlKey: mods.ctrlKey,
+        metaKey: mods.metaKey,
+        shiftKey: mods.shiftKey
+      });
+    };
     const onPointerMove = (e) => {
       routeAt(e.pointerId, e.clientX, e.clientY);
       const rec = held.get(e.pointerId);
       if (rec) rec.pos = { x: e.clientX, y: e.clientY };
+      const joinedAt = multiTouchStart?.at.get(e.pointerId);
+      if (multiTouchStart && joinedAt && Math.hypot(e.clientX - joinedAt.x, e.clientY - joinedAt.y) > TAP_THRESHOLD_PX) {
+        multiTouchStart.moved = true;
+      }
       const buffered = rec?.buffered;
       if (rec && buffered) {
         if (pastDragThreshold(buffered, e)) {
@@ -677,13 +859,12 @@ function useGestureDispatcher(opts) {
         clearHoverCursor();
         return;
       }
-      const painted = tier.kind === "painted" ? tier : null;
-      paintedCursorRef.current?.()?.setOverride(painted);
       const cursor = tier.kind === "css" ? tier.css : "none";
       if (!cursor) {
         clearHoverCursor();
         return;
       }
+      paintedCursorRef.current?.()?.setOverride(tier.kind === "painted" ? tier : "none");
       canvas.style.cursor = cursor;
       cursorOverridden = true;
     };
@@ -771,11 +952,8 @@ function useGestureDispatcher(opts) {
       const rec = held.get(e.pointerId);
       held.delete(e.pointerId);
       const staysUnderThreshold = rec?.buffered != null;
+      if (prevSize >= 2) endMultiTouch("commit", prevSize, e);
       if (prevSize >= 2 && held.size < 2) {
-        const mtGestureId = `multitouch-${prevSize}`;
-        if (dispatcherNow().inFlight().has(mtGestureId)) {
-          dispatcherNow().cancelAll("commit");
-        }
         const start = multiTouchStart;
         if (start) {
           const centroid = toCanvasLocal(
@@ -786,7 +964,8 @@ function useGestureDispatcher(opts) {
           );
           const dx = centroid.x - start.centroid.x;
           const dy = centroid.y - start.centroid.y;
-          if (Math.hypot(dx, dy) <= TAP_THRESHOLD_PX) {
+          const brief = performance.now() - start.startedAt < (longPressRef.current?.duration ?? LONG_PRESS_MS);
+          if (brief && !start.moved && Math.hypot(dx, dy) <= TAP_THRESHOLD_PX) {
             const tap = {
               kind: "multitouchtap",
               fingers: start.fingers,
@@ -883,9 +1062,11 @@ function useGestureDispatcher(opts) {
       if (disposed) return;
       const rec = held.get(pointerId);
       if (!rec) return;
+      const prevSize = held.size;
       held.delete(pointerId);
       routeAt(pointerId, rec.pos.x, rec.pos.y);
       cancelLongPress(pointerId);
+      if (prevSize >= 2) endMultiTouch("cancel", prevSize, rec.down);
       multiTouchStart = null;
       const ev = {
         kind: "pointercancel",
@@ -898,82 +1079,8 @@ function useGestureDispatcher(opts) {
       dispatch(ev);
       routeRelease(pointerId);
     };
-    const onContextMenu = (e) => {
-      e.preventDefault();
-      routeAt(null, e.clientX, e.clientY);
-      const w = toWorld(e.clientX, e.clientY);
-      const affordance = target().affordanceAt?.(w) ?? void 0;
-      const menuBody = target().classifyTarget?.(w);
-      const ev = {
-        kind: "contextmenu",
-        target: e.target,
-        altKey: e.altKey,
-        ctrlKey: e.ctrlKey,
-        metaKey: e.metaKey,
-        shiftKey: e.shiftKey,
-        x: w.x,
-        y: w.y,
-        clientX: e.clientX,
-        clientY: e.clientY,
-        ...affordance !== void 0 ? { affordance } : {},
-        ...menuBody?.body !== void 0 ? { bodyTarget: menuBody.body } : {},
-        ...menuBody?.kind !== void 0 ? { bodyKind: menuBody.kind } : {}
-      };
-      dispatch(ev);
-    };
-    const onDragOver = (e) => {
-      if (!e.dataTransfer) return;
-      e.preventDefault();
-      e.dataTransfer.dropEffect = "copy";
-      canvas?.classList.add(DROPOVER_CLASS);
-    };
-    const onDragLeave = () => {
-      canvas?.classList.remove(DROPOVER_CLASS);
-    };
-    const onDrop = (e) => {
-      canvas?.classList.remove(DROPOVER_CLASS);
-      const dt = e.dataTransfer;
-      if (!dt) return;
-      e.preventDefault();
-      routeAt(null, e.clientX, e.clientY);
-      const dropOn = target().dispatcher;
-      const w = toWorld(e.clientX, e.clientY);
-      const base = {
-        altKey: e.altKey,
-        ctrlKey: e.ctrlKey,
-        metaKey: e.metaKey,
-        shiftKey: e.shiftKey
-      };
-      void itemsFromDataTransfer(dt).then((items) => {
-        if (disposed) return;
-        if (items.length === 0) return;
-        dispatch({
-          kind: "drop",
-          items,
-          x: w.x,
-          y: w.y,
-          clientX: e.clientX,
-          clientY: e.clientY,
-          ...base
-        }, dropOn);
-      });
-    };
-    const onPaste = (e) => {
-      if (isEditableTarget(e.target)) return;
-      const cd = e.clipboardData;
-      if (!cd) return;
-      const items = itemsFromClipboardData(cd);
-      if (items.length === 0) return;
-      const result = dispatch({
-        kind: "paste",
-        items,
-        // ClipboardEvent carries no modifier state.
-        altKey: false,
-        ctrlKey: false,
-        metaKey: false,
-        shiftKey: false
-      });
-      if (result === "handled") e.preventDefault();
+    const onPressActivate = () => {
+      registryRef.current.activate();
     };
     const keyCapture = keyboard === "first";
     if (keyboard) {
@@ -981,6 +1088,7 @@ function useGestureDispatcher(opts) {
       window.addEventListener("keyup", onKeyUp, keyCapture);
     }
     window.addEventListener("blur", onWindowBlur);
+    canvas?.addEventListener("pointerdown", onPressActivate);
     window.addEventListener("keydown", scheduleHoverCursorRefresh);
     window.addEventListener("keyup", scheduleHoverCursorRefresh);
     if (pointerChannel) {
@@ -1009,6 +1117,7 @@ function useGestureDispatcher(opts) {
         window.removeEventListener("keyup", onKeyUp, keyCapture);
       }
       window.removeEventListener("blur", onWindowBlur);
+      canvas?.removeEventListener("pointerdown", onPressActivate);
       window.removeEventListener("keydown", scheduleHoverCursorRefresh);
       window.removeEventListener("keyup", scheduleHoverCursorRefresh);
       canvas?.removeEventListener("pointerleave", onHoverPointerLeave);
@@ -1026,6 +1135,7 @@ function useGestureDispatcher(opts) {
       canvas?.removeEventListener("drop", onDrop);
       window.removeEventListener("paste", onPaste);
       canvas?.classList.remove(DROPOVER_CLASS);
+      registryRef.current.dropKeys();
       clearHoverCursor();
       cancelAllLongPress();
       disposed = true;
@@ -1118,6 +1228,7 @@ var ActionsNode = class extends ScopeNode {
     return null;
   }
   activate() {
+    keyHolder = this;
     super.activate();
     for (const f of this.onActivate) f();
   }
@@ -1138,7 +1249,11 @@ var ActionsNode = class extends ScopeNode {
         const i = cur.lastIndexOf(action);
         if (i === -1) return;
         cur.splice(i, 1);
-        if (cur.length === 0) this.actions.delete(action.id);
+        if (cur.length === 0) {
+          queueMicrotask(() => {
+            if (cur.length === 0 && this.actions.get(action.id) === cur) this.actions.delete(action.id);
+          });
+        }
         this.changed();
       };
     },
@@ -1163,11 +1278,9 @@ var ActionsNode = class extends ScopeNode {
     trigger: (id, params) => {
       const leaf = this.start();
       const a = leaf.resolve(id);
-      if (!a) return false;
+      if (!a?.invoker || a.invoker.timing !== "immediate") return false;
       try {
-        if (a.invoker && a.invoker.timing === "immediate") {
-          a.invoker.run(depsFor(a, leaf.deps()), params);
-        }
+        a.invoker.run(depsFor(a, leaf.deps()), params);
       } catch (err) {
         console.error(`weasel ActionsRegistry: action "${id}" threw`, err);
       }
@@ -1188,9 +1301,14 @@ var ActionsNode = class extends ScopeNode {
       return disp.beginUiOngoing(id, depsFor(a, leaf.deps()), params);
     },
     activate: () => this.activate(),
-    isActive: () => this.isActive()
+    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;
@@ -1271,16 +1389,14 @@ function useOngoingAction(actionId) {
       ctrlRef.current = null;
       ctrl?.end(reason);
     };
+    const drive = (params) => {
+      if (ctrlRef.current?.active) ctrlRef.current.update(params);
+      else ctrlRef.current = regRef.current?.begin(idRef.current, params) ?? null;
+    };
     return {
-      input(params) {
-        if (ctrlRef.current) ctrlRef.current.update(params);
-        else ctrlRef.current = regRef.current?.begin(idRef.current, params) ?? null;
-      },
+      input: drive,
       commit(params) {
-        if (params !== void 0) {
-          if (ctrlRef.current) ctrlRef.current.update(params);
-          else ctrlRef.current = regRef.current?.begin(idRef.current, params) ?? null;
-        }
+        if (params !== void 0) drive(params);
         end("commit");
       },
       cancel() {
@@ -1291,6 +1407,8 @@ function useOngoingAction(actionId) {
   useEffect(() => () => edit.commit(), [edit, actionId]);
   return edit;
 }
+var NO_MODES = () => () => {
+};
 function useContributions(opts) {
   const ctx = useActiveToolContext();
   const actionsRegistry = useActionsRegistry();
@@ -1309,25 +1427,18 @@ function useContributions(opts) {
   const setFocused = useCallback((id) => {
     ctx.setActive(id);
   }, [ctx]);
-  const snapshot = useCallback(() => {
-    const engagedIds = new Set(engaged);
-    const ordered = [];
-    for (const id of engaged) {
-      const entry = entries.find((e) => e.id === id);
-      if (entry && !ordered.includes(entry)) ordered.push(entry);
-    }
-    for (const entry of entries) {
-      if (!ordered.includes(entry)) ordered.push(entry);
-    }
-    return {
-      ordered,
-      state: { focusedId: focused, engagedIds }
-    };
-  }, [entries, focused, engaged]);
-  const scopedBindings = useCallback(() => {
-    const { ordered, state } = snapshot();
-    return scopeBindings(ordered, state);
-  }, [snapshot]);
+  const modes = opts.modes;
+  const modeVersion = useSyncExternalStore(
+    modes ? modes.subscribe : NO_MODES,
+    () => modes?.getVersion() ?? 0
+  );
+  const snapshot = useCallback(() => assembleEntries(entries, {
+    focusedId: focused,
+    hotkeyStack: engaged,
+    ...modes ? { allowedCapabilities: activeModeOf(modes.current()).allowedCapabilities } : {}
+    // The version is what changes; `modes` is one object for the registry's life.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }), [entries, focused, engaged, modes, modeVersion]);
   const overlays = useCallback((position = "top") => {
     const { ordered, state } = snapshot();
     const active = [];
@@ -1367,8 +1478,8 @@ function useContributions(opts) {
     });
   }, [entrySig, entries, actionsRegistry, modesRegistry]);
   return useMemo(
-    () => ({ entries, focused, setFocused, scopedBindings, overlays }),
-    [entries, focused, setFocused, scopedBindings, overlays]
+    () => ({ entries, focused, setFocused, overlays }),
+    [entries, focused, setFocused, overlays]
   );
 }
 function useOffhandAction(entries) {