@weasel-js/labkit 1.0.2 → 1.0.4

package/dist/{chunk-3P56ZCCJ.js → chunk-DWV7SFKR.js}

@@ -3,7 +3,7 @@ import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 import earcut from 'earcut';
 import polygonClipping from 'polygon-clipping';
 
-// ../core/dist/chunk-W2WB4352.js
+// ../core/dist/chunk-J3YC3GVF.js
 
 // ../gestures/dist/index.js
 var GESTURE_DESCRIPTORS = [
@@ -60,9 +60,8 @@ function formatRoute(r) {
   const desc = getGestureDescriptor(r.gesture);
   const phaseStr = `[${r.phases.map(formatPhaseAtom).join(",")}]`;
   let out = `${phaseStr} ${r.gesture}`;
-  if (desc.arg) {
-    const isDefault = r.arg === void 0 || desc.arg.default !== void 0 && r.arg === desc.arg.default;
-    if (!isDefault) out += `(${r.arg})`;
+  if (desc.arg && r.arg !== void 0 && r.arg !== (desc.arg.default ?? "*")) {
+    out += `(${r.arg})`;
   }
   if (desc.hasTarget && r.target !== void 0 && r.target !== "*") {
     out += ` => ${r.target}`;
@@ -288,7 +287,7 @@ function matchSpec(e, spec, isMac, phaseCtx) {
 }
 var EMPTY_ENGAGED = /* @__PURE__ */ new Set();
 
-// ../core/dist/chunk-W2WB4352.js
+// ../core/dist/chunk-J3YC3GVF.js
 var DepRegistryContext = createContext(null);
 function DepRegistryProvider({ children }) {
   const sourcesRef = useRef(/* @__PURE__ */ new Map());
@@ -520,7 +519,8 @@ function ActionsProvider({ children }) {
         const disp = dispatcherRef.current;
         if (!disp) return null;
         const r = wiredDepRegRef.current ?? depRegRef.current;
-        const deps = r ? {
+        const a = actionsRef.current.get(id);
+        const deps = !r ? {} : a?.requires ? buildDepsFromRequires(a, r) : {
           selection: r.get("selection"),
           scene: r.get("scene"),
           history: r.get("history"),
@@ -528,7 +528,7 @@ function ActionsProvider({ children }) {
           pointer: r.get("pointer"),
           activeTool: r.get("activeTool"),
           booleansAdapter: r.get("booleansAdapter")
-        } : {};
+        };
         return disp.beginUiOngoing(id, deps, params);
       }
     };
@@ -699,7 +699,7 @@ function reportRouteConflicts(scopes, warn = (m) => console.warn(m)) {
   return conflicts;
 }
 
-// ../geom/dist/chunk-K5JJ6WRB.js
+// ../geom/dist/chunk-KU7FXMOA.js
 function cubicEvalAt(x0, y0, x1, y1, x2, y2, x3, y3, t) {
   const u = 1 - t;
   const a = u * u * u, b = 3 * u * u * t, c = 3 * u * t * t, d = t * t * t;
@@ -753,6 +753,12 @@ function cubicBounds(x0, y0, x1, y1, x2, y2, x3, y3) {
 }
 
 // ../geom/dist/index.js
+function dot(ax, ay, bx, by) {
+  return ax * bx + ay * by;
+}
+function len2(x, y) {
+  return x * x + y * y;
+}
 function sign(n) {
   return n > 0 ? 1 : n < 0 ? -1 : 0;
 }
@@ -804,6 +810,15 @@ function segmentsCross(ax, ay, bx, by, cx, cy, dx, dy) {
   const d4 = sign((bx - ax) * (dy - ay) - (by - ay) * (dx - ax));
   return d1 !== d2 && d3 !== d4;
 }
+function pointSegmentDist2(px, py, ax, ay, bx, by) {
+  const vx = bx - ax, vy = by - ay;
+  const wx = px - ax, wy = py - ay;
+  const vv = len2(vx, vy);
+  let t = vv === 0 ? 0 : dot(wx, wy, vx, vy) / vv;
+  t = t < 0 ? 0 : t > 1 ? 1 : t;
+  const dx = px - (ax + t * vx), dy = py - (ay + t * vy);
+  return len2(dx, dy);
+}
 function transformCoords(coords, m) {
   const out = new Float64Array(coords.length);
   const a = m[0], b = m[1], c = m[2], d = m[3], e = m[4], f = m[5];
@@ -815,7 +830,7 @@ function transformCoords(coords, m) {
   return out;
 }
 
-// ../core/dist/chunk-6SHZHXXR.js
+// ../core/dist/chunk-4Z6J4IVH.js
 function resolveUnit(v, unitSystem) {
   if (typeof v === "number") return v;
   if (!unitSystem) {
@@ -900,19 +915,36 @@ function boundsOfPath(path) {
   return { kind: "rect", x: minX, y: minY, width: maxX - minX, height: maxY - minY };
 }
 var DEFAULT_FLATTEN_TOLERANCE = 0.5;
+var MIN_FLATTEN_TOLERANCE = 1e-6;
+function usableTolerance(tolerance) {
+  return tolerance > 0 ? tolerance : MIN_FLATTEN_TOLERANCE;
+}
+function finite6(a, b, c, d, e, f) {
+  return Number.isFinite(a) && Number.isFinite(b) && Number.isFinite(c) && Number.isFinite(d) && Number.isFinite(e) && Number.isFinite(f);
+}
+function finite8(a, b, c, d, e, f, g, h) {
+  return finite6(a, b, c, d, e, f) && Number.isFinite(g) && Number.isFinite(h);
+}
 function distPointToLine(px, py, ax, ay, bx, by) {
   const dx = bx - ax;
   const dy = by - ay;
-  const len2 = dx * dx + dy * dy;
-  if (len2 === 0) {
+  const len22 = dx * dx + dy * dy;
+  if (len22 === 0) {
     const ex = px - ax;
     const ey = py - ay;
     return Math.sqrt(ex * ex + ey * ey);
   }
   const cross = (px - ax) * dy - (py - ay) * dx;
-  return Math.abs(cross) / Math.sqrt(len2);
+  return Math.abs(cross) / Math.sqrt(len22);
 }
 function flattenCubic2(x0, y0, x1, y1, x2, y2, x3, y3, tolerance, out) {
+  if (!finite8(x0, y0, x1, y1, x2, y2, x3, y3)) {
+    out.push(x3, y3);
+    return;
+  }
+  flattenCubicRec(x0, y0, x1, y1, x2, y2, x3, y3, usableTolerance(tolerance), out);
+}
+function flattenCubicRec(x0, y0, x1, y1, x2, y2, x3, y3, tolerance, out) {
   const d1 = distPointToLine(x1, y1, x0, y0, x3, y3);
   const d2 = distPointToLine(x2, y2, x0, y0, x3, y3);
   if (Math.max(d1, d2) <= tolerance) {
@@ -925,10 +957,17 @@ function flattenCubic2(x0, y0, x1, y1, x2, y2, x3, y3, tolerance, out) {
   const x012 = (x01 + x12) * 0.5, y012 = (y01 + y12) * 0.5;
   const x123 = (x12 + x23) * 0.5, y123 = (y12 + y23) * 0.5;
   const x0123 = (x012 + x123) * 0.5, y0123 = (y012 + y123) * 0.5;
-  flattenCubic2(x0, y0, x01, y01, x012, y012, x0123, y0123, tolerance, out);
-  flattenCubic2(x0123, y0123, x123, y123, x23, y23, x3, y3, tolerance, out);
+  flattenCubicRec(x0, y0, x01, y01, x012, y012, x0123, y0123, tolerance, out);
+  flattenCubicRec(x0123, y0123, x123, y123, x23, y23, x3, y3, tolerance, out);
 }
 function flattenQuadratic(x0, y0, x1, y1, x2, y2, tolerance, out) {
+  if (!finite6(x0, y0, x1, y1, x2, y2)) {
+    out.push(x2, y2);
+    return;
+  }
+  flattenQuadraticRec(x0, y0, x1, y1, x2, y2, usableTolerance(tolerance), out);
+}
+function flattenQuadraticRec(x0, y0, x1, y1, x2, y2, tolerance, out) {
   const d = distPointToLine(x1, y1, x0, y0, x2, y2);
   if (d <= tolerance) {
     out.push(x2, y2);
@@ -937,11 +976,16 @@ function flattenQuadratic(x0, y0, x1, y1, x2, y2, tolerance, out) {
   const x01 = (x0 + x1) * 0.5, y01 = (y0 + y1) * 0.5;
   const x12 = (x1 + x2) * 0.5, y12 = (y1 + y2) * 0.5;
   const x012 = (x01 + x12) * 0.5, y012 = (y01 + y12) * 0.5;
-  flattenQuadratic(x0, y0, x01, y01, x012, y012, tolerance, out);
-  flattenQuadratic(x012, y012, x12, y12, x2, y2, tolerance, out);
+  flattenQuadraticRec(x0, y0, x01, y01, x012, y012, tolerance, out);
+  flattenQuadraticRec(x012, y012, x12, y12, x2, y2, tolerance, out);
 }
 function flattenCubicWithArcLen(x0, y0, x1, y1, x2, y2, x3, y3, tolerance, out, arcOut) {
-  return flattenCubicArcRec(x0, y0, x1, y1, x2, y2, x3, y3, tolerance, out, arcOut, 0);
+  if (!finite8(x0, y0, x1, y1, x2, y2, x3, y3)) {
+    out.push(x3, y3);
+    arcOut.push(0);
+    return 0;
+  }
+  return flattenCubicArcRec(x0, y0, x1, y1, x2, y2, x3, y3, usableTolerance(tolerance), out, arcOut, 0);
 }
 function flattenCubicArcRec(x0, y0, x1, y1, x2, y2, x3, y3, tolerance, out, arcOut, accum) {
   const d1 = distPointToLine(x1, y1, x0, y0, x3, y3);
@@ -966,7 +1010,12 @@ function flattenCubicArcRec(x0, y0, x1, y1, x2, y2, x3, y3, tolerance, out, arcO
   return accum;
 }
 function flattenQuadraticWithArcLen(x0, y0, x1, y1, x2, y2, tolerance, out, arcOut) {
-  return flattenQuadraticArcRec(x0, y0, x1, y1, x2, y2, tolerance, out, arcOut, 0);
+  if (!finite6(x0, y0, x1, y1, x2, y2)) {
+    out.push(x2, y2);
+    arcOut.push(0);
+    return 0;
+  }
+  return flattenQuadraticArcRec(x0, y0, x1, y1, x2, y2, usableTolerance(tolerance), out, arcOut, 0);
 }
 function flattenQuadraticArcRec(x0, y0, x1, y1, x2, y2, tolerance, out, arcOut, accum) {
   const d = distPointToLine(x1, y1, x0, y0, x2, y2);
@@ -1159,22 +1208,6 @@ function polylineWithinThreshold(path, px, py, t2, tolerance) {
   if (subOpen && checkSegments(false)) return true;
   return false;
 }
-function pointSegmentDist2(px, py, ax, ay, bx, by) {
-  const dx = bx - ax;
-  const 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 + t * dx;
-  const cy = ay + t * dy;
-  const ex = px - cx, ey = py - cy;
-  return ex * ex + ey * ey;
-}
 var PathBuilder = class _PathBuilder {
   cmds = [];
   xs = [];
@@ -1563,7 +1596,7 @@ function createDeleteOp(args) {
 }
 registerOpFactory("delete", (args) => createDeleteOp(args));
 
-// ../core/dist/chunk-UB6A6L77.js
+// ../core/dist/chunk-CSMF654J.js
 function createTransformOp(args) {
   const { id, from, to, label, coalesceKey = `transform:${id}` } = args;
   return {
@@ -1644,7 +1677,7 @@ function snap(strategy, opts = {}) {
   };
 }
 
-// ../core/dist/chunk-Z3KNFTTS.js
+// ../core/dist/chunk-J7LUY47N.js
 function lockAspectWithModifier(opts = {}) {
   const { key = "shift" } = opts;
   return {
@@ -1840,7 +1873,7 @@ function materializePaste(adapter, snapshot, opts) {
   return { ops, newIds, created };
 }
 
-// ../core/dist/chunk-IO5Z75X4.js
+// ../core/dist/chunk-HGF5X6MZ.js
 var counter = 0;
 var registry = /* @__PURE__ */ new Map();
 function getTexture(id) {
@@ -1998,7 +2031,7 @@ function chunks(params) {
   return build({ tile: "chunks", ...params });
 }
 
-// ../font/dist/index.js
+// ../font/dist/chunk-3RSTZDXH.js
 var subscribers = /* @__PURE__ */ new Set();
 var generation = 0;
 function glyphGeneration() {
@@ -2642,6 +2675,8 @@ function warnOnce(key, message) {
   warned.add(key);
   console.warn(message);
 }
+
+// ../font/dist/index.js
 var TEXT_VERT_SRC = (
   /* glsl */
   `#version 300 es
@@ -2738,7 +2773,7 @@ var TEXT_SDF_UNIFORMS = [
 ];
 var TEXT_SDF_ATTRIBUTES = ["a_position", "a_uv", "a_baselineY"];
 
-// ../modes/dist/chunk-KILROWYB.js
+// ../modes/dist/chunk-YAJYQMBG.js
 var NORMAL = {
   allows: [
     "creates-selection",
@@ -2848,6 +2883,7 @@ function createHistory(adapter, options = {}) {
   const logger = options.debug ?? SILENT;
   let nextEntryId = 1;
   let version = 0;
+  let coalesceAnchorVersion = -1;
   const listeners = /* @__PURE__ */ new Set();
   function bump() {
     version++;
@@ -2888,6 +2924,7 @@ function createHistory(adapter, options = {}) {
   }
   function canCoalesce(top, incoming) {
     if (coalesceWindowMs <= 0) return false;
+    if (version !== coalesceAnchorVersion) return false;
     if (now() - top.timestamp > coalesceWindowMs) return false;
     if (top.forwardOps.length === 0 || incoming.length === 0) return false;
     if (top.forwardOps.length !== incoming.length) return false;
@@ -2925,9 +2962,9 @@ function createHistory(adapter, options = {}) {
         for (const id of incoming) merged.add(id);
         top.touchedIds = merged;
       }
-      dropRedo();
       logger.log(`coalesce '${label}' into entry id=${top.id} (${ops.length} ops)`);
       bump();
+      coalesceAnchorVersion = version;
       return;
     }
     logger.log(`push '${label}' (${ops.length} ops)`);
@@ -2935,6 +2972,7 @@ function createHistory(adapter, options = {}) {
     dropRedo();
     enforceLimit();
     bump();
+    coalesceAnchorVersion = version;
   }
   return {
     apply(op, label) {
@@ -3040,7 +3078,11 @@ function createHistory(adapter, options = {}) {
       return j;
     },
     resumeJournal(journal) {
+      if (activeJournal !== null && activeJournal !== journal && activeJournal.isActive()) {
+        throw new Error("A journal is already active \u2014 commit, cancel, or suspend it first");
+      }
       _resumeJournalInternal(journal);
+      activeJournal = journal;
     },
     restore(snapshot) {
       undoStack.length = 0;
@@ -3121,9 +3163,8 @@ function serialToEntry(se, custom, logger) {
     label: se.label,
     forwardOps,
     baseOps,
-    // Restored entries inherit a "now" timestamp — coalesce eligibility is
-    // a within-session concept and a restored entry shouldn't merge with a
-    // freshly-typed one regardless of when it was originally pushed.
+    // Coalescing is a within-session concept; a restored entry is never a
+    // coalesce anchor, so its timestamp only has to be non-null.
     timestamp: 0,
     // Re-derive touchedIds from the rebuilt ops rather than trying to
     // round-trip the Set through the serialized form (Sets aren't JSON-safe).
@@ -3131,7 +3172,7 @@ function serialToEntry(se, custom, logger) {
   };
 }
 
-// ../core/dist/chunk-PI56ORHE.js
+// ../core/dist/chunk-AYGSXNY3.js
 function worldToScreen(worldX, worldY, view) {
   return [view.panX + worldX * view.zoom.x, view.panY + worldY * view.zoom.y];
 }
@@ -3568,13 +3609,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 cached2 = this.map.get(id);
+    if (cached2) {
+      if (this.wraps.get(id) !== wrap) this.applyWrap(id, cached2, wrap);
+      return id;
+    }
     const gl = this.gl;
     const tex = gl.createTexture();
     if (!tex) throw new Error(`GLTextureCache: createTexture failed for id="${id}"`);
@@ -3587,8 +3635,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. */
@@ -3607,6 +3665,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) {
@@ -3638,6 +3697,7 @@ var GLTextureCache = class {
       gl.deleteTexture(tex);
     }
     this.map.clear();
+    this.wraps.clear();
   }
 };
 var GLImageCache = class {
@@ -4287,6 +4347,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");
@@ -4934,16 +5001,28 @@ function verticalAlignOffset(align, boxHeight, textHeight) {
   return align === "center" ? slack / 2 : slack;
 }
 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++;
@@ -4961,6 +5040,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,
@@ -5151,9 +5254,9 @@ function arcToCubics(x1, y1, x2, y2, rx, ry, xAxisRotationDeg, largeArc, sweep,
   const cx = cosPhi * cxp - sinPhi * cyp + (x1 + x2) / 2;
   const cy = sinPhi * cxp + cosPhi * cyp + (y1 + y2) / 2;
   const angle = (ux, uy, vx, vy) => {
-    const dot = ux * vx + uy * vy;
+    const dot2 = ux * vx + uy * vy;
     const len = Math.sqrt((ux * ux + uy * uy) * (vx * vx + vy * vy));
-    let a = Math.acos(Math.max(-1, Math.min(1, dot / len)));
+    let a = Math.acos(Math.max(-1, Math.min(1, dot2 / len)));
     if (ux * vy - uy * vx < 0) a = -a;
     return a;
   };
@@ -5865,42 +5968,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;
@@ -5970,6 +6073,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];
@@ -5990,67 +6094,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);
   }
 };
 var FRAME_UPLOADS = /* @__PURE__ */ new WeakMap();
@@ -6073,6 +6219,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);
@@ -6365,8 +6530,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);
@@ -6431,10 +6596,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";
@@ -6480,7 +6644,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);
@@ -6504,7 +6668,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);
@@ -6654,6 +6818,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);
@@ -6769,7 +6934,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);
   }
@@ -6887,8 +7052,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);
@@ -6972,7 +7137,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);
@@ -6988,70 +7153,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);
 }
 var CUSTOM_VERT_SRC = (
   /* glsl */
@@ -7263,6 +7456,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() {
@@ -7360,7 +7555,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()) {
@@ -7371,6 +7566,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();
   }
   /**
@@ -7386,6 +7582,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 = {
@@ -10955,7 +11152,7 @@ var reorderBackwardAction = {
     }
   ],
   eligible: { capability: "edits-page" },
-  requires: ["selection", "scene"],
+  requires: ["selection", "scene", "applyOps"],
   invoker: {
     timing: "immediate",
     run: (deps, params) => {
@@ -11095,6 +11292,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: {
@@ -11106,7 +11304,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");
@@ -11187,6 +11392,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",
@@ -11197,7 +11403,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");
@@ -11279,7 +11492,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;
@@ -11592,6 +11889,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: {
@@ -13884,10 +14182,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));
@@ -13897,7 +14196,10 @@ function createDispatcher(opts) {
         notify2();
       },
       end(reason) {
-        if (ended) return;
+        if (!live()) {
+          ended = true;
+          return;
+        }
         ended = true;
         if (handle.onEnd) {
           try {
@@ -15111,6 +15413,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,
@@ -15123,7 +15426,7 @@ function useTools(opts) {
       has,
       getActiveOverlays
     }),
-    [active, setActive, hotkeyEngaged, engageHotkey, disengageHotkey, has, getActiveOverlays]
+    [active, setActive, hotkeyEngaged, engageHotkey, disengageHotkey, has, getActiveOverlays, registryKey]
   );
 }
 var TOOL_ACTIVATE_ID = "tool.activate";
@@ -16514,8 +16817,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 {
@@ -17118,6 +17430,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;
@@ -18696,7 +19012,6 @@ function CanvasInner(props, ref) {
     shaders,
     previewIdsExtra,
     previewPoseExtra,
-    previewBoundsExtra,
     gestureSource,
     viewport,
     backgroundFill,
@@ -18722,6 +19037,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);
@@ -18744,7 +19060,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;
@@ -18899,8 +19215,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]);
@@ -18919,10 +19235,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);
@@ -18963,10 +19275,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);
@@ -19002,6 +19310,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) => {
@@ -19183,6 +19492,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;
@@ -20611,6 +20925,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 };
+}
 var DEFAULT_PICK_TOLERANCE_PX = 4;
 function useSceneSelectTool(args) {
   const { scene, selection, geometry, selectTool: opts, insertTool, layouts, getView } = args;
@@ -20708,7 +21105,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);
@@ -21592,8 +21991,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}`,
@@ -21848,80 +22249,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,
@@ -22693,6 +23020,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) {
@@ -22720,10 +23048,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]);
 }
@@ -24475,5 +24807,5 @@ function oklchToOklab(L, C, h) {
 }
 
 export { FALLBACK_FIT_VIEW, MinimapCanvas, SceneViewCanvas, UnknownIcon, buildSceneViewCommands, computeFitView2, computeIndicatorCommand, eligibleContribution, evaluateEnabled, oklabToSrgbU8, oklchToOklab, renderSceneToCanvas, rgbaToHex, useActionsRegistry, useOptionalDepRegistry };
-//# sourceMappingURL=chunk-3P56ZCCJ.js.map
-//# sourceMappingURL=chunk-3P56ZCCJ.js.map
+//# sourceMappingURL=chunk-DWV7SFKR.js.map
+//# sourceMappingURL=chunk-DWV7SFKR.js.map