@weasel-js/labkit 0.7.2 → 1.0.0

package/dist/{chunk-5XDFILHZ.js → chunk-XVBXYKFJ.js}

@@ -16,11 +16,12 @@ var GESTURE_DESCRIPTORS = [
   { name: "pointerDown", hasTarget: true },
   { name: "dblTap", hasTarget: true },
   { name: "drag", hasTarget: true },
-  { name: "wheel", hasTarget: false, arg: { name: "direction", values: ["up", "down", "*"], default: "*" } },
+  { name: "wheel", hasTarget: true, arg: { name: "direction", values: ["up", "down", "*"], default: "*" } },
   { name: "keyDown", hasTarget: false, arg: { name: "key", values: "free" } },
   { name: "keyUp", hasTarget: false, arg: { name: "key", values: "free" } },
   { name: "keyHeld", hasTarget: false, arg: { name: "key", values: "free" } },
   { name: "contextMenu", hasTarget: true },
+  { name: "longPress", hasTarget: true },
   { name: "multiTouchTap", hasTarget: false, arg: { name: "fingers", values: ["2", "3", "4"] } }
 ];
 var BY_NAME = new Map(
@@ -318,6 +319,8 @@ function actionClause(parsed, required) {
       return `the user taps with ${parsed.arg ?? "multiple"} fingers`;
     case "contextMenu":
       return `the user ${modPrefix}opens the context menu${target}`;
+    case "longPress":
+      return `the user ${modPrefix}presses and holds${target}`;
     case "click":
       return `the user ${modPrefix}clicks${target}`;
     case "pointerDown":
@@ -385,12 +388,12 @@ function checkKey(req, held) {
   if (req === "forbidden") return !held;
   return true;
 }
-function matchKey(eventKey, specKey) {
+function matchKey(eventKey, specKey2) {
   const lower = eventKey.toLowerCase();
-  if (Array.isArray(specKey)) {
-    return specKey.some((k) => k.toLowerCase() === lower);
+  if (Array.isArray(specKey2)) {
+    return specKey2.some((k) => k.toLowerCase() === lower);
   }
-  return specKey.toLowerCase() === lower;
+  return specKey2.toLowerCase() === lower;
 }
 function affordanceKindOf(target) {
   if (typeof target !== "object" || target === null) return void 0;
@@ -485,7 +488,7 @@ function matchSpec(e, spec, isMac, phaseCtx) {
       const direction = spec.direction ?? "*";
       if (direction === "up" && !(e.deltaY < 0)) return false;
       if (direction === "down" && !(e.deltaY > 0)) return false;
-      return true;
+      return matchTarget(e.affordance, spec.target, e.bodyTarget, e.bodyKind);
     }
     case "click": {
       if (e.kind !== "click") return false;
@@ -495,12 +498,17 @@ function matchSpec(e, spec, isMac, phaseCtx) {
     case "doubleClick": {
       if (e.kind !== "doubleclick") return false;
       if (!matchModifiers(e, spec.mods, isMac)) return false;
-      return matchTarget(e.target, spec.target, e.bodyTarget, e.bodyKind);
+      return matchTarget(e.affordance, spec.target, e.bodyTarget, e.bodyKind);
     }
     case "contextMenu": {
       if (e.kind !== "contextmenu") return false;
       if (!matchModifiers(e, spec.mods, isMac)) return false;
-      return matchTarget(e.target, spec.target, e.bodyTarget, e.bodyKind);
+      return matchTarget(e.affordance, spec.target, e.bodyTarget, e.bodyKind);
+    }
+    case "longPress": {
+      if (e.kind !== "longpress") return false;
+      if (!matchModifiers(e, spec.mods, isMac)) return false;
+      return matchTarget(e.affordance, spec.target, e.bodyTarget, e.bodyKind);
     }
     case "drag": {
       if (e.kind !== "pointerdown") return false;
@@ -539,8 +547,6 @@ function matchSpec(e, spec, isMac, phaseCtx) {
   }
 }
 var EMPTY_ENGAGED = /* @__PURE__ */ new Set();
-
-// ../core/dist/chunk-SYM6RAM4.js
 var routing_exports = {};
 __export(routing_exports, {
   GESTURE_DESCRIPTORS: () => GESTURE_DESCRIPTORS,
@@ -589,7 +595,11 @@ function defineTool(def) {
   };
   return {
     id: def.id,
-    capabilities: def.capabilities,
+    eligibility: {
+      focus: true,
+      capabilities: def.capabilities,
+      ...def.hotkey ? { offhand: def.hotkey } : {}
+    },
     actions: def.actions,
     def,
     presentation: def.presentation,
@@ -613,6 +623,7 @@ var SPEC_KIND_TO_GESTURE = {
   click: "click",
   doubleClick: "dblTap",
   contextMenu: "contextMenu",
+  longPress: "longPress",
   drag: "drag",
   pointerDown: "pointerDown",
   multiTouch: void 0,
@@ -674,6 +685,255 @@ function argOf(spec, fallback) {
   if ("direction" in spec) return spec.direction ?? fallback;
   return fallback;
 }
+var DepRegistryContext = createContext(null);
+function DepRegistryProvider({ children }) {
+  const sourcesRef = useRef(/* @__PURE__ */ new Map());
+  const registry4 = useMemo(() => ({
+    register: (name, source) => {
+      sourcesRef.current.set(name, source);
+      return () => {
+        sourcesRef.current.delete(name);
+      };
+    },
+    get: (name) => sourcesRef.current.get(name)?.()
+  }), []);
+  return /* @__PURE__ */ jsx(DepRegistryContext.Provider, { value: registry4, 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 registry4 = useDepRegistry();
+  const sourceRef = useRef(source);
+  sourceRef.current = source;
+  useEffect(() => {
+    return registry4.register(name, () => sourceRef.current());
+  }, [name, registry4]);
+}
+var DEV = (() => {
+  try {
+    return Boolean(import.meta.env?.DEV);
+  } catch {
+    return false;
+  }
+})();
+function buildDepsFromRequires(action, depRegistry) {
+  const requires = action.requires ?? [];
+  const entries = requires.map((name) => [name, depRegistry.get(name)]);
+  const deps = Object.fromEntries(entries);
+  if (DEV) {
+    const declared = new Set(requires);
+    return new Proxy(deps, {
+      get(target, prop, receiver) {
+        if (typeof prop === "string" && !declared.has(prop) && prop !== "then") {
+          const message = `[weasel:dispatcher] action "${action.id}" read deps.${prop} but did not declare it in \`requires\`. Add \`requires: [...'${prop}']\` to the descriptor or the dep will be undefined at runtime.`;
+          console.warn(message);
+          throw new Error(message);
+        }
+        return Reflect.get(target, prop, receiver);
+      }
+    });
+  }
+  return deps;
+}
+function actionBindings(action) {
+  const gs = action.defaultBinding;
+  if (!gs) return [];
+  const raw = Array.isArray(gs) ? gs : [gs];
+  return raw.map((entry) => {
+    const isBoundObj = !("kind" in entry);
+    const spec = isBoundObj ? entry.spec : entry;
+    const opts = isBoundObj ? entry.opts : void 0;
+    return { spec, actionId: action.id, ...opts !== void 0 ? { opts } : {} };
+  });
+}
+var ActionDisabledReason = {
+  SelectionRequired: "selection-required",
+  NotApplicable: "not-applicable",
+  /** Sentinel: the predicate threw. Surfaced by `evaluateEnabled`'s catch. */
+  PredicateThrew: "predicate-threw"
+};
+var enabledSlowWarned = /* @__PURE__ */ new Set();
+var enabledThrewWarned = /* @__PURE__ */ new Set();
+var ENABLED_BUDGET_MS = 4;
+function evaluateEnabled(action, deps) {
+  if (!action.enabled) return { enabled: true };
+  const isDev = typeof process !== "undefined" ? process.env.NODE_ENV !== "production" : true;
+  const now = typeof performance !== "undefined" && typeof performance.now === "function" ? () => performance.now() : () => Date.now();
+  const start = isDev ? now() : 0;
+  try {
+    const result = action.enabled(deps);
+    if (isDev) {
+      const elapsed = now() - start;
+      if (elapsed > ENABLED_BUDGET_MS && !enabledSlowWarned.has(action.id)) {
+        enabledSlowWarned.add(action.id);
+        console.warn(
+          `weasel actions: enabled() for action "${action.id}" took ${elapsed.toFixed(2)}ms (budget ${ENABLED_BUDGET_MS}ms). The predicate must be pure and fast \u2014 see Action.enabled JSDoc.`
+        );
+      }
+    }
+    if (result === true) return { enabled: true };
+    return { enabled: false, reason: result };
+  } catch (e) {
+    if (isDev && !enabledThrewWarned.has(action.id)) {
+      enabledThrewWarned.add(action.id);
+      console.warn(
+        `weasel actions: enabled() for action "${action.id}" threw; treating as disabled. The predicate must not throw \u2014 see Action.enabled JSDoc.`,
+        e
+      );
+    }
+    return { enabled: false, reason: ActionDisabledReason.PredicateThrew };
+  }
+}
+function validateActionId(id) {
+  if (id.length === 0) {
+    throw new Error(`weasel: action id may not be empty`);
+  }
+  if (RESERVED_ID_PREFIXES.has(id[0])) {
+    throw new Error(
+      `weasel: action id "${id}" starts with reserved sigil "${id[0]}" (reserved set: ${[...RESERVED_ID_PREFIXES].join(" ")})`
+    );
+  }
+  if (RESERVED_ID_NAMES.has(id)) {
+    throw new Error(
+      `weasel: action id "${id}" collides with a reserved phase keyword (reserved: ${[...RESERVED_ID_NAMES].join(", ")})`
+    );
+  }
+}
+function validateActionDefaultBinding(action) {
+  const gs = action.defaultBinding;
+  if (!gs) return;
+  const entries = Array.isArray(gs) ? gs : [gs];
+  for (const entry of entries) {
+    const spec = "kind" in entry ? entry : entry.spec;
+    const phase = spec.phase;
+    if (phase === void 0) continue;
+    const atoms = Array.isArray(phase) ? phase : [{ channel: "&", phase }];
+    for (const atom of atoms) {
+      if (atom.channel === "&") {
+        throw new Error(
+          `weasel: action "${action.id}" defaultBinding uses '&' channel which has no owning tool to resolve to. Use a named tool channel (e.g. '[rect:engaged]') or '*' instead, or move this binding to the tool's own Tool.bindings.`
+        );
+      }
+    }
+  }
+}
+var ActionsContext = createContext(null);
+function ActionsProvider({ children }) {
+  const actionsRef = useRef(/* @__PURE__ */ new Map());
+  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 wiredDepRegRef = useRef(null);
+  const dispatcherRef = useRef(null);
+  const registry4 = useMemo(() => {
+    const snapshot = () => {
+      const v = versionRef.current;
+      if (cachedVerRef.current === v) return cachedRef.current;
+      const out = Object.freeze(Array.from(actionsRef.current.values()));
+      cachedRef.current = out;
+      cachedVerRef.current = v;
+      return out;
+    };
+    const notify2 = () => {
+      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);
+        actionsRef.current.set(action.id, action);
+        versionRef.current++;
+        notify2();
+        return () => {
+          const cur = actionsRef.current.get(action.id);
+          if (cur === action) {
+            actionsRef.current.delete(action.id);
+            versionRef.current++;
+            notify2();
+          }
+        };
+      },
+      unregister: (id) => {
+        if (actionsRef.current.delete(id)) {
+          versionRef.current++;
+          notify2();
+        }
+      },
+      list: () => snapshot(),
+      trigger: (id, params) => {
+        const a = actionsRef.current.get(id);
+        if (!a) return false;
+        try {
+          if (a.invoker && a.invoker.timing === "immediate") {
+            const r = wiredDepRegRef.current ?? 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) => {
+        dispatcherRef.current = d;
+      },
+      setDepRegistry: (r) => {
+        wiredDepRegRef.current = r;
+      },
+      begin: (id, params) => {
+        const disp = dispatcherRef.current;
+        if (!disp) return null;
+        const r = wiredDepRegRef.current ?? depRegRef.current;
+        const deps = 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);
+      }
+    };
+  }, []);
+  return /* @__PURE__ */ jsx(ActionsContext.Provider, { value: registry4, children });
+}
+function useActionsRegistry() {
+  return useContext(ActionsContext);
+}
 function findConflicts(tools) {
   const entries = buildRouteRegistry(tools);
   const groups = /* @__PURE__ */ new Map();
@@ -715,9 +975,15 @@ function predicateId(pred) {
   }
   return id;
 }
+function actionAsTool(action) {
+  return { id: action.id, eligibility: {}, bindings: actionBindings(action) };
+}
 function findScopedConflicts(scopes) {
   const registry4 = Array.isArray(scopes.registry) ? scopes.registry : Object.values(scopes.registry);
-  const ambient = scopes.ambient ?? [];
+  const actions = scopes.actions ?? [];
+  const ambientActions = actions.filter((a) => a.scope !== "hotkey").map(actionAsTool);
+  const hotkeyActions = actions.filter((a) => a.scope === "hotkey").map(actionAsTool);
+  const ambient = [...scopes.ambient ?? [], ...ambientActions];
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   const add = (conflicts) => {
@@ -728,12 +994,13 @@ function findScopedConflicts(scopes) {
       out.push(c);
     }
   };
-  for (const tool of [...registry4, ...ambient]) add(findConflicts([tool]));
+  for (const tool of [...registry4, ...scopes.ambient ?? []]) add(findConflicts([tool]));
   if (ambient.length > 1) add(findConflicts(ambient));
-  const hotkeyTools = registry4.filter(
-    (t) => t.def?.hotkey !== void 0
-  );
-  if (hotkeyTools.length > 1) add(findConflicts(hotkeyTools));
+  const hotkey = [
+    ...registry4.filter((t) => t.def?.hotkey !== void 0),
+    ...hotkeyActions
+  ];
+  if (hotkey.length > 1) add(findConflicts(hotkey));
   return out;
 }
 function formatConflict(conflict) {
@@ -873,7 +1140,7 @@ function transformCoords(coords, m) {
   return out;
 }
 
-// ../core/dist/chunk-CQNKCG34.js
+// ../core/dist/chunk-6SHZHXXR.js
 function resolveUnit(v, unitSystem) {
   if (typeof v === "number") return v;
   if (!unitSystem) {
@@ -1444,6 +1711,28 @@ var RECT_POSE_DESCRIPTOR = {
   translate: RECT_POSE_DESCRIPTOR.translate,
   intersectsRect: RECT_POSE_DESCRIPTOR.intersectsRect,
   lerp: RECT_POSE_DESCRIPTOR.lerp});
+function remapRotatedLeaf(pose, src, dst) {
+  const sx = src.width === 0 ? 1 : dst.width / src.width;
+  const sy = src.height === 0 ? 1 : dst.height / src.height;
+  const theta = pose.rotation ?? 0;
+  const cos = Math.cos(theta);
+  const sin = Math.sin(theta);
+  const ux = sx * cos, uy = sy * sin;
+  const vx = -sx * sin, vy = sy * cos;
+  const width = pose.width * Math.hypot(ux, uy);
+  const height = pose.height * Math.hypot(vx, vy);
+  const rotation = Math.atan2(uy, ux);
+  const cxNew = dst.x + (pose.x + pose.width / 2 - src.x) * sx;
+  const cyNew = dst.y + (pose.y + pose.height / 2 - src.y) * sy;
+  return {
+    ...pose,
+    x: cxNew - width / 2,
+    y: cyNew - height / 2,
+    width,
+    height,
+    rotation
+  };
+}
 var pathPoseDescriptor = {
   getBounds: (path) => boundsOfPath(path),
   remapBounds: (path, src, dst) => {
@@ -1540,14 +1829,29 @@ var RECT_ORIGIN_PROJECTION = {
   getOrigin: (p) => ({ x: p.x, y: p.y }),
   translate: (p, dx, dy) => ({ ...p, x: p.x + dx, y: p.y + dy })
 };
-function meanScale(s) {
-  return Math.sqrt(s.x * s.y);
+var MIN_SCALE = 1e-9;
+function pxExtent(px, scale2) {
+  return {
+    x: px / Math.max(MIN_SCALE, Math.abs(scale2.x)),
+    y: px / Math.max(MIN_SCALE, Math.abs(scale2.y))
+  };
+}
+function scaleDelta(dx, dy, scale2) {
+  return { x: dx * scale2.x, y: dy * scale2.y };
+}
+function withinPxBox(dx, dy, px, scale2) {
+  const s = scaleDelta(dx, dy, scale2);
+  return Math.abs(s.x) <= px && Math.abs(s.y) <= px;
+}
+function withinPxRadius(dx, dy, px, scale2) {
+  const s = scaleDelta(dx, dy, scale2);
+  return s.x * s.x + s.y * s.y <= px * px;
 }
 
 // ../core/dist/chunk-GVCNT7UH.js
 var FACTORIES = /* @__PURE__ */ new Map();
-function registerOpFactory(name, build) {
-  FACTORIES.set(name, build);
+function registerOpFactory(name, build2) {
+  FACTORIES.set(name, build2);
 }
 function rebuildOp(name, args) {
   const f = FACTORIES.get(name);
@@ -1584,7 +1888,7 @@ function createDeleteOp(args) {
 }
 registerOpFactory("delete", (args) => createDeleteOp(args));
 
-// ../core/dist/chunk-VOVKONXA.js
+// ../core/dist/chunk-UB6A6L77.js
 function createTransformOp(args) {
   const { id, from, to, label, coalesceKey = `transform:${id}` } = args;
   return {
@@ -1665,7 +1969,7 @@ function snap(strategy, opts = {}) {
   };
 }
 
-// ../core/dist/chunk-BGGZ4CVF.js
+// ../core/dist/chunk-Z3KNFTTS.js
 function lockAspectWithModifier(opts = {}) {
   const { key = "shift" } = opts;
   return {
@@ -1861,13 +2165,165 @@ function materializePaste(adapter, snapshot, opts) {
   return { ops, newIds, created };
 }
 
-// ../core/dist/chunk-Y52N27PF.js
+// ../core/dist/chunk-IO5Z75X4.js
+var counter = 0;
 var registry = /* @__PURE__ */ new Map();
 function getTexture(id) {
   return registry.get(id) ?? null;
 }
-
-// ../font/dist/index.js
+function registerTexture(image) {
+  const id = `tex_${++counter}`;
+  registry.set(id, { source: image });
+  return { id };
+}
+function tileSize(spec) {
+  if (spec.size !== void 0) return spec.size;
+  switch (spec.tile) {
+    case "hatch":
+      return 5;
+    case "crosshatch":
+      return 6;
+    case "dots":
+      return 6;
+    case "chunks":
+      return 48;
+    default:
+      return 8;
+  }
+}
+function mulberry32(seed) {
+  let s = seed | 0;
+  return () => {
+    s = s + 1831565813 | 0;
+    let t = Math.imul(s ^ s >>> 15, 1 | s);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function tileGeometry(spec) {
+  const s = tileSize(spec);
+  const { color } = spec;
+  switch (spec.tile) {
+    case "hatch": {
+      const width = spec.lineWidth ?? 1;
+      return { size: s, shapes: forwardDiagonals(s, width, color) };
+    }
+    case "crosshatch": {
+      const width = spec.lineWidth ?? 0.8;
+      return {
+        size: s,
+        shapes: [...forwardDiagonals(s, width, color), ...backwardDiagonals(s, width, color)]
+      };
+    }
+    case "dots": {
+      const r = spec.radius ?? 1;
+      return { size: s, shapes: [{ kind: "circle", cx: s / 2, cy: s / 2, r, color }] };
+    }
+    case "chunks": {
+      const density = spec.density ?? 0.35;
+      const chunkSize = spec.chunkSize ?? 3;
+      const rand = mulberry32(spec.seed ?? 42);
+      const count = Math.round(s * s * density / (chunkSize * chunkSize));
+      const shapes = [];
+      if (spec.bg !== void 0) {
+        shapes.push({ kind: "rect", x: 0, y: 0, width: s, height: s, color: spec.bg });
+      }
+      for (let i = 0; i < count; i++) {
+        const cx = rand() * s;
+        const cy = rand() * s;
+        const w = chunkSize * (0.5 + rand());
+        const h = chunkSize * (0.5 + rand());
+        const rotation = rand() * Math.PI;
+        shapes.push({ kind: "ellipse", cx, cy, rx: w / 2, ry: h / 2, rotation, color });
+      }
+      return { size: s, shapes };
+    }
+    default:
+      return { size: s, shapes: [] };
+  }
+}
+function forwardDiagonals(s, width, color) {
+  return [
+    { kind: "line", x1: -1, y1: s + 1, x2: s + 1, y2: -1, width, color },
+    { kind: "line", x1: -1, y1: 1, x2: 1, y2: -1, width, color },
+    { kind: "line", x1: s - 1, y1: s + 1, x2: s + 1, y2: s - 1, width, color }
+  ];
+}
+function backwardDiagonals(s, width, color) {
+  return [
+    { kind: "line", x1: -1, y1: -1, x2: s + 1, y2: s + 1, width, color },
+    { kind: "line", x1: s - 1, y1: -1, x2: s + 1, y2: 1, width, color },
+    { kind: "line", x1: -1, y1: s - 1, x2: 1, y2: s + 1, width, color }
+  ];
+}
+function drawTileShapes(oc, geometry) {
+  for (const shape of geometry.shapes) {
+    if (shape.kind === "line") {
+      oc.strokeStyle = shape.color;
+      oc.lineWidth = shape.width;
+      oc.beginPath();
+      oc.moveTo(shape.x1, shape.y1);
+      oc.lineTo(shape.x2, shape.y2);
+      oc.stroke();
+      continue;
+    }
+    oc.fillStyle = shape.color;
+    if (shape.kind === "rect") {
+      oc.fillRect(shape.x, shape.y, shape.width, shape.height);
+      continue;
+    }
+    oc.beginPath();
+    if (shape.kind === "circle") {
+      oc.arc(shape.cx, shape.cy, shape.r, 0, Math.PI * 2);
+    } else {
+      oc.ellipse(shape.cx, shape.cy, shape.rx, shape.ry, shape.rotation, 0, Math.PI * 2);
+    }
+    oc.fill();
+  }
+}
+function createTilePattern(opts) {
+  let off;
+  try {
+    off = new OffscreenCanvas(opts.size, opts.size);
+  } catch {
+    if (typeof document === "undefined") return null;
+    const c = document.createElement("canvas");
+    c.width = opts.size;
+    c.height = opts.size;
+    off = c;
+  }
+  const oc = off.getContext("2d");
+  if (!oc) return null;
+  opts.draw(oc, opts.size);
+  let bitmap;
+  if (typeof off.transferToImageBitmap === "function") {
+    bitmap = off.transferToImageBitmap();
+  } else {
+    return null;
+  }
+  return registerTexture(bitmap);
+}
+function build(spec) {
+  const geometry = tileGeometry(spec);
+  return createTilePattern({
+    size: tileSize(spec),
+    draw: (oc) => drawTileShapes(oc, geometry)
+  });
+}
+function hatch(params) {
+  return build({ tile: "hatch", ...params });
+}
+function crosshatch(params) {
+  return build({ tile: "crosshatch", ...params });
+}
+function dots(params) {
+  return build({ tile: "dots", ...params });
+}
+function chunks(params) {
+  return build({ tile: "chunks", ...params });
+}
+
+// ../font/dist/index.js
 var subscribers = /* @__PURE__ */ new Set();
 var generation = 0;
 function glyphGeneration() {
@@ -2003,8 +2459,8 @@ function alphaToSdf(alpha, width, height, radius, cutoff) {
   edt2d(gridInner, width, height, f, d, v, z);
   const out = new Uint8Array(n);
   for (let i = 0; i < n; i++) {
-    const dist4 = Math.sqrt(gridOuter[i]) - Math.sqrt(gridInner[i]);
-    const byte = Math.round(255 - 255 * (dist4 / radius + cutoff));
+    const dist3 = Math.sqrt(gridOuter[i]) - Math.sqrt(gridInner[i]);
+    const byte = Math.round(255 - 255 * (dist3 / radius + cutoff));
     out[i] = byte < 0 ? 0 : byte > 255 ? 255 : byte;
   }
   return out;
@@ -2210,17 +2666,17 @@ function dynamicPageTextureId(page) {
   return `weasel-dyn-sdf-page-${page}`;
 }
 var uploadedVersions = /* @__PURE__ */ new WeakMap();
-function syncDynamicPageTexture(cache5, pageIndex) {
+function syncDynamicPageTexture(cache7, pageIndex) {
   const page = pages[pageIndex];
   if (!page) return false;
   const id = dynamicPageTextureId(pageIndex);
-  let seen = uploadedVersions.get(cache5);
+  let seen = uploadedVersions.get(cache7);
   if (!seen) {
     seen = /* @__PURE__ */ new Map();
-    uploadedVersions.set(cache5, seen);
+    uploadedVersions.set(cache7, seen);
   }
-  if (!cache5.has(id)) {
-    cache5.uploadR8(id, PAGE_SIZE, PAGE_SIZE, page.data);
+  if (!cache7.has(id)) {
+    cache7.uploadR8(id, PAGE_SIZE, PAGE_SIZE, page.data);
     seen.set(pageIndex, page.version);
     return true;
   }
@@ -2233,7 +2689,7 @@ function syncDynamicPageTexture(cache5, pageIndex) {
       const src = (patch.y + row) * PAGE_SIZE + patch.x;
       tight.set(page.data.subarray(src, src + patch.w), row * patch.w);
     }
-    cache5.subImageR8(id, patch.x, patch.y, patch.w, patch.h, tight);
+    cache7.subImageR8(id, patch.x, patch.y, patch.w, patch.h, tight);
   }
   seen.set(pageIndex, page.version);
   return true;
@@ -2441,6 +2897,23 @@ var slots = /* @__PURE__ */ new Map();
 function slotKey(family, weight, style) {
   return `${family}|${weight}|${style}`;
 }
+function closeContours(d) {
+  let out = "";
+  let start = 0;
+  for (let i = 1; i < d.length; i++) {
+    const c = d[i];
+    if (c !== "M" && c !== "m") continue;
+    out += closeOne(d.slice(start, i));
+    start = i;
+  }
+  return out + closeOne(d.slice(start));
+}
+function closeOne(contour) {
+  const trimmed = contour.trimEnd();
+  if (trimmed.length === 0) return "";
+  const last = trimmed[trimmed.length - 1];
+  return last === "Z" || last === "z" ? trimmed : `${trimmed}Z`;
+}
 function glyphOutline(family, weight, style, cp) {
   const slot = slots.get(slotKey(family, weight, style));
   if (!slot) return null;
@@ -2453,7 +2926,8 @@ function glyphOutline(family, weight, style, cp) {
   if (cached2 !== void 0) return cached2;
   let d = null;
   try {
-    d = slot.face.glyphD(cp);
+    const raw = slot.face.glyphD(cp);
+    d = raw === null ? null : closeContours(raw);
   } catch (err) {
     warnOnce(
       `glyph|${slotKey(family, weight, style)}`,
@@ -2612,8 +3086,8 @@ function eligibleForMode(mode, toolTags) {
   }
   return false;
 }
-function eligibleTool(reg, tool) {
-  return eligibleForMode(reg.current(), tool.capabilities ?? []);
+function eligibleContribution(reg, entry) {
+  return eligibleForMode(reg.current(), entry.eligibility?.capabilities ?? []);
 }
 
 // ../history/dist/index.js
@@ -2982,7 +3456,7 @@ function serialToEntry(se, custom, logger) {
   };
 }
 
-// ../core/dist/chunk-5F3PIERN.js
+// ../core/dist/chunk-D2C6K6FO.js
 function worldToScreen(worldX, worldY, view) {
   return [view.panX + worldX * view.zoom.x, view.panY + worldY * view.zoom.y];
 }
@@ -3233,6 +3707,58 @@ var GRAD_FILL_UNIFORMS = [
   "u_gradAngle"
 ];
 var GRAD_FILL_ATTRIBUTES = ["a_position"];
+var PATTERN_VERT_SRC = (
+  /* glsl */
+  `#version 300 es
+in vec2 a_position;
+uniform mat3 u_proj;
+uniform mat3 u_model;
+uniform mat3 u_worldInv;
+out vec2 v_world;
+void main() {
+  vec3 screen = u_model * vec3(a_position, 1.0);
+  vec3 clip   = u_proj  * vec3(screen.xy, 1.0);
+  gl_Position = vec4(clip.xy, 0.0, 1.0);
+  vec3 world = u_worldInv * vec3(screen.xy, 1.0);
+  v_world = world.xy;
+}
+`
+);
+var PATTERN_FRAG_SRC = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+in vec2 v_world;
+uniform sampler2D u_sampler;
+uniform vec2  u_tileOrigin;
+uniform vec2  u_tileSize;
+uniform float u_opacity;
+uniform float u_alpha;
+uniform mat4  u_colorMatrix;
+uniform vec4  u_colorBias;
+out vec4 outColor;
+void main() {
+  vec2 uv = (v_world - u_tileOrigin) / max(u_tileSize, vec2(0.0001));
+  vec4 texel = texture(u_sampler, uv);
+  vec4 mapped = clamp(u_colorMatrix * texel + u_colorBias, 0.0, 1.0);
+  float a = mapped.a * u_opacity * u_alpha;
+  outColor = vec4(mapped.rgb * a, a);
+}
+`
+);
+var PATTERN_FILL_UNIFORMS = [
+  "u_proj",
+  "u_model",
+  "u_worldInv",
+  "u_sampler",
+  "u_tileOrigin",
+  "u_tileSize",
+  "u_opacity",
+  "u_alpha",
+  "u_colorMatrix",
+  "u_colorBias"
+];
+var PATTERN_FILL_ATTRIBUTES = ["a_position"];
 var GLMeshCache = class {
   constructor(gl, aPositionLoc) {
     this.gl = gl;
@@ -3355,17 +3881,20 @@ var GLTextureCache = class {
   has(id) {
     return this.map.has(id);
   }
-  upload(id, source) {
+  /** Uploads once per id; `wrap` therefore applies on first upload only.
+   *  An id is either a pattern tile or a shader texture, never both. */
+  upload(id, source, wrap = "clamp") {
     if (this.map.has(id)) return id;
     const gl = this.gl;
     const tex = gl.createTexture();
     if (!tex) throw new Error(`GLTextureCache: createTexture failed for id="${id}"`);
+    const wrapMode = wrap === "repeat" ? gl.REPEAT : gl.CLAMP_TO_EDGE;
     gl.bindTexture(gl.TEXTURE_2D, tex);
     gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, source);
     gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
     gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, wrapMode);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, wrapMode);
     gl.bindTexture(gl.TEXTURE_2D, null);
     this.map.set(id, tex);
     return id;
@@ -3960,6 +4489,18 @@ function scale(m, sx, sy) {
   const s = create(sx, 0, 0, sy, 0, 0);
   return multiply2(m, s);
 }
+function invert(m) {
+  const a = m[0], b = m[1];
+  const c = m[3], d = m[4];
+  const tx = m[6], ty = m[7];
+  const det = a * d - b * c;
+  if (det === 0 || !Number.isFinite(det)) return identity();
+  const ia = d / det;
+  const ib = -b / det;
+  const ic = -c / det;
+  const id = a / det;
+  return create(ia, ib, ic, id, -(ia * tx + ic * ty), -(ib * tx + id * ty));
+}
 function apply(m, x, y) {
   const a = m[0], b = m[1];
   const c = m[3], d = m[4];
@@ -3987,6 +4528,7 @@ var mat3 = {
   multiply: multiply2,
   translate: translate2,
   scale,
+  invert,
   apply,
   screenToClip
 };
@@ -4355,6 +4897,16 @@ function extractPolygon(p, opts) {
     out.push(next);
     return next;
   };
+  const dropDuplicateClosingPoint = () => {
+    if (!pts || !aA || !aB || !aT) return;
+    const n = pts.length / 2;
+    if (n < 2) return;
+    if (pts[0] !== pts[(n - 1) * 2] || pts[1] !== pts[(n - 1) * 2 + 1]) return;
+    pts.length -= 2;
+    aA.length -= 1;
+    aB.length -= 1;
+    aT.length -= 1;
+  };
   const commit = (target) => {
     if (!pts || !aA || !aB || !aT) return;
     target.anchorA = new Uint32Array(aA);
@@ -4438,7 +4990,10 @@ function extractPolygon(p, opts) {
         break;
       }
       case PATH_Z2: {
-        if (current) current.closed = true;
+        if (current) {
+          current.closed = true;
+          dropDuplicateClosingPoint();
+        }
         break;
       }
       default:
@@ -4919,8 +5474,20 @@ function sameFill(a, b) {
   }
   return false;
 }
-function groupKey(family, weight, style, synthetic, fill, source, page) {
-  return `${family}|${weight}|${style}|${synthetic.bold ? 1 : 0}${synthetic.italic ? 1 : 0}|${fillKey(fill)}|${source}|${page}`;
+function strokeKey(s) {
+  if (!s) return "-";
+  return [
+    fillKey(s.paint),
+    s.width ?? 1,
+    s.join ?? "miter",
+    s.cap ?? "butt",
+    s.miterLimit ?? "",
+    s.align ?? "center",
+    (s.dash ?? []).join(",")
+  ].join(":");
+}
+function groupKey(family, weight, style, synthetic, fill, stroke, source, page) {
+  return `${family}|${weight}|${style}|${synthetic.bold ? 1 : 0}${synthetic.italic ? 1 : 0}|${fillKey(fill)}|${strokeKey(stroke)}|${source}|${page}`;
 }
 function getOrCreateGroup(ctx, run, resolved, page, sourceOverride) {
   const atlasFamily = resolved.resolved.family;
@@ -4933,6 +5500,7 @@ function getOrCreateGroup(ctx, run, resolved, page, sourceOverride) {
     resolvedStyle,
     resolved.synthetic,
     run.fill,
+    source === "outline" ? run.stroke : void 0,
     source,
     page
   );
@@ -4946,6 +5514,9 @@ function getOrCreateGroup(ctx, run, resolved, page, sourceOverride) {
       source,
       page,
       fill: run.fill,
+      // Only the outline tier can paint it, and carrying it on an SDF group
+      // would be a promise the renderer cannot keep.
+      ...source === "outline" && run.stroke !== void 0 ? { stroke: run.stroke } : {},
       quads: [],
       glyphs: []
     };
@@ -5542,6 +6113,34 @@ function outlineMesh(key, d) {
   cache3.set(key, mesh);
   return mesh;
 }
+var OUTLINE_STROKE_MESH_CACHE_LIMIT = 2048;
+var WIDTH_QUANTUM = 1 / 1024;
+var cache4 = /* @__PURE__ */ new Map();
+function quantizeEmWidth(emWidth) {
+  return Math.round(emWidth / WIDTH_QUANTUM) * WIDTH_QUANTUM;
+}
+function outlineStrokeMesh(glyphKey, d, emWidth, stroke) {
+  if (!(emWidth > 0)) return null;
+  const key = [
+    glyphKey,
+    emWidth,
+    stroke.join ?? "miter",
+    stroke.cap ?? "butt",
+    stroke.miterLimit ?? "",
+    stroke.align ?? "center",
+    (stroke.dash ?? []).join(",")
+  ].join("|");
+  const cached2 = cache4.get(key);
+  if (cached2 !== void 0) return cached2.indices.length === 0 ? null : cached2;
+  if (cache4.size >= OUTLINE_STROKE_MESH_CACHE_LIMIT) cache4 = /* @__PURE__ */ new Map();
+  const mesh = tessellateStroke(
+    pathFromD(d),
+    { ...stroke, width: emWidth },
+    { flattenTolerance: OUTLINE_FLATTEN_TOLERANCE }
+  );
+  cache4.set(key, mesh);
+  return mesh.indices.length === 0 ? null : mesh;
+}
 function setColorMatrixUniforms(ctx, prog) {
   const gl = ctx.gl;
   const cm = ctx.state.colorMatrix;
@@ -5832,28 +6431,42 @@ function drawPathFillPattern(ctx, fill, handle) {
     if (isDev3) console.warn(`weasel: pattern TextureHandle "${tex.id}" not registered`);
     return;
   }
-  ctx.textureCache.upload(tex.id, entry.source);
+  ctx.textureCache.upload(tex.id, entry.source, "repeat");
   const gl = ctx.gl;
-  gl.useProgram(ctx.imageFill.handle);
+  gl.useProgram(ctx.patternFill.handle);
   gl.bindVertexArray(handle.vao);
-  setProjAndModel(ctx, ctx.imageFill);
-  setColorMatrixUniforms(ctx, ctx.imageFill);
+  setProjAndModel(ctx, ctx.patternFill);
+  setColorMatrixUniforms(ctx, ctx.patternFill);
+  gl.uniformMatrix3fv(ctx.patternFill.uniform("u_worldInv"), false, gradientSpaceInverse(ctx, fill.units));
+  const [tw, th] = textureSize(entry.source);
+  const origin = fill.origin ?? { x: 0, y: 0 };
+  gl.uniform2f(ctx.patternFill.uniform("u_tileOrigin"), origin.x, origin.y);
+  gl.uniform2f(ctx.patternFill.uniform("u_tileSize"), tw, th);
   ctx.textureCache.bind(tex.id, 0);
-  gl.uniform1i(ctx.imageFill.uniform("u_sampler"), 0);
-  gl.uniform1f(ctx.imageFill.uniform("u_opacity"), fill.opacity ?? 1);
-  gl.uniform1f(ctx.imageFill.uniform("u_alpha"), ctx.state.alpha);
+  gl.uniform1i(ctx.patternFill.uniform("u_sampler"), 0);
+  gl.uniform1f(ctx.patternFill.uniform("u_opacity"), fill.opacity ?? 1);
+  gl.uniform1f(ctx.patternFill.uniform("u_alpha"), ctx.state.alpha);
   applyClipTest(ctx);
   gl.drawElements(gl.TRIANGLES, handle.indexCount, gl.UNSIGNED_INT, 0);
   gl.bindVertexArray(null);
 }
+function textureSize(source) {
+  const w = "naturalWidth" in source ? source.naturalWidth : source.width;
+  const h = "naturalHeight" in source ? source.naturalHeight : source.height;
+  return [w || 1, h || 1];
+}
+function gradientSpaceInverse(ctx, units) {
+  if (units === "local") return mat3.invert(ctx.state.transform);
+  if (units === "world" && ctx.viewMatrix) return mat3.invert(ctx.viewMatrix);
+  return mat3.identity();
+}
 function drawPathFillGradient(ctx, fill, handle) {
   const gl = ctx.gl;
   const key = ctx.gradRampCache.upload(fill.stops);
   gl.useProgram(ctx.gradFill.handle);
   gl.bindVertexArray(handle.vao);
   setProjAndModel(ctx, ctx.gradFill);
-  const identity3 = new Float32Array([1, 0, 0, 0, 1, 0, 0, 0, 1]);
-  gl.uniformMatrix3fv(ctx.gradFill.uniform("u_worldInv"), false, identity3);
+  gl.uniformMatrix3fv(ctx.gradFill.uniform("u_worldInv"), false, gradientSpaceInverse(ctx, fill.units));
   ctx.gradRampCache.bind(key, 0);
   gl.uniform1i(ctx.gradFill.uniform("u_ramp"), 0);
   gl.uniform1f(ctx.gradFill.uniform("u_alpha"), ctx.state.alpha);
@@ -6115,16 +6728,30 @@ function drawText(ctx, cmd) {
 var SYNTHETIC_ITALIC_RADIANS = 0.2094;
 function drawTextOutlineGroup(ctx, group, dy) {
   const mesh = outlineGroupMesh(group, dy);
-  if (!mesh) return;
-  drawPathFillByKind(ctx, group.fill, ctx.meshCache.uploadTransient(mesh));
+  if (mesh) drawPathFillByKind(ctx, group.fill, ctx.meshCache.uploadTransient(mesh));
+  if (!group.stroke) return;
+  const strokeMesh = outlineGroupStrokeMesh(group, dy);
+  if (strokeMesh) {
+    drawPathFillByKind(ctx, group.stroke.paint, ctx.meshCache.uploadTransient(strokeMesh));
+  }
 }
 function outlineGroupMesh(group, dy) {
+  return mergeGlyphMeshes(group, dy, (glyph) => outlineMesh(glyph.key, glyph.d));
+}
+function outlineGroupStrokeMesh(group, dy) {
+  const stroke = group.stroke;
+  if (!stroke) return null;
+  const width = stroke.width ?? 1;
+  if (!(width > 0)) return null;
+  return mergeGlyphMeshes(group, dy, (glyph) => glyph.scale > 0 ? outlineStrokeMesh(glyph.key, glyph.d, quantizeEmWidth(width / glyph.scale), stroke) : null);
+}
+function mergeGlyphMeshes(group, dy, meshFor) {
   const parts = [];
   let vertexFloats = 0;
   let indexCount = 0;
   for (const glyph of group.glyphs) {
-    const mesh = outlineMesh(glyph.key, glyph.d);
-    if (mesh.indices.length === 0) continue;
+    const mesh = meshFor(glyph);
+    if (!mesh || mesh.indices.length === 0) continue;
     parts.push({ mesh, glyph });
     vertexFloats += mesh.vertices.length;
     indexCount += mesh.indices.length;
@@ -6359,6 +6986,11 @@ function drawImage(ctx, cmd) {
   setProjAndModel(ctx, ctx.imageFill);
   setColorMatrixUniforms(ctx, ctx.imageFill);
   ctx.imageCache.bind(cmd.image, 0);
+  gl.texParameteri(
+    gl.TEXTURE_2D,
+    gl.TEXTURE_MAG_FILTER,
+    cmd.sampling === "nearest" ? gl.NEAREST : gl.LINEAR
+  );
   gl.uniform1i(ctx.imageFill.uniform("u_sampler"), 0);
   gl.uniform1f(ctx.imageFill.uniform("u_opacity"), cmd.opacity ?? 1);
   gl.uniform1f(ctx.imageFill.uniform("u_alpha"), ctx.state.alpha);
@@ -6445,6 +7077,7 @@ var WeaselRenderer = class {
   textSdfR8;
   imageFill;
   gradFill;
+  patternFill;
   meshCache;
   textureCache;
   imageCache;
@@ -6520,6 +7153,9 @@ var WeaselRenderer = class {
     this.gradFill = new ShaderProgram(this.gl, GRAD_VERT_SRC, GRAD_FRAG_SRC);
     this.gradFill.lookupUniforms(GRAD_FILL_UNIFORMS);
     this.gradFill.lookupAttributes(GRAD_FILL_ATTRIBUTES);
+    this.patternFill = new ShaderProgram(this.gl, PATTERN_VERT_SRC, PATTERN_FRAG_SRC);
+    this.patternFill.lookupUniforms(PATTERN_FILL_UNIFORMS);
+    this.patternFill.lookupAttributes(PATTERN_FILL_ATTRIBUTES);
     const aPos = this.pathFill.attribute("a_position");
     if (aPos === void 0) throw new Error("WeaselRenderer: a_position not found in path-fill shader");
     this.meshCache = new GLMeshCache(this.gl, aPos);
@@ -6628,6 +7264,9 @@ var WeaselRenderer = class {
     this.gradFill = new ShaderProgram(this.gl, GRAD_VERT_SRC, GRAD_FRAG_SRC);
     this.gradFill.lookupUniforms(GRAD_FILL_UNIFORMS);
     this.gradFill.lookupAttributes(GRAD_FILL_ATTRIBUTES);
+    this.patternFill = new ShaderProgram(this.gl, PATTERN_VERT_SRC, PATTERN_FRAG_SRC);
+    this.patternFill.lookupUniforms(PATTERN_FILL_UNIFORMS);
+    this.patternFill.lookupAttributes(PATTERN_FILL_ATTRIBUTES);
     const aPos = this.pathFill.attribute("a_position");
     if (aPos === void 0) throw new Error("a_position missing after restore");
     this.meshCache = new GLMeshCache(this.gl, aPos);
@@ -6699,7 +7338,15 @@ var WeaselRenderer = class {
     if (this.rectIbo) gl.deleteBuffer(this.rectIbo);
     if (this.rectVao) gl.deleteVertexArray(this.rectVao);
   }
-  render(commands) {
+  /**
+   * Draw one frame.
+   *
+   * `viewMatrix` is the frame's world→screen transform. It is only consulted
+   * by `units: 'world'` gradients, which fall back to screen space without
+   * it — every other command carries its own transform in the stream, so
+   * callers with no view concept can keep calling `render(commands)`.
+   */
+  render(commands, viewMatrix) {
     if (this.contextLost || this.disposed) return;
     const gl = this.gl;
     this.meshCache.drainPendingDeletes();
@@ -6714,6 +7361,7 @@ var WeaselRenderer = class {
       textSdfR8: this.textSdfR8,
       imageFill: this.imageFill,
       gradFill: this.gradFill,
+      patternFill: this.patternFill,
       meshCache: this.meshCache,
       textureCache: this.textureCache,
       imageCache: this.imageCache,
@@ -6728,7 +7376,8 @@ var WeaselRenderer = class {
       heightCss: this.heightCss,
       clipDepth: 0,
       flattenTolerance: this.flattenTolerance,
-      textOutlineMinScreenSize: this.textOutlineMinScreenSize
+      textOutlineMinScreenSize: this.textOutlineMinScreenSize,
+      viewMatrix
     };
     for (const cmd of commands) dispatch(ctx, cmd);
     this.meshCache.freeTransient();
@@ -6776,6 +7425,10 @@ var WeaselRenderer = class {
     return this.gradFill;
   }
   /** @internal */
+  _patternFill() {
+    return this.patternFill;
+  }
+  /** @internal */
   _meshCache() {
     return this.meshCache;
   }
@@ -6836,6 +7489,9 @@ function alignedStrokeRect(rect, align, width = 1) {
     height: rect.height + 2 * d
   };
 }
+function meanScale(s) {
+  return Math.sqrt(s.x * s.y);
+}
 var DEFAULT_LINE = {
   paint: { fill: "solid", color: "rgba(255, 255, 255, 0.08)" },
   width: 1
@@ -6964,289 +7620,148 @@ function clientToCanvas(canvas, clientX, clientY) {
 function clientToCanvasRect(rect, clientX, clientY) {
   return [clientX - rect.left, clientY - rect.top];
 }
-function zoomAt(view, anchor, factor, opts) {
-  const fx = typeof factor === "number" ? factor : factor.x;
-  const fy = typeof factor === "number" ? factor : factor.y;
-  const minX = typeof opts?.min === "number" ? opts.min : opts?.min?.x ?? 0.1;
-  const minY = typeof opts?.min === "number" ? opts.min : opts?.min?.y ?? 0.1;
-  const maxX = typeof opts?.max === "number" ? opts.max : opts?.max?.x ?? 8;
-  const maxY = typeof opts?.max === "number" ? opts.max : opts?.max?.y ?? 8;
-  const nextX = Math.min(maxX, Math.max(minX, view.scale.x * fx));
-  const nextY = Math.min(maxY, Math.max(minY, view.scale.y * fy));
-  const worldX = anchor.x / view.scale.x + view.x;
-  const worldY = anchor.y / view.scale.y + view.y;
+var COARSE_TARGET_SCALE = 1.75;
+function resolveDeviceProfile(detected, overrides) {
+  const coarsePointer2 = overrides?.coarsePointer ?? detected.coarsePointer;
+  const canHover2 = overrides?.canHover ?? detected.canHover;
+  const dpr = overrides?.dpr ?? detected.dpr;
+  const targetScale = overrides?.targetScale ?? (coarsePointer2 ? COARSE_TARGET_SCALE : 1);
+  return { coarsePointer: coarsePointer2, canHover: canHover2, dpr, targetScale };
+}
+var DEFAULT_DEVICE_PROFILE = resolveDeviceProfile({
+  coarsePointer: false,
+  canHover: true,
+  dpr: 1
+});
+var COARSE_QUERY = "(pointer: coarse)";
+var HOVER_QUERY = "(hover: hover)";
+function hasMatchMedia() {
+  return typeof window !== "undefined" && typeof window.matchMedia === "function";
+}
+function detectOnce() {
+  const dpr = typeof window !== "undefined" && window.devicePixelRatio || 1;
+  if (!hasMatchMedia()) {
+    return {
+      coarsePointer: DEFAULT_DEVICE_PROFILE.coarsePointer,
+      canHover: DEFAULT_DEVICE_PROFILE.canHover,
+      dpr
+    };
+  }
   return {
-    scale: { x: nextX, y: nextY },
-    x: worldX - anchor.x / nextX,
-    y: worldY - anchor.y / nextY
+    coarsePointer: window.matchMedia(COARSE_QUERY).matches,
+    canHover: window.matchMedia(HOVER_QUERY).matches,
+    dpr
   };
 }
-function clampView(view, bounds, canvas) {
-  const visW = canvas.width / view.scale.x;
-  const visH = canvas.height / view.scale.y;
-  let x;
-  if (visW >= bounds.width) {
-    x = bounds.x + (bounds.width - visW) / 2;
-  } else {
-    const minX = bounds.x;
-    const maxX = bounds.x + bounds.width - visW;
-    x = view.x < minX ? minX : view.x > maxX ? maxX : view.x;
-  }
-  let y;
-  if (visH >= bounds.height) {
-    y = bounds.y + (bounds.height - visH) / 2;
-  } else {
-    const minY = bounds.y;
-    const maxY = bounds.y + bounds.height - visH;
-    y = view.y < minY ? minY : view.y > maxY ? maxY : view.y;
-  }
-  return x === view.x && y === view.y ? view : { x, y, scale: view.scale };
-}
-function isEditableTarget2(target) {
-  if (!target || !(target instanceof Element)) return false;
-  const tag = target.tagName;
-  if (tag === "INPUT" || tag === "TEXTAREA") return true;
-  if (target.isContentEditable) return true;
-  const ce = target.getAttribute("contenteditable");
-  return ce === "true" || ce === "";
-}
-var DepRegistryContext = createContext(null);
-function DepRegistryProvider({ children }) {
-  const sourcesRef = useRef(/* @__PURE__ */ new Map());
-  const registry22 = useMemo(() => ({
-    register: (name, source) => {
-      sourcesRef.current.set(name, source);
-      return () => {
-        sourcesRef.current.delete(name);
-      };
-    },
-    get: (name) => sourcesRef.current.get(name)?.()
-  }), []);
-  return /* @__PURE__ */ jsx(DepRegistryContext.Provider, { value: registry22, 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 registry22 = useDepRegistry();
-  const sourceRef = useRef(source);
-  sourceRef.current = source;
+function useDetectedFacts() {
+  const [facts, setFacts] = useState(detectOnce);
   useEffect(() => {
-    return registry22.register(name, () => sourceRef.current());
-  }, [name, registry22]);
-}
-var DEV = (() => {
-  try {
-    return Boolean(import.meta.env?.DEV);
-  } catch {
-    return false;
-  }
-})();
-function buildDepsFromRequires(action, depRegistry) {
-  const requires = action.requires ?? [];
-  const entries = requires.map((name) => [name, depRegistry.get(name)]);
-  const deps = Object.fromEntries(entries);
-  if (DEV) {
-    const declared = new Set(requires);
-    return new Proxy(deps, {
-      get(target, prop, receiver) {
-        if (typeof prop === "string" && !declared.has(prop) && prop !== "then") {
-          const message = `[weasel:dispatcher] action "${action.id}" read deps.${prop} but did not declare it in \`requires\`. Add \`requires: [...'${prop}']\` to the descriptor or the dep will be undefined at runtime.`;
-          console.warn(message);
-          throw new Error(message);
-        }
-        return Reflect.get(target, prop, receiver);
-      }
-    });
-  }
-  return deps;
-}
-var ActionDisabledReason = {
-  SelectionRequired: "selection-required",
-  NotApplicable: "not-applicable",
-  /** Sentinel: the predicate threw. Surfaced by `evaluateEnabled`'s catch. */
-  PredicateThrew: "predicate-threw"
-};
-var enabledSlowWarned = /* @__PURE__ */ new Set();
-var enabledThrewWarned = /* @__PURE__ */ new Set();
-var ENABLED_BUDGET_MS = 4;
-function evaluateEnabled(action, deps) {
-  if (!action.enabled) return { enabled: true };
-  const isDev3 = typeof process !== "undefined" ? process.env.NODE_ENV !== "production" : true;
-  const now = typeof performance !== "undefined" && typeof performance.now === "function" ? () => performance.now() : () => Date.now();
-  const start = isDev3 ? now() : 0;
-  try {
-    const result = action.enabled(deps);
-    if (isDev3) {
-      const elapsed = now() - start;
-      if (elapsed > ENABLED_BUDGET_MS && !enabledSlowWarned.has(action.id)) {
-        enabledSlowWarned.add(action.id);
-        console.warn(
-          `weasel actions: enabled() for action "${action.id}" took ${elapsed.toFixed(2)}ms (budget ${ENABLED_BUDGET_MS}ms). The predicate must be pure and fast \u2014 see Action.enabled JSDoc.`
-        );
-      }
-    }
-    if (result === true) return { enabled: true };
-    return { enabled: false, reason: result };
-  } catch (e) {
-    if (isDev3 && !enabledThrewWarned.has(action.id)) {
-      enabledThrewWarned.add(action.id);
-      console.warn(
-        `weasel actions: enabled() for action "${action.id}" threw; treating as disabled. The predicate must not throw \u2014 see Action.enabled JSDoc.`,
-        e
+    if (!hasMatchMedia()) return;
+    const coarseMq = window.matchMedia(COARSE_QUERY);
+    const hoverMq = window.matchMedia(HOVER_QUERY);
+    const onCoarse = (e) => setFacts((f) => ({ ...f, coarsePointer: e.matches }));
+    const onHover = (e) => setFacts((f) => ({ ...f, canHover: e.matches }));
+    coarseMq.addEventListener("change", onCoarse);
+    hoverMq.addEventListener("change", onHover);
+    let disposed = false;
+    let densityMq = null;
+    const onDensity = () => {
+      if (disposed) return;
+      const next = window.devicePixelRatio || 1;
+      setFacts((f) => f.dpr === next ? f : { ...f, dpr: next });
+      arm();
+    };
+    function arm() {
+      if (disposed) return;
+      densityMq?.removeEventListener("change", onDensity);
+      densityMq = window.matchMedia(
+        `(resolution: ${window.devicePixelRatio || 1}dppx)`
       );
+      densityMq.addEventListener("change", onDensity);
     }
-    return { enabled: false, reason: ActionDisabledReason.PredicateThrew };
-  }
-}
-function validateActionId(id) {
-  if (id.length === 0) {
-    throw new Error(`weasel: action id may not be empty`);
-  }
-  if (RESERVED_ID_PREFIXES.has(id[0])) {
-    throw new Error(
-      `weasel: action id "${id}" starts with reserved sigil "${id[0]}" (reserved set: ${[...RESERVED_ID_PREFIXES].join(" ")})`
-    );
-  }
-  if (RESERVED_ID_NAMES.has(id)) {
-    throw new Error(
-      `weasel: action id "${id}" collides with a reserved phase keyword (reserved: ${[...RESERVED_ID_NAMES].join(", ")})`
-    );
-  }
-}
-function validateActionDefaultBinding(action) {
-  const gs = action.defaultBinding;
-  if (!gs) return;
-  const entries = Array.isArray(gs) ? gs : [gs];
-  for (const entry of entries) {
-    const spec = "kind" in entry ? entry : entry.spec;
-    const phase = spec.phase;
-    if (phase === void 0) continue;
-    const atoms = Array.isArray(phase) ? phase : [{ channel: "&", phase }];
-    for (const atom of atoms) {
-      if (atom.channel === "&") {
-        throw new Error(
-          `weasel: action "${action.id}" defaultBinding uses '&' channel which has no owning tool to resolve to. Use a named tool channel (e.g. '[rect:engaged]') or '*' instead, or move this binding to the tool's own Tool.bindings.`
-        );
-      }
-    }
-  }
-}
-var ActionsContext = createContext(null);
-function ActionsProvider({ children }) {
-  const actionsRef = useRef(/* @__PURE__ */ new Map());
-  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 wiredDepRegRef = useRef(null);
-  const dispatcherRef = useRef(null);
-  const registry22 = useMemo(() => {
-    const snapshot = () => {
-      const v = versionRef.current;
-      if (cachedVerRef.current === v) return cachedRef.current;
-      const out = Object.freeze(Array.from(actionsRef.current.values()));
-      cachedRef.current = out;
-      cachedVerRef.current = v;
-      return out;
-    };
-    const notify2 = () => {
-      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);
-        actionsRef.current.set(action.id, action);
-        versionRef.current++;
-        notify2();
-        return () => {
-          const cur = actionsRef.current.get(action.id);
-          if (cur === action) {
-            actionsRef.current.delete(action.id);
-            versionRef.current++;
-            notify2();
-          }
-        };
-      },
-      unregister: (id) => {
-        if (actionsRef.current.delete(id)) {
-          versionRef.current++;
-          notify2();
-        }
-      },
-      list: () => snapshot(),
-      trigger: (id, params) => {
-        const a = actionsRef.current.get(id);
-        if (!a) return false;
-        try {
-          if (a.invoker && a.invoker.timing === "immediate") {
-            const r = wiredDepRegRef.current ?? 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) => {
-        dispatcherRef.current = d;
-      },
-      setDepRegistry: (r) => {
-        wiredDepRegRef.current = r;
-      },
-      begin: (id, params) => {
-        const disp = dispatcherRef.current;
-        if (!disp) return null;
-        const r = wiredDepRegRef.current ?? depRegRef.current;
-        const deps = 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);
-      }
+    arm();
+    setFacts({
+      coarsePointer: coarseMq.matches,
+      canHover: hoverMq.matches,
+      dpr: window.devicePixelRatio || 1
+    });
+    return () => {
+      disposed = true;
+      coarseMq.removeEventListener("change", onCoarse);
+      hoverMq.removeEventListener("change", onHover);
+      densityMq?.removeEventListener("change", onDensity);
     };
   }, []);
-  return /* @__PURE__ */ jsx(ActionsContext.Provider, { value: registry22, children });
+  return facts;
+}
+var DeviceProfileContext = createContext(null);
+function useDeviceProfile(overrides) {
+  const provided = useContext(DeviceProfileContext);
+  const detected = useDetectedFacts();
+  const base = provided ?? detected;
+  const { coarsePointer: coarsePointer2, canHover: canHover2, dpr, targetScale } = overrides ?? {};
+  return useMemo(
+    () => resolveDeviceProfile(base, {
+      ...coarsePointer2 !== void 0 ? { coarsePointer: coarsePointer2 } : {},
+      ...canHover2 !== void 0 ? { canHover: canHover2 } : {},
+      ...dpr !== void 0 ? { dpr } : {},
+      ...targetScale !== void 0 ? { targetScale } : {}
+    }),
+    [base.coarsePointer, base.canHover, base.dpr, coarsePointer2, canHover2, dpr, targetScale]
+  );
+}
+function DeviceProfileProvider({ value, children }) {
+  const profile = useDeviceProfile(value);
+  return createElement(DeviceProfileContext.Provider, { value: profile }, children);
+}
+var HANDLE_BASE_PX = 8;
+var ANCHOR_HIT_BASE_PX = 8;
+var ROTATION_HANDLE_BASE_PX = 24;
+function zoomAt(view, anchor, factor, opts) {
+  const fx = typeof factor === "number" ? factor : factor.x;
+  const fy = typeof factor === "number" ? factor : factor.y;
+  const minX = typeof opts?.min === "number" ? opts.min : opts?.min?.x ?? 0.1;
+  const minY = typeof opts?.min === "number" ? opts.min : opts?.min?.y ?? 0.1;
+  const maxX = typeof opts?.max === "number" ? opts.max : opts?.max?.x ?? 8;
+  const maxY = typeof opts?.max === "number" ? opts.max : opts?.max?.y ?? 8;
+  const nextX = Math.min(maxX, Math.max(minX, view.scale.x * fx));
+  const nextY = Math.min(maxY, Math.max(minY, view.scale.y * fy));
+  const worldX = anchor.x / view.scale.x + view.x;
+  const worldY = anchor.y / view.scale.y + view.y;
+  return {
+    scale: { x: nextX, y: nextY },
+    x: worldX - anchor.x / nextX,
+    y: worldY - anchor.y / nextY
+  };
 }
-function useActionsRegistry() {
-  return useContext(ActionsContext);
+function clampView(view, bounds, canvas) {
+  const visW = canvas.width / view.scale.x;
+  const visH = canvas.height / view.scale.y;
+  let x;
+  if (visW >= bounds.width) {
+    x = bounds.x + (bounds.width - visW) / 2;
+  } else {
+    const minX = bounds.x;
+    const maxX = bounds.x + bounds.width - visW;
+    x = view.x < minX ? minX : view.x > maxX ? maxX : view.x;
+  }
+  let y;
+  if (visH >= bounds.height) {
+    y = bounds.y + (bounds.height - visH) / 2;
+  } else {
+    const minY = bounds.y;
+    const maxY = bounds.y + bounds.height - visH;
+    y = view.y < minY ? minY : view.y > maxY ? maxY : view.y;
+  }
+  return x === view.x && y === view.y ? view : { x, y, scale: view.scale };
+}
+function isEditableTarget2(target) {
+  if (!target || !(target instanceof Element)) return false;
+  const tag = target.tagName;
+  if (tag === "INPUT" || tag === "TEXTAREA") return true;
+  if (target.isContentEditable) return true;
+  const ce = target.getAttribute("contenteditable");
+  return ce === "true" || ce === "";
 }
 function resolveParams(params) {
   if (params === void 0) return void 0;
@@ -7782,6 +8297,60 @@ var moveAction = {
    */
   enabled: () => true
 };
+function poseRotationOf(pose) {
+  const p = pose;
+  if (p.rotation && p.x != null && p.y != null && p.width != null && p.height != null) {
+    return { cx: p.x + p.width / 2, cy: p.y + p.height / 2, rotation: p.rotation };
+  }
+  return null;
+}
+function rotatePathAround(path, cx, cy, rotation) {
+  if (path.kind === "rect") {
+    return rotateRectCorners(path.x, path.y, path.width, path.height, cx, cy, rotation);
+  }
+  return rotatePolygon(path, cx, cy, rotation);
+}
+function rotatePolygon(path, cx, cy, rotation) {
+  const cos = Math.cos(rotation);
+  const sin = Math.sin(rotation);
+  const { commands, coords } = path;
+  const next = new Float32Array(coords.length);
+  let ci = 0;
+  for (let i = 0; i < commands.length; i++) {
+    const len = COORD_COUNT3[commands[i]];
+    for (let k = 0; k < len; k += 2) {
+      const dx = coords[ci + k] - cx;
+      const dy = coords[ci + k + 1] - cy;
+      next[ci + k] = cx + dx * cos - dy * sin;
+      next[ci + k + 1] = cy + dx * sin + dy * cos;
+    }
+    ci += len;
+  }
+  return { kind: "polygon", commands: path.commands, coords: next, fillRule: path.fillRule };
+}
+function rotateRectCorners(x, y, w, h, cx, cy, rotation) {
+  const cos = Math.cos(rotation);
+  const sin = Math.sin(rotation);
+  const rotate2 = (px, py) => {
+    const dx = px - cx;
+    const dy = py - cy;
+    return [cx + dx * cos - dy * sin, cy + dx * sin + dy * cos];
+  };
+  const [x0, y0] = rotate2(x, y);
+  const [x1, y1] = rotate2(x + w, y);
+  const [x2, y2] = rotate2(x + w, y + h);
+  const [x3, y3] = rotate2(x, y + h);
+  const commands = new Uint8Array([PATH_M2, PATH_L2, PATH_L2, PATH_L2, PATH_Z2]);
+  const coords = new Float32Array([x0, y0, x1, y1, x2, y2, x3, y3]);
+  return { kind: "polygon", commands, coords, fillRule: "nonzero" };
+}
+var COORD_COUNT3 = {
+  [PATH_M2]: 2,
+  [PATH_L2]: 2,
+  [PATH_C2]: 6,
+  [PATH_Q2]: 4,
+  [PATH_Z2]: 0
+};
 function aabbCenter(bounds) {
   return { x: bounds.x + bounds.width / 2, y: bounds.y + bounds.height / 2 };
 }
@@ -8074,6 +8643,13 @@ var resizeAction = {
           const computePose = (id) => {
             const sp = scratch.startPoses.get(id);
             if (sp === void 0) return void 0;
+            if (isGroupPath && poseRotationOf(sp) !== null) {
+              return remapRotatedLeaf(
+                sp,
+                scratch.originBounds,
+                proposedBounds
+              );
+            }
             return scratch.geometry.remapBounds(sp, scratch.originBounds, proposedBounds);
           };
           scratch.previews.clear();
@@ -8694,6 +9270,10 @@ var clearSelectionAction = {
     return true;
   }
 };
+var counter2 = 0;
+function freshNodeId() {
+  return asNodeId(`n${(counter2++).toString(36)}-${Math.random().toString(36).slice(2, 8)}`);
+}
 function translatePose(pose, dx, dy) {
   const p = pose;
   return {
@@ -8702,10 +9282,6 @@ function translatePose(pose, dx, dy) {
     y: (p["y"] ?? 0) + dy
   };
 }
-var cloneIdCounter = 0;
-function freshCloneId() {
-  return asNodeId(`n${(cloneIdCounter++).toString(36)}-${Math.random().toString(36).slice(2, 8)}`);
-}
 var cloneAction = {
   id: "clone",
   label: "Clone",
@@ -8772,7 +9348,7 @@ var cloneAction = {
             if (origin === void 0 || !originNode) continue;
             const newPose = translatePose(origin, dx, dy);
             const node = {
-              id: freshCloneId(),
+              id: freshNodeId(),
               kind: originNode.kind,
               layer: originNode.layer,
               pose: newPose,
@@ -8913,7 +9489,13 @@ function makeViewportZoomAction(opts = {}) {
   };
 }
 makeViewportZoomAction();
-var isBody = (_target, bodyTarget) => bodyTarget === "selected-body" || bodyTarget === "unselected-body";
+function bodyPredicate(fn) {
+  return Object.assign(fn, { readsAffordance: false });
+}
+var isBody = bodyPredicate((_target, bodyTarget) => bodyTarget === "selected-body" || bodyTarget === "unselected-body");
+bodyPredicate((_target, bodyTarget) => bodyTarget === "selected-body");
+bodyPredicate((_target, bodyTarget) => bodyTarget === "unselected-body");
+bodyPredicate((_target, bodyTarget) => bodyTarget === "empty");
 function kindOf(target) {
   if (typeof target !== "object" || target === null) return void 0;
   const k = target.kind;
@@ -8952,17 +9534,17 @@ function splitCubicAtT(p0, p1, p2, p3, t) {
 function fitCubicThroughDeletion(prev, next) {
   const dx = next.x - prev.x;
   const dy = next.y - prev.y;
-  const dist4 = Math.sqrt(dx * dx + dy * dy);
+  const dist3 = Math.sqrt(dx * dx + dy * dy);
   const c1DirX = prev.outHandle ? prev.outHandle.x - prev.x : dx;
   const c1DirY = prev.outHandle ? prev.outHandle.y - prev.y : dy;
-  const c1 = controlOnSide(prev, c1DirX, c1DirY, dist4, 1 / 3);
+  const c1 = controlOnSide(prev, c1DirX, c1DirY, dist3, 1 / 3);
   const c2DirX = next.inHandle ? next.inHandle.x - next.x : -dx;
   const c2DirY = next.inHandle ? next.inHandle.y - next.y : -dy;
-  const c2 = controlOnSide(next, c2DirX, c2DirY, dist4, 1 / 3);
+  const c2 = controlOnSide(next, c2DirX, c2DirY, dist3, 1 / 3);
   return { c1, c2 };
 }
-function controlOnSide(anchor, dirX, dirY, dist4, fraction) {
-  const targetDist = dist4 * fraction;
+function controlOnSide(anchor, dirX, dirY, dist3, fraction) {
+  const targetDist = dist3 * fraction;
   const len = Math.hypot(dirX, dirY) || 1;
   const ux = dirX / len, uy = dirY / len;
   return { x: anchor.x + ux * targetDist, y: anchor.y + uy * targetDist };
@@ -9219,60 +9801,6 @@ function anchorsInRect(set, rect) {
   }
   return hits;
 }
-function poseRotationOf(pose) {
-  const p = pose;
-  if (p.rotation && p.x != null && p.y != null && p.width != null && p.height != null) {
-    return { cx: p.x + p.width / 2, cy: p.y + p.height / 2, rotation: p.rotation };
-  }
-  return null;
-}
-function rotatePathAround(path, cx, cy, rotation) {
-  if (path.kind === "rect") {
-    return rotateRectCorners(path.x, path.y, path.width, path.height, cx, cy, rotation);
-  }
-  return rotatePolygon(path, cx, cy, rotation);
-}
-function rotatePolygon(path, cx, cy, rotation) {
-  const cos = Math.cos(rotation);
-  const sin = Math.sin(rotation);
-  const { commands, coords } = path;
-  const next = new Float32Array(coords.length);
-  let ci = 0;
-  for (let i = 0; i < commands.length; i++) {
-    const len = COORD_COUNT3[commands[i]];
-    for (let k = 0; k < len; k += 2) {
-      const dx = coords[ci + k] - cx;
-      const dy = coords[ci + k + 1] - cy;
-      next[ci + k] = cx + dx * cos - dy * sin;
-      next[ci + k + 1] = cy + dx * sin + dy * cos;
-    }
-    ci += len;
-  }
-  return { kind: "polygon", commands: path.commands, coords: next, fillRule: path.fillRule };
-}
-function rotateRectCorners(x, y, w, h, cx, cy, rotation) {
-  const cos = Math.cos(rotation);
-  const sin = Math.sin(rotation);
-  const rotate2 = (px, py) => {
-    const dx = px - cx;
-    const dy = py - cy;
-    return [cx + dx * cos - dy * sin, cy + dx * sin + dy * cos];
-  };
-  const [x0, y0] = rotate2(x, y);
-  const [x1, y1] = rotate2(x + w, y);
-  const [x2, y2] = rotate2(x + w, y + h);
-  const [x3, y3] = rotate2(x, y + h);
-  const commands = new Uint8Array([PATH_M2, PATH_L2, PATH_L2, PATH_L2, PATH_Z2]);
-  const coords = new Float32Array([x0, y0, x1, y1, x2, y2, x3, y3]);
-  return { kind: "polygon", commands, coords, fillRule: "nonzero" };
-}
-var COORD_COUNT3 = {
-  [PATH_M2]: 2,
-  [PATH_L2]: 2,
-  [PATH_C2]: 6,
-  [PATH_Q2]: 4,
-  [PATH_Z2]: 0
-};
 function pathInPoseFrame(path, pose) {
   if (path.kind === "rect") {
     if (path.x === pose.x && path.y === pose.y && path.width === pose.width && path.height === pose.height) return path;
@@ -9555,6 +10083,119 @@ var pinchZoomAction = {
   },
   enabled: () => true
 };
+function hostIndex(scene, id) {
+  const node = scene.get(id);
+  const siblings = node?.parent == null ? scene.roots : scene.childrenOf(node.parent);
+  return siblings.indexOf(id);
+}
+function hasSelectedAncestor(scene, id, set) {
+  let parent = scene.get(id)?.parent ?? null;
+  while (parent != null) {
+    if (set.has(parent)) return true;
+    parent = scene.get(parent)?.parent ?? null;
+  }
+  return false;
+}
+function buildDeleteOps(scene, ids, label) {
+  const set = new Set(ids);
+  const ops = [];
+  for (const id of ids) {
+    const node = scene.get(id);
+    if (!node) continue;
+    if (hasSelectedAncestor(scene, id, set)) continue;
+    ops.push(createDeleteOp({
+      node,
+      index: hostIndex(scene, id),
+      label
+    }));
+  }
+  return ops;
+}
+var deleteAction = {
+  id: "delete",
+  label: "Delete",
+  // Suppressed while any tool is mid-gesture — accidentally hitting
+  // Delete during a drag shouldn't wipe the selection out from under
+  // the in-flight handle.
+  defaultBinding: {
+    kind: "key",
+    key: ["Delete", "Backspace"],
+    phase: [{ channel: "*", phase: "initial" }]
+  },
+  eligible: { capability: "edits-page" },
+  requires: ["scene", "selection", "applyOps"],
+  invoker: {
+    timing: "immediate",
+    run: (deps) => {
+      const selection = deps.selection;
+      const scene = deps.scene;
+      const applyOps = deps.applyOps;
+      if (!selection || !scene) return;
+      const ids = selection.get();
+      if (ids.length === 0) return;
+      const ops = buildDeleteOps(scene, ids, "Delete");
+      if (ops.length > 0) {
+        if (applyOps) applyOps(ops, "Delete");
+        else scene.applyBatch(ops, "Delete", defaultCommitAdapter(scene));
+      }
+      selection.set([]);
+    }
+  },
+  enabled: () => true
+};
+function requiresSelection(deps) {
+  const selection = deps?.selection;
+  if (!selection || selection.get().length === 0) {
+    return ActionDisabledReason.SelectionRequired;
+  }
+  return true;
+}
+var clipboardCopyAction = {
+  id: "clipboard.copy",
+  label: "Copy",
+  defaultBinding: { kind: "key", key: "c", mods: { mod: true } },
+  // Same gate as `duplicate`: a mode that can neither edit the page nor own a
+  // selection has nothing to copy. Notably excludes `text-edit`, where Cmd+C
+  // must stay the browser's own copy of the caret range.
+  eligible: { capability: ["edits-page", "creates-selection"] },
+  // `selection` is read by the `enabled` gate, not the invoker — the
+  // dispatcher builds deps for both, and an undeclared read is undefined.
+  requires: ["clipboard", "selection"],
+  invoker: {
+    timing: "immediate",
+    run: (deps) => {
+      deps.clipboard?.copy();
+    }
+  },
+  enabled: requiresSelection
+};
+var clipboardCutAction = {
+  id: "clipboard.cut",
+  label: "Cut",
+  defaultBinding: { kind: "key", key: "x", mods: { mod: true } },
+  eligible: { capability: "edits-page" },
+  requires: ["clipboard", "scene", "selection", "applyOps"],
+  invoker: {
+    timing: "immediate",
+    run: (deps) => {
+      const clipboard = deps.clipboard;
+      const selection = deps.selection;
+      const scene = deps.scene;
+      const applyOps = deps.applyOps;
+      if (!clipboard || !selection || !scene) return;
+      const ids = selection.get();
+      if (ids.length === 0) return;
+      clipboard.copy();
+      const ops = buildDeleteOps(scene, ids, "Cut");
+      if (ops.length > 0) {
+        if (applyOps) applyOps(ops, "Cut");
+        else scene.applyBatch(ops, "Cut", defaultCommitAdapter(scene));
+      }
+      selection.set([]);
+    }
+  },
+  enabled: requiresSelection
+};
 var enterTextEditAction = {
   id: "enterTextEdit",
   label: "Enter text edit",
@@ -9677,26 +10318,47 @@ var selectAllAction = {
       if (all.length === 0) return;
       deps.selection?.set(all);
     }
-  }
-};
-function hostIndex(scene, id) {
-  const node = scene.get(id);
-  const siblings = node?.parent == null ? scene.roots : scene.childrenOf(node.parent);
-  return siblings.indexOf(id);
-}
-var deleteAction = {
-  id: "delete",
-  label: "Delete",
-  // Suppressed while any tool is mid-gesture — accidentally hitting
-  // Delete during a drag shouldn't wipe the selection out from under
-  // the in-flight handle.
-  defaultBinding: {
-    kind: "key",
-    key: ["Delete", "Backspace"],
-    phase: [{ channel: "*", phase: "initial" }]
-  },
-  eligible: { capability: "edits-page" },
-  requires: ["scene", "selection", "applyOps"],
+  }
+};
+var DUPLICATE_OFFSET = 12;
+function translatePose2(pose, dx, dy) {
+  const p = pose;
+  return { ...p, x: (p["x"] ?? 0) + dx, y: (p["y"] ?? 0) + dy };
+}
+function hasSelectedAncestor2(scene, id, set) {
+  let parent = scene.get(id)?.parent ?? null;
+  while (parent != null) {
+    if (set.has(parent)) return true;
+    parent = scene.get(parent)?.parent ?? null;
+  }
+  return false;
+}
+function copySubtree(scene, id, parent, offset, offsetDescendants, ops) {
+  const node = scene.get(id);
+  if (!node) return null;
+  const newId = freshNodeId();
+  const copy = {
+    ...node,
+    id: newId,
+    pose: translatePose2(node.pose, offset.dx, offset.dy),
+    parent
+  };
+  ops.push(createInsertOp({ node: copy, label: "Duplicate" }));
+  const childOffset = offsetDescendants ? offset : { dx: 0, dy: 0 };
+  for (const child of scene.childrenOf(id)) {
+    copySubtree(scene, child, newId, childOffset, offsetDescendants, ops);
+  }
+  return newId;
+}
+var duplicateAction = {
+  id: "duplicate",
+  label: "Duplicate",
+  defaultBinding: { kind: "key", key: "d", mods: { mod: true } },
+  eligible: { capability: ["edits-page", "creates-selection"] },
+  // `selection` is read by the `enabled` gate as well as the invoker. An
+  // undeclared read throws inside the dev-build deps Proxy before the gate can
+  // answer, which is how this action spent a while doing nothing at all.
+  requires: ["scene", "selection", "applyOps", "poseComposition"],
   invoker: {
     timing: "immediate",
     run: (deps) => {
@@ -9706,40 +10368,22 @@ var deleteAction = {
       if (!selection || !scene) return;
       const ids = selection.get();
       if (ids.length === 0) return;
+      const set = new Set(ids);
+      const offset = { dx: DUPLICATE_OFFSET, dy: DUPLICATE_OFFSET };
       const ops = [];
+      const newIds = [];
       for (const id of ids) {
-        const node = scene.get(id);
+        const nid = asNodeId(id);
+        const node = scene.get(nid);
         if (!node) continue;
-        ops.push(createDeleteOp({
-          node,
-          index: hostIndex(scene, id),
-          label: "Delete"
-        }));
-      }
-      if (ops.length > 0) {
-        if (applyOps) applyOps(ops, "Delete");
-        else scene.applyBatch(ops, "Delete", defaultCommitAdapter(scene));
+        if (hasSelectedAncestor2(scene, nid, set)) continue;
+        const newId = copySubtree(scene, nid, node.parent ?? null, offset, deps.poseComposition === void 0, ops);
+        if (newId) newIds.push(newId);
       }
-      selection.set([]);
-    }
-  },
-  enabled: () => true
-};
-function requiresSelection(deps) {
-  const selection = deps?.selection;
-  if (!selection || selection.get().length === 0) {
-    return ActionDisabledReason.SelectionRequired;
-  }
-  return true;
-}
-var duplicateAction = {
-  id: "duplicate",
-  label: "Duplicate",
-  defaultBinding: { kind: "key", key: "d", mods: { mod: true } },
-  eligible: { capability: ["edits-page", "creates-selection"] },
-  invoker: {
-    timing: "immediate",
-    run: (_deps, params) => {
+      if (ops.length === 0) return;
+      if (applyOps) applyOps(ops, "Duplicate");
+      else scene.applyBatch(ops, "Duplicate", defaultCommitAdapter(scene));
+      selection.set(newIds);
     }
   },
   enabled: requiresSelection
@@ -10709,7 +11353,7 @@ var LABEL = {
   divide: "Divide",
   crop: "Crop"
 };
-function isEmpty(p) {
+function isEmpty2(p) {
   return p.commands.length === 0;
 }
 function applyBooleanOp(adapter, op) {
@@ -10747,7 +11391,7 @@ function applyBooleanOp(adapter, op) {
       break;
     }
   }
-  results = results.filter((p) => !isEmpty(p));
+  results = results.filter((p) => !isEmpty2(p));
   if (results.length === 0) return { kind: "noop", reason: "empty-result" };
   const topmostId = entries[entries.length - 1].id;
   const topAnchor = adapter.getZOrder?.(topmostId);
@@ -11283,14 +11927,24 @@ var DEFAULT_PALETTE = [
   "#7ab8d4",
   "#d47a7a"
 ];
+function resolveFill(scratch, prev) {
+  if (scratch.currentPaint) return scratch.currentPaint;
+  const prevColor = typeof prev?.fill === "string" ? prev.fill : DEFAULT_FILL_COLOR;
+  return mergeAlphaFromPrev(scratch.currentColor, prevColor);
+}
 function refreshPreviews(scratch) {
   scratch.previews.clear();
   for (const id of scratch.ids) {
     const prev = scratch.startData.get(id);
-    const next = mergeAlphaFromPrev(scratch.currentColor, prev?.fill ?? DEFAULT_FILL_COLOR);
-    scratch.previews.set(id, { ...prev ?? {}, fill: next });
+    scratch.previews.set(id, { ...prev ?? {}, fill: resolveFill(scratch, prev) });
   }
 }
+function readParams(params) {
+  return {
+    color: params?.color,
+    paint: params?.paint
+  };
+}
 var setFillAction = {
   id: "setFill",
   label: "Set fill",
@@ -11305,9 +11959,10 @@ var setFillAction = {
       if (!selection || !scene) return {};
       const ids = selection.get();
       if (ids.length === 0) return {};
-      const ctxColor = ctx.params?.color;
-      const optsColor = opts?.params?.color;
-      const initialColor = ctxColor ?? optsColor ?? DEFAULT_STROKE_COLOR;
+      const fromCtx = readParams(ctx.params);
+      const fromOpts = readParams(opts?.params);
+      const initialPaint = fromCtx.paint ?? fromOpts.paint;
+      const initialColor = fromCtx.color ?? fromOpts.color ?? DEFAULT_STROKE_COLOR;
       const startData = /* @__PURE__ */ new Map();
       for (const id of ids) {
         const node = scene.get(id);
@@ -11318,15 +11973,20 @@ var setFillAction = {
         scene,
         startData,
         currentColor: initialColor,
+        currentPaint: initialPaint,
         previews: /* @__PURE__ */ new Map(),
         applyOps
       };
       refreshPreviews(scratch);
       return {
         onMove(moveCtx) {
-          const next = moveCtx.params?.color;
-          if (next === void 0) return;
-          scratch.currentColor = next;
+          const { color, paint } = readParams(moveCtx.params);
+          if (color === void 0 && paint === void 0) return;
+          if (paint !== void 0) scratch.currentPaint = paint;
+          if (color !== void 0) {
+            scratch.currentColor = color;
+            if (paint === void 0) scratch.currentPaint = void 0;
+          }
           refreshPreviews(scratch);
         },
         onEnd(_endCtx, reason) {
@@ -11336,8 +11996,7 @@ var setFillAction = {
           }
           const ops = [];
           for (const id of scratch.ids) {
-            const prev = scratch.startData.get(id);
-            const merged = mergeAlphaFromPrev(scratch.currentColor, prev?.fill ?? DEFAULT_FILL_COLOR);
+            const merged = resolveFill(scratch, scratch.startData.get(id));
             const nodeNow = scratch.scene.get(id);
             if (!nodeNow) continue;
             const from = { ...nodeNow.data };
@@ -11719,7 +12378,8 @@ function resolveTextStyle(style) {
     selectionColor: style.selectionColor ?? null,
     letterSpacing: style.letterSpacing ?? DEFAULT_TEXT_STYLE.letterSpacing,
     underline: style.underline ?? DEFAULT_TEXT_STYLE.underline,
-    strikethrough: style.strikethrough ?? DEFAULT_TEXT_STYLE.strikethrough
+    strikethrough: style.strikethrough ?? DEFAULT_TEXT_STYLE.strikethrough,
+    ...style.stroke !== void 0 ? { stroke: style.stroke } : {}
   };
 }
 function numericWeight(w) {
@@ -11740,6 +12400,9 @@ function resolveRuns(runs, style) {
       fontWeight: run.bold ? 700 : baseWeight,
       fontStyle: run.italic ? "italic" : style.fontStyle,
       fill: run.fill ?? style.fill,
+      // Unlike the decorations below, a run's stroke *replaces* the node's
+      // rather than adding to it — there is only one outline to paint.
+      ...(run.stroke ?? style.stroke) !== void 0 ? { stroke: run.stroke ?? style.stroke } : {},
       letterSpacing: run.letterSpacing ?? style.letterSpacing,
       // `||`, not `??`: run-level decorations are additive over the node style.
       underline: run.underline || style.underline,
@@ -12116,7 +12779,9 @@ var KIT_STANDARD_DESCRIPTORS = [
   setStrokeAction,
   setFillOpacityAction,
   setStrokeOpacityAction,
-  ingestAction
+  ingestAction,
+  clipboardCopyAction,
+  clipboardCutAction
 ];
 function useStandardActions(opts) {
   const optsRef = useRef(opts);
@@ -12191,6 +12856,54 @@ function targetRank(target) {
   if (target.startsWith("affordance:")) return 2;
   return 1;
 }
+function targetConsultsAffordance(specTarget) {
+  if (specTarget === void 0) return false;
+  if (typeof specTarget === "object" && specTarget !== null && "kindOf" in specTarget) {
+    const kindOf2 = specTarget.kindOf;
+    return kindOf2?.readsAffordance !== false;
+  }
+  return typeof specTarget === "string" && specTarget.startsWith("affordance:");
+}
+function specTargetOf(spec) {
+  return "target" in spec ? spec.target : void 0;
+}
+function claimOf(e) {
+  return "affordance" in e ? e.affordance : void 0;
+}
+function claimGestureOf(e) {
+  switch (e.kind) {
+    case "pointerdown":
+    case "click":
+      return "pointer";
+    case "doubleclick":
+      return "doubleClick";
+    case "contextmenu":
+      return "contextMenu";
+    case "longpress":
+      return "longPress";
+    case "wheel":
+      return "wheel";
+    default:
+      return null;
+  }
+}
+function isExclusiveClaim(e) {
+  const claim = claimOf(e);
+  if (claim?.strength !== "exclusive") return false;
+  const gesture = claimGestureOf(e);
+  if (gesture === null) return false;
+  return claim.claimedKinds === void 0 || claim.claimedKinds.includes(gesture);
+}
+var warnedDeadClaims = /* @__PURE__ */ new Set();
+function reportDeadClaim(owner, warn) {
+  if (process.env.NODE_ENV === "production") return;
+  const key = String(owner);
+  if (warnedDeadClaims.has(key)) return;
+  warnedDeadClaims.add(key);
+  warn(
+    `[weasel] exclusive claim by "${key}" matched no binding: no \`affordance:\` or \`kindOf\` target resolved against it, so the press was dropped.`
+  );
+}
 function specificity(spec) {
   const t = targetRank("target" in spec ? spec.target : void 0);
   const mods = "mods" in spec ? spec.mods : void 0;
@@ -12207,12 +12920,14 @@ function compareSpecificity(a, b) {
   }
   return 0;
 }
-function matchSorted(e, bindings, isMac, engagedChannels) {
+function matchSorted(e, bindings, isMac, engagedChannels, warn = (m) => console.warn(m)) {
   const out = [];
   const engaged = engagedChannels ?? EMPTY_ENGAGED2;
+  const exclusive = isExclusiveClaim(e);
+  const pool = exclusive ? bindings.filter((sb) => targetConsultsAffordance(specTargetOf(sb.binding.spec))) : bindings;
   for (const scope of SCOPE_PRIORITY) {
     const scopeMatches = [];
-    for (const sb of bindings) {
+    for (const sb of pool) {
       if (sb.scope !== scope) continue;
       const phaseCtx = { selfChannel: sb.ownerToolId, engagedChannels: engaged };
       if (matchSpec(e, sb.binding.spec, isMac, phaseCtx)) {
@@ -12222,9 +12937,32 @@ function matchSorted(e, bindings, isMac, engagedChannels) {
     scopeMatches.sort((a, b) => compareSpecificity(a.binding.spec, b.binding.spec));
     out.push(...scopeMatches);
   }
+  if (exclusive && out.length === 0 && bindings.length > 0) {
+    reportDeadClaim(claimOf(e)?.owner, warn);
+  }
   return out;
 }
 var EMPTY_ENGAGED2 = /* @__PURE__ */ new Set();
+function liveScope(id, eligibility, state) {
+  const tags = eligibility.capabilities;
+  if (tags && tags.length > 0 && state.allows && !state.allows(tags)) return null;
+  if (state.engagedIds?.has(id)) return "hotkey";
+  if (eligibility.offhand && state.heldTriggers.has(eligibility.offhand)) return "hotkey";
+  if (eligibility.focus && state.focusedId === id) return "active";
+  if (eligibility.always || eligibility.claimed) return "ambient";
+  return null;
+}
+function scopeBindings(entries, state) {
+  const out = [];
+  for (const entry of entries) {
+    const scope = liveScope(entry.id, entry.eligibility ?? {}, state);
+    if (scope === null) continue;
+    for (const binding of entry.bindings ?? []) {
+      out.push({ binding, scope, ownerToolId: entry.id });
+    }
+  }
+  return out;
+}
 var ALWAYS = { all: [] };
 var NEVER = { any: [] };
 function isAllRule(r) {
@@ -12281,6 +13019,14 @@ function evaluateSelector(s, ctx) {
     const resizable2 = ctx.selectionResizable ?? true;
     if (resizable2 !== s.resizable) return false;
   }
+  if (s.coarsePointer !== void 0) {
+    const device = ctx.device ?? DEFAULT_DEVICE_PROFILE;
+    if (device.coarsePointer !== s.coarsePointer) return false;
+  }
+  if (s.canHover !== void 0) {
+    const device = ctx.device ?? DEFAULT_DEVICE_PROFILE;
+    if (device.canHover !== s.canHover) return false;
+  }
   return true;
 }
 var MAX_RULE_DEPTH = 10;
@@ -12350,6 +13096,8 @@ cond({ selection: { empty: true } });
 cond({ when: (c) => c.multiActive });
 cond({ hovering: true });
 cond({ hoveringSelected: true });
+cond({ coarsePointer: true });
+cond({ canHover: true });
 var DEFAULT_ALLOWED_CAPABILITIES = /* @__PURE__ */ new Set([
   ...NORMAL.allows,
   ...IMPLICIT_TAGS
@@ -12509,6 +13257,7 @@ function filterEligible(matches, actionLookup, ruleCtx) {
     return isEligible(action, ruleCtx);
   });
 }
+var EMPTY_TRIGGERS = /* @__PURE__ */ new Set();
 var EMPTY_ENGAGED22 = /* @__PURE__ */ new Set();
 function modifiersOf(e) {
   return { alt: e.altKey, ctrl: e.ctrlKey, meta: e.metaKey, shift: e.shiftKey };
@@ -12616,34 +13365,23 @@ function createDispatcher(opts) {
     return `ongoing-${event.kind}`;
   }
   function assembleScopedBindings(ctx) {
-    const result = [];
-    for (const toolId of ctx.hotkeyStack) {
-      const tool = ctx.toolsById.get(toolId);
-      for (const binding of tool?.bindings ?? []) {
-        result.push({ binding, scope: "hotkey", ownerToolId: toolId });
-      }
-    }
-    const activeTool = ctx.toolsById.get(ctx.activeToolId);
-    for (const binding of activeTool?.bindings ?? []) {
-      result.push({ binding, scope: "active", ownerToolId: ctx.activeToolId });
-    }
-    for (const toolId of ctx.ambientToolIds ?? []) {
-      const tool = ctx.toolsById.get(toolId);
-      for (const binding of tool?.bindings ?? []) {
-        result.push({ binding, scope: "ambient", ownerToolId: toolId });
-      }
-    }
+    const ordered = [];
+    for (const id of ctx.hotkeyStack) {
+      const tool = ctx.toolsById.get(id);
+      if (tool && !ordered.includes(tool)) ordered.push(tool);
+    }
+    for (const tool of ctx.toolsById.values()) {
+      if (!ordered.includes(tool)) ordered.push(tool);
+    }
+    const result = scopeBindings(ordered, {
+      focusedId: ctx.activeToolId,
+      heldTriggers: EMPTY_TRIGGERS,
+      engagedIds: new Set(ctx.hotkeyStack)
+    });
     for (const action of ctx.actions.list()) {
-      const gs = action.defaultBinding;
-      if (!gs) continue;
-      const raw = Array.isArray(gs) ? gs : [gs];
-      for (const entry of raw) {
-        const isBoundObj = !("kind" in entry);
-        const spec = isBoundObj ? entry.spec : entry;
-        const opts2 = isBoundObj ? entry.opts : void 0;
-        const defaultBinding = { spec, actionId: action.id, ...opts2 !== void 0 ? { opts: opts2 } : {} };
-        const targetScope = action.scope === "hotkey" ? "hotkey" : "ambient";
-        result.push({ binding: defaultBinding, scope: targetScope, ownerToolId: null });
+      const targetScope = action.scope === "hotkey" ? "hotkey" : "ambient";
+      for (const binding of actionBindings(action)) {
+        result.push({ binding, scope: targetScope, ownerToolId: null });
       }
     }
     return result;
@@ -12798,15 +13536,26 @@ function createDispatcher(opts) {
               deltaY: event.deltaY,
               clientX: event.clientX,
               clientY: event.clientY,
+              affordance: event.affordance,
               ...resolved
             };
           } else if (event.kind === "click" || event.kind === "doubleclick") {
             params = {
               worldX: event.worldX,
               worldY: event.worldY,
+              affordance: event.affordance,
               // Press point as well as release point — an action that places
               // geometry at the click wants the former. See `ClickEvent`.
-              ...event.kind === "click" ? { pressX: event.pressX, pressY: event.pressY, affordance: event.affordance } : {},
+              ...event.kind === "click" ? { pressX: event.pressX, pressY: event.pressY } : {},
+              mods: modifiersOf(event),
+              ...resolved
+            };
+          } else if (event.kind === "contextmenu" || event.kind === "longpress") {
+            params = {
+              worldX: event.kind === "contextmenu" ? event.worldX : event.x,
+              worldY: event.kind === "contextmenu" ? event.worldY : event.y,
+              affordance: event.affordance,
+              bodyTarget: event.bodyTarget,
               mods: modifiersOf(event),
               ...resolved
             };
@@ -13174,7 +13923,7 @@ function computeMultiTouchGeometry(positions) {
   return { centroid, spread };
 }
 function useGestureDispatcher(opts) {
-  const { canvasRef, actions, toolsById, ambientToolIds, enabled = true, keyboard = true, affordanceAt, classifyTarget, dispatcher: dispatcherOpt, clientToWorld: clientToWorld2, requestRedraw, getRuleCtx, onDoubleClick } = opts;
+  const { canvasRef, actions, toolsById, enabled = true, keyboard = true, affordanceAt, classifyTarget, dispatcher: dispatcherOpt, clientToWorld: clientToWorld2, requestRedraw, getRuleCtx, onDoubleClick } = opts;
   const onDoubleClickRef = useRef(onDoubleClick);
   onDoubleClickRef.current = onDoubleClick;
   const activeTool = useActiveToolContext();
@@ -13189,7 +13938,6 @@ function useGestureDispatcher(opts) {
     activeToolId: activeTool.active,
     hotkeyStack: activeTool.hotkeyStack,
     toolsById,
-    ambientToolIds,
     isMac: IS_MAC,
     getRuleCtx
   });
@@ -13199,7 +13947,6 @@ function useGestureDispatcher(opts) {
     activeToolId: activeTool.active,
     hotkeyStack: activeTool.hotkeyStack,
     toolsById,
-    ambientToolIds,
     isMac: IS_MAC,
     getRuleCtx
   };
@@ -13255,6 +14002,49 @@ function useGestureDispatcher(opts) {
     const DRAG_THRESHOLD_PX = 4;
     const bufferedDown = /* @__PURE__ */ new Map();
     const lastPointerDown = /* @__PURE__ */ new Map();
+    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 = lastPointerDown.get(pointerId);
+      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 = dispatch2({
+        kind: "longpress",
+        x: down.worldX,
+        y: down.worldY,
+        clientX: down.clientX,
+        clientY: down.clientY,
+        ...shared
+      });
+      if (result === "unhandled") {
+        dispatch2({
+          kind: "contextmenu",
+          worldX: down.worldX,
+          worldY: down.worldY,
+          ...shared
+        });
+      }
+    };
     const DOUBLE_CLICK_MAX_MS = 600;
     const DOUBLE_CLICK_MAX_PX = 8;
     const onKeyDown = (e) => {
@@ -13307,6 +14097,9 @@ function useGestureDispatcher(opts) {
     const onWheel = (e) => {
       const rect = canvas?.getBoundingClientRect();
       const [localX, localY] = rect ? clientToCanvasRect(rect, e.clientX, e.clientY) : [e.clientX, e.clientY];
+      const screenPoint = { x: e.clientX, y: e.clientY };
+      const affordance = affordanceAtRef.current?.(screenPoint) ?? void 0;
+      const body = classifyTargetRef.current?.(screenPoint);
       const ev = {
         kind: "wheel",
         altKey: e.altKey,
@@ -13316,7 +14109,10 @@ function useGestureDispatcher(opts) {
         deltaX: e.deltaX,
         deltaY: e.deltaY,
         clientX: localX,
-        clientY: localY
+        clientY: localY,
+        ...affordance !== void 0 ? { affordance } : {},
+        ...body?.body !== void 0 ? { bodyTarget: body.body } : {},
+        ...body?.kind !== void 0 ? { bodyKind: body.kind } : {}
       };
       const result = dispatch2(ev);
       if (result === "handled") {
@@ -13358,6 +14154,7 @@ function useGestureDispatcher(opts) {
       bufferedDown.set(e.pointerId, { ev, clientX: e.clientX, clientY: e.clientY });
       dispatch2({ ...ev, stage: "press" });
       lastPointerDown.set(e.pointerId, {
+        target: e.target,
         clientX: e.clientX,
         clientY: e.clientY,
         worldX: w.x,
@@ -13370,7 +14167,19 @@ function useGestureDispatcher(opts) {
         metaKey: e.metaKey,
         shiftKey: e.shiftKey
       });
+      if ((e.pointerType === "touch" || e.pointerType === "pen") && activePointers.size === 1) {
+        cancelLongPress(e.pointerId);
+        longPressTimers.set(
+          e.pointerId,
+          setTimeout(() => {
+            longPressTimers.delete(e.pointerId);
+            if (disposed) return;
+            fireLongPress(e.pointerId);
+          }, LONG_PRESS_MS)
+        );
+      }
       if (activePointers.size >= 2) {
+        cancelAllLongPress();
         for (const id of activePointers) bufferedDown.delete(id);
         const { centroid, spread } = computeMultiTouchGeometry(pointerPositions);
         if (!multiTouchStart) {
@@ -13401,6 +14210,7 @@ function useGestureDispatcher(opts) {
         const dy = e.clientY - buffered.clientY;
         if (Math.hypot(dx, dy) >= DRAG_THRESHOLD_PX) {
           bufferedDown.delete(e.pointerId);
+          cancelLongPress(e.pointerId);
           dispatch2(buffered.ev);
         }
       }
@@ -13514,6 +14324,7 @@ function useGestureDispatcher(opts) {
       clearHoverCursor();
     };
     const onPointerUp = (e) => {
+      cancelLongPress(e.pointerId);
       const prevSize = activePointers.size;
       activePointers.delete(e.pointerId);
       pointerPositions.delete(e.pointerId);
@@ -13595,6 +14406,7 @@ function useGestureDispatcher(opts) {
             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 } : {}
           };
@@ -13618,6 +14430,7 @@ function useGestureDispatcher(opts) {
       }, 0);
     };
     const onPointerCancel = (e) => {
+      cancelLongPress(e.pointerId);
       activePointers.delete(e.pointerId);
       pointerPositions.delete(e.pointerId);
       lastPointerDown.delete(e.pointerId);
@@ -13635,8 +14448,10 @@ function useGestureDispatcher(opts) {
     };
     const onContextMenu = (e) => {
       e.preventDefault();
-      const worldPoint = { x: e.clientX, y: e.clientY };
-      const menuBody = classifyTargetRef.current?.(worldPoint);
+      const screenPoint = { x: e.clientX, y: e.clientY };
+      const affordance = affordanceAtRef.current?.(screenPoint) ?? void 0;
+      const menuBody = classifyTargetRef.current?.(screenPoint);
+      const w = toWorld(e.clientX, e.clientY);
       const ev = {
         kind: "contextmenu",
         target: e.target,
@@ -13644,6 +14459,9 @@ function useGestureDispatcher(opts) {
         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 } : {}
       };
@@ -13740,6 +14558,7 @@ function useGestureDispatcher(opts) {
       window.removeEventListener("paste", onPaste);
       canvas?.classList.remove(DROPOVER_CLASS);
       clearHoverCursor();
+      cancelAllLongPress();
       disposed = true;
       dispatcher.cancelAll("cancel");
     };
@@ -13941,47 +14760,203 @@ function usePinchGesture(canvasRef, onPinch, enabled = true) {
     };
   }, [canvasRef, enabled]);
 }
-function useTools(opts) {
-  if (!(opts.active in opts.registry)) {
-    throw new Error(`useTools: active "${opts.active}" not in registry`);
+var TOOL_OFFHAND_ID = "tool.offhand";
+function offhandKeyFor(trigger) {
+  switch (trigger) {
+    case "space":
+      return " ";
+    case "alt":
+      return "Alt";
+    case "ctrl":
+      return "Control";
+    case "meta":
+      return "Meta";
+    case "shift":
+      return "Shift";
   }
+}
+function buildToolOffhandBindings(specs) {
+  return specs.map(({ toolId, key }) => ({
+    spec: { kind: "key-held", key },
+    opts: { params: { toolId } }
+  }));
+}
+function makeToolOffhandAction(bindings) {
+  return {
+    id: TOOL_OFFHAND_ID,
+    label: "Engage tool (offhand)",
+    defaultBinding: bindings,
+    scope: "hotkey",
+    invoker: {
+      timing: "ongoing",
+      start: (ctx, opts) => {
+        const activeTool = ctx.deps.activeTool;
+        const toolId = resolveParams(opts?.params)?.toolId;
+        if (!activeTool || !toolId) return {};
+        activeTool.pushHotkey(toolId);
+        return {
+          onEnd: () => {
+            activeTool.popHotkey();
+          }
+        };
+      }
+    },
+    requires: ["activeTool"]
+  };
+}
+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.active !== "select";
+    needsFirstMountSyncRef.current = ctx.active === "select" && opts.focused !== "select";
   }
   useEffect(() => {
     if (!needsFirstMountSyncRef.current) return;
     needsFirstMountSyncRef.current = false;
-    ctx.setActive(opts.active);
+    ctx.setActive(opts.focused);
+  }, []);
+  const focused2 = isFirstRender && ctx.active === "select" && opts.focused !== "select" ? opts.focused : ctx.active;
+  const entriesRef = useRef(opts.entries);
+  entriesRef.current = opts.entries;
+  const focusedRef = useRef(focused2);
+  focusedRef.current = focused2;
+  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 active = isFirstRender && ctx.active === "select" && opts.active !== "select" ? opts.active : ctx.active;
-  const hotkeyStack = ctx.hotkeyStack;
-  const hotkeyEngaged = hotkeyStack.at(-1) ?? null;
-  const registryRef = useRef(opts.registry);
-  registryRef.current = opts.registry;
-  const ambientRef = useRef(opts.ambient ?? []);
-  ambientRef.current = opts.ambient ?? [];
-  const activeRef = useRef(active);
-  activeRef.current = active;
+  const scopedBindings = useCallback(() => {
+    const { ordered, state } = snapshot();
+    return scopeBindings(ordered, state);
+  }, [snapshot]);
+  const overlays = useCallback(() => {
+    const { ordered, state } = snapshot();
+    const active = [];
+    const hotkey = [];
+    const ambient = [];
+    for (const entry of ordered) {
+      if (!entry.overlay) continue;
+      const scope = liveScope(entry.id, entry.eligibility ?? {}, state);
+      if (scope === "active") active.push(entry.overlay);
+      else if (scope === "hotkey") hotkey.push(entry.overlay);
+      else if (scope === "ambient") ambient.push(entry.overlay);
+    }
+    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 (process.env.NODE_ENV === "production") return;
+    if (lastConflictSigRef.current === entrySig) return;
+    lastConflictSigRef.current = entrySig;
+    const registry22 = [];
+    const ambient = [];
+    for (const entry of entriesRef.current) {
+      (entry.eligibility?.focus ? registry22 : ambient).push(entry);
+    }
+    reportRouteConflicts({
+      registry: registry22,
+      ambient,
+      actions: actionsRegistry?.list() ?? []
+    });
+  }, [entrySig, actionsRegistry]);
+  return useMemo(
+    () => ({
+      entries: entriesRef.current,
+      focused: focused2,
+      setFocused,
+      scopedBindings,
+      overlays
+    }),
+    [focused2, setFocused, scopedBindings, overlays]
+  );
+}
+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 registry22 = {};
+    for (const [id, tool] of Object.entries(opts.registry)) {
+      registry22[id] = declareSlot(tool, "focus");
+    }
+    const ambient = (opts.ambient ?? []).map((t) => declareSlot(t, "always"));
+    const byId2 = /* @__PURE__ */ new Map();
+    for (const tool of [...Object.values(registry22), ...ambient]) {
+      const prior = byId2.get(tool.id);
+      if (prior) byId2.set(tool.id, { ...tool, eligibility: { ...prior.eligibility, ...tool.eligibility } });
+      else byId2.set(tool.id, tool);
+    }
+    return { registry: registry22, ambient, entries: [...byId2.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 registryRef.current)) {
+      if (!(id in slottedRef.current.registry)) {
         throw new Error(`setActive: "${id}" not in registry`);
       }
       dlog("tools", "active:", activeRef.current, "\u2192", id);
-      ctx.setActive(id);
+      setFocused(id);
     },
-    [ctx]
+    [setFocused]
   );
   const engageHotkey = useCallback(
     (id) => {
-      if (!(id in registryRef.current)) {
+      if (!(id in slottedRef.current.registry)) {
         throw new Error(`engageHotkey: "${id}" not in registry`);
       }
       dlog("tools", "hotkey engaged:", id);
@@ -13993,32 +14968,12 @@ function useTools(opts) {
     if (hotkeyRef.current) dlog("tools", "hotkey disengaged:", hotkeyRef.current);
     ctx.popHotkey();
   }, [ctx]);
-  const lastConflictSigRef = useRef(null);
-  const toolSetSig = Object.keys(opts.registry).join(",") + "|" + (opts.ambient ?? []).map((t) => t.id).join(",");
-  useEffect(() => {
-    if (process.env.NODE_ENV === "production") return;
-    if (lastConflictSigRef.current === toolSetSig) return;
-    lastConflictSigRef.current = toolSetSig;
-    reportRouteConflicts({
-      registry: registryRef.current,
-      ambient: ambientRef.current
-    });
-  }, [toolSetSig]);
   const has = useCallback(
-    (id) => id in registryRef.current || ambientRef.current.some((t) => t.id === id),
+    (id) => id in slottedRef.current.registry || slottedRef.current.ambient.some((t) => t.id === id),
     []
   );
-  const getActiveOverlays = useCallback(() => {
-    const out = [];
-    const activeTool = registryRef.current[activeRef.current];
-    if (activeTool?.overlay) out.push(activeTool.overlay);
-    const mod = hotkeyRef.current ? registryRef.current[hotkeyRef.current] : null;
-    if (mod?.overlay) out.push(mod.overlay);
-    for (const t of ambientRef.current) {
-      if (t.overlay) out.push(t.overlay);
-    }
-    return out;
-  }, []);
+  const active = contributions.focused;
+  const getActiveOverlays = contributions.overlays;
   return useMemo(
     () => ({
       active,
@@ -14026,44 +14981,14 @@ function useTools(opts) {
       hotkeyEngaged,
       engageHotkey,
       disengageHotkey,
-      ambient: ambientRef.current,
-      registry: registryRef.current,
+      ambient: slottedRef.current.ambient,
+      registry: slottedRef.current.registry,
       has,
       getActiveOverlays
     }),
     [active, setActive, hotkeyEngaged, engageHotkey, disengageHotkey, has, getActiveOverlays]
   );
 }
-var TOOL_OFFHAND_ID = "tool.offhand";
-function buildToolOffhandBindings(specs) {
-  return specs.map(({ toolId, key }) => ({
-    spec: { kind: "key-held", key },
-    opts: { params: { toolId } }
-  }));
-}
-function makeToolOffhandAction(bindings) {
-  return {
-    id: TOOL_OFFHAND_ID,
-    label: "Engage tool (offhand)",
-    defaultBinding: bindings,
-    scope: "hotkey",
-    invoker: {
-      timing: "ongoing",
-      start: (ctx, opts) => {
-        const activeTool = ctx.deps.activeTool;
-        const toolId = resolveParams(opts?.params)?.toolId;
-        if (!activeTool || !toolId) return {};
-        activeTool.pushHotkey(toolId);
-        return {
-          onEnd: () => {
-            activeTool.popHotkey();
-          }
-        };
-      }
-    },
-    requires: ["activeTool"]
-  };
-}
 var TOOL_ACTIVATE_ID = "tool.activate";
 function buildToolActivateBindings(specs) {
   return specs.map(({ toolId, keyOpts }) => {
@@ -14135,9 +15060,6 @@ var BUILTIN_SELECT_KEYS = {
   hand: { key: "H" },
   pen: { key: "P" }
 };
-var BUILTIN_OFFHAND_ACTIONS = {
-  hand: " "
-};
 function useKeybindings(tools, options = {}) {
   const toolsRef = useRef(tools);
   toolsRef.current = tools;
@@ -14145,19 +15067,6 @@ function useKeybindings(tools, options = {}) {
   optionsRef.current = options;
   const initialActiveRef = useRef(tools.active);
   const registry22 = useActionsRegistry();
-  useEffect(() => {
-    if (optionsRef.current.disable) return;
-    if (!registry22) return;
-    const specs = [];
-    for (const [toolId, key] of Object.entries(BUILTIN_OFFHAND_ACTIONS)) {
-      if (toolsRef.current.has(toolId)) {
-        specs.push({ toolId, key });
-      }
-    }
-    if (specs.length === 0) return;
-    const bindings = buildToolOffhandBindings(specs);
-    return registry22.register(makeToolOffhandAction(bindings));
-  }, [registry22, tools]);
   useEffect(() => {
     if (optionsRef.current.disable) return;
     if (!registry22) return;
@@ -14552,7 +15461,82 @@ function textLineBoxes(pose, opts = {}) {
   }
   return out;
 }
-var cache4 = /* @__PURE__ */ new Map();
+function fillInPoseFrame(fill, box) {
+  if (isBoundsPattern(fill)) {
+    const o = fill.origin ?? { x: 0, y: 0 };
+    return { ...fill, origin: { x: box.x + o.x, y: box.y + o.y }, units: "local" };
+  }
+  if (!isBoundsGradient(fill)) return fill;
+  const toBox = (p) => ({
+    x: box.x + p.x * box.width,
+    y: box.y + p.y * box.height
+  });
+  if (fill.fill === "linear-gradient") {
+    return { ...fill, from: toBox(fill.from), to: toBox(fill.to), units: "local" };
+  }
+  if (fill.fill === "radial-gradient") {
+    const scale2 = Math.hypot(box.width, box.height) / Math.SQRT2;
+    return { ...fill, center: toBox(fill.center), radius: fill.radius * scale2, units: "local" };
+  }
+  return { ...fill, center: toBox(fill.center), units: "local" };
+}
+function isBoundsPattern(fill) {
+  return fill.fill === "pattern" && fill.units === "bounds";
+}
+function isBoundsGradient(fill) {
+  if (fill === void 0) return false;
+  const kind = fill.fill;
+  if (kind !== "linear-gradient" && kind !== "radial-gradient" && kind !== "conic-gradient") {
+    return false;
+  }
+  return fill.units === "bounds";
+}
+var cache5 = /* @__PURE__ */ new Map();
+function specKey(spec) {
+  const keys = Object.keys(spec).sort();
+  const bag = spec;
+  return keys.map((k) => `${k}=${String(bag[k])}`).join("&");
+}
+function resolvePatternSpec(spec) {
+  const key = specKey(spec);
+  const hit = cache5.get(key);
+  if (hit !== void 0) return hit;
+  const built = buildTile(spec);
+  cache5.set(key, built);
+  return built;
+}
+function buildTile(spec) {
+  const { color, size } = spec;
+  switch (spec.tile) {
+    case "hatch":
+      return hatch({ color, size, lineWidth: spec.lineWidth });
+    case "crosshatch":
+      return crosshatch({ color, size, lineWidth: spec.lineWidth });
+    case "dots":
+      return dots({ color, size, radius: spec.radius });
+    case "chunks":
+      return chunks({
+        color,
+        size,
+        bg: spec.bg,
+        density: spec.density,
+        chunkSize: spec.chunkSize,
+        seed: spec.seed
+      });
+    default:
+      return null;
+  }
+}
+function isPatternSpec(payload) {
+  return "tile" in payload;
+}
+function resolveFillPattern(fill) {
+  if (fill.fill !== "pattern") return fill;
+  if (!isPatternSpec(fill.pattern)) return fill;
+  const handle = resolvePatternSpec(fill.pattern);
+  return handle ? { ...fill, pattern: handle } : null;
+}
+var cache6 = /* @__PURE__ */ new Map();
 var subscribers2 = /* @__PURE__ */ new Set();
 var defaultLoader = async (src) => {
   if (typeof Image === "undefined" || typeof createImageBitmap === "undefined") {
@@ -14570,28 +15554,28 @@ function notify() {
 }
 function startLoad(src) {
   const entry = { status: "loading" };
-  cache4.set(src, entry);
+  cache6.set(src, entry);
   loader(src).then(
     (bitmap) => {
-      if (cache4.get(src) !== entry) return;
-      cache4.set(src, { status: "ready", bitmap });
+      if (cache6.get(src) !== entry) return;
+      cache6.set(src, { status: "ready", bitmap });
       notify();
     },
     () => {
-      if (cache4.get(src) !== entry) return;
-      cache4.set(src, { status: "error" });
+      if (cache6.get(src) !== entry) return;
+      cache6.set(src, { status: "error" });
       notify();
     }
   );
 }
 function getImageBitmap(src) {
-  const entry = cache4.get(src);
+  const entry = cache6.get(src);
   if (entry) return entry.bitmap;
   startLoad(src);
   return void 0;
 }
 function imageStatus(src) {
-  return cache4.get(src)?.status ?? "idle";
+  return cache6.get(src)?.status ?? "idle";
 }
 function subscribeImageReady(cb) {
   subscribers2.add(cb);
@@ -14685,6 +15669,13 @@ function shapeCoversPoint(node, pose, x, y, opts = {}) {
   const reach = ink.strokeWidth / 2 + (opts.tolerance ?? 0);
   return reach > 0 && strokeHitTest(sil, x, y, reach);
 }
+function withLeafStroke(style, stroke, strokeWidth) {
+  if (style?.stroke !== void 0) return style;
+  if (!stroke || stroke === "none") return style;
+  const width = strokeWidth ?? 1;
+  if (width <= 0) return style;
+  return { ...style, stroke: { paint: { color: stroke }, width } };
+}
 var TEXT_PAINTER = {
   id: "kit:text",
   matches: (node) => {
@@ -14703,7 +15694,8 @@ var TEXT_PAINTER = {
     const d = node.data;
     const p = pose;
     const y = p.y;
-    return d.runs && d.runs.length > 0 ? [textCommandFromRuns(p.x, y, d.runs, d.style, void 0, p.height)] : [textCommand(p.x, y, d.text, d.style, void 0, p.height)];
+    const style = withLeafStroke(d.style, d.stroke, d.strokeWidth);
+    return d.runs && d.runs.length > 0 ? [textCommandFromRuns(p.x, y, d.runs, style, void 0, p.height)] : [textCommand(p.x, y, d.text, style, void 0, p.height)];
   }),
   // The pose is a *wrap box*, not a bounding box — "Away" in a 300-unit box
   // leaves most of it empty, and a pose-rect silhouette claims all of it. The
@@ -14761,6 +15753,17 @@ function rectsToPath(rects) {
   }
   return { kind: "polygon", commands, coords, fillRule: "nonzero" };
 }
+function isFillStyle(v) {
+  return typeof v === "object" && v !== null;
+}
+function resolveNodeFill(fill, color, hasStroke, fallback) {
+  if (isFillStyle(fill)) return fill;
+  const c = fill ?? color;
+  if (c === "none") return null;
+  if (c !== void 0) return { color: c };
+  if (hasStroke && fallback === null) return null;
+  return fallback === null ? null : { color: fallback };
+}
 var PATH_PAINTER = {
   id: "kit:path",
   matches: (node) => {
@@ -14774,12 +15777,12 @@ var PATH_PAINTER = {
     const d = node.data;
     const projected = pathInPoseFrame(d.path, pose);
     const hasStroke = !!d.stroke && d.stroke !== "none" && (d.strokeWidth ?? 0) > 0;
-    const fillColor = d.fill ?? d.color;
-    const hasFill = fillColor !== "none" && (fillColor !== void 0 || !hasStroke);
+    const declared = resolveNodeFill(d.fill, d.color, hasStroke, hasStroke ? null : "#888");
+    const fill = declared && resolveFillPattern(fillInPoseFrame(declared, pose));
     const cmd = {
       kind: "path",
       path: projected,
-      ...hasFill ? { fill: { color: fillColor ?? "#888" } } : {},
+      ...fill ? { fill } : {},
       ...hasStroke ? { stroke: { paint: { color: d.stroke }, width: d.strokeWidth ?? 1 } } : {}
     };
     return [cmd];
@@ -14795,9 +15798,8 @@ var PATH_PAINTER = {
   ink: (node) => {
     const d = node.data;
     const hasStroke = !!d.stroke && d.stroke !== "none" && (d.strokeWidth ?? 0) > 0;
-    const fillColor = d.fill ?? d.color;
     return {
-      filled: fillColor !== "none" && (fillColor !== void 0 || !hasStroke),
+      filled: resolveNodeFill(d.fill, d.color, hasStroke, hasStroke ? null : "#888") !== null,
       strokeWidth: hasStroke ? d.strokeWidth ?? 1 : 0
     };
   }
@@ -14814,10 +15816,12 @@ var SHAPE_PAINTER = {
   paint: (node, pose) => nodeMemo(node, PAINT_SLOT, pose, () => {
     const d = node.data;
     const path = pathForShape(d, pose);
+    const declaredFill = resolveNodeFill(d.fill, d.color, false, "#888");
+    const shapeFill = declaredFill && resolveFillPattern(fillInPoseFrame(declaredFill, pose));
     return [{
       kind: "path",
       path,
-      fill: { color: d.fill ?? d.color ?? "#888" },
+      ...shapeFill ? { fill: shapeFill } : {},
       ...d.stroke && (d.strokeWidth ?? 0) > 0 ? { stroke: { paint: { color: d.stroke }, width: d.strokeWidth ?? 1 } } : {}
     }];
   }),
@@ -15213,11 +16217,8 @@ function useSelectTool(adapter, options) {
             ...moveOpts
           },
           { spec: { kind: "drag", target: "empty" }, actionId: "areaSelect" },
-          // Click on empty canvas → clear. Same no-affordance requirement as
-          // the press binding above, and for the same two reasons: clicking a
-          // widget that happens to float over empty canvas isn't a click on
-          // empty canvas, and declining in the SPEC lets the chrome's owner
-          // have the click instead of it being consumed here.
+          // resize/rotate bind only drag (no click), so a click on either handle
+          // (body genuinely empty) would hit target:'empty' and wrongly clear selection.
           {
             spec: {
               kind: "click",
@@ -15301,17 +16302,17 @@ function worldToLocal(xf, wx, wy) {
 function annulusSemiAxes(shape, view) {
   const bandPx = shape.minBandPx ?? 0;
   if (bandPx === 0) return { rx: shape.rx, ry: shape.ry };
-  const band = bandPx / meanScale(view.scale);
+  const band = pxExtent(bandPx, view.scale);
   return {
-    rx: Math.max(shape.rx, shape.innerWidth / 2 + band),
-    ry: Math.max(shape.ry, shape.innerHeight / 2 + band)
+    rx: Math.max(shape.rx, shape.innerWidth / 2 + band.x),
+    ry: Math.max(shape.ry, shape.innerHeight / 2 + band.y)
   };
 }
 function hitRegion(region, wx, wy, xf, view) {
   const local = worldToLocal(xf, wx, wy);
   if (region.shape.kind === "point") {
-    const radiusWorld = region.shape.hitRadiusPx / meanScale(view.scale);
-    return Math.abs(local.x - region.shape.x) <= radiusWorld && Math.abs(local.y - region.shape.y) <= radiusWorld;
+    const anchor = localToWorld(xf, region.shape.x, region.shape.y);
+    return withinPxBox(anchor.x - wx, anchor.y - wy, region.shape.hitRadiusPx, view.scale);
   }
   if (region.shape.kind === "annulus") {
     const s = region.shape;
@@ -15375,14 +16376,13 @@ function asIsVisible(data) {
 function recordRegionHitbox(debug, affordanceId, region, xf, view) {
   if (region.shape.kind === "point") {
     const w2 = localToWorld(xf, region.shape.x, region.shape.y);
-    const r2 = region.shape.hitRadiusPx / meanScale(view.scale);
+    const e = pxExtent(region.shape.hitRadiusPx, view.scale);
     debug.recordHitbox(affordanceId, "handle", {
       kind: "rect",
-      x: w2.x - r2,
-      y: w2.y - r2,
-      width: r2 * 2,
-      height: r2 * 2,
-      ...xf.identity ? {} : { rotation: Math.atan2(xf.sin, xf.cos) }
+      x: w2.x - e.x,
+      y: w2.y - e.y,
+      width: e.x * 2,
+      height: e.y * 2
     });
     return;
   }
@@ -15441,7 +16441,7 @@ function paintRegion(region, xf, view, state, viewT, out) {
   if (paint.kind === "annulus") {
     if (region.shape.kind !== "annulus") return;
     const s = region.shape;
-    const insetLocal = (paint.insetPx ?? 0) / meanScale(view.scale);
+    const insetLocal = pxExtent(paint.insetPx ?? 0, view.scale);
     const cmd = annulusCommand(s, annulusSemiAxes(s, view), insetLocal, xf, viewT, paint.fill, paint.stroke);
     if (cmd) out.push(cmd);
     return;
@@ -15458,13 +16458,13 @@ function paintRegion(region, xf, view, state, viewT, out) {
   }
 }
 function annulusCommand(shape, semiAxes, insetLocal, xf, viewT, fill, stroke) {
-  const rx = semiAxes.rx - insetLocal;
-  const ry = semiAxes.ry - insetLocal;
+  const rx = semiAxes.rx - insetLocal.x;
+  const ry = semiAxes.ry - insetLocal.y;
   if (rx <= 0 || ry <= 0) return null;
   const cx = shape.cx;
   const cy = shape.cy;
-  const rectHW = shape.innerWidth / 2 + insetLocal;
-  const rectHH = shape.innerHeight / 2 + insetLocal;
+  const rectHW = shape.innerWidth / 2 + insetLocal.x;
+  const rectHH = shape.innerHeight / 2 + insetLocal.y;
   const haveTopBottom = rectHH < ry;
   const haveLeftRight = rectHW < rx;
   if (!haveTopBottom && !haveLeftRight) return null;
@@ -15711,6 +16711,7 @@ function useHandTool(opts = {}) {
     () => Object.assign(defineViewportTool({
       id: "hand",
       capabilities: ["navigation"],
+      hotkey: "space",
       hookName: "useHandTool",
       presentation: {
         label: "Hand",
@@ -15831,10 +16832,6 @@ function mirrorHandle(anchor, out) {
   if (!out || anchor.altBroken) return void 0;
   return { x: 2 * anchor.x - out.x, y: 2 * anchor.y - out.y };
 }
-function dist2(ax, ay, bx, by) {
-  const dx = ax - bx, dy = ay - by;
-  return Math.hypot(dx, dy);
-}
 function usePenTool(options) {
   const { wrapPath, adapter, autoSelect = true, autoCommitOnClose = true, closeHitRadius = 8, snapPoint: snapPoint2 } = options;
   const scratchRef = useRef(null);
@@ -15858,11 +16855,14 @@ function usePenTool(options) {
     const fn = optsRef.current.snapPoint;
     return fn ? fn({ x, y }) : { x, y };
   }, []);
-  const closeRadius = useCallback((deps) => {
-    const view = deps.view?.get();
-    const scale2 = view?.scale ?? { x: 1, y: 1 };
-    return optsRef.current.closeHitRadius / meanScale(scale2);
-  }, []);
+  const withinCloseRadius = useCallback(
+    (deps, ax, ay, wx, wy) => {
+      const view = deps.view?.get();
+      const scale2 = view?.scale ?? { x: 1, y: 1 };
+      return withinPxRadius(ax - wx, ay - wy, optsRef.current.closeHitRadius, scale2);
+    },
+    []
+  );
   const actions = useMemo(() => {
     const s = () => scratchRef.current;
     return [
@@ -15878,10 +16878,9 @@ function usePenTool(options) {
             if (p?.pressX === void 0 || p.pressY === void 0) return;
             const { x: wx, y: wy } = snap2(p.pressX, p.pressY);
             const scratch = s();
-            const radius = closeRadius(deps);
             if (scratch.current && scratch.current.anchors.length >= 3) {
               const first = scratch.current.anchors[0];
-              if (dist2(first.x, first.y, wx, wy) <= radius) {
+              if (withinCloseRadius(deps, first.x, first.y, wx, wy)) {
                 scratch.current.closed = true;
                 scratch.finishedSubpaths.push(scratch.current);
                 scratch.current = null;
@@ -16000,7 +16999,7 @@ function usePenTool(options) {
         }
       }
     ];
-  }, [commit, snap2, closeRadius]);
+  }, [commit, snap2, withinCloseRadius]);
   return useMemo(() => {
     return defineTool({
       id: "pen",
@@ -16753,7 +17752,7 @@ function buildChromeState(args) {
     }
   };
 }
-var DEFAULT_ROTATION_HANDLE_DISTANCE = 24;
+var DEFAULT_ROTATION_HANDLE_DISTANCE = ROTATION_HANDLE_BASE_PX;
 function rotationHandle(pose, distance = DEFAULT_ROTATION_HANDLE_DISTANCE) {
   const rotation = pose.rotation ?? 0;
   const c = aabbCenter(pose);
@@ -16813,7 +17812,7 @@ var DEFAULT_HANDLE_OUTLINE = {
   paint: { fill: "solid", color: "#1a130d" },
   width: 1
 };
-var DEFAULT_HANDLE_SIZE = 8;
+var DEFAULT_HANDLE_SIZE = HANDLE_BASE_PX;
 function defaultHandlesOf(b) {
   return [
     { x: b.x, y: b.y },
@@ -17566,8 +18565,8 @@ function CanvasInner(props, ref) {
     const isVisible = getIsVisibleRef.current?.() ?? alwaysVisible;
     for (const layer of layers2) {
       if (!layer.hitTest) continue;
-      const binding = layer.hitTest(worldX, worldY, void 0, view, dims, isVisible);
-      if (binding) return { layerId: layer.id, binding };
+      const hit = layer.hitTest(worldX, worldY, void 0, view, dims, isVisible);
+      if (hit) return { layerId: layer.id, hit };
     }
     return null;
   }, []);
@@ -18003,7 +19002,7 @@ function CanvasInner(props, ref) {
       effectiveView,
       { width, height }
     );
-    renderer.render(commands);
+    renderer.render(commands, viewToMat3(effectiveView));
   }, [layersWithDebug, width, height, effectiveView, debugSink, redrawNonce, dprProp]);
   const shaderIdKey = shaders?.map((h) => h.id).join("|") ?? "";
   useEffect(() => {
@@ -20212,8 +21211,8 @@ var DEFAULT_FILL3 = "#d4c4a8";
 var DEFAULT_STROKE = "#1a130d";
 function createCornerResizeAffordance(opts = {}) {
   const {
-    handleHitRadius = 8,
-    handleSize = 8,
+    handleHitRadius = HANDLE_BASE_PX,
+    handleSize = HANDLE_BASE_PX,
     fill = DEFAULT_FILL3,
     stroke = DEFAULT_STROKE
   } = opts;
@@ -20351,8 +21350,8 @@ function createPathAnchorAffordances(getAnchorState, opts = {}) {
   };
   return [anchors, controls];
 }
-var HANDLE_HIT_RADIUS = 8;
-var ANCHOR_HIT_RADIUS = 8;
+var HANDLE_HIT_RADIUS = HANDLE_BASE_PX;
+var ANCHOR_HIT_RADIUS = ANCHOR_HIT_BASE_PX;
 function buildAffordanceAt(opts) {
   const {
     getChromeState,
@@ -20384,6 +21383,8 @@ function toAffordanceHit(hit) {
   const scratch = hit.binding.initialScratch ?? {};
   return {
     kind: hit.region.hitKind ?? `${hit.affordanceId}:${hit.regionId}`,
+    owner: hit.affordanceId,
+    strength: "shared",
     ...scratch.targetId !== void 0 ? { targetIds: [scratch.targetId] } : {},
     ...scratch.anchor !== void 0 ? { anchor: scratch.anchor } : {},
     ...scratch.fixedPoint !== void 0 ? { fixedPoint: scratch.fixedPoint } : {},
@@ -20904,7 +21905,7 @@ function chordLengthParam(samples) {
   ts[0] = 0;
   let total = 0;
   for (let i = 1; i < n; i++) {
-    total += dist3(samples[i - 1], samples[i]);
+    total += dist2(samples[i - 1], samples[i]);
     ts[i] = total;
   }
   if (total === 0) return null;
@@ -20937,13 +21938,13 @@ function solveLS(samples, ts, a, e, tStart, tEnd) {
   let alpha1;
   let alpha2;
   if (Math.abs(det) < 1e-12) {
-    const chord = dist3(a, e);
+    const chord = dist2(a, e);
     alpha1 = alpha2 = chord / 3;
   } else {
     alpha1 = (c22 * x1 - c12 * x2) / det;
     alpha2 = (c11 * x2 - c12 * x1) / det;
     if (alpha1 < 1e-6 || alpha2 < 1e-6) {
-      const chord = dist3(a, e);
+      const chord = dist2(a, e);
       alpha1 = alpha2 = chord / 3;
     }
   }
@@ -20979,7 +21980,7 @@ function newtonRefineT(p, t, p0, p1, p2, p3) {
 function sub(a, b) {
   return { x: a.x - b.x, y: a.y - b.y };
 }
-function dist3(a, b) {
+function dist2(a, b) {
   return Math.hypot(a.x - b.x, a.y - b.y);
 }
 function unit(v) {
@@ -21567,7 +22568,6 @@ function makeGetNodeAtPoint(pickEvery, nodeResolver) {
     return { id, kind, pose, data };
   };
 }
-var DEFAULT_HANDLE_SIZE2 = 8;
 var IS_DEV = (() => {
   try {
     return Boolean(import.meta.env?.DEV);
@@ -21586,10 +22586,10 @@ function recordCoordTrace(entry) {
   coordTrace.push(entry);
   if (coordTrace.length > COORD_TRACE_LIMIT) coordTrace.shift();
 }
-function mergeLayersWithDefaults(user) {
+function mergeLayersWithDefaults(user, targetScale = 1) {
   const defaults = {
     scene: { drawOne: defaultDrawOne },
-    selectionOverlay: { handles: { size: DEFAULT_HANDLE_SIZE2 } }
+    selectionOverlay: { handles: { size: HANDLE_BASE_PX * targetScale } }
   };
   if (!user) return defaults;
   const result = { ...user };
@@ -21677,8 +22677,10 @@ function SceneCanvasInner(props, ref) {
     chromeVisibility,
     getActiveMode,
     getFocused: getFocusedProp,
+    device,
     ...rest
   } = props;
+  const deviceProfile = useDeviceProfile(device);
   const isSerialized = (s) => typeof s === "object" && s != null && s.version === 1 && Array.isArray(s.nodes);
   const [bakedScene] = useState(
     () => isSerialized(sceneInput) ? sceneFromJSON(sceneInput, {}) : null
@@ -21796,7 +22798,7 @@ function SceneCanvasInner(props, ref) {
     }
   }), []);
   const selectToolWithDefaults = useMemo(() => ({
-    handleHitRadius: DEFAULT_HANDLE_SIZE2,
+    handleHitRadius: HANDLE_BASE_PX * deviceProfile.targetScale,
     // Shift-click belongs to the anchor selection while a path is being
     // anchor-edited; see `UseSelectToolOptions.extendClickLocked`.
     extendClickLocked: () => effectivePathEditingId() !== "",
@@ -21806,7 +22808,7 @@ function SceneCanvasInner(props, ref) {
     // pipeline (audit 3.4). The classifier is now `select.pick`, which
     // declares that capability itself — one rule, evaluated in one place.
     ...selectToolOpts
-  }), [selectToolOpts]);
+  }), [selectToolOpts, deviceProfile.targetScale]);
   const selectionRef = useRef(selection);
   selectionRef.current = selection;
   const kindClassifier = useMemo(() => {
@@ -21938,7 +22940,7 @@ function SceneCanvasInner(props, ref) {
     const getMode = getActiveModeRef.current;
     if (!getMode) return true;
     const registry22 = toolsForEligibilityRef.current?.registry;
-    const caps = registry22?.[toolId]?.capabilities ?? [];
+    const caps = registry22?.[toolId]?.eligibility.capabilities ?? [];
     if (caps.length === 0) return false;
     const allowed = getMode().allowedCapabilities;
     for (const c of caps) if (allowed.has(c)) return true;
@@ -21964,8 +22966,8 @@ function SceneCanvasInner(props, ref) {
     };
   }, [Boolean(onDoubleClick)]);
   const mergedLayers = useMemo(
-    () => mergeLayersWithDefaults(layers),
-    [layers]
+    () => mergeLayersWithDefaults(layers, deviceProfile.targetScale),
+    [layers, deviceProfile.targetScale]
   );
   const resolvedActions = useMemo(() => {
     if (selectToolOpts?.rotate !== false) return actions;
@@ -22024,6 +23026,8 @@ function SceneCanvasInner(props, ref) {
   chromeVisibilityRef.current = effectiveChromeVisibility;
   const getActiveModeRef = useRef(getActiveMode);
   getActiveModeRef.current = getActiveMode;
+  const deviceProfileRef = useRef(deviceProfile);
+  deviceProfileRef.current = deviceProfile;
   const resizablePredRef = useRef(selectToolOpts?.resize?.resizable);
   resizablePredRef.current = selectToolOpts?.resize?.resizable;
   const buildCurrentRuleCtx = useCallback(() => {
@@ -22045,7 +23049,8 @@ function SceneCanvasInner(props, ref) {
       mode: modeInfo.id,
       allowedCapabilities: modeInfo.allowedCapabilities,
       selectionResizable,
-      editingAnchors: effectivePathEditingId() !== ""
+      editingAnchors: effectivePathEditingId() !== "",
+      device: deviceProfileRef.current
     };
   }, [dispatcher, getHover]);
   const anchorEditingAllowed = useMemo(
@@ -22300,7 +23305,7 @@ function SceneCanvasInner(props, ref) {
       testHookRef.current?._markReady();
     }
   }, []);
-  return /* @__PURE__ */ jsx(DepRegistryProviderIfRoot, { children: /* @__PURE__ */ jsx(PointerProviderIfRoot, { children: /* @__PURE__ */ jsxs(ActionsProviderIfRoot, { children: [
+  return /* @__PURE__ */ jsx(DeviceProfileProvider, { value: device, children: /* @__PURE__ */ jsx(DepRegistryProviderIfRoot, { children: /* @__PURE__ */ jsx(PointerProviderIfRoot, { children: /* @__PURE__ */ jsxs(ActionsProviderIfRoot, { children: [
     canvas,
     /* @__PURE__ */ jsx(PointerPublisher, { canvasRef: internalCanvasRef, viewRef: currentViewRef }),
     /* @__PURE__ */ jsx(
@@ -22363,7 +23368,7 @@ function SceneCanvasInner(props, ref) {
       }
     ),
     children
-  ] }) }) });
+  ] }) }) }) });
 }
 function ToolKeybindingsMounter({
   internalTools,
@@ -22409,10 +23414,6 @@ function GestureDispatcherMounter({
     for (const tool of tools.ambient) m.set(tool.id, tool);
     return m;
   }, [tools.registry, tools.ambient]);
-  const ambientToolIds = useMemo(
-    () => tools.ambient.map((t) => t.id),
-    [tools.ambient]
-  );
   const boundsOfRef = useRef(boundsOf2);
   boundsOfRef.current = boundsOf2;
   const pickEveryRef = useRef(pickEvery);
@@ -22524,9 +23525,14 @@ function GestureDispatcherMounter({
       const worldPoint = clientToWorld2(screenPoint.x, screenPoint.y);
       const extra = canvasApiRef?.current?.hitTestExtras?.(worldPoint.x, worldPoint.y);
       if (extra) {
+        const claim = extra.hit;
         return {
           kind: `layer:${extra.layerId}`,
-          ...extra.binding.initialScratch !== void 0 ? { payload: extra.binding.initialScratch } : {}
+          owner: extra.layerId,
+          strength: claim.strength ?? "shared",
+          ...claim.claimedKinds !== void 0 ? { claimedKinds: claim.claimedKinds } : {},
+          ...claim.cursor !== void 0 ? { cursor: claim.cursor } : {},
+          ...claim.initialScratch !== void 0 ? { payload: claim.initialScratch } : {}
         };
       }
       return affordanceAt ? affordanceAt(worldPoint) : null;
@@ -22546,7 +23552,6 @@ function GestureDispatcherMounter({
     canvasRef,
     actions: registry22,
     toolsById,
-    ambientToolIds,
     enabled,
     keyboard,
     affordanceAt: wrappedAffordanceAt,
@@ -22777,7 +23782,7 @@ function renderSceneToCanvas(args) {
     entry.dpr = dpr;
   }
   const commands = buildSceneViewCommands(scene, view, drawOne, extraCommands);
-  entry.renderer.render(commands);
+  entry.renderer.render(commands, viewToMat3(view));
 }
 function SceneViewCanvasInner(props) {
   const { scene, view, width, height, drawOne, extraCommands, className, canvasRef } = props;
@@ -23151,6 +24156,6 @@ function oklchToOklab(L, C, h) {
   return [L, C * Math.cos(h), C * Math.sin(h)];
 }
 
-export { FALLBACK_FIT_VIEW, MinimapCanvas, SceneViewCanvas, UnknownIcon, buildSceneViewCommands, computeFitView2, computeIndicatorCommand, eligibleTool, evaluateEnabled, oklabToSrgbU8, oklchToOklab, renderSceneToCanvas, rgbaToHex, useActionsRegistry, useOptionalDepRegistry };
-//# sourceMappingURL=chunk-5XDFILHZ.js.map
-//# sourceMappingURL=chunk-5XDFILHZ.js.map
+export { FALLBACK_FIT_VIEW, MinimapCanvas, SceneViewCanvas, UnknownIcon, buildSceneViewCommands, computeFitView2, computeIndicatorCommand, eligibleContribution, evaluateEnabled, oklabToSrgbU8, oklchToOklab, renderSceneToCanvas, rgbaToHex, useActionsRegistry, useOptionalDepRegistry };
+//# sourceMappingURL=chunk-XVBXYKFJ.js.map
+//# sourceMappingURL=chunk-XVBXYKFJ.js.map