@weasel-js/core 1.4.2 → 1.4.3

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

@@ -1,10 +1,10 @@
-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 { ActionDisabledReason, useOptionalDepRegistry, DepRegistryProvider, useActionsRegistry, ActionsScope, ActionsProvider, useDepRegistry, reportRouteConflicts, buildDepsFromRequires, useDepSource, actionBindings } from './chunk-LEURURX3.js';
+import { scratchKey, createReparentOp, createTransformOp, snap, getScratch, setScratch } from './chunk-ORZNKVXM.js';
 import { fixedCornerOf, DEFAULT_RESIZE_BEHAVIORS, CORNER_ANCHORS, cornerPoint } from './chunk-BLJNRMKB.js';
-import { AUTO_POSE_DESCRIPTOR, 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';
-import { dispatchApplyBatch, dlog, dwarn, usePointerContext, PointerContextProvider, applyOpsTo, extractWeaselClipboardFromSvg, parseWeaselClipboardText, materializePaste, WEASEL_CLIPBOARD_MIME, WEASEL_CLIPBOARD_MIME_WEB, sniffWeaselClipboardText } from './chunk-67KE7SDP.js';
-import { createSetSelectionOp } from './chunk-ZB7UYJVG.js';
-import { registerOpFactory, createDeleteOp, createInsertOp, rebuildOp } from './chunk-2KKYDDDD.js';
+import { AUTO_POSE_DESCRIPTOR, remapRotatedLeaf, PATH_Z, PATH_Q, PATH_C, PATH_L, PATH_M, resolveUnit, polylineFromPoints, starPath, regularPolygonPath, linePath, ellipsePath, rectPath, polygonFromPoints, RECT_POSE_DESCRIPTOR, PathBuilder, pathPoseDescriptor, withinPxRadius, boundsOfPath, DEFAULT_FLATTEN_TOLERANCE, flattenQuadratic, flattenCubic, pointInPath, strokeHitTest, transformPath, translatePath, pxExtent, withinPxBox, flattenCubicWithArcLen, flattenQuadraticWithArcLen, PATH_CMD_LENGTHS, pointToGridCell } from './chunk-SBFC6J3C.js';
+import { dispatchApplyBatch, dlog, dwarn, usePointerContext, PointerContextProvider, extractWeaselClipboardFromSvg, parseWeaselClipboardText, materializePaste, WEASEL_CLIPBOARD_MIME, WEASEL_CLIPBOARD_MIME_WEB, sniffWeaselClipboardText, applyOpsTo } from './chunk-T3UQ3F6R.js';
+import { createSetSelectionOp } from './chunk-DOBSZOPR.js';
+import { registerOpFactory, createInsertOp, createDeleteOp, rebuildOp } from './chunk-4RJP2N2L.js';
 import { getTexture, chunks, dots, crosshatch, hatch } from './chunk-BJN5ZRIJ.js';
 import { createContext, createElement, forwardRef, useMemo, useRef, useCallback, useState, useEffect, useImperativeHandle, useSyncExternalStore, useLayoutEffect, useContext, useId, useReducer } from 'react';
 import { subscribeGlyphReady, DEFAULT_BAKE_BUDGET, TEXT_VERT_SRC, TEXT_FRAG_SRC, TEXT_SDF_UNIFORMS, TEXT_SDF_ATTRIBUTES, TEXT_FRAG_R8_SRC, markAllFontsNotUploaded, resetBakeBudget, syncDynamicPageTexture, ensureFontTexture, dynamicPageTextureId, textureCacheKey } from '@weasel-js/font';
@@ -14,10 +14,10 @@ export { DEFAULT_TEXT_STYLE, MARKDOWN_RUN_GRAMMAR, SCRIPT_METRICS, cachedLayoutR
 import earcut from 'earcut';
 import { dashForStrokeStyle, strokeDashStyleOf, alignedStrokeRect } from '@weasel-js/paint';
 export { STROKE_DASH_RATIOS, alignedStrokeRect, dashForStrokeStyle, strokeDashStyleOf } from '@weasel-js/paint';
-import { clampRectWithin, applyToPoint, rotateAboutPoint, boxToBox, pointInPolygon, segmentsCross, forEachSegment, pathCommandCoordCount, multiply as multiply$1, invert as invert$1, pointSegmentDist2 } from '@weasel-js/geom';
+import { boxToBox, clampRectWithin, applyToPoint, rotateAboutPoint, pointInPolygon, segmentsCross, forEachSegment, pathCommandCoordCount, multiply as multiply$1, invert as invert$1, pointSegmentDist2 } from '@weasel-js/geom';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 import polygonClipping from 'polygon-clipping';
-import { matchSpec, RESERVED_ID_PREFIXES, RESERVED_ID_NAMES, parseTargetSpec, mimeMatchesGlob } from '@weasel-js/gestures';
+import { mimeMatchesGlob, matchSpec, RESERVED_ID_PREFIXES, RESERVED_ID_NAMES, parseTargetSpec } from '@weasel-js/gestures';
 import { NORMAL, IMPLICIT_TAGS } from '@weasel-js/modes';
 import { GLYPHS, cursorWorldSize, cursorPaintOps, chromeLineWidthScale, cursorPaintMatrix, resolveCursorTier, cursorFor, resolveCursor } from '@weasel-js/cursor';
 export { bakeCursor, cursorFor, resolveCursor, resolveCursorTier } from '@weasel-js/cursor';
@@ -25,7 +25,7 @@ import { createHistory } from '@weasel-js/history';
 export * from '@weasel-js/history';
 
 // src/version.ts
-var VERSION = "1.4.2" ;
+var VERSION = "1.4.3" ;
 
 // src/features/grid/roundToCell.ts
 function roundToCell(value, cellSize) {
@@ -1431,6 +1431,28 @@ var GroupState = class {
     this.alphaStack.push(nextAlpha);
     this.colorMatrixStack.push(nextCM);
   }
+  /**
+   * Push a frame whose children paint into a surface of their own.
+   *
+   * The transform still accumulates — the children draw where they would have
+   * drawn. Alpha and colour do not: they describe how the finished surface
+   * joins the frame, and applying them on the way in as well would fade the
+   * pixels an effect is about to read, then fade them again on the way out.
+   *
+   * Returns the pair the caller must apply at composite time — what `push`
+   * would have left on the stack — so the composition rules live here and not
+   * in the dispatcher.
+   */
+  pushIsolated(frame) {
+    this.push(frame);
+    const composited = { alpha: this.alpha, colorMatrix: this.colorMatrix };
+    this.pop();
+    const current = this.transform;
+    this.transformStack.push(frame.transform ? mat3.multiply(current, frame.transform) : current);
+    this.alphaStack.push(1);
+    this.colorMatrixStack.push(IDENTITY_COLOR_MATRIX);
+    return composited;
+  }
   /** Drop every pushed frame, leaving the root. A frame that throws part-way
    *  down the tree never pops, and the next frame would draw under leftovers. */
   reset() {
@@ -3495,6 +3517,63 @@ var ImageBatch = class {
   }
 };
 
+// src/renderer/shaders/registerProgram.ts
+var registry = /* @__PURE__ */ new Map();
+function getProgramSource(id) {
+  return registry.get(id) ?? null;
+}
+var isDev = () => typeof process !== "undefined" ? process.env.NODE_ENV !== "production" : true;
+function registerProgram(id, vert, frag) {
+  if (registry.has(id) && !isDev()) {
+    throw new Error(`weasel registerProgram: duplicate program id "${id}". In production, re-registration is not allowed. Pass a unique id or call in dev mode.`);
+  }
+  registry.set(id, { vert, frag });
+  return { id };
+}
+
+// src/renderer/effects/effectPrelude.ts
+var EFFECT_VERT_SRC = (
+  /* glsl */
+  `#version 300 es
+in vec2 a_position;
+in vec2 a_uv;
+out vec2 v_uv;
+
+void main() {
+  v_uv = a_uv;
+  gl_Position = vec4(a_position, 0.0, 1.0);
+}
+`
+);
+var EFFECT_KIT_UNIFORMS = ["u_source", "u_resolution", "u_texel"];
+var COMPOSITE_FRAG_SRC = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+in vec2 v_uv;
+uniform sampler2D u_source;
+uniform float u_alpha;
+uniform mat4 u_colorMatrix;
+uniform vec4 u_colorBias;
+out vec4 outColor;
+
+void main() {
+  vec4 src = texture(u_source, v_uv);
+  // Undo premultiplication before the colour matrix, which is defined on
+  // straight alpha, then put it back for the blend.
+  float a = src.a;
+  vec3 rgb = a > 0.0 ? src.rgb / a : vec3(0.0);
+  vec4 c = u_colorMatrix * vec4(rgb, a) + u_colorBias;
+  c.a *= u_alpha;
+  outColor = vec4(clamp(c.rgb, 0.0, 1.0) * c.a, c.a);
+}
+`
+);
+
+// src/renderer/effects/composite.ts
+var COMPOSITE_PROGRAM_ID = "weasel:effect-composite";
+registerProgram(COMPOSITE_PROGRAM_ID, EFFECT_VERT_SRC, COMPOSITE_FRAG_SRC);
+
 // src/renderer/draw.ts
 var FRAME_UPLOADS = /* @__PURE__ */ new WeakMap();
 var FRAME_PROJ = /* @__PURE__ */ new WeakMap();
@@ -3711,7 +3790,118 @@ function drawShader(ctx, cmd) {
   gl.bindBuffer(gl.ARRAY_BUFFER, null);
   gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
 }
+function drawGroupWithEffects(ctx, cmd, targets, width, height) {
+  const gl = ctx.gl;
+  flushBatches(ctx);
+  const parentTarget = ctx.renderTarget ?? null;
+  const parentClipDepth = ctx.clipDepth;
+  const scissorWasOn = gl.isEnabled(gl.SCISSOR_TEST);
+  let front = targets.acquire(width, height);
+  const composited = ctx.state.pushIsolated({ transform: cmd.transform });
+  ctx.clipDepth = 0;
+  gl.bindFramebuffer(gl.FRAMEBUFFER, front.fbo);
+  ctx.renderTarget = front;
+  gl.viewport(0, 0, width, height);
+  gl.disable(gl.SCISSOR_TEST);
+  gl.stencilMask(255);
+  gl.clear(gl.COLOR_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);
+  for (const child of cmd.children) dispatch(ctx, child);
+  flushBatches(ctx);
+  gl.disable(gl.BLEND);
+  for (const effect of cmd.effects) {
+    const program = ctx.ensureProgram?.(effect.program.id) ?? null;
+    if (!program) {
+      warnOnceUniform(effect.program.id, "(program)");
+      continue;
+    }
+    const back = targets.acquire(width, height);
+    gl.bindFramebuffer(gl.FRAMEBUFFER, back.fbo);
+    gl.viewport(0, 0, width, height);
+    gl.clear(gl.COLOR_BUFFER_BIT);
+    drawFullscreenQuad(
+      ctx,
+      program,
+      front.texture,
+      width,
+      height,
+      effect.uniforms,
+      void 0,
+      effect.program.id
+    );
+    targets.release(front);
+    front = back;
+  }
+  gl.enable(gl.BLEND);
+  ctx.state.pop();
+  ctx.clipDepth = parentClipDepth;
+  ctx.renderTarget = parentTarget;
+  gl.bindFramebuffer(gl.FRAMEBUFFER, parentTarget ? parentTarget.fbo : null);
+  if (parentTarget) {
+    gl.viewport(0, 0, width, height);
+  } else {
+    ctx.restoreTargetRect?.();
+    if (scissorWasOn) gl.enable(gl.SCISSOR_TEST);
+  }
+  const composite = ctx.ensureProgram?.(COMPOSITE_PROGRAM_ID) ?? null;
+  if (composite) {
+    applyClipTest(ctx);
+    drawFullscreenQuad(ctx, composite, front.texture, width, height, void 0, {
+      alpha: composited.alpha,
+      colorMatrix: composited.colorMatrix
+    });
+  }
+  targets.release(front);
+}
+function drawFullscreenQuad(ctx, program, texture, width, height, uniforms, composite, programId) {
+  const gl = ctx.gl;
+  gl.useProgram(program.handle);
+  const aPos = program.attribute("a_position");
+  const aUv = program.attribute("a_uv");
+  gl.bindBuffer(gl.ARRAY_BUFFER, ctx.quadVbo);
+  gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ctx.quadIbo);
+  if (aPos !== void 0 && aPos >= 0) {
+    gl.enableVertexAttribArray(aPos);
+    gl.vertexAttribPointer(aPos, 2, gl.FLOAT, false, 16, 0);
+  }
+  if (aUv !== void 0 && aUv >= 0) {
+    gl.enableVertexAttribArray(aUv);
+    gl.vertexAttribPointer(aUv, 2, gl.FLOAT, false, 16, 8);
+  }
+  gl.activeTexture(gl.TEXTURE0);
+  gl.bindTexture(gl.TEXTURE_2D, texture);
+  const source = program.uniform("u_source");
+  if (source !== void 0) gl.uniform1i(source, 0);
+  const resolution = program.uniform("u_resolution");
+  if (resolution !== void 0) gl.uniform2f(resolution, width, height);
+  const texel = program.uniform("u_texel");
+  if (texel !== void 0) gl.uniform2f(texel, 1 / width, 1 / height);
+  if (composite) {
+    const alpha = program.uniform("u_alpha");
+    if (alpha !== void 0) gl.uniform1f(alpha, composite.alpha);
+    setColorMatrixUniforms(ctx, program, composite.colorMatrix);
+  }
+  if (uniforms) {
+    const nextTexUnit = { value: 1 };
+    for (const [name, value] of Object.entries(uniforms)) {
+      const loc = program.uniform(name);
+      if (loc === void 0) {
+        warnOnceUniform(programId ?? "effect", name);
+        continue;
+      }
+      setUniform(gl, loc, value, ctx.textureCache, nextTexUnit);
+    }
+  }
+  gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0);
+  if (aPos !== void 0 && aPos >= 0) gl.disableVertexAttribArray(aPos);
+  if (aUv !== void 0 && aUv >= 0) gl.disableVertexAttribArray(aUv);
+  gl.bindBuffer(gl.ARRAY_BUFFER, null);
+  gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
+}
 function drawGroup(ctx, cmd) {
+  if (cmd.effects && cmd.effects.length > 0 && ctx.effectTargets && ctx.deviceWidth && ctx.deviceHeight) {
+    drawGroupWithEffects(ctx, cmd, ctx.effectTargets, ctx.deviceWidth, ctx.deviceHeight);
+    return;
+  }
   ctx.state.push({
     transform: cmd.transform,
     alpha: cmd.alpha,
@@ -3737,7 +3927,7 @@ function drawGroup(ctx, cmd) {
 }
 function drawPath(ctx, cmd) {
   if (cmd.fill) drawPathFill(ctx, cmd);
-  if (cmd.stroke) drawPathStroke(ctx, cmd);
+  if (cmd.stroke?.paint) drawPathStroke(ctx, cmd);
 }
 function drawPathFill(ctx, cmd) {
   const fill = cmd.fill;
@@ -4329,12 +4519,16 @@ function drawText(ctx, cmd) {
 }
 var SYNTHETIC_ITALIC_RADIANS = 0.2094;
 function drawTextOutlineGroup(ctx, group, dx, dy) {
-  const mesh = outlineGroupMesh(group, dx, dy);
-  if (mesh) drawPathFillByKind(ctx, group.fill, ctx.meshCache.uploadTransient(mesh));
-  if (!group.stroke) return;
+  const fill = group.fill;
+  if (fill !== null) {
+    const mesh = outlineGroupMesh(group, dx, dy);
+    if (mesh) drawPathFillByKind(ctx, fill, ctx.meshCache.uploadTransient(mesh));
+  }
+  const strokePaint = group.stroke?.paint;
+  if (!strokePaint) return;
   const ribbon = outlineGroupStrokeMesh(group, dx, dy, mat3.meanScaleOf(ctx.state.transform));
   if (ribbon) {
-    drawPathFillByKind(ctx, group.stroke.paint, ctx.meshCache.uploadTransient(ribbon));
+    drawPathFillByKind(ctx, strokePaint, ctx.meshCache.uploadTransient(ribbon));
   }
 }
 function outlineGroupMesh(group, dx, dy) {
@@ -4485,7 +4679,7 @@ function drawTextGroup(ctx, group, prog, dx, dy) {
   ensureQuadIndices(gl, ring, group.quads.length);
   bindTextQuadSlot(gl, ring, vertices.subarray(0, floats));
   let r = 0, g = 0, b = 0, a = 1;
-  if ("color" in group.fill) {
+  if (group.fill !== null && "color" in group.fill) {
     [r, g, b, a] = resolveColor(group.fill.color);
   }
   setColorUniform(ctx, prog, r, g, b, a);
@@ -4699,19 +4893,79 @@ var QUAD_VERTICES = new Float32Array([
 ]);
 var QUAD_INDICES = new Uint16Array([0, 1, 2, 0, 2, 3]);
 
-// src/renderer/shaders/registerProgram.ts
-var registry = /* @__PURE__ */ new Map();
-function getProgramSource(id) {
-  return registry.get(id) ?? null;
-}
-var isDev = () => typeof process !== "undefined" ? process.env.NODE_ENV !== "production" : true;
-function registerProgram(id, vert, frag) {
-  if (registry.has(id) && !isDev()) {
-    throw new Error(`weasel registerProgram: duplicate program id "${id}". In production, re-registration is not allowed. Pass a unique id or call in dev mode.`);
+// src/renderer/effects/EffectTargets.ts
+var EffectTargets = class {
+  gl;
+  all = [];
+  free = [];
+  width = 0;
+  height = 0;
+  constructor(gl) {
+    this.gl = gl;
   }
-  registry.set(id, { vert, frag });
-  return { id };
-}
+  /** True once anything has been allocated — what a test asks instead of
+   *  reaching for the private arrays. */
+  get allocated() {
+    return this.all.length > 0;
+  }
+  /**
+   * Borrow a target sized `width` × `height` device pixels. A size change
+   * drops every pooled buffer rather than resizing in place: a borrowed one
+   * cannot be resized under its holder, and a resize is not a per-frame event.
+   */
+  acquire(width, height) {
+    if (width !== this.width || height !== this.height) {
+      this.free = [];
+      this.releaseAll();
+      this.width = width;
+      this.height = height;
+    }
+    const pooled = this.free.pop();
+    if (pooled) return pooled;
+    const made = this.create(width, height);
+    this.all.push(made);
+    return made;
+  }
+  /** Hand one back. Order does not matter — every target is interchangeable. */
+  release(target) {
+    this.free.push(target);
+  }
+  /** Drop every buffer. Called on dispose and on context loss, where the
+   *  handles are already invalid and only the bookkeeping has to go. */
+  releaseAll() {
+    const gl = this.gl;
+    for (const t of this.all) {
+      gl.deleteFramebuffer(t.fbo);
+      gl.deleteTexture(t.texture);
+      gl.deleteRenderbuffer(t.stencil);
+    }
+    this.all.length = 0;
+    this.free = [];
+    this.width = 0;
+    this.height = 0;
+  }
+  create(width, height) {
+    const gl = this.gl;
+    const texture = gl.createTexture();
+    gl.bindTexture(gl.TEXTURE_2D, texture);
+    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA8, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    gl.bindTexture(gl.TEXTURE_2D, null);
+    const stencil = gl.createRenderbuffer();
+    gl.bindRenderbuffer(gl.RENDERBUFFER, stencil);
+    gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH24_STENCIL8, width, height);
+    gl.bindRenderbuffer(gl.RENDERBUFFER, null);
+    const fbo = gl.createFramebuffer();
+    gl.bindFramebuffer(gl.FRAMEBUFFER, fbo);
+    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);
+    gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.RENDERBUFFER, stencil);
+    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+    return { fbo, texture, stencil };
+  }
+};
 
 // src/renderer/WeaselRenderer.ts
 var UNIFORM_QUALIFIER = /^(?:lowp|mediump|highp|precise|invariant|centroid|flat|smooth|noperspective)$/;
@@ -4764,6 +5018,9 @@ var WeaselRenderer = class {
   dpr;
   canvas = null;
   target = null;
+  /** Offscreen buffers for group effects. Allocates nothing until a group
+   *  with effects asks, so a canvas without them pays no memory. */
+  effectTargets;
   imageMinification;
   flattenTolerance;
   bakeBudget;
@@ -4781,6 +5038,7 @@ var WeaselRenderer = class {
     const gl = opts.gl ?? opts.canvas.getContext("webgl2", { stencil: true });
     if (!gl) throw new Error("WeaselRenderer: WebGL2 not available");
     this.gl = gl;
+    this.effectTargets = new EffectTargets(this.gl);
     const attrs = typeof this.gl.getContextAttributes === "function" ? this.gl.getContextAttributes() : null;
     if (attrs && attrs.stencil === false) {
       throw new Error(
@@ -4952,6 +5210,7 @@ var WeaselRenderer = class {
     this.contextLost = false;
     this.applyGlState();
     this.applyTarget();
+    this.effectTargets.releaseAll();
     this.pathFill = new ShaderProgram(this.gl, VERT_SRC, FRAG_SRC);
     this.pathFill.lookupUniforms(PATH_FILL_UNIFORMS);
     this.pathFill.lookupAttributes(PATH_FILL_ATTRIBUTES);
@@ -5052,6 +5311,7 @@ var WeaselRenderer = class {
     for (const prog of [this.textSdf, this.textSdfR8, this.pathFill]) disposeTextQuads(gl, prog);
     this.solidBatch.dispose();
     this.imageBatch.dispose();
+    this.effectTargets.releaseAll();
   }
   /**
    * Draw one frame.
@@ -5099,7 +5359,12 @@ var WeaselRenderer = class {
       clipDepth: 0,
       flattenTolerance: this.flattenTolerance,
       textOutlineMinScreenSize: this.textOutlineMinScreenSize,
-      viewMatrix: viewMatrix2
+      viewMatrix: viewMatrix2,
+      effectTargets: this.effectTargets,
+      renderTarget: null,
+      deviceWidth: Math.round(this.widthCss * this.dpr),
+      deviceHeight: Math.round(this.heightCss * this.dpr),
+      restoreTargetRect: () => this.applyTarget()
     };
     for (const cmd of commands) dispatch(ctx, cmd);
     flushBatches(ctx);
@@ -5231,6 +5496,71 @@ function viewToMat3(view) {
   ]);
 }
 
+// src/renderer/effects/types.ts
+function registerEffect(id, frag) {
+  return registerProgram(id, EFFECT_VERT_SRC, frag);
+}
+
+// src/renderer/effects/builtins.ts
+var BLUR_FRAG = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+in vec2 v_uv;
+uniform sampler2D u_source;
+uniform vec2 u_texel;
+uniform vec2 u_direction;
+uniform float u_radius;
+out vec4 outColor;
+
+void main() {
+  // Nine taps on a Gaussian, spread across the requested radius. The weights
+  // are a normalized binomial row, so a radius of 0 collapses to a copy.
+  const float W[5] = float[5](0.2270270, 0.1945946, 0.1216216, 0.0540541, 0.0162162);
+  vec2 step = u_direction * u_texel * (u_radius / 4.0);
+  vec4 sum = texture(u_source, v_uv) * W[0];
+  for (int i = 1; i < 5; i++) {
+    vec2 off = step * float(i);
+    sum += texture(u_source, v_uv + off) * W[i];
+    sum += texture(u_source, v_uv - off) * W[i];
+  }
+  outColor = sum;
+}
+`
+);
+var VIGNETTE_FRAG = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+in vec2 v_uv;
+uniform sampler2D u_source;
+uniform float u_amount;
+uniform float u_feather;
+out vec4 outColor;
+
+void main() {
+  vec4 src = texture(u_source, v_uv);
+  float d = distance(v_uv, vec2(0.5)) * 1.41421356;
+  float shade = 1.0 - u_amount * smoothstep(1.0 - u_feather, 1.0, d);
+  // Premultiplied in, premultiplied out: scaling all four channels darkens
+  // toward transparent black, which is what a vignette over a transparent
+  // canvas should do.
+  outColor = src * shade;
+}
+`
+);
+var BLUR = registerEffect("weasel:blur", BLUR_FRAG);
+var VIGNETTE = registerEffect("weasel:vignette", VIGNETTE_FRAG);
+function blur({ radius }) {
+  return [
+    { program: BLUR, uniforms: { u_direction: [1, 0], u_radius: radius } },
+    { program: BLUR, uniforms: { u_direction: [0, 1], u_radius: radius } }
+  ];
+}
+function vignette({ amount, feather = 0.6 }) {
+  return [{ program: VIGNETTE, uniforms: { u_amount: amount, u_feather: feather } }];
+}
+
 // src/core/viewport/meanScale.ts
 function meanScale(s) {
   return Math.sqrt(s.x * s.y);
@@ -5348,7 +5678,13 @@ function createCellHighlightLayer(opts) {
 
 // src/core/layers/render.ts
 var IDENTITY_VIEW = { x: 0, y: 0, scale: { x: 1, y: 1 } };
-function drawLayers(layers, data, visibility, order, view, dims, cache7) {
+function reportLayerFailure({ layerId, error }) {
+  console.error(
+    `[weasel] layer "${layerId}" threw while drawing; it painted nothing this frame.`,
+    error
+  );
+}
+function drawLayers(layers, data, visibility, order, view, dims, cache7, onLayerError = reportLayerFailure, groups) {
   const layerById = new Map(layers.map((l) => [l.id, l]));
   const sequence = order ? order.map((id) => layerById.get(id)).filter((l) => l !== void 0) : layers;
   const v = view ?? IDENTITY_VIEW;
@@ -5358,12 +5694,67 @@ function drawLayers(layers, data, visibility, order, view, dims, cache7) {
       if (!layerById.has(id)) cache7.delete(id);
     }
   }
+  const groupOf = groupMembership(groups);
+  const bracketed = /* @__PURE__ */ new Set();
+  let run = null;
+  const closeRun = () => {
+    if (!run) return;
+    for (const c of wrapGroup(run.group, run.children, v, dims)) out.push(c);
+    run = null;
+  };
   for (const layer of sequence) {
     if (!isLayerVisible(layer, visibility)) continue;
-    for (const c of drawOneLayer(layer, data, v, dims, cache7)) out.push(c);
+    const cmds = drawOneLayer(layer, data, v, dims, cache7, onLayerError);
+    if (cmds.length === 0) continue;
+    const group = groupOf?.get(layer.id);
+    if (run && run.group !== group) closeRun();
+    if (!group) {
+      for (const c of cmds) out.push(c);
+      continue;
+    }
+    if (!run) {
+      if (bracketed.has(group)) {
+        console.warn(
+          `[weasel] layer group "${group.id}" is not one run \u2014 another layer is drawn between its members, so it composites as more than one pass over more than one buffer. Move its members together in the layer order.`
+        );
+      }
+      bracketed.add(group);
+      run = { group, children: [] };
+    }
+    for (const c of cmds) run.children.push(c);
   }
+  closeRun();
   return out;
 }
+function groupMembership(groups) {
+  if (!groups || groups.length === 0) return null;
+  const byLayer = /* @__PURE__ */ new Map();
+  for (const group of groups) {
+    for (const id of group.layers) {
+      const claimed = byLayer.get(id);
+      if (claimed) {
+        console.warn(
+          `[weasel] layer "${id}" is claimed by layer groups "${claimed.id}" and "${group.id}"; it stays in "${claimed.id}".`
+        );
+        continue;
+      }
+      byLayer.set(id, group);
+    }
+  }
+  return byLayer;
+}
+function wrapGroup(group, children, view, dims) {
+  const declared = typeof group.effects === "function" ? group.effects(view, dims) : group.effects;
+  const effects = declared && declared.length > 0 ? declared : void 0;
+  if (!effects && group.alpha === void 0 && group.colorMatrix === void 0) return children;
+  return [{
+    kind: "group",
+    ...effects ? { effects } : {},
+    ...group.alpha !== void 0 ? { alpha: group.alpha } : {},
+    ...group.colorMatrix !== void 0 ? { colorMatrix: group.colorMatrix } : {},
+    children
+  }];
+}
 function isLayerVisible(layer, visibility) {
   if (layer.alwaysOn) return true;
   if (layer.id in visibility) return visibility[layer.id];
@@ -5373,11 +5764,21 @@ function isLayerPainted(layer, visibility, order) {
   if (order && !order.includes(layer.id)) return false;
   return isLayerVisible(layer, visibility);
 }
-function drawOneLayer(layer, data, view, dims, cache7) {
-  const cmds = layerCommands(layer, data, view, dims, cache7);
+function drawOneLayer(layer, data, view, dims, cache7, onLayerError = reportLayerFailure) {
+  let cmds;
+  try {
+    cmds = layerCommands(layer, data, view, dims, cache7);
+  } catch (error) {
+    cache7?.delete(layer.id);
+    onLayerError({ layerId: layer.id, error });
+    return [];
+  }
   if (cmds.length === 0) return [];
-  if ((layer.space ?? "world") === "screen") return cmds;
-  return [{ kind: "group", transform: viewToMat3(view), children: cmds }];
+  const effects = layer.effects && layer.effects.length > 0 ? layer.effects : void 0;
+  if ((layer.space ?? "world") === "screen") {
+    return effects ? [{ kind: "group", effects, children: cmds }] : cmds;
+  }
+  return [{ kind: "group", transform: viewToMat3(view), ...effects ? { effects } : {}, children: cmds }];
 }
 function layerCommands(layer, data, view, dims, cache7) {
   if (!cache7 || !layer.deps) return layer.draw(data, view, dims);
@@ -5535,7 +5936,7 @@ function createParallaxLayer(opts) {
     space: "screen",
     draw: (data, outer, dims) => {
       const inner = deriveParallaxView(getOuterView?.() ?? outer, { pan, zoom, anchor });
-      return source.flatMap((layer) => layer.draw(data, inner, dims));
+      return source.flatMap((layer) => drawOneLayer(layer, data, inner, dims));
     }
   };
 }
@@ -6548,16 +6949,16 @@ function targetSizesPx(targetScale = 1) {
 }
 
 // src/core/viewport/fitToBounds.ts
-function fitZoom(availW, availH, contentW, contentH, clamp2) {
+function fitZoom(availW, availH, contentW, contentH, clamp) {
   const raw = Math.min(availW / contentW, availH / contentH);
-  const min = clamp2?.min ?? -Infinity;
-  const max = clamp2?.max ?? Infinity;
+  const min = clamp?.min ?? -Infinity;
+  const max = clamp?.max ?? Infinity;
   return Math.min(max, Math.max(min, raw));
 }
-function fitToBounds(viewportW, viewportH, contentW, contentH, paddingPx = 0, clamp2) {
+function fitToBounds(viewportW, viewportH, contentW, contentH, paddingPx = 0, clamp) {
   const availW = Math.max(1, viewportW - paddingPx * 2);
   const availH = Math.max(1, viewportH - paddingPx * 2);
-  const zoom = fitZoom(availW, availH, contentW, contentH, clamp2);
+  const zoom = fitZoom(availW, availH, contentW, contentH, clamp);
   const contentPxW = contentW * zoom;
   const contentPxH = contentH * zoom;
   return {
@@ -6680,128 +7081,6 @@ function sceneNodeClientRect(opts) {
     height: bounds.height * opts.view.scale.y
   };
 }
-var clamp = (z, min, max) => Math.min(max, Math.max(min, z));
-function isEditableTarget(t) {
-  if (!t) return false;
-  const el = t;
-  if (el.isContentEditable) return true;
-  const tag = (el.tagName ?? "").toUpperCase();
-  return tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT";
-}
-function useZoom(opts) {
-  const min = opts.min ?? DEFAULT_MIN_ZOOM;
-  const max = opts.max ?? DEFAULT_MAX_ZOOM;
-  const wheelStep = opts.wheelStep ?? 1.1;
-  const keyStep = opts.keyStep ?? 1.25;
-  const sources = useMemo(
-    () => ({
-      wheel: opts.sources?.wheel ?? true,
-      keys: opts.sources?.keys ?? true,
-      doubleClick: opts.sources?.doubleClick ?? false,
-      pinch: opts.sources?.pinch ?? true
-    }),
-    [opts.sources?.wheel, opts.sources?.keys, opts.sources?.doubleClick, opts.sources?.pinch]
-  );
-  const applyZoom = useCallback(
-    (nextZoom, focal) => {
-      const oldZoom = opts.zoom;
-      const newZoom = clamp(nextZoom, min, max);
-      const k = newZoom / oldZoom;
-      const newPan = {
-        x: focal.x - (focal.x - opts.pan.x) * k,
-        y: focal.y - (focal.y - opts.pan.y) * k
-      };
-      opts.setZoom(newZoom);
-      opts.setPan(newPan);
-    },
-    [opts, min, max]
-  );
-  const viewportCenter = useCallback(() => {
-    if (!opts.viewport) {
-      throw new Error(
-        "useZoom: viewport option is required for keyboard zoom and zoomTo without focal"
-      );
-    }
-    return { x: opts.viewport.width / 2, y: opts.viewport.height / 2 };
-  }, [opts.viewport]);
-  const zoomTo = useCallback(
-    (level, focal) => {
-      applyZoom(level, focal ?? viewportCenter());
-    },
-    [applyZoom, viewportCenter]
-  );
-  const zoomBy = useCallback(
-    (factor, focal) => {
-      applyZoom(opts.zoom * factor, focal ?? viewportCenter());
-    },
-    [applyZoom, opts.zoom, viewportCenter]
-  );
-  const reset = useCallback(() => {
-    opts.setZoom(1);
-    opts.setPan({ x: 0, y: 0 });
-  }, [opts]);
-  const onWheel = useCallback(
-    (e) => {
-      const evt = e;
-      const isPinch = evt.ctrlKey === true;
-      if (isPinch) {
-        if (!sources.pinch) return;
-        evt.preventDefault?.();
-      } else {
-        if (!sources.wheel) return;
-        if (opts.wheelRequiresModifier && !evt.metaKey) return;
-      }
-      const target = evt.currentTarget;
-      const rect = target?.getBoundingClientRect?.();
-      const focal = {
-        x: evt.clientX - (rect?.left ?? 0),
-        y: evt.clientY - (rect?.top ?? 0)
-      };
-      const factor = evt.deltaY < 0 ? wheelStep : 1 / wheelStep;
-      applyZoom(opts.zoom * factor, focal);
-    },
-    [applyZoom, opts, sources, wheelStep]
-  );
-  const onKeyDown = useCallback(
-    (e) => {
-      if (!sources.keys) return;
-      const evt = e;
-      if (isEditableTarget(evt.target)) return;
-      if (evt.key === "0" && (evt.metaKey || evt.ctrlKey)) {
-        opts.setZoom(1);
-        opts.setPan({ x: 0, y: 0 });
-        return;
-      }
-      let factor = 0;
-      if (evt.key === "+" || evt.key === "=") factor = keyStep;
-      else if (evt.key === "-" || evt.key === "_") factor = 1 / keyStep;
-      if (factor === 0) return;
-      applyZoom(opts.zoom * factor, viewportCenter());
-    },
-    [applyZoom, opts, sources, keyStep, viewportCenter]
-  );
-  const onDoubleClick = useCallback(
-    (e) => {
-      if (!sources.doubleClick) return;
-      const evt = e;
-      if (evt.altKey) {
-        opts.setZoom(1);
-        opts.setPan({ x: 0, y: 0 });
-        return;
-      }
-      const target = evt.currentTarget;
-      const rect = target?.getBoundingClientRect?.();
-      const focal = {
-        x: evt.clientX - (rect?.left ?? 0),
-        y: evt.clientY - (rect?.top ?? 0)
-      };
-      const factor = evt.shiftKey ? 1 / keyStep : keyStep;
-      applyZoom(opts.zoom * factor, focal);
-    },
-    [applyZoom, opts, sources, keyStep]
-  );
-  return { onWheel, onKeyDown, onDoubleClick, zoomTo, zoomBy, reset };
-}
 function computeFitViewport(viewportW, viewportH, contentW, contentH, padRatio = 0.85) {
   const zoom = fitZoom(viewportW * padRatio, viewportH * padRatio, contentW, contentH);
   const cw = contentW * zoom;
@@ -6821,7 +7100,7 @@ function useAutoCenter(width, height, contentW, contentH, setZoom, setPan) {
 }
 
 // src/interactions/keyHelpers.ts
-function isEditableTarget2(target) {
+function isEditableTarget(target) {
   if (!target || !(target instanceof Element)) return false;
   const tag = target.tagName;
   if (tag === "INPUT" || tag === "TEXTAREA") return true;
@@ -6959,7 +7238,10 @@ function moveGestureAdapter(scene) {
       data: node.data,
       id: node.id,
       ...index !== void 0 ? { index } : {},
-      ...node.parent !== null ? { parent: node.parent } : {}
+      ...node.parent !== null ? { parent: node.parent } : {},
+      ...node.dependsOn !== void 0 ? { dependsOn: node.dependsOn } : {},
+      ...node.derivePath !== void 0 ? { derivePath: node.derivePath } : {},
+      ...node.kind === "container" && node.clipFromPose !== void 0 ? { clipFromPose: node.clipFromPose } : {}
     }),
     getChildren: (parentId) => parentId === null ? [...scene.roots] : [...scene.childrenOf(asNodeId(parentId))],
     setChildOrder: (parentId, ids) => {
@@ -6984,31 +7266,51 @@ function runLayoutPass(scratch, moveCtx) {
   if (!layoutDep || !moveCtx.drag) return;
   const scene = scratch.scene;
   const pc = scratch.pc;
-  const draggedId = scratch.ids[0];
   const poseAdapter = scenePoseAdapter(scene);
-  if (!scene.get(draggedId)) return;
-  const sourceContainerId = scene.get(draggedId)?.parent ?? null;
   const { dx, dy } = scratch.currentDelta;
-  const startWorld = composeWorldPose(poseAdapter, draggedId, pc.compose);
-  const draggedWorld = { ...startWorld, x: startWorld.x + dx, y: startWorld.y + dy };
-  const draggedCenter = {
-    x: draggedWorld.x + (draggedWorld.width ?? 0) / 2,
-    y: draggedWorld.y + (draggedWorld.height ?? 0) / 2
+  const dragged = [];
+  for (const id of scratch.ids) {
+    const node = scene.get(id);
+    if (!node) continue;
+    const startWorld = composeWorldPose(poseAdapter, id, pc.compose);
+    const world = { ...startWorld, x: startWorld.x + dx, y: startWorld.y + dy };
+    dragged.push({
+      id,
+      arg: {
+        id,
+        originPose: startWorld,
+        pose: world,
+        sourceContainerId: node.parent ?? null
+      },
+      center: { x: world.x + (world.width ?? 0) / 2, y: world.y + (world.height ?? 0) / 2 }
+    });
+  }
+  if (dragged.length === 0) return;
+  const draggedIds = new Set(dragged.map((d) => d.id));
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const d of dragged) {
+    const p = d.arg.pose;
+    minX = Math.min(minX, p.x);
+    minY = Math.min(minY, p.y);
+    maxX = Math.max(maxX, p.x + (p.width ?? 0));
+    maxY = Math.max(maxY, p.y + (p.height ?? 0));
+  }
+  const selectionCenter = { x: (minX + maxX) / 2, y: (minY + maxY) / 2 };
+  const probeOffset = {
+    x: moveCtx.drag.current.x - selectionCenter.x,
+    y: moveCtx.drag.current.y - selectionCenter.y
   };
   const candidates = [];
   const boundsOf2 = scratch.projection?.getBounds ?? AUTO_POSE_DESCRIPTOR.getBounds;
   const testInside = (cPose, aabb, layout2) => {
-    if (layout2.contains) return layout2.contains(cPose, draggedCenter);
-    return draggedCenter.x >= aabb.x && draggedCenter.x < aabb.x + aabb.width && draggedCenter.y >= aabb.y && draggedCenter.y < aabb.y + aabb.height;
-  };
-  const draggedArg = {
-    id: draggedId,
-    originPose: startWorld,
-    pose: draggedWorld,
-    sourceContainerId
+    if (layout2.contains) return layout2.contains(cPose, selectionCenter);
+    return selectionCenter.x >= aabb.x && selectionCenter.x < aabb.x + aabb.width && selectionCenter.y >= aabb.y && selectionCenter.y < aabb.y + aabb.height;
   };
   const consider = (id, zPath) => {
-    if (id === draggedId) return;
+    if (draggedIds.has(id)) return;
     const layout2 = layoutDep.getLayout(id);
     if (!layout2) return;
     const node = scene.get(id);
@@ -7016,7 +7318,10 @@ function runLayoutPass(scratch, moveCtx) {
     const worldPose = composeWorldPose(poseAdapter, id, pc.compose);
     const worldAABB = boundsOf2(worldPose);
     if (!testInside(worldPose, worldAABB, layout2)) return;
-    if (layout2.acceptsDrop && !layout2.acceptsDrop({ id, bounds: worldAABB }, draggedArg)) return;
+    if (layout2.acceptsDrop) {
+      const arg = { id, bounds: worldAABB };
+      for (const d of dragged) if (!layout2.acceptsDrop(arg, d.arg)) return;
+    }
     candidates.push({
       id,
       bounds: worldAABB,
@@ -7061,47 +7366,126 @@ function runLayoutPass(scratch, moveCtx) {
   if (!dest) return;
   const layout = dest.layout;
   const container = { id: dest.id, bounds: dest.bounds };
-  const children = scene.childrenOf(dest.id).filter((cid) => cid !== draggedId || sourceContainerId === dest.id).map((cid) => ({
+  const working = scene.childrenOf(dest.id).map((cid) => ({
     id: cid,
     pose: composeWorldPose(poseAdapter, cid, pc.compose)
   }));
-  const targets = layout.getDropTargets(container, children, draggedArg);
-  const target = layout.snap.pickTarget(targets, { x: moveCtx.drag.current.x, y: moveCtx.drag.current.y });
-  if (!target) return;
+  const setWorking = (id, pose) => {
+    const at = working.findIndex((c) => c.id === id);
+    if (at >= 0) working[at] = { id, pose };
+    else working.push({ id, pose });
+  };
+  const placements = [];
+  const destReflow = /* @__PURE__ */ new Map();
+  for (const d of dragged) {
+    const children = working.map((c) => ({ ...c }));
+    const targets = layout.getDropTargets(container, children, d.arg);
+    const target = layout.snap.pickTarget(targets, {
+      x: d.center.x + probeOffset.x,
+      y: d.center.y + probeOffset.y
+    });
+    if (!target) return;
+    placements.push({ dragged: d.arg, children, target });
+    const poses = layout.reflowPoses(container, children, d.arg, target);
+    for (const [cid, pose] of poses) {
+      setWorking(cid, pose);
+      if (!draggedIds.has(asNodeId(cid))) destReflow.set(asNodeId(cid), pose);
+    }
+    setWorking(d.arg.id, poses.get(d.arg.id) ?? target.pose);
+  }
   const reflowIds = /* @__PURE__ */ new Set();
-  for (const [cid, pose] of layout.reflowPoses(container, children, draggedArg, target)) {
-    if (asNodeId(cid) === draggedId) continue;
-    const parent = scene.get(asNodeId(cid))?.parent ?? null;
-    const local = rebaseLocalPose(poseAdapter, pose, parent, pc.compose, pc.decompose);
-    scratch.previews.set(asNodeId(cid), local);
-    reflowIds.add(asNodeId(cid));
+  for (const [cid, pose] of destReflow) {
+    const parent = scene.get(cid)?.parent ?? null;
+    scratch.previews.set(cid, rebaseLocalPose(poseAdapter, pose, parent, pc.compose, pc.decompose));
+    reflowIds.add(cid);
   }
   const sourceReflow = /* @__PURE__ */ new Map();
-  if (sourceContainerId && sourceContainerId !== dest.id) {
-    const srcLayout = layoutDep.getLayout(sourceContainerId);
-    const srcNode = scene.get(asNodeId(sourceContainerId));
-    if (srcLayout && srcNode) {
-      const srcContainer = {
-        id: sourceContainerId,
-        bounds: composeWorldPose(poseAdapter, sourceContainerId, pc.compose)
-      };
-      const srcChildren = scene.childrenOf(asNodeId(sourceContainerId)).filter((cid) => cid !== draggedId).map((cid) => ({
-        id: cid,
-        pose: composeWorldPose(poseAdapter, cid, pc.compose)
-      }));
-      for (const [cid, pose] of srcLayout.childPoses(srcContainer, srcChildren)) {
-        const cur = composeWorldPose(poseAdapter, cid, pc.compose);
-        const next = pose;
-        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));
-        reflowIds.add(asNodeId(cid));
+  for (const [srcId, leaving] of groupBySourceContainer(dragged.map((d) => ({
+    id: d.id,
+    sourceContainerId: d.arg.sourceContainerId
+  })), container.id)) {
+    const srcLayout = layoutDep.getLayout(srcId);
+    const srcNode = scene.get(asNodeId(srcId));
+    if (!srcLayout || !srcNode) continue;
+    const srcContainer = {
+      id: srcId,
+      bounds: composeWorldPose(poseAdapter, srcId, pc.compose)
+    };
+    const srcChildren = scene.childrenOf(asNodeId(srcId)).filter((cid) => !leaving.has(cid)).map((cid) => ({
+      id: cid,
+      pose: composeWorldPose(poseAdapter, cid, pc.compose)
+    }));
+    for (const [cid, pose] of srcLayout.childPoses(srcContainer, srcChildren)) {
+      const cur = composeWorldPose(poseAdapter, cid, pc.compose);
+      const next = pose;
+      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));
+      reflowIds.add(asNodeId(cid));
+    }
+  }
+  scratch.layoutPass = { layout, container, placements, sourceReflow, reflowIds };
+}
+function groupBySourceContainer(dragged, exclude) {
+  const out = /* @__PURE__ */ new Map();
+  for (const d of dragged) {
+    const src = d.sourceContainerId;
+    if (!src || src === exclude) continue;
+    let set = out.get(src);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      out.set(src, set);
+    }
+    set.add(d.id);
+  }
+  return out;
+}
+function translateCommitOps(scratch, ids, dx, dy) {
+  const m = [1, 0, 0, 1, dx, dy];
+  const ops = [];
+  for (const id of ids) {
+    const origin = scratch.startPoses.get(id);
+    if (origin === void 0) continue;
+    ops.push(createTransformOp({
+      id,
+      from: origin,
+      to: translatePoseGeneric(origin, dx, dy, scratch.projection),
+      label: "Move"
+    }));
+    if (scratch.geometryProjection) {
+      const node = scratch.scene.get(id);
+      if (node) {
+        const dataOp = geometryDataOp(
+          scratch.geometryProjection,
+          { id, data: node.data, pose: origin },
+          m,
+          "Move"
+        );
+        if (dataOp) ops.push(dataOp);
       }
     }
   }
-  scratch.layoutPass = { layout, container, children, target, sourceReflow, reflowIds };
+  return ops;
+}
+function unreleasedIds(scratch, released) {
+  const selected = new Set(scratch.ids);
+  const out = scratch.ids.filter((id) => !released.has(id));
+  for (const id of scratch.cascadeIds) {
+    let cur = scratch.scene.get(id)?.parent ?? null;
+    let claimed = false;
+    while (cur) {
+      if (released.has(cur)) {
+        claimed = true;
+        break;
+      }
+      if (selected.has(cur)) break;
+      cur = scratch.scene.get(cur)?.parent ?? null;
+    }
+    if (!claimed) out.push(id);
+  }
+  return out;
 }
 function scenePoseAdapter(scene) {
   return {
@@ -7286,7 +7670,7 @@ var moveAction = {
             scratch.previews.set(id, translatePoseGeneric(ori, dx, dy, scratch.projection));
           }
           scratch.layoutPass = null;
-          if (scratch.ids.length === 1) runLayoutPass(scratch, moveCtx);
+          runLayoutPass(scratch, moveCtx);
           syncPreviewOverrides(scratch);
         },
         onEnd(endCtx, reason) {
@@ -7321,25 +7705,17 @@ var moveAction = {
             scratch.previews.clear();
             return;
           }
-          if (scratch.layout && scratch.ids.length === 1 && scratch.layoutPass) {
+          if (scratch.layout && scratch.layoutPass) {
             const lp = scratch.layoutPass;
             const pc2 = scratch.pc;
-            const draggedId = scratch.ids[0];
             const commitAdapter = scenePoseAdapter(scratch.scene);
-            const startWorld = composeWorldPose(commitAdapter, draggedId, pc2.compose);
-            const sourceContainerId = scratch.scene.get(draggedId)?.parent ?? null;
-            const draggedArg = {
-              id: draggedId,
-              originPose: startWorld,
-              pose: { ...startWorld, x: startWorld.x + dx, y: startWorld.y + dy },
-              sourceContainerId
-            };
             const destId = lp.container.id;
+            const draggedIds = new Set(scratch.ids.map((id) => id));
             const rebaseOpToLocal = (op) => {
               if (op.name !== "transform") return op;
               const a = op.args;
               const curParent = scratch.scene.get(asNodeId(a.id))?.parent ?? null;
-              const toParent = a.id === draggedId ? destId : curParent;
+              const toParent = draggedIds.has(a.id) ? destId : curParent;
               return createTransformOp({
                 id: a.id,
                 from: rebaseLocalPose(commitAdapter, a.from, curParent, pc2.compose, pc2.decompose),
@@ -7348,15 +7724,24 @@ var moveAction = {
                 coalesceKey: a.coalesceKey
               });
             };
-            const dropOps = lp.layout.commitDrop(lp.container, lp.children, draggedArg, lp.target).map(rebaseOpToLocal);
             const reparentOps = [];
-            if (draggedArg.sourceContainerId !== destId) {
-              reparentOps.push(createReparentOp({
-                id: draggedId,
-                fromParentId: draggedArg.sourceContainerId,
-                toParentId: destId,
-                label: "Reparent"
-              }));
+            const dropOps = [];
+            for (const placement of lp.placements) {
+              if (placement.dragged.sourceContainerId !== destId) {
+                reparentOps.push(createReparentOp({
+                  id: placement.dragged.id,
+                  fromParentId: placement.dragged.sourceContainerId,
+                  toParentId: destId,
+                  label: "Reparent"
+                }));
+              }
+              const ops2 = lp.layout.commitDrop(
+                lp.container,
+                placement.children,
+                placement.dragged,
+                placement.target
+              );
+              for (const op of ops2) dropOps.push(rebaseOpToLocal(op));
             }
             const reflowOps = [];
             for (const [cid, worldPose] of lp.sourceReflow) {
@@ -7375,38 +7760,82 @@ var moveAction = {
             scratch.previews.clear();
             return;
           }
+          const released = /* @__PURE__ */ new Set();
+          const releasedOps = [];
+          if (scratch.layout && !scratch.layoutPass) {
+            const pc2 = scratch.pc;
+            const commitAdapter = scenePoseAdapter(scratch.scene);
+            const boundsOf2 = scratch.projection?.getBounds ?? AUTO_POSE_DESCRIPTOR.getBounds;
+            const rebaseReleased = (op) => {
+              if (op.name !== "transform") return op;
+              const a = op.args;
+              const parent = scratch.scene.get(asNodeId(a.id))?.parent ?? null;
+              return createTransformOp({
+                id: a.id,
+                from: rebaseLocalPose(commitAdapter, a.from, parent, pc2.compose, pc2.decompose),
+                to: rebaseLocalPose(commitAdapter, a.to, parent, pc2.compose, pc2.decompose),
+                label: a.label,
+                coalesceKey: a.coalesceKey
+              });
+            };
+            const sources = groupBySourceContainer(
+              scratch.ids.map((id) => ({
+                id,
+                sourceContainerId: scratch.scene.get(id)?.parent ?? null
+              })),
+              null
+            );
+            for (const [srcId, leaving] of sources) {
+              const srcLayout = scratch.layout.getLayout(srcId);
+              if (!srcLayout?.releaseDrop) continue;
+              const srcContainer = {
+                id: srcId,
+                bounds: boundsOf2(
+                  composeWorldPose(commitAdapter, srcId, pc2.compose)
+                )
+              };
+              let srcChildren = scratch.scene.childrenOf(asNodeId(srcId)).filter((cid) => !leaving.has(cid)).map((cid) => ({
+                id: cid,
+                pose: composeWorldPose(commitAdapter, cid, pc2.compose)
+              }));
+              for (const id of leaving) {
+                const startWorld = composeWorldPose(commitAdapter, id, pc2.compose);
+                const ops = srcLayout.releaseDrop(srcContainer, srcChildren, {
+                  id,
+                  originPose: startWorld,
+                  pose: { ...startWorld, x: startWorld.x + dx, y: startWorld.y + dy },
+                  sourceContainerId: srcId
+                });
+                if (ops === null) continue;
+                released.add(id);
+                let landed = startWorld;
+                for (const op of ops) {
+                  const a = op.args;
+                  if (op.name === "transform" && a.id === id) landed = a.to;
+                  releasedOps.push(rebaseReleased(op));
+                }
+                srcChildren = [...srcChildren, { id, pose: landed }];
+              }
+            }
+          }
+          if (released.size > 0) {
+            const ops = [
+              ...releasedOps,
+              ...translateCommitOps(scratch, unreleasedIds(scratch, released), dx, dy)
+            ];
+            if (ops.length > 0) commitOps(ops, ops[0].label ?? "Move");
+            scratch.previews.clear();
+            return;
+          }
           const resolved = resolveParams(opts?.params);
           const reparentMode = resolved?.["reparentOnDrop"] ?? "off";
           const dropTarget = reparentMode !== "off" ? resolveDropTarget(endCtx, scratch) : null;
           if (dropTarget) {
             scratch.scene.batch("Move", () => {
               applyReparent(scratch, dropTarget, reparentMode, dx, dy, scratch.pc);
-            });
-          } else {
-            const m = [1, 0, 0, 1, dx, dy];
-            const ops = [];
-            for (const id of [...scratch.ids, ...scratch.cascadeIds]) {
-              const origin2 = scratch.startPoses.get(id);
-              if (origin2 === void 0) continue;
-              ops.push(createTransformOp({
-                id,
-                from: origin2,
-                to: translatePoseGeneric(origin2, dx, dy, scratch.projection),
-                label: "Move"
-              }));
-              if (scratch.geometryProjection) {
-                const node = scratch.scene.get(id);
-                if (node) {
-                  const dataOp = geometryDataOp(
-                    scratch.geometryProjection,
-                    { id, data: node.data, pose: origin2 },
-                    m,
-                    "Move"
-                  );
-                  if (dataOp) ops.push(dataOp);
-                }
-              }
-            }
+            });
+          } else {
+            const ops = translateCommitOps(scratch, [...scratch.ids, ...scratch.cascadeIds], dx, dy);
             if (ops.length > 0) commitOps(ops, "Move");
           }
           dropPreviewOverrides(scratch);
@@ -7477,6 +7906,7 @@ function defaultCommitAdapter(scene) {
     getSelection: () => [...scene.getSelection()],
     setSelection: (ids) => scene.setSelection(ids.map(asNodeId)),
     getParent: (id) => scene.get(asNodeId(id))?.parent ?? null,
+    getRemovalClosure: (ids) => [...scene.removalClosure(ids.map(asNodeId))],
     getChildren: (parentId) => parentId === null ? [...scene.roots] : [...scene.childrenOf(asNodeId(parentId))],
     // Re-stamp each slot whose occupant changed. `scene.reorder` mutates the
     // live sibling list in place, so re-read it each iteration and skip slots
@@ -7505,7 +7935,13 @@ function defaultCommitAdapter(scene) {
       // Sibling-index passthrough: undo of a delete (or a boolean op's
       // source removal) re-inserts at the recorded z-order slot instead
       // of appending at the end.
-      ...index !== void 0 ? { index } : {}
+      ...index !== void 0 ? { index } : {},
+      // The function-valued fields travel with the node, or undo of a delete
+      // brings an edge back as a static path that never follows its endpoints
+      // again, and a clipped container back with nothing clipped.
+      ...node.dependsOn !== void 0 ? { dependsOn: node.dependsOn } : {},
+      ...node.derivePath !== void 0 ? { derivePath: node.derivePath } : {},
+      ...node.kind === "container" && node.clipFromPose !== void 0 ? { clipFromPose: node.clipFromPose } : {}
     })
   };
 }
@@ -8681,15 +9117,40 @@ var viewportDragPanAction = {
   enabled: () => true
 };
 
+// src/core/viewport/wheelHandler.ts
+var WHEEL_ZOOM_STEP = 1.1;
+function wheelZoomFactor(deltaY) {
+  return Math.pow(WHEEL_ZOOM_STEP, -deltaY / 100);
+}
+function wheelZoom(view, anchor, deltaY, clamp) {
+  return zoomAt(view, anchor, wheelZoomFactor(deltaY), clamp);
+}
+function wheelPan(view, delta3, opts = {}) {
+  const axis = opts.axis ?? "both";
+  const swapped = opts.swapAxis === true;
+  const screenX = swapped ? delta3.deltaX !== 0 ? delta3.deltaX : delta3.deltaY : delta3.deltaX;
+  const screenY = swapped ? 0 : delta3.deltaY;
+  return {
+    scale: view.scale,
+    x: view.x + (axis === "y" ? 0 : screenX / view.scale.x),
+    y: view.y + (axis === "x" ? 0 : screenY / view.scale.y)
+  };
+}
+function computeWheelAction(view, input, clamp, opts = {}) {
+  if (input.ctrlKey || input.metaKey) {
+    return wheelZoom(view, { x: input.x, y: input.y }, input.deltaY, clamp);
+  }
+  return wheelPan(view, input, { axis: opts.axis, swapAxis: input.shiftKey === true });
+}
+
 // src/interactions/actions/defaults/viewportZoom.ts
 var KEY_STEP = 1.25;
 function keyAnchor(view) {
   const size = view.hostSize?.();
   return size ? { x: size.width / 2, y: size.height / 2 } : { x: 0, y: 0 };
 }
-var WHEEL_STEP = 1.1;
 function makeViewportZoomAction(opts = {}) {
-  const clamp2 = { min: opts.min ?? DEFAULT_MIN_ZOOM, max: opts.max ?? DEFAULT_MAX_ZOOM };
+  const clamp = { min: opts.min ?? DEFAULT_MIN_ZOOM, max: opts.max ?? DEFAULT_MAX_ZOOM };
   const wheelSpec = opts.wheel === "plain" ? { kind: "wheel" } : { kind: "wheel", mods: { mod: true } };
   const rawAnimate = opts.animate === true ? {} : opts.animate || null;
   const { resetMs, ...animateRest } = rawAnimate ?? {};
@@ -8749,15 +9210,14 @@ function makeViewportZoomAction(opts = {}) {
             const deltaY = params?.deltaY ?? 0;
             const clientX = params?.clientX ?? 0;
             const clientY = params?.clientY ?? 0;
-            const factor = Math.pow(WHEEL_STEP, -deltaY / 100);
-            view.set(zoomAt(current, { x: clientX, y: clientY }, factor, clamp2));
+            view.set(wheelZoom(current, { x: clientX, y: clientY }, deltaY, clamp));
             break;
           }
           case "in":
-            stepTo(zoomAt(stepFrom(), keyAnchor(view), KEY_STEP, clamp2));
+            stepTo(zoomAt(stepFrom(), keyAnchor(view), KEY_STEP, clamp));
             break;
           case "out":
-            stepTo(zoomAt(stepFrom(), keyAnchor(view), 1 / KEY_STEP, clamp2));
+            stepTo(zoomAt(stepFrom(), keyAnchor(view), 1 / KEY_STEP, clamp));
             break;
           case "reset": {
             const target = view.recenter ? view.recenter() : { x: 0, y: 0, scale: { x: 1, y: 1 } };
@@ -8766,7 +9226,7 @@ function makeViewportZoomAction(opts = {}) {
           }
           default:
             if (params === void 0) {
-              view.set(zoomAt(current, { x: 0, y: 0 }, KEY_STEP, clamp2));
+              view.set(zoomAt(current, { x: 0, y: 0 }, KEY_STEP, clamp));
             }
             break;
         }
@@ -8801,15 +9261,9 @@ var viewportWheelPanAction = {
       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)
-      });
+      view.set(
+        wheelPan(view.get(), { deltaX, deltaY }, { axis, swapAxis: params?.swapAxis === true })
+      );
     }
   },
   enabled: () => true
@@ -9457,7 +9911,7 @@ var sliceAction = {
 
 // src/interactions/actions/defaults/pinchZoom.ts
 function makePinchZoomAction(opts = {}) {
-  const clamp2 = { min: opts.min ?? DEFAULT_MIN_ZOOM, max: opts.max ?? DEFAULT_MAX_ZOOM };
+  const clamp = { min: opts.min ?? DEFAULT_MIN_ZOOM, max: opts.max ?? DEFAULT_MAX_ZOOM };
   return {
     id: "viewport.pinchZoom",
     label: "Pinch Zoom",
@@ -9485,7 +9939,7 @@ function makePinchZoomAction(opts = {}) {
             const prev = scratch.centroid;
             scratch.centroid = centroid;
             const current = scratch.view.get();
-            const zoomed = zoomAt(current, prev, factor, clamp2);
+            const zoomed = zoomAt(current, prev, factor, clamp);
             scratch.view.set({
               scale: zoomed.scale,
               x: zoomed.x - (centroid.x - prev.x) / zoomed.scale.x,
@@ -9507,31 +9961,14 @@ function hostIndex(scene, id) {
   const siblings = node?.parent == null ? scene.roots : scene.childrenOf(node.parent);
   return siblings.indexOf(id);
 }
-function coveredByEmitted(scene, id, emitted) {
-  const seen = /* @__PURE__ */ new Set([id]);
-  const stack = [id];
-  while (stack.length > 0) {
-    const node = scene.get(stack.pop());
-    if (!node) continue;
-    const up = node.parent == null ? node.dependsOn ?? [] : [node.parent, ...node.dependsOn ?? []];
-    for (const next of up) {
-      if (seen.has(next)) continue;
-      if (emitted.has(next)) return true;
-      seen.add(next);
-      stack.push(next);
-    }
-  }
-  return false;
-}
 function buildDeleteOps(scene, ids, label) {
-  const emitted = /* @__PURE__ */ new Set();
+  const covered = /* @__PURE__ */ new Set();
   const ops = [];
   for (const id of ids) {
     const node = scene.get(id);
     if (!node) continue;
-    if (emitted.has(id)) continue;
-    if (coveredByEmitted(scene, id, emitted)) continue;
-    emitted.add(id);
+    if (covered.has(id)) continue;
+    for (const taken of scene.removalClosure([id])) covered.add(taken);
     ops.push(createDeleteOp({
       node,
       index: hostIndex(scene, id),
@@ -9755,7 +10192,10 @@ var selectAllAction = {
     timing: "immediate",
     run: (deps) => {
       const scene = deps.scene;
-      const all = scene?.renderOrder ? [...scene.renderOrder()] : [];
+      const hidden = new Set(
+        (scene?.layers ?? []).filter((l) => !l.visible).map((l) => l.id)
+      );
+      const all = hidden.size === 0 || !scene?.renderOrderNodes ? scene?.renderOrder ? [...scene.renderOrder()] : [] : scene.renderOrderNodes().filter((n) => !hidden.has(n.layer)).map((n) => n.id);
       if (all.length === 0) return;
       deps.selection?.set(all);
     }
@@ -11773,7 +12213,7 @@ var setStrokeOpacityAction = createPaintAction({
   readParams: (_prev, params) => params?.alpha01 ?? null,
   merge: (prev, alpha01) => {
     const base = prev ?? strokeOf(DEFAULT_STROKE_COLOR);
-    return { ...base, paint: paintWithAlpha(base.paint, alpha01) };
+    return { ...base, paint: paintWithAlpha(base.paint ?? solid(DEFAULT_STROKE_COLOR), alpha01) };
   }
 });
 
@@ -12243,6 +12683,7 @@ var KIT_STANDARD_DESCRIPTORS = [
   clipboardCopyAction,
   clipboardCutAction
 ];
+var KIT_STANDARD_ACTION_IDS = KIT_STANDARD_DESCRIPTORS.map((a) => a.id);
 function useStandardActions(opts) {
   const optsRef = useRef(opts);
   optsRef.current = opts;
@@ -12275,13 +12716,15 @@ function useStandardActions(opts) {
   const reg = useActionsRegistry();
   const regRef = useRef(reg);
   regRef.current = reg;
+  const excludeKey = opts.exclude ? [...opts.exclude].join("\0") : "";
   useEffect(() => {
     if (!reg || !depReg) return;
-    const unregisters = KIT_STANDARD_DESCRIPTORS.map((a) => reg.register(a));
+    const excluded = new Set(excludeKey ? excludeKey.split("\0") : []);
+    const unregisters = KIT_STANDARD_DESCRIPTORS.filter((a) => !excluded.has(a.id)).map((a) => reg.register(a));
     return () => {
       for (const u of unregisters) u();
     };
-  }, [reg, depReg]);
+  }, [reg, depReg, excludeKey]);
 }
 var IDENTITY_EXPAND2 = (ids) => ids;
 var EMPTY = Object.freeze([]);
@@ -13599,9 +14042,18 @@ function useGestureDispatcher(opts) {
     };
     const heldKeys = /* @__PURE__ */ new Set();
     const held = /* @__PURE__ */ new Map();
-    const heldGeometry = () => computeMultiTouchGeometry(
-      [...held.values()].map((p) => p.pos)
-    );
+    const toCanvasLocal = (p) => {
+      const rect = canvas?.getBoundingClientRect();
+      if (!rect) return p;
+      const [x, y] = clientToCanvasRect(rect, p.x, p.y);
+      return { x, y };
+    };
+    const heldGeometry = () => {
+      const { centroid, spread } = computeMultiTouchGeometry(
+        [...held.values()].map((p) => p.pos)
+      );
+      return { centroid: toCanvasLocal(centroid), spread };
+    };
     let multiTouchStart = null;
     const TAP_THRESHOLD_PX = 8;
     const DRAG_THRESHOLD_PX = 4;
@@ -13651,7 +14103,7 @@ function useGestureDispatcher(opts) {
     const DOUBLE_CLICK_MAX_MS = 600;
     const DOUBLE_CLICK_MAX_PX = 8;
     const onKeyDown = (e) => {
-      if (isEditableTarget2(e.target)) return;
+      if (isEditableTarget(e.target)) return;
       if (e.repeat && heldKeys.has(e.key)) {
         e.preventDefault();
         return;
@@ -13989,10 +14441,12 @@ function useGestureDispatcher(opts) {
         }
         const start = multiTouchStart;
         if (start) {
-          const { centroid } = computeMultiTouchGeometry([
-            ...[...held.values()].map((p) => p.pos),
-            { x: e.clientX, y: e.clientY }
-          ]);
+          const centroid = toCanvasLocal(
+            computeMultiTouchGeometry([
+              ...[...held.values()].map((p) => p.pos),
+              { x: e.clientX, y: e.clientY }
+            ]).centroid
+          );
           const dx = centroid.x - start.centroid.x;
           const dy = centroid.y - start.centroid.y;
           if (Math.hypot(dx, dy) <= TAP_THRESHOLD_PX) {
@@ -14161,7 +14615,7 @@ function useGestureDispatcher(opts) {
       });
     };
     const onPaste = (e) => {
-      if (isEditableTarget2(e.target)) return;
+      if (isEditableTarget(e.target)) return;
       const cd = e.clipboardData;
       if (!cd) return;
       const items = itemsFromClipboardData(cd);
@@ -14222,33 +14676,6 @@ function useGestureDispatcher(opts) {
     };
   }, [enabled, keyboard, canvasRef]);
 }
-
-// src/core/viewport/wheelHandler.ts
-function computeWheelAction(state, input, bounds = { min: DEFAULT_MIN_ZOOM, max: DEFAULT_MAX_ZOOM }) {
-  if (input.shiftKey) {
-    return {
-      zoom: state.zoom,
-      panX: state.panX - input.deltaY,
-      panY: state.panY
-    };
-  }
-  if (input.metaKey) {
-    return {
-      zoom: state.zoom,
-      panX: state.panX,
-      panY: state.panY - input.deltaY
-    };
-  }
-  const factor = input.deltaY < 0 ? 1.1 : 0.9;
-  const newZoom = Math.min(bounds.max, Math.max(bounds.min, state.zoom * factor));
-  const worldX = (input.mouseX - state.panX) / state.zoom;
-  const worldY = (input.mouseY - state.panY) / state.zoom;
-  return {
-    zoom: newZoom,
-    panX: input.mouseX - worldX * newZoom,
-    panY: input.mouseY - worldY * newZoom
-  };
-}
 function useVelocityTracker() {
   return useMemo(() => createVelocityTracker(), []);
 }
@@ -16373,85 +16800,64 @@ function UnknownIcon({ className, size = 20 }) {
     }
   );
 }
-function flattenVerts(poly2) {
-  const flat = new Array(poly2.length * 2);
-  for (let i = 0; i < poly2.length; i++) {
-    flat[i * 2] = poly2[i].x;
-    flat[i * 2 + 1] = poly2[i].y;
-  }
-  return flat;
-}
-function polygonContainsRectCenter(poly2, rect) {
-  return pointInPolygon(flattenVerts(poly2), rect.x + rect.width / 2, rect.y + rect.height / 2);
-}
-function polygonContainsRect(poly2, rect) {
-  if (poly2.length < 3) return false;
-  const flat = flattenVerts(poly2);
-  if (!pointInPolygon(flat, rect.x, rect.y)) return false;
-  if (!pointInPolygon(flat, rect.x + rect.width, rect.y)) return false;
-  if (!pointInPolygon(flat, rect.x + rect.width, rect.y + rect.height)) return false;
-  if (!pointInPolygon(flat, rect.x, rect.y + rect.height)) return false;
-  return !anyPolyEdgeCrossesRect(poly2, rect);
-}
-function polygonIntersectsRect(poly2, rect) {
-  if (poly2.length < 3) return false;
-  const ab = polygonAabb(poly2);
-  if (ab.x + ab.width < rect.x || ab.x > rect.x + rect.width) return false;
-  if (ab.y + ab.height < rect.y || ab.y > rect.y + rect.height) return false;
-  for (const v of poly2) {
-    if (v.x >= rect.x && v.x <= rect.x + rect.width && v.y >= rect.y && v.y <= rect.y + rect.height) return true;
-  }
-  const flat = flattenVerts(poly2);
-  if (pointInPolygon(flat, rect.x, rect.y)) return true;
-  if (pointInPolygon(flat, rect.x + rect.width, rect.y)) return true;
-  if (pointInPolygon(flat, rect.x + rect.width, rect.y + rect.height)) return true;
-  if (pointInPolygon(flat, rect.x, rect.y + rect.height)) return true;
-  return anyPolyEdgeCrossesRect(poly2, rect);
-}
-function polygonAabb(poly2) {
-  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
-  for (const v of poly2) {
-    if (v.x < minX) minX = v.x;
-    if (v.y < minY) minY = v.y;
-    if (v.x > maxX) maxX = v.x;
-    if (v.y > maxY) maxY = v.y;
-  }
-  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
-}
-function anyPolyEdgeCrossesRect(poly2, rect) {
-  const r0x = rect.x, r0y = rect.y;
-  const r1x = rect.x + rect.width, r1y = rect.y;
-  const r2x = rect.x + rect.width, r2y = rect.y + rect.height;
-  const r3x = rect.x, r3y = rect.y + rect.height;
-  for (let i = 0, j = poly2.length - 1; i < poly2.length; j = i++) {
-    const a = poly2[j], b = poly2[i];
-    if (segmentsCross(a.x, a.y, b.x, b.y, r0x, r0y, r1x, r1y)) return true;
-    if (segmentsCross(a.x, a.y, b.x, b.y, r1x, r1y, r2x, r2y)) return true;
-    if (segmentsCross(a.x, a.y, b.x, b.y, r2x, r2y, r3x, r3y)) return true;
-    if (segmentsCross(a.x, a.y, b.x, b.y, r3x, r3y, r0x, r0y)) return true;
-  }
-  return false;
-}
-
-// src/features/paths/pathHitTest.ts
-function extractVertices(path) {
+function closedSubpaths(path, tolerance) {
   const { commands, coords } = path;
-  const verts = [];
+  const out = [];
+  let sub2 = [];
+  let subStartX = 0, subStartY = 0;
+  let curX = 0, curY = 0;
   let ci = 0;
   for (let i = 0; i < commands.length; i++) {
     const cmd = commands[i];
-    if (cmd === PATH_M || cmd === PATH_L) {
-      verts.push({ x: coords[ci], y: coords[ci + 1] });
-      ci += 2;
-    } else if (cmd === PATH_Z) {
-      break;
-    } else {
-      throw new Error(
-        `pathHitTest: bezier command ${cmd} not supported \u2014 promote path to use pointInPath for bezier paths`
-      );
+    switch (cmd) {
+      case PATH_M: {
+        sub2 = [];
+        subStartX = coords[ci];
+        subStartY = coords[ci + 1];
+        curX = subStartX;
+        curY = subStartY;
+        sub2.push(curX, curY);
+        ci += 2;
+        break;
+      }
+      case PATH_L: {
+        curX = coords[ci];
+        curY = coords[ci + 1];
+        sub2.push(curX, curY);
+        ci += 2;
+        break;
+      }
+      case PATH_C: {
+        const x1 = coords[ci], y1 = coords[ci + 1];
+        const x2 = coords[ci + 2], y2 = coords[ci + 3];
+        const x3 = coords[ci + 4], y3 = coords[ci + 5];
+        flattenCubic(curX, curY, x1, y1, x2, y2, x3, y3, tolerance, sub2);
+        curX = x3;
+        curY = y3;
+        ci += 6;
+        break;
+      }
+      case PATH_Q: {
+        const x1 = coords[ci], y1 = coords[ci + 1];
+        const x2 = coords[ci + 2], y2 = coords[ci + 3];
+        flattenQuadratic(curX, curY, x1, y1, x2, y2, tolerance, sub2);
+        curX = x2;
+        curY = y2;
+        ci += 4;
+        break;
+      }
+      case PATH_Z: {
+        if (sub2.length >= 6) out.push(sub2);
+        sub2 = [];
+        curX = subStartX;
+        curY = subStartY;
+        break;
+      }
+      default:
+        throw new Error(`pathHitTest: unknown command ${cmd}`);
     }
   }
-  return verts;
+  return out;
 }
 function rectToVerts(r) {
   return [
@@ -16461,7 +16867,7 @@ function rectToVerts(r) {
     { x: r.x, y: r.y + r.height }
   ];
 }
-function flattenVerts2(poly2) {
+function flattenVerts(poly2) {
   const flat = new Array(poly2.length * 2);
   for (let i = 0; i < poly2.length; i++) {
     flat[i * 2] = poly2[i].x;
@@ -16469,15 +16875,10 @@ function flattenVerts2(poly2) {
   }
   return flat;
 }
-function polygonContainsPolygon(outer, inner) {
-  if (inner.length === 0) return false;
-  const flatOuter = flattenVerts2(outer);
-  return inner.every((p) => pointInPolygon(flatOuter, p.x, p.y));
-}
 function polygonsIntersect(a, b) {
   if (a.length === 0 || b.length === 0) return false;
-  if (pointInPolygon(flattenVerts2(a), b[0].x, b[0].y)) return true;
-  if (pointInPolygon(flattenVerts2(b), a[0].x, a[0].y)) return true;
+  if (pointInPolygon(flattenVerts(a), b[0].x, b[0].y)) return true;
+  if (pointInPolygon(flattenVerts(b), a[0].x, a[0].y)) return true;
   for (let i = 0; i < a.length; i++) {
     const a0 = a[i], a1 = a[(i + 1) % a.length];
     for (let j = 0; j < b.length; j++) {
@@ -16487,35 +16888,105 @@ function polygonsIntersect(a, b) {
   }
   return false;
 }
-function pathContainsPoint(path, x, y) {
-  return pointInPath(path, x, y);
+function anyEdge(subpaths, visit) {
+  for (const sub2 of subpaths) {
+    const n = sub2.length;
+    for (let i = 0; i < n; i += 2) {
+      const j = (i + 2) % n;
+      if (visit(sub2[i], sub2[i + 1], sub2[j], sub2[j + 1])) return true;
+    }
+  }
+  return false;
+}
+function anyEdgeCrossesRect(subpaths, r) {
+  const x0 = r.x, y0 = r.y, x1 = r.x + r.width, y1 = r.y + r.height;
+  return anyEdge(
+    subpaths,
+    (ax, ay, bx, by) => segmentsCross(ax, ay, bx, by, x0, y0, x1, y0) || segmentsCross(ax, ay, bx, by, x1, y0, x1, y1) || segmentsCross(ax, ay, bx, by, x1, y1, x0, y1) || segmentsCross(ax, ay, bx, by, x0, y1, x0, y0)
+  );
+}
+function anyEdgeCrossesPolygon(subpaths, poly2) {
+  if (poly2.length === 0) return false;
+  return anyEdge(subpaths, (ax, ay, bx, by) => {
+    for (let i = 0; i < poly2.length; i++) {
+      const p0 = poly2[i], p1 = poly2[(i + 1) % poly2.length];
+      if (segmentsCross(ax, ay, bx, by, p0.x, p0.y, p1.x, p1.y)) return true;
+    }
+    return false;
+  });
+}
+function anyVertexInRect(subpaths, r) {
+  for (const sub2 of subpaths) {
+    for (let i = 0; i < sub2.length; i += 2) {
+      const x = sub2[i], y = sub2[i + 1];
+      if (x >= r.x && x <= r.x + r.width && y >= r.y && y <= r.y + r.height) return true;
+    }
+  }
+  return false;
+}
+function anyVertexInPolygon(subpaths, flatPoly) {
+  for (const sub2 of subpaths) {
+    for (let i = 0; i < sub2.length; i += 2) {
+      if (pointInPolygon(flatPoly, sub2[i], sub2[i + 1])) return true;
+    }
+  }
+  return false;
+}
+function subpathsOf(path, opts) {
+  return closedSubpaths(path, opts.tolerance ?? DEFAULT_FLATTEN_TOLERANCE);
 }
-function pathContainsRect(path, rect) {
+function pathContainsPoint(path, x, y, opts = {}) {
+  return pointInPath(path, x, y, opts);
+}
+function pathContainsRect(path, rect, opts = {}) {
   if (path.kind === "rect") {
     return rect.x >= path.x && rect.y >= path.y && rect.x + rect.width <= path.x + path.width && rect.y + rect.height <= path.y + path.height;
   }
-  return polygonContainsRect(extractVertices(path), rect);
+  const subpaths = subpathsOf(path, opts);
+  if (subpaths.length === 0) return false;
+  for (const c of rectToVerts(rect)) {
+    if (!pointInPath(path, c.x, c.y, opts)) return false;
+  }
+  return !anyVertexInRect(subpaths, rect) && !anyEdgeCrossesRect(subpaths, rect);
 }
-function pathIntersectsRect(path, rect) {
+function pathIntersectsRect(path, rect, opts = {}) {
   if (path.kind === "rect") {
     return rect.x < path.x + path.width && rect.x + rect.width > path.x && rect.y < path.y + path.height && rect.y + rect.height > path.y;
   }
-  return polygonIntersectsRect(extractVertices(path), rect);
+  const subpaths = subpathsOf(path, opts);
+  if (subpaths.length === 0) return false;
+  for (const c of rectToVerts(rect)) {
+    if (pointInPath(path, c.x, c.y, opts)) return true;
+  }
+  if (anyVertexInRect(subpaths, rect)) return true;
+  return anyEdgeCrossesRect(subpaths, rect);
 }
-function pathContainsPolygon(path, polygon) {
+function pathContainsPolygon(path, polygon, opts = {}) {
   if (polygon.length === 0) return false;
   if (path.kind === "rect") {
     return polygon.every(
       (p) => p.x >= path.x && p.x <= path.x + path.width && p.y >= path.y && p.y <= path.y + path.height
     );
   }
-  return polygonContainsPolygon(extractVertices(path), polygon);
+  const subpaths = subpathsOf(path, opts);
+  if (subpaths.length === 0) return false;
+  for (const p of polygon) {
+    if (!pointInPath(path, p.x, p.y, opts)) return false;
+  }
+  return !anyVertexInPolygon(subpaths, flattenVerts(polygon)) && !anyEdgeCrossesPolygon(subpaths, polygon);
 }
-function pathIntersectsPolygon(path, polygon) {
+function pathIntersectsPolygon(path, polygon, opts = {}) {
+  if (polygon.length === 0) return false;
   if (path.kind === "rect") {
     return polygonsIntersect(rectToVerts(path), polygon);
   }
-  return polygonsIntersect(extractVertices(path), polygon);
+  const subpaths = subpathsOf(path, opts);
+  if (subpaths.length === 0) return false;
+  for (const p of polygon) {
+    if (pointInPath(path, p.x, p.y, opts)) return true;
+  }
+  if (anyVertexInPolygon(subpaths, flattenVerts(polygon))) return true;
+  return anyEdgeCrossesPolygon(subpaths, polygon);
 }
 
 // src/features/paths/markerSites.ts
@@ -16908,10 +17379,11 @@ var TEXT_PAINTER = {
     if (boxes.length === 0) return null;
     return rectsToPath(boxes);
   },
-  // `filled` is unconditional: a text node's `data.fill: null` still resolves
-  // to the default in `ResolvedRun`, so there is no outline-only text to
-  // report. The reach is the point — a heavily outlined glyph was unpickable
-  // across the width of its own outline.
+  // `filled` is unconditional, `data.fill: null` included: the silhouette
+  // above is line boxes, not glyph ink, so reporting outline-only text as
+  // unfilled would leave it grabbable within a stroke width of a box edge and
+  // nowhere near the letters. The reach still matters — a heavily outlined
+  // glyph was unpickable across the width of its own outline.
   ink: (node, _pose, ctx) => {
     const d = node.data;
     return { filled: true, ...inkReach(resolveNodeStroke(d.stroke), ctx?.scale) };
@@ -16947,7 +17419,7 @@ function resolveNodeFill(fill, fallback) {
   return fill === void 0 ? fallback : fill;
 }
 function resolveNodeStroke(stroke) {
-  if (stroke == null || stroke.paint == null) return null;
+  if (stroke?.paint == null) return null;
   return stroke;
 }
 function strokeInPoseFrame(stroke, box) {
@@ -18069,6 +18541,7 @@ function worldOf(region, xf, view) {
 }
 
 // src/affordances/rotationHandle.ts
+var isAnnulusForm = (paint) => "fill" in paint || "stroke" in paint || "insetPx" in paint;
 var DEFAULT_PAINT = {
   fill: { fill: "solid", color: "rgba(26, 19, 13, 0.12)" },
   insetPx: 10
@@ -18077,7 +18550,7 @@ function createRotationAffordance(opts = {}) {
   const { bandPx = 24, paint = DEFAULT_PAINT, cursor } = opts;
   const annulusPaint = (() => {
     if (!paint) return null;
-    if ("paint" in paint) {
+    if (!isAnnulusForm(paint)) {
       return { kind: "annulus", stroke: paint };
     }
     return {
@@ -18273,29 +18746,6 @@ function useTextTool() {
     []
   );
 }
-function usePinchZoomTool(canvasRef, getView, setView, opts = {}) {
-  const getViewRef = useRef(getView);
-  getViewRef.current = getView;
-  const setViewRef = useRef(setView);
-  setViewRef.current = setView;
-  const { min = DEFAULT_MIN_ZOOM, max = DEFAULT_MAX_ZOOM, enabled = true } = opts;
-  const resolveTargetRef = useRef(opts.resolveTarget);
-  resolveTargetRef.current = opts.resolveTarget;
-  usePinchGesture(canvasRef, (clientAnchor, scaleFactor) => {
-    const el = canvasRef.current;
-    if (!el) return;
-    const target = resolveTargetRef.current?.(clientAnchor.x, clientAnchor.y) ?? null;
-    let anchor;
-    if (target) {
-      anchor = { x: clientAnchor.x - target.origin.left, y: clientAnchor.y - target.origin.top };
-    } else {
-      const [cx, cy] = clientToCanvas(el, clientAnchor.x, clientAnchor.y);
-      anchor = { x: cx, y: cy };
-    }
-    const newView = zoomAt(target?.view ?? getViewRef.current(), anchor, scaleFactor, { min, max });
-    (target ? target.setView : setViewRef.current)(newView);
-  }, enabled);
-}
 
 // src/util/constrainTo45.ts
 function constrainTo45(dx, dy) {
@@ -20611,7 +21061,6 @@ function CanvasInner(props, ref) {
     previewIdsExtra,
     previewPoseExtra,
     gestureSource,
-    viewport,
     backgroundFill,
     cursorCoordsHud,
     pickHud,
@@ -20620,7 +21069,8 @@ function CanvasInner(props, ref) {
     decorationLayer,
     getIsVisible,
     layerVisibility,
-    layerOrder
+    layerOrder,
+    layerGroups
   } = props;
   const resolvedDebugConfig = useMemo(() => {
     if (debugProp === false) return null;
@@ -20773,25 +21223,7 @@ function CanvasInner(props, ref) {
   const glRendererRef = useRef(null);
   const layerCacheRef = useRef(/* @__PURE__ */ new Map());
   const lastResizeRef = useRef(null);
-  const pinchConfig = viewport?.pinchZoom === true ? {} : viewport?.pinchZoom || null;
   const viewRegistry = useOptionalViewRegistry();
-  const viewRegistryRef = useRef(viewRegistry);
-  viewRegistryRef.current = viewRegistry;
-  const resolvePinchTarget = useCallback((clientX, clientY) => {
-    const reg = viewRegistryRef.current;
-    if (!reg) return null;
-    const target = reg.resolver.at(null, clientX, clientY);
-    if (target.id === null) return null;
-    const api = reg.list().find((r) => r.id === target.id)?.target.deps?.().view;
-    if (!api) return null;
-    return { view: api.get(), setView: api.set, origin: target.origin };
-  }, []);
-  usePinchZoomTool(
-    canvasRef,
-    getView,
-    setView,
-    { ...pinchConfig ?? {}, enabled: pinchConfig !== null, resolveTarget: resolvePinchTarget }
-  );
   const noopAdapter = useMemo(
     () => ({
       getPose: () => ({}),
@@ -20883,6 +21315,7 @@ function CanvasInner(props, ref) {
   const selectedIdsForWiring = effectiveSelection.current;
   const {
     helpers: viewHelpers,
+    chromeState: viewChromeState,
     effectiveBoundsOf,
     previewExtraRef
   } = useViewHelpers({
@@ -21051,6 +21484,7 @@ function CanvasInner(props, ref) {
     dpr: dprProp,
     layerVisibility,
     layerOrder,
+    layerGroups,
     shaders
   });
   paintInputsRef.current = {
@@ -21061,6 +21495,7 @@ function CanvasInner(props, ref) {
     dpr: dprProp,
     layerVisibility,
     layerOrder,
+    layerGroups,
     shaders
   };
   const paint = useCallback(() => {
@@ -21075,6 +21510,7 @@ function CanvasInner(props, ref) {
       dpr: dprIn,
       layerVisibility: vis,
       layerOrder: order,
+      layerGroups: groups,
       shaders: paintShaders
     } = paintInputsRef.current;
     sink?.beginFrame();
@@ -21125,7 +21561,9 @@ function CanvasInner(props, ref) {
       order,
       view,
       { width: w, height: h },
-      layerCacheRef.current
+      layerCacheRef.current,
+      void 0,
+      groups
     );
     renderer.render(commands, viewToMat3(view));
     paintedVersionRef.current = contentVersionRef.current?.() ?? 0;
@@ -21143,8 +21581,11 @@ function CanvasInner(props, ref) {
     dprProp,
     layerVisibility,
     layerOrder,
+    layerGroups,
     shaderIdKey,
     syncPaint,
+    viewChromeState,
+    getIsVisible,
     requestRedraw
   ]);
   useEffect(() => {
@@ -21355,6 +21796,14 @@ function createDependentsIndex() {
 // src/core/scene/scene.ts
 var defaultIdCounter = 0;
 var defaultGenerateId = () => asNodeId(`n${(defaultIdCounter++).toString(36)}-${Math.random().toString(36).slice(2, 8)}`);
+function layerFromSerialized(spec) {
+  const base = {
+    id: spec.id,
+    visible: spec.visible ?? true,
+    locked: spec.locked ?? false
+  };
+  return spec.kind === "user" ? { ...base, kind: "user", name: spec.name ?? spec.id } : { ...base, kind: "system" };
+}
 function createScene(options) {
   if (!options.systemLayers || options.systemLayers.length === 0) {
     throw new Error("useScene: systemLayers must declare at least one layer");
@@ -21578,6 +22027,28 @@ function createScene(options) {
     state.nodes.get(id).derivePath = spec.derivePath;
     if (cacheForRedo) pendingDerivePathPatches.set(id, spec.derivePath);
   }
+  function restoreNodeFunctions(node, keys) {
+    if (!keys) return;
+    if (node.derivePath === void 0 && keys.derivePathKey !== void 0) {
+      const fn = registry2.derivePath?.[keys.derivePathKey];
+      if (fn) {
+        node.derivePath = fn;
+        pendingDerivePathPatches.set(node.id, fn);
+      } else {
+        dwarn("scene", `kit:remove: derivePathKey "${keys.derivePathKey}" not in this scene's registry \u2014 node "${node.id}" restored without derived geometry. Register a function with this key in the registry option to restore it.`);
+      }
+    }
+    if (node.kind !== "container" || keys.clipKey === void 0) return;
+    const container = node;
+    if (container.clipFromPose !== void 0) return;
+    const clip = registry2.clipFromPose?.[keys.clipKey];
+    if (clip) {
+      container.clipFromPose = clip;
+      pendingClipPatches.set(node.id, clip);
+    } else {
+      dwarn("scene", `kit:remove: clipKey "${keys.clipKey}" not in this scene's registry \u2014 container "${node.id}" restored without clip. Register a function with this key in the registry option to restore the clip.`);
+    }
+  }
   function registerKitOp(kind, handler) {
     registered.set(kind, handler);
   }
@@ -21635,8 +22106,10 @@ function createScene(options) {
       }
     },
     revert: (p) => {
+      const keys = new Map((p.fnKeys ?? []).map((k) => [k.id, k]));
       for (const n of p.nodes) {
         const clone = n.kind === "container" ? { ...n, children: [...n.children] } : { ...n };
+        restoreNodeFunctions(clone, keys.get(n.id));
         state.nodes.set(n.id, clone);
         dependents.add(n.id, clone.dependsOn ?? []);
       }
@@ -21974,6 +22447,9 @@ function createScene(options) {
     remove(id) {
       scene.removeMany([id]);
     },
+    removalClosure(rootIds) {
+      return removalClosure(rootIds).ids;
+    },
     removeMany(rootIds) {
       if (rootIds.length === 0) return;
       const { ids, removing } = removalClosure(rootIds);
@@ -21983,7 +22459,20 @@ function createScene(options) {
       });
       const detached = snapshot.filter((n) => n.parent === null || !removing.has(n.parent)).map((n) => ({ id: n.id, parent: n.parent, index: siblingsOf(n.parent).indexOf(n.id) })).sort((l, r) => l.index - r.index);
       for (const nid of ids) overrides.clear(nid);
-      const payload = { nodes: snapshot, detached };
+      const fnKeys = snapshot.flatMap((n) => {
+        const derivePathKey = n.derivePath !== void 0 ? reverseDerivePath.get(n.derivePath) : void 0;
+        const clipKey = n.kind === "container" && n.clipFromPose !== void 0 ? reverseClipFromPose.get(n.clipFromPose) : void 0;
+        return derivePathKey === void 0 && clipKey === void 0 ? [] : [{
+          id: n.id,
+          ...derivePathKey !== void 0 ? { derivePathKey } : {},
+          ...clipKey !== void 0 ? { clipKey } : {}
+        }];
+      });
+      const payload = {
+        nodes: snapshot,
+        detached,
+        ...fnKeys.length > 0 ? { fnKeys } : {}
+      };
       executeAndLog("kit:remove", payload, "remove");
     },
     update(id, patch) {
@@ -22280,6 +22769,10 @@ function createScene(options) {
         const layer = { id: l.id };
         if (l.visible === false) layer.visible = false;
         if (l.locked === true) layer.locked = true;
+        if (l.kind === "user") {
+          layer.kind = "user";
+          layer.name = l.name;
+        }
         return layer;
       });
       return { version: 1, systemLayers, nodes };
@@ -22297,12 +22790,7 @@ function createScene(options) {
         if (state.layerIndex.has(spec.id)) {
           throw new Error(`Scene.loadState: duplicate system layer id "${spec.id}"`);
         }
-        state.layers.push({
-          kind: "system",
-          id: spec.id,
-          visible: spec.visible ?? true,
-          locked: spec.locked ?? false
-        });
+        state.layers.push(layerFromSerialized(spec));
         state.layerIndex.set(spec.id, i);
       }
       history.clear();
@@ -22402,16 +22890,16 @@ function sceneSelectionStore(scene) {
 }
 function sceneFromJSON(json, options) {
   const registry2 = options.registry ?? {};
-  const initial = specsFromSerialized(json, registry2);
-  return createScene({
-    systemLayers: json.systemLayers,
-    initial,
+  const scene = createScene({
+    systemLayers: json.systemLayers.map((l) => ({ id: l.id })),
     registry: registry2,
     ...options.historyLimit !== void 0 ? { historyLimit: options.historyLimit } : {},
     ...options.coalesceWindowMs !== void 0 ? { coalesceWindowMs: options.coalesceWindowMs } : {},
     ...options.generateId !== void 0 ? { generateId: options.generateId } : {},
     ...options.ops !== void 0 ? { ops: options.ops } : {}
   });
+  scene.loadState(json);
+  return scene;
 }
 var SelectionContext = createContext(null);
 function SelectionContextProvider({ children }) {
@@ -23154,7 +23642,7 @@ function CanvasView(props) {
 }
 function ActionsProviderIfRoot({ children }) {
   const parent = useActionsRegistry();
-  if (parent) return /* @__PURE__ */ jsx(Fragment, { children });
+  if (parent) return /* @__PURE__ */ jsx(ActionsScope, { children });
   return /* @__PURE__ */ jsx(ActionsProvider, { children });
 }
 function useToolActions(tools) {
@@ -23221,6 +23709,65 @@ function PointerPublisher({
   }, [ctx, canvasRef, registry2]);
   return null;
 }
+function flattenVerts2(poly2) {
+  const flat = new Array(poly2.length * 2);
+  for (let i = 0; i < poly2.length; i++) {
+    flat[i * 2] = poly2[i].x;
+    flat[i * 2 + 1] = poly2[i].y;
+  }
+  return flat;
+}
+function polygonContainsRectCenter(poly2, rect) {
+  return pointInPolygon(flattenVerts2(poly2), rect.x + rect.width / 2, rect.y + rect.height / 2);
+}
+function polygonContainsRect(poly2, rect) {
+  if (poly2.length < 3) return false;
+  const flat = flattenVerts2(poly2);
+  if (!pointInPolygon(flat, rect.x, rect.y)) return false;
+  if (!pointInPolygon(flat, rect.x + rect.width, rect.y)) return false;
+  if (!pointInPolygon(flat, rect.x + rect.width, rect.y + rect.height)) return false;
+  if (!pointInPolygon(flat, rect.x, rect.y + rect.height)) return false;
+  return !anyPolyEdgeCrossesRect(poly2, rect);
+}
+function polygonIntersectsRect(poly2, rect) {
+  if (poly2.length < 3) return false;
+  const ab = polygonAabb(poly2);
+  if (ab.x + ab.width < rect.x || ab.x > rect.x + rect.width) return false;
+  if (ab.y + ab.height < rect.y || ab.y > rect.y + rect.height) return false;
+  for (const v of poly2) {
+    if (v.x >= rect.x && v.x <= rect.x + rect.width && v.y >= rect.y && v.y <= rect.y + rect.height) return true;
+  }
+  const flat = flattenVerts2(poly2);
+  if (pointInPolygon(flat, rect.x, rect.y)) return true;
+  if (pointInPolygon(flat, rect.x + rect.width, rect.y)) return true;
+  if (pointInPolygon(flat, rect.x + rect.width, rect.y + rect.height)) return true;
+  if (pointInPolygon(flat, rect.x, rect.y + rect.height)) return true;
+  return anyPolyEdgeCrossesRect(poly2, rect);
+}
+function polygonAabb(poly2) {
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const v of poly2) {
+    if (v.x < minX) minX = v.x;
+    if (v.y < minY) minY = v.y;
+    if (v.x > maxX) maxX = v.x;
+    if (v.y > maxY) maxY = v.y;
+  }
+  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+}
+function anyPolyEdgeCrossesRect(poly2, rect) {
+  const r0x = rect.x, r0y = rect.y;
+  const r1x = rect.x + rect.width, r1y = rect.y;
+  const r2x = rect.x + rect.width, r2y = rect.y + rect.height;
+  const r3x = rect.x, r3y = rect.y + rect.height;
+  for (let i = 0, j = poly2.length - 1; i < poly2.length; j = i++) {
+    const a = poly2[j], b = poly2[i];
+    if (segmentsCross(a.x, a.y, b.x, b.y, r0x, r0y, r1x, r1y)) return true;
+    if (segmentsCross(a.x, a.y, b.x, b.y, r1x, r1y, r2x, r2y)) return true;
+    if (segmentsCross(a.x, a.y, b.x, b.y, r2x, r2y, r3x, r3y)) return true;
+    if (segmentsCross(a.x, a.y, b.x, b.y, r3x, r3y, r0x, r0y)) return true;
+  }
+  return false;
+}
 function isPathLike(p) {
   if (!p || typeof p !== "object") return false;
   const k = p.kind;
@@ -23402,12 +23949,19 @@ function sceneToAdapter(scene, options = {}) {
         id: node.id,
         ...index !== void 0 ? { index } : {},
         ...node.parent !== null ? { parent: node.parent } : {},
-        ...node.kind === "container" && node.clipFromPose ? { clipFromPose: node.clipFromPose } : {}
+        ...node.kind === "container" && node.clipFromPose ? { clipFromPose: node.clipFromPose } : {},
+        // Derivation travels with the node, or undo of a delete brings an
+        // edge back as a static path that never follows its endpoints again.
+        ...node.dependsOn !== void 0 ? { dependsOn: node.dependsOn } : {},
+        ...node.derivePath !== void 0 ? { derivePath: node.derivePath } : {}
       });
     },
     removeNode(id) {
       scene.remove(asNodeId(id));
     },
+    getRemovalClosure(ids) {
+      return [...scene.removalClosure(ids.map(asNodeId))];
+    },
     // AreaSelectAdapter surface — included unconditionally so plain
     // `useSelectTool(sceneToAdapter(scene, { selection }))` Just Works for the
     // marquee gesture. `applyOps` (above) dispatches transiently when called
@@ -25333,17 +25887,18 @@ function useActionsPropResolver(actions) {
   useEffect(() => {
     if (!reg) return;
     const prop = actionsRef.current;
+    const unregisters = [];
     if (prop === null) {
-      const ids = reg.list().map((a) => a.id);
-      for (const id of ids) reg.unregister(id);
-      return;
+      for (const id of reg.list().map((a) => a.id)) unregisters.push(reg.mute(id));
+      return () => {
+        for (const u of unregisters) u();
+      };
     }
     if (!prop) return;
-    const unregisters = [];
     const warnedIds = /* @__PURE__ */ new Set();
     for (const [slotId, entry] of Object.entries(prop)) {
       if (entry === null) {
-        reg.unregister(slotId);
+        unregisters.push(reg.mute(slotId));
         continue;
       }
       const isFull = (e) => typeof e.id === "string" && typeof e.label === "string" && !!e.invoker;
@@ -25400,7 +25955,7 @@ function useViewportActions(args) {
         r.register(makePinchZoomAction(typeof pinchZoom === "object" ? pinchZoom : {}))
       );
     } else {
-      r.unregister("viewport.pinchZoom");
+      unregisters.push(r.mute("viewport.pinchZoom"));
     }
     return () => {
       for (const u of unregisters) u();
@@ -28291,7 +28846,7 @@ function applyOverlayStyle(el, style) {
   el.style.border = "0";
   el.style.outline = "none";
   el.style.background = "transparent";
-  el.style.color = "color" in style.fill ? style.fill.color : "#000";
+  el.style.color = style.fill !== null && "color" in style.fill ? style.fill.color : "#000";
   el.style.caretColor = style.caretColor;
   el.style.font = fontString(style);
   el.style.lineHeight = String(style.lineHeight);
@@ -31259,6 +31814,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, 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
+export { ALWAYS, ANCHOR_HIT_BASE_PX, ActionsProviderIfRoot, ActiveToolContextProvider, ActiveToolContextProviderIfRoot, ArrowIcon, BUILTIN_MARKERS, BUNDLE_TOOLS, COARSE_TARGET_SCALE, CURVE_REPS, CanvasView, ColorOverrideRegistry, CropIcon, CursorCoordsHud, DEFAULT_ALPHA_DECAY, DEFAULT_ALPHA_MIN, DEFAULT_DEBUG_STROKES, DEFAULT_DEBUG_THEME, DEFAULT_DEVICE_PROFILE, DEFAULT_FILL_COLOR, DEFAULT_HANDLE_SIZE2 as DEFAULT_HANDLE_SIZE, DEFAULT_MAX_ZOOM, DEFAULT_MIN_ZOOM, DEFAULT_PALETTE, DEFAULT_ROTATION_HANDLE_DISTANCE, DEFAULT_SHAPE_FILL, DEFAULT_STROKE_COLOR, DEFAULT_VELOCITY_DECAY, DepRegistryProviderIfRoot, DeviceProfileProvider, DivideIcon, EASINGS, EFFECT_KIT_UNIFORMS, EFFECT_VERT_SRC, EllipseIcon, ExcludeIcon, EyedropperIcon, FALLBACK_FIT_VIEW, GHOST_STROKE, HANDLE_BASE_PX, HandIcon, IDENTITY_COLOR_MATRIX, IDENTITY_JOINT, IDENTITY_POSE_COMPOSITION, ImageIcon, IntersectIcon, KIT_SHAPE_KINDS, KIT_STANDARD_ACTION_IDS, LassoIcon, LineIcon, MIXED, MOVE_ANCHORS, MinimapCanvas, NEVER, OUTLINE_MIN_SCREEN_PX, PAINTED_CURSOR_LAYER_ID, PATH_ANCHOR_CHROME_ID, PenIcon, PencilIcon, PickHud, PointerProviderIfRoot, PolygonIcon, RECT_ALIGN_PROJECTION, ROTATION_HANDLE_BASE_PX, RectIcon, SPRING_PRESETS, SPRITE_STRIDE, SceneCanvas, SceneViewCanvas, SelectIcon, SelectionContextProvider, SelectionContextProviderIfRoot, ShaderCompileError, StarIcon, SubtractIcon, TOOL_PREF_KINDS, TextIcon, UnionIcon, UnknownIcon, VERSION, VIEW_ANIMATION_KEY, WHEEL_ZOOM_STEP, WeaselProvider, WeaselRenderer, _resetMarkersForTests, _resetPaintKindsForTests, aabbCenter, actionIs, actionShortcuts, alignDeltaFor, alignInsertBehavior, alignMoveBehavior, alignResizeBehavior, always, and, animateLifecycle, animateOnSetPose, annulusSemiAxes, applyBooleanOp, applyStyleToRange, areaSelectAction, arrayAdapter, asNodeId, asPaint, axisAlignedBounds, bezierCubic, bezierQuadratic, blendPoses, blur, buildChromeCtx, buildGradientRamp, buildRuleCtx, buildSceneViewCommands, canBringForward, canHover, canSendBackward, capabilityAll, capabilityIn, capabilityIs, capabilityNot, caretIndexAt, cellAt, charOffsetToDomPosition, clampView, clearSelectionAction, clientToCanvas, clipboardCopyAction, clipboardCutAction, cloneAction, coarsePointer, composeAffordanceLayer, composePath, composeRectPose, composeSelectionPose, composeWorldPose, computeFitView, computeFitViewport, computeIndicatorCommand, computeWheelAction, cond, constrainTo45, containedThenNearest, countPathAnchors, createCellHighlightLayer, createChildrenLayer, createCornerResizeAffordance, createDebugOverlayLayer, createDebugSink, createDispatcher, createGridLayer, createGuidesLayer, createHistory2 as createHistory, createMoveToIndexOp, createNodeProperties, createNodeRouting, createPaintedCursorLayer, createPaintedCursorState, createParallaxLayer, createPathAnchorAffordances, createPathEditingOverlayLayer, createPathLayer, createPenPreviewLayer, createReorderOp, createRotationAffordance, createScene, createSelectionHandlesLayer, createSelectionOutlineLayer, createSelectionOverlayLayer, createSetDataOp, createSetLayerOp, createSetPathOp, createSetTextOp, createTextLayer, createVelocityTracker, createViewResolver, createViewportLayer, cubicBezierEasing, cycleVertexColors, decomposePath, decomposeRectPose, defaultCommitAdapter, defaultDrawOne, defaultLabelTextRenderer, defaultNodeProperties, defaultNodeRouting, defaultVisibilityRules, defineTool, defineViewportTool, deriveAlignmentGuides, deriveParallaxView, describeRule, domPositionToCharOffset, domToRuns, drawLayers, drawOneLayer, easeIn, easeInBack, easeInBounce, easeInCirc, easeInCubic, easeInElastic, easeInExpo, easeInOut, easeInOutBack, easeInOutBounce, easeInOutCirc, easeInOutCubic, easeInOutElastic, easeInOutExpo, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInOutSine, easeInQuad, easeInQuart, easeInQuint, easeInSine, easeOut, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, editAnchorsAction, enterTextEditAction, enumerateAnchors, evaluate, fillInPoseFrame, fillToBoundsFrame, findNodeShape, findShapeInk, findShapeSilhouette, fitTextPose, fitToBounds, fitViewToBounds, fitZoom, focused, forEachCoalesced, frameRect, freeform, gateLayer, gesturing, getAlpha01, getImageBitmap, getMarker, getNodeShapes, getPaintKind, getStylusData, gradientForBounds, gradientGeometry, hexToRgba, hitAffordanceRegions, hitAnchor, hitRotationHandle, hostAnchorCss, hostAnchorRect, hovering, hoveringSelected, imageStatus, inferredNodeProperties, inferredNodeRouting, insertAction, interpolateView, isBuiltinToolPref, isEditableTarget, isGradientFill, isLayerPainted, isLayerVisible, isPatternSpec, keySpecShortcut, lassoSelectAction, lerpColorArray, lerpOklab, lerpOklch, linear, listMarkers, listPaintKinds, liveScope, makePinchZoomAction, makeViewportWheelPanAction, makeViewportZoomAction, markerDrawCommands, markerInset, markerKeyOf, markerSites, mat3, matchAlignment, matchesKeyBinding, meanScale, mergeAlphaFromPrev, mergeContributions, modeIn, modeIs, modeNot, modifierHeld, momentum, moveAction, multiActive, nearest, nearestWithin, nestedHitTester, never, nodeHasFlag, none, normalizeHex, not, nurbs, oklabToOklch, oklabToSrgbU8, oklchToOklab, openFilePicker, openPointerSession, or, paintAlpha, paintKindOf, paintWithAlpha, paintWithColor, parseColor, parseColorToRgba255, parseDebugFlags, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathDistanceToPoint, pathDivide, pathExclude, pathFromD, pathInPoseFrame, pathInWorld, pathIntersect, pathIntersectsPolygon, pathIntersectsRect, pathOriginProjection, pathSubtract, pathToAnchors, pathUnion, pickTopMostHit, pinchZoomAction, planPixelRender, pointInRotatedRect, pointInTextPose, poseRotationOf, pressureToWidth, rainbowVertexColors, rebaseLocalPose, rectCorners, registerContentHandler, registerEffect, registerMarker, registerNodeShape, registerPaintKind, registerProgram, renderLabel, renderSceneToCanvas, renderSceneToPixels, resizeAction, resolveColor, resolveDeviceProfile, resolveEasing, resolveFillPattern, resolveMarkerSize, resolveParams, resolvePatternSpec, resolveSkeleton, resolveStrokeWidth, resolveVisibility, rgbaToHex, rotateAction, rotateAroundAABBCenter, rotatePathAround, rotatePoint, rotatedRectCorners, rotationDegreesUnit, rotationHandle, roundToCell, runsToDom, sampleGradientStops, sampleTrack, sceneFromJSON, sceneNodeClientRect, sceneSelectionStore, sceneToAdapter, scopeBindings, screenToWorld, selectFromLasso, selectionAtLeast, selectionEmpty, selectionIs, setFlagOverRange, shapeCoversPoint, sliceAction, snapPoint, solid, solidVertexColors, specificity, spiro, splitPathByLine, splitSubpaths, springPose, springVertexColors, srgbU8ToOklab, staggerVertexColors, startThresholdDrag, strokeInsets, strokeOf, strokeWith, styleAtRange, subscribeImageReady, tessellate, tessellateStroke, textCommand, textCommandFromRuns, tileGrid, toHex8, translatePoseViaDescriptor, translateRectPose, trimPolyline, tweenPose, tweenVertexColors, unionAABB, unionBounds, unionBoundsPath, useActiveToolContext, useAlign, useAnimator, useArrayAdapter, useAutoCenter, useBooleans, useBooleansAdapter, useCanvasFocus, useCanvasSize, useDecayLoop, useDeviceProfile, useDistribute, useDragGesture, useDragHandle, useDragRadial, useDragRect, useDropZone, useEllipseTool, useEyedropperTool, useGestureDispatcher, useGridCellHover, useGuides, useHandTool, useHandleDrag, useHostAnchor, useHoverTracking, useImageTool, useKeybindings, useLassoTool, useLineTool, useNodeOverlayFrame, useOptionalActiveToolContext, usePenTool, usePencilTool, usePinchGesture, usePointerStylus, usePolygonTool, usePublishSelection, useRectTool, useResizePolicy, useRotateTool, useScene, useSceneAdapter, useSceneTextEdit, useSelectTool, useSelection, useSelectionContext, useSimulation, useSliceDep, useStandardActions, useStarTool, useTextEdit, useTextTool, useTools, useVelocityTracker, useViewAnimation, useVisibleRaf, viewToMat3, viewToTransform, viewportDragPanAction, viewportWheelPanAction, viewportZoomAction, viewportsAt, vignette, visualBoundsViaDescriptor, wheelPan, wheelZoom, wheelZoomFactor, when, withAlpha01, withCoord, withGradientKind, worldEditToStorage, worldPoseLookup, worldToScreen, zoomAt, zoomAtLeast };
+//# sourceMappingURL=chunk-WYPSGIYS.js.map
+//# sourceMappingURL=chunk-WYPSGIYS.js.map