@weasel-js/core 1.0.3 → 1.1.0

package/dist/{chunk-SMCZRSYB.js → chunk-3B4QEB2G.js}

@@ -1,7 +1,7 @@
-import { ActionDisabledReason, useOptionalDepRegistry, DepRegistryProvider, useActionsRegistry, ActionsProvider, useDepRegistry, reportRouteConflicts, buildDepsFromRequires, useDepSource, actionBindings } from './chunk-TR3HZN34.js';
-import { scratchKey, createTransformOp, snap, getScratch, createReparentOp, setScratch } from './chunk-3KGMJMOS.js';
-import { fixedCornerOf, DEFAULT_RESIZE_BEHAVIORS, CORNER_ANCHORS, cornerPoint } from './chunk-3JYFAQIB.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-U45SODC2.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';
@@ -10,7 +10,7 @@ import { createContext, createElement, forwardRef, useMemo, useRef, useState, us
 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.3" ;
+var VERSION = "1.1.0" ;
 
 // 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);
@@ -4092,7 +4216,7 @@ function drawImage(ctx, cmd) {
   );
   gl.uniform1i(prog.uniform("u_sampler"), 0);
   gl.uniform1f(prog.uniform("u_opacity"), cmd.opacity ?? 1);
-  gl.uniform1f(prog.uniform("u_alpha"), ctx.state.alpha);
+  setAlphaUniform(ctx, prog, ctx.state.alpha);
   applyClipTest(ctx);
   gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_INT, 0);
   gl.bindVertexArray(null);
@@ -4321,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() {
@@ -4419,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()) {
@@ -4446,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 = {
@@ -5202,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);
@@ -5225,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;
@@ -5260,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" } };
 }
@@ -5817,7 +5956,7 @@ var IDENTITY_POSE_COMPOSITION = {
   compose: (_parent, child) => child,
   decompose: (_parent, world) => world
 };
-function composeWorldPose(adapter, id, compose) {
+function composeWorldPose(adapter, id, compose2) {
   const chain = [id];
   const seen = /* @__PURE__ */ new Set([id]);
   let cursor = adapter.getParent(id);
@@ -5829,7 +5968,7 @@ function composeWorldPose(adapter, id, compose) {
   }
   let world = adapter.getPose(chain[chain.length - 1]);
   for (let i = chain.length - 2; i >= 0; i--) {
-    world = compose(world, adapter.getPose(chain[i]));
+    world = compose2(world, adapter.getPose(chain[i]));
   }
   return world;
 }
@@ -5843,9 +5982,9 @@ function composeRectPose(parent, child) {
 function translateRectPose(pose, dx, dy) {
   return { ...pose, x: pose.x + dx, y: pose.y + dy };
 }
-function rebaseLocalPose(adapter, worldPose, newParentId, compose, decompose) {
+function rebaseLocalPose(adapter, worldPose, newParentId, compose2, decompose) {
   if (newParentId === null) return worldPose;
-  const parentWorld = composeWorldPose(adapter, newParentId, compose);
+  const parentWorld = composeWorldPose(adapter, newParentId, compose2);
   return decompose(parentWorld, worldPose);
 }
 function decomposeRectPose(parent, world) {
@@ -5855,10 +5994,10 @@ function decomposeRectPose(parent, world) {
     y: world.y - parent.y
   };
 }
-function worldPoseLookup(adapter, compose) {
+function worldPoseLookup(adapter, compose2) {
   return (id) => {
     try {
-      return composeWorldPose(adapter, id, compose);
+      return composeWorldPose(adapter, id, compose2);
     } catch {
       return null;
     }
@@ -8916,9 +9055,17 @@ function arraysEqual(a, b) {
   return true;
 }
 function createPartitionedReorderOp(args) {
-  const { ids, fn, label } = args;
-  let restore = null;
+  const { ids, direction, fn, label, prevOrders } = args;
+  const argsForSerial = {
+    ids,
+    direction,
+    label,
+    prevOrders: prevOrders ? prevOrders.map((e) => ({ ...e, before: e.before.slice() })) : void 0
+  };
+  let restore = prevOrders ? prevOrders.map((e) => ({ ...e, before: e.before.slice() })) : null;
   return {
+    name: "reorder",
+    args: argsForSerial,
     label,
     apply(adapter) {
       const a = adapter;
@@ -8941,6 +9088,7 @@ function createPartitionedReorderOp(args) {
         mutated = true;
       }
       restore = snapshots;
+      argsForSerial.prevOrders = snapshots.map((e) => ({ ...e, before: e.before.slice() }));
       return mutated;
     },
     invert() {
@@ -8972,10 +9120,17 @@ var REORDER_DIRECTIONS = {
   back: { fn: sendToBack, defaultLabel: "Send to back" }
 };
 function createReorderOp(args) {
-  const { ids, direction, label } = args;
+  const { ids, direction, label, prevOrders } = args;
   const { fn, defaultLabel } = REORDER_DIRECTIONS[direction];
-  return createPartitionedReorderOp({ ids, fn, label: label ?? defaultLabel });
+  return createPartitionedReorderOp({
+    ids,
+    direction,
+    fn,
+    label: label ?? defaultLabel,
+    prevOrders
+  });
 }
+registerOpFactory("reorder", (args) => createReorderOp(args));
 function createMoveToIndexOp(args) {
   const { ids, parentId, index, label } = args;
   const argsForSerial = {
@@ -9102,7 +9257,7 @@ var reorderBackwardAction = {
     }
   ],
   eligible: { capability: "edits-page" },
-  requires: ["selection", "scene"],
+  requires: ["selection", "scene", "applyOps"],
   invoker: {
     timing: "immediate",
     run: (deps, params) => {
@@ -9269,6 +9424,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: {
@@ -9280,7 +9436,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");
@@ -9361,6 +9524,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",
@@ -9371,7 +9535,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");
@@ -9455,7 +9626,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;
@@ -9772,6 +10027,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: {
@@ -12169,10 +12425,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));
@@ -12182,7 +12439,10 @@ function createDispatcher(opts) {
         notify2();
       },
       end(reason) {
-        if (ended) return;
+        if (!live()) {
+          ended = true;
+          return;
+        }
         ended = true;
         if (handle.onEnd) {
           try {
@@ -13509,6 +13769,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,
@@ -13521,7 +13782,7 @@ function useTools(opts) {
       has,
       getActiveOverlays
     }),
-    [active, setActive, hotkeyEngaged, engageHotkey, disengageHotkey, has, getActiveOverlays]
+    [active, setActive, hotkeyEngaged, engageHotkey, disengageHotkey, has, getActiveOverlays, registryKey]
   );
 }
 
@@ -15128,8 +15389,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 {
@@ -15489,16 +15759,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";
@@ -15750,6 +16010,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;
@@ -16699,7 +16963,7 @@ function composeSelectionPose(opts) {
     const visit = (nid) => {
       const kids = getChildren(nid);
       if (kids.length === 0) {
-        out.push(nid);
+        if (!isContainer(nid)) out.push(nid);
         return;
       }
       for (const k of kids) visit(k);
@@ -16752,7 +17016,7 @@ function makeContainerAwareBoundsResolver(getPose, getBounds, getChildren, isCon
     const visit = (nid) => {
       const kids = getChildren(nid);
       if (kids.length === 0) {
-        out.push(nid);
+        if (!isContainer(nid)) out.push(nid);
         return;
       }
       for (const k of kids) visit(k);
@@ -17541,7 +17805,6 @@ function CanvasInner(props, ref) {
     shaders,
     previewIdsExtra,
     previewPoseExtra,
-    previewBoundsExtra,
     gestureSource,
     viewport,
     backgroundFill,
@@ -17567,6 +17830,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);
@@ -17589,7 +17853,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;
@@ -17744,8 +18008,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]);
@@ -17764,10 +18028,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);
@@ -17808,10 +18068,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);
@@ -17847,6 +18103,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) => {
@@ -18028,6 +18285,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;
@@ -19492,6 +19754,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;
@@ -19591,7 +19936,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);
@@ -20494,8 +20841,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}`,
@@ -20758,80 +21107,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,
@@ -21634,6 +21909,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) {
@@ -21661,10 +21937,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]);
 }
@@ -24894,23 +25174,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;
@@ -24919,7 +25183,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;
@@ -24956,7 +25220,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;
@@ -24983,7 +25247,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;
@@ -25836,7 +26100,10 @@ function arrayAdapter(config) {
     },
     getParent,
     setParent,
-    insertNode: (obj) => setItems((items) => [...items, obj]),
+    insertNode: (obj, index) => setItems((items) => {
+      if (index === void 0 || index < 0 || index >= items.length) return [...items, obj];
+      return [...items.slice(0, index), obj, ...items.slice(index)];
+    }),
     removeNode: (id) => setItems((items) => items.filter((o) => o.id !== id)),
     getSelection,
     setSelection,
@@ -27122,6 +27389,225 @@ function makeBuilder(animator, timers, createSupervisor, watchCompletion, items,
   };
 }
 
+// src/animation/timeline/sampleTrack.ts
+function floorKeyIndex(keys, t) {
+  let lo = 0;
+  let hi = keys.length - 1;
+  let found = -1;
+  while (lo <= hi) {
+    const mid2 = lo + hi >> 1;
+    if (keys[mid2].t <= t) {
+      found = mid2;
+      lo = mid2 + 1;
+    } else {
+      hi = mid2 - 1;
+    }
+  }
+  return found;
+}
+function sampleTrack(track, t, segmentCache) {
+  const { keys } = track;
+  if (keys.length === 0) return void 0;
+  const i = floorKeyIndex(keys, t);
+  if (i < 0) return keys[0].value;
+  if (i >= keys.length - 1) return keys[keys.length - 1].value;
+  const a = keys[i];
+  const b = keys[i + 1];
+  const span = b.t - a.t;
+  const raw = span <= 0 ? 1 : (t - a.t) / span;
+  const u = b.easing ? b.easing(raw) : raw;
+  if (track.interpolator) {
+    let fn = segmentCache?.get(i + 1);
+    if (!fn) {
+      fn = track.interpolator(a.value, b.value);
+      segmentCache?.set(i + 1, fn);
+    }
+    return fn(u);
+  }
+  if (track.interpolate) return track.interpolate(a.value, b.value, u);
+  if (typeof a.value === "number" && typeof b.value === "number") {
+    return a.value + (b.value - a.value) * u;
+  }
+  throw new Error("sampleTrack: interpolate or interpolator is required for non-numeric keyframe values");
+}
+
+// src/animation/timeline/createTimeline.ts
+function firstAfter(events, t) {
+  let lo = 0;
+  let hi = events.length;
+  while (lo < hi) {
+    const mid2 = lo + hi >> 1;
+    if (events[mid2].t > t) hi = mid2;
+    else lo = mid2 + 1;
+  }
+  return lo;
+}
+function trackEnd(track) {
+  switch (track.kind) {
+    case "sampled":
+      return track.keys.length ? track.keys[track.keys.length - 1].t : 0;
+    case "event":
+      return track.events.length ? track.events[track.events.length - 1].t : 0;
+    case "timeline":
+      return track.at + tracksEnd(track.timeline.tracks, track.timeline.duration);
+  }
+}
+function tracksEnd(tracks, explicit) {
+  if (explicit != null) return explicit;
+  let max = 0;
+  for (const t of tracks) max = Math.max(max, trackEnd(t));
+  return max;
+}
+function createTimeline(register, id, opts) {
+  let duration = tracksEnd(opts.tracks, opts.duration);
+  let offset = 0;
+  let lastVirtual = 0;
+  let playhead = 0;
+  let prevPlayhead = -Infinity;
+  let done = false;
+  let live = true;
+  let cancelled = false;
+  let wantPaused = opts.autoplay === false;
+  let wantScale = 1;
+  const subscribers2 = /* @__PURE__ */ new Set();
+  const loopOpt = opts.loop ?? false;
+  let loopsLeft = loopOpt === true ? Infinity : loopOpt === false ? 0 : loopOpt;
+  let caches = /* @__PURE__ */ new WeakMap();
+  const cacheFor = (track) => {
+    let c = caches.get(track);
+    if (!c) {
+      c = /* @__PURE__ */ new Map();
+      caches.set(track, c);
+    }
+    return c;
+  };
+  const applySampled = (tracks, t) => {
+    for (const track of tracks) {
+      if (track.kind === "sampled") {
+        const st = track;
+        const v = sampleTrack(st, t, cacheFor(st));
+        if (v !== void 0) st.onTick(v);
+      } else if (track.kind === "timeline") {
+        applySampled(track.timeline.tracks, t - track.at);
+      }
+    }
+  };
+  const fireEvents = (tracks, from, to) => {
+    for (const track of tracks) {
+      if (track.kind === "event") {
+        const end = firstAfter(track.events, to);
+        for (let i = firstAfter(track.events, from); i < end; i += 1) track.events[i].fire();
+      } else if (track.kind === "timeline") {
+        fireEvents(track.timeline.tracks, from - track.at, to - track.at);
+      }
+    }
+  };
+  const onWrap = () => {
+    fireEvents(opts.tracks, prevPlayhead, duration);
+    prevPlayhead = -Infinity;
+  };
+  const tick = (virtualNow) => {
+    lastVirtual = virtualNow;
+    playhead = virtualNow + offset;
+    if (duration > 0 && playhead >= duration) {
+      if (loopsLeft === Infinity) {
+        const laps = Math.floor(playhead / duration);
+        offset -= laps * duration;
+        playhead -= laps * duration;
+        onWrap();
+      } else {
+        while (playhead >= duration && loopsLeft > 0) {
+          loopsLeft -= 1;
+          offset -= duration;
+          playhead -= duration;
+          onWrap();
+        }
+      }
+    }
+    const finished = playhead >= duration;
+    playhead = Math.min(playhead, duration);
+    applySampled(opts.tracks, playhead);
+    fireEvents(opts.tracks, prevPlayhead, playhead);
+    prevPlayhead = playhead;
+    if (finished && !done) {
+      done = true;
+      opts.onDone?.();
+    }
+    if (playhead < duration) return false;
+    live = false;
+    return true;
+  };
+  const onCancel = () => {
+    cancelled = true;
+    live = false;
+  };
+  const base = register({ id, cancelKey: opts.cancelKey, tick, onCancel });
+  if (opts.autoplay === false) base.pause();
+  const rearm = () => {
+    if (cancelled || playhead >= duration) return;
+    done = false;
+    if (live) return;
+    lastVirtual = 0;
+    offset = playhead;
+    live = true;
+    register({ id, cancelKey: opts.cancelKey, keepExisting: true, tick, onCancel });
+    if (wantPaused) base.pause();
+    base.setTimeScale(wantScale);
+  };
+  return {
+    ...base,
+    // Not just `onCancel`: cancelling a finished timeline never reaches the
+    // animator, and must still keep a later seek from reviving it.
+    cancel() {
+      onCancel();
+      base.cancel();
+    },
+    // Playback intent is tracked here, not read back from the entry: a revived
+    // one is a fresh registration, and defaults to running at scale 1.
+    pause() {
+      wantPaused = true;
+      base.pause();
+    },
+    resume() {
+      wantPaused = false;
+      base.resume();
+    },
+    setTimeScale(s) {
+      wantScale = s;
+      base.setTimeScale(s);
+    },
+    isPaused: () => live ? base.isPaused() : wantPaused,
+    seek(t) {
+      offset = t - lastVirtual;
+      playhead = t;
+      prevPlayhead = t;
+      rearm();
+    },
+    time: () => playhead,
+    duration: () => duration,
+    tracks: () => opts.tracks,
+    edit(fn) {
+      fn();
+      caches = /* @__PURE__ */ new WeakMap();
+      duration = tracksEnd(opts.tracks, opts.duration);
+      rearm();
+      for (const cb of subscribers2) {
+        try {
+          cb();
+        } catch (err) {
+          console.error("timeline: subscriber threw", err);
+        }
+      }
+    },
+    subscribe(cb) {
+      subscribers2.add(cb);
+      return () => {
+        subscribers2.delete(cb);
+      };
+    }
+  };
+}
+
 // src/animation/colorRegistry.ts
 var ColorOverrideRegistry = class {
   map = /* @__PURE__ */ new Map();
@@ -27276,7 +27762,7 @@ function useAnimator(opts = {}) {
       }
     };
     const register = (seed) => {
-      if (seed.cancelKey != null) cancelByKey(seed.cancelKey);
+      if (seed.cancelKey != null && !seed.keepExisting) cancelByKey(seed.cancelKey);
       const anim = seed;
       anim.paused = false;
       anim.timeScale = 1;
@@ -27515,6 +28001,7 @@ function useAnimator(opts = {}) {
         factory,
         staggerOpts
       )),
+      timeline: (o) => createTimeline(register, nextId.current++, o),
       colorOverrides: colorOverrides.current,
       onTick: (cb) => {
         tickSubscribers.current.add(cb);
@@ -27586,8 +28073,8 @@ function animateLifecycle(adapter, animator, opts) {
   const ms = opts.ms ?? 200;
   return {
     ...adapter,
-    insertNode(object) {
-      adapter.insertNode(object);
+    insertNode(object, index) {
+      adapter.insertNode(object, index);
       if (!opts.enterFrom) return;
       const final = adapter.getPose(object.id);
       const start = opts.enterFrom(final);
@@ -28050,6 +28537,101 @@ function hslToRgbUnit(h, s, l) {
   return hslToRgb(h, s, l);
 }
 
+// src/animation/rig/types.ts
+var IDENTITY_JOINT = {
+  x: 0,
+  y: 0,
+  rotation: 0,
+  scaleX: 1,
+  scaleY: 1
+};
+
+// src/animation/rig/blendPoses.ts
+var TAU = Math.PI * 2;
+function shortestDelta(a, b) {
+  let d = (b - a) % TAU;
+  if (d > Math.PI) d -= TAU;
+  if (d < -Math.PI) d += TAU;
+  return d;
+}
+var FIELDS = ["x", "y", "scaleX", "scaleY"];
+function blendPoses(poses, weights) {
+  if (poses.length !== weights.length) {
+    throw new Error("blendPoses: poses and weights must have the same length");
+  }
+  const total = weights.reduce((s, w) => s + w, 0);
+  if (total === 0) return {};
+  const norm = weights.map((w) => w / total);
+  const names = /* @__PURE__ */ new Set();
+  for (const p of poses) for (const k of Object.keys(p)) names.add(k);
+  const out = {};
+  for (const name of names) {
+    const joint = {};
+    for (const field of FIELDS) {
+      let acc = 0;
+      for (let i = 0; i < poses.length; i += 1) {
+        const v = poses[i][name]?.[field];
+        acc += (v ?? IDENTITY_JOINT[field]) * norm[i];
+      }
+      joint[field] = acc;
+    }
+    const base = poses[0][name]?.rotation ?? 0;
+    let rot = 0;
+    for (let i = 0; i < poses.length; i += 1) {
+      const v = poses[i][name]?.rotation ?? 0;
+      rot += shortestDelta(base, v) * norm[i];
+    }
+    joint.rotation = base + rot;
+    out[name] = joint;
+  }
+  return out;
+}
+
+// src/animation/rig/resolveSkeleton.ts
+function compose(bind, delta3) {
+  if (!delta3) return bind;
+  return {
+    x: bind.x + (delta3.x ?? 0),
+    y: bind.y + (delta3.y ?? 0),
+    rotation: bind.rotation + (delta3.rotation ?? 0),
+    scaleX: bind.scaleX * (delta3.scaleX ?? 1),
+    scaleY: bind.scaleY * (delta3.scaleY ?? 1)
+  };
+}
+function toMat3(t) {
+  const c = Math.cos(t.rotation);
+  const s = Math.sin(t.rotation);
+  const m = new Float32Array(9);
+  m[0] = c * t.scaleX;
+  m[1] = s * t.scaleX;
+  m[2] = 0;
+  m[3] = -s * t.scaleY;
+  m[4] = c * t.scaleY;
+  m[5] = 0;
+  m[6] = t.x;
+  m[7] = t.y;
+  m[8] = 1;
+  return m;
+}
+function resolveSkeleton(skeleton, pose) {
+  const out = /* @__PURE__ */ new Map();
+  for (const joint of skeleton.joints) {
+    const local = toMat3(compose(joint.bind, pose[joint.name]));
+    if (joint.parent == null) {
+      out.set(joint.name, local);
+      continue;
+    }
+    const parent = out.get(joint.parent);
+    if (!parent) {
+      throw new Error(
+        `resolveSkeleton: joint "${joint.name}" names parent "${joint.parent}", which has not been resolved. Skeleton.joints must be in topological order.`
+      );
+    }
+    out.set(joint.name, mat3.multiply(parent, local));
+  }
+  return out;
+}
+
 // src/layout/snaps.ts
 function dist22(a, b) {
   const dx = a.x - b.x;
@@ -28338,6 +28920,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-SMCZRSYB.js.map
-//# sourceMappingURL=chunk-SMCZRSYB.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_JOINT, 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, blendPoses, 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, resolveSkeleton, resolveTextStyle, resolveVisibility, rgbaToHex, rotateAction, rotateAroundAABBCenter, rotatePathAround, rotatePoint, rotatedRectCorners, rotationDegreesUnit, rotationHandle, roundToCell, runsToDom, runsToMarkdown, runsToPlainText, sampleGradientStops, sampleTrack, 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-3B4QEB2G.js.map
+//# sourceMappingURL=chunk-3B4QEB2G.js.map