@weasel-js/core 1.0.2 → 1.0.4

package/dist/{chunk-PI56ORHE.js → chunk-AYGSXNY3.js}

@@ -1,16 +1,16 @@
-import { ActionDisabledReason, useOptionalDepRegistry, DepRegistryProvider, useActionsRegistry, ActionsProvider, useDepRegistry, reportRouteConflicts, buildDepsFromRequires, useDepSource, actionBindings } from './chunk-W2WB4352.js';
-import { scratchKey, createTransformOp, snap, getScratch, createReparentOp, setScratch } from './chunk-UB6A6L77.js';
-import { fixedCornerOf, DEFAULT_RESIZE_BEHAVIORS, CORNER_ANCHORS, cornerPoint } from './chunk-Z3KNFTTS.js';
-import { AUTO_POSE_DESCRIPTOR, RECT_POSE_DESCRIPTOR, resolveUnit, pathPoseDescriptor, polygonFromPoints, starPath, regularPolygonPath, linePath, ellipsePath, rectPath, strokeHitTest, withinPxRadius, boundsOfPath, PATH_M, PATH_L, PATH_Z, PATH_Q, PATH_C, DEFAULT_FLATTEN_TOLERANCE, flattenQuadratic, flattenCubic, PathBuilder, pointInPath, transformPath, translatePath, pxExtent, remapRotatedLeaf, withinPxBox, flattenCubicWithArcLen, flattenQuadraticWithArcLen, PATH_CMD_LENGTHS, pointToGridCell } from './chunk-6SHZHXXR.js';
-import { dispatchApplyBatch, dlog, dwarn, usePointerContext, PointerContextProvider, applyOpsTo, extractWeaselClipboardFromSvg, parseWeaselClipboardText, materializePaste, WEASEL_CLIPBOARD_MIME, WEASEL_CLIPBOARD_MIME_WEB, sniffWeaselClipboardText } from './chunk-775XXAHR.js';
+import { ActionDisabledReason, useOptionalDepRegistry, DepRegistryProvider, useActionsRegistry, ActionsProvider, useDepRegistry, reportRouteConflicts, buildDepsFromRequires, useDepSource, actionBindings } from './chunk-J3YC3GVF.js';
+import { scratchKey, createTransformOp, snap, getScratch, createReparentOp, setScratch } from './chunk-CSMF654J.js';
+import { fixedCornerOf, DEFAULT_RESIZE_BEHAVIORS, CORNER_ANCHORS, cornerPoint } from './chunk-J7LUY47N.js';
+import { AUTO_POSE_DESCRIPTOR, RECT_POSE_DESCRIPTOR, resolveUnit, pathPoseDescriptor, polygonFromPoints, starPath, regularPolygonPath, linePath, ellipsePath, rectPath, strokeHitTest, withinPxRadius, boundsOfPath, PATH_M, PATH_L, PATH_Z, PATH_Q, PATH_C, DEFAULT_FLATTEN_TOLERANCE, flattenQuadratic, flattenCubic, PathBuilder, pointInPath, transformPath, translatePath, pxExtent, remapRotatedLeaf, withinPxBox, flattenCubicWithArcLen, flattenQuadraticWithArcLen, PATH_CMD_LENGTHS, pointToGridCell } from './chunk-4Z6J4IVH.js';
+import { dispatchApplyBatch, dlog, dwarn, usePointerContext, PointerContextProvider, applyOpsTo, extractWeaselClipboardFromSvg, parseWeaselClipboardText, materializePaste, WEASEL_CLIPBOARD_MIME, WEASEL_CLIPBOARD_MIME_WEB, sniffWeaselClipboardText } from './chunk-JOSUVS6C.js';
 import { createSetSelectionOp } from './chunk-BHVYVFGV.js';
 import { registerOpFactory, createDeleteOp, createInsertOp, rebuildOp } from './chunk-GVCNT7UH.js';
-import { getTexture, chunks, dots, crosshatch, hatch } from './chunk-IO5Z75X4.js';
+import { getTexture, chunks, dots, crosshatch, hatch } from './chunk-HGF5X6MZ.js';
 import { createContext, createElement, forwardRef, useMemo, useRef, useState, useCallback, useImperativeHandle, useEffect, useSyncExternalStore, useContext, useReducer, useLayoutEffect } from 'react';
 import { subscribeGlyphReady, DEFAULT_BAKE_BUDGET, TEXT_VERT_SRC, TEXT_FRAG_SRC, TEXT_SDF_UNIFORMS, TEXT_SDF_ATTRIBUTES, TEXT_FRAG_R8_SRC, markAllFontsNotUploaded, resetBakeBudget, glyphGeneration, syncDynamicPageTexture, ensureFontTexture, dynamicPageTextureId, textureCacheKey, resolveFontVariant, resolveGlyphFallback, glyphOutline } from '@weasel-js/font';
 export { canQueryLocalFonts, canQueryLocalFonts as canQueryLocalFonts2, enableLocalFontOutlines, enableLocalFontOutlines as enableLocalFontOutlines2, hasFontOutlines, hasFontOutlines as hasFontOutlines2, isCanvasFont, isCanvasFont as isCanvasFont2, listFontOutlines, listFontOutlines as listFontOutlines2, outlineStatus, outlineStatus as outlineStatus2, registerCanvasFont, registerCanvasFont as registerCanvasFont2, registerFont, registerFont as registerFont2, registerFontOutlines, registerFontOutlines as registerFontOutlines2, subscribeGlyphReady, subscribeGlyphReady as subscribeGlyphReady2, unregisterCanvasFont, unregisterCanvasFont as unregisterCanvasFont2, unregisterFontOutlines, unregisterFontOutlines as unregisterFontOutlines2 } from '@weasel-js/font';
 import earcut from 'earcut';
-import { applyToPoint, rotateAboutPoint, boxToBox, pointInPolygon, segmentsCross } from '@weasel-js/geom';
+import { applyToPoint, rotateAboutPoint, boxToBox, pointInPolygon, segmentsCross, pointSegmentDist2 } from '@weasel-js/geom';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 import polygonClipping from 'polygon-clipping';
 import { matchSpec, RESERVED_ID_PREFIXES, RESERVED_ID_NAMES, parseTargetSpec, mimeMatchesGlob } from '@weasel-js/gestures';
@@ -19,7 +19,7 @@ import { createHistory } from '@weasel-js/history';
 export * from '@weasel-js/history';
 
 // src/version.ts
-var VERSION = "1.0.2" ;
+var VERSION = "1.0.4" ;
 
 // src/features/grid/roundToCell.ts
 function roundToCell(value, cellSize) {
@@ -524,13 +524,20 @@ var GLTextureCache = class {
   }
   gl;
   map = /* @__PURE__ */ new Map();
+  wraps = /* @__PURE__ */ new Map();
   has(id) {
     return this.map.has(id);
   }
-  /** Uploads once per id; `wrap` therefore applies on first upload only.
-   *  An id is either a pattern tile or a shader texture, never both. */
+  /** Uploads the pixels once per id. `wrap` is re-applied whenever it differs
+   *  from what the id was last uploaded under: the same registered image can
+   *  be a clamped shader texture in one draw and a repeating pattern tile in
+   *  the next, and first-upload-wins gave the second one the first one's mode. */
   upload(id, source, wrap = "clamp") {
-    if (this.map.has(id)) return id;
+    const cached = this.map.get(id);
+    if (cached) {
+      if (this.wraps.get(id) !== wrap) this.applyWrap(id, cached, wrap);
+      return id;
+    }
     const gl = this.gl;
     const tex = gl.createTexture();
     if (!tex) throw new Error(`GLTextureCache: createTexture failed for id="${id}"`);
@@ -543,8 +550,18 @@ var GLTextureCache = class {
     gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, wrapMode);
     gl.bindTexture(gl.TEXTURE_2D, null);
     this.map.set(id, tex);
+    this.wraps.set(id, wrap);
     return id;
   }
+  applyWrap(id, tex, wrap) {
+    const gl = this.gl;
+    const mode = wrap === "repeat" ? gl.REPEAT : gl.CLAMP_TO_EDGE;
+    gl.bindTexture(gl.TEXTURE_2D, tex);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, mode);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, mode);
+    gl.bindTexture(gl.TEXTURE_2D, null);
+    this.wraps.set(id, wrap);
+  }
   /** Create a single-channel R8 texture from raw bytes (full upload).
    *  No-op if `id` already exists. Same LINEAR/CLAMP params as `upload`;
    *  UNPACK_ALIGNMENT dropped to 1 for non-4-aligned row widths. */
@@ -563,6 +580,7 @@ var GLTextureCache = class {
     gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
     gl.bindTexture(gl.TEXTURE_2D, null);
     this.map.set(id, tex);
+    this.wraps.set(id, "clamp");
   }
   /** Patch a rect of an existing R8 texture with tightly-packed w×h bytes. */
   subImageR8(id, x, y, w, h, data) {
@@ -594,6 +612,7 @@ var GLTextureCache = class {
       gl.deleteTexture(tex);
     }
     this.map.clear();
+    this.wraps.clear();
   }
 };
 
@@ -1282,6 +1301,13 @@ var GroupState = class {
     this.alphaStack.push(nextAlpha);
     this.colorMatrixStack.push(nextCM);
   }
+  /** Drop every pushed frame, leaving the root. A frame that throws part-way
+   *  down the tree never pops, and the next frame would draw under leftovers. */
+  reset() {
+    this.transformStack.length = 1;
+    this.alphaStack.length = 1;
+    this.colorMatrixStack.length = 1;
+  }
   pop() {
     if (this.transformStack.length <= 1) {
       throw new Error("GroupState.pop: cannot pop root frame");
@@ -1935,16 +1961,28 @@ function verticalAlignOffset(align, boxHeight, textHeight) {
 
 // src/features/paths/pathFromD.ts
 var NUM_RE = /[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/g;
+var NUM_RE_AT = /[+-]?(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?/y;
+function isCommandLetter(d, j) {
+  const c = d[j];
+  if (!/[A-Za-z]/.test(c)) return false;
+  if (c !== "e" && c !== "E") return true;
+  if (!/[\d.]/.test(d[j - 1] ?? "")) return true;
+  const k = d[j + 1] === "+" || d[j + 1] === "-" ? j + 2 : j + 1;
+  return !/\d/.test(d[k] ?? "");
+}
 function tokenize(d) {
   const out = [];
   let i = 0;
   while (i < d.length) {
-    const ch = d[i];
-    if (/[A-Za-z]/.test(ch)) {
+    if (isCommandLetter(d, i)) {
       let j = i + 1;
-      while (j < d.length && !/[A-Za-z]/.test(d[j])) j++;
+      while (j < d.length && !isCommandLetter(d, j)) j++;
       const argSlice = d.slice(i + 1, j);
-      out.push({ cmd: ch, args: readNumbers(argSlice) });
+      const cmd = d[i];
+      out.push({
+        cmd,
+        args: cmd === "A" || cmd === "a" ? readArcArgs(argSlice) : readNumbers(argSlice)
+      });
       i = j;
     } else {
       i++;
@@ -1962,6 +2000,30 @@ function readNumbers(s) {
   }
   return out;
 }
+function readArcArgs(s) {
+  const out = [];
+  let i = 0;
+  while (i < s.length) {
+    const c = s[i];
+    if (c === "," || c === " " || c === "	" || c === "\n" || c === "\r") {
+      i++;
+      continue;
+    }
+    const slot = out.length % 7;
+    if (slot === 3 || slot === 4) {
+      if (c !== "0" && c !== "1") return out;
+      out.push(c === "1" ? 1 : 0);
+      i++;
+      continue;
+    }
+    NUM_RE_AT.lastIndex = i;
+    const m = NUM_RE_AT.exec(s);
+    if (!m) return out;
+    out.push(Number(m[0]));
+    i = NUM_RE_AT.lastIndex;
+  }
+  return out;
+}
 var ARG_COUNTS = {
   M: 2,
   L: 2,
@@ -2879,42 +2941,42 @@ var MAX_VERTICES_PER_BATCH = 32768;
 var FLOATS_PER_VERTEX = 6;
 var INITIAL_VERTICES = 256;
 var INITIAL_INDICES = 384;
+var SOLID_RING_SIZE = 64;
+var SOLID_RING_SLOT_VERTICES = 1024;
+var SOLID_RING_SLOT_INDICES = 3072;
+var SOLID_LARGE_RING_SIZE = 4;
+function doubledTo(from, need) {
+  let capacity = from;
+  while (capacity < need) capacity *= 2;
+  return capacity;
+}
 var SolidBatch = class {
   gl;
-  vao;
-  vbo;
-  ibo;
+  aPos;
+  aColor;
+  /** Cycled per flush, and created on first use so a renderer that flushes
+   *  rarely allocates as few slots as it flushes. */
+  ring = new Array(SOLID_RING_SIZE).fill(void 0);
+  next = 0;
+  /** The same, for flushes past a slot's capacity; these sets grow to fit. */
+  largeRing = new Array(SOLID_LARGE_RING_SIZE).fill(void 0);
+  nextLarge = 0;
   verts = new Float32Array(INITIAL_VERTICES * FLOATS_PER_VERTEX);
   idx = new Uint32Array(INITIAL_INDICES);
   nVerts = 0;
   nIdx = 0;
-  /** What the GPU buffers are currently sized for. */
-  vboVerts = 0;
-  iboIdx = 0;
+  /** Whether the staged run is rects alone, so its indices are the canonical
+   *  quad pattern and a slot already holding that pattern needs no upload. */
+  pureRects = true;
   constructor(gl, prog) {
     const aPos = prog.attribute("a_position");
     const aColor = prog.attribute("a_vertexColor");
     if (aPos === void 0 || aColor === void 0) {
       throw new Error("SolidBatch: vertex-color program is missing a_position / a_vertexColor");
     }
-    const vao = gl.createVertexArray();
-    const vbo = gl.createBuffer();
-    const ibo = gl.createBuffer();
-    if (!vao || !vbo || !ibo) throw new Error("SolidBatch: failed to create GL objects");
     this.gl = gl;
-    this.vao = vao;
-    this.vbo = vbo;
-    this.ibo = ibo;
-    const stride = FLOATS_PER_VERTEX * 4;
-    gl.bindVertexArray(vao);
-    gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
-    gl.enableVertexAttribArray(aPos);
-    gl.vertexAttribPointer(aPos, 2, gl.FLOAT, false, stride, 0);
-    gl.enableVertexAttribArray(aColor);
-    gl.vertexAttribPointer(aColor, 4, gl.FLOAT, false, stride, 8);
-    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ibo);
-    gl.bindVertexArray(null);
-    this.growGpu(INITIAL_VERTICES, INITIAL_INDICES);
+    this.aPos = aPos;
+    this.aColor = aColor;
   }
   get length() {
     return this.nIdx;
@@ -2984,6 +3046,7 @@ var SolidBatch = class {
     const srcIdx = mesh.indices;
     const n = src.length >> 1;
     this.reserve(n, srcIdx.length);
+    this.pureRects = false;
     const v = this.verts;
     let i = this.nVerts * FLOATS_PER_VERTEX;
     const ma = m[0], mb = m[1], mc = m[3], md = m[4], mtx = m[6], mty = m[7];
@@ -3004,67 +3067,109 @@ var SolidBatch = class {
     this.nVerts += n;
     this.nIdx += srcIdx.length;
   }
-  /** Upload the staged geometry and bind the batch VAO. Returns the index
-   *  count for the caller's `drawElements`. */
+  /** Upload the staged geometry into the next set of buffers and bind its VAO.
+   *  Returns the index count for the caller's `drawElements`. */
   uploadAndBind() {
     const gl = this.gl;
-    if (this.nVerts > this.vboVerts || this.nIdx > this.iboIdx) {
-      this.growGpu(this.nVerts, this.nIdx);
-    }
-    gl.bindVertexArray(this.vao);
-    gl.bindBuffer(gl.ARRAY_BUFFER, this.vbo);
+    const set = this.nVerts <= SOLID_RING_SLOT_VERTICES && this.nIdx <= SOLID_RING_SLOT_INDICES ? this.nextRingSlot() : this.nextLargeSlot();
+    gl.bindVertexArray(set.vao);
+    gl.bindBuffer(gl.ARRAY_BUFFER, set.vbo);
     gl.bufferSubData(gl.ARRAY_BUFFER, 0, this.verts, 0, this.nVerts * FLOATS_PER_VERTEX);
-    gl.bufferSubData(gl.ELEMENT_ARRAY_BUFFER, 0, this.idx, 0, this.nIdx);
+    const rects = this.pureRects ? this.nVerts >> 2 : -1;
+    if (rects < 0 || rects !== set.indexRects) {
+      gl.bufferSubData(gl.ELEMENT_ARRAY_BUFFER, 0, this.idx, 0, this.nIdx);
+      set.indexRects = rects;
+    }
     return this.nIdx;
   }
   reset() {
     this.nVerts = 0;
     this.nIdx = 0;
+    this.pureRects = true;
   }
   dispose() {
-    const gl = this.gl;
-    gl.deleteBuffer(this.vbo);
-    gl.deleteBuffer(this.ibo);
-    gl.deleteVertexArray(this.vao);
+    for (const set of [...this.ring, ...this.largeRing]) {
+      if (set) this.deleteSet(set);
+    }
+    this.ring.fill(void 0);
+    this.largeRing.fill(void 0);
   }
   /** Grow the CPU arrays so `vertices` / `indices` more fit. */
   reserve(vertices, indices) {
     const needVerts = (this.nVerts + vertices) * FLOATS_PER_VERTEX;
     if (needVerts > this.verts.length) {
-      let len = this.verts.length;
-      while (len < needVerts) len *= 2;
-      const grown = new Float32Array(len);
+      const grown = new Float32Array(doubledTo(this.verts.length, needVerts));
       grown.set(this.verts);
       this.verts = grown;
     }
     const needIdx = this.nIdx + indices;
     if (needIdx > this.idx.length) {
-      let len = this.idx.length;
-      while (len < needIdx) len *= 2;
-      const grown = new Uint32Array(len);
+      const grown = new Uint32Array(doubledTo(this.idx.length, needIdx));
       grown.set(this.idx);
       this.idx = grown;
     }
   }
-  /** Size both GPU buffers for at least what is staged, doubling to amortize. */
-  growGpu(vertices, indices) {
+  nextRingSlot() {
+    const slot = this.next;
+    this.next = (slot + 1) % SOLID_RING_SIZE;
+    const existing = this.ring[slot];
+    if (existing) return existing;
+    const set = this.createSet(SOLID_RING_SLOT_VERTICES, SOLID_RING_SLOT_INDICES);
+    this.ring[slot] = set;
+    return set;
+  }
+  nextLargeSlot() {
     const gl = this.gl;
-    if (vertices > this.vboVerts) {
-      let capacity = Math.max(this.vboVerts, INITIAL_VERTICES);
-      while (capacity < vertices) capacity *= 2;
-      gl.bindBuffer(gl.ARRAY_BUFFER, this.vbo);
-      gl.bufferData(gl.ARRAY_BUFFER, capacity * FLOATS_PER_VERTEX * 4, gl.DYNAMIC_DRAW);
-      this.vboVerts = capacity;
-    }
-    if (indices > this.iboIdx) {
-      let capacity = Math.max(this.iboIdx, INITIAL_INDICES);
-      while (capacity < indices) capacity *= 2;
-      gl.bindVertexArray(this.vao);
-      gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.ibo);
-      gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, capacity * 4, gl.DYNAMIC_DRAW);
+    const slot = this.nextLarge;
+    this.nextLarge = (slot + 1) % SOLID_LARGE_RING_SIZE;
+    let set = this.largeRing[slot];
+    if (!set) {
+      set = this.createSet(
+        doubledTo(SOLID_RING_SLOT_VERTICES, this.nVerts),
+        doubledTo(SOLID_RING_SLOT_INDICES, this.nIdx)
+      );
+      this.largeRing[slot] = set;
+      return set;
+    }
+    if (this.nVerts > set.vertexCapacity) {
+      set.vertexCapacity = doubledTo(set.vertexCapacity, this.nVerts);
+      gl.bindBuffer(gl.ARRAY_BUFFER, set.vbo);
+      gl.bufferData(gl.ARRAY_BUFFER, set.vertexCapacity * FLOATS_PER_VERTEX * 4, gl.DYNAMIC_DRAW);
+    }
+    if (this.nIdx > set.indexCapacity) {
+      set.indexCapacity = doubledTo(set.indexCapacity, this.nIdx);
+      gl.bindVertexArray(set.vao);
+      gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, set.ibo);
+      gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, set.indexCapacity * 4, gl.DYNAMIC_DRAW);
       gl.bindVertexArray(null);
-      this.iboIdx = capacity;
+      set.indexRects = -1;
     }
+    return set;
+  }
+  createSet(vertices, indices) {
+    const gl = this.gl;
+    const vao = gl.createVertexArray();
+    const vbo = gl.createBuffer();
+    const ibo = gl.createBuffer();
+    if (!vao || !vbo || !ibo) throw new Error("SolidBatch: failed to create GL objects");
+    const stride = FLOATS_PER_VERTEX * 4;
+    gl.bindVertexArray(vao);
+    gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
+    gl.bufferData(gl.ARRAY_BUFFER, vertices * stride, gl.DYNAMIC_DRAW);
+    gl.enableVertexAttribArray(this.aPos);
+    gl.vertexAttribPointer(this.aPos, 2, gl.FLOAT, false, stride, 0);
+    gl.enableVertexAttribArray(this.aColor);
+    gl.vertexAttribPointer(this.aColor, 4, gl.FLOAT, false, stride, 8);
+    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ibo);
+    gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, indices * 4, gl.DYNAMIC_DRAW);
+    gl.bindVertexArray(null);
+    return { vao, vbo, ibo, vertexCapacity: vertices, indexCapacity: indices, indexRects: -1 };
+  }
+  deleteSet(set) {
+    const gl = this.gl;
+    gl.deleteBuffer(set.vbo);
+    gl.deleteBuffer(set.ibo);
+    gl.deleteVertexArray(set.vao);
   }
 };
 
@@ -3089,6 +3194,25 @@ function sameValues(prev, next) {
   for (let i = 0; i < prev.length; i++) if (prev[i] !== next[i]) return false;
   return true;
 }
+function setColorUniform(ctx, prog, r, g, b, a) {
+  const loc = prog.uniform("u_color");
+  if (loc === void 0) return;
+  const uploaded = uploadedFor(ctx, prog);
+  const prev = uploaded.color;
+  if (prev !== void 0 && prev[0] === r && prev[1] === g && prev[2] === b && prev[3] === a) {
+    return;
+  }
+  ctx.gl.uniform4f(loc, r, g, b, a);
+  uploaded.color = [r, g, b, a];
+}
+function setAlphaUniform(ctx, prog, alpha) {
+  const loc = prog.uniform("u_alpha");
+  if (loc === void 0) return;
+  const uploaded = uploadedFor(ctx, prog);
+  if (uploaded.alpha === alpha) return;
+  ctx.gl.uniform1f(loc, alpha);
+  uploaded.alpha = alpha;
+}
 var BATCH_MODEL = mat3.identity();
 function projFor(ctx) {
   let proj = FRAME_PROJ.get(ctx);
@@ -3381,8 +3505,8 @@ function flushSolids(ctx) {
   gl.useProgram(prog.handle);
   const indexCount = batch.uploadAndBind();
   setProjAndModel(ctx, prog, BATCH_MODEL);
-  gl.uniform4f(prog.uniform("u_color"), 1, 1, 1, 1);
-  gl.uniform1f(prog.uniform("u_alpha"), staged.alpha);
+  setColorUniform(ctx, prog, 1, 1, 1, 1);
+  setAlphaUniform(ctx, prog, staged.alpha);
   setColorMatrixUniforms(ctx, prog, staged.colorMatrix);
   applyClipTest(ctx, staged.clipDepth);
   gl.drawElements(gl.TRIANGLES, indexCount, gl.UNSIGNED_INT, 0);
@@ -3447,10 +3571,9 @@ function setProjAndModel(ctx, prog, model = ctx.state.transform) {
   }
 }
 function setSolidPaintUniforms(ctx, prog, color, opacity) {
-  const gl = ctx.gl;
   const [r, g, b, a] = resolveColor(color);
-  gl.uniform4f(prog.uniform("u_color"), r, g, b, a * (opacity ?? 1));
-  gl.uniform1f(prog.uniform("u_alpha"), ctx.state.alpha);
+  setColorUniform(ctx, prog, r, g, b, a * (opacity ?? 1));
+  setAlphaUniform(ctx, prog, ctx.state.alpha);
 }
 function drawPathFillByKind(ctx, fill, handle) {
   const kind = fill.fill ?? "solid";
@@ -3496,7 +3619,7 @@ function drawPathFillPattern(ctx, fill, handle) {
   ctx.textureCache.bind(tex.id, 0);
   gl.uniform1i(ctx.patternFill.uniform("u_sampler"), 0);
   gl.uniform1f(ctx.patternFill.uniform("u_opacity"), fill.opacity ?? 1);
-  gl.uniform1f(ctx.patternFill.uniform("u_alpha"), ctx.state.alpha);
+  setAlphaUniform(ctx, ctx.patternFill, ctx.state.alpha);
   applyClipTest(ctx);
   gl.drawElements(gl.TRIANGLES, handle.indexCount, gl.UNSIGNED_INT, 0);
   gl.bindVertexArray(null);
@@ -3520,7 +3643,7 @@ function drawPathFillGradient(ctx, fill, handle) {
   gl.uniformMatrix3fv(ctx.gradFill.uniform("u_worldInv"), false, gradientSpaceInverse(ctx, fill.units));
   ctx.gradRampCache.bind(key, 0);
   gl.uniform1i(ctx.gradFill.uniform("u_ramp"), 0);
-  gl.uniform1f(ctx.gradFill.uniform("u_alpha"), ctx.state.alpha);
+  setAlphaUniform(ctx, ctx.gradFill, ctx.state.alpha);
   gl.uniform1f(ctx.gradFill.uniform("u_opacity"), fill.opacity ?? 1);
   if (fill.fill === "linear-gradient") {
     gl.uniform1i(ctx.gradFill.uniform("u_gradKind"), 0);
@@ -3670,6 +3793,7 @@ function drawPathStrokeUnclipped(ctx, cmd) {
       gl.enableVertexAttribArray(aVColorLoc);
       gl.vertexAttribPointer(aVColorLoc, 4, gl.FLOAT, false, 0, 0);
     }
+    applyClipTest(ctx);
     gl.drawElements(gl.TRIANGLES, handle.indexCount, gl.UNSIGNED_INT, 0);
     gl.bindVertexArray(null);
     gl.deleteBuffer(colorVbo);
@@ -3785,7 +3909,7 @@ function drawText(ctx, cmd) {
       preparedPrograms.add(prog);
       setProjAndModel(ctx, prog);
       setColorMatrixUniforms(ctx, prog);
-      gl.uniform1f(prog.uniform("u_alpha"), ctx.state.alpha);
+      setAlphaUniform(ctx, prog, ctx.state.alpha);
     }
     drawTextGroup(ctx, group, prog, dx, dy);
   }
@@ -3903,8 +4027,8 @@ function drawTextDecorations(ctx, decorations, dx, dy) {
     if (!ibo) throw new Error("drawTextDecorations: createBuffer (IBO) returned null");
     gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ibo);
     gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, indices, gl.DYNAMIC_DRAW);
-    gl.uniform4f(prog.uniform("u_color"), rgba[0], rgba[1], rgba[2], rgba[3]);
-    gl.uniform1f(prog.uniform("u_alpha"), ctx.state.alpha);
+    setColorUniform(ctx, prog, rgba[0], rgba[1], rgba[2], rgba[3]);
+    setAlphaUniform(ctx, prog, ctx.state.alpha);
     gl.drawElements(gl.TRIANGLES, indices.length, gl.UNSIGNED_INT, 0);
     gl.bindVertexArray(null);
     gl.deleteVertexArray(vao);
@@ -3988,7 +4112,7 @@ function drawTextGroup(ctx, group, prog, dx, dy) {
   if ("color" in group.fill) {
     [r, g, b, a] = resolveColor(group.fill.color);
   }
-  gl.uniform4f(prog.uniform("u_color"), r, g, b, a);
+  setColorUniform(ctx, prog, r, g, b, a);
   const synthBoldAmount = group.synthetic.bold ? 0.08 : 0;
   const uSynthBold = prog.uniform("u_synthBold");
   if (uSynthBold !== void 0) gl.uniform1f(uSynthBold, synthBoldAmount);
@@ -4004,70 +4128,98 @@ function drawTextGroup(ctx, group, prog, dx, dy) {
   gl.deleteBuffer(vbo);
   gl.deleteBuffer(ibo);
 }
+var IMAGE_QUAD_RING_SIZE = 64;
+var IMAGE_QUAD_RINGS = /* @__PURE__ */ new WeakMap();
+var IMAGE_QUAD_INDICES = new Uint32Array([0, 1, 2, 1, 3, 2]);
+var IMAGE_QUAD_STRIDE = 16;
+function imageQuadRing(gl, prog) {
+  const existing = IMAGE_QUAD_RINGS.get(prog);
+  if (existing) return existing;
+  const aPosLoc = prog.attribute("a_position");
+  const aUvLoc = prog.attribute("a_uv");
+  const ibo = gl.createBuffer();
+  if (!ibo) throw new Error("drawImage: createBuffer (IBO) returned null");
+  const vaos = [];
+  const vbos = [];
+  for (let slot = 0; slot < IMAGE_QUAD_RING_SIZE; slot++) {
+    const vao = gl.createVertexArray();
+    const vbo = gl.createBuffer();
+    if (!vao) throw new Error("drawImage: createVertexArray returned null");
+    if (!vbo) throw new Error("drawImage: createBuffer returned null");
+    gl.bindVertexArray(vao);
+    gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
+    gl.bufferData(gl.ARRAY_BUFFER, 4 * IMAGE_QUAD_STRIDE, gl.DYNAMIC_DRAW);
+    if (aPosLoc !== void 0) {
+      gl.enableVertexAttribArray(aPosLoc);
+      gl.vertexAttribPointer(aPosLoc, 2, gl.FLOAT, false, IMAGE_QUAD_STRIDE, 0);
+    }
+    if (aUvLoc !== void 0) {
+      gl.enableVertexAttribArray(aUvLoc);
+      gl.vertexAttribPointer(aUvLoc, 2, gl.FLOAT, false, IMAGE_QUAD_STRIDE, 8);
+    }
+    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ibo);
+    if (slot === 0) gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, IMAGE_QUAD_INDICES, gl.STATIC_DRAW);
+    gl.bindVertexArray(null);
+    vaos.push(vao);
+    vbos.push(vbo);
+  }
+  const ring = { vaos, vbos, ibo, next: 0 };
+  IMAGE_QUAD_RINGS.set(prog, ring);
+  return ring;
+}
+function disposeImageQuads(gl, prog) {
+  const ring = IMAGE_QUAD_RINGS.get(prog);
+  if (!ring) return;
+  for (const vao of ring.vaos) gl.deleteVertexArray(vao);
+  for (const vbo of ring.vbos) gl.deleteBuffer(vbo);
+  gl.deleteBuffer(ring.ibo);
+  IMAGE_QUAD_RINGS.delete(prog);
+}
+var IMAGE_QUAD_VERTICES = new Float32Array(16);
 function drawImage(ctx, cmd) {
   ctx.imageCache.upload(cmd.image, cmd.image);
   const gl = ctx.gl;
-  gl.useProgram(ctx.imageFill.handle);
+  const prog = ctx.imageFill;
+  gl.useProgram(prog.handle);
   const x0 = cmd.x, y0 = cmd.y;
   const x1 = cmd.x + cmd.w, y1 = cmd.y + cmd.h;
-  const vertices = new Float32Array([
-    x0,
-    y0,
-    0,
-    0,
-    x1,
-    y0,
-    1,
-    0,
-    x0,
-    y1,
-    0,
-    1,
-    x1,
-    y1,
-    1,
-    1
-  ]);
-  const indices = new Uint32Array([0, 1, 2, 1, 3, 2]);
-  const vao = gl.createVertexArray();
-  if (!vao) throw new Error("drawImage: createVertexArray returned null");
-  gl.bindVertexArray(vao);
-  const vbo = gl.createBuffer();
-  if (!vbo) throw new Error("drawImage: createBuffer returned null");
-  gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
-  gl.bufferData(gl.ARRAY_BUFFER, vertices, gl.DYNAMIC_DRAW);
-  const stride = 16;
-  const aPosLoc = ctx.imageFill.attribute("a_position");
-  const aUvLoc = ctx.imageFill.attribute("a_uv");
-  if (aPosLoc !== void 0) {
-    gl.enableVertexAttribArray(aPosLoc);
-    gl.vertexAttribPointer(aPosLoc, 2, gl.FLOAT, false, stride, 0);
-  }
-  if (aUvLoc !== void 0) {
-    gl.enableVertexAttribArray(aUvLoc);
-    gl.vertexAttribPointer(aUvLoc, 2, gl.FLOAT, false, stride, 8);
-  }
-  const ibo = gl.createBuffer();
-  if (!ibo) throw new Error("drawImage: createBuffer (IBO) returned null");
-  gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ibo);
-  gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, indices, gl.DYNAMIC_DRAW);
-  setProjAndModel(ctx, ctx.imageFill);
-  setColorMatrixUniforms(ctx, ctx.imageFill);
+  const v = IMAGE_QUAD_VERTICES;
+  v[0] = x0;
+  v[1] = y0;
+  v[2] = 0;
+  v[3] = 0;
+  v[4] = x1;
+  v[5] = y0;
+  v[6] = 1;
+  v[7] = 0;
+  v[8] = x0;
+  v[9] = y1;
+  v[10] = 0;
+  v[11] = 1;
+  v[12] = x1;
+  v[13] = y1;
+  v[14] = 1;
+  v[15] = 1;
+  const ring = imageQuadRing(gl, prog);
+  const slot = ring.next;
+  ring.next = (slot + 1) % IMAGE_QUAD_RING_SIZE;
+  gl.bindVertexArray(ring.vaos[slot]);
+  gl.bindBuffer(gl.ARRAY_BUFFER, ring.vbos[slot]);
+  gl.bufferSubData(gl.ARRAY_BUFFER, 0, v);
+  setProjAndModel(ctx, prog);
+  setColorMatrixUniforms(ctx, prog);
   ctx.imageCache.bind(cmd.image, 0);
   gl.texParameteri(
     gl.TEXTURE_2D,
     gl.TEXTURE_MAG_FILTER,
     cmd.sampling === "nearest" ? gl.NEAREST : gl.LINEAR
   );
-  gl.uniform1i(ctx.imageFill.uniform("u_sampler"), 0);
-  gl.uniform1f(ctx.imageFill.uniform("u_opacity"), cmd.opacity ?? 1);
-  gl.uniform1f(ctx.imageFill.uniform("u_alpha"), ctx.state.alpha);
+  gl.uniform1i(prog.uniform("u_sampler"), 0);
+  gl.uniform1f(prog.uniform("u_opacity"), cmd.opacity ?? 1);
+  setAlphaUniform(ctx, prog, ctx.state.alpha);
   applyClipTest(ctx);
   gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_INT, 0);
   gl.bindVertexArray(null);
-  gl.deleteVertexArray(vao);
-  gl.deleteBuffer(vbo);
-  gl.deleteBuffer(ibo);
 }
 
 // src/renderer/shaders/customPrelude.ts
@@ -4293,6 +4445,8 @@ var WeaselRenderer = class {
     const program = new ShaderProgram(this.gl, vertSrc, fragSrc);
     program.lookupUniforms([...CUSTOM_KIT_UNIFORMS, ...extractUniformNames(fragSrc)]);
     program.lookupAttributes(CUSTOM_ATTRIBUTES);
+    const previous = this.programRegistry.get(handle.id);
+    if (previous) this.gl.deleteProgram(previous.handle);
     this.programRegistry.set(handle.id, program);
   }
   applyViewport() {
@@ -4391,7 +4545,7 @@ var WeaselRenderer = class {
     }
     this.meshCache.freeTransient();
     this.meshCache.drainPendingDeletes();
-    for (const prog of [this.pathFill, this.pathFillVColor, this.textSdf, this.textSdfR8, this.imageFill, this.gradFill]) {
+    for (const prog of [this.pathFill, this.pathFillVColor, this.textSdf, this.textSdfR8, this.imageFill, this.gradFill, this.patternFill]) {
       gl.deleteProgram(prog.handle);
     }
     for (const prog of this.programRegistry.values()) {
@@ -4402,6 +4556,7 @@ var WeaselRenderer = class {
     this.gradRampCache.free();
     if (this.quadVbo) gl.deleteBuffer(this.quadVbo);
     if (this.quadIbo) gl.deleteBuffer(this.quadIbo);
+    disposeImageQuads(gl, this.imageFill);
     this.solidBatch.dispose();
   }
   /**
@@ -4417,6 +4572,7 @@ var WeaselRenderer = class {
     const gl = this.gl;
     this.meshCache.drainPendingDeletes();
     resetBakeBudget(this.bakeBudget);
+    this.groupState.reset();
     gl.stencilMask(255);
     gl.clear(gl.COLOR_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);
     const ctx = {
@@ -5173,9 +5329,15 @@ function beginPointerDrag(payload, source, startX, startY, ghostFn) {
   function onUp(e) {
     if (!activeDrag) return;
     const zone = findZone(e.clientX, e.clientY, payload.kind);
+    const dropped = activeDrag.payload;
     activeDrag.lastZone?.onOver?.(false);
-    if (zone) zone.onDrop(activeDrag.payload, e.clientX, e.clientY);
-    cleanup();
+    try {
+      if (zone) zone.onDrop(dropped, e.clientX, e.clientY);
+    } catch (err) {
+      console.error("weasel pointerDrag: drop zone onDrop threw", err);
+    } finally {
+      cleanup();
+    }
   }
   function onCancel() {
     activeDrag?.lastZone?.onOver?.(false);
@@ -5196,6 +5358,10 @@ var DRAG_THRESHOLD_PX_SQ = 25;
 function useDragHandle(getPayload, options) {
   const optsRef = useRef(options);
   optsRef.current = options;
+  const pendingTeardownRef = useRef(null);
+  useEffect(() => () => {
+    pendingTeardownRef.current?.();
+  }, []);
   const onPointerDown = useCallback((e) => {
     if (e.pointerType === "mouse" && e.button !== 0) return;
     const target = e.currentTarget;
@@ -5231,10 +5397,12 @@ function useDragHandle(getPayload, options) {
       document.removeEventListener("pointermove", onMove);
       document.removeEventListener("pointerup", onEnd);
       document.removeEventListener("pointercancel", onEnd);
+      pendingTeardownRef.current = null;
     }
     document.addEventListener("pointermove", onMove);
     document.addEventListener("pointerup", onEnd);
     document.addEventListener("pointercancel", onEnd);
+    pendingTeardownRef.current = cleanup;
   }, [getPayload]);
   return { onPointerDown, style: { touchAction: "none" } };
 }
@@ -9073,7 +9241,7 @@ var reorderBackwardAction = {
     }
   ],
   eligible: { capability: "edits-page" },
-  requires: ["selection", "scene"],
+  requires: ["selection", "scene", "applyOps"],
   invoker: {
     timing: "immediate",
     run: (deps, params) => {
@@ -9240,6 +9408,7 @@ function makeAlignAction(edge) {
     icon: ICON_FOR[edge],
     group: "align",
     eligible: { capability: "transforms-selection" },
+    requires: ["selection", "scene"],
     // No default keybindings — six edges/centers don't fit a clean default
     // chord set. Wire bindings explicitly via the actions registry override map.
     invoker: {
@@ -9251,7 +9420,14 @@ function makeAlignAction(edge) {
         alignSelection(selection, scene, edge);
       }
     },
-    enabled: () => ActionDisabledReason.SelectionRequired
+    // Deps-aware, matching `alignSelection`'s own `ids.length < 2` guard: a
+    // constant disabled reason greys the entry out forever (see
+    // `requiresSelection`).
+    enabled: (deps) => {
+      const selection = deps?.selection;
+      const count = selection?.get().length ?? 0;
+      return count >= 2 ? true : ActionDisabledReason.SelectionRequired;
+    }
   };
 }
 var alignLeftAction = makeAlignAction("left");
@@ -9332,6 +9508,7 @@ function makeDistributeAction(axis) {
     icon: ICON_FOR2[axis],
     group: "distribute",
     eligible: { capability: "transforms-selection" },
+    requires: ["selection", "scene"],
     // No default keybindings. Wire bindings explicitly via the actions registry.
     invoker: {
       timing: "immediate",
@@ -9342,7 +9519,14 @@ function makeDistributeAction(axis) {
         distributeSelection(selection, scene, axis);
       }
     },
-    enabled: () => ActionDisabledReason.SelectionRequired
+    // Deps-aware, matching `distributeSelection`'s own `ids.length < 3` guard:
+    // a constant disabled reason greys the entry out forever (see
+    // `requiresSelection`).
+    enabled: (deps) => {
+      const selection = deps?.selection;
+      const count = selection?.get().length ?? 0;
+      return count >= 3 ? true : ActionDisabledReason.SelectionRequired;
+    }
   };
 }
 var distributeHorizontalAction = makeDistributeAction("x");
@@ -9426,7 +9610,91 @@ function pathToMultiPolygon(path, opts = {}) {
   }
   finalizeCurrent();
   if (rings.length === 0) return [];
-  return rings.map((r) => [r]);
+  return groupRings(rings, path.fillRule);
+}
+function ringSignedArea(ring) {
+  let a = 0;
+  for (let i = 0, n = ring.length - 1; i < n; i++) {
+    a += ring[i][0] * ring[i + 1][1] - ring[i + 1][0] * ring[i][1];
+  }
+  return a * 0.5;
+}
+function ringBox(ring) {
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const [x, y] of ring) {
+    if (x < minX) minX = x;
+    if (x > maxX) maxX = x;
+    if (y < minY) minY = y;
+    if (y > maxY) maxY = y;
+  }
+  return [minX, minY, maxX, maxY];
+}
+function pointInRing(ring, px, py) {
+  let inside = false;
+  for (let i = 0, n = ring.length - 1; i < n; i++) {
+    const [ax, ay] = ring[i];
+    const [bx, by] = ring[i + 1];
+    if (ay > py !== by > py && px < (bx - ax) * (py - ay) / (by - ay) + ax) {
+      inside = !inside;
+    }
+  }
+  return inside;
+}
+function ringContains(outer, outerBox, inner, innerBox) {
+  if (innerBox[0] < outerBox[0] || innerBox[1] < outerBox[1] || innerBox[2] > outerBox[2] || innerBox[3] > outerBox[3]) return false;
+  const n = inner.length - 1;
+  let votes = 0;
+  for (const k of [0, Math.floor(n / 3), Math.floor(2 * n / 3)]) {
+    if (pointInRing(outer, inner[k][0], inner[k][1])) votes++;
+  }
+  return votes >= 2;
+}
+function groupRings(rings, fillRule) {
+  const n = rings.length;
+  if (n === 1) return [[rings[0]]];
+  const boxes = rings.map(ringBox);
+  const orient = rings.map((r) => ringSignedArea(r) >= 0 ? 1 : -1);
+  const parent = new Array(n).fill(-1);
+  const children = rings.map(() => []);
+  for (let i = 0; i < n; i++) {
+    let best = -1;
+    let bestArea = Infinity;
+    for (let j = 0; j < n; j++) {
+      if (i === j) continue;
+      if (!ringContains(rings[j], boxes[j], rings[i], boxes[i])) continue;
+      const area = (boxes[j][2] - boxes[j][0]) * (boxes[j][3] - boxes[j][1]);
+      if (area < bestArea) {
+        bestArea = area;
+        best = j;
+      }
+    }
+    parent[i] = best;
+  }
+  for (let i = 0; i < n; i++) if (parent[i] >= 0) children[parent[i]].push(i);
+  const filled = new Array(n);
+  for (let i = 0; i < n; i++) {
+    let depth = 0;
+    let winding = 0;
+    for (let a = i; a >= 0; a = parent[a]) {
+      winding += orient[a];
+      if (a !== i) depth++;
+    }
+    filled[i] = fillRule === "evenodd" ? depth % 2 === 0 : winding !== 0;
+  }
+  const out = [];
+  for (let i = 0; i < n; i++) {
+    if (!filled[i]) continue;
+    if (parent[i] >= 0 && filled[parent[i]]) continue;
+    const polygon = [rings[i]];
+    const queue = [...children[i]];
+    while (queue.length > 0) {
+      const c = queue.pop();
+      if (filled[c]) queue.push(...children[c]);
+      else polygon.push(rings[c]);
+    }
+    out.push(polygon);
+  }
+  return out;
 }
 function multiPolygonToPath(mp) {
   let nCmds = 0;
@@ -9743,6 +10011,7 @@ function makePathfinderAction(op) {
     icon: ICON_FOR3[op],
     group: "pathfinder",
     eligible: { capability: "creates-shapes" },
+    requires: ["selection", "booleansAdapter"],
     // No default keybindings — there's no industry-standard chord set for
     // boolean ops. Wire bindings explicitly via the actions registry override map.
     invoker: {
@@ -12140,10 +12409,11 @@ function createDispatcher(opts) {
     uiOngoingByAction.set(actionId, gestureId);
     notify2();
     let ended = false;
+    const live = () => !ended && inFlightHandles.get(gestureId) === handle;
     return {
       gestureId,
       update(nextParams) {
-        if (ended) return;
+        if (!live()) return;
         if (!handle.onMove) return;
         try {
           handle.onMove(buildUiInvocationCtx(deps, nextParams));
@@ -12153,7 +12423,10 @@ function createDispatcher(opts) {
         notify2();
       },
       end(reason) {
-        if (ended) return;
+        if (!live()) {
+          ended = true;
+          return;
+        }
         ended = true;
         if (handle.onEnd) {
           try {
@@ -13480,6 +13753,7 @@ function useTools(opts) {
   );
   const active = contributions.focused;
   const getActiveOverlays = contributions.overlays;
+  const registryKey = Object.keys(slotted.registry).sort().join("|") + "#" + slotted.ambient.map((t) => t.id).join("|");
   return useMemo(
     () => ({
       active,
@@ -13492,7 +13766,7 @@ function useTools(opts) {
       has,
       getActiveOverlays
     }),
-    [active, setActive, hotkeyEngaged, engageHotkey, disengageHotkey, has, getActiveOverlays]
+    [active, setActive, hotkeyEngaged, engageHotkey, disengageHotkey, has, getActiveOverlays, registryKey]
   );
 }
 
@@ -15099,8 +15373,17 @@ function composeAffordanceLayer(id, label, affordances) {
     // `buildAffordanceAt` share one implementation rather than two that can
     // drift. This wrapper lifts the region's declared cursor and claim onto
     // the binding, the way `buildAffordanceAt` lifts them onto `AffordanceHit`.
-    hitTest: (wx, wy, state, view, _dims, isVisible) => {
-      const hit = hitAffordanceRegions(affordances, wx, wy, state, view, isVisible);
+    hitTest: (wx, wy, data, view, _dims, isVisible) => {
+      const state = asChromeState(data);
+      if (!state) return null;
+      const hit = hitAffordanceRegions(
+        affordances,
+        wx,
+        wy,
+        state,
+        view,
+        isVisible ?? asIsVisible(data) ?? void 0
+      );
       if (!hit) return null;
       const { cursor, strength, claimedKinds } = hit.region;
       return {
@@ -15460,16 +15743,6 @@ function useRotateTool(adapter, options) {
     [overlay, handleHitRadius, rotationHandleDistance]
   );
 }
-
-// src/tools/builtin/hitExistingGate.ts
-function applyHitExistingGate(ctx, hitExisting) {
-  if (!hitExisting) return false;
-  const hit = hitExisting({ x: ctx.worldX, y: ctx.worldY });
-  if (!hit) return false;
-  const ids = Array.isArray(hit) ? hit : [hit];
-  ctx.selection.set(ids);
-  return true;
-}
 function useHandTool(opts = {}) {
   const inertia = opts.inertia === false ? false : opts.inertia;
   const axis = opts.axis ?? "both";
@@ -15721,6 +15994,10 @@ function usePenTool(options) {
               onEnd: (endCtx, reason) => {
                 const se = s();
                 if (reason === "cancel") {
+                  if (se.current && se.draggingHandleAt === se.current.anchors.length - 1) {
+                    se.current.anchors.pop();
+                    if (se.current.anchors.length === 0) se.current = null;
+                  }
                   se.draggingHandleAt = null;
                   forceRenderRef.current();
                   return;
@@ -17512,7 +17789,6 @@ function CanvasInner(props, ref) {
     shaders,
     previewIdsExtra,
     previewPoseExtra,
-    previewBoundsExtra,
     gestureSource,
     viewport,
     backgroundFill,
@@ -17538,6 +17814,7 @@ function CanvasInner(props, ref) {
   debugSinkRefForCtx.current = debugSink;
   const adapter = adapterProp;
   const canvasRef = useRef(null);
+  const helpersForLayersRef = useRef(null);
   const dimsRef = useRef({ width, height });
   dimsRef.current = { width, height };
   const getIsVisibleRef = useRef(getIsVisible);
@@ -17560,7 +17837,7 @@ function CanvasInner(props, ref) {
     const isVisible = getIsVisibleRef.current?.() ?? alwaysVisible;
     for (const layer of layers2) {
       if (!layer.hitTest) continue;
-      const hit = layer.hitTest(worldX, worldY, void 0, view, dims, isVisible);
+      const hit = layer.hitTest(worldX, worldY, helpersForLayersRef.current, view, dims, isVisible);
       if (hit) return { layerId: layer.id, hit };
     }
     return null;
@@ -17715,8 +17992,8 @@ function CanvasInner(props, ref) {
   };
   const selectedIdsForWiring = effectiveSelection.current;
   const multiActive2 = selectedIdsForWiring.length > 1;
-  const previewExtraRef = useRef({ previewPoseExtra, previewBoundsExtra });
-  previewExtraRef.current = { previewPoseExtra, previewBoundsExtra };
+  const previewExtraRef = useRef({ previewPoseExtra });
+  previewExtraRef.current = { previewPoseExtra };
   const effectiveBoundsOf = useMemo(() => {
     return boundsOf2 ?? baseBoundsOf;
   }, [boundsOf2, baseBoundsOf]);
@@ -17735,10 +18012,6 @@ function CanvasInner(props, ref) {
           if (p != null) return geometry.getBounds(p);
         }
         const extras = previewExtraRef.current;
-        if (extras.previewBoundsExtra) {
-          const b = extras.previewBoundsExtra(id);
-          if (b) return b;
-        }
         if (extras.previewPoseExtra) {
           const p = extras.previewPoseExtra(id);
           if (p != null) return geometry.getBounds(p);
@@ -17779,10 +18052,6 @@ function CanvasInner(props, ref) {
       const p = firstPreviewPose(tools, id);
       if (p != null) return geometry.getBounds(p);
     }
-    if (previewBoundsExtra) {
-      const b = previewBoundsExtra(id);
-      if (b) return b;
-    }
     if (previewPoseExtra) {
       const p = previewPoseExtra(id);
       if (p != null) return geometry.getBounds(p);
@@ -17818,6 +18087,7 @@ function CanvasInner(props, ref) {
     getDebug: () => debugSink,
     getIsVisible: () => getIsVisibleRef.current?.() ?? alwaysVisible
   };
+  helpersForLayersRef.current = helpersForLayers;
   if (helpersRef) helpersRef.current = helpersForLayers;
   const pointerDownRef = useRef(false);
   const handlePointerDown = (e) => {
@@ -17999,6 +18269,11 @@ function CanvasInner(props, ref) {
     );
     renderer.render(commands, viewToMat3(effectiveView));
   }, [layersWithDebug, width, height, effectiveView, debugSink, redrawNonce, dprProp]);
+  useEffect(() => () => {
+    glRendererRef.current?.dispose();
+    glRendererRef.current = null;
+    lastResizeRef.current = null;
+  }, []);
   const shaderIdKey = shaders?.map((h) => h.id).join("|") ?? "";
   useEffect(() => {
     const renderer = glRendererRef.current;
@@ -19463,6 +19738,89 @@ function poseContainsRotated(pose, wx, wy, tolerance) {
   }
   return poseContains(pose, wx, wy, tolerance);
 }
+function hiddenLayerIds(layers) {
+  const out = /* @__PURE__ */ new Set();
+  for (const layer of layers ?? []) {
+    if (layer.visible === false) out.add(layer.id);
+  }
+  return out;
+}
+function hitTestArea(scene, bounds) {
+  const { x, y, width: w, height: h } = bounds;
+  const area = [x, y, x + w, y, x + w, y + h, x, y + h];
+  return hitTestAreaPolygon(scene, area, { x, y, width: w, height: h }, true);
+}
+function hitTestAreaPolygon(scene, area, areaBounds, areaIsRect = false) {
+  const ab = areaBounds ?? boundsOf(area);
+  if (!ab) return [];
+  const hits = [];
+  const hidden = hiddenLayerIds(scene.layers);
+  const order = scene.renderOrderNodes();
+  for (let i = 0; i < order.length; i++) {
+    const node = order[i];
+    if (node.kind === "container") continue;
+    if (hidden.size > 0 && hidden.has(node.layer)) continue;
+    const pose = node.pose;
+    const silhouette = pose !== null && typeof pose === "object" && pose.kind === "polygon";
+    const b = silhouette ? nodeMemo(node, "aabb", pose, () => aabbOfPose(pose)) : aabbOfPose(pose);
+    if (!Number.isFinite(b.x) || !Number.isFinite(b.y) || !Number.isFinite(b.width) || !Number.isFinite(b.height)) {
+      continue;
+    }
+    if (b.x >= ab.x + ab.width || b.x + b.width <= ab.x || b.y >= ab.y + ab.height || b.y + b.height <= ab.y) {
+      continue;
+    }
+    if (areaIsRect && b.x >= ab.x && b.y >= ab.y && b.x + b.width <= ab.x + ab.width && b.y + b.height <= ab.y + ab.height) {
+      hits.push(node.id);
+      continue;
+    }
+    if (silhouette) {
+      if (silhouetteOverlapsArea(pose.coords, area)) {
+        hits.push(node.id);
+      }
+      continue;
+    }
+    const drawn = findShapeSilhouette(node, pose);
+    if (drawn?.kind === "polygon") {
+      if (silhouetteOverlapsArea(drawn.coords, area)) hits.push(node.id);
+      continue;
+    }
+    hits.push(node.id);
+  }
+  return hits;
+}
+function silhouetteOverlapsArea(sil, area) {
+  const ns = sil.length >> 1;
+  const na = area.length >> 1;
+  if (ns < 1 || na < 3) return false;
+  for (let i = 0; i < ns; i++) {
+    if (pointInPolygon(area, sil[i * 2], sil[i * 2 + 1])) return true;
+  }
+  for (let i = 0; i < na; i++) {
+    if (pointInPolygon(sil, area[i * 2], area[i * 2 + 1])) return true;
+  }
+  for (let i = 0, j = ns - 1; i < ns; j = i++) {
+    const ax = sil[j * 2], ay = sil[j * 2 + 1];
+    const bx = sil[i * 2], by = sil[i * 2 + 1];
+    for (let k = 0, l = na - 1; k < na; l = k++) {
+      const cx = area[l * 2], cy = area[l * 2 + 1];
+      const dx = area[k * 2], dy = area[k * 2 + 1];
+      if (segmentsCross(ax, ay, bx, by, cx, cy, dx, dy)) return true;
+    }
+  }
+  return false;
+}
+function boundsOf(coords) {
+  if (coords.length < 2) return null;
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (let i = 0; i + 1 < coords.length; i += 2) {
+    const x = coords[i], y = coords[i + 1];
+    if (x < minX) minX = x;
+    if (y < minY) minY = y;
+    if (x > maxX) maxX = x;
+    if (y > maxY) maxY = y;
+  }
+  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+}
 
 // src/canvas/SceneCanvas/useSceneSelectTool.ts
 var DEFAULT_PICK_TOLERANCE_PX = 4;
@@ -19562,7 +19920,9 @@ function useSceneSelectTool(args) {
       }
       const tolerance = pickTolerancePx / meanScale(getView?.()?.scale ?? { x: 1, y: 1 });
       const out = [];
+      const hidden = hiddenLayerIds(scene.layers);
       for (const n of scene.renderOrderNodes()) {
+        if (hidden.size > 0 && hidden.has(n.layer)) continue;
         if (!poseContainsRotated(n.pose, wx, wy, tolerance)) continue;
         if (shapePicking && !shapeCoversPoint(n, n.pose, wx, wy, { tolerance })) continue;
         out.push(n.id);
@@ -20465,8 +20825,10 @@ function createPathAnchorAffordances(getAnchorState, opts = {}) {
   const anchors = {
     id: PATH_ANCHOR_CHROME_ID,
     regions(state) {
+      const editingId = getAnchorState()?.editingId ?? null;
       const out = [];
       for (const { id, path } of editablePaths(state)) {
+        if (editingId !== null && id !== editingId) continue;
         for (const a of enumerateAnchors(path)) {
           out.push(point(
             `${id}:anchor:${a.anchorIndex}`,
@@ -20729,80 +21091,6 @@ function DepRegistryProviderIfRoot({ children }) {
   if (parent) return /* @__PURE__ */ jsx(Fragment, { children });
   return /* @__PURE__ */ jsx(DepRegistryProvider, { children });
 }
-function hitTestArea(scene, bounds) {
-  const { x, y, width: w, height: h } = bounds;
-  const area = [x, y, x + w, y, x + w, y + h, x, y + h];
-  return hitTestAreaPolygon(scene, area, { x, y, width: w, height: h }, true);
-}
-function hitTestAreaPolygon(scene, area, areaBounds, areaIsRect = false) {
-  const ab = areaBounds ?? boundsOf(area);
-  if (!ab) return [];
-  const hits = [];
-  const order = scene.renderOrderNodes();
-  for (let i = 0; i < order.length; i++) {
-    const node = order[i];
-    if (node.kind === "container") continue;
-    const pose = node.pose;
-    const silhouette = pose !== null && typeof pose === "object" && pose.kind === "polygon";
-    const b = silhouette ? nodeMemo(node, "aabb", pose, () => aabbOfPose(pose)) : aabbOfPose(pose);
-    if (!Number.isFinite(b.x) || !Number.isFinite(b.y) || !Number.isFinite(b.width) || !Number.isFinite(b.height)) {
-      continue;
-    }
-    if (b.x >= ab.x + ab.width || b.x + b.width <= ab.x || b.y >= ab.y + ab.height || b.y + b.height <= ab.y) {
-      continue;
-    }
-    if (areaIsRect && b.x >= ab.x && b.y >= ab.y && b.x + b.width <= ab.x + ab.width && b.y + b.height <= ab.y + ab.height) {
-      hits.push(node.id);
-      continue;
-    }
-    if (silhouette) {
-      if (silhouetteOverlapsArea(pose.coords, area)) {
-        hits.push(node.id);
-      }
-      continue;
-    }
-    const drawn = findShapeSilhouette(node, pose);
-    if (drawn?.kind === "polygon") {
-      if (silhouetteOverlapsArea(drawn.coords, area)) hits.push(node.id);
-      continue;
-    }
-    hits.push(node.id);
-  }
-  return hits;
-}
-function silhouetteOverlapsArea(sil, area) {
-  const ns = sil.length >> 1;
-  const na = area.length >> 1;
-  if (ns < 1 || na < 3) return false;
-  for (let i = 0; i < ns; i++) {
-    if (pointInPolygon(area, sil[i * 2], sil[i * 2 + 1])) return true;
-  }
-  for (let i = 0; i < na; i++) {
-    if (pointInPolygon(sil, area[i * 2], area[i * 2 + 1])) return true;
-  }
-  for (let i = 0, j = ns - 1; i < ns; j = i++) {
-    const ax = sil[j * 2], ay = sil[j * 2 + 1];
-    const bx = sil[i * 2], by = sil[i * 2 + 1];
-    for (let k = 0, l = na - 1; k < na; l = k++) {
-      const cx = area[l * 2], cy = area[l * 2 + 1];
-      const dx = area[k * 2], dy = area[k * 2 + 1];
-      if (segmentsCross(ax, ay, bx, by, cx, cy, dx, dy)) return true;
-    }
-  }
-  return false;
-}
-function boundsOf(coords) {
-  if (coords.length < 2) return null;
-  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
-  for (let i = 0; i + 1 < coords.length; i += 2) {
-    const x = coords[i], y = coords[i + 1];
-    if (x < minX) minX = x;
-    if (y < minY) minY = y;
-    if (x > maxX) maxX = x;
-    if (y > maxY) maxY = y;
-  }
-  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
-}
 function useViewDepSource(currentViewRef, onViewChange, recenter, hostSize) {
   const viewApiRef = useRef({
     get: () => currentViewRef.current,
@@ -21605,6 +21893,7 @@ function useActionsPropResolver(actions) {
     }
     if (!prop) return;
     const unregisters = [];
+    const restores = [];
     const warnedIds = /* @__PURE__ */ new Set();
     for (const [slotId, entry] of Object.entries(prop)) {
       if (entry === null) {
@@ -21632,10 +21921,14 @@ function useActionsPropResolver(actions) {
       }
       const { id: _drop, ...rest } = entry;
       const merged = { ...existing, ...rest };
+      restores.push(() => {
+        reg.register(existing);
+      });
       unregisters.push(reg.register(merged));
     }
     return () => {
       for (const u of unregisters) u();
+      for (const r of restores) r();
     };
   }, [reg, actions]);
 }
@@ -24865,23 +25158,7 @@ function nestedHitTester(adapter, opts) {
   };
   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;
@@ -24890,7 +25167,7 @@ function pointCubicDist2(px, py, x0, y0, x1, y1, x2, y2, x3, y3) {
     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);
+    const d2 = pointSegmentDist2(px, py, prevX, prevY, sx, sy);
     if (d2 < best) best = d2;
     prevX = sx;
     prevY = sy;
@@ -24927,7 +25204,7 @@ function polygonPathDistance(path, px, py) {
       ci += 2;
     } else if (cmd === PATH_L) {
       const x = coords[ci], y = coords[ci + 1];
-      const d2 = pointSegDist2(px, py, curX, curY, x, y);
+      const d2 = pointSegmentDist2(px, py, curX, curY, x, y);
       if (d2 < best) best = d2;
       curX = x;
       curY = y;
@@ -24954,7 +25231,7 @@ function polygonPathDistance(path, px, py) {
       curY = y;
       ci += 4;
     } else if (cmd === PATH_Z) {
-      const d2 = pointSegDist2(px, py, curX, curY, startX, startY);
+      const d2 = pointSegmentDist2(px, py, curX, curY, startX, startY);
       if (d2 < best) best = d2;
       curX = startX;
       curY = startY;
@@ -28309,6 +28586,6 @@ function mergeContributions(...bundles) {
   return out;
 }
 
-export { ALWAYS, ANCHOR_HIT_BASE_PX, ActionsProviderIfRoot, ActiveToolContextProvider, ActiveToolContextProviderIfRoot, BUNDLE_TOOLS, COARSE_TARGET_SCALE, CURVE_REPS, ColorOverrideRegistry, CropIcon, CursorCoordsHud, DEFAULT_ALPHA_DECAY, DEFAULT_ALPHA_MIN, DEFAULT_DEBUG_STROKES, DEFAULT_DEBUG_THEME, DEFAULT_DEVICE_PROFILE, DEFAULT_FILL_COLOR, DEFAULT_HANDLE_SIZE2 as DEFAULT_HANDLE_SIZE, DEFAULT_PALETTE, DEFAULT_ROTATION_HANDLE_DISTANCE, DEFAULT_STROKE_COLOR, DEFAULT_TEXT_STYLE, DEFAULT_VELOCITY_DECAY, DepRegistryProviderIfRoot, DeviceProfileProvider, DivideIcon, EASINGS, EllipseIcon, ExcludeIcon, EyedropperIcon, FALLBACK_FIT_VIEW, GHOST_STROKE, HANDLE_BASE_PX, HandIcon, IDENTITY_COLOR_MATRIX, IDENTITY_POSE_COMPOSITION, IntersectIcon, KIT_SHAPE_KINDS, LassoIcon, LineIcon, MIXED, MOVE_ANCHORS, MinimapCanvas, NEVER, OUTLINE_MIN_SCREEN_PX, PATH_ANCHOR_CHROME_ID, PenIcon, PencilIcon, PickHud, PointerProviderIfRoot, PolygonIcon, RECT_ALIGN_PROJECTION, ROTATION_HANDLE_BASE_PX, RectIcon, SPRING_PRESETS, SceneCanvas, SceneViewCanvas, SelectIcon, SelectionContextProvider, SelectionContextProviderIfRoot, ShaderCompileError, StarIcon, SubtractIcon, TextIcon, UnionIcon, UnknownIcon, VERSION, WeaselProvider, WeaselRenderer, aabbCenter, actionIs, alignDeltaFor, alignInsertBehavior, alignMoveBehavior, alignResizeBehavior, alignedStrokeRect, always, and, animateLifecycle, animateOnSetPose, annulusSemiAxes, applyBooleanOp, applyHitExistingGate, applyStyleToRange, areaSelectAction, arrayAdapter, asNodeId, bezierCubic, bezierQuadratic, buildChromeCtx, buildGradientRamp, buildRuleCtx, buildSceneViewCommands, canBringForward, canHover, canSendBackward, capabilityAll, capabilityIn, capabilityIs, capabilityNot, caretIndexAt, cellAt, charOffsetToDomPosition, clampView, clearSelectionAction, clientToCanvas, clipboardCopyAction, clipboardCutAction, cloneAction, coarsePointer, composeAffordanceLayer, composePath, composeRectPose, composeSelectionPose, composeWorldPose, computeFitView2 as computeFitView, computeIndicatorCommand, computeWheelAction, cond, constrainTo45, containedThenNearest, countPathAnchors, createCellHighlightLayer, createChildrenLayer, createCornerResizeAffordance, createDebugOverlayLayer, createDebugSink, createDispatcher, createGridLayer, createGuidesLayer, createHistory2 as createHistory, createMarkdownRenderer, createMoveToIndexOp, createNodeProperties, createNodeRouting, createParallaxLayer, createPathAnchorAffordances, createPathEditingOverlayLayer, createPathLayer, createPenPreviewLayer, createReorderOp, createRotationAffordance, createScene, createSelectionHandlesLayer, createSelectionOutlineLayer, createSelectionOverlayLayer, createSetDataOp, createSetLayerOp, createSetPathOp, createSetTextOp, createTextLayer, createViewportLayer, cycleVertexColors, decomposePath, decomposeRectPose, defaultCommitAdapter, defaultDrawOne, defaultLabelTextRenderer, defaultNodeProperties, defaultNodeRouting, defaultVisibilityRules, defineTool, defineViewportTool, deriveAlignmentGuides, deriveParallaxView, describeRule, domPositionToCharOffset, domToRuns, drawLayers, easeIn, easeInBack, easeInBounce, easeInCirc, easeInCubic, easeInElastic, easeInExpo, easeInOut, easeInOutBack, easeInOutBounce, easeInOutCirc, easeInOutCubic, easeInOutElastic, easeInOutExpo, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInOutSine, easeInQuad, easeInQuart, easeInQuint, easeInSine, easeOut, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic2 as easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, editAnchorsAction, enterTextEditAction, enumerateAnchors, evaluate, fillInPoseFrame, fillToBoundsFrame, findNodeShape, findShapeInk, findShapeSilhouette, fitTextPose, fitToBounds, fitViewToBounds, fitZoom, focused, fontString, forEachCoalesced, freeform, gateLayer, gesturing, getAlpha01, getImageBitmap, getNodeShapes, getStylusData, gradientForBounds, gradientGeometry, hexToRgba, hitAffordanceRegions, hitAnchor, hitRotationHandle, hovering, hoveringSelected, imageStatus, inferredNodeProperties, inferredNodeRouting, insertAction, isEditableTarget2 as isEditableTarget, isPatternSpec, lassoSelectAction, layoutMarkdown, lerpColorArray, lerpOklab, lerpOklch, linear, liveScope, makeViewportZoomAction, markdownToRuns, mat3, matchAlignment, matchesKeyBinding, meanScale, measureText, measureTextBounds, measuredWidth, mergeAlphaFromPrev, mergeContributions, modeIn, modeIs, modeNot, modifierHeld, momentum, moveAction, multiActive, nearest, nearestWithin, nestedHitTester, never, nodeHasFlag, none, normalizeHex, not, nurbs, oklabToOklch, oklabToSrgbU8, oklchToOklab, openFilePicker, or, parseColor, parseColorToRgba255, parseDebugFlags, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathDistanceToPoint, pathDivide, pathExclude, pathFromD, pathInPoseFrame, pathInWorld, pathIntersect, pathIntersectsPolygon, pathIntersectsRect, pathOriginProjection, pathSubtract, pathToAnchors, pathUnion, pickTopMostHit, pinchZoomAction, planPixelRender, pointInRotatedRect, pointInTextPose, poseRotationOf, pressureToWidth, rainbowVertexColors, rebaseLocalPose, rectCorners, registerContentHandler, registerNodeShape, registerProgram, renderLabel, renderSceneToCanvas, renderSceneToPixels, resizeAction, resolveColor, resolveDeviceProfile, resolveFillPattern, resolvePatternSpec, resolveRuns, resolveTextStyle, resolveVisibility, rgbaToHex, rotateAction, rotateAroundAABBCenter, rotatePathAround, rotatePoint, rotatedRectCorners, rotationDegreesUnit, rotationHandle, roundToCell, runsToDom, runsToMarkdown, runsToPlainText, sampleGradientStops, sceneFromJSON, sceneNodeClientRect, sceneToAdapter, scopeBindings, screenToWorld, selectFromLasso, selectionAtLeast, selectionEmpty, selectionIs, setFlagOverRange, shapeCoversPoint, sliceAction, snapPoint, solidVertexColors, specificity, spiro, splitPathByLine, splitSubpaths, springPose, springVertexColors, srgbU8ToOklab, staggerVertexColors, startThresholdDrag, styleAtRange, subscribeImageReady, tessellate, tessellateStroke, textCommand, textLineBoxes, tileGrid, toHex8, toRuns, translatePoseViaDescriptor, translateRectPose, tweenPose, tweenVertexColors, unionBounds, unionBoundsPath, useActiveToolContext, useAlign, useAnimator, useArrayAdapter, useAutoCenter, useBooleans, useBooleansAdapter, useCanvasFocus, useCanvasSize, useDecayLoop, useDeviceProfile, useDistribute, useDragGesture, useDragHandle, useDragRadial, useDragRect, useDropZone, useEllipseTool, useEyedropperTool, useGestureDispatcher, useGridCellHover, useGuides, useHandTool, useHandleDrag, useHoverTracking, useImageTool, useKeybindings, useLassoTool, useLineTool, useOptionalActiveToolContext, usePenTool, usePencilTool, usePinchGesture, usePinchZoomTool, usePointerStylus, usePolygonTool, usePublishSelection, useRectTool, useResizePolicy, useRotateTool, useScene, useSceneAdapter, useSceneTextEdit, useSelectTool, useSelection, useSelectionContext, useSimulation, useSliceDep, useStandardActions, useStarTool, useTextEdit, useTextTool, useTools, useVelocityTracker, useViewAnimation, useViewTween, useZoom, verticalAlignOffset, viewToMat3, viewToTransform, viewportDragPanAction, viewportZoomAction, viewportsAt, when, withAlpha01, withCoord, withGradientKind, worldEditToStorage, worldPoseLookup, worldToScreen, zoomAt, zoomAtLeast };
-//# sourceMappingURL=chunk-PI56ORHE.js.map
-//# sourceMappingURL=chunk-PI56ORHE.js.map
+export { ALWAYS, ANCHOR_HIT_BASE_PX, ActionsProviderIfRoot, ActiveToolContextProvider, ActiveToolContextProviderIfRoot, BUNDLE_TOOLS, COARSE_TARGET_SCALE, CURVE_REPS, ColorOverrideRegistry, CropIcon, CursorCoordsHud, DEFAULT_ALPHA_DECAY, DEFAULT_ALPHA_MIN, DEFAULT_DEBUG_STROKES, DEFAULT_DEBUG_THEME, DEFAULT_DEVICE_PROFILE, DEFAULT_FILL_COLOR, DEFAULT_HANDLE_SIZE2 as DEFAULT_HANDLE_SIZE, DEFAULT_PALETTE, DEFAULT_ROTATION_HANDLE_DISTANCE, DEFAULT_STROKE_COLOR, DEFAULT_TEXT_STYLE, DEFAULT_VELOCITY_DECAY, DepRegistryProviderIfRoot, DeviceProfileProvider, DivideIcon, EASINGS, EllipseIcon, ExcludeIcon, EyedropperIcon, FALLBACK_FIT_VIEW, GHOST_STROKE, HANDLE_BASE_PX, HandIcon, IDENTITY_COLOR_MATRIX, IDENTITY_POSE_COMPOSITION, IntersectIcon, KIT_SHAPE_KINDS, LassoIcon, LineIcon, MIXED, MOVE_ANCHORS, MinimapCanvas, NEVER, OUTLINE_MIN_SCREEN_PX, PATH_ANCHOR_CHROME_ID, PenIcon, PencilIcon, PickHud, PointerProviderIfRoot, PolygonIcon, RECT_ALIGN_PROJECTION, ROTATION_HANDLE_BASE_PX, RectIcon, SPRING_PRESETS, SceneCanvas, SceneViewCanvas, SelectIcon, SelectionContextProvider, SelectionContextProviderIfRoot, ShaderCompileError, StarIcon, SubtractIcon, TextIcon, UnionIcon, UnknownIcon, VERSION, WeaselProvider, WeaselRenderer, aabbCenter, actionIs, alignDeltaFor, alignInsertBehavior, alignMoveBehavior, alignResizeBehavior, alignedStrokeRect, always, and, animateLifecycle, animateOnSetPose, annulusSemiAxes, applyBooleanOp, applyStyleToRange, areaSelectAction, arrayAdapter, asNodeId, bezierCubic, bezierQuadratic, buildChromeCtx, buildGradientRamp, buildRuleCtx, buildSceneViewCommands, canBringForward, canHover, canSendBackward, capabilityAll, capabilityIn, capabilityIs, capabilityNot, caretIndexAt, cellAt, charOffsetToDomPosition, clampView, clearSelectionAction, clientToCanvas, clipboardCopyAction, clipboardCutAction, cloneAction, coarsePointer, composeAffordanceLayer, composePath, composeRectPose, composeSelectionPose, composeWorldPose, computeFitView2 as computeFitView, computeIndicatorCommand, computeWheelAction, cond, constrainTo45, containedThenNearest, countPathAnchors, createCellHighlightLayer, createChildrenLayer, createCornerResizeAffordance, createDebugOverlayLayer, createDebugSink, createDispatcher, createGridLayer, createGuidesLayer, createHistory2 as createHistory, createMarkdownRenderer, createMoveToIndexOp, createNodeProperties, createNodeRouting, createParallaxLayer, createPathAnchorAffordances, createPathEditingOverlayLayer, createPathLayer, createPenPreviewLayer, createReorderOp, createRotationAffordance, createScene, createSelectionHandlesLayer, createSelectionOutlineLayer, createSelectionOverlayLayer, createSetDataOp, createSetLayerOp, createSetPathOp, createSetTextOp, createTextLayer, createViewportLayer, cycleVertexColors, decomposePath, decomposeRectPose, defaultCommitAdapter, defaultDrawOne, defaultLabelTextRenderer, defaultNodeProperties, defaultNodeRouting, defaultVisibilityRules, defineTool, defineViewportTool, deriveAlignmentGuides, deriveParallaxView, describeRule, domPositionToCharOffset, domToRuns, drawLayers, easeIn, easeInBack, easeInBounce, easeInCirc, easeInCubic, easeInElastic, easeInExpo, easeInOut, easeInOutBack, easeInOutBounce, easeInOutCirc, easeInOutCubic, easeInOutElastic, easeInOutExpo, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInOutSine, easeInQuad, easeInQuart, easeInQuint, easeInSine, easeOut, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic2 as easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, editAnchorsAction, enterTextEditAction, enumerateAnchors, evaluate, fillInPoseFrame, fillToBoundsFrame, findNodeShape, findShapeInk, findShapeSilhouette, fitTextPose, fitToBounds, fitViewToBounds, fitZoom, focused, fontString, forEachCoalesced, freeform, gateLayer, gesturing, getAlpha01, getImageBitmap, getNodeShapes, getStylusData, gradientForBounds, gradientGeometry, hexToRgba, hitAffordanceRegions, hitAnchor, hitRotationHandle, hovering, hoveringSelected, imageStatus, inferredNodeProperties, inferredNodeRouting, insertAction, isEditableTarget2 as isEditableTarget, isPatternSpec, lassoSelectAction, layoutMarkdown, lerpColorArray, lerpOklab, lerpOklch, linear, liveScope, makeViewportZoomAction, markdownToRuns, mat3, matchAlignment, matchesKeyBinding, meanScale, measureText, measureTextBounds, measuredWidth, mergeAlphaFromPrev, mergeContributions, modeIn, modeIs, modeNot, modifierHeld, momentum, moveAction, multiActive, nearest, nearestWithin, nestedHitTester, never, nodeHasFlag, none, normalizeHex, not, nurbs, oklabToOklch, oklabToSrgbU8, oklchToOklab, openFilePicker, or, parseColor, parseColorToRgba255, parseDebugFlags, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathDistanceToPoint, pathDivide, pathExclude, pathFromD, pathInPoseFrame, pathInWorld, pathIntersect, pathIntersectsPolygon, pathIntersectsRect, pathOriginProjection, pathSubtract, pathToAnchors, pathUnion, pickTopMostHit, pinchZoomAction, planPixelRender, pointInRotatedRect, pointInTextPose, poseRotationOf, pressureToWidth, rainbowVertexColors, rebaseLocalPose, rectCorners, registerContentHandler, registerNodeShape, registerProgram, renderLabel, renderSceneToCanvas, renderSceneToPixels, resizeAction, resolveColor, resolveDeviceProfile, resolveFillPattern, resolvePatternSpec, resolveRuns, resolveTextStyle, resolveVisibility, rgbaToHex, rotateAction, rotateAroundAABBCenter, rotatePathAround, rotatePoint, rotatedRectCorners, rotationDegreesUnit, rotationHandle, roundToCell, runsToDom, runsToMarkdown, runsToPlainText, sampleGradientStops, sceneFromJSON, sceneNodeClientRect, sceneToAdapter, scopeBindings, screenToWorld, selectFromLasso, selectionAtLeast, selectionEmpty, selectionIs, setFlagOverRange, shapeCoversPoint, sliceAction, snapPoint, solidVertexColors, specificity, spiro, splitPathByLine, splitSubpaths, springPose, springVertexColors, srgbU8ToOklab, staggerVertexColors, startThresholdDrag, styleAtRange, subscribeImageReady, tessellate, tessellateStroke, textCommand, textLineBoxes, tileGrid, toHex8, toRuns, translatePoseViaDescriptor, translateRectPose, tweenPose, tweenVertexColors, unionBounds, unionBoundsPath, useActiveToolContext, useAlign, useAnimator, useArrayAdapter, useAutoCenter, useBooleans, useBooleansAdapter, useCanvasFocus, useCanvasSize, useDecayLoop, useDeviceProfile, useDistribute, useDragGesture, useDragHandle, useDragRadial, useDragRect, useDropZone, useEllipseTool, useEyedropperTool, useGestureDispatcher, useGridCellHover, useGuides, useHandTool, useHandleDrag, useHoverTracking, useImageTool, useKeybindings, useLassoTool, useLineTool, useOptionalActiveToolContext, usePenTool, usePencilTool, usePinchGesture, usePinchZoomTool, usePointerStylus, usePolygonTool, usePublishSelection, useRectTool, useResizePolicy, useRotateTool, useScene, useSceneAdapter, useSceneTextEdit, useSelectTool, useSelection, useSelectionContext, useSimulation, useSliceDep, useStandardActions, useStarTool, useTextEdit, useTextTool, useTools, useVelocityTracker, useViewAnimation, useViewTween, useZoom, verticalAlignOffset, viewToMat3, viewToTransform, viewportDragPanAction, viewportZoomAction, viewportsAt, when, withAlpha01, withCoord, withGradientKind, worldEditToStorage, worldPoseLookup, worldToScreen, zoomAt, zoomAtLeast };
+//# sourceMappingURL=chunk-AYGSXNY3.js.map
+//# sourceMappingURL=chunk-AYGSXNY3.js.map