@weasel-js/core 0.7.0 → 0.7.1

package/dist/{chunk-7F3SDUJ4.js → chunk-2J6V527H.js}

@@ -1,14 +1,14 @@
-import { defineViewportTool, defineTool, RESERVED_ID_PREFIXES, RESERVED_ID_NAMES } from './chunk-FSZEXVCR.js';
+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, boundsOfPath, PATH_M, PATH_L, PATH_Z, PATH_Q, PATH_C, DEFAULT_FLATTEN_TOLERANCE, flattenQuadratic, flattenCubic, PathBuilder, pointInPath, strokeHitTest, transformPath, flattenCubicWithArcLen, flattenQuadraticWithArcLen, translatePath, PATH_CMD_LENGTHS, pointToGridCell } from './chunk-CQNKCG34.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 { 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 { 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, resolveFontVariant, syncDynamicPageTexture, ensureFontTexture, dynamicPageTextureId, textureCacheKey, resolveGlyphFallback } from '@weasel-js/font';
-export { isCanvasFont, isCanvasFont as isCanvasFont2, registerCanvasFont, registerCanvasFont as registerCanvasFont2, registerFont, registerFont as registerFont2, subscribeGlyphReady, subscribeGlyphReady as subscribeGlyphReady2, unregisterCanvasFont, unregisterCanvasFont as unregisterCanvasFont2 } from '@weasel-js/font';
+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';
@@ -18,6 +18,9 @@ import { NORMAL, IMPLICIT_TAGS } from '@weasel-js/modes';
 import { createHistory } from '@weasel-js/history';
 export * from '@weasel-js/history';
 
+// src/version.ts
+var VERSION = "0.7.0" ;
+
 // src/features/grid/roundToCell.ts
 function roundToCell(value, cellSize) {
   return Math.round(value / cellSize) * cellSize || 0;
@@ -2067,11 +2070,11 @@ function sameFill(a, b) {
 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 getOrCreateGroup(ctx, run, resolved, page) {
+function getOrCreateGroup(ctx, run, resolved, page, sourceOverride) {
   const atlasFamily = resolved.resolved.family;
   const resolvedWeight = resolved.resolved.weight;
   const resolvedStyle = resolved.resolved.style;
-  const source = resolved.source;
+  const source = sourceOverride ?? resolved.source;
   const key = groupKey(
     atlasFamily,
     resolvedWeight,
@@ -2091,7 +2094,8 @@ function getOrCreateGroup(ctx, run, resolved, page) {
       source,
       page,
       fill: run.fill,
-      quads: []
+      quads: [],
+      glyphs: []
     };
     ctx.groups.set(key, g);
   }
@@ -2230,6 +2234,10 @@ function layoutRuns(runs, opts, origin) {
   while (i < entries.length) {
     const e = entries[i];
     if (e.isNewline) {
+      if (cur.entries.length === 0) {
+        cur.height = Math.max(cur.height, e.fontSize * opts.lineHeight);
+        cur.blank = e;
+      }
       commitLine();
       i++;
       continue;
@@ -2263,6 +2271,13 @@ function layoutRuns(runs, opts, origin) {
     i = j;
   }
   if (cur.entries.length > 0) commitLine();
+  function outlineFor(e) {
+    const min = opts.outlineMinSize;
+    if (min === void 0 || e.fontSize < min) return null;
+    if (e.resolved.synthetic.bold) return null;
+    const r = e.resolved.resolved;
+    return glyphOutline(r.family, r.weight, r.style, e.cp);
+  }
   const decorations = [];
   let span = null;
   function flushSpan() {
@@ -2279,6 +2294,7 @@ function layoutRuns(runs, opts, origin) {
       decorations.push({ kind: "strikethrough", x0: s.x0, y0, x1: s.x1, y1: y0 + thickness, fill: s.fill });
     }
   }
+  const lineBoxes = [];
   let penY = origin.y;
   let maxLineWidth = 0;
   const finiteWidth = Number.isFinite(opts.maxWidth) ? opts.maxWidth : 0;
@@ -2291,7 +2307,10 @@ function layoutRuns(runs, opts, origin) {
       const slack = finiteWidth - line.width;
       return opts.align === "center" ? slack / 2 : slack;
     })();
-    let penX = origin.x + alignShift;
+    const lineX0 = origin.x + alignShift;
+    const baselineSource = line.entries[0] ?? line.blank;
+    const lineBaselineY = baselineSource ? penY + baselineSource.font.common.base * (baselineSource.fontSize / baselineSource.font.info.size) : penY;
+    let penX = lineX0;
     for (const e of line.entries) {
       penX += e.kerningBefore;
       const step = e.advance + e.tracking;
@@ -2315,6 +2334,20 @@ function layoutRuns(runs, opts, origin) {
       } else {
         flushSpan();
       }
+      const outlineD = outlineFor(e);
+      if (outlineD !== null) {
+        const group2 = getOrCreateGroup(ctx, e.run, e.resolved, 0, "outline");
+        group2.glyphs.push({
+          d: outlineD,
+          key: `${e.resolved.resolved.family}|${e.resolved.resolved.weight}|${e.resolved.resolved.style}|${e.cp}`,
+          x: penX,
+          baselineY,
+          // Em space is unit-scale, so world units per em is just the size.
+          scale: e.fontSize
+        });
+        penX += step;
+        continue;
+      }
       if (e.advance === 0 || e.glyph.width === 0 || e.glyph.page < 0) {
         penX += step;
         continue;
@@ -2334,15 +2367,54 @@ function layoutRuns(runs, opts, origin) {
       penX += step;
     }
     flushSpan();
+    lineBoxes.push({
+      x0: lineX0,
+      y0: penY,
+      x1: lineX0 + line.width,
+      y1: penY + line.height,
+      baselineY: lineBaselineY
+    });
     maxLineWidth = Math.max(maxLineWidth, line.width);
     penY += line.height;
   }
   return {
     groups: [...ctx.groups.values()],
     decorations,
+    lines: lineBoxes,
     bounds: { width: maxLineWidth, height: penY - origin.y }
   };
 }
+var LAYOUT_CACHE_VARIANT_LIMIT = 8;
+var cache2 = /* @__PURE__ */ new WeakMap();
+function outlineBucket(runs, min) {
+  if (min === void 0) return -1;
+  const sizes = /* @__PURE__ */ new Set();
+  for (const r of runs) sizes.add(r.fontSize);
+  let n = 0;
+  for (const size of sizes) if (size >= min) n++;
+  return n;
+}
+function variantKey(runs, opts, origin) {
+  return `${opts.maxWidth}|${opts.lineHeight}|${opts.align}|${outlineBucket(runs, opts.outlineMinSize)}|${origin.x}|${origin.y}`;
+}
+function cachedLayoutRuns(runs, opts, origin) {
+  const fonts = glyphGeneration();
+  let entry = cache2.get(runs);
+  if (entry === void 0) {
+    entry = { generation: fonts, byVariant: /* @__PURE__ */ new Map() };
+    cache2.set(runs, entry);
+  } else if (entry.generation !== fonts) {
+    entry.generation = fonts;
+    entry.byVariant.clear();
+  }
+  const key = variantKey(runs, opts, origin);
+  const hit = entry.byVariant.get(key);
+  if (hit !== void 0) return hit;
+  const laid = layoutRuns(runs, opts, origin);
+  if (entry.byVariant.size >= LAYOUT_CACHE_VARIANT_LIMIT) entry.byVariant.clear();
+  entry.byVariant.set(key, laid);
+  return laid;
+}
 
 // src/features/text/verticalAlign.ts
 function verticalAlignOffset(align, boxHeight, textHeight) {
@@ -2351,170 +2423,445 @@ function verticalAlignOffset(align, boxHeight, textHeight) {
   return align === "center" ? slack / 2 : slack;
 }
 
-// src/renderer/draw.ts
-function setColorMatrixUniforms(ctx, prog) {
-  const gl = ctx.gl;
-  const cm = ctx.state.colorMatrix;
-  const m4 = new Float32Array(16);
-  for (let row = 0; row < 4; row++) {
-    for (let col = 0; col < 4; col++) {
-      m4[col * 4 + row] = cm[row * 5 + col];
+// src/features/paths/pathFromD.ts
+var NUM_RE = /[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g;
+function tokenize(d) {
+  const out = [];
+  let i = 0;
+  while (i < d.length) {
+    const ch = d[i];
+    if (/[A-Za-z]/.test(ch)) {
+      let j = i + 1;
+      while (j < d.length && !/[A-Za-z]/.test(d[j])) j++;
+      const argSlice = d.slice(i + 1, j);
+      out.push({ cmd: ch, args: readNumbers(argSlice) });
+      i = j;
+    } else {
+      i++;
     }
   }
-  const mLoc = prog.uniform("u_colorMatrix");
-  const bLoc = prog.uniform("u_colorBias");
-  if (mLoc !== void 0) gl.uniformMatrix4fv(mLoc, false, m4);
-  if (bLoc !== void 0) gl.uniform4f(bLoc, cm[4], cm[9], cm[14], cm[19]);
-}
-function fillMeshHandle(ctx, path) {
-  if (ctx.flattenTolerance !== void 0) {
-    return ctx.meshCache.uploadTransient(tessellate(path, { flattenTolerance: ctx.flattenTolerance }));
-  }
-  return ctx.meshCache.handleFor(getMesh(path));
-}
-function dispatch(ctx, cmd) {
-  switch (cmd.kind) {
-    case "group":
-      return drawGroup(ctx, cmd);
-    case "path":
-      return drawPath(ctx, cmd);
-    case "text":
-      return drawText(ctx, cmd);
-    case "image":
-      return drawImage(ctx, cmd);
-    case "shader":
-      return drawShader(ctx, cmd);
-  }
+  return out;
 }
-var warnedUniforms = /* @__PURE__ */ new Set();
-function warnOnceUniform(programId, name) {
-  const key = `${programId}:${name}`;
-  if (warnedUniforms.has(key)) return;
-  warnedUniforms.add(key);
-  const isDev3 = typeof process !== "undefined" ? process.env.NODE_ENV !== "production" : true;
-  if (isDev3) {
-    console.warn(`weasel drawShader: uniform "${name}" not found in program "${programId}". Check spelling, ensure it's used in the shader (unused uniforms are optimized away by the driver).`);
+function readNumbers(s) {
+  const out = [];
+  let m;
+  NUM_RE.lastIndex = 0;
+  while ((m = NUM_RE.exec(s)) !== null) {
+    const n = Number(m[0]);
+    if (Number.isFinite(n)) out.push(n);
   }
+  return out;
 }
-function setUniform(gl, loc, value, textureCache, nextTexUnit) {
-  if (value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Float32Array) && "id" in value && typeof value.id === "string") {
-    const handle = value;
-    const entry = getTexture(handle.id);
-    if (!entry) {
-      const isDev3 = typeof process !== "undefined" ? process.env.NODE_ENV !== "production" : true;
-      if (isDev3) console.warn(`weasel setUniform: TextureHandle "${handle.id}" not registered`);
-      return;
+var ARG_COUNTS = {
+  M: 2,
+  L: 2,
+  H: 1,
+  V: 1,
+  C: 6,
+  S: 4,
+  Q: 4,
+  T: 2,
+  A: 7,
+  Z: 0
+};
+function pathFromD(d, onWarn) {
+  const tokens = tokenize(d);
+  const b = new PathBuilder();
+  const st = {
+    x: 0,
+    y: 0,
+    startX: 0,
+    startY: 0,
+    lastCubicCtrl: null,
+    lastQuadCtrl: null
+  };
+  for (const { cmd, args } of tokens) {
+    const upper = cmd.toUpperCase();
+    const relative = cmd !== upper;
+    const argCount = ARG_COUNTS[upper];
+    if (argCount === void 0) {
+      onWarn?.(`unknown path command: ${cmd}`);
+      continue;
     }
-    const unit2 = nextTexUnit.value++;
-    textureCache.upload(handle.id, entry.source);
-    textureCache.bind(handle.id, unit2);
-    gl.uniform1i(loc, unit2);
-    return;
-  }
-  if (value instanceof Float32Array) {
-    if (value.length === 9) {
-      gl.uniformMatrix3fv(loc, false, value);
-    } else if (value.length === 16) {
-      gl.uniformMatrix4fv(loc, false, value);
-    } else {
-      const isDev3 = typeof process !== "undefined" ? process.env.NODE_ENV !== "production" : true;
-      if (isDev3) throw new TypeError(`weasel setUniform: Float32Array must be length 9 (mat3) or 16 (mat4), got ${value.length}`);
+    if (upper === "Z") {
+      b.close();
+      st.x = st.startX;
+      st.y = st.startY;
+      st.lastCubicCtrl = null;
+      st.lastQuadCtrl = null;
+      continue;
     }
-    return;
-  }
-  if (Array.isArray(value)) {
-    const arr = value;
-    switch (arr.length) {
-      case 2:
-        gl.uniform2fv(loc, arr);
-        break;
-      case 3:
-        gl.uniform3fv(loc, arr);
-        break;
-      case 4:
-        gl.uniform4fv(loc, arr);
-        break;
-      default: {
-        const isDev3 = typeof process !== "undefined" ? process.env.NODE_ENV !== "production" : true;
-        if (isDev3) throw new TypeError(`weasel setUniform: array length ${arr.length} not supported`);
-      }
+    const groups = argCount === 0 ? 1 : Math.floor(args.length / argCount);
+    for (let g = 0; g < groups; g++) {
+      const a = args.slice(g * argCount, (g + 1) * argCount);
+      const effectiveUpper = upper === "M" && g > 0 ? "L" : upper;
+      runCommand(effectiveUpper, relative, a, st, b);
     }
-    return;
-  }
-  if (typeof value === "number") {
-    gl.uniform1f(loc, value);
-    return;
   }
+  return b.build();
 }
-function drawShader(ctx, cmd) {
-  const { gl, programRegistry, quadVbo, quadIbo, textureCache } = ctx;
-  const program = programRegistry.get(cmd.program.id);
-  if (!program) {
-    console.warn(
-      `weasel drawShader: program "${cmd.program.id}" not compiled on this renderer. Call renderer.registerProgram(handle) after the module-level registerProgram().`
-    );
-    return;
-  }
-  if (!quadVbo || !quadIbo) {
-    console.warn("weasel drawShader: quad geometry not initialized");
-    return;
-  }
-  gl.useProgram(program.handle);
-  const aPosLoc = program.attribute("a_position");
-  const aUvLoc = program.attribute("a_uv");
-  gl.bindBuffer(gl.ARRAY_BUFFER, quadVbo);
-  if (aPosLoc !== void 0) {
-    gl.enableVertexAttribArray(aPosLoc);
-    gl.vertexAttribPointer(aPosLoc, 2, gl.FLOAT, false, 16, 0);
-  }
-  if (aUvLoc !== void 0) {
-    gl.enableVertexAttribArray(aUvLoc);
-    gl.vertexAttribPointer(aUvLoc, 2, gl.FLOAT, false, 16, 8);
-  }
-  gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, quadIbo);
-  const proj = mat3.screenToClip(ctx.widthCss, ctx.heightCss);
-  const uProj = program.uniform("u_proj");
-  if (uProj !== void 0) gl.uniformMatrix3fv(uProj, false, proj);
-  const uBounds = program.uniform("u_bounds");
-  if (uBounds !== void 0) {
-    gl.uniform4f(uBounds, cmd.bounds.x, cmd.bounds.y, cmd.bounds.w, cmd.bounds.h);
-  }
-  const uView = program.uniform("u_view");
-  if (uView !== void 0) gl.uniformMatrix3fv(uView, false, ctx.state.transform);
-  const nextTexUnit = { value: 1 };
-  for (const [name, value] of Object.entries(cmd.uniforms)) {
-    const loc = program.uniform(name);
-    if (loc === void 0) {
-      warnOnceUniform(cmd.program.id, name);
-      continue;
+function runCommand(upper, relative, a, st, b) {
+  const rx = relative ? st.x : 0;
+  const ry = relative ? st.y : 0;
+  switch (upper) {
+    case "M": {
+      const x = a[0] + rx;
+      const y = a[1] + ry;
+      b.moveTo(x, y);
+      st.x = x;
+      st.y = y;
+      st.startX = x;
+      st.startY = y;
+      st.lastCubicCtrl = null;
+      st.lastQuadCtrl = null;
+      return;
     }
-    setUniform(gl, loc, value, textureCache, nextTexUnit);
-  }
-  applyClipTest(ctx);
-  gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0);
-  if (aPosLoc !== void 0) gl.disableVertexAttribArray(aPosLoc);
-  if (aUvLoc !== void 0) gl.disableVertexAttribArray(aUvLoc);
-  gl.bindBuffer(gl.ARRAY_BUFFER, null);
-  gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
-}
-function drawGroup(ctx, cmd) {
-  ctx.state.push({
-    transform: cmd.transform,
-    alpha: cmd.alpha,
-    colorMatrix: cmd.colorMatrix
-  });
-  if (cmd.clip) {
-    const newDepth = ctx.clipDepth + 1;
-    if (newDepth > 7) {
-      ctx.state.pop();
-      throw new Error(
-        "weasel: clip nesting depth exceeded (max 7). You can't nest more than 7 levels of clipped containers in a single draw tree. Flatten the hierarchy or compose poses outside the scene graph."
-      );
+    case "L": {
+      const x = a[0] + rx;
+      const y = a[1] + ry;
+      b.lineTo(x, y);
+      st.x = x;
+      st.y = y;
+      st.lastCubicCtrl = null;
+      st.lastQuadCtrl = null;
+      return;
     }
-    pushClip(ctx, cmd.clip, newDepth);
-    ctx.clipDepth = newDepth;
-  }
-  for (const child of cmd.children) dispatch(ctx, child);
+    case "H": {
+      const x = a[0] + (relative ? st.x : 0);
+      b.lineTo(x, st.y);
+      st.x = x;
+      st.lastCubicCtrl = null;
+      st.lastQuadCtrl = null;
+      return;
+    }
+    case "V": {
+      const y = a[0] + (relative ? st.y : 0);
+      b.lineTo(st.x, y);
+      st.y = y;
+      st.lastCubicCtrl = null;
+      st.lastQuadCtrl = null;
+      return;
+    }
+    case "C": {
+      const x1 = a[0] + rx, y1 = a[1] + ry;
+      const x2 = a[2] + rx, y2 = a[3] + ry;
+      const x = a[4] + rx, y = a[5] + ry;
+      b.curveTo(x1, y1, x2, y2, x, y);
+      st.x = x;
+      st.y = y;
+      st.lastCubicCtrl = { x: x2, y: y2 };
+      st.lastQuadCtrl = null;
+      return;
+    }
+    case "S": {
+      const ref = st.lastCubicCtrl ?? { x: st.x, y: st.y };
+      const x1 = 2 * st.x - ref.x;
+      const y1 = 2 * st.y - ref.y;
+      const x2 = a[0] + rx, y2 = a[1] + ry;
+      const x = a[2] + rx, y = a[3] + ry;
+      b.curveTo(x1, y1, x2, y2, x, y);
+      st.x = x;
+      st.y = y;
+      st.lastCubicCtrl = { x: x2, y: y2 };
+      st.lastQuadCtrl = null;
+      return;
+    }
+    case "Q": {
+      const x1 = a[0] + rx, y1 = a[1] + ry;
+      const x = a[2] + rx, y = a[3] + ry;
+      b.quadTo(x1, y1, x, y);
+      st.x = x;
+      st.y = y;
+      st.lastQuadCtrl = { x: x1, y: y1 };
+      st.lastCubicCtrl = null;
+      return;
+    }
+    case "T": {
+      const ref = st.lastQuadCtrl ?? { x: st.x, y: st.y };
+      const x1 = 2 * st.x - ref.x;
+      const y1 = 2 * st.y - ref.y;
+      const x = a[0] + rx, y = a[1] + ry;
+      b.quadTo(x1, y1, x, y);
+      st.x = x;
+      st.y = y;
+      st.lastQuadCtrl = { x: x1, y: y1 };
+      st.lastCubicCtrl = null;
+      return;
+    }
+    case "A": {
+      const rxA = Math.abs(a[0]);
+      const ryA = Math.abs(a[1]);
+      const xRot = a[2];
+      const largeArc = a[3] !== 0;
+      const sweep = a[4] !== 0;
+      const ex = a[5] + rx;
+      const ey = a[6] + ry;
+      arcToCubics(st.x, st.y, ex, ey, rxA, ryA, xRot, largeArc, sweep, b);
+      st.x = ex;
+      st.y = ey;
+      st.lastCubicCtrl = null;
+      st.lastQuadCtrl = null;
+      return;
+    }
+    default:
+      return;
+  }
+}
+function arcToCubics(x1, y1, x2, y2, rx, ry, xAxisRotationDeg, largeArc, sweep, b) {
+  if (x1 === x2 && y1 === y2) return;
+  if (rx === 0 || ry === 0) {
+    b.lineTo(x2, y2);
+    return;
+  }
+  const phi = xAxisRotationDeg * Math.PI / 180;
+  const cosPhi = Math.cos(phi);
+  const sinPhi = Math.sin(phi);
+  const dx = (x1 - x2) / 2;
+  const dy = (y1 - y2) / 2;
+  const x1p = cosPhi * dx + sinPhi * dy;
+  const y1p = -sinPhi * dx + cosPhi * dy;
+  let rxs = rx * rx;
+  let rys = ry * ry;
+  const x1ps = x1p * x1p;
+  const y1ps = y1p * y1p;
+  const lambda = x1ps / rxs + y1ps / rys;
+  let rxFixed = rx;
+  let ryFixed = ry;
+  if (lambda > 1) {
+    const sqrtLambda = Math.sqrt(lambda);
+    rxFixed = sqrtLambda * rx;
+    ryFixed = sqrtLambda * ry;
+    rxs = rxFixed * rxFixed;
+    rys = ryFixed * ryFixed;
+  }
+  const sign = largeArc === sweep ? -1 : 1;
+  const num = rxs * rys - rxs * y1ps - rys * x1ps;
+  const den = rxs * y1ps + rys * x1ps;
+  const factor = sign * Math.sqrt(Math.max(0, num / den));
+  const cxp = factor * (rxFixed * y1p) / ryFixed;
+  const cyp = factor * -(ryFixed * x1p) / rxFixed;
+  const cx = cosPhi * cxp - sinPhi * cyp + (x1 + x2) / 2;
+  const cy = sinPhi * cxp + cosPhi * cyp + (y1 + y2) / 2;
+  const angle = (ux, uy, vx, vy) => {
+    const dot = ux * vx + uy * vy;
+    const len = Math.sqrt((ux * ux + uy * uy) * (vx * vx + vy * vy));
+    let a = Math.acos(Math.max(-1, Math.min(1, dot / len)));
+    if (ux * vy - uy * vx < 0) a = -a;
+    return a;
+  };
+  const theta1 = angle(1, 0, (x1p - cxp) / rxFixed, (y1p - cyp) / ryFixed);
+  let dTheta = angle(
+    (x1p - cxp) / rxFixed,
+    (y1p - cyp) / ryFixed,
+    (-x1p - cxp) / rxFixed,
+    (-y1p - cyp) / ryFixed
+  );
+  if (!sweep && dTheta > 0) dTheta -= 2 * Math.PI;
+  else if (sweep && dTheta < 0) dTheta += 2 * Math.PI;
+  const segCount = Math.max(1, Math.ceil(Math.abs(dTheta) / (Math.PI / 2)));
+  const segAngle = dTheta / segCount;
+  const t = 4 / 3 * Math.tan(segAngle / 4);
+  let prevX = x1;
+  let prevY = y1;
+  let prevDx = -Math.sin(theta1) * rxFixed;
+  let prevDy = Math.cos(theta1) * ryFixed;
+  for (let i = 1; i <= segCount; i++) {
+    const theta = theta1 + i * segAngle;
+    const cosT = Math.cos(theta);
+    const sinT = Math.sin(theta);
+    const px = cosPhi * (cosT * rxFixed) - sinPhi * (sinT * ryFixed) + cx;
+    const py = sinPhi * (cosT * rxFixed) + cosPhi * (sinT * ryFixed) + cy;
+    const dxNew = -sinT * rxFixed;
+    const dyNew = cosT * ryFixed;
+    const c1x = prevX + cosPhi * (t * prevDx) - sinPhi * (t * prevDy);
+    const c1y = prevY + sinPhi * (t * prevDx) + cosPhi * (t * prevDy);
+    const c2x = px - cosPhi * (t * dxNew) + sinPhi * (t * dyNew);
+    const c2y = py - sinPhi * (t * dxNew) - cosPhi * (t * dyNew);
+    b.curveTo(c1x, c1y, c2x, c2y, px, py);
+    prevX = px;
+    prevY = py;
+    prevDx = dxNew;
+    prevDy = dyNew;
+  }
+}
+
+// src/renderer/cache/outlineMeshCache.ts
+var OUTLINE_FLATTEN_TOLERANCE = 1 / 4096;
+var OUTLINE_MESH_CACHE_LIMIT = 2048;
+var cache3 = /* @__PURE__ */ new Map();
+function outlineMesh(key, d) {
+  const cached = cache3.get(key);
+  if (cached !== void 0) return cached;
+  if (cache3.size >= OUTLINE_MESH_CACHE_LIMIT) cache3 = /* @__PURE__ */ new Map();
+  const mesh = tessellate(pathFromD(d), { flattenTolerance: OUTLINE_FLATTEN_TOLERANCE });
+  cache3.set(key, mesh);
+  return mesh;
+}
+
+// src/renderer/draw.ts
+function setColorMatrixUniforms(ctx, prog) {
+  const gl = ctx.gl;
+  const cm = ctx.state.colorMatrix;
+  const m4 = new Float32Array(16);
+  for (let row = 0; row < 4; row++) {
+    for (let col = 0; col < 4; col++) {
+      m4[col * 4 + row] = cm[row * 5 + col];
+    }
+  }
+  const mLoc = prog.uniform("u_colorMatrix");
+  const bLoc = prog.uniform("u_colorBias");
+  if (mLoc !== void 0) gl.uniformMatrix4fv(mLoc, false, m4);
+  if (bLoc !== void 0) gl.uniform4f(bLoc, cm[4], cm[9], cm[14], cm[19]);
+}
+function fillMeshHandle(ctx, path) {
+  if (ctx.flattenTolerance !== void 0) {
+    return ctx.meshCache.uploadTransient(tessellate(path, { flattenTolerance: ctx.flattenTolerance }));
+  }
+  return ctx.meshCache.handleFor(getMesh(path));
+}
+function dispatch(ctx, cmd) {
+  switch (cmd.kind) {
+    case "group":
+      return drawGroup(ctx, cmd);
+    case "path":
+      return drawPath(ctx, cmd);
+    case "text":
+      return drawText(ctx, cmd);
+    case "image":
+      return drawImage(ctx, cmd);
+    case "shader":
+      return drawShader(ctx, cmd);
+  }
+}
+var warnedUniforms = /* @__PURE__ */ new Set();
+function warnOnceUniform(programId, name) {
+  const key = `${programId}:${name}`;
+  if (warnedUniforms.has(key)) return;
+  warnedUniforms.add(key);
+  const isDev3 = typeof process !== "undefined" ? process.env.NODE_ENV !== "production" : true;
+  if (isDev3) {
+    console.warn(`weasel drawShader: uniform "${name}" not found in program "${programId}". Check spelling, ensure it's used in the shader (unused uniforms are optimized away by the driver).`);
+  }
+}
+function setUniform(gl, loc, value, textureCache, nextTexUnit) {
+  if (value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Float32Array) && "id" in value && typeof value.id === "string") {
+    const handle = value;
+    const entry = getTexture(handle.id);
+    if (!entry) {
+      const isDev3 = typeof process !== "undefined" ? process.env.NODE_ENV !== "production" : true;
+      if (isDev3) console.warn(`weasel setUniform: TextureHandle "${handle.id}" not registered`);
+      return;
+    }
+    const unit2 = nextTexUnit.value++;
+    textureCache.upload(handle.id, entry.source);
+    textureCache.bind(handle.id, unit2);
+    gl.uniform1i(loc, unit2);
+    return;
+  }
+  if (value instanceof Float32Array) {
+    if (value.length === 9) {
+      gl.uniformMatrix3fv(loc, false, value);
+    } else if (value.length === 16) {
+      gl.uniformMatrix4fv(loc, false, value);
+    } else {
+      const isDev3 = typeof process !== "undefined" ? process.env.NODE_ENV !== "production" : true;
+      if (isDev3) throw new TypeError(`weasel setUniform: Float32Array must be length 9 (mat3) or 16 (mat4), got ${value.length}`);
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    const arr = value;
+    switch (arr.length) {
+      case 2:
+        gl.uniform2fv(loc, arr);
+        break;
+      case 3:
+        gl.uniform3fv(loc, arr);
+        break;
+      case 4:
+        gl.uniform4fv(loc, arr);
+        break;
+      default: {
+        const isDev3 = typeof process !== "undefined" ? process.env.NODE_ENV !== "production" : true;
+        if (isDev3) throw new TypeError(`weasel setUniform: array length ${arr.length} not supported`);
+      }
+    }
+    return;
+  }
+  if (typeof value === "number") {
+    gl.uniform1f(loc, value);
+    return;
+  }
+}
+function drawShader(ctx, cmd) {
+  const { gl, programRegistry, quadVbo, quadIbo, textureCache } = ctx;
+  const program = programRegistry.get(cmd.program.id);
+  if (!program) {
+    console.warn(
+      `weasel drawShader: program "${cmd.program.id}" not compiled on this renderer. Call renderer.registerProgram(handle) after the module-level registerProgram().`
+    );
+    return;
+  }
+  if (!quadVbo || !quadIbo) {
+    console.warn("weasel drawShader: quad geometry not initialized");
+    return;
+  }
+  gl.useProgram(program.handle);
+  const aPosLoc = program.attribute("a_position");
+  const aUvLoc = program.attribute("a_uv");
+  gl.bindBuffer(gl.ARRAY_BUFFER, quadVbo);
+  if (aPosLoc !== void 0) {
+    gl.enableVertexAttribArray(aPosLoc);
+    gl.vertexAttribPointer(aPosLoc, 2, gl.FLOAT, false, 16, 0);
+  }
+  if (aUvLoc !== void 0) {
+    gl.enableVertexAttribArray(aUvLoc);
+    gl.vertexAttribPointer(aUvLoc, 2, gl.FLOAT, false, 16, 8);
+  }
+  gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, quadIbo);
+  const proj = mat3.screenToClip(ctx.widthCss, ctx.heightCss);
+  const uProj = program.uniform("u_proj");
+  if (uProj !== void 0) gl.uniformMatrix3fv(uProj, false, proj);
+  const uBounds = program.uniform("u_bounds");
+  if (uBounds !== void 0) {
+    gl.uniform4f(uBounds, cmd.bounds.x, cmd.bounds.y, cmd.bounds.w, cmd.bounds.h);
+  }
+  const uView = program.uniform("u_view");
+  if (uView !== void 0) gl.uniformMatrix3fv(uView, false, ctx.state.transform);
+  const nextTexUnit = { value: 1 };
+  for (const [name, value] of Object.entries(cmd.uniforms)) {
+    const loc = program.uniform(name);
+    if (loc === void 0) {
+      warnOnceUniform(cmd.program.id, name);
+      continue;
+    }
+    setUniform(gl, loc, value, textureCache, nextTexUnit);
+  }
+  applyClipTest(ctx);
+  gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0);
+  if (aPosLoc !== void 0) gl.disableVertexAttribArray(aPosLoc);
+  if (aUvLoc !== void 0) gl.disableVertexAttribArray(aUvLoc);
+  gl.bindBuffer(gl.ARRAY_BUFFER, null);
+  gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
+}
+function drawGroup(ctx, cmd) {
+  ctx.state.push({
+    transform: cmd.transform,
+    alpha: cmd.alpha,
+    colorMatrix: cmd.colorMatrix
+  });
+  if (cmd.clip) {
+    const newDepth = ctx.clipDepth + 1;
+    if (newDepth > 7) {
+      ctx.state.pop();
+      throw new Error(
+        "weasel: clip nesting depth exceeded (max 7). You can't nest more than 7 levels of clipped containers in a single draw tree. Flatten the hierarchy or compose poses outside the scene graph."
+      );
+    }
+    pushClip(ctx, cmd.clip, newDepth);
+    ctx.clipDepth = newDepth;
+  }
+  for (const child of cmd.children) dispatch(ctx, child);
   if (cmd.clip) {
     popClip(ctx, cmd.clip, ctx.clipDepth - 1);
     ctx.clipDepth -= 1;
@@ -2877,36 +3224,36 @@ function drawPathStrokeStenciled(ctx, cmd, align) {
   gl.disable(gl.STENCIL_TEST);
   gl.bindVertexArray(null);
 }
+var OUTLINE_MIN_SCREEN_PX = 48;
+function modelScale(m) {
+  const sx = Math.hypot(m[0], m[1]);
+  const sy = Math.hypot(m[3], m[4]);
+  return Math.sqrt(sx * sy) || 1;
+}
 function drawText(ctx, cmd) {
   const style = resolveTextStyle(cmd.style);
   const lineHeight = style.lineHeight;
   const align = cmd.align ?? style.align;
   const maxWidth = cmd.maxWidth ?? Infinity;
-  const laid = layoutRuns(
+  const minScreen = ctx.textOutlineMinScreenSize ?? OUTLINE_MIN_SCREEN_PX;
+  const outlineMinSize = Number.isFinite(minScreen) ? minScreen / modelScale(ctx.state.transform) : void 0;
+  const laid = cachedLayoutRuns(
     cmd.runs,
-    { maxWidth, lineHeight, align },
+    { maxWidth, lineHeight, align, outlineMinSize },
     { x: cmd.x, y: cmd.y }
   );
   if (laid.groups.length === 0 && laid.decorations.length === 0) return;
   const dy = verticalAlignOffset(cmd.verticalAlign, cmd.height, laid.bounds.height);
-  if (dy !== 0) {
-    for (const group of laid.groups) {
-      for (const q of group.quads) {
-        q.y0 += dy;
-        q.y1 += dy;
-        q.baselineY += dy;
-      }
-    }
-    for (const d of laid.decorations) {
-      d.y0 += dy;
-      d.y1 += dy;
-    }
-  }
   const gl = ctx.gl;
   applyClipTest(ctx);
   const preparedPrograms = /* @__PURE__ */ new Set();
   let currentProg = null;
   for (const group of laid.groups) {
+    if (group.source === "outline") {
+      drawTextOutlineGroup(ctx, group, dy);
+      currentProg = null;
+      continue;
+    }
     const prog = group.source === "canvas" ? ctx.textSdfR8 : ctx.textSdf;
     if (prog !== currentProg) {
       gl.useProgram(prog.handle);
@@ -2918,11 +3265,48 @@ function drawText(ctx, cmd) {
       setColorMatrixUniforms(ctx, prog);
       gl.uniform1f(prog.uniform("u_alpha"), ctx.state.alpha);
     }
-    drawTextGroup(ctx, group, prog);
+    drawTextGroup(ctx, group, prog, dy);
   }
-  drawTextDecorations(ctx, laid.decorations);
+  drawTextDecorations(ctx, laid.decorations, dy);
 }
-function drawTextDecorations(ctx, decorations) {
+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));
+}
+function outlineGroupMesh(group, dy) {
+  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;
+    parts.push({ mesh, glyph });
+    vertexFloats += mesh.vertices.length;
+    indexCount += mesh.indices.length;
+  }
+  if (parts.length === 0) return null;
+  const shear = group.synthetic.italic ? Math.tan(SYNTHETIC_ITALIC_RADIANS) : 0;
+  const vertices = new Float32Array(vertexFloats);
+  const indices = new Uint32Array(indexCount);
+  let vi = 0;
+  let ii = 0;
+  let base = 0;
+  for (const { mesh, glyph } of parts) {
+    const { x, baselineY, scale: scale2 } = glyph;
+    for (let k = 0; k < mesh.vertices.length; k += 2) {
+      const ex = mesh.vertices[k];
+      const ey = mesh.vertices[k + 1];
+      vertices[vi++] = x + (ex - ey * shear) * scale2;
+      vertices[vi++] = baselineY + dy + ey * scale2;
+    }
+    for (let k = 0; k < mesh.indices.length; k++) indices[ii++] = base + mesh.indices[k];
+    base += mesh.vertices.length / 2;
+  }
+  return { vertices, indices };
+}
+function drawTextDecorations(ctx, decorations, dy) {
   if (decorations.length === 0) return;
   const batches = /* @__PURE__ */ new Map();
   for (const d of decorations) {
@@ -2945,14 +3329,15 @@ function drawTextDecorations(ctx, decorations) {
     const vertices = new Float32Array(rects.length * 4 * 2);
     let vi = 0;
     for (const d of rects) {
+      const dy0 = d.y0 + dy, dy1 = d.y1 + dy;
       vertices[vi++] = d.x0;
-      vertices[vi++] = d.y0;
+      vertices[vi++] = dy0;
       vertices[vi++] = d.x1;
-      vertices[vi++] = d.y0;
+      vertices[vi++] = dy0;
       vertices[vi++] = d.x0;
-      vertices[vi++] = d.y1;
+      vertices[vi++] = dy1;
       vertices[vi++] = d.x1;
-      vertices[vi++] = d.y1;
+      vertices[vi++] = dy1;
     }
     const indices = new Uint32Array(rects.length * 6);
     let ii = 0;
@@ -2990,7 +3375,7 @@ function drawTextDecorations(ctx, decorations) {
     gl.deleteBuffer(ibo);
   }
 }
-function drawTextGroup(ctx, group, prog) {
+function drawTextGroup(ctx, group, prog, dy) {
   if (group.source === "canvas") {
     if (!syncDynamicPageTexture(ctx.textureCache, group.page)) return;
   } else {
@@ -3001,26 +3386,27 @@ function drawTextGroup(ctx, group, prog) {
   const vertices = new Float32Array(group.quads.length * 4 * 5);
   let vi = 0;
   for (const q of group.quads) {
+    const y0 = q.y0 + dy, y1 = q.y1 + dy, by = q.baselineY + dy;
     vertices[vi++] = q.x0;
-    vertices[vi++] = q.y0;
+    vertices[vi++] = y0;
     vertices[vi++] = q.u0;
     vertices[vi++] = q.v0;
-    vertices[vi++] = q.baselineY;
+    vertices[vi++] = by;
     vertices[vi++] = q.x1;
-    vertices[vi++] = q.y0;
+    vertices[vi++] = y0;
     vertices[vi++] = q.u1;
     vertices[vi++] = q.v0;
-    vertices[vi++] = q.baselineY;
+    vertices[vi++] = by;
     vertices[vi++] = q.x0;
-    vertices[vi++] = q.y1;
+    vertices[vi++] = y1;
     vertices[vi++] = q.u0;
     vertices[vi++] = q.v1;
-    vertices[vi++] = q.baselineY;
+    vertices[vi++] = by;
     vertices[vi++] = q.x1;
-    vertices[vi++] = q.y1;
+    vertices[vi++] = y1;
     vertices[vi++] = q.u1;
     vertices[vi++] = q.v1;
-    vertices[vi++] = q.baselineY;
+    vertices[vi++] = by;
   }
   const indices = new Uint32Array(group.quads.length * 6);
   let ii = 0;
@@ -3068,7 +3454,7 @@ function drawTextGroup(ctx, group, prog) {
   const synthBoldAmount = group.synthetic.bold ? 0.08 : 0;
   const uSynthBold = prog.uniform("u_synthBold");
   if (uSynthBold !== void 0) gl.uniform1f(uSynthBold, synthBoldAmount);
-  const synthItalicAmount = group.synthetic.italic ? 0.2094 : 0;
+  const synthItalicAmount = group.synthetic.italic ? SYNTHETIC_ITALIC_RADIANS : 0;
   const uSynthItalic = prog.uniform("u_synthItalic");
   if (uSynthItalic !== void 0) gl.uniform1f(uSynthItalic, synthItalicAmount);
   const texId = group.source === "canvas" ? dynamicPageTextureId(group.page) : textureCacheKey(group.family, group.weight, group.style);
@@ -3249,6 +3635,7 @@ var WeaselRenderer = class {
   imageMinification;
   flattenTolerance;
   bakeBudget;
+  textOutlineMinScreenSize;
   contextLost = false;
   boundOnLost = (e) => this.onContextLost(e);
   boundOnRestored = () => this.onContextRestored();
@@ -3268,6 +3655,7 @@ var WeaselRenderer = class {
     this.imageMinification = opts.imageMinification ?? "linear";
     this.flattenTolerance = opts.flattenTolerance;
     this.bakeBudget = opts.bakeBudget ?? DEFAULT_BAKE_BUDGET;
+    this.textOutlineMinScreenSize = opts.textOutlineMinScreenSize ?? OUTLINE_MIN_SCREEN_PX;
     this.canvas = opts.canvas ?? null;
     if (this.canvas) {
       this.canvas.width = Math.round(opts.width * opts.dpr);
@@ -3511,7 +3899,8 @@ var WeaselRenderer = class {
       widthCss: this.widthCss,
       heightCss: this.heightCss,
       clipDepth: 0,
-      flattenTolerance: this.flattenTolerance
+      flattenTolerance: this.flattenTolerance,
+      textOutlineMinScreenSize: this.textOutlineMinScreenSize
     };
     for (const cmd of commands) dispatch(ctx, cmd);
     this.meshCache.freeTransient();
@@ -8058,15 +8447,25 @@ var reorderForwardAction = {
   group: "reorder",
   defaultBinding: [
     {
-      spec: { kind: "key", key: ["]", "}"], mods: { mod: true } },
+      // Modifier matching is strict, so Shift must be absent here — listing
+      // the shifted `'}'` on this binding would be dead weight, since you
+      // can't type it without the Shift this spec forbids.
+      spec: { kind: "key", key: ["]"], mods: { mod: true } },
       opts: { params: { distance: "adjacent" } }
     },
     {
-      // Cmd+Alt+] → bring-to-front. NOT Cmd+Shift+] — Chrome on macOS reserves
-      // Cmd+Shift+[ / Cmd+Shift+] for tab switching and never delivers them to
-      // the page. On macOS Option+] emits the character '‘' (U+2018); whether
-      // Cmd suppresses that transform is browser-dependent, so we match both the
-      // bracket and the Option-produced char (US layout). matchKey is
+      // Cmd+Shift+] → bring-to-front, the convention every drawing app uses.
+      // With Shift held the US-layout key reports as '}', so both characters
+      // are listed. Some browsers bind Cmd+Shift+[ / ] to tab switching and
+      // may consume the event before the page sees it — hence the Cmd+Alt
+      // binding below, which nothing reserves.
+      spec: { kind: "key", key: ["]", "}"], mods: { mod: true, shift: true } },
+      opts: { params: { distance: "extreme" } }
+    },
+    {
+      // Cmd+Alt+] → bring-to-front. On macOS Option+] emits '‘' (U+2018);
+      // whether Cmd suppresses that transform is browser-dependent, so match
+      // both the bracket and the Option-produced char (US layout). matchKey is
       // character-based, so non-US layouts may need a rebind.
       spec: { kind: "key", key: ["]", "\u2018"], mods: { mod: true, alt: true } },
       opts: { params: { distance: "extreme" } }
@@ -8093,13 +8492,17 @@ var reorderBackwardAction = {
   group: "reorder",
   defaultBinding: [
     {
-      spec: { kind: "key", key: ["[", "{"], mods: { mod: true } },
+      spec: { kind: "key", key: ["["], mods: { mod: true } },
       opts: { params: { distance: "adjacent" } }
     },
     {
-      // Cmd+Alt+[ → send-to-back. See the bring-to-front note above: avoids
-      // Chrome's reserved Cmd+Shift+[ tab-switch shortcut. On macOS Option+[
-      // emits '“' (U+201C), included alongside the bracket for robustness.
+      // Cmd+Shift+[ → send-to-back. See the bring-to-front notes above.
+      spec: { kind: "key", key: ["[", "{"], mods: { mod: true, shift: true } },
+      opts: { params: { distance: "extreme" } }
+    },
+    {
+      // Cmd+Alt+[ → send-to-back, the binding no browser reserves. On macOS
+      // Option+[ emits '“' (U+201C), included alongside the bracket.
       spec: { kind: "key", key: ["[", "\u201C"], mods: { mod: true, alt: true } },
       opts: { params: { distance: "extreme" } }
     }
@@ -10437,6 +10840,9 @@ function useHoverTracking(args) {
 }
 
 // src/interactions/dispatcher/dispatcher.ts
+function pointerGestureId(pointerId) {
+  return `pointer-${pointerId ?? "mouse"}`;
+}
 var DEV2 = (() => {
   try {
     return Boolean(import.meta.env?.DEV);
@@ -10577,7 +10983,7 @@ function createDispatcher(opts) {
       return `key-held-${event.key}`;
     }
     if (event.kind === "pointerdown" || event.kind === "pointermove" || event.kind === "pointerup" || event.kind === "pointercancel") {
-      return `pointer-mouse`;
+      return pointerGestureId(event.pointerId);
     }
     if (event.kind === "multitouch") {
       return `multitouch-${event.fingers}`;
@@ -11314,6 +11720,7 @@ function useGestureDispatcher(opts) {
       const ev = {
         kind: "pointerdown",
         target: e.target,
+        pointerId: e.pointerId,
         x: w.x,
         y: w.y,
         clientX: e.clientX,
@@ -11343,6 +11750,7 @@ function useGestureDispatcher(opts) {
         shiftKey: e.shiftKey
       });
       if (activePointers.size >= 2) {
+        for (const id of activePointers) bufferedDown.delete(id);
         const { centroid, spread } = computeMultiTouchGeometry(pointerPositions);
         if (!multiTouchStart) {
           multiTouchStart = { fingers: activePointers.size, centroid: { ...centroid } };
@@ -11393,6 +11801,7 @@ function useGestureDispatcher(opts) {
       const w = toWorld(e.clientX, e.clientY);
       const ev = {
         kind: "pointermove",
+        pointerId: e.pointerId,
         x: w.x,
         y: w.y,
         clientX: e.clientX,
@@ -11516,10 +11925,11 @@ function useGestureDispatcher(opts) {
       }
       const downForClick = lastPointerDown.get(e.pointerId);
       const movedDuringDrag = downForClick ? downForClick.clientX !== e.clientX || downForClick.clientY !== e.clientY : true;
-      const hadDragInFlight = dispatcher.inFlight().has("pointer-mouse") && movedDuringDrag;
+      const hadDragInFlight = dispatcher.inFlight().has(pointerGestureId(e.pointerId)) && movedDuringDrag;
       const wUp = toWorld(e.clientX, e.clientY);
       const ev = {
         kind: "pointerup",
+        pointerId: e.pointerId,
         x: wUp.x,
         y: wUp.y,
         clientX: e.clientX,
@@ -11594,6 +12004,7 @@ function useGestureDispatcher(opts) {
       multiTouchStart = null;
       const ev = {
         kind: "pointercancel",
+        pointerId: e.pointerId,
         altKey: e.altKey,
         ctrlKey: e.ctrlKey,
         metaKey: e.metaKey,
@@ -12062,6 +12473,17 @@ 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),
     []
@@ -12670,17 +13092,123 @@ function pathContainsPolygon(path, polygon) {
       (p) => p.x >= path.x && p.x <= path.x + path.width && p.y >= path.y && p.y <= path.y + path.height
     );
   }
-  return polygonContainsPolygon(extractVertices(path), polygon);
+  return polygonContainsPolygon(extractVertices(path), polygon);
+}
+function pathIntersectsPolygon(path, polygon) {
+  if (path.kind === "rect") {
+    return polygonsIntersect(rectToVerts(path), polygon);
+  }
+  return polygonsIntersect(extractVertices(path), polygon);
+}
+
+// src/features/text/runs.ts
+function toRuns(input) {
+  if (typeof input === "string") {
+    return input.length === 0 ? [] : [{ text: input }];
+  }
+  for (let i = 0; i < input.length; i++) {
+    const r = input[i];
+    if (typeof r?.text !== "string") {
+      throw new Error(`toRuns: run at index ${i} is missing string \`text\``);
+    }
+  }
+  return input;
+}
+function runsToPlainText(runs) {
+  let out = "";
+  for (const r of runs) out += r.text;
+  return out;
+}
+function escapeMarkdown(s) {
+  return s.replace(/\\/g, "\\\\").replace(/\*/g, "\\*");
+}
+function runsToMarkdown(runs) {
+  let out = "";
+  for (const r of runs) {
+    const escaped = escapeMarkdown(r.text);
+    if (r.bold && r.italic) out += `***${escaped}***`;
+    else if (r.bold) out += `**${escaped}**`;
+    else if (r.italic) out += `*${escaped}*`;
+    else out += escaped;
+  }
+  return out;
+}
+function markdownToRuns(input) {
+  const runs = [];
+  let bold = false;
+  let italic = false;
+  let buf = "";
+  let i = 0;
+  function flush() {
+    if (buf.length === 0) return;
+    const run = { text: buf };
+    if (bold) run.bold = true;
+    if (italic) run.italic = true;
+    runs.push(run);
+    buf = "";
+  }
+  while (i < input.length) {
+    const ch = input[i];
+    if (ch === "\\" && i + 1 < input.length && "*\\".includes(input[i + 1])) {
+      buf += input[i + 1];
+      i += 2;
+      continue;
+    }
+    if (ch === "*") {
+      let count = 0;
+      while (i + count < input.length && input[i + count] === "*") count++;
+      flush();
+      if (count >= 3) {
+        bold = !bold;
+        italic = !italic;
+        i += 3;
+      } else if (count === 2) {
+        bold = !bold;
+        i += 2;
+      } else {
+        italic = !italic;
+        i += 1;
+      }
+      continue;
+    }
+    buf += ch;
+    i++;
+  }
+  flush();
+  return runs;
 }
-function pathIntersectsPolygon(path, polygon) {
-  if (path.kind === "rect") {
-    return polygonsIntersect(rectToVerts(path), polygon);
+
+// src/features/text/lineBoxes.ts
+function textLineBoxes(pose, opts = {}) {
+  const padding = opts.padding ?? 0;
+  const style = resolveTextStyle(pose.style);
+  const source = pose.runs && pose.runs.length > 0 ? pose.runs : pose.text;
+  const runs = resolveRuns(toRuns(source), style);
+  const laid = layoutRuns(
+    runs,
+    {
+      maxWidth: opts.maxWidth ?? pose.width,
+      lineHeight: style.lineHeight,
+      align: style.align
+    },
+    { x: pose.x, y: pose.y }
+  );
+  const dy = verticalAlignOffset(pose.verticalAlign, pose.height, laid.bounds.height);
+  const out = [];
+  for (const line of laid.lines) {
+    if (!opts.includeEmpty && line.x1 <= line.x0) continue;
+    out.push({
+      x: line.x0 - padding,
+      y: line.y0 + dy - padding,
+      width: line.x1 - line.x0 + padding * 2,
+      height: line.y1 - line.y0 + padding * 2
+    });
   }
-  return polygonsIntersect(extractVertices(path), polygon);
+  return out;
 }
 
 // src/features/images/imageCache.ts
-var cache2 = /* @__PURE__ */ new Map();
+var cache4 = /* @__PURE__ */ new Map();
 var subscribers = /* @__PURE__ */ new Set();
 var defaultLoader = async (src) => {
   if (typeof Image === "undefined" || typeof createImageBitmap === "undefined") {
@@ -12698,28 +13226,28 @@ function notify() {
 }
 function startLoad(src) {
   const entry = { status: "loading" };
-  cache2.set(src, entry);
+  cache4.set(src, entry);
   loader(src).then(
     (bitmap) => {
-      if (cache2.get(src) !== entry) return;
-      cache2.set(src, { status: "ready", bitmap });
+      if (cache4.get(src) !== entry) return;
+      cache4.set(src, { status: "ready", bitmap });
       notify();
     },
     () => {
-      if (cache2.get(src) !== entry) return;
-      cache2.set(src, { status: "error" });
+      if (cache4.get(src) !== entry) return;
+      cache4.set(src, { status: "error" });
       notify();
     }
   );
 }
 function getImageBitmap(src) {
-  const entry = cache2.get(src);
+  const entry = cache4.get(src);
   if (entry) return entry.bitmap;
   startLoad(src);
   return void 0;
 }
 function imageStatus(src) {
-  return cache2.get(src)?.status ?? "idle";
+  return cache4.get(src)?.status ?? "idle";
 }
 function subscribeImageReady(cb) {
   subscribers.add(cb);
@@ -12728,7 +13256,39 @@ function subscribeImageReady(cb) {
   };
 }
 
+// src/core/scene/nodeMemo.ts
+var MEMO = /* @__PURE__ */ new WeakMap();
+var generation = 0;
+function nodeMemo(node, slot, pose, derive) {
+  let record = MEMO.get(node);
+  if (record === void 0) {
+    record = { generation, slots: /* @__PURE__ */ new Map() };
+    MEMO.set(node, record);
+  } else if (record.generation !== generation) {
+    record.generation = generation;
+    record.slots.clear();
+  }
+  const data = node.data;
+  const hit = record.slots.get(slot);
+  if (hit !== void 0 && hit.pose === pose && hit.data === data) {
+    return hit.value;
+  }
+  const value = derive();
+  if (hit !== void 0) {
+    hit.pose = pose;
+    hit.data = data;
+    hit.value = value;
+  } else {
+    record.slots.set(slot, { pose, data, value });
+  }
+  return value;
+}
+function bumpNodeMemoGeneration() {
+  generation++;
+}
+
 // src/canvas/NodeShape.ts
+var DEFAULT_INK = { filled: true, strokeWidth: 0 };
 var PAINTERS = {
   high: [],
   normal: []
@@ -12736,12 +13296,25 @@ var PAINTERS = {
 function registerNodeShape(painter, opts = {}) {
   const list = opts.priority === "high" ? PAINTERS.high : PAINTERS.normal;
   list.push(painter);
+  bumpNodeMemoGeneration();
   return () => {
     const i = list.indexOf(painter);
     if (i >= 0) list.splice(i, 1);
+    bumpNodeMemoGeneration();
   };
 }
+var PAINTER_SLOT = "shape:painter";
+var SILHOUETTE_SLOT = "shape:silhouette";
+var PAINT_SLOT = "shape:paint";
 function findNodeShape(node) {
+  return nodeMemo(
+    node,
+    PAINTER_SLOT,
+    void 0,
+    () => matchNodeShape(node)
+  );
+}
+function matchNodeShape(node) {
   for (const p of PAINTERS.high) {
     if (p.matches(node)) {
       return p;
@@ -12755,10 +13328,22 @@ function findNodeShape(node) {
   return void 0;
 }
 function findShapeSilhouette(node, pose) {
-  const sil = findNodeShape(node)?.silhouette?.(node, pose) ?? null;
-  if (!sil) return null;
-  const r = poseRotationOf(pose);
-  return r ? rotatePathAround(sil, r.cx, r.cy, r.rotation) : sil;
+  return nodeMemo(node, SILHOUETTE_SLOT, pose, () => {
+    const sil = findNodeShape(node)?.silhouette?.(node, pose) ?? null;
+    const r = sil ? poseRotationOf(pose) : null;
+    return sil && r ? rotatePathAround(sil, r.cx, r.cy, r.rotation) : sil;
+  });
+}
+function findShapeInk(node, pose) {
+  return findNodeShape(node)?.ink?.(node, pose) ?? null;
+}
+function shapeCoversPoint(node, pose, x, y, opts = {}) {
+  const sil = findShapeSilhouette(node, pose);
+  if (sil === null) return true;
+  const ink = findShapeInk(node, pose) ?? DEFAULT_INK;
+  if (ink.filled && pathContainsPoint(sil, x, y)) return true;
+  const reach = ink.strokeWidth / 2 + (opts.tolerance ?? 0);
+  return reach > 0 && strokeHitTest(sil, x, y, reach);
 }
 function getNodeShapes() {
   return [...PAINTERS.high, ...PAINTERS.normal];
@@ -12769,21 +13354,86 @@ var TEXT_PAINTER = {
     const d = node.data;
     return d?.text != null;
   },
-  paint: (node, pose) => {
+  // Memoized, and not for its own sake — `resolveTextStyle` + `resolveRuns`
+  // are cheap (0.14 ms/frame at 1000 text nodes). It is the enabler: the
+  // renderer's layout cache keys on the `ResolvedRun[]` array identity, and
+  // `layoutRuns` costs 25.9 ms/frame for 200 wrapped paragraphs. Handing back
+  // a fresh runs array per frame would leave that cache missing on every
+  // draw, exactly as a fresh `Path` per frame defeated the mesh cache. Both
+  // resolvers are pure style merging — no font reads — so `(data, pose)` is
+  // the whole key. See PAINT_SLOT.
+  paint: (node, pose) => nodeMemo(node, PAINT_SLOT, pose, () => {
     const d = node.data;
     const p = pose;
-    const fontSize = d.style?.fontSize ?? 16;
-    const y = p.y + fontSize;
+    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)];
+  }),
+  // 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
+  // union of the line boxes is what the node actually covers, so picking,
+  // lasso and clipping stop grabbing blank space. `Infinity` because `paint`
+  // above deliberately does not forward `maxWidth`: this text does not wrap,
+  // and boxes measured against `p.width` would wrap where the paint did not.
+  //
+  // `null` rather than an empty path when there are no non-blank lines: an
+  // empty text node would otherwise become unpickable, and a caller reading
+  // "no silhouette" falls back to the pose rect, which is the behavior an
+  // empty box wants.
+  silhouette: (node, pose) => {
+    const d = node.data;
+    const p = pose;
+    const boxes = textLineBoxes(
+      {
+        x: p.x,
+        y: p.y,
+        width: p.width,
+        height: p.height,
+        text: d.text,
+        runs: d.runs,
+        style: d.style
+      },
+      { maxWidth: Infinity }
+    );
+    if (boxes.length === 0) return null;
+    return rectsToPath(boxes);
   }
 };
+function rectsToPath(rects) {
+  const commands = new Uint8Array(rects.length * 6);
+  const coords = new Float32Array(rects.length * 10);
+  let ci = 0;
+  let cmd = 0;
+  for (const r of rects) {
+    const { x, y, width: w, height: h } = r;
+    commands[cmd++] = PATH_M;
+    coords[ci++] = x;
+    coords[ci++] = y;
+    commands[cmd++] = PATH_L;
+    coords[ci++] = x + w;
+    coords[ci++] = y;
+    commands[cmd++] = PATH_L;
+    coords[ci++] = x + w;
+    coords[ci++] = y + h;
+    commands[cmd++] = PATH_L;
+    coords[ci++] = x;
+    coords[ci++] = y + h;
+    commands[cmd++] = PATH_L;
+    coords[ci++] = x;
+    coords[ci++] = y;
+    commands[cmd++] = PATH_Z;
+  }
+  return { kind: "polygon", commands, coords, fillRule: "nonzero" };
+}
 var PATH_PAINTER = {
   id: "kit:path",
   matches: (node) => {
     const d = node.data;
     return d?.path != null;
   },
-  paint: (node, pose) => {
+  // Memoized: a pure function of `(data, pose)`, and `pathInPoseFrame`
+  // allocates on every call but the identity (`kind: 'rect'`) branch. See
+  // PAINT_SLOT.
+  paint: (node, pose) => nodeMemo(node, PAINT_SLOT, pose, () => {
     const d = node.data;
     const projected = pathInPoseFrame(d.path, pose);
     const hasStroke = !!d.stroke && d.stroke !== "none" && (d.strokeWidth ?? 0) > 0;
@@ -12796,10 +13446,23 @@ var PATH_PAINTER = {
       ...hasStroke ? { stroke: { paint: { color: d.stroke }, width: d.strokeWidth ?? 1 } } : {}
     };
     return [cmd];
-  },
+  }),
   silhouette: (node, pose) => {
     const d = node.data;
     return pathInPoseFrame(d.path, pose);
+  },
+  // Mirrors the fill/stroke decisions `paint` makes above — same reads, same
+  // 'none' handling, same "no fill declared and a stroke present means
+  // stroke-only" fallback. Kept in step with `paint` by
+  // `NodeShape.ink.test.ts`, which asserts the two agree.
+  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),
+      strokeWidth: hasStroke ? d.strokeWidth ?? 1 : 0
+    };
   }
 };
 var SHAPE_PAINTER = {
@@ -12808,7 +13471,10 @@ var SHAPE_PAINTER = {
     const s = node.data?.shape;
     return s != null && SHAPE_KINDS.has(s);
   },
-  paint: (node, pose) => {
+  // Memoized: a pure function of `(data, pose)`, and `pathForShape` builds a
+  // fresh `Uint8Array` + `Float32Array` for every ellipse, polygon and star.
+  // See PAINT_SLOT.
+  paint: (node, pose) => nodeMemo(node, PAINT_SLOT, pose, () => {
     const d = node.data;
     const path = pathForShape(d, pose);
     return [{
@@ -12817,10 +13483,17 @@ var SHAPE_PAINTER = {
       fill: { color: d.fill ?? d.color ?? "#888" },
       ...d.stroke && (d.strokeWidth ?? 0) > 0 ? { stroke: { paint: { color: d.stroke }, width: d.strokeWidth ?? 1 } } : {}
     }];
-  },
+  }),
   silhouette: (node, pose) => {
     const d = node.data;
     return pathForShape(d, pose);
+  },
+  // `paint` above always emits a fill (defaulting to '#888'), so this shape
+  // family is always filled — unlike `kit:path`, it has no stroke-only form.
+  ink: (node) => {
+    const d = node.data;
+    const hasStroke = !!d.stroke && (d.strokeWidth ?? 0) > 0;
+    return { filled: true, strokeWidth: hasStroke ? d.strokeWidth ?? 1 : 0 };
   }
 };
 var SHAPE_KINDS = /* @__PURE__ */ new Set(["rect", "ellipse", "polygon", "star"]);
@@ -12951,15 +13624,29 @@ var MULTI_RESIZE_TARGET_ID = "__weasel:multi-selection";
 // src/tools/builtin/select/useSelectTool.ts
 function useSelectTool(adapter, options) {
   const poseBoundsFn = options.poseBounds ?? ((p) => p);
+  const preciseLeaves = options.leafPicking === "silhouette";
+  const tolerance = options.pickTolerance ?? 0;
   const pickEveryFn = options.pickEvery ?? ((worldX, worldY) => {
     const hier = adapter;
+    const covers = (node, pose, b) => {
+      const t = preciseLeaves ? tolerance : 0;
+      if (!(worldX >= b.x - t && worldX <= b.x + b.width + t && worldY >= b.y - t && worldY <= b.y + b.height + t)) {
+        return false;
+      }
+      if (!preciseLeaves) return true;
+      return shapeCoversPoint(
+        node,
+        pose,
+        worldX,
+        worldY,
+        { tolerance }
+      );
+    };
     if (typeof hier.getChildren !== "function" || typeof hier.getNode !== "function") {
       const out2 = [];
       for (const obj of adapter.getNodes()) {
-        const b = poseBoundsFn(adapter.getPose(obj.id));
-        if (worldX >= b.x && worldX <= b.x + b.width && worldY >= b.y && worldY <= b.y + b.height) {
-          out2.push(obj.id);
-        }
+        const pose = adapter.getPose(obj.id);
+        if (covers(obj, pose, poseBoundsFn(pose))) out2.push(obj.id);
       }
       return out2;
     }
@@ -12997,10 +13684,7 @@ function useSelectTool(adapter, options) {
           for (const clip of ancestorClips) {
             if (!pathContainsPoint(clip, worldX, worldY)) continue nextChild;
           }
-          const b = poseBoundsFn(pose);
-          if (worldX >= b.x && worldX <= b.x + b.width && worldY >= b.y && worldY <= b.y + b.height) {
-            out.push(childId);
-          }
+          if (covers(node, pose, poseBoundsFn(pose))) out.push(childId);
         }
       }
     }
@@ -13218,6 +13902,101 @@ function useSelectTool(adapter, options) {
   );
 }
 
+// src/affordances/hitAffordanceRegions.ts
+function hitAffordanceRegions(affordances, wx, wy, state, view, isVisible) {
+  for (let i = affordances.length - 1; i >= 0; i--) {
+    const a = affordances[i];
+    if (isVisible && !isVisible(a.id)) continue;
+    const regions = a.regions(state);
+    let best = null;
+    for (let j = 0; j < regions.length; j++) {
+      const region = regions[j];
+      const xf = transformOf(state, region.targetId);
+      if (!hitRegion(region, wx, wy, xf, view)) continue;
+      const d2 = regionDistance2(region, wx, wy, xf);
+      if (best === null || d2 <= best.d2) best = { region, d2 };
+    }
+    if (best) {
+      return {
+        affordanceId: a.id,
+        regionId: best.region.id,
+        region: best.region,
+        binding: best.region.bind()
+      };
+    }
+  }
+  return null;
+}
+function regionDistance2(region, wx, wy, xf) {
+  const s = region.shape;
+  const local = s.kind === "point" ? { x: s.x, y: s.y } : s.kind === "annulus" ? { x: s.cx, y: s.cy } : { x: s.x + s.width / 2, y: s.y + s.height / 2 };
+  const w = localToWorld(xf, local.x, local.y);
+  const dx = w.x - wx;
+  const dy = w.y - wy;
+  return dx * dx + dy * dy;
+}
+var IDENTITY_XF = { cx: 0, cy: 0, cos: 1, sin: 0, identity: true };
+function transformOf(state, targetId) {
+  if (targetId === null) return IDENTITY_XF;
+  const b = state.boundsOf(targetId);
+  if (!b) return IDENTITY_XF;
+  const r = poseRotationOf(b);
+  if (!r) return IDENTITY_XF;
+  return {
+    cx: r.cx,
+    cy: r.cy,
+    cos: Math.cos(r.rotation),
+    sin: Math.sin(r.rotation),
+    identity: false
+  };
+}
+function localToWorld(xf, lx, ly) {
+  if (xf.identity) return { x: lx, y: ly };
+  const dx = lx - xf.cx;
+  const dy = ly - xf.cy;
+  return {
+    x: xf.cx + xf.cos * dx - xf.sin * dy,
+    y: xf.cy + xf.sin * dx + xf.cos * dy
+  };
+}
+function worldToLocal(xf, wx, wy) {
+  if (xf.identity) return { x: wx, y: wy };
+  const dx = wx - xf.cx;
+  const dy = wy - xf.cy;
+  return {
+    x: xf.cx + xf.cos * dx + xf.sin * dy,
+    y: xf.cy - xf.sin * dx + xf.cos * dy
+  };
+}
+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);
+  return {
+    rx: Math.max(shape.rx, shape.innerWidth / 2 + band),
+    ry: Math.max(shape.ry, shape.innerHeight / 2 + band)
+  };
+}
+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;
+  }
+  if (region.shape.kind === "annulus") {
+    const s = region.shape;
+    const insideInner = local.x >= s.innerX && local.x <= s.innerX + s.innerWidth && local.y >= s.innerY && local.y <= s.innerY + s.innerHeight;
+    if (insideInner) return false;
+    const { rx, ry } = annulusSemiAxes(s, view);
+    if (rx <= 0 || ry <= 0) return false;
+    const ex = (local.x - s.cx) / rx;
+    const ey = (local.y - s.cy) / ry;
+    return ex * ex + ey * ey <= 1;
+  }
+  const r = region.shape;
+  return local.x >= r.x && local.x <= r.x + r.width && local.y >= r.y && local.y <= r.y + r.height;
+}
+
 // src/affordances/composeAffordanceLayer.ts
 function composeAffordanceLayer(id, label, affordances) {
   return {
@@ -13243,21 +14022,11 @@ function composeAffordanceLayer(id, label, affordances) {
       }
       return out;
     },
-    hitTest: (wx, wy, state, view, _dims, isVisible) => {
-      for (let i = affordances.length - 1; i >= 0; i--) {
-        const a = affordances[i];
-        if (isVisible && !isVisible(a.id)) continue;
-        const regs = a.regions(state);
-        for (let j = regs.length - 1; j >= 0; j--) {
-          const region = regs[j];
-          const xf = transformOf(state, region.targetId);
-          if (hitRegion(region, wx, wy, xf, view)) {
-            return region.bind();
-          }
-        }
-      }
-      return null;
-    }
+    // The walk itself lives in `hitAffordanceRegions` so this layer and
+    // `buildAffordanceAt` share one implementation rather than two that can
+    // drift. This wrapper exists because `RenderLayer.hitTest` wants only the
+    // binding back.
+    hitTest: (wx, wy, state, view, _dims, isVisible) => hitAffordanceRegions(affordances, wx, wy, state, view, isVisible)?.binding ?? null
   };
 }
 function asChromeState(data) {
@@ -13291,11 +14060,12 @@ function recordRegionHitbox(debug, affordanceId, region, xf, view) {
   }
   if (region.shape.kind === "annulus") {
     const s = region.shape;
+    const { rx, ry } = annulusSemiAxes(s, view);
     const pts = [
-      localToWorld(xf, s.cx + s.rx, s.cy),
-      localToWorld(xf, s.cx - s.rx, s.cy),
-      localToWorld(xf, s.cx, s.cy + s.ry),
-      localToWorld(xf, s.cx, s.cy - s.ry)
+      localToWorld(xf, s.cx + rx, s.cy),
+      localToWorld(xf, s.cx - rx, s.cy),
+      localToWorld(xf, s.cx, s.cy + ry),
+      localToWorld(xf, s.cx, s.cy - ry)
     ];
     const minX = Math.min(...pts.map((p) => p.x));
     const minY = Math.min(...pts.map((p) => p.y));
@@ -13322,39 +14092,6 @@ function recordRegionHitbox(debug, affordanceId, region, xf, view) {
     ...xf.identity ? {} : { rotation: Math.atan2(xf.sin, xf.cos) }
   });
 }
-var IDENTITY_XF = { cx: 0, cy: 0, cos: 1, sin: 0, identity: true };
-function transformOf(state, targetId) {
-  if (targetId === null) return IDENTITY_XF;
-  const b = state.boundsOf(targetId);
-  if (!b) return IDENTITY_XF;
-  const r = poseRotationOf(b);
-  if (!r) return IDENTITY_XF;
-  return {
-    cx: r.cx,
-    cy: r.cy,
-    cos: Math.cos(r.rotation),
-    sin: Math.sin(r.rotation),
-    identity: false
-  };
-}
-function localToWorld(xf, lx, ly) {
-  if (xf.identity) return { x: lx, y: ly };
-  const dx = lx - xf.cx;
-  const dy = ly - xf.cy;
-  return {
-    x: xf.cx + xf.cos * dx - xf.sin * dy,
-    y: xf.cy + xf.sin * dx + xf.cos * dy
-  };
-}
-function worldToLocal(xf, wx, wy) {
-  if (xf.identity) return { x: wx, y: wy };
-  const dx = wx - xf.cx;
-  const dy = wy - xf.cy;
-  return {
-    x: xf.cx + xf.cos * dx + xf.sin * dy,
-    y: xf.cy - xf.sin * dx + xf.cos * dy
-  };
-}
 function paintRegion(region, xf, view, state, viewT, out) {
   const paint = region.paint;
   if (paint.kind === "square") {
@@ -13377,13 +14114,13 @@ function paintRegion(region, xf, view, state, viewT, out) {
     if (region.shape.kind !== "annulus") return;
     const s = region.shape;
     const insetLocal = (paint.insetPx ?? 0) / meanScale(view.scale);
-    const cmd = annulusCommand(s, insetLocal, xf, viewT, paint.fill, paint.stroke);
+    const cmd = annulusCommand(s, annulusSemiAxes(s, view), insetLocal, xf, viewT, paint.fill, paint.stroke);
     if (cmd) out.push(cmd);
     return;
   }
   if (paint.kind === "custom") {
     const ctx = {
-      world: worldOf(region, xf),
+      world: worldOf(region, xf, view),
       local: region.shape,
       view,
       state
@@ -13392,9 +14129,9 @@ function paintRegion(region, xf, view, state, viewT, out) {
     return;
   }
 }
-function annulusCommand(shape, insetLocal, xf, viewT, fill, stroke) {
-  const rx = shape.rx - insetLocal;
-  const ry = shape.ry - insetLocal;
+function annulusCommand(shape, semiAxes, insetLocal, xf, viewT, fill, stroke) {
+  const rx = semiAxes.rx - insetLocal;
+  const ry = semiAxes.ry - insetLocal;
   if (rx <= 0 || ry <= 0) return null;
   const cx = shape.cx;
   const cy = shape.cy;
@@ -13460,18 +14197,19 @@ function annulusCommand(shape, insetLocal, xf, viewT, fill, stroke) {
     ...stroke ? { stroke } : {}
   };
 }
-function worldOf(region, xf) {
+function worldOf(region, xf, view) {
   if (region.shape.kind === "point") {
     const w = localToWorld(xf, region.shape.x, region.shape.y);
     return { x: w.x, y: w.y };
   }
   if (region.shape.kind === "annulus") {
     const s = region.shape;
+    const { rx, ry } = annulusSemiAxes(s, view);
     const pts = [
-      localToWorld(xf, s.cx + s.rx, s.cy),
-      localToWorld(xf, s.cx - s.rx, s.cy),
-      localToWorld(xf, s.cx, s.cy + s.ry),
-      localToWorld(xf, s.cx, s.cy - s.ry)
+      localToWorld(xf, s.cx + rx, s.cy),
+      localToWorld(xf, s.cx - rx, s.cy),
+      localToWorld(xf, s.cx, s.cy + ry),
+      localToWorld(xf, s.cx, s.cy - ry)
     ];
     const minX2 = Math.min(...pts.map((p) => p.x));
     const minY2 = Math.min(...pts.map((p) => p.y));
@@ -13490,24 +14228,6 @@ function worldOf(region, xf) {
   const maxY = Math.max(a.y, b.y, c.y, d.y);
   return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
 }
-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;
-  }
-  if (region.shape.kind === "annulus") {
-    const s = region.shape;
-    const insideInner = local.x >= s.innerX && local.x <= s.innerX + s.innerWidth && local.y >= s.innerY && local.y <= s.innerY + s.innerHeight;
-    if (insideInner) return false;
-    if (s.rx <= 0 || s.ry <= 0) return false;
-    const ex = (local.x - s.cx) / s.rx;
-    const ey = (local.y - s.cy) / s.ry;
-    return ex * ex + ey * ey <= 1;
-  }
-  const r = region.shape;
-  return local.x >= r.x && local.x <= r.x + r.width && local.y >= r.y && local.y <= r.y + r.height;
-}
 
 // src/affordances/rotationHandle.ts
 var DEFAULT_PAINT = {
@@ -13538,13 +14258,8 @@ function createRotationAffordance(opts = {}) {
       const target = pickTarget(state);
       if (!target) return [];
       const b = target.bounds;
-      const minBand = bandPx;
       const halfW = b.width / 2;
       const halfH = b.height / 2;
-      const naturalRx = halfW * Math.SQRT2;
-      const naturalRy = halfH * Math.SQRT2;
-      const rx = Math.max(naturalRx, halfW + minBand);
-      const ry = Math.max(naturalRy, halfH + minBand);
       const region = {
         id: "selection.rotation-handle",
         targetId: target.id,
@@ -13552,17 +14267,24 @@ function createRotationAffordance(opts = {}) {
           kind: "annulus",
           cx: b.x + halfW,
           cy: b.y + halfH,
-          rx,
-          ry,
+          rx: halfW * Math.SQRT2,
+          ry: halfH * Math.SQRT2,
           innerX: b.x,
           innerY: b.y,
           innerWidth: b.width,
-          innerHeight: b.height
+          innerHeight: b.height,
+          minBandPx: bandPx
         },
         ...annulusPaint ? { paint: annulusPaint } : {},
+        hitKind: "rotate-handle",
         cursor,
         bind: () => ({
-          initialScratch: { targetId: target.id }
+          initialScratch: {
+            targetId: target.id,
+            // Pivot. `rotateAction` recomputes its own union pivot for
+            // multi-selection, but the single-target case reads this.
+            fixedPoint: { x: b.x + halfW, y: b.y + halfH }
+          }
         })
       };
       return [region];
@@ -13630,8 +14352,7 @@ function useRotateTool(adapter, options) {
         const ghosts = ghostOverlay.draw(data, view, dims);
         const aff = affordanceOverlay.draw(toChromeState(data), view, dims);
         return [...ghosts, ...aff];
-      },
-      hitTest: (wx, wy, data, view, dims) => affordanceOverlay.hitTest(wx, wy, toChromeState(data), view, dims)
+      }
     }),
     [ghostOverlay, affordanceOverlay]
   );
@@ -14476,12 +15197,12 @@ function defaultDrawOne(node, pose, ctx) {
   const data = node.data;
   if (data?.label && data.text == null) {
     const p = pose;
-    primary.push(textCommand(
+    return [...primary, textCommand(
       p.x + 6,
       p.y + 14,
       data.label,
       { fontFamily: "sans-serif", fontSize: 11, fill: { fill: "solid", color: "rgba(0,0,0,0.7)" } }
-    ));
+    )];
   }
   return primary;
 }
@@ -17546,28 +18267,32 @@ function aabbOfPose(pose) {
   );
 }
 var DEFAULT_PATH_STROKE_SLOP = 4;
-function poseContains(pose, wx, wy) {
+function poseContains(pose, wx, wy, tolerance) {
   if (isPathLike(pose)) {
     if (pointInPath(pose, wx, wy)) return true;
-    return strokeHitTest(pose, wx, wy, DEFAULT_PATH_STROKE_SLOP);
+    return strokeHitTest(pose, wx, wy, tolerance ?? DEFAULT_PATH_STROKE_SLOP);
   }
   const b = aabbOfPose(pose);
-  return wx >= b.x && wx <= b.x + b.width && wy >= b.y && wy <= b.y + b.height;
+  const t = tolerance ?? 0;
+  return wx >= b.x - t && wx <= b.x + b.width + t && wy >= b.y - t && wy <= b.y + b.height + t;
 }
-function poseContainsRotated(pose, wx, wy) {
+function poseContainsRotated(pose, wx, wy, tolerance) {
   const r = poseRotationOf(pose);
   if (r) {
     const [lx, ly] = applyToPoint(rotateAboutPoint(r.cx, r.cy, -r.rotation), wx, wy);
-    return poseContains(pose, lx, ly);
+    return poseContains(pose, lx, ly, tolerance);
   }
-  return poseContains(pose, wx, wy);
+  return poseContains(pose, wx, wy, tolerance);
 }
 
 // src/canvas/SceneCanvas/useSceneSelectTool.ts
+var DEFAULT_PICK_TOLERANCE_PX = 4;
 function useSceneSelectTool(args) {
-  const { scene, selection, geometry, selectTool: opts, insertTool, layouts } = args;
+  const { scene, selection, geometry, selectTool: opts, insertTool, layouts, getView } = args;
   const pickEveryProp = geometry?.pickEvery;
   const boundsOfProp = geometry?.boundsOf;
+  const shapePicking = (geometry?.picking ?? "shape") === "shape";
+  const pickTolerancePx = geometry?.pickTolerancePx ?? DEFAULT_PICK_TOLERANCE_PX;
   const moveOptions = opts?.move;
   const rotateOptions = opts?.rotate;
   const snap2 = opts?.snap;
@@ -17658,14 +18383,17 @@ function useSceneSelectTool(args) {
         if (r == null) return [];
         return Array.isArray(r) ? r : [r];
       }
+      const tolerance = pickTolerancePx / meanScale(getView?.()?.scale ?? { x: 1, y: 1 });
       const out = [];
       for (const id of scene.renderOrder()) {
         const n = scene.get(id);
-        if (n && poseContainsRotated(n.pose, wx, wy)) out.push(n.id);
+        if (!n || !poseContainsRotated(n.pose, wx, wy, tolerance)) continue;
+        if (shapePicking && !shapeCoversPoint(n, n.pose, wx, wy, { tolerance })) continue;
+        out.push(n.id);
       }
       return out;
     };
-  }, [scene, pickEveryProp]);
+  }, [scene, pickEveryProp, shapePicking, pickTolerancePx, getView]);
   const wiredBoundsOf = useMemo(() => {
     return (id) => {
       if (boundsOfProp) return boundsOfProp(id);
@@ -18417,77 +19145,76 @@ function enumerateAnchors(path) {
         };
         anchors.push(a);
         lastAnchor = a;
-        ci += 4;
-        break;
-      }
-      case PATH_Z: {
-        lastAnchor = null;
-        break;
-      }
-    }
-  }
-  return anchors;
-}
-function withCoord(path, coordIndex, x, y) {
-  const next = new Float32Array(path.coords);
-  next[coordIndex] = x;
-  next[coordIndex + 1] = y;
-  return { kind: "polygon", commands: path.commands, coords: next, fillRule: path.fillRule };
-}
-
-// src/interactions/actions/edit-anchors/handles.ts
-function hitAnchor(path, worldX, worldY, threshold) {
-  const anchors = enumerateAnchors(path);
-  let bestControl = null;
-  let bestAnchor = null;
-  const t2 = threshold * threshold;
-  for (const a of anchors) {
-    if (a.controlIn) {
-      const dx2 = a.controlIn.x - worldX;
-      const dy2 = a.controlIn.y - worldY;
-      const d22 = dx2 * dx2 + dy2 * dy2;
-      if (d22 <= t2 && (!bestControl || d22 < bestControl.d2)) {
-        bestControl = {
-          d2: d22,
-          hit: { anchorIndex: a.anchorIndex, kind: "controlIn", coordIndex: a.controlIn.coordIndex }
-        };
-      }
-    }
-    if (a.controlOut) {
-      const dx2 = a.controlOut.x - worldX;
-      const dy2 = a.controlOut.y - worldY;
-      const d22 = dx2 * dx2 + dy2 * dy2;
-      if (d22 <= t2 && (!bestControl || d22 < bestControl.d2)) {
-        bestControl = {
-          d2: d22,
-          hit: { anchorIndex: a.anchorIndex, kind: "controlOut", coordIndex: a.controlOut.coordIndex }
-        };
+        ci += 4;
+        break;
+      }
+      case PATH_Z: {
+        lastAnchor = null;
+        break;
       }
-    }
-    const dx = a.x - worldX;
-    const dy = a.y - worldY;
-    const d2 = dx * dx + dy * dy;
-    if (d2 <= t2 && (!bestAnchor || d2 < bestAnchor.d2)) {
-      bestAnchor = {
-        d2,
-        hit: { anchorIndex: a.anchorIndex, kind: "anchor", coordIndex: a.coordIndex }
-      };
     }
   }
-  if (bestControl) return bestControl.hit;
-  if (bestAnchor) return bestAnchor.hit;
-  return null;
+  return anchors;
+}
+function withCoord(path, coordIndex, x, y) {
+  const next = new Float32Array(path.coords);
+  next[coordIndex] = x;
+  next[coordIndex + 1] = y;
+  return { kind: "polygon", commands: path.commands, coords: next, fillRule: path.fillRule };
 }
 
-// src/canvas/affordanceAt.ts
-var HANDLE_HIT_RADIUS = 8;
-var ROTATE_DISTANCE = DEFAULT_ROTATION_HANDLE_DISTANCE;
-function dist22(ax, ay, bx, by) {
-  const dx = ax - bx;
-  const dy = ay - by;
-  return dx * dx + dy * dy;
+// src/affordances/cornerResize.ts
+var DEFAULT_FILL3 = "#d4c4a8";
+var DEFAULT_STROKE = "#1a130d";
+function createCornerResizeAffordance(opts = {}) {
+  const {
+    handleHitRadius = 8,
+    handleSize = 8,
+    fill = DEFAULT_FILL3,
+    stroke = DEFAULT_STROKE
+  } = opts;
+  const paint = {
+    kind: "square",
+    sizePx: handleSize,
+    fill: { color: fill },
+    stroke: { paint: { color: stroke }, width: 1 }
+  };
+  return {
+    id: "selection.resize-handles",
+    regions(state) {
+      const target = pickRenderTarget(state);
+      if (!target) return [];
+      const b = target.bounds;
+      const xf = transformOf(state, target.id);
+      return CORNER_ANCHORS.map((c) => {
+        const corner = cornerPoint(b, c);
+        const fixedLocal = fixedCornerOf(b, c.anchor);
+        const fixedPoint = localToWorld(xf, fixedLocal.x, fixedLocal.y);
+        return {
+          id: `corner-${c.tag}`,
+          targetId: target.id,
+          shape: { kind: "point", x: corner.x, y: corner.y, hitRadiusPx: handleHitRadius },
+          paint,
+          hitKind: c.kind,
+          // Diagonal by fixed-corner parity: a matched-axis anchor (min-min /
+          // max-max fixed) means the dragged corner sits on the ↘ diagonal;
+          // mixed axes sit on the ↗ diagonal. Not rotation-aware — a rotated
+          // target keeps the unrotated hint, the same policy as every
+          // mainstream editor short of Figma.
+          cursor: c.anchor.x === c.anchor.y ? "nwse-resize" : "nesw-resize",
+          bind: () => ({
+            initialScratch: {
+              anchor: c.anchor,
+              targetId: target.id,
+              fixedPoint
+            }
+          })
+        };
+      });
+    }
+  };
 }
-function pickResizeTarget(state) {
+function pickRenderTarget(state) {
   if (state.multiActive && state.unionBounds) {
     return { id: MULTI_RESIZE_TARGET_ID, bounds: state.unionBounds };
   }
@@ -18498,110 +19225,130 @@ function pickResizeTarget(state) {
   }
   return null;
 }
-function cornersFor(b) {
-  const r = poseRotationOf(b);
-  const place = (px, py) => r ? rotatePoint(px, py, r.cx, r.cy, r.rotation) : { x: px, y: py };
-  return CORNER_ANCHORS.map((c) => {
-    const corner = cornerPoint(b, c);
-    const fixed = fixedCornerOf(b, c.anchor);
-    const wp = place(corner.x, corner.y);
-    const fp = place(fixed.x, fixed.y);
-    return { worldX: wp.x, worldY: wp.y, kind: c.kind, anchor: c.anchor, fixedX: fp.x, fixedY: fp.y };
-  });
-}
-function buildAffordanceAt(getChromeState, hitRadius = HANDLE_HIT_RADIUS, rotateDistance = ROTATE_DISTANCE, getAnchorState, getIsVisible) {
-  return function affordanceAt({ x: wx, y: wy }) {
-    const state = getChromeState();
-    const isVisible = getIsVisible?.() ?? (() => true);
-    const hr = typeof hitRadius === "function" ? hitRadius() : hitRadius;
-    const rd = typeof rotateDistance === "function" ? rotateDistance() : rotateDistance;
-    const r2 = hr * hr;
-    if (isVisible("selection.resize-handles")) {
-      const resizeTarget = pickResizeTarget(state);
-      if (resizeTarget) {
-        for (const c of cornersFor(resizeTarget.bounds)) {
-          if (dist22(wx, wy, c.worldX, c.worldY) <= r2) {
-            return {
-              kind: c.kind,
-              fixedPoint: { x: c.fixedX, y: c.fixedY },
-              targetIds: [resizeTarget.id],
-              anchor: c.anchor,
-              // Diagonal by fixed-corner parity: a matched-axis anchor
-              // (min-min / max-max fixed) means the dragged corner sits on
-              // the ↘ diagonal; mixed axes sit on the ↗ diagonal. Cursor is
-              // not rotation-aware — a rotated target keeps the unrotated
-              // hint (same policy as every mainstream editor short of Figma).
-              cursor: c.anchor.x === c.anchor.y ? "nwse-resize" : "nesw-resize"
-            };
-          }
-        }
-      }
+
+// src/affordances/pathAnchors.ts
+var PATH_ANCHOR_CHROME_ID = "path-edit.anchors";
+function createPathAnchorAffordances(getAnchorState, opts = {}) {
+  const { hitRadius = 8, cursor = "pointer" } = opts;
+  const editablePaths = (state) => {
+    const anchorState = getAnchorState();
+    if (!anchorState) return [];
+    const out = [];
+    for (const id of state.selection) {
+      const pose = anchorState.getPose(id);
+      if (!pose || pose.kind !== "polygon") continue;
+      out.push({ id, path: pose });
     }
-    if (isVisible("selection.rotation-handle")) {
-      const rotateTarget = pickResizeTarget(state);
-      if (rotateTarget) {
-        const { x: bx, y: by, width: bw, height: bh } = rotateTarget.bounds;
-        const halfW = bw / 2;
-        const halfH = bh / 2;
-        const centerX = bx + halfW;
-        const centerY = by + halfH;
-        const r = poseRotationOf(rotateTarget.bounds);
-        const lp = r ? rotatePoint(wx, wy, centerX, centerY, -r.rotation) : { x: wx, y: wy };
-        const insideAabb = lp.x >= bx && lp.x <= bx + bw && lp.y >= by && lp.y <= by + bh;
-        if (!insideAabb) {
-          const rx = Math.max(halfW * Math.SQRT2, halfW + rd);
-          const ry = Math.max(halfH * Math.SQRT2, halfH + rd);
-          if (rx > 0 && ry > 0) {
-            const ex = (lp.x - centerX) / rx;
-            const ey = (lp.y - centerY) / ry;
-            if (ex * ex + ey * ey <= 1) {
-              return {
-                kind: "rotate-handle",
-                fixedPoint: { x: centerX, y: centerY },
-                // pivot
-                targetIds: [rotateTarget.id],
-                cursor: "grab"
-              };
-            }
-          }
+    return out;
+  };
+  const point = (id, targetId, x, y, scratch, hitKind) => ({
+    id,
+    // Anchor coordinates are already in the path's own space, which for an
+    // editable path is world space — the pose rotation that `targetId` would
+    // introduce is baked into the coords. Anchoring to `null` keeps the
+    // framework from applying it twice.
+    targetId: null,
+    shape: { kind: "point", x, y, hitRadiusPx: hitRadius },
+    hitKind,
+    cursor,
+    bind: () => ({ initialScratch: { ...scratch, targetId } })
+  });
+  const anchors = {
+    id: PATH_ANCHOR_CHROME_ID,
+    regions(state) {
+      const out = [];
+      for (const { id, path } of editablePaths(state)) {
+        for (const a of enumerateAnchors(path)) {
+          out.push(point(
+            `${id}:anchor:${a.anchorIndex}`,
+            id,
+            a.x,
+            a.y,
+            { targetId: id, anchorIndex: a.anchorIndex, part: "anchor" },
+            `anchor:${a.anchorIndex}`
+          ));
         }
       }
+      return out;
     }
-    if (isVisible("path-edit.anchors") && getAnchorState) {
+  };
+  const controls = {
+    id: PATH_ANCHOR_CHROME_ID,
+    regions(state) {
       const anchorState = getAnchorState();
-      if (anchorState) {
-        const { editingId } = anchorState;
-        for (const id of state.selection) {
-          const pose = anchorState.getPose(id);
-          if (!pose || pose.kind !== "polygon") continue;
-          const polygon = pose;
-          const inEditMode = editingId === id;
-          if (inEditMode) {
-            const hit = hitAnchor(polygon, wx, wy, hr);
-            if (hit) {
-              const kindStr = hit.kind === "anchor" ? `anchor:${hit.anchorIndex}` : hit.kind === "controlIn" ? `controlIn:${hit.anchorIndex}` : `controlOut:${hit.anchorIndex}`;
-              return { kind: kindStr, targetIds: [id] };
-            }
-          } else {
-            const anchors = enumerateAnchors(polygon);
-            const r2anchor = hr * hr;
-            let best = null;
-            for (const a of anchors) {
-              const dx = a.x - wx;
-              const dy = a.y - wy;
-              const d2 = dx * dx + dy * dy;
-              if (d2 <= r2anchor && (!best || d2 < best.d2)) {
-                best = { d2, anchorIndex: a.anchorIndex };
-              }
-            }
-            if (best !== null) {
-              return { kind: `anchor:${best.anchorIndex}`, targetIds: [id] };
-            }
+      const editingId = anchorState?.editingId ?? null;
+      if (editingId === null) return [];
+      const out = [];
+      for (const { id, path } of editablePaths(state)) {
+        if (id !== editingId) continue;
+        for (const a of enumerateAnchors(path)) {
+          if (a.controlIn) {
+            out.push(point(
+              `${id}:controlIn:${a.anchorIndex}`,
+              id,
+              a.controlIn.x,
+              a.controlIn.y,
+              { targetId: id, anchorIndex: a.anchorIndex, part: "controlIn" },
+              `controlIn:${a.anchorIndex}`
+            ));
+          }
+          if (a.controlOut) {
+            out.push(point(
+              `${id}:controlOut:${a.anchorIndex}`,
+              id,
+              a.controlOut.x,
+              a.controlOut.y,
+              { targetId: id, anchorIndex: a.anchorIndex, part: "controlOut" },
+              `controlOut:${a.anchorIndex}`
+            ));
           }
         }
       }
+      return out;
     }
-    return null;
+  };
+  return [anchors, controls];
+}
+
+// src/canvas/affordanceAt.ts
+var HANDLE_HIT_RADIUS = 8;
+var ANCHOR_HIT_RADIUS = 8;
+function buildAffordanceAt(opts) {
+  const {
+    getChromeState,
+    getView,
+    handleHitRadius = HANDLE_HIT_RADIUS,
+    anchorHitRadius = ANCHOR_HIT_RADIUS,
+    rotateBandPx = DEFAULT_ROTATION_HANDLE_DISTANCE,
+    getAnchorState,
+    getIsVisible
+  } = opts;
+  const affordances = [
+    createRotationAffordance({ bandPx: rotateBandPx, paint: null }),
+    createCornerResizeAffordance({ handleHitRadius }),
+    ...getAnchorState ? createPathAnchorAffordances(getAnchorState, { hitRadius: anchorHitRadius }) : []
+  ];
+  return function affordanceAt({ x: wx, y: wy }) {
+    const hit = hitAffordanceRegions(
+      affordances,
+      wx,
+      wy,
+      getChromeState(),
+      getView(),
+      getIsVisible?.()
+    );
+    return hit ? toAffordanceHit(hit) : null;
+  };
+}
+function toAffordanceHit(hit) {
+  const scratch = hit.binding.initialScratch ?? {};
+  return {
+    kind: hit.region.hitKind ?? `${hit.affordanceId}:${hit.regionId}`,
+    ...scratch.targetId !== void 0 ? { targetIds: [scratch.targetId] } : {},
+    ...scratch.anchor !== void 0 ? { anchor: scratch.anchor } : {},
+    ...scratch.fixedPoint !== void 0 ? { fixedPoint: scratch.fixedPoint } : {},
+    ...hit.region.cursor !== void 0 ? { cursor: hit.region.cursor } : {},
+    ...hit.binding.initialScratch !== void 0 ? { payload: hit.binding.initialScratch } : {}
   };
 }
 function buildClassifyTarget(getSelection, pickBest, kindOfNode) {
@@ -19881,7 +20628,10 @@ function mergeLayersWithDefaults(user) {
 }
 var BUNDLE_TOOLS = {
   minimal: ["select", "hand"],
-  standard: ["select", "rotate", "hand", "rect", "ellipse", "line", "pencil"],
+  // No `pencil`: freehand is a specialist instrument, not part of the
+  // everyday shape-drawing set. It stays in `exhaustive`, which means
+  // everything.
+  standard: ["select", "rotate", "hand", "rect", "ellipse", "line"],
   exhaustive: [
     "select",
     "rotate",
@@ -20094,6 +20844,8 @@ function SceneCanvasInner(props, ref) {
     scene,
     selection,
     geometry,
+    // The pick tolerance is declared in screen pixels; this is what converts it.
+    getView: () => currentViewRef.current,
     selectTool: selectToolWithDefaults,
     ...insertTool ? { insertTool } : {},
     ...layouts ? { layouts } : {}
@@ -20701,8 +21453,8 @@ function GestureDispatcherMounter({
   }, []);
   const affordanceAt = useMemo(() => {
     if (!selectionRef || !boundsOf2 || !viewRef) return void 0;
-    return buildAffordanceAt(
-      () => {
+    return buildAffordanceAt({
+      getChromeState: () => {
         const sel = selectionRef.current;
         const selection = sel?.current ?? [];
         const multiActive2 = selection.length >= 2;
@@ -20728,21 +21480,18 @@ function GestureDispatcherMounter({
           }
         };
       },
-      // Hit radius / rotate-band distance in WORLD units, derived from the
-      // screen-px visual size divided by current view scale. Without this
-      // the world-unit radius shrinks below the screen-px handle at zoom > 1
-      // and clicks on the handle slip past affordance hit-test → fall through
-      // to body classification → move binding fires instead of resize.
-      () => HANDLE_HIT_RADIUS / meanScale(viewRef.current?.scale ?? { x: 1, y: 1 }),
-      () => DEFAULT_ROTATION_HANDLE_DISTANCE / meanScale(viewRef.current?.scale ?? { x: 1, y: 1 }),
+      // Radii are declared in screen pixels and converted against this view.
+      // The caller used to do that division itself (`8 / meanScale(scale)`),
+      // in two places, with a comment explaining what breaks if you forget.
+      getView: () => viewRef.current ?? { x: 0, y: 0, scale: { x: 1, y: 1 } },
       getAnchorState,
       // Chrome-caps resolver: keep the affordance hit-test in sync with what
       // the renderer is actually painting. Without this, a click on a (no
       // longer visible) resize handle position still classifies as a resize
       // handle — e.g. an anchor drag in path-edit mode resizes the path's
       // bounding box instead of moving the anchor.
-      getIsVisibleForCanvas ? () => getIsVisibleForCanvas() : void 0
-    );
+      ...getIsVisibleForCanvas ? { getIsVisible: () => getIsVisibleForCanvas() } : {}
+    });
   }, [selectionRef, boundsOf2, viewRef, getAnchorState, getIsVisibleForCanvas]);
   const classifyTarget = useMemo(() => {
     if (!selectionRef || !pickEvery || !viewRef) return void 0;
@@ -21502,166 +22251,39 @@ function createChildrenLayer(opts) {
   };
 }
 
-// src/affordances/cornerResize.ts
-var DEFAULT_FILL3 = "#d4c4a8";
-var DEFAULT_STROKE = "#1a130d";
-function createCornerResizeAffordance(opts = {}) {
-  const {
-    handleHitRadius = 8,
-    handleSize = 8,
-    fill = DEFAULT_FILL3,
-    stroke = DEFAULT_STROKE
-  } = opts;
-  const paint = {
-    kind: "square",
-    sizePx: handleSize,
-    fill: { color: fill },
-    stroke: { paint: { color: stroke }, width: 1 }
-  };
-  return {
-    id: "selection.resize-handles",
-    regions(state) {
-      const target = pickRenderTarget(state);
-      if (!target) return [];
-      const b = target.bounds;
-      const corners = CORNER_ANCHORS.map((c) => {
-        const p = cornerPoint(b, c);
-        return { lx: p.x, ly: p.y, anchor: c.anchor, tag: c.tag };
-      });
-      return corners.map(({ lx, ly, anchor, tag }) => ({
-        id: `corner-${tag}`,
-        targetId: target.id,
-        shape: { kind: "point", x: lx, y: ly, hitRadiusPx: handleHitRadius },
-        paint,
-        bind: () => ({
-          initialScratch: { anchor, targetId: target.id }
-        })
-      }));
-    }
-  };
-}
-function pickRenderTarget(state) {
-  if (state.multiActive && state.unionBounds) {
-    return { id: MULTI_RESIZE_TARGET_ID, bounds: state.unionBounds };
-  }
-  if (state.selection.length === 1) {
-    const id = state.selection[0];
-    const b = state.boundsOf(id);
-    return b ? { id, bounds: b } : null;
-  }
-  return null;
-}
-
 // src/features/text/renderLabel.ts
 function renderLabel(ctx, text, x, y, options = {}) {
   const {
     align = "center",
     fontSize = 13,
     renderText,
-    width,
-    height,
-    padX = 4,
-    padY = 1,
-    cornerRadius = 3
-  } = options;
-  ctx.save();
-  ctx.font = `${fontSize}px sans-serif`;
-  ctx.textBaseline = "top";
-  const contentW = width ?? ctx.measureText(text).width;
-  const contentH = height ?? fontSize;
-  const w = contentW + padX * 2;
-  const h = contentH + padY * 2;
-  const rx = align === "center" ? x - w / 2 : x - padX;
-  ctx.fillStyle = "rgba(0, 0, 0, 0.75)";
-  ctx.beginPath();
-  ctx.roundRect(rx, y - padY, w, h, cornerRadius);
-  ctx.fill();
-  ctx.textAlign = align === "center" ? "center" : "left";
-  const tx = align === "center" ? x : x;
-  (renderText ?? defaultLabelTextRenderer)(ctx, text, tx, y);
-  ctx.restore();
-}
-var defaultLabelTextRenderer = (ctx, text, x, y) => {
-  ctx.fillStyle = "#FFFFFF";
-  ctx.fillText(text, x, y);
-};
-
-// src/features/text/runs.ts
-function toRuns(input) {
-  if (typeof input === "string") {
-    return input.length === 0 ? [] : [{ text: input }];
-  }
-  for (let i = 0; i < input.length; i++) {
-    const r = input[i];
-    if (typeof r?.text !== "string") {
-      throw new Error(`toRuns: run at index ${i} is missing string \`text\``);
-    }
-  }
-  return input;
-}
-function runsToPlainText(runs) {
-  let out = "";
-  for (const r of runs) out += r.text;
-  return out;
-}
-function escapeMarkdown(s) {
-  return s.replace(/\\/g, "\\\\").replace(/\*/g, "\\*");
-}
-function runsToMarkdown(runs) {
-  let out = "";
-  for (const r of runs) {
-    const escaped = escapeMarkdown(r.text);
-    if (r.bold && r.italic) out += `***${escaped}***`;
-    else if (r.bold) out += `**${escaped}**`;
-    else if (r.italic) out += `*${escaped}*`;
-    else out += escaped;
-  }
-  return out;
-}
-function markdownToRuns(input) {
-  const runs = [];
-  let bold = false;
-  let italic = false;
-  let buf = "";
-  let i = 0;
-  function flush() {
-    if (buf.length === 0) return;
-    const run = { text: buf };
-    if (bold) run.bold = true;
-    if (italic) run.italic = true;
-    runs.push(run);
-    buf = "";
-  }
-  while (i < input.length) {
-    const ch = input[i];
-    if (ch === "\\" && i + 1 < input.length && "*\\".includes(input[i + 1])) {
-      buf += input[i + 1];
-      i += 2;
-      continue;
-    }
-    if (ch === "*") {
-      let count = 0;
-      while (i + count < input.length && input[i + count] === "*") count++;
-      flush();
-      if (count >= 3) {
-        bold = !bold;
-        italic = !italic;
-        i += 3;
-      } else if (count === 2) {
-        bold = !bold;
-        i += 2;
-      } else {
-        italic = !italic;
-        i += 1;
-      }
-      continue;
-    }
-    buf += ch;
-    i++;
-  }
-  flush();
-  return runs;
+    width,
+    height,
+    padX = 4,
+    padY = 1,
+    cornerRadius = 3
+  } = options;
+  ctx.save();
+  ctx.font = `${fontSize}px sans-serif`;
+  ctx.textBaseline = "top";
+  const contentW = width ?? ctx.measureText(text).width;
+  const contentH = height ?? fontSize;
+  const w = contentW + padX * 2;
+  const h = contentH + padY * 2;
+  const rx = align === "center" ? x - w / 2 : x - padX;
+  ctx.fillStyle = "rgba(0, 0, 0, 0.75)";
+  ctx.beginPath();
+  ctx.roundRect(rx, y - padY, w, h, cornerRadius);
+  ctx.fill();
+  ctx.textAlign = align === "center" ? "center" : "left";
+  const tx = align === "center" ? x : x;
+  (renderText ?? defaultLabelTextRenderer)(ctx, text, tx, y);
+  ctx.restore();
 }
+var defaultLabelTextRenderer = (ctx, text, x, y) => {
+  ctx.fillStyle = "#FFFFFF";
+  ctx.fillText(text, x, y);
+};
 
 // src/features/text/markdownText.ts
 function layoutMarkdown(runs, maxWidth, fontSize, measure3, lineHeightFactor = 1.3) {
@@ -22801,502 +23423,240 @@ function nestedHitTester(adapter, opts) {
       if (wx >= b.x && wx <= b.x + b.width && wy >= b.y && wy <= b.y + b.height) {
         return o.id;
       }
-    }
-    return null;
-  };
-  const pickOutermost = (wx, wy) => {
-    const leaf = hitLeaf(wx, wy);
-    return leaf === null ? null : ancestorChain(leaf)[0];
-  };
-  const pickBest = (wx, wy, alt, selection) => {
-    const leaf = hitLeaf(wx, wy);
-    if (leaf === null) return null;
-    const chain = ancestorChain(leaf);
-    if (!alt) return chain[0];
-    for (let i = chain.length - 1; i >= 0; i--) {
-      if (selection.includes(chain[i])) {
-        return chain[Math.min(i + 1, chain.length - 1)];
-      }
-    }
-    return chain[chain.length - 1];
-  };
-  return { pickOutermost, pickBest };
-}
-
-// src/features/paths/pathDistance.ts
-var BEZIER_SAMPLES = 16;
-function pointSegDist2(px, py, ax, ay, bx, by) {
-  const dx = bx - ax, dy = by - ay;
-  const len2 = dx * dx + dy * dy;
-  if (len2 === 0) {
-    const ex2 = px - ax, ey2 = py - ay;
-    return ex2 * ex2 + ey2 * ey2;
-  }
-  let t = ((px - ax) * dx + (py - ay) * dy) / len2;
-  if (t < 0) t = 0;
-  else if (t > 1) t = 1;
-  const cx = ax + dx * t, cy = ay + dy * t;
-  const ex = px - cx, ey = py - cy;
-  return ex * ex + ey * ey;
-}
-function pointCubicDist2(px, py, x0, y0, x1, y1, x2, y2, x3, y3) {
-  let prevX = x0, prevY = y0;
-  let best = Infinity;
-  for (let i = 1; i <= BEZIER_SAMPLES; i++) {
-    const t = i / BEZIER_SAMPLES;
-    const u = 1 - t;
-    const sx = u * u * u * x0 + 3 * u * u * t * x1 + 3 * u * t * t * x2 + t * t * t * x3;
-    const sy = u * u * u * y0 + 3 * u * u * t * y1 + 3 * u * t * t * y2 + t * t * t * y3;
-    const d2 = pointSegDist2(px, py, prevX, prevY, sx, sy);
-    if (d2 < best) best = d2;
-    prevX = sx;
-    prevY = sy;
-  }
-  return best;
-}
-function pointToRectPerimeterDist(px, py, rx, ry, rw, rh) {
-  const dx = Math.max(rx - px, px - (rx + rw), 0);
-  const dy = Math.max(ry - py, py - (ry + rh), 0);
-  if (dx > 0 || dy > 0) return Math.hypot(dx, dy);
-  const left = px - rx, right = rx + rw - px;
-  const top = py - ry, bottom = ry + rh - py;
-  return Math.min(left, right, top, bottom);
-}
-function pathDistanceToPoint(path, px, py) {
-  if (path.kind === "rect") {
-    return pointToRectPerimeterDist(px, py, path.x, path.y, path.width, path.height);
-  }
-  return polygonPathDistance(path, px, py);
-}
-function polygonPathDistance(path, px, py) {
-  const { commands, coords } = path;
-  let ci = 0;
-  let startX = 0, startY = 0;
-  let curX = 0, curY = 0;
-  let best = Infinity;
-  for (let i = 0; i < commands.length; i++) {
-    const cmd = commands[i];
-    if (cmd === PATH_M) {
-      startX = coords[ci];
-      startY = coords[ci + 1];
-      curX = startX;
-      curY = startY;
-      ci += 2;
-    } else if (cmd === PATH_L) {
-      const x = coords[ci], y = coords[ci + 1];
-      const d2 = pointSegDist2(px, py, curX, curY, x, y);
-      if (d2 < best) best = d2;
-      curX = x;
-      curY = y;
-      ci += 2;
-    } else if (cmd === PATH_C) {
-      const c1x = coords[ci], c1y = coords[ci + 1];
-      const c2x = coords[ci + 2], c2y = coords[ci + 3];
-      const x = coords[ci + 4], y = coords[ci + 5];
-      const d2 = pointCubicDist2(px, py, curX, curY, c1x, c1y, c2x, c2y, x, y);
-      if (d2 < best) best = d2;
-      curX = x;
-      curY = y;
-      ci += 6;
-    } else if (cmd === PATH_Q) {
-      const qx = coords[ci], qy = coords[ci + 1];
-      const x = coords[ci + 2], y = coords[ci + 3];
-      const c1x = curX + 2 / 3 * (qx - curX);
-      const c1y = curY + 2 / 3 * (qy - curY);
-      const c2x = x + 2 / 3 * (qx - x);
-      const c2y = y + 2 / 3 * (qy - y);
-      const d2 = pointCubicDist2(px, py, curX, curY, c1x, c1y, c2x, c2y, x, y);
-      if (d2 < best) best = d2;
-      curX = x;
-      curY = y;
-      ci += 4;
-    } else if (cmd === PATH_Z) {
-      const d2 = pointSegDist2(px, py, curX, curY, startX, startY);
-      if (d2 < best) best = d2;
-      curX = startX;
-      curY = startY;
-    }
-  }
-  return best === Infinity ? Infinity : Math.sqrt(best);
-}
-
-// src/features/paths/pathLayer.ts
-var PLACEHOLDER_FILL = { color: "#ffffff" };
-var PLACEHOLDER_STROKE = { paint: { color: "#ffffff" }, width: 1 };
-function resolveOverride(base, override, tMs) {
-  if (!override) return base;
-  if (typeof override === "function") {
-    if (!base) return base;
-    const result = override(base, tMs);
-    if (result.length !== base.length) return base;
-    return result;
-  }
-  return override;
-}
-function createPathLayer(opts) {
-  const {
-    id = "paths",
-    label = "Paths",
-    getNodes,
-    getPath,
-    getFill,
-    getStroke,
-    isHidden,
-    getVertexColors,
-    getStrokeVertexColors,
-    getStrokeVertexWidths,
-    colorOverrides,
-    now = () => typeof performance !== "undefined" ? performance.now() : Date.now()
-  } = opts;
-  const warned = /* @__PURE__ */ new Set();
-  const isDev3 = typeof import.meta !== "undefined" && import.meta.env && import.meta.env.DEV;
-  return {
-    id,
-    label,
-    draw: () => {
-      const children = [];
-      const nodes = getNodes();
-      for (let idx = 0; idx < nodes.length; idx++) {
-        const node = nodes[idx];
-        if (isHidden?.(node)) continue;
-        const path = getPath(node);
-        const fillFromHook = getFill?.(node);
-        const strokeFromHook = getStroke?.(node);
-        const baseVColors = getVertexColors?.(node);
-        const baseStrokeVColors = getStrokeVertexColors?.(node);
-        const strokeVWidths = getStrokeVertexWidths?.(node);
-        const nodeId = node.id ?? String(idx);
-        const tMs = colorOverrides ? now() : 0;
-        const fillOverride = colorOverrides?.get(nodeId, "fill");
-        const strokeOverride = colorOverrides?.get(nodeId, "stroke");
-        const vColors = resolveOverride(baseVColors, fillOverride, tMs);
-        const strokeVColors = resolveOverride(baseStrokeVColors, strokeOverride, tMs);
-        const nodeKey = nodeId;
-        const anchorCount2 = countPathAnchors(path);
-        const expectedLen = 4 * anchorCount2;
-        let useVColors = null;
-        if (vColors != null) {
-          if (vColors.length === expectedLen) {
-            useVColors = vColors;
-          } else if (isDev3) {
-            const key = `${id}:${nodeKey}:fill`;
-            if (!warned.has(key)) {
-              warned.add(key);
-              console.warn(
-                `[createPathLayer ${id}] node ${nodeKey}: fill vertexColors length ${vColors.length}, expected ${expectedLen}; dropping`
-              );
-            }
-          }
-        }
-        let useStrokeVColors = null;
-        if (strokeVColors != null) {
-          if (strokeVColors.length === expectedLen) {
-            useStrokeVColors = strokeVColors;
-          } else if (isDev3) {
-            const key = `${id}:${nodeKey}:stroke`;
-            if (!warned.has(key)) {
-              warned.add(key);
-              console.warn(
-                `[createPathLayer ${id}] node ${nodeKey}: stroke vertexColors length ${strokeVColors.length}, expected ${expectedLen}; dropping`
-              );
-            }
-          }
-        }
-        const fill = fillFromHook != null ? fillFromHook : useVColors != null ? PLACEHOLDER_FILL : void 0;
-        let useStrokeVWidths = null;
-        if (strokeVWidths != null) {
-          if (strokeVWidths.length === anchorCount2) {
-            useStrokeVWidths = strokeVWidths;
-          } else if (isDev3) {
-            const key = `${id}:${nodeKey}:strokeWidths`;
-            if (!warned.has(key)) {
-              warned.add(key);
-              console.warn(
-                `[createPathLayer ${id}] node ${nodeKey}: stroke vertexWidths length ${strokeVWidths.length}, expected ${anchorCount2}; dropping`
-              );
-            }
-          }
-        }
-        const baseStroke = strokeFromHook != null ? strokeFromHook : useStrokeVColors != null || useStrokeVWidths != null ? PLACEHOLDER_STROKE : void 0;
-        const stroke = baseStroke != null ? {
-          ...baseStroke,
-          ...useStrokeVColors != null ? { vertexColors: useStrokeVColors } : {},
-          ...useStrokeVWidths != null ? { vertexWidths: useStrokeVWidths } : {}
-        } : baseStroke;
-        if (fill == null && stroke == null) continue;
-        children.push({
-          kind: "path",
-          path,
-          ...fill != null ? { fill } : {},
-          ...stroke != null ? { stroke } : {},
-          ...useVColors != null ? { vertexColors: useVColors } : {}
-        });
+    }
+    return null;
+  };
+  const pickOutermost = (wx, wy) => {
+    const leaf = hitLeaf(wx, wy);
+    return leaf === null ? null : ancestorChain(leaf)[0];
+  };
+  const pickBest = (wx, wy, alt, selection) => {
+    const leaf = hitLeaf(wx, wy);
+    if (leaf === null) return null;
+    const chain = ancestorChain(leaf);
+    if (!alt) return chain[0];
+    for (let i = chain.length - 1; i >= 0; i--) {
+      if (selection.includes(chain[i])) {
+        return chain[Math.min(i + 1, chain.length - 1)];
       }
-      return children;
     }
+    return chain[chain.length - 1];
   };
+  return { pickOutermost, pickBest };
 }
 
-// src/features/paths/pathFromD.ts
-var NUM_RE = /[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g;
-function tokenize(d) {
-  const out = [];
-  let i = 0;
-  while (i < d.length) {
-    const ch = d[i];
-    if (/[A-Za-z]/.test(ch)) {
-      let j = i + 1;
-      while (j < d.length && !/[A-Za-z]/.test(d[j])) j++;
-      const argSlice = d.slice(i + 1, j);
-      out.push({ cmd: ch, args: readNumbers(argSlice) });
-      i = j;
-    } else {
-      i++;
-    }
+// src/features/paths/pathDistance.ts
+var BEZIER_SAMPLES = 16;
+function pointSegDist2(px, py, ax, ay, bx, by) {
+  const dx = bx - ax, dy = by - ay;
+  const len2 = dx * dx + dy * dy;
+  if (len2 === 0) {
+    const ex2 = px - ax, ey2 = py - ay;
+    return ex2 * ex2 + ey2 * ey2;
   }
-  return out;
+  let t = ((px - ax) * dx + (py - ay) * dy) / len2;
+  if (t < 0) t = 0;
+  else if (t > 1) t = 1;
+  const cx = ax + dx * t, cy = ay + dy * t;
+  const ex = px - cx, ey = py - cy;
+  return ex * ex + ey * ey;
 }
-function readNumbers(s) {
-  const out = [];
-  let m;
-  NUM_RE.lastIndex = 0;
-  while ((m = NUM_RE.exec(s)) !== null) {
-    const n = Number(m[0]);
-    if (Number.isFinite(n)) out.push(n);
+function pointCubicDist2(px, py, x0, y0, x1, y1, x2, y2, x3, y3) {
+  let prevX = x0, prevY = y0;
+  let best = Infinity;
+  for (let i = 1; i <= BEZIER_SAMPLES; i++) {
+    const t = i / BEZIER_SAMPLES;
+    const u = 1 - t;
+    const sx = u * u * u * x0 + 3 * u * u * t * x1 + 3 * u * t * t * x2 + t * t * t * x3;
+    const sy = u * u * u * y0 + 3 * u * u * t * y1 + 3 * u * t * t * y2 + t * t * t * y3;
+    const d2 = pointSegDist2(px, py, prevX, prevY, sx, sy);
+    if (d2 < best) best = d2;
+    prevX = sx;
+    prevY = sy;
   }
-  return out;
+  return best;
 }
-var ARG_COUNTS = {
-  M: 2,
-  L: 2,
-  H: 1,
-  V: 1,
-  C: 6,
-  S: 4,
-  Q: 4,
-  T: 2,
-  A: 7,
-  Z: 0
-};
-function pathFromD(d, onWarn) {
-  const tokens = tokenize(d);
-  const b = new PathBuilder();
-  const st = {
-    x: 0,
-    y: 0,
-    startX: 0,
-    startY: 0,
-    lastCubicCtrl: null,
-    lastQuadCtrl: null
-  };
-  for (const { cmd, args } of tokens) {
-    const upper = cmd.toUpperCase();
-    const relative = cmd !== upper;
-    const argCount = ARG_COUNTS[upper];
-    if (argCount === void 0) {
-      onWarn?.(`unknown path command: ${cmd}`);
-      continue;
-    }
-    if (upper === "Z") {
-      b.close();
-      st.x = st.startX;
-      st.y = st.startY;
-      st.lastCubicCtrl = null;
-      st.lastQuadCtrl = null;
-      continue;
-    }
-    const groups = argCount === 0 ? 1 : Math.floor(args.length / argCount);
-    for (let g = 0; g < groups; g++) {
-      const a = args.slice(g * argCount, (g + 1) * argCount);
-      const effectiveUpper = upper === "M" && g > 0 ? "L" : upper;
-      runCommand(effectiveUpper, relative, a, st, b);
-    }
+function pointToRectPerimeterDist(px, py, rx, ry, rw, rh) {
+  const dx = Math.max(rx - px, px - (rx + rw), 0);
+  const dy = Math.max(ry - py, py - (ry + rh), 0);
+  if (dx > 0 || dy > 0) return Math.hypot(dx, dy);
+  const left = px - rx, right = rx + rw - px;
+  const top = py - ry, bottom = ry + rh - py;
+  return Math.min(left, right, top, bottom);
+}
+function pathDistanceToPoint(path, px, py) {
+  if (path.kind === "rect") {
+    return pointToRectPerimeterDist(px, py, path.x, path.y, path.width, path.height);
   }
-  return b.build();
+  return polygonPathDistance(path, px, py);
 }
-function runCommand(upper, relative, a, st, b) {
-  const rx = relative ? st.x : 0;
-  const ry = relative ? st.y : 0;
-  switch (upper) {
-    case "M": {
-      const x = a[0] + rx;
-      const y = a[1] + ry;
-      b.moveTo(x, y);
-      st.x = x;
-      st.y = y;
-      st.startX = x;
-      st.startY = y;
-      st.lastCubicCtrl = null;
-      st.lastQuadCtrl = null;
-      return;
-    }
-    case "L": {
-      const x = a[0] + rx;
-      const y = a[1] + ry;
-      b.lineTo(x, y);
-      st.x = x;
-      st.y = y;
-      st.lastCubicCtrl = null;
-      st.lastQuadCtrl = null;
-      return;
-    }
-    case "H": {
-      const x = a[0] + (relative ? st.x : 0);
-      b.lineTo(x, st.y);
-      st.x = x;
-      st.lastCubicCtrl = null;
-      st.lastQuadCtrl = null;
-      return;
-    }
-    case "V": {
-      const y = a[0] + (relative ? st.y : 0);
-      b.lineTo(st.x, y);
-      st.y = y;
-      st.lastCubicCtrl = null;
-      st.lastQuadCtrl = null;
-      return;
-    }
-    case "C": {
-      const x1 = a[0] + rx, y1 = a[1] + ry;
-      const x2 = a[2] + rx, y2 = a[3] + ry;
-      const x = a[4] + rx, y = a[5] + ry;
-      b.curveTo(x1, y1, x2, y2, x, y);
-      st.x = x;
-      st.y = y;
-      st.lastCubicCtrl = { x: x2, y: y2 };
-      st.lastQuadCtrl = null;
-      return;
-    }
-    case "S": {
-      const ref = st.lastCubicCtrl ?? { x: st.x, y: st.y };
-      const x1 = 2 * st.x - ref.x;
-      const y1 = 2 * st.y - ref.y;
-      const x2 = a[0] + rx, y2 = a[1] + ry;
-      const x = a[2] + rx, y = a[3] + ry;
-      b.curveTo(x1, y1, x2, y2, x, y);
-      st.x = x;
-      st.y = y;
-      st.lastCubicCtrl = { x: x2, y: y2 };
-      st.lastQuadCtrl = null;
-      return;
-    }
-    case "Q": {
-      const x1 = a[0] + rx, y1 = a[1] + ry;
-      const x = a[2] + rx, y = a[3] + ry;
-      b.quadTo(x1, y1, x, y);
-      st.x = x;
-      st.y = y;
-      st.lastQuadCtrl = { x: x1, y: y1 };
-      st.lastCubicCtrl = null;
-      return;
-    }
-    case "T": {
-      const ref = st.lastQuadCtrl ?? { x: st.x, y: st.y };
-      const x1 = 2 * st.x - ref.x;
-      const y1 = 2 * st.y - ref.y;
-      const x = a[0] + rx, y = a[1] + ry;
-      b.quadTo(x1, y1, x, y);
-      st.x = x;
-      st.y = y;
-      st.lastQuadCtrl = { x: x1, y: y1 };
-      st.lastCubicCtrl = null;
-      return;
-    }
-    case "A": {
-      const rxA = Math.abs(a[0]);
-      const ryA = Math.abs(a[1]);
-      const xRot = a[2];
-      const largeArc = a[3] !== 0;
-      const sweep = a[4] !== 0;
-      const ex = a[5] + rx;
-      const ey = a[6] + ry;
-      arcToCubics(st.x, st.y, ex, ey, rxA, ryA, xRot, largeArc, sweep, b);
-      st.x = ex;
-      st.y = ey;
-      st.lastCubicCtrl = null;
-      st.lastQuadCtrl = null;
-      return;
+function polygonPathDistance(path, px, py) {
+  const { commands, coords } = path;
+  let ci = 0;
+  let startX = 0, startY = 0;
+  let curX = 0, curY = 0;
+  let best = Infinity;
+  for (let i = 0; i < commands.length; i++) {
+    const cmd = commands[i];
+    if (cmd === PATH_M) {
+      startX = coords[ci];
+      startY = coords[ci + 1];
+      curX = startX;
+      curY = startY;
+      ci += 2;
+    } else if (cmd === PATH_L) {
+      const x = coords[ci], y = coords[ci + 1];
+      const d2 = pointSegDist2(px, py, curX, curY, x, y);
+      if (d2 < best) best = d2;
+      curX = x;
+      curY = y;
+      ci += 2;
+    } else if (cmd === PATH_C) {
+      const c1x = coords[ci], c1y = coords[ci + 1];
+      const c2x = coords[ci + 2], c2y = coords[ci + 3];
+      const x = coords[ci + 4], y = coords[ci + 5];
+      const d2 = pointCubicDist2(px, py, curX, curY, c1x, c1y, c2x, c2y, x, y);
+      if (d2 < best) best = d2;
+      curX = x;
+      curY = y;
+      ci += 6;
+    } else if (cmd === PATH_Q) {
+      const qx = coords[ci], qy = coords[ci + 1];
+      const x = coords[ci + 2], y = coords[ci + 3];
+      const c1x = curX + 2 / 3 * (qx - curX);
+      const c1y = curY + 2 / 3 * (qy - curY);
+      const c2x = x + 2 / 3 * (qx - x);
+      const c2y = y + 2 / 3 * (qy - y);
+      const d2 = pointCubicDist2(px, py, curX, curY, c1x, c1y, c2x, c2y, x, y);
+      if (d2 < best) best = d2;
+      curX = x;
+      curY = y;
+      ci += 4;
+    } else if (cmd === PATH_Z) {
+      const d2 = pointSegDist2(px, py, curX, curY, startX, startY);
+      if (d2 < best) best = d2;
+      curX = startX;
+      curY = startY;
     }
-    default:
-      return;
   }
+  return best === Infinity ? Infinity : Math.sqrt(best);
 }
-function arcToCubics(x1, y1, x2, y2, rx, ry, xAxisRotationDeg, largeArc, sweep, b) {
-  if (x1 === x2 && y1 === y2) return;
-  if (rx === 0 || ry === 0) {
-    b.lineTo(x2, y2);
-    return;
-  }
-  const phi = xAxisRotationDeg * Math.PI / 180;
-  const cosPhi = Math.cos(phi);
-  const sinPhi = Math.sin(phi);
-  const dx = (x1 - x2) / 2;
-  const dy = (y1 - y2) / 2;
-  const x1p = cosPhi * dx + sinPhi * dy;
-  const y1p = -sinPhi * dx + cosPhi * dy;
-  let rxs = rx * rx;
-  let rys = ry * ry;
-  const x1ps = x1p * x1p;
-  const y1ps = y1p * y1p;
-  const lambda = x1ps / rxs + y1ps / rys;
-  let rxFixed = rx;
-  let ryFixed = ry;
-  if (lambda > 1) {
-    const sqrtLambda = Math.sqrt(lambda);
-    rxFixed = sqrtLambda * rx;
-    ryFixed = sqrtLambda * ry;
-    rxs = rxFixed * rxFixed;
-    rys = ryFixed * ryFixed;
+
+// src/features/paths/pathLayer.ts
+var PLACEHOLDER_FILL = { color: "#ffffff" };
+var PLACEHOLDER_STROKE = { paint: { color: "#ffffff" }, width: 1 };
+function resolveOverride(base, override, tMs) {
+  if (!override) return base;
+  if (typeof override === "function") {
+    if (!base) return base;
+    const result = override(base, tMs);
+    if (result.length !== base.length) return base;
+    return result;
   }
-  const sign = largeArc === sweep ? -1 : 1;
-  const num = rxs * rys - rxs * y1ps - rys * x1ps;
-  const den = rxs * y1ps + rys * x1ps;
-  const factor = sign * Math.sqrt(Math.max(0, num / den));
-  const cxp = factor * (rxFixed * y1p) / ryFixed;
-  const cyp = factor * -(ryFixed * x1p) / rxFixed;
-  const cx = cosPhi * cxp - sinPhi * cyp + (x1 + x2) / 2;
-  const cy = sinPhi * cxp + cosPhi * cyp + (y1 + y2) / 2;
-  const angle = (ux, uy, vx, vy) => {
-    const dot = ux * vx + uy * vy;
-    const len = Math.sqrt((ux * ux + uy * uy) * (vx * vx + vy * vy));
-    let a = Math.acos(Math.max(-1, Math.min(1, dot / len)));
-    if (ux * vy - uy * vx < 0) a = -a;
-    return a;
+  return override;
+}
+function createPathLayer(opts) {
+  const {
+    id = "paths",
+    label = "Paths",
+    getNodes,
+    getPath,
+    getFill,
+    getStroke,
+    isHidden,
+    getVertexColors,
+    getStrokeVertexColors,
+    getStrokeVertexWidths,
+    colorOverrides,
+    now = () => typeof performance !== "undefined" ? performance.now() : Date.now()
+  } = opts;
+  const warned = /* @__PURE__ */ new Set();
+  const isDev3 = typeof import.meta !== "undefined" && import.meta.env && import.meta.env.DEV;
+  return {
+    id,
+    label,
+    draw: () => {
+      const children = [];
+      const nodes = getNodes();
+      for (let idx = 0; idx < nodes.length; idx++) {
+        const node = nodes[idx];
+        if (isHidden?.(node)) continue;
+        const path = getPath(node);
+        const fillFromHook = getFill?.(node);
+        const strokeFromHook = getStroke?.(node);
+        const baseVColors = getVertexColors?.(node);
+        const baseStrokeVColors = getStrokeVertexColors?.(node);
+        const strokeVWidths = getStrokeVertexWidths?.(node);
+        const nodeId = node.id ?? String(idx);
+        const tMs = colorOverrides ? now() : 0;
+        const fillOverride = colorOverrides?.get(nodeId, "fill");
+        const strokeOverride = colorOverrides?.get(nodeId, "stroke");
+        const vColors = resolveOverride(baseVColors, fillOverride, tMs);
+        const strokeVColors = resolveOverride(baseStrokeVColors, strokeOverride, tMs);
+        const nodeKey = nodeId;
+        const anchorCount2 = countPathAnchors(path);
+        const expectedLen = 4 * anchorCount2;
+        let useVColors = null;
+        if (vColors != null) {
+          if (vColors.length === expectedLen) {
+            useVColors = vColors;
+          } else if (isDev3) {
+            const key = `${id}:${nodeKey}:fill`;
+            if (!warned.has(key)) {
+              warned.add(key);
+              console.warn(
+                `[createPathLayer ${id}] node ${nodeKey}: fill vertexColors length ${vColors.length}, expected ${expectedLen}; dropping`
+              );
+            }
+          }
+        }
+        let useStrokeVColors = null;
+        if (strokeVColors != null) {
+          if (strokeVColors.length === expectedLen) {
+            useStrokeVColors = strokeVColors;
+          } else if (isDev3) {
+            const key = `${id}:${nodeKey}:stroke`;
+            if (!warned.has(key)) {
+              warned.add(key);
+              console.warn(
+                `[createPathLayer ${id}] node ${nodeKey}: stroke vertexColors length ${strokeVColors.length}, expected ${expectedLen}; dropping`
+              );
+            }
+          }
+        }
+        const fill = fillFromHook != null ? fillFromHook : useVColors != null ? PLACEHOLDER_FILL : void 0;
+        let useStrokeVWidths = null;
+        if (strokeVWidths != null) {
+          if (strokeVWidths.length === anchorCount2) {
+            useStrokeVWidths = strokeVWidths;
+          } else if (isDev3) {
+            const key = `${id}:${nodeKey}:strokeWidths`;
+            if (!warned.has(key)) {
+              warned.add(key);
+              console.warn(
+                `[createPathLayer ${id}] node ${nodeKey}: stroke vertexWidths length ${strokeVWidths.length}, expected ${anchorCount2}; dropping`
+              );
+            }
+          }
+        }
+        const baseStroke = strokeFromHook != null ? strokeFromHook : useStrokeVColors != null || useStrokeVWidths != null ? PLACEHOLDER_STROKE : void 0;
+        const stroke = baseStroke != null ? {
+          ...baseStroke,
+          ...useStrokeVColors != null ? { vertexColors: useStrokeVColors } : {},
+          ...useStrokeVWidths != null ? { vertexWidths: useStrokeVWidths } : {}
+        } : baseStroke;
+        if (fill == null && stroke == null) continue;
+        children.push({
+          kind: "path",
+          path,
+          ...fill != null ? { fill } : {},
+          ...stroke != null ? { stroke } : {},
+          ...useVColors != null ? { vertexColors: useVColors } : {}
+        });
+      }
+      return children;
+    }
   };
-  const theta1 = angle(1, 0, (x1p - cxp) / rxFixed, (y1p - cyp) / ryFixed);
-  let dTheta = angle(
-    (x1p - cxp) / rxFixed,
-    (y1p - cyp) / ryFixed,
-    (-x1p - cxp) / rxFixed,
-    (-y1p - cyp) / ryFixed
-  );
-  if (!sweep && dTheta > 0) dTheta -= 2 * Math.PI;
-  else if (sweep && dTheta < 0) dTheta += 2 * Math.PI;
-  const segCount = Math.max(1, Math.ceil(Math.abs(dTheta) / (Math.PI / 2)));
-  const segAngle = dTheta / segCount;
-  const t = 4 / 3 * Math.tan(segAngle / 4);
-  let prevX = x1;
-  let prevY = y1;
-  let prevDx = -Math.sin(theta1) * rxFixed;
-  let prevDy = Math.cos(theta1) * ryFixed;
-  for (let i = 1; i <= segCount; i++) {
-    const theta = theta1 + i * segAngle;
-    const cosT = Math.cos(theta);
-    const sinT = Math.sin(theta);
-    const px = cosPhi * (cosT * rxFixed) - sinPhi * (sinT * ryFixed) + cx;
-    const py = sinPhi * (cosT * rxFixed) + cosPhi * (sinT * ryFixed) + cy;
-    const dxNew = -sinT * rxFixed;
-    const dyNew = cosT * ryFixed;
-    const c1x = prevX + cosPhi * (t * prevDx) - sinPhi * (t * prevDy);
-    const c1y = prevY + sinPhi * (t * prevDx) + cosPhi * (t * prevDy);
-    const c2x = px - cosPhi * (t * dxNew) + sinPhi * (t * dyNew);
-    const c2y = py - sinPhi * (t * dxNew) - cosPhi * (t * dyNew);
-    b.curveTo(c1x, c1y, c2x, c2y, px, py);
-    prevX = px;
-    prevY = py;
-    prevDx = dxNew;
-    prevDy = dyNew;
-  }
 }
 
 // src/features/paths/compose.ts
@@ -24763,6 +25123,50 @@ function useDragRadial(options = {}) {
     }
   }), [start, move, gesture.end, gesture.cancel]);
 }
+
+// src/interactions/actions/edit-anchors/handles.ts
+function hitAnchor(path, worldX, worldY, threshold) {
+  const anchors = enumerateAnchors(path);
+  let bestControl = null;
+  let bestAnchor = null;
+  const t2 = threshold * threshold;
+  for (const a of anchors) {
+    if (a.controlIn) {
+      const dx2 = a.controlIn.x - worldX;
+      const dy2 = a.controlIn.y - worldY;
+      const d22 = dx2 * dx2 + dy2 * dy2;
+      if (d22 <= t2 && (!bestControl || d22 < bestControl.d2)) {
+        bestControl = {
+          d2: d22,
+          hit: { anchorIndex: a.anchorIndex, kind: "controlIn", coordIndex: a.controlIn.coordIndex }
+        };
+      }
+    }
+    if (a.controlOut) {
+      const dx2 = a.controlOut.x - worldX;
+      const dy2 = a.controlOut.y - worldY;
+      const d22 = dx2 * dx2 + dy2 * dy2;
+      if (d22 <= t2 && (!bestControl || d22 < bestControl.d2)) {
+        bestControl = {
+          d2: d22,
+          hit: { anchorIndex: a.anchorIndex, kind: "controlOut", coordIndex: a.controlOut.coordIndex }
+        };
+      }
+    }
+    const dx = a.x - worldX;
+    const dy = a.y - worldY;
+    const d2 = dx * dx + dy * dy;
+    if (d2 <= t2 && (!bestAnchor || d2 < bestAnchor.d2)) {
+      bestAnchor = {
+        d2,
+        hit: { anchorIndex: a.anchorIndex, kind: "anchor", coordIndex: a.coordIndex }
+      };
+    }
+  }
+  if (bestControl) return bestControl.hit;
+  if (bestAnchor) return bestAnchor.hit;
+  return null;
+}
 function useDistribute(adapter, options = {}) {
   const adapterRef = useRef(adapter);
   adapterRef.current = adapter;
@@ -26197,7 +26601,7 @@ function hslToRgbUnit(h, s, l) {
 }
 
 // src/layout/snaps.ts
-function dist23(a, b) {
+function dist22(a, b) {
   const dx = a.x - b.x;
   const dy = a.y - b.y;
   return dx * dx + dy * dy;
@@ -26205,9 +26609,9 @@ function dist23(a, b) {
 function nearestOf(targets, pointer) {
   if (targets.length === 0) return null;
   let best = targets[0];
-  let bestD = dist23(best.origin, pointer);
+  let bestD = dist22(best.origin, pointer);
   for (let i = 1; i < targets.length; i++) {
-    const d = dist23(targets[i].origin, pointer);
+    const d = dist22(targets[i].origin, pointer);
     if (d < bestD) {
       bestD = d;
       best = targets[i];
@@ -26227,7 +26631,7 @@ function nearestWithin(opts) {
     pickTarget(targets, pointer) {
       const got = nearestOf(targets, pointer);
       if (got === null) return null;
-      return dist23(got.origin, pointer) <= tol2 ? got : null;
+      return dist22(got.origin, pointer) <= tol2 ? got : null;
     }
   };
 }
@@ -26466,6 +26870,6 @@ 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, PenIcon, PencilIcon, PickHud, PointerProviderIfRoot, PolygonIcon, RECT_ALIGN_PROJECTION, RectIcon, SPRING_PRESETS, SceneCanvas, SceneViewCanvas, SelectIcon, SelectionContextProvider, SelectionContextProviderIfRoot, ShaderCompileError, StarIcon, SubtractIcon, TextIcon, UnionIcon, UnknownIcon, WeaselProvider, WeaselRenderer, aabbCenter, actionIs, alignDeltaFor, alignInsertBehavior, alignMoveBehavior, alignResizeBehavior, alignedStrokeRect, always, and, animateLifecycle, animateOnSetPose, 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, 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, findShapeSilhouette, fitTextPose, fitToBounds, fitViewToBounds, fitZoom, focused, fontString, forEachCoalesced, freeform, gateLayer, gesturing, getAlpha01, getImageBitmap, getNodeShapes, getStylusData, hexToRgba, 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, sliceAction, snapPoint, solidVertexColors, specificity, spiro, splitPathByLine, splitSubpaths, springPose, springVertexColors, srgbU8ToOklab, staggerVertexColors, startThresholdDrag, styleAtRange, subscribeImageReady, tessellate, tessellateStroke, textCommand, 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-7F3SDUJ4.js.map
-//# sourceMappingURL=chunk-7F3SDUJ4.js.map
+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-2J6V527H.js.map
+//# sourceMappingURL=chunk-2J6V527H.js.map