@weasel-js/core 0.8.0 → 1.0.0

package/dist/{chunk-DLV5F4NY.js → chunk-D2C6K6FO.js}

@@ -1,17 +1,17 @@
-import { defineViewportTool, reportRouteConflicts, defineTool, RESERVED_ID_PREFIXES, RESERVED_ID_NAMES } from './chunk-6DAUIMTO.js';
-import { scratchKey, createTransformOp, snap, getScratch, createReparentOp, setScratch } from './chunk-BPRHGTLQ.js';
-import { fixedCornerOf, DEFAULT_RESIZE_BEHAVIORS, CORNER_ANCHORS, cornerPoint } from './chunk-CMBE45MT.js';
-import { AUTO_POSE_DESCRIPTOR, RECT_POSE_DESCRIPTOR, resolveUnit, meanScale, pathPoseDescriptor, polygonFromPoints, starPath, regularPolygonPath, linePath, ellipsePath, rectPath, strokeHitTest, boundsOfPath, PATH_M, PATH_L, PATH_Z, PATH_Q, PATH_C, DEFAULT_FLATTEN_TOLERANCE, flattenQuadratic, flattenCubic, PathBuilder, pointInPath, transformPath, flattenCubicWithArcLen, flattenQuadraticWithArcLen, translatePath, PATH_CMD_LENGTHS, pointToGridCell } from './chunk-GLZLSPGJ.js';
+import { ActionDisabledReason, defineViewportTool, useOptionalDepRegistry, DepRegistryProvider, useActionsRegistry, ActionsProvider, useDepRegistry, defineTool, reportRouteConflicts, buildDepsFromRequires, useDepSource, actionBindings } from './chunk-DCIU3SRK.js';
+import { scratchKey, createTransformOp, snap, getScratch, createReparentOp, setScratch } from './chunk-UB6A6L77.js';
+import { fixedCornerOf, DEFAULT_RESIZE_BEHAVIORS, CORNER_ANCHORS, cornerPoint } from './chunk-Z3KNFTTS.js';
+import { AUTO_POSE_DESCRIPTOR, RECT_POSE_DESCRIPTOR, resolveUnit, pathPoseDescriptor, polygonFromPoints, starPath, regularPolygonPath, linePath, ellipsePath, rectPath, strokeHitTest, withinPxRadius, boundsOfPath, PATH_M, PATH_L, PATH_Z, PATH_Q, PATH_C, DEFAULT_FLATTEN_TOLERANCE, flattenQuadratic, flattenCubic, PathBuilder, pointInPath, transformPath, translatePath, pxExtent, remapRotatedLeaf, withinPxBox, flattenCubicWithArcLen, flattenQuadraticWithArcLen, PATH_CMD_LENGTHS, pointToGridCell } from './chunk-6SHZHXXR.js';
 import { dispatchApplyBatch, dlog, dwarn, usePointerContext, PointerContextProvider, applyOpsTo, extractWeaselClipboardFromSvg, parseWeaselClipboardText, materializePaste, WEASEL_CLIPBOARD_MIME, WEASEL_CLIPBOARD_MIME_WEB, sniffWeaselClipboardText } from './chunk-775XXAHR.js';
 import { createSetSelectionOp } from './chunk-BHVYVFGV.js';
 import { registerOpFactory, createDeleteOp, createInsertOp, rebuildOp } from './chunk-GVCNT7UH.js';
-import { getTexture } from './chunk-Y52N27PF.js';
+import { getTexture, chunks, dots, crosshatch, hatch } from './chunk-IO5Z75X4.js';
 import { createContext, createElement, forwardRef, useMemo, useRef, useState, useCallback, useImperativeHandle, useEffect, useSyncExternalStore, useContext, useReducer, useLayoutEffect } from 'react';
 import { subscribeGlyphReady, DEFAULT_BAKE_BUDGET, TEXT_VERT_SRC, TEXT_FRAG_SRC, TEXT_SDF_UNIFORMS, TEXT_SDF_ATTRIBUTES, TEXT_FRAG_R8_SRC, markAllFontsNotUploaded, resetBakeBudget, glyphGeneration, syncDynamicPageTexture, ensureFontTexture, dynamicPageTextureId, textureCacheKey, resolveFontVariant, resolveGlyphFallback, glyphOutline } from '@weasel-js/font';
 export { canQueryLocalFonts, canQueryLocalFonts as canQueryLocalFonts2, enableLocalFontOutlines, enableLocalFontOutlines as enableLocalFontOutlines2, hasFontOutlines, hasFontOutlines as hasFontOutlines2, isCanvasFont, isCanvasFont as isCanvasFont2, listFontOutlines, listFontOutlines as listFontOutlines2, outlineStatus, outlineStatus as outlineStatus2, registerCanvasFont, registerCanvasFont as registerCanvasFont2, registerFont, registerFont as registerFont2, registerFontOutlines, registerFontOutlines as registerFontOutlines2, subscribeGlyphReady, subscribeGlyphReady as subscribeGlyphReady2, unregisterCanvasFont, unregisterCanvasFont as unregisterCanvasFont2, unregisterFontOutlines, unregisterFontOutlines as unregisterFontOutlines2 } from '@weasel-js/font';
 import earcut from 'earcut';
-import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 import { applyToPoint, rotateAboutPoint, boxToBox, pointInPolygon, segmentsCross } from '@weasel-js/geom';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 import polygonClipping from 'polygon-clipping';
 import { matchSpec, mimeMatchesGlob } from '@weasel-js/gestures';
 import { NORMAL, IMPLICIT_TAGS } from '@weasel-js/modes';
@@ -19,7 +19,7 @@ import { createHistory } from '@weasel-js/history';
 export * from '@weasel-js/history';
 
 // src/version.ts
-var VERSION = "0.8.0" ;
+var VERSION = "1.0.0" ;
 
 // src/features/grid/roundToCell.ts
 function roundToCell(value, cellSize) {
@@ -333,6 +333,60 @@ var GRAD_FILL_UNIFORMS = [
 ];
 var GRAD_FILL_ATTRIBUTES = ["a_position"];
 
+// src/renderer/shaders/patternFill.ts
+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"];
+
 // src/renderer/cache/GLMeshCache.ts
 var GLMeshCache = class {
   constructor(gl, aPositionLoc) {
@@ -458,17 +512,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;
@@ -1100,6 +1157,18 @@ function scale(m, sx, sy) {
   const s = create(sx, 0, 0, sy, 0, 0);
   return multiply(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];
@@ -1127,6 +1196,7 @@ var mat3 = {
   multiply,
   translate,
   scale,
+  invert,
   apply,
   screenToClip
 };
@@ -3048,28 +3118,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);
@@ -3589,6 +3673,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);
@@ -3689,6 +3778,7 @@ var WeaselRenderer = class {
   textSdfR8;
   imageFill;
   gradFill;
+  patternFill;
   meshCache;
   textureCache;
   imageCache;
@@ -3764,6 +3854,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);
@@ -3872,6 +3965,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);
@@ -3944,7 +4040,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();
@@ -3959,6 +4063,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,
@@ -3973,7 +4078,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();
@@ -4021,6 +4127,10 @@ var WeaselRenderer = class {
     return this.gradFill;
   }
   /** @internal */
+  _patternFill() {
+    return this.patternFill;
+  }
+  /** @internal */
   _meshCache() {
     return this.meshCache;
   }
@@ -4086,6 +4196,11 @@ function alignedStrokeRect(rect, align, width = 1) {
   };
 }
 
+// src/core/viewport/meanScale.ts
+function meanScale(s) {
+  return Math.sqrt(s.x * s.y);
+}
+
 // src/features/grid/layer.ts
 var DEFAULT_LINE = {
   paint: { fill: "solid", color: "rgba(255, 255, 255, 0.08)" },
@@ -5224,254 +5339,6 @@ function matchesKeyBinding(e, b) {
   }
   return true;
 }
-var DepRegistryContext = createContext(null);
-function DepRegistryProvider({ children }) {
-  const sourcesRef = useRef(/* @__PURE__ */ new Map());
-  const registry2 = 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: registry2, 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 registry2 = useDepRegistry();
-  const sourceRef = useRef(source);
-  sourceRef.current = source;
-  useEffect(() => {
-    return registry2.register(name, () => sourceRef.current());
-  }, [name, registry2]);
-}
-
-// src/interactions/actions/buildDeps.ts
-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",
-  SceneEmpty: "scene-empty",
-  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
-      );
-    }
-    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 registry2 = 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: registry2, children });
-}
-function useActionsRegistry() {
-  return useContext(ActionsContext);
-}
-function useAction(action) {
-  const reg = useActionsRegistry();
-  useEffect(() => {
-    if (!reg) return;
-    return reg.register(action);
-  }, [reg, action]);
-}
 
 // src/interactions/actions/invoker.ts
 function resolveParams(params) {
@@ -6044,6 +5911,62 @@ var moveAction = {
   enabled: () => true
 };
 
+// src/features/paths/poseRotation.ts
+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_COUNT[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 rotate = (px, py) => {
+    const dx = px - cx;
+    const dy = py - cy;
+    return [cx + dx * cos - dy * sin, cy + dx * sin + dy * cos];
+  };
+  const [x0, y0] = rotate(x, y);
+  const [x1, y1] = rotate(x + w, y);
+  const [x2, y2] = rotate(x + w, y + h);
+  const [x3, y3] = rotate(x, y + h);
+  const commands = new Uint8Array([PATH_M, PATH_L, PATH_L, PATH_L, PATH_Z]);
+  const coords = new Float32Array([x0, y0, x1, y1, x2, y2, x3, y3]);
+  return { kind: "polygon", commands, coords, fillRule: "nonzero" };
+}
+var COORD_COUNT = {
+  [PATH_M]: 2,
+  [PATH_L]: 2,
+  [PATH_C]: 6,
+  [PATH_Q]: 4,
+  [PATH_Z]: 0
+};
+
 // src/interactions/actions/rotate/geometry.ts
 function aabbCenter(bounds) {
   return { x: bounds.x + bounds.width / 2, y: bounds.y + bounds.height / 2 };
@@ -6360,6 +6283,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();
@@ -7217,7 +7147,13 @@ function makeViewportZoomAction(opts = {}) {
 var viewportZoomAction = makeViewportZoomAction();
 
 // src/interactions/dispatcher/predicates.ts
-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;
@@ -7258,17 +7194,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 };
@@ -7539,64 +7475,6 @@ function anchorsInRect(set, rect) {
   }
   return hits;
 }
-
-// src/features/paths/poseRotation.ts
-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_COUNT[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 rotate = (px, py) => {
-    const dx = px - cx;
-    const dy = py - cy;
-    return [cx + dx * cos - dy * sin, cy + dx * sin + dy * cos];
-  };
-  const [x0, y0] = rotate(x, y);
-  const [x1, y1] = rotate(x + w, y);
-  const [x2, y2] = rotate(x + w, y + h);
-  const [x3, y3] = rotate(x, y + h);
-  const commands = new Uint8Array([PATH_M, PATH_L, PATH_L, PATH_L, PATH_Z]);
-  const coords = new Float32Array([x0, y0, x1, y1, x2, y2, x3, y3]);
-  return { kind: "polygon", commands, coords, fillRule: "nonzero" };
-}
-var COORD_COUNT = {
-  [PATH_M]: 2,
-  [PATH_L]: 2,
-  [PATH_C]: 6,
-  [PATH_Q]: 4,
-  [PATH_Z]: 0
-};
-
-// src/features/paths/pathInWorld.ts
 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;
@@ -9281,7 +9159,7 @@ var LABEL = {
   divide: "Divide",
   crop: "Crop"
 };
-function isEmpty(p) {
+function isEmpty2(p) {
   return p.commands.length === 0;
 }
 function applyBooleanOp(adapter, op) {
@@ -9319,7 +9197,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);
@@ -9870,14 +9748,24 @@ var DEFAULT_PALETTE = [
 var GHOST_STROKE = DEFAULT_PALETTE[0];
 
 // src/interactions/actions/defaults/setFill.ts
+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",
@@ -9892,9 +9780,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);
@@ -9905,15 +9794,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) {
@@ -9923,8 +9817,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 };
@@ -10818,6 +10711,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;
@@ -10834,12 +10775,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_ENGAGED;
+  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)) {
@@ -10849,10 +10792,37 @@ 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_ENGAGED = /* @__PURE__ */ new Set();
 
+// src/contributions/eligibility.ts
+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;
+}
+
+// src/contributions/assemble.ts
+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;
+}
+
 // src/features/chrome-caps/rule.ts
 var ALWAYS = { all: [] };
 var NEVER = { any: [] };
@@ -11157,7 +11127,7 @@ function useHoverTracking(args) {
 function pointerGestureId(pointerId) {
   return `pointer-${pointerId ?? "mouse"}`;
 }
-var DEV2 = (() => {
+var DEV = (() => {
   try {
     return Boolean(import.meta.env?.DEV);
   } catch {
@@ -11165,9 +11135,9 @@ var DEV2 = (() => {
   }
 })();
 var TRACE_LIMIT = 200;
-var traceLog = DEV2 && typeof window !== "undefined" ? window.__weaselDispatchLog__ ??= [] : [];
+var traceLog = DEV && typeof window !== "undefined" ? window.__weaselDispatchLog__ ??= [] : [];
 function recordTrace(entry) {
-  if (!DEV2) return;
+  if (!DEV) return;
   traceLog.push(entry);
   if (traceLog.length > TRACE_LIMIT) traceLog.shift();
 }
@@ -11198,6 +11168,7 @@ function filterEligible(matches, actionLookup, ruleCtx) {
     return isEligible(action, ruleCtx);
   });
 }
+var EMPTY_TRIGGERS = /* @__PURE__ */ new Set();
 var EMPTY_ENGAGED2 = /* @__PURE__ */ new Set();
 function modifiersOf(e) {
   return { alt: e.altKey, ctrl: e.ctrlKey, meta: e.metaKey, shift: e.shiftKey };
@@ -11305,34 +11276,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;
@@ -11487,15 +11447,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
             };
@@ -11867,7 +11838,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();
@@ -11882,7 +11853,6 @@ function useGestureDispatcher(opts) {
     activeToolId: activeTool.active,
     hotkeyStack: activeTool.hotkeyStack,
     toolsById,
-    ambientToolIds,
     isMac: IS_MAC,
     getRuleCtx
   });
@@ -11892,7 +11862,6 @@ function useGestureDispatcher(opts) {
     activeToolId: activeTool.active,
     hotkeyStack: activeTool.hotkeyStack,
     toolsById,
-    ambientToolIds,
     isMac: IS_MAC,
     getRuleCtx
   };
@@ -11970,6 +11939,7 @@ function useGestureDispatcher(opts) {
         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 } : {}
       };
@@ -11979,11 +11949,15 @@ function useGestureDispatcher(opts) {
         y: down.worldY,
         clientX: down.clientX,
         clientY: down.clientY,
-        ...down.affordance !== void 0 ? { affordance: down.affordance } : {},
         ...shared
       });
       if (result === "unhandled") {
-        dispatch2({ kind: "contextmenu", ...shared });
+        dispatch2({
+          kind: "contextmenu",
+          worldX: down.worldX,
+          worldY: down.worldY,
+          ...shared
+        });
       }
     };
     const DOUBLE_CLICK_MAX_MS = 600;
@@ -12038,6 +12012,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,
@@ -12047,7 +12024,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") {
@@ -12341,6 +12321,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 } : {}
           };
@@ -12382,8 +12363,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,
@@ -12391,6 +12374,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 } : {}
       };
@@ -12790,47 +12776,209 @@ function useViewAnimation(setView) {
   );
   return { animateTo, animateToBounds, cancel };
 }
-function useTools(opts) {
-  if (!(opts.active in opts.registry)) {
-    throw new Error(`useTools: active "${opts.active}" not in registry`);
+
+// src/interactions/actions/defaults/toolOffhand.ts
+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"]
+  };
+}
+
+// src/contributions/useContributions.ts
+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 registry2 = [];
+    const ambient = [];
+    for (const entry of entriesRef.current) {
+      (entry.eligibility?.focus ? registry2 : ambient).push(entry);
+    }
+    reportRouteConflicts({
+      registry: registry2,
+      ambient,
+      actions: actionsRegistry?.list() ?? []
+    });
+  }, [entrySig, actionsRegistry]);
+  return useMemo(
+    () => ({
+      entries: entriesRef.current,
+      focused: focused2,
+      setFocused,
+      scopedBindings,
+      overlays
+    }),
+    [focused2, setFocused, scopedBindings, overlays]
+  );
+}
+
+// src/tools/useTools.ts
+function declareSlot(tool, slot) {
+  const hotkey = tool.def?.hotkey;
+  const eligibility = {
+    ...tool.eligibility,
+    [slot]: true,
+    ...hotkey ? { offhand: hotkey } : {}
+  };
+  return sameEligibility(tool.eligibility, eligibility) ? tool : { ...tool, eligibility };
+}
+function sameEligibility(a, b) {
+  if (!a) return false;
+  const keys = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
+  for (const key of keys) if (a[key] !== b[key]) return false;
+  return true;
+}
+function useTools(opts) {
+  if (!(opts.active in opts.registry)) {
+    throw new Error(`useTools: active "${opts.active}" not in registry`);
+  }
+  const ctx = useActiveToolContext();
+  const slotted = useMemo(() => {
+    const registry2 = {};
+    for (const [id, tool] of Object.entries(opts.registry)) {
+      registry2[id] = declareSlot(tool, "focus");
+    }
+    const ambient = (opts.ambient ?? []).map((t) => declareSlot(t, "always"));
+    const byId = /* @__PURE__ */ new Map();
+    for (const tool of [...Object.values(registry2), ...ambient]) {
+      const prior = byId.get(tool.id);
+      if (prior) byId.set(tool.id, { ...tool, eligibility: { ...prior.eligibility, ...tool.eligibility } });
+      else byId.set(tool.id, tool);
+    }
+    return { registry: registry2, ambient, entries: [...byId.values()] };
+  }, [opts.registry, opts.ambient]);
+  const contributions = useContributions({ entries: slotted.entries, focused: opts.active });
+  const hotkeyEngaged = ctx.hotkeyStack.at(-1) ?? null;
+  const slottedRef = useRef(slotted);
+  slottedRef.current = slotted;
+  const activeRef = useRef(contributions.focused);
+  activeRef.current = contributions.focused;
   const hotkeyRef = useRef(hotkeyEngaged);
   hotkeyRef.current = hotkeyEngaged;
+  const setFocused = contributions.setFocused;
   const setActive = useCallback(
     (id) => {
-      if (!(id in 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);
@@ -12842,32 +12990,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,
@@ -12875,8 +13003,8 @@ function useTools(opts) {
       hotkeyEngaged,
       engageHotkey,
       disengageHotkey,
-      ambient: ambientRef.current,
-      registry: registryRef.current,
+      ambient: slottedRef.current.ambient,
+      registry: slottedRef.current.registry,
       has,
       getActiveOverlays
     }),
@@ -12884,38 +13012,6 @@ function useTools(opts) {
   );
 }
 
-// src/interactions/actions/defaults/toolOffhand.ts
-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"]
-  };
-}
-
 // src/interactions/actions/defaults/toolActivate.ts
 var TOOL_ACTIVATE_ID = "tool.activate";
 function buildToolActivateBindings(specs) {
@@ -12992,9 +13088,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;
@@ -13002,19 +13095,6 @@ function useKeybindings(tools, options = {}) {
   optionsRef.current = options;
   const initialActiveRef = useRef(tools.active);
   const registry2 = useActionsRegistry();
-  useEffect(() => {
-    if (optionsRef.current.disable) return;
-    if (!registry2) 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 registry2.register(makeToolOffhandAction(bindings));
-  }, [registry2, tools]);
   useEffect(() => {
     if (optionsRef.current.disable) return;
     if (!registry2) return;
@@ -13576,8 +13656,108 @@ function textLineBoxes(pose, opts = {}) {
   return out;
 }
 
-// src/features/images/imageCache.ts
+// src/core/fillInPoseFrame.ts
+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 fillToBoundsFrame(fill, box) {
+  if (fill.fill === "pattern") {
+    const o = fill.origin ?? { x: 0, y: 0 };
+    return { ...fill, origin: { x: o.x - box.x, y: o.y - box.y }, units: "bounds" };
+  }
+  const isGradient = fill.fill === "linear-gradient" || fill.fill === "radial-gradient" || fill.fill === "conic-gradient";
+  if (!isGradient) return fill;
+  if (box.width === 0 || box.height === 0) return fill;
+  const fromBox = (p) => ({
+    x: (p.x - box.x) / box.width,
+    y: (p.y - box.y) / box.height
+  });
+  if (fill.fill === "linear-gradient") {
+    return { ...fill, from: fromBox(fill.from), to: fromBox(fill.to), units: "bounds" };
+  }
+  if (fill.fill === "radial-gradient") {
+    const scale2 = Math.hypot(box.width, box.height) / Math.SQRT2;
+    return { ...fill, center: fromBox(fill.center), radius: fill.radius / scale2, units: "bounds" };
+  }
+  return { ...fill, center: fromBox(fill.center), units: "bounds" };
+}
+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";
+}
+
+// src/features/patterns/resolveSpec.ts
 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;
+}
+
+// src/features/images/imageCache.ts
+var cache6 = /* @__PURE__ */ new Map();
 var subscribers = /* @__PURE__ */ new Set();
 var defaultLoader = async (src) => {
   if (typeof Image === "undefined" || typeof createImageBitmap === "undefined") {
@@ -13595,28 +13775,28 @@ function notify() {
 }
 function startLoad(src) {
   const entry = { status: "loading" };
-  cache5.set(src, entry);
+  cache6.set(src, entry);
   loader(src).then(
     (bitmap) => {
-      if (cache5.get(src) !== entry) return;
-      cache5.set(src, { status: "ready", bitmap });
+      if (cache6.get(src) !== entry) return;
+      cache6.set(src, { status: "ready", bitmap });
       notify();
     },
     () => {
-      if (cache5.get(src) !== entry) return;
-      cache5.set(src, { status: "error" });
+      if (cache6.get(src) !== entry) return;
+      cache6.set(src, { status: "error" });
       notify();
     }
   );
 }
 function getImageBitmap(src) {
-  const entry = cache5.get(src);
+  const entry = cache6.get(src);
   if (entry) return entry.bitmap;
   startLoad(src);
   return void 0;
 }
 function imageStatus(src) {
-  return cache5.get(src)?.status ?? "idle";
+  return cache6.get(src)?.status ?? "idle";
 }
 function subscribeImageReady(cb) {
   subscribers.add(cb);
@@ -13801,6 +13981,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) => {
@@ -13814,12 +14005,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];
@@ -13835,9 +14026,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
     };
   }
@@ -13854,10 +14044,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 } } : {}
     }];
   }),
@@ -14258,11 +14450,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",
@@ -14348,17 +14537,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;
@@ -14424,14 +14613,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;
   }
@@ -14490,7 +14678,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;
@@ -14507,13 +14695,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;
@@ -14774,6 +14962,7 @@ function useHandTool(opts = {}) {
     () => Object.assign(defineViewportTool({
       id: "hand",
       capabilities: ["navigation"],
+      hotkey: "space",
       hookName: "useHandTool",
       presentation: {
         label: "Hand",
@@ -14898,10 +15087,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);
@@ -14925,11 +15110,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 [
@@ -14945,10 +15133,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;
@@ -15067,7 +15254,7 @@ function usePenTool(options) {
         }
       }
     ];
-  }, [commit, snap2, closeRadius]);
+  }, [commit, snap2, withinCloseRadius]);
   return useMemo(() => {
     return defineTool({
       id: "pen",
@@ -16844,8 +17031,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;
   }, []);
@@ -17281,7 +17468,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(() => {
@@ -19721,6 +19908,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 } : {},
@@ -20249,7 +20438,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;
@@ -20282,13 +20471,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;
     }
   }
@@ -20324,7 +20513,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) {
@@ -21334,7 +21523,7 @@ function SceneCanvasInner(props, ref) {
     const getMode = getActiveModeRef.current;
     if (!getMode) return true;
     const registry2 = toolsForEligibilityRef.current?.registry;
-    const caps = registry2?.[toolId]?.capabilities ?? [];
+    const caps = registry2?.[toolId]?.eligibility.capabilities ?? [];
     if (caps.length === 0) return false;
     const allowed = getMode().allowedCapabilities;
     for (const c of caps) if (allowed.has(c)) return true;
@@ -21808,10 +21997,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);
@@ -21923,9 +22108,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;
@@ -21945,7 +22135,6 @@ function GestureDispatcherMounter({
     canvasRef,
     actions: registry2,
     toolsById,
-    ambientToolIds,
     enabled,
     keyboard,
     affordanceAt: wrappedAffordanceAt,
@@ -22203,7 +22392,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;
@@ -22543,7 +22732,7 @@ function renderSceneToPixels(args) {
     bakeBudget: Infinity
   });
   try {
-    renderer.render(plan.commands);
+    renderer.render(plan.commands, viewToMat3(plan.view));
     if (typeof gl.isContextLost === "function" && gl.isContextLost()) {
       throw new Error("renderSceneToPixels: WebGL2 context was lost during render");
     }
@@ -23267,6 +23456,64 @@ function applyStyleToRange(runs, start, end, patch) {
   return coalesceRuns(out);
 }
 
+// src/features/text/runs/flagRange.ts
+function nodeHasFlag(style, key) {
+  switch (key) {
+    case "bold":
+      return isBoldWeight(style.fontWeight);
+    case "italic":
+      return style.fontStyle === "italic";
+    case "underline":
+      return style.underline === true;
+    case "strikethrough":
+      return style.strikethrough === true;
+  }
+}
+function isBoldWeight(w) {
+  if (w === void 0) return false;
+  if (typeof w === "number") return w >= 600;
+  return w === "bold" || w === "bolder";
+}
+function weightIsExpressibleAsRunBold(w) {
+  return w === 700 || w === "bold";
+}
+function clearNodeFlag(style, key) {
+  const next = { ...style };
+  switch (key) {
+    case "bold":
+      next.fontWeight = 400;
+      break;
+    case "italic":
+      next.fontStyle = "normal";
+      break;
+    case "underline":
+      delete next.underline;
+      break;
+    case "strikethrough":
+      delete next.strikethrough;
+      break;
+  }
+  return next;
+}
+function setFlagOverRange(runs, style, start, end, key, value) {
+  if (value || !nodeHasFlag(style, key)) {
+    return {
+      runs: applyStyleToRange(runs, start, end, { [key]: value }),
+      style,
+      applied: true
+    };
+  }
+  if (key === "bold" && !weightIsExpressibleAsRunBold(style.fontWeight)) {
+    return { runs: [...runs], style, applied: false };
+  }
+  const total = runs.reduce((n, r) => n + r.text.length, 0);
+  const lo = Math.max(0, start);
+  const hi = Math.min(total, end);
+  let next = applyStyleToRange(runs, 0, total, { [key]: true });
+  if (lo < hi) next = applyStyleToRange(next, lo, hi, { [key]: false });
+  return { runs: next, style: clearNodeFlag(style, key), applied: true };
+}
+
 // src/features/text/useTextEdit.ts
 var FLAG_SHORTCUTS = [
   { key: "b", shift: false, flag: "bold" },
@@ -23428,7 +23675,21 @@ function useTextEdit(opts) {
         togglePending(flag);
         return;
       }
-      const next = toggleFlagInRange(domToRuns(overlay), range2.start, range2.end, flag);
+      if (editingId === null) return;
+      const runs = domToRuns(overlay);
+      const nodeStyle = optsRef.current.getStyle(editingId) ?? {};
+      const setStyle = optsRef.current.setStyle;
+      const current = styleAtRange(runs, range2.start, range2.end)[flag];
+      const unsetting = current === true;
+      if (unsetting && setStyle && nodeHasFlag(nodeStyle, flag)) {
+        const r = setFlagOverRange(runs, nodeStyle, range2.start, range2.end, flag, false);
+        if (!r.applied) return;
+        setStyle(editingId, r.style);
+        writeRunsPreservingSelection(overlay, r.runs, range2.start, range2.end);
+        syncSelection();
+        return;
+      }
+      const next = toggleFlagInRange(runs, range2.start, range2.end, flag);
       writeRunsPreservingSelection(overlay, next, range2.start, range2.end);
       syncSelection();
     }
@@ -23706,6 +23967,95 @@ function useSceneTextEdit(scene, container, options = {}) {
   return { ...edit, onDoubleClick };
 }
 
+// src/core/gradient.ts
+function sampleGradientStops(stops, t) {
+  if (stops.length === 0) return "rgba(0,0,0,0)";
+  const sorted = [...stops].sort((a, b) => a.offset - b.offset);
+  if (sorted.length === 1) return sorted[0].color;
+  const first = sorted[0];
+  const last = sorted[sorted.length - 1];
+  if (t <= first.offset) return first.color;
+  if (t >= last.offset) return last.color;
+  for (let i = 0; i < sorted.length - 1; i++) {
+    const lo = sorted[i];
+    const hi = sorted[i + 1];
+    if (t < lo.offset || t > hi.offset) continue;
+    const span = hi.offset - lo.offset;
+    if (span <= 0) return hi.color;
+    return lerpColor(lo.color, hi.color, (t - lo.offset) / span);
+  }
+  return last.color;
+}
+function lerpColor(a, b, t) {
+  const [ar, ag, ab, aa] = hexToRgba(a);
+  const [br, bg, bb, ba] = hexToRgba(b);
+  return rgbaToHex([
+    ar + (br - ar) * t,
+    ag + (bg - ag) * t,
+    ab + (bb - ab) * t,
+    aa + (ba - aa) * t
+  ]);
+}
+function withGradientKind(fill, kind) {
+  if (fill.fill === kind) return fill;
+  const common = { stops: fill.stops, units: fill.units, opacity: fill.opacity };
+  const { center, radius, angle } = gradientGeometry(fill);
+  if (kind === "linear-gradient") {
+    const dx = Math.cos(angle) * radius;
+    const dy = Math.sin(angle) * radius;
+    return {
+      fill: "linear-gradient",
+      from: { x: center.x - dx, y: center.y - dy },
+      to: { x: center.x + dx, y: center.y + dy },
+      ...common
+    };
+  }
+  if (kind === "radial-gradient") {
+    return { fill: "radial-gradient", center, radius, ...common };
+  }
+  return { fill: "conic-gradient", center, angle, ...common };
+}
+function gradientGeometry(fill) {
+  if (fill.fill === "linear-gradient") {
+    const dx = fill.to.x - fill.from.x;
+    const dy = fill.to.y - fill.from.y;
+    return {
+      center: { x: (fill.from.x + fill.to.x) / 2, y: (fill.from.y + fill.to.y) / 2 },
+      radius: Math.hypot(dx, dy) / 2,
+      angle: Math.atan2(dy, dx)
+    };
+  }
+  if (fill.fill === "radial-gradient") {
+    return { center: fill.center, radius: fill.radius, angle: 0 };
+  }
+  return { center: fill.center, radius: conicArmRadius(fill.units), angle: fill.angle };
+}
+function conicArmRadius(units) {
+  return units === "bounds" ? 0.5 : 50;
+}
+function gradientForBounds(kind, bounds, stops, units) {
+  const center = { x: bounds.x + bounds.width / 2, y: bounds.y + bounds.height / 2 };
+  if (kind === "linear-gradient") {
+    return {
+      fill: "linear-gradient",
+      from: { x: bounds.x, y: center.y },
+      to: { x: bounds.x + bounds.width, y: center.y },
+      stops,
+      units
+    };
+  }
+  if (kind === "radial-gradient") {
+    return {
+      fill: "radial-gradient",
+      center,
+      radius: Math.max(bounds.width, bounds.height) / 2,
+      stops,
+      units
+    };
+  }
+  return { fill: "conic-gradient", center, angle: 0, stops, units };
+}
+
 // src/core/ops/setText.ts
 function createSetTextOp(args) {
   const { id, from, to, label, coalesceKey = `setText:${id}` } = args;
@@ -25040,8 +25390,8 @@ function bestAxis(b, axis, anchors, candidates, worldTolerance) {
   return { delta: bestGuide ? bestDelta : 0, guide: bestGuide };
 }
 function matchAlignment(bounds, candidates, worldTolerance, anchors) {
-  const x = bestAxis(bounds, "x", anchors.x, candidates, worldTolerance);
-  const y = bestAxis(bounds, "y", anchors.y, candidates, worldTolerance);
+  const x = bestAxis(bounds, "x", anchors.x, candidates, worldTolerance.x);
+  const y = bestAxis(bounds, "y", anchors.y, candidates, worldTolerance.y);
   return { dx: x.delta, dy: y.delta, activeX: x.guide, activeY: y.guide };
 }
 
@@ -25049,7 +25399,7 @@ function matchAlignment(bounds, candidates, worldTolerance, anchors) {
 var activeList = (m) => [m.activeX, m.activeY].filter((g) => g !== null);
 function worldTol(base) {
   const t = base.tolerance ?? 6;
-  return base.getView ? t / Math.max(1e-9, meanScale(base.getView().scale)) : t;
+  return base.getView ? pxExtent(t, base.getView().scale) : { x: t, y: t };
 }
 function alignMoveBehavior(args) {
   const proj = args.projection ?? RECT_ALIGN_PROJECTION;
@@ -27270,6 +27620,24 @@ function snapPoint(opts) {
   };
 }
 
-export { ALWAYS, ANCHOR_HIT_BASE_PX, ActionDisabledReason, ActionsProvider, ActionsProviderIfRoot, ActiveToolContextProvider, ActiveToolContextProviderIfRoot, BUNDLE_TOOLS, COARSE_TARGET_SCALE, CURVE_REPS, ColorOverrideRegistry, CropIcon, CursorCoordsHud, DEFAULT_ALPHA_DECAY, DEFAULT_ALPHA_MIN, DEFAULT_DEBUG_THEME, DEFAULT_DEVICE_PROFILE, DEFAULT_FILL_COLOR, DEFAULT_HANDLE_SIZE2 as DEFAULT_HANDLE_SIZE, DEFAULT_PALETTE, DEFAULT_ROTATION_HANDLE_DISTANCE, DEFAULT_STROKE_COLOR, DEFAULT_TEXT_STYLE, DEFAULT_VELOCITY_DECAY, DepRegistryProvider, DepRegistryProviderIfRoot, DeviceProfileProvider, DivideIcon, EASINGS, EllipseIcon, ExcludeIcon, EyedropperIcon, FALLBACK_FIT_VIEW, GHOST_STROKE, HANDLE_BASE_PX, HandIcon, IDENTITY_COLOR_MATRIX, IDENTITY_POSE_COMPOSITION, IntersectIcon, KIT_SHAPE_KINDS, LassoIcon, LineIcon, MIXED, MOVE_ANCHORS, MinimapCanvas, NEVER, OUTLINE_MIN_SCREEN_PX, PATH_ANCHOR_CHROME_ID, PenIcon, PencilIcon, PickHud, PointerProviderIfRoot, PolygonIcon, RECT_ALIGN_PROJECTION, ROTATION_HANDLE_BASE_PX, RectIcon, SPRING_PRESETS, SceneCanvas, SceneViewCanvas, SelectIcon, SelectionContextProvider, SelectionContextProviderIfRoot, ShaderCompileError, StarIcon, SubtractIcon, TextIcon, UnionIcon, UnknownIcon, VERSION, WeaselProvider, WeaselRenderer, aabbCenter, actionIs, alignDeltaFor, alignInsertBehavior, alignMoveBehavior, alignResizeBehavior, alignedStrokeRect, always, and, animateLifecycle, animateOnSetPose, annulusSemiAxes, applyBooleanOp, applyHitExistingGate, applyStyleToRange, areaSelectAction, arrayAdapter, asNodeId, bezierCubic, bezierQuadratic, buildChromeCtx, buildGradientRamp, buildRuleCtx, buildSceneViewCommands, canBringForward, canHover, canSendBackward, capabilityAll, capabilityIn, capabilityIs, capabilityNot, caretIndexAt, cellAt, charOffsetToDomPosition, clampView, clearSelectionAction, clientToCanvas, clipboardCopyAction, clipboardCutAction, cloneAction, coarsePointer, composeAffordanceLayer, composePath, composeRectPose, composeSelectionPose, composeWorldPose, computeFitView2 as computeFitView, computeIndicatorCommand, computeWheelAction, cond, constrainTo45, containedThenNearest, countPathAnchors, createCellHighlightLayer, createChildrenLayer, createCornerResizeAffordance, createDebugOverlayLayer, createDebugSink, createDispatcher, createGridLayer, createGuidesLayer, createHistory2 as createHistory, createMarkdownRenderer, createMoveToIndexOp, createNodeProperties, createNodeRouting, createParallaxLayer, createPathAnchorAffordances, createPathEditingOverlayLayer, createPathLayer, createPenPreviewLayer, createReorderOp, createRotationAffordance, createScene, createSelectionHandlesLayer, createSelectionOutlineLayer, createSelectionOverlayLayer, createSetDataOp, createSetLayerOp, createSetPathOp, createSetTextOp, createTextLayer, createViewportLayer, cycleVertexColors, decomposePath, decomposeRectPose, defaultCommitAdapter, defaultDrawOne, defaultLabelTextRenderer, defaultNodeProperties, defaultNodeRouting, defaultVisibilityRules, deriveAlignmentGuides, deriveParallaxView, describeRule, domPositionToCharOffset, domToRuns, drawLayers, easeIn, easeInBack, easeInBounce, easeInCirc, easeInCubic, easeInElastic, easeInExpo, easeInOut, easeInOutBack, easeInOutBounce, easeInOutCirc, easeInOutCubic, easeInOutElastic, easeInOutExpo, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInOutSine, easeInQuad, easeInQuart, easeInQuint, easeInSine, easeOut, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic2 as easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, editAnchorsAction, enterTextEditAction, enumerateAnchors, evaluate, evaluateEnabled, findNodeShape, findShapeInk, findShapeSilhouette, fitTextPose, fitToBounds, fitViewToBounds, fitZoom, focused, fontString, forEachCoalesced, freeform, gateLayer, gesturing, getAlpha01, getImageBitmap, getNodeShapes, getStylusData, hexToRgba, hitAffordanceRegions, hitAnchor, hitRotationHandle, hovering, hoveringSelected, imageStatus, inferredNodeProperties, inferredNodeRouting, insertAction, isEditableTarget2 as isEditableTarget, lassoSelectAction, layoutMarkdown, lerpColorArray, lerpOklab, lerpOklch, linear, makeViewportZoomAction, markdownToRuns, mat3, matchAlignment, matchesKeyBinding, measureText, measureTextBounds, measuredWidth, mergeAlphaFromPrev, modeIn, modeIs, modeNot, modifierHeld, momentum, moveAction, multiActive, nearest, nearestWithin, nestedHitTester, never, none, normalizeHex, not, nurbs, oklabToOklch, oklabToSrgbU8, oklchToOklab, openFilePicker, or, parseColor, parseColorToRgba255, parseDebugFlags, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathDistanceToPoint, pathDivide, pathExclude, pathFromD, pathInPoseFrame, pathInWorld, pathIntersect, pathIntersectsPolygon, pathIntersectsRect, pathOriginProjection, pathSubtract, pathToAnchors, pathUnion, pickTopMostHit, pinchZoomAction, planPixelRender, pointInRotatedRect, pointInTextPose, poseRotationOf, pressureToWidth, rainbowVertexColors, rebaseLocalPose, rectCorners, registerContentHandler, registerNodeShape, registerProgram, renderLabel, renderSceneToCanvas, renderSceneToPixels, resizeAction, resolveColor, resolveDeviceProfile, resolveRuns, resolveTextStyle, resolveVisibility, rgbaToHex, rotateAction, rotateAroundAABBCenter, rotatePathAround, rotatePoint, rotatedRectCorners, rotationDegreesUnit, rotationHandle, roundToCell, runsToDom, runsToMarkdown, runsToPlainText, sceneFromJSON, sceneNodeClientRect, sceneToAdapter, screenToWorld, selectFromLasso, selectionAtLeast, selectionEmpty, selectionIs, shapeCoversPoint, sliceAction, snapPoint, solidVertexColors, specificity, spiro, splitPathByLine, splitSubpaths, springPose, springVertexColors, srgbU8ToOklab, staggerVertexColors, startThresholdDrag, styleAtRange, subscribeImageReady, tessellate, tessellateStroke, textCommand, textLineBoxes, tileGrid, toHex8, toRuns, translatePoseViaDescriptor, translateRectPose, tweenPose, tweenVertexColors, unionBounds, unionBoundsPath, useAction, useActionsRegistry, useActiveToolContext, useAlign, useAnimator, useArrayAdapter, useAutoCenter, useBooleans, useBooleansAdapter, useCanvasFocus, useCanvasSize, useDecayLoop, useDepRegistry, useDepSource, useDeviceProfile, useDistribute, useDragGesture, useDragHandle, useDragRadial, useDragRect, useDropZone, useEllipseTool, useEyedropperTool, useGestureDispatcher, useGridCellHover, useGuides, useHandTool, useHandleDrag, useHoverTracking, useImageTool, useKeybindings, useLassoTool, useLineTool, useOptionalActiveToolContext, useOptionalDepRegistry, usePenTool, usePencilTool, usePinchGesture, usePinchZoomTool, usePointerStylus, usePolygonTool, usePublishSelection, useRectTool, useResizePolicy, useRotateTool, useScene, useSceneAdapter, useSceneTextEdit, useSelectTool, useSelection, useSelectionContext, useSimulation, useSliceDep, useStandardActions, useStarTool, useTextEdit, useTextTool, useTools, useVelocityTracker, useViewAnimation, useViewTween, useZoom, verticalAlignOffset, viewToMat3, viewToTransform, viewportDragPanAction, viewportZoomAction, when, withAlpha01, withCoord, worldEditToStorage, worldPoseLookup, worldToScreen, zoomAt, zoomAtLeast };
-//# sourceMappingURL=chunk-DLV5F4NY.js.map
-//# sourceMappingURL=chunk-DLV5F4NY.js.map
+// src/contributions/merge.ts
+function mergeContributions(...bundles) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const bundle of bundles) {
+    for (const entry of bundle) {
+      if (seen.has(entry.id)) {
+        throw new Error(
+          `mergeContributions: duplicate contribution id "${entry.id}". Two bundles registered the same id; rename one or merge them by hand.`
+        );
+      }
+      seen.add(entry.id);
+      out.push(entry);
+    }
+  }
+  return out;
+}
+
+export { ALWAYS, ANCHOR_HIT_BASE_PX, ActionsProviderIfRoot, ActiveToolContextProvider, ActiveToolContextProviderIfRoot, BUNDLE_TOOLS, COARSE_TARGET_SCALE, CURVE_REPS, ColorOverrideRegistry, CropIcon, CursorCoordsHud, DEFAULT_ALPHA_DECAY, DEFAULT_ALPHA_MIN, DEFAULT_DEBUG_THEME, DEFAULT_DEVICE_PROFILE, DEFAULT_FILL_COLOR, DEFAULT_HANDLE_SIZE2 as DEFAULT_HANDLE_SIZE, DEFAULT_PALETTE, DEFAULT_ROTATION_HANDLE_DISTANCE, DEFAULT_STROKE_COLOR, DEFAULT_TEXT_STYLE, DEFAULT_VELOCITY_DECAY, DepRegistryProviderIfRoot, DeviceProfileProvider, DivideIcon, EASINGS, EllipseIcon, ExcludeIcon, EyedropperIcon, FALLBACK_FIT_VIEW, GHOST_STROKE, HANDLE_BASE_PX, HandIcon, IDENTITY_COLOR_MATRIX, IDENTITY_POSE_COMPOSITION, IntersectIcon, KIT_SHAPE_KINDS, LassoIcon, LineIcon, MIXED, MOVE_ANCHORS, MinimapCanvas, NEVER, OUTLINE_MIN_SCREEN_PX, PATH_ANCHOR_CHROME_ID, PenIcon, PencilIcon, PickHud, PointerProviderIfRoot, PolygonIcon, RECT_ALIGN_PROJECTION, ROTATION_HANDLE_BASE_PX, RectIcon, SPRING_PRESETS, SceneCanvas, SceneViewCanvas, SelectIcon, SelectionContextProvider, SelectionContextProviderIfRoot, ShaderCompileError, StarIcon, SubtractIcon, TextIcon, UnionIcon, UnknownIcon, VERSION, WeaselProvider, WeaselRenderer, aabbCenter, actionIs, alignDeltaFor, alignInsertBehavior, alignMoveBehavior, alignResizeBehavior, alignedStrokeRect, always, and, animateLifecycle, animateOnSetPose, annulusSemiAxes, applyBooleanOp, applyHitExistingGate, applyStyleToRange, areaSelectAction, arrayAdapter, asNodeId, bezierCubic, bezierQuadratic, buildChromeCtx, buildGradientRamp, buildRuleCtx, buildSceneViewCommands, canBringForward, canHover, canSendBackward, capabilityAll, capabilityIn, capabilityIs, capabilityNot, caretIndexAt, cellAt, charOffsetToDomPosition, clampView, clearSelectionAction, clientToCanvas, clipboardCopyAction, clipboardCutAction, cloneAction, coarsePointer, composeAffordanceLayer, composePath, composeRectPose, composeSelectionPose, composeWorldPose, computeFitView2 as computeFitView, computeIndicatorCommand, computeWheelAction, cond, constrainTo45, containedThenNearest, countPathAnchors, createCellHighlightLayer, createChildrenLayer, createCornerResizeAffordance, createDebugOverlayLayer, createDebugSink, createDispatcher, createGridLayer, createGuidesLayer, createHistory2 as createHistory, createMarkdownRenderer, createMoveToIndexOp, createNodeProperties, createNodeRouting, createParallaxLayer, createPathAnchorAffordances, createPathEditingOverlayLayer, createPathLayer, createPenPreviewLayer, createReorderOp, createRotationAffordance, createScene, createSelectionHandlesLayer, createSelectionOutlineLayer, createSelectionOverlayLayer, createSetDataOp, createSetLayerOp, createSetPathOp, createSetTextOp, createTextLayer, createViewportLayer, cycleVertexColors, decomposePath, decomposeRectPose, defaultCommitAdapter, defaultDrawOne, defaultLabelTextRenderer, defaultNodeProperties, defaultNodeRouting, defaultVisibilityRules, deriveAlignmentGuides, deriveParallaxView, describeRule, domPositionToCharOffset, domToRuns, drawLayers, easeIn, easeInBack, easeInBounce, easeInCirc, easeInCubic, easeInElastic, easeInExpo, easeInOut, easeInOutBack, easeInOutBounce, easeInOutCirc, easeInOutCubic, easeInOutElastic, easeInOutExpo, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInOutSine, easeInQuad, easeInQuart, easeInQuint, easeInSine, easeOut, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic2 as easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, editAnchorsAction, enterTextEditAction, enumerateAnchors, evaluate, fillInPoseFrame, fillToBoundsFrame, findNodeShape, findShapeInk, findShapeSilhouette, fitTextPose, fitToBounds, fitViewToBounds, fitZoom, focused, fontString, forEachCoalesced, freeform, gateLayer, gesturing, getAlpha01, getImageBitmap, getNodeShapes, getStylusData, gradientForBounds, gradientGeometry, hexToRgba, hitAffordanceRegions, hitAnchor, hitRotationHandle, hovering, hoveringSelected, imageStatus, inferredNodeProperties, inferredNodeRouting, insertAction, isEditableTarget2 as isEditableTarget, isPatternSpec, lassoSelectAction, layoutMarkdown, lerpColorArray, lerpOklab, lerpOklch, linear, liveScope, makeViewportZoomAction, markdownToRuns, mat3, matchAlignment, matchesKeyBinding, meanScale, measureText, measureTextBounds, measuredWidth, mergeAlphaFromPrev, mergeContributions, modeIn, modeIs, modeNot, modifierHeld, momentum, moveAction, multiActive, nearest, nearestWithin, nestedHitTester, never, nodeHasFlag, none, normalizeHex, not, nurbs, oklabToOklch, oklabToSrgbU8, oklchToOklab, openFilePicker, or, parseColor, parseColorToRgba255, parseDebugFlags, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathDistanceToPoint, pathDivide, pathExclude, pathFromD, pathInPoseFrame, pathInWorld, pathIntersect, pathIntersectsPolygon, pathIntersectsRect, pathOriginProjection, pathSubtract, pathToAnchors, pathUnion, pickTopMostHit, pinchZoomAction, planPixelRender, pointInRotatedRect, pointInTextPose, poseRotationOf, pressureToWidth, rainbowVertexColors, rebaseLocalPose, rectCorners, registerContentHandler, registerNodeShape, registerProgram, renderLabel, renderSceneToCanvas, renderSceneToPixels, resizeAction, resolveColor, resolveDeviceProfile, resolveFillPattern, resolvePatternSpec, resolveRuns, resolveTextStyle, resolveVisibility, rgbaToHex, rotateAction, rotateAroundAABBCenter, rotatePathAround, rotatePoint, rotatedRectCorners, rotationDegreesUnit, rotationHandle, roundToCell, runsToDom, runsToMarkdown, runsToPlainText, sampleGradientStops, sceneFromJSON, sceneNodeClientRect, sceneToAdapter, scopeBindings, screenToWorld, selectFromLasso, selectionAtLeast, selectionEmpty, selectionIs, setFlagOverRange, shapeCoversPoint, sliceAction, snapPoint, solidVertexColors, specificity, spiro, splitPathByLine, splitSubpaths, springPose, springVertexColors, srgbU8ToOklab, staggerVertexColors, startThresholdDrag, styleAtRange, subscribeImageReady, tessellate, tessellateStroke, textCommand, textLineBoxes, tileGrid, toHex8, toRuns, translatePoseViaDescriptor, translateRectPose, tweenPose, tweenVertexColors, unionBounds, unionBoundsPath, useActiveToolContext, useAlign, useAnimator, useArrayAdapter, useAutoCenter, useBooleans, useBooleansAdapter, useCanvasFocus, useCanvasSize, useDecayLoop, useDeviceProfile, useDistribute, useDragGesture, useDragHandle, useDragRadial, useDragRect, useDropZone, useEllipseTool, useEyedropperTool, useGestureDispatcher, useGridCellHover, useGuides, useHandTool, useHandleDrag, useHoverTracking, useImageTool, useKeybindings, useLassoTool, useLineTool, useOptionalActiveToolContext, usePenTool, usePencilTool, usePinchGesture, usePinchZoomTool, usePointerStylus, usePolygonTool, usePublishSelection, useRectTool, useResizePolicy, useRotateTool, useScene, useSceneAdapter, useSceneTextEdit, useSelectTool, useSelection, useSelectionContext, useSimulation, useSliceDep, useStandardActions, useStarTool, useTextEdit, useTextTool, useTools, useVelocityTracker, useViewAnimation, useViewTween, useZoom, verticalAlignOffset, viewToMat3, viewToTransform, viewportDragPanAction, viewportZoomAction, when, withAlpha01, withCoord, withGradientKind, worldEditToStorage, worldPoseLookup, worldToScreen, zoomAt, zoomAtLeast };
+//# sourceMappingURL=chunk-D2C6K6FO.js.map
+//# sourceMappingURL=chunk-D2C6K6FO.js.map