@weasel-js/routing 1.9.3 → 1.10.0

package/dist/react.js

@@ -1,9 +1,10 @@
-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, assembleEntries, liveScope, isDev, reportRouteConflicts, offhandKeyFor, makeToolOffhandAction, buildToolOffhandBindings, dlog, ScopeNode, isTool, DEV, publishLiveDispatch, LONG_PRESS_HAPTIC_MS, multiTouchGestureId, openPointerSession, pushOwner, evaluateEnabled, validateActionId, validateActionDefaultBinding, depNodeOf, DepNode, clientToCanvas, buildDepsFromRequires, isEditableTarget, focusedControlOwnsKey, itemsFromClipboardData, itemsFromDataTransfer, itemTypesFromDataTransfer } from './chunk-4DR6AJMN.js';
 import { createContext, useState, useContext, useEffect, useRef, useCallback, useMemo, useSyncExternalStore } from 'react';
+import { isApplePlatform, createPointerRecognizer, isInControlWithin, longPressEvents, stylusOf } from '@weasel-js/gestures';
 import { useLatest, useStableByContent, sameList } from '@weasel-js/react';
 import { jsx, Fragment } from 'react/jsx-runtime';
-import { 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,19 +111,93 @@ function useDepSource(name, source) {
     return registry.register(name, () => sourceRef.current());
   }, [name, registry, sourceRef]);
 }
-var DROPOVER_CLASS = "weasel-dropover";
-function stylusOf(e) {
+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 !== 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 {
-    ...typeof e.pressure === "number" ? { pressure: e.pressure } : {},
-    ...typeof e.tiltX === "number" ? { tiltX: e.tiltX } : {},
-    ...typeof e.tiltY === "number" ? { tiltY: e.tiltY } : {}
+    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
   };
 }
-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
-);
 function withViewDeps(base, overlay) {
   return {
     register: (name, source) => base().register(name, source),
@@ -138,25 +208,584 @@ function withViewDeps(base, overlay) {
     }
   };
 }
-function computeMultiTouchGeometry(positions) {
-  const pts = [...positions];
-  if (pts.length < 2) {
-    return { centroid: { x: 0, y: 0 }, spread: 0 };
-  }
-  let sumX = 0;
-  let sumY = 0;
-  for (const p of pts) {
-    sumX += p.x;
-    sumY += p.y;
-  }
-  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 };
+
+// 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, 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 ev = {
+      kind: "contextmenu",
+      target: e.target,
+      x: w.x,
+      y: w.y,
+      clientX: e.clientX,
+      clientY: e.clientY,
+      ...underPointer(target(), e, w)
+    };
+    dispatch(ev);
+  };
+  return onContextMenu;
+}
+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);
+        facts = { at: last, where };
+        dispatch({ kind: "hover", x: w.x, y: w.y, clientX: e.clientX, clientY: e.clientY, ...where });
+      }
+      refresh();
+    },
+    released(e) {
+      last = hoverOf(e);
+      refreshSoon();
+    },
+    onLeave() {
+      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) => {
+    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();
+    dt.dropEffect = "copy";
+  };
+  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 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) || 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),
+      ...mods,
+      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",
+      ...mods,
+      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 });
+    }
+    const handled = keyResult === "handled" || heldResult === "handled";
+    if (handled) e.preventDefault();
+    return handled;
+  };
+  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/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();
+    },
+    heldCount: () => recognizer.heldCount(),
+    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;
+  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 = 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 local = core.toCanvasLocal(cx, cy);
+    const hitPoint = toWorld(cx, cy);
+    const mods = {
+      altKey: g.altKey === true,
+      ctrlKey: g.ctrlKey === true,
+      metaKey: g.metaKey === true,
+      shiftKey: g.shiftKey === true
+    };
+    return {
+      kind: "pinch",
+      scale,
+      rotation,
+      clientX: local.x,
+      clientY: local.y,
+      ...underPointer(target(), mods, hitPoint)
+    };
+  };
+  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 { 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 local = core.toCanvasLocal(e.clientX, e.clientY);
+    const hitPoint = toWorld(e.clientX, e.clientY);
+    const ev = {
+      kind: "wheel",
+      deltaX: e.deltaX,
+      deltaY: e.deltaY,
+      clientX: local.x,
+      clientY: local.y,
+      ...underPointer(target(), e, hitPoint)
+    };
+    const result = dispatch(ev);
+    if (result === "handled") {
+      e.preventDefault();
+      e.stopImmediatePropagation();
+    }
+  };
+  return onWheel;
+}
+
+// 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 } = 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;
@@ -166,6 +795,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();
@@ -177,7 +807,7 @@ function useGestureDispatcher(opts) {
     activeToolId: activeTool.active,
     hotkeyStack: activeTool.hotkeyStack,
     entriesById,
-    isMac: IS_MAC
+    isMac
   });
   const rootTargetRef = useLatest({
     id: null,
@@ -193,844 +823,100 @@ 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 fireLifecycle = useCallback((id, hook) => {
-    const tool = entriesByIdRef.current.get(id);
-    if (!tool || !isTool(tool)) return;
-    const fn = tool[hook];
-    if (!fn) return;
-    try {
-      fn({ scratch: tool.initScratch?.() });
-    } 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 heldKeys = /* @__PURE__ */ new Map();
-    const physicalKey = (e) => e.code || e.key.toLowerCase();
-    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 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();
-    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 down = held.get(pointerId)?.down;
-      clearPending(pointerId);
-      if (!down) return;
-      const evs = longPressEvents(down);
-      let result = dispatch(evs.longpress);
-      if (result === "unhandled") result = dispatch(evs.contextmenu);
-      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 redraw = dispatcherWatch(() => {
+      requestRedrawRef.current?.();
+    });
+    redraw.sync(allDispatchers());
+    const core = createDispatchCore({
+      canvas,
+      root: () => rootTargetRef.current,
+      views: () => viewsRef.current,
+      context: () => ctxRef.current,
+      actions: () => registryRef.current,
+      uses: () => {
+        redraw.sync(allDispatchers());
+      },
+      disposed: () => disposed
+    });
+    const keys = keyboardInput(core);
+    const pinch = webkitPinchInput(core);
+    const ingest = ingestInput(core);
+    const hover = hoverCursorInput(core, () => cursorRef.current.painted?.(), () => pointer.heldCount(), () => cursorRef.current.sink?.());
+    const pointer = pointerInput(core, {
+      longPress: () => longPressRef.current,
+      onClick: () => onClickRef.current,
+      onDoubleClick: () => onDoubleClickRef.current,
+      clicks: clicksRef.current,
+      hover
+    });
     const onWindowBlur = () => {
-      endPinch();
-      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();
-    };
-    let claimedDoubleClick = false;
-    const onNativeDoubleClick = (e) => {
-      if (!claimedDoubleClick) return;
-      claimedDoubleClick = false;
-      e.preventDefault();
-    };
-    const onPointerDown = (e) => {
-      claimedDoubleClick = false;
-      registryRef.current.activate();
-      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 } };
-        } else {
-          multiTouchStart.fingers = held.size;
-        }
-        const mt = {
-          kind: "multitouch",
-          fingers: held.size,
-          altKey: e.altKey,
-          ctrlKey: e.ctrlKey,
-          metaKey: e.metaKey,
-          shiftKey: e.shiftKey,
-          centroid,
-          spread
-        };
-        dispatch(mt);
-      }
-    };
-    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 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 painted = tier.kind === "painted" ? tier : null;
-      paintedCursorRef.current?.()?.setOverride(painted);
-      const cursor = tier.kind === "css" ? tier.css : "none";
-      if (!cursor) {
-        clearHoverCursor();
-        return;
-      }
-      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 && held.size < 2) {
-        const mtGestureId = `multitouch-${prevSize}`;
-        if (dispatcherNow().inFlight().has(mtGestureId)) {
-          dispatcherNow().cancelAll("commit");
-        }
-        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;
-          if (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;
-      held.delete(pointerId);
-      routeAt(pointerId, rec.pos.x, rec.pos.y);
-      cancelLongPress(pointerId);
-      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 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();
+      pinch.end();
+      pointer.cancelHeld();
+      keys.releaseAll();
     };
+    const listeners = listenerSet();
     const keyCapture = keyboard === "first";
     if (keyboard) {
-      window.addEventListener("keydown", onKeyDown, keyCapture);
-      window.addEventListener("keyup", onKeyUp, keyCapture);
+      listeners.on(window, "keydown", keys.onKeyDown, keyCapture);
+      listeners.on(window, "keyup", keys.onKeyUp, keyCapture);
     }
-    window.addEventListener("blur", onWindowBlur);
-    window.addEventListener("keydown", scheduleHoverCursorRefresh);
-    window.addEventListener("keyup", scheduleHoverCursorRefresh);
+    listeners.on(window, "blur", onWindowBlur);
+    listeners.on(canvas, "pointerdown", () => {
+      registryRef.current.activate();
+    });
     if (pointerChannel) {
-      canvas?.addEventListener("pointerleave", onHoverPointerLeave);
-      canvas?.addEventListener("pointerdown", onPointerDown);
-      canvas?.addEventListener("pointermove", onHoverMove);
-      canvas?.addEventListener("dblclick", onNativeDoubleClick);
+      listeners.on(window, "keydown", hover.onKey);
+      listeners.on(window, "keyup", hover.onKey);
+      listeners.on(canvas, "pointerleave", hover.onLeave);
+      listeners.on(canvas, "pointerdown", pointer.onPointerDown);
+      listeners.on(canvas, "pointermove", pointer.onHoverMove);
+      listeners.on(canvas, "dblclick", pointer.onNativeDoubleClick);
+    }
+    if (wheelChannel) {
+      listeners.on(canvas, "wheel", wheelInput(core, pinch.live), { passive: false, capture: true });
     }
-    if (wheelChannel) canvas?.addEventListener("wheel", onWheel, { passive: false, capture: true });
     if (pinchChannel) {
-      canvas?.addEventListener("gesturestart", onGestureStart);
-      canvas?.addEventListener("gesturechange", onGestureChange);
-      canvas?.addEventListener("gestureend", onGestureEnd);
+      listeners.on(canvas, "gesturestart", pinch.onGestureStart);
+      listeners.on(canvas, "gesturechange", pinch.onGestureChange);
+      listeners.on(canvas, "gestureend", pinch.onGestureEnd);
+    }
+    if (contextMenuChannel) {
+      listeners.on(canvas, "contextmenu", contextMenuInput(core, pointer.takeNativeHold));
     }
-    if (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);
+      listeners.on(canvas, "dragenter", ingest.onDragOver);
+      listeners.on(canvas, "dragover", ingest.onDragOver);
+      listeners.on(canvas, "dragleave", ingest.onDragLeave);
+      listeners.on(canvas, "drop", ingest.onDrop);
+      listeners.on(window, "paste", ingest.onPaste);
     }
     return () => {
-      if (keyboard) {
-        window.removeEventListener("keydown", onKeyDown, keyCapture);
-        window.removeEventListener("keyup", onKeyUp, keyCapture);
-      }
-      window.removeEventListener("blur", onWindowBlur);
-      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);
+      listeners.removeAll();
       canvas?.classList.remove(DROPOVER_CLASS);
-      clearHoverCursor();
-      cancelAllLongPress();
+      registryRef.current.dropKeys();
+      hover.clear();
       disposed = true;
-      for (const p of held.values()) p.session.cancel();
-      held.clear();
+      pointer.dispose();
+      redraw.stop();
       for (const d of allDispatchers()) d.cancelAll("cancel");
     };
   }, [
@@ -1047,7 +933,7 @@ function useGestureDispatcher(opts) {
     longPressRef,
     onClickRef,
     onDoubleClickRef,
-    paintedCursorRef,
+    cursorRef,
     registryRef,
     requestRedrawRef,
     rootTargetRef,
@@ -1118,6 +1004,7 @@ var ActionsNode = class extends ScopeNode {
     return null;
   }
   activate() {
+    keyHolder = this;
     super.activate();
     for (const f of this.onActivate) f();
   }
@@ -1138,7 +1025,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,22 +1054,17 @@ 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;
+      const deps = depsFor(a, leaf.deps());
+      if (!evaluateEnabled(a, deps).enabled) return false;
       try {
-        if (a.invoker && a.invoker.timing === "immediate") {
-          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();
@@ -1188,9 +1074,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 +1162,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 +1180,98 @@ function useOngoingAction(actionId) {
   useEffect(() => () => 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) {
   const ctx = useActiveToolContext();
   const actionsRegistry = useActionsRegistry();
@@ -1309,25 +1290,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 +1341,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) {
@@ -1485,6 +1459,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