@weasel-js/routing 1.9.4 → 1.10.1

package/dist/react.js

@@ -1,9 +1,10 @@
-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 { 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 { isApplePlatform, heldPointers, createPointerRecognizer, isInControlWithin, longPressEvents, stylusOf } from '@weasel-js/gestures';
 import { useLatest, useStableByContent, sameList } from '@weasel-js/react';
 import { jsx, Fragment } from 'react/jsx-runtime';
-import { isApplePlatform, isInControlWithin, pastDragThreshold } from '@weasel-js/gestures';
-import { resolveCursorTier } from '@weasel-js/cursor';
+import { createCursorSink, resolveCursorTier } from '@weasel-js/cursor';
+import { createEmitter } from '@weasel-js/registry';
 import { activeModeOf } from '@weasel-js/modes';
 
 var ToolNode = class extends ScopeNode {
@@ -48,12 +49,7 @@ var ToolNode = class extends ScopeNode {
     this.value = { from, state, out };
     return out;
   }
-  subscribe = (listener) => {
-    this.tree.listeners.add(listener);
-    return () => {
-      this.tree.listeners.delete(listener);
-    };
-  };
+  subscribe = (listener) => this.tree.listeners.subscribe(listener);
 };
 var ActiveToolContext = createContext(null);
 var ActiveToolNodeContext = ActiveToolContext;
@@ -115,8 +111,93 @@ function useDepSource(name, source) {
     return registry.register(name, () => sourceRef.current());
   }, [name, registry, sourceRef]);
 }
+function useToolLifecycle(opts) {
+  const { active, hotkeyStack } = opts;
+  const liveRef = useRef(/* @__PURE__ */ new Set());
+  const prevActiveRef = useRef(active);
+  const entriesRef = useLatest(opts.entriesById);
+  const onSwitchRef = useLatest(opts.onSwitch);
+  const fire = useCallback((id, hook) => {
+    const tool = entriesRef.current.get(id);
+    if (!tool || !isTool(tool)) return;
+    const fn = tool[hook];
+    if (!fn) return;
+    try {
+      fn();
+    } catch (err) {
+      console.error(`weasel: tool "${id}".${hook} threw`, err);
+    }
+  }, [entriesRef]);
+  useEffect(() => {
+    const prev = liveRef.current;
+    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 !== null && prevActiveRef.current !== active) onSwitchRef.current?.();
+    prevActiveRef.current = active;
+    for (const id of next) if (!prev.has(id)) fire(id, "onActivate");
+  });
+  useEffect(() => () => {
+    const live = liveRef.current;
+    liveRef.current = /* @__PURE__ */ new Set();
+    for (const id of live) fire(id, "onDeactivate");
+  }, [fire]);
+}
 
 // src/interactions/dispatcher/dispatchCore.ts
+function createDispatchCore(src) {
+  const { canvas } = src;
+  let routedId = null;
+  const target = () => {
+    if (routedId === null) return src.root();
+    return src.views()?.targets().find((t) => t.id === routedId) ?? src.root();
+  };
+  const dispatcherNow = () => target().dispatcher;
+  const routedDeps = withViewDeps(() => src.context().depRegistry, () => target().deps?.());
+  const routedRuleCtx = () => target().getRuleCtx?.();
+  const ctxNow = () => ({
+    ...src.context(),
+    depRegistry: routedDeps,
+    getRuleCtx: routedRuleCtx,
+    viewId: target().id
+  });
+  return {
+    canvas,
+    target,
+    routeAt: (pointerId, clientX, clientY) => {
+      routedId = src.views()?.resolver.at(pointerId, clientX, clientY).id ?? null;
+    },
+    routeDown: (pointerId, clientX, clientY) => {
+      routedId = src.views()?.resolver.begin(pointerId, clientX, clientY).id ?? null;
+    },
+    routeRelease: (pointerId) => {
+      src.views()?.resolver.end(pointerId);
+    },
+    routedView: () => routedId,
+    setRoutedView: (id) => {
+      routedId = id;
+    },
+    dispatcherNow,
+    ctxNow,
+    toWorld: (cx, cy) => {
+      const fn = target().clientToWorld;
+      return fn ? fn(cx, cy) : { x: cx, y: cy };
+    },
+    toCanvasLocal: (cx, cy) => {
+      if (!canvas) return { x: cx, y: cy };
+      const [x, y] = clientToCanvas(canvas, cx, cy);
+      return { x, y };
+    },
+    dispatch: (ev, on) => {
+      const d = on ?? dispatcherNow();
+      src.uses(d);
+      return d.handleInput(ev, ctxNow());
+    },
+    holdsKeys: () => canvas ? src.actions().holdsKeys() : src.actions().isActive(),
+    activate: () => src.actions().activate(),
+    disposed: src.disposed
+  };
+}
 function withViewDeps(base, overlay) {
   return {
     register: (name, source) => base().register(name, source),
@@ -128,44 +209,183 @@ function withViewDeps(base, overlay) {
   };
 }
 
+// src/interactions/dispatcher/dispatcherWatch.ts
+function dispatcherWatch(onChange) {
+  const subscriptions = /* @__PURE__ */ new Map();
+  return {
+    sync(live) {
+      for (const d of live) {
+        if (!subscriptions.has(d)) subscriptions.set(d, d.subscribe(onChange));
+      }
+      if (subscriptions.size === live.length) return;
+      const keep = new Set(live);
+      for (const [d, unsubscribe] of subscriptions) {
+        if (keep.has(d)) continue;
+        unsubscribe();
+        subscriptions.delete(d);
+      }
+    },
+    stop() {
+      for (const unsubscribe of subscriptions.values()) unsubscribe();
+      subscriptions.clear();
+    }
+  };
+}
+
+// src/interactions/dispatcher/underPointer.ts
+function underPointer(view, mods, w) {
+  const affordance = view.affordanceAt?.(w) ?? void 0;
+  const body = view.classifyTarget?.(w);
+  return {
+    altKey: mods.altKey,
+    ctrlKey: mods.ctrlKey,
+    metaKey: mods.metaKey,
+    shiftKey: mods.shiftKey,
+    ...affordance !== void 0 ? { affordance } : {},
+    ...body?.body !== void 0 ? { bodyTarget: body.body } : {},
+    ...body?.kind !== void 0 ? { bodyKind: body.kind } : {}
+  };
+}
+
 // src/interactions/dispatcher/channels/contextMenu.ts
-function contextMenuInput(core) {
+function contextMenuInput(core, takeNativeHold) {
   const { routeAt, toWorld, target, dispatch } = core;
   const onContextMenu = (e) => {
     e.preventDefault();
+    if (takeNativeHold()) return;
     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 } : {}
+      ...underPointer(target(), e, w)
     };
     dispatch(ev);
   };
   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,
+  altKey: e.altKey,
+  ctrlKey: e.ctrlKey,
+  metaKey: e.metaKey,
+  shiftKey: e.shiftKey
+});
+function hoverCursorInput(core, paintedCursor, pointersHeld, cursorSink = () => void 0) {
+  const { canvas, routeAt, toWorld, target, dispatch, dispatcherNow, ctxNow } = core;
+  const ownSink = createCursorSink({ element: () => canvas, painted: paintedCursor });
+  const override = {
+    apply: (spec) => (cursorSink() ?? ownSink).setOverride(spec === null ? null : resolveCursorTier(spec)),
+    clear: () => (cursorSink() ?? ownSink).setOverride(null)
+  };
+  let last = null;
+  let facts = null;
+  const resolve = () => {
+    if (!canvas || !last) return;
+    if (pointersHeld() > 0 || dispatcherNow().inFlight().size > 0) {
+      override.apply(dispatcherNow().inFlightCursor());
+      return;
+    }
+    const h = last;
+    routeAt(null, h.clientX, h.clientY);
+    const w = toWorld(h.clientX, h.clientY);
+    const where = facts?.at === h ? facts.where : underPointer(target(), h, w);
+    if (where.affordance?.cursor) {
+      override.apply(where.affordance.cursor);
+      return;
+    }
+    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));
+    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;
+    override.apply(cursor ?? null);
+  };
+  const refresh = () => {
+    resolve();
+    const painted = paintedCursor();
+    if (!painted?.active() || !canvas || !last) return;
+    const local = core.toCanvasLocal(last.clientX, last.clientY);
+    painted.setPointer(local.x, local.y);
+  };
+  const refreshSoon = () => {
+    setTimeout(() => {
+      if (!core.disposed()) refresh();
+    }, 0);
+  };
+  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 });
+      }
+      refresh();
+    },
+    released(e) {
+      last = hoverOf(e);
+      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();
+      override.clear();
+    },
+    onKey(e) {
+      if (!last) return;
+      last = { ...last, altKey: e.altKey, ctrlKey: e.ctrlKey, metaKey: e.metaKey, shiftKey: e.shiftKey };
+      refreshSoon();
+    },
+    clear: override.clear
+  };
+}
 
 // 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;
+    const dt = e.dataTransfer;
+    if (!dt) return;
+    routeAt(null, e.clientX, e.clientY);
+    const w = toWorld(e.clientX, e.clientY);
+    const wanted = core.dispatcherNow().resolveOnly({
+      kind: "drop",
+      items: itemTypesFromDataTransfer(dt),
+      x: w.x,
+      y: w.y,
+      clientX: e.clientX,
+      clientY: e.clientY,
+      altKey: e.altKey,
+      ctrlKey: e.ctrlKey,
+      metaKey: e.metaKey,
+      shiftKey: e.shiftKey
+    }, core.ctxNow()) !== null;
+    canvas?.classList.toggle(DROPOVER_CLASS, wanted);
+    if (!wanted) return;
     e.preventDefault();
-    e.dataTransfer.dropEffect = "copy";
-    canvas?.classList.add(DROPOVER_CLASS);
+    dt.dropEffect = "copy";
   };
   const onDragLeave = () => {
     canvas?.classList.remove(DROPOVER_CLASS);
@@ -226,24 +446,32 @@ function ingestInput(core) {
 }
 
 // src/interactions/dispatcher/channels/keyboard.ts
+function typedWithAltGraph(e) {
+  if (!e.ctrlKey || !e.altKey || e.key.length !== 1 || !e.getModifierState?.("AltGraph")) return false;
+  const base = /^(?:Key|Digit)(.)$/.exec(e.code)?.[1];
+  return base === void 0 || base.toLowerCase() !== e.key.toLowerCase();
+}
 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 (e.defaultPrevented || isEditableTarget(e.target) || focusedControlOwnsKey(e)) return;
     if (!core.holdsKeys()) 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 });
+  };
+  const press = (e, mods) => {
     const keyEv = {
       kind: "key",
       key: e.key,
       ...codeOf(e),
-      altKey: e.altKey,
-      ctrlKey: e.ctrlKey,
+      ...mods,
       metaKey: e.metaKey,
       shiftKey: e.shiftKey,
       repeat: e.repeat
@@ -254,8 +482,7 @@ function keyboardInput(core) {
       key: e.key,
       ...codeOf(e),
       phase: "down",
-      altKey: e.altKey,
-      ctrlKey: e.ctrlKey,
+      ...mods,
       metaKey: e.metaKey,
       shiftKey: e.shiftKey
     };
@@ -264,9 +491,9 @@ function keyboardInput(core) {
     if (heldResult === "handled") {
       heldKeys.set(physicalKey(e), { key: e.key, ...codeOf(e), on: heldOn });
     }
-    if (keyResult === "handled" || heldResult === "handled") {
-      e.preventDefault();
-    }
+    const handled = keyResult === "handled" || heldResult === "handled";
+    if (handled) e.preventDefault();
+    return handled;
   };
   const onKeyUp = (e) => {
     const physical = physicalKey(e);
@@ -305,6 +532,175 @@ function keyboardInput(core) {
   return { onKeyDown, onKeyUp, releaseAll };
 }
 
+// src/interactions/dispatcher/channels/listeners.ts
+function listenerSet() {
+  const removers = [];
+  return {
+    on(target, type, listener, options) {
+      if (!target) return;
+      target.addEventListener(type, listener, options);
+      removers.push(() => {
+        target.removeEventListener(type, listener, options);
+      });
+    },
+    removeAll() {
+      for (const remove of removers.splice(0)) remove();
+    }
+  };
+}
+var sampleOf = (e) => ({
+  pointerId: e.pointerId,
+  clientX: e.clientX,
+  clientY: e.clientY,
+  target: e.target,
+  altKey: e.altKey,
+  ctrlKey: e.ctrlKey,
+  metaKey: e.metaKey,
+  shiftKey: e.shiftKey,
+  ...stylusOf(e)
+});
+function holdPublisher(core, longPress) {
+  return (pending) => {
+    const store = longPress()?.state;
+    if (!store) return;
+    if (!pending) {
+      store.set(null);
+      return;
+    }
+    const { press } = pending;
+    const evs = longPressEvents(press);
+    const d = core.dispatcherNow();
+    store.set({
+      pointerId: pending.pointerId,
+      pointerType: pending.pointerType,
+      client: { x: press.clientX, y: press.clientY },
+      local: core.toCanvasLocal(press.clientX, press.clientY),
+      world: { x: press.worldX, y: press.worldY },
+      viewId: core.target().id,
+      startedAt: pending.startedAt,
+      duration: pending.duration,
+      armed: d.resolveOnly(evs.longpress, core.ctxNow()) !== null || d.resolveOnly(evs.contextmenu, core.ctxNow()) !== null
+    });
+  };
+}
+function holdClock(core) {
+  let holdView = null;
+  return {
+    clock: {
+      now: () => performance.now(),
+      setTimer: (fn, ms) => {
+        const view = core.routedView();
+        holdView = { id: view };
+        return setTimeout(() => {
+          holdView = null;
+          core.setRoutedView(view);
+          fn();
+        }, ms);
+      },
+      clearTimer: (timer) => {
+        holdView = null;
+        clearTimeout(timer);
+      }
+    },
+    routeToPress: () => {
+      if (holdView) core.setRoutedView(holdView.id);
+    }
+  };
+}
+function pointerInput(core, opts) {
+  const { canvas, routeAt, routeDown, routeRelease, toWorld, target } = core;
+  const sessions = /* @__PURE__ */ new Map();
+  let claimedDoubleClick = false;
+  const hold = holdClock(core);
+  const recognizer = createPointerRecognizer({
+    sink: {
+      dispatch: (ev) => core.dispatch(ev),
+      multiTouchInFlight: (fingers) => core.dispatcherNow().inFlight().has(multiTouchGestureId(fingers))
+    },
+    clock: hold.clock,
+    toWorld,
+    toSurface: (p) => core.toCanvasLocal(p.x, p.y),
+    longPressMs: () => opts.longPress()?.duration,
+    clicks: opts.clicks,
+    observer: {
+      click: (world) => {
+        opts.onClick()?.(world);
+      },
+      doubleClick: (world) => {
+        opts.onDoubleClick()?.(world);
+      },
+      holdChanged: holdPublisher(core, opts.longPress),
+      longPress: () => {
+        if (opts.longPress()?.haptics === false) return;
+        if (typeof navigator !== "undefined" && typeof navigator.vibrate === "function") {
+          navigator.vibrate(LONG_PRESS_HAPTIC_MS);
+        }
+      }
+    }
+  });
+  const onMove = (e) => {
+    routeAt(e.pointerId, e.clientX, e.clientY);
+    recognizer.move(sampleOf(e));
+    opts.hover.moved(e);
+  };
+  const onUp = (e) => {
+    routeAt(e.pointerId, e.clientX, e.clientY);
+    sessions.delete(e.pointerId);
+    const { doubleClick } = recognizer.release(sampleOf(e));
+    if (doubleClick) claimedDoubleClick = doubleClick === "handled" || opts.onDoubleClick() !== void 0;
+    routeRelease(e.pointerId);
+    opts.hover.released(e);
+  };
+  const onCancel = (pointerId) => {
+    if (core.disposed()) return;
+    const at = recognizer.positionOf(pointerId);
+    if (!at) return;
+    sessions.delete(pointerId);
+    routeAt(pointerId, at.x, at.y);
+    recognizer.cancel(pointerId);
+    routeRelease(pointerId);
+  };
+  return {
+    onPointerDown(e) {
+      claimedDoubleClick = false;
+      if ((e.button ?? 0) !== 0) return;
+      if (!canvas) return;
+      if (isInControlWithin(e.target, canvas)) return;
+      routeDown(e.pointerId, e.clientX, e.clientY);
+      const w = toWorld(e.clientX, e.clientY);
+      const where = underPointer(target(), e, w);
+      sessions.set(e.pointerId, openPointerSession(canvas, e, {
+        onMove,
+        onEnd: onUp,
+        onCancel: () => {
+          onCancel(e.pointerId);
+        }
+      }));
+      recognizer.press({ ...sampleOf(e), x: w.x, y: w.y, pointerType: e.pointerType, ...where });
+    },
+    onHoverMove(e) {
+      if (!sessions.has(e.pointerId)) onMove(e);
+    },
+    onNativeDoubleClick(e) {
+      if (!claimedDoubleClick) return;
+      claimedDoubleClick = false;
+      e.preventDefault();
+    },
+    takeNativeHold: () => {
+      hold.routeToPress();
+      return recognizer.takeHold();
+    },
+    cancelHeld() {
+      for (const session of [...sessions.values()]) session.cancel();
+    },
+    dispose() {
+      recognizer.reset();
+      for (const session of sessions.values()) session.cancel();
+      sessions.clear();
+    }
+  };
+}
+
 // src/interactions/dispatcher/channels/webkitPinch.ts
 function webkitPinchInput(core) {
   const { canvas, routeAt, toWorld, target, dispatch, dispatcherNow, ctxNow } = core;
@@ -318,27 +714,25 @@ function webkitPinchInput(core) {
   };
   const pinchEventOf = (e, scale, rotation) => {
     const g = e;
-    const rect = canvas?.getBoundingClientRect();
+    const rect = typeof g.clientX === "number" && typeof g.clientY === "number" ? void 0 : 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 local = core.toCanvasLocal(cx, cy);
     const hitPoint = toWorld(cx, cy);
-    const affordance = target().affordanceAt?.(hitPoint) ?? void 0;
-    const body = target().classifyTarget?.(hitPoint);
-    return {
-      kind: "pinch",
+    const mods = {
       altKey: g.altKey === true,
       ctrlKey: g.ctrlKey === true,
       metaKey: g.metaKey === true,
-      shiftKey: g.shiftKey === true,
+      shiftKey: g.shiftKey === true
+    };
+    return {
+      kind: "pinch",
       scale,
       rotation,
-      clientX: localX,
-      clientY: localY,
-      ...affordance !== void 0 ? { affordance } : {},
-      ...body?.body !== void 0 ? { bodyTarget: body.body } : {},
-      ...body?.kind !== void 0 ? { bodyKind: body.kind } : {}
+      clientX: local.x,
+      clientY: local.y,
+      ...underPointer(target(), mods, hitPoint)
     };
   };
   const onGestureStart = (e) => {
@@ -372,7 +766,7 @@ function webkitPinchInput(core) {
 
 // src/interactions/dispatcher/channels/wheel.ts
 function wheelInput(core, pinchLive) {
-  const { canvas, routeAt, toWorld, target, dispatch } = core;
+  const { routeAt, toWorld, target, dispatch } = core;
   const onWheel = (e) => {
     core.activate();
     if (pinchLive() && e.ctrlKey) {
@@ -381,24 +775,15 @@ function wheelInput(core, pinchLive) {
       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 local = core.toCanvasLocal(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 } : {}
+      clientX: local.x,
+      clientY: local.y,
+      ...underPointer(target(), e, hitPoint)
     };
     const result = dispatch(ev);
     if (result === "handled") {
@@ -409,34 +794,91 @@ function wheelInput(core, pinchLive) {
   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 } : {}
+// 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,
+    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,
+    onClick: src.onClick,
+    onDoubleClick: src.onDoubleClick,
+    clicks: src.clicks,
+    hover
+  });
+  const onWindowBlur = () => {
+    pinch.end();
+    pointer.cancelHeld();
+    keys.releaseAll();
   };
-}
-var IS_MAC = isApplePlatform();
-function computeMultiTouchGeometry(positions) {
-  const pts = [...positions];
-  if (pts.length < 2) {
-    return { centroid: { x: 0, y: 0 }, spread: 0 };
+  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);
   }
-  let sumX = 0;
-  let sumY = 0;
-  for (const p of pts) {
-    sumX += p.x;
-    sumY += p.y;
+  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 centroid = { x: sumX / pts.length, y: sumY / pts.length };
-  const dx = pts[1].x - pts[0].x;
-  const dy = pts[1].y - pts[0].y;
-  const spread = Math.sqrt(dx * dx + dy * dy);
-  return { centroid, spread };
+  return () => {
+    listeners.removeAll();
+    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, getRuleCtx, onClick, onDoubleClick, views, channels, longPress, claimKeys = false } = 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 pointerChannel = channels?.pointer !== false;
   const wheelChannel = channels?.wheel !== false;
   const pinchChannel = channels?.pinch !== false;
@@ -446,6 +888,7 @@ function useGestureDispatcher(opts) {
   const onDoubleClickRef = useLatest(onDoubleClick);
   const activeTool = useActiveToolContext();
   const depRegistry = useDepRegistry();
+  const [isMac] = useState(isApplePlatform);
   const dispatcherRef = useRef(null);
   if (!dispatcherRef.current) {
     dispatcherRef.current = dispatcherOpt ?? createDispatcher();
@@ -457,7 +900,7 @@ function useGestureDispatcher(opts) {
     activeToolId: activeTool.active,
     hotkeyStack: activeTool.hotkeyStack,
     entriesById,
-    isMac: IS_MAC
+    isMac
   });
   const rootTargetRef = useLatest({
     id: null,
@@ -473,676 +916,46 @@ function useGestureDispatcher(opts) {
     ...(viewsRef.current?.targets() ?? []).map((t) => t.dispatcher)
   ], [rootTargetRef, viewsRef]);
   const requestRedrawRef = useLatest(requestRedraw);
-  const paintedCursorRef = useLatest(paintedCursor);
+  const cursorRef = useLatest({ painted: paintedCursor, sink: cursorSink });
   const longPressRef = useLatest(longPress);
-  const lastClickRef = useRef(null);
-  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)) {
-      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 });
-    } catch (err) {
-      console.error(`weasel: tool "${id}".${hook} threw`, err);
-    }
-  }, [entriesByIdRef]);
-  useEffect(() => {
-    const prev = liveToolsRef.current;
-    const next = new Set(
-      activeTool.active === null ? activeTool.hotkeyStack : [activeTool.active, ...activeTool.hotkeyStack]
-    );
-    liveToolsRef.current = next;
-    for (const id of prev) if (!next.has(id)) fireLifecycle(id, "onDeactivate");
-    if (prevActiveRef.current !== activeTool.active) {
+  const clicksRef = useRef({ last: null });
+  useToolLifecycle({
+    entriesById,
+    active: activeTool.active,
+    hotkeyStack: activeTool.hotkeyStack,
+    // The incoming tool must not inherit a live gesture.
+    onSwitch: () => {
       for (const d of allDispatchers()) d.cancelAll("cancel");
     }
-    prevActiveRef.current = activeTool.active;
-    for (const id of next) if (!prev.has(id)) fireLifecycle(id, "onActivate");
   });
-  useEffect(() => () => {
-    const live = liveToolsRef.current;
-    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;
-    let routedId = null;
-    const target = () => {
-      if (routedId === null) return rootTargetRef.current;
-      return viewsRef.current?.targets().find((t) => t.id === routedId) ?? rootTargetRef.current;
-    };
-    const routeAt = (pointerId, clientX, clientY) => {
-      routedId = viewsRef.current?.resolver.at(pointerId, clientX, clientY).id ?? null;
-    };
-    const routeDown = (pointerId, clientX, clientY) => {
-      routedId = viewsRef.current?.resolver.begin(pointerId, clientX, clientY).id ?? null;
-    };
-    const routeRelease = (pointerId) => {
-      viewsRef.current?.resolver.end(pointerId);
-    };
-    const dispatcherNow = () => target().dispatcher;
-    const routedDeps = withViewDeps(() => ctxRef.current.depRegistry, () => target().deps?.());
-    const routedRuleCtx = () => target().getRuleCtx?.();
-    const ctxNow = () => ({
-      ...ctxRef.current,
-      depRegistry: routedDeps,
-      getRuleCtx: routedRuleCtx,
-      viewId: target().id
-    });
-    const canvas = canvasRef.current;
-    const toWorld = (cx, cy) => {
-      const fn = target().clientToWorld;
-      return fn ? fn(cx, cy) : { x: cx, y: cy };
-    };
-    const dispatch = (ev, on) => {
-      const d = on ?? dispatcherNow();
-      const before = d.inFlight().size;
-      const result = d.handleInput(ev, ctxNow());
-      const after = d.inFlight().size;
-      if (before > 0 || after > 0) requestRedrawRef.current?.();
-      return result;
-    };
-    const core = {
-      canvas,
-      target,
-      routeAt,
-      routedView: () => routedId,
-      setRoutedView: (id) => {
-        routedId = id;
+    return attachInput(canvasRef.current, {
+      root: () => rootTargetRef.current,
+      views: () => viewsRef.current,
+      context: () => ctxRef.current,
+      actions: () => registryRef.current,
+      dispatchers: allDispatchers,
+      requestRedraw: () => {
+        requestRedrawRef.current?.();
       },
-      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();
-      if (!rect) return p;
-      const [x, y] = clientToCanvasRect(rect, p.x, p.y);
-      return { x, y };
-    };
-    const heldGeometry = () => {
-      const { centroid, spread } = computeMultiTouchGeometry(
-        [...held.values()].map((p) => p.pos)
-      );
-      return { centroid: toCanvasLocal(centroid), spread };
-    };
-    let multiTouchStart = null;
-    const TAP_THRESHOLD_PX = 8;
-    const longPressTimers = /* @__PURE__ */ new Map();
-    const clearPending = (pointerId) => {
-      const store = longPressRef.current?.state;
-      const p = store?.get();
-      if (p && (pointerId === void 0 || p.pointerId === pointerId)) store.set(null);
-    };
-    const cancelLongPress = (pointerId) => {
-      const t = longPressTimers.get(pointerId);
-      if (t !== void 0) {
-        clearTimeout(t);
-        longPressTimers.delete(pointerId);
-      }
-      clearPending(pointerId);
-    };
-    const cancelAllLongPress = () => {
-      for (const t of longPressTimers.values()) clearTimeout(t);
-      longPressTimers.clear();
-      clearPending();
-    };
-    const HAPTIC_MS = 15;
-    const longPressEvents = (down) => {
-      const shared = {
-        target: down.target,
-        altKey: down.altKey,
-        ctrlKey: down.ctrlKey,
-        metaKey: down.metaKey,
-        shiftKey: down.shiftKey,
-        ...down.affordance !== void 0 ? { affordance: down.affordance } : {},
-        ...down.bodyTarget !== void 0 ? { bodyTarget: down.bodyTarget } : {},
-        ...down.bodyKind !== void 0 ? { bodyKind: down.bodyKind } : {}
-      };
-      const at = { x: down.worldX, y: down.worldY, clientX: down.clientX, clientY: down.clientY };
-      return {
-        longpress: { kind: "longpress", ...at, ...shared },
-        contextmenu: { kind: "contextmenu", ...at, ...shared }
-      };
-    };
-    const longPressWouldFire = (down) => {
-      const evs = longPressEvents(down);
-      const d = dispatcherNow();
-      return d.resolveOnly(evs.longpress, ctxNow()) !== null || d.resolveOnly(evs.contextmenu, ctxNow()) !== null;
-    };
-    const fireLongPress = (pointerId, pointerType) => {
-      const rec = held.get(pointerId);
-      clearPending(pointerId);
-      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 onWindowBlur = () => {
-      pinch.end();
-      for (const p of [...held.values()]) p.session.cancel();
-      keys.releaseAll();
-    };
-    let claimedDoubleClick = false;
-    const onNativeDoubleClick = (e) => {
-      if (!claimedDoubleClick) return;
-      claimedDoubleClick = false;
-      e.preventDefault();
-    };
-    const onPointerDown = (e) => {
-      claimedDoubleClick = false;
-      if ((e.button ?? 0) !== 0) return;
-      if (!canvas) return;
-      if (isInControlWithin(e.target, canvas)) return;
-      routeDown(e.pointerId, e.clientX, e.clientY);
-      const w = toWorld(e.clientX, e.clientY);
-      const affordance = target().affordanceAt?.(w) ?? void 0;
-      const body = target().classifyTarget?.(w);
-      const bodyTarget = body?.body;
-      const bodyKind = body?.kind;
-      const ev = {
-        kind: "pointerdown",
-        target: e.target,
-        pointerId: e.pointerId,
-        x: w.x,
-        y: w.y,
-        clientX: e.clientX,
-        clientY: e.clientY,
-        altKey: e.altKey,
-        ctrlKey: e.ctrlKey,
-        metaKey: e.metaKey,
-        shiftKey: e.shiftKey,
-        ...stylusOf(e),
-        ...affordance !== void 0 ? { affordance } : {},
-        ...bodyTarget !== void 0 ? { bodyTarget } : {},
-        ...bodyKind !== void 0 ? { bodyKind } : {}
-      };
-      held.set(e.pointerId, {
-        session: openPointerSession(canvas, e, {
-          onMove: onPointerMove,
-          onEnd: onPointerUp,
-          onCancel: () => {
-            onPointerCancel(e.pointerId);
-          }
-        }),
-        pos: { x: e.clientX, y: e.clientY },
-        // Deferred until the first past-threshold pointermove: a bare
-        // press-and-release should fire `click`, not start a drag action.
-        buffered: { ev, clientX: e.clientX, clientY: e.clientY },
-        down: {
-          target: e.target,
-          clientX: e.clientX,
-          clientY: e.clientY,
-          worldX: w.x,
-          worldY: w.y,
-          affordance,
-          bodyTarget,
-          bodyKind,
-          altKey: e.altKey,
-          ctrlKey: e.ctrlKey,
-          metaKey: e.metaKey,
-          shiftKey: e.shiftKey
-        }
-      });
-      if (held.size < 2) dispatch({ ...ev, stage: "press" });
-      if ((e.pointerType === "touch" || e.pointerType === "pen") && held.size === 1) {
-        cancelLongPress(e.pointerId);
-        const duration = longPressRef.current?.duration ?? LONG_PRESS_MS;
-        longPressTimers.set(
-          e.pointerId,
-          setTimeout(() => {
-            longPressTimers.delete(e.pointerId);
-            if (disposed) return;
-            fireLongPress(e.pointerId, e.pointerType);
-          }, duration)
-        );
-        const store = longPressRef.current?.state;
-        const rec = held.get(e.pointerId);
-        if (store && rec) {
-          store.set({
-            pointerId: e.pointerId,
-            pointerType: e.pointerType,
-            client: { x: e.clientX, y: e.clientY },
-            local: toCanvasLocal({ x: e.clientX, y: e.clientY }),
-            world: { x: w.x, y: w.y },
-            viewId: target().id,
-            startedAt: performance.now(),
-            duration,
-            armed: longPressWouldFire(rec.down)
-          });
-        }
-      }
-      if (held.size >= 2) {
-        cancelAllLongPress();
-        for (const p of held.values()) p.buffered = null;
-        const { centroid, spread } = heldGeometry();
-        if (!multiTouchStart) {
-          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,
-          altKey: e.altKey,
-          ctrlKey: e.ctrlKey,
-          metaKey: e.metaKey,
-          shiftKey: e.shiftKey,
-          centroid,
-          spread
-        };
-        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)) {
-          rec.buffered = null;
-          cancelLongPress(e.pointerId);
-          dispatch(buffered.ev);
-        }
-      }
-      const mtGestureId = `multitouch-${held.size}`;
-      if (held.size >= 2 && dispatcherNow().inFlight().has(mtGestureId)) {
-        const { centroid, spread } = heldGeometry();
-        const mtEv = {
-          kind: "multitouch",
-          fingers: held.size,
-          altKey: e.altKey,
-          ctrlKey: e.ctrlKey,
-          metaKey: e.metaKey,
-          shiftKey: e.shiftKey,
-          centroid,
-          spread
-        };
-        dispatch(mtEv);
-      }
-      const w = toWorld(e.clientX, e.clientY);
-      const ev = {
-        kind: "pointermove",
-        pointerId: e.pointerId,
-        x: w.x,
-        y: w.y,
-        clientX: e.clientX,
-        clientY: e.clientY,
-        altKey: e.altKey,
-        ctrlKey: e.ctrlKey,
-        metaKey: e.metaKey,
-        shiftKey: e.shiftKey,
-        ...stylusOf(e)
-      };
-      dispatch(ev);
-      lastHover = {
-        clientX: e.clientX,
-        clientY: e.clientY,
-        altKey: e.altKey,
-        ctrlKey: e.ctrlKey,
-        metaKey: e.metaKey,
-        shiftKey: e.shiftKey
-      };
-      refreshHoverCursor();
-    };
-    let lastHover = null;
-    let cursorOverridden = false;
-    const clearHoverCursor = () => {
-      paintedCursorRef.current?.()?.setOverride(null);
-      if (cursorOverridden && canvas) {
-        canvas.style.cursor = "";
-        cursorOverridden = false;
-      }
-    };
-    const applyHoverCursor = (spec) => {
-      const tier = spec === null ? null : resolveCursorTier(spec);
-      if (!tier || !canvas) {
-        clearHoverCursor();
-        return;
-      }
-      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;
-    };
-    function pushPaintedPointer() {
-      const painted = paintedCursorRef.current?.();
-      if (!painted?.active() || !canvas || !lastHover) return;
-      const r = canvas.getBoundingClientRect();
-      painted.setPointer(lastHover.clientX - r.left, lastHover.clientY - r.top);
-    }
-    function refreshHoverCursor() {
-      resolveHoverCursor();
-      pushPaintedPointer();
-    }
-    function resolveHoverCursor() {
-      if (!canvas || !lastHover) return;
-      if (held.size > 0 || dispatcherNow().inFlight().size > 0) {
-        applyHoverCursor(dispatcherNow().inFlightCursor());
-        return;
-      }
-      const h = lastHover;
-      routeAt(null, h.clientX, h.clientY);
-      const w = toWorld(h.clientX, h.clientY);
-      const affordance = target().affordanceAt?.(w) ?? void 0;
-      if (affordance?.cursor) {
-        applyHoverCursor(affordance.cursor);
-        return;
-      }
-      const hoverBody = target().classifyTarget?.(w);
-      const bodyTarget = hoverBody?.body;
-      const bodyKind = hoverBody?.kind;
-      const where = {
-        altKey: h.altKey,
-        ctrlKey: h.ctrlKey,
-        metaKey: h.metaKey,
-        shiftKey: h.shiftKey,
-        ...affordance !== void 0 ? { affordance } : {},
-        ...bodyTarget !== void 0 ? { bodyTarget } : {},
-        ...bodyKind !== void 0 ? { bodyKind } : {}
-      };
-      const ctx = ctxNow();
-      const press = {
-        kind: "pointerdown",
-        x: w.x,
-        y: w.y,
-        clientX: h.clientX,
-        clientY: h.clientY,
-        ...where
-      };
-      const d = dispatcherNow();
-      publishLiveDispatch(() => d.explain(press, ctx));
-      const dragCursor = d.resolveOnly(press, ctx)?.action.cursor;
-      const cursor = dragCursor ?? dispatcherNow().resolveOnly(
-        { kind: "click", x: w.x, y: w.y, pressX: w.x, pressY: w.y, ...where },
-        ctx
-      )?.action.cursor;
-      applyHoverCursor(cursor ?? null);
-    }
-    const scheduleHoverCursorRefresh = (e) => {
-      if (!lastHover) return;
-      lastHover = {
-        ...lastHover,
-        altKey: e.altKey,
-        ctrlKey: e.ctrlKey,
-        metaKey: e.metaKey,
-        shiftKey: e.shiftKey
-      };
-      setTimeout(() => {
-        if (!disposed) refreshHoverCursor();
-      }, 0);
-    };
-    const onHoverMove = (e) => {
-      if (held.has(e.pointerId)) return;
-      onPointerMove(e);
-    };
-    const onHoverPointerLeave = () => {
-      lastHover = null;
-      publishLiveDispatch(null);
-      paintedCursorRef.current?.()?.clearPointer();
-      clearHoverCursor();
-    };
-    const onPointerUp = (e) => {
-      routeAt(e.pointerId, e.clientX, e.clientY);
-      cancelLongPress(e.pointerId);
-      const prevSize = held.size;
-      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 start = multiTouchStart;
-        if (start) {
-          const centroid = toCanvasLocal(
-            computeMultiTouchGeometry([
-              ...[...held.values()].map((p) => p.pos),
-              { x: e.clientX, y: e.clientY }
-            ]).centroid
-          );
-          const dx = centroid.x - start.centroid.x;
-          const dy = centroid.y - start.centroid.y;
-          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,
-              altKey: e.altKey,
-              ctrlKey: e.ctrlKey,
-              metaKey: e.metaKey,
-              shiftKey: e.shiftKey
-            };
-            dispatch(tap);
-          }
-          multiTouchStart = null;
-        }
-      }
-      const movedDuringDrag = rec ? rec.down.clientX !== e.clientX || rec.down.clientY !== e.clientY : true;
-      const hadDragInFlight = dispatcherNow().inFlight().has(pointerGestureId(e.pointerId)) && movedDuringDrag;
-      const wUp = toWorld(e.clientX, e.clientY);
-      const ev = {
-        kind: "pointerup",
-        pointerId: e.pointerId,
-        x: wUp.x,
-        y: wUp.y,
-        clientX: e.clientX,
-        clientY: e.clientY,
-        altKey: e.altKey,
-        ctrlKey: e.ctrlKey,
-        metaKey: e.metaKey,
-        shiftKey: e.shiftKey
-      };
-      dispatch(ev);
-      const down = rec?.down;
-      if (!hadDragInFlight && staysUnderThreshold && down) {
-        const wClick = toWorld(e.clientX, e.clientY);
-        const clickEv = {
-          kind: "click",
-          target: e.target,
-          altKey: e.altKey,
-          ctrlKey: e.ctrlKey,
-          metaKey: e.metaKey,
-          shiftKey: e.shiftKey,
-          x: wClick.x,
-          y: wClick.y,
-          clientX: e.clientX,
-          clientY: e.clientY,
-          pressX: down.worldX,
-          pressY: down.worldY,
-          ...down.affordance !== void 0 ? { affordance: down.affordance } : {},
-          ...down.bodyTarget !== void 0 ? { bodyTarget: down.bodyTarget } : {},
-          ...down.bodyKind !== void 0 ? { bodyKind: down.bodyKind } : {}
-        };
-        dispatch(clickEv);
-        onClickRef.current?.({ x: wClick.x, y: wClick.y });
-        const now = Date.now();
-        const prev = lastClickRef.current;
-        const dx = e.clientX - (prev?.clientX ?? 0);
-        const dy = e.clientY - (prev?.clientY ?? 0);
-        if (prev && now - prev.t < DOUBLE_CLICK_MAX_MS && Math.hypot(dx, dy) < DOUBLE_CLICK_MAX_PX) {
-          const dblEv = {
-            kind: "doubleclick",
-            target: e.target,
-            altKey: e.altKey,
-            ctrlKey: e.ctrlKey,
-            metaKey: e.metaKey,
-            shiftKey: e.shiftKey,
-            x: wClick.x,
-            y: wClick.y,
-            clientX: e.clientX,
-            clientY: e.clientY,
-            ...down.affordance !== void 0 ? { affordance: down.affordance } : {},
-            ...down.bodyTarget !== void 0 ? { bodyTarget: down.bodyTarget } : {},
-            ...down.bodyKind !== void 0 ? { bodyKind: down.bodyKind } : {}
-          };
-          onDoubleClickRef.current?.({ x: wClick.x, y: wClick.y });
-          const handled = dispatch(dblEv) === "handled";
-          claimedDoubleClick = handled || onDoubleClickRef.current !== void 0;
-          lastClickRef.current = null;
-        } else {
-          lastClickRef.current = { t: now, clientX: e.clientX, clientY: e.clientY };
-        }
-      }
-      routeRelease(e.pointerId);
-      lastHover = {
-        clientX: e.clientX,
-        clientY: e.clientY,
-        altKey: e.altKey,
-        ctrlKey: e.ctrlKey,
-        metaKey: e.metaKey,
-        shiftKey: e.shiftKey
-      };
-      setTimeout(() => {
-        if (!disposed) refreshHoverCursor();
-      }, 0);
-    };
-    const onPointerCancel = (pointerId) => {
-      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",
-        pointerId,
-        altKey: rec.down.altKey,
-        ctrlKey: rec.down.ctrlKey,
-        metaKey: rec.down.metaKey,
-        shiftKey: rec.down.shiftKey
-      };
-      dispatch(ev);
-      routeRelease(pointerId);
-    };
-    const onPressActivate = () => {
-      registryRef.current.activate();
-    };
-    const keyCapture = keyboard === "first";
-    if (keyboard) {
-      window.addEventListener("keydown", onKeyDown, keyCapture);
-      window.addEventListener("keyup", onKeyUp, keyCapture);
-    }
-    window.addEventListener("blur", onWindowBlur);
-    canvas?.addEventListener("pointerdown", onPressActivate);
-    window.addEventListener("keydown", scheduleHoverCursorRefresh);
-    window.addEventListener("keyup", scheduleHoverCursorRefresh);
-    if (pointerChannel) {
-      canvas?.addEventListener("pointerleave", onHoverPointerLeave);
-      canvas?.addEventListener("pointerdown", onPointerDown);
-      canvas?.addEventListener("pointermove", onHoverMove);
-      canvas?.addEventListener("dblclick", onNativeDoubleClick);
-    }
-    if (wheelChannel) canvas?.addEventListener("wheel", onWheel, { passive: false, capture: true });
-    if (pinchChannel) {
-      canvas?.addEventListener("gesturestart", onGestureStart);
-      canvas?.addEventListener("gesturechange", onGestureChange);
-      canvas?.addEventListener("gestureend", onGestureEnd);
-    }
-    if (contextMenuChannel) canvas?.addEventListener("contextmenu", onContextMenu);
-    if (ingestChannel) {
-      canvas?.addEventListener("dragenter", onDragOver);
-      canvas?.addEventListener("dragover", onDragOver);
-      canvas?.addEventListener("dragleave", onDragLeave);
-      canvas?.addEventListener("drop", onDrop);
-      window.addEventListener("paste", onPaste);
-    }
-    return () => {
-      if (keyboard) {
-        window.removeEventListener("keydown", onKeyDown, keyCapture);
-        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);
-      canvas?.removeEventListener("wheel", onWheel, { capture: true });
-      canvas?.removeEventListener("gesturestart", onGestureStart);
-      canvas?.removeEventListener("gesturechange", onGestureChange);
-      canvas?.removeEventListener("gestureend", onGestureEnd);
-      canvas?.removeEventListener("pointerdown", onPointerDown);
-      canvas?.removeEventListener("pointermove", onHoverMove);
-      canvas?.removeEventListener("dblclick", onNativeDoubleClick);
-      canvas?.removeEventListener("contextmenu", onContextMenu);
-      canvas?.removeEventListener("dragenter", onDragOver);
-      canvas?.removeEventListener("dragover", onDragOver);
-      canvas?.removeEventListener("dragleave", onDragLeave);
-      canvas?.removeEventListener("drop", onDrop);
-      window.removeEventListener("paste", onPaste);
-      canvas?.classList.remove(DROPOVER_CLASS);
-      registryRef.current.dropKeys();
-      clearHoverCursor();
-      cancelAllLongPress();
-      disposed = true;
-      for (const p of held.values()) p.session.cancel();
-      held.clear();
-      for (const d of allDispatchers()) d.cancelAll("cancel");
-    };
+      paintedCursor: () => cursorRef.current.painted?.(),
+      cursorSink: () => cursorRef.current.sink?.(),
+      longPress: () => longPressRef.current,
+      onClick: () => onClickRef.current,
+      onDoubleClick: () => onDoubleClickRef.current,
+      clicks: clicksRef.current
+    }, {
+      keyboard,
+      pointer: pointerChannel,
+      wheel: wheelChannel,
+      pinch: pinchChannel,
+      contextMenu: contextMenuChannel,
+      ingest: ingestChannel
+    });
   }, [
     enabled,
     keyboard,
@@ -1157,7 +970,7 @@ function useGestureDispatcher(opts) {
     longPressRef,
     onClickRef,
     onDoubleClickRef,
-    paintedCursorRef,
+    cursorRef,
     registryRef,
     requestRedrawRef,
     rootTargetRef,
@@ -1186,6 +999,7 @@ var ActionsNode = class extends ScopeNode {
   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. */
@@ -1194,10 +1008,19 @@ var ActionsNode = class extends ScopeNode {
     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;
+      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;
@@ -1274,24 +1097,35 @@ var ActionsNode = class extends ScopeNode {
         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(depsFor(a, leaf.deps()), params);
+        a.invoker.run(deps, params);
       } catch (err) {
         console.error(`weasel ActionsRegistry: action "${id}" threw`, err);
       }
       return true;
     },
-    subscribe: (listener) => {
-      this.tree.listeners.add(listener);
-      return () => {
-        this.tree.listeners.delete(listener);
-      };
-    },
+    subscribe: (listener) => this.tree.listeners.subscribe(listener),
     setDispatcher: (d) => pushOwner(this.dispatchers, d),
     begin: (id, params) => {
       const leaf = this.start();
@@ -1404,9 +1238,112 @@ 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) {
+  if (a === null || b === null) return a === b;
+  return a.worldX === b.worldX && a.worldY === b.worldY && a.viewId === b.viewId;
+}
+function createPointerStore() {
+  let current = null;
+  let version = 0;
+  const changed = createEmitter();
+  const get = () => current;
+  return {
+    get,
+    set(next) {
+      if (samePos(current, next)) return;
+      current = next;
+      version++;
+      changed.emit();
+    },
+    subscribe: changed.subscribe,
+    getVersion: () => version,
+    getDropPoint: get
+  };
+}
+var PointerContext = createContext(null);
+function PointerContextProvider({ children, store }) {
+  const [own] = useState(createPointerStore);
+  return /* @__PURE__ */ jsx(PointerContext.Provider, { value: store ?? own, children });
+}
+function usePointerContext() {
+  return useContext(PointerContext);
+}
+var noSubscribe = () => () => {
+};
+var noPointer = () => null;
+function usePointerPosition() {
+  const store = usePointerContext();
+  return useSyncExternalStore(
+    store ? store.subscribe : noSubscribe,
+    store ? store.get : noPointer,
+    store ? store.get : noPointer
+  );
+}
+var SelectionContext = createContext(null);
+function SelectionContextProvider({ children }) {
+  const [state, setState] = useState({ selection: [], kinds: void 0 });
+  const lastSerializedRef = useRef("");
+  const publishSelection = useCallback((ids, kinds) => {
+    const next = JSON.stringify([ids, kinds]);
+    if (next === lastSerializedRef.current) return;
+    lastSerializedRef.current = next;
+    setState({ selection: ids, kinds });
+  }, []);
+  const value = useMemo(
+    () => ({
+      selection: state.selection,
+      ...state.kinds !== void 0 ? { kinds: state.kinds } : {},
+      publishSelection
+    }),
+    [state, publishSelection]
+  );
+  return /* @__PURE__ */ jsx(SelectionContext.Provider, { value, children });
+}
+function useSelectionContext() {
+  return useContext(SelectionContext);
+}
+function SelectionContextProviderIfRoot({
+  children
+}) {
+  const parent = useContext(SelectionContext);
+  if (parent !== null) return /* @__PURE__ */ jsx(Fragment, { children });
+  return /* @__PURE__ */ jsx(SelectionContextProvider, { children });
+}
+function usePublishSelection(ids, kinds) {
+  const ctx = useContext(SelectionContext);
+  const idsRef = useLatest(ids);
+  const kindsRef = useLatest(kinds);
+  const serialized = JSON.stringify([ids, kinds]);
+  const publish = ctx?.publishSelection;
+  useEffect(() => {
+    if (!publish) return;
+    publish(idsRef.current, kindsRef.current);
+  }, [publish, serialized, idsRef, kindsRef]);
+  const ctxRef = useLatest(ctx);
+  const serializedRef = useLatest(serialized);
+  useEffect(() => () => {
+    const slot = ctxRef.current;
+    if (slot && JSON.stringify([slot.selection, slot.kinds]) === serializedRef.current) {
+      slot.publishSelection([]);
+    }
+  }, [ctxRef, serializedRef]);
+}
 var NO_MODES = () => () => {
 };
 function useContributions(opts) {
@@ -1596,6 +1533,6 @@ function useTools(opts) {
   );
 }
 
-export { ActionsProvider, ActiveToolContextProvider, ActiveToolContextProviderIfRoot, DepRegistryProvider, InputScope, Yoke, useAction, useActionsRegistry, useActiveToolContext, useContributions, useDepRegistry, useDepSource, useGestureDispatcher, useOffhandAction, useOngoingAction, useOptionalActiveToolContext, useOptionalDepRegistry, useTools, useYoke };
+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 };
 //# sourceMappingURL=react.js.map
 //# sourceMappingURL=react.js.map