@weasel-js/routing 1.5.0

package/dist/react.js

@@ -0,0 +1,1304 @@
+import { createDispatcher, buildDepsFromRequires, validateActionId, validateActionDefaultBinding, scopeBindings, liveScope, offhandKeyFor, makeToolOffhandAction, buildToolOffhandBindings, isDev, reportRouteConflicts, dlog, isEditableTarget, clientToCanvasRect, openPointerSession, pointerGestureId, itemsFromDataTransfer, itemsFromClipboardData } from './chunk-Y5FHAA4U.js';
+import { createContext, useState, useCallback, useMemo, useContext, useRef, useEffect } from 'react';
+import { jsx, Fragment } from 'react/jsx-runtime';
+import { resolveCursorTier } from '@weasel-js/cursor';
+
+var ActiveToolContext = createContext(null);
+function ActiveToolContextProvider({
+  children,
+  initialActive = "select"
+}) {
+  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]
+  );
+  return /* @__PURE__ */ jsx(ActiveToolContext.Provider, { value, children });
+}
+function useActiveToolContext() {
+  const value = useContext(ActiveToolContext);
+  if (value === null) {
+    throw new Error(
+      "useActiveToolContext: no ActiveToolContextProvider in scope. Wrap your tree with <ActiveToolContextProvider> (typically inside <SceneCanvas>)."
+    );
+  }
+  return value;
+}
+function useOptionalActiveToolContext() {
+  return useContext(ActiveToolContext);
+}
+function ActiveToolContextProviderIfRoot({
+  children
+}) {
+  const parent = useContext(ActiveToolContext);
+  if (parent !== null) return /* @__PURE__ */ jsx(Fragment, { children });
+  return /* @__PURE__ */ jsx(ActiveToolContextProvider, { children });
+}
+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)?.()
+  }), []);
+  return /* @__PURE__ */ jsx(DepRegistryContext.Provider, { value: registry, children });
+}
+function useDepRegistry() {
+  const r = useContext(DepRegistryContext);
+  if (r === null) {
+    throw new Error("useDepRegistry: no DepRegistryProvider in scope. Wrap your tree with <DepRegistryProvider> (typically inside <SceneCanvas>).");
+  }
+  return r;
+}
+function useOptionalDepRegistry() {
+  return useContext(DepRegistryContext);
+}
+function useDepSource(name, source) {
+  const registry = useDepRegistry();
+  const sourceRef = useRef(source);
+  sourceRef.current = source;
+  useEffect(() => {
+    return registry.register(name, () => sourceRef.current());
+  }, [name, registry]);
+}
+var DROPOVER_CLASS = "weasel-dropover";
+function stylusOf(e) {
+  return {
+    ...typeof e.pressure === "number" ? { pressure: e.pressure } : {},
+    ...typeof e.tiltX === "number" ? { tiltX: e.tiltX } : {},
+    ...typeof e.tiltY === "number" ? { tiltY: e.tiltY } : {}
+  };
+}
+var IS_MAC = typeof navigator !== "undefined" && /mac/i.test(
+  // `||`, not `??`: jsdom (and some embedders) report an empty-string
+  // platform, which is not nullish and would swallow the UA fallback.
+  navigator.platform || navigator.userAgent
+);
+function withViewDeps(base, overlay) {
+  return {
+    register: (name, source) => base().register(name, source),
+    get: (name) => {
+      const own = overlay()?.[name];
+      if (own !== void 0) return own;
+      return base().get(name);
+    }
+  };
+}
+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 };
+}
+function useGestureDispatcher(opts) {
+  const { canvasRef, actions, toolsById, enabled = true, keyboard = true, affordanceAt, classifyTarget, dispatcher: dispatcherOpt, clientToWorld, requestRedraw, paintedCursor, getRuleCtx, onDoubleClick, views } = opts;
+  const onDoubleClickRef = useRef(onDoubleClick);
+  onDoubleClickRef.current = onDoubleClick;
+  const activeTool = useActiveToolContext();
+  const depRegistry = useDepRegistry();
+  const dispatcherRef = useRef(null);
+  if (!dispatcherRef.current) {
+    dispatcherRef.current = dispatcherOpt ?? createDispatcher();
+  }
+  const ctxRef = useRef({
+    actions,
+    depRegistry,
+    activeToolId: activeTool.active,
+    hotkeyStack: activeTool.hotkeyStack,
+    toolsById,
+    isMac: IS_MAC
+  });
+  ctxRef.current = {
+    actions,
+    depRegistry,
+    activeToolId: activeTool.active,
+    hotkeyStack: activeTool.hotkeyStack,
+    toolsById,
+    isMac: IS_MAC
+  };
+  const rootTargetRef = useRef({
+    id: null,
+    dispatcher: dispatcherRef.current,
+    affordanceAt,
+    classifyTarget,
+    clientToWorld,
+    getRuleCtx
+  });
+  rootTargetRef.current = {
+    id: null,
+    dispatcher: dispatcherRef.current,
+    affordanceAt,
+    classifyTarget,
+    clientToWorld,
+    getRuleCtx
+  };
+  const viewsRef = useRef(views);
+  viewsRef.current = views;
+  const allDispatchers = () => [
+    rootTargetRef.current.dispatcher,
+    ...(viewsRef.current?.targets() ?? []).map((t) => t.dispatcher)
+  ];
+  const requestRedrawRef = useRef(requestRedraw);
+  requestRedrawRef.current = requestRedraw;
+  const paintedCursorRef = useRef(paintedCursor);
+  paintedCursorRef.current = paintedCursor;
+  const lastClickRef = useRef(null);
+  const prevActiveRef = useRef(activeTool.active);
+  useEffect(() => {
+    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;
+  });
+  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
+    });
+    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 Set();
+    const held = /* @__PURE__ */ new Map();
+    const toCanvasLocal = (p) => {
+      const rect = canvas?.getBoundingClientRect();
+      if (!rect) return p;
+      const [x, y] = clientToCanvasRect(rect, p.x, p.y);
+      return { x, y };
+    };
+    const heldGeometry = () => {
+      const { centroid, spread } = computeMultiTouchGeometry(
+        [...held.values()].map((p) => p.pos)
+      );
+      return { centroid: toCanvasLocal(centroid), spread };
+    };
+    let multiTouchStart = null;
+    const TAP_THRESHOLD_PX = 8;
+    const DRAG_THRESHOLD_PX = 4;
+    const LONG_PRESS_MS = 500;
+    const longPressTimers = /* @__PURE__ */ new Map();
+    const cancelLongPress = (pointerId) => {
+      const t = longPressTimers.get(pointerId);
+      if (t !== void 0) {
+        clearTimeout(t);
+        longPressTimers.delete(pointerId);
+      }
+    };
+    const cancelAllLongPress = () => {
+      for (const t of longPressTimers.values()) clearTimeout(t);
+      longPressTimers.clear();
+    };
+    const fireLongPress = (pointerId) => {
+      const down = held.get(pointerId)?.down;
+      if (!down) return;
+      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 result = dispatch({
+        kind: "longpress",
+        x: down.worldX,
+        y: down.worldY,
+        clientX: down.clientX,
+        clientY: down.clientY,
+        ...shared
+      });
+      if (result === "unhandled") {
+        dispatch({
+          kind: "contextmenu",
+          worldX: down.worldX,
+          worldY: down.worldY,
+          ...shared
+        });
+      }
+    };
+    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)) {
+        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.add(e.key);
+      }
+      if (keyResult === "handled" || heldResult === "handled") {
+        e.preventDefault();
+      }
+    };
+    const onKeyUp = (e) => {
+      if (!heldKeys.has(e.key)) return;
+      const ev = {
+        kind: "key-held",
+        key: e.key,
+        phase: "up",
+        altKey: e.altKey,
+        ctrlKey: e.ctrlKey,
+        metaKey: e.metaKey,
+        shiftKey: e.shiftKey
+      };
+      dispatch(ev);
+      heldKeys.delete(e.key);
+    };
+    const onWindowBlur = () => {
+      for (const p of [...held.values()]) p.session.cancel();
+      for (const key of heldKeys) {
+        const ev = {
+          kind: "key-held",
+          key,
+          phase: "up",
+          altKey: false,
+          ctrlKey: false,
+          metaKey: false,
+          shiftKey: false
+        };
+        dispatch(ev);
+      }
+      heldKeys.clear();
+    };
+    const onWheel = (e) => {
+      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.stopPropagation();
+      }
+    };
+    const onPointerDown = (e) => {
+      if ((e.button ?? 0) !== 0) return;
+      if (!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
+        }
+      });
+      dispatch({ ...ev, stage: "press" });
+      if ((e.pointerType === "touch" || e.pointerType === "pen") && held.size === 1) {
+        cancelLongPress(e.pointerId);
+        longPressTimers.set(
+          e.pointerId,
+          setTimeout(() => {
+            longPressTimers.delete(e.pointerId);
+            if (disposed) return;
+            fireLongPress(e.pointerId);
+          }, LONG_PRESS_MS)
+        );
+      }
+      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) {
+        const dx = e.clientX - buffered.clientX;
+        const dy = e.clientY - buffered.clientY;
+        if (Math.hypot(dx, dy) >= DRAG_THRESHOLD_PX) {
+          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 predicted = dispatcherNow().resolveOnly(
+        {
+          kind: "pointerdown",
+          x: w.x,
+          y: w.y,
+          clientX: h.clientX,
+          clientY: h.clientY,
+          altKey: h.altKey,
+          ctrlKey: h.ctrlKey,
+          metaKey: h.metaKey,
+          shiftKey: h.shiftKey,
+          ...affordance !== void 0 ? { affordance } : {},
+          ...bodyTarget !== void 0 ? { bodyTarget } : {},
+          ...bodyKind !== void 0 ? { bodyKind } : {}
+        },
+        ctxNow()
+      );
+      applyHoverCursor(predicted?.action.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;
+      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,
+          worldX: wClick.x,
+          worldY: wClick.y,
+          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);
+        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,
+            worldX: wClick.x,
+            worldY: wClick.y,
+            ...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 });
+          dispatch(dblEv);
+          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,
+        worldX: w.x,
+        worldY: w.y,
+        ...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();
+    };
+    if (keyboard) {
+      window.addEventListener("keydown", onKeyDown);
+      window.addEventListener("keyup", onKeyUp);
+    }
+    window.addEventListener("blur", onWindowBlur);
+    window.addEventListener("keydown", scheduleHoverCursorRefresh);
+    window.addEventListener("keyup", scheduleHoverCursorRefresh);
+    canvas?.addEventListener("pointerleave", onHoverPointerLeave);
+    canvas?.addEventListener("wheel", onWheel, { passive: false });
+    canvas?.addEventListener("pointerdown", onPointerDown);
+    canvas?.addEventListener("pointermove", onHoverMove);
+    canvas?.addEventListener("contextmenu", onContextMenu);
+    canvas?.addEventListener("dragenter", onDragOver);
+    canvas?.addEventListener("dragover", onDragOver);
+    canvas?.addEventListener("dragleave", onDragLeave);
+    canvas?.addEventListener("drop", onDrop);
+    window.addEventListener("paste", onPaste);
+    return () => {
+      if (keyboard) {
+        window.removeEventListener("keydown", onKeyDown);
+        window.removeEventListener("keyup", onKeyUp);
+      }
+      window.removeEventListener("blur", onWindowBlur);
+      window.removeEventListener("keydown", scheduleHoverCursorRefresh);
+      window.removeEventListener("keyup", scheduleHoverCursorRefresh);
+      canvas?.removeEventListener("pointerleave", onHoverPointerLeave);
+      canvas?.removeEventListener("wheel", onWheel);
+      canvas?.removeEventListener("pointerdown", onPointerDown);
+      canvas?.removeEventListener("pointermove", onHoverMove);
+      canvas?.removeEventListener("contextmenu", onContextMenu);
+      canvas?.removeEventListener("dragenter", onDragOver);
+      canvas?.removeEventListener("dragover", onDragOver);
+      canvas?.removeEventListener("dragleave", onDragLeave);
+      canvas?.removeEventListener("drop", onDrop);
+      window.removeEventListener("paste", onPaste);
+      canvas?.classList.remove(DROPOVER_CLASS);
+      clearHoverCursor();
+      cancelAllLongPress();
+      disposed = true;
+      for (const p of held.values()) p.session.cancel();
+      held.clear();
+      for (const d of allDispatchers()) d.cancelAll("cancel");
+    };
+  }, [enabled, keyboard, canvasRef]);
+}
+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);
+        }
+      }
+    };
+    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);
+  };
+}
+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"),
+              pointer: r.get("pointer"),
+              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"),
+          pointer: r.get("pointer"),
+          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>."
+  );
+}
+var IS_DEV = (() => {
+  try {
+    return Boolean(import.meta.env?.DEV);
+  } catch {
+    return false;
+  }
+})();
+function useActionsRegistry() {
+  return useContext(ActionsContext);
+}
+function useAction(action) {
+  const reg = useActionsRegistry();
+  useEffect(() => {
+    if (!reg) {
+      if (IS_DEV) {
+        console.warn(
+          `useAction("${action.id}"): no <ActionsProvider> is in scope, so the action was not registered and its bindings will never fire.`
+        );
+      }
+      return;
+    }
+    return reg.register(action);
+  }, [reg, action]);
+}
+var NO_TRIGGERS = /* @__PURE__ */ new Set();
+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";
+  }
+  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 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 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);
+      if (entry && !ordered.includes(entry)) ordered.push(entry);
+    }
+    for (const entry of entriesRef.current) {
+      if (!ordered.includes(entry)) ordered.push(entry);
+    }
+    return {
+      ordered,
+      state: { focusedId: focusedRef.current, heldTriggers: NO_TRIGGERS, engagedIds }
+    };
+  }, []);
+  const scopedBindings = useCallback(() => {
+    const { ordered, state } = snapshot();
+    return scopeBindings(ordered, state);
+  }, [snapshot]);
+  const overlays = useCallback((position = "top") => {
+    const { ordered, state } = snapshot();
+    const active = [];
+    const hotkey = [];
+    const ambient = [];
+    for (const entry of ordered) {
+      if (!entry.overlay) continue;
+      if ((entry.overlayPosition ?? "top") !== position) continue;
+      const layers = Array.isArray(entry.overlay) ? entry.overlay : [entry.overlay];
+      const scope = liveScope(entry.id, entry.eligibility ?? {}, state);
+      if (scope === "active") active.push(...layers);
+      else if (scope === "hotkey") hotkey.push(...layers);
+      else if (scope === "ambient") ambient.push(...layers);
+    }
+    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]);
+  const lastConflictSigRef = useRef(null);
+  const entrySig = opts.entries.map((e) => e.id).join(",");
+  useEffect(() => {
+    if (!isDev()) return;
+    if (lastConflictSigRef.current === entrySig) return;
+    lastConflictSigRef.current = entrySig;
+    const registry = [];
+    const ambient = [];
+    for (const entry of entriesRef.current) {
+      if (entry.eligibility?.focus) registry.push(entry);
+      if (entry.eligibility?.always || entry.eligibility?.claimed) ambient.push(entry);
+    }
+    reportRouteConflicts({
+      registry,
+      ambient,
+      actions: actionsRegistry?.list() ?? []
+    });
+  }, [entrySig, actionsRegistry]);
+  return useMemo(
+    () => ({
+      get entries() {
+        return entriesRef.current;
+      },
+      focused,
+      setFocused,
+      scopedBindings,
+      overlays
+    }),
+    [focused, setFocused, scopedBindings, overlays]
+  );
+}
+
+// src/tools/useTools.ts
+function declareSlot(tool, slot) {
+  const hotkey = tool.def?.hotkey;
+  const eligibility = {
+    ...tool.eligibility,
+    [slot]: true,
+    ...hotkey ? { offhand: hotkey } : {}
+  };
+  return sameEligibility(tool.eligibility, eligibility) ? tool : { ...tool, eligibility };
+}
+function sameEligibility(a, b) {
+  if (!a) return false;
+  const keys = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
+  for (const key of keys) if (a[key] !== b[key]) return false;
+  return true;
+}
+function useTools(opts) {
+  if (!(opts.active in opts.registry)) {
+    throw new Error(`useTools: active "${opts.active}" not in registry`);
+  }
+  const ctx = useActiveToolContext();
+  const slotted = useMemo(() => {
+    const registry = {};
+    for (const [id, tool] of Object.entries(opts.registry)) {
+      registry[id] = declareSlot(tool, "focus");
+    }
+    const ambient = (opts.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);
+      if (prior) byId.set(tool.id, { ...tool, eligibility: { ...prior.eligibility, ...tool.eligibility } });
+      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 });
+  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 setFocused = contributions.setFocused;
+  const setActive = useCallback(
+    (id) => {
+      if (!(id in slottedRef.current.registry)) {
+        throw new Error(`setActive: "${id}" not in registry`);
+      }
+      dlog("tools", "active:", activeRef.current, "\u2192", id);
+      setFocused(id);
+    },
+    [setFocused]
+  );
+  const engageHotkey = useCallback(
+    (id) => {
+      if (!(id in slottedRef.current.registry)) {
+        throw new Error(`engageHotkey: "${id}" not in registry`);
+      }
+      dlog("tools", "hotkey engaged:", id);
+      ctx.pushHotkey(id);
+    },
+    [ctx]
+  );
+  const disengageHotkey = useCallback(() => {
+    if (hotkeyRef.current) dlog("tools", "hotkey disengaged:", hotkeyRef.current);
+    ctx.popHotkey();
+  }, [ctx]);
+  const has = useCallback(
+    (id) => id in slottedRef.current.registry || slottedRef.current.ambient.some((t) => t.id === id),
+    []
+  );
+  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,
+      setActive,
+      hotkeyEngaged,
+      engageHotkey,
+      disengageHotkey,
+      ambient: slottedRef.current.ambient,
+      registry: slottedRef.current.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]
+  );
+}
+
+export { ActionsProvider, ActionsScope, ActiveToolContextProvider, ActiveToolContextProviderIfRoot, DepRegistryProvider, useAction, useActionsRegistry, useActiveToolContext, useContributions, useDepRegistry, useDepSource, useGestureDispatcher, useOptionalActiveToolContext, useOptionalDepRegistry, useTools };
+//# sourceMappingURL=react.js.map
+//# sourceMappingURL=react.js.map