@weasel-js/core 0.7.2 → 1.0.0

package/dist/{chunk-5F3PIERN.js → chunk-D2C6K6FO.js}

@@ -1,17 +1,17 @@
-import { defineViewportTool, reportRouteConflicts, defineTool, RESERVED_ID_PREFIXES, RESERVED_ID_NAMES } from './chunk-SYM6RAM4.js';
-import { scratchKey, createTransformOp, snap, getScratch, createReparentOp, setScratch } from './chunk-VOVKONXA.js';
-import { fixedCornerOf, DEFAULT_RESIZE_BEHAVIORS, CORNER_ANCHORS, cornerPoint } from './chunk-BGGZ4CVF.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-CQNKCG34.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.7.2" ;
+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
 };
@@ -1501,6 +1571,16 @@ function extractPolygon(p, opts) {
     out.push(next);
     return next;
   };
+  const dropDuplicateClosingPoint = () => {
+    if (!pts || !aA || !aB || !aT) return;
+    const n = pts.length / 2;
+    if (n < 2) return;
+    if (pts[0] !== pts[(n - 1) * 2] || pts[1] !== pts[(n - 1) * 2 + 1]) return;
+    pts.length -= 2;
+    aA.length -= 1;
+    aB.length -= 1;
+    aT.length -= 1;
+  };
   const commit = (target) => {
     if (!pts || !aA || !aB || !aT) return;
     target.anchorA = new Uint32Array(aA);
@@ -1584,7 +1664,10 @@ function extractPolygon(p, opts) {
         break;
       }
       case PATH_Z: {
-        if (current) current.closed = true;
+        if (current) {
+          current.closed = true;
+          dropDuplicateClosingPoint();
+        }
         break;
       }
       default:
@@ -2067,8 +2150,20 @@ function sameFill(a, b) {
   }
   return false;
 }
-function groupKey(family, weight, style, synthetic, fill, source, page) {
-  return `${family}|${weight}|${style}|${synthetic.bold ? 1 : 0}${synthetic.italic ? 1 : 0}|${fillKey(fill)}|${source}|${page}`;
+function strokeKey(s) {
+  if (!s) return "-";
+  return [
+    fillKey(s.paint),
+    s.width ?? 1,
+    s.join ?? "miter",
+    s.cap ?? "butt",
+    s.miterLimit ?? "",
+    s.align ?? "center",
+    (s.dash ?? []).join(",")
+  ].join(":");
+}
+function groupKey(family, weight, style, synthetic, fill, stroke, source, page) {
+  return `${family}|${weight}|${style}|${synthetic.bold ? 1 : 0}${synthetic.italic ? 1 : 0}|${fillKey(fill)}|${strokeKey(stroke)}|${source}|${page}`;
 }
 function getOrCreateGroup(ctx, run, resolved, page, sourceOverride) {
   const atlasFamily = resolved.resolved.family;
@@ -2081,6 +2176,7 @@ function getOrCreateGroup(ctx, run, resolved, page, sourceOverride) {
     resolvedStyle,
     resolved.synthetic,
     run.fill,
+    source === "outline" ? run.stroke : void 0,
     source,
     page
   );
@@ -2094,6 +2190,9 @@ function getOrCreateGroup(ctx, run, resolved, page, sourceOverride) {
       source,
       page,
       fill: run.fill,
+      // Only the outline tier can paint it, and carrying it on an SDF group
+      // would be a promise the renderer cannot keep.
+      ...source === "outline" && run.stroke !== void 0 ? { stroke: run.stroke } : {},
       quads: [],
       glyphs: []
     };
@@ -2698,6 +2797,36 @@ function outlineMesh(key, d) {
   return mesh;
 }
 
+// src/renderer/cache/outlineStrokeMeshCache.ts
+var OUTLINE_STROKE_MESH_CACHE_LIMIT = 2048;
+var WIDTH_QUANTUM = 1 / 1024;
+var cache4 = /* @__PURE__ */ new Map();
+function quantizeEmWidth(emWidth) {
+  return Math.round(emWidth / WIDTH_QUANTUM) * WIDTH_QUANTUM;
+}
+function outlineStrokeMesh(glyphKey, d, emWidth, stroke) {
+  if (!(emWidth > 0)) return null;
+  const key = [
+    glyphKey,
+    emWidth,
+    stroke.join ?? "miter",
+    stroke.cap ?? "butt",
+    stroke.miterLimit ?? "",
+    stroke.align ?? "center",
+    (stroke.dash ?? []).join(",")
+  ].join("|");
+  const cached = cache4.get(key);
+  if (cached !== void 0) return cached.indices.length === 0 ? null : cached;
+  if (cache4.size >= OUTLINE_STROKE_MESH_CACHE_LIMIT) cache4 = /* @__PURE__ */ new Map();
+  const mesh = tessellateStroke(
+    pathFromD(d),
+    { ...stroke, width: emWidth },
+    { flattenTolerance: OUTLINE_FLATTEN_TOLERANCE }
+  );
+  cache4.set(key, mesh);
+  return mesh.indices.length === 0 ? null : mesh;
+}
+
 // src/renderer/draw.ts
 function setColorMatrixUniforms(ctx, prog) {
   const gl = ctx.gl;
@@ -2989,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);
@@ -3272,16 +3415,30 @@ function drawText(ctx, cmd) {
 var SYNTHETIC_ITALIC_RADIANS = 0.2094;
 function drawTextOutlineGroup(ctx, group, dy) {
   const mesh = outlineGroupMesh(group, dy);
-  if (!mesh) return;
-  drawPathFillByKind(ctx, group.fill, ctx.meshCache.uploadTransient(mesh));
+  if (mesh) drawPathFillByKind(ctx, group.fill, ctx.meshCache.uploadTransient(mesh));
+  if (!group.stroke) return;
+  const strokeMesh = outlineGroupStrokeMesh(group, dy);
+  if (strokeMesh) {
+    drawPathFillByKind(ctx, group.stroke.paint, ctx.meshCache.uploadTransient(strokeMesh));
+  }
 }
 function outlineGroupMesh(group, dy) {
+  return mergeGlyphMeshes(group, dy, (glyph) => outlineMesh(glyph.key, glyph.d));
+}
+function outlineGroupStrokeMesh(group, dy) {
+  const stroke = group.stroke;
+  if (!stroke) return null;
+  const width = stroke.width ?? 1;
+  if (!(width > 0)) return null;
+  return mergeGlyphMeshes(group, dy, (glyph) => glyph.scale > 0 ? outlineStrokeMesh(glyph.key, glyph.d, quantizeEmWidth(width / glyph.scale), stroke) : null);
+}
+function mergeGlyphMeshes(group, dy, meshFor) {
   const parts = [];
   let vertexFloats = 0;
   let indexCount = 0;
   for (const glyph of group.glyphs) {
-    const mesh = outlineMesh(glyph.key, glyph.d);
-    if (mesh.indices.length === 0) continue;
+    const mesh = meshFor(glyph);
+    if (!mesh || mesh.indices.length === 0) continue;
     parts.push({ mesh, glyph });
     vertexFloats += mesh.vertices.length;
     indexCount += mesh.indices.length;
@@ -3516,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);
@@ -3616,6 +3778,7 @@ var WeaselRenderer = class {
   textSdfR8;
   imageFill;
   gradFill;
+  patternFill;
   meshCache;
   textureCache;
   imageCache;
@@ -3691,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);
@@ -3799,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);
@@ -3871,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();
@@ -3886,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,
@@ -3900,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();
@@ -3948,6 +4127,10 @@ var WeaselRenderer = class {
     return this.gradFill;
   }
   /** @internal */
+  _patternFill() {
+    return this.patternFill;
+  }
+  /** @internal */
   _meshCache() {
     return this.meshCache;
   }
@@ -4013,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)" },
@@ -4731,16 +4919,115 @@ function startThresholdDrag(e, opts) {
   document.addEventListener("pointercancel", onCancel);
   return { isDragging: () => activated };
 }
+
+// src/core/device/profile.ts
+var COARSE_TARGET_SCALE = 1.75;
+function resolveDeviceProfile(detected, overrides) {
+  const coarsePointer2 = overrides?.coarsePointer ?? detected.coarsePointer;
+  const canHover2 = overrides?.canHover ?? detected.canHover;
+  const dpr = overrides?.dpr ?? detected.dpr;
+  const targetScale = overrides?.targetScale ?? (coarsePointer2 ? COARSE_TARGET_SCALE : 1);
+  return { coarsePointer: coarsePointer2, canHover: canHover2, dpr, targetScale };
+}
+var DEFAULT_DEVICE_PROFILE = resolveDeviceProfile({
+  coarsePointer: false,
+  canHover: true,
+  dpr: 1
+});
+
+// src/core/device/useDeviceProfile.ts
+var COARSE_QUERY = "(pointer: coarse)";
+var HOVER_QUERY = "(hover: hover)";
+function hasMatchMedia() {
+  return typeof window !== "undefined" && typeof window.matchMedia === "function";
+}
+function detectOnce() {
+  const dpr = typeof window !== "undefined" && window.devicePixelRatio || 1;
+  if (!hasMatchMedia()) {
+    return {
+      coarsePointer: DEFAULT_DEVICE_PROFILE.coarsePointer,
+      canHover: DEFAULT_DEVICE_PROFILE.canHover,
+      dpr
+    };
+  }
+  return {
+    coarsePointer: window.matchMedia(COARSE_QUERY).matches,
+    canHover: window.matchMedia(HOVER_QUERY).matches,
+    dpr
+  };
+}
+function useDetectedFacts() {
+  const [facts, setFacts] = useState(detectOnce);
+  useEffect(() => {
+    if (!hasMatchMedia()) return;
+    const coarseMq = window.matchMedia(COARSE_QUERY);
+    const hoverMq = window.matchMedia(HOVER_QUERY);
+    const onCoarse = (e) => setFacts((f) => ({ ...f, coarsePointer: e.matches }));
+    const onHover = (e) => setFacts((f) => ({ ...f, canHover: e.matches }));
+    coarseMq.addEventListener("change", onCoarse);
+    hoverMq.addEventListener("change", onHover);
+    let disposed = false;
+    let densityMq = null;
+    const onDensity = () => {
+      if (disposed) return;
+      const next = window.devicePixelRatio || 1;
+      setFacts((f) => f.dpr === next ? f : { ...f, dpr: next });
+      arm();
+    };
+    function arm() {
+      if (disposed) return;
+      densityMq?.removeEventListener("change", onDensity);
+      densityMq = window.matchMedia(
+        `(resolution: ${window.devicePixelRatio || 1}dppx)`
+      );
+      densityMq.addEventListener("change", onDensity);
+    }
+    arm();
+    setFacts({
+      coarsePointer: coarseMq.matches,
+      canHover: hoverMq.matches,
+      dpr: window.devicePixelRatio || 1
+    });
+    return () => {
+      disposed = true;
+      coarseMq.removeEventListener("change", onCoarse);
+      hoverMq.removeEventListener("change", onHover);
+      densityMq?.removeEventListener("change", onDensity);
+    };
+  }, []);
+  return facts;
+}
+var DeviceProfileContext = createContext(null);
+function useDeviceProfile(overrides) {
+  const provided = useContext(DeviceProfileContext);
+  const detected = useDetectedFacts();
+  const base = provided ?? detected;
+  const { coarsePointer: coarsePointer2, canHover: canHover2, dpr, targetScale } = overrides ?? {};
+  return useMemo(
+    () => resolveDeviceProfile(base, {
+      ...coarsePointer2 !== void 0 ? { coarsePointer: coarsePointer2 } : {},
+      ...canHover2 !== void 0 ? { canHover: canHover2 } : {},
+      ...dpr !== void 0 ? { dpr } : {},
+      ...targetScale !== void 0 ? { targetScale } : {}
+    }),
+    [base.coarsePointer, base.canHover, base.dpr, coarsePointer2, canHover2, dpr, targetScale]
+  );
+}
+function DeviceProfileProvider({ value, children }) {
+  const profile = useDeviceProfile(value);
+  return createElement(DeviceProfileContext.Provider, { value: profile }, children);
+}
+
+// src/core/viewport/useCanvasSize.ts
 function useCanvasSize(containerRef) {
-  const [size, setSize] = useState({ width: 0, height: 0, dpr: 1 });
+  const { dpr } = useDeviceProfile();
+  const [size, setSize] = useState({ width: 0, height: 0 });
   const measure3 = useCallback(() => {
     if (!containerRef.current) return;
     const rect = containerRef.current.getBoundingClientRect();
-    setSize({
-      width: rect.width,
-      height: rect.height,
-      dpr: window.devicePixelRatio || 1
-    });
+    setSize(
+      (prev) => prev.width === rect.width && prev.height === rect.height ? prev : { width: rect.width, height: rect.height }
+    );
   }, [containerRef]);
   useEffect(() => {
     measure3();
@@ -4750,9 +5037,14 @@ function useCanvasSize(containerRef) {
     }
     return () => observer.disconnect();
   }, [measure3, containerRef]);
-  return size;
+  return { width: size.width, height: size.height, dpr };
 }
 
+// src/core/device/targets.ts
+var HANDLE_BASE_PX = 8;
+var ANCHOR_HIT_BASE_PX = 8;
+var ROTATION_HANDLE_BASE_PX = 24;
+
 // src/core/viewport/fitToBounds.ts
 function fitZoom(availW, availH, contentW, contentH, clamp2) {
   const raw = Math.min(availW / contentW, availH / contentH);
@@ -5047,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) {
@@ -5867,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 };
@@ -6183,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();
@@ -6812,6 +6919,12 @@ var clearSelectionAction = {
   }
 };
 
+// src/interactions/actions/defaults/freshNodeId.ts
+var counter = 0;
+function freshNodeId() {
+  return asNodeId(`n${(counter++).toString(36)}-${Math.random().toString(36).slice(2, 8)}`);
+}
+
 // src/interactions/actions/defaults/clone.ts
 function translatePose(pose, dx, dy) {
   const p = pose;
@@ -6821,10 +6934,6 @@ function translatePose(pose, dx, dy) {
     y: (p["y"] ?? 0) + dy
   };
 }
-var cloneIdCounter = 0;
-function freshCloneId() {
-  return asNodeId(`n${(cloneIdCounter++).toString(36)}-${Math.random().toString(36).slice(2, 8)}`);
-}
 var cloneAction = {
   id: "clone",
   label: "Clone",
@@ -6891,7 +7000,7 @@ var cloneAction = {
             if (origin === void 0 || !originNode) continue;
             const newPose = translatePose(origin, dx, dy);
             const node = {
-              id: freshCloneId(),
+              id: freshNodeId(),
               kind: originNode.kind,
               layer: originNode.layer,
               pose: newPose,
@@ -7038,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;
@@ -7079,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 };
@@ -7360,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;
@@ -7754,6 +7811,125 @@ var pinchZoomAction = {
   enabled: () => true
 };
 
+// src/interactions/actions/defaults/delete.ts
+function hostIndex(scene, id) {
+  const node = scene.get(id);
+  const siblings = node?.parent == null ? scene.roots : scene.childrenOf(node.parent);
+  return siblings.indexOf(id);
+}
+function hasSelectedAncestor(scene, id, set) {
+  let parent = scene.get(id)?.parent ?? null;
+  while (parent != null) {
+    if (set.has(parent)) return true;
+    parent = scene.get(parent)?.parent ?? null;
+  }
+  return false;
+}
+function buildDeleteOps(scene, ids, label) {
+  const set = new Set(ids);
+  const ops = [];
+  for (const id of ids) {
+    const node = scene.get(id);
+    if (!node) continue;
+    if (hasSelectedAncestor(scene, id, set)) continue;
+    ops.push(createDeleteOp({
+      node,
+      index: hostIndex(scene, id),
+      label
+    }));
+  }
+  return ops;
+}
+var deleteAction = {
+  id: "delete",
+  label: "Delete",
+  // Suppressed while any tool is mid-gesture — accidentally hitting
+  // Delete during a drag shouldn't wipe the selection out from under
+  // the in-flight handle.
+  defaultBinding: {
+    kind: "key",
+    key: ["Delete", "Backspace"],
+    phase: [{ channel: "*", phase: "initial" }]
+  },
+  eligible: { capability: "edits-page" },
+  requires: ["scene", "selection", "applyOps"],
+  invoker: {
+    timing: "immediate",
+    run: (deps) => {
+      const selection = deps.selection;
+      const scene = deps.scene;
+      const applyOps = deps.applyOps;
+      if (!selection || !scene) return;
+      const ids = selection.get();
+      if (ids.length === 0) return;
+      const ops = buildDeleteOps(scene, ids, "Delete");
+      if (ops.length > 0) {
+        if (applyOps) applyOps(ops, "Delete");
+        else scene.applyBatch(ops, "Delete", defaultCommitAdapter(scene));
+      }
+      selection.set([]);
+    }
+  },
+  enabled: () => true
+};
+
+// src/interactions/actions/defaults/requiresSelection.ts
+function requiresSelection(deps) {
+  const selection = deps?.selection;
+  if (!selection || selection.get().length === 0) {
+    return ActionDisabledReason.SelectionRequired;
+  }
+  return true;
+}
+
+// src/interactions/actions/defaults/clipboard.ts
+var clipboardCopyAction = {
+  id: "clipboard.copy",
+  label: "Copy",
+  defaultBinding: { kind: "key", key: "c", mods: { mod: true } },
+  // Same gate as `duplicate`: a mode that can neither edit the page nor own a
+  // selection has nothing to copy. Notably excludes `text-edit`, where Cmd+C
+  // must stay the browser's own copy of the caret range.
+  eligible: { capability: ["edits-page", "creates-selection"] },
+  // `selection` is read by the `enabled` gate, not the invoker — the
+  // dispatcher builds deps for both, and an undeclared read is undefined.
+  requires: ["clipboard", "selection"],
+  invoker: {
+    timing: "immediate",
+    run: (deps) => {
+      deps.clipboard?.copy();
+    }
+  },
+  enabled: requiresSelection
+};
+var clipboardCutAction = {
+  id: "clipboard.cut",
+  label: "Cut",
+  defaultBinding: { kind: "key", key: "x", mods: { mod: true } },
+  eligible: { capability: "edits-page" },
+  requires: ["clipboard", "scene", "selection", "applyOps"],
+  invoker: {
+    timing: "immediate",
+    run: (deps) => {
+      const clipboard = deps.clipboard;
+      const selection = deps.selection;
+      const scene = deps.scene;
+      const applyOps = deps.applyOps;
+      if (!clipboard || !selection || !scene) return;
+      const ids = selection.get();
+      if (ids.length === 0) return;
+      clipboard.copy();
+      const ops = buildDeleteOps(scene, ids, "Cut");
+      if (ops.length > 0) {
+        if (applyOps) applyOps(ops, "Cut");
+        else scene.applyBatch(ops, "Cut", defaultCommitAdapter(scene));
+      }
+      selection.set([]);
+    }
+  },
+  enabled: requiresSelection
+};
+
 // src/interactions/actions/defaults/enterTextEdit.ts
 var enterTextEditAction = {
   id: "enterTextEdit",
@@ -7886,25 +8062,46 @@ var selectAllAction = {
   }
 };
 
-// src/interactions/actions/defaults/delete.ts
-function hostIndex(scene, id) {
+// src/interactions/actions/defaults/duplicate.ts
+var DUPLICATE_OFFSET = 12;
+function translatePose2(pose, dx, dy) {
+  const p = pose;
+  return { ...p, x: (p["x"] ?? 0) + dx, y: (p["y"] ?? 0) + dy };
+}
+function hasSelectedAncestor2(scene, id, set) {
+  let parent = scene.get(id)?.parent ?? null;
+  while (parent != null) {
+    if (set.has(parent)) return true;
+    parent = scene.get(parent)?.parent ?? null;
+  }
+  return false;
+}
+function copySubtree(scene, id, parent, offset, offsetDescendants, ops) {
   const node = scene.get(id);
-  const siblings = node?.parent == null ? scene.roots : scene.childrenOf(node.parent);
-  return siblings.indexOf(id);
+  if (!node) return null;
+  const newId = freshNodeId();
+  const copy = {
+    ...node,
+    id: newId,
+    pose: translatePose2(node.pose, offset.dx, offset.dy),
+    parent
+  };
+  ops.push(createInsertOp({ node: copy, label: "Duplicate" }));
+  const childOffset = offsetDescendants ? offset : { dx: 0, dy: 0 };
+  for (const child of scene.childrenOf(id)) {
+    copySubtree(scene, child, newId, childOffset, offsetDescendants, ops);
+  }
+  return newId;
 }
-var deleteAction = {
-  id: "delete",
-  label: "Delete",
-  // Suppressed while any tool is mid-gesture — accidentally hitting
-  // Delete during a drag shouldn't wipe the selection out from under
-  // the in-flight handle.
-  defaultBinding: {
-    kind: "key",
-    key: ["Delete", "Backspace"],
-    phase: [{ channel: "*", phase: "initial" }]
-  },
-  eligible: { capability: "edits-page" },
-  requires: ["scene", "selection", "applyOps"],
+var duplicateAction = {
+  id: "duplicate",
+  label: "Duplicate",
+  defaultBinding: { kind: "key", key: "d", mods: { mod: true } },
+  eligible: { capability: ["edits-page", "creates-selection"] },
+  // `selection` is read by the `enabled` gate as well as the invoker. An
+  // undeclared read throws inside the dev-build deps Proxy before the gate can
+  // answer, which is how this action spent a while doing nothing at all.
+  requires: ["scene", "selection", "applyOps", "poseComposition"],
   invoker: {
     timing: "immediate",
     run: (deps) => {
@@ -7914,44 +8111,22 @@ var deleteAction = {
       if (!selection || !scene) return;
       const ids = selection.get();
       if (ids.length === 0) return;
+      const set = new Set(ids);
+      const offset = { dx: DUPLICATE_OFFSET, dy: DUPLICATE_OFFSET };
       const ops = [];
+      const newIds = [];
       for (const id of ids) {
-        const node = scene.get(id);
+        const nid = asNodeId(id);
+        const node = scene.get(nid);
         if (!node) continue;
-        ops.push(createDeleteOp({
-          node,
-          index: hostIndex(scene, id),
-          label: "Delete"
-        }));
+        if (hasSelectedAncestor2(scene, nid, set)) continue;
+        const newId = copySubtree(scene, nid, node.parent ?? null, offset, deps.poseComposition === void 0, ops);
+        if (newId) newIds.push(newId);
       }
-      if (ops.length > 0) {
-        if (applyOps) applyOps(ops, "Delete");
-        else scene.applyBatch(ops, "Delete", defaultCommitAdapter(scene));
-      }
-      selection.set([]);
-    }
-  },
-  enabled: () => true
-};
-
-// src/interactions/actions/defaults/requiresSelection.ts
-function requiresSelection(deps) {
-  const selection = deps?.selection;
-  if (!selection || selection.get().length === 0) {
-    return ActionDisabledReason.SelectionRequired;
-  }
-  return true;
-}
-
-// src/interactions/actions/defaults/duplicate.ts
-var duplicateAction = {
-  id: "duplicate",
-  label: "Duplicate",
-  defaultBinding: { kind: "key", key: "d", mods: { mod: true } },
-  eligible: { capability: ["edits-page", "creates-selection"] },
-  invoker: {
-    timing: "immediate",
-    run: (_deps, params) => {
+      if (ops.length === 0) return;
+      if (applyOps) applyOps(ops, "Duplicate");
+      else scene.applyBatch(ops, "Duplicate", defaultCommitAdapter(scene));
+      selection.set(newIds);
     }
   },
   enabled: requiresSelection
@@ -8984,7 +9159,7 @@ var LABEL = {
   divide: "Divide",
   crop: "Crop"
 };
-function isEmpty(p) {
+function isEmpty2(p) {
   return p.commands.length === 0;
 }
 function applyBooleanOp(adapter, op) {
@@ -9022,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);
@@ -9573,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",
@@ -9595,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);
@@ -9608,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) {
@@ -9626,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 };
@@ -10021,7 +10211,8 @@ function resolveTextStyle(style) {
     selectionColor: style.selectionColor ?? null,
     letterSpacing: style.letterSpacing ?? DEFAULT_TEXT_STYLE.letterSpacing,
     underline: style.underline ?? DEFAULT_TEXT_STYLE.underline,
-    strikethrough: style.strikethrough ?? DEFAULT_TEXT_STYLE.strikethrough
+    strikethrough: style.strikethrough ?? DEFAULT_TEXT_STYLE.strikethrough,
+    ...style.stroke !== void 0 ? { stroke: style.stroke } : {}
   };
 }
 function fontString(s) {
@@ -10047,6 +10238,9 @@ function resolveRuns(runs, style) {
       fontWeight: run.bold ? 700 : baseWeight,
       fontStyle: run.italic ? "italic" : style.fontStyle,
       fill: run.fill ?? style.fill,
+      // Unlike the decorations below, a run's stroke *replaces* the node's
+      // rather than adding to it — there is only one outline to paint.
+      ...(run.stroke ?? style.stroke) !== void 0 ? { stroke: run.stroke ?? style.stroke } : {},
       letterSpacing: run.letterSpacing ?? style.letterSpacing,
       // `||`, not `??`: run-level decorations are additive over the node style.
       underline: run.underline || style.underline,
@@ -10435,7 +10629,9 @@ var KIT_STANDARD_DESCRIPTORS = [
   setStrokeAction,
   setFillOpacityAction,
   setStrokeOpacityAction,
-  ingestAction
+  ingestAction,
+  clipboardCopyAction,
+  clipboardCutAction
 ];
 function useStandardActions(opts) {
   const optsRef = useRef(opts);
@@ -10515,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;
@@ -10531,24 +10775,53 @@ 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)) {
         scopeMatches.push({ binding: sb.binding, scope, ownerToolId: sb.ownerToolId });
       }
     }
-    scopeMatches.sort((a, b) => compareSpecificity(a.binding.spec, b.binding.spec));
-    out.push(...scopeMatches);
+    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;
 }
-var EMPTY_ENGAGED = /* @__PURE__ */ new Set();
 
 // src/features/chrome-caps/rule.ts
 var ALWAYS = { all: [] };
@@ -10607,6 +10880,14 @@ function evaluateSelector(s, ctx) {
     const resizable2 = ctx.selectionResizable ?? true;
     if (resizable2 !== s.resizable) return false;
   }
+  if (s.coarsePointer !== void 0) {
+    const device = ctx.device ?? DEFAULT_DEVICE_PROFILE;
+    if (device.coarsePointer !== s.coarsePointer) return false;
+  }
+  if (s.canHover !== void 0) {
+    const device = ctx.device ?? DEFAULT_DEVICE_PROFILE;
+    if (device.canHover !== s.canHover) return false;
+  }
   return true;
 }
 var MAX_RULE_DEPTH = 10;
@@ -10702,6 +10983,8 @@ var capabilityIs = (cap) => cond({ capability: cap });
 var capabilityIn = (caps) => cond({ capability: { in: caps } });
 var capabilityAll = (caps) => cond({ capability: [...caps] });
 var capabilityNot = (cap) => cond({ capability: { not: cap } });
+var coarsePointer = cond({ coarsePointer: true });
+var canHover = cond({ canHover: true });
 var DEFAULT_ALLOWED_CAPABILITIES = /* @__PURE__ */ new Set([
   ...NORMAL.allows,
   ...IMPLICIT_TAGS
@@ -10718,7 +11001,8 @@ function buildRuleCtx(args) {
     mode: args.mode,
     allowedCapabilities: args.allowedCapabilities,
     selectionResizable: args.selectionResizable,
-    editingAnchors: args.editingAnchors
+    editingAnchors: args.editingAnchors,
+    device: args.device
   };
 }
 
@@ -10843,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 {
@@ -10851,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();
 }
@@ -10884,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 };
@@ -10991,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;
@@ -11173,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
             };
@@ -11553,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();
@@ -11568,7 +11853,6 @@ function useGestureDispatcher(opts) {
     activeToolId: activeTool.active,
     hotkeyStack: activeTool.hotkeyStack,
     toolsById,
-    ambientToolIds,
     isMac: IS_MAC,
     getRuleCtx
   });
@@ -11578,7 +11862,6 @@ function useGestureDispatcher(opts) {
     activeToolId: activeTool.active,
     hotkeyStack: activeTool.hotkeyStack,
     toolsById,
-    ambientToolIds,
     isMac: IS_MAC,
     getRuleCtx
   };
@@ -11634,6 +11917,49 @@ function useGestureDispatcher(opts) {
     const DRAG_THRESHOLD_PX = 4;
     const bufferedDown = /* @__PURE__ */ new Map();
     const lastPointerDown = /* @__PURE__ */ new Map();
+    const LONG_PRESS_MS = 500;
+    const longPressTimers = /* @__PURE__ */ new Map();
+    const cancelLongPress = (pointerId) => {
+      const t = longPressTimers.get(pointerId);
+      if (t !== void 0) {
+        clearTimeout(t);
+        longPressTimers.delete(pointerId);
+      }
+    };
+    const cancelAllLongPress = () => {
+      for (const t of longPressTimers.values()) clearTimeout(t);
+      longPressTimers.clear();
+    };
+    const fireLongPress = (pointerId) => {
+      const down = lastPointerDown.get(pointerId);
+      if (!down) return;
+      const shared = {
+        target: down.target,
+        altKey: down.altKey,
+        ctrlKey: down.ctrlKey,
+        metaKey: down.metaKey,
+        shiftKey: down.shiftKey,
+        ...down.affordance !== void 0 ? { affordance: down.affordance } : {},
+        ...down.bodyTarget !== void 0 ? { bodyTarget: down.bodyTarget } : {},
+        ...down.bodyKind !== void 0 ? { bodyKind: down.bodyKind } : {}
+      };
+      const result = dispatch2({
+        kind: "longpress",
+        x: down.worldX,
+        y: down.worldY,
+        clientX: down.clientX,
+        clientY: down.clientY,
+        ...shared
+      });
+      if (result === "unhandled") {
+        dispatch2({
+          kind: "contextmenu",
+          worldX: down.worldX,
+          worldY: down.worldY,
+          ...shared
+        });
+      }
+    };
     const DOUBLE_CLICK_MAX_MS = 600;
     const DOUBLE_CLICK_MAX_PX = 8;
     const onKeyDown = (e) => {
@@ -11686,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,
@@ -11695,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") {
@@ -11737,6 +12069,7 @@ function useGestureDispatcher(opts) {
       bufferedDown.set(e.pointerId, { ev, clientX: e.clientX, clientY: e.clientY });
       dispatch2({ ...ev, stage: "press" });
       lastPointerDown.set(e.pointerId, {
+        target: e.target,
         clientX: e.clientX,
         clientY: e.clientY,
         worldX: w.x,
@@ -11749,7 +12082,19 @@ function useGestureDispatcher(opts) {
         metaKey: e.metaKey,
         shiftKey: e.shiftKey
       });
+      if ((e.pointerType === "touch" || e.pointerType === "pen") && activePointers.size === 1) {
+        cancelLongPress(e.pointerId);
+        longPressTimers.set(
+          e.pointerId,
+          setTimeout(() => {
+            longPressTimers.delete(e.pointerId);
+            if (disposed) return;
+            fireLongPress(e.pointerId);
+          }, LONG_PRESS_MS)
+        );
+      }
       if (activePointers.size >= 2) {
+        cancelAllLongPress();
         for (const id of activePointers) bufferedDown.delete(id);
         const { centroid, spread } = computeMultiTouchGeometry(pointerPositions);
         if (!multiTouchStart) {
@@ -11780,6 +12125,7 @@ function useGestureDispatcher(opts) {
         const dy = e.clientY - buffered.clientY;
         if (Math.hypot(dx, dy) >= DRAG_THRESHOLD_PX) {
           bufferedDown.delete(e.pointerId);
+          cancelLongPress(e.pointerId);
           dispatch2(buffered.ev);
         }
       }
@@ -11893,6 +12239,7 @@ function useGestureDispatcher(opts) {
       clearHoverCursor();
     };
     const onPointerUp = (e) => {
+      cancelLongPress(e.pointerId);
       const prevSize = activePointers.size;
       activePointers.delete(e.pointerId);
       pointerPositions.delete(e.pointerId);
@@ -11974,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 } : {}
           };
@@ -11997,6 +12345,7 @@ function useGestureDispatcher(opts) {
       }, 0);
     };
     const onPointerCancel = (e) => {
+      cancelLongPress(e.pointerId);
       activePointers.delete(e.pointerId);
       pointerPositions.delete(e.pointerId);
       lastPointerDown.delete(e.pointerId);
@@ -12014,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,
@@ -12023,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 } : {}
       };
@@ -12119,6 +12473,7 @@ function useGestureDispatcher(opts) {
       window.removeEventListener("paste", onPaste);
       canvas?.classList.remove(DROPOVER_CLASS);
       clearHoverCursor();
+      cancelAllLongPress();
       disposed = true;
       dispatcher.cancelAll("cancel");
     };
@@ -12421,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);
@@ -12473,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,
@@ -12506,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
     }),
@@ -12515,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) {
@@ -12623,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;
@@ -12633,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;
@@ -13207,8 +13656,108 @@ function textLineBoxes(pose, opts = {}) {
   return out;
 }
 
+// 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 cache4 = /* @__PURE__ */ new Map();
+var cache6 = /* @__PURE__ */ new Map();
 var subscribers = /* @__PURE__ */ new Set();
 var defaultLoader = async (src) => {
   if (typeof Image === "undefined" || typeof createImageBitmap === "undefined") {
@@ -13226,28 +13775,28 @@ function notify() {
 }
 function startLoad(src) {
   const entry = { status: "loading" };
-  cache4.set(src, entry);
+  cache6.set(src, entry);
   loader(src).then(
     (bitmap) => {
-      if (cache4.get(src) !== entry) return;
-      cache4.set(src, { status: "ready", bitmap });
+      if (cache6.get(src) !== entry) return;
+      cache6.set(src, { status: "ready", bitmap });
       notify();
     },
     () => {
-      if (cache4.get(src) !== entry) return;
-      cache4.set(src, { status: "error" });
+      if (cache6.get(src) !== entry) return;
+      cache6.set(src, { status: "error" });
       notify();
     }
   );
 }
 function getImageBitmap(src) {
-  const entry = cache4.get(src);
+  const entry = cache6.get(src);
   if (entry) return entry.bitmap;
   startLoad(src);
   return void 0;
 }
 function imageStatus(src) {
-  return cache4.get(src)?.status ?? "idle";
+  return cache6.get(src)?.status ?? "idle";
 }
 function subscribeImageReady(cb) {
   subscribers.add(cb);
@@ -13348,6 +13897,13 @@ function shapeCoversPoint(node, pose, x, y, opts = {}) {
 function getNodeShapes() {
   return [...PAINTERS.high, ...PAINTERS.normal];
 }
+function withLeafStroke(style, stroke, strokeWidth) {
+  if (style?.stroke !== void 0) return style;
+  if (!stroke || stroke === "none") return style;
+  const width = strokeWidth ?? 1;
+  if (width <= 0) return style;
+  return { ...style, stroke: { paint: { color: stroke }, width } };
+}
 var TEXT_PAINTER = {
   id: "kit:text",
   matches: (node) => {
@@ -13366,7 +13922,8 @@ var TEXT_PAINTER = {
     const d = node.data;
     const p = pose;
     const y = p.y;
-    return d.runs && d.runs.length > 0 ? [textCommandFromRuns(p.x, y, d.runs, d.style, void 0, p.height)] : [textCommand(p.x, y, d.text, d.style, void 0, p.height)];
+    const style = withLeafStroke(d.style, d.stroke, d.strokeWidth);
+    return d.runs && d.runs.length > 0 ? [textCommandFromRuns(p.x, y, d.runs, style, void 0, p.height)] : [textCommand(p.x, y, d.text, style, void 0, p.height)];
   }),
   // The pose is a *wrap box*, not a bounding box — "Away" in a 300-unit box
   // leaves most of it empty, and a pose-rect silhouette claims all of it. The
@@ -13424,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) => {
@@ -13437,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];
@@ -13458,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
     };
   }
@@ -13477,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 } } : {}
     }];
   }),
@@ -13881,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",
@@ -13971,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;
@@ -14047,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;
   }
@@ -14113,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;
@@ -14130,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;
@@ -14397,6 +14962,7 @@ function useHandTool(opts = {}) {
     () => Object.assign(defineViewportTool({
       id: "hand",
       capabilities: ["navigation"],
+      hotkey: "space",
       hookName: "useHandTool",
       presentation: {
         label: "Hand",
@@ -14521,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);
@@ -14548,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 [
@@ -14568,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;
@@ -14690,7 +15254,7 @@ function usePenTool(options) {
         }
       }
     ];
-  }, [commit, snap2, closeRadius]);
+  }, [commit, snap2, withinCloseRadius]);
   return useMemo(() => {
     return defineTool({
       id: "pen",
@@ -15548,7 +16112,7 @@ function buildChromeState(args) {
 }
 
 // src/interactions/actions/rotate/handle.ts
-var DEFAULT_ROTATION_HANDLE_DISTANCE = 24;
+var DEFAULT_ROTATION_HANDLE_DISTANCE = ROTATION_HANDLE_BASE_PX;
 function rotationHandle(pose, distance = DEFAULT_ROTATION_HANDLE_DISTANCE) {
   const rotation = pose.rotation ?? 0;
   const c = aabbCenter(pose);
@@ -15663,7 +16227,7 @@ var DEFAULT_HANDLE_OUTLINE = {
   paint: { fill: "solid", color: "#1a130d" },
   width: 1
 };
-var DEFAULT_HANDLE_SIZE = 8;
+var DEFAULT_HANDLE_SIZE = HANDLE_BASE_PX;
 function defaultHandlesOf(b) {
   return [
     { x: b.x, y: b.y },
@@ -16467,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;
   }, []);
@@ -16904,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(() => {
@@ -19168,8 +19732,8 @@ var DEFAULT_FILL3 = "#d4c4a8";
 var DEFAULT_STROKE = "#1a130d";
 function createCornerResizeAffordance(opts = {}) {
   const {
-    handleHitRadius = 8,
-    handleSize = 8,
+    handleHitRadius = HANDLE_BASE_PX,
+    handleSize = HANDLE_BASE_PX,
     fill = DEFAULT_FILL3,
     stroke = DEFAULT_STROKE
   } = opts;
@@ -19311,8 +19875,8 @@ function createPathAnchorAffordances(getAnchorState, opts = {}) {
 }
 
 // src/canvas/affordanceAt.ts
-var HANDLE_HIT_RADIUS = 8;
-var ANCHOR_HIT_RADIUS = 8;
+var HANDLE_HIT_RADIUS = HANDLE_BASE_PX;
+var ANCHOR_HIT_RADIUS = ANCHOR_HIT_BASE_PX;
 function buildAffordanceAt(opts) {
   const {
     getChromeState,
@@ -19344,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 } : {},
@@ -19872,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;
@@ -19905,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;
     }
   }
@@ -19947,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) {
@@ -20584,7 +21150,7 @@ function makeGetNodeAtPoint(pickEvery, nodeResolver) {
     return { id, kind, pose, data };
   };
 }
-var DEFAULT_HANDLE_SIZE2 = 8;
+var DEFAULT_HANDLE_SIZE2 = HANDLE_BASE_PX;
 var IS_DEV = (() => {
   try {
     return Boolean(import.meta.env?.DEV);
@@ -20603,10 +21169,10 @@ function recordCoordTrace(entry) {
   coordTrace.push(entry);
   if (coordTrace.length > COORD_TRACE_LIMIT) coordTrace.shift();
 }
-function mergeLayersWithDefaults(user) {
+function mergeLayersWithDefaults(user, targetScale = 1) {
   const defaults = {
     scene: { drawOne: defaultDrawOne },
-    selectionOverlay: { handles: { size: DEFAULT_HANDLE_SIZE2 } }
+    selectionOverlay: { handles: { size: HANDLE_BASE_PX * targetScale } }
   };
   if (!user) return defaults;
   const result = { ...user };
@@ -20694,8 +21260,10 @@ function SceneCanvasInner(props, ref) {
     chromeVisibility,
     getActiveMode,
     getFocused: getFocusedProp,
+    device,
     ...rest
   } = props;
+  const deviceProfile = useDeviceProfile(device);
   const isSerialized = (s) => typeof s === "object" && s != null && s.version === 1 && Array.isArray(s.nodes);
   const [bakedScene] = useState(
     () => isSerialized(sceneInput) ? sceneFromJSON(sceneInput, {}) : null
@@ -20813,7 +21381,7 @@ function SceneCanvasInner(props, ref) {
     }
   }), []);
   const selectToolWithDefaults = useMemo(() => ({
-    handleHitRadius: DEFAULT_HANDLE_SIZE2,
+    handleHitRadius: HANDLE_BASE_PX * deviceProfile.targetScale,
     // Shift-click belongs to the anchor selection while a path is being
     // anchor-edited; see `UseSelectToolOptions.extendClickLocked`.
     extendClickLocked: () => effectivePathEditingId() !== "",
@@ -20823,7 +21391,7 @@ function SceneCanvasInner(props, ref) {
     // pipeline (audit 3.4). The classifier is now `select.pick`, which
     // declares that capability itself — one rule, evaluated in one place.
     ...selectToolOpts
-  }), [selectToolOpts]);
+  }), [selectToolOpts, deviceProfile.targetScale]);
   const selectionRef = useRef(selection);
   selectionRef.current = selection;
   const kindClassifier = useMemo(() => {
@@ -20955,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;
@@ -20981,8 +21549,8 @@ function SceneCanvasInner(props, ref) {
     };
   }, [Boolean(onDoubleClick)]);
   const mergedLayers = useMemo(
-    () => mergeLayersWithDefaults(layers),
-    [layers]
+    () => mergeLayersWithDefaults(layers, deviceProfile.targetScale),
+    [layers, deviceProfile.targetScale]
   );
   const resolvedActions = useMemo(() => {
     if (selectToolOpts?.rotate !== false) return actions;
@@ -21041,6 +21609,8 @@ function SceneCanvasInner(props, ref) {
   chromeVisibilityRef.current = effectiveChromeVisibility;
   const getActiveModeRef = useRef(getActiveMode);
   getActiveModeRef.current = getActiveMode;
+  const deviceProfileRef = useRef(deviceProfile);
+  deviceProfileRef.current = deviceProfile;
   const resizablePredRef = useRef(selectToolOpts?.resize?.resizable);
   resizablePredRef.current = selectToolOpts?.resize?.resizable;
   const buildCurrentRuleCtx = useCallback(() => {
@@ -21062,7 +21632,8 @@ function SceneCanvasInner(props, ref) {
       mode: modeInfo.id,
       allowedCapabilities: modeInfo.allowedCapabilities,
       selectionResizable,
-      editingAnchors: effectivePathEditingId() !== ""
+      editingAnchors: effectivePathEditingId() !== "",
+      device: deviceProfileRef.current
     };
   }, [dispatcher, getHover]);
   const anchorEditingAllowed = useMemo(
@@ -21317,7 +21888,7 @@ function SceneCanvasInner(props, ref) {
       testHookRef.current?._markReady();
     }
   }, []);
-  return /* @__PURE__ */ jsx(DepRegistryProviderIfRoot, { children: /* @__PURE__ */ jsx(PointerProviderIfRoot, { children: /* @__PURE__ */ jsxs(ActionsProviderIfRoot, { children: [
+  return /* @__PURE__ */ jsx(DeviceProfileProvider, { value: device, children: /* @__PURE__ */ jsx(DepRegistryProviderIfRoot, { children: /* @__PURE__ */ jsx(PointerProviderIfRoot, { children: /* @__PURE__ */ jsxs(ActionsProviderIfRoot, { children: [
     canvas,
     /* @__PURE__ */ jsx(PointerPublisher, { canvasRef: internalCanvasRef, viewRef: currentViewRef }),
     /* @__PURE__ */ jsx(
@@ -21380,7 +21951,7 @@ function SceneCanvasInner(props, ref) {
       }
     ),
     children
-  ] }) }) });
+  ] }) }) }) });
 }
 function ToolKeybindingsMounter({
   internalTools,
@@ -21426,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);
@@ -21541,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;
@@ -21563,7 +22135,6 @@ function GestureDispatcherMounter({
     canvasRef,
     actions: registry2,
     toolsById,
-    ambientToolIds,
     enabled,
     keyboard,
     affordanceAt: wrappedAffordanceAt,
@@ -21821,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;
@@ -22161,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");
     }
@@ -22760,7 +23331,8 @@ var STYLE_KEYS = [
   "fontFamily",
   "fontSize",
   "letterSpacing",
-  "fill"
+  "fill",
+  "stroke"
 ];
 var FLAG_KEYS = /* @__PURE__ */ new Set([
   "bold",
@@ -22788,8 +23360,9 @@ function valueAt(run, key) {
   if (FLAG_KEYS.has(key)) return value ?? false;
   return value;
 }
+var STRUCTURAL_KEYS = /* @__PURE__ */ new Set(["fill", "stroke"]);
 function sameValue(key, a, b) {
-  return key === "fill" ? deepEqual(a, b) : Object.is(a, b);
+  return STRUCTURAL_KEYS.has(key) ? deepEqual(a, b) : Object.is(a, b);
 }
 function sameStyle(a, b) {
   return STYLE_KEYS.every((key) => sameValue(key, valueAt(a, key), valueAt(b, key)));
@@ -22883,7 +23456,79 @@ 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" },
+  { key: "i", shift: false, flag: "italic" },
+  { key: "u", shift: false, flag: "underline" },
+  { key: "x", shift: true, flag: "strikethrough" }
+];
+function flagForKey(e) {
+  if (!e.metaKey && !e.ctrlKey) return null;
+  const key = e.key.toLowerCase();
+  return FLAG_SHORTCUTS.find((s) => s.key === key && s.shift === e.shiftKey)?.flag ?? null;
+}
+function pendingKey(flag) {
+  return `pending${flag[0].toUpperCase()}${flag.slice(1)}`;
+}
 function toggleFlagInRange(runs, start, end, flag) {
   const current = styleAtRange(runs, start, end)[flag];
   return applyStyleToRange(runs, start, end, { [flag]: current !== true });
@@ -23030,12 +23675,26 @@ 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();
     }
     function togglePending(flag) {
-      const key = flag === "bold" ? "pendingBold" : "pendingItalic";
+      const key = pendingKey(flag);
       if (overlay.dataset[key] === "1") {
         delete overlay.dataset[key];
       } else {
@@ -23053,9 +23712,9 @@ function useTextEdit(opts) {
         cancelEdit();
         return;
       }
-      if ((e.metaKey || e.ctrlKey) && (e.key === "b" || e.key === "i" || e.key === "B" || e.key === "I")) {
+      const flag = flagForKey(e);
+      if (flag) {
         e.preventDefault();
-        const flag = e.key.toLowerCase() === "b" ? "bold" : "italic";
         handleStyleToggle(flag);
       }
     };
@@ -23067,18 +23726,21 @@ function useTextEdit(opts) {
     };
     const onBeforeInput = (ie) => {
       if (ie.inputType !== "insertText" || !ie.data) return;
-      const pendingBold = overlay.dataset.pendingBold === "1";
-      const pendingItalic = overlay.dataset.pendingItalic === "1";
+      const pending = FLAG_SHORTCUTS.map((s) => s.flag).filter((flag) => overlay.dataset[pendingKey(flag)] === "1");
       ie.preventDefault();
       const sel2 = window.getSelection();
       if (!sel2 || sel2.rangeCount === 0) return;
       const range2 = sel2.getRangeAt(0);
       range2.deleteContents();
-      if (pendingBold || pendingItalic) {
+      if (pending.length > 0) {
         const span = document.createElement("span");
         span.setAttribute("data-run", "");
-        if (pendingBold) span.style.fontWeight = "700";
-        if (pendingItalic) span.style.fontStyle = "italic";
+        if (pending.includes("bold")) span.style.fontWeight = "700";
+        if (pending.includes("italic")) span.style.fontStyle = "italic";
+        const decorations = [];
+        if (pending.includes("underline")) decorations.push("underline");
+        if (pending.includes("strikethrough")) decorations.push("line-through");
+        if (decorations.length > 0) span.style.textDecoration = decorations.join(" ");
         span.textContent = ie.data;
         range2.insertNode(span);
         const after = document.createRange();
@@ -23086,8 +23748,7 @@ function useTextEdit(opts) {
         after.collapse(true);
         sel2.removeAllRanges();
         sel2.addRange(after);
-        delete overlay.dataset.pendingBold;
-        delete overlay.dataset.pendingItalic;
+        for (const flag of pending) delete overlay.dataset[pendingKey(flag)];
       } else {
         const textNode = document.createTextNode(ie.data);
         range2.insertNode(textNode);
@@ -23306,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;
@@ -24370,7 +25120,7 @@ function arrayAdapter(config) {
     poseBounds = defaultPoseBounds2,
     intersectsRect,
     nextId = defaultNextId,
-    translatePose: translatePose2 = defaultTranslatePose
+    translatePose: translatePose3 = defaultTranslatePose
   } = config;
   const getSelection = selectionRef ? () => selectionRef.current : () => [];
   const adapter = {
@@ -24446,7 +25196,7 @@ function arrayAdapter(config) {
       for (const n of src) {
         const cloned = JSON.parse(JSON.stringify(n));
         cloned.id = nextId();
-        const translated = translatePose2(toPose(cloned), dx, dy);
+        const translated = translatePose3(toPose(cloned), dx, dy);
         out.push(fromPose(cloned, translated));
       }
       return out;
@@ -24640,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 };
 }
 
@@ -24649,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;
@@ -26870,6 +27620,24 @@ function snapPoint(opts) {
   };
 }
 
-export { ALWAYS, ActionDisabledReason, ActionsProvider, ActionsProviderIfRoot, ActiveToolContextProvider, ActiveToolContextProviderIfRoot, BUNDLE_TOOLS, CURVE_REPS, ColorOverrideRegistry, CropIcon, CursorCoordsHud, DEFAULT_ALPHA_DECAY, DEFAULT_ALPHA_MIN, DEFAULT_DEBUG_THEME, 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, DivideIcon, EASINGS, EllipseIcon, ExcludeIcon, EyedropperIcon, FALLBACK_FIT_VIEW, GHOST_STROKE, 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, 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, canSendBackward, capabilityAll, capabilityIn, capabilityIs, capabilityNot, caretIndexAt, cellAt, charOffsetToDomPosition, clampView, clearSelectionAction, clientToCanvas, cloneAction, 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, 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, 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-5F3PIERN.js.map
-//# sourceMappingURL=chunk-5F3PIERN.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