@weasel-js/routing 1.6.1 → 1.7.1

package/dist/react.js

@@ -1,37 +1,81 @@
-import { createDispatcher, buildDepsFromRequires, validateActionId, validateActionDefaultBinding, scopeBindings, liveScope, offhandKeyFor, makeToolOffhandAction, buildToolOffhandBindings, isDev, reportRouteConflicts, dlog, isEditableTarget, clientToCanvasRect, openPointerSession, pointerGestureId, itemsFromDataTransfer, itemsFromClipboardData } from './chunk-VEC3ACV5.js';
-import { createContext, useState, useCallback, useMemo, useContext, useRef, useEffect } from 'react';
+import { createDepRegistry, createDispatcher, isTool, scopeBindings, liveScope, isDev, reportRouteConflicts, offhandKeyFor, makeToolOffhandAction, buildToolOffhandBindings, dlog, isEditableTarget, clientToCanvasRect, openPointerSession, LONG_PRESS_MS, publishLiveDispatch, pointerGestureId, itemsFromDataTransfer, itemsFromClipboardData, ScopeNode, pushOwner, validateActionId, validateActionDefaultBinding, depNodeOf, DepNode, buildDepsFromRequires } from './chunk-ZGKJWZ4S.js';
+import { createContext, useState, useContext, useMemo, useEffect, useRef, useCallback, useSyncExternalStore } from 'react';
+import { useLatest, useStableByContent, sameList } from '@weasel-js/react';
 import { jsx, Fragment } from 'react/jsx-runtime';
+import { pastDragThreshold } from '@weasel-js/gestures';
 import { resolveCursorTier } from '@weasel-js/cursor';
+import { activeModeOf } from '@weasel-js/modes';
 
+var ToolNode = class extends ScopeNode {
+  state;
+  value = null;
+  constructor(parent, descends, owns, initialActive) {
+    super(parent, descends);
+    this.state = owns ? { active: initialActive ?? parent?.owner().state?.active ?? null, hotkeyStack: [] } : null;
+  }
+  /** The node whose tool a read here resolves to. */
+  owner() {
+    for (const n of this.start().chain()) if (n.state) return n;
+    return this;
+  }
+  update(next) {
+    const owner = this.owner();
+    if (!owner.state) return;
+    const updated = next(owner.state);
+    if (updated === owner.state) return;
+    owner.state = updated;
+    owner.changed();
+  }
+  /** A stable value per owner and state, for `useSyncExternalStore`. */
+  snapshot() {
+    const from = this.owner();
+    const state = from.state ?? { active: null, hotkeyStack: [] };
+    const cached = this.value;
+    if (cached && cached.from === from && cached.state === state) return cached.out;
+    const out = {
+      active: state.active,
+      hotkeyStack: state.hotkeyStack,
+      setActive: (id) => this.update((s) => s.active === id ? s : { ...s, active: id }),
+      pushHotkey: (id) => this.update((s) => ({ ...s, hotkeyStack: [...s.hotkeyStack, id] })),
+      popHotkey: (id) => this.update((s) => {
+        const stack = s.hotkeyStack;
+        if (stack.length === 0) return s;
+        if (id === void 0) return { ...s, hotkeyStack: stack.slice(0, -1) };
+        const i = stack.lastIndexOf(id);
+        return i === -1 ? s : { ...s, hotkeyStack: [...stack.slice(0, i), ...stack.slice(i + 1)] };
+      })
+    };
+    this.value = { from, state, out };
+    return out;
+  }
+  subscribe = (listener) => {
+    this.tree.listeners.add(listener);
+    return () => {
+      this.tree.listeners.delete(listener);
+    };
+  };
+};
 var ActiveToolContext = createContext(null);
+var ActiveToolNodeContext = ActiveToolContext;
 function ActiveToolContextProvider({
   children,
-  initialActive = "select"
+  initialActive = null
 }) {
-  const [active, setActiveState] = useState(initialActive);
-  const [hotkeyStack, setHotkeyStack] = useState([]);
-  const setActive = useCallback((id) => {
-    setActiveState(id);
-  }, []);
-  const pushHotkey = useCallback((id) => {
-    setHotkeyStack((s) => [...s, id]);
-  }, []);
-  const popHotkey = useCallback((id) => {
-    setHotkeyStack((s) => {
-      if (s.length === 0) return s;
-      if (id === void 0) return s.slice(0, -1);
-      const i = s.lastIndexOf(id);
-      return i === -1 ? s : [...s.slice(0, i), ...s.slice(i + 1)];
-    });
-  }, []);
-  const value = useMemo(
-    () => ({ active, hotkeyStack, setActive, pushHotkey, popHotkey }),
-    [active, hotkeyStack, setActive, pushHotkey, popHotkey]
+  const [node] = useState(() => new ToolNode(null, true, true, initialActive));
+  return /* @__PURE__ */ jsx(ActiveToolContext.Provider, { value: node, children });
+}
+function useNodeValue(node) {
+  const subscribe = useMemo(() => node?.subscribe ?? NO_SUBSCRIBE, [node]);
+  return useSyncExternalStore(
+    subscribe,
+    () => node?.snapshot() ?? null,
+    () => node?.snapshot() ?? null
   );
-  return /* @__PURE__ */ jsx(ActiveToolContext.Provider, { value, children });
 }
+var NO_SUBSCRIBE = () => () => {
+};
 function useActiveToolContext() {
-  const value = useContext(ActiveToolContext);
+  const value = useNodeValue(useContext(ActiveToolContext));
   if (value === null) {
     throw new Error(
       "useActiveToolContext: no ActiveToolContextProvider in scope. Wrap your tree with <ActiveToolContextProvider> (typically inside <SceneCanvas>)."
@@ -40,7 +84,7 @@ function useActiveToolContext() {
   return value;
 }
 function useOptionalActiveToolContext() {
-  return useContext(ActiveToolContext);
+  return useNodeValue(useContext(ActiveToolContext));
 }
 function ActiveToolContextProviderIfRoot({
   children
@@ -51,28 +95,7 @@ function ActiveToolContextProviderIfRoot({
 }
 var DepRegistryContext = createContext(null);
 function DepRegistryProvider({ children }) {
-  const sourcesRef = useRef(/* @__PURE__ */ new Map());
-  const registry = useMemo(() => ({
-    register: (name, source) => {
-      const key = name;
-      const entry = source;
-      const stack = sourcesRef.current.get(key);
-      if (stack) stack.push(entry);
-      else sourcesRef.current.set(key, [entry]);
-      let released = false;
-      return () => {
-        if (released) return;
-        released = true;
-        const cur = sourcesRef.current.get(key);
-        if (!cur) return;
-        const i = cur.lastIndexOf(entry);
-        if (i === -1) return;
-        cur.splice(i, 1);
-        if (cur.length === 0) sourcesRef.current.delete(key);
-      };
-    },
-    get: (name) => sourcesRef.current.get(name)?.at(-1)?.()
-  }), []);
+  const registry = useMemo(createDepRegistry, []);
   return /* @__PURE__ */ jsx(DepRegistryContext.Provider, { value: registry, children });
 }
 function useDepRegistry() {
@@ -87,11 +110,10 @@ function useOptionalDepRegistry() {
 }
 function useDepSource(name, source) {
   const registry = useDepRegistry();
-  const sourceRef = useRef(source);
-  sourceRef.current = source;
+  const sourceRef = useLatest(source);
   useEffect(() => {
     return registry.register(name, () => sourceRef.current());
-  }, [name, registry]);
+  }, [name, registry, sourceRef]);
 }
 var DROPOVER_CLASS = "weasel-dropover";
 function stylusOf(e) {
@@ -134,37 +156,29 @@ function computeMultiTouchGeometry(positions) {
   return { centroid, spread };
 }
 function useGestureDispatcher(opts) {
-  const { canvasRef, actions, toolsById, enabled = true, keyboard = true, affordanceAt, classifyTarget, dispatcher: dispatcherOpt, clientToWorld, requestRedraw, paintedCursor, getRuleCtx, onDoubleClick, views, channels } = opts;
+  const { canvasRef, actions, entriesById, enabled = true, keyboard = true, affordanceAt, classifyTarget, dispatcher: dispatcherOpt, clientToWorld, requestRedraw, paintedCursor, getRuleCtx, onDoubleClick, views, channels, longPress } = opts;
   const pointerChannel = channels?.pointer !== false;
   const wheelChannel = channels?.wheel !== false;
   const pinchChannel = channels?.pinch !== false;
   const contextMenuChannel = channels?.contextMenu !== false;
   const ingestChannel = channels?.ingest !== false;
-  const onDoubleClickRef = useRef(onDoubleClick);
-  onDoubleClickRef.current = onDoubleClick;
+  const onDoubleClickRef = useLatest(onDoubleClick);
   const activeTool = useActiveToolContext();
   const depRegistry = useDepRegistry();
   const dispatcherRef = useRef(null);
   if (!dispatcherRef.current) {
     dispatcherRef.current = dispatcherOpt ?? createDispatcher();
   }
-  const ctxRef = useRef({
+  const registryRef = useLatest(actions);
+  const ctxRef = useLatest({
     actions,
     depRegistry,
     activeToolId: activeTool.active,
     hotkeyStack: activeTool.hotkeyStack,
-    toolsById,
+    entriesById,
     isMac: IS_MAC
   });
-  ctxRef.current = {
-    actions,
-    depRegistry,
-    activeToolId: activeTool.active,
-    hotkeyStack: activeTool.hotkeyStack,
-    toolsById,
-    isMac: IS_MAC
-  };
-  const rootTargetRef = useRef({
+  const rootTargetRef = useLatest({
     id: null,
     dispatcher: dispatcherRef.current,
     affordanceAt,
@@ -172,44 +186,47 @@ function useGestureDispatcher(opts) {
     clientToWorld,
     getRuleCtx
   });
-  rootTargetRef.current = {
-    id: null,
-    dispatcher: dispatcherRef.current,
-    affordanceAt,
-    classifyTarget,
-    clientToWorld,
-    getRuleCtx
-  };
-  const viewsRef = useRef(views);
-  viewsRef.current = views;
-  const allDispatchers = () => [
+  const viewsRef = useLatest(views);
+  const allDispatchers = useCallback(() => [
     rootTargetRef.current.dispatcher,
     ...(viewsRef.current?.targets() ?? []).map((t) => t.dispatcher)
-  ];
-  const requestRedrawRef = useRef(requestRedraw);
-  requestRedrawRef.current = requestRedraw;
-  const paintedCursorRef = useRef(paintedCursor);
-  paintedCursorRef.current = paintedCursor;
+  ], [rootTargetRef, viewsRef]);
+  const requestRedrawRef = useLatest(requestRedraw);
+  const paintedCursorRef = useLatest(paintedCursor);
+  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 prevTool = toolsById.get(prevActiveRef.current);
-      if (prevTool?.onDeactivate) {
-        const scratch = prevTool.initScratch?.();
-        try {
-          prevTool.onDeactivate({ scratch });
-        } catch (err) {
-          console.error(
-            `weasel: tool "${prevActiveRef.current}".onDeactivate threw`,
-            err
-          );
-        }
-      }
       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) return;
     let disposed = false;
@@ -249,7 +266,8 @@ function useGestureDispatcher(opts) {
       if (before > 0 || after > 0) requestRedrawRef.current?.();
       return result;
     };
-    const heldKeys = /* @__PURE__ */ new Set();
+    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();
@@ -273,23 +291,27 @@ function useGestureDispatcher(opts) {
     };
     let multiTouchStart = null;
     const TAP_THRESHOLD_PX = 8;
-    const DRAG_THRESHOLD_PX = 4;
-    const LONG_PRESS_MS = 500;
     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 fireLongPress = (pointerId) => {
-      const down = held.get(pointerId)?.down;
-      if (!down) return;
+    const HAPTIC_MS = 15;
+    const longPressEvents = (down) => {
       const shared = {
         target: down.target,
         altKey: down.altKey,
@@ -300,30 +322,34 @@ function useGestureDispatcher(opts) {
         ...down.bodyTarget !== void 0 ? { bodyTarget: down.bodyTarget } : {},
         ...down.bodyKind !== void 0 ? { bodyKind: down.bodyKind } : {}
       };
-      const result = dispatch({
-        kind: "longpress",
-        x: down.worldX,
-        y: down.worldY,
-        clientX: down.clientX,
-        clientY: down.clientY,
-        ...shared
-      });
-      if (result === "unhandled") {
-        dispatch({
-          kind: "contextmenu",
-          x: down.worldX,
-          y: down.worldY,
-          clientX: down.clientX,
-          clientY: down.clientY,
-          ...shared
-        });
+      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 (isEditableTarget(e.target)) return;
-      if (e.repeat && heldKeys.has(e.key)) {
+      if (e.defaultPrevented || isEditableTarget(e.target)) return;
+      if (!registryRef.current.isActive()) return;
+      if (e.repeat && heldKeys.has(physicalKey(e))) {
         e.preventDefault();
         return;
       }
@@ -348,17 +374,19 @@ function useGestureDispatcher(opts) {
       };
       const heldResult = dispatch(heldEv);
       if (heldResult === "handled") {
-        heldKeys.add(e.key);
+        heldKeys.set(physicalKey(e), e.key);
       }
       if (keyResult === "handled" || heldResult === "handled") {
         e.preventDefault();
       }
     };
     const onKeyUp = (e) => {
-      if (!heldKeys.has(e.key)) return;
+      const physical = physicalKey(e);
+      const downKey = heldKeys.get(physical);
+      if (downKey === void 0) return;
       const ev = {
         kind: "key-held",
-        key: e.key,
+        key: downKey,
         phase: "up",
         altKey: e.altKey,
         ctrlKey: e.ctrlKey,
@@ -366,12 +394,12 @@ function useGestureDispatcher(opts) {
         shiftKey: e.shiftKey
       };
       dispatch(ev);
-      heldKeys.delete(e.key);
+      heldKeys.delete(physical);
     };
     const onWindowBlur = () => {
       endPinch();
       for (const p of [...held.values()]) p.session.cancel();
-      for (const key of heldKeys) {
+      for (const key of heldKeys.values()) {
         const ev = {
           kind: "key-held",
           key,
@@ -386,6 +414,7 @@ function useGestureDispatcher(opts) {
       heldKeys.clear();
     };
     const onWheel = (e) => {
+      registryRef.current.activate();
       if (pinchLive && e.ctrlKey) {
         e.preventDefault();
         e.stopPropagation();
@@ -469,6 +498,7 @@ function useGestureDispatcher(opts) {
       endPinch();
     };
     const onPointerDown = (e) => {
+      registryRef.current.activate();
       if ((e.button ?? 0) !== 0) return;
       if (!canvas) return;
       routeDown(e.pointerId, e.clientX, e.clientY);
@@ -524,14 +554,30 @@ function useGestureDispatcher(opts) {
       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);
-          }, LONG_PRESS_MS)
+            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();
@@ -561,9 +607,7 @@ function useGestureDispatcher(opts) {
       if (rec) rec.pos = { x: e.clientX, y: e.clientY };
       const buffered = rec?.buffered;
       if (rec && buffered) {
-        const dx = e.clientX - buffered.clientX;
-        const dy = e.clientY - buffered.clientY;
-        if (Math.hypot(dx, dy) >= DRAG_THRESHOLD_PX) {
+        if (pastDragThreshold(buffered, e)) {
           rec.buffered = null;
           cancelLongPress(e.pointerId);
           dispatch(buffered.ev);
@@ -671,10 +715,17 @@ function useGestureDispatcher(opts) {
         ...bodyKind !== void 0 ? { bodyKind } : {}
       };
       const ctx = ctxNow();
-      const dragCursor = dispatcherNow().resolveOnly(
-        { kind: "pointerdown", x: w.x, y: w.y, clientX: h.clientX, clientY: h.clientY, ...where },
-        ctx
-      )?.action.cursor;
+      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
@@ -700,6 +751,7 @@ function useGestureDispatcher(opts) {
     };
     const onHoverPointerLeave = () => {
       lastHover = null;
+      publishLiveDispatch(null);
       paintedCursorRef.current?.()?.clearPointer();
       clearHoverCursor();
     };
@@ -912,9 +964,10 @@ function useGestureDispatcher(opts) {
       });
       if (result === "handled") e.preventDefault();
     };
+    const keyCapture = keyboard === "first";
     if (keyboard) {
-      window.addEventListener("keydown", onKeyDown);
-      window.addEventListener("keyup", onKeyUp);
+      window.addEventListener("keydown", onKeyDown, keyCapture);
+      window.addEventListener("keyup", onKeyUp, keyCapture);
     }
     window.addEventListener("blur", onWindowBlur);
     window.addEventListener("keydown", scheduleHoverCursorRefresh);
@@ -940,8 +993,8 @@ function useGestureDispatcher(opts) {
     }
     return () => {
       if (keyboard) {
-        window.removeEventListener("keydown", onKeyDown);
-        window.removeEventListener("keyup", onKeyUp);
+        window.removeEventListener("keydown", onKeyDown, keyCapture);
+        window.removeEventListener("keyup", onKeyUp, keyCapture);
       }
       window.removeEventListener("blur", onWindowBlur);
       window.removeEventListener("keydown", scheduleHoverCursorRefresh);
@@ -967,206 +1020,172 @@ function useGestureDispatcher(opts) {
       held.clear();
       for (const d of allDispatchers()) d.cancelAll("cancel");
     };
-  }, [enabled, keyboard, canvasRef, pointerChannel, wheelChannel, pinchChannel, contextMenuChannel, ingestChannel]);
+  }, [
+    enabled,
+    keyboard,
+    canvasRef,
+    pointerChannel,
+    wheelChannel,
+    pinchChannel,
+    contextMenuChannel,
+    ingestChannel,
+    allDispatchers,
+    ctxRef,
+    longPressRef,
+    onDoubleClickRef,
+    paintedCursorRef,
+    registryRef,
+    requestRedrawRef,
+    rootTargetRef,
+    viewsRef
+  ]);
 }
 var ActionsContext = createContext(null);
-function useMuted(base) {
-  const mutedRef = useRef(/* @__PURE__ */ new Map());
-  const listenersRef = useRef(/* @__PURE__ */ new Set());
-  const cacheRef = useRef(null);
-  return useMemo(() => {
-    if (!base) return null;
-    const isMuted = (id) => mutedRef.current.has(id);
-    const notify = () => {
-      for (const l of listenersRef.current) {
-        try {
-          l();
-        } catch (err) {
-          console.error("weasel ActionsRegistry: subscriber threw", err);
+function depsFor(a, r) {
+  if (!r) return {};
+  if (a.requires) return buildDepsFromRequires(a, r);
+  return {
+    selection: r.get("selection"),
+    scene: r.get("scene"),
+    history: r.get("history"),
+    view: r.get("view"),
+    activeTool: r.get("activeTool"),
+    booleansAdapter: r.get("booleansAdapter")
+  };
+}
+var ActionsNode = class extends ScopeNode {
+  constructor(parent, descends, contextDeps) {
+    super(parent, descends);
+    this.contextDeps = contextDeps;
+    NODES.set(this.registry, this);
+  }
+  contextDeps;
+  actions = /* @__PURE__ */ new Map();
+  muted = /* @__PURE__ */ new Map();
+  dispatchers = [];
+  cache = null;
+  /** Called on `activate`, so a scope's dep and tool nodes move with it. */
+  onActivate = [];
+  resolve(id) {
+    for (const n of this.chain()) {
+      if (n.muted.has(id)) return void 0;
+      const a = n.actions.get(id)?.at(-1);
+      if (a) return a;
+    }
+    return void 0;
+  }
+  snapshot() {
+    const leaf = this.start();
+    const cached = this.cache;
+    if (cached && cached.version === this.tree.version && cached.leaf === leaf) return cached.list;
+    const ids = /* @__PURE__ */ new Set();
+    for (const n of leaf.chain()) for (const id of n.actions.keys()) ids.add(id);
+    const out = [];
+    for (const id of ids) {
+      const a = leaf.resolve(id);
+      if (a) out.push(a);
+    }
+    const list = Object.freeze(out);
+    this.cache = { version: this.tree.version, leaf, list };
+    return list;
+  }
+  deps() {
+    for (const n of this.chain()) {
+      const r = n.contextDeps();
+      if (r) return r;
+    }
+    return null;
+  }
+  dispatcher() {
+    for (const n of this.chain()) {
+      const d = n.dispatchers.at(-1);
+      if (d) return d;
+    }
+    return null;
+  }
+  activate() {
+    super.activate();
+    for (const f of this.onActivate) f();
+  }
+  registry = {
+    register: (action) => {
+      validateActionId(action.id);
+      validateActionDefaultBinding(action);
+      const stack = this.actions.get(action.id);
+      if (stack) stack.push(action);
+      else this.actions.set(action.id, [action]);
+      this.changed();
+      let released = false;
+      return () => {
+        if (released) return;
+        released = true;
+        const cur = this.actions.get(action.id);
+        if (!cur) return;
+        const i = cur.lastIndexOf(action);
+        if (i === -1) return;
+        cur.splice(i, 1);
+        if (cur.length === 0) this.actions.delete(action.id);
+        this.changed();
+      };
+    },
+    unregister: (id) => {
+      if (this.actions.delete(id)) this.changed();
+    },
+    mute: (id) => {
+      this.muted.set(id, (this.muted.get(id) ?? 0) + 1);
+      this.changed();
+      let released = false;
+      return () => {
+        if (released) return;
+        released = true;
+        const held = this.muted.get(id);
+        if (held === void 0) return;
+        if (held > 1) this.muted.set(id, held - 1);
+        else this.muted.delete(id);
+        this.changed();
+      };
+    },
+    list: () => this.snapshot(),
+    trigger: (id, params) => {
+      const leaf = this.start();
+      const a = leaf.resolve(id);
+      if (!a) return false;
+      try {
+        if (a.invoker && a.invoker.timing === "immediate") {
+          a.invoker.run(depsFor(a, leaf.deps()), params);
         }
+      } catch (err) {
+        console.error(`weasel ActionsRegistry: action "${id}" threw`, err);
       }
-    };
-    return {
-      ...base,
-      list: () => {
-        const src = base.list();
-        if (mutedRef.current.size === 0) return src;
-        const cached = cacheRef.current;
-        if (cached && cached.src === src) return cached.out;
-        const out = Object.freeze(src.filter((a) => !mutedRef.current.has(a.id)));
-        cacheRef.current = { src, out };
-        return out;
-      },
-      trigger: (id, params) => isMuted(id) ? false : base.trigger(id, params),
-      begin: (id, params) => isMuted(id) ? null : base.begin(id, params),
-      subscribe: (listener) => {
-        const offBase = base.subscribe(listener);
-        listenersRef.current.add(listener);
-        return () => {
-          offBase();
-          listenersRef.current.delete(listener);
-        };
-      },
-      mute: (id) => {
-        mutedRef.current.set(id, (mutedRef.current.get(id) ?? 0) + 1);
-        cacheRef.current = null;
-        notify();
-        let released = false;
-        return () => {
-          if (released) return;
-          released = true;
-          const held = mutedRef.current.get(id);
-          if (held === void 0) return;
-          if (held > 1) mutedRef.current.set(id, held - 1);
-          else mutedRef.current.delete(id);
-          cacheRef.current = null;
-          notify();
-        };
-      }
-    };
-  }, [base]);
-}
-function ActionsScope({ children }) {
-  const parent = useActionsRegistry();
-  const scoped = useMuted(parent);
-  if (!scoped) return /* @__PURE__ */ jsx(Fragment, { children });
-  return /* @__PURE__ */ jsx(ActionsContext.Provider, { value: scoped, children });
-}
-function pushOwner(ref, value) {
-  if (value === null) return () => {
-  };
-  ref.current.push(value);
-  let released = false;
-  return () => {
-    if (released) return;
-    released = true;
-    const i = ref.current.lastIndexOf(value);
-    if (i !== -1) ref.current.splice(i, 1);
+      return true;
+    },
+    subscribe: (listener) => {
+      this.tree.listeners.add(listener);
+      return () => {
+        this.tree.listeners.delete(listener);
+      };
+    },
+    setDispatcher: (d) => pushOwner(this.dispatchers, d),
+    begin: (id, params) => {
+      const leaf = this.start();
+      const a = leaf.resolve(id);
+      const disp = leaf.dispatcher();
+      if (!a || !disp) return null;
+      return disp.beginUiOngoing(id, depsFor(a, leaf.deps()), params);
+    },
+    activate: () => this.activate(),
+    isActive: () => this.isActive()
   };
+};
+var NODES = /* @__PURE__ */ new WeakMap();
+function actionsNodeOf(registry) {
+  return registry ? NODES.get(registry) ?? null : null;
 }
 function ActionsProvider({ children }) {
-  const actionsRef = useRef(/* @__PURE__ */ new Map());
-  const liveAction = (id) => actionsRef.current.get(id)?.at(-1);
-  const versionRef = useRef(0);
-  const cachedRef = useRef([]);
-  const cachedVerRef = useRef(-1);
-  const listenersRef = useRef(/* @__PURE__ */ new Set());
   const depReg = useOptionalDepRegistry();
-  const depRegRef = useRef(depReg);
-  depRegRef.current = depReg;
-  const warnedRef = useRef(false);
-  const wiredDepRegRef = useRef([]);
-  const dispatcherRef = useRef([]);
-  const store = useMemo(() => {
-    const snapshot = () => {
-      const v = versionRef.current;
-      if (cachedVerRef.current === v) return cachedRef.current;
-      const out = Object.freeze(
-        Array.from(actionsRef.current.values(), (stack) => stack[stack.length - 1])
-      );
-      cachedRef.current = out;
-      cachedVerRef.current = v;
-      return out;
-    };
-    const notify = () => {
-      for (const l of listenersRef.current) {
-        try {
-          l();
-        } catch (err) {
-          console.error("weasel ActionsRegistry: subscriber threw", err);
-        }
-      }
-    };
-    return {
-      register: (action) => {
-        validateActionId(action.id);
-        validateActionDefaultBinding(action);
-        const stack = actionsRef.current.get(action.id);
-        if (stack) stack.push(action);
-        else actionsRef.current.set(action.id, [action]);
-        versionRef.current++;
-        notify();
-        let released = false;
-        return () => {
-          if (released) return;
-          released = true;
-          const cur = actionsRef.current.get(action.id);
-          if (!cur) return;
-          const i = cur.lastIndexOf(action);
-          if (i === -1) return;
-          cur.splice(i, 1);
-          if (cur.length === 0) actionsRef.current.delete(action.id);
-          versionRef.current++;
-          notify();
-        };
-      },
-      unregister: (id) => {
-        if (actionsRef.current.delete(id)) {
-          versionRef.current++;
-          notify();
-        }
-      },
-      list: () => snapshot(),
-      trigger: (id, params) => {
-        const a = liveAction(id);
-        if (!a) return false;
-        try {
-          if (a.invoker && a.invoker.timing === "immediate") {
-            const r = wiredDepRegRef.current.at(-1) ?? depRegRef.current;
-            const deps = !r ? {} : a.requires ? buildDepsFromRequires(a, r) : {
-              selection: r.get("selection"),
-              scene: r.get("scene"),
-              history: r.get("history"),
-              view: r.get("view"),
-              activeTool: r.get("activeTool"),
-              booleansAdapter: r.get("booleansAdapter")
-            };
-            a.invoker.run(deps, params);
-          }
-        } catch (err) {
-          console.error(`weasel ActionsRegistry: action "${id}" threw`, err);
-        }
-        return true;
-      },
-      subscribe: (listener) => {
-        listenersRef.current.add(listener);
-        return () => {
-          listenersRef.current.delete(listener);
-        };
-      },
-      setDispatcher: (d) => {
-        if (d && dispatcherRef.current.length > 0 && dispatcherRef.current.at(-1) !== d && !warnedRef.current) {
-          warnedRef.current = true;
-          warnSharedScope();
-        }
-        return pushOwner(dispatcherRef, d);
-      },
-      setDepRegistry: (r) => pushOwner(wiredDepRegRef, r),
-      begin: (id, params) => {
-        const disp = dispatcherRef.current.at(-1) ?? null;
-        if (!disp) return null;
-        const r = wiredDepRegRef.current.at(-1) ?? depRegRef.current;
-        const a = liveAction(id);
-        const deps = !r ? {} : a?.requires ? buildDepsFromRequires(a, r) : {
-          selection: r.get("selection"),
-          scene: r.get("scene"),
-          history: r.get("history"),
-          view: r.get("view"),
-          activeTool: r.get("activeTool"),
-          booleansAdapter: r.get("booleansAdapter")
-        };
-        return disp.beginUiOngoing(id, deps, params);
-      }
-    };
-  }, []);
-  const registry = useMuted(store);
-  return /* @__PURE__ */ jsx(ActionsContext.Provider, { value: registry, children });
-}
-function warnSharedScope() {
-  if (!IS_DEV) return;
-  console.warn(
-    "weasel: a second dispatcher claimed this <ActionsProvider>, so only the newest <SceneCanvas> under it will respond to input. Give each canvas its own scope with <WeaselProvider isolate>."
-  );
+  const depRegRef = useLatest(depReg);
+  const node = useMemo(() => new ActionsNode(null, true, () => depRegRef.current), [depRegRef]);
+  return /* @__PURE__ */ jsx(ActionsContext.Provider, { value: node.registry, children });
 }
 var IS_DEV = (() => {
   try {
@@ -1192,12 +1211,45 @@ function useAction(action) {
     return reg.register(action);
   }, [reg, action]);
 }
+function useNodes(descends, ownsTool, parent) {
+  const parentActions = useActionsRegistry();
+  const parentDeps = useOptionalDepRegistry();
+  const parentTools = useContext(ActiveToolNodeContext);
+  const pa = parent ? parent.actions : actionsNodeOf(parentActions);
+  const pd = parent ? parent.deps : depNodeOf(parentDeps);
+  const pt = parent ? parent.tools : parentTools;
+  const nodes = useMemo(() => {
+    const deps = new DepNode(pd, descends);
+    const tools = new ToolNode(pt, descends, ownsTool, null);
+    const actions = new ActionsNode(pa, descends, () => deps.registry);
+    actions.onActivate.push(() => deps.activate(), () => tools.activate());
+    return { actions, deps, tools };
+  }, [pa, pd, pt, descends, ownsTool]);
+  useEffect(() => {
+    const leave = [nodes.deps.mount(), nodes.tools.mount(), nodes.actions.mount()];
+    return () => {
+      for (const f of leave) f();
+    };
+  }, [nodes]);
+  return nodes;
+}
+function Provide({ nodes, children }) {
+  return /* @__PURE__ */ jsx(DepRegistryContext.Provider, { value: nodes.deps.registry, children: /* @__PURE__ */ jsx(ActionsContext.Provider, { value: nodes.actions.registry, children: /* @__PURE__ */ jsx(ActiveToolNodeContext.Provider, { value: nodes.tools, children }) }) });
+}
+function InputScope({ yoke, children }) {
+  const nodes = useNodes(false, yoke === void 0, yoke);
+  return /* @__PURE__ */ jsx(Provide, { nodes, children });
+}
+function useYoke() {
+  return useNodes(true, true, void 0);
+}
+function Yoke({ value, children }) {
+  return /* @__PURE__ */ jsx(Provide, { nodes: value, children });
+}
 function useOngoingAction(actionId) {
   const reg = useActionsRegistry();
-  const regRef = useRef(reg);
-  regRef.current = reg;
-  const idRef = useRef(actionId);
-  idRef.current = actionId;
+  const regRef = useLatest(reg);
+  const idRef = useLatest(actionId);
   const ctrlRef = useRef(null);
   const edit = useMemo(() => {
     const end = (reason) => {
@@ -1221,51 +1273,43 @@ function useOngoingAction(actionId) {
         end("cancel");
       }
     };
-  }, []);
+  }, [regRef, idRef]);
   useEffect(() => () => edit.commit(), [edit, actionId]);
   return edit;
 }
 function useContributions(opts) {
   const ctx = useActiveToolContext();
   const actionsRegistry = useActionsRegistry();
-  const hasInitializedRef = useRef(false);
-  const isFirstRender = !hasInitializedRef.current;
-  const needsFirstMountSyncRef = useRef(false);
-  if (isFirstRender) {
-    hasInitializedRef.current = true;
-    needsFirstMountSyncRef.current = ctx.active === "select" && opts.focused !== "select";
-  }
+  const firstMountRef = useRef(null);
+  const isFirstRender = firstMountRef.current == null;
+  if (firstMountRef.current == null) firstMountRef.current = { sync: ctx.active === null && opts.focused !== null };
   useEffect(() => {
-    if (!needsFirstMountSyncRef.current) return;
-    needsFirstMountSyncRef.current = false;
+    const first = firstMountRef.current;
+    if (!first?.sync) return;
+    first.sync = false;
     ctx.setActive(opts.focused);
   }, []);
-  const focused = isFirstRender && ctx.active === "select" && opts.focused !== "select" ? opts.focused : ctx.active;
-  const entriesRef = useRef(opts.entries);
-  entriesRef.current = opts.entries;
-  const focusedRef = useRef(focused);
-  focusedRef.current = focused;
-  const engagedRef = useRef(ctx.hotkeyStack);
-  engagedRef.current = ctx.hotkeyStack;
+  const focused = isFirstRender && ctx.active === null && opts.focused !== null ? opts.focused : ctx.active;
+  const entries = useStableByContent(opts.entries, sameList);
+  const engaged = ctx.hotkeyStack;
   const setFocused = useCallback((id) => {
     ctx.setActive(id);
   }, [ctx]);
   const snapshot = useCallback(() => {
-    const engaged = engagedRef.current;
     const engagedIds = new Set(engaged);
     const ordered = [];
     for (const id of engaged) {
-      const entry = entriesRef.current.find((e) => e.id === id);
+      const entry = entries.find((e) => e.id === id);
       if (entry && !ordered.includes(entry)) ordered.push(entry);
     }
-    for (const entry of entriesRef.current) {
+    for (const entry of entries) {
       if (!ordered.includes(entry)) ordered.push(entry);
     }
     return {
       ordered,
-      state: { focusedId: focusedRef.current, engagedIds }
+      state: { focusedId: focused, engagedIds }
     };
-  }, []);
+  }, [entries, focused, engaged]);
   const scopedBindings = useCallback(() => {
     const { ordered, state } = snapshot();
     return scopeBindings(ordered, state);
@@ -1286,48 +1330,43 @@ function useContributions(opts) {
     }
     return [...active, ...hotkey, ...ambient];
   }, [snapshot]);
-  const offhandSig = opts.entries.map((e) => e.eligibility?.offhand ? `${e.id}:${e.eligibility.offhand}` : "").filter(Boolean).join(",");
-  useEffect(() => {
-    if (!actionsRegistry || offhandSig === "") return;
-    const specs = offhandSig.split(",").map((entry) => {
-      const [toolId, trigger] = entry.split(":");
-      return { toolId, key: offhandKeyFor(trigger) };
-    });
-    return actionsRegistry.register(makeToolOffhandAction(buildToolOffhandBindings(specs)));
-  }, [actionsRegistry, offhandSig]);
+  useOffhandAction(entries);
   const lastConflictSigRef = useRef(null);
-  const entrySig = opts.entries.map((e) => e.id).join(",");
+  const entrySig = entries.map((e) => e.id).join(",");
+  const modesRegistry = opts.modes;
   useEffect(() => {
     if (!isDev()) return;
-    if (lastConflictSigRef.current === entrySig) return;
-    lastConflictSigRef.current = entrySig;
+    const last = lastConflictSigRef.current;
+    if (last?.sig === entrySig && last.modes === modesRegistry) return;
+    lastConflictSigRef.current = { sig: entrySig, modes: modesRegistry };
     const registry = [];
     const ambient = [];
-    for (const entry of entriesRef.current) {
+    for (const entry of entries) {
       if (entry.eligibility?.focus) registry.push(entry);
       if (entry.eligibility?.always || entry.eligibility?.claimed) ambient.push(entry);
     }
     reportRouteConflicts({
       registry,
       ambient,
-      actions: actionsRegistry?.list() ?? []
+      actions: actionsRegistry?.list() ?? [],
+      ...modesRegistry ? { modes: modesRegistry.list().map(activeModeOf) } : {}
     });
-  }, [entrySig, actionsRegistry]);
+  }, [entrySig, entries, actionsRegistry, modesRegistry]);
   return useMemo(
-    () => ({
-      get entries() {
-        return entriesRef.current;
-      },
-      focused,
-      setFocused,
-      scopedBindings,
-      overlays
-    }),
-    [focused, setFocused, scopedBindings, overlays]
+    () => ({ entries, focused, setFocused, scopedBindings, overlays }),
+    [entries, focused, setFocused, scopedBindings, overlays]
   );
 }
-
-// src/tools/useTools.ts
+function useOffhandAction(entries) {
+  const actionsRegistry = useActionsRegistry();
+  const offhandSig = JSON.stringify(entries.filter((e) => e.eligibility?.offhand).map((e) => [e.id, e.eligibility.offhand]));
+  useEffect(() => {
+    const pairs = JSON.parse(offhandSig);
+    if (!actionsRegistry || pairs.length === 0) return;
+    const specs = pairs.map(([toolId, trigger]) => ({ toolId, key: offhandKeyFor(trigger) }));
+    return actionsRegistry.register(makeToolOffhandAction(buildToolOffhandBindings(specs)));
+  }, [actionsRegistry, offhandSig]);
+}
 function declareSlot(tool, slot) {
   const hotkey = tool.def?.hotkey;
   const eligibility = {
@@ -1337,6 +1376,18 @@ function declareSlot(tool, slot) {
   };
   return sameEligibility(tool.eligibility, eligibility) ? tool : { ...tool, eligibility };
 }
+var NO_AMBIENT = [];
+function useStableSources(registry, ambient) {
+  return useStableByContent(
+    { registry, ambient: ambient ?? NO_AMBIENT },
+    (a, b) => sameRecord(a.registry, b.registry) && sameList(a.ambient, b.ambient)
+  );
+}
+function sameRecord(a, b) {
+  const ak = Object.keys(a);
+  if (ak.length !== Object.keys(b).length) return false;
+  return ak.every((k) => k in b && a[k] === b[k]);
+}
 function sameEligibility(a, b) {
   if (!a) return false;
   const keys = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
@@ -1344,16 +1395,18 @@ function sameEligibility(a, b) {
   return true;
 }
 function useTools(opts) {
-  if (!(opts.active in opts.registry)) {
-    throw new Error(`useTools: active "${opts.active}" not in registry`);
+  const initialActive = opts.active ?? null;
+  if (initialActive !== null && !(initialActive in opts.registry)) {
+    throw new Error(`useTools: active "${initialActive}" not in registry`);
   }
   const ctx = useActiveToolContext();
+  const sources = useStableSources(opts.registry, opts.ambient);
   const slotted = useMemo(() => {
     const registry = {};
-    for (const [id, tool] of Object.entries(opts.registry)) {
+    for (const [id, tool] of Object.entries(sources.registry)) {
       registry[id] = declareSlot(tool, "focus");
     }
-    const ambient = (opts.ambient ?? []).map((t) => declareSlot(t, "always"));
+    const ambient = sources.ambient.map((t) => declareSlot(t, "always"));
     const byId = /* @__PURE__ */ new Map();
     for (const tool of [...Object.values(registry), ...ambient]) {
       const prior = byId.get(tool.id);
@@ -1361,25 +1414,26 @@ function useTools(opts) {
       else byId.set(tool.id, tool);
     }
     return { registry, ambient, entries: [...byId.values()] };
-  }, [opts.registry, opts.ambient]);
-  const contributions = useContributions({ entries: slotted.entries, focused: opts.active });
+  }, [sources]);
+  const contributions = useContributions({
+    entries: slotted.entries,
+    focused: initialActive,
+    ...opts.modes ? { modes: opts.modes } : {}
+  });
   const hotkeyEngaged = ctx.hotkeyStack.at(-1) ?? null;
-  const slottedRef = useRef(slotted);
-  slottedRef.current = slotted;
-  const activeRef = useRef(contributions.focused);
-  activeRef.current = contributions.focused;
-  const hotkeyRef = useRef(hotkeyEngaged);
-  hotkeyRef.current = hotkeyEngaged;
+  const slottedRef = useLatest(slotted);
+  const activeRef = useLatest(contributions.focused);
+  const hotkeyRef = useLatest(hotkeyEngaged);
   const setFocused = contributions.setFocused;
   const setActive = useCallback(
     (id) => {
-      if (!(id in slottedRef.current.registry)) {
+      if (id !== null && !(id in slottedRef.current.registry)) {
         throw new Error(`setActive: "${id}" not in registry`);
       }
       dlog("tools", "active:", activeRef.current, "\u2192", id);
       setFocused(id);
     },
-    [setFocused]
+    [setFocused, slottedRef, activeRef]
   );
   const engageHotkey = useCallback(
     (id) => {
@@ -1389,19 +1443,18 @@ function useTools(opts) {
       dlog("tools", "hotkey engaged:", id);
       ctx.pushHotkey(id);
     },
-    [ctx]
+    [ctx, slottedRef]
   );
   const disengageHotkey = useCallback(() => {
     if (hotkeyRef.current) dlog("tools", "hotkey disengaged:", hotkeyRef.current);
     ctx.popHotkey();
-  }, [ctx]);
+  }, [ctx, hotkeyRef]);
   const has = useCallback(
-    (id) => id in slottedRef.current.registry || slottedRef.current.ambient.some((t) => t.id === id),
-    []
+    (id) => id in slotted.registry || slotted.ambient.some((t) => t.id === id),
+    [slotted]
   );
   const active = contributions.focused;
   const getActiveOverlays = contributions.overlays;
-  const registryKey = Object.keys(slotted.registry).sort().join("|") + "#" + slotted.ambient.map((t) => t.id).join("|");
   return useMemo(
     () => ({
       active,
@@ -1409,18 +1462,15 @@ function useTools(opts) {
       hotkeyEngaged,
       engageHotkey,
       disengageHotkey,
-      ambient: slottedRef.current.ambient,
-      registry: slottedRef.current.registry,
+      ambient: slotted.ambient,
+      registry: slotted.registry,
       has,
       getActiveOverlays
     }),
-    // `registryKey` isn't read in the body on purpose: the body reads
-    // `slottedRef.current`, and the key is what tells us that ref's contents moved.
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [active, setActive, hotkeyEngaged, engageHotkey, disengageHotkey, has, getActiveOverlays, registryKey]
+    [active, setActive, hotkeyEngaged, engageHotkey, disengageHotkey, has, getActiveOverlays, slotted]
   );
 }
 
-export { ActionsProvider, ActionsScope, ActiveToolContextProvider, ActiveToolContextProviderIfRoot, DepRegistryProvider, useAction, useActionsRegistry, useActiveToolContext, useContributions, useDepRegistry, useDepSource, useGestureDispatcher, useOngoingAction, useOptionalActiveToolContext, useOptionalDepRegistry, useTools };
+export { ActionsProvider, ActiveToolContextProvider, ActiveToolContextProviderIfRoot, DepRegistryProvider, InputScope, Yoke, useAction, useActionsRegistry, useActiveToolContext, useContributions, useDepRegistry, useDepSource, useGestureDispatcher, useOffhandAction, useOngoingAction, useOptionalActiveToolContext, useOptionalDepRegistry, useTools, useYoke };
 //# sourceMappingURL=react.js.map
 //# sourceMappingURL=react.js.map