@weasel-js/routing 1.6.0 → 1.7.0

package/dist/react.js

@@ -1,37 +1,80 @@
-import { createDispatcher, buildDepsFromRequires, validateActionId, validateActionDefaultBinding, scopeBindings, liveScope, offhandKeyFor, makeToolOffhandAction, buildToolOffhandBindings, isDev, reportRouteConflicts, dlog, isEditableTarget, clientToCanvasRect, openPointerSession, pointerGestureId, itemsFromDataTransfer, itemsFromClipboardData } from './chunk-D2TZLDP5.js';
-import { createContext, useState, useCallback, useMemo, useContext, useRef, useEffect } from 'react';
+import { createDepRegistry, createDispatcher, scopeBindings, liveScope, isDev, reportRouteConflicts, offhandKeyFor, makeToolOffhandAction, buildToolOffhandBindings, dlog, isTool, isEditableTarget, clientToCanvasRect, openPointerSession, publishLiveDispatch, pointerGestureId, itemsFromDataTransfer, itemsFromClipboardData, ScopeNode, pushOwner, validateActionId, validateActionDefaultBinding, depNodeOf, DepNode, buildDepsFromRequires } from './chunk-Q3Y3DPKH.js';
+import { createContext, useState, useContext, useMemo, useRef, useEffect, useCallback, useSyncExternalStore } from '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 +83,7 @@ function useActiveToolContext() {
   return value;
 }
 function useOptionalActiveToolContext() {
-  return useContext(ActiveToolContext);
+  return useNodeValue(useContext(ActiveToolContext));
 }
 function ActiveToolContextProviderIfRoot({
   children
@@ -51,28 +94,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() {
@@ -134,7 +156,7 @@ 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 } = opts;
   const pointerChannel = channels?.pointer !== false;
   const wheelChannel = channels?.wheel !== false;
   const pinchChannel = channels?.pinch !== false;
@@ -148,12 +170,14 @@ function useGestureDispatcher(opts) {
   if (!dispatcherRef.current) {
     dispatcherRef.current = dispatcherOpt ?? createDispatcher();
   }
+  const registryRef = useRef(actions);
+  registryRef.current = actions;
   const ctxRef = useRef({
     actions,
     depRegistry,
     activeToolId: activeTool.active,
     hotkeyStack: activeTool.hotkeyStack,
-    toolsById,
+    entriesById,
     isMac: IS_MAC
   });
   ctxRef.current = {
@@ -161,7 +185,7 @@ function useGestureDispatcher(opts) {
     depRegistry,
     activeToolId: activeTool.active,
     hotkeyStack: activeTool.hotkeyStack,
-    toolsById,
+    entriesById,
     isMac: IS_MAC
   };
   const rootTargetRef = useRef({
@@ -191,25 +215,39 @@ function useGestureDispatcher(opts) {
   const paintedCursorRef = useRef(paintedCursor);
   paintedCursorRef.current = paintedCursor;
   const lastClickRef = useRef(null);
+  const liveToolsRef = useRef(/* @__PURE__ */ new Set());
   const prevActiveRef = useRef(activeTool.active);
+  const entriesByIdRef = useRef(entriesById);
+  entriesByIdRef.current = entriesById;
+  const fireLifecycle = (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);
+    }
+  };
   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");
+  }, []);
   useEffect(() => {
     if (!enabled) return;
     let disposed = false;
@@ -233,7 +271,8 @@ function useGestureDispatcher(opts) {
     const ctxNow = () => ({
       ...ctxRef.current,
       depRegistry: routedDeps,
-      getRuleCtx: routedRuleCtx
+      getRuleCtx: routedRuleCtx,
+      viewId: target().id
     });
     const canvas = canvasRef.current;
     const toWorld = (cx, cy) => {
@@ -248,7 +287,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();
@@ -272,7 +312,6 @@ 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 cancelLongPress = (pointerId) => {
@@ -321,8 +360,9 @@ function useGestureDispatcher(opts) {
     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;
       }
@@ -347,17 +387,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,
@@ -365,12 +407,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,
@@ -385,6 +427,7 @@ function useGestureDispatcher(opts) {
       heldKeys.clear();
     };
     const onWheel = (e) => {
+      registryRef.current.activate();
       if (pinchLive && e.ctrlKey) {
         e.preventDefault();
         e.stopPropagation();
@@ -468,6 +511,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);
@@ -560,9 +604,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);
@@ -670,10 +712,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
@@ -699,6 +748,7 @@ function useGestureDispatcher(opts) {
     };
     const onHoverPointerLeave = () => {
       lastHover = null;
+      publishLiveDispatch(null);
       paintedCursorRef.current?.()?.clearPointer();
       clearHoverCursor();
     };
@@ -911,9 +961,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);
@@ -939,8 +990,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);
@@ -969,203 +1020,152 @@ function useGestureDispatcher(opts) {
   }, [enabled, keyboard, canvasRef, pointerChannel, wheelChannel, pinchChannel, contextMenuChannel, ingestChannel]);
 }
 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 node = useMemo(() => new ActionsNode(null, true, () => depRegRef.current), []);
+  return /* @__PURE__ */ jsx(ActionsContext.Provider, { value: node.registry, children });
 }
 var IS_DEV = (() => {
   try {
@@ -1191,6 +1191,41 @@ 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);
@@ -1232,14 +1267,14 @@ function useContributions(opts) {
   const needsFirstMountSyncRef = useRef(false);
   if (isFirstRender) {
     hasInitializedRef.current = true;
-    needsFirstMountSyncRef.current = ctx.active === "select" && opts.focused !== "select";
+    needsFirstMountSyncRef.current = ctx.active === null && opts.focused !== null;
   }
   useEffect(() => {
     if (!needsFirstMountSyncRef.current) return;
     needsFirstMountSyncRef.current = false;
     ctx.setActive(opts.focused);
   }, []);
-  const focused = isFirstRender && ctx.active === "select" && opts.focused !== "select" ? opts.focused : ctx.active;
+  const focused = isFirstRender && ctx.active === null && opts.focused !== null ? opts.focused : ctx.active;
   const entriesRef = useRef(opts.entries);
   entriesRef.current = opts.entries;
   const focusedRef = useRef(focused);
@@ -1285,21 +1320,15 @@ 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(opts.entries);
   const lastConflictSigRef = useRef(null);
   const entrySig = opts.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) {
@@ -1309,9 +1338,10 @@ function useContributions(opts) {
     reportRouteConflicts({
       registry,
       ambient,
-      actions: actionsRegistry?.list() ?? []
+      actions: actionsRegistry?.list() ?? [],
+      ...modesRegistry ? { modes: modesRegistry.list().map(activeModeOf) } : {}
     });
-  }, [entrySig, actionsRegistry]);
+  }, [entrySig, actionsRegistry, modesRegistry]);
   return useMemo(
     () => ({
       get entries() {
@@ -1325,6 +1355,16 @@ function useContributions(opts) {
     [focused, setFocused, scopedBindings, overlays]
   );
 }
+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]);
+}
 
 // src/tools/useTools.ts
 function declareSlot(tool, slot) {
@@ -1336,6 +1376,24 @@ function declareSlot(tool, slot) {
   };
   return sameEligibility(tool.eligibility, eligibility) ? tool : { ...tool, eligibility };
 }
+var NO_AMBIENT = [];
+function useStableSources(registry, ambient) {
+  const next = { registry, ambient: ambient ?? NO_AMBIENT };
+  const ref = useRef(next);
+  const prev = ref.current;
+  if (prev !== next && !(sameRecord(prev.registry, next.registry) && sameList(prev.ambient, next.ambient))) {
+    ref.current = next;
+  }
+  return ref.current;
+}
+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 sameList(a, b) {
+  return a.length === b.length && a.every((t, i) => t === b[i]);
+}
 function sameEligibility(a, b) {
   if (!a) return false;
   const keys = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
@@ -1343,16 +1401,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);
@@ -1360,8 +1420,12 @@ 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;
@@ -1372,7 +1436,7 @@ function useTools(opts) {
   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);
@@ -1400,7 +1464,6 @@ function useTools(opts) {
   );
   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,
@@ -1408,18 +1471,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