@weasel-js/core 1.4.0-pre.1 → 1.4.1

package/dist/{chunk-FUQWXDG3.js → chunk-NU7D64RL.js}

@@ -1,4 +1,4 @@
-import { ActionDisabledReason, useOptionalDepRegistry, DepRegistryProvider, useActionsRegistry, ActionsProvider, useDepRegistry, reportRouteConflicts, buildDepsFromRequires, useDepSource, actionBindings } from './chunk-H6E6KPTU.js';
+import { ActionDisabledReason, useOptionalDepRegistry, DepRegistryProvider, useActionsRegistry, ActionsProvider, useDepRegistry, reportRouteConflicts, buildDepsFromRequires, useDepSource, actionBindings } from './chunk-TORKRNFY.js';
 import { scratchKey, createTransformOp, snap, getScratch, createReparentOp, setScratch } from './chunk-Y5KS66G7.js';
 import { fixedCornerOf, DEFAULT_RESIZE_BEHAVIORS, CORNER_ANCHORS, cornerPoint } from './chunk-BLJNRMKB.js';
 import { AUTO_POSE_DESCRIPTOR, resolveUnit, polylineFromPoints, starPath, regularPolygonPath, linePath, ellipsePath, rectPath, polygonFromPoints, PATH_M, PATH_L, PATH_Z, RECT_POSE_DESCRIPTOR, pathPoseDescriptor, withinPxRadius, boundsOfPath, PATH_Q, PATH_C, DEFAULT_FLATTEN_TOLERANCE, flattenQuadratic, flattenCubic, PathBuilder, pointInPath, strokeHitTest, transformPath, translatePath, pxExtent, remapRotatedLeaf, withinPxBox, flattenCubicWithArcLen, flattenQuadraticWithArcLen, PATH_CMD_LENGTHS, pointToGridCell } from './chunk-SBFC6J3C.js';
@@ -6,7 +6,7 @@ import { dispatchApplyBatch, dlog, dwarn, usePointerContext, PointerContextProvi
 import { createSetSelectionOp } from './chunk-ZB7UYJVG.js';
 import { registerOpFactory, createDeleteOp, createInsertOp, rebuildOp } from './chunk-2KKYDDDD.js';
 import { getTexture, chunks, dots, crosshatch, hatch } from './chunk-BJN5ZRIJ.js';
-import { createContext, createElement, forwardRef, useMemo, useRef, useCallback, useState, useImperativeHandle, useSyncExternalStore, useEffect, useLayoutEffect, useContext, useId, useReducer } from 'react';
+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';
 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';
@@ -19,12 +19,13 @@ import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 import polygonClipping from 'polygon-clipping';
 import { matchSpec, RESERVED_ID_PREFIXES, RESERVED_ID_NAMES, parseTargetSpec, mimeMatchesGlob } from '@weasel-js/gestures';
 import { NORMAL, IMPLICIT_TAGS } from '@weasel-js/modes';
-import { cursorFor } from '@weasel-js/cursor';
+import { GLYPHS, cursorWorldSize, cursorPaintOps, chromeLineWidthScale, cursorPaintMatrix, resolveCursorTier, cursorFor, resolveCursor } from '@weasel-js/cursor';
+export { bakeCursor, cursorFor, resolveCursor, resolveCursorTier } from '@weasel-js/cursor';
 import { createHistory } from '@weasel-js/history';
 export * from '@weasel-js/history';
 
 // src/version.ts
-var VERSION = "1.4.0-pre.1" ;
+var VERSION = "1.4.1" ;
 
 // src/features/grid/roundToCell.ts
 function roundToCell(value, cellSize) {
@@ -257,6 +258,44 @@ void main() {
 }
 `
 );
+var IMAGE_VOPACITY_VERT_SRC = (
+  /* glsl */
+  `#version 300 es
+in vec2 a_position;
+in vec2 a_uv;
+in float a_opacity;
+uniform mat3 u_proj;
+uniform mat3 u_model;
+out vec2 v_uv;
+out float v_opacity;
+void main() {
+  vec3 screen = u_model * vec3(a_position, 1.0);
+  vec3 clip   = u_proj  * vec3(screen.xy, 1.0);
+  gl_Position = vec4(clip.xy, 0.0, 1.0);
+  v_uv = a_uv;
+  v_opacity = a_opacity;
+}
+`
+);
+var IMAGE_VOPACITY_FRAG_SRC = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+in vec2 v_uv;
+in float v_opacity;
+uniform sampler2D u_sampler;
+uniform float u_alpha;
+uniform mat4 u_colorMatrix;
+uniform vec4 u_colorBias;
+out vec4 outColor;
+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;
+  outColor = vec4(mapped.rgb * a, a);
+}
+`
+);
 var IMAGE_FILL_UNIFORMS = [
   "u_proj",
   "u_model",
@@ -267,6 +306,15 @@ var IMAGE_FILL_UNIFORMS = [
   "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 IMAGE_VOPACITY_ATTRIBUTES = ["a_position", "a_uv", "a_opacity"];
 
 // src/renderer/shaders/gradFill.ts
 var GRAD_VERT_SRC = (
@@ -1516,6 +1564,9 @@ function _resetPaintKindsForTests() {
   seedBuiltins();
   bumpNodeMemoGeneration();
 }
+
+// src/renderer/DrawCommand.ts
+var SPRITE_STRIDE = 9;
 function tessellate(path, opts = {}) {
   if (path.kind === "rect") return tessellateRect(path);
   return tessellatePolygon(path, opts);
@@ -3240,6 +3291,210 @@ 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;
+}
+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 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/draw.ts
 var FRAME_UPLOADS = /* @__PURE__ */ new WeakMap();
 var FRAME_PROJ = /* @__PURE__ */ new WeakMap();
@@ -3334,13 +3589,14 @@ function dispatch(ctx, cmd) {
     case "path":
       return drawPath(ctx, cmd);
     case "text":
-      flushSolids(ctx);
+      flushBatches(ctx);
       return drawText(ctx, cmd);
     case "image":
-      flushSolids(ctx);
       return drawImage(ctx, cmd);
+    case "sprites":
+      return drawSprites(ctx, cmd);
     case "shader":
-      flushSolids(ctx);
+      flushBatches(ctx);
       return drawShader(ctx, cmd);
   }
 }
@@ -3517,6 +3773,7 @@ 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) {
@@ -3560,7 +3817,7 @@ function tryStageSolid(ctx, mesh, paint) {
     pushMesh(ctx, mesh, paint);
     return true;
   }
-  flushSolids(ctx);
+  flushBatches(ctx);
   return false;
 }
 function flushSolids(ctx) {
@@ -3581,6 +3838,56 @@ function flushSolids(ctx) {
   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
+    };
+  }
+}
+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);
+  applyClipTest(ctx, staged.clipDepth);
+  gl.drawElements(gl.TRIANGLES, indexCount, gl.UNSIGNED_INT, 0);
+  gl.bindVertexArray(null);
+  batch.reset();
+  ctx.imageState = void 0;
+}
+function flushBatches(ctx) {
+  flushSolids(ctx);
+  flushImages(ctx);
+}
 function expandAnchorColors(perAnchor, handle) {
   const aA = handle.anchorA;
   const aB = handle.anchorB;
@@ -3784,7 +4091,7 @@ function rasterizePathToStencil(ctx, path) {
   gl.bindVertexArray(null);
 }
 function pushClip(ctx, path, newDepth) {
-  flushSolids(ctx);
+  flushBatches(ctx);
   const gl = ctx.gl;
   const ancestors = ancestorMask(newDepth - 1);
   const newBit = 1 << newDepth;
@@ -3799,7 +4106,7 @@ function pushClip(ctx, path, newDepth) {
   gl.stencilMask(255);
 }
 function popClip(ctx, path, oldDepth) {
-  flushSolids(ctx);
+  flushBatches(ctx);
   const gl = ctx.gl;
   gl.enable(gl.STENCIL_TEST);
   const oldBit = 1 << oldDepth + 1;
@@ -3846,7 +4153,7 @@ function drawPathStroke(ctx, rawCmd) {
   const stroke = cmd.stroke;
   const align = stroke.align ?? "center";
   if (cmd.path.kind === "polygon" && align !== "center") {
-    flushSolids(ctx);
+    flushBatches(ctx);
     drawPathStrokeStenciled(ctx, cmd, align);
     return;
   }
@@ -4194,45 +4501,6 @@ function drawTextGroup(ctx, group, prog, dx, dy) {
   gl.drawElements(gl.TRIANGLES, group.quads.length * 6, gl.UNSIGNED_INT, 0);
   gl.bindVertexArray(null);
 }
-var IMAGE_QUAD_RING_SIZE = 64;
-var IMAGE_QUAD_RINGS = /* @__PURE__ */ new WeakMap();
-var IMAGE_QUAD_INDICES = new Uint32Array([0, 1, 2, 1, 3, 2]);
-var IMAGE_QUAD_STRIDE = 16;
-function imageQuadRing(gl, prog) {
-  const existing = IMAGE_QUAD_RINGS.get(prog);
-  if (existing) return existing;
-  const aPosLoc = prog.attribute("a_position");
-  const aUvLoc = prog.attribute("a_uv");
-  const ibo = gl.createBuffer();
-  if (!ibo) throw new Error("drawImage: createBuffer (IBO) returned null");
-  const vaos = [];
-  const vbos = [];
-  for (let slot = 0; slot < IMAGE_QUAD_RING_SIZE; slot++) {
-    const vao = gl.createVertexArray();
-    const vbo = gl.createBuffer();
-    if (!vao) throw new Error("drawImage: createVertexArray returned null");
-    if (!vbo) throw new Error("drawImage: createBuffer returned null");
-    gl.bindVertexArray(vao);
-    gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
-    gl.bufferData(gl.ARRAY_BUFFER, 4 * IMAGE_QUAD_STRIDE, gl.DYNAMIC_DRAW);
-    if (aPosLoc !== void 0) {
-      gl.enableVertexAttribArray(aPosLoc);
-      gl.vertexAttribPointer(aPosLoc, 2, gl.FLOAT, false, IMAGE_QUAD_STRIDE, 0);
-    }
-    if (aUvLoc !== void 0) {
-      gl.enableVertexAttribArray(aUvLoc);
-      gl.vertexAttribPointer(aUvLoc, 2, gl.FLOAT, false, IMAGE_QUAD_STRIDE, 8);
-    }
-    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ibo);
-    if (slot === 0) gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, IMAGE_QUAD_INDICES, gl.STATIC_DRAW);
-    gl.bindVertexArray(null);
-    vaos.push(vao);
-    vbos.push(vbo);
-  }
-  const ring = { vaos, vbos, ibo, next: 0 };
-  IMAGE_QUAD_RINGS.set(prog, ring);
-  return ring;
-}
 var TEXT_QUAD_RING_SIZE = 64;
 var TEXT_QUAD_RINGS = /* @__PURE__ */ new WeakMap();
 function grownTo(need) {
@@ -4310,22 +4578,9 @@ function disposeTextQuads(gl, prog) {
   gl.deleteBuffer(ring.ibo);
   TEXT_QUAD_RINGS.delete(prog);
 }
-function disposeImageQuads(gl, prog) {
-  const ring = IMAGE_QUAD_RINGS.get(prog);
-  if (!ring) return;
-  for (const vao of ring.vaos) gl.deleteVertexArray(vao);
-  for (const vbo of ring.vbos) gl.deleteBuffer(vbo);
-  gl.deleteBuffer(ring.ibo);
-  IMAGE_QUAD_RINGS.delete(prog);
-}
-var IMAGE_QUAD_VERTICES = new Float32Array(16);
 function drawImage(ctx, cmd) {
   ctx.imageCache.upload(cmd.image, cmd.image);
-  const gl = ctx.gl;
-  const prog = ctx.imageFill;
-  gl.useProgram(prog.handle);
-  const x0 = cmd.x, y0 = cmd.y;
-  const x1 = cmd.x + cmd.w, y1 = cmd.y + cmd.h;
+  stageImage(ctx, cmd.image, cmd.sampling ?? "linear");
   const src = cmd.source;
   let u0 = 0, v0 = 0, u1 = 1, v1 = 1;
   if (src) {
@@ -4345,43 +4600,50 @@ function drawImage(ctx, cmd) {
     v0 = v1;
     v1 = t;
   }
-  const v = IMAGE_QUAD_VERTICES;
-  v[0] = x0;
-  v[1] = y0;
-  v[2] = u0;
-  v[3] = v0;
-  v[4] = x1;
-  v[5] = y0;
-  v[6] = u1;
-  v[7] = v0;
-  v[8] = x0;
-  v[9] = y1;
-  v[10] = u0;
-  v[11] = v1;
-  v[12] = x1;
-  v[13] = y1;
-  v[14] = u1;
-  v[15] = v1;
-  const ring = imageQuadRing(gl, prog);
-  const slot = ring.next;
-  ring.next = (slot + 1) % IMAGE_QUAD_RING_SIZE;
-  gl.bindVertexArray(ring.vaos[slot]);
-  gl.bindBuffer(gl.ARRAY_BUFFER, ring.vbos[slot]);
-  gl.bufferSubData(gl.ARRAY_BUFFER, 0, v);
-  setProjAndModel(ctx, prog);
-  setColorMatrixUniforms(ctx, prog);
-  ctx.imageCache.bind(cmd.image, 0);
-  gl.texParameteri(
-    gl.TEXTURE_2D,
-    gl.TEXTURE_MAG_FILTER,
-    cmd.sampling === "nearest" ? gl.NEAREST : gl.LINEAR
+  ctx.imageBatch.pushQuad(
+    cmd.x,
+    cmd.y,
+    cmd.w,
+    cmd.h,
+    ctx.state.transform,
+    u0,
+    v0,
+    u1,
+    v1,
+    (cmd.opacity ?? 1) * ctx.state.alpha
   );
-  gl.uniform1i(prog.uniform("u_sampler"), 0);
-  gl.uniform1f(prog.uniform("u_opacity"), cmd.opacity ?? 1);
-  setAlphaUniform(ctx, prog, ctx.state.alpha);
-  applyClipTest(ctx);
-  gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_INT, 0);
-  gl.bindVertexArray(null);
+}
+function drawSprites(ctx, cmd) {
+  const data = cmd.sprites;
+  const count = Math.floor(data.length / SPRITE_STRIDE);
+  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;
+  const m = ctx.state.transform;
+  const groupAlpha = ctx.state.alpha;
+  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);
+    }
+    const sx = data[i + 4], sy = data[i + 5], sw = data[i + 6], sh = data[i + 7];
+    batch.pushQuad(
+      data[i],
+      data[i + 1],
+      data[i + 2],
+      data[i + 3],
+      m,
+      sx / tw,
+      sy / th,
+      (sx + sw) / tw,
+      (sy + sh) / th,
+      data[i + 8] * groupAlpha
+    );
+  }
 }
 
 // src/renderer/shaders/customPrelude.ts
@@ -4484,6 +4746,7 @@ var WeaselRenderer = class {
   textSdf;
   textSdfR8;
   imageFill;
+  imageFillVOpacity;
   gradFill;
   patternFill;
   meshCache;
@@ -4494,6 +4757,7 @@ var WeaselRenderer = class {
   quadVbo = null;
   quadIbo = null;
   solidBatch;
+  imageBatch;
   groupState = new GroupState();
   widthCss;
   heightCss;
@@ -4558,6 +4822,13 @@ var WeaselRenderer = class {
     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.gradFill = new ShaderProgram(this.gl, GRAD_VERT_SRC, GRAD_FRAG_SRC);
     this.gradFill.lookupUniforms(GRAD_FILL_UNIFORMS);
     this.gradFill.lookupAttributes(GRAD_FILL_ATTRIBUTES);
@@ -4572,6 +4843,7 @@ var WeaselRenderer = class {
     this.gradRampCache = new GradientRampCache(this.gl);
     this.uploadQuadGeometry();
     this.solidBatch = new SolidBatch(this.gl, this.pathFillVColor);
+    this.imageBatch = new ImageBatch(this.gl, this.imageFillVOpacity);
   }
   uploadQuadGeometry() {
     const gl = this.gl;
@@ -4695,6 +4967,13 @@ var WeaselRenderer = class {
     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.gradFill = new ShaderProgram(this.gl, GRAD_VERT_SRC, GRAD_FRAG_SRC);
     this.gradFill.lookupUniforms(GRAD_FILL_UNIFORMS);
     this.gradFill.lookupAttributes(GRAD_FILL_ATTRIBUTES);
@@ -4710,6 +4989,7 @@ var WeaselRenderer = class {
     markAllFontsNotUploaded();
     this.uploadQuadGeometry();
     this.solidBatch = new SolidBatch(this.gl, this.pathFillVColor);
+    this.imageBatch = new ImageBatch(this.gl, this.imageFillVOpacity);
     for (const id of this.programRegistry.keys()) {
       const src = getProgramSource(id);
       if (!src) continue;
@@ -4758,7 +5038,7 @@ var WeaselRenderer = class {
     }
     this.meshCache.freeTransient();
     this.meshCache.drainPendingDeletes();
-    for (const prog of [this.pathFill, this.pathFillVColor, this.textSdf, this.textSdfR8, this.imageFill, this.gradFill, this.patternFill]) {
+    for (const prog of [this.pathFill, this.pathFillVColor, this.textSdf, this.textSdfR8, this.imageFill, this.imageFillVOpacity, this.gradFill, this.patternFill]) {
       gl.deleteProgram(prog.handle);
     }
     for (const prog of this.programRegistry.values()) {
@@ -4769,9 +5049,9 @@ var WeaselRenderer = class {
     this.gradRampCache.free();
     if (this.quadVbo) gl.deleteBuffer(this.quadVbo);
     if (this.quadIbo) gl.deleteBuffer(this.quadIbo);
-    disposeImageQuads(gl, this.imageFill);
     for (const prog of [this.textSdf, this.textSdfR8, this.pathFill]) disposeTextQuads(gl, prog);
     this.solidBatch.dispose();
+    this.imageBatch.dispose();
   }
   /**
    * Draw one frame.
@@ -4800,6 +5080,7 @@ var WeaselRenderer = class {
       textSdf: this.textSdf,
       textSdfR8: this.textSdfR8,
       imageFill: this.imageFill,
+      imageFillVOpacity: this.imageFillVOpacity,
       gradFill: this.gradFill,
       patternFill: this.patternFill,
       meshCache: this.meshCache,
@@ -4811,6 +5092,7 @@ var WeaselRenderer = class {
       quadVbo: this.quadVbo,
       quadIbo: this.quadIbo,
       solidBatch: this.solidBatch,
+      imageBatch: this.imageBatch,
       state: this.groupState,
       widthCss: this.widthCss,
       heightCss: this.heightCss,
@@ -4820,7 +5102,7 @@ var WeaselRenderer = class {
       viewMatrix: viewMatrix2
     };
     for (const cmd of commands) dispatch(ctx, cmd);
-    flushSolids(ctx);
+    flushBatches(ctx);
     this.meshCache.freeTransient();
   }
   resize(dims) {
@@ -4854,6 +5136,10 @@ var WeaselRenderer = class {
     return this.solidBatch;
   }
   /** @internal */
+  _imageBatch() {
+    return this.imageBatch;
+  }
+  /** @internal */
   _textSdf() {
     return this.textSdf;
   }
@@ -4866,6 +5152,10 @@ var WeaselRenderer = class {
     return this.imageFill;
   }
   /** @internal */
+  _imageFillVOpacity() {
+    return this.imageFillVOpacity;
+  }
+  /** @internal */
   _gradFill() {
     return this.gradFill;
   }
@@ -5914,6 +6204,86 @@ function clientToCanvasRect(rect, clientX, clientY) {
   return [clientX - rect.left, clientY - rect.top];
 }
 
+// src/interactions/gestures/pointerSession/recovery.ts
+var LOST_CAPTURE_EVENT = "lostpointercapture";
+function reportsButtons(down) {
+  return !!down.buttons;
+}
+function isMissedRelease(move) {
+  return move.buttons === 0;
+}
+
+// src/interactions/gestures/pointerSession/pointerSession.ts
+function openPointerSession(origin, down, cb, opts = {}) {
+  const pointerId = down.pointerId;
+  const doc = origin.ownerDocument ?? document;
+  const buttonsReported = reportsButtons(down);
+  let active = true;
+  const teardown = () => {
+    active = false;
+    doc.removeEventListener("pointermove", onMove, true);
+    doc.removeEventListener("pointerup", onUp, true);
+    doc.removeEventListener("pointercancel", onPointerCancel, true);
+    doc.removeEventListener("pointerdown", onRepress, true);
+    origin.removeEventListener(LOST_CAPTURE_EVENT, onLostCapture);
+    if (opts.capture !== false) {
+      try {
+        origin.releasePointerCapture?.(pointerId);
+      } catch {
+      }
+    }
+  };
+  const mine = (e) => e.pointerId === pointerId;
+  const end = (e) => {
+    if (!active) return;
+    teardown();
+    cb.onEnd?.(e);
+  };
+  const abort = (reason) => {
+    if (!active) return;
+    teardown();
+    cb.onCancel?.(reason);
+  };
+  function onMove(e) {
+    if (!active || !mine(e)) return;
+    if (buttonsReported && isMissedRelease(e)) {
+      end(e);
+      return;
+    }
+    cb.onMove?.(e);
+  }
+  function onUp(e) {
+    if (mine(e)) end(e);
+  }
+  function onPointerCancel(e) {
+    if (mine(e)) abort("pointercancel");
+  }
+  function onRepress(e) {
+    if (mine(e)) abort("superseded");
+  }
+  function onLostCapture(e) {
+    if (e.pointerId === pointerId) abort("lostcapture");
+  }
+  if (opts.capture !== false) {
+    try {
+      origin.setPointerCapture?.(pointerId);
+    } catch {
+    }
+  }
+  doc.addEventListener("pointermove", onMove, true);
+  doc.addEventListener("pointerup", onUp, true);
+  doc.addEventListener("pointercancel", onPointerCancel, true);
+  doc.addEventListener("pointerdown", onRepress, true);
+  origin.addEventListener(LOST_CAPTURE_EVENT, onLostCapture);
+  return {
+    pointerId,
+    get active() {
+      return active;
+    },
+    cancel: () => abort("aborted")
+  };
+}
+
 // src/interactions/gestures/handleDrag/handleDrag.ts
 function defaultRectEl(target) {
   if (target instanceof SVGElement && target.ownerSVGElement) {
@@ -5922,10 +6292,15 @@ function defaultRectEl(target) {
   return target;
 }
 function useHandleDrag(opts) {
-  const { onMove, onStart, onEnd, getRect } = opts;
+  const { onMove, onStart, onEnd, onCancel, getRect } = opts;
+  const live = useRef(null);
+  useEffect(() => () => {
+    live.current?.cancel();
+  }, []);
   const onPointerDown = useCallback(
     (e) => {
       e.preventDefault();
+      live.current?.cancel();
       const target = e.currentTarget;
       const rectEl = getRect ? getRect(target) : defaultRectEl(target);
       const rect = rectEl.getBoundingClientRect();
@@ -5933,26 +6308,24 @@ function useHandleDrag(opts) {
         const [x, y] = clientToCanvasRect(rect, clientX, clientY);
         return { x, y };
       };
-      target.setPointerCapture(e.pointerId);
-      onStart?.(localOf(e.clientX, e.clientY), e);
-      const move = (ev) => {
-        onMove(localOf(ev.clientX, ev.clientY), ev);
-      };
-      const end = (ev) => {
-        target.removeEventListener("pointermove", move);
-        target.removeEventListener("pointerup", end);
-        target.removeEventListener("pointercancel", end);
-        try {
-          target.releasePointerCapture(ev.pointerId);
-        } catch {
+      let moved = false;
+      live.current = openPointerSession(target, e, {
+        onMove: (ev) => {
+          moved = true;
+          onMove(localOf(ev.clientX, ev.clientY), ev);
+        },
+        onEnd: (ev) => {
+          live.current = null;
+          onEnd?.({ point: localOf(ev.clientX, ev.clientY), moved, event: ev });
+        },
+        onCancel: (reason) => {
+          live.current = null;
+          onCancel?.(reason);
         }
-        onEnd?.(ev);
-      };
-      target.addEventListener("pointermove", move);
-      target.addEventListener("pointerup", end);
-      target.addEventListener("pointercancel", end);
+      });
+      onStart?.(localOf(e.clientX, e.clientY), e);
     },
-    [onMove, onStart, onEnd, getRect]
+    [onMove, onStart, onEnd, onCancel, getRect]
   );
   return { onPointerDown };
 }
@@ -6008,57 +6381,53 @@ function positionGhost(el, x, y) {
   el.style.transform = `translate(${x - el.offsetWidth / 2}px, ${y - el.offsetHeight / 2}px) scale(0.92)`;
 }
 function beginPointerDrag(payload, source, startX, startY, ghostFn) {
-  if (activeDrag) return;
+  if (activeDrag) return null;
   const ghost = ghostFn(source, payload);
   document.body.appendChild(ghost);
   positionGhost(ghost, startX, startY);
   activeDrag = { payload, ghost, lastZone: null };
-  function onMove(e) {
-    if (!activeDrag) return;
-    positionGhost(activeDrag.ghost, e.clientX, e.clientY);
-    const zone = findZone(e.clientX, e.clientY, payload.kind);
-    if (zone !== activeDrag.lastZone) {
-      activeDrag.lastZone?.onOver?.(false);
-      zone?.onOver?.(true);
-      activeDrag.lastZone = zone;
-    }
-    zone?.onMove?.(payload, e.clientX, e.clientY);
-  }
-  function onUp(e) {
-    if (!activeDrag) return;
-    const zone = findZone(e.clientX, e.clientY, payload.kind);
-    const dropped = activeDrag.payload;
-    activeDrag.lastZone?.onOver?.(false);
-    try {
-      if (zone) zone.onDrop(dropped, e.clientX, e.clientY);
-    } catch (err) {
-      console.error("weasel pointerDrag: drop zone onDrop threw", err);
-    } finally {
-      cleanup();
-    }
-  }
-  function onCancel() {
-    activeDrag?.lastZone?.onOver?.(false);
-    cleanup();
-  }
-  function cleanup() {
+  const teardown = () => {
     activeDrag?.ghost.remove();
     activeDrag = null;
-    document.removeEventListener("pointermove", onMove);
-    document.removeEventListener("pointerup", onUp);
-    document.removeEventListener("pointercancel", onCancel);
-  }
-  document.addEventListener("pointermove", onMove);
-  document.addEventListener("pointerup", onUp);
-  document.addEventListener("pointercancel", onCancel);
+  };
+  return {
+    move(e) {
+      if (!activeDrag) return;
+      positionGhost(activeDrag.ghost, e.clientX, e.clientY);
+      const zone = findZone(e.clientX, e.clientY, payload.kind);
+      if (zone !== activeDrag.lastZone) {
+        activeDrag.lastZone?.onOver?.(false);
+        zone?.onOver?.(true);
+        activeDrag.lastZone = zone;
+      }
+      zone?.onMove?.(payload, e.clientX, e.clientY);
+    },
+    drop(e) {
+      if (!activeDrag) return;
+      const zone = findZone(e.clientX, e.clientY, payload.kind);
+      const dropped = activeDrag.payload;
+      activeDrag.lastZone?.onOver?.(false);
+      try {
+        if (zone) zone.onDrop(dropped, e.clientX, e.clientY);
+      } catch (err) {
+        console.error("weasel pointerDrag: drop zone onDrop threw", err);
+      } finally {
+        teardown();
+      }
+    },
+    cancel() {
+      activeDrag?.lastZone?.onOver?.(false);
+      teardown();
+    }
+  };
 }
 var DRAG_THRESHOLD_PX_SQ = 25;
 function useDragHandle(getPayload, options) {
   const optsRef = useRef(options);
   optsRef.current = options;
-  const pendingTeardownRef = useRef(null);
+  const live = useRef(null);
   useEffect(() => () => {
-    pendingTeardownRef.current?.();
+    live.current?.cancel();
   }, []);
   const onPointerDown = useCallback((e) => {
     if (e.pointerType === "mouse" && e.button !== 0) return;
@@ -6066,41 +6435,46 @@ function useDragHandle(getPayload, options) {
     if (e.target instanceof HTMLElement && e.target.closest("input, button, select, textarea")) return;
     const startX = e.clientX;
     const startY = e.clientY;
-    let started = false;
-    function onMove(ev) {
-      if (started) return;
-      const dx = ev.clientX - startX;
-      const dy = ev.clientY - startY;
-      if (dx * dx + dy * dy > DRAG_THRESHOLD_PX_SQ) {
-        started = true;
-        const payload = getPayload();
-        cleanup();
-        if (payload) {
-          target.addEventListener(
-            "click",
-            (ce) => {
-              ce.stopPropagation();
-              ce.preventDefault();
-            },
-            { capture: true, once: true }
-          );
-          beginPointerDrag(payload, target, ev.clientX, ev.clientY, optsRef.current?.createGhost ?? defaultGhost);
+    let ghost = null;
+    let past = false;
+    live.current = openPointerSession(target, e, {
+      onMove: (ev) => {
+        if (ghost) {
+          ghost.move(ev);
+          return;
         }
+        if (past) return;
+        const dx = ev.clientX - startX;
+        const dy = ev.clientY - startY;
+        if (dx * dx + dy * dy <= DRAG_THRESHOLD_PX_SQ) return;
+        past = true;
+        const payload = getPayload();
+        if (!payload) return;
+        target.addEventListener(
+          "click",
+          (ce) => {
+            ce.stopPropagation();
+            ce.preventDefault();
+          },
+          { capture: true, once: true }
+        );
+        ghost = beginPointerDrag(
+          payload,
+          target,
+          ev.clientX,
+          ev.clientY,
+          optsRef.current?.createGhost ?? defaultGhost
+        );
+      },
+      onEnd: (ev) => {
+        live.current = null;
+        ghost?.drop(ev);
+      },
+      onCancel: () => {
+        live.current = null;
+        ghost?.cancel();
       }
-    }
-    function onEnd() {
-      cleanup();
-    }
-    function cleanup() {
-      document.removeEventListener("pointermove", onMove);
-      document.removeEventListener("pointerup", onEnd);
-      document.removeEventListener("pointercancel", onEnd);
-      pendingTeardownRef.current = null;
-    }
-    document.addEventListener("pointermove", onMove);
-    document.addEventListener("pointerup", onEnd);
-    document.addEventListener("pointercancel", onEnd);
-    pendingTeardownRef.current = cleanup;
+    }, { capture: false });
   }, [getPayload]);
   return { onPointerDown, style: { touchAction: "none" } };
 }
@@ -6127,47 +6501,34 @@ function startThresholdDrag(e, opts) {
   const startX = e.clientX;
   const startY = e.clientY;
   const threshold = opts.threshold ?? 4;
-  const target = e.currentTarget;
-  target.setPointerCapture(e.pointerId);
   let activated = false;
-  function maybeActivate(ev) {
+  const maybeActivate = (ev) => {
     if (activated) return;
     const dx = ev.clientX - startX;
     const dy = ev.clientY - startY;
     if (dx * dx + dy * dy < threshold * threshold) return;
     activated = true;
     opts.onActivate?.(ev);
-  }
-  function onMove(ev) {
-    maybeActivate(ev);
-    if (!activated) return;
-    opts.onMove(ev);
-  }
-  function cleanup() {
-    document.removeEventListener("pointermove", onMove);
-    document.removeEventListener("pointerup", onUp);
-    document.removeEventListener("pointercancel", onCancel);
-  }
-  function onUp(ev) {
-    cleanup();
-    try {
-      target.releasePointerCapture(ev.pointerId);
-    } catch {
-    }
-    if (!activated) {
+  };
+  const session = openPointerSession(e.currentTarget, e, {
+    onMove: (ev) => {
+      maybeActivate(ev);
+      if (activated) opts.onMove(ev);
+    },
+    onEnd: (ev) => {
+      if (activated) opts.onCommit(ev);
+      else opts.onCancel?.();
+    },
+    onCancel: () => {
       opts.onCancel?.();
-      return;
     }
-    opts.onCommit(ev);
-  }
-  function onCancel() {
-    cleanup();
-    opts.onCancel?.();
-  }
-  document.addEventListener("pointermove", onMove);
-  document.addEventListener("pointerup", onUp);
-  document.addEventListener("pointercancel", onCancel);
-  return { isDragging: () => activated };
+  });
+  return {
+    isDragging: () => activated,
+    cancel: () => {
+      session.cancel();
+    }
+  };
 }
 
 // src/core/device/targets.ts
@@ -6732,8 +7093,8 @@ function runLayoutPass(scratch, moveCtx) {
       for (const [cid, pose] of srcLayout.childPoses(srcContainer, srcChildren)) {
         const cur = composeWorldPose(poseAdapter, cid, pc.compose);
         const next = pose;
-        const same = cur.x === next.x && cur.y === next.y && cur.width === next.width && cur.height === next.height;
-        if (same) continue;
+        const same2 = cur.x === next.x && cur.y === next.y && cur.width === next.width && cur.height === next.height;
+        if (same2) continue;
         sourceReflow.set(cid, pose);
         const parent = scene.get(asNodeId(cid))?.parent ?? null;
         scratch.previews.set(asNodeId(cid), rebaseLocalPose(poseAdapter, pose, parent, pc.compose, pc.decompose));
@@ -8126,6 +8487,11 @@ var cloneAction = {
   id: "clone",
   label: "Clone",
   defaultBinding: { kind: "drag" },
+  // The platform's duplicate cursor, and the whole reason this field is
+  // modifier-aware: the select tool binds clone behind `mods: { alt: true }`,
+  // so the pump predicts it — and shows this — only while Alt is down.
+  cursor: "copy",
+  activeCursor: "copy",
   eligible: { capability: ["edits-page", "creates-selection"] },
   requires: ["selection", "scene", "applyOps"],
   invoker: {
@@ -8211,6 +8577,30 @@ var cloneAction = {
   enabled: () => true
 };
 
+// src/core/viewport/createVelocityTracker.ts
+function createVelocityTracker() {
+  let samples = [];
+  return {
+    record(dx, dy, t) {
+      samples.push({ dx, dy, t });
+      const cutoff = t - 100;
+      samples = samples.filter((s) => s.t >= cutoff);
+    },
+    getVelocity() {
+      const s = samples;
+      if (s.length < 2) return { vx: 0, vy: 0 };
+      const dt = s[s.length - 1].t - s[0].t;
+      if (dt === 0) return { vx: 0, vy: 0 };
+      const totalDx = s.slice(1).reduce((acc, p) => acc + p.dx, 0);
+      const totalDy = s.slice(1).reduce((acc, p) => acc + p.dy, 0);
+      return { vx: totalDx / dt, vy: totalDy / dt };
+    },
+    reset() {
+      samples = [];
+    }
+  };
+}
+
 // src/interactions/actions/defaults/viewportDragPan.ts
 var viewportDragPanAction = {
   id: "viewport.dragPan",
@@ -8229,17 +8619,37 @@ var viewportDragPanAction = {
   requires: ["view"],
   invoker: {
     timing: "ongoing",
-    start(ctx) {
+    start(ctx, opts) {
       const view = ctx.deps.view;
       if (!view) return {};
       const startView = view.get();
-      const scratch = { startView, view };
+      const params = resolveParams(opts?.params) ?? {};
+      const inertia = params.inertia === false ? void 0 : params.inertia;
+      const scratch = {
+        startView,
+        view,
+        axis: params.axis ?? "both",
+        inertia,
+        // Only track when a coast could actually happen, so the common
+        // no-inertia drag does no per-move work.
+        tracker: inertia && view.decay ? createVelocityTracker() : void 0,
+        lastScreen: { x: 0, y: 0 }
+      };
       return {
         kind: "pan",
         onMove(moveCtx) {
           if (!moveCtx.drag) return;
           const screen = moveCtx.drag.screenDelta ?? moveCtx.drag.delta;
-          const { x: screenDx, y: screenDy } = screen;
+          const screenDx = scratch.axis === "y" ? 0 : screen.x;
+          const screenDy = scratch.axis === "x" ? 0 : screen.y;
+          if (scratch.tracker) {
+            scratch.tracker.record(
+              screenDx - scratch.lastScreen.x,
+              screenDy - scratch.lastScreen.y,
+              performance.now()
+            );
+            scratch.lastScreen = { x: screenDx, y: screenDy };
+          }
           const sv = scratch.startView;
           scratch.view.set({
             ...sv,
@@ -8247,7 +8657,24 @@ var viewportDragPanAction = {
             y: sv.y - screenDy / sv.scale.y
           });
         },
-        onEnd() {
+        onEnd(_endCtx, reason) {
+          const { tracker, inertia: inertia2, view: v } = scratch;
+          if (reason === "cancel" || !tracker || !inertia2 || !v.decay) return;
+          const { vx, vy } = tracker.getVelocity();
+          const scale2 = scratch.startView.scale;
+          v.decay({
+            // Screen px/ms → world units/ms, matching the onMove conversion.
+            velocity: { vx: -vx / scale2.x, vy: -vy / scale2.y },
+            friction: inertia2.friction,
+            minSpeed: inertia2.minSpeed,
+            boundary: inertia2.boundary,
+            viewBounds: inertia2.bounds,
+            initialPosition: { x: v.get().x, y: v.get().y },
+            onTick: (dx, dy) => {
+              const cur = v.get();
+              v.set({ ...cur, x: cur.x + dx, y: cur.y + dy });
+            }
+          });
         }
       };
     }
@@ -8351,6 +8778,54 @@ function makeViewportZoomAction(opts = {}) {
 }
 var viewportZoomAction = makeViewportZoomAction();
 
+// src/interactions/actions/defaults/viewportWheelPan.ts
+var viewportWheelPanAction = {
+  id: "viewport.wheelPan",
+  label: "Pan (wheel)",
+  group: "viewport",
+  /**
+   * Plain wheel → pan; Shift+wheel → horizontal pan (axis swap).
+   * Cmd+wheel is claimed by `viewportZoomAction`. The matcher's strict
+   * modifier check keeps the bindings exclusive: omitting `mods` forbids
+   * any modifier, and `mods: { shift: true }` forbids the others.
+   */
+  defaultBinding: [
+    { spec: { kind: "wheel" }, opts: {} },
+    { spec: { kind: "wheel", mods: { shift: true } }, opts: { params: { swapAxis: true } } }
+  ],
+  requires: ["view"],
+  invoker: {
+    timing: "immediate",
+    run(deps, params) {
+      const view = deps.view;
+      if (!view) return;
+      const axis = params?.axis ?? "both";
+      const deltaX = params?.deltaX ?? 0;
+      const deltaY = params?.deltaY ?? 0;
+      const current = view.get();
+      const swap = params?.swapAxis === true;
+      const dx = swap ? (deltaX !== 0 ? deltaX : deltaY) / current.scale.x : deltaX / current.scale.x;
+      const dy = swap ? 0 : deltaY / current.scale.y;
+      view.set({
+        ...current,
+        x: current.x + (axis === "y" ? 0 : dx),
+        y: current.y + (axis === "x" ? 0 : dy)
+      });
+    }
+  },
+  enabled: () => true
+};
+function makeViewportWheelPanAction(opts = {}) {
+  const axis = opts.axis ?? "both";
+  return {
+    ...viewportWheelPanAction,
+    defaultBinding: [
+      { spec: { kind: "wheel" }, opts: { params: { axis } } },
+      { spec: { kind: "wheel", mods: { shift: true } }, opts: { params: { swapAxis: true, axis } } }
+    ]
+  };
+}
+
 // src/interactions/dispatcher/predicates.ts
 function bodyPredicate(fn) {
   return Object.assign(fn, { readsAffordance: false });
@@ -12286,8 +12761,6 @@ function useHoverTracking(args) {
   }, [canvasRef, enabled]);
   return () => hoverRef.current;
 }
-
-// src/interactions/dispatcher/dispatcher.ts
 function pointerGestureId(pointerId) {
   return `pointer-${pointerId ?? "mouse"}`;
 }
@@ -12792,7 +13265,7 @@ function createDispatcher(opts) {
   }
   function inFlightCursor() {
     for (const action of inFlightActions.values()) {
-      const cursor = action.activeCursor ?? action.cursor;
+      const cursor = resolveCursor(action.activeCursor ?? action.cursor);
       if (cursor) return cursor;
     }
     return null;
@@ -12975,8 +13448,6 @@ function itemsFromClipboardData(cd) {
   }
   return out;
 }
-
-// src/interactions/dispatcher/useGestureDispatcher.tsx
 var DROPOVER_CLASS = "weasel-dropover";
 function stylusOf(e) {
   return {
@@ -13018,7 +13489,7 @@ function computeMultiTouchGeometry(positions) {
   return { centroid, spread };
 }
 function useGestureDispatcher(opts) {
-  const { canvasRef, actions, toolsById, enabled = true, keyboard = true, affordanceAt, classifyTarget, dispatcher: dispatcherOpt, clientToWorld: clientToWorld2, requestRedraw, getRuleCtx, onDoubleClick, views } = opts;
+  const { canvasRef, actions, toolsById, enabled = true, keyboard = true, affordanceAt, classifyTarget, dispatcher: dispatcherOpt, clientToWorld: clientToWorld2, requestRedraw, paintedCursor, getRuleCtx, onDoubleClick, views } = opts;
   const onDoubleClickRef = useRef(onDoubleClick);
   onDoubleClickRef.current = onDoubleClick;
   const activeTool = useActiveToolContext();
@@ -13067,6 +13538,8 @@ function useGestureDispatcher(opts) {
   ];
   const requestRedrawRef = useRef(requestRedraw);
   requestRedrawRef.current = requestRedraw;
+  const paintedCursorRef = useRef(paintedCursor);
+  paintedCursorRef.current = paintedCursor;
   const lastClickRef = useRef(null);
   const prevActiveRef = useRef(activeTool.active);
   useEffect(() => {
@@ -13127,6 +13600,7 @@ function useGestureDispatcher(opts) {
     };
     const heldKeys = /* @__PURE__ */ new Set();
     const activePointers = /* @__PURE__ */ new Set();
+    const buttonsReportedFor = /* @__PURE__ */ new Set();
     const pointerPositions = /* @__PURE__ */ new Map();
     let multiTouchStart = null;
     const TAP_THRESHOLD_PX = 8;
@@ -13269,8 +13743,10 @@ function useGestureDispatcher(opts) {
     };
     const onPointerDown = (e) => {
       if ((e.button ?? 0) !== 0) return;
+      if (activePointers.has(e.pointerId)) onPointerUp(e);
       routeDown(e.pointerId, e.clientX, e.clientY);
       activePointers.add(e.pointerId);
+      if (reportsButtons(e)) buttonsReportedFor.add(e.pointerId);
       pointerPositions.set(e.pointerId, { x: e.clientX, y: e.clientY });
       try {
         canvas?.setPointerCapture?.(e.pointerId);
@@ -13349,6 +13825,10 @@ function useGestureDispatcher(opts) {
       }
     };
     const onPointerMove = (e) => {
+      if (activePointers.has(e.pointerId) && buttonsReportedFor.has(e.pointerId) && isMissedRelease(e)) {
+        onPointerUp(e);
+        return;
+      }
       routeAt(e.pointerId, e.clientX, e.clientY);
       if (activePointers.has(e.pointerId)) {
         pointerPositions.set(e.pointerId, { x: e.clientX, y: e.clientY });
@@ -13406,20 +13886,39 @@ function useGestureDispatcher(opts) {
     let lastHover = null;
     let cursorOverridden = false;
     const clearHoverCursor = () => {
+      paintedCursorRef.current?.()?.setOverride(null);
       if (cursorOverridden && canvas) {
         canvas.style.cursor = "";
         cursorOverridden = false;
       }
     };
-    const applyHoverCursor = (cursor) => {
-      if (cursor && canvas) {
-        canvas.style.cursor = cursor;
-        cursorOverridden = true;
-      } else {
+    const applyHoverCursor = (spec) => {
+      const tier = spec === null ? null : resolveCursorTier(spec);
+      if (!tier || !canvas) {
+        clearHoverCursor();
+        return;
+      }
+      const painted = tier.kind === "painted" ? tier : null;
+      paintedCursorRef.current?.()?.setOverride(painted);
+      const cursor = tier.kind === "css" ? tier.css : "none";
+      if (!cursor) {
         clearHoverCursor();
+        return;
       }
+      canvas.style.cursor = cursor;
+      cursorOverridden = true;
     };
+    function pushPaintedPointer() {
+      const painted = paintedCursorRef.current?.();
+      if (!painted?.active() || !canvas || !lastHover) return;
+      const r = canvas.getBoundingClientRect();
+      painted.setPointer(lastHover.clientX - r.left, lastHover.clientY - r.top);
+    }
     function refreshHoverCursor() {
+      resolveHoverCursor();
+      pushPaintedPointer();
+    }
+    function resolveHoverCursor() {
       if (!canvas || !lastHover) return;
       if (activePointers.size > 0 || dispatcherNow().inFlight().size > 0) {
         applyHoverCursor(dispatcherNow().inFlightCursor());
@@ -13471,6 +13970,7 @@ function useGestureDispatcher(opts) {
     };
     const onHoverPointerLeave = () => {
       lastHover = null;
+      paintedCursorRef.current?.()?.clearPointer();
       clearHoverCursor();
     };
     const onPointerUp = (e) => {
@@ -13478,6 +13978,7 @@ function useGestureDispatcher(opts) {
       cancelLongPress(e.pointerId);
       const prevSize = activePointers.size;
       activePointers.delete(e.pointerId);
+      buttonsReportedFor.delete(e.pointerId);
       pointerPositions.delete(e.pointerId);
       const staysUnderThreshold = bufferedDown.delete(e.pointerId);
       if (prevSize >= 2 && activePointers.size < 2) {
@@ -13585,6 +14086,7 @@ function useGestureDispatcher(opts) {
       routeAt(e.pointerId, e.clientX, e.clientY);
       cancelLongPress(e.pointerId);
       activePointers.delete(e.pointerId);
+      buttonsReportedFor.delete(e.pointerId);
       pointerPositions.delete(e.pointerId);
       lastPointerDown.delete(e.pointerId);
       bufferedDown.delete(e.pointerId);
@@ -13600,6 +14102,11 @@ function useGestureDispatcher(opts) {
       dispatch2(ev);
       routeRelease(e.pointerId);
     };
+    const onLostCapture = (e) => {
+      const pe = e;
+      if (!activePointers.has(pe.pointerId)) return;
+      onPointerCancel(pe);
+    };
     const onContextMenu = (e) => {
       e.preventDefault();
       routeAt(null, e.clientX, e.clientY);
@@ -13689,6 +14196,7 @@ function useGestureDispatcher(opts) {
     canvas?.addEventListener("pointermove", onPointerMove);
     canvas?.addEventListener("pointerup", onPointerUp);
     canvas?.addEventListener("pointercancel", onPointerCancel);
+    canvas?.addEventListener(LOST_CAPTURE_EVENT, onLostCapture);
     canvas?.addEventListener("contextmenu", onContextMenu);
     canvas?.addEventListener("dragenter", onDragOver);
     canvas?.addEventListener("dragover", onDragOver);
@@ -13709,6 +14217,7 @@ function useGestureDispatcher(opts) {
       canvas?.removeEventListener("pointermove", onPointerMove);
       canvas?.removeEventListener("pointerup", onPointerUp);
       canvas?.removeEventListener("pointercancel", onPointerCancel);
+      canvas?.removeEventListener(LOST_CAPTURE_EVENT, onLostCapture);
       canvas?.removeEventListener("contextmenu", onContextMenu);
       canvas?.removeEventListener("dragenter", onDragOver);
       canvas?.removeEventListener("dragover", onDragOver);
@@ -13751,26 +14260,7 @@ function computeWheelAction(state, input, bounds = { min: DEFAULT_MIN_ZOOM, max:
   };
 }
 function useVelocityTracker() {
-  const samplesRef = useRef([]);
-  return useMemo(() => ({
-    record(dx, dy, t) {
-      samplesRef.current.push({ dx, dy, t });
-      const cutoff = t - 100;
-      samplesRef.current = samplesRef.current.filter((s) => s.t >= cutoff);
-    },
-    getVelocity() {
-      const s = samplesRef.current;
-      if (s.length < 2) return { vx: 0, vy: 0 };
-      const dt = s[s.length - 1].t - s[0].t;
-      if (dt === 0) return { vx: 0, vy: 0 };
-      const totalDx = s.slice(1).reduce((acc, p) => acc + p.dx, 0);
-      const totalDy = s.slice(1).reduce((acc, p) => acc + p.dy, 0);
-      return { vx: totalDx / dt, vy: totalDy / dt };
-    },
-    reset() {
-      samplesRef.current = [];
-    }
-  }), []);
+  return useMemo(() => createVelocityTracker(), []);
 }
 var SPRING_DAMPING = 0.5;
 function useDecayLoop() {
@@ -15200,7 +15690,7 @@ function validateId(id, kind) {
 }
 function defineTool(def) {
   validateId(def.id, "tool");
-  const resolveCursor = (ctx) => {
+  const resolveCursor3 = (ctx) => {
     if (def.cursor == null) return "";
     return typeof def.cursor === "function" ? def.cursor(ctx) : def.cursor;
   };
@@ -15218,7 +15708,7 @@ function defineTool(def) {
     onActivate: def.onActivate,
     onDeactivate: def.onDeactivate,
     initScratch: def.initScratch ?? (() => null),
-    cursor: resolveCursor,
+    cursor: resolveCursor3,
     bindings: def.bindings,
     overlay: def.overlay,
     overlayPosition: def.overlayPosition
@@ -17288,6 +17778,9 @@ function transformOf(state, targetId) {
     identity: false
   };
 }
+function angleOf(xf) {
+  return xf.identity ? 0 : Math.atan2(xf.sin, xf.cos);
+}
 function localToWorld(xf, lx, ly) {
   if (xf.identity) return { x: lx, y: ly };
   const dx = lx - xf.cx;
@@ -17591,11 +18084,7 @@ var DEFAULT_PAINT = {
   insetPx: 10
 };
 function createRotationAffordance(opts = {}) {
-  const {
-    bandPx = 24,
-    paint = DEFAULT_PAINT,
-    cursor = "grab"
-  } = opts;
+  const { bandPx = 24, paint = DEFAULT_PAINT, cursor } = opts;
   const annulusPaint = (() => {
     if (!paint) return null;
     if ("paint" in paint) {
@@ -17633,7 +18122,14 @@ function createRotationAffordance(opts = {}) {
         },
         ...annulusPaint ? { paint: annulusPaint } : {},
         hitKind: "rotate-handle",
-        cursor,
+        // Turned with the target, so the arc follows the selection it rotates.
+        // Resolved per region rather than defaulted in the option list because
+        // the angle is only known once a target is picked.
+        cursor: cursor ?? {
+          glyph: "rotate",
+          angle: angleOf(transformOf(state, target.id)),
+          fallback: "grab"
+        },
         bind: () => ({
           initialScratch: {
             targetId: target.id,
@@ -17732,7 +18228,9 @@ function useRotateTool(adapter, options) {
     [overlay]
   );
 }
-function useHandTool(_opts = {}) {
+function useHandTool(opts = {}) {
+  const optsRef = useRef(opts);
+  optsRef.current = opts;
   return useMemo(
     () => Object.assign(defineViewportTool({
       id: "hand",
@@ -17750,7 +18248,16 @@ function useHandTool(_opts = {}) {
       // viewportDragPanAction, which also owns the grabbing cursor
       // (`Action.activeCursor`) the tool used to declare as an `engaged`
       // phase entry.
-      bindings: [{ spec: { kind: "drag" }, actionId: "viewport.dragPan" }]
+      bindings: [{
+        spec: { kind: "drag" },
+        actionId: "viewport.dragPan",
+        opts: {
+          params: () => ({
+            axis: optsRef.current.axis ?? "both",
+            inertia: optsRef.current.inertia
+          })
+        }
+      }]
     }),
     []
   );
@@ -18116,7 +18623,7 @@ function useRectTool() {
       id: "rect",
       capabilities: ["creates-shapes"],
       hookName: "useRectTool",
-      cursor: "crosshair",
+      cursor: cursorFor("crosshairRect", { fallback: "crosshair" }),
       presentation: {
         label: "Rectangle",
         icon: createElement(RectIcon),
@@ -18142,7 +18649,7 @@ function useEllipseTool() {
       id: "ellipse",
       capabilities: ["creates-shapes"],
       hookName: "useEllipseTool",
-      cursor: "crosshair",
+      cursor: cursorFor("crosshairEllipse", { fallback: "crosshair" }),
       presentation: {
         label: "Ellipse",
         group: "shape",
@@ -18250,7 +18757,7 @@ function useLineTool() {
       id: "line",
       capabilities: ["creates-shapes"],
       hookName: "useLineTool",
-      cursor: "crosshair",
+      cursor: cursorFor("crosshairLine", { fallback: "crosshair" }),
       presentation: {
         label: "Line",
         group: "shape",
@@ -18365,7 +18872,7 @@ function usePolygonTool(options = {}) {
       id: "polygon",
       capabilities: ["creates-shapes"],
       hookName: "usePolygonTool",
-      cursor: "crosshair",
+      cursor: cursorFor("crosshairPolygon", { fallback: "crosshair" }),
       // Registered by <ToolActionsMounter>, inside the ActionsProvider —
       // see `ToolDef.actions` for why the hook can't register it itself.
       actions: [adjustSidesAction],
@@ -18465,7 +18972,7 @@ function useStarTool(options = {}) {
       id: "star",
       capabilities: ["creates-shapes"],
       hookName: "useStarTool",
-      cursor: "crosshair",
+      cursor: cursorFor("crosshairStar", { fallback: "crosshair" }),
       // Registered by <ToolActionsMounter>, inside the ActionsProvider —
       // see `ToolDef.actions` for why the hook can't register it itself.
       actions: [adjustPointsAction],
@@ -19121,24 +19628,25 @@ function projectBounds(b, view) {
   const [sx, sy] = worldToScreen(b.x, b.y, t);
   return { ...b, x: sx, y: sy, width: b.width * view.scale.x, height: b.height * view.scale.y };
 }
+function leavesOf(id, getChildren, isContainer) {
+  if (!isContainer(id)) return [id];
+  const out = [];
+  const visit = (nid) => {
+    const kids = getChildren(nid);
+    if (kids.length === 0) {
+      if (!isContainer(nid)) out.push(nid);
+      return;
+    }
+    for (const k of kids) visit(k);
+  };
+  visit(id);
+  return out;
+}
 function composeSelectionPose(opts) {
   const { moveOverlay, resizeOverlay, getStoredPose, getChildren, isContainer } = opts;
   const getBounds = opts.getBounds ?? ((pose) => pose);
   const fromBounds = opts.fromBounds ?? ((bounds) => bounds);
-  const leavesOf = (id) => {
-    if (!getChildren || !isContainer || !isContainer(id)) return [id];
-    const out = [];
-    const visit = (nid) => {
-      const kids = getChildren(nid);
-      if (kids.length === 0) {
-        if (!isContainer(nid)) out.push(nid);
-        return;
-      }
-      for (const k of kids) visit(k);
-    };
-    visit(id);
-    return out;
-  };
+  const selectionLeaves = (id) => getChildren && isContainer ? leavesOf(id, getChildren, isContainer) : [id];
   const resolveLeaf = (id) => {
     const moved = moveOverlay?.poses.get(id);
     if (moved !== void 0) return moved;
@@ -19147,7 +19655,7 @@ function composeSelectionPose(opts) {
   };
   return (id) => {
     if (isContainer?.(id)) {
-      const leaves = leavesOf(id);
+      const leaves = selectionLeaves(id);
       if (leaves.length === 0) return null;
       const containerResizeLeafPoses = resizeOverlay && resizeOverlay.id === id ? resizeOverlay.leafPoses : void 0;
       const leafBounds = [];
@@ -19178,26 +19686,12 @@ function makeContainerAwareBoundsResolver(getPose, getBounds, getChildren, isCon
       return p === null ? null : getBounds(p);
     };
   }
-  const leavesOf = (id) => {
-    if (!isContainer(id)) return [id];
-    const out = [];
-    const visit = (nid) => {
-      const kids = getChildren(nid);
-      if (kids.length === 0) {
-        if (!isContainer(nid)) out.push(nid);
-        return;
-      }
-      for (const k of kids) visit(k);
-    };
-    visit(id);
-    return out;
-  };
   return (id) => {
     if (!isContainer(id)) {
       const p = getPose(id);
       return p === null ? null : getBounds(p);
     }
-    const leaves = leavesOf(id);
+    const leaves = leavesOf(id, getChildren, isContainer);
     if (leaves.length === 0) return null;
     const leafBounds = [];
     for (const leafId of leaves) {
@@ -19592,6 +20086,113 @@ function buildSceneTree(adapter, drawOne, view, forLayer, derivedPathOf) {
   }
   return out;
 }
+
+// src/features/cursor/paintedCursorState.ts
+function same(a, b) {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  return a.glyph === b.glyph && a.angle === b.angle && a.size === b.size && a.worldRadius === b.worldRadius;
+}
+function createPaintedCursorState() {
+  let base = null;
+  let override = null;
+  let at = null;
+  const subs = /* @__PURE__ */ new Set();
+  const notify2 = () => {
+    for (const fn of subs) fn();
+  };
+  return {
+    setBase(cursor) {
+      if (same(base, cursor)) return;
+      base = cursor;
+      notify2();
+    },
+    setOverride(cursor) {
+      if (same(override, cursor)) return;
+      override = cursor;
+      notify2();
+    },
+    setPointer(x, y) {
+      if (at && at.x === x && at.y === y) return;
+      at = { x, y };
+      if (override ?? base) notify2();
+    },
+    clearPointer() {
+      if (at === null) return;
+      at = null;
+      notify2();
+    },
+    active() {
+      return (override ?? base) !== null;
+    },
+    current() {
+      const cursor = override ?? base;
+      if (!cursor || !at) return null;
+      return { cursor, at };
+    },
+    subscribe(fn) {
+      subs.add(fn);
+      return () => {
+        subs.delete(fn);
+      };
+    }
+  };
+}
+var PAINTED_CURSOR_LAYER_ID = "painted-cursor";
+var pathCache = /* @__PURE__ */ new Map();
+function pathFor(d) {
+  let p = pathCache.get(d);
+  if (p === void 0) {
+    p = pathFromD(d);
+    pathCache.set(d, p);
+  }
+  return p;
+}
+function commandFor2(op) {
+  return {
+    kind: "path",
+    path: pathFor(op.d),
+    ...op.fill !== void 0 ? { fill: { color: op.fill } } : {},
+    ...op.stroke !== void 0 ? {
+      stroke: {
+        paint: { color: op.stroke.color },
+        width: op.stroke.width,
+        cap: "round",
+        join: "round"
+      }
+    } : {}
+  };
+}
+function createPaintedCursorLayer(state) {
+  return {
+    id: PAINTED_CURSOR_LAYER_ID,
+    label: "Painted cursor",
+    space: "screen",
+    draw: (_data, view) => {
+      const frame = state.current();
+      if (!frame) return [];
+      const { cursor, at } = frame;
+      const glyph = GLYPHS[cursor.glyph];
+      if (!glyph) return [];
+      const scale2 = (view.scale.x + view.scale.y) / 2;
+      const worldSized = cursor.worldRadius !== void 0;
+      const size = worldSized ? cursorWorldSize(glyph, cursor.worldRadius, scale2) : cursor.size ?? 24;
+      if (!(size > 0) || !Number.isFinite(size)) return [];
+      const ops = cursorPaintOps(
+        glyph,
+        worldSized ? { lineWidthScale: chromeLineWidthScale(glyph, size) } : {}
+      );
+      const [a, b, c, d, e, f] = cursorPaintMatrix(glyph, {
+        size,
+        angle: cursor.angle,
+        at
+      });
+      const transform = new Float32Array([a, b, 0, c, d, 0, e, f, 1]);
+      const children = ops.map(commandFor2);
+      return [{ kind: "group", transform, children }];
+    }
+  };
+}
 function mat3ToRenderMatrix(m) {
   return new Float32Array([m[0], m[1], 0, m[2], m[3], 0, m[4], m[5], 1]);
 }
@@ -19972,11 +20573,11 @@ function resolveToolsCursor(tools, ctxBase) {
   const id = tools.hotkeyEngaged ?? tools.active;
   const tool = tools.registry[id];
   if (!tool?.cursor) return void 0;
-  if (typeof tool.cursor === "string") return tool.cursor;
+  if (typeof tool.cursor !== "function") return resolveCursorTier(tool.cursor);
   if (!ctxBase) return void 0;
   try {
     const base = ctxBase();
-    return tool.cursor({ ...base, scratch: null });
+    return resolveCursorTier(tool.cursor({ ...base, scratch: null }));
   } catch {
     return void 0;
   }
@@ -20141,6 +20742,14 @@ function CanvasInner(props, ref) {
       viewSubsRef.current.delete(fn);
     };
   }, []);
+  const paintedCursor = useMemo(() => createPaintedCursorState(), []);
+  const paintedCursorLayer = useMemo(
+    () => createPaintedCursorLayer(paintedCursor),
+    [paintedCursor]
+  );
+  useEffect(() => paintedCursor.subscribe(() => {
+    requestRedraw();
+  }), [paintedCursor, requestRedraw]);
   useImperativeHandle(ref, () => ({
     // Named rather than read off `canvasRef` so the handle rebuilds when a
     // detached surface's input element arrives, which is a render later.
@@ -20153,7 +20762,8 @@ function CanvasInner(props, ref) {
     getView,
     setView,
     subscribeView,
-    getPaintedVersion
+    getPaintedVersion,
+    paintedCursor
   }), [
     canvasRef,
     ownCanvasRef,
@@ -20167,7 +20777,8 @@ function CanvasInner(props, ref) {
     getView,
     setView,
     subscribeView,
-    getPaintedVersion
+    getPaintedVersion,
+    paintedCursor
   ]);
   const glRendererRef = useRef(null);
   const layerCacheRef = useRef(/* @__PURE__ */ new Map());
@@ -20247,7 +20858,7 @@ function CanvasInner(props, ref) {
       return {
         worldX,
         worldY,
-        modifiers: m ? { alt: m.alt, shift: m.shift, meta: m.meta, ctrl: m.ctrl, space: false } : { alt: false, shift: false, meta: false, ctrl: false, space: false },
+        modifiers: m ? { alt: m.alt, shift: m.shift, meta: m.meta, ctrl: m.ctrl } : { alt: false, shift: false, meta: false, ctrl: false },
         selection: effectiveSelectionRefForCtx.current,
         adapter: effectiveAdapterRefForCtx.current,
         applyOps: (ops, label) => {
@@ -20431,8 +21042,16 @@ function CanvasInner(props, ref) {
   const layersWithDebug = useMemo(() => {
     const withViews = viewRegistry ? [...layers, ...viewRegistry.list().map((r) => r.layer)] : layers;
     const base = debugSink && resolvedDebugConfig ? [...withViews, createDebugOverlayLayer({ sink: debugSink, config: resolvedDebugConfig })] : withViews;
-    return [...base, ...extrasRef.current];
-  }, [layers, debugSink, resolvedDebugConfig, extrasVersion, viewRegistry, viewRegistryVersion]);
+    return [...base, ...extrasRef.current, paintedCursorLayer];
+  }, [
+    layers,
+    debugSink,
+    resolvedDebugConfig,
+    extrasVersion,
+    viewRegistry,
+    viewRegistryVersion,
+    paintedCursorLayer
+  ]);
   const shaderIdKey = shaders?.map((h) => h.id).join("|") ?? "";
   const paintInputsRef = useRef({
     layers: layersWithDebug,
@@ -20554,8 +21173,14 @@ function CanvasInner(props, ref) {
     if (!renderer) return;
     registerShadersOnRenderer(renderer, shaders);
   }, [shaderIdKey]);
-  const toolsCursor = tools ? resolveToolsCursor(tools, toolsCtxBase) : void 0;
+  const toolsCursorTier = tools ? resolveToolsCursor(tools, toolsCtxBase) : void 0;
+  const toolsCursor = toolsCursorTier === void 0 ? void 0 : toolsCursorTier.kind === "css" ? toolsCursorTier.css : "none";
   const effectiveStyle = toolsCursor ? { ...style, cursor: toolsCursor } : style;
+  const toolsPainted = toolsCursorTier?.kind === "painted" ? toolsCursorTier : null;
+  const toolsPaintedKey = toolsPainted ? `${toolsPainted.glyph}|${toolsPainted.angle}|${toolsPainted.size}|${toolsPainted.worldRadius}` : "";
+  useEffect(() => {
+    paintedCursor.setBase(toolsPainted);
+  }, [paintedCursor, toolsPaintedKey]);
   const layersForMoveRef = useRef(layersWithDebug);
   layersForMoveRef.current = layersWithDebug;
   useEffect(() => {
@@ -21894,10 +22519,16 @@ function createCornerResizeAffordance(opts = {}) {
           hitKind: c.kind,
           // Diagonal by fixed-corner parity: a matched-axis anchor (min-min /
           // max-max fixed) means the dragged corner sits on the ↘ diagonal;
-          // mixed axes sit on the ↗ diagonal. Not rotation-aware — a rotated
-          // target keeps the unrotated hint, the same policy as every
-          // mainstream editor short of Figma.
-          cursor: c.anchor.x === c.anchor.y ? "nwse-resize" : "nesw-resize",
+          // mixed axes sit on the ↗ diagonal. The glyph is horizontal at angle
+          // 0, so the diagonal is a half-quarter-turn either way, plus the
+          // target's own rotation. The keyword is the fallback rather than the
+          // answer: CSS has four of them, which cannot express a target
+          // rotated to anything but a multiple of 45°.
+          cursor: {
+            glyph: "resize",
+            angle: (c.anchor.x === c.anchor.y ? Math.PI / 4 : -Math.PI / 4) + angleOf(xf),
+            fallback: c.anchor.x === c.anchor.y ? "nwse-resize" : "nesw-resize"
+          },
           bind: () => ({
             initialScratch: {
               anchor: c.anchor,
@@ -23930,10 +24561,10 @@ function boundsOf(coords) {
   }
   return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
 }
-function useViewDepSource(currentViewRef, onViewChange, recenter, hostSize, animation) {
-  const wiring = useRef({ currentViewRef, onViewChange, recenter, hostSize, animation });
-  wiring.current = { currentViewRef, onViewChange, recenter, hostSize, animation };
-  const shape = `${recenter ? "r" : ""}${hostSize ? "h" : ""}${animation ? "a" : ""}`;
+function useViewDepSource(currentViewRef, onViewChange, recenter, hostSize, animation, decay) {
+  const wiring = useRef({ currentViewRef, onViewChange, recenter, hostSize, animation, decay });
+  wiring.current = { currentViewRef, onViewChange, recenter, hostSize, animation, decay };
+  const shape = `${recenter ? "r" : ""}${hostSize ? "h" : ""}${animation ? "a" : ""}${decay ? "d" : ""}`;
   const shapeRef = useRef(null);
   const viewApiRef = useRef(null);
   if (viewApiRef.current === null || shapeRef.current !== shape) {
@@ -23952,6 +24583,10 @@ function useViewDepSource(currentViewRef, onViewChange, recenter, hostSize, anim
         animate: (to, opts) => wiring.current.animation.animate(to, opts),
         stopAnimation: () => wiring.current.animation.stop(),
         animationTarget: () => wiring.current.animation.target()
+      } : {},
+      ...decay ? {
+        decay: (config) => wiring.current.decay.start(config),
+        stopDecay: () => wiring.current.decay.cancel()
       } : {}
     };
   }
@@ -24715,7 +25350,6 @@ function useActionsPropResolver(actions) {
     }
     if (!prop) return;
     const unregisters = [];
-    const restores = [];
     const warnedIds = /* @__PURE__ */ new Set();
     for (const [slotId, entry] of Object.entries(prop)) {
       if (entry === null) {
@@ -24743,64 +25377,30 @@ function useActionsPropResolver(actions) {
       }
       const { id: _drop, ...rest } = entry;
       const merged = { ...existing, ...rest };
-      restores.push(() => {
-        reg.register(existing);
-      });
       unregisters.push(reg.register(merged));
     }
     return () => {
       for (const u of unregisters) u();
-      for (const r of restores) r();
     };
   }, [reg, actions]);
 }
-
-// src/interactions/actions/defaults/viewportWheelPan.ts
-var viewportWheelPanAction = {
-  id: "viewport.wheelPan",
-  label: "Pan (wheel)",
-  group: "viewport",
-  /**
-   * Plain wheel → pan; Shift+wheel → horizontal pan (axis swap).
-   * Cmd+wheel is claimed by `viewportZoomAction`. The matcher's strict
-   * modifier check keeps the bindings exclusive: omitting `mods` forbids
-   * any modifier, and `mods: { shift: true }` forbids the others.
-   */
-  defaultBinding: [
-    { spec: { kind: "wheel" }, opts: {} },
-    { spec: { kind: "wheel", mods: { shift: true } }, opts: { params: { swapAxis: true } } }
-  ],
-  requires: ["view"],
-  invoker: {
-    timing: "immediate",
-    run(deps, params) {
-      const view = deps.view;
-      if (!view) return;
-      const deltaX = params?.deltaX ?? 0;
-      const deltaY = params?.deltaY ?? 0;
-      const current = view.get();
-      const swap = params?.swapAxis === true;
-      const dx = swap ? (deltaX !== 0 ? deltaX : deltaY) / current.scale.x : deltaX / current.scale.x;
-      const dy = swap ? 0 : deltaY / current.scale.y;
-      view.set({ ...current, x: current.x + dx, y: current.y + dy });
-    }
-  },
-  enabled: () => true
-};
-
-// src/canvas/SceneCanvas/useViewportActions.ts
 function useViewportActions(args) {
   const { pan, zoom, pinchZoom } = args;
   const reg = useActionsRegistry();
   const regRef = useRef(reg);
   regRef.current = reg;
+  const panKey = typeof pan === "object" ? JSON.stringify(pan) : String(pan);
   const zoomKey = typeof zoom === "object" ? JSON.stringify(zoom) : String(zoom);
   const pinchKey = typeof pinchZoom === "object" ? JSON.stringify(pinchZoom) : String(pinchZoom);
   useEffect(() => {
     const r = regRef.current;
     if (!r) return;
     const unregisters = [];
-    if (pan) unregisters.push(r.register(viewportWheelPanAction));
+    if (pan) {
+      unregisters.push(
+        r.register(makeViewportWheelPanAction(typeof pan === "object" ? pan : {}))
+      );
+    }
     if (zoom) {
       const zoomAction = typeof zoom === "object" ? makeViewportZoomAction(zoom) : makeViewportZoomAction();
       unregisters.push(r.register(zoomAction));
@@ -24815,7 +25415,7 @@ function useViewportActions(args) {
     return () => {
       for (const u of unregisters) u();
     };
-  }, [pan, zoomKey, pinchKey]);
+  }, [panKey, zoomKey, pinchKey]);
 }
 
 // src/core/scene/NodeRouting.ts
@@ -25250,13 +25850,13 @@ function SceneCanvasInner(props, ref) {
   const viewportRegistered = !!viewport;
   const inertiaEnabled = !!viewport?.inertia;
   const inertiaObj = typeof viewport?.inertia === "object" ? viewport.inertia : void 0;
-  const handToolInertia = inertiaEnabled && inertiaObj ? {
-    friction: inertiaObj.friction,
-    minSpeed: inertiaObj.minSpeed,
-    boundary: inertiaObj.boundary,
-    bounds: inertiaObj.bounds
+  const handToolInertia = inertiaEnabled ? {
+    friction: inertiaObj?.friction,
+    minSpeed: inertiaObj?.minSpeed,
+    boundary: inertiaObj?.boundary,
+    bounds: inertiaObj?.bounds
   } : void 0;
-  const handTool = useHandTool(handToolInertia ? { } : {});
+  const handTool = useHandTool(handToolInertia ? { inertia: handToolInertia } : {});
   const viewportAmbient = [];
   const baseRequestedTools = defaultTools ?? (toolBundle ? BUNDLE_TOOLS[toolBundle] : null) ?? (viewportRegistered ? ["select", "rotate", "hand"] : ["select", "rotate"]);
   const KNOWN_BUILTIN_IDS = /* @__PURE__ */ new Set([
@@ -25709,7 +26309,7 @@ function SceneCanvasInner(props, ref) {
         dispatcher,
         getActionRef,
         pickEvery: internalPickEvery,
-        viewportPanEnabled: viewport?.pan !== false,
+        viewportPanEnabled: viewport?.pan ?? true,
         viewportZoom: resolvedViewportZoom,
         viewportPinchZoom: viewport?.pinchZoom ?? true,
         viewportRecenter: viewport?.recenter,
@@ -25920,6 +26520,10 @@ function GestureDispatcherMounter({
   const requestRedraw = useCallback(() => {
     canvasApiRef?.current?.requestRedraw?.();
   }, [canvasApiRef]);
+  const paintedCursor = useCallback(
+    () => canvasApiRef?.current?.paintedCursor,
+    [canvasApiRef]
+  );
   const views = useMemo(() => {
     if (!viewRegistry) return void 0;
     return {
@@ -25938,6 +26542,7 @@ function GestureDispatcherMounter({
     dispatcher,
     clientToWorld: clientToWorld2,
     requestRedraw,
+    paintedCursor,
     getRuleCtx,
     onDoubleClick,
     ...views ? { views } : {}
@@ -25995,6 +26600,7 @@ function StandardActionsRegistrar({
       getActionRef.current = null;
     };
   }, [registry2, getActionRef]);
+  const decayLoop = useDecayLoop();
   const view = useViewDepSource(
     currentViewRef,
     onViewChange,
@@ -26003,7 +26609,8 @@ function StandardActionsRegistrar({
       const el = canvasRef.current;
       return el ? { width: el.clientWidth, height: el.clientHeight } : null;
     },
-    viewAnimation
+    viewAnimation,
+    decayLoop
   );
   const sceneAsHistory = scene;
   useStandardActions({ selection, scene, view, history: sceneAsHistory });
@@ -26463,8 +27070,7 @@ function MinimapCanvasInner(props) {
   }, [mainView, mainViewDims, indicatorStyle]);
   const extraCommands = useMemo(() => [indicatorCmd], [indicatorCmd]);
   const localCanvasRef = useRef(null);
-  const dragActiveRef = useRef(false);
-  const capturedPointerIdRef = useRef(null);
+  const sessionRef = useRef(null);
   const mainViewRef = useRef(mainView);
   const mainViewDimsRef = useRef(mainViewDims);
   const onMainViewChangeRef = useRef(onMainViewChange);
@@ -26493,36 +27099,18 @@ function MinimapCanvasInner(props) {
   }, []);
   const handlePointerDown = useCallback((ev) => {
     const canvas = localCanvasRef.current;
-    if (!canvas) return;
+    if (!canvas || sessionRef.current) return;
     if (ev.pointerType === "mouse" && ev.button !== 0) return;
-    try {
-      canvas.setPointerCapture(ev.pointerId);
-    } catch {
-    }
-    dragActiveRef.current = true;
-    capturedPointerIdRef.current = ev.pointerId;
-    recenterFromPointer(ev);
-  }, [recenterFromPointer]);
-  const handlePointerMove = useCallback((ev) => {
-    if (!dragActiveRef.current) return;
-    if (capturedPointerIdRef.current !== null && ev.pointerId !== capturedPointerIdRef.current) {
-      return;
-    }
+    const done = () => {
+      sessionRef.current = null;
+    };
+    sessionRef.current = openPointerSession(canvas, ev, {
+      onMove: recenterFromPointer,
+      onEnd: done,
+      onCancel: done
+    });
     recenterFromPointer(ev);
   }, [recenterFromPointer]);
-  const releaseCapture = useCallback((ev) => {
-    const canvas = localCanvasRef.current;
-    if (canvas) {
-      try {
-        if (canvas.hasPointerCapture?.(ev.pointerId)) {
-          canvas.releasePointerCapture(ev.pointerId);
-        }
-      } catch {
-      }
-    }
-    dragActiveRef.current = false;
-    capturedPointerIdRef.current = null;
-  }, []);
   const setCanvasRef = useCallback((el) => {
     localCanvasRef.current = el;
     if (typeof canvasRef === "function") {
@@ -26535,16 +27123,11 @@ function MinimapCanvasInner(props) {
     const canvas = localCanvasRef.current;
     if (!canvas) return;
     canvas.addEventListener("pointerdown", handlePointerDown);
-    canvas.addEventListener("pointermove", handlePointerMove);
-    canvas.addEventListener("pointerup", releaseCapture);
-    canvas.addEventListener("pointercancel", releaseCapture);
     return () => {
       canvas.removeEventListener("pointerdown", handlePointerDown);
-      canvas.removeEventListener("pointermove", handlePointerMove);
-      canvas.removeEventListener("pointerup", releaseCapture);
-      canvas.removeEventListener("pointercancel", releaseCapture);
+      sessionRef.current?.cancel();
     };
-  }, [handlePointerDown, handlePointerMove, releaseCapture]);
+  }, [handlePointerDown]);
   return /* @__PURE__ */ jsx(
     SceneViewCanvas,
     {
@@ -30684,6 +31267,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, 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, LassoIcon, LineIcon, MIXED, MOVE_ANCHORS, MinimapCanvas, NEVER, OUTLINE_MIN_SCREEN_PX, PATH_ANCHOR_CHROME_ID, PenIcon, PencilIcon, PickHud, PointerProviderIfRoot, PolygonIcon, RECT_ALIGN_PROJECTION, ROTATION_HANDLE_BASE_PX, RectIcon, SPRING_PRESETS, SceneCanvas, SceneViewCanvas, SelectIcon, SelectionContextProvider, SelectionContextProviderIfRoot, ShaderCompileError, StarIcon, SubtractIcon, TOOL_PREF_KINDS, TextIcon, UnionIcon, UnknownIcon, VERSION, VIEW_ANIMATION_KEY, 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, 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, createParallaxLayer, createPathAnchorAffordances, createPathEditingOverlayLayer, createPathLayer, createPenPreviewLayer, createReorderOp, createRotationAffordance, createScene, createSelectionHandlesLayer, createSelectionOutlineLayer, createSelectionOverlayLayer, createSetDataOp, createSetLayerOp, createSetPathOp, createSetTextOp, createTextLayer, 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, isEditableTarget2 as isEditableTarget, isGradientFill, isLayerPainted, isLayerVisible, isPatternSpec, keySpecShortcut, lassoSelectAction, lerpColorArray, lerpOklab, lerpOklch, linear, listMarkers, listPaintKinds, liveScope, makePinchZoomAction, 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, 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, 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, usePinchZoomTool, usePointerStylus, usePolygonTool, usePublishSelection, useRectTool, useResizePolicy, useRotateTool, useScene, useSceneAdapter, useSceneTextEdit, useSelectTool, useSelection, useSelectionContext, useSimulation, useSliceDep, useStandardActions, useStarTool, useTextEdit, useTextTool, useTools, useVelocityTracker, useViewAnimation, useVisibleRaf, useZoom, viewToMat3, viewToTransform, viewportDragPanAction, viewportZoomAction, viewportsAt, visualBoundsViaDescriptor, when, withAlpha01, withCoord, withGradientKind, worldEditToStorage, worldPoseLookup, worldToScreen, zoomAt, zoomAtLeast };
-//# sourceMappingURL=chunk-FUQWXDG3.js.map
-//# sourceMappingURL=chunk-FUQWXDG3.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, 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, 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, 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, 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, isEditableTarget2 as 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, 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, usePinchZoomTool, usePointerStylus, usePolygonTool, usePublishSelection, useRectTool, useResizePolicy, useRotateTool, useScene, useSceneAdapter, useSceneTextEdit, useSelectTool, useSelection, useSelectionContext, useSimulation, useSliceDep, useStandardActions, useStarTool, useTextEdit, useTextTool, useTools, useVelocityTracker, useViewAnimation, useVisibleRaf, useZoom, viewToMat3, viewToTransform, viewportDragPanAction, viewportWheelPanAction, viewportZoomAction, viewportsAt, visualBoundsViaDescriptor, when, withAlpha01, withCoord, withGradientKind, worldEditToStorage, worldPoseLookup, worldToScreen, zoomAt, zoomAtLeast };
+//# sourceMappingURL=chunk-NU7D64RL.js.map
+//# sourceMappingURL=chunk-NU7D64RL.js.map