@weasel-js/core 1.4.3 → 1.4.4

package/dist/{chunk-WYPSGIYS.js → chunk-R3AWPTLZ.js}

@@ -1,13 +1,13 @@
-import { ActionDisabledReason, useOptionalDepRegistry, DepRegistryProvider, useActionsRegistry, ActionsScope, ActionsProvider, useDepRegistry, reportRouteConflicts, buildDepsFromRequires, useDepSource, actionBindings } from './chunk-LEURURX3.js';
-import { scratchKey, createReparentOp, createTransformOp, snap, getScratch, setScratch } from './chunk-ORZNKVXM.js';
-import { fixedCornerOf, DEFAULT_RESIZE_BEHAVIORS, CORNER_ANCHORS, cornerPoint } from './chunk-BLJNRMKB.js';
-import { AUTO_POSE_DESCRIPTOR, remapRotatedLeaf, PATH_Z, PATH_Q, PATH_C, PATH_L, PATH_M, resolveUnit, polylineFromPoints, starPath, regularPolygonPath, linePath, ellipsePath, rectPath, polygonFromPoints, RECT_POSE_DESCRIPTOR, PathBuilder, pathPoseDescriptor, withinPxRadius, boundsOfPath, DEFAULT_FLATTEN_TOLERANCE, flattenQuadratic, flattenCubic, pointInPath, strokeHitTest, transformPath, translatePath, pxExtent, withinPxBox, flattenCubicWithArcLen, flattenQuadraticWithArcLen, PATH_CMD_LENGTHS, pointToGridCell } from './chunk-SBFC6J3C.js';
+import { ActionDisabledReason, useOptionalDepRegistry, DepRegistryProvider, useActionsRegistry, ActionsScope, ActionsProvider, useDepRegistry, reportRouteConflicts, buildDepsFromRequires, useDepSource, actionBindings } from './chunk-BL65SHCX.js';
+import { scratchKey, createReparentOp, createTransformOp, snap, getScratch, setScratch } from './chunk-2VXGHUVL.js';
+import { fixedCornerOf, DEFAULT_RESIZE_BEHAVIORS, CORNER_ANCHORS, cornerPoint } from './chunk-PRGBGMH3.js';
+import { AUTO_POSE_DESCRIPTOR, remapRotatedLeaf, PATH_Z, PATH_Q, PATH_C, PATH_L, PATH_M, resolveUnit, polylineFromPoints, starPath, regularPolygonPath, linePath, ellipsePath, rectPath, polygonFromPoints, RECT_POSE_DESCRIPTOR, PathBuilder, pathPoseDescriptor, withinPxRadius, boundsOfPath, DEFAULT_FLATTEN_TOLERANCE, flattenQuadratic, flattenCubic, pointInPath, strokeHitTest, transformPath, translatePath, pxExtent, withinPxBox, flattenCubicWithArcLen, flattenQuadraticWithArcLen, PATH_CMD_LENGTHS, pointToGridCell } from './chunk-WPM42WJP.js';
 import { dispatchApplyBatch, dlog, dwarn, usePointerContext, PointerContextProvider, extractWeaselClipboardFromSvg, parseWeaselClipboardText, materializePaste, WEASEL_CLIPBOARD_MIME, WEASEL_CLIPBOARD_MIME_WEB, sniffWeaselClipboardText, applyOpsTo } from './chunk-T3UQ3F6R.js';
 import { createSetSelectionOp } from './chunk-DOBSZOPR.js';
 import { registerOpFactory, createInsertOp, createDeleteOp, rebuildOp } from './chunk-4RJP2N2L.js';
 import { getTexture, chunks, dots, crosshatch, hatch } from './chunk-BJN5ZRIJ.js';
 import { createContext, createElement, forwardRef, useMemo, useRef, useCallback, useState, useEffect, useImperativeHandle, useSyncExternalStore, useLayoutEffect, useContext, useId, useReducer } from 'react';
-import { subscribeGlyphReady, DEFAULT_BAKE_BUDGET, TEXT_VERT_SRC, TEXT_FRAG_SRC, TEXT_SDF_UNIFORMS, TEXT_SDF_ATTRIBUTES, TEXT_FRAG_R8_SRC, markAllFontsNotUploaded, resetBakeBudget, syncDynamicPageTexture, ensureFontTexture, dynamicPageTextureId, textureCacheKey } from '@weasel-js/font';
+import { GLYPH_COVERAGE_GLSL, subscribeGlyphReady, DEFAULT_BAKE_BUDGET, markAllFontsNotUploaded, resetBakeBudget, syncDynamicPageTexture, ensureFontTexture, dynamicPageTextureId, textureCacheKey, GLYPH_MODE_R8, GLYPH_MODE_MSDF } 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 { resolveTextStyle, resolveAlign, resolveRuns, cachedLayoutRuns, verticalAlignOffset, runsToPlainText, toRuns, fontString, textLineBoxes } from '@weasel-js/text';
 export { DEFAULT_TEXT_STYLE, MARKDOWN_RUN_GRAMMAR, SCRIPT_METRICS, cachedLayoutRuns, createMarkdownRenderer, fontString, layoutMarkdown, layoutRuns, markdownToRuns, measureText, measureTextBounds, measuredWidth, resolveAlign, resolveRuns, resolveTextStyle, runsToMarkdown, runsToPlainText, textLineBoxes, toRuns, verticalAlignOffset } from '@weasel-js/text';
@@ -25,7 +25,7 @@ import { createHistory } from '@weasel-js/history';
 export * from '@weasel-js/history';
 
 // src/version.ts
-var VERSION = "1.4.3" ;
+var VERSION = "1.4.4" ;
 
 // src/features/grid/roundToCell.ts
 function roundToCell(value, cellSize) {
@@ -258,63 +258,135 @@ void main() {
 }
 `
 );
-var IMAGE_VOPACITY_VERT_SRC = (
+var IMAGE_FILL_UNIFORMS = [
+  "u_proj",
+  "u_model",
+  "u_sampler",
+  "u_opacity",
+  "u_alpha",
+  "u_colorMatrix",
+  "u_colorBias"
+];
+var IMAGE_FILL_ATTRIBUTES = ["a_position", "a_uv"];
+var BATCH_TEXTURE_SLOTS = 8;
+var WHITE_SLOT = 0;
+var PAINT_MODE_PLAIN = 0;
+var PAINT_MODE_RADIAL = 3;
+var PAINT_MODE_CONIC = 4;
+var INV_TAU = (1 / (2 * Math.PI)).toFixed(10);
+function packSlot(slot, mode) {
+  return slot + BATCH_TEXTURE_SLOTS * mode;
+}
+function sampleChain(slots) {
+  const arms = [];
+  for (let i = 1; i < slots; i++) {
+    arms.push(`  if (slot == ${i}) return texture(u_samplers[${i}], uv);`);
+  }
+  return arms.join("\n");
+}
+var BATCH_VERT_SRC = (
   /* glsl */
   `#version 300 es
 in vec2 a_position;
+in vec4 a_vertexColor;
 in vec2 a_uv;
-in float a_opacity;
+in float a_post;
+in float a_texSlot;
 uniform mat3 u_proj;
 uniform mat3 u_model;
+out vec4 v_vertexColor;
 out vec2 v_uv;
-out float v_opacity;
+out float v_post;
+flat out int v_texSlot;
+flat out float v_paintMode;
 void main() {
   vec3 screen = u_model * vec3(a_position, 1.0);
-  vec3 clip   = u_proj  * vec3(screen.xy, 1.0);
+  vec3 clip = u_proj * vec3(screen.xy, 1.0);
   gl_Position = vec4(clip.xy, 0.0, 1.0);
+  v_vertexColor = a_vertexColor;
   v_uv = a_uv;
-  v_opacity = a_opacity;
+  v_post = a_post;
+  // slot + 8 * mode, unpacked \u2014 see the file header for why they share a float.
+  int packed = int(a_texSlot + 0.5);
+  v_texSlot = packed % ${BATCH_TEXTURE_SLOTS};
+  v_paintMode = float(packed / ${BATCH_TEXTURE_SLOTS});
 }
 `
 );
-var IMAGE_VOPACITY_FRAG_SRC = (
+var BATCH_FRAG_SRC = (
   /* glsl */
   `#version 300 es
 precision highp float;
+in vec4 v_vertexColor;
 in vec2 v_uv;
-in float v_opacity;
-uniform sampler2D u_sampler;
+in float v_post;
+flat in int v_texSlot;
+flat in float v_paintMode;
+uniform sampler2D u_samplers[${BATCH_TEXTURE_SLOTS}];
+uniform vec4 u_color;
 uniform float u_alpha;
+uniform float u_synthBold;
 uniform mat4 u_colorMatrix;
 uniform vec4 u_colorBias;
 out vec4 outColor;
+
+vec4 sampleSlot(int slot, vec2 uv) {
+${sampleChain(BATCH_TEXTURE_SLOTS)}
+  return texture(u_samplers[0], uv);
+}
+${GLYPH_COVERAGE_GLSL}
 void main() {
-  vec4 texel = texture(u_sampler, v_uv);
-  vec4 mapped = clamp(u_colorMatrix * texel + u_colorBias, 0.0, 1.0);
-  float a = mapped.a * v_opacity * u_alpha;
+  float isGrad = step(2.5, v_paintMode);
+  // A radial or conic vertex carries a gradient-space coordinate rather than a
+  // texture coordinate, and its atlas row rather than an alpha. The sample is
+  // split across the branch rather than the coordinate selected before it: an
+  // arm that reads v_uv straight is a fetch the hardware can schedule against a
+  // varying, and one reading a coordinate the shader computed is not. Selecting
+  // the coordinate first and sampling once costs 65% of a fragment that is not
+  // a gradient; splitting it costs 5% (tests/perf/fill-rate.spec.ts).
+  //
+  // Branching at all is safe here where it would not be around the glyph math:
+  // v_paintMode is flat, so every fragment of a quad takes the same arm, and
+  // nothing in either arm is a derivative.
+  vec4 texel;
+  if (isGrad > 0.5) {
+    float t = v_paintMode > ${PAINT_MODE_CONIC - 0.5}
+      ? fract(atan(v_uv.y, v_uv.x) * ${INV_TAU})
+      : length(v_uv);
+    texel = sampleSlot(v_texSlot, vec2(t, v_post));
+  } else {
+    texel = sampleSlot(v_texSlot, v_uv);
+  }
+  float isGlyph = step(0.5, v_paintMode) * step(v_paintMode, 2.5);
+  // Unconditional, and multiplied out afterwards rather than branched around:
+  // see the file header.
+  float coverage = glyphCoverage(texel, v_paintMode, u_synthBold);
+  // A glyph's texel is a distance field, so it takes no part in the color; a
+  // plain vertex multiplies its texel in as it always did.
+  vec4 src = mix(texel, vec4(1.0), isGlyph) * u_color * v_vertexColor;
+  vec4 mapped = clamp(u_colorMatrix * src + u_colorBias, 0.0, 1.0);
+  float a = mapped.a * u_alpha * mix(v_post, 1.0, isGrad) * mix(1.0, coverage, isGlyph);
   outColor = vec4(mapped.rgb * a, a);
 }
 `
 );
-var IMAGE_FILL_UNIFORMS = [
+var BATCH_FILL_UNIFORMS = [
   "u_proj",
   "u_model",
-  "u_sampler",
-  "u_opacity",
+  "u_samplers",
+  "u_color",
   "u_alpha",
+  "u_synthBold",
   "u_colorMatrix",
   "u_colorBias"
 ];
-var IMAGE_FILL_ATTRIBUTES = ["a_position", "a_uv"];
-var IMAGE_VOPACITY_UNIFORMS = [
-  "u_proj",
-  "u_model",
-  "u_sampler",
-  "u_alpha",
-  "u_colorMatrix",
-  "u_colorBias"
+var BATCH_FILL_ATTRIBUTES = [
+  "a_position",
+  "a_vertexColor",
+  "a_uv",
+  "a_post",
+  "a_texSlot"
 ];
-var IMAGE_VOPACITY_ATTRIBUTES = ["a_position", "a_uv", "a_opacity"];
 
 // src/renderer/shaders/gradFill.ts
 var GRAD_VERT_SRC = (
@@ -340,7 +412,10 @@ var GRAD_FRAG_SRC = (
 precision highp float;
 in vec2 v_world;
 uniform sampler2D u_ramp;
+uniform float u_rampV;
 uniform float u_alpha;
+uniform mat4  u_colorMatrix;
+uniform vec4  u_colorBias;
 uniform float u_opacity;
 uniform int   u_gradKind;
 uniform vec2  u_gradP0;
@@ -364,9 +439,14 @@ void main() {
     t = fract(a / (2.0 * PI));
   }
   t = clamp(t, 0.0, 1.0);
-  vec4 rampColor = texture(u_ramp, vec2(t, 0.5));
-  float a = rampColor.a * u_opacity * u_alpha;
-  outColor = vec4(rampColor.rgb * a, a);
+  vec4 rampColor = texture(u_ramp, vec2(t, u_rampV));
+  // Fill opacity into the alpha channel before the matrix, which is where the
+  // batch program's vertex alpha sits \u2014 the two have to agree, since a linear
+  // gradient goes through that one and a radial through this.
+  vec4 src = vec4(rampColor.rgb, rampColor.a * u_opacity);
+  vec4 mapped = clamp(u_colorMatrix * src + u_colorBias, 0.0, 1.0);
+  float a = mapped.a * u_alpha;
+  outColor = vec4(mapped.rgb * a, a);
 }
 `
 );
@@ -375,8 +455,11 @@ var GRAD_FILL_UNIFORMS = [
   "u_model",
   "u_worldInv",
   "u_ramp",
+  "u_rampV",
   "u_alpha",
   "u_opacity",
+  "u_colorMatrix",
+  "u_colorBias",
   "u_gradKind",
   "u_gradP0",
   "u_gradDir",
@@ -684,6 +767,23 @@ var GLImageCache = class {
   gl;
   minification;
   map = /* @__PURE__ */ new WeakMap();
+  /**
+   * MAG_FILTER each texture currently carries, so a redundant write can be
+   * skipped.
+   *
+   * The batch sets this per flush — the same bitmap can be drawn at both
+   * filters in one frame, and the value has to be right at the draw rather than
+   * at upload. Filtering is state on the *texture object*, though, not on the
+   * unit, so re-asserting a value it already has is a write to a live texture
+   * for no reason. On a large sheet that is not free: a consumer's wall samples
+   * a 5652px-square atlas, 122MB resident, and measured `sampling: 'nearest'`
+   * costing up to 8x `'linear'` there — where the linear pass re-asserts the
+   * upload default and the nearest pass changes state on every draw.
+   *
+   * Whether that is the cause is unproven (see `docs/TODO.md`), but the write
+   * was redundant either way.
+   */
+  magFilters = /* @__PURE__ */ new WeakMap();
   upload(key, source, repetition) {
     const existing = this.map.get(key);
     if (existing) return existing;
@@ -698,6 +798,7 @@ var GLImageCache = class {
       this.minification === "mipmap" ? gl.LINEAR_MIPMAP_LINEAR : gl.LINEAR
     );
     gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+    this.magFilters.set(key, gl.LINEAR);
     const [wrapS, wrapT] = wrapModes(gl, repetition);
     gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, wrapS);
     gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, wrapT);
@@ -713,6 +814,14 @@ var GLImageCache = class {
     gl.activeTexture(gl.TEXTURE0 + unit2);
     gl.bindTexture(gl.TEXTURE_2D, tex);
   }
+  /** Set `key`'s MAG_FILTER, skipping the call when it already holds that
+   *  value. Its texture must be bound to the active unit — callers pair this
+   *  with `bind`. */
+  setMagFilter(key, filter) {
+    if (this.magFilters.get(key) === filter) return;
+    this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_MAG_FILTER, filter);
+    this.magFilters.set(key, filter);
+  }
 };
 function wrapModes(gl, rep) {
   switch (rep) {
@@ -1194,14 +1303,16 @@ function gradientForBounds(kind, bounds, stops, units) {
   return { fill: "conic-gradient", center, angle: 0, stops, units };
 }
 
-// src/renderer/cache/GradientRampCache.ts
-var RAMP_SIZE = 256;
+// src/renderer/cache/GradientRampAtlas.ts
+var RAMP_WIDTH = 256;
+var INITIAL_ROWS = 16;
+var RAMP_ATLAS_MAX_ROWS = 1024;
 function buildGradientRamp(stops) {
-  const data = new Uint8ClampedArray(RAMP_SIZE * 4);
+  const data = new Uint8ClampedArray(RAMP_WIDTH * 4);
   if (stops.length === 0) return data;
   const resolved = resolveGradientStops(stops);
-  for (let i = 0; i < RAMP_SIZE; i++) {
-    const [r, g, b, a] = sampleResolvedStops(resolved, i / (RAMP_SIZE - 1));
+  for (let i = 0; i < RAMP_WIDTH; i++) {
+    const [r, g, b, a] = sampleResolvedStops(resolved, i / (RAMP_WIDTH - 1));
     data[i * 4] = r * 255;
     data[i * 4 + 1] = g * 255;
     data[i * 4 + 2] = b * 255;
@@ -1209,51 +1320,76 @@ function buildGradientRamp(stops) {
   }
   return data;
 }
-var GradientRampCache = class {
+var GradientRampAtlas = class {
   constructor(gl) {
     this.gl = gl;
   }
   gl;
-  map = /* @__PURE__ */ new Map();
+  /** Row per stop list, in least-recently-used order: a hit re-inserts, so the
+   *  first entry is the row a full atlas recycles. */
+  rowByKey = /* @__PURE__ */ new Map();
+  texture = null;
+  rows = 0;
+  /** Mirror of the texture, so growth can respecify it without re-baking every
+   *  ramp it already holds. */
+  pixels = new Uint8ClampedArray(0);
   totalQueries = 0;
   cacheHits = 0;
+  /** Rows the atlas currently holds — its texture height. */
+  get height() {
+    return this.rows;
+  }
+  /**
+   * Bake `stops` into a row and return it, reusing the row an identical stop
+   * list already holds.
+   *
+   * **A returned row outlives the frame only while the atlas has room.** Past
+   * `RAMP_ATLAS_MAX_ROWS` an upload recycles the least recently used row, which
+   * rewrites texels a row handed out earlier still names. Nothing that defers
+   * its draw past this call may hold a row across another `upload` without
+   * arranging to be flushed first.
+   */
   upload(stops) {
     const key = JSON.stringify(stops);
     this.totalQueries++;
-    if (this.map.has(key)) {
+    const existing = this.rowByKey.get(key);
+    if (existing !== void 0) {
       this.cacheHits++;
-      return key;
+      this.rowByKey.delete(key);
+      this.rowByKey.set(key, existing);
+      return existing;
     }
-    const ramp = buildGradientRamp(stops);
-    const gl = this.gl;
-    const tex = gl.createTexture();
-    if (!tex) throw new Error("GradientRampCache: createTexture failed");
-    gl.bindTexture(gl.TEXTURE_2D, tex);
-    gl.texImage2D(
-      gl.TEXTURE_2D,
-      0,
-      gl.RGBA,
-      RAMP_SIZE,
-      1,
-      0,
-      gl.RGBA,
-      gl.UNSIGNED_BYTE,
-      ramp
-    );
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
-    gl.bindTexture(gl.TEXTURE_2D, null);
-    this.map.set(key, tex);
-    return key;
+    const row = this.claimRow();
+    this.writeRow(row, buildGradientRamp(stops));
+    this.rowByKey.set(key, row);
+    return row;
   }
-  bind(key, unit2) {
-    const tex = this.map.get(key);
-    if (!tex) throw new Error(`GradientRampCache: key "${key}" not uploaded`);
+  /**
+   * Whether uploading `stops` would move where existing rows sit — by growing
+   * the atlas, which changes every row's `v`, or by recycling one, which
+   * rewrites its texels.
+   *
+   * Anything holding a row past this call asks first and gets itself out of
+   * the way, because neither can be undone once it has happened.
+   */
+  wouldReshape(stops) {
+    if (this.rowByKey.size === 0) return false;
+    return !this.rowByKey.has(JSON.stringify(stops)) && this.rowByKey.size >= this.rows;
+  }
+  /**
+   * The `v` a row is sampled at — its center.
+   *
+   * The center is load-bearing: the atlas filters LINEAR, so a `v` anywhere
+   * else blends the ramp beside it into this one. At the center the neighbor's
+   * weight is exactly zero.
+   */
+  rowV(row) {
+    return (row + 0.5) / (this.rows || 1);
+  }
+  bind(unit2) {
     const gl = this.gl;
     gl.activeTexture(gl.TEXTURE0 + unit2);
-    gl.bindTexture(gl.TEXTURE_2D, tex);
+    gl.bindTexture(gl.TEXTURE_2D, this.texture);
   }
   hitRate() {
     if (this.totalQueries === 0) return 0;
@@ -1264,19 +1400,79 @@ var GradientRampCache = class {
     this.cacheHits = 0;
   }
   /**
-   * Delete every uploaded GL ramp texture and clear the map. Called by
-   * `WeaselRenderer.dispose()`. Only the GL textures are owned resources —
-   * `buildGradientRamp`'s CPU-side `Uint8ClampedArray` is transient per
-   * `upload()` call and already gone by the time a ramp is cached. The
-   * cache is unusable but refillable afterward (stats are left as-is; call
+   * Delete the atlas texture and forget every row in it. Called by
+   * `WeaselRenderer.dispose()`. The CPU mirror goes with it, so the atlas is
+   * unusable but refillable afterward (stats are left as-is; call
    * `resetStats()` separately if desired).
    */
   free() {
+    if (this.texture) this.gl.deleteTexture(this.texture);
+    this.texture = null;
+    this.rows = 0;
+    this.pixels = new Uint8ClampedArray(0);
+    this.rowByKey.clear();
+  }
+  /** The row the next ramp is written to: a free one, a taller atlas, or the
+   *  least recently used row of a full one. */
+  claimRow() {
+    if (this.rowByKey.size < this.rows) return this.rowByKey.size;
+    if (this.rows < RAMP_ATLAS_MAX_ROWS) {
+      this.resize(this.rows === 0 ? INITIAL_ROWS : this.rows * 2);
+      return this.rowByKey.size;
+    }
+    const [lruKey, lruRow] = this.rowByKey.entries().next().value;
+    this.rowByKey.delete(lruKey);
+    return lruRow;
+  }
+  /** Grow to `rows`, keeping every row at the index it already had — a row
+   *  index is a stable name, and callers hold them. */
+  resize(rows) {
     const gl = this.gl;
-    for (const tex of this.map.values()) {
-      gl.deleteTexture(tex);
+    const next = new Uint8ClampedArray(RAMP_WIDTH * rows * 4);
+    next.set(this.pixels);
+    this.pixels = next;
+    this.rows = rows;
+    if (!this.texture) {
+      const tex = gl.createTexture();
+      if (!tex) throw new Error("GradientRampAtlas: createTexture failed");
+      this.texture = tex;
+      gl.bindTexture(gl.TEXTURE_2D, tex);
+      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    } else {
+      gl.bindTexture(gl.TEXTURE_2D, this.texture);
     }
-    this.map.clear();
+    gl.texImage2D(
+      gl.TEXTURE_2D,
+      0,
+      gl.RGBA,
+      RAMP_WIDTH,
+      rows,
+      0,
+      gl.RGBA,
+      gl.UNSIGNED_BYTE,
+      this.pixels
+    );
+    gl.bindTexture(gl.TEXTURE_2D, null);
+  }
+  writeRow(row, ramp2) {
+    const gl = this.gl;
+    this.pixels.set(ramp2, row * RAMP_WIDTH * 4);
+    gl.bindTexture(gl.TEXTURE_2D, this.texture);
+    gl.texSubImage2D(
+      gl.TEXTURE_2D,
+      0,
+      0,
+      row,
+      RAMP_WIDTH,
+      1,
+      gl.RGBA,
+      gl.UNSIGNED_BYTE,
+      ramp2
+    );
+    gl.bindTexture(gl.TEXTURE_2D, null);
   }
 };
 
@@ -3076,47 +3272,78 @@ function strokeMesh(path, stroke, flattenTolerance) {
   return mesh;
 }
 
-// src/renderer/solidBatch.ts
+// src/renderer/drawBatch.ts
 var MAX_VERTICES_PER_BATCH = 32768;
-var FLOATS_PER_VERTEX = 6;
+var FLOATS_PER_VERTEX = 10;
 var INITIAL_VERTICES = 256;
 var INITIAL_INDICES = 384;
+var WHITE_U = 0.5;
+var WHITE_V = 0.5;
+var PLAIN_WHITE = packSlot(WHITE_SLOT, PAINT_MODE_PLAIN);
 var SOLID_RING_SIZE = 64;
-var SOLID_RING_SLOT_VERTICES = 1024;
-var SOLID_RING_SLOT_INDICES = 3072;
+var BATCH_TIERS = [
+  { vertices: 16, indices: 24 },
+  { vertices: 1024, indices: 3072 }
+];
+var SOLID_RING_SLOT_VERTICES = BATCH_TIERS[BATCH_TIERS.length - 1].vertices;
 var SOLID_LARGE_RING_SIZE = 4;
 function doubledTo(from, need) {
   let capacity = from;
   while (capacity < need) capacity *= 2;
   return capacity;
 }
-var SolidBatch = class {
+function quadIndices(quads) {
+  const out = new Uint32Array(quads * 6);
+  for (let q = 0; q < quads; q++) {
+    const b = q * 4;
+    const j = q * 6;
+    out[j] = b;
+    out[j + 1] = b + 1;
+    out[j + 2] = b + 2;
+    out[j + 3] = b;
+    out[j + 4] = b + 2;
+    out[j + 5] = b + 3;
+  }
+  return out;
+}
+var DrawBatch = class {
   gl;
   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. */
+  aUv;
+  aPost;
+  aSlot;
+  /** One ring per tier, cycled per flush. Slots are created on first use, so a
+   *  renderer that flushes rarely allocates as few as it flushes. */
+  rings = BATCH_TIERS.map(() => new Array(SOLID_RING_SIZE).fill(void 0));
+  nextInRing = BATCH_TIERS.map(() => 0);
+  /** The same, for flushes past the largest tier; 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;
-  /** 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. */
+  /** Whether the staged run is quads alone, so its indices are the canonical
+   *  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 aUv = prog.attribute("a_uv");
+    const aPost = prog.attribute("a_post");
+    const aSlot = prog.attribute("a_texSlot");
+    if (aPos === void 0 || aColor === void 0 || aUv === void 0 || aPost === void 0 || aSlot === void 0) {
+      throw new Error(
+        "DrawBatch: batch program is missing a_position / a_vertexColor / a_uv / a_post / a_texSlot"
+      );
     }
     this.gl = gl;
     this.aPos = aPos;
     this.aColor = aColor;
+    this.aUv = aUv;
+    this.aPost = aPost;
+    this.aSlot = aSlot;
   }
   get length() {
     return this.nIdx;
@@ -3132,7 +3359,6 @@ var SolidBatch = class {
    */
   pushRect(x, y, w, h, m, r, g, b, a) {
     this.reserve(4, 6);
-    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];
     const x1 = x + w;
@@ -3141,40 +3367,161 @@ var SolidBatch = class {
     const bx = ma * x1 + mc * y + mtx, by = mb * x1 + md * y + mty;
     const cx = ma * x1 + mc * y1 + mtx, cy = mb * x1 + md * y1 + mty;
     const dx = ma * x + mc * y1 + mtx, dy = mb * x + md * y1 + mty;
-    v[i++] = ax;
-    v[i++] = ay;
-    v[i++] = r;
-    v[i++] = g;
-    v[i++] = b;
-    v[i++] = a;
-    v[i++] = bx;
-    v[i++] = by;
-    v[i++] = r;
-    v[i++] = g;
-    v[i++] = b;
-    v[i++] = a;
-    v[i++] = cx;
-    v[i++] = cy;
-    v[i++] = r;
-    v[i++] = g;
-    v[i++] = b;
-    v[i++] = a;
-    v[i++] = dx;
-    v[i++] = dy;
-    v[i++] = r;
-    v[i++] = g;
-    v[i++] = b;
-    v[i++] = a;
+    const P = PLAIN_WHITE;
+    i = this.writeVertex(i, ax, ay, r, g, b, a, WHITE_U, WHITE_V, 1, P);
+    i = this.writeVertex(i, bx, by, r, g, b, a, WHITE_U, WHITE_V, 1, P);
+    i = this.writeVertex(i, cx, cy, r, g, b, a, WHITE_U, WHITE_V, 1, P);
+    this.writeVertex(i, dx, dy, r, g, b, a, WHITE_U, WHITE_V, 1, P);
+    this.pushQuadIndices();
+  }
+  /**
+   * Append one image quad: the destination rect `(x, y, w, h)` mapped through
+   * `m`, sampling `(u0, v0)`-`(u1, v1)`, every corner carrying `post` as the
+   * after-the-color-matrix alpha factor.
+   *
+   * Corners wind top-left, top-right, bottom-right, bottom-left with UVs
+   * following — the same winding `pushRect` uses, which is what lets a run of
+   * mixed rects and quads keep the canonical index pattern. The flips a command
+   * asks for are already in the `u` / `v` the caller passes.
+   *
+   * `slot` is the texture unit the corners sample, which `draw.ts` assigns per
+   * bitmap within the run.
+   */
+  pushQuad(x, y, w, h, m, u0, v0, u1, v1, post, slot) {
+    this.reserve(4, 6);
+    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];
+    const x1 = x + w;
+    const y1 = y + h;
+    const ax = ma * x + mc * y + mtx, ay = mb * x + md * y + mty;
+    const bx = ma * x1 + mc * y + mtx, by = mb * x1 + md * y + mty;
+    const cx = ma * x1 + mc * y1 + mtx, cy = mb * x1 + md * y1 + mty;
+    const dx = ma * x + mc * y1 + mtx, dy = mb * x + md * y1 + mty;
+    const P = packSlot(slot, PAINT_MODE_PLAIN);
+    i = this.writeVertex(i, ax, ay, 1, 1, 1, 1, u0, v0, post, P);
+    i = this.writeVertex(i, bx, by, 1, 1, 1, 1, u1, v0, post, P);
+    i = this.writeVertex(i, cx, cy, 1, 1, 1, 1, u1, v1, post, P);
+    this.writeVertex(i, dx, dy, 1, 1, 1, 1, u0, v1, post, P);
+    this.pushQuadIndices();
+  }
+  /**
+   * Append one glyph quad: the box `(x0, y0)`-`(x1, y1)` mapped through `m`,
+   * sampling `(u0, v0)`-`(u1, v1)` of the font atlas at `slot`, painted in
+   * `rgba`.
+   *
+   * `mode` says which channels of that atlas carry the distance field, and
+   * rides the vertices packed into the slot — so a run off a baked MSDF atlas
+   * and one off the runtime canvas bake still share a draw. The synthetic-bold
+   * threshold does not: it is `u_synthBold`, and `draw.ts` breaks the run when
+   * it changes.
+   *
+   * **A synthetic oblique is sheared here rather than in the shader.** The old
+   * text program carried the baseline per vertex and skewed against
+   * `u_synthItalic`; the batch places its own corners, so the shear is one
+   * multiply while they are being placed, and `tanItalic` is 0 for an upright
+   * face. It has to happen before `m`, which is where the shader had it too.
+   *
+   * Corners wind top-left, top-right, bottom-right, bottom-left — `pushQuad`'s
+   * winding, which is what lets a run of mixed rects, image quads and glyphs
+   * keep the canonical index pattern.
+   */
+  pushGlyph(x0, y0, x1, y1, baselineY, tanItalic, m, u0, v0, u1, v1, r, g, b, a, slot, mode) {
+    this.reserve(4, 6);
+    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];
+    const topShift = (baselineY - y0) * tanItalic;
+    const botShift = (baselineY - y1) * tanItalic;
+    const tx0 = x0 + topShift, tx1 = x1 + topShift;
+    const bx0 = x0 + botShift, bx1 = x1 + botShift;
+    const ax = ma * tx0 + mc * y0 + mtx, ay = mb * tx0 + md * y0 + mty;
+    const bx = ma * tx1 + mc * y0 + mtx, by = mb * tx1 + md * y0 + mty;
+    const cx = ma * bx1 + mc * y1 + mtx, cy = mb * bx1 + md * y1 + mty;
+    const dx = ma * bx0 + mc * y1 + mtx, dy = mb * bx0 + md * y1 + mty;
+    const P = packSlot(slot, mode);
+    i = this.writeVertex(i, ax, ay, r, g, b, a, u0, v0, 1, P);
+    i = this.writeVertex(i, bx, by, r, g, b, a, u1, v0, 1, P);
+    i = this.writeVertex(i, cx, cy, r, g, b, a, u1, v1, 1, P);
+    this.writeVertex(i, dx, dy, r, g, b, a, u0, v1, 1, P);
+    this.pushQuadIndices();
+  }
+  /**
+   * Append one rect filled by a gradient: the corners of `(x, y, w, h)` mapped
+   * through `m`, sampling the ramp atlas at `slot`.
+   *
+   * `uv` gives each channel of `a_uv` as an affine function of the coordinates
+   * the corners arrive in, which is what lets a gradient ride the vertices at
+   * all: a linear one's ramp position is affine in position outright, and a
+   * radial or conic one's gradient-space *coordinate* is, even though the ramp
+   * position it yields is not. Either way the rasterizer's interpolation across
+   * a triangle is exact. `mode` says which of the two the fragment shader is
+   * looking at, and `post` carries the atlas row for the modes that read it —
+   * see `shaders/batchFill.ts`.
+   *
+   * Values outside 0..1 are the sampler's business; the atlas clamps to the
+   * edge texel, which is what the gradient shader's own `clamp` did.
+   */
+  pushGradientRect(x, y, w, h, m, uv, post, slot, mode, r, g, b, a) {
+    this.reserve(4, 6);
+    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];
+    const x1 = x + w;
+    const y1 = y + h;
+    const P = packSlot(slot, mode);
+    const corner = (cx, cy) => {
+      const at = i;
+      i = this.writeVertex(
+        at,
+        ma * cx + mc * cy + mtx,
+        mb * cx + md * cy + mty,
+        r,
+        g,
+        b,
+        a,
+        uv.ux * cx + uv.uy * cy + uv.u0,
+        uv.vx * cx + uv.vy * cy + uv.v0,
+        post,
+        P
+      );
+      return i;
+    };
+    corner(x, y);
+    corner(x1, y);
+    corner(x1, y1);
+    corner(x, y1);
+    this.pushQuadIndices();
+  }
+  /** `pushMesh` for a mesh filled by a gradient — see `pushGradientRect` for
+   *  what `uv`, `post` and `mode` carry. */
+  pushGradientMesh(mesh, m, uv, post, slot, mode, r, g, b, a) {
+    const src = mesh.vertices;
+    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];
+    const P = packSlot(slot, mode);
+    for (let k = 0; k < n; k++) {
+      const x = src[k * 2];
+      const y = src[k * 2 + 1];
+      v[i++] = ma * x + mc * y + mtx;
+      v[i++] = mb * x + md * y + mty;
+      v[i++] = r;
+      v[i++] = g;
+      v[i++] = b;
+      v[i++] = a;
+      v[i++] = uv.ux * x + uv.uy * y + uv.u0;
+      v[i++] = uv.vx * x + uv.vy * y + uv.v0;
+      v[i++] = post;
+      v[i++] = P;
+    }
     const base = this.nVerts;
+    const out = this.idx;
     let j = this.nIdx;
-    this.idx[j++] = base;
-    this.idx[j++] = base + 1;
-    this.idx[j++] = base + 2;
-    this.idx[j++] = base;
-    this.idx[j++] = base + 2;
-    this.idx[j++] = base + 3;
-    this.nVerts += 4;
-    this.nIdx += 6;
+    for (let k = 0; k < srcIdx.length; k++) out[j++] = base + srcIdx[k];
+    this.nVerts += n;
+    this.nIdx += srcIdx.length;
   }
   /**
    * Append a tessellated mesh through `m`, all vertices carrying `rgba`. The
@@ -3199,6 +3546,10 @@ var SolidBatch = class {
       v[i++] = g;
       v[i++] = b;
       v[i++] = a;
+      v[i++] = WHITE_U;
+      v[i++] = WHITE_V;
+      v[i++] = 1;
+      v[i++] = PLAIN_WHITE;
     }
     const base = this.nVerts;
     const out = this.idx;
@@ -3211,14 +3562,20 @@ var SolidBatch = class {
    *  Returns the index count for the caller's `drawElements`. */
   uploadAndBind() {
     const gl = this.gl;
-    const set = this.nVerts <= SOLID_RING_SLOT_VERTICES && this.nIdx <= SOLID_RING_SLOT_INDICES ? this.nextRingSlot() : this.nextLargeSlot();
+    const tier = BATCH_TIERS.findIndex(
+      (t) => this.nVerts <= t.vertices && this.nIdx <= t.indices
+    );
+    const set = tier < 0 ? this.nextLargeSlot() : this.nextRingSlot(tier);
     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);
-    const rects = this.pureRects ? this.nVerts >> 2 : -1;
-    if (rects < 0 || rects !== set.indexRects) {
+    if (!this.pureRects) {
       gl.bufferSubData(gl.ELEMENT_ARRAY_BUFFER, 0, this.idx, 0, this.nIdx);
-      set.indexRects = rects;
+      set.canonicalQuads = 0;
+    } else if (set.canonicalQuads < this.nVerts >> 2) {
+      const quads = Math.min(set.vertexCapacity >> 2, Math.floor(set.indexCapacity / 6));
+      gl.bufferSubData(gl.ELEMENT_ARRAY_BUFFER, 0, quadIndices(quads));
+      set.canonicalQuads = quads;
     }
     return this.nIdx;
   }
@@ -3228,12 +3585,39 @@ var SolidBatch = class {
     this.pureRects = true;
   }
   dispose() {
-    for (const set of [...this.ring, ...this.largeRing]) {
+    for (const set of [...this.rings.flat(), ...this.largeRing]) {
       if (set) this.deleteSet(set);
     }
-    this.ring.fill(void 0);
+    for (const ring of this.rings) ring.fill(void 0);
     this.largeRing.fill(void 0);
   }
+  writeVertex(i, x, y, r, g, b, a, u, v, post, packed) {
+    const out = this.verts;
+    out[i] = x;
+    out[i + 1] = y;
+    out[i + 2] = r;
+    out[i + 3] = g;
+    out[i + 4] = b;
+    out[i + 5] = a;
+    out[i + 6] = u;
+    out[i + 7] = v;
+    out[i + 8] = post;
+    out[i + 9] = packed;
+    return i + FLOATS_PER_VERTEX;
+  }
+  /** Two triangles over the four corners just written. */
+  pushQuadIndices() {
+    const base = this.nVerts;
+    let j = this.nIdx;
+    this.idx[j++] = base;
+    this.idx[j++] = base + 1;
+    this.idx[j++] = base + 2;
+    this.idx[j++] = base;
+    this.idx[j++] = base + 2;
+    this.idx[j++] = base + 3;
+    this.nVerts += 4;
+    this.nIdx += 6;
+  }
   /** Grow the CPU arrays so `vertices` / `indices` more fit. */
   reserve(vertices, indices) {
     const needVerts = (this.nVerts + vertices) * FLOATS_PER_VERTEX;
@@ -3249,13 +3633,14 @@ var SolidBatch = class {
       this.idx = grown;
     }
   }
-  nextRingSlot() {
-    const slot = this.next;
-    this.next = (slot + 1) % SOLID_RING_SIZE;
-    const existing = this.ring[slot];
+  nextRingSlot(tier) {
+    const ring = this.rings[tier];
+    const slot = this.nextInRing[tier];
+    this.nextInRing[tier] = (slot + 1) % ring.length;
+    const existing = ring[slot];
     if (existing) return existing;
-    const set = this.createSet(SOLID_RING_SLOT_VERTICES, SOLID_RING_SLOT_INDICES);
-    this.ring[slot] = set;
+    const set = this.createSet(BATCH_TIERS[tier].vertices, BATCH_TIERS[tier].indices);
+    ring[slot] = set;
     return set;
   }
   nextLargeSlot() {
@@ -3266,7 +3651,7 @@ var SolidBatch = class {
     if (!set) {
       set = this.createSet(
         doubledTo(SOLID_RING_SLOT_VERTICES, this.nVerts),
-        doubledTo(SOLID_RING_SLOT_INDICES, this.nIdx)
+        doubledTo(BATCH_TIERS[BATCH_TIERS.length - 1].indices, this.nIdx)
       );
       this.largeRing[slot] = set;
       return set;
@@ -3282,7 +3667,7 @@ var SolidBatch = class {
       gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, set.ibo);
       gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, set.indexCapacity * 4, gl.DYNAMIC_DRAW);
       gl.bindVertexArray(null);
-      set.indexRects = -1;
+      set.canonicalQuads = 0;
     }
     return set;
   }
@@ -3291,7 +3676,7 @@ var SolidBatch = class {
     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");
+    if (!vao || !vbo || !ibo) throw new Error("DrawBatch: failed to create GL objects");
     const stride = FLOATS_PER_VERTEX * 4;
     gl.bindVertexArray(vao);
     gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
@@ -3300,10 +3685,16 @@ var SolidBatch = class {
     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.enableVertexAttribArray(this.aUv);
+    gl.vertexAttribPointer(this.aUv, 2, gl.FLOAT, false, stride, 24);
+    gl.enableVertexAttribArray(this.aPost);
+    gl.vertexAttribPointer(this.aPost, 1, gl.FLOAT, false, stride, 32);
+    gl.enableVertexAttribArray(this.aSlot);
+    gl.vertexAttribPointer(this.aSlot, 1, gl.FLOAT, false, stride, 36);
     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 };
+    return { vao, vbo, ibo, vertexCapacity: vertices, indexCapacity: indices, canonicalQuads: 0 };
   }
   deleteSet(set) {
     const gl = this.gl;
@@ -3313,222 +3704,18 @@ var SolidBatch = class {
   }
 };
 
-// src/renderer/imageBatch.ts
-var MAX_IMAGE_VERTICES_PER_BATCH = 32768;
-var FLOATS_PER_VERTEX2 = 5;
-var INITIAL_QUADS = 64;
-var TIERS = [
-  { quads: 1, slots: 64 },
-  { quads: 16, slots: 64 },
-  { quads: 256, slots: 16 }
-];
-TIERS[0].slots;
-var IMAGE_LARGE_RING_SIZE = 4;
-function doubledTo2(from, need) {
-  let capacity = from;
-  while (capacity < need) capacity *= 2;
-  return capacity;
+// src/renderer/shaders/registerProgram.ts
+var registry = /* @__PURE__ */ new Map();
+function getProgramSource(id) {
+  return registry.get(id) ?? null;
 }
-function quadIndices(quads) {
-  const out = new Uint32Array(quads * 6);
-  for (let q = 0; q < quads; q++) {
-    const b = q * 4;
-    const j = q * 6;
-    out[j] = b;
-    out[j + 1] = b + 1;
-    out[j + 2] = b + 2;
-    out[j + 3] = b;
-    out[j + 4] = b + 2;
-    out[j + 5] = b + 3;
+var isDev = () => typeof process !== "undefined" ? process.env.NODE_ENV !== "production" : true;
+function registerProgram(id, vert, frag) {
+  if (registry.has(id) && !isDev()) {
+    throw new Error(`weasel registerProgram: duplicate program id "${id}". In production, re-registration is not allowed. Pass a unique id or call in dev mode.`);
   }
-  return out;
-}
-var ImageBatch = class {
-  gl;
-  aPos;
-  aUv;
-  aOpacity;
-  /** One ring per tier, cycled per flush. Slots are created on first use, so a
-   *  renderer that flushes rarely allocates as few as it flushes. */
-  rings = TIERS.map((t) => new Array(t.slots).fill(void 0));
-  nextInRing = TIERS.map(() => 0);
-  /** For flushes past the largest tier; these sets grow to fit. */
-  largeRing = new Array(IMAGE_LARGE_RING_SIZE).fill(void 0);
-  nextLarge = 0;
-  verts = new Float32Array(INITIAL_QUADS * 4 * FLOATS_PER_VERTEX2);
-  nQuads = 0;
-  constructor(gl, prog) {
-    const aPos = prog.attribute("a_position");
-    const aUv = prog.attribute("a_uv");
-    const aOpacity = prog.attribute("a_opacity");
-    if (aPos === void 0 || aUv === void 0 || aOpacity === void 0) {
-      throw new Error(
-        "ImageBatch: vertex-opacity program is missing a_position / a_uv / a_opacity"
-      );
-    }
-    this.gl = gl;
-    this.aPos = aPos;
-    this.aUv = aUv;
-    this.aOpacity = aOpacity;
-  }
-  /** Indices staged — what a caller passes to `drawElements`. */
-  get length() {
-    return this.nQuads * 6;
-  }
-  get quads() {
-    return this.nQuads;
-  }
-  /** Whether staging one more quad would put the run past the per-flush cap. */
-  wouldOverflow() {
-    return (this.nQuads + 1) * 4 > MAX_IMAGE_VERTICES_PER_BATCH;
-  }
-  /**
-   * Append one image quad: the destination rect `(x, y, w, h)` mapped through
-   * `m`, sampling `(u0, v0)`-`(u1, v1)`, every corner carrying `opacity`.
-   *
-   * An affine maps a rect to a parallelogram, so two triangles still cover it
-   * and the batch draws at `u_model` identity. Corners wind top-left,
-   * top-right, bottom-right, bottom-left, with UVs following — the flips a
-   * command asks for are already in the `u`/`v` the caller passes.
-   */
-  pushQuad(x, y, w, h, m, u0, v0, u1, v1, opacity) {
-    this.reserve();
-    const v = this.verts;
-    let i = this.nQuads * 4 * FLOATS_PER_VERTEX2;
-    const ma = m[0], mb = m[1], mc = m[3], md = m[4], mtx = m[6], mty = m[7];
-    const x1 = x + w;
-    const y1 = y + h;
-    const ax = ma * x + mc * y + mtx, ay = mb * x + md * y + mty;
-    const bx = ma * x1 + mc * y + mtx, by = mb * x1 + md * y + mty;
-    const cx = ma * x1 + mc * y1 + mtx, cy = mb * x1 + md * y1 + mty;
-    const dx = ma * x + mc * y1 + mtx, dy = mb * x + md * y1 + mty;
-    v[i++] = ax;
-    v[i++] = ay;
-    v[i++] = u0;
-    v[i++] = v0;
-    v[i++] = opacity;
-    v[i++] = bx;
-    v[i++] = by;
-    v[i++] = u1;
-    v[i++] = v0;
-    v[i++] = opacity;
-    v[i++] = cx;
-    v[i++] = cy;
-    v[i++] = u1;
-    v[i++] = v1;
-    v[i++] = opacity;
-    v[i++] = dx;
-    v[i++] = dy;
-    v[i++] = u0;
-    v[i++] = v1;
-    v[i++] = opacity;
-    this.nQuads += 1;
-  }
-  /** 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;
-    const tier = TIERS.findIndex((t) => this.nQuads <= t.quads);
-    const set = tier < 0 ? this.nextLargeSlot() : this.nextRingSlot(tier);
-    gl.bindVertexArray(set.vao);
-    gl.bindBuffer(gl.ARRAY_BUFFER, set.vbo);
-    gl.bufferSubData(gl.ARRAY_BUFFER, 0, this.verts, 0, this.nQuads * 4 * FLOATS_PER_VERTEX2);
-    return this.nQuads * 6;
-  }
-  reset() {
-    this.nQuads = 0;
-  }
-  dispose() {
-    for (const set of [...this.rings.flat(), ...this.largeRing]) {
-      if (set) this.deleteSet(set);
-    }
-    for (const ring of this.rings) ring.fill(void 0);
-    this.largeRing.fill(void 0);
-  }
-  /** Grow the CPU arrays so one more quad fits. */
-  reserve() {
-    const need = (this.nQuads + 1) * 4 * FLOATS_PER_VERTEX2;
-    if (need <= this.verts.length) return;
-    const grown = new Float32Array(doubledTo2(this.verts.length, need));
-    grown.set(this.verts);
-    this.verts = grown;
-  }
-  nextRingSlot(tier) {
-    const ring = this.rings[tier];
-    const slot = this.nextInRing[tier];
-    this.nextInRing[tier] = (slot + 1) % ring.length;
-    const existing = ring[slot];
-    if (existing) return existing;
-    const set = this.createSet(TIERS[tier].quads);
-    ring[slot] = set;
-    return set;
-  }
-  nextLargeSlot() {
-    const gl = this.gl;
-    const slot = this.nextLarge;
-    this.nextLarge = (slot + 1) % IMAGE_LARGE_RING_SIZE;
-    let set = this.largeRing[slot];
-    if (!set) {
-      set = this.createSet(doubledTo2(TIERS[TIERS.length - 1].quads, this.nQuads));
-      this.largeRing[slot] = set;
-      return set;
-    }
-    if (this.nQuads > set.quadCapacity) {
-      set.quadCapacity = doubledTo2(set.quadCapacity, this.nQuads);
-      gl.bindVertexArray(set.vao);
-      gl.bindBuffer(gl.ARRAY_BUFFER, set.vbo);
-      gl.bufferData(
-        gl.ARRAY_BUFFER,
-        set.quadCapacity * 4 * FLOATS_PER_VERTEX2 * 4,
-        gl.DYNAMIC_DRAW
-      );
-      gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, set.ibo);
-      gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, quadIndices(set.quadCapacity), gl.STATIC_DRAW);
-      gl.bindVertexArray(null);
-    }
-    return set;
-  }
-  createSet(quads) {
-    const gl = this.gl;
-    const vao = gl.createVertexArray();
-    const vbo = gl.createBuffer();
-    const ibo = gl.createBuffer();
-    if (!vao || !vbo || !ibo) throw new Error("ImageBatch: failed to create GL objects");
-    const stride = FLOATS_PER_VERTEX2 * 4;
-    gl.bindVertexArray(vao);
-    gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
-    gl.bufferData(gl.ARRAY_BUFFER, quads * 4 * stride, gl.DYNAMIC_DRAW);
-    gl.enableVertexAttribArray(this.aPos);
-    gl.vertexAttribPointer(this.aPos, 2, gl.FLOAT, false, stride, 0);
-    gl.enableVertexAttribArray(this.aUv);
-    gl.vertexAttribPointer(this.aUv, 2, gl.FLOAT, false, stride, 8);
-    gl.enableVertexAttribArray(this.aOpacity);
-    gl.vertexAttribPointer(this.aOpacity, 1, gl.FLOAT, false, stride, 16);
-    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ibo);
-    gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, quadIndices(quads), gl.STATIC_DRAW);
-    gl.bindVertexArray(null);
-    return { vao, vbo, ibo, quadCapacity: quads };
-  }
-  deleteSet(set) {
-    const gl = this.gl;
-    gl.deleteBuffer(set.vbo);
-    gl.deleteBuffer(set.ibo);
-    gl.deleteVertexArray(set.vao);
-  }
-};
-
-// src/renderer/shaders/registerProgram.ts
-var registry = /* @__PURE__ */ new Map();
-function getProgramSource(id) {
-  return registry.get(id) ?? null;
-}
-var isDev = () => typeof process !== "undefined" ? process.env.NODE_ENV !== "production" : true;
-function registerProgram(id, vert, frag) {
-  if (registry.has(id) && !isDev()) {
-    throw new Error(`weasel registerProgram: duplicate program id "${id}". In production, re-registration is not allowed. Pass a unique id or call in dev mode.`);
-  }
-  registry.set(id, { vert, frag });
-  return { id };
+  registry.set(id, { vert, frag });
+  return { id };
 }
 
 // src/renderer/effects/effectPrelude.ts
@@ -3668,14 +3855,13 @@ function dispatch(ctx, cmd) {
     case "path":
       return drawPath(ctx, cmd);
     case "text":
-      flushBatches(ctx);
       return drawText(ctx, cmd);
     case "image":
       return drawImage(ctx, cmd);
     case "sprites":
       return drawSprites(ctx, cmd);
     case "shader":
-      flushBatches(ctx);
+      flushBatch(ctx);
       return drawShader(ctx, cmd);
   }
 }
@@ -3792,7 +3978,7 @@ function drawShader(ctx, cmd) {
 }
 function drawGroupWithEffects(ctx, cmd, targets, width, height) {
   const gl = ctx.gl;
-  flushBatches(ctx);
+  flushBatch(ctx);
   const parentTarget = ctx.renderTarget ?? null;
   const parentClipDepth = ctx.clipDepth;
   const scissorWasOn = gl.isEnabled(gl.SCISSOR_TEST);
@@ -3806,7 +3992,7 @@ function drawGroupWithEffects(ctx, cmd, targets, width, height) {
   gl.stencilMask(255);
   gl.clear(gl.COLOR_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);
   for (const child of cmd.children) dispatch(ctx, child);
-  flushBatches(ctx);
+  flushBatch(ctx);
   gl.disable(gl.BLEND);
   for (const effect of cmd.effects) {
     const program = ctx.ensureProgram?.(effect.program.id) ?? null;
@@ -3934,12 +4120,14 @@ function drawPathFill(ctx, cmd) {
   const isSolid = fill.fill === void 0 || fill.fill === "solid";
   const hasVColors = !!(cmd.vertexColors && cmd.vertexColors.length > 0);
   const solid2 = fill;
-  if (isSolid && !hasVColors && cmd.path.kind === "rect") {
-    pushRect(ctx, cmd.path, solid2);
+  const paint = batchPaint(ctx, fill, hasVColors);
+  if (paint !== void 0 && cmd.path.kind === "rect") {
+    if (paint.kind === "ramp") pushRampRect(ctx, cmd.path, paint);
+    else pushRect(ctx, cmd.path, paint);
     return;
   }
   const mesh = fillMesh(ctx, cmd.path);
-  if (tryStageSolid(ctx, mesh, isSolid && !hasVColors ? solid2 : void 0)) return;
+  if (tryStageFill(ctx, mesh, paint)) return;
   const handle = meshHandle(ctx, mesh);
   if (isSolid && hasVColors) {
     drawPathFillVColor(ctx, cmd, solid2, handle);
@@ -3949,43 +4137,120 @@ function drawPathFill(ctx, cmd) {
     drawPathFillByKind(ctx, fill, handle);
   }
 }
+var SAMPLER_UNITS = new Int32Array(
+  Array.from({ length: BATCH_TEXTURE_SLOTS }, (_, i) => i)
+);
 function isIdentityColorMatrix(cm) {
   return cm === IDENTITY_COLOR_MATRIX || sameValues(IDENTITY_COLOR_MATRIX, cm);
 }
-function stagedStateIsLive(ctx, staged) {
+function stagedStateIsLive(ctx, staged, image, sampling, synthBold = 0) {
   if (staged.clipDepth !== ctx.clipDepth) return false;
+  if (staged.synthBold !== synthBold) return false;
   if (!staged.foldsAlpha && staged.alpha !== ctx.state.alpha) return false;
+  if (image !== void 0 && slotForBitmap(staged, image, sampling) < 0) return false;
   const colorMatrix = ctx.state.colorMatrix;
   return staged.colorMatrix === colorMatrix || sameValues(staged.colorMatrix, colorMatrix);
 }
+function slotForBitmap(staged, image, sampling) {
+  for (let i = 0; i < staged.textures.length; i++) {
+    const entry = staged.textures[i];
+    if (entry.kind !== "bitmap" || entry.image !== image) continue;
+    return entry.sampling === sampling ? i + 1 : -1;
+  }
+  return nextFreeSlot(staged);
+}
+function slotForRamps(staged) {
+  for (let i = 0; i < staged.textures.length; i++) {
+    if (staged.textures[i].kind === "ramps") return i + 1;
+  }
+  return nextFreeSlot(staged);
+}
+function slotForAtlas(staged, id) {
+  for (let i = 0; i < staged.textures.length; i++) {
+    const entry = staged.textures[i];
+    if (entry.kind === "atlas" && entry.id === id) return i + 1;
+  }
+  return nextFreeSlot(staged);
+}
+function nextFreeSlot(staged) {
+  return staged.textures.length + 1 < BATCH_TEXTURE_SLOTS ? staged.textures.length + 1 : -1;
+}
 var MAX_BATCHED_MESH_VERTICES = 256;
 function canBatchMesh(mesh) {
   return !mesh.requiresStencil && mesh.vertices.length >> 1 <= MAX_BATCHED_MESH_VERTICES;
 }
 function stageSolid(ctx, vertices) {
-  flushImages(ctx);
-  if (ctx.solidState !== void 0 && !stagedStateIsLive(ctx, ctx.solidState)) flushSolids(ctx);
-  if (ctx.solidBatch.wouldOverflow(vertices)) flushSolids(ctx);
-  if (ctx.solidState === void 0) {
+  if (ctx.batchState !== void 0 && !stagedStateIsLive(ctx, ctx.batchState)) flushBatch(ctx);
+  if (ctx.drawBatch.wouldOverflow(vertices)) flushBatch(ctx);
+  return openRun(ctx);
+}
+function openRun(ctx) {
+  if (ctx.batchState === void 0) {
     const colorMatrix = ctx.state.colorMatrix;
     const foldsAlpha = isIdentityColorMatrix(colorMatrix);
-    ctx.solidState = {
+    ctx.batchState = {
       alpha: foldsAlpha ? 1 : ctx.state.alpha,
       colorMatrix,
       clipDepth: ctx.clipDepth,
-      foldsAlpha
+      synthBold: 0,
+      foldsAlpha,
+      textures: []
     };
   }
-  return ctx.solidState;
+  return ctx.batchState;
+}
+function stageImage(ctx, image, sampling) {
+  if (ctx.batchState !== void 0 && !stagedStateIsLive(ctx, ctx.batchState, image, sampling)) {
+    flushBatch(ctx);
+  }
+  if (ctx.drawBatch.wouldOverflow(4)) flushBatch(ctx);
+  const staged = openRun(ctx);
+  let slot = slotForBitmap(staged, image, sampling);
+  if (slot > staged.textures.length) {
+    staged.textures.push({ kind: "bitmap", image, sampling });
+    slot = staged.textures.length;
+  }
+  return { staged, slot };
+}
+function stageGlyphs(ctx, atlasId, synthBold) {
+  if (ctx.batchState !== void 0 && (!stagedStateIsLive(ctx, ctx.batchState, void 0, void 0, synthBold) || slotForAtlas(ctx.batchState, atlasId) < 0)) {
+    flushBatch(ctx);
+  }
+  if (ctx.drawBatch.wouldOverflow(4)) flushBatch(ctx);
+  const staged = openRun(ctx);
+  staged.synthBold = synthBold;
+  let slot = slotForAtlas(staged, atlasId);
+  if (slot > staged.textures.length) {
+    staged.textures.push({ kind: "atlas", id: atlasId });
+    slot = staged.textures.length;
+  }
+  return { staged, slot };
+}
+function stageRamps(ctx, stops, vertices) {
+  if (ctx.gradRamps.wouldReshape(stops)) flushBatch(ctx);
+  if (ctx.batchState !== void 0 && (!stagedStateIsLive(ctx, ctx.batchState) || slotForRamps(ctx.batchState) < 0)) {
+    flushBatch(ctx);
+  }
+  if (ctx.drawBatch.wouldOverflow(vertices)) flushBatch(ctx);
+  const staged = openRun(ctx);
+  let slot = slotForRamps(staged);
+  if (slot > staged.textures.length) {
+    staged.textures.push({ kind: "ramps" });
+    slot = staged.textures.length;
+  }
+  return { staged, slot, rowV: ctx.gradRamps.rowV(ctx.gradRamps.upload(stops)) };
+}
+function stagedAlpha(ctx, staged, opacity) {
+  return (opacity ?? 1) * (staged.foldsAlpha ? ctx.state.alpha : 1);
 }
 function stagedColor(ctx, staged, paint) {
   const [r, g, b, a] = resolveColor(paint.color);
-  return [r, g, b, a * (paint.opacity ?? 1) * (staged.foldsAlpha ? ctx.state.alpha : 1)];
+  return [r, g, b, a * stagedAlpha(ctx, staged, paint.opacity)];
 }
 function pushRect(ctx, rect, fill) {
   const staged = stageSolid(ctx, 4);
   const [r, g, b, a] = stagedColor(ctx, staged, fill);
-  ctx.solidBatch.pushRect(
+  ctx.drawBatch.pushRect(
     rect.x,
     rect.y,
     rect.width,
@@ -4000,83 +4265,162 @@ function pushRect(ctx, rect, fill) {
 function pushMesh(ctx, mesh, paint) {
   const staged = stageSolid(ctx, mesh.vertices.length >> 1);
   const [r, g, b, a] = stagedColor(ctx, staged, paint);
-  ctx.solidBatch.pushMesh(mesh, ctx.state.transform, r, g, b, a);
+  ctx.drawBatch.pushMesh(mesh, ctx.state.transform, r, g, b, a);
+}
+function batchPaint(ctx, fill, hasVColors) {
+  if (hasVColors) return void 0;
+  const kind = fill.fill ?? "solid";
+  if (kind === "solid") {
+    const solid2 = fill;
+    return { kind: "solid", color: solid2.color, opacity: solid2.opacity };
+  }
+  if (kind === "linear-gradient") {
+    const grad = fill;
+    return ramp(grad, PAINT_MODE_PLAIN, linearRampUV(ctx, grad));
+  }
+  if (kind === "radial-gradient") {
+    const grad = fill;
+    return ramp(grad, PAINT_MODE_RADIAL, radialRampUV(ctx, grad));
+  }
+  if (kind === "conic-gradient") {
+    const grad = fill;
+    return ramp(grad, PAINT_MODE_CONIC, conicRampUV(ctx, grad));
+  }
+  return void 0;
 }
-function tryStageSolid(ctx, mesh, paint) {
+function ramp(fill, mode, uv) {
+  return { kind: "ramp", stops: fill.stops, opacity: fill.opacity, mode, uv };
+}
+function gradientMap(ctx, units) {
+  return mat3.multiply(gradientSpaceInverse(ctx, units), ctx.state.transform);
+}
+function linearRampUV(ctx, fill) {
+  const g = gradientMap(ctx, fill.units);
+  const dx = fill.to.x - fill.from.x;
+  const dy = fill.to.y - fill.from.y;
+  const len = Math.hypot(dx, dy) || 1;
+  const k = 1 / (len * len);
+  return {
+    ux: (g[0] * dx + g[1] * dy) * k,
+    uy: (g[3] * dx + g[4] * dy) * k,
+    u0: ((g[6] - fill.from.x) * dx + (g[7] - fill.from.y) * dy) * k,
+    vx: 0,
+    vy: 0,
+    v0: 0
+  };
+}
+function radialRampUV(ctx, fill) {
+  const g = gradientMap(ctx, fill.units);
+  const k = 1 / Math.max(fill.radius, 1e-4);
+  return {
+    ux: g[0] * k,
+    uy: g[3] * k,
+    u0: (g[6] - fill.center.x) * k,
+    vx: g[1] * k,
+    vy: g[4] * k,
+    v0: (g[7] - fill.center.y) * k
+  };
+}
+function conicRampUV(ctx, fill) {
+  const g = gradientMap(ctx, fill.units);
+  const cos = Math.cos(fill.angle);
+  const sin = Math.sin(fill.angle);
+  const dx0 = g[6] - fill.center.x;
+  const dy0 = g[7] - fill.center.y;
+  return {
+    ux: cos * g[0] + sin * g[1],
+    uy: cos * g[3] + sin * g[4],
+    u0: cos * dx0 + sin * dy0,
+    vx: cos * g[1] - sin * g[0],
+    vy: cos * g[4] - sin * g[3],
+    v0: cos * dy0 - sin * dx0
+  };
+}
+function rampVertices(paint, rowV) {
+  return paint.mode === PAINT_MODE_PLAIN ? { uv: { ...paint.uv, v0: rowV }, post: 1 } : { uv: paint.uv, post: rowV };
+}
+function pushRampRect(ctx, rect, paint) {
+  const { staged, slot, rowV } = stageRamps(ctx, paint.stops, 4);
+  const { uv, post } = rampVertices(paint, rowV);
+  ctx.drawBatch.pushGradientRect(
+    rect.x,
+    rect.y,
+    rect.width,
+    rect.height,
+    ctx.state.transform,
+    uv,
+    post,
+    slot,
+    paint.mode,
+    1,
+    1,
+    1,
+    stagedAlpha(ctx, staged, paint.opacity)
+  );
+}
+function pushRampMesh(ctx, mesh, paint) {
+  const { staged, slot, rowV } = stageRamps(ctx, paint.stops, mesh.vertices.length >> 1);
+  const { uv, post } = rampVertices(paint, rowV);
+  ctx.drawBatch.pushGradientMesh(
+    mesh,
+    ctx.state.transform,
+    uv,
+    post,
+    slot,
+    paint.mode,
+    1,
+    1,
+    1,
+    stagedAlpha(ctx, staged, paint.opacity)
+  );
+}
+function tryStageFill(ctx, mesh, paint) {
   if (paint !== void 0 && canBatchMesh(mesh)) {
-    pushMesh(ctx, mesh, paint);
+    if (paint.kind === "ramp") pushRampMesh(ctx, mesh, paint);
+    else pushMesh(ctx, mesh, paint);
     return true;
   }
-  flushBatches(ctx);
+  flushBatch(ctx);
   return false;
 }
-function flushSolids(ctx) {
-  const batch = ctx.solidBatch;
-  const staged = ctx.solidState;
+function flushBatch(ctx) {
+  const batch = ctx.drawBatch;
+  const staged = ctx.batchState;
   if (batch.length === 0 || staged === void 0) return;
   const gl = ctx.gl;
-  const prog = ctx.pathFillVColor;
+  const prog = ctx.batchFill;
   gl.useProgram(prog.handle);
   const indexCount = batch.uploadAndBind();
   setProjAndModel(ctx, prog, BATCH_MODEL);
   setColorUniform(ctx, prog, 1, 1, 1, 1);
   setAlphaUniform(ctx, prog, staged.alpha);
+  gl.uniform1f(prog.uniform("u_synthBold"), staged.synthBold);
   setColorMatrixUniforms(ctx, prog, staged.colorMatrix);
-  applyClipTest(ctx, staged.clipDepth);
-  gl.drawElements(gl.TRIANGLES, indexCount, gl.UNSIGNED_INT, 0);
-  gl.bindVertexArray(null);
-  batch.reset();
-  ctx.solidState = void 0;
-}
-function stagedImageStateIsLive(ctx, staged, image, sampling) {
-  if (staged.image !== image) return false;
-  if (staged.sampling !== sampling) return false;
-  if (staged.clipDepth !== ctx.clipDepth) return false;
-  const colorMatrix = ctx.state.colorMatrix;
-  return staged.colorMatrix === colorMatrix || sameValues(staged.colorMatrix, colorMatrix);
-}
-function stageImage(ctx, image, sampling) {
-  flushSolids(ctx);
-  if (ctx.imageState !== void 0 && !stagedImageStateIsLive(ctx, ctx.imageState, image, sampling)) {
-    flushImages(ctx);
-  }
-  if (ctx.imageBatch.wouldOverflow()) flushImages(ctx);
-  if (ctx.imageState === void 0) {
-    ctx.imageState = {
-      image,
-      sampling,
-      colorMatrix: ctx.state.colorMatrix,
-      clipDepth: ctx.clipDepth
-    };
+  gl.activeTexture(gl.TEXTURE0);
+  gl.bindTexture(gl.TEXTURE_2D, ctx.whiteTexture);
+  for (let i = 0; i < staged.textures.length; i++) {
+    const entry = staged.textures[i];
+    if (entry.kind === "atlas") {
+      ctx.textureCache.bind(entry.id, i + 1);
+      continue;
+    }
+    if (entry.kind === "ramps") {
+      ctx.gradRamps.bind(i + 1);
+      continue;
+    }
+    ctx.imageCache.bind(entry.image, i + 1);
+    ctx.imageCache.setMagFilter(
+      entry.image,
+      entry.sampling === "nearest" ? gl.NEAREST : gl.LINEAR
+    );
   }
-}
-function flushImages(ctx) {
-  const batch = ctx.imageBatch;
-  const staged = ctx.imageState;
-  if (batch.length === 0 || staged === void 0) return;
-  const gl = ctx.gl;
-  const prog = ctx.imageFillVOpacity;
-  gl.useProgram(prog.handle);
-  const indexCount = batch.uploadAndBind();
-  setProjAndModel(ctx, prog, BATCH_MODEL);
-  setAlphaUniform(ctx, prog, 1);
-  setColorMatrixUniforms(ctx, prog, staged.colorMatrix);
-  ctx.imageCache.bind(staged.image, 0);
-  gl.texParameteri(
-    gl.TEXTURE_2D,
-    gl.TEXTURE_MAG_FILTER,
-    staged.sampling === "nearest" ? gl.NEAREST : gl.LINEAR
-  );
-  gl.uniform1i(prog.uniform("u_sampler"), 0);
+  gl.uniform1iv(prog.uniform("u_samplers"), SAMPLER_UNITS);
   applyClipTest(ctx, staged.clipDepth);
   gl.drawElements(gl.TRIANGLES, indexCount, gl.UNSIGNED_INT, 0);
+  gl.activeTexture(gl.TEXTURE0);
   gl.bindVertexArray(null);
   batch.reset();
-  ctx.imageState = void 0;
-}
-function flushBatches(ctx) {
-  flushSolids(ctx);
-  flushImages(ctx);
+  ctx.batchState = void 0;
 }
 function expandAnchorColors(perAnchor, handle) {
   const aA = handle.anchorA;
@@ -4161,8 +4505,9 @@ function paintBindContext(ctx) {
     setProjAndModel: (prog) => setProjAndModel(ctx, prog),
     spaceInverse: (units) => gradientSpaceInverse(ctx, units),
     bindRamp: (stops, unit2) => {
-      const key = ctx.gradRampCache.upload(stops);
-      ctx.gradRampCache.bind(key, unit2);
+      const row = ctx.gradRamps.upload(stops);
+      ctx.gradRamps.bind(unit2);
+      return ctx.gradRamps.rowV(row);
     }
   };
   BIND_CONTEXTS.set(ctx, made);
@@ -4222,12 +4567,14 @@ function gradientSpaceInverse(ctx, units) {
 }
 function bindPathFillGradient(ctx, fill) {
   const gl = ctx.gl;
-  const key = ctx.gradRampCache.upload(fill.stops);
+  const row = ctx.gradRamps.upload(fill.stops);
   gl.useProgram(ctx.gradFill.handle);
   setProjAndModel(ctx, ctx.gradFill);
   gl.uniformMatrix3fv(ctx.gradFill.uniform("u_worldInv"), false, gradientSpaceInverse(ctx, fill.units));
-  ctx.gradRampCache.bind(key, 0);
+  setColorMatrixUniforms(ctx, ctx.gradFill);
+  ctx.gradRamps.bind(0);
   gl.uniform1i(ctx.gradFill.uniform("u_ramp"), 0);
+  gl.uniform1f(ctx.gradFill.uniform("u_rampV"), ctx.gradRamps.rowV(row));
   setAlphaUniform(ctx, ctx.gradFill, ctx.state.alpha);
   gl.uniform1f(ctx.gradFill.uniform("u_opacity"), fill.opacity ?? 1);
   if (fill.fill === "linear-gradient") {
@@ -4281,7 +4628,7 @@ function rasterizePathToStencil(ctx, path) {
   gl.bindVertexArray(null);
 }
 function pushClip(ctx, path, newDepth) {
-  flushBatches(ctx);
+  flushBatch(ctx);
   const gl = ctx.gl;
   const ancestors = ancestorMask(newDepth - 1);
   const newBit = 1 << newDepth;
@@ -4296,7 +4643,7 @@ function pushClip(ctx, path, newDepth) {
   gl.stencilMask(255);
 }
 function popClip(ctx, path, oldDepth) {
-  flushBatches(ctx);
+  flushBatch(ctx);
   const gl = ctx.gl;
   gl.enable(gl.STENCIL_TEST);
   const oldBit = 1 << oldDepth + 1;
@@ -4343,7 +4690,7 @@ function drawPathStroke(ctx, rawCmd) {
   const stroke = cmd.stroke;
   const align = stroke.align ?? "center";
   if (cmd.path.kind === "polygon" && align !== "center") {
-    flushBatches(ctx);
+    flushBatch(ctx);
     drawPathStrokeStenciled(ctx, cmd, align);
     return;
   }
@@ -4357,7 +4704,7 @@ function drawPathStrokeUnclipped(ctx, cmd) {
   const mesh = strokeMesh(cmd.path, stroke, ctx.flattenTolerance);
   if (mesh.indices.length === 0) return;
   const hasVColors = !!(stroke.vertexColors && stroke.vertexColors.length > 0);
-  if (tryStageSolid(ctx, mesh, isSolid && !hasVColors ? solid2 : void 0)) return;
+  if (tryStageFill(ctx, mesh, batchPaint(ctx, paint, hasVColors))) return;
   const handle = hasVColors ? ctx.meshCache.uploadTransient(mesh) : ctx.meshCache.uploadRecurring(mesh);
   if (!isSolid && !hasVColors) {
     drawPathFillByKind(ctx, paint, handle);
@@ -4492,28 +4839,9 @@ function drawText(ctx, cmd) {
   if (laid.groups.length === 0 && laid.decorations.length === 0) return;
   const dx = cmd.x;
   const dy = cmd.y + verticalAlignOffset(cmd.verticalAlign, cmd.height, laid.bounds.height);
-  const gl = ctx.gl;
-  applyClipTest(ctx);
-  const preparedPrograms = /* @__PURE__ */ new Set();
-  let currentProg = null;
   for (const group of laid.groups) {
-    if (group.source === "outline") {
-      drawTextOutlineGroup(ctx, group, dx, dy);
-      currentProg = null;
-      continue;
-    }
-    const prog = group.source === "canvas" ? ctx.textSdfR8 : ctx.textSdf;
-    if (prog !== currentProg) {
-      gl.useProgram(prog.handle);
-      currentProg = prog;
-    }
-    if (!preparedPrograms.has(prog)) {
-      preparedPrograms.add(prog);
-      setProjAndModel(ctx, prog);
-      setColorMatrixUniforms(ctx, prog);
-      setAlphaUniform(ctx, prog, ctx.state.alpha);
-    }
-    drawTextGroup(ctx, group, prog, dx, dy);
+    if (group.source === "outline") drawTextOutlineGroup(ctx, group, dx, dy);
+    else drawTextGroup(ctx, group, dx, dy);
   }
   drawTextDecorations(ctx, laid.decorations, dx, dy);
 }
@@ -4522,14 +4850,16 @@ function drawTextOutlineGroup(ctx, group, dx, dy) {
   const fill = group.fill;
   if (fill !== null) {
     const mesh = outlineGroupMesh(group, dx, dy);
-    if (mesh) drawPathFillByKind(ctx, fill, ctx.meshCache.uploadTransient(mesh));
+    if (mesh) drawOutlineMesh(ctx, fill, mesh);
   }
   const strokePaint = group.stroke?.paint;
   if (!strokePaint) return;
   const ribbon = outlineGroupStrokeMesh(group, dx, dy, mat3.meanScaleOf(ctx.state.transform));
-  if (ribbon) {
-    drawPathFillByKind(ctx, strokePaint, ctx.meshCache.uploadTransient(ribbon));
-  }
+  if (ribbon) drawOutlineMesh(ctx, strokePaint, ribbon);
+}
+function drawOutlineMesh(ctx, fill, mesh) {
+  if (tryStageFill(ctx, mesh, batchPaint(ctx, fill, false))) return;
+  drawPathFillByKind(ctx, fill, ctx.meshCache.uploadTransient(mesh));
 }
 function outlineGroupMesh(group, dx, dy) {
   return mergeGlyphMeshes(group, dx, dy, (glyph) => outlineMesh(glyph.key, glyph.d));
@@ -4573,208 +4903,69 @@ function mergeGlyphMeshes(group, dx, dy, meshFor) {
   return { vertices, indices };
 }
 function drawTextDecorations(ctx, decorations, dx, dy) {
-  if (decorations.length === 0) return;
-  const batches = /* @__PURE__ */ new Map();
   for (const d of decorations) {
-    const rgba = "color" in d.fill ? resolveColor(d.fill.color) : [0, 0, 0, 1];
-    const key = rgba.join(",");
-    let batch = batches.get(key);
-    if (!batch) {
-      batch = { rgba, rects: [] };
-      batches.set(key, batch);
-    }
-    batch.rects.push(d);
-  }
-  const gl = ctx.gl;
-  const prog = ctx.pathFill;
-  gl.useProgram(prog.handle);
-  setProjAndModel(ctx, prog);
-  setColorMatrixUniforms(ctx, prog);
-  applyClipTest(ctx);
-  for (const { rgba, rects } of batches.values()) {
-    const floats = rects.length * 4 * 2;
-    if (TEXT_RULE_VERTICES.length < floats) TEXT_RULE_VERTICES = new Float32Array(grownTo(floats));
-    const vertices = TEXT_RULE_VERTICES;
-    let vi = 0;
-    for (const d of rects) {
-      const dx0 = d.x0 + dx, dx1 = d.x1 + dx;
-      const dy0 = d.y0 + dy, dy1 = d.y1 + dy;
-      vertices[vi++] = dx0;
-      vertices[vi++] = dy0;
-      vertices[vi++] = dx1;
-      vertices[vi++] = dy0;
-      vertices[vi++] = dx0;
-      vertices[vi++] = dy1;
-      vertices[vi++] = dx1;
-      vertices[vi++] = dy1;
-    }
-    const ring = textQuadRing(gl, prog, TEXT_RULE_STRIDE, (loc) => {
-      const aPos = loc("a_position");
-      if (aPos !== void 0) {
-        gl.enableVertexAttribArray(aPos);
-        gl.vertexAttribPointer(aPos, 2, gl.FLOAT, false, TEXT_RULE_STRIDE, 0);
-      }
-    });
-    ensureQuadIndices(gl, ring, rects.length);
-    bindTextQuadSlot(gl, ring, vertices.subarray(0, floats));
-    setColorUniform(ctx, prog, rgba[0], rgba[1], rgba[2], rgba[3]);
-    setAlphaUniform(ctx, prog, ctx.state.alpha);
-    gl.drawElements(gl.TRIANGLES, rects.length * 6, gl.UNSIGNED_INT, 0);
-    gl.bindVertexArray(null);
+    const [r, g, b, a] = "color" in d.fill ? resolveColor(d.fill.color) : [0, 0, 0, 1];
+    const staged = stageSolid(ctx, 4);
+    ctx.drawBatch.pushRect(
+      d.x0 + dx,
+      d.y0 + dy,
+      d.x1 - d.x0,
+      d.y1 - d.y0,
+      ctx.state.transform,
+      r,
+      g,
+      b,
+      a * (staged.foldsAlpha ? ctx.state.alpha : 1)
+    );
   }
 }
-function drawTextGroup(ctx, group, prog, dx, dy) {
+var SYNTH_BOLD_AMOUNT = 0.08;
+function drawTextGroup(ctx, group, dx, dy) {
   if (group.source === "canvas") {
     if (!syncDynamicPageTexture(ctx.textureCache, group.page)) return;
   } else {
     if (!ensureFontTexture(group.family, group.weight, group.style, ctx.textureCache)) return;
   }
   if (group.quads.length === 0) return;
-  const gl = ctx.gl;
-  const floats = group.quads.length * 4 * 5;
-  if (TEXT_GROUP_VERTICES.length < floats) TEXT_GROUP_VERTICES = new Float32Array(grownTo(floats));
-  const vertices = TEXT_GROUP_VERTICES;
-  let vi = 0;
+  const atlasId = group.source === "canvas" ? dynamicPageTextureId(group.page) : textureCacheKey(group.family, group.weight, group.style);
+  const mode = group.source === "canvas" ? GLYPH_MODE_R8 : GLYPH_MODE_MSDF;
+  const bold = group.synthetic.bold ? SYNTH_BOLD_AMOUNT : 0;
+  const tanItalic = group.synthetic.italic ? Math.tan(SYNTHETIC_ITALIC_RADIANS) : 0;
+  const color = group.fill !== null && "color" in group.fill ? resolveColor(group.fill.color) : [0, 0, 0, 1];
+  const batch = ctx.drawBatch;
+  const m = ctx.state.transform;
+  let { staged, slot } = stageGlyphs(ctx, atlasId, bold);
+  let alpha = color[3] * (staged.foldsAlpha ? ctx.state.alpha : 1);
   for (const q of group.quads) {
-    const x0 = q.x0 + dx, x1 = q.x1 + dx;
-    const y0 = q.y0 + dy, y1 = q.y1 + dy, by = q.baselineY + dy;
-    vertices[vi++] = x0;
-    vertices[vi++] = y0;
-    vertices[vi++] = q.u0;
-    vertices[vi++] = q.v0;
-    vertices[vi++] = by;
-    vertices[vi++] = x1;
-    vertices[vi++] = y0;
-    vertices[vi++] = q.u1;
-    vertices[vi++] = q.v0;
-    vertices[vi++] = by;
-    vertices[vi++] = x0;
-    vertices[vi++] = y1;
-    vertices[vi++] = q.u0;
-    vertices[vi++] = q.v1;
-    vertices[vi++] = by;
-    vertices[vi++] = x1;
-    vertices[vi++] = y1;
-    vertices[vi++] = q.u1;
-    vertices[vi++] = q.v1;
-    vertices[vi++] = by;
-  }
-  const ring = textQuadRing(gl, prog, TEXT_GROUP_STRIDE, (loc) => {
-    const aPos = loc("a_position");
-    const aUv = loc("a_uv");
-    const aBase = loc("a_baselineY");
-    if (aPos !== void 0) {
-      gl.enableVertexAttribArray(aPos);
-      gl.vertexAttribPointer(aPos, 2, gl.FLOAT, false, TEXT_GROUP_STRIDE, 0);
-    }
-    if (aUv !== void 0) {
-      gl.enableVertexAttribArray(aUv);
-      gl.vertexAttribPointer(aUv, 2, gl.FLOAT, false, TEXT_GROUP_STRIDE, 8);
-    }
-    if (aBase !== void 0) {
-      gl.enableVertexAttribArray(aBase);
-      gl.vertexAttribPointer(aBase, 1, gl.FLOAT, false, TEXT_GROUP_STRIDE, 16);
-    }
-  });
-  ensureQuadIndices(gl, ring, group.quads.length);
-  bindTextQuadSlot(gl, ring, vertices.subarray(0, floats));
-  let r = 0, g = 0, b = 0, a = 1;
-  if (group.fill !== null && "color" in group.fill) {
-    [r, g, b, a] = resolveColor(group.fill.color);
-  }
-  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);
-  const synthItalicAmount = group.synthetic.italic ? SYNTHETIC_ITALIC_RADIANS : 0;
-  const uSynthItalic = prog.uniform("u_synthItalic");
-  if (uSynthItalic !== void 0) gl.uniform1f(uSynthItalic, synthItalicAmount);
-  const texId = group.source === "canvas" ? dynamicPageTextureId(group.page) : textureCacheKey(group.family, group.weight, group.style);
-  ctx.textureCache.bind(texId, 0);
-  gl.uniform1i(prog.uniform("u_atlas"), 0);
-  gl.drawElements(gl.TRIANGLES, group.quads.length * 6, gl.UNSIGNED_INT, 0);
-  gl.bindVertexArray(null);
-}
-var TEXT_QUAD_RING_SIZE = 64;
-var TEXT_QUAD_RINGS = /* @__PURE__ */ new WeakMap();
-function grownTo(need) {
-  let n = 256;
-  while (n < need) n *= 2;
-  return n;
-}
-function textQuadRing(gl, prog, stride, configureAttribs) {
-  const existing = TEXT_QUAD_RINGS.get(prog);
-  if (existing) return existing;
-  const ibo = gl.createBuffer();
-  if (!ibo) throw new Error("textQuadRing: createBuffer (IBO) returned null");
-  const slots = [];
-  for (let i = 0; i < TEXT_QUAD_RING_SIZE; i++) {
-    const vao = gl.createVertexArray();
-    const vbo = gl.createBuffer();
-    if (!vao) throw new Error("textQuadRing: createVertexArray returned null");
-    if (!vbo) throw new Error("textQuadRing: createBuffer returned null");
-    const bytes = grownTo(64 * 4 * stride);
-    gl.bindVertexArray(vao);
-    gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
-    gl.bufferData(gl.ARRAY_BUFFER, bytes, gl.DYNAMIC_DRAW);
-    configureAttribs((name) => prog.attribute(name));
-    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ibo);
-    gl.bindVertexArray(null);
-    slots.push({ vao, vbo, bytes });
-  }
-  const ring = { slots, ibo, quads: 0, next: 0 };
-  TEXT_QUAD_RINGS.set(prog, ring);
-  return ring;
-}
-var TEXT_QUAD_INDICES = new Uint32Array(0);
-var TEXT_GROUP_STRIDE = 20;
-var TEXT_RULE_STRIDE = 8;
-var TEXT_GROUP_VERTICES = new Float32Array(0);
-var TEXT_RULE_VERTICES = new Float32Array(0);
-function ensureQuadIndices(gl, ring, quads) {
-  if (quads <= ring.quads) return;
-  const grown = grownTo(quads);
-  if (TEXT_QUAD_INDICES.length < grown * 6) TEXT_QUAD_INDICES = new Uint32Array(grown * 6);
-  const idx = TEXT_QUAD_INDICES;
-  let ii = ring.quads * 6;
-  for (let q = ring.quads; q < grown; q++) {
-    const base = q * 4;
-    idx[ii++] = base;
-    idx[ii++] = base + 1;
-    idx[ii++] = base + 2;
-    idx[ii++] = base + 1;
-    idx[ii++] = base + 3;
-    idx[ii++] = base + 2;
-  }
-  gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ring.ibo);
-  gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, idx.subarray(0, grown * 6), gl.STATIC_DRAW);
-  ring.quads = grown;
-}
-function bindTextQuadSlot(gl, ring, vertices) {
-  const slot = ring.slots[ring.next];
-  ring.next = (ring.next + 1) % TEXT_QUAD_RING_SIZE;
-  gl.bindVertexArray(slot.vao);
-  gl.bindBuffer(gl.ARRAY_BUFFER, slot.vbo);
-  const bytes = vertices.byteLength;
-  if (bytes > slot.bytes) {
-    slot.bytes = grownTo(bytes);
-    gl.bufferData(gl.ARRAY_BUFFER, slot.bytes, gl.DYNAMIC_DRAW);
-  }
-  gl.bufferSubData(gl.ARRAY_BUFFER, 0, vertices);
-}
-function disposeTextQuads(gl, prog) {
-  const ring = TEXT_QUAD_RINGS.get(prog);
-  if (!ring) return;
-  for (const slot of ring.slots) {
-    gl.deleteVertexArray(slot.vao);
-    gl.deleteBuffer(slot.vbo);
-  }
-  gl.deleteBuffer(ring.ibo);
-  TEXT_QUAD_RINGS.delete(prog);
+    if (batch.wouldOverflow(4)) {
+      flushBatch(ctx);
+      ({ staged, slot } = stageGlyphs(ctx, atlasId, bold));
+      alpha = color[3] * (staged.foldsAlpha ? ctx.state.alpha : 1);
+    }
+    batch.pushGlyph(
+      q.x0 + dx,
+      q.y0 + dy,
+      q.x1 + dx,
+      q.y1 + dy,
+      q.baselineY + dy,
+      tanItalic,
+      m,
+      q.u0,
+      q.v0,
+      q.u1,
+      q.v1,
+      color[0],
+      color[1],
+      color[2],
+      alpha,
+      slot,
+      mode
+    );
+  }
 }
 function drawImage(ctx, cmd) {
   ctx.imageCache.upload(cmd.image, cmd.image);
-  stageImage(ctx, cmd.image, cmd.sampling ?? "linear");
+  const { staged, slot } = stageImage(ctx, cmd.image, cmd.sampling ?? "linear");
   const src = cmd.source;
   let u0 = 0, v0 = 0, u1 = 1, v1 = 1;
   if (src) {
@@ -4794,7 +4985,7 @@ function drawImage(ctx, cmd) {
     v0 = v1;
     v1 = t;
   }
-  ctx.imageBatch.pushQuad(
+  ctx.drawBatch.pushQuad(
     cmd.x,
     cmd.y,
     cmd.w,
@@ -4804,7 +4995,11 @@ function drawImage(ctx, cmd) {
     v0,
     u1,
     v1,
-    (cmd.opacity ?? 1) * ctx.state.alpha
+    // Group alpha rides the vertices only where it rode the solid colors too:
+    // with a real color matrix in the run it is `u_alpha`, and folding it here
+    // as well would apply it twice.
+    (cmd.opacity ?? 1) * (staged.foldsAlpha ? ctx.state.alpha : 1),
+    slot
   );
 }
 function drawSprites(ctx, cmd) {
@@ -4813,16 +5008,17 @@ function drawSprites(ctx, cmd) {
   if (count === 0) return;
   ctx.imageCache.upload(cmd.image, cmd.image);
   const sampling = cmd.sampling ?? "linear";
-  stageImage(ctx, cmd.image, sampling);
-  const batch = ctx.imageBatch;
+  let { staged, slot } = stageImage(ctx, cmd.image, sampling);
+  const batch = ctx.drawBatch;
   const m = ctx.state.transform;
-  const groupAlpha = ctx.state.alpha;
+  let groupAlpha = staged.foldsAlpha ? ctx.state.alpha : 1;
   const tw = cmd.image.width;
   const th = cmd.image.height;
   for (let s = 0, i = 0; s < count; s++, i += SPRITE_STRIDE) {
-    if (batch.wouldOverflow()) {
-      flushImages(ctx);
-      stageImage(ctx, cmd.image, sampling);
+    if (batch.wouldOverflow(4)) {
+      flushBatch(ctx);
+      ({ staged, slot } = stageImage(ctx, cmd.image, sampling));
+      groupAlpha = staged.foldsAlpha ? ctx.state.alpha : 1;
     }
     const sx = data[i + 4], sy = data[i + 5], sw = data[i + 6], sh = data[i + 7];
     batch.pushQuad(
@@ -4835,7 +5031,8 @@ function drawSprites(ctx, cmd) {
       sy / th,
       (sx + sw) / tw,
       (sy + sh) / th,
-      data[i + 8] * groupAlpha
+      data[i + 8] * groupAlpha,
+      slot
     );
   }
 }
@@ -4997,21 +5194,21 @@ var WeaselRenderer = class {
   gl;
   pathFill;
   pathFillVColor;
-  textSdf;
-  textSdfR8;
   imageFill;
-  imageFillVOpacity;
+  batchFill;
   gradFill;
   patternFill;
   meshCache;
   textureCache;
   imageCache;
-  gradRampCache;
+  gradRamps;
   programRegistry = /* @__PURE__ */ new Map();
   quadVbo = null;
   quadIbo = null;
-  solidBatch;
-  imageBatch;
+  drawBatch;
+  /** 1x1 white, so a batch flush sampling no image still samples something —
+   *  see `shaders/batchFill.ts`. */
+  whiteTexture = null;
   groupState = new GroupState();
   widthCss;
   heightCss;
@@ -5071,22 +5268,12 @@ var WeaselRenderer = class {
     this.pathFillVColor = new ShaderProgram(this.gl, VCOLOR_VERT_SRC, VCOLOR_FRAG_SRC);
     this.pathFillVColor.lookupUniforms(PATH_FILL_UNIFORMS);
     this.pathFillVColor.lookupAttributes(PATH_FILL_VCOLOR_ATTRIBUTES);
-    this.textSdf = new ShaderProgram(this.gl, TEXT_VERT_SRC, TEXT_FRAG_SRC);
-    this.textSdf.lookupUniforms(TEXT_SDF_UNIFORMS);
-    this.textSdf.lookupAttributes(TEXT_SDF_ATTRIBUTES);
-    this.textSdfR8 = new ShaderProgram(this.gl, TEXT_VERT_SRC, TEXT_FRAG_R8_SRC);
-    this.textSdfR8.lookupUniforms(TEXT_SDF_UNIFORMS);
-    this.textSdfR8.lookupAttributes(TEXT_SDF_ATTRIBUTES);
     this.imageFill = new ShaderProgram(this.gl, IMAGE_VERT_SRC, IMAGE_FRAG_SRC);
     this.imageFill.lookupUniforms(IMAGE_FILL_UNIFORMS);
     this.imageFill.lookupAttributes(IMAGE_FILL_ATTRIBUTES);
-    this.imageFillVOpacity = new ShaderProgram(
-      this.gl,
-      IMAGE_VOPACITY_VERT_SRC,
-      IMAGE_VOPACITY_FRAG_SRC
-    );
-    this.imageFillVOpacity.lookupUniforms(IMAGE_VOPACITY_UNIFORMS);
-    this.imageFillVOpacity.lookupAttributes(IMAGE_VOPACITY_ATTRIBUTES);
+    this.batchFill = new ShaderProgram(this.gl, BATCH_VERT_SRC, BATCH_FRAG_SRC);
+    this.batchFill.lookupUniforms(BATCH_FILL_UNIFORMS);
+    this.batchFill.lookupAttributes(BATCH_FILL_ATTRIBUTES);
     this.gradFill = new ShaderProgram(this.gl, GRAD_VERT_SRC, GRAD_FRAG_SRC);
     this.gradFill.lookupUniforms(GRAD_FILL_UNIFORMS);
     this.gradFill.lookupAttributes(GRAD_FILL_ATTRIBUTES);
@@ -5098,10 +5285,10 @@ var WeaselRenderer = class {
     this.meshCache = new GLMeshCache(this.gl, aPos);
     this.textureCache = new GLTextureCache(this.gl);
     this.imageCache = new GLImageCache(this.gl, this.imageMinification);
-    this.gradRampCache = new GradientRampCache(this.gl);
+    this.gradRamps = new GradientRampAtlas(this.gl);
     this.uploadQuadGeometry();
-    this.solidBatch = new SolidBatch(this.gl, this.pathFillVColor);
-    this.imageBatch = new ImageBatch(this.gl, this.imageFillVOpacity);
+    this.drawBatch = new DrawBatch(this.gl, this.batchFill);
+    this.whiteTexture = createWhiteTexture(this.gl);
   }
   uploadQuadGeometry() {
     const gl = this.gl;
@@ -5217,22 +5404,12 @@ var WeaselRenderer = class {
     this.pathFillVColor = new ShaderProgram(this.gl, VCOLOR_VERT_SRC, VCOLOR_FRAG_SRC);
     this.pathFillVColor.lookupUniforms(PATH_FILL_UNIFORMS);
     this.pathFillVColor.lookupAttributes(PATH_FILL_VCOLOR_ATTRIBUTES);
-    this.textSdf = new ShaderProgram(this.gl, TEXT_VERT_SRC, TEXT_FRAG_SRC);
-    this.textSdf.lookupUniforms(TEXT_SDF_UNIFORMS);
-    this.textSdf.lookupAttributes(TEXT_SDF_ATTRIBUTES);
-    this.textSdfR8 = new ShaderProgram(this.gl, TEXT_VERT_SRC, TEXT_FRAG_R8_SRC);
-    this.textSdfR8.lookupUniforms(TEXT_SDF_UNIFORMS);
-    this.textSdfR8.lookupAttributes(TEXT_SDF_ATTRIBUTES);
     this.imageFill = new ShaderProgram(this.gl, IMAGE_VERT_SRC, IMAGE_FRAG_SRC);
     this.imageFill.lookupUniforms(IMAGE_FILL_UNIFORMS);
     this.imageFill.lookupAttributes(IMAGE_FILL_ATTRIBUTES);
-    this.imageFillVOpacity = new ShaderProgram(
-      this.gl,
-      IMAGE_VOPACITY_VERT_SRC,
-      IMAGE_VOPACITY_FRAG_SRC
-    );
-    this.imageFillVOpacity.lookupUniforms(IMAGE_VOPACITY_UNIFORMS);
-    this.imageFillVOpacity.lookupAttributes(IMAGE_VOPACITY_ATTRIBUTES);
+    this.batchFill = new ShaderProgram(this.gl, BATCH_VERT_SRC, BATCH_FRAG_SRC);
+    this.batchFill.lookupUniforms(BATCH_FILL_UNIFORMS);
+    this.batchFill.lookupAttributes(BATCH_FILL_ATTRIBUTES);
     this.gradFill = new ShaderProgram(this.gl, GRAD_VERT_SRC, GRAD_FRAG_SRC);
     this.gradFill.lookupUniforms(GRAD_FILL_UNIFORMS);
     this.gradFill.lookupAttributes(GRAD_FILL_ATTRIBUTES);
@@ -5244,11 +5421,11 @@ var WeaselRenderer = class {
     this.meshCache = new GLMeshCache(this.gl, aPos);
     this.textureCache = new GLTextureCache(this.gl);
     this.imageCache = new GLImageCache(this.gl, this.imageMinification);
-    this.gradRampCache = new GradientRampCache(this.gl);
+    this.gradRamps = new GradientRampAtlas(this.gl);
     markAllFontsNotUploaded();
     this.uploadQuadGeometry();
-    this.solidBatch = new SolidBatch(this.gl, this.pathFillVColor);
-    this.imageBatch = new ImageBatch(this.gl, this.imageFillVOpacity);
+    this.drawBatch = new DrawBatch(this.gl, this.batchFill);
+    this.whiteTexture = createWhiteTexture(this.gl);
     for (const id of this.programRegistry.keys()) {
       const src = getProgramSource(id);
       if (!src) continue;
@@ -5269,7 +5446,7 @@ var WeaselRenderer = class {
    *  Scope: built-in shader programs, any consumer-registered programs, the
    *  shared quad/rect geometry, any in-flight transient meshes, and the
    *  enumerable Map-keyed caches (`GLTextureCache` atlas/image textures,
-   *  `GradientRampCache` ramp textures) ARE freed.
+   *  `GradientRampAtlas`'s ramp texture) ARE freed.
    *
    *  NOT freed: `GLImageCache` (bitmap/pattern textures) and `GLMeshCache`'s
    *  persistent per-Path mesh cache are keyed by `WeakMap`, not enumerable,
@@ -5297,7 +5474,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.imageFillVOpacity, this.gradFill, this.patternFill]) {
+    for (const prog of [this.pathFill, this.pathFillVColor, this.imageFill, this.batchFill, this.gradFill, this.patternFill]) {
       gl.deleteProgram(prog.handle);
     }
     for (const prog of this.programRegistry.values()) {
@@ -5305,12 +5482,12 @@ var WeaselRenderer = class {
     }
     this.programRegistry.clear();
     this.textureCache.free();
-    this.gradRampCache.free();
+    this.gradRamps.free();
     if (this.quadVbo) gl.deleteBuffer(this.quadVbo);
     if (this.quadIbo) gl.deleteBuffer(this.quadIbo);
-    for (const prog of [this.textSdf, this.textSdfR8, this.pathFill]) disposeTextQuads(gl, prog);
-    this.solidBatch.dispose();
-    this.imageBatch.dispose();
+    this.drawBatch.dispose();
+    if (this.whiteTexture) gl.deleteTexture(this.whiteTexture);
+    this.whiteTexture = null;
     this.effectTargets.releaseAll();
   }
   /**
@@ -5337,22 +5514,20 @@ var WeaselRenderer = class {
       gl,
       pathFill: this.pathFill,
       pathFillVColor: this.pathFillVColor,
-      textSdf: this.textSdf,
-      textSdfR8: this.textSdfR8,
       imageFill: this.imageFill,
-      imageFillVOpacity: this.imageFillVOpacity,
+      batchFill: this.batchFill,
       gradFill: this.gradFill,
       patternFill: this.patternFill,
       meshCache: this.meshCache,
       textureCache: this.textureCache,
       imageCache: this.imageCache,
-      gradRampCache: this.gradRampCache,
+      gradRamps: this.gradRamps,
       programRegistry: this.programRegistry,
       ensureProgram: (id) => this.ensureProgram(id),
       quadVbo: this.quadVbo,
       quadIbo: this.quadIbo,
-      solidBatch: this.solidBatch,
-      imageBatch: this.imageBatch,
+      drawBatch: this.drawBatch,
+      whiteTexture: this.whiteTexture,
       state: this.groupState,
       widthCss: this.widthCss,
       heightCss: this.heightCss,
@@ -5367,7 +5542,7 @@ var WeaselRenderer = class {
       restoreTargetRect: () => this.applyTarget()
     };
     for (const cmd of commands) dispatch(ctx, cmd);
-    flushBatches(ctx);
+    flushBatch(ctx);
     this.meshCache.freeTransient();
   }
   resize(dims) {
@@ -5397,28 +5572,16 @@ var WeaselRenderer = class {
     return this.pathFillVColor;
   }
   /** @internal */
-  _solidBatch() {
-    return this.solidBatch;
-  }
-  /** @internal */
-  _imageBatch() {
-    return this.imageBatch;
-  }
-  /** @internal */
-  _textSdf() {
-    return this.textSdf;
-  }
-  /** @internal */
-  _textSdfR8() {
-    return this.textSdfR8;
+  _drawBatch() {
+    return this.drawBatch;
   }
   /** @internal */
   _imageFill() {
     return this.imageFill;
   }
   /** @internal */
-  _imageFillVOpacity() {
-    return this.imageFillVOpacity;
+  _batchFill() {
+    return this.batchFill;
   }
   /** @internal */
   _gradFill() {
@@ -5441,8 +5604,8 @@ var WeaselRenderer = class {
     return this.imageCache;
   }
   /** @internal */
-  _gradRampCache() {
-    return this.gradRampCache;
+  _gradRamps() {
+    return this.gradRamps;
   }
   /** @internal */
   _groupState() {
@@ -5461,6 +5624,28 @@ var WeaselRenderer = class {
     return this.dpr;
   }
 };
+function createWhiteTexture(gl) {
+  const tex = gl.createTexture();
+  if (!tex) return null;
+  gl.bindTexture(gl.TEXTURE_2D, tex);
+  gl.texImage2D(
+    gl.TEXTURE_2D,
+    0,
+    gl.RGBA,
+    1,
+    1,
+    0,
+    gl.RGBA,
+    gl.UNSIGNED_BYTE,
+    new Uint8Array([255, 255, 255, 255])
+  );
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+  gl.bindTexture(gl.TEXTURE_2D, null);
+  return tex;
+}
 
 // src/renderer/spriteSheet.ts
 function frameRect(sheet, index) {
@@ -5940,6 +6125,109 @@ function createParallaxLayer(opts) {
     }
   };
 }
+
+// src/features/simulation/types.ts
+var DEFAULT_ALPHA_DECAY = 1 - Math.pow(1e-3, 1 / 300);
+var DEFAULT_ALPHA_MIN = 1e-3;
+var DEFAULT_VELOCITY_DECAY = 0.4;
+
+// src/features/simulation/createSimulation.ts
+function createSimulation(opts) {
+  let nodes = opts.nodes;
+  let forces = opts.forces ?? [];
+  let alpha = opts.alpha ?? 1;
+  let alphaMin = opts.alphaMin ?? DEFAULT_ALPHA_MIN;
+  let alphaDecay = opts.alphaDecay ?? DEFAULT_ALPHA_DECAY;
+  let alphaTarget = opts.alphaTarget ?? 0;
+  let velocityDecay = opts.velocityDecay ?? DEFAULT_VELOCITY_DECAY;
+  const random = opts.random ?? Math.random;
+  function prime(list) {
+    list.forEach((n, i) => {
+      n.index = i;
+      if (n.vx == null) n.vx = 0;
+      if (n.vy == null) n.vy = 0;
+    });
+  }
+  prime(nodes);
+  for (const f of forces) f.initialize?.(nodes, random);
+  function step() {
+    alpha += (alphaTarget - alpha) * alphaDecay;
+    for (const f of forces) f(alpha);
+    const friction = 1 - velocityDecay;
+    for (const n of nodes) {
+      if (n.fx == null) {
+        n.vx = (n.vx ?? 0) * friction;
+        if (!Number.isFinite(n.vx)) n.vx = 0;
+        n.x += n.vx;
+        if (!Number.isFinite(n.x)) n.x = 0;
+      } else {
+        n.x = n.fx;
+        n.vx = 0;
+      }
+      if (n.fy == null) {
+        n.vy = (n.vy ?? 0) * friction;
+        if (!Number.isFinite(n.vy)) n.vy = 0;
+        n.y += n.vy;
+        if (!Number.isFinite(n.y)) n.y = 0;
+      } else {
+        n.y = n.fy;
+        n.vy = 0;
+      }
+    }
+  }
+  const core = {
+    get nodes() {
+      return nodes;
+    },
+    setNodes(next) {
+      nodes = next;
+      prime(nodes);
+      for (const f of forces) f.initialize?.(nodes, random);
+      return core;
+    },
+    setForces(next) {
+      const old = forces;
+      forces = next;
+      for (const f of next) {
+        if (!old.includes(f)) f.initialize?.(nodes, random);
+      }
+      return core;
+    },
+    alpha(value) {
+      if (value === void 0) return alpha;
+      alpha = value;
+      return core;
+    },
+    alphaTarget(value) {
+      if (value === void 0) return alphaTarget;
+      alphaTarget = value;
+      return core;
+    },
+    alphaDecay(value) {
+      if (value === void 0) return alphaDecay;
+      alphaDecay = value;
+      return core;
+    },
+    alphaMin(value) {
+      if (value === void 0) return alphaMin;
+      alphaMin = value;
+      return core;
+    },
+    velocityDecay(value) {
+      if (value === void 0) return velocityDecay;
+      velocityDecay = value;
+      return core;
+    },
+    tick(iterations = 1) {
+      for (let i = 0; i < iterations; i++) step();
+      return core;
+    },
+    isSettled() {
+      return alpha < alphaMin && alphaTarget === 0;
+    }
+  };
+  return core;
+}
 var documentHidden = () => typeof document !== "undefined" && document.hidden;
 var resolveTarget = (target) => typeof target === "function" ? target() : target?.current ?? null;
 function useVisibleRaf(frame, options = {}) {
@@ -6034,75 +6322,32 @@ function useVisibleRaf(frame, options = {}) {
   return useMemo(() => ({ request, cancel, isVisible }), [request, cancel, isVisible]);
 }
 
-// src/features/simulation/types.ts
-var DEFAULT_ALPHA_DECAY = 1 - Math.pow(1e-3, 1 / 300);
-var DEFAULT_ALPHA_MIN = 1e-3;
-var DEFAULT_VELOCITY_DECAY = 0.4;
-
 // src/features/simulation/useSimulation.ts
 function useSimulation(opts) {
   const optsRef = useRef(opts);
   optsRef.current = opts;
-  const nodesRef = useRef(opts.nodes);
-  const forcesRef = useRef(opts.forces ?? []);
-  const alphaRef = useRef(opts.alpha ?? 1);
-  const alphaMinRef = useRef(opts.alphaMin ?? DEFAULT_ALPHA_MIN);
-  const alphaDecayRef = useRef(opts.alphaDecay ?? DEFAULT_ALPHA_DECAY);
-  const alphaTargetRef = useRef(opts.alphaTarget ?? 0);
-  const velocityDecayRef = useRef(opts.velocityDecay ?? DEFAULT_VELOCITY_DECAY);
+  const coreRef = useRef(null);
+  coreRef.current ??= createSimulation(opts);
+  const core = coreRef.current;
   const endedRef = useRef(false);
   const mountedRef = useRef(true);
-  const clockRef = useRef(null);
-  if (clockRef.current === null) {
-    clockRef.current = {
-      requestFrame: opts.requestFrame ?? ((cb) => requestAnimationFrame(cb)),
-      cancelFrame: opts.cancelFrame ?? ((h) => cancelAnimationFrame(h))
-    };
-  }
   const frameLoop = useVisibleRaf(
     () => {
       rafTick();
     },
     {
-      requestFrame: clockRef.current.requestFrame,
-      cancelFrame: clockRef.current.cancelFrame
+      requestFrame: opts.requestFrame,
+      cancelFrame: opts.cancelFrame
     }
   );
-  const tickOnce = () => {
-    alphaRef.current += (alphaTargetRef.current - alphaRef.current) * alphaDecayRef.current;
-    const forces = forcesRef.current;
-    for (const f of forces) f(alphaRef.current);
-    const friction = 1 - velocityDecayRef.current;
-    const nodes = nodesRef.current;
-    for (const n of nodes) {
-      if (n.fx == null) {
-        n.vx = (n.vx ?? 0) * friction;
-        if (!Number.isFinite(n.vx)) n.vx = 0;
-        n.x += n.vx;
-        if (!Number.isFinite(n.x)) n.x = 0;
-      } else {
-        n.x = n.fx;
-        n.vx = 0;
-      }
-      if (n.fy == null) {
-        n.vy = (n.vy ?? 0) * friction;
-        if (!Number.isFinite(n.vy)) n.vy = 0;
-        n.y += n.vy;
-        if (!Number.isFinite(n.y)) n.y = 0;
-      } else {
-        n.y = n.fy;
-        n.vy = 0;
-      }
-    }
-  };
   const stopRaf = () => {
     frameLoop.cancel();
   };
   const rafTick = () => {
     if (!mountedRef.current) return;
-    tickOnce();
-    optsRef.current.onTick?.(nodesRef.current);
-    if (alphaRef.current < alphaMinRef.current) {
+    core.tick();
+    optsRef.current.onTick?.(core.nodes);
+    if (core.alpha() < core.alphaMin()) {
       stopRaf();
       if (!endedRef.current) {
         endedRef.current = true;
@@ -6116,17 +6361,9 @@ function useSimulation(opts) {
     if (!mountedRef.current) return;
     frameLoop.request();
   };
-  const initOnceRef = useRef(false);
-  if (!initOnceRef.current) {
-    initOnceRef.current = true;
-    nodesRef.current.forEach((n, i) => {
-      n.index = i;
-      if (n.vx == null) n.vx = 0;
-      if (n.vy == null) n.vy = 0;
-    });
-    for (const f of forcesRef.current) {
-      f.initialize?.(nodesRef.current, Math.random);
-    }
+  const startedRef = useRef(false);
+  if (!startedRef.current) {
+    startedRef.current = true;
     startRaf();
   }
   useEffect(() => {
@@ -6139,80 +6376,195 @@ function useSimulation(opts) {
   const handle = useMemo(() => {
     const h = {
       get nodes() {
-        return nodesRef.current;
+        return core.nodes;
       },
       setNodes(newNodes) {
-        nodesRef.current = newNodes;
-        newNodes.forEach((n, i) => {
-          n.index = i;
-          if (n.vx == null) n.vx = 0;
-          if (n.vy == null) n.vy = 0;
-        });
-        for (const f of forcesRef.current) {
-          f.initialize?.(newNodes, Math.random);
-        }
+        core.setNodes(newNodes);
         return h;
       },
       setForces(newForces) {
-        const old = forcesRef.current;
-        forcesRef.current = newForces;
-        for (const f of newForces) {
-          if (!old.includes(f)) {
-            f.initialize?.(nodesRef.current, Math.random);
-          }
-        }
+        core.setForces(newForces);
         return h;
       },
       alpha(value) {
-        if (value === void 0) return alphaRef.current;
-        alphaRef.current = value;
-        if (value >= alphaMinRef.current) endedRef.current = false;
+        if (value === void 0) return core.alpha();
+        core.alpha(value);
+        if (value >= core.alphaMin()) endedRef.current = false;
         return h;
       },
       alphaTarget(value) {
-        if (value === void 0) return alphaTargetRef.current;
-        alphaTargetRef.current = value;
+        if (value === void 0) return core.alphaTarget();
+        core.alphaTarget(value);
         if (value > 0) endedRef.current = false;
         return h;
       },
       alphaDecay(value) {
-        if (value === void 0) return alphaDecayRef.current;
-        alphaDecayRef.current = value;
+        if (value === void 0) return core.alphaDecay();
+        core.alphaDecay(value);
         return h;
       },
       alphaMin(value) {
-        if (value === void 0) return alphaMinRef.current;
-        alphaMinRef.current = value;
+        if (value === void 0) return core.alphaMin();
+        core.alphaMin(value);
         return h;
       },
       velocityDecay(value) {
-        if (value === void 0) return velocityDecayRef.current;
-        velocityDecayRef.current = value;
+        if (value === void 0) return core.velocityDecay();
+        core.velocityDecay(value);
         return h;
       },
       restart() {
-        if (alphaRef.current < alphaMinRef.current) {
-          alphaRef.current = 1;
+        if (core.alpha() < core.alphaMin()) core.alpha(1);
+        endedRef.current = false;
+        startRaf();
+        return h;
+      },
+      stop() {
+        stopRaf();
+        return h;
+      },
+      tick(iterations = 1) {
+        core.tick(iterations);
+        return h;
+      },
+      isSettled() {
+        return core.isSettled();
+      }
+    };
+    return h;
+  }, []);
+  return handle;
+}
+
+// src/interactions/actions/previewOverrides.ts
+function syncPreviewOverrides(state) {
+  const { overrides } = state.scene;
+  for (const [id, pose] of state.previews) {
+    const existing = state.overrideEntries.get(id);
+    if (existing) {
+      existing.pose = pose;
+      continue;
+    }
+    const entry = { pose };
+    state.overrideEntries.set(id, entry);
+    overrides.set(id, entry);
+  }
+  for (const id of state.overrideEntries.keys()) {
+    if (state.previews.has(id)) continue;
+    state.overrideEntries.delete(id);
+    overrides.clear(id);
+  }
+  overrides.commit();
+}
+function dropPreviewOverrides(state) {
+  if (state.overrideEntries.size === 0) return;
+  for (const id of state.overrideEntries.keys()) state.scene.overrides.clear(id);
+  state.overrideEntries.clear();
+  state.scene.overrides.commit();
+}
+
+// src/features/poseRun/usePoseRun.ts
+var EMPTY = /* @__PURE__ */ new Map();
+function usePoseRun(opts) {
+  const optsRef = useRef(opts);
+  optsRef.current = opts;
+  const state = useRef({
+    previews: /* @__PURE__ */ new Map(),
+    overrideEntries: /* @__PURE__ */ new Map()
+  });
+  const running = useRef(false);
+  const frame = useRef(0);
+  const mounted = useRef(true);
+  const loop = useVisibleRaf(() => {
+    tick();
+  }, {
+    requestFrame: opts.requestFrame,
+    cancelFrame: opts.cancelFrame
+  });
+  const syncState = () => ({
+    scene: optsRef.current.scene,
+    previews: state.current.previews,
+    overrideEntries: state.current.overrideEntries
+  });
+  const pinnedNow = () => {
+    const { overrides } = optsRef.current.scene;
+    let pinned;
+    for (const id of overrides.ids()) {
+      const entry = overrides.get(id);
+      if (entry === void 0 || entry === state.current.overrideEntries.get(id)) continue;
+      if (entry.pose === void 0) continue;
+      (pinned ??= /* @__PURE__ */ new Map()).set(id, entry.pose);
+    }
+    return pinned ?? EMPTY;
+  };
+  const commit = () => {
+    const { previews } = state.current;
+    const scene = optsRef.current.scene;
+    let moved = 0;
+    if (previews.size > 0) {
+      scene.batch(optsRef.current.label ?? "Layout", () => {
+        for (const [id, pose] of previews) {
+          if (scene.get(id) === void 0) continue;
+          scene.setPose(id, pose);
+          moved++;
         }
-        endedRef.current = false;
-        startRaf();
-        return h;
-      },
-      stop() {
-        stopRaf();
-        return h;
-      },
-      tick(iterations = 1) {
-        for (let i = 0; i < iterations; i++) tickOnce();
-        return h;
-      },
-      isSettled() {
-        return alphaRef.current < alphaMinRef.current && alphaTargetRef.current === 0;
-      }
+      });
+    }
+    dropPreviewOverrides(syncState());
+    previews.clear();
+    optsRef.current.onCommit?.(moved);
+  };
+  const halt = () => {
+    running.current = false;
+    loop.cancel();
+  };
+  const tick = () => {
+    if (!mounted.current || !running.current) return;
+    const pinned = pinnedNow();
+    const { poses, done } = optsRef.current.step({ pinned, frame: frame.current });
+    frame.current++;
+    state.current.previews.clear();
+    for (const [id, pose] of poses) {
+      if (pinned.has(id)) continue;
+      state.current.previews.set(id, pose);
+    }
+    syncPreviewOverrides(syncState());
+    if (done) {
+      halt();
+      commit();
+      return;
+    }
+    loop.request();
+  };
+  useEffect(() => {
+    mounted.current = true;
+    return () => {
+      mounted.current = false;
+      loop.cancel();
+      dropPreviewOverrides(syncState());
+      state.current.previews.clear();
     };
-    return h;
-  }, []);
-  return handle;
+  }, [loop]);
+  return useMemo(() => ({
+    start() {
+      if (running.current || !mounted.current) return;
+      running.current = true;
+      frame.current = 0;
+      loop.request();
+    },
+    stop() {
+      if (!running.current) return;
+      halt();
+      commit();
+    },
+    cancel() {
+      halt();
+      dropPreviewOverrides(syncState());
+      state.current.previews.clear();
+    },
+    isRunning: () => running.current
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }), [loop]);
 }
 
 // src/core/device/profile.ts
@@ -7162,31 +7514,158 @@ function resolveParams(params) {
   return typeof params === "function" ? params() : params;
 }
 
-// src/interactions/actions/previewOverrides.ts
-function syncPreviewOverrides(state) {
-  const { overrides } = state.scene;
-  for (const [id, pose] of state.previews) {
-    const existing = state.overrideEntries.get(id);
-    if (existing) {
-      existing.pose = pose;
-      continue;
+// src/core/scene/dependents.ts
+var NONE = Object.freeze([]);
+function dependencyIdsOf(node, childrenOf) {
+  const deps = node.dependsOn;
+  if (deps === void 0) return NONE;
+  return deps === "children" ? childrenOf(node.id) : deps;
+}
+function createDependentsIndex() {
+  const forward = /* @__PURE__ */ new Map();
+  const reverse = /* @__PURE__ */ new Map();
+  function detachOwnDeps(id) {
+    const old = reverse.get(id);
+    if (old === void 0) return;
+    for (const dep of old) {
+      const set = forward.get(dep);
+      if (set === void 0) continue;
+      set.delete(id);
+      if (set.size === 0) forward.delete(dep);
     }
-    const entry = { pose };
-    state.overrideEntries.set(id, entry);
-    overrides.set(id, entry);
+    reverse.delete(id);
   }
-  for (const id of state.overrideEntries.keys()) {
-    if (state.previews.has(id)) continue;
-    state.overrideEntries.delete(id);
-    overrides.clear(id);
+  return {
+    add(id, deps) {
+      detachOwnDeps(id);
+      if (deps.length === 0) return;
+      reverse.set(id, [...deps]);
+      for (const dep of deps) {
+        let set = forward.get(dep);
+        if (set === void 0) {
+          set = /* @__PURE__ */ new Set();
+          forward.set(dep, set);
+        }
+        set.add(id);
+      }
+    },
+    remove(id) {
+      detachOwnDeps(id);
+    },
+    clear() {
+      forward.clear();
+      reverse.clear();
+    },
+    isEmpty() {
+      return forward.size === 0;
+    },
+    dependentsOf(id) {
+      const set = forward.get(id);
+      return set === void 0 ? NONE : [...set];
+    },
+    transitiveDependentsOf(id) {
+      const direct = forward.get(id);
+      if (direct === void 0) return NONE;
+      const out = /* @__PURE__ */ new Set();
+      const stack = [...direct];
+      while (stack.length > 0) {
+        const next = stack.pop();
+        if (out.has(next)) continue;
+        out.add(next);
+        for (const d of forward.get(next) ?? []) stack.push(d);
+      }
+      return out;
+    }
+  };
+}
+function sameDependsOn(a, b) {
+  if (a === b) return true;
+  if (a === void 0 || b === void 0) return false;
+  if (a === "children" || b === "children") return false;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+  return true;
+}
+
+// src/core/scene/derivedPath.ts
+var SLOT = "kit:derivedPath";
+var resolving = /* @__PURE__ */ new Set();
+var cycleHits = 0;
+function resolveDerivedPath(node, depOf2, childrenOf) {
+  const derivePath = node.derivePath;
+  if (derivePath === void 0) return null;
+  const ids = dependencyIdsOf(node, childrenOf);
+  if (ids.length === 0) return null;
+  if (resolving.has(node.id)) {
+    cycleHits++;
+    return null;
+  }
+  resolving.add(node.id);
+  const hitsBefore = cycleHits;
+  try {
+    const value = nodeMemo(
+      node,
+      SLOT,
+      node.pose,
+      () => derivePath(node, ids.map((id) => depOf2(id)))
+    );
+    if (cycleHits !== hitsBefore) dropPoseKeyedMemoSlots(node);
+    return value;
+  } finally {
+    resolving.delete(node.id);
   }
-  overrides.commit();
 }
-function dropPreviewOverrides(state) {
-  if (state.overrideEntries.size === 0) return;
-  for (const id of state.overrideEntries.keys()) state.scene.overrides.clear(id);
-  state.overrideEntries.clear();
-  state.scene.overrides.commit();
+
+// src/core/scene/effectivePose.ts
+var SLOT2 = "kit:derivedPose";
+var resolving2 = /* @__PURE__ */ new Set();
+var cycleHits2 = 0;
+function derivedPose(source, node) {
+  const derive = node.derivePose;
+  if (derive === void 0) return null;
+  const ids = dependencyIdsOf(node, source.childrenOf);
+  if (ids.length === 0) return null;
+  if (resolving2.has(node.id)) {
+    cycleHits2++;
+    return null;
+  }
+  resolving2.add(node.id);
+  const hitsBefore = cycleHits2;
+  try {
+    const value = nodeMemo(
+      node,
+      SLOT2,
+      node.pose,
+      () => derive(node, ids.map((id) => derivedDepOf(source, id)))
+    );
+    if (cycleHits2 !== hitsBefore) dropPoseKeyedMemoSlots(node);
+    return value;
+  } finally {
+    resolving2.delete(node.id);
+  }
+}
+function derivedDepOf(source, id) {
+  const node = source.get(id);
+  if (node === void 0) return void 0;
+  return {
+    node,
+    pose: effectivePose(source, node),
+    get path() {
+      return resolveDerivedPath(
+        node,
+        (depId) => derivedDepOf(source, depId),
+        (depId) => source.childrenOf(depId)
+      );
+    }
+  };
+}
+function documentPose(source, node) {
+  return derivedPose(source, node) ?? node.pose;
+}
+function effectivePose(source, node) {
+  const override = source.overrides.get(node.id)?.pose;
+  if (override !== void 0) return override;
+  return derivedPose(source, node) ?? node.pose;
 }
 
 // src/core/scene/types.ts
@@ -7218,6 +7697,86 @@ function geometryDataOp(projection, node, m, label) {
   return createSetDataOp({ id: node.id, from: node.data, to: next, label, coalesceKey: `setData:${node.id}` });
 }
 
+// src/core/scene/nodeFnFields.ts
+var NODE_FN_FIELDS = [
+  {
+    field: "clipFromPose",
+    opKey: "clipKey",
+    jsonKey: "clipFromPoseKey",
+    containersOnly: true,
+    lost: "clip"
+  },
+  {
+    field: "derivePath",
+    opKey: "derivePathKey",
+    jsonKey: "derivePathKey",
+    containersOnly: false,
+    lost: "derived path"
+  },
+  {
+    field: "derivePose",
+    opKey: "derivePoseKey",
+    jsonKey: "derivePoseKey",
+    containersOnly: false,
+    lost: "derived pose"
+  }
+];
+function createNodeFnFields(registry2) {
+  return NODE_FN_FIELDS.map((spec) => {
+    const table = registry2[spec.field];
+    const reverse = /* @__PURE__ */ new Map();
+    if (table) for (const [key, fn] of Object.entries(table)) reverse.set(fn, key);
+    const pending = /* @__PURE__ */ new Map();
+    const applies = (node) => !spec.containersOnly || node.kind === "container";
+    return {
+      spec,
+      keyOf: (fn) => reverse.get(fn),
+      fnOf: (key) => table?.[key],
+      read: (node) => applies(node) ? node[spec.field] : void 0,
+      write: (node, fn) => {
+        if (applies(node)) node[spec.field] = fn;
+      },
+      pending
+    };
+  });
+}
+function restoreFn(field, node, key, site, warn) {
+  const fn = field.fnOf(key);
+  if (fn === void 0) {
+    warn(
+      "scene",
+      `${site}: ${field.spec.opKey} "${key}" not in this scene's registry \u2014 node "${node.id}" restored without its ${field.spec.lost}. Register a function with this key in the registry option to restore it.`
+    );
+    return;
+  }
+  field.write(node, fn);
+  field.pending.set(node.id, fn);
+}
+function fnKeysOf(fields, node, which, onUnregistered) {
+  const out = {};
+  for (const field of fields) {
+    const fn = field.read(node);
+    if (fn === void 0) continue;
+    const key = field.keyOf(fn);
+    if (key === void 0) {
+      onUnregistered?.(field);
+      continue;
+    }
+    out[field.spec[which]] = key;
+  }
+  return out;
+}
+function fnFieldsOfNode(node) {
+  const src = node;
+  const out = {};
+  for (const spec of NODE_FN_FIELDS) {
+    if (spec.containersOnly && node.kind !== "container") continue;
+    const fn = src[spec.field];
+    if (fn !== void 0) out[spec.field] = fn;
+  }
+  return out;
+}
+
 // src/interactions/actions/move/gestureAdapter.ts
 function moveGestureAdapter(scene) {
   return {
@@ -7225,7 +7784,7 @@ function moveGestureAdapter(scene) {
     getNodes: () => {
       return [...scene.renderOrderNodes()];
     },
-    getPose: (id) => scene.get(asNodeId(id)).pose,
+    getPose: (id) => documentPose(scene, scene.get(asNodeId(id))),
     getParent: (id) => scene.get(asNodeId(id))?.parent ?? null,
     setPose: (id, pose) => scene.setPose(asNodeId(id), pose),
     setParent: (id, parentId) => scene.move(asNodeId(id), parentId === null ? null : asNodeId(parentId)),
@@ -7240,8 +7799,7 @@ function moveGestureAdapter(scene) {
       ...index !== void 0 ? { index } : {},
       ...node.parent !== null ? { parent: node.parent } : {},
       ...node.dependsOn !== void 0 ? { dependsOn: node.dependsOn } : {},
-      ...node.derivePath !== void 0 ? { derivePath: node.derivePath } : {},
-      ...node.kind === "container" && node.clipFromPose !== void 0 ? { clipFromPose: node.clipFromPose } : {}
+      ...fnFieldsOfNode(node)
     }),
     getChildren: (parentId) => parentId === null ? [...scene.roots] : [...scene.childrenOf(asNodeId(parentId))],
     setChildOrder: (parentId, ids) => {
@@ -7489,7 +8047,7 @@ function unreleasedIds(scratch, released) {
 }
 function scenePoseAdapter(scene) {
   return {
-    getPose: (id) => scene.get(id).pose,
+    getPose: (id) => documentPose(scene, scene.get(id)),
     getParent: (id) => scene.get(id)?.parent ?? null
   };
 }
@@ -7902,7 +8460,7 @@ function defaultCommitAdapter(scene) {
     getNodes: () => {
       return [...scene.renderOrderNodes()];
     },
-    getPose: (id) => scene.get(asNodeId(id)).pose,
+    getPose: (id) => documentPose(scene, scene.get(asNodeId(id))),
     getSelection: () => [...scene.getSelection()],
     setSelection: (ids) => scene.setSelection(ids.map(asNodeId)),
     getParent: (id) => scene.get(asNodeId(id))?.parent ?? null,
@@ -7936,12 +8494,8 @@ function defaultCommitAdapter(scene) {
       // source removal) re-inserts at the recorded z-order slot instead
       // of appending at the end.
       ...index !== void 0 ? { index } : {},
-      // The function-valued fields travel with the node, or undo of a delete
-      // brings an edge back as a static path that never follows its endpoints
-      // again, and a clipped container back with nothing clipped.
       ...node.dependsOn !== void 0 ? { dependsOn: node.dependsOn } : {},
-      ...node.derivePath !== void 0 ? { derivePath: node.derivePath } : {},
-      ...node.kind === "container" && node.clipFromPose !== void 0 ? { clipFromPose: node.clipFromPose } : {}
+      ...fnFieldsOfNode(node)
     })
   };
 }
@@ -10272,6 +10826,26 @@ var duplicateAction = {
   enabled: requiresSelection
 };
 
+// src/core/scene/kitRegistry.ts
+var UNION_OF_CHILDREN = "kit:unionOfChildren";
+function unionOfChildren(_node, deps) {
+  const poses = [];
+  for (const d of deps) {
+    if (d !== void 0) poses.push(d.pose);
+  }
+  if (poses.length === 0) return null;
+  return unionAABB(poses);
+}
+function withKitRegistry(registry2) {
+  return {
+    ...registry2,
+    derivePose: {
+      [UNION_OF_CHILDREN]: unionOfChildren,
+      ...registry2.derivePose
+    }
+  };
+}
+
 // src/interactions/actions/defaults/group.ts
 var containerIdCounter = 0;
 function freshContainerId() {
@@ -10309,7 +10883,9 @@ var groupAction = {
             layer,
             pose,
             data: {},
-            parent: parent ?? null
+            parent: parent ?? null,
+            dependsOn: "children",
+            derivePose: unionOfChildren
           },
           label: "Group"
         })
@@ -12727,7 +13303,7 @@ function useStandardActions(opts) {
   }, [reg, depReg, excludeKey]);
 }
 var IDENTITY_EXPAND2 = (ids) => ids;
-var EMPTY = Object.freeze([]);
+var EMPTY2 = Object.freeze([]);
 function useResizePolicy(options) {
   const optsRef = useRef(options);
   optsRef.current = options;
@@ -12735,7 +13311,7 @@ function useResizePolicy(options) {
     const o = optsRef.current;
     return {
       constraints: o.constraints ?? DEFAULT_RESIZE_BEHAVIORS,
-      pointSnap: o.pointSnap ?? EMPTY,
+      pointSnap: o.pointSnap ?? EMPTY2,
       expandIds: o.expandIds ?? IDENTITY_EXPAND2,
       projection: o.projection ?? AUTO_POSE_DESCRIPTOR
     };
@@ -17348,7 +17924,7 @@ var TEXT_PAINTER = {
     const p = pose;
     const y = p.y;
     const paint = { fill: d.fill, stroke: resolveNodeStroke(d.stroke) ?? void 0 };
-    return d.runs && d.runs.length > 0 ? [textCommandFromRuns(p.x, y, d.runs, d.style, void 0, p.height, void 0, paint)] : [textCommand(p.x, y, d.text, d.style, void 0, p.height, void 0, paint)];
+    return d.runs && d.runs.length > 0 ? [textCommandFromRuns(p.x, y, d.runs, d.style, void 0, p.height, d.verticalAlign, paint)] : [textCommand(p.x, y, d.text, d.style, void 0, p.height, d.verticalAlign, paint)];
   }),
   // The pose is a *wrap box*, not a bounding box — "Away" in a 300-unit box
   // leaves most of it empty, and a pose-rect silhouette claims all of it. The
@@ -17372,7 +17948,11 @@ var TEXT_PAINTER = {
         height: p.height,
         text: d.text,
         runs: d.runs,
-        style: d.style
+        style: d.style,
+        // `textLineBoxes` applies the same shift `drawText` does, so picking
+        // follows a centered or bottom-aligned block down its box instead of
+        // staying where a top-aligned one would have drawn.
+        verticalAlign: d.verticalAlign
       },
       { maxWidth: Infinity }
     );
@@ -17607,12 +18187,15 @@ var DERIVED_PAINTER = {
     const declared = resolveNodeFill(d?.fill, strokeSpec === null ? DEFAULT_SHAPE_FILL : null);
     const fill = declared && resolveFillPattern(fillInPoseFrame(declared, box));
     const stroke = strokeSpec && strokeInPoseFrame(strokeSpec, box);
-    return [{
+    const cmd = {
       kind: "path",
       path,
       ...fill ? { fill } : {},
       ...stroke ? { stroke } : {}
-    }];
+    };
+    if (!stroke) return [cmd];
+    const width = resolveStrokeWidth(stroke.width ?? 1, 1);
+    return [cmd, ...markerDrawCommands(path, stroke, width, void 0)];
   },
   // The derived path *is* the silhouette, and it is already absolute — the
   // pose is a placeholder, so nothing here can be recovered from it. Without
@@ -17656,95 +18239,27 @@ function registerBuiltInShapePainters() {
   registerNodeShape(PATH_PAINTER);
   registerNodeShape(SHAPE_PAINTER);
   registerNodeShape(IMAGE_PAINTER);
-  registerNodeShape(RECT_FALLBACK_PAINTER);
-}
-registerBuiltInShapePainters();
-
-// src/core/scene/poseOverrides.ts
-function createPoseOverrides(getNode, onInvalidate) {
-  const entries = /* @__PURE__ */ new Map();
-  const listeners = /* @__PURE__ */ new Set();
-  let generation2 = 0;
-  function invalidate(id) {
-    const node = getNode(id);
-    if (node) dropPoseKeyedMemoSlots(node);
-    onInvalidate?.(id);
-  }
-  function published() {
-    generation2++;
-    for (const listener of listeners) listener();
-  }
-  return {
-    set(id, entry) {
-      entries.set(id, entry);
-      invalidate(id);
-      published();
-    },
-    get(id) {
-      return entries.get(id);
-    },
-    has(id) {
-      return entries.has(id);
-    },
-    ids() {
-      return [...entries.keys()];
-    },
-    clear(id) {
-      if (!entries.delete(id)) return;
-      invalidate(id);
-      published();
-    },
-    clearAll() {
-      if (entries.size === 0) return;
-      for (const id of entries.keys()) invalidate(id);
-      entries.clear();
-      published();
-    },
-    commit() {
-      for (const id of entries.keys()) invalidate(id);
-      published();
-    },
-    subscribe(fn) {
-      listeners.add(fn);
-      return () => {
-        listeners.delete(fn);
-      };
-    },
-    getGeneration() {
-      return generation2;
-    }
-  };
-}
-function effectivePose(overrides, node) {
-  return overrides.get(node.id)?.pose ?? node.pose;
-}
-
-// src/canvas/derivedPath.ts
-var SLOT = "kit:derivedPath";
-function resolveDerivedPath(node, poseOf) {
-  const deps = node.dependsOn;
-  const derivePath = node.derivePath;
-  if (deps === void 0 || deps.length === 0 || derivePath === void 0) return null;
-  return nodeMemo(
-    node,
-    SLOT,
-    node.pose,
-    () => derivePath(node, deps.map((id) => poseOf(id)))
-  );
+  registerNodeShape(RECT_FALLBACK_PAINTER);
 }
-function scenePoseLookup(scene) {
-  return (id) => {
-    const node = scene.get(id);
-    if (node === void 0) return void 0;
-    return scene.overrides.get(id)?.pose ?? node.pose;
-  };
+registerBuiltInShapePainters();
+
+// src/canvas/derivedPath.ts
+function sceneDepLookup(scene) {
+  return (id) => derivedDepOf(scene, id);
 }
 function withDerivedPaths(scene, drawOne) {
-  const poseOf = scenePoseLookup(scene);
+  const depOf2 = sceneDepLookup(scene);
+  const childrenOf = (id) => scene.childrenOf(id);
   return (node, pose, view, ctx) => {
-    const deps = node.dependsOn;
-    if (deps === void 0 || deps.length === 0) return drawOne(node, pose, view, ctx);
-    return drawOne(node, pose, view, { ...ctx, derivedPath: resolveDerivedPath(node, poseOf) });
+    if (node.dependsOn === void 0) return drawOne(node, pose, view, ctx);
+    return drawOne(node, pose, view, {
+      ...ctx,
+      derivedPath: resolveDerivedPath(
+        node,
+        depOf2,
+        childrenOf
+      )
+    });
   };
 }
 
@@ -17776,6 +18291,7 @@ function pickWalk(src, q) {
   };
   for (const node of src.order()) {
     if (!includeContainers && node.kind === "container") continue;
+    if (node.pickable === false) continue;
     if (node.layer !== void 0 && src.layerIsPainted?.(node.layer) === false) continue;
     if (src.alphaOf !== void 0 && src.alphaOf(node.id) <= 0) continue;
     const pose = src.poseOf(node);
@@ -17813,14 +18329,23 @@ function scenePickSource(scene, opts = {}) {
     }
   }
   const readAlpha = alphaOf ?? (enumerable ? faded ? (id) => faded.has(id) ? 0 : 1 : void 0 : (id) => scene.overrides.get(asNodeId(id))?.alpha ?? 1);
-  const poseOf = getPose ? (node) => getPose(node.id) : (node) => effectivePose(scene.overrides, node);
+  const poseOf = getPose ? (node) => getPose(node.id) : (node) => effectivePose(scene, node);
+  const childrenOf = (id) => scene.childrenOf(id);
+  const depOf2 = (id) => {
+    const dep = scene.get(id);
+    if (dep === void 0) return void 0;
+    return {
+      node: dep,
+      pose: poseOf(dep),
+      get path() {
+        return resolveDerivedPath(dep, depOf2, childrenOf);
+      }
+    };
+  };
   const derivedPathOf = (node) => {
     const n = node;
-    if (n.dependsOn === void 0 || n.dependsOn.length === 0) return null;
-    return resolveDerivedPath(n, (id) => {
-      const dep = scene.get(id);
-      return dep === void 0 ? void 0 : poseOf(dep);
-    });
+    if (n.dependsOn === void 0) return null;
+    return resolveDerivedPath(n, depOf2, childrenOf);
   };
   return {
     order: () => scene.renderOrderNodes(),
@@ -19938,8 +20463,8 @@ function useFrameLoop(paint, options = {}) {
   }, []);
   return { requestRedraw, subscribeFrame };
 }
-var EMPTY2 = [];
-var EMPTY_SNAPSHOT = () => EMPTY2;
+var EMPTY3 = [];
+var EMPTY_SNAPSHOT = () => EMPTY3;
 var NEVER_CHANGES = () => () => {
 };
 function useSelection(opts = {}) {
@@ -21724,71 +22249,67 @@ function composeAlphaFor(scene, alphaFor) {
   return alphaFor ? (id) => alphaFor(id) * overrideAlphaFor(id) : overrideAlphaFor;
 }
 function wireSceneSlotToScene(slot, scene, alphaFor) {
-  const poseOf = scenePoseLookup(scene);
+  const depOf2 = sceneDepLookup(scene);
   return {
     ...slot,
     drawOne: withDerivedPaths(scene, slot.drawOne),
-    derivedPathOf: (node) => resolveDerivedPath(node, poseOf),
+    derivedPathOf: (node) => resolveDerivedPath(node, depOf2, (id) => scene.childrenOf(id)),
     alphaFor: composeAlphaFor(scene, alphaFor)
   };
 }
 
-// src/core/scene/dependents.ts
-var NONE = Object.freeze([]);
-function createDependentsIndex() {
-  const forward = /* @__PURE__ */ new Map();
-  const reverse = /* @__PURE__ */ new Map();
-  function detachOwnDeps(id) {
-    const old = reverse.get(id);
-    if (old === void 0) return;
-    for (const dep of old) {
-      const set = forward.get(dep);
-      if (set === void 0) continue;
-      set.delete(id);
-      if (set.size === 0) forward.delete(dep);
-    }
-    reverse.delete(id);
+// src/core/scene/poseOverrides.ts
+function createPoseOverrides(getNode, onInvalidate) {
+  const entries = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  let generation2 = 0;
+  function invalidate(id) {
+    const node = getNode(id);
+    if (node) dropPoseKeyedMemoSlots(node);
+    onInvalidate?.(id);
+  }
+  function published() {
+    generation2++;
+    for (const listener of listeners) listener();
   }
   return {
-    add(id, deps) {
-      detachOwnDeps(id);
-      if (deps.length === 0) return;
-      reverse.set(id, [...deps]);
-      for (const dep of deps) {
-        let set = forward.get(dep);
-        if (set === void 0) {
-          set = /* @__PURE__ */ new Set();
-          forward.set(dep, set);
-        }
-        set.add(id);
-      }
+    set(id, entry) {
+      entries.set(id, entry);
+      invalidate(id);
+      published();
     },
-    remove(id) {
-      detachOwnDeps(id);
+    get(id) {
+      return entries.get(id);
     },
-    clear() {
-      forward.clear();
-      reverse.clear();
+    has(id) {
+      return entries.has(id);
     },
-    isEmpty() {
-      return forward.size === 0;
+    ids() {
+      return [...entries.keys()];
     },
-    dependentsOf(id) {
-      const set = forward.get(id);
-      return set === void 0 ? NONE : [...set];
+    clear(id) {
+      if (!entries.delete(id)) return;
+      invalidate(id);
+      published();
     },
-    transitiveDependentsOf(id) {
-      const direct = forward.get(id);
-      if (direct === void 0) return NONE;
-      const out = /* @__PURE__ */ new Set();
-      const stack = [...direct];
-      while (stack.length > 0) {
-        const next = stack.pop();
-        if (out.has(next)) continue;
-        out.add(next);
-        for (const d of forward.get(next) ?? []) stack.push(d);
-      }
-      return out;
+    clearAll() {
+      if (entries.size === 0) return;
+      for (const id of entries.keys()) invalidate(id);
+      entries.clear();
+      published();
+    },
+    commit() {
+      for (const id of entries.keys()) invalidate(id);
+      published();
+    },
+    subscribe(fn) {
+      listeners.add(fn);
+      return () => {
+        listeners.delete(fn);
+      };
+    },
+    getGeneration() {
+      return generation2;
     }
   };
 }
@@ -21814,23 +22335,13 @@ function createScene(options) {
     layers: [],
     layerIndex: /* @__PURE__ */ new Map()
   };
-  const registry2 = options.registry ?? {};
-  const reverseClipFromPose = /* @__PURE__ */ new Map();
-  if (registry2.clipFromPose) {
-    for (const [key, fn] of Object.entries(registry2.clipFromPose)) {
-      reverseClipFromPose.set(fn, key);
-    }
-  }
-  const reverseDerivePath = /* @__PURE__ */ new Map();
-  if (registry2.derivePath) {
-    for (const [key, fn] of Object.entries(registry2.derivePath)) {
-      reverseDerivePath.set(fn, key);
-    }
-  }
-  const pendingClipPatches = /* @__PURE__ */ new Map();
-  const pendingDerivePathPatches = /* @__PURE__ */ new Map();
+  const registry2 = withKitRegistry(options.registry ?? {});
+  const fnFields = createNodeFnFields(registry2);
+  const fnField = (name) => fnFields.find((f) => f.spec.field === name);
   const dependents = createDependentsIndex();
+  const childDerived = /* @__PURE__ */ new Set();
   function invalidateDependents(id) {
+    invalidateChildDerivedFrom(state.nodes.get(id)?.parent ?? null);
     if (dependents.isEmpty()) return;
     const subtree = [id];
     descendants(id, subtree);
@@ -21841,6 +22352,35 @@ function createScene(options) {
       }
     }
   }
+  function invalidateChildDerivedFrom(start) {
+    if (childDerived.size === 0) return;
+    let cursor = start;
+    while (cursor !== null) {
+      const node = state.nodes.get(cursor);
+      if (node === void 0) return;
+      if (childDerived.has(cursor)) {
+        dropPoseKeyedMemoSlots(node);
+        for (const dep of dependents.transitiveDependentsOf(cursor)) {
+          const d = state.nodes.get(dep);
+          if (d !== void 0) dropPoseKeyedMemoSlots(d);
+        }
+      }
+      cursor = node.parent;
+    }
+  }
+  function trackChildDerived(id, dependsOn) {
+    if (dependsOn === "children") childDerived.add(id);
+    else childDerived.delete(id);
+  }
+  function retarget(id, dependsOn) {
+    const node = requireNode(id);
+    if (dependsOn === void 0) delete node.dependsOn;
+    else node.dependsOn = dependsOn;
+    dependents.add(id, dependsOn === void 0 || dependsOn === "children" ? [] : dependsOn);
+    trackChildDerived(id, dependsOn);
+    dropPoseKeyedMemoSlots(requireNode(id));
+    invalidateDependents(id);
+  }
   for (let i = 0; i < options.systemLayers.length; i++) {
     const spec = options.systemLayers[i];
     if (state.layerIndex.has(spec.id)) {
@@ -21927,13 +22467,12 @@ function createScene(options) {
     for (const listener of listeners) listener();
   }
   function pruneCacheForDroppedOps(ops) {
-    if (pendingClipPatches.size === 0 && pendingDerivePathPatches.size === 0) return;
+    if (fnFields.every((f) => f.pending.size === 0)) return;
     for (const op of ops) {
       if (op.name !== "kit:add") continue;
       const id = op.args?.id;
       if (id && !state.nodes.has(id)) {
-        pendingClipPatches.delete(id);
-        pendingDerivePathPatches.delete(id);
+        for (const field of fnFields) field.pending.delete(id);
       }
     }
   }
@@ -22014,39 +22553,25 @@ function createScene(options) {
     }
     return { ids, removing };
   }
-  function patchClipFromPose(spec, id, { cacheForRedo }) {
-    if (spec.kind === "container" && spec.clipFromPose !== void 0) {
-      state.nodes.get(id).clipFromPose = spec.clipFromPose;
-      if (cacheForRedo) {
-        pendingClipPatches.set(id, spec.clipFromPose);
-      }
+  function patchNodeFunctions(spec, id, { cacheForRedo }) {
+    const node = state.nodes.get(id);
+    if (node === void 0) return;
+    for (const field of fnFields) {
+      const fn = spec[field.spec.field];
+      if (fn === void 0) continue;
+      if (field.spec.containersOnly && spec.kind !== "container") continue;
+      field.write(node, fn);
+      if (cacheForRedo) field.pending.set(id, fn);
     }
   }
-  function patchDerivePath(spec, id, { cacheForRedo }) {
-    if (spec.derivePath === void 0) return;
-    state.nodes.get(id).derivePath = spec.derivePath;
-    if (cacheForRedo) pendingDerivePathPatches.set(id, spec.derivePath);
-  }
   function restoreNodeFunctions(node, keys) {
     if (!keys) return;
-    if (node.derivePath === void 0 && keys.derivePathKey !== void 0) {
-      const fn = registry2.derivePath?.[keys.derivePathKey];
-      if (fn) {
-        node.derivePath = fn;
-        pendingDerivePathPatches.set(node.id, fn);
-      } else {
-        dwarn("scene", `kit:remove: derivePathKey "${keys.derivePathKey}" not in this scene's registry \u2014 node "${node.id}" restored without derived geometry. Register a function with this key in the registry option to restore it.`);
-      }
-    }
-    if (node.kind !== "container" || keys.clipKey === void 0) return;
-    const container = node;
-    if (container.clipFromPose !== void 0) return;
-    const clip = registry2.clipFromPose?.[keys.clipKey];
-    if (clip) {
-      container.clipFromPose = clip;
-      pendingClipPatches.set(node.id, clip);
-    } else {
-      dwarn("scene", `kit:remove: clipKey "${keys.clipKey}" not in this scene's registry \u2014 container "${node.id}" restored without clip. Register a function with this key in the registry option to restore the clip.`);
+    const target = node;
+    for (const field of fnFields) {
+      if (field.read(target) !== void 0) continue;
+      const key = keys[field.spec.opKey];
+      if (key === void 0) continue;
+      restoreFn(field, target, key, "kit:remove", dwarn);
     }
   }
   function registerKitOp(kind, handler) {
@@ -22060,33 +22585,19 @@ function createScene(options) {
       const node = p.kind === "container" ? { kind: "container", id: p.id, layer: p.layer, pose: p.pose, data: p.data, parent: p.parent, children: [] } : { kind: "leaf", id: p.id, layer: p.layer, pose: p.pose, data: p.data, parent: p.parent };
       state.nodes.set(p.id, node);
       attach(p.id, p.parent, p.index);
-      if (p.kind === "container") {
-        const cached = pendingClipPatches.get(p.id);
-        if (cached) {
-          node.clipFromPose = cached;
-        } else if (p.clipKey !== void 0) {
-          const fn = registry2.clipFromPose?.[p.clipKey];
-          if (fn) {
-            node.clipFromPose = fn;
-            pendingClipPatches.set(p.id, fn);
-          } else {
-            dwarn("scene", `kit:add: clipKey "${p.clipKey}" not in this scene's registry \u2014 container "${p.id}" restored without clip. Register a function with this key in the registry option to restore the clip.`);
-          }
-        }
-      }
       if (p.dependsOn !== void 0) node.dependsOn = p.dependsOn;
-      dependents.add(p.id, p.dependsOn ?? []);
-      const cachedDerivePath = pendingDerivePathPatches.get(p.id);
-      if (cachedDerivePath) {
-        node.derivePath = cachedDerivePath;
-      } else if (p.derivePathKey !== void 0) {
-        const fn = registry2.derivePath?.[p.derivePathKey];
-        if (fn) {
-          node.derivePath = fn;
-          pendingDerivePathPatches.set(p.id, fn);
-        } else {
-          dwarn("scene", `kit:add: derivePathKey "${p.derivePathKey}" not in this scene's registry \u2014 node "${p.id}" restored without derived geometry. Register a function with this key in the registry option to restore it.`);
+      if (p.pickable !== void 0) node.pickable = p.pickable;
+      dependents.add(p.id, p.dependsOn === "children" ? [] : p.dependsOn ?? []);
+      trackChildDerived(p.id, p.dependsOn);
+      const target = node;
+      for (const field of fnFields) {
+        const cached = field.pending.get(p.id);
+        if (cached !== void 0) {
+          field.write(target, cached);
+          continue;
         }
+        const key = p[field.spec.opKey];
+        if (key !== void 0) restoreFn(field, target, key, "kit:add", dwarn);
       }
       invalidateDependents(p.id);
     },
@@ -22094,6 +22605,8 @@ function createScene(options) {
       detach(p.id);
       state.nodes.delete(p.id);
       dependents.remove(p.id);
+      childDerived.delete(p.id);
+      invalidateChildDerivedFrom(p.parent);
       invalidateDependents(p.id);
     }
   });
@@ -22103,7 +22616,9 @@ function createScene(options) {
       for (const n of p.nodes) {
         state.nodes.delete(n.id);
         dependents.remove(n.id);
+        childDerived.delete(n.id);
       }
+      for (const d of p.detached) invalidateChildDerivedFrom(d.parent);
     },
     revert: (p) => {
       const keys = new Map((p.fnKeys ?? []).map((k) => [k.id, k]));
@@ -22111,9 +22626,11 @@ function createScene(options) {
         const clone = n.kind === "container" ? { ...n, children: [...n.children] } : { ...n };
         restoreNodeFunctions(clone, keys.get(n.id));
         state.nodes.set(n.id, clone);
-        dependents.add(n.id, clone.dependsOn ?? []);
+        dependents.add(n.id, clone.dependsOn === "children" ? [] : clone.dependsOn ?? []);
+        trackChildDerived(n.id, clone.dependsOn);
       }
       for (const d of p.detached) attach(d.id, d.parent, d.index);
+      for (const d of p.detached) invalidateChildDerivedFrom(d.parent);
     }
   });
   registerKitOp("kit:setPose", {
@@ -22129,9 +22646,11 @@ function createScene(options) {
   registerKitOp("kit:setData", {
     apply: (p) => {
       requireNode(p.id).data = p.to;
+      invalidateDependents(p.id);
     },
     revert: (p) => {
       requireNode(p.id).data = p.from;
+      invalidateDependents(p.id);
     }
   });
   registerKitOp("kit:setLayer", {
@@ -22139,21 +22658,33 @@ function createScene(options) {
       requireLayerIndex(p.to);
       requireNode(p.id).layer = p.to;
       invalidateOrder();
+      invalidateDependents(p.id);
     },
     revert: (p) => {
       requireNode(p.id).layer = p.from;
       invalidateOrder();
+      invalidateDependents(p.id);
+    }
+  });
+  registerKitOp("kit:setDependsOn", {
+    apply: (p) => {
+      retarget(p.id, p.to);
+    },
+    revert: (p) => {
+      retarget(p.id, p.from);
     }
   });
   registerKitOp("kit:move", {
     apply: (p) => {
       detach(p.id);
       attach(p.id, p.toParent, p.toIndex);
+      invalidateChildDerivedFrom(p.fromParent);
       invalidateDependents(p.id);
     },
     revert: (p) => {
       detach(p.id);
       attach(p.id, p.fromParent, p.fromIndex);
+      invalidateChildDerivedFrom(p.toParent);
       invalidateDependents(p.id);
     }
   });
@@ -22426,8 +22957,6 @@ function createScene(options) {
       }
       const sibs = siblingsOf(parent);
       const index = spec.index ?? sibs.length;
-      const clipKey = spec.kind === "container" && spec.clipFromPose !== void 0 ? reverseClipFromPose.get(spec.clipFromPose) : void 0;
-      const derivePathKey = spec.derivePath !== void 0 ? reverseDerivePath.get(spec.derivePath) : void 0;
       executeAndLog("kit:add", {
         id,
         kind: spec.kind,
@@ -22436,12 +22965,11 @@ function createScene(options) {
         data: spec.data,
         parent,
         index,
-        ...clipKey !== void 0 ? { clipKey } : {},
         ...spec.dependsOn !== void 0 ? { dependsOn: spec.dependsOn } : {},
-        ...derivePathKey !== void 0 ? { derivePathKey } : {}
+        ...spec.pickable !== void 0 ? { pickable: spec.pickable } : {},
+        ...fnKeysOf(fnFields, { ...spec, id, kind: spec.kind }, "opKey")
       }, `add ${spec.kind}`);
-      patchClipFromPose(spec, id, { cacheForRedo: true });
-      patchDerivePath(spec, id, { cacheForRedo: true });
+      patchNodeFunctions(spec, id, { cacheForRedo: true });
       return id;
     },
     remove(id) {
@@ -22460,13 +22988,8 @@ function createScene(options) {
       const detached = snapshot.filter((n) => n.parent === null || !removing.has(n.parent)).map((n) => ({ id: n.id, parent: n.parent, index: siblingsOf(n.parent).indexOf(n.id) })).sort((l, r) => l.index - r.index);
       for (const nid of ids) overrides.clear(nid);
       const fnKeys = snapshot.flatMap((n) => {
-        const derivePathKey = n.derivePath !== void 0 ? reverseDerivePath.get(n.derivePath) : void 0;
-        const clipKey = n.kind === "container" && n.clipFromPose !== void 0 ? reverseClipFromPose.get(n.clipFromPose) : void 0;
-        return derivePathKey === void 0 && clipKey === void 0 ? [] : [{
-          id: n.id,
-          ...derivePathKey !== void 0 ? { derivePathKey } : {},
-          ...clipKey !== void 0 ? { clipKey } : {}
-        }];
+        const keys = fnKeysOf(fnFields, n, "opKey");
+        return Object.keys(keys).length === 0 ? [] : [{ id: n.id, ...keys }];
       });
       const payload = {
         nodes: snapshot,
@@ -22516,6 +23039,15 @@ function createScene(options) {
         });
       }
     },
+    setDependsOn(id, dependsOn) {
+      const node = requireNode(id);
+      if (sameDependsOn(node.dependsOn, dependsOn)) return;
+      executeAndLog(
+        "kit:setDependsOn",
+        { id, from: node.dependsOn, to: dependsOn },
+        "setDependsOn"
+      );
+    },
     move(id, parent, index) {
       const node = requireNode(id);
       if (parent !== null) {
@@ -22744,25 +23276,17 @@ function createScene(options) {
           data: n.data
         };
         if (n.parent != null) out.parent = n.parent;
-        if (n.kind === "container" && n.clipFromPose) {
-          const key = reverseClipFromPose.get(n.clipFromPose);
-          if (!key) {
-            throw new Error(
-              `Scene.toJSON: container '${id}' has clipFromPose but no matching registry key. The function must be registered via createScene's registry option to round-trip.`
-            );
-          }
-          out.clipFromPoseKey = key;
-        }
-        if (n.dependsOn && n.dependsOn.length > 0) out.dependsOn = n.dependsOn;
-        if (n.derivePath) {
-          const key = reverseDerivePath.get(n.derivePath);
-          if (!key) {
+        if (n.dependsOn === "children") out.dependsOn = "children";
+        else if (n.dependsOn && n.dependsOn.length > 0) out.dependsOn = n.dependsOn;
+        if (n.pickable === false) out.pickable = false;
+        Object.assign(
+          out,
+          fnKeysOf(fnFields, n, "jsonKey", (field) => {
             throw new Error(
-              `Scene.toJSON: node '${id}' has derivePath but no matching registry key. The function must be registered via createScene's registry option to round-trip.`
+              `Scene.toJSON: node '${id}' has ${field.spec.field} but no matching registry key. The function must be registered via createScene's registry option to round-trip.`
             );
-          }
-          out.derivePathKey = key;
-        }
+          })
+        );
         nodes.push(out);
       }
       const systemLayers = state.layers.map((l) => {
@@ -22794,8 +23318,7 @@ function createScene(options) {
         state.layerIndex.set(spec.id, i);
       }
       history.clear();
-      pendingClipPatches.clear();
-      pendingDerivePathPatches.clear();
+      for (const field of fnFields) field.pending.clear();
       currentBatch = null;
       batchDepth = 0;
       batchDirty = false;
@@ -22833,18 +23356,19 @@ function createScene(options) {
         data: spec.data,
         parent,
         index,
-        ...spec.dependsOn !== void 0 ? { dependsOn: spec.dependsOn } : {}
+        ...spec.dependsOn !== void 0 ? { dependsOn: spec.dependsOn } : {},
+        ...spec.pickable !== void 0 ? { pickable: spec.pickable } : {}
       });
-      patchClipFromPose(spec, id, { cacheForRedo: false });
-      patchDerivePath(spec, id, { cacheForRedo: false });
+      patchNodeFunctions(spec, id, { cacheForRedo: false });
     }
   }
   if (options.initial) {
     applyConstructionSpecs(options.initial);
     notify2();
   }
-  scene.__clipCacheSize = () => pendingClipPatches.size;
-  scene.__derivePathCacheSize = () => pendingDerivePathPatches.size;
+  scene.__clipCacheSize = () => fnField("clipFromPose").pending.size;
+  scene.__derivePathCacheSize = () => fnField("derivePath").pending.size;
+  scene.__derivePoseCacheSize = () => fnField("derivePose").pending.size;
   return scene;
 }
 function specsFromSerialized(json, registry2) {
@@ -22860,24 +23384,21 @@ function specsFromSerialized(json, registry2) {
       data: n.data
     };
     if (n.parent !== void 0) spec.parent = n.parent;
-    if (n.clipFromPoseKey !== void 0) {
-      const fn = registry2.clipFromPose?.[n.clipFromPoseKey];
-      if (!fn) {
-        throw new Error(
-          `Scene: unknown clipFromPose key '${n.clipFromPoseKey}'. Register a function with this key in the registry option.`
-        );
-      }
-      spec.clipFromPose = fn;
-    }
-    if (n.dependsOn !== void 0) spec.dependsOn = n.dependsOn;
-    if (n.derivePathKey !== void 0) {
-      const fn = registry2.derivePath?.[n.derivePathKey];
+    if (n.pickable !== void 0) spec.pickable = n.pickable;
+    if (n.dependsOn !== void 0) {
+      spec.dependsOn = n.dependsOn === "children" ? "children" : n.dependsOn;
+    }
+    const serialized = n;
+    for (const field of NODE_FN_FIELDS) {
+      const key = serialized[field.jsonKey];
+      if (key === void 0) continue;
+      const fn = registry2[field.field]?.[key];
       if (!fn) {
         throw new Error(
-          `Scene: unknown derivePath key '${n.derivePathKey}'. Register a function with this key in the registry option.`
+          `Scene: unknown ${field.field} key '${key}'. Register a function with this key in the registry option.`
         );
       }
-      spec.derivePath = fn;
+      spec[field.field] = fn;
     }
     return spec;
   });
@@ -23864,7 +24385,7 @@ function sceneToAdapter(scene, options = {}) {
       const nid = asNodeId(id);
       const n = scene.get(nid);
       if (!n) throw new Error(`sceneToAdapter: unknown node "${id}"`);
-      return effectivePose(scene.overrides, { id: nid, pose: n.pose });
+      return effectivePose(scene, n);
     },
     getParent(id) {
       const n = scene.get(asNodeId(id));
@@ -23949,11 +24470,10 @@ function sceneToAdapter(scene, options = {}) {
         id: node.id,
         ...index !== void 0 ? { index } : {},
         ...node.parent !== null ? { parent: node.parent } : {},
-        ...node.kind === "container" && node.clipFromPose ? { clipFromPose: node.clipFromPose } : {},
         // Derivation travels with the node, or undo of a delete brings an
         // edge back as a static path that never follows its endpoints again.
         ...node.dependsOn !== void 0 ? { dependsOn: node.dependsOn } : {},
-        ...node.derivePath !== void 0 ? { derivePath: node.derivePath } : {}
+        ...fnFieldsOfNode(node)
       });
     },
     removeNode(id) {
@@ -24183,20 +24703,13 @@ function useSceneSelectTool(args) {
     };
   }, [scene, commitInsert, insertLayer, layouts, selection]);
   const wiredMoveOptions = useMemo(() => {
-    const defaultCascade = (id) => {
-      const n = scene.get(asNodeId(id));
-      return n ? n.pose : null;
-    };
-    const merged = {
-      cascadeWorldPose: defaultCascade,
-      ...moveOptions ?? {}
-    };
+    const merged = { ...moveOptions ?? {} };
     if (snap2) {
       const existing = merged.behaviors ?? [];
       merged.behaviors = [snap(snap2), ...existing];
     }
     return merged;
-  }, [scene, moveOptions, snap2]);
+  }, [moveOptions, snap2]);
   const wiredHitBody = useMemo(() => {
     return (wx, wy, camera) => {
       if (pickEveryProp) {
@@ -24339,7 +24852,7 @@ function usePreviewGhostLayer(args) {
       }
       if (idSet.size === 0) return [];
       const sc = sceneRef.current;
-      const poseOf = scenePoseLookup(sc);
+      const depOf2 = sceneDepLookup(sc);
       const previewPoseFor = (id) => previewPoseIn(sources, id);
       const previewDataFor = (id) => previewDataIn(sources, id);
       const buildSubtree = (id) => {
@@ -24362,7 +24875,7 @@ function usePreviewGhostLayer(args) {
           const clip = findShapeSilhouette(
             effNode,
             effPose,
-            { derivedPath: resolveDerivedPath(effNode, poseOf) }
+            { derivedPath: resolveDerivedPath(effNode, depOf2, (nid) => sc.childrenOf(nid)) }
           );
           if (clip) group.clip = clip;
         }
@@ -27396,12 +27909,12 @@ function sceneAsHierarchy(scene) {
       const node = scene.get(parentId);
       return node && node.kind === "container" ? node.children : [];
     },
-    getPose: (id) => scene.overrides.get(id)?.pose ?? scene.get(id).pose
+    getPose: (id) => effectivePose(scene, scene.get(id))
   };
 }
 function buildSceneViewCommands(scene, view, drawOne, extraCommands, alphaFor) {
   const derived = withDerivedPaths(scene, drawOne);
-  const poseLookup = scenePoseLookup(scene);
+  const depLookup = sceneDepLookup(scene);
   const wrappedDrawOne = (node, pose, v) => {
     const overrideAlpha = scene.overrides.get(node.id)?.alpha ?? 1;
     return wrapNodeOutput(
@@ -27417,7 +27930,8 @@ function buildSceneViewCommands(scene, view, drawOne, extraCommands, alphaFor) {
     void 0,
     ((node) => resolveDerivedPath(
       node,
-      poseLookup
+      depLookup,
+      (id) => scene.childrenOf(id)
     ))
   );
   if (extraCommands && extraCommands.length > 0) {
@@ -27511,6 +28025,44 @@ function SceneViewCanvasInner(props) {
   );
 }
 var SceneViewCanvas = SceneViewCanvasInner;
+var NEVER_SUBSCRIBE = () => () => {
+};
+var DEFAULT_LAYER = "default";
+function isTrivialOptions(options) {
+  return !!options && typeof options === "object" && "items" in options && !("systemLayers" in options);
+}
+function useScene(options) {
+  const sceneRef = useRef(null);
+  if (sceneRef.current === null) {
+    if (isTrivialOptions(options)) {
+      const scene2 = createScene({
+        systemLayers: [{ id: DEFAULT_LAYER }],
+        historyLimit: options.historyLimit,
+        generateId: options.generateId,
+        initial: options.items.map((item) => ({
+          kind: "leaf",
+          layer: DEFAULT_LAYER,
+          pose: item,
+          data: item,
+          id: asNodeId(item.id)
+        }))
+      });
+      sceneRef.current = scene2;
+    } else {
+      sceneRef.current = createScene(
+        options
+      );
+    }
+  }
+  const scene = sceneRef.current;
+  const subscribed = options?.subscribe !== false;
+  useSyncExternalStore(
+    subscribed ? scene.subscribe : NEVER_SUBSCRIBE,
+    scene.getVersion,
+    scene.getVersion
+  );
+  return scene;
+}
 
 // src/canvas/minimapMath.ts
 var DEFAULT_FIT_PADDING = 8;
@@ -27547,7 +28099,7 @@ function sceneLeafBounds(scene, poseBounds) {
   let any = false;
   for (const node of scene.nodes.values()) {
     if (node.kind !== "leaf") continue;
-    const b = poseBounds(node.pose);
+    const b = poseBounds(documentPose(scene, node));
     if (b.x < minX) minX = b.x;
     if (b.y < minY) minY = b.y;
     const right = b.x + b.width;
@@ -28920,9 +29472,10 @@ function useSceneTextEdit(scene, container, options = {}) {
       return get ? get(node.data) : { fill: node.data.fill, stroke: node.data.stroke };
     },
     getScreenPose: (id) => {
-      const node = sceneRef.current.get(asNodeId(id));
+      const scene2 = sceneRef.current;
+      const node = scene2.get(asNodeId(id));
       if (!node) return null;
-      const pose = node.pose;
+      const pose = effectivePose(scene2, node);
       const style = optsRef.current.getStyle ? optsRef.current.getStyle(node.data) : node.data.style;
       const view = resolveView2(optsRef.current.view);
       const zoom = view ? view.scale.x : 1;
@@ -28980,11 +29533,12 @@ function useSceneTextEdit(scene, container, options = {}) {
     for (let i = order.length - 1; i >= 0; i--) {
       const node = order[i];
       const text = readText(node.data);
+      const at = effectivePose(sceneRef.current, node);
       const pose = {
-        x: node.pose.x,
-        y: node.pose.y,
-        width: node.pose.width,
-        height: node.pose.height,
+        x: at.x,
+        y: at.y,
+        width: at.width,
+        height: at.height,
         text,
         runs: readRuns(node.data),
         style: readStyle(node.data)
@@ -29218,6 +29772,54 @@ function polygonPathDistance(path, px, py) {
   }
   return best === Infinity ? Infinity : Math.sqrt(best);
 }
+
+// src/features/paths/pathAt.ts
+function pointAlongPath(path, t, opts = {}) {
+  const polylines = extractPolylines(
+    path,
+    opts.flattenTolerance === void 0 ? {} : { flattenTolerance: opts.flattenTolerance }
+  );
+  const segments = [];
+  let total = 0;
+  let first;
+  for (const pl of polylines) {
+    const count = pl.points.length / 2;
+    if (count === 0) continue;
+    first ??= { x: pl.points[0], y: pl.points[1] };
+    const last2 = pl.closed ? count : count - 1;
+    for (let i = 0; i < last2; i++) {
+      const j = (i + 1) % count;
+      const ax = pl.points[i * 2];
+      const ay = pl.points[i * 2 + 1];
+      const bx = pl.points[j * 2];
+      const by = pl.points[j * 2 + 1];
+      const len = Math.hypot(bx - ax, by - ay);
+      if (len === 0) continue;
+      segments.push({ ax, ay, bx, by, len });
+      total += len;
+    }
+  }
+  if (first === void 0) return null;
+  if (segments.length === 0) return { point: first, tangent: { x: 1, y: 0 } };
+  const target = Math.min(Math.max(t, 0), 1) * total;
+  let walked = 0;
+  for (const seg of segments) {
+    if (walked + seg.len < target) {
+      walked += seg.len;
+      continue;
+    }
+    const u = (target - walked) / seg.len;
+    return {
+      point: { x: seg.ax + (seg.bx - seg.ax) * u, y: seg.ay + (seg.by - seg.ay) * u },
+      tangent: { x: (seg.bx - seg.ax) / seg.len, y: (seg.by - seg.ay) / seg.len }
+    };
+  }
+  const last = segments[segments.length - 1];
+  return {
+    point: { x: last.bx, y: last.by },
+    tangent: { x: (last.bx - last.ax) / last.len, y: (last.by - last.ay) / last.len }
+  };
+}
 var PLACEHOLDER_FILL = { color: "#ffffff" };
 var PLACEHOLDER_STROKE = { paint: { color: "#ffffff" }, width: 1 };
 function resolveOverride(base, override, tMs) {
@@ -30149,44 +30751,6 @@ function useArrayAdapter(options) {
   ref.current = items;
   return arrayAdapter({ ref, ...rest });
 }
-var NEVER_SUBSCRIBE = () => () => {
-};
-var DEFAULT_LAYER = "default";
-function isTrivialOptions(options) {
-  return !!options && typeof options === "object" && "items" in options && !("systemLayers" in options);
-}
-function useScene(options) {
-  const sceneRef = useRef(null);
-  if (sceneRef.current === null) {
-    if (isTrivialOptions(options)) {
-      const scene2 = createScene({
-        systemLayers: [{ id: DEFAULT_LAYER }],
-        historyLimit: options.historyLimit,
-        generateId: options.generateId,
-        initial: options.items.map((item) => ({
-          kind: "leaf",
-          layer: DEFAULT_LAYER,
-          pose: item,
-          data: item,
-          id: asNodeId(item.id)
-        }))
-      });
-      sceneRef.current = scene2;
-    } else {
-      sceneRef.current = createScene(
-        options
-      );
-    }
-  }
-  const scene = sceneRef.current;
-  const subscribed = options?.subscribe !== false;
-  useSyncExternalStore(
-    subscribed ? scene.subscribe : NEVER_SUBSCRIBE,
-    scene.getVersion,
-    scene.getVersion
-  );
-  return scene;
-}
 function useGuides(initial = []) {
   const [guides, setGuides] = useState(initial);
   const ref = useRef(initial);
@@ -31814,6 +32378,6 @@ function mergeContributions(...bundles) {
   return out;
 }
 
-export { ALWAYS, ANCHOR_HIT_BASE_PX, ActionsProviderIfRoot, ActiveToolContextProvider, ActiveToolContextProviderIfRoot, ArrowIcon, BUILTIN_MARKERS, BUNDLE_TOOLS, COARSE_TARGET_SCALE, CURVE_REPS, CanvasView, 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_MAX_ZOOM, DEFAULT_MIN_ZOOM, DEFAULT_PALETTE, DEFAULT_ROTATION_HANDLE_DISTANCE, DEFAULT_SHAPE_FILL, DEFAULT_STROKE_COLOR, DEFAULT_VELOCITY_DECAY, DepRegistryProviderIfRoot, DeviceProfileProvider, DivideIcon, EASINGS, EFFECT_KIT_UNIFORMS, EFFECT_VERT_SRC, EllipseIcon, ExcludeIcon, EyedropperIcon, FALLBACK_FIT_VIEW, GHOST_STROKE, HANDLE_BASE_PX, HandIcon, IDENTITY_COLOR_MATRIX, IDENTITY_JOINT, IDENTITY_POSE_COMPOSITION, ImageIcon, IntersectIcon, KIT_SHAPE_KINDS, KIT_STANDARD_ACTION_IDS, LassoIcon, LineIcon, MIXED, MOVE_ANCHORS, MinimapCanvas, NEVER, OUTLINE_MIN_SCREEN_PX, PAINTED_CURSOR_LAYER_ID, PATH_ANCHOR_CHROME_ID, PenIcon, PencilIcon, PickHud, PointerProviderIfRoot, PolygonIcon, RECT_ALIGN_PROJECTION, ROTATION_HANDLE_BASE_PX, RectIcon, SPRING_PRESETS, SPRITE_STRIDE, SceneCanvas, SceneViewCanvas, SelectIcon, SelectionContextProvider, SelectionContextProviderIfRoot, ShaderCompileError, StarIcon, SubtractIcon, TOOL_PREF_KINDS, TextIcon, UnionIcon, UnknownIcon, VERSION, VIEW_ANIMATION_KEY, WHEEL_ZOOM_STEP, WeaselProvider, WeaselRenderer, _resetMarkersForTests, _resetPaintKindsForTests, aabbCenter, actionIs, actionShortcuts, alignDeltaFor, alignInsertBehavior, alignMoveBehavior, alignResizeBehavior, always, and, animateLifecycle, animateOnSetPose, annulusSemiAxes, applyBooleanOp, applyStyleToRange, areaSelectAction, arrayAdapter, asNodeId, asPaint, axisAlignedBounds, bezierCubic, bezierQuadratic, blendPoses, blur, 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, computeFitView, computeFitViewport, computeIndicatorCommand, computeWheelAction, cond, constrainTo45, containedThenNearest, countPathAnchors, createCellHighlightLayer, createChildrenLayer, createCornerResizeAffordance, createDebugOverlayLayer, createDebugSink, createDispatcher, createGridLayer, createGuidesLayer, createHistory2 as createHistory, createMoveToIndexOp, createNodeProperties, createNodeRouting, createPaintedCursorLayer, createPaintedCursorState, createParallaxLayer, createPathAnchorAffordances, createPathEditingOverlayLayer, createPathLayer, createPenPreviewLayer, createReorderOp, createRotationAffordance, createScene, createSelectionHandlesLayer, createSelectionOutlineLayer, createSelectionOverlayLayer, createSetDataOp, createSetLayerOp, createSetPathOp, createSetTextOp, createTextLayer, createVelocityTracker, createViewResolver, createViewportLayer, cubicBezierEasing, cycleVertexColors, decomposePath, decomposeRectPose, defaultCommitAdapter, defaultDrawOne, defaultLabelTextRenderer, defaultNodeProperties, defaultNodeRouting, defaultVisibilityRules, defineTool, defineViewportTool, deriveAlignmentGuides, deriveParallaxView, describeRule, domPositionToCharOffset, domToRuns, drawLayers, drawOneLayer, 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, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, editAnchorsAction, enterTextEditAction, enumerateAnchors, evaluate, fillInPoseFrame, fillToBoundsFrame, findNodeShape, findShapeInk, findShapeSilhouette, fitTextPose, fitToBounds, fitViewToBounds, fitZoom, focused, forEachCoalesced, frameRect, freeform, gateLayer, gesturing, getAlpha01, getImageBitmap, getMarker, getNodeShapes, getPaintKind, getStylusData, gradientForBounds, gradientGeometry, hexToRgba, hitAffordanceRegions, hitAnchor, hitRotationHandle, hostAnchorCss, hostAnchorRect, hovering, hoveringSelected, imageStatus, inferredNodeProperties, inferredNodeRouting, insertAction, interpolateView, isBuiltinToolPref, isEditableTarget, isGradientFill, isLayerPainted, isLayerVisible, isPatternSpec, keySpecShortcut, lassoSelectAction, lerpColorArray, lerpOklab, lerpOklch, linear, listMarkers, listPaintKinds, liveScope, makePinchZoomAction, makeViewportWheelPanAction, makeViewportZoomAction, markerDrawCommands, markerInset, markerKeyOf, markerSites, mat3, matchAlignment, matchesKeyBinding, meanScale, mergeAlphaFromPrev, mergeContributions, modeIn, modeIs, modeNot, modifierHeld, momentum, moveAction, multiActive, nearest, nearestWithin, nestedHitTester, never, nodeHasFlag, none, normalizeHex, not, nurbs, oklabToOklch, oklabToSrgbU8, oklchToOklab, openFilePicker, openPointerSession, or, paintAlpha, paintKindOf, paintWithAlpha, paintWithColor, 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, registerEffect, registerMarker, registerNodeShape, registerPaintKind, registerProgram, renderLabel, renderSceneToCanvas, renderSceneToPixels, resizeAction, resolveColor, resolveDeviceProfile, resolveEasing, resolveFillPattern, resolveMarkerSize, resolveParams, resolvePatternSpec, resolveSkeleton, resolveStrokeWidth, resolveVisibility, rgbaToHex, rotateAction, rotateAroundAABBCenter, rotatePathAround, rotatePoint, rotatedRectCorners, rotationDegreesUnit, rotationHandle, roundToCell, runsToDom, sampleGradientStops, sampleTrack, sceneFromJSON, sceneNodeClientRect, sceneSelectionStore, sceneToAdapter, scopeBindings, screenToWorld, selectFromLasso, selectionAtLeast, selectionEmpty, selectionIs, setFlagOverRange, shapeCoversPoint, sliceAction, snapPoint, solid, solidVertexColors, specificity, spiro, splitPathByLine, splitSubpaths, springPose, springVertexColors, srgbU8ToOklab, staggerVertexColors, startThresholdDrag, strokeInsets, strokeOf, strokeWith, styleAtRange, subscribeImageReady, tessellate, tessellateStroke, textCommand, textCommandFromRuns, tileGrid, toHex8, translatePoseViaDescriptor, translateRectPose, trimPolyline, tweenPose, tweenVertexColors, unionAABB, 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, useHostAnchor, useHoverTracking, useImageTool, useKeybindings, useLassoTool, useLineTool, useNodeOverlayFrame, useOptionalActiveToolContext, usePenTool, usePencilTool, usePinchGesture, usePointerStylus, usePolygonTool, usePublishSelection, useRectTool, useResizePolicy, useRotateTool, useScene, useSceneAdapter, useSceneTextEdit, useSelectTool, useSelection, useSelectionContext, useSimulation, useSliceDep, useStandardActions, useStarTool, useTextEdit, useTextTool, useTools, useVelocityTracker, useViewAnimation, useVisibleRaf, viewToMat3, viewToTransform, viewportDragPanAction, viewportWheelPanAction, viewportZoomAction, viewportsAt, vignette, visualBoundsViaDescriptor, wheelPan, wheelZoom, wheelZoomFactor, when, withAlpha01, withCoord, withGradientKind, worldEditToStorage, worldPoseLookup, worldToScreen, zoomAt, zoomAtLeast };
-//# sourceMappingURL=chunk-WYPSGIYS.js.map
-//# sourceMappingURL=chunk-WYPSGIYS.js.map
+export { ALWAYS, ANCHOR_HIT_BASE_PX, ActionsProviderIfRoot, ActiveToolContextProvider, ActiveToolContextProviderIfRoot, ArrowIcon, BUILTIN_MARKERS, BUNDLE_TOOLS, COARSE_TARGET_SCALE, CURVE_REPS, CanvasView, 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_MAX_ZOOM, DEFAULT_MIN_ZOOM, DEFAULT_PALETTE, DEFAULT_ROTATION_HANDLE_DISTANCE, DEFAULT_SHAPE_FILL, DEFAULT_STROKE_COLOR, DEFAULT_VELOCITY_DECAY, DepRegistryProviderIfRoot, DeviceProfileProvider, DivideIcon, EASINGS, EFFECT_KIT_UNIFORMS, EFFECT_VERT_SRC, EllipseIcon, ExcludeIcon, EyedropperIcon, FALLBACK_FIT_VIEW, GHOST_STROKE, HANDLE_BASE_PX, HandIcon, IDENTITY_COLOR_MATRIX, IDENTITY_JOINT, IDENTITY_POSE_COMPOSITION, ImageIcon, IntersectIcon, KIT_SHAPE_KINDS, KIT_STANDARD_ACTION_IDS, LassoIcon, LineIcon, MIXED, MOVE_ANCHORS, MinimapCanvas, NEVER, OUTLINE_MIN_SCREEN_PX, PAINTED_CURSOR_LAYER_ID, PATH_ANCHOR_CHROME_ID, PenIcon, PencilIcon, PickHud, PointerProviderIfRoot, PolygonIcon, RECT_ALIGN_PROJECTION, ROTATION_HANDLE_BASE_PX, RectIcon, SPRING_PRESETS, SPRITE_STRIDE, SceneCanvas, SceneViewCanvas, SelectIcon, SelectionContextProvider, SelectionContextProviderIfRoot, ShaderCompileError, StarIcon, SubtractIcon, TOOL_PREF_KINDS, TextIcon, UNION_OF_CHILDREN, UnionIcon, UnknownIcon, VERSION, VIEW_ANIMATION_KEY, WHEEL_ZOOM_STEP, WeaselProvider, WeaselRenderer, _resetMarkersForTests, _resetPaintKindsForTests, aabbCenter, actionIs, actionShortcuts, alignDeltaFor, alignInsertBehavior, alignMoveBehavior, alignResizeBehavior, always, and, animateLifecycle, animateOnSetPose, annulusSemiAxes, applyBooleanOp, applyStyleToRange, areaSelectAction, arrayAdapter, asNodeId, asPaint, axisAlignedBounds, bezierCubic, bezierQuadratic, blendPoses, blur, 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, computeFitView, computeFitViewport, computeIndicatorCommand, computeWheelAction, cond, constrainTo45, containedThenNearest, countPathAnchors, createCellHighlightLayer, createChildrenLayer, createCornerResizeAffordance, createDebugOverlayLayer, createDebugSink, createDispatcher, createGridLayer, createGuidesLayer, createHistory2 as createHistory, createMoveToIndexOp, createNodeProperties, createNodeRouting, createPaintedCursorLayer, createPaintedCursorState, createParallaxLayer, createPathAnchorAffordances, createPathEditingOverlayLayer, createPathLayer, createPenPreviewLayer, createPoseOverrides, createReorderOp, createRotationAffordance, createScene, createSelectionHandlesLayer, createSelectionOutlineLayer, createSelectionOverlayLayer, createSetDataOp, createSetLayerOp, createSetPathOp, createSetTextOp, createSimulation, createTextLayer, createVelocityTracker, createViewResolver, createViewportLayer, cubicBezierEasing, cycleVertexColors, decomposePath, decomposeRectPose, defaultCommitAdapter, defaultDrawOne, defaultLabelTextRenderer, defaultNodeProperties, defaultNodeRouting, defaultVisibilityRules, defineTool, defineViewportTool, deriveAlignmentGuides, deriveParallaxView, derivedDepOf, derivedPose, describeRule, documentPose, domPositionToCharOffset, domToRuns, drawLayers, drawOneLayer, 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, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, editAnchorsAction, effectivePose, enterTextEditAction, enumerateAnchors, evaluate, fillInPoseFrame, fillToBoundsFrame, findNodeShape, findShapeInk, findShapeSilhouette, fitTextPose, fitToBounds, fitViewToBounds, fitZoom, focused, forEachCoalesced, frameRect, freeform, gateLayer, gesturing, getAlpha01, getImageBitmap, getMarker, getNodeShapes, getPaintKind, getStylusData, gradientForBounds, gradientGeometry, hexToRgba, hitAffordanceRegions, hitAnchor, hitRotationHandle, hostAnchorCss, hostAnchorRect, hovering, hoveringSelected, imageStatus, inferredNodeProperties, inferredNodeRouting, insertAction, interpolateView, isBuiltinToolPref, isEditableTarget, isGradientFill, isLayerPainted, isLayerVisible, isPatternSpec, keySpecShortcut, lassoSelectAction, lerpColorArray, lerpOklab, lerpOklch, linear, listMarkers, listPaintKinds, liveScope, makePinchZoomAction, makeViewportWheelPanAction, makeViewportZoomAction, markerDrawCommands, markerInset, markerKeyOf, markerSites, mat3, matchAlignment, matchesKeyBinding, meanScale, mergeAlphaFromPrev, mergeContributions, modeIn, modeIs, modeNot, modifierHeld, momentum, moveAction, multiActive, nearest, nearestWithin, nestedHitTester, never, nodeHasFlag, none, normalizeHex, not, nurbs, oklabToOklch, oklabToSrgbU8, oklchToOklab, openFilePicker, openPointerSession, or, paintAlpha, paintKindOf, paintWithAlpha, paintWithColor, parseColor, parseColorToRgba255, parseDebugFlags, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathDistanceToPoint, pathDivide, pathExclude, pathFromD, pathInPoseFrame, pathInWorld, pathIntersect, pathIntersectsPolygon, pathIntersectsRect, pathOriginProjection, pathSubtract, pathToAnchors, pathUnion, pickTopMostHit, pinchZoomAction, planPixelRender, pointAlongPath, pointInRotatedRect, pointInTextPose, poseRotationOf, pressureToWidth, rainbowVertexColors, rebaseLocalPose, rectCorners, registerContentHandler, registerEffect, registerMarker, registerNodeShape, registerPaintKind, registerProgram, renderLabel, renderSceneToCanvas, renderSceneToPixels, resizeAction, resolveColor, resolveDeviceProfile, resolveEasing, resolveFillPattern, resolveMarkerSize, resolveParams, resolvePatternSpec, resolveSkeleton, resolveStrokeWidth, resolveVisibility, rgbaToHex, rotateAction, rotateAroundAABBCenter, rotatePathAround, rotatePoint, rotatedRectCorners, rotationDegreesUnit, rotationHandle, roundToCell, runsToDom, sampleGradientStops, sampleTrack, sceneFromJSON, sceneNodeClientRect, sceneSelectionStore, sceneToAdapter, scopeBindings, screenToWorld, selectFromLasso, selectionAtLeast, selectionEmpty, selectionIs, setFlagOverRange, shapeCoversPoint, sliceAction, snapPoint, solid, solidVertexColors, specificity, spiro, splitPathByLine, splitSubpaths, springPose, springVertexColors, srgbU8ToOklab, staggerVertexColors, startThresholdDrag, strokeInsets, strokeOf, strokeWith, styleAtRange, subscribeImageReady, tessellate, tessellateStroke, textCommand, textCommandFromRuns, tileGrid, toHex8, translatePoseViaDescriptor, translateRectPose, trimPolyline, tweenPose, tweenVertexColors, unionAABB, unionBounds, unionBoundsPath, unionOfChildren, useActiveToolContext, useAlign, useAnimator, useArrayAdapter, useAutoCenter, useBooleans, useBooleansAdapter, useCanvasFocus, useCanvasSize, useDecayLoop, useDeviceProfile, useDistribute, useDragGesture, useDragHandle, useDragRadial, useDragRect, useDropZone, useEllipseTool, useEyedropperTool, useGestureDispatcher, useGridCellHover, useGuides, useHandTool, useHandleDrag, useHostAnchor, useHoverTracking, useImageTool, useKeybindings, useLassoTool, useLineTool, useNodeOverlayFrame, useOptionalActiveToolContext, usePenTool, usePencilTool, usePinchGesture, usePointerStylus, usePolygonTool, usePoseRun, usePublishSelection, useRectTool, useResizePolicy, useRotateTool, useScene, useSceneAdapter, useSceneTextEdit, useSelectTool, useSelection, useSelectionContext, useSimulation, useSliceDep, useStandardActions, useStarTool, useTextEdit, useTextTool, useTools, useVelocityTracker, useViewAnimation, useVisibleRaf, viewToMat3, viewToTransform, viewportDragPanAction, viewportWheelPanAction, viewportZoomAction, viewportsAt, vignette, visualBoundsViaDescriptor, wheelPan, wheelZoom, wheelZoomFactor, when, withAlpha01, withCoord, withGradientKind, worldEditToStorage, worldPoseLookup, worldToScreen, zoomAt, zoomAtLeast };
+//# sourceMappingURL=chunk-R3AWPTLZ.js.map
+//# sourceMappingURL=chunk-R3AWPTLZ.js.map