@weasel-js/core 1.4.0 → 1.4.2

package/dist/{chunk-HYJL7OOJ.js → chunk-KIVJXUYE.js}

@@ -1,4 +1,4 @@
-import { ActionDisabledReason, useOptionalDepRegistry, DepRegistryProvider, useActionsRegistry, ActionsProvider, useDepRegistry, reportRouteConflicts, buildDepsFromRequires, useDepSource, actionBindings } from './chunk-UTIFY2UU.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';
@@ -25,7 +25,7 @@ import { createHistory } from '@weasel-js/history';
 export * from '@weasel-js/history';
 
 // src/version.ts
-var VERSION = "1.4.0" ;
+var VERSION = "1.4.2" ;
 
 // src/features/grid/roundToCell.ts
 function roundToCell(value, cellSize) {
@@ -258,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",
@@ -268,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 = (
@@ -1517,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);
@@ -3241,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();
@@ -3335,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);
   }
 }
@@ -3518,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) {
@@ -3561,7 +3817,7 @@ function tryStageSolid(ctx, mesh, paint) {
     pushMesh(ctx, mesh, paint);
     return true;
   }
-  flushSolids(ctx);
+  flushBatches(ctx);
   return false;
 }
 function flushSolids(ctx) {
@@ -3582,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;
@@ -3785,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;
@@ -3800,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;
@@ -3847,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;
   }
@@ -4195,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) {
@@ -4311,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) {
@@ -4346,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
@@ -4485,6 +4746,7 @@ var WeaselRenderer = class {
   textSdf;
   textSdfR8;
   imageFill;
+  imageFillVOpacity;
   gradFill;
   patternFill;
   meshCache;
@@ -4495,6 +4757,7 @@ var WeaselRenderer = class {
   quadVbo = null;
   quadIbo = null;
   solidBatch;
+  imageBatch;
   groupState = new GroupState();
   widthCss;
   heightCss;
@@ -4559,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);
@@ -4573,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;
@@ -4696,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);
@@ -4711,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;
@@ -4759,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()) {
@@ -4770,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.
@@ -4801,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,
@@ -4812,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,
@@ -4821,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) {
@@ -4855,6 +5136,10 @@ var WeaselRenderer = class {
     return this.solidBatch;
   }
   /** @internal */
+  _imageBatch() {
+    return this.imageBatch;
+  }
+  /** @internal */
   _textSdf() {
     return this.textSdf;
   }
@@ -4867,6 +5152,10 @@ var WeaselRenderer = class {
     return this.imageFill;
   }
   /** @internal */
+  _imageFillVOpacity() {
+    return this.imageFillVOpacity;
+  }
+  /** @internal */
   _gradFill() {
     return this.gradFill;
   }
@@ -5915,6 +6204,85 @@ function clientToCanvasRect(rect, clientX, clientY) {
   return [clientX - rect.left, clientY - rect.top];
 }
 
+// src/interactions/gestures/pointerSession/pointerSession.ts
+var LOST_CAPTURE_EVENT = "lostpointercapture";
+function reportsButtons(down) {
+  return !!down.buttons;
+}
+function isMissedRelease(move) {
+  return move.buttons === 0;
+}
+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) return;
+    if (!origin.isConnected) 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) {
@@ -5923,10 +6291,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();
@@ -5934,26 +6307,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 };
 }
@@ -6009,57 +6380,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;
@@ -6067,41 +6434,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" } };
 }
@@ -6128,47 +6500,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(opts.origin ?? e.currentTarget, e, {
+    onMove: (ev) => {
+      maybeActivate(ev);
+      if (activated) opts.onMove(ev);
+    },
+    onEnd: (ev) => {
+      if (activated) opts.onCommit(ev);
+      else opts.onClick?.(ev);
+    },
+    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
@@ -8217,6 +8576,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",
@@ -8235,17 +8618,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,
@@ -8253,7 +8656,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 });
+            }
+          });
         }
       };
     }
@@ -8357,6 +8777,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 });
@@ -13003,7 +13471,7 @@ function withViewDeps(base, overlay) {
   };
 }
 function computeMultiTouchGeometry(positions) {
-  const pts = [...positions.values()];
+  const pts = [...positions];
   if (pts.length < 2) {
     return { centroid: { x: 0, y: 0 }, spread: 0 };
   }
@@ -13130,13 +13598,13 @@ function useGestureDispatcher(opts) {
       return result;
     };
     const heldKeys = /* @__PURE__ */ new Set();
-    const activePointers = /* @__PURE__ */ new Set();
-    const pointerPositions = /* @__PURE__ */ new Map();
+    const held = /* @__PURE__ */ new Map();
+    const heldGeometry = () => computeMultiTouchGeometry(
+      [...held.values()].map((p) => p.pos)
+    );
     let multiTouchStart = null;
     const TAP_THRESHOLD_PX = 8;
     const DRAG_THRESHOLD_PX = 4;
-    const bufferedDown = /* @__PURE__ */ new Map();
-    const lastPointerDown = /* @__PURE__ */ new Map();
     const LONG_PRESS_MS = 500;
     const longPressTimers = /* @__PURE__ */ new Map();
     const cancelLongPress = (pointerId) => {
@@ -13151,7 +13619,7 @@ function useGestureDispatcher(opts) {
       longPressTimers.clear();
     };
     const fireLongPress = (pointerId) => {
-      const down = lastPointerDown.get(pointerId);
+      const down = held.get(pointerId)?.down;
       if (!down) return;
       const shared = {
         target: down.target,
@@ -13273,13 +13741,8 @@ function useGestureDispatcher(opts) {
     };
     const onPointerDown = (e) => {
       if ((e.button ?? 0) !== 0) return;
+      if (!canvas) return;
       routeDown(e.pointerId, e.clientX, e.clientY);
-      activePointers.add(e.pointerId);
-      pointerPositions.set(e.pointerId, { x: e.clientX, y: e.clientY });
-      try {
-        canvas?.setPointerCapture?.(e.pointerId);
-      } catch {
-      }
       const worldPoint = { x: e.clientX, y: e.clientY };
       const affordance = target().affordanceAt?.(worldPoint) ?? void 0;
       const body = target().classifyTarget?.(worldPoint);
@@ -13303,23 +13766,35 @@ function useGestureDispatcher(opts) {
         ...bodyTarget !== void 0 ? { bodyTarget } : {},
         ...bodyKind !== void 0 ? { bodyKind } : {}
       };
-      bufferedDown.set(e.pointerId, { ev, clientX: e.clientX, clientY: e.clientY });
-      dispatch2({ ...ev, stage: "press" });
-      lastPointerDown.set(e.pointerId, {
-        target: e.target,
-        clientX: e.clientX,
-        clientY: e.clientY,
-        worldX: w.x,
-        worldY: w.y,
-        affordance,
-        bodyTarget,
-        bodyKind,
-        altKey: e.altKey,
-        ctrlKey: e.ctrlKey,
-        metaKey: e.metaKey,
-        shiftKey: e.shiftKey
+      held.set(e.pointerId, {
+        session: openPointerSession(canvas, e, {
+          onMove: onPointerMove,
+          onEnd: onPointerUp,
+          onCancel: () => {
+            onPointerCancel(e.pointerId);
+          }
+        }),
+        pos: { x: e.clientX, y: e.clientY },
+        // Deferred until the first past-threshold pointermove: a bare
+        // press-and-release should fire `click`, not start a drag action.
+        buffered: { ev, clientX: e.clientX, clientY: e.clientY },
+        down: {
+          target: e.target,
+          clientX: e.clientX,
+          clientY: e.clientY,
+          worldX: w.x,
+          worldY: w.y,
+          affordance,
+          bodyTarget,
+          bodyKind,
+          altKey: e.altKey,
+          ctrlKey: e.ctrlKey,
+          metaKey: e.metaKey,
+          shiftKey: e.shiftKey
+        }
       });
-      if ((e.pointerType === "touch" || e.pointerType === "pen") && activePointers.size === 1) {
+      dispatch2({ ...ev, stage: "press" });
+      if ((e.pointerType === "touch" || e.pointerType === "pen") && held.size === 1) {
         cancelLongPress(e.pointerId);
         longPressTimers.set(
           e.pointerId,
@@ -13330,18 +13805,18 @@ function useGestureDispatcher(opts) {
           }, LONG_PRESS_MS)
         );
       }
-      if (activePointers.size >= 2) {
+      if (held.size >= 2) {
         cancelAllLongPress();
-        for (const id of activePointers) bufferedDown.delete(id);
-        const { centroid, spread } = computeMultiTouchGeometry(pointerPositions);
+        for (const p of held.values()) p.buffered = null;
+        const { centroid, spread } = heldGeometry();
         if (!multiTouchStart) {
-          multiTouchStart = { fingers: activePointers.size, centroid: { ...centroid } };
+          multiTouchStart = { fingers: held.size, centroid: { ...centroid } };
         } else {
-          multiTouchStart.fingers = activePointers.size;
+          multiTouchStart.fingers = held.size;
         }
         const mt = {
           kind: "multitouch",
-          fingers: activePointers.size,
+          fingers: held.size,
           altKey: e.altKey,
           ctrlKey: e.ctrlKey,
           metaKey: e.metaKey,
@@ -13354,25 +13829,24 @@ function useGestureDispatcher(opts) {
     };
     const onPointerMove = (e) => {
       routeAt(e.pointerId, e.clientX, e.clientY);
-      if (activePointers.has(e.pointerId)) {
-        pointerPositions.set(e.pointerId, { x: e.clientX, y: e.clientY });
-      }
-      const buffered = bufferedDown.get(e.pointerId);
-      if (buffered) {
+      const rec = held.get(e.pointerId);
+      if (rec) rec.pos = { x: e.clientX, y: e.clientY };
+      const buffered = rec?.buffered;
+      if (rec && buffered) {
         const dx = e.clientX - buffered.clientX;
         const dy = e.clientY - buffered.clientY;
         if (Math.hypot(dx, dy) >= DRAG_THRESHOLD_PX) {
-          bufferedDown.delete(e.pointerId);
+          rec.buffered = null;
           cancelLongPress(e.pointerId);
           dispatch2(buffered.ev);
         }
       }
-      const mtGestureId = `multitouch-${activePointers.size}`;
-      if (activePointers.size >= 2 && dispatcherNow().inFlight().has(mtGestureId)) {
-        const { centroid, spread } = computeMultiTouchGeometry(pointerPositions);
+      const mtGestureId = `multitouch-${held.size}`;
+      if (held.size >= 2 && dispatcherNow().inFlight().has(mtGestureId)) {
+        const { centroid, spread } = heldGeometry();
         const mtEv = {
           kind: "multitouch",
-          fingers: activePointers.size,
+          fingers: held.size,
           altKey: e.altKey,
           ctrlKey: e.ctrlKey,
           metaKey: e.metaKey,
@@ -13444,7 +13918,7 @@ function useGestureDispatcher(opts) {
     }
     function resolveHoverCursor() {
       if (!canvas || !lastHover) return;
-      if (activePointers.size > 0 || dispatcherNow().inFlight().size > 0) {
+      if (held.size > 0 || dispatcherNow().inFlight().size > 0) {
         applyHoverCursor(dispatcherNow().inFlightCursor());
         return;
       }
@@ -13492,6 +13966,10 @@ function useGestureDispatcher(opts) {
         if (!disposed) refreshHoverCursor();
       }, 0);
     };
+    const onHoverMove = (e) => {
+      if (held.has(e.pointerId)) return;
+      onPointerMove(e);
+    };
     const onHoverPointerLeave = () => {
       lastHover = null;
       paintedCursorRef.current?.()?.clearPointer();
@@ -13500,20 +13978,21 @@ function useGestureDispatcher(opts) {
     const onPointerUp = (e) => {
       routeAt(e.pointerId, e.clientX, e.clientY);
       cancelLongPress(e.pointerId);
-      const prevSize = activePointers.size;
-      activePointers.delete(e.pointerId);
-      pointerPositions.delete(e.pointerId);
-      const staysUnderThreshold = bufferedDown.delete(e.pointerId);
-      if (prevSize >= 2 && activePointers.size < 2) {
+      const prevSize = held.size;
+      const rec = held.get(e.pointerId);
+      held.delete(e.pointerId);
+      const staysUnderThreshold = rec?.buffered != null;
+      if (prevSize >= 2 && held.size < 2) {
         const mtGestureId = `multitouch-${prevSize}`;
         if (dispatcherNow().inFlight().has(mtGestureId)) {
           dispatcherNow().cancelAll("commit");
         }
         const start = multiTouchStart;
         if (start) {
-          const finalPositions = new Map(pointerPositions);
-          finalPositions.set(e.pointerId, { x: e.clientX, y: e.clientY });
-          const { centroid } = computeMultiTouchGeometry(finalPositions);
+          const { centroid } = computeMultiTouchGeometry([
+            ...[...held.values()].map((p) => p.pos),
+            { x: e.clientX, y: e.clientY }
+          ]);
           const dx = centroid.x - start.centroid.x;
           const dy = centroid.y - start.centroid.y;
           if (Math.hypot(dx, dy) <= TAP_THRESHOLD_PX) {
@@ -13530,8 +14009,7 @@ function useGestureDispatcher(opts) {
           multiTouchStart = null;
         }
       }
-      const downForClick = lastPointerDown.get(e.pointerId);
-      const movedDuringDrag = downForClick ? downForClick.clientX !== e.clientX || downForClick.clientY !== e.clientY : true;
+      const movedDuringDrag = rec ? rec.down.clientX !== e.clientX || rec.down.clientY !== e.clientY : true;
       const hadDragInFlight = dispatcherNow().inFlight().has(pointerGestureId(e.pointerId)) && movedDuringDrag;
       const wUp = toWorld2(e.clientX, e.clientY);
       const ev = {
@@ -13547,8 +14025,7 @@ function useGestureDispatcher(opts) {
         shiftKey: e.shiftKey
       };
       dispatch2(ev);
-      const down = lastPointerDown.get(e.pointerId);
-      lastPointerDown.delete(e.pointerId);
+      const down = rec?.down;
       if (!hadDragInFlight && staysUnderThreshold && down) {
         const wClick = toWorld2(e.clientX, e.clientY);
         const clickEv = {
@@ -13605,24 +14082,24 @@ function useGestureDispatcher(opts) {
         if (!disposed) refreshHoverCursor();
       }, 0);
     };
-    const onPointerCancel = (e) => {
-      routeAt(e.pointerId, e.clientX, e.clientY);
-      cancelLongPress(e.pointerId);
-      activePointers.delete(e.pointerId);
-      pointerPositions.delete(e.pointerId);
-      lastPointerDown.delete(e.pointerId);
-      bufferedDown.delete(e.pointerId);
+    const onPointerCancel = (pointerId) => {
+      if (disposed) return;
+      const rec = held.get(pointerId);
+      if (!rec) return;
+      held.delete(pointerId);
+      routeAt(pointerId, rec.pos.x, rec.pos.y);
+      cancelLongPress(pointerId);
       multiTouchStart = null;
       const ev = {
         kind: "pointercancel",
-        pointerId: e.pointerId,
-        altKey: e.altKey,
-        ctrlKey: e.ctrlKey,
-        metaKey: e.metaKey,
-        shiftKey: e.shiftKey
+        pointerId,
+        altKey: rec.down.altKey,
+        ctrlKey: rec.down.ctrlKey,
+        metaKey: rec.down.metaKey,
+        shiftKey: rec.down.shiftKey
       };
       dispatch2(ev);
-      routeRelease(e.pointerId);
+      routeRelease(pointerId);
     };
     const onContextMenu = (e) => {
       e.preventDefault();
@@ -13710,9 +14187,7 @@ function useGestureDispatcher(opts) {
     canvas?.addEventListener("pointerleave", onHoverPointerLeave);
     canvas?.addEventListener("wheel", onWheel, { passive: false });
     canvas?.addEventListener("pointerdown", onPointerDown);
-    canvas?.addEventListener("pointermove", onPointerMove);
-    canvas?.addEventListener("pointerup", onPointerUp);
-    canvas?.addEventListener("pointercancel", onPointerCancel);
+    canvas?.addEventListener("pointermove", onHoverMove);
     canvas?.addEventListener("contextmenu", onContextMenu);
     canvas?.addEventListener("dragenter", onDragOver);
     canvas?.addEventListener("dragover", onDragOver);
@@ -13730,9 +14205,7 @@ function useGestureDispatcher(opts) {
       canvas?.removeEventListener("pointerleave", onHoverPointerLeave);
       canvas?.removeEventListener("wheel", onWheel);
       canvas?.removeEventListener("pointerdown", onPointerDown);
-      canvas?.removeEventListener("pointermove", onPointerMove);
-      canvas?.removeEventListener("pointerup", onPointerUp);
-      canvas?.removeEventListener("pointercancel", onPointerCancel);
+      canvas?.removeEventListener("pointermove", onHoverMove);
       canvas?.removeEventListener("contextmenu", onContextMenu);
       canvas?.removeEventListener("dragenter", onDragOver);
       canvas?.removeEventListener("dragover", onDragOver);
@@ -13743,6 +14216,8 @@ function useGestureDispatcher(opts) {
       clearHoverCursor();
       cancelAllLongPress();
       disposed = true;
+      for (const p of held.values()) p.session.cancel();
+      held.clear();
       for (const d of allDispatchers()) d.cancelAll("cancel");
     };
   }, [enabled, keyboard, canvasRef]);
@@ -13775,26 +14250,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() {
@@ -17762,7 +18218,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",
@@ -17780,7 +18238,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
+          })
+        }
+      }]
     }),
     []
   );
@@ -19151,24 +19618,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;
@@ -19177,7 +19645,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 = [];
@@ -19208,26 +19676,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) {
@@ -20394,7 +20848,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) => {
@@ -24097,10 +24551,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) {
@@ -24119,6 +24573,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()
       } : {}
     };
   }
@@ -24882,7 +25340,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) {
@@ -24910,64 +25367,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));
@@ -24982,7 +25405,7 @@ function useViewportActions(args) {
     return () => {
       for (const u of unregisters) u();
     };
-  }, [pan, zoomKey, pinchKey]);
+  }, [panKey, zoomKey, pinchKey]);
 }
 
 // src/core/scene/NodeRouting.ts
@@ -25206,7 +25629,6 @@ function SceneCanvasInner(props, ref) {
     () => isSerialized(sceneInput) ? sceneFromJSON(sceneInput, {}) : null
   );
   const scene = bakedScene ?? sceneInput;
-  useSyncExternalStore(scene.subscribe, scene.getVersion, scene.getVersion);
   const { view: viewProp, onViewChange: onViewChangeProp, defaultView, ...restProps } = rest;
   const internalCanvasRef = useRef(null);
   const canvasApiRef = useRef(null);
@@ -25237,6 +25659,9 @@ function SceneCanvasInner(props, ref) {
   useEffect(() => scene.overrides.subscribe(() => {
     canvasApiRef.current?.requestRedraw?.();
   }), [scene]);
+  useEffect(() => scene.subscribe(() => {
+    canvasApiRef.current?.requestRedraw?.();
+  }), [scene]);
   const currentViewRef = useRef(
     viewProp ?? defaultView ?? { x: 0, y: 0, scale: { x: 1, y: 1 } }
   );
@@ -25417,13 +25842,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([
@@ -25876,7 +26301,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,
@@ -26167,6 +26592,7 @@ function StandardActionsRegistrar({
       getActionRef.current = null;
     };
   }, [registry2, getActionRef]);
+  const decayLoop = useDecayLoop();
   const view = useViewDepSource(
     currentViewRef,
     onViewChange,
@@ -26175,7 +26601,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 });
@@ -26635,8 +27062,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);
@@ -26665,36 +27091,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") {
@@ -26707,16 +27115,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,
     {
@@ -30856,6 +31259,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, PAINTED_CURSOR_LAYER_ID, 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, createPaintedCursorLayer, createPaintedCursorState, 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-HYJL7OOJ.js.map
-//# sourceMappingURL=chunk-HYJL7OOJ.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-KIVJXUYE.js.map
+//# sourceMappingURL=chunk-KIVJXUYE.js.map