@weasel-js/core 1.6.1 → 1.7.0

package/dist/{chunk-MZAIDI6D.js → chunk-G4ZGQMY7.js}

@@ -1,25 +1,29 @@
 import { rotatePoint, aabbCenter, extractPolylines, createSimulation } from './chunk-PNNZSYRD.js';
-import { createReparentOp, createTransformOp, snap } from './chunk-44EWMJV2.js';
-import { fixedCornerOf, DEFAULT_RESIZE_BEHAVIORS, CORNER_ANCHORS, cornerPoint } from './chunk-H6N2JSZ3.js';
-import { unitScale, formatUnit, resolveUnit, ANGLE_RADIANS, withinPxRadius, scaleDelta, pxExtent, withinPxBox, pointToGridCell } from './chunk-HPFJUUTF.js';
-import { unionBounds, visualBoundsViaDescriptor, translatePoseViaDescriptor, poseDescriptorForNode, unionAABB, AUTO_POSE_DESCRIPTOR, remapRotatedLeaf, PATH_Z, PATH_Q, PATH_C, PATH_L, PATH_M, polylineFromPoints, starPath, regularPolygonPath, linePath, ellipsePath, rectPath, polygonFromPoints, PathBuilder, boundsOfPath, pointInPath, isPathLike, strokeHitTest, isRectPose, transformPath, translatePath, DEFAULT_FLATTEN_TOLERANCE, flattenQuadratic, flattenCubic, flattenCubicWithArcLen, flattenQuadraticWithArcLen, RECT_POSE_DESCRIPTOR, aabbIntersectsRect } from './chunk-L5YNZYEG.js';
-import { dispatchApplyBatch, dlog, dwarn, usePointerContext, PointerContextProvider, extractWeaselClipboardFromSvg, parseWeaselClipboardText, materializePaste, WEASEL_CLIPBOARD_MIME, WEASEL_CLIPBOARD_MIME_WEB, sniffWeaselClipboardText, applyOpsTo, usePointerPosition } from './chunk-RMR4QMM6.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 { createReparentOp, createTransformOp, snap } from './chunk-XMAWPGTK.js';
+import { fixedCornerOf, DEFAULT_RESIZE_BEHAVIORS, CORNER_ANCHORS, cornerPoint } from './chunk-DGWNNKGD.js';
+import { withinPxRadius, scaleDelta, pxExtent, withinPxBox, pointToGridCell } from './chunk-LU4IJ52W.js';
+import { unionBounds, visualBoundsViaDescriptor, translatePoseViaDescriptor, poseDescriptorForNode, unionAABB, AUTO_POSE_DESCRIPTOR, remapRotatedLeaf, PATH_Z, PATH_Q, PATH_C, PATH_L, PATH_M, polylineFromPoints, starPath, regularPolygonPath, linePath, ellipsePath, rectPath, polygonFromPoints, PathBuilder, boundsOfPath, pointInPath, isPathLike, strokeHitTest, isRectPose, transformPath, translatePath, DEFAULT_FLATTEN_TOLERANCE, flattenCubicWithArcLen, flattenQuadraticWithArcLen, flattenQuadratic, flattenCubic, RECT_POSE_DESCRIPTOR, aabbIntersectsRect } from './chunk-L5YNZYEG.js';
+import { dispatchApplyBatch, dlog, dwarn, usePointerContext, PointerContextProvider, applyOpsTo, extractWeaselClipboardFromSvg, parseWeaselClipboardText, materializePaste, WEASEL_CLIPBOARD_MIME, WEASEL_CLIPBOARD_MIME_WEB, sniffWeaselClipboardText, usePointerPosition } from './chunk-WPNA6L5O.js';
+import { createSetSelectionOp } from './chunk-UPZY4ART.js';
+import { registerOpFactory, createInsertOp, createDeleteOp, rebuildOp } from './chunk-NE27EOLP.js';
+import { getTexture, chunks, dots, crosshatch, hatch } from './chunk-3TY6FHAF.js';
 import { createContext, createElement, forwardRef, useMemo, useRef, useCallback, useState, useLayoutEffect, useEffect, useImperativeHandle, useSyncExternalStore, useContext, useId, useReducer } from 'react';
 import { GLYPH_COVERAGE_GLSL, subscribeGlyphReady, DEFAULT_BAKE_BUDGET, markAllFontsNotUploaded, resetBakeBudget, syncDynamicPageTexture, ensureFontTexture, dynamicPageTextureId, textureCacheKey, GLYPH_MODE_R8, GLYPH_MODE_MSDF } from '@weasel-js/font';
-export { canQueryLocalFonts, canQueryLocalFonts as canQueryLocalFonts2, enableLocalFontOutlines, enableLocalFontOutlines as enableLocalFontOutlines2, hasFontOutlines, hasFontOutlines as hasFontOutlines2, isCanvasFont, isCanvasFont as isCanvasFont2, listFontOutlines, listFontOutlines as listFontOutlines2, outlineStatus, outlineStatus as outlineStatus2, registerCanvasFont, registerCanvasFont as registerCanvasFont2, registerFont, registerFont as registerFont2, registerFontOutlines, registerFontOutlines as registerFontOutlines2, subscribeGlyphReady, subscribeGlyphReady as subscribeGlyphReady2, unregisterCanvasFont, unregisterCanvasFont as unregisterCanvasFont2, unregisterFontOutlines, unregisterFontOutlines as unregisterFontOutlines2 } from '@weasel-js/font';
+export { canQueryLocalFonts, canQueryLocalFonts as canQueryLocalFonts2, enableLocalFontOutlines, enableLocalFontOutlines as enableLocalFontOutlines2, fontOutlineRegistry, fontOutlineRegistry as fontOutlineRegistry2, fontRegistry, fontRegistry as fontRegistry2, hasFontOutlines, hasFontOutlines as hasFontOutlines2, isCanvasFont, isCanvasFont as isCanvasFont2, listFontOutlines, listFontOutlines as listFontOutlines2, outlineStatus, outlineStatus as outlineStatus2, registerCanvasFont, registerCanvasFont as registerCanvasFont2, registerFont, registerFont as registerFont2, registerFontOutlines, registerFontOutlines as registerFontOutlines2, subscribeGlyphReady, subscribeGlyphReady as subscribeGlyphReady2, unregisterCanvasFont, unregisterCanvasFont as unregisterCanvasFont2, unregisterFontOutlines, unregisterFontOutlines as unregisterFontOutlines2 } from '@weasel-js/font';
 import { hexToColorLiteral, resolvePaletteColor, colorLiteralToHex, dashForStrokeStyle, strokeDashStyleOf, resolveScreenLength, alignedStrokeRect, lerpColorArray, hslToSrgb, srgbFloatToOklab, oklabToOklch, oklchToOklab, oklabToSrgbU8 } from '@weasel-js/paint';
 export { STROKE_DASH_RATIOS, alignedStrokeRect, contrastLineColor, dashForStrokeStyle, hexToOklchDeg, hslToSrgb, interpolateSrgb, lerpColorArray, lerpOklab, lerpOklch, linearSrgbToOklab, linearToSrgb, oklabToLinearSrgb, oklabToOklch, oklabToSrgbU8, oklchDegToHex, oklchToOklab, resolveScreenLength, srgbFloatToOklab, srgbToHsl, srgbToLinear, srgbU8ToOklab, strokeDashStyleOf } from '@weasel-js/paint';
-import { boxToBox, forEachSegment, multiply as multiply$1, rotate, translate as translate$1, rectToContour, invert as invert$1, clampRectWithin, applyToPoint, rotateAboutPoint, cubicEvalAt, pointInPolygon, segmentsCross, pathCommandCoordCount, pointSegmentDist2, elevateQuadraticToCubic } from '@weasel-js/geom';
-import { resolveTextStyle, resolveAlign, resolveRuns, cachedLayoutRuns, verticalAlignOffset, textPoseLayoutInput, runsToPlainText, layoutTextPose, fontString, textLineBoxes } from '@weasel-js/text';
+import { boxToBox, forEachSegment, multiply as multiply$1, rotate, translate as translate$1, rectToContour, splitCubicAt, invert as invert$1, clampRectWithin, applyToPoint, rotateAboutPoint, nearestOnLine, nearestOnCubic, cubicEvalAt, pathCommandCoordCount, pointInPolygon, segmentsCross, nearestOnPath, splitQuadraticAt } from '@weasel-js/geom';
+import { createReflectable } from '@weasel-js/registry';
+export { createReflectable } from '@weasel-js/registry';
+import { resolveAlign, resolveTextStyle, resolveRuns, cachedLayoutRuns, verticalAlignOffset, textPoseLayoutInput, runsToPlainText, layoutTextPose, fontString, textLineBoxes, SCRIPT_METRICS } from '@weasel-js/text';
 export { DEFAULT_TEXT_STYLE, MARKDOWN_RUN_GRAMMAR, SCRIPT_METRICS, cachedLayoutRuns, createMarkdownRenderer, fontString, layoutMarkdown, layoutRuns, layoutTextPose, markdownToRuns, measureText, measureTextBounds, measuredWidth, resolveAlign, resolveRuns, resolveTextStyle, runsToMarkdown, runsToPlainText, textLineBoxes, textPoseLayoutInput, toRuns, transformRunTexts, verticalAlignOffset } from '@weasel-js/text';
 import earcut from 'earcut';
-import { isAnchorOrControl, isBody, ActionDisabledReason, scratchKey, resolveParams, createDispatcher, DEFAULT_ALLOWED_CAPABILITIES, itemsFromFiles, evaluate, resolveDeviceProfile, isResizeHandle, isRotateHandle, defineViewportTool as defineViewportTool$1, NEVER, recordModeSwitch, DEFAULT_DEVICE_PROFILE, defineTool as defineTool$1, getScratch, openPointerSession, actionBindings, ALWAYS, clientToCanvas, setScratch, mergeContributions as mergeContributions$1, clientToCanvasRect, isEditableTarget } from '@weasel-js/routing';
-export { ALWAYS, ActionDisabledReason, COARSE_TARGET_SCALE, DEFAULT_ALLOWED_CAPABILITIES, DEFAULT_DEVICE_PROFILE, NEVER, actionBindings, actionItems, buildDepsFromRequires, buildRuleCtx, clientToCanvas, createDispatcher, deleteScratch, describeRule, evaluate, evaluateEnabled, getScratch, isEditableTarget, liveScope, matchesKeyBinding, openPointerSession, resolveDeviceProfile, resolveParams, scopeBindings, scratchKey, setScratch, specificity } from '@weasel-js/routing';
-import { ActiveToolContextProviderIfRoot, useOptionalActiveToolContext, useTools as useTools$1, useOptionalDepRegistry, DepRegistryProvider, useActionsRegistry, ActionsScope, ActionsProvider, useDepRegistry, useDepSource, useGestureDispatcher, ActiveToolContextProvider } from '@weasel-js/routing/react';
-export { ActionsProvider, ActionsScope, ActiveToolContextProvider, ActiveToolContextProviderIfRoot, DepRegistryProvider, useAction, useActionsRegistry, useActiveToolContext, useDepRegistry, useDepSource, useGestureDispatcher, useOngoingAction, useOptionalActiveToolContext, useOptionalDepRegistry } from '@weasel-js/routing/react';
+import { unitScale, formatUnit, resolveUnit, ANGLE_RADIANS } from '@weasel-js/quantity';
+export { ANGLE_RADIANS, IMPERIAL_INCHES, METRIC_MM, PIXELS, formatUnit, resolveUnit, unitScale } from '@weasel-js/quantity';
+import { scratchKey, isAnchorOrControl, isBody, ActionDisabledReason, resolveParams, DRAG_THRESHOLD_PX, pastDragThreshold, setScratch, createDispatcher, DEFAULT_ALLOWED_CAPABILITIES, itemsFromFiles, evaluate, resolveDeviceProfile, defineTool, isResizeHandle, isRotateHandle, NEVER, recordModeSwitch, DEFAULT_DEVICE_PROFILE, openPointerSession, actionBindings, getScratch, ALWAYS, clientToCanvas, mergeContributions as mergeContributions$1, clientToCanvasRect, isEditableTarget } from '@weasel-js/routing';
+export { ALWAYS, ActionDisabledReason, COARSE_TARGET_SCALE, DEFAULT_ALLOWED_CAPABILITIES, DEFAULT_DEVICE_PROFILE, DRAG_THRESHOLD_PX, NEVER, actionBindings, actionItems, buildDepsFromRequires, buildRuleCtx, clientToCanvas, createDepRegistry, createDispatcher, defineTool, deleteScratch, describeRule, evaluate, evaluateEnabled, getScratch, isEditableTarget, liveScope, matchesKeyBinding, modeShortcutSpec, modeShortcuts, openPointerSession, pastDragThreshold, resolveDeviceProfile, resolveParams, scopeBindings, scratchKey, setScratch, specificity } from '@weasel-js/routing';
+import { InputScope, useOptionalActiveToolContext, useTools as useTools$1, useActionsRegistry, useDepSource, useDepRegistry, useGestureDispatcher, useOptionalDepRegistry, useOffhandAction, DepRegistryProvider, ActionsProvider, ActiveToolContextProvider, ActiveToolContextProviderIfRoot } from '@weasel-js/routing/react';
+export { ActionsProvider, ActiveToolContextProvider, ActiveToolContextProviderIfRoot, DepRegistryProvider, InputScope, Yoke, useAction, useActionsRegistry, useActiveToolContext, useDepRegistry, useDepSource, useGestureDispatcher, useOngoingAction, useOptionalActiveToolContext, useOptionalDepRegistry, useYoke } from '@weasel-js/routing/react';
 import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
 import { pathCrop as pathCrop$1, pathDivide as pathDivide$1, pathUnion as pathUnion$1, pathSubtract as pathSubtract$1, pathExclude as pathExclude$1, pathIntersect as pathIntersect$1 } from '@weasel-js/geom/booleans';
 import { mimeMatchesGlob } from '@weasel-js/gestures';
@@ -27,9 +31,10 @@ import { createPaintedCursorState, GLYPHS, cursorWorldSize, cursorPaintOps, chro
 export { bakeCursor, createPaintedCursorState, cursorFor, resolveCursor, resolveCursorTier } from '@weasel-js/cursor';
 import { createHistory } from '@weasel-js/history';
 export * from '@weasel-js/history';
+import { getActiveModeFor } from '@weasel-js/modes';
 
 // src/version.ts
-var VERSION = "1.6.1" ;
+var VERSION = "1.7.0" ;
 
 // src/features/grid/roundToCell.ts
 function roundToCell(value, cellSize) {
@@ -1719,8 +1724,6 @@ function dropPoseKeyedMemoSlots(node) {
     if (entry.pose !== void 0) record.slots.delete(slot);
   }
 }
-
-// src/core/paintKinds.ts
 var BUILTINS = [
   {
     id: "solid",
@@ -1751,7 +1754,9 @@ function gradientKind(id, label, icon) {
     icon,
     // `bounds` units make the seed independent of the node's actual size.
     seed: (color) => gradientForBounds(id, UNIT_BOX, twoStopRamp(color), "bounds"),
-    colorOf: (paint) => paint.stops?.[0]?.color
+    colorOf: (paint) => paint.stops?.[0]?.color,
+    stopsOf: (paint) => paint.stops,
+    fromStops: (stops) => gradientForBounds(id, UNIT_BOX, stops, "bounds")
   };
 }
 var UNIT_BOX = { x: 0, y: 0, width: 1, height: 1 };
@@ -1759,44 +1764,61 @@ function twoStopRamp(color) {
   const isWhite = color.slice(0, 7).toLowerCase() === "#ffffff";
   return [{ offset: 0, color }, { offset: 1, color: isWhite ? "#000000ff" : "#ffffffff" }];
 }
-var KINDS = /* @__PURE__ */ new Map();
+var KINDS = createReflectable();
 function seedBuiltins() {
-  for (const entry of BUILTINS) KINDS.set(entry.id, entry);
+  for (const entry of BUILTINS) KINDS.push(entry.id, entry, { source: "kit" });
 }
 seedBuiltins();
+KINDS.subscribe(bumpNodeMemoGeneration);
+var paintKindRegistry = KINDS.reflection;
 function asPaint(paint) {
   return paint;
 }
 function registerPaintKind(entry) {
+  if (entry.stopsOf === void 0 !== (entry.fromStops === void 0)) {
+    const missing = entry.stopsOf === void 0 ? "stopsOf" : "fromStops";
+    throw new Error(
+      `weasel registerPaintKind: kind "${entry.id}" is missing ${missing}. A gradient kind reads as a stop list and builds from one; supply both or neither.`
+    );
+  }
   if (entry.inPoseFrame === void 0 !== (entry.toBoundsFrame === void 0)) {
     const missing = entry.inPoseFrame === void 0 ? "inPoseFrame" : "toBoundsFrame";
     throw new Error(
       `weasel registerPaintKind: kind "${entry.id}" is missing ${missing}. A kind that converts one frame direction and not the other drifts on the next resize; supply both or neither.`
     );
   }
-  const displaced = KINDS.get(entry.id);
-  KINDS.set(entry.id, entry);
-  bumpNodeMemoGeneration();
-  return () => {
-    if (KINDS.get(entry.id) !== entry) return;
-    if (displaced) KINDS.set(entry.id, displaced);
-    else KINDS.delete(entry.id);
-    bumpNodeMemoGeneration();
-  };
+  return KINDS.push(entry.id, entry);
 }
 function getPaintKind(kind) {
   return KINDS.get(kind ?? "solid");
 }
 function listPaintKinds() {
-  return [...KINDS.values()];
+  return KINDS.entries().map((e) => e.value);
+}
+function listGradientKinds() {
+  return listPaintKinds().filter((entry) => entry.stopsOf && entry.fromStops);
+}
+function switchGradientKind(paint, kind) {
+  const from = paintKindOf(paint);
+  const to = getPaintKind(kind);
+  if (!from?.stopsOf || !to?.fromStops) return void 0;
+  if (from.id === to.id) return paint;
+  if (isGradientFill(paint) && isGradientFill({ fill: kind })) {
+    return withGradientKind(paint, kind);
+  }
+  const { interpolate, opacity } = paint;
+  return {
+    ...to.fromStops(from.stopsOf(paint)),
+    ...interpolate !== void 0 ? { interpolate } : {},
+    ...opacity !== void 0 ? { opacity } : {}
+  };
 }
 function paintKindOf(fill) {
   return getPaintKind(fill.fill ?? "solid");
 }
 function _resetPaintKindsForTests() {
-  KINDS = /* @__PURE__ */ new Map();
+  KINDS.clear();
   seedBuiltins();
-  bumpNodeMemoGeneration();
 }
 
 // src/renderer/DrawCommand.ts
@@ -2970,11 +2992,13 @@ function circle(cx, r, size, segments = 32) {
 var BUILTIN_MARKERS = [
   {
     id: "arrow",
+    reads: [],
     inset: 3,
     path: ({ size }) => poly([0, 0, -3, -1.5, -3, 1.5], size)
   },
   {
     id: "arrow-open",
+    reads: [],
     inset: 0,
     fill: "none",
     outline: { width: 1 },
@@ -2986,16 +3010,19 @@ var BUILTIN_MARKERS = [
   },
   {
     id: "arrow-concave",
+    reads: [],
     inset: 3,
     path: ({ size }) => poly([0, 0, -3, -1.5, -2, 0, -3, 1.5], size)
   },
   {
     id: "diamond",
+    reads: [],
     inset: 4,
     path: ({ size }) => poly([0, 0, -2, -1.2, -4, 0, -2, 1.2], size)
   },
   {
     id: "diamond-hollow",
+    reads: [],
     inset: 4,
     fill: "none",
     outline: { width: 0.5 },
@@ -3003,16 +3030,19 @@ var BUILTIN_MARKERS = [
   },
   {
     id: "circle",
+    reads: [],
     inset: 2,
     path: ({ size }) => circle(-1, 1, size)
   },
   {
     id: "square",
+    reads: [],
     inset: 2,
     path: ({ size }) => poly([0, -1, 0, 1, -2, 1, -2, -1], size)
   },
   {
     id: "bar",
+    reads: [],
     inset: 0,
     fill: "none",
     outline: { width: 1 },
@@ -3021,48 +3051,42 @@ var BUILTIN_MARKERS = [
 ];
 
 // src/core/strokeMarkers.ts
-var MARKERS = /* @__PURE__ */ new Map();
+var MARKERS = createReflectable();
 function seedBuiltins2() {
-  for (const entry of BUILTIN_MARKERS) MARKERS.set(entry.id, entry);
+  for (const entry of BUILTIN_MARKERS) MARKERS.push(entry.id, entry, { source: "kit" });
 }
 seedBuiltins2();
+var markerRegistry = MARKERS.reflection;
+function markerGeneration() {
+  return MARKERS.getVersion();
+}
 function registerMarker(entry) {
-  const displaced = MARKERS.get(entry.id);
-  MARKERS.set(entry.id, entry);
-  bumpNodeMemoGeneration();
-  return () => {
-    if (MARKERS.get(entry.id) !== entry) return;
-    if (displaced) MARKERS.set(entry.id, displaced);
-    else MARKERS.delete(entry.id);
-    bumpNodeMemoGeneration();
-  };
+  return MARKERS.push(entry.id, entry);
 }
 function getMarker(key) {
   return key === void 0 ? void 0 : MARKERS.get(key);
 }
 function listMarkers() {
-  return [...MARKERS.values()];
+  return MARKERS.entries().map((e) => e.value);
 }
 function _resetMarkersForTests() {
-  MARKERS = /* @__PURE__ */ new Map();
+  MARKERS.clear();
   seedBuiltins2();
-  bumpNodeMemoGeneration();
 }
 
 // src/core/markerInset.ts
-function resolveMarkerSize(ref, strokeWidth) {
+function resolveMarkerSize(ref, strokeWidth, scale = 1) {
   if (typeof ref === "string" || ref.size === void 0) return strokeWidth;
-  const { size } = ref;
-  return typeof size === "number" ? size : size.px;
+  return resolveScreenLength(ref.size, scale);
 }
 function markerKeyOf(ref) {
   return typeof ref === "string" ? ref : ref.key;
 }
-function markerInset(ref, strokeWidth) {
+function markerInset(ref, strokeWidth, scale = 1) {
   if (ref === void 0) return 0;
   const entry = getMarker(markerKeyOf(ref));
   if (entry === void 0) return 0;
-  return (entry.inset ?? 0) * resolveMarkerSize(ref, strokeWidth);
+  return (entry.inset ?? 0) * resolveMarkerSize(ref, strokeWidth, scale);
 }
 function strokeInsets(stroke, strokeWidth) {
   return {
@@ -3119,6 +3143,220 @@ function strokeMesh(path, stroke, flattenTolerance) {
   return mesh;
 }
 
+// src/features/paths/markerSites.ts
+var EPS2 = 1e-9;
+function dir(pl, i, j) {
+  const dx = pl.points[j * 2] - pl.points[i * 2];
+  const dy = pl.points[j * 2 + 1] - pl.points[i * 2 + 1];
+  const len = Math.hypot(dx, dy);
+  if (len < EPS2) return null;
+  return { x: dx / len, y: dy / len };
+}
+function nextDistinct(pl, i, n) {
+  for (let k = i + 1; k < n; k++) if (dir(pl, i, k)) return k;
+  return -1;
+}
+function prevDistinct(pl, i) {
+  for (let k = i - 1; k >= 0; k--) if (dir(pl, k, i)) return k;
+  return -1;
+}
+function markerSites(pl, want) {
+  const out = [];
+  const n = pl.points.length / 2;
+  if (n < 2) return out;
+  if (want.start && !pl.closed) {
+    const j = nextDistinct(pl, 0, n);
+    const d = j >= 0 ? dir(pl, 0, j) : null;
+    if (d) {
+      out.push({ x: pl.points[0], y: pl.points[1], angle: Math.atan2(-d.y, -d.x), role: "start" });
+    }
+  }
+  if (want.mid) {
+    const A = pl.anchorA, B = pl.anchorB, T = pl.anchorT;
+    if (A && B && T) {
+      for (let i = 1; i < n - 1; i++) {
+        if (A[i] !== B[i] || T[i] !== 0) continue;
+        const p = prevDistinct(pl, i);
+        const q = nextDistinct(pl, i, n);
+        if (p < 0 || q < 0) continue;
+        const inDir = dir(pl, p, i);
+        const outDir = dir(pl, i, q);
+        let bx = inDir.x + outDir.x;
+        let by = inDir.y + outDir.y;
+        if (Math.hypot(bx, by) < EPS2) {
+          bx = inDir.x;
+          by = inDir.y;
+        }
+        out.push({ x: pl.points[i * 2], y: pl.points[i * 2 + 1], angle: Math.atan2(by, bx), role: "mid" });
+      }
+    }
+  }
+  if (want.end && !pl.closed) {
+    const last = n - 1;
+    const p = prevDistinct(pl, last);
+    const d = p >= 0 ? dir(pl, p, last) : null;
+    if (d) {
+      out.push({ x: pl.points[last * 2], y: pl.points[last * 2 + 1], angle: Math.atan2(d.y, d.x), role: "end" });
+    }
+  }
+  return out;
+}
+
+// src/features/paths/markerCommands.ts
+function placed(path, site) {
+  const src = path;
+  const cos = Math.cos(site.angle);
+  const sin = Math.sin(site.angle);
+  const coords = new Float32Array(src.coords.length);
+  for (let i = 0; i < src.coords.length; i += 2) {
+    const x = src.coords[i], y = src.coords[i + 1];
+    coords[i] = site.x + x * cos - y * sin;
+    coords[i + 1] = site.y + x * sin + y * cos;
+  }
+  return { kind: "polygon", commands: src.commands, coords, fillRule: src.fillRule };
+}
+function resolvePaint(p, stroke, fallback) {
+  const v = p ?? fallback;
+  if (v === "none") return void 0;
+  return v === "line" ? stroke.paint : v;
+}
+function markerHeads(path, stroke, strokeWidth, flattenTolerance) {
+  const want = {
+    start: stroke.markerStart !== void 0,
+    mid: stroke.markerMid !== void 0,
+    end: stroke.markerEnd !== void 0
+  };
+  if (!want.start && !want.mid && !want.end) return [];
+  const refFor = (role) => role === "start" ? stroke.markerStart : role === "mid" ? stroke.markerMid : stroke.markerEnd;
+  const out = [];
+  for (const pl of extractPolylines(path, { flattenTolerance })) {
+    for (const site of markerSites(pl, want)) {
+      const ref = refFor(site.role);
+      if (ref === void 0) continue;
+      const entry = getMarker(markerKeyOf(ref));
+      if (entry === void 0) continue;
+      const size = resolveMarkerSize(ref, strokeWidth);
+      const angle = entry.orient === void 0 || entry.orient === "auto" ? site.angle : entry.orient;
+      out.push({ entry, size, path: placed(entry.path({ size, stroke }), { ...site, angle }) });
+    }
+  }
+  return out;
+}
+function headCommands(heads, stroke) {
+  const out = [];
+  for (const { entry, path, size } of heads) {
+    const fill = resolvePaint(entry.fill, stroke, "line");
+    const outline = entry.outline ? { paint: resolvePaint(entry.outline.paint, stroke, "line"), width: entry.outline.width * size } : null;
+    if (fill === void 0 && (outline === null || outline.paint === void 0)) continue;
+    out.push({
+      kind: "path",
+      path,
+      ...fill ? { fill } : {},
+      ...outline && outline.paint ? { stroke: { paint: outline.paint, width: outline.width, cap: "round", join: "round" } } : {}
+    });
+  }
+  return out;
+}
+function markerReadsKey(entry, stroke) {
+  if (entry.reads === void 0) return null;
+  let key = "";
+  for (const field of entry.reads) key += `${JSON.stringify(stroke[field]) ?? ""}|`;
+  return key;
+}
+var READINGS_PER_ENTRY = 64;
+var REACH_BY_READING = /* @__PURE__ */ new WeakMap();
+var REACH_BY_STROKE = /* @__PURE__ */ new WeakMap();
+function measureUnitReach(entry, stroke) {
+  const b = boundsOfPath(entry.path({ size: 1, stroke }));
+  return Math.max(Math.abs(b.x), Math.abs(b.x + b.width), Math.abs(b.y), Math.abs(b.y + b.height)) + (entry.outline ? entry.outline.width / 2 : 0);
+}
+function unitReach(entry, stroke) {
+  const key = markerReadsKey(entry, stroke);
+  if (key === null) {
+    let byStroke2 = REACH_BY_STROKE.get(entry);
+    if (byStroke2 === void 0) REACH_BY_STROKE.set(entry, byStroke2 = /* @__PURE__ */ new WeakMap());
+    let reach2 = byStroke2.get(stroke);
+    if (reach2 === void 0) byStroke2.set(stroke, reach2 = measureUnitReach(entry, stroke));
+    return reach2;
+  }
+  let byReading = REACH_BY_READING.get(entry);
+  if (byReading === void 0) REACH_BY_READING.set(entry, byReading = /* @__PURE__ */ new Map());
+  let reach = byReading.get(key);
+  if (reach === void 0) {
+    if (byReading.size >= READINGS_PER_ENTRY) byReading.clear();
+    byReading.set(key, reach = measureUnitReach(entry, stroke));
+  }
+  return reach;
+}
+function markerReach(stroke, strokeWidth, scale = 1) {
+  let reach = 0;
+  for (const ref of [stroke.markerStart, stroke.markerMid, stroke.markerEnd]) {
+    if (ref === void 0) continue;
+    const entry = getMarker(markerKeyOf(ref));
+    if (entry === void 0) continue;
+    reach = Math.max(reach, unitReach(entry, stroke) * resolveMarkerSize(ref, strokeWidth, scale));
+  }
+  return reach;
+}
+
+// src/renderer/cache/markerCommandCache.ts
+var byValue = /* @__PURE__ */ new WeakMap();
+var byStroke = /* @__PURE__ */ new WeakMap();
+var refKey = (ref) => ref === void 0 ? "" : typeof ref === "string" ? ref : `${ref.key}@${String(ref.size ?? "")}`;
+function readsKey(stroke) {
+  let key = "";
+  for (const ref of [stroke.markerStart, stroke.markerMid, stroke.markerEnd]) {
+    const entry = ref === void 0 ? void 0 : getMarker(markerKeyOf(ref));
+    if (entry === void 0) {
+      key += "/";
+      continue;
+    }
+    const reads = markerReadsKey(entry, stroke);
+    if (reads === null) return null;
+    key += `${reads}/`;
+  }
+  return key;
+}
+function mapFor(path, source, reads) {
+  if (reads !== null) {
+    let map2 = byValue.get(path);
+    if (map2 === void 0) byValue.set(path, map2 = /* @__PURE__ */ new Map());
+    return map2;
+  }
+  let strokes = byStroke.get(path);
+  if (strokes === void 0) byStroke.set(path, strokes = /* @__PURE__ */ new WeakMap());
+  let map = strokes.get(source);
+  if (map === void 0) strokes.set(source, map = /* @__PURE__ */ new Map());
+  return map;
+}
+function cachedMarkerCommands(path, source, stroke, strokeWidth, flattenTolerance) {
+  if (stroke.markerStart === void 0 && stroke.markerMid === void 0 && stroke.markerEnd === void 0) {
+    return [];
+  }
+  const reads = readsKey(stroke);
+  const map = mapFor(path, source, reads);
+  const key = [
+    strokeWidth,
+    flattenTolerance ?? "",
+    markerGeneration(),
+    refKey(stroke.markerStart),
+    refKey(stroke.markerMid),
+    refKey(stroke.markerEnd),
+    reads ?? ""
+  ].join("|");
+  let entry = map.get(key);
+  if (entry === void 0) {
+    const heads = markerHeads(path, stroke, strokeWidth, flattenTolerance);
+    entry = { heads, paint: stroke.paint, cmds: headCommands(heads, stroke) };
+    if (map.size >= STROKE_CONFIGS_PER_PATH) map.clear();
+    map.set(key, entry);
+  } else if (entry.paint !== stroke.paint) {
+    entry.paint = stroke.paint;
+    entry.cmds = headCommands(entry.heads, stroke);
+  }
+  return entry.cmds;
+}
+
 // src/renderer/drawBatch.ts
 var MAX_VERTICES_PER_BATCH = 32768;
 var FLOATS_PER_VERTEX = 10;
@@ -3550,9 +3788,8 @@ var DrawBatch = class {
     gl.deleteVertexArray(set.vao);
   }
 };
-
-// src/renderer/shaders/registerProgram.ts
-var registry = /* @__PURE__ */ new Map();
+var registry = createReflectable();
+var programSourceRegistry = registry.reflection;
 function getProgramSource(id) {
   return registry.get(id) ?? null;
 }
@@ -4532,23 +4769,42 @@ function drawPathFillStencil(ctx, fill, handle) {
   gl.disable(gl.STENCIL_TEST);
   gl.bindVertexArray(null);
 }
-function withResolvedStrokeWidth(ctx, cmd) {
+function withResolvedStrokeLengths(ctx, cmd) {
   const stroke = cmd.stroke;
-  if (typeof stroke.width !== "object") return cmd;
-  const scale = quantizeStrokeScale(stroke.width.px, mat3.meanScaleOf(ctx.state.transform));
-  const width = resolveStrokeWidth(stroke.width, scale);
-  return { ...cmd, stroke: { ...stroke, width } };
+  const { markerStart, markerMid, markerEnd } = stroke;
+  if (typeof stroke.width !== "object" && !isPxMarker(markerStart) && !isPxMarker(markerMid) && !isPxMarker(markerEnd)) {
+    return cmd;
+  }
+  const scale = mat3.meanScaleOf(ctx.state.transform);
+  const resolved = { ...stroke };
+  if (typeof stroke.width === "object") {
+    resolved.width = resolveStrokeWidth(stroke.width, quantizeStrokeScale(stroke.width.px, scale));
+  }
+  if (isPxMarker(markerStart)) resolved.markerStart = resolvedMarker(markerStart, scale);
+  if (isPxMarker(markerMid)) resolved.markerMid = resolvedMarker(markerMid, scale);
+  if (isPxMarker(markerEnd)) resolved.markerEnd = resolvedMarker(markerEnd, scale);
+  return { ...cmd, stroke: resolved };
+}
+function isPxMarker(ref) {
+  return typeof ref === "object" && typeof ref.size === "object";
+}
+function resolvedMarker(ref, scale) {
+  return { ...ref, size: resolveMarkerSize(ref, 0, quantizeStrokeScale(ref.size.px, scale)) };
 }
 function drawPathStroke(ctx, rawCmd) {
-  const cmd = withResolvedStrokeWidth(ctx, rawCmd);
+  const cmd = withResolvedStrokeLengths(ctx, rawCmd);
   const stroke = cmd.stroke;
   const align = stroke.align ?? "center";
   if (cmd.path.kind === "polygon" && align !== "center") {
     flushBatch(ctx);
     drawPathStrokeStenciled(ctx, cmd, align);
-    return;
+  } else {
+    drawPathStrokeUnclipped(ctx, cmd);
+  }
+  const width = resolveStrokeWidth(stroke.width ?? 1, 1);
+  for (const marker of cachedMarkerCommands(cmd.path, rawCmd.stroke, stroke, width, ctx.flattenTolerance)) {
+    drawPath(ctx, marker);
   }
-  drawPathStrokeUnclipped(ctx, cmd);
 }
 function drawPathStrokeUnclipped(ctx, cmd) {
   const stroke = cmd.stroke;
@@ -5810,13 +6066,14 @@ function pathMisses(path, stroke, m, box) {
   return quadMisses(minX - reach, minY - reach, maxX + reach, maxY + reach, m, box);
 }
 function strokeReach(stroke, m) {
-  const w = stroke.width ?? 1;
-  let width = typeof w === "number" ? w : w.px / (mat3.meanScaleOf(m) || 1);
+  const scale = mat3.meanScaleOf(m);
+  const base = resolveStrokeWidth(stroke.width ?? 1, scale);
+  let width = base;
   if (stroke.vertexWidths) {
     for (const v of stroke.vertexWidths) if (v > width) width = v;
   }
   const spike = Math.max(stroke.miterLimit ?? DEFAULT_MITER_LIMIT2, Math.SQRT2);
-  return Math.abs(width) * spike;
+  return Math.max(Math.abs(width) * spike, markerReach(stroke, base, scale));
 }
 function spritesMiss(sprites, m, box) {
   let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
@@ -6027,6 +6284,15 @@ function reportLayerFailure({ layerId, error }) {
     error
   );
 }
+function subscribeToSources(sources) {
+  return (listener) => {
+    const list2 = typeof sources === "function" ? sources() : sources;
+    const offs = list2.flatMap((l) => l.subscribe ? [l.subscribe(listener)] : []);
+    return () => {
+      for (const off of offs) off();
+    };
+  };
+}
 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;
@@ -6216,6 +6482,7 @@ function createViewportLayer(opts) {
     id,
     label,
     space: "screen",
+    subscribe: subscribeToSources(sourceAt),
     resolvable(outer, dims) {
       return { id, view: viewAt(outer, dims), rect: bounds(outer, dims) };
     },
@@ -6346,6 +6613,7 @@ function createParallaxLayer(opts) {
     id,
     label,
     space: "screen",
+    subscribe: subscribeToSources(source),
     draw: (data, outer, dims) => {
       const inner = deriveParallaxView(getOuterView?.() ?? outer, { pan, zoom, anchor });
       return source.flatMap((layer) => drawOneLayer(layer, data, inner, dims));
@@ -6377,6 +6645,7 @@ function createTiledLayer(opts) {
     id,
     label,
     space: "world",
+    subscribe: subscribeToSources(source),
     draw: (data, view, dims) => {
       const p = axes(typeof period === "function" ? period(view, dims) : period, Infinity);
       const b = axes(bleed, 0);
@@ -6958,13 +7227,16 @@ function worldPoseLookup(adapter, compose2) {
   };
 }
 
+// src/core/isPlainObject.ts
+function isPlainPrototype(proto) {
+  return proto === Object.prototype || proto === null || Object.getPrototypeOf(proto) === null;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && isPlainPrototype(Object.getPrototypeOf(value));
+}
+
 // src/core/scene/poseSnapshot.ts
 var DEPTH = 4;
-function isPlainObject(v) {
-  if (typeof v !== "object" || v === null) return false;
-  const proto = Object.getPrototypeOf(v);
-  return proto === Object.prototype || proto === null;
-}
 function isTypedArray(v) {
   return ArrayBuffer.isView(v) && !(v instanceof DataView);
 }
@@ -6989,9 +7261,8 @@ function samePoseValue(snapshot, value, depth = DEPTH) {
   if (typeof snapshot !== "object" || snapshot === null || typeof value !== "object" || value === null) return Object.is(snapshot, value);
   if (depth <= 0) return false;
   const proto = Object.getPrototypeOf(snapshot);
-  if (proto === Object.prototype || proto === null) {
-    const other = Object.getPrototypeOf(value);
-    if (other !== Object.prototype && other !== null) return false;
+  if (isPlainPrototype(proto)) {
+    if (!isPlainPrototype(Object.getPrototypeOf(value))) return false;
     const a = snapshot;
     const b = value;
     let count = 0;
@@ -7580,7 +7851,6 @@ function beginPointerDrag(payload, source, startX, startY, ghostFn) {
     }
   };
 }
-var DRAG_THRESHOLD_PX_SQ = 25;
 function useDragHandle(getPayload, options) {
   const optsRef = useRef(options);
   optsRef.current = options;
@@ -7592,8 +7862,7 @@ function useDragHandle(getPayload, options) {
     if (e.pointerType === "mouse" && e.button !== 0) return;
     const target = e.currentTarget;
     if (e.target instanceof HTMLElement && e.target.closest("input, button, select, textarea")) return;
-    const startX = e.clientX;
-    const startY = e.clientY;
+    const start = { clientX: e.clientX, clientY: e.clientY };
     let ghost = null;
     let past = false;
     live2.current = openPointerSession(target, e, {
@@ -7603,9 +7872,7 @@ function useDragHandle(getPayload, options) {
           return;
         }
         if (past) return;
-        const dx = ev.clientX - startX;
-        const dy = ev.clientY - startY;
-        if (dx * dx + dy * dy <= DRAG_THRESHOLD_PX_SQ) return;
+        if (!pastDragThreshold(start, ev)) return;
         past = true;
         const payload = getPayload();
         if (!payload) return;
@@ -7655,15 +7922,11 @@ function useDropZone(opts) {
   }, []);
 }
 function startThresholdDrag(e, opts) {
-  const startX = e.clientX;
-  const startY = e.clientY;
-  const threshold = opts.threshold ?? 4;
+  const start = { clientX: e.clientX, clientY: e.clientY };
   let activated = false;
   const maybeActivate = (ev) => {
     if (activated) return;
-    const dx = ev.clientX - startX;
-    const dy = ev.clientY - startY;
-    if (dx * dx + dy * dy < threshold * threshold) return;
+    if (!pastDragThreshold(start, ev, opts.threshold)) return;
     activated = true;
     opts.onActivate?.(ev);
   };
@@ -8012,6 +8275,47 @@ function paramsMatch(bound, wanted) {
   return Object.entries(wanted).every(([k, v]) => bound[k] === v);
 }
 
+// src/interactions/actions/gestureLifecycle.ts
+function gestureLifecycleParams(o) {
+  const out = {};
+  if (o.label !== void 0) out.label = o.label;
+  if (o.transient !== void 0) out.transient = o.transient;
+  if (o.onGestureStart) out.onGestureStart = o.onGestureStart;
+  if (o.onGestureEnd) out.onGestureEnd = o.onGestureEnd;
+  return out;
+}
+function readGestureLifecycle(source, defaultLabel, behaviors = []) {
+  const o = source ?? {};
+  let started = false;
+  let ended = false;
+  return {
+    label: o.label ?? defaultLabel,
+    labelFor: (ops) => o.label ?? ops[0]?.label ?? defaultLabel,
+    transient: o.transient ?? behaviors.some((b) => b.defaultTransient === true),
+    start(ids) {
+      if (started) return;
+      started = true;
+      o.onGestureStart?.([...ids]);
+    },
+    end(committed) {
+      if (!started || ended) return;
+      ended = true;
+      o.onGestureEnd?.(committed);
+    }
+  };
+}
+function commitGestureOps(target, lifecycle, ops) {
+  if (lifecycle.transient) {
+    target.scene.untracked(() => {
+      for (const op of ops) op.apply(target.adapter);
+    });
+    return;
+  }
+  const label = lifecycle.labelFor(ops);
+  if (target.applyOps) target.applyOps(ops, label);
+  else target.scene.applyBatch(ops, label, target.adapter);
+}
+
 // src/core/scene/types.ts
 var asNodeId = (s) => s;
 
@@ -8373,14 +8677,14 @@ function translateCommitOps(scratch, ids, dx, dy) {
       id,
       from: authored,
       to: translatePoseViaDescriptor(authored, l.dx, l.dy, scratch.projection),
-      label: "Move"
+      label: scratch.lifecycle.label
     }));
     if (scratch.geometryProjection) {
       const dataOp = geometryDataOp(
         scratch.geometryProjection,
         { id, data: node.data, pose: authored },
         m,
-        "Move"
+        scratch.lifecycle.label
       );
       if (dataOp) ops.push(dataOp);
     }
@@ -8502,7 +8806,10 @@ var moveAction = {
       const pc = ctx.deps.poseComposition ?? IDENTITY_POSE_COMPOSITION;
       if (!selection || !scene) return {};
       if (isAnchorOrControl(ctx.drag?.affordance)) return {};
-      const ids = selection.get();
+      const params = resolveParams(opts?.params);
+      const expandIds = params?.["expandIds"];
+      const selected = [...selection.get()];
+      const ids = expandIds ? expandIds(selected) : selected;
       if (ids.length === 0) return {};
       const startPoses = /* @__PURE__ */ new Map();
       const cascadeIds = [];
@@ -8545,6 +8852,9 @@ var moveAction = {
         }
       }
       const behaviors = opts?.behaviors ?? [];
+      const dragThresholdPx = params?.["dragThresholdPx"] ?? DRAG_THRESHOLD_PX;
+      const lifecycle = readGestureLifecycle(params, "Move", behaviors);
+      let engaged = false;
       const adapter = moveGestureAdapter(scene);
       const origin = /* @__PURE__ */ new Map();
       for (const [id, pose] of startPoses) origin.set(id, pose);
@@ -8577,12 +8887,170 @@ var moveAction = {
         layoutPass: null,
         pc,
         applyOps,
-        geometryProjection
+        geometryProjection,
+        lifecycle
+      };
+      const commitMove = (endCtx) => {
+        const { dx, dy } = scratch.currentDelta;
+        let committed = false;
+        const commitOps = (ops) => {
+          commitGestureOps(scratch, lifecycle, ops);
+          committed = true;
+        };
+        if (scratch.behaviors.length > 0) {
+          const gctx = scratch.gestureCtx;
+          for (const [id, ori] of scratch.startPoses) {
+            gctx.current.set(id, translatePoseViaDescriptor(ori, dx, dy, scratch.projection));
+          }
+          for (const b of scratch.behaviors) {
+            const r = b.onEnd?.(gctx);
+            if (r === void 0) continue;
+            if (r === null) return false;
+            commitOps(r);
+            return true;
+          }
+        }
+        if (dx === 0 && dy === 0) return false;
+        if (scratch.layout && scratch.layoutPass) {
+          const lp = scratch.layoutPass;
+          const pc2 = scratch.pc;
+          const commitAdapter = scenePoseAdapter(scratch.scene);
+          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 = draggedIds.has(a.id) ? destId : curParent;
+            return createTransformOp({
+              id: a.id,
+              from: rebaseLocalPose(commitAdapter, a.from, curParent, pc2.compose, pc2.decompose),
+              to: rebaseLocalPose(commitAdapter, a.to, toParent, pc2.compose, pc2.decompose),
+              label: a.label,
+              coalesceKey: a.coalesceKey
+            });
+          };
+          const reparentOps = [];
+          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) {
+            const parent = scratch.scene.get(asNodeId(cid))?.parent ?? null;
+            reflowOps.push(createTransformOp({
+              id: cid,
+              from: scratch.scene.get(asNodeId(cid)).pose,
+              to: rebaseLocalPose(commitAdapter, worldPose, parent, pc2.compose, pc2.decompose),
+              label: "Source reflow"
+            }));
+          }
+          const ops = [...reparentOps, ...dropOps, ...reflowOps];
+          if (ops.length > 0) commitOps(ops);
+          return committed;
+        }
+        const released = /* @__PURE__ */ new Set();
+        const releasedOps = [];
+        if (scratch.layout && !scratch.layoutPass) {
+          const pc2 = scratch.pc;
+          const commitAdapter = scenePoseAdapter(scratch.scene);
+          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: scratch.projection.getBounds(
+                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: translatePoseViaDescriptor(startWorld, dx, dy, scratch.projection),
+                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);
+          return committed;
+        }
+        const reparentMode = resolveParams(opts?.params)?.["reparentOnDrop"] ?? "off";
+        const dropTarget = reparentMode !== "off" ? resolveDropTarget(endCtx, scratch) : null;
+        if (dropTarget) {
+          const reparent = () => applyReparent(scratch, dropTarget, reparentMode, dx, dy, scratch.pc);
+          if (lifecycle.transient) scratch.scene.untracked(reparent);
+          else scratch.scene.batch(lifecycle.label, reparent);
+          committed = true;
+        } else {
+          const ops = translateCommitOps(scratch, [...scratch.ids, ...scratch.cascadeIds], dx, dy);
+          if (ops.length > 0) commitOps(ops);
+        }
+        return committed;
       };
       return {
         kind: "move",
         onMove(moveCtx) {
           if (!moveCtx.drag) return;
+          if (!engaged) {
+            const s = moveCtx.drag.screenDelta;
+            if (s && !pastDragThreshold({ clientX: 0, clientY: 0 }, { clientX: s.x, clientY: s.y }, dragThresholdPx)) return;
+            engaged = true;
+            lifecycle.start(scratch.ids);
+          }
           let dx = moveCtx.drag.delta.x;
           let dy = moveCtx.drag.delta.y;
           if (scratch.behaviors.length > 0) {
@@ -8629,171 +9097,14 @@ var moveAction = {
           syncPreviewOverrides(scratch);
         },
         onEnd(endCtx, reason) {
-          if (reason === "cancel") {
+          let committed = false;
+          try {
+            if (reason === "commit") committed = commitMove(endCtx);
+          } finally {
             dropPreviewOverrides(scratch);
             scratch.previews.clear();
-            return;
-          }
-          const { dx, dy } = scratch.currentDelta;
-          const commitOps = (ops, label) => {
-            if (scratch.applyOps) scratch.applyOps(ops, label);
-            else scratch.scene.applyBatch(ops, label, scratch.adapter);
-          };
-          if (scratch.behaviors.length > 0) {
-            const gctx = scratch.gestureCtx;
-            for (const [id, ori] of scratch.startPoses) {
-              gctx.current.set(id, translatePoseViaDescriptor(ori, dx, dy, scratch.projection));
-            }
-            for (const b of scratch.behaviors) {
-              const r = b.onEnd?.(gctx);
-              if (r === void 0) continue;
-              if (r === null) {
-                scratch.previews.clear();
-                return;
-              }
-              commitOps(r, "Move");
-              scratch.previews.clear();
-              return;
-            }
-          }
-          if (dx === 0 && dy === 0) {
-            scratch.previews.clear();
-            return;
-          }
-          if (scratch.layout && scratch.layoutPass) {
-            const lp = scratch.layoutPass;
-            const pc2 = scratch.pc;
-            const commitAdapter = scenePoseAdapter(scratch.scene);
-            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 = draggedIds.has(a.id) ? destId : curParent;
-              return createTransformOp({
-                id: a.id,
-                from: rebaseLocalPose(commitAdapter, a.from, curParent, pc2.compose, pc2.decompose),
-                to: rebaseLocalPose(commitAdapter, a.to, toParent, pc2.compose, pc2.decompose),
-                label: a.label,
-                coalesceKey: a.coalesceKey
-              });
-            };
-            const reparentOps = [];
-            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) {
-              const parent = scratch.scene.get(asNodeId(cid))?.parent ?? null;
-              reflowOps.push(createTransformOp({
-                id: cid,
-                from: scratch.scene.get(asNodeId(cid)).pose,
-                to: rebaseLocalPose(commitAdapter, worldPose, parent, pc2.compose, pc2.decompose),
-                label: "Source reflow"
-              }));
-            }
-            const ops = [...reparentOps, ...dropOps, ...reflowOps];
-            if (ops.length > 0) {
-              commitOps(ops, ops[0].label ?? "Move");
-            }
-            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 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: scratch.projection.getBounds(
-                  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: translatePoseViaDescriptor(startWorld, dx, dy, scratch.projection),
-                  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;
+            lifecycle.end(committed);
           }
-          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 ops = translateCommitOps(scratch, [...scratch.ids, ...scratch.cascadeIds], dx, dy);
-            if (ops.length > 0) commitOps(ops, "Move");
-          }
-          dropPreviewOverrides(scratch);
-          scratch.previews.clear();
         },
         previewIds: () => scratch.previews.keys(),
         previewPose: (id) => scratch.previews.get(id) ?? null,
@@ -8913,14 +9224,16 @@ function resolveDeps(ctx) {
       behaviors: DEFAULT_RESIZE_BEHAVIORS,
       pointSnap: EMPTY_POINT_SNAP,
       expandIds: IDENTITY_EXPAND,
-      geometry
+      geometry,
+      policy: void 0
     };
   }
   return {
     behaviors: dep.constraints,
     pointSnap: dep.pointSnap,
     expandIds: dep.expandIds,
-    geometry
+    geometry,
+    policy: dep
   };
 }
 function buildPointSnapContext(pose, rotation, anchor, modifiers) {
@@ -9004,7 +9317,9 @@ function computeProposedBounds(ob, anchor, dx, dy, rotation) {
 var resizeAction = {
   id: "resize",
   label: "Resize",
-  defaultBinding: { kind: "drag" },
+  // No default binding: a bare `{ kind: 'drag' }` claimed every drag at ambient
+  // scope, tying areaSelect's. The resize handles bind it
+  // (`selectionTransformBindings`, the `transform` preset).
   eligible: { capability: "transforms-selection" },
   requires: ["selection", "scene", "resizePolicy", "poseDescriptor", "applyOps", "geometryProjection", "poseComposition"],
   invoker: {
@@ -9020,7 +9335,7 @@ var resizeAction = {
       const affordance = ctx.drag?.affordance;
       const anchor = affordance?.anchor;
       if (!anchor) return {};
-      const { behaviors, pointSnap, expandIds, geometry } = resolveDeps(ctx);
+      const { behaviors, pointSnap, expandIds, geometry, policy } = resolveDeps(ctx);
       const expanded = expandIds(ids);
       if (expanded.length === 0) return {};
       const isGroupPath = ids.length === 1 && (expanded.length !== 1 || expanded[0] !== ids[0]);
@@ -9081,7 +9396,78 @@ var resizeAction = {
         pointSnap,
         gestureCtx,
         applyOps,
-        geometryProjection
+        geometryProjection,
+        lifecycle: readGestureLifecycle(policy, "Resize", behaviors)
+      };
+      const { lifecycle } = scratch;
+      lifecycle.start(writeIds);
+      const commitResize = () => {
+        const target = {
+          scene,
+          applyOps: scratch.applyOps,
+          adapter: defaultCommitAdapter(scene, selection.adapterMethods)
+        };
+        for (const b of scratch.behaviors) {
+          const r = b.onEnd?.(scratch.gestureCtx);
+          if (r === void 0) continue;
+          if (r === null) return false;
+          commitGestureOps(target, lifecycle, r);
+          return true;
+        }
+        if (scratch.previews.size === 0) return false;
+        const ops = [];
+        for (const id of scratch.writeIds) {
+          const next = scratch.previews.get(id);
+          if (next === void 0) continue;
+          const from = scratch.startPoses.get(id);
+          if (from === void 0) continue;
+          let committed = next;
+          if (scratch.geometryProjection) {
+            const node = scratch.scene.get(id);
+            if (node) {
+              const sb = scratch.geometry.getBounds(from);
+              const db = scratch.geometry.getBounds(next);
+              const m = boxToBox(
+                sb.x,
+                sb.y,
+                sb.width,
+                sb.height,
+                db.x,
+                db.y,
+                db.width,
+                db.height
+              );
+              const dataOp = geometryDataOp(
+                scratch.geometryProjection,
+                { id, data: node.data, pose: from },
+                m,
+                lifecycle.label
+              );
+              if (dataOp) {
+                ops.push(dataOp);
+                if (db.width < 0 || db.height < 0) {
+                  const nb = {
+                    ...db,
+                    x: db.width < 0 ? db.x + db.width : db.x,
+                    y: db.height < 0 ? db.y + db.height : db.y,
+                    width: Math.abs(db.width),
+                    height: Math.abs(db.height)
+                  };
+                  committed = scratch.geometry.remapBounds(next, db, nb);
+                }
+              }
+            }
+          }
+          ops.push(createTransformOp({
+            id,
+            from,
+            to: committed,
+            label: lifecycle.label
+          }));
+        }
+        if (ops.length === 0) return false;
+        commitGestureOps(target, lifecycle, ops);
+        return true;
       };
       return {
         kind: "resize",
@@ -9183,79 +9569,14 @@ var resizeAction = {
           syncPreviewOverrides(scratch);
         },
         onEnd(_endCtx, reason) {
-          if (reason === "cancel") {
+          let committed = false;
+          try {
+            if (reason === "commit") committed = commitResize();
+          } finally {
             dropPreviewOverrides(scratch);
             scratch.previews.clear();
-            return;
-          }
-          for (const b of scratch.behaviors) {
-            const r = b.onEnd?.(scratch.gestureCtx);
-            if (r === null) {
-              dropPreviewOverrides(scratch);
-              scratch.previews.clear();
-              return;
-            }
-          }
-          if (scratch.previews.size === 0) {
-            dropPreviewOverrides(scratch);
-            return;
-          }
-          const ops = [];
-          for (const id of scratch.writeIds) {
-            const next = scratch.previews.get(id);
-            if (next === void 0) continue;
-            const from = scratch.startPoses.get(id);
-            if (from === void 0) continue;
-            let committed = next;
-            if (scratch.geometryProjection) {
-              const node = scratch.scene.get(id);
-              if (node) {
-                const sb = scratch.geometry.getBounds(from);
-                const db = scratch.geometry.getBounds(next);
-                const m = boxToBox(
-                  sb.x,
-                  sb.y,
-                  sb.width,
-                  sb.height,
-                  db.x,
-                  db.y,
-                  db.width,
-                  db.height
-                );
-                const dataOp = geometryDataOp(
-                  scratch.geometryProjection,
-                  { id, data: node.data, pose: from },
-                  m,
-                  "Resize"
-                );
-                if (dataOp) {
-                  ops.push(dataOp);
-                  if (db.width < 0 || db.height < 0) {
-                    const nb = {
-                      ...db,
-                      x: db.width < 0 ? db.x + db.width : db.x,
-                      y: db.height < 0 ? db.y + db.height : db.y,
-                      width: Math.abs(db.width),
-                      height: Math.abs(db.height)
-                    };
-                    committed = scratch.geometry.remapBounds(next, db, nb);
-                  }
-                }
-              }
-            }
-            ops.push(createTransformOp({
-              id,
-              from,
-              to: committed,
-              label: "Resize"
-            }));
-          }
-          if (ops.length > 0) {
-            if (scratch.applyOps) scratch.applyOps(ops, "Resize");
-            else scratch.scene.applyBatch(ops, "Resize", defaultCommitAdapter(scratch.scene, selection.adapterMethods));
+            lifecycle.end(committed);
           }
-          dropPreviewOverrides(scratch);
-          scratch.previews.clear();
         },
         previewIds: () => scratch.previews.keys(),
         previewPose: (id) => scratch.previews.get(id) ?? null
@@ -9276,8 +9597,6 @@ var resizeAction = {
    */
   enabled: () => true
 };
-
-// src/interactions/actions/defaults/rotate.ts
 function applyRotationDelta(d, pose, originRotation, delta3, originCenter, unionCenter, useUnionPivot) {
   const rotated = d.withRotation(pose, originRotation + delta3);
   if (!useUnionPivot) return rotated;
@@ -9292,15 +9611,19 @@ function applyRotationDelta(d, pose, originRotation, delta3, originCenter, union
 var rotateAction = {
   id: "rotate",
   label: "Rotate",
-  defaultBinding: { kind: "drag" },
+  // No default binding. It used to be a bare `{ kind: 'drag' }`, which made
+  // any drag no active tool claimed rotate a non-empty selection. The rotation
+  // handle binds it (`selectionTransformBindings`, the `transform` preset).
   eligible: { capability: "transforms-selection" },
   requires: ["selection", "scene", "applyOps", "poseDescriptor", "poseComposition"],
   invoker: {
     timing: "ongoing",
-    start(ctx, _opts) {
+    start(ctx, opts) {
       const selection = ctx.deps.selection;
       const scene = ctx.deps.scene;
       const applyOps = ctx.deps.applyOps;
+      const params = resolveParams(opts?.params);
+      const behaviors = opts?.behaviors ?? [];
       if (!selection || !scene) return {};
       const ids = selection.get();
       if (ids.length === 0) return {};
@@ -9343,35 +9666,109 @@ var rotateAction = {
         unionCenter,
         startPointerAngle,
         currentDelta: 0,
-        useUnionPivot: ids.length > 1,
+        useUnionPivot: ids.length > 1 && params?.["pivot"] !== "each",
         previews: /* @__PURE__ */ new Map(),
         overrideEntries: /* @__PURE__ */ new Map(),
-        applyOps
-      };
-      const recomputePreviews = (delta3) => {
-        scratch.previews.clear();
-        if (delta3 === 0) {
-          syncPreviewOverrides(scratch);
-          return;
+        applyOps,
+        lifecycle: readGestureLifecycle(params, "Rotate", behaviors),
+        behaviors,
+        gestureCtx: {
+          draggedIds: [...originPoses.keys()],
+          origin: new Map([...originWorlds].map(([id, p]) => [id, p])),
+          current: new Map([...originWorlds].map(([id, p]) => [id, p])),
+          snap: null,
+          modifiers: { ...ctx.modifiers },
+          pointer: { worldX: ctx.world.x, worldY: ctx.world.y, clientX: 0, clientY: 0 },
+          adapter: moveGestureAdapter(scene),
+          scratch: {}
         }
-        for (const id of scratch.ids) {
-          const origin = scratch.originWorlds.get(id);
-          if (origin === void 0) continue;
-          const originRotation = scratch.originRotations.get(id) ?? 0;
-          const originCenter = scratch.originCenters.get(id) ?? { x: 0, y: 0 };
-          const turned = applyRotationDelta(
+      };
+      const { lifecycle } = scratch;
+      const turnedWorlds = (delta3) => {
+        const out = /* @__PURE__ */ new Map();
+        for (const [id, origin] of scratch.originWorlds) {
+          out.set(id, applyRotationDelta(
             scratch.descriptor,
             origin,
-            originRotation,
+            scratch.originRotations.get(id) ?? 0,
             delta3,
-            originCenter,
+            scratch.originCenters.get(id) ?? { x: 0, y: 0 },
             scratch.unionCenter,
             scratch.useUnionPivot
-          );
-          scratch.previews.set(id, scratch.frame.local(id, turned));
+          ));
+        }
+        return out;
+      };
+      const syncGestureCurrent = (delta3) => {
+        const turned = turnedWorlds(delta3);
+        for (const [id, pose] of turned) scratch.gestureCtx.current.set(id, pose);
+        return turned;
+      };
+      const shapeDelta = (moveCtx, raw) => {
+        const gctx = scratch.gestureCtx;
+        gctx.modifiers = { ...moveCtx.modifiers };
+        gctx.pointer = { worldX: moveCtx.world.x, worldY: moveCtx.world.y, clientX: 0, clientY: 0 };
+        const primary = scratch.originWorlds.keys().next().value;
+        const originRotation = scratch.originRotations.get(primary) ?? 0;
+        let delta3 = raw;
+        let proposed = {
+          pose: syncGestureCurrent(raw).get(primary),
+          rotation: originRotation + raw
+        };
+        for (const b of scratch.behaviors) {
+          const r = b.onMove?.(gctx, proposed);
+          if (!r || r.pose === void 0) continue;
+          const rotation = scratch.descriptor.getRotation?.(r.pose) ?? 0;
+          delta3 = rotation - originRotation;
+          proposed = { pose: r.pose, rotation };
+        }
+        return delta3;
+      };
+      const commitRotate = () => {
+        const target = {
+          scene,
+          applyOps: scratch.applyOps,
+          adapter: defaultCommitAdapter(scene, selection.adapterMethods)
+        };
+        if (scratch.behaviors.length > 0) {
+          syncGestureCurrent(scratch.currentDelta);
+          for (const b of scratch.behaviors) {
+            const r = b.onEnd?.(scratch.gestureCtx);
+            if (r === void 0) continue;
+            if (r === null) return false;
+            commitGestureOps(target, lifecycle, r);
+            return true;
+          }
+        }
+        if (scratch.currentDelta === 0) return false;
+        const ops = [];
+        for (const id of scratch.ids) {
+          const next = scratch.previews.get(id);
+          if (next === void 0) continue;
+          const from = scratch.originPoses.get(id);
+          if (from === void 0) continue;
+          ops.push(createTransformOp({
+            id,
+            from,
+            to: next,
+            label: lifecycle.label
+          }));
+        }
+        if (ops.length === 0) return false;
+        commitGestureOps(target, lifecycle, ops);
+        return true;
+      };
+      const recomputePreviews = (delta3) => {
+        scratch.previews.clear();
+        if (delta3 !== 0) {
+          for (const [id, turned] of turnedWorlds(delta3)) {
+            scratch.previews.set(id, scratch.frame.local(id, turned));
+          }
         }
         syncPreviewOverrides(scratch);
       };
+      for (const b of behaviors) b.onStart?.(scratch.gestureCtx);
+      lifecycle.start(scratch.gestureCtx.draggedIds);
       return {
         kind: "rotate",
         onMove(moveCtx) {
@@ -9379,39 +9776,19 @@ var rotateAction = {
             moveCtx.world.y - scratch.unionCenter.y,
             moveCtx.world.x - scratch.unionCenter.x
           );
-          scratch.currentDelta = pointerAngle - scratch.startPointerAngle;
+          const raw = pointerAngle - scratch.startPointerAngle;
+          scratch.currentDelta = scratch.behaviors.length > 0 ? shapeDelta(moveCtx, raw) : raw;
           recomputePreviews(scratch.currentDelta);
         },
         onEnd(_endCtx, reason) {
-          if (reason === "cancel") {
-            dropPreviewOverrides(scratch);
-            scratch.previews.clear();
-            return;
-          }
-          if (scratch.currentDelta === 0) {
+          let committed = false;
+          try {
+            if (reason === "commit") committed = commitRotate();
+          } finally {
             dropPreviewOverrides(scratch);
             scratch.previews.clear();
-            return;
-          }
-          const ops = [];
-          for (const id of scratch.ids) {
-            const next = scratch.previews.get(id);
-            if (next === void 0) continue;
-            const from = scratch.originPoses.get(id);
-            if (from === void 0) continue;
-            ops.push(createTransformOp({
-              id,
-              from,
-              to: next,
-              label: "Rotate"
-            }));
-          }
-          if (ops.length > 0) {
-            if (scratch.applyOps) scratch.applyOps(ops, "Rotate");
-            else scratch.scene.applyBatch(ops, "Rotate", defaultCommitAdapter(scratch.scene, selection.adapterMethods));
+            lifecycle.end(committed);
           }
-          dropPreviewOverrides(scratch);
-          scratch.previews.clear();
         },
         previewIds: () => scratch.previews.keys(),
         previewPose: (id) => scratch.previews.get(id) ?? null
@@ -9428,7 +9805,6 @@ var areaSelectAction = {
   // Crosshair while the marquee is being pulled — the select tool used to
   // read this off its own gesture scratch.
   activeCursor: "crosshair",
-  defaultBinding: { kind: "drag" },
   eligible: { capability: "creates-selection" },
   requires: ["areaSelect", "editAnchors", "view"],
   invoker: {
@@ -9618,7 +9994,6 @@ var insertAction = {
   id: "insert",
   label: "Insert",
   group: "insert",
-  defaultBinding: { kind: "drag" },
   eligible: { capability: "creates-shapes" },
   requires: ["insert", "selection", "snap", "textEdit"],
   invoker: {
@@ -9788,7 +10163,9 @@ function freshNodeId() {
 var cloneAction = {
   id: "clone",
   label: "Clone",
-  defaultBinding: { kind: "drag" },
+  // No default binding: a bare `{ kind: 'drag' }` would clone a non-empty
+  // selection on any drag no tool claimed. Alt-drag on a body binds it
+  // (`selectionMoveBindings`, the `move` preset).
   // The platform's duplicate cursor, and the whole reason this field is
   // modifier-aware: the select tool binds clone behind `mods: { alt: true }`,
   // so the pump predicts it — and shows this — only while Alt is down.
@@ -9924,7 +10301,6 @@ var viewportDragPanAction = {
   id: "viewport.dragPan",
   label: "Drag to pan viewport",
   group: "viewport",
-  defaultBinding: { kind: "drag" },
   // Hover hint: when this action would win the drag at the hovered point
   // (e.g. empty canvas with no marquee-capable tool ahead of it), the
   // hover-cursor pump shows the open hand.
@@ -10178,20 +10554,9 @@ function cubicPointAt(p0, p1, p2, p3, t) {
   return { x, y };
 }
 function splitCubicAtT(p0, p1, p2, p3, t) {
-  const lerp = (a, b) => ({
-    x: a.x + (b.x - a.x) * t,
-    y: a.y + (b.y - a.y) * t
-  });
-  const q0 = lerp(p0, p1);
-  const q1 = lerp(p1, p2);
-  const q2 = lerp(p2, p3);
-  const r0 = lerp(q0, q1);
-  const r1 = lerp(q1, q2);
-  const s0 = lerp(r0, r1);
-  return {
-    left: [p0, q0, r0, s0],
-    right: [s0, r1, q2, p3]
-  };
+  const [l, r] = splitCubicAt(p0.x, p0.y, p1.x, p1.y, p2.x, p2.y, p3.x, p3.y, t);
+  const quad = (c) => [{ x: c[0], y: c[1] }, { x: c[2], y: c[3] }, { x: c[4], y: c[5] }, { x: c[6], y: c[7] }];
+  return { left: quad(l), right: quad(r) };
 }
 function fitCubicThroughDeletion(prev, next) {
   const dx = next.x - prev.x;
@@ -10333,59 +10698,11 @@ function segmentEnds(anchors, closed, sub2, segIdx) {
 function isStraightSegment(a, b) {
   return a.outHandle == null && b.inHandle == null;
 }
-var COARSE_SAMPLES = 32;
-var REFINE_STEPS = 48;
-var GOLDEN = (Math.sqrt(5) - 1) / 2;
 function nearestOnSegment(a, b, x, y) {
-  if (isStraightSegment(a, b)) {
-    const dx = b.x - a.x;
-    const dy = b.y - a.y;
-    const len2 = dx * dx + dy * dy;
-    const t2 = len2 === 0 ? 0 : Math.min(1, Math.max(0, ((x - a.x) * dx + (y - a.y) * dy) / len2));
-    const ex = a.x + dx * t2 - x;
-    const ey = a.y + dy * t2 - y;
-    return { t: t2, d2: ex * ex + ey * ey };
-  }
   const p1 = a.outHandle ?? a;
   const p2 = b.inHandle ?? b;
-  const d2At = (t2) => {
-    const q = cubicPointAt(a, p1, p2, b, t2);
-    return (q.x - x) ** 2 + (q.y - y) ** 2;
-  };
-  let bestT = 0;
-  let bestD2 = Infinity;
-  for (let k = 0; k <= COARSE_SAMPLES; k++) {
-    const t2 = k / COARSE_SAMPLES;
-    const d22 = d2At(t2);
-    if (d22 < bestD2) {
-      bestD2 = d22;
-      bestT = t2;
-    }
-  }
-  let lo = Math.max(0, bestT - 1 / COARSE_SAMPLES);
-  let hi = Math.min(1, bestT + 1 / COARSE_SAMPLES);
-  let m1 = hi - GOLDEN * (hi - lo);
-  let m2 = lo + GOLDEN * (hi - lo);
-  let f1 = d2At(m1);
-  let f2 = d2At(m2);
-  for (let i = 0; i < REFINE_STEPS; i++) {
-    if (f1 < f2) {
-      hi = m2;
-      m2 = m1;
-      f2 = f1;
-      m1 = hi - GOLDEN * (hi - lo);
-      f1 = d2At(m1);
-    } else {
-      lo = m1;
-      m1 = m2;
-      f1 = f2;
-      m2 = lo + GOLDEN * (hi - lo);
-      f2 = d2At(m2);
-    }
-  }
-  const t = (lo + hi) / 2;
-  const d2 = d2At(t);
-  return d2 < bestD2 ? { t, d2 } : { t: bestT, d2: bestD2 };
+  const hit = isStraightSegment(a, b) ? nearestOnLine(x, y, a.x, a.y, b.x, b.y) : nearestOnCubic(x, y, a.x, a.y, p1.x, p1.y, p2.x, p2.y, b.x, b.y);
+  return { t: hit.t, d2: hit.dist * hit.dist };
 }
 function nearestSegmentT(anchors, wx, wy, closed) {
   let bestD2 = Infinity;
@@ -10738,6 +11055,48 @@ var editAnchorsAction = {
   },
   enabled: () => true
 };
+var LASSO_VERTICES = scratchKey("lassoSelect.vertices");
+var MIN_AREA = 4;
+function selectFromLasso(opts) {
+  const mode = opts?.mode ?? "intersect";
+  return {
+    defaultTransient: true,
+    onEnd(ctx) {
+      const adapter = ctx.adapter;
+      if (!adapter.getSelection || !adapter.hitTestLasso) return null;
+      const vertices = getScratch(ctx.scratch, LASSO_VERTICES) ?? [];
+      const startPose = ctx.origin.get("gesture");
+      const shiftHeld = startPose ? startPose.shiftHeld === true : false;
+      const from = adapter.getSelection();
+      const tiny = vertices.length < 3 || polygonAabbArea(vertices) < MIN_AREA;
+      if (tiny) {
+        const to2 = shiftHeld ? from : [];
+        const op2 = createSetSelectionOp({ from, to: to2 });
+        return [op2];
+      }
+      const hits = adapter.hitTestLasso(vertices, mode);
+      const to = shiftHeld ? mergeUnique(from, hits) : hits;
+      const op = createSetSelectionOp({ from, to });
+      return [op];
+    }
+  };
+}
+function polygonAabbArea(vertices) {
+  if (vertices.length === 0) return 0;
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const v of vertices) {
+    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 (maxX - minX) * (maxY - minY);
+}
+function mergeUnique(a, b) {
+  const out = [...a];
+  for (const id of b) if (!out.includes(id)) out.push(id);
+  return out;
+}
 
 // src/interactions/actions/defaults/lassoSelect.ts
 function polygonAABB(pts) {
@@ -10751,26 +11110,68 @@ function polygonAABB(pts) {
   }
   return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
 }
-var MIN_VERTEX_SPACING = 2;
+function hitTestPolygon(dep, vertices, mode, view) {
+  if (dep.hitTestLasso) return dep.hitTestLasso(vertices, mode, view);
+  const aabb = polygonAABB(vertices);
+  return aabb ? dep.hitTestArea(aabb, view) : [];
+}
+function behaviorAdapter(dep, view) {
+  const adapter = {
+    getSelection: () => dep.getSelection(),
+    setSelection: (ids) => dep.setSelection(ids),
+    hitTestArea: (rect) => dep.hitTestArea(rect, view),
+    hitTestLasso: (polygon, mode) => hitTestPolygon(dep, polygon, mode, view),
+    applyOps: (ops) => applyOpsTo(adapter, ops)
+  };
+  return adapter;
+}
+var DEFAULT_MIN_VERTEX_SPACING = 2;
 var lassoSelectAction = {
   id: "lassoSelect",
   label: "Lasso Select",
-  defaultBinding: { kind: "drag", mods: { shift: "optional" } },
   eligible: { capability: "creates-selection" },
   requires: ["lassoSelect", "view"],
   invoker: {
     timing: "ongoing",
-    start(ctx, _opts) {
+    start(ctx, opts) {
       const dep = ctx.deps.lassoSelect;
       if (!dep) return {};
+      const params = resolveParams(opts?.params);
+      const view = ctx.deps.view;
+      const vertices = [{ x: ctx.world.x, y: ctx.world.y }];
+      const behaviors = opts?.behaviors ?? [];
+      let gesture = null;
+      if (behaviors.length > 0) {
+        const pose = {
+          worldX: ctx.world.x,
+          worldY: ctx.world.y,
+          shiftHeld: ctx.modifiers.shift
+        };
+        gesture = {
+          draggedIds: ["gesture"],
+          origin: /* @__PURE__ */ new Map([["gesture", pose]]),
+          current: /* @__PURE__ */ new Map([["gesture", { ...pose }]]),
+          snap: null,
+          modifiers: { ...ctx.modifiers },
+          pointer: { worldX: ctx.world.x, worldY: ctx.world.y, clientX: 0, clientY: 0 },
+          adapter: behaviorAdapter(dep, view),
+          scratch: {}
+        };
+        setScratch(gesture.scratch, LASSO_VERTICES, vertices);
+        for (const b of behaviors) b.onStart?.(gesture);
+      }
       const scratch = {
         dep,
-        view: ctx.deps.view,
-        vertices: [{ x: ctx.world.x, y: ctx.world.y }],
+        mode: params?.mode ?? "intersect",
+        minVertexSpacing: params?.minVertexSpacing ?? DEFAULT_MIN_VERTEX_SPACING,
+        view,
+        vertices,
         shiftHeld: ctx.modifiers.shift,
         currentX: ctx.world.x,
         currentY: ctx.world.y,
-        open: true
+        open: true,
+        behaviors,
+        gesture
       };
       return {
         kind: "lasso",
@@ -10781,9 +11182,18 @@ var lassoSelectAction = {
           const last = scratch.vertices[scratch.vertices.length - 1];
           const dx = x - last.x;
           const dy = y - last.y;
-          if (dx * dx + dy * dy >= MIN_VERTEX_SPACING * MIN_VERTEX_SPACING) {
+          const min = scratch.minVertexSpacing;
+          if (dx * dx + dy * dy >= min * min) {
             scratch.vertices.push({ x, y });
           }
+          const g = scratch.gesture;
+          if (g) {
+            g.modifiers = { ...moveCtx.modifiers };
+            g.pointer = { worldX: x, worldY: y, clientX: 0, clientY: 0 };
+            g.current.set("gesture", { worldX: x, worldY: y, shiftHeld: scratch.shiftHeld });
+            const proposed = { vertices: scratch.vertices, shiftHeld: scratch.shiftHeld };
+            for (const b of scratch.behaviors) b.onMove?.(g, proposed);
+          }
         },
         overlay() {
           if (!scratch.open) return null;
@@ -10797,18 +11207,20 @@ var lassoSelectAction = {
         onEnd(_endCtx, reason) {
           scratch.open = false;
           if (reason === "cancel") return;
-          const { dep: d, view, vertices, shiftHeld } = scratch;
-          if (vertices.length < 3) {
+          const { dep: d, mode, view: view2, vertices: vertices2, shiftHeld, gesture: g } = scratch;
+          if (g) {
+            for (const b of scratch.behaviors) {
+              const r = b.onEnd?.(g);
+              if (r === void 0) continue;
+              if (r !== null) g.adapter.applyOps(r);
+              return;
+            }
+          }
+          if (vertices2.length < 3) {
             if (!shiftHeld) d.setSelection([]);
             return;
           }
-          let hits;
-          if (d.hitTestLasso) {
-            hits = d.hitTestLasso(vertices, "centers", view);
-          } else {
-            const aabb = polygonAABB(vertices);
-            hits = aabb ? d.hitTestArea(aabb, view) : [];
-          }
+          const hits = hitTestPolygon(d, vertices2, mode, view2);
           if (shiftHeld) {
             const current = d.getSelection();
             const merged = [...current];
@@ -10829,7 +11241,6 @@ var sliceAction = {
   id: "slice",
   label: "Slice",
   group: "edit",
-  defaultBinding: { kind: "drag" },
   eligible: { capability: "edits-page" },
   requires: ["slice"],
   invoker: {
@@ -11225,9 +11636,13 @@ var escapeAction = {
   // `exitPathEdit`'s bare key spec, swallowing the Escape that should leave
   // edit mode. With this gate, `escape` reports a disabled reason in that
   // case and the dispatcher falls through to `exitPathEdit`.
+  // With nothing selected there is nothing to clear, so the press falls
+  // through to `tool.resetToDefault` instead of being spent here.
   enabled: (deps) => {
     const editAnchors = deps?.editAnchors;
     if (editAnchors?.editingId) return ActionDisabledReason.NotApplicable;
+    const sel = deps?.selection?.get() ?? [];
+    if (sel.length === 0) return ActionDisabledReason.NotApplicable;
     return true;
   }
 };
@@ -13666,12 +14081,27 @@ function useResizePolicy(options) {
   useDepSource("resizePolicy", () => {
     const o = optsRef.current;
     return {
+      label: o.label,
+      transient: o.transient,
+      onGestureStart: o.onGestureStart,
+      onGestureEnd: o.onGestureEnd,
       constraints: o.constraints ?? DEFAULT_RESIZE_BEHAVIORS,
       pointSnap: o.pointSnap ?? EMPTY2,
       expandIds: o.expandIds ?? IDENTITY_EXPAND2
     };
   });
 }
+function resizePolicyOptions(o) {
+  return {
+    constraints: o.behaviors,
+    pointSnap: o.pointSnapBehaviors,
+    expandIds: o.expandIds,
+    label: o.resizeLabel,
+    transient: o.transient,
+    onGestureStart: o.onGestureStart,
+    onGestureEnd: o.onGestureEnd
+  };
+}
 function usePoseDescriptorDepSource(descriptor) {
   const ref = useRef(descriptor);
   ref.current = descriptor;
@@ -13816,63 +14246,6 @@ function useDecayLoop() {
   }, [cancel]);
   return { start, cancel };
 }
-function dist(a, b) {
-  return Math.hypot(b.x - a.x, b.y - a.y);
-}
-function mid(a, b) {
-  return { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
-}
-function usePinchGesture(canvasRef, onPinch, enabled = true) {
-  const onPinchRef = useRef(onPinch);
-  onPinchRef.current = onPinch;
-  useEffect(() => {
-    if (!enabled) return;
-    const el = canvasRef.current;
-    if (!el) return;
-    const pointers = /* @__PURE__ */ new Map();
-    let startDist = null;
-    function getTwo() {
-      const vals = [...pointers.values()];
-      if (vals.length < 2) return null;
-      return [vals[0], vals[1]];
-    }
-    function onDown(e) {
-      pointers.set(e.pointerId, { x: e.clientX, y: e.clientY });
-      const two = getTwo();
-      if (two) startDist = dist(two[0], two[1]);
-    }
-    function onMove(e) {
-      if (!pointers.has(e.pointerId)) return;
-      pointers.set(e.pointerId, { x: e.clientX, y: e.clientY });
-      const two = getTwo();
-      if (!two || startDist === null) return;
-      const currentDist = dist(two[0], two[1]);
-      const anchor = mid(two[0], two[1]);
-      const factor = currentDist / startDist;
-      startDist = currentDist;
-      onPinchRef.current(anchor, factor);
-    }
-    function onUp(e) {
-      pointers.delete(e.pointerId);
-      if (pointers.size < 2) {
-        startDist = null;
-      } else {
-        const two = getTwo();
-        if (two) startDist = dist(two[0], two[1]);
-      }
-    }
-    el.addEventListener("pointerdown", onDown);
-    el.addEventListener("pointermove", onMove);
-    el.addEventListener("pointerup", onUp);
-    el.addEventListener("pointercancel", onUp);
-    return () => {
-      el.removeEventListener("pointerdown", onDown);
-      el.removeEventListener("pointermove", onMove);
-      el.removeEventListener("pointerup", onUp);
-      el.removeEventListener("pointercancel", onUp);
-    };
-  }, [canvasRef, enabled]);
-}
 
 // src/core/viewport/interpolateView.ts
 function axisCurve(x0, s0, x1, s1) {
@@ -14396,9 +14769,9 @@ function firstAfter(events, t) {
   let lo = 0;
   let hi = events.length;
   while (lo < hi) {
-    const mid2 = lo + hi >> 1;
-    if (events[mid2].t > t) hi = mid2;
-    else lo = mid2 + 1;
+    const mid = lo + hi >> 1;
+    if (events[mid].t > t) hi = mid;
+    else lo = mid + 1;
   }
   return lo;
 }
@@ -14526,12 +14899,12 @@ function floorKeyIndex(keys, t) {
   let hi = keys.length - 1;
   let found = -1;
   while (lo <= hi) {
-    const mid2 = lo + hi >> 1;
-    if (keys[mid2].t <= t) {
-      found = mid2;
-      lo = mid2 + 1;
+    const mid = lo + hi >> 1;
+    if (keys[mid].t <= t) {
+      found = mid;
+      lo = mid + 1;
     } else {
-      hi = mid2 - 1;
+      hi = mid - 1;
     }
   }
   return found;
@@ -15267,12 +15640,6 @@ function useViewAnimationOn(view, animator) {
     };
   }, [key]);
 }
-function defineTool(def) {
-  return defineTool$1(def);
-}
-function defineViewportTool(def) {
-  return defineViewportTool$1(def);
-}
 var useTools = useTools$1;
 
 // src/interactions/actions/defaults/toolActivate.ts
@@ -15359,6 +15726,7 @@ function useKeybindings(tools, options = {}) {
   useEffect(() => {
     if (optionsRef.current.disable) return;
     if (!registry2) return;
+    if (Object.keys(toolsRef.current.registry).length === 0) return;
     const specs = [];
     for (const [toolId, keyOpts] of Object.entries(BUILTIN_SELECT_KEYS)) {
       if (toolsRef.current.has(toolId)) {
@@ -15398,8 +15766,6 @@ function useKeybindings(tools, options = {}) {
     };
   }, [registry2, tools]);
 }
-
-// src/tools/prefs.ts
 function prefUnit(system, display, opts) {
   let self;
   try {
@@ -15726,13 +16092,19 @@ function UnknownIcon({ className, size = 20 }) {
     }
   );
 }
-function closedSubpaths(path, tolerance) {
+function closedSubpaths(path, tolerance, keepOpen = false) {
+  const { closed, open } = flatSubpaths(path, tolerance);
+  return keepOpen ? [...closed, ...open] : closed;
+}
+function flatSubpaths(path, tolerance) {
   const { commands, coords } = path;
-  const out = [];
+  const closed = [];
+  const open = [];
   let sub2 = [];
   forEachSegment(commands, coords, (cmd, ci, curX, curY) => {
     switch (cmd) {
       case PATH_M:
+        if (sub2.length >= 2) open.push(sub2);
         sub2 = [coords[ci], coords[ci + 1]];
         break;
       case PATH_L:
@@ -15765,14 +16137,16 @@ function closedSubpaths(path, tolerance) {
         );
         break;
       case PATH_Z:
-        if (sub2.length >= 6) out.push(sub2);
+        if (sub2.length >= 6) closed.push(sub2);
+        else if (sub2.length >= 2) open.push(sub2);
         sub2 = [];
         break;
       default:
         throw new Error(`pathHitTest: unknown command ${cmd}`);
     }
   });
-  return out;
+  if (sub2.length >= 2) open.push(sub2);
+  return { closed, open };
 }
 function rectToVerts(r) {
   return [
@@ -15830,6 +16204,18 @@ function anyEdgeCrossesPolygon(subpaths, poly2) {
     return false;
   });
 }
+function anyOpenEdgeCrossesPolygon(runs, poly2) {
+  for (const run2 of runs) {
+    for (let i = 0; i + 3 < run2.length; i += 2) {
+      const ax = run2[i], ay = run2[i + 1], bx = run2[i + 2], by = run2[i + 3];
+      for (let k = 0; k < poly2.length; k++) {
+        const p0 = poly2[k], p1 = poly2[(k + 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) {
@@ -15903,128 +16289,34 @@ function pathIntersectsPolygon(path, polygon, opts = {}) {
   if (anyVertexInPolygon(subpaths, flattenVerts(polygon))) return true;
   return anyEdgeCrossesPolygon(subpaths, polygon);
 }
-
-// src/features/paths/markerSites.ts
-var EPS2 = 1e-9;
-function dir(pl, i, j) {
-  const dx = pl.points[j * 2] - pl.points[i * 2];
-  const dy = pl.points[j * 2 + 1] - pl.points[i * 2 + 1];
-  const len = Math.hypot(dx, dy);
-  if (len < EPS2) return null;
-  return { x: dx / len, y: dy / len };
-}
-function nextDistinct(pl, i, n) {
-  for (let k = i + 1; k < n; k++) if (dir(pl, i, k)) return k;
-  return -1;
+function polygonContainsPath(polygon, path, opts = {}) {
+  if (polygon.length < 3) return false;
+  const subpaths = path.kind === "rect" ? [flattenVerts(rectToVerts(path))] : closedSubpaths(path, opts.tolerance ?? DEFAULT_FLATTEN_TOLERANCE, true);
+  if (subpaths.length === 0) return false;
+  const flatPoly = flattenVerts(polygon);
+  for (const sub2 of subpaths) {
+    for (let i = 0; i < sub2.length; i += 2) {
+      if (!pointInPolygon(flatPoly, sub2[i], sub2[i + 1])) return false;
+    }
+  }
+  return !anyEdgeCrossesPolygon(subpaths, polygon);
 }
-function prevDistinct(pl, i) {
-  for (let k = i - 1; k >= 0; k--) if (dir(pl, k, i)) return k;
-  return -1;
+function polygonIntersectsPath(polygon, path, opts = {}) {
+  if (polygon.length < 3) return false;
+  if (path.kind === "rect") return polygonsIntersect(rectToVerts(path), polygon);
+  const { closed, open } = flatSubpaths(path, opts.tolerance ?? DEFAULT_FLATTEN_TOLERANCE);
+  const flatPoly = flattenVerts(polygon);
+  if (anyVertexInPolygon(closed, flatPoly) || anyVertexInPolygon(open, flatPoly)) return true;
+  if (anyEdgeCrossesPolygon(closed, polygon) || anyOpenEdgeCrossesPolygon(open, polygon)) {
+    return true;
+  }
+  return closed.length > 0 && pointInPath(path, polygon[0].x, polygon[0].y, opts);
 }
-function markerSites(pl, want) {
-  const out = [];
-  const n = pl.points.length / 2;
-  if (n < 2) return out;
-  if (want.start && !pl.closed) {
-    const j = nextDistinct(pl, 0, n);
-    const d = j >= 0 ? dir(pl, 0, j) : null;
-    if (d) {
-      out.push({ x: pl.points[0], y: pl.points[1], angle: Math.atan2(-d.y, -d.x), role: "start" });
-    }
-  }
-  if (want.mid) {
-    const A = pl.anchorA, B = pl.anchorB, T = pl.anchorT;
-    if (A && B && T) {
-      for (let i = 1; i < n - 1; i++) {
-        if (A[i] !== B[i] || T[i] !== 0) continue;
-        const p = prevDistinct(pl, i);
-        const q = nextDistinct(pl, i, n);
-        if (p < 0 || q < 0) continue;
-        const inDir = dir(pl, p, i);
-        const outDir = dir(pl, i, q);
-        let bx = inDir.x + outDir.x;
-        let by = inDir.y + outDir.y;
-        if (Math.hypot(bx, by) < EPS2) {
-          bx = inDir.x;
-          by = inDir.y;
-        }
-        out.push({ x: pl.points[i * 2], y: pl.points[i * 2 + 1], angle: Math.atan2(by, bx), role: "mid" });
-      }
-    }
-  }
-  if (want.end && !pl.closed) {
-    const last = n - 1;
-    const p = prevDistinct(pl, last);
-    const d = p >= 0 ? dir(pl, p, last) : null;
-    if (d) {
-      out.push({ x: pl.points[last * 2], y: pl.points[last * 2 + 1], angle: Math.atan2(d.y, d.x), role: "end" });
-    }
-  }
-  return out;
-}
-
-// src/features/paths/markerCommands.ts
-function placed(path, site) {
-  const src = path;
-  const cos = Math.cos(site.angle);
-  const sin = Math.sin(site.angle);
-  const coords = new Float32Array(src.coords.length);
-  for (let i = 0; i < src.coords.length; i += 2) {
-    const x = src.coords[i], y = src.coords[i + 1];
-    coords[i] = site.x + x * cos - y * sin;
-    coords[i + 1] = site.y + x * sin + y * cos;
-  }
-  return { kind: "polygon", commands: src.commands, coords, fillRule: src.fillRule };
-}
-function resolvePaint(p, stroke, fallback) {
-  const v = p ?? fallback;
-  if (v === "none") return void 0;
-  return v === "line" ? stroke.paint : v;
-}
-function commandFor(entry, ref, stroke, strokeWidth, site) {
-  const size = resolveMarkerSize(ref, strokeWidth);
-  const geometry = entry.path({ size, stroke });
-  const angle = entry.orient === void 0 || entry.orient === "auto" ? site.angle : entry.orient;
-  const path = placed(geometry, { ...site, angle });
-  const fill = resolvePaint(entry.fill, stroke, "line");
-  const outline = entry.outline ? {
-    paint: resolvePaint(entry.outline.paint, stroke, "line"),
-    width: entry.outline.width * size
-  } : null;
-  if (fill === void 0 && (outline === null || outline.paint === void 0)) return null;
-  return {
-    kind: "path",
-    path,
-    ...fill ? { fill } : {},
-    ...outline && outline.paint ? { stroke: { paint: outline.paint, width: outline.width, cap: "round", join: "round" } } : {}
-  };
-}
-function markerDrawCommands(path, stroke, strokeWidth, flattenTolerance) {
-  const want = {
-    start: stroke.markerStart !== void 0,
-    mid: stroke.markerMid !== void 0,
-    end: stroke.markerEnd !== void 0
-  };
-  if (!want.start && !want.mid && !want.end) return [];
-  const refFor = (role) => role === "start" ? stroke.markerStart : role === "mid" ? stroke.markerMid : stroke.markerEnd;
-  const out = [];
-  for (const pl of extractPolylines(path, { flattenTolerance })) {
-    for (const site of markerSites(pl, want)) {
-      const ref = refFor(site.role);
-      if (ref === void 0) continue;
-      const entry = getMarker(markerKeyOf(ref));
-      if (entry === void 0) continue;
-      const cmd = commandFor(entry, ref, stroke, strokeWidth, site);
-      if (cmd) out.push(cmd);
-    }
-  }
-  return out;
-}
-
-// src/core/fillInPoseFrame.ts
-function fillInPoseFrame(fill, box) {
-  if (!isBuiltinKind(fill)) {
-    return getPaintKind(fill.fill)?.inPoseFrame?.(fill, box) ?? fill;
+
+// src/core/fillInPoseFrame.ts
+function fillInPoseFrame(fill, box) {
+  if (!isBuiltinKind(fill)) {
+    return getPaintKind(fill.fill)?.inPoseFrame?.(fill, box) ?? fill;
   }
   if (isBoundsPattern(fill)) {
     const o = fill.origin ?? { x: 0, y: 0 };
@@ -16434,11 +16726,7 @@ function strokeInPoseFrame(stroke, box) {
 function inkReach(stroke, scale) {
   if (stroke === null) return { outset: 0, inset: 0 };
   const w = resolveStrokeWidth(stroke.width ?? 1, scale ?? 1);
-  const reach = Math.max(
-    markerInset(stroke.markerStart, w),
-    markerInset(stroke.markerEnd, w),
-    markerInset(stroke.markerMid, w)
-  );
+  const reach = markerReach(stroke, w, scale);
   switch (stroke.align ?? "center") {
     case "inner":
       return { outset: reach, inset: w };
@@ -16490,9 +16778,7 @@ var PATH_PAINTER = {
       ...fill && d.vertexColors ? { vertexColors: d.vertexColors } : {},
       ...stroke ? { stroke } : {}
     };
-    if (!stroke) return [cmd];
-    const width = resolveStrokeWidth(stroke.width ?? 1, 1);
-    return [cmd, ...markerDrawCommands(projected, stroke, width, void 0)];
+    return [cmd];
   }), ctx),
   silhouette: (node, pose) => {
     const d = node.data;
@@ -16657,9 +16943,7 @@ var DERIVED_PAINTER = {
       ...fill && d?.vertexColors ? { vertexColors: d.vertexColors } : {},
       ...stroke ? { stroke } : {}
     };
-    if (!stroke) return withAnimatedVertexColors([cmd], ctx);
-    const width = resolveStrokeWidth(stroke.width ?? 1, 1);
-    return withAnimatedVertexColors([cmd, ...markerDrawCommands(path, stroke, width, void 0)], ctx);
+    return withAnimatedVertexColors([cmd], ctx);
   },
   // The derived path *is* the silhouette, and it is already absolute — the
   // pose is a placeholder, so nothing here can be recovered from it. Without
@@ -17010,6 +17294,103 @@ function zOf(getZIndex, id) {
   const z = getZIndex(id);
   return typeof z === "number" && Number.isFinite(z) ? z : -Infinity;
 }
+var SELECTION_MOVE_ID = "selection.move";
+var SELECTION_TRANSFORM_ID = "selection.transform";
+function selectionMoveBindings(options = {}) {
+  const moveOpts = (() => {
+    const move = options.move ?? {};
+    const params = gestureLifecycleParams({ ...move, label: move.moveLabel });
+    if (options.reparentOnDrop && options.reparentOnDrop !== "off") params.reparentOnDrop = options.reparentOnDrop;
+    if (move.dragThresholdPx !== void 0) params.dragThresholdPx = move.dragThresholdPx;
+    if (move.expandIds) params.expandIds = move.expandIds;
+    const withParams = Object.keys(params).length > 0 ? { params } : void 0;
+    const behaviors = options.move?.behaviors?.length ? { behaviors: options.move.behaviors } : void 0;
+    return withParams || behaviors ? { opts: { ...withParams, ...behaviors } } : {};
+  })();
+  return [
+    // Alt-drag on a body → clone (Illustrator convention).
+    // Listed BEFORE bare move so the strict-modifier dispatcher
+    // picks this when Alt is held; bare move matches no-mod drags.
+    // Both selected and unselected bodies are valid clone targets — the
+    // select tool's pointerDown classifier calls `selection.applyClick(top, mods)`
+    // on an unselected hit before the drag fires, so cloneAction's
+    // `start` sees the hit node in `selection.get()` either way.
+    { spec: { kind: "drag", target: "selected-body", mods: { alt: true } }, actionId: "clone" },
+    { spec: { kind: "drag", target: "unselected-body", mods: { alt: true } }, actionId: "clone" },
+    {
+      // Body-drag → move, BUT defer when the pointerdown hit a path
+      // anchor / control affordance. Anchors lie on the curve so the
+      // body classifier still reports 'selected-body'; without this
+      // opt-out, move's binding beats editAnchors's on every anchor drag.
+      //
+      // `isAnchorOrControl` is the SAME predicate `editAnchorsAction`
+      // matches on. That is load-bearing: the two must agree on what
+      // counts as an anchor hit or move steals the drag — which is
+      // exactly the bug this opt-out exists to prevent.
+      spec: {
+        kind: "drag",
+        target: {
+          kindOf: (afford, body) => body === "selected-body" && !isAnchorOrControl(afford)
+        }
+      },
+      actionId: "move",
+      ...moveOpts
+    },
+    // Body-drag on a NOT-yet-selected node → also move. The select tool's
+    // pointerDown classifier selects the hit node before the drag fires (same
+    // contract clone relies on), so by the time moveAction.start() runs the
+    // node is in `selection.get()`. Without this binding an unselected-body
+    // drag falls through to whatever ambient drag binding comes next — once
+    // the `rotate` catch-all, which made the first drag rotate and later ones
+    // move. Unselected nodes never carry anchor affordances (those gate on
+    // selection), so the plain string-form target is sufficient here.
+    {
+      spec: { kind: "drag", target: "unselected-body" },
+      actionId: "move",
+      ...moveOpts
+    }
+  ];
+}
+function selectionTransformBindings(options = {}) {
+  const rotate2 = options.rotate ?? {};
+  const params = gestureLifecycleParams({ ...rotate2, label: rotate2.rotateLabel });
+  if (rotate2.pivot) params.pivot = rotate2.pivot;
+  const opts = {
+    ...Object.keys(params).length > 0 ? { params } : {},
+    ...rotate2.behaviors?.length ? { behaviors: rotate2.behaviors } : {}
+  };
+  return [
+    { spec: { kind: "drag", target: { kindOf: isResizeHandle } }, actionId: "resize" },
+    {
+      spec: { kind: "drag", target: { kindOf: isRotateHandle } },
+      actionId: "rotate",
+      ...Object.keys(opts).length > 0 ? { opts } : {}
+    }
+  ];
+}
+function selectionMoveContribution(options = {}) {
+  return {
+    id: SELECTION_MOVE_ID,
+    eligibility: { always: true },
+    bindings: selectionMoveBindings(options)
+  };
+}
+function selectionTransformContribution(options = {}) {
+  return {
+    id: SELECTION_TRANSFORM_ID,
+    eligibility: { always: true },
+    bindings: selectionTransformBindings(options)
+  };
+}
+var AREA_SELECT_ID = "selection.areaSelect";
+var onEmptyCanvas = (hit, body) => hit == null && body === "empty";
+function areaSelectContribution() {
+  return {
+    id: AREA_SELECT_ID,
+    eligibility: { always: true },
+    bindings: [{ spec: { kind: "drag", target: { kindOf: onEmptyCanvas } }, actionId: "areaSelect" }]
+  };
+}
 
 // src/core/selection/selectionTarget.ts
 var MULTI_RESIZE_TARGET_ID = "__weasel:multi-selection";
@@ -17136,21 +17517,14 @@ function useSelectTool(adapter, options) {
         },
         actions: [pickAction, collapseDeferredAction]
       });
-      const moveOpts = (() => {
-        const reparent = options.reparentOnDrop && options.reparentOnDrop !== "off" ? { params: { reparentOnDrop: options.reparentOnDrop } } : void 0;
-        const behaviors = options.move?.behaviors?.length ? { behaviors: options.move.behaviors } : void 0;
-        return reparent || behaviors ? { opts: { ...reparent, ...behaviors } } : {};
-      })();
       return {
         ...base,
-        // Declarative bindings for the gesture dispatcher.
-        // Binding priority (first match wins):
-        //   0. Press → classify + select (runs before click/drag classification).
-        //   1. Handle drags (resize) — guard on AffordanceHit kind.
-        //   2. Rotate-handle drag — single-selection rotation.
-        //   3. Body drag (selected OR unselected) — move the selection.
-        //   4. Empty drag — marquee area-select.
-        //   5. Click on empty (no modifiers) → clear selection.
+        // Declarative bindings for the gesture dispatcher. The select tool
+        // only chooses: press → classify + select, release → collapse a
+        // deferred multi-click, empty drag → marquee, click on empty → clear.
+        // Moving, cloning, resizing and rotating the selection are ambient
+        // bindings owned by the selection (`selectionContributions.ts`), so
+        // they run under any tool that leaves the gesture unclaimed.
         bindings: [
           // Every press that landed on the scene rather than on chrome. This
           // is the former `initial.pointerDown['*']` route: it classifies the
@@ -17190,55 +17564,13 @@ function useSelectTool(adapter, options) {
             },
             actionId: "select.collapseDeferred"
           },
-          { spec: { kind: "drag", target: { kindOf: isResizeHandle } }, actionId: "resize" },
-          { spec: { kind: "drag", target: { kindOf: isRotateHandle } }, actionId: "rotate" },
-          // Alt-drag on a body → clone (Illustrator convention).
-          // Listed BEFORE bare move so the strict-modifier dispatcher
-          // picks this when Alt is held; bare move matches no-mod drags.
-          // Both selected and unselected bodies are valid clone targets — the
-          // pointerDown classifier calls `selection.applyClick(top, mods)` on
-          // an unselected hit before the drag fires, so cloneAction's
-          // `start` sees the hit node in `selection.get()` either way.
-          { spec: { kind: "drag", target: "selected-body", mods: { alt: true } }, actionId: "clone" },
-          { spec: { kind: "drag", target: "unselected-body", mods: { alt: true } }, actionId: "clone" },
+          // Empty drag → marquee. `onEmptyCanvas` rather than a bare `'empty'`
+          // target: the ambient bindings that own the handles rank below this
+          // active one, so `'empty'` took drags that start on them.
           {
-            // Body-drag → move, BUT defer when the pointerdown hit a path
-            // anchor / control affordance. Anchors lie on the curve so the
-            // body classifier still reports 'selected-body'; without this
-            // opt-out, move's active-scope binding beats editAnchors's
-            // ambient-scope binding on every anchor drag.
-            //
-            // `isAnchorOrControl` is the SAME predicate `editAnchorsAction`
-            // matches on. That is load-bearing: the two must agree on what
-            // counts as an anchor hit or move steals the drag — which is
-            // exactly the bug this opt-out exists to prevent. (It used to be
-            // a hand-rolled regex here that lacked the trailing-index
-            // requirement, so the two sides could disagree.)
-            spec: {
-              kind: "drag",
-              target: {
-                kindOf: (afford, body) => body === "selected-body" && !isAnchorOrControl(afford)
-              }
-            },
-            actionId: "move",
-            ...moveOpts
-          },
-          // Body-drag on a NOT-yet-selected node → also move. The pointerDown
-          // classifier selects the hit node before the drag fires (same
-          // contract clone relies on), so by the time moveAction.start() runs
-          // the node is in `selection.get()`. Without this active binding an
-          // unselected-body drag finds no active match and falls through to
-          // ambient scope, where the `rotate` catch-all (`{ kind: 'drag' }`,
-          // start()-guarded only on a non-empty selection) hijacks it — the
-          // "first drag rotates, later drags move" bug. Unselected nodes never
-          // carry anchor affordances (those gate on selection), so the plain
-          // string-form target is sufficient here.
-          {
-            spec: { kind: "drag", target: "unselected-body" },
-            actionId: "move",
-            ...moveOpts
+            spec: { kind: "drag", target: { kindOf: onEmptyCanvas } },
+            actionId: "areaSelect"
           },
-          { spec: { kind: "drag", target: "empty" }, actionId: "areaSelect" },
           // resize/rotate bind only drag (no click), so a click on either handle
           // (body genuinely empty) would hit target:'empty' and wrongly clear selection.
           {
@@ -17252,15 +17584,14 @@ function useSelectTool(adapter, options) {
         ]
       };
     },
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [options.debug, options.reparentOnDrop, options.move, pickAction, collapseDeferredAction]
+    [pickAction, collapseDeferredAction]
   );
 }
 function useHandTool(opts = {}) {
   const optsRef = useRef(opts);
   optsRef.current = opts;
   return useMemo(
-    () => Object.assign(defineViewportTool({
+    () => Object.assign(defineTool({
       id: "hand",
       capabilities: ["navigation"],
       hotkey: "space",
@@ -17290,6 +17621,20 @@ function useHandTool(opts = {}) {
     []
   );
 }
+
+// src/tools/builtin/hand/dragPanContribution.ts
+var DRAG_PAN_ID = "viewport.dragPanBinding";
+function dragPanContribution(params = {}) {
+  return {
+    id: DRAG_PAN_ID,
+    eligibility: { always: true },
+    bindings: [{
+      spec: { kind: "drag" },
+      actionId: "viewport.dragPan",
+      ...Object.keys(params).length > 0 ? { opts: { params: { ...params } } } : {}
+    }]
+  };
+}
 var PRESENTATION = {
   label: "Text",
   icon: createElement(TextIcon),
@@ -17336,14 +17681,19 @@ useTextTool.options = {
     underline: flag("Underline", "underline"),
     strikethrough: flag("Strikethrough", "strikethrough"),
     overline: flag("Overline", "overline"),
-    // Its own kind rather than an enum: the two values are exclusive *and*
-    // absent is a third state an enum cannot name, so clicking the lit
-    // segment has to clear it. The host draws it and owns that rule.
+    // Clearable: the two values are exclusive *and* absent is a third state,
+    // so clicking the lit segment turns the script off.
     script: {
-      kind: "script",
+      kind: "enum",
       name: "Script",
       description: "Raise or lower the range off the baseline, at a smaller size.",
-      default: void 0
+      control: "toggle",
+      clearable: true,
+      default: void 0,
+      options: [
+        { value: "super", label: "Superscript", icon: "superscript" },
+        { value: "sub", label: "Subscript", icon: "subscript" }
+      ]
     },
     textTransform: {
       kind: "enum",
@@ -18009,52 +18359,13 @@ function useLineTool() {
     []
   );
 }
-var LASSO_VERTICES = scratchKey("lassoSelect.vertices");
-var MIN_AREA = 4;
-function selectFromLasso(opts) {
-  const mode = opts?.mode ?? "intersect";
-  return {
-    defaultTransient: true,
-    onEnd(ctx) {
-      const adapter = ctx.adapter;
-      if (!adapter.getSelection || !adapter.hitTestLasso) return null;
-      const vertices = getScratch(ctx.scratch, LASSO_VERTICES) ?? [];
-      const startPose = ctx.origin.get("gesture");
-      const shiftHeld = startPose ? startPose.shiftHeld === true : false;
-      const from = adapter.getSelection();
-      const tiny = vertices.length < 3 || polygonAabbArea(vertices) < MIN_AREA;
-      if (tiny) {
-        const to2 = shiftHeld ? from : [];
-        const op2 = createSetSelectionOp({ from, to: to2 });
-        return [op2];
-      }
-      const hits = adapter.hitTestLasso(vertices, mode);
-      const to = shiftHeld ? mergeUnique(from, hits) : hits;
-      const op = createSetSelectionOp({ from, to });
-      return [op];
-    }
-  };
-}
-function polygonAabbArea(vertices) {
-  if (vertices.length === 0) return 0;
-  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
-  for (const v of vertices) {
-    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 (maxX - minX) * (maxY - minY);
-}
-function mergeUnique(a, b) {
-  const out = [...a];
-  for (const id of b) if (!out.includes(id)) out.push(id);
-  return out;
-}
-
-// src/tools/builtin/lasso/useLassoTool.ts
 function useLassoTool(_adapter, options = {}) {
-  void (options.behaviors ?? [selectFromLasso({ mode: options.mode ?? "intersect" })]);
+  const paramsRef = useRef({ mode: "intersect" });
+  paramsRef.current = {
+    mode: options.mode ?? "intersect",
+    ...options.minVertexSpacing !== void 0 ? { minVertexSpacing: options.minVertexSpacing } : {}
+  };
+  const { behaviors } = options;
   return useMemo(() => {
     return defineTool({
       id: "lasso",
@@ -18071,10 +18382,19 @@ function useLassoTool(_adapter, options = {}) {
       // dispatcher invokes `lassoSelectAction`, which owns vertex buffering,
       // overlay state, and the commit-on-end selection write.
       bindings: [
-        { spec: { kind: "drag", mods: { shift: "optional" } }, actionId: "lassoSelect" }
+        {
+          spec: { kind: "drag", mods: { shift: "optional" } },
+          actionId: "lassoSelect",
+          // Thunked so a mode or spacing change reaches the next gesture
+          // without rebuilding the tool.
+          opts: {
+            params: () => paramsRef.current,
+            ...behaviors ? { behaviors } : {}
+          }
+        }
       ]
     });
-  }, [options.keybinding]);
+  }, [options.keybinding, behaviors]);
 }
 var MIN_SIDES = 3;
 var MAX_SIDES = 32;
@@ -18324,7 +18644,7 @@ function isCustomEntry(v) {
 
 // src/canvas/layerOrder.ts
 var STANDARD_SLOT_SET = new Set(STANDARD_SLOTS);
-function composeOrderedLayers(layersMap, standardLayers, sceneLayers) {
+function composeOrderedLayers(layersMap, standardLayers, sceneLayers, background) {
   const afterByParent = /* @__PURE__ */ new Map();
   const beforeByParent = /* @__PURE__ */ new Map();
   const tail = [];
@@ -18346,7 +18666,7 @@ function composeOrderedLayers(layersMap, standardLayers, sceneLayers) {
     }
   }
   const emitted = /* @__PURE__ */ new Set();
-  const out = [];
+  const out = background ? [background] : [];
   function emitChild(child) {
     if (emitted.has(child.key)) {
       console.warn(`composeOrderedLayers: cycle detected involving custom layer "${child.key}"`);
@@ -18471,7 +18791,7 @@ function findMountedCanvas(root, hint) {
 function* toolsInPriorityOrder(tools) {
   const seen = /* @__PURE__ */ new Set();
   const hotkey = tools.hotkeyEngaged ? tools.registry[tools.hotkeyEngaged] : void 0;
-  const active = tools.registry[tools.active];
+  const active = tools.active === null ? void 0 : tools.registry[tools.active];
   for (const t of [hotkey, active]) {
     if (t && !seen.has(t)) {
       seen.add(t);
@@ -18532,22 +18852,17 @@ var EMPTY_CHROME_STATE = {
 };
 function buildChromeState(args) {
   const { selection, multiActive: multiActive2, effectiveBoundsOf, modifiers, canRotate } = args;
-  const cached = { value: null, computed: false };
   return {
     selection,
     multiActive: multiActive2,
     boundsOf: effectiveBoundsOf,
     modifiers,
     canRotate: canRotate ?? (() => true),
+    // Not cached: the state is memoized across renders, and poses move under
+    // it (a committed move, a live preview) without any of its inputs changing.
     get unionBounds() {
-      if (cached.computed) return cached.value;
-      cached.computed = true;
-      if (!multiActive2) {
-        cached.value = null;
-        return null;
-      }
-      cached.value = unionAABB(selection.map((id) => effectiveBoundsOf(id)));
-      return cached.value;
+      if (!multiActive2) return null;
+      return unionAABB(selection.map((id) => effectiveBoundsOf(id)));
     }
   };
 }
@@ -19413,7 +19728,7 @@ function pathFor(d) {
   }
   return p;
 }
-function commandFor2(op) {
+function commandFor(op) {
   return {
     kind: "path",
     path: pathFor(op.d),
@@ -19453,7 +19768,7 @@ function createPaintedCursorLayer(state) {
         at
       });
       const transform = new Float32Array([a, b, 0, c, d, 0, e, f, 1]);
-      const children = ops.map(commandFor2);
+      const children = ops.map(commandFor);
       return [{ kind: "group", transform, children }];
     }
   };
@@ -19486,6 +19801,9 @@ function wrapNodeOutput(cmds, pose, alpha) {
   }
   return rotated;
 }
+
+// src/canvas/hud.module.css
+var hud_default = {};
 function insetAlong(start, extent, size, align, by) {
   if (align === "start") return start + by;
   if (align === "end") return start + extent - size - by;
@@ -19624,20 +19942,8 @@ function CursorCoordsHud({ canvasRef, anchorRef, viewRef, offset }) {
     "div",
     {
       ref,
-      style: {
-        position: "fixed",
-        ...anchorStyle,
-        zIndex: 1e4,
-        background: "rgba(0,0,0,0.7)",
-        color: "#e8e8e8",
-        font: "11px ui-monospace, SFMono-Regular, Menlo, monospace",
-        padding: "6px 8px",
-        borderRadius: 4,
-        pointerEvents: "none",
-        lineHeight: 1.4,
-        whiteSpace: "pre",
-        textAlign: "right"
-      },
+      className: `${hud_default.hud} ${hud_default.pre}`,
+      style: anchorStyle,
       children: [
         `fps    ${fps.toString().padStart(3)}`,
         "\n",
@@ -19648,9 +19954,6 @@ function CursorCoordsHud({ canvasRef, anchorRef, viewRef, offset }) {
     }
   );
 }
-
-// src/canvas/PickHud.module.css
-var PickHud_default = {};
 function PickHud({ canvasRef, anchorRef, viewRef, pickEvery, pickBest, offset }) {
   const [state, setState] = useState({
     ids: [],
@@ -19702,25 +20005,22 @@ function PickHud({ canvasRef, anchorRef, viewRef, pickEvery, pickBest, offset })
     };
   }, [canvasRef, viewRef, pickEvery, pickBest]);
   if (!style) return null;
-  return /* @__PURE__ */ jsxs("div", { ref, className: PickHud_default.hud, style, children: [
-    /* @__PURE__ */ jsxs("div", { className: PickHud_default.header, children: [
+  return /* @__PURE__ */ jsxs("div", { ref, className: `${hud_default.hud} ${hud_default.sized}`, style, children: [
+    /* @__PURE__ */ jsxs("div", { className: `${hud_default.header} ${hud_default.muted}`, children: [
       "pickEvery (",
       state.ids.length,
       ")"
     ] }),
-    state.ids.length === 0 ? /* @__PURE__ */ jsx("div", { className: PickHud_default.empty, children: state.inCanvas ? "\u2014" : "off-canvas" }) : /* @__PURE__ */ jsx("ul", { className: PickHud_default.list, children: state.ids.slice().reverse().map((id) => /* @__PURE__ */ jsx(
+    state.ids.length === 0 ? /* @__PURE__ */ jsx("div", { className: hud_default.absent, children: state.inCanvas ? "\u2014" : "off-canvas" }) : /* @__PURE__ */ jsx("ul", { className: hud_default.list, children: state.ids.slice().reverse().map((id) => /* @__PURE__ */ jsx(
       "li",
       {
-        className: id === state.best ? `${PickHud_default.item} ${PickHud_default.itemBest}` : PickHud_default.item,
+        className: id === state.best ? `${hud_default.item} ${hud_default.itemBest}` : hud_default.item,
         children: id
       },
       id
     )) })
   ] });
 }
-
-// src/canvas/ModalityHud.module.css
-var ModalityHud_default = {};
 function ModalityHud({ canvasRef, anchorRef, modeId, offset }) {
   const toolCtx = useOptionalActiveToolContext();
   const { ref, style } = useHostAnchor(
@@ -19734,18 +20034,18 @@ function ModalityHud({ canvasRef, anchorRef, modeId, offset }) {
   const active = toolCtx?.active ?? null;
   const hotkeys = toolCtx?.hotkeyStack ?? [];
   const hotkeyTop = hotkeys.length > 0 ? hotkeys[hotkeys.length - 1] : null;
-  return /* @__PURE__ */ jsxs("div", { ref, className: ModalityHud_default.hud, style, children: [
-    /* @__PURE__ */ jsxs("div", { className: ModalityHud_default.row, children: [
-      /* @__PURE__ */ jsx("span", { className: ModalityHud_default.label, children: "mode" }),
-      /* @__PURE__ */ jsx("span", { className: modeId ? ModalityHud_default.value : ModalityHud_default.valueMuted, children: modeId ?? "\u2014" })
+  return /* @__PURE__ */ jsxs("div", { ref, className: `${hud_default.hud} ${hud_default.sized}`, style, children: [
+    /* @__PURE__ */ jsxs("div", { className: hud_default.row, children: [
+      /* @__PURE__ */ jsx("span", { className: hud_default.muted, children: "mode" }),
+      /* @__PURE__ */ jsx("span", { className: modeId ? void 0 : hud_default.absent, children: modeId ?? "\u2014" })
     ] }),
-    /* @__PURE__ */ jsxs("div", { className: ModalityHud_default.row, children: [
-      /* @__PURE__ */ jsx("span", { className: ModalityHud_default.label, children: "active" }),
-      /* @__PURE__ */ jsx("span", { className: active ? ModalityHud_default.value : ModalityHud_default.valueMuted, children: active ?? "\u2014" })
+    /* @__PURE__ */ jsxs("div", { className: hud_default.row, children: [
+      /* @__PURE__ */ jsx("span", { className: hud_default.muted, children: "active" }),
+      /* @__PURE__ */ jsx("span", { className: active ? void 0 : hud_default.absent, children: active ?? "\u2014" })
     ] }),
-    /* @__PURE__ */ jsxs("div", { className: ModalityHud_default.row, children: [
-      /* @__PURE__ */ jsx("span", { className: ModalityHud_default.label, children: "hotkey" }),
-      hotkeys.length <= 1 ? /* @__PURE__ */ jsx("span", { className: hotkeyTop ? ModalityHud_default.value : ModalityHud_default.valueMuted, children: hotkeyTop ?? "\u2014" }) : /* @__PURE__ */ jsx("span", { className: ModalityHud_default.stack, children: hotkeys.slice().reverse().map((id, i) => /* @__PURE__ */ jsx("span", { className: i === 0 ? ModalityHud_default.value : ModalityHud_default.valueMuted, children: id }, `${id}-${i}`)) })
+    /* @__PURE__ */ jsxs("div", { className: hud_default.row, children: [
+      /* @__PURE__ */ jsx("span", { className: hud_default.muted, children: "hotkey" }),
+      hotkeys.length <= 1 ? /* @__PURE__ */ jsx("span", { className: hotkeyTop ? void 0 : hud_default.absent, children: hotkeyTop ?? "\u2014" }) : /* @__PURE__ */ jsx("span", { className: hud_default.stack, children: hotkeys.slice().reverse().map((id, i) => /* @__PURE__ */ jsx("span", { className: i === 0 ? void 0 : hud_default.absent, children: id }, `${id}-${i}`)) })
     ] })
   ] });
 }
@@ -19837,7 +20137,7 @@ function buildSceneLayers(cfg, adapter, debugSink, boundsOfFn, hideIds) {
 }
 function resolveToolsCursor(tools, ctxBase) {
   const id = tools.hotkeyEngaged ?? tools.active;
-  const tool = tools.registry[id];
+  const tool = id === null ? void 0 : tools.registry[id];
   if (!tool?.cursor) return void 0;
   if (typeof tool.cursor !== "function") return resolveCursorTier(tool.cursor);
   if (!ctxBase) return void 0;
@@ -19861,6 +20161,7 @@ function CanvasInner(props, ref) {
     flattenTolerance,
     contentVersion,
     syncPaint = false,
+    redrawOn,
     adapter: adapterProp,
     layers: layersMap,
     selection,
@@ -20260,8 +20561,12 @@ function CanvasInner(props, ref) {
         ...cfg.poseById ? { getPose: cfg.poseById, poseDescriptor: cfg.poseDescriptor ?? geometry } : {}
       });
     }
-    const effectiveLayersMap = backgroundLayer ? { ...layersMap, backgroundFill: { layer: backgroundLayer, before: "scene" } } : layersMap;
-    const out = composeOrderedLayers(effectiveLayersMap, standardLayers, sceneLayers);
+    const out = composeOrderedLayers(
+      layersMap,
+      standardLayers,
+      sceneLayers,
+      backgroundLayer ?? void 0
+    );
     if (decorationLayer) out.push(decorationLayer);
     if (tools) {
       placeToolOverlays(out, standardLayers.selectionOverlay, tools.getActiveOverlays);
@@ -20325,6 +20630,26 @@ function CanvasInner(props, ref) {
     viewRegistryVersion,
     paintedCursorLayer
   ]);
+  useEffect(() => {
+    const redraw = () => {
+      requestRedraw();
+    };
+    const offs = [];
+    for (const layer of layersWithDebug) if (layer.subscribe) offs.push(layer.subscribe(redraw));
+    return () => {
+      for (const off of offs) off();
+    };
+  }, [layersWithDebug, requestRedraw]);
+  const redrawSources = useSameElements(redrawOn);
+  useEffect(() => {
+    const redraw = () => {
+      requestRedraw();
+    };
+    const offs = (redrawSources ?? []).map((src) => src.subscribe(redraw));
+    return () => {
+      for (const off of offs) off();
+    };
+  }, [redrawSources, requestRedraw]);
   const shaderIdKey = shaders?.map((h) => h.id).join("|") ?? "";
   const paintInputsRef = useRef({
     layers: layersWithDebug,
@@ -20573,6 +20898,14 @@ function CanvasInner(props, ref) {
   ] });
 }
 var Canvas = forwardRef(CanvasInner);
+function useSameElements(list2) {
+  const ref = useRef(list2);
+  const prev = ref.current;
+  if (prev !== list2 && !(prev && list2 && prev.length === list2.length && prev.every((x, i) => x === list2[i]))) {
+    ref.current = list2;
+  }
+  return ref.current;
+}
 
 // src/canvas/colorOverrides.ts
 var clock = () => typeof performance !== "undefined" ? performance.now() : Date.now();
@@ -20602,73 +20935,127 @@ function wireSceneSlotToScene(slot, scene, alphaFor, colorOverrides) {
     alphaFor: composeAlphaFor(scene, alphaFor)
   };
 }
-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;
+function aabbOfPose(pose, descriptor = AUTO_POSE_DESCRIPTOR) {
+  return descriptor.getBounds(pose);
+}
+var DEFAULT_PATH_STROKE_SLOP = 4;
+function poseContains(pose, wx, wy, tolerance, descriptor = AUTO_POSE_DESCRIPTOR) {
+  if (isPathLike(pose)) {
+    if (pointInPath(pose, wx, wy)) return true;
+    return strokeHitTest(pose, wx, wy, tolerance ?? DEFAULT_PATH_STROKE_SLOP);
   }
-  return flat;
+  const b = aabbOfPose(pose, descriptor);
+  const t = tolerance ?? 0;
+  return wx >= b.x - t && wx <= b.x + b.width + t && wy >= b.y - t && wy <= b.y + b.height + t;
 }
-function polygonContainsRectCenter(poly2, rect) {
-  return pointInPolygon(flattenVerts2(poly2), rect.x + rect.width / 2, rect.y + rect.height / 2);
+function poseContainsRotated(pose, wx, wy, tolerance, descriptor = AUTO_POSE_DESCRIPTOR) {
+  const r = descriptor === AUTO_POSE_DESCRIPTOR ? poseRotationOf(pose) : rotationAboutCenter(pose, descriptor);
+  if (r) {
+    const [lx, ly] = applyToPoint(rotateAboutPoint(r.cx, r.cy, -r.rotation), wx, wy);
+    return poseContains(pose, lx, ly, tolerance, descriptor);
+  }
+  return poseContains(pose, wx, wy, tolerance, descriptor);
 }
-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 rotationAboutCenter(pose, descriptor) {
+  const rotation = descriptor.getRotation?.(pose) ?? 0;
+  if (!rotation) return null;
+  const b = descriptor.getBounds(pose);
+  return { cx: b.x + b.width / 2, cy: b.y + b.height / 2, rotation };
 }
-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;
+function regionPickOptions(view, alphaOf, poseComposition) {
+  return {
+    ...poseComposition ? { poseComposition } : {},
+    ...alphaOf ? { alphaOf } : {},
+    ...view?.layerIsPainted ? { layerIsPainted: (layer) => view.layerIsPainted(layer) } : {}
+  };
+}
+function hitTestArea(scene, bounds, opts, descriptor = AUTO_POSE_DESCRIPTOR, query = {}) {
+  const { x, y, width: w, height: h } = bounds;
+  const area = Array.from(rectToContour(x, y, w, h));
+  return hitTestAreaPolygon(scene, area, { x, y, width: w, height: h }, true, opts, descriptor, query);
+}
+function hitTestAreaPolygon(scene, area, areaBounds, areaIsRect = false, opts, descriptor = AUTO_POSE_DESCRIPTOR, query = {}) {
+  const ab = areaBounds ?? boundsOf(area);
+  if (!ab) return [];
+  const areaVerts = [];
+  for (let i = 0; i + 1 < area.length; i += 2) areaVerts.push({ x: area[i], y: area[i + 1] });
+  return walkArea(scene, ab, opts, descriptor, query, (node, pose, b, silhouette) => {
+    if (areaIsRect && b.x >= ab.x && b.y >= ab.y && b.x + b.width <= ab.x + ab.width && b.y + b.height <= ab.y + ab.height) {
+      return true;
+    }
+    if (silhouette) {
+      return polygonIntersectsPath(areaVerts, pose);
+    }
+    const outline = outlineOf(node, pose, b);
+    if (outline.kind === "rect" && areaIsRect) return true;
+    return polygonIntersectsPath(areaVerts, outline);
+  });
+}
+function hitTestLassoPolygon(scene, polygon, mode, opts, descriptor = AUTO_POSE_DESCRIPTOR, query = {}) {
+  if (polygon.length < 3) return [];
+  const area = [];
+  for (const p of polygon) area.push(p.x, p.y);
+  if (mode === "intersect") {
+    return hitTestAreaPolygon(scene, area, void 0, false, opts, descriptor, query);
   }
-  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);
+  const ab = boundsOf(area);
+  if (!ab) return [];
+  return walkArea(scene, ab, opts, descriptor, query, (node, pose, b, silhouette) => {
+    if (mode === "centers") {
+      return pointInPolygon(area, b.x + b.width / 2, b.y + b.height / 2);
+    }
+    if (b.x < ab.x || b.y < ab.y || b.x + b.width > ab.x + ab.width || b.y + b.height > ab.y + ab.height) {
+      return false;
+    }
+    const outline = silhouette ? pose : outlineOf(node, pose, b);
+    return polygonContainsPath(polygon, outline);
+  });
 }
-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;
+function walkArea(scene, ab, opts, descriptor, query, hits) {
+  return pickWalk(scenePickSource(scene, opts), {
+    includeContainers: query.includeContainers === true,
+    clipAdmits: (clip, node, pose) => {
+      const g = poseDescriptorForNode(descriptor, node);
+      return pathIntersectsRect(clip, visualBoundsViaDescriptor(pose, g)) && pathIntersectsRect(clip, ab);
+    },
+    hits: (node, pose) => {
+      const g = poseDescriptorForNode(descriptor, node);
+      const silhouette = pose !== null && typeof pose === "object" && pose.kind === "polygon";
+      const b = silhouette ? nodeMemo(node, "aabb", pose, () => aabbOfPose(pose, g)) : visualBoundsViaDescriptor(pose, g);
+      if (!Number.isFinite(b.x) || !Number.isFinite(b.y) || !Number.isFinite(b.width) || !Number.isFinite(b.height)) {
+        return false;
+      }
+      if (b.x >= ab.x + ab.width || b.x + b.width <= ab.x || b.y >= ab.y + ab.height || b.y + b.height <= ab.y) {
+        return false;
+      }
+      return hits(node, pose, b, silhouette);
+    }
+  });
+}
+function outlineOf(node, pose, b) {
+  const drawn = findShapeSilhouette(node, pose);
+  if (drawn) return drawn;
+  const r = poseRotationOf(pose);
+  if (r) {
+    const p = pose;
+    return rotatePathAround(rectPath(p.x, p.y, p.width, p.height), r.cx, r.cy, r.rotation);
   }
-  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+  return rectPath(b.x, b.y, b.width, b.height);
 }
-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;
+function boundsOf(coords) {
+  if (coords.length < 2) return null;
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (let i = 0; i + 1 < coords.length; i += 2) {
+    const x = coords[i], y = coords[i + 1];
+    if (x < minX) minX = x;
+    if (y < minY) minY = y;
+    if (x > maxX) maxX = x;
+    if (y > maxY) maxY = y;
   }
-  return false;
+  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
 }
 
 // src/canvas/sceneAdapter.ts
-function walkClipAware(scene, poseBounds, nodeTest, poseComposition) {
-  return pickWalk(scenePickSource(scene, poseComposition ? { poseComposition } : {}), {
-    hits: (node, pose) => nodeTest(node, pose),
-    clipAdmits: (clip, _node, pose) => pathIntersectsRect(clip, poseBounds(pose))
-  });
-}
 var adapterFallbackIdCounter = 0;
 function adapterFallbackId() {
   return `n${(adapterFallbackIdCounter++).toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
@@ -20704,6 +21091,7 @@ function sceneToAdapter(scene, options = {}) {
   );
   const composition = options.poseComposition;
   const composes = composition !== void 0 && composition.closure !== "identity";
+  const pickOpts = composition ? { poseComposition: composition } : {};
   if (composes && options.cascadeContainerPose) {
     throw new Error(
       "sceneToAdapter: poseComposition and cascadeContainerPose contradict each other. Under a composing strategy a child's pose is already relative to its parent, so the cascade would move every descendant twice. Drop cascadeContainerPose."
@@ -20840,23 +21228,29 @@ function sceneToAdapter(scene, options = {}) {
     // AreaSelectAdapter surface — included unconditionally so plain
     // `useSelectTool(sceneToAdapter(scene, { selection }))` Just Works for the
     // marquee gesture. `applyOps` (above) dispatches transiently when called
-    // without a label, matching the AreaSelectAdapter contract; `hitTestArea`
-    // does an AABB-vs-AABB scan over `scene.renderOrder()`, reading bounds
-    // through the pose descriptor.
+    // without a label, matching the AreaSelectAdapter contract.
     getSelection,
     setSelection,
+    // The live marquee's and lasso's own hit-tests. Containers come back:
+    // this adapter's consumer has nothing to fold children into them.
     hitTestArea(rect) {
-      return walkClipAware(scene, poseBounds, (_n, pose) => {
-        const b = poseBounds(pose);
-        return b.x < rect.x + rect.width && b.x + b.width > rect.x && b.y < rect.y + rect.height && b.y + b.height > rect.y;
-      }, composition);
+      return hitTestArea(
+        scene,
+        rect,
+        pickOpts,
+        d,
+        { includeContainers: true }
+      );
     },
     hitTestLasso(polygon, mode) {
-      if (polygon.length < 3) return [];
-      return walkClipAware(scene, poseBounds, (_n, pose) => {
-        const b = poseBounds(pose);
-        return mode === "centers" ? polygonContainsRectCenter(polygon, b) : mode === "enclosed" ? polygonContainsRect(polygon, b) : polygonIntersectsRect(polygon, b);
-      }, composition);
+      return hitTestLassoPolygon(
+        scene,
+        polygon,
+        mode,
+        pickOpts,
+        d,
+        { includeContainers: true }
+      );
     },
     // commitInsert (gesture-time leaf insert) is opt-in: present only when
     // `options.commitInsert` is. The full insertNode/removeNode mutators
@@ -21757,6 +22151,9 @@ function createScene(options) {
       canUndo: () => raw.canUndo(),
       canRedo: () => raw.canRedo(),
       entries: () => raw.entries(),
+      seal: () => raw.seal(),
+      getVersion: () => raw.getVersion(),
+      subscribe: (listener) => raw.subscribe(listener),
       commit(label) {
         raw.commit(label);
         notify2();
@@ -23310,11 +23707,6 @@ function CanvasView(props) {
   }, [registry2, effectiveView]);
   return null;
 }
-function ActionsProviderIfRoot({ children }) {
-  const parent = useActionsRegistry();
-  if (parent) return /* @__PURE__ */ jsx(ActionsScope, { children });
-  return /* @__PURE__ */ jsx(ActionsProvider, { children });
-}
 function contributionEntries(tools) {
   return [...Object.values(tools.registry), ...tools.ambient];
 }
@@ -23339,10 +23731,11 @@ function useKeyedInstall(items) {
 function useContributionRoles(tools, api) {
   const registry2 = useActionsRegistry();
   const depRegistry = useOptionalDepRegistry();
+  const { registry: toolRegistry, ambient } = tools;
   useEffect(() => {
     if (!registry2) return;
     const unregisters = [];
-    for (const entry of contributionEntries(tools)) {
+    for (const entry of contributionEntries({ registry: toolRegistry, ambient })) {
       for (const action of entry.actions ?? []) {
         unregisters.push(registry2.register(action));
       }
@@ -23350,7 +23743,7 @@ function useContributionRoles(tools, api) {
     return () => {
       for (const u of unregisters) u();
     };
-  }, [registry2, tools.registry, tools.ambient]);
+  }, [registry2, toolRegistry, ambient]);
   const installs = /* @__PURE__ */ new Map();
   for (const entry of contributionEntries(tools)) {
     const deps = entry.deps;
@@ -23362,6 +23755,7 @@ function useContributionRoles(tools, api) {
     }
   }
   useKeyedInstall(installs);
+  useOffhandAction(contributionEntries(tools));
 }
 function registerDeps(depRegistry, deps) {
   const unregisters = Object.keys(deps).map((name) => depRegistry.register(name, deps[name]));
@@ -23418,35 +23812,6 @@ function PointerPublisher({
   }, [ctx, canvasRef, registry2]);
   return null;
 }
-function aabbOfPose(pose, descriptor = AUTO_POSE_DESCRIPTOR) {
-  return descriptor.getBounds(pose);
-}
-var DEFAULT_PATH_STROKE_SLOP = 4;
-function poseContains(pose, wx, wy, tolerance, descriptor = AUTO_POSE_DESCRIPTOR) {
-  if (isPathLike(pose)) {
-    if (pointInPath(pose, wx, wy)) return true;
-    return strokeHitTest(pose, wx, wy, tolerance ?? DEFAULT_PATH_STROKE_SLOP);
-  }
-  const b = aabbOfPose(pose, descriptor);
-  const t = tolerance ?? 0;
-  return wx >= b.x - t && wx <= b.x + b.width + t && wy >= b.y - t && wy <= b.y + b.height + t;
-}
-function poseContainsRotated(pose, wx, wy, tolerance, descriptor = AUTO_POSE_DESCRIPTOR) {
-  const r = descriptor === AUTO_POSE_DESCRIPTOR ? poseRotationOf(pose) : rotationAboutCenter(pose, descriptor);
-  if (r) {
-    const [lx, ly] = applyToPoint(rotateAboutPoint(r.cx, r.cy, -r.rotation), wx, wy);
-    return poseContains(pose, lx, ly, tolerance, descriptor);
-  }
-  return poseContains(pose, wx, wy, tolerance, descriptor);
-}
-function rotationAboutCenter(pose, descriptor) {
-  const rotation = descriptor.getRotation?.(pose) ?? 0;
-  if (!rotation) return null;
-  const b = descriptor.getBounds(pose);
-  return { cx: b.x + b.width / 2, cy: b.y + b.height / 2, rotation };
-}
-
-// src/canvas/SceneCanvas/useSceneSelectTool.ts
 var DEFAULT_PICK_TOLERANCE_PX = 4;
 function useSceneSelectTool(args) {
   const { scene, adapter, geometry, selectTool: opts, getView, alphaOf, layerIsPainted } = args;
@@ -23520,7 +23885,6 @@ function useSceneSelectTool(args) {
   }, [scene, adapter, boundsOfProp, d]);
   const selectTool = useSelectTool(adapter, {
     pickEvery: wiredHitBody,
-    move: wiredMoveOptions,
     ...opts?.pickBest ? { pickBest: opts.pickBest } : {},
     ...opts?.extendClickLocked ? { extendClickLocked: opts.extendClickLocked } : {}
   });
@@ -23534,8 +23898,100 @@ function useSceneSelectTool(args) {
     selectTool,
     pickEvery: wiredHitBody,
     pickBest: wiredPickBest,
-    boundsOf: wiredBoundsOf
-  };
+    boundsOf: wiredBoundsOf,
+    moveOptions: wiredMoveOptions
+  };
+}
+
+// src/canvas/SceneCanvas/features.ts
+var SCENE_CANVAS_FEATURES = [
+  "view",
+  "pick",
+  "move",
+  "transform",
+  "edit",
+  "arrange",
+  "paths",
+  "ingest",
+  "draw"
+];
+var BASE_FEATURES = SCENE_CANVAS_FEATURES.filter((f) => f !== "draw");
+var FEATURE_ACTION_IDS = {
+  view: ["viewport.dragPan", "viewport.pinchZoom"],
+  pick: ["areaSelect", "clearSelection", "lassoSelect"],
+  move: ["move", "clone"],
+  transform: ["resize", "rotate"],
+  edit: [
+    "escape",
+    "cancelGesture",
+    "selectAll",
+    "duplicate",
+    "delete",
+    "group",
+    "ungroup",
+    "undo",
+    "redo",
+    "nudge.up",
+    "nudge.down",
+    "nudge.left",
+    "nudge.right",
+    "clipboard.cut",
+    "clipboard.copy",
+    "clipboard.paste",
+    "setFill",
+    "setStroke",
+    "setFillOpacity",
+    "setStrokeOpacity"
+  ],
+  arrange: [
+    "flip",
+    "reorder.forward",
+    "reorder.backward",
+    "align.left",
+    "align.centerX",
+    "align.right",
+    "align.top",
+    "align.centerY",
+    "align.bottom",
+    "distribute.horizontal",
+    "distribute.vertical"
+  ],
+  paths: [
+    "pathfinder.union",
+    "pathfinder.subtract",
+    "pathfinder.intersect",
+    "pathfinder.exclude",
+    "pathfinder.divide",
+    "pathfinder.crop",
+    "editAnchors",
+    "enterPathEdit",
+    "exitPathEdit",
+    "insertPathAnchor",
+    "nudgeAnchors.up",
+    "nudgeAnchors.down",
+    "nudgeAnchors.left",
+    "nudgeAnchors.right",
+    "deleteAnchors",
+    "cutPathAtAnchor",
+    "marqueeAnchors",
+    "selectAnchor"
+  ],
+  ingest: ["ingest"]
+};
+var TOOL_DRIVEN_ACTION_IDS = ["insert", "insert.adjustRotation", "enterTextEdit"];
+function resolveFeatures(features, opts = {}) {
+  const out = /* @__PURE__ */ new Set();
+  for (const f of features ?? []) {
+    if (f === "draw") for (const b of BASE_FEATURES) out.add(b);
+    else out.add(f);
+  }
+  if (opts.viewport) out.add("view");
+  return out;
+}
+function featureActionIds(features) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const f of features) for (const id of FEATURE_ACTION_IDS[f]) ids.add(id);
+  return ids;
 }
 
 // src/canvas/drawEnvelope.ts
@@ -24353,101 +24809,15 @@ function useBuiltinShapeTools(args) {
       addNode: (carrier) => {
         const node = makePenLeaf(carrier);
         adapter.insertNode(node);
-        return String(node.id);
-      },
-      makeNode: (carrier) => makePenLeaf(carrier),
-      setSelection: (ids) => adapter.setSelection(ids)
-    }
-  });
-  const lasso = useLassoTool(adapter, options?.lasso ?? {});
-  const text = useTextTool();
-  return { rect, ellipse, line, polygon, star, pen, pencil, lasso, text };
-}
-function DepRegistryProviderIfRoot({ children }) {
-  const parent = useOptionalDepRegistry();
-  if (parent) return /* @__PURE__ */ jsx(Fragment, { children });
-  return /* @__PURE__ */ jsx(DepRegistryProvider, { children });
-}
-function regionPickOptions(view, alphaOf, poseComposition) {
-  return {
-    ...poseComposition ? { poseComposition } : {},
-    ...alphaOf ? { alphaOf } : {},
-    ...view?.layerIsPainted ? { layerIsPainted: (layer) => view.layerIsPainted(layer) } : {}
-  };
-}
-function hitTestArea(scene, bounds, opts, descriptor = AUTO_POSE_DESCRIPTOR) {
-  const { x, y, width: w, height: h } = bounds;
-  const area = Array.from(rectToContour(x, y, w, h));
-  return hitTestAreaPolygon(scene, area, { x, y, width: w, height: h }, true, opts, descriptor);
-}
-function hitTestAreaPolygon(scene, area, areaBounds, areaIsRect = false, opts, descriptor = AUTO_POSE_DESCRIPTOR) {
-  const ab = areaBounds ?? boundsOf(area);
-  if (!ab) return [];
-  return pickWalk(scenePickSource(scene, opts), {
-    // A marquee that returns a container *and* its children selects the same
-    // ink twice; the container comes back through the selection's own
-    // parent-folding instead.
-    includeContainers: false,
-    clipAdmits: (clip, node, pose) => {
-      const g = poseDescriptorForNode(descriptor, node);
-      return pathIntersectsRect(clip, visualBoundsViaDescriptor(pose, g)) && pathIntersectsRect(clip, ab);
-    },
-    hits: (node, pose) => {
-      const g = poseDescriptorForNode(descriptor, node);
-      const silhouette = pose !== null && typeof pose === "object" && pose.kind === "polygon";
-      const b = silhouette ? nodeMemo(node, "aabb", pose, () => aabbOfPose(pose, g)) : visualBoundsViaDescriptor(pose, g);
-      if (!Number.isFinite(b.x) || !Number.isFinite(b.y) || !Number.isFinite(b.width) || !Number.isFinite(b.height)) {
-        return false;
-      }
-      if (b.x >= ab.x + ab.width || b.x + b.width <= ab.x || b.y >= ab.y + ab.height || b.y + b.height <= ab.y) {
-        return false;
-      }
-      if (areaIsRect && b.x >= ab.x && b.y >= ab.y && b.x + b.width <= ab.x + ab.width && b.y + b.height <= ab.y + ab.height) {
-        return true;
-      }
-      if (silhouette) {
-        return silhouetteOverlapsArea(pose.coords, area);
-      }
-      const drawn = findShapeSilhouette(node, pose);
-      if (drawn?.kind === "polygon") {
-        return silhouetteOverlapsArea(drawn.coords, area);
-      }
-      return true;
+        return String(node.id);
+      },
+      makeNode: (carrier) => makePenLeaf(carrier),
+      setSelection: (ids) => adapter.setSelection(ids)
     }
   });
-}
-function silhouetteOverlapsArea(sil, area) {
-  const ns = sil.length >> 1;
-  const na = area.length >> 1;
-  if (ns < 1 || na < 3) return false;
-  for (let i = 0; i < ns; i++) {
-    if (pointInPolygon(area, sil[i * 2], sil[i * 2 + 1])) return true;
-  }
-  for (let i = 0; i < na; i++) {
-    if (pointInPolygon(sil, area[i * 2], area[i * 2 + 1])) return true;
-  }
-  for (let i = 0, j = ns - 1; i < ns; j = i++) {
-    const ax = sil[j * 2], ay = sil[j * 2 + 1];
-    const bx = sil[i * 2], by = sil[i * 2 + 1];
-    for (let k = 0, l = na - 1; k < na; l = k++) {
-      const cx = area[l * 2], cy = area[l * 2 + 1];
-      const dx = area[k * 2], dy = area[k * 2 + 1];
-      if (segmentsCross(ax, ay, bx, by, cx, cy, dx, dy)) return true;
-    }
-  }
-  return false;
-}
-function boundsOf(coords) {
-  if (coords.length < 2) return null;
-  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
-  for (let i = 0; i + 1 < coords.length; i += 2) {
-    const x = coords[i], y = coords[i + 1];
-    if (x < minX) minX = x;
-    if (y < minY) minY = y;
-    if (x > maxX) maxX = x;
-    if (y > maxY) maxY = y;
-  }
-  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+  const lasso = useLassoTool(adapter, options?.lasso ?? {});
+  const text = useTextTool();
+  return { rect, ellipse, line, polygon, star, pen, pencil, lasso, text };
 }
 function useViewDepSource(currentViewRef, onViewChange, recenter, hostSize, animation, decay, layerIsPainted) {
   const wiring = useRef({
@@ -24543,6 +24913,7 @@ function useLassoSelectDepSource(scene, selection, descriptor, poseComposition,
     const d = descriptorRef.current;
     const a = alphaOfRef.current;
     return {
+      hitTestLasso: (polygon, mode, view) => hitTestLassoPolygon(sc, polygon, mode, regionPickOptions(view, a, poseComposition), d),
       hitTestArea: (bounds, view) => hitTestArea(sc, bounds, regionPickOptions(view, a, poseComposition), d),
       getSelection: () => s.current,
       setSelection: (ids) => s.set(ids)
@@ -24765,7 +25136,7 @@ function chordLengthParam(samples) {
   ts[0] = 0;
   let total = 0;
   for (let i = 1; i < n; i++) {
-    total += dist2(samples[i - 1], samples[i]);
+    total += dist(samples[i - 1], samples[i]);
     ts[i] = total;
   }
   if (total === 0) return null;
@@ -24798,13 +25169,13 @@ function solveLS(samples, ts, a, e, tStart, tEnd) {
   let alpha1;
   let alpha2;
   if (Math.abs(det) < 1e-12) {
-    const chord = dist2(a, e);
+    const chord = dist(a, e);
     alpha1 = alpha2 = chord / 3;
   } else {
     alpha1 = (c22 * x1 - c12 * x2) / det;
     alpha2 = (c11 * x2 - c12 * x1) / det;
     if (alpha1 < 1e-6 || alpha2 < 1e-6) {
-      const chord = dist2(a, e);
+      const chord = dist(a, e);
       alpha1 = alpha2 = chord / 3;
     }
   }
@@ -24839,7 +25210,7 @@ function newtonRefineT(p, t, p0, p1, p2, p3) {
 function sub(a, b) {
   return { x: a.x - b.x, y: a.y - b.y };
 }
-function dist2(a, b) {
+function dist(a, b) {
   return Math.hypot(a.x - b.x, a.y - b.y);
 }
 function unit(v) {
@@ -25233,7 +25604,7 @@ function openFilePicker(opts = {}) {
     input.click();
   });
 }
-function useActionsPropResolver(actions) {
+function useActionsPropResolver(actions, rev) {
   const reg = useActionsRegistry();
   const actionsRef = useRef(actions);
   actionsRef.current = actions;
@@ -25280,7 +25651,7 @@ function useActionsPropResolver(actions) {
     return () => {
       for (const u of unregisters) u();
     };
-  }, [reg, actions]);
+  }, [reg, actions, rev]);
 }
 function useViewportActions(args) {
   const { pan, zoom, pinchZoom } = args;
@@ -25643,14 +26014,7 @@ function mergeLayersWithDefaults(user, targetScale = 1) {
   return result;
 }
 var NON_SHAPE_BUILTIN_TOOLS = ["select", "hand"];
-var BUNDLE_TOOLS = {
-  minimal: ["select", "hand"],
-  // No `pencil`: freehand is a specialist instrument, not part of the
-  // everyday shape-drawing set. It stays in `exhaustive`, which means
-  // everything.
-  standard: ["select", "hand", "rect", "ellipse", "line"],
-  exhaustive: [...NON_SHAPE_BUILTIN_TOOLS, ...KIT_SHAPE_KINDS]
-};
+var BUILTIN_TOOL_IDS = [...NON_SHAPE_BUILTIN_TOOLS, ...KIT_SHAPE_KINDS];
 var EMPTY_ID_SET = /* @__PURE__ */ new Set();
 var EMPTY_ANCHOR_SELECTION2 = /* @__PURE__ */ new Set();
 function isToolsApi(tools) {
@@ -25674,10 +26038,10 @@ function SceneCanvasInner(props, ref) {
     selectionOptions,
     selectionMode = "single",
     tools: toolsProp,
+    features,
     enableKeybindings = true,
     enableGestureDispatcher = true,
     onToolsCreated,
-    toolBundle,
     defaultTools,
     toolOptions,
     initialActiveTool,
@@ -25703,7 +26067,7 @@ function SceneCanvasInner(props, ref) {
     isPointerInteractive,
     onDoubleClick,
     chromeVisibility,
-    getActiveMode,
+    modes,
     getFocused: getFocusedProp,
     device,
     ...rest
@@ -25719,7 +26083,12 @@ function SceneCanvasInner(props, ref) {
     () => isSerialized(sceneInput) ? sceneFromJSON(sceneInput, {}) : null
   );
   const scene = bakedScene ?? sceneInput;
-  const { view: viewProp, onViewChange: onViewChangeProp, defaultView, ...restProps } = rest;
+  const { view: viewProp, onViewChange: onViewChangeProp, defaultView, redrawOn: redrawOnProp, ...restProps } = rest;
+  const getActiveMode = useMemo(() => modes ? getActiveModeFor(modes) : void 0, [modes]);
+  const redrawOn = useMemo(
+    () => modes ? [...redrawOnProp ?? [], modes] : redrawOnProp,
+    [modes, redrawOnProp]
+  );
   const internalCanvasRef = useRef(null);
   const canvasApiRef = useRef(null);
   const [canvasReady, setCanvasReady] = useState(false);
@@ -25921,7 +26290,13 @@ function SceneCanvasInner(props, ref) {
     poseComposition,
     cascadeContainerPose: !framed
   });
-  const { selectTool: internalSelect, pickEvery: internalPickEvery, pickBest: internalPickBest, boundsOf: internalBoundsOf } = useSceneSelectTool({
+  const {
+    selectTool: internalSelect,
+    pickEvery: internalPickEvery,
+    pickBest: internalPickBest,
+    boundsOf: internalBoundsOf,
+    moveOptions: internalMoveOptions
+  } = useSceneSelectTool({
     scene,
     adapter,
     poseDescriptor: descriptor,
@@ -25953,7 +26328,13 @@ function SceneCanvasInner(props, ref) {
       return hit;
     };
   }, [adapter, internalPickEvery, isPointerInteractive, kindClassifier]);
-  const viewportRegistered = !!viewport;
+  const featuresKey = (features ?? []).join("|");
+  const hasViewport = viewport !== void 0;
+  const enabled = useMemo(
+    () => resolveFeatures(features, { viewport: hasViewport }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [featuresKey, hasViewport]
+  );
   const inertiaEnabled = !!viewport?.inertia;
   const inertiaObj = typeof viewport?.inertia === "object" ? viewport.inertia : void 0;
   const handToolInertia = inertiaEnabled ? {
@@ -25963,8 +26344,11 @@ function SceneCanvasInner(props, ref) {
     bounds: inertiaObj?.bounds
   } : void 0;
   const handTool = useHandTool(handToolInertia ? { inertia: handToolInertia } : {});
-  const viewportAmbient = [];
-  const baseRequestedTools = defaultTools ?? (toolBundle ? BUNDLE_TOOLS[toolBundle] : null) ?? (viewportRegistered ? ["select", "hand"] : ["select"]);
+  const baseRequestedTools = [
+    ...defaultTools ?? [],
+    ...enabled.has("pick") ? ["select"] : [],
+    ...enabled.has("view") ? ["hand"] : []
+  ];
   const KNOWN_BUILTIN_IDS = /* @__PURE__ */ new Set([
     ...NON_SHAPE_BUILTIN_TOOLS,
     ...KIT_SHAPE_KINDS
@@ -25988,10 +26372,10 @@ function SceneCanvasInner(props, ref) {
   }
   const wants = (id) => baseRequestedTools.includes(id) || trueIds.has(id);
   const shapeTools = useBuiltinShapeTools({ scene, adapter, options: toolOptions });
-  const mergedAmbient = [...viewportAmbient, ...ambient ?? []];
+  const mergedAmbient = ambient ?? [];
   const internalRegistry = {};
   if (wants("select")) internalRegistry.select = internalSelect;
-  if (wants("hand") && viewportRegistered) internalRegistry.hand = handTool;
+  if (wants("hand")) internalRegistry.hand = handTool;
   if (wants("rect")) internalRegistry.rect = shapeTools.rect;
   if (wants("ellipse")) internalRegistry.ellipse = shapeTools.ellipse;
   if (wants("line")) internalRegistry.line = shapeTools.line;
@@ -26018,16 +26402,17 @@ function SceneCanvasInner(props, ref) {
   }
   const toolsTakeover = toolsProp && isToolsApi(toolsProp) ? toolsProp : null;
   const internalTools = useTools({
-    active: initialActiveTool ?? "select",
+    active: initialActiveTool ?? ("select" in internalRegistry ? "select" : null),
     registry: internalRegistry,
-    ...mergedAmbient.length ? { ambient: mergedAmbient } : {}
+    ...mergedAmbient.length ? { ambient: mergedAmbient } : {},
+    ...modes ? { modes } : {}
   });
-  const toolsForEligibilityRef = useRef(null);
-  toolsForEligibilityRef.current = toolsTakeover ?? internalTools;
+  const liveToolsRef = useRef(null);
+  liveToolsRef.current = toolsTakeover ?? internalTools;
   const isToolEligible = useCallback((toolId) => {
     const getMode = getActiveModeRef.current;
     if (!getMode) return true;
-    const registry2 = toolsForEligibilityRef.current?.registry;
+    const registry2 = liveToolsRef.current?.registry;
     const caps = registry2?.[toolId]?.eligibility.capabilities ?? [];
     if (caps.length === 0) return false;
     const allowed = getMode().allowedCapabilities;
@@ -26035,6 +26420,27 @@ function SceneCanvasInner(props, ref) {
     return false;
   }, []);
   const tools = toolsTakeover ?? internalTools;
+  const selectionMoveOptions = useMemo(
+    () => ({ move: internalMoveOptions }),
+    [internalMoveOptions]
+  );
+  const rotateOptions = selectToolOpts?.rotate || void 0;
+  const featureContributions = useMemo(() => [
+    ...enabled.has("transform") ? [selectionTransformContribution({ rotate: rotateOptions })] : [],
+    ...enabled.has("move") ? [selectionMoveContribution(selectionMoveOptions)] : []
+  ], [enabled, selectionMoveOptions, rotateOptions]);
+  const standardActionsExclude = useMemo(() => {
+    const include = featureActionIds(enabled);
+    const bound = [
+      ...Object.values(tools.registry),
+      ...tools.ambient,
+      ...featureContributions
+    ];
+    for (const entry of bound) {
+      for (const b of entry.bindings ?? []) include.add(b.actionId);
+    }
+    return KIT_STANDARD_ACTION_IDS.filter((id) => !include.has(id));
+  }, [enabled, tools, featureContributions]);
   const onToolsCreatedRef = useRef(onToolsCreated);
   onToolsCreatedRef.current = onToolsCreated;
   useEffect(() => {
@@ -26123,6 +26529,11 @@ function SceneCanvasInner(props, ref) {
   getFocusedPropRef.current = getFocusedProp;
   const effectiveChromeVisibility = useMemo(() => {
     const defaults = {};
+    if (!enabled.has("pick")) defaults["selection.outline"] = never;
+    if (!enabled.has("transform")) {
+      defaults["selection.resize-handles"] = never;
+      defaults["selection.rotation-handle"] = never;
+    }
     if (selectionMode === "none") {
       defaults["action.marquee"] = never;
       defaults["action.lasso"] = never;
@@ -26130,7 +26541,7 @@ function SceneCanvasInner(props, ref) {
     if (selectToolOpts?.rotate === false) defaults["selection.rotation-handle"] = never;
     if (Object.keys(defaults).length === 0) return chromeVisibility;
     return { ...defaults, ...chromeVisibility };
-  }, [chromeVisibility, selectionMode, selectToolOpts?.rotate]);
+  }, [chromeVisibility, selectionMode, selectToolOpts?.rotate, enabled]);
   const chromeVisibilityRef = useRef(effectiveChromeVisibility);
   chromeVisibilityRef.current = effectiveChromeVisibility;
   const getActiveModeRef = useRef(getActiveMode);
@@ -26188,13 +26599,10 @@ function SceneCanvasInner(props, ref) {
     () => chromeCaps.isVisible(currentRuleInputs()),
     [chromeCaps, currentRuleInputs]
   );
+  const wantsPen = wants("pen");
   const penPreviewLayer = useMemo(
-    () => wants("pen") ? createPenPreviewLayer({ penTool: shapeTools.pen }) : null,
-    // shapeTools.pen identity is stable across renders (returned from a hook
-    // that memoizes via defineTool). `wants('pen')` is recomputed each render
-    // from `baseRequestedTools` + patch-form `true` entries — capture both.
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [shapeTools.pen, baseRequestedTools, trueIds]
+    () => wantsPen ? createPenPreviewLayer({ penTool: shapeTools.pen }) : null,
+    [shapeTools.pen, wantsPen]
   );
   useEffect(() => {
     canvasApiRef.current?.requestRedraw?.();
@@ -26396,12 +26804,12 @@ function SceneCanvasInner(props, ref) {
       onViewChange: notifyViewChange,
       shaders,
       flattenTolerance,
+      ...redrawOn ? { redrawOn } : {},
       ...restProps
     }
   );
   const testHookSceneRef = useRef(scene);
   const testHookSelectionRef = useRef(selection);
-  const testHookActiveToolRef = useRef(null);
   testHookSceneRef.current = scene;
   testHookSelectionRef.current = selection;
   const testHookRef = useRef(null);
@@ -26411,12 +26819,12 @@ function SceneCanvasInner(props, ref) {
         getScene: () => testHookSceneRef.current,
         getSelectionIds: () => testHookSelectionRef.current?.current ?? [],
         getView: () => currentViewRef.current,
-        getActiveToolId: () => testHookActiveToolRef.current
+        getActiveToolId: () => liveToolsRef.current?.active ?? null
       });
       testHookRef.current?._markReady();
     }
   }, []);
-  return /* @__PURE__ */ jsx(DeviceProfileProvider, { value: device, children: /* @__PURE__ */ jsx(ViewInputsProvider, { value: viewInputs, children: /* @__PURE__ */ jsx(DepRegistryProviderIfRoot, { children: /* @__PURE__ */ jsx(PointerProviderIfRoot, { children: /* @__PURE__ */ jsxs(ActionsProviderIfRoot, { children: [
+  return /* @__PURE__ */ jsx(DeviceProfileProvider, { value: device, children: /* @__PURE__ */ jsx(ViewInputsProvider, { value: viewInputs, children: /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsx(PointerProviderIfRoot, { children: /* @__PURE__ */ jsxs(Fragment, { children: [
     canvas,
     /* @__PURE__ */ jsx(PointerPublisher, { canvasRef: internalCanvasRef }),
     /* @__PURE__ */ jsx(
@@ -26427,6 +26835,7 @@ function SceneCanvasInner(props, ref) {
         adapter,
         actionDefaults,
         actions: resolvedActions,
+        excludeActions: standardActionsExclude,
         currentViewRef,
         onViewChange: handleViewChange,
         resizeOptions: selectToolOpts?.resize,
@@ -26437,9 +26846,9 @@ function SceneCanvasInner(props, ref) {
         pickEvery: internalPickEvery,
         layerIsPainted: viewLayerGate,
         alphaOf: alphaFor ? composedAlphaFor : void 0,
-        viewportPanEnabled: viewport?.pan ?? true,
-        viewportZoom: resolvedViewportZoom,
-        viewportPinchZoom: viewport?.pinchZoom ?? true,
+        viewportPanEnabled: enabled.has("view") ? viewport?.pan ?? true : false,
+        viewportZoom: enabled.has("view") ? resolvedViewportZoom : false,
+        viewportPinchZoom: enabled.has("view") ? viewport?.pinchZoom ?? true : false,
         viewportRecenter: viewport?.recenter,
         viewAnimation,
         editAnchorsExternalState,
@@ -26462,6 +26871,7 @@ function SceneCanvasInner(props, ref) {
         canvasRef: internalCanvasRef,
         canvasApiRef,
         tools,
+        contributions: featureContributions,
         enabled: enableGestureDispatcher,
         keyboard: enableKeybindings,
         selectionRef,
@@ -26516,6 +26926,7 @@ function GestureDispatcherMounter({
   canvasRef,
   canvasApiRef,
   tools,
+  contributions,
   enabled,
   keyboard,
   selectionRef,
@@ -26534,14 +26945,15 @@ function GestureDispatcherMounter({
   const registry2 = useActionsRegistry();
   const depRegistry = useDepRegistry();
   const viewRegistry = useOptionalViewRegistry();
-  const toolsById = useMemo(() => {
+  const entriesById = useMemo(() => {
     const m = /* @__PURE__ */ new Map();
     for (const [id, tool] of Object.entries(tools.registry)) {
       m.set(id, tool);
     }
-    for (const tool of tools.ambient) m.set(tool.id, tool);
+    for (const entry of contributions) m.set(entry.id, entry);
+    for (const entry of tools.ambient) m.set(entry.id, entry);
     return m;
-  }, [tools.registry, tools.ambient]);
+  }, [tools.registry, tools.ambient, contributions]);
   const boundsOfRef = useRef(boundsOf2);
   boundsOfRef.current = boundsOf2;
   const pickEveryRef = useRef(pickEvery);
@@ -26660,7 +27072,7 @@ function GestureDispatcherMounter({
   useGestureDispatcher({
     canvasRef,
     actions: registry2,
-    toolsById,
+    entriesById,
     enabled,
     keyboard,
     affordanceAt: affordanceWithLayers,
@@ -26680,6 +27092,7 @@ function StandardActionsRegistrar({
   scene,
   adapter,
   actions,
+  excludeActions,
   currentViewRef,
   onViewChange,
   resizeOptions,
@@ -26719,11 +27132,6 @@ function StandardActionsRegistrar({
     if (!registry2) return;
     return registry2.setDispatcher(dispatcher);
   }, [registry2, dispatcher]);
-  const wiredDepRegistry = useDepRegistry();
-  useEffect(() => {
-    if (!registry2) return;
-    return registry2.setDepRegistry(wiredDepRegistry);
-  }, [registry2, wiredDepRegistry]);
   useEffect(() => {
     if (!registry2) return;
     getActionRef.current = (id) => registry2.list().find((a) => a.id === id);
@@ -26744,7 +27152,7 @@ function StandardActionsRegistrar({
     decayLoop,
     layerIsPainted
   );
-  useStandardActions({ selection, scene, view, history: scene.history });
+  useStandardActions({ selection, scene, view, history: scene.history, exclude: excludeActions });
   useDepSource("rootView", () => view);
   const pointer = usePointerContext();
   useDepSource("pointer", () => pointer ?? void 0);
@@ -26763,7 +27171,7 @@ function StandardActionsRegistrar({
   useDispatcherDepSource(dispatcher);
   usePoseDescriptorDepSource(poseDescriptor);
   usePoseCompositionDepSource(poseComposition);
-  useActionsPropResolver(actions);
+  useActionsPropResolver(actions, excludeActions.join("|"));
   return /* @__PURE__ */ jsxs(Fragment, { children: [
     resizeOptions ? /* @__PURE__ */ jsx(ResizePolicyRegistrar, { options: resizeOptions }) : null,
     geometryProjection ? /* @__PURE__ */ jsx(GeometryProjectionRegistrar, { projection: geometryProjection }) : null
@@ -26772,11 +27180,7 @@ function StandardActionsRegistrar({
 function ResizePolicyRegistrar({
   options
 }) {
-  useResizePolicy({
-    constraints: options.behaviors,
-    pointSnap: options.pointSnapBehaviors,
-    expandIds: options.expandIds
-  });
+  useResizePolicy(resizePolicyOptions(options));
   return null;
 }
 function GeometryProjectionRegistrar({
@@ -26787,7 +27191,7 @@ function GeometryProjectionRegistrar({
 }
 var SceneCanvasInnerForwardRef = forwardRef(SceneCanvasInner);
 function SceneCanvasWrapper(props, ref) {
-  return /* @__PURE__ */ jsx(ActiveToolContextProviderIfRoot, { children: /* @__PURE__ */ jsx(ViewRegistryProvider, { children: /* @__PURE__ */ jsx(SceneCanvasInnerForwardRef, { ...props, ref }) }) });
+  return /* @__PURE__ */ jsx(InputScope, { yoke: props.yoke, children: /* @__PURE__ */ jsx(ViewRegistryProvider, { children: /* @__PURE__ */ jsx(SceneCanvasInnerForwardRef, { ...props, ref }) }) });
 }
 var SceneCanvas = forwardRef(SceneCanvasWrapper);
 
@@ -26837,6 +27241,18 @@ var markerEncoding = {
   },
   write: (value) => value === "" ? void 0 : value
 };
+var italicEncoding = {
+  read: (stored) => stored === "italic",
+  write: (on) => on ? "italic" : void 0
+};
+var alignEncoding = {
+  read: (stored, style) => {
+    if (stored === void 0) return void 0;
+    const direction = style?.direction === "rtl" ? "rtl" : "ltr";
+    return resolveAlign(stored, direction);
+  },
+  write: (edge2) => edge2
+};
 var markerOptions = () => [
   { value: "", label: "None" },
   ...listMarkers().map((m) => ({ value: m.id, label: m.id }))
@@ -26940,23 +27356,33 @@ function shapeSchema(opts = {}) {
                     fontFamily: { kind: "font-family", name: "Font", description: "Registered font family.", default: "sans-serif" },
                     fontSize: { kind: "number", name: "Size", description: "Font size, world units.", default: 16, min: 1, step: 1, pair: "Size / weight" },
                     fontWeight: { kind: "number", name: "Weight", description: "Font weight, 100\u2013900.", default: 400, min: 100, max: 900, step: 100, pair: "Size / weight" },
-                    fontStyle: { kind: "enum", name: "Style", description: "Upright or italic.", default: "normal", options: [{ value: "normal", label: "Normal" }, { value: "italic", label: "Italic" }] },
+                    // One row of segments, the strip every text editor
+                    // draws: the slant, the three rules, then the two
+                    // scripts. Italic is a flag here although the field
+                    // is `fontStyle`, whose only other value is upright.
+                    fontStyle: { kind: "boolean", name: "Italic", description: "Set the text in its italic face.", default: false, control: "toggle", icon: "italic", short: "I", pair: "Style", encoding: italicEncoding },
+                    underline: { kind: "boolean", name: "Underline", description: "Underline the text.", default: false, control: "toggle", icon: "underline", short: "U", pair: "Style" },
+                    strikethrough: { kind: "boolean", name: "Strikethrough", description: "Strike through the text.", default: false, control: "toggle", icon: "strikethrough", short: "S", pair: "Style" },
+                    overline: { kind: "boolean", name: "Overline", description: "Rule the text above its ascent.", default: false, control: "toggle", icon: "overline", short: "O", pair: "Style" },
+                    script: { kind: "enum", name: "Script", description: "Set the text smaller and raised or lowered, on the line it would otherwise hold.", default: void 0, control: "toggle", clearable: true, pair: "Style", options: [{ value: "super", label: "Superscript", icon: "superscript" }, { value: "sub", label: "Subscript", icon: "subscript" }] },
                     letterSpacing: { kind: "number", name: "Tracking", description: "Extra advance per glyph, world units.", default: 0, step: 0.1 },
-                    underline: { kind: "boolean", name: "Underline", description: "Underline the text.", default: false, control: "toggle", short: "U", pair: "Decoration" },
-                    strikethrough: { kind: "boolean", name: "Strikethrough", description: "Strike through the text.", default: false, control: "toggle", short: "S", pair: "Decoration" },
-                    overline: { kind: "boolean", name: "Overline", description: "Rule the text above its ascent.", default: false, control: "toggle", short: "O", pair: "Decoration" },
                     textTransform: { kind: "enum", name: "Case", description: "Draw the text in capitals, lowercase or title case. The text itself is unchanged.", default: "none", control: "toggle", options: [{ value: "none", label: "None", short: "\u2013" }, { value: "uppercase", label: "Uppercase", short: "AA" }, { value: "lowercase", label: "Lowercase", short: "aa" }, { value: "capitalize", label: "Capitalize", short: "Aa" }] }
                   }
                 },
                 paragraph: {
                   name: "Paragraph",
                   children: {
-                    align: { kind: "enum", name: "Align", description: "Horizontal alignment.", default: "left", control: "toggle", options: [{ value: "left", label: "Left", short: "L" }, { value: "center", label: "Center", short: "C" }, { value: "right", label: "Right", short: "R" }] },
-                    lineHeight: { kind: "number", name: "Leading", description: "Line height as a multiple of font size.", default: 1.2, min: 0.5, step: 0.1 }
+                    lineHeight: { kind: "number", name: "Leading", description: "Line height as a multiple of font size.", default: 1.2, min: 0.5, step: 0.1 },
+                    wrap: { kind: "boolean", name: "Wrap", description: "Break lines between words at the box width.", default: false, control: "switch" },
+                    direction: { kind: "enum", name: "Direction", description: "Reading direction.", default: "ltr", control: "toggle", options: [{ value: "ltr", label: "Left to right", short: "LTR" }, { value: "rtl", label: "Right to left", short: "RTL" }] },
+                    // Last, so the box's vertical alignment — a field of
+                    // the node rather than of its style — follows it.
+                    align: { kind: "enum", name: "Align", description: "Horizontal alignment.", default: "left", control: "toggle", encoding: alignEncoding, options: [{ value: "left", label: "Left", icon: "textAlignLeft" }, { value: "center", label: "Center", icon: "textAlignCenter" }, { value: "right", label: "Right", icon: "textAlignRight" }] }
                   }
                 }
               }
-            }
+            },
+            "data.verticalAlign": { kind: "enum", name: "Vertical", description: "Where the lines sit in the box's height.", default: "top", control: "toggle", options: [{ value: "top", label: "Top", icon: "textAlignTop" }, { value: "center", label: "Middle", icon: "textAlignMiddle" }, { value: "bottom", label: "Bottom", icon: "textAlignBottom" }] }
           }
         }
       } : {}
@@ -27545,7 +27971,7 @@ function MinimapCanvasInner(props) {
   useGestureDispatcher({
     canvasRef: localCanvasRef,
     actions,
-    toolsById: TOOLS_BY_ID,
+    entriesById: TOOLS_BY_ID,
     clientToWorld: clientToWorld2,
     keyboard: false,
     channels: CHANNELS
@@ -27824,6 +28250,16 @@ function renderSceneToPixels(args) {
     renderer.dispose();
   }
 }
+function ActionsProviderIfRoot({ children }) {
+  const parent = useActionsRegistry();
+  if (parent) return /* @__PURE__ */ jsx(Fragment, { children });
+  return /* @__PURE__ */ jsx(ActionsProvider, { children });
+}
+function DepRegistryProviderIfRoot({ children }) {
+  const parent = useOptionalDepRegistry();
+  if (parent) return /* @__PURE__ */ jsx(Fragment, { children });
+  return /* @__PURE__ */ jsx(DepRegistryProvider, { children });
+}
 function WeaselProvider({ children, isolate = false }) {
   const Deps = isolate ? DepRegistryProvider : DepRegistryProviderIfRoot;
   const Actions = isolate ? ActionsProvider : ActionsProviderIfRoot;
@@ -27881,9 +28317,66 @@ function gateLayer(opts) {
   if (layer.defaultVisible !== void 0) wrapped.defaultVisible = layer.defaultVisible;
   if (layer.alwaysOn !== void 0) wrapped.alwaysOn = layer.alwaysOn;
   if (layer.space !== void 0) wrapped.space = layer.space;
+  if (layer.subscribe) wrapped.subscribe = subscribeToSources([layer]);
   return wrapped;
 }
 
+// src/features/modes/modeLayers.ts
+var DEFAULT_INTENSITY = 0.12;
+function workspaceTintLayer(opts) {
+  const { registry: registry2 } = opts;
+  return {
+    id: opts.id ?? "mode-tint",
+    label: opts.label ?? "Mode tint",
+    space: "screen",
+    subscribe: registry2.subscribe,
+    draw: (_data, view, dims) => {
+      const ws = registry2.current().workspace;
+      const tint = ws?.tint;
+      if (!tint || tint === "transparent") return [];
+      const opacity = opts.intensity ?? ws.intensity ?? DEFAULT_INTENSITY;
+      const { width: W, height: H } = dims;
+      const strip = (x, y, width, height, from, to) => ({
+        kind: "path",
+        path: { kind: "rect", x, y, width, height },
+        fill: ws.gradient ? { fill: "linear-gradient", from, to, stops: [{ offset: 0, color: tint }, { offset: 1, color: "transparent" }], opacity } : { fill: "solid", color: tint, opacity }
+      });
+      const whole = () => [
+        ws.gradient === "top-down" ? strip(0, 0, W, H, { x: 0, y: 0 }, { x: 0, y: H }) : strip(0, 0, W, H, { x: 0, y: H }, { x: 0, y: 0 })
+      ];
+      const page = opts.page?.();
+      if (!page) return whole();
+      const t = viewToTransform(view);
+      const [sx0, sy0] = worldToScreen(page.x, page.y, t);
+      const [sx1, sy1] = worldToScreen(page.x + page.width, page.y + page.height, t);
+      const pl = Math.max(0, Math.min(sx0, sx1));
+      const pt = Math.max(0, Math.min(sy0, sy1));
+      const pr = Math.min(W, Math.max(sx0, sx1));
+      const pb = Math.min(H, Math.max(sy0, sy1));
+      if (pr <= pl || pb <= pt) {
+        return [{ kind: "path", path: { kind: "rect", x: 0, y: 0, width: W, height: H }, fill: { fill: "solid", color: tint, opacity } }];
+      }
+      const cmds = [];
+      const push = (x, y, w, h, from, to) => {
+        if (w > 0 && h > 0) cmds.push(strip(x, y, w, h, from, to));
+      };
+      push(0, 0, W, pt, { x: 0, y: 0 }, { x: 0, y: pt });
+      push(0, pb, W, H - pb, { x: 0, y: H }, { x: 0, y: pb });
+      push(0, pt, pl, pb - pt, { x: 0, y: 0 }, { x: pl, y: 0 });
+      push(pr, pt, W - pr, pb - pt, { x: W, y: 0 }, { x: pr, y: 0 });
+      return cmds;
+    }
+  };
+}
+function modeDecorationLayer(decorations, opts = {}) {
+  return {
+    id: opts.id ?? "mode-decorations",
+    label: opts.label ?? "Mode decorations",
+    subscribe: decorations.subscribe,
+    draw: () => decorations.paint()
+  };
+}
+
 // src/features/groups/children.ts
 function createChildrenLayer(opts) {
   return {
@@ -28989,7 +29482,8 @@ function useTextEdit(opts) {
       }
       if (e.key === "Escape") {
         e.preventDefault();
-        cancelEdit();
+        if (optsRef.current.escape === "commit") commit();
+        else cancelEdit();
         return;
       }
       const toggle = toggleForKey(e);
@@ -29138,6 +29632,7 @@ function applyOverlayStyle(el, style) {
   const decorations = [];
   if (style.underline) decorations.push("underline");
   if (style.strikethrough) decorations.push("line-through");
+  if (style.overline) decorations.push("overline");
   el.style.textDecoration = decorations.length > 0 ? decorations.join(" ") : "none";
   el.style.textTransform = style.textTransform;
   el.style.whiteSpace = style.wrap ? "pre-wrap" : "pre";
@@ -29178,8 +29673,11 @@ function placeOverlay(el, clipBox, pose, clip, style) {
   el.style.left = `${pose.x + pose.width * (pose.zoom ?? 1) * anchor + 1 - (clip?.x ?? 0)}px`;
   el.style.width = style.wrap ? `${pose.width}px` : "max-content";
   el.style.minWidth = style.wrap ? "" : `${pose.width}px`;
-  el.style.fontSize = `${pose.fontSize}px`;
-  el.style.lineHeight = String(pose.lineHeight ?? style.lineHeight);
+  const script = style.script ? SCRIPT_METRICS[style.script] : void 0;
+  const lineHeight = pose.lineHeight ?? style.lineHeight;
+  el.style.fontSize = `${pose.fontSize * (script?.size ?? 1)}px`;
+  el.style.lineHeight = script ? `${pose.fontSize * lineHeight}px` : String(lineHeight);
+  el.style.translate = script ? `0 ${-script.shift * pose.fontSize * (pose.zoom ?? 1)}px` : "";
   const aligned = pose.verticalAlign !== void 0 && pose.verticalAlign !== "top";
   el.style.minHeight = aligned ? "" : `${pose.height}px`;
   el.style.top = `${overlayTop(pose, aligned ? el.offsetHeight : pose.height) - (clip?.y ?? 0)}px`;
@@ -29221,6 +29719,7 @@ function useSceneTextEdit(scene, container, options = {}) {
   const edit = useTextEdit({
     container,
     isEditorChrome: (el) => optsRef.current.isEditorChrome?.(el) ?? false,
+    escape: options.escape,
     getText: (id) => {
       const node = sceneRef.current.get(asNodeId(id));
       if (!node) return "";
@@ -29640,6 +30139,44 @@ function seedMeshPatch(color) {
     units: "bounds"
   };
 }
+function bandPatch(x0, x1, left, right) {
+  const corners = [{ x: x0, y: 0 }, { x: x1, y: 0 }, { x: x1, y: 1 }, { x: x0, y: 1 }];
+  const points = [];
+  for (let i = 0; i < 4; i++) {
+    const a = corners[i];
+    const b = corners[(i + 1) % 4];
+    points.push(a, { x: a.x + (b.x - a.x) / 3, y: a.y + (b.y - a.y) / 3 }, { x: a.x + 2 * (b.x - a.x) / 3, y: a.y + 2 * (b.y - a.y) / 3 });
+  }
+  return { points, colors: [left, right, right, left] };
+}
+function meshFromStops(stops) {
+  const sorted = [...stops].sort((a, b) => a.offset - b.offset);
+  if (sorted.length === 1) sorted.push({ offset: 1, color: sorted[0].color });
+  if (sorted.length === 0) return seedMeshPatch("#000000ff");
+  const patches = [];
+  for (let i = 0; i < sorted.length - 1; i++) {
+    const a = sorted[i];
+    const b = sorted[i + 1];
+    if (b.offset > a.offset) patches.push(bandPatch(a.offset, b.offset, a.color, b.color));
+  }
+  return { fill: MESH_GRADIENT_KIND, patches, units: "bounds" };
+}
+function meshStops(mesh) {
+  const valid = mesh.patches.filter(isValidPatch);
+  if (valid.length === 0) return [];
+  const xs = valid.flatMap((p) => [p.points[0].x, p.points[3].x]);
+  const lo = Math.min(...xs);
+  const span = Math.max(...xs) - lo;
+  const offsetOf = (x) => span > 0 ? (x - lo) / span : 0;
+  const stops = [];
+  for (const patch of valid) {
+    for (const [point, color] of [[patch.points[0], patch.colors[0]], [patch.points[3], patch.colors[1]]]) {
+      const offset = offsetOf(point.x);
+      if (!stops.some((s) => s.offset === offset && s.color === color)) stops.push({ offset, color });
+    }
+  }
+  return stops.sort((a, b) => a.offset - b.offset);
+}
 function mapPatches(mesh, move) {
   return mesh.patches.map((patch) => ({ ...patch, points: patch.points.map(move) }));
 }
@@ -29709,6 +30246,8 @@ registerPaintKind({
   // The first corner of the first patch: a mesh has no single color, and this
   // is the one a fallback swatch and an SVG paint fallback both read.
   colorOf: (paint) => asMesh(paint).patches?.[0]?.colors?.[0],
+  stopsOf: (paint) => meshStops(asMesh(paint)),
+  fromStops: (stops) => asPaint(meshFromStops(stops)),
   bind: bindMesh,
   inPoseFrame: (fill, box) => {
     const mesh = asMesh(fill);
@@ -29899,19 +30438,6 @@ function unionOfChildrenVia(descriptor) {
     return u === null ? null : poseDescriptorForNode(descriptor, node).fromBounds(u, node.pose);
   };
 }
-var BEZIER_SAMPLES = 16;
-function pointCubicDist2(px, py, x0, y0, x1, y1, x2, y2, x3, y3) {
-  let prevX = x0, prevY = y0;
-  let best = Infinity;
-  for (let i = 1; i <= BEZIER_SAMPLES; i++) {
-    const [sx, sy] = cubicEvalAt(x0, y0, x1, y1, x2, y2, x3, y3, i / BEZIER_SAMPLES);
-    const d2 = pointSegmentDist2(px, py, prevX, prevY, sx, sy);
-    if (d2 < best) best = d2;
-    prevX = sx;
-    prevY = sy;
-  }
-  return best;
-}
 function pointToRectPerimeterDist(px, py, rx, ry, rw, rh) {
   const dx = Math.max(rx - px, px - (rx + rw), 0);
   const dy = Math.max(ry - py, py - (ry + rh), 0);
@@ -29924,52 +30450,66 @@ function pathDistanceToPoint(path, px, py) {
   if (path.kind === "rect") {
     return pointToRectPerimeterDist(px, py, path.x, path.y, path.width, path.height);
   }
-  return polygonPathDistance(path, px, py);
+  return nearestOnPath(path.commands, path.coords, px, py)?.dist ?? Infinity;
 }
-function polygonPathDistance(path, px, py) {
-  const { commands, coords } = path;
-  let startX = 0, startY = 0;
-  let best = Infinity;
-  const consider = (d2) => {
-    if (d2 < best) best = d2;
-  };
-  forEachSegment(commands, coords, (cmd, ci, curX, curY) => {
-    switch (cmd) {
-      case PATH_M:
-        startX = coords[ci];
-        startY = coords[ci + 1];
-        break;
-      case PATH_L:
-        consider(pointSegmentDist2(px, py, curX, curY, coords[ci], coords[ci + 1]));
-        break;
-      case PATH_C:
-        consider(pointCubicDist2(
-          px,
-          py,
-          curX,
-          curY,
-          coords[ci],
-          coords[ci + 1],
-          coords[ci + 2],
-          coords[ci + 3],
-          coords[ci + 4],
-          coords[ci + 5]
-        ));
-        break;
-      case PATH_Q: {
-        const x = coords[ci + 2], y = coords[ci + 3];
-        const [c1x, c1y, c2x, c2y] = elevateQuadraticToCubic(curX, curY, coords[ci], coords[ci + 1], x, y);
-        consider(pointCubicDist2(px, py, curX, curY, c1x, c1y, c2x, c2y, x, y));
-        break;
-      }
-      case PATH_Z:
-        consider(pointSegmentDist2(px, py, curX, curY, startX, startY));
-        break;
-      default:
-        throw new Error(`pathDistanceToPoint: unknown command code ${cmd}`);
-    }
-  });
-  return best === Infinity ? Infinity : Math.sqrt(best);
+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;
 }
 var PLACEHOLDER_FILL = { color: "#ffffff" };
 var PLACEHOLDER_STROKE = { paint: { color: "#ffffff" }, width: 1 };
@@ -30120,60 +30660,400 @@ function splitSubpaths(path) {
   });
   return out;
 }
-
-// src/features/paths/splitByLine.ts
-function segmentsProperlyCross(a, b, c, d) {
-  const s = (p, q, r) => Math.sign((q.x - p.x) * (r.y - p.y) - (q.y - p.y) * (r.x - p.x));
-  const d1 = s(c, d, a), d2 = s(c, d, b), d3 = s(a, b, c), d4 = s(a, b, d);
-  return d1 !== d2 && d3 !== d4;
+function splitPathBySegment(path, a, b, opts = {}) {
+  if (a.x === b.x && a.y === b.y) return null;
+  const outRule = path.kind === "polygon" ? path.fillRule : "nonzero";
+  let contours = parseContours(path);
+  let fillRule = outRule;
+  if (contoursIntersect(contours, opts.flattenTolerance ?? 0.5)) {
+    contours = parseContours(pathUnion(path));
+    fillRule = "nonzero";
+  }
+  const boundaries = orientBoundaries(contours, fillRule);
+  if (boundaries.length === 0) return null;
+  const crossings = findCrossings(boundaries, a, b);
+  const partner = /* @__PURE__ */ new Map();
+  for (let k = 0; k + 1 < crossings.length; k++) {
+    const c0 = crossings[k], c1 = crossings[k + 1];
+    if (c0.enters && !c1.enters && c1.s - c0.s > 1e-9) {
+      partner.set(c0, c1);
+      partner.set(c1, c0);
+    }
+  }
+  if (partner.size === 0) return null;
+  const { loops, untouched } = traceLoops(boundaries, partner);
+  const traced = assembleRegions(loops, untouched.filter((c) => signedArea2(c) < 0));
+  const islands = untouched.filter((c) => signedArea2(c) > 0);
+  const pieces = traced.filter((r) => Math.abs(regionArea(r)) > 1e-6);
+  if (islands.length > 0) {
+    const leftover = untouched.filter((c) => !traced.some((r) => r.includes(c)));
+    pieces.push(leftover);
+  }
+  return pieces.map((r) => toPath(r, outRule));
+}
+function evalSeg(s, t) {
+  const u = 1 - t;
+  if (s.length === 2) return { x: u * s[0].x + t * s[1].x, y: u * s[0].y + t * s[1].y };
+  if (s.length === 3) {
+    const a2 = u * u, b2 = 2 * u * t, c2 = t * t;
+    return { x: a2 * s[0].x + b2 * s[1].x + c2 * s[2].x, y: a2 * s[0].y + b2 * s[1].y + c2 * s[2].y };
+  }
+  const a = u * u * u, b = 3 * u * u * t, c = 3 * u * t * t, d = t * t * t;
+  return {
+    x: a * s[0].x + b * s[1].x + c * s[2].x + d * s[3].x,
+    y: a * s[0].y + b * s[1].y + c * s[2].y + d * s[3].y
+  };
 }
-function countBoundaryCrossings(path, a, b, tol) {
-  let n = 0;
-  for (const pl of extractPolylines(path, { flattenTolerance: tol })) {
-    const pts = pl.points;
-    const count = pts.length / 2;
-    const last = pl.closed ? count : count - 1;
-    for (let i = 0; i < last; i++) {
-      const j = (i + 1) % count;
-      const c = { x: pts[i * 2], y: pts[i * 2 + 1] };
-      const dd = { x: pts[j * 2], y: pts[j * 2 + 1] };
-      if (segmentsProperlyCross(a, b, c, dd)) n++;
+function derivSeg(s, t) {
+  const n = s.length - 1;
+  const d = [];
+  for (let i = 0; i < n; i++) d.push({ x: n * (s[i + 1].x - s[i].x), y: n * (s[i + 1].y - s[i].y) });
+  return d.length === 1 ? d[0] : evalSeg(d, t);
+}
+function splitSeg(s, t) {
+  const pts = (c) => {
+    const out = [];
+    for (let i = 0; i < c.length; i += 2) out.push({ x: c[i], y: c[i + 1] });
+    return out;
+  };
+  if (s.length === 2) {
+    const m = evalSeg(s, t);
+    return [[s[0], m], [m, s[1]]];
+  }
+  if (s.length === 3) {
+    const [l2, r2] = splitQuadraticAt(s[0].x, s[0].y, s[1].x, s[1].y, s[2].x, s[2].y, t);
+    return [pts(l2), pts(r2)];
+  }
+  const [l, r] = splitCubicAt(s[0].x, s[0].y, s[1].x, s[1].y, s[2].x, s[2].y, s[3].x, s[3].y, t);
+  return [pts(l), pts(r)];
+}
+function subSeg(s, t0, t1, p0, p1) {
+  if (t1 - t0 <= 0) return null;
+  let out = s;
+  if (t0 > 0) out = splitSeg(out, t0)[1];
+  const u = (t1 - t0) / (1 - t0);
+  if (u < 1) out = splitSeg(out, u)[0];
+  out = out.slice();
+  out[0] = p0;
+  out[out.length - 1] = p1;
+  return out;
+}
+var reverseContour = (c) => c.map((s) => s.slice().reverse()).reverse();
+function sampleContour(c) {
+  const out = [];
+  for (const s of c) {
+    const n = s.length === 2 ? 1 : 16;
+    for (let i = 0; i < n; i++) {
+      const p = evalSeg(s, i / n);
+      out.push(p.x, p.y);
     }
   }
-  return n;
+  return out;
 }
-function splitPathByLine(path, a, b, opts = {}) {
-  const tol = opts.flattenTolerance ?? 0.5;
-  if (a.x === b.x && a.y === b.y) return null;
-  if (countBoundaryCrossings(path, a, b, tol) < 2) return null;
-  const dx = b.x - a.x, dy = b.y - a.y;
-  const len = Math.hypot(dx, dy);
-  const ux = dx / len, uy = dy / len;
-  const nx = -uy, ny = ux;
-  const bb = boundsOfPath(path);
-  const R = (Math.hypot(bb.width, bb.height) + 1) * 4;
-  const mid2 = { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
-  const p0 = { x: mid2.x - ux * R, y: mid2.y - uy * R };
-  const p1 = { x: mid2.x + ux * R, y: mid2.y + uy * R };
-  const sideQuad = (sign) => polygonFromPoints([
-    p0,
-    p1,
-    { x: p1.x + nx * R * sign, y: p1.y + ny * R * sign },
-    { x: p0.x + nx * R * sign, y: p0.y + ny * R * sign }
-  ]);
-  const fillRule = path.kind === "polygon" ? path.fillRule : "nonzero";
-  const sideA = withFillRule(pathIntersect(path, sideQuad(1)), fillRule);
-  const sideB = withFillRule(pathIntersect(path, sideQuad(-1)), fillRule);
-  const isSubstantial = (p) => {
-    if (p.commands.length === 0) return false;
-    const bb2 = boundsOfPath(p);
-    return bb2.width * bb2.height >= 1e-6;
+function signedArea2(c) {
+  const pts = sampleContour(c);
+  let a = 0;
+  for (let i = 0; i < pts.length; i += 2) {
+    const j = (i + 2) % pts.length;
+    a += pts[i] * pts[j + 1] - pts[j] * pts[i + 1];
+  }
+  return a / 2;
+}
+function sideCoeffs(s, o, d) {
+  return s.map((p) => d.x * (p.y - o.y) - d.y * (p.x - o.x));
+}
+function bernstein(f, t) {
+  const u = 1 - t;
+  if (f.length === 2) return u * f[0] + t * f[1];
+  if (f.length === 3) return u * u * f[0] + 2 * u * t * f[1] + t * t * f[2];
+  return u * u * u * f[0] + 3 * u * u * t * f[1] + 3 * u * t * t * f[2] + t * t * t * f[3];
+}
+function signChanges(f, zeroIsPositive) {
+  const sgn = (v) => v > 0 ? 1 : v < 0 ? -1 : zeroIsPositive ? 1 : 0;
+  const cuts = [0, ...criticalPoints(f), 1];
+  const out = [];
+  for (let i = 0; i + 1 < cuts.length; i++) {
+    let lo = cuts[i], hi = cuts[i + 1];
+    const slo = sgn(bernstein(f, lo)), shi = sgn(bernstein(f, hi));
+    if (slo === 0 && i > 0) {
+      const before = sgn(bernstein(f, lo - 1e-7)), after = sgn(bernstein(f, lo + 1e-7));
+      if (before * after < 0) out.push({ t: lo, before, after });
+    }
+    if (slo * shi >= 0) continue;
+    for (let it = 0; it < 64; it++) {
+      const mid = (lo + hi) / 2;
+      if (sgn(bernstein(f, mid)) === slo) lo = mid;
+      else hi = mid;
+    }
+    out.push({ t: (lo + hi) / 2, before: slo, after: shi });
+  }
+  return out;
+}
+function criticalPoints(f) {
+  if (f.length < 3) return [];
+  const n = f.length - 1;
+  const d = f.slice(1).map((v, i) => n * (v - f[i]));
+  let A = 0, B, C;
+  if (d.length === 2) {
+    B = d[1] - d[0];
+    C = d[0];
+  } else {
+    A = d[0] - 2 * d[1] + d[2];
+    B = 2 * (d[1] - d[0]);
+    C = d[0];
+  }
+  const out = [];
+  const scale = Math.max(Math.abs(A), Math.abs(B), Math.abs(C)) || 1;
+  if (Math.abs(A) / scale < 1e-12) {
+    if (Math.abs(B) / scale > 1e-12) out.push(-C / B);
+  } else {
+    const disc = B * B - 4 * A * C;
+    if (disc >= 0) {
+      const q = -0.5 * (B + Math.sign(B || 1) * Math.sqrt(disc));
+      out.push(q / A);
+      if (q !== 0) out.push(C / q);
+    }
+  }
+  return out.filter((t) => t > 0 && t < 1).sort((x, y) => x - y);
+}
+function endSide(f, fromStart) {
+  const n = f.length;
+  for (let i = 1; i < n; i++) {
+    const v = fromStart ? f[i] : f[n - 1 - i];
+    if (v !== 0) return Math.sign(v);
+  }
+  return 0;
+}
+function parseContours(path) {
+  if (path.kind === "rect") {
+    const { x, y, width: w, height: h } = path;
+    const p = [{ x, y }, { x: x + w, y }, { x: x + w, y: y + h }, { x, y: y + h }];
+    return [p.map((q, i) => [q, p[(i + 1) % 4]])];
+  }
+  const out = [];
+  let cur = [];
+  let start = { x: 0, y: 0 };
+  let pen = start;
+  const finish = () => {
+    if (cur.length > 0 && (pen.x !== start.x || pen.y !== start.y)) cur.push([pen, start]);
+    if (cur.length > 0) out.push(cur);
+    cur = [];
+    pen = start;
+  };
+  const c = path.coords;
+  let k = 0;
+  for (const cmd of path.commands) {
+    if (cmd === PATH_M) {
+      finish();
+      start = pen = { x: c[k], y: c[k + 1] };
+      k += 2;
+    } else if (cmd === PATH_L) {
+      const e = { x: c[k], y: c[k + 1] };
+      if (e.x !== pen.x || e.y !== pen.y) cur.push([pen, e]);
+      pen = e;
+      k += 2;
+    } else if (cmd === PATH_Q) {
+      const e = { x: c[k + 2], y: c[k + 3] };
+      cur.push([pen, { x: c[k], y: c[k + 1] }, e]);
+      pen = e;
+      k += 4;
+    } else if (cmd === PATH_C) {
+      const e = { x: c[k + 4], y: c[k + 5] };
+      cur.push([pen, { x: c[k], y: c[k + 1] }, { x: c[k + 2], y: c[k + 3] }, e]);
+      pen = e;
+      k += 6;
+    } else if (cmd === PATH_Z) {
+      finish();
+    }
+  }
+  finish();
+  return out;
+}
+function contoursIntersect(contours, tol) {
+  const edges = [];
+  contours.forEach((contour, ci) => {
+    const pts = [];
+    for (const s of contour) {
+      let n = 1;
+      if (s.length > 2) {
+        let len = 0;
+        for (let i = 0; i + 1 < s.length; i++) len += Math.hypot(s[i + 1].x - s[i].x, s[i + 1].y - s[i].y);
+        n = Math.min(64, Math.max(2, Math.ceil(Math.sqrt(len / Math.max(tol, 1e-3)))));
+      }
+      for (let i = 0; i < n; i++) pts.push(evalSeg(s, i / n));
+    }
+    for (let i = 0; i < pts.length; i++) {
+      const p = pts[i], q = pts[(i + 1) % pts.length];
+      edges.push({ x0: p.x, y0: p.y, x1: q.x, y1: q.y, c: ci, i, n: pts.length });
+    }
+  });
+  for (let i = 0; i < edges.length; i++) {
+    const e = edges[i];
+    for (let j = i + 1; j < edges.length; j++) {
+      const f = edges[j];
+      if (e.c === f.c && (j - i === 1 || i === 0 && f.i === f.n - 1)) continue;
+      if (Math.max(e.x0, e.x1) < Math.min(f.x0, f.x1) || Math.max(f.x0, f.x1) < Math.min(e.x0, e.x1)) continue;
+      if (Math.max(e.y0, e.y1) < Math.min(f.y0, f.y1) || Math.max(f.y0, f.y1) < Math.min(e.y0, e.y1)) continue;
+      if (segmentsCross(e.x0, e.y0, e.x1, e.y1, f.x0, f.y0, f.x1, f.y1)) return true;
+    }
+  }
+  return false;
+}
+function windingAt(q, contours) {
+  const dir2 = { x: 1, y: 0 };
+  let w = 0;
+  for (const contour of contours) {
+    for (const s of contour) {
+      for (const c of signChanges(sideCoeffs(s, q, dir2), true)) {
+        if (evalSeg(s, c.t).x > q.x) w += c.after > 0 ? 1 : -1;
+      }
+    }
+  }
+  return w;
+}
+function orientBoundaries(contours, fillRule) {
+  const filled = (q) => {
+    const w = windingAt(q, contours);
+    return fillRule === "evenodd" ? (w & 1) !== 0 : w !== 0;
+  };
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const c of contours) for (const s of c) for (const p of s) {
+    minX = Math.min(minX, p.x);
+    maxX = Math.max(maxX, p.x);
+    minY = Math.min(minY, p.y);
+    maxY = Math.max(maxY, p.y);
+  }
+  const eps = Math.max(Math.hypot(maxX - minX, maxY - minY) * 1e-6, 1e-9);
+  const out = [];
+  for (const contour of contours) {
+    let probe = contour[0];
+    let best = -1;
+    for (const s of contour) {
+      const len = Math.hypot(s[s.length - 1].x - s[0].x, s[s.length - 1].y - s[0].y);
+      if (len > best) {
+        best = len;
+        probe = s;
+      }
+    }
+    const p = evalSeg(probe, 0.5);
+    let tan = derivSeg(probe, 0.5);
+    const tl = Math.hypot(tan.x, tan.y);
+    if (tl === 0) continue;
+    tan = { x: tan.x / tl, y: tan.y / tl };
+    const left = filled({ x: p.x - tan.y * eps, y: p.y + tan.x * eps });
+    const right = filled({ x: p.x + tan.y * eps, y: p.y - tan.x * eps });
+    if (left && !right) out.push(contour);
+    else if (right && !left) out.push(reverseContour(contour));
+  }
+  return out;
+}
+function findCrossings(boundaries, a, b) {
+  const d = { x: b.x - a.x, y: b.y - a.y };
+  const dd = d.x * d.x + d.y * d.y;
+  const out = [];
+  const push = (contour, seg, t, before, after) => {
+    const pt = evalSeg(boundaries[contour][seg], t);
+    const s = ((pt.x - a.x) * d.x + (pt.y - a.y) * d.y) / dd;
+    if (s < 0 || s > 1) return;
+    out.push({ contour, seg, t, pt, s, enters: before > 0 && after < 0 });
+  };
+  boundaries.forEach((contour, ci) => {
+    const fs = contour.map((s) => sideCoeffs(s, a, d));
+    const n = contour.length;
+    fs.forEach((f, si) => {
+      for (const c of signChanges(f, false)) push(ci, si, c.t, c.before, c.after);
+      if (f[0] !== 0) return;
+      const after = endSide(f, true);
+      if (after === 0) return;
+      let before = 0;
+      for (let k = 1; k <= n && before === 0; k++) before = endSide(fs[(si - k + n) % n], false);
+      if (before !== 0 && before !== after) push(ci, si, 0, before, after);
+    });
+  });
+  return out.sort((x, y) => x.s - y.s);
+}
+function traceLoops(boundaries, partner) {
+  const byContour = /* @__PURE__ */ new Map();
+  for (const c of partner.keys()) {
+    const list2 = byContour.get(c.contour) ?? [];
+    list2.push(c);
+    byContour.set(c.contour, list2);
+  }
+  const arcFrom = /* @__PURE__ */ new Map();
+  const untouched = [];
+  boundaries.forEach((contour, ci) => {
+    const cuts = byContour.get(ci);
+    if (!cuts) {
+      untouched.push(contour);
+      return;
+    }
+    cuts.sort((x, y) => x.seg - y.seg || x.t - y.t);
+    for (let k = 0; k < cuts.length; k++) {
+      const from = cuts[k], to = cuts[(k + 1) % cuts.length];
+      arcFrom.set(from, { segs: arcBetween(contour, from, to, cuts.length === 1), end: to });
+    }
+  });
+  const loops = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const start of arcFrom.keys()) {
+    if (seen.has(start)) continue;
+    const loop = [];
+    let at = start;
+    while (!seen.has(at)) {
+      seen.add(at);
+      const arc = arcFrom.get(at);
+      loop.push(...arc.segs);
+      const other = partner.get(arc.end);
+      loop.push([arc.end.pt, other.pt]);
+      at = other;
+    }
+    loops.push(loop);
+  }
+  return { loops, untouched };
+}
+function arcBetween(contour, from, to, whole) {
+  const out = [];
+  const add = (s) => {
+    if (s) out.push(s);
   };
-  const pieces = [sideA, sideB].filter(isSubstantial);
-  return pieces.length === 2 ? pieces : null;
+  if (!whole && to.seg === from.seg && to.t > from.t) {
+    add(subSeg(contour[from.seg], from.t, to.t, from.pt, to.pt));
+    return out;
+  }
+  const n = contour.length;
+  const first = contour[from.seg];
+  add(subSeg(first, from.t, 1, from.pt, first[first.length - 1]));
+  for (let i = (from.seg + 1) % n; i !== to.seg; i = (i + 1) % n) out.push(contour[i]);
+  const last = contour[to.seg];
+  add(subSeg(last, 0, to.t, last[0], to.pt));
+  return out;
+}
+function assembleRegions(outers, holes) {
+  const regions = outers.map((o) => ({ loops: [o], ring: sampleContour(o), area: signedArea2(o) }));
+  for (const h of holes) {
+    const hp = evalSeg(h[0], 0.5);
+    let best = null;
+    for (const r of regions) {
+      if (pointInPolygon(r.ring, hp.x, hp.y) && (!best || r.area < best.area)) best = r;
+    }
+    best?.loops.push(h);
+  }
+  return regions.map((r) => r.loops);
 }
-function withFillRule(p, fillRule) {
-  return p.fillRule === fillRule ? p : { ...p, fillRule };
+var regionArea = (r) => r.reduce((s, c) => s + signedArea2(c), 0);
+function toPath(loops, fillRule) {
+  const cmds = [];
+  const xs = [];
+  for (const loop of loops) {
+    cmds.push(PATH_M);
+    xs.push(loop[0][0].x, loop[0][0].y);
+    for (const s of loop) {
+      cmds.push(s.length === 2 ? PATH_L : s.length === 3 ? PATH_Q : PATH_C);
+      for (let i = 1; i < s.length; i++) xs.push(s[i].x, s[i].y);
+    }
+    cmds.push(PATH_Z);
+  }
+  return { kind: "polygon", commands: new Uint8Array(cmds), coords: new Float32Array(xs), fillRule };
 }
 
 // src/features/paths/unionBoundsPath.ts
@@ -30471,13 +31351,13 @@ function findSpan(n, p, u, knots) {
   if (u <= knots[p]) return p;
   let lo = p;
   let hi = n;
-  let mid2 = lo + hi >> 1;
-  while (u < knots[mid2] || u >= knots[mid2 + 1]) {
-    if (u < knots[mid2]) hi = mid2;
-    else lo = mid2;
-    mid2 = lo + hi >> 1;
+  let mid = lo + hi >> 1;
+  while (u < knots[mid] || u >= knots[mid + 1]) {
+    if (u < knots[mid]) hi = mid;
+    else lo = mid;
+    mid = lo + hi >> 1;
   }
-  return mid2;
+  return mid;
 }
 function basisFunctions(i, u, p, knots) {
   const N = new Array(p + 1).fill(0);
@@ -32168,7 +33048,7 @@ function useRig(options) {
 }
 
 // src/layout/snaps.ts
-function dist22(a, b) {
+function dist2(a, b) {
   const dx = a.x - b.x;
   const dy = a.y - b.y;
   return dx * dx + dy * dy;
@@ -32176,9 +33056,9 @@ function dist22(a, b) {
 function nearestOf(targets, pointer) {
   if (targets.length === 0) return null;
   let best = targets[0];
-  let bestD = dist22(best.origin, pointer);
+  let bestD = dist2(best.origin, pointer);
   for (let i = 1; i < targets.length; i++) {
-    const d = dist22(targets[i].origin, pointer);
+    const d = dist2(targets[i].origin, pointer);
     if (d < bestD) {
       bestD = d;
       best = targets[i];
@@ -32198,7 +33078,7 @@ function nearestWithin(opts) {
     pickTarget(targets, pointer) {
       const got = nearestOf(targets, pointer);
       if (got === null) return null;
-      return dist22(got.origin, pointer) <= tol2 ? got : null;
+      return dist2(got.origin, pointer) <= tol2 ? got : null;
     }
   };
 }
@@ -32487,6 +33367,6 @@ function mergeContributions(...bundles) {
   return out;
 }
 
-export { ACTION_GLYPHS, ANCHOR_HIT_BASE_PX, ActionsProviderIfRoot, AlignBottomIcon, AlignCenterXIcon, AlignCenterYIcon, AlignLeftIcon, AlignRightIcon, AlignTopIcon, ArrowIcon, BUILTIN_MARKERS, BUNDLE_TOOLS, BringForwardIcon, BringToFrontIcon, CROSSHAIR_HALO, CURVE_REPS, CanvasView, ColorOverrideRegistry, CopyIcon, CropIcon, CursorCoordsHud, CutIcon, DEFAULT_DEBUG_STROKES, DEFAULT_DEBUG_THEME, 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, DeleteIcon, DepRegistryProviderIfRoot, DeviceProfileProvider, DistributeHorizontalIcon, DistributeVerticalIcon, DivideIcon, DuplicateIcon, EASINGS, EFFECT_KIT_UNIFORMS, EFFECT_VERT_SRC, EllipseIcon, ExcludeIcon, EyedropperIcon, FALLBACK_FIT_VIEW, FlipXIcon, FlipYIcon, GHOST_STROKE, GroupIcon, HANDLE_BASE_PX, HandIcon, IDENTITY_COLOR_MATRIX, IDENTITY_JOINT, IDENTITY_POSE_COMPOSITION, ImageIcon, IntersectIcon, KIT_SHAPE_KINDS, KIT_STANDARD_ACTION_IDS, LassoIcon, LineIcon, MESH_BAKE_SIZE, MESH_GRADIENT_KIND, MINIMAP_CENTER, MINIMAP_PAN, MIXED, MOVE_ANCHORS, MinimapCanvas, OUTLINE_MIN_SCREEN_PX, PAINTED_CURSOR_LAYER_ID, PATH_ANCHOR_CHROME_ID, PasteIcon, PenIcon, PencilIcon, PickHud, PointerProviderIfRoot, PolygonIcon, RECT_POSE_COMPOSITION, RIGID_POSE_COMPOSITION, ROTATION_HANDLE_BASE_PX, RectIcon, RedoIcon, SPRING_PRESETS, SPRITE_STRIDE, SceneCanvas, SceneViewCanvas, SelectIcon, SelectionContextProvider, SelectionContextProviderIfRoot, SendBackwardIcon, SendToBackIcon, ShaderCompileError, StarIcon, SubtractIcon, TOOL_PREF_KINDS, TextIcon, UNION_OF_CHILDREN, UndoIcon, UngroupIcon, UnionIcon, UnknownIcon, VERSION, VIEW_ANIMATION_KEY, WHEEL_ZOOM_STEP, WeaselProvider, WeaselRenderer, ZOOM_FLOOR, _resetMarkersForTests, _resetPaintKindsForTests, actionIs, actionShortcuts, alignDeltaFor, alignInsertBehavior, alignMoveBehavior, alignResizeBehavior, always, and, animateLifecycle, animateOnSetPose, annulusSemiAxes, applyBooleanOp, applyStyleToRange, areaSelectAction, arrayAdapter, asNodeId, asPaint, bakeMesh, bezierCubic, bezierQuadratic, bindRig, blendPoses, blur, buildChromeCtx, buildGradientRamp, buildSceneViewCommands, canBringForward, canHover, canSendBackward, capabilityAll, capabilityIn, capabilityIs, capabilityNot, caretIndexAt, cellAt, centerRootOn, charOffsetToDomPosition, circlePath, clampView, clearSelectionAction, clipboardCopyAction, clipboardCutAction, clipboardPasteAction, cloneAction, coarsePointer, composeAffordanceLayer, composePath, composeRectPose, composeRigidPose, composeSelectionPose, composeWorldPose, computeFitView, computeFitViewport, computeIndicatorCommand, computeWheelAction, cond, constrainTo45, containedThenNearest, cornerWeights, countPathAnchors, createCellHighlightLayer, createChildrenLayer, createCornerResizeAffordance, createDebugOverlayLayer, createDebugSink, createGridLayer, createGuidesLayer, createHistory2 as createHistory, createKeyState, createLinkedCursorContribution, createMinimapContribution, createMoveToIndexOp, createNodeProperties, createNodeRouting, createPaintedCursorLayer, createParallaxLayer, createPathAnchorAffordances, createPathEditingOverlayLayer, createPathLayer, createPenPreviewLayer, createPoseFeed, createPoseOverrides, createReorderOp, createRotationAffordance, createScene, createSelectionHandlesLayer, createSelectionOutlineLayer, createSelectionOverlayLayer, createSetDataOp, createSetLayerOp, createSetPathOp, createSetTextOp, createSlew, createTextLayer, createTiledLayer, createVelocityTracker, createViewResolver, createViewportLayer, crosshairRects, cubicBezierEasing, cullDrawCommands, cycleFill, cycleVertexColors, decomposePath, decomposeRectPose, decomposeRigidPose, defaultCommitAdapter, defaultDrawOne, defaultLabelTextRenderer, defaultNodeProperties, defaultNodeRouting, defaultVisibilityRules, defineTool, defineViewportTool, definesFrame, deriveAlignmentGuides, deriveParallaxView, derivedDepOf, derivedPose, documentPose, domPositionToCharOffset, domToRuns, drawLayers, drawOneLayer, easeIn, easeInBack, easeInBounce, easeInCirc, easeInCubic, easeInElastic, easeInExpo, easeInOut, easeInOutBack, easeInOutBounce, easeInOutCirc, easeInOutCubic, easeInOutElastic, easeInOutExpo, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInOutSine, easeInQuad, easeInQuart, easeInQuint, easeInSine, easeOut, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, editAnchorsAction, effectivePose, effectiveRangeStyle, enterTextEditAction, enumerateAnchors, evalPatch, fillInPoseFrame, fillToBoundsFrame, findNodeShape, findShapeInk, findShapeSilhouette, fitTextPose, fitToBounds, fitViewToBounds, fitZoom, flattenPreviews, 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, insertPreviewExtent, interpolateView, isBuiltinToolPref, isGradientFill, isLayerPainted, isLayerVisible, isMeshGradientFill, isPatternSpec, isTensorPatch, isValidPatch, isVectorImageSrc, keySpecShortcut, lassoSelectAction, linear, listMarkers, listPaintKinds, makePinchZoomAction, makeViewportWheelPanAction, makeViewportZoomAction, markerDrawCommands, markerInset, markerKeyOf, markerSites, mat3, matchAlignment, meanScale, mergeAlphaFromPrev, mergeContributions, meshBounds, meshGradientXml, minimapCenterAction, minimapPanAction, modeIn, modeIs, modeNot, modifierHeld, momentum, moveAction, multiActive, nearest, nearestWithin, nestedHitTester, never, nodeHasFlag, none, normalizeHex, normalizeView, normalizeZoom, not, nurbs, openFilePicker, or, paintAlpha, paintKindOf, paintWithAlpha, paintWithColor, parseColor, parseColorToRgba255, parseDebugFlags, patchBounds, patchCorner, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathDistanceToPoint, pathDivide, pathExclude, pathFromD, pathInPoseFrame, pathInWorld, pathIntersect, pathIntersectsPolygon, pathIntersectsRect, pathOriginProjection, pathSubtract, pathToAnchors, pathUnion, pickTopMostHit, pinchZoomAction, planPixelRender, pointInTextPose, poseRotationOf, prefUnit, pressureToWidth, rainbowVertexColors, rebaseLocalPose, rectMarkerPath, registerContentHandler, registerEffect, registerMarker, registerNodeShape, registerPaintKind, registerProgram, renderLabel, renderSceneToCanvas, renderSceneToPixels, resizeAction, resolveColor, resolveEasing, resolveFillPattern, resolveMarkerSize, resolveOverlays, resolvePatternSpec, resolvePreviews, resolveSkeleton, resolveStrokeWidth, resolveVisibility, rgbaToHex, rigidRigApply, rotateAction, rotateAroundAABBCenter, rotatePathAround, rotationDegreesUnit, rotationHandle, roundRectPath, roundToCell, runsToDom, sampleGradientStops, sampleTrack, sceneFromJSON, sceneNodeClientRect, sceneSelectionStore, sceneToAdapter, screenToWorld, seedMeshPatch, selectFromLasso, selectionAtLeast, selectionEmpty, selectionIs, setFlagOverRange, shapeCoversPoint, slewToward, sliceAction, snapPoint, solid, solidVertexColors, spiro, splitPathByLine, splitSubpaths, springPose, springVertexColors, squarePath, staggerVertexColors, startThresholdDrag, strokeInsets, strokeOf, strokeWith, styleAtRange, subscribeImageReady, tessellate, tessellateStroke, textCommand, textCommandFromPose, textCommandFromRuns, tileGrid, tiledProject, toHex8, translateRectPose, trimPolyline, tweenPose, tweenVertexColors, unionBoundsPath, unionOfChildren, unionOfChildrenVia, useAlign, useAnimator, useArrayAdapter, useAutoCenter, useBooleans, useBooleansAdapter, useCanvasFocus, useCanvasSize, useDecayLoop, useDeviceProfile, useDistribute, useDragGesture, useDragHandle, useDragRadial, useDragRect, useDropZone, useEllipseTool, useEyedropperTool, useGridCellHover, useGuides, useHandTool, useHandleDrag, useHostAnchor, useHoverTracking, useImageTool, useKeyState, useKeybindings, useLassoTool, useLineTool, useNodeOverlayFrame, usePenTool, usePencilTool, usePinchGesture, usePointerStylus, usePolygonTool, usePoseCompositionDepSource, usePoseDescriptorDepSource, usePoseRun, usePublishSelection, useRectTool, useResizePolicy, useRig, useScene, useSceneAdapter, useSceneTextEdit, useSelectTool, useSelection, useSelectionContext, useSimulation, useSliceDep, useStandardActions, useStarTool, useTextEdit, useTextTool, useTools, useVelocityTracker, useViewAnimation, useViewAnimationOn, useVisibleRaf, viewToMat3, viewToTransform, viewZoom, viewportDragPanAction, viewportWheelPanAction, viewportZoomAction, viewportsAt, vignette, wheelPan, wheelZoom, wheelZoomFactor, when, withAlpha01, withCoord, withGradientKind, worldEditToStorage, worldPoseLookup, worldToScreen, zoomAt, zoomAtLeast };
-//# sourceMappingURL=chunk-MZAIDI6D.js.map
-//# sourceMappingURL=chunk-MZAIDI6D.js.map
+export { ACTION_GLYPHS, ANCHOR_HIT_BASE_PX, AREA_SELECT_ID, ActionsProviderIfRoot, AlignBottomIcon, AlignCenterXIcon, AlignCenterYIcon, AlignLeftIcon, AlignRightIcon, AlignTopIcon, ArrowIcon, BUILTIN_MARKERS, BUILTIN_TOOL_IDS, BringForwardIcon, BringToFrontIcon, CROSSHAIR_HALO, CURVE_REPS, CanvasView, ColorOverrideRegistry, CopyIcon, CropIcon, CursorCoordsHud, CutIcon, DEFAULT_DEBUG_STROKES, DEFAULT_DEBUG_THEME, 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, DRAG_PAN_ID, DeleteIcon, DepRegistryProviderIfRoot, DeviceProfileProvider, DistributeHorizontalIcon, DistributeVerticalIcon, DivideIcon, DuplicateIcon, EASINGS, EFFECT_KIT_UNIFORMS, EFFECT_VERT_SRC, EllipseIcon, ExcludeIcon, EyedropperIcon, FALLBACK_FIT_VIEW, FEATURE_ACTION_IDS, FlipXIcon, FlipYIcon, GHOST_STROKE, GroupIcon, HANDLE_BASE_PX, HandIcon, IDENTITY_COLOR_MATRIX, IDENTITY_JOINT, IDENTITY_POSE_COMPOSITION, ImageIcon, IntersectIcon, KIT_SHAPE_KINDS, KIT_STANDARD_ACTION_IDS, LassoIcon, LineIcon, MESH_BAKE_SIZE, MESH_GRADIENT_KIND, MINIMAP_CENTER, MINIMAP_PAN, MIXED, MOVE_ANCHORS, MinimapCanvas, OUTLINE_MIN_SCREEN_PX, PAINTED_CURSOR_LAYER_ID, PATH_ANCHOR_CHROME_ID, PasteIcon, PenIcon, PencilIcon, PickHud, PointerProviderIfRoot, PolygonIcon, RECT_POSE_COMPOSITION, RIGID_POSE_COMPOSITION, ROTATION_HANDLE_BASE_PX, RectIcon, RedoIcon, SCENE_CANVAS_FEATURES, SELECTION_MOVE_ID, SELECTION_TRANSFORM_ID, SPRING_PRESETS, SPRITE_STRIDE, SceneCanvas, SceneViewCanvas, SelectIcon, SelectionContextProvider, SelectionContextProviderIfRoot, SendBackwardIcon, SendToBackIcon, ShaderCompileError, StarIcon, SubtractIcon, TOOL_DRIVEN_ACTION_IDS, TOOL_PREF_KINDS, TextIcon, UNION_OF_CHILDREN, UndoIcon, UngroupIcon, UnionIcon, UnknownIcon, VERSION, VIEW_ANIMATION_KEY, WHEEL_ZOOM_STEP, WeaselProvider, WeaselRenderer, ZOOM_FLOOR, _resetMarkersForTests, _resetPaintKindsForTests, actionIs, actionShortcuts, alignDeltaFor, alignInsertBehavior, alignMoveBehavior, alignResizeBehavior, always, and, animateLifecycle, animateOnSetPose, annulusSemiAxes, applyBooleanOp, applyStyleToRange, areaSelectAction, areaSelectContribution, arrayAdapter, asNodeId, asPaint, bakeMesh, bezierCubic, bezierQuadratic, bindRig, blendPoses, blur, buildChromeCtx, buildGradientRamp, buildSceneViewCommands, canBringForward, canHover, canSendBackward, capabilityAll, capabilityIn, capabilityIs, capabilityNot, caretIndexAt, cellAt, centerRootOn, charOffsetToDomPosition, circlePath, clampView, clearSelectionAction, clipboardCopyAction, clipboardCutAction, clipboardPasteAction, cloneAction, coarsePointer, composeAffordanceLayer, composePath, composeRectPose, composeRigidPose, composeSelectionPose, composeWorldPose, computeFitView, computeFitViewport, computeIndicatorCommand, computeWheelAction, cond, constrainTo45, containedThenNearest, cornerWeights, countPathAnchors, createCellHighlightLayer, createChildrenLayer, createCornerResizeAffordance, createDebugOverlayLayer, createDebugSink, createGridLayer, createGuidesLayer, createHistory2 as createHistory, createKeyState, createLinkedCursorContribution, createMinimapContribution, createMoveToIndexOp, createNodeProperties, createNodeRouting, createPaintedCursorLayer, createParallaxLayer, createPathAnchorAffordances, createPathEditingOverlayLayer, createPathLayer, createPenPreviewLayer, createPoseFeed, createPoseOverrides, createReorderOp, createRotationAffordance, createScene, createSelectionHandlesLayer, createSelectionOutlineLayer, createSelectionOverlayLayer, createSetDataOp, createSetLayerOp, createSetPathOp, createSetTextOp, createSlew, createTextLayer, createTiledLayer, createVelocityTracker, createViewResolver, createViewportLayer, crosshairRects, cubicBezierEasing, cullDrawCommands, cycleFill, cycleVertexColors, decomposePath, decomposeRectPose, decomposeRigidPose, defaultCommitAdapter, defaultDrawOne, defaultLabelTextRenderer, defaultNodeProperties, defaultNodeRouting, defaultVisibilityRules, definesFrame, deriveAlignmentGuides, deriveParallaxView, derivedDepOf, derivedPose, documentPose, domPositionToCharOffset, domToRuns, dragPanContribution, drawLayers, drawOneLayer, easeIn, easeInBack, easeInBounce, easeInCirc, easeInCubic, easeInElastic, easeInExpo, easeInOut, easeInOutBack, easeInOutBounce, easeInOutCirc, easeInOutCubic, easeInOutElastic, easeInOutExpo, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInOutSine, easeInQuad, easeInQuart, easeInQuint, easeInSine, easeOut, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, editAnchorsAction, effectivePose, effectiveRangeStyle, enterTextEditAction, enumerateAnchors, evalPatch, fillInPoseFrame, fillToBoundsFrame, findNodeShape, findShapeInk, findShapeSilhouette, fitTextPose, fitToBounds, fitViewToBounds, fitZoom, flattenPreviews, 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, insertPreviewExtent, interpolateView, isBuiltinToolPref, isGradientFill, isLayerPainted, isLayerVisible, isMeshGradientFill, isPatternSpec, isPlainObject, isTensorPatch, isValidPatch, isVectorImageSrc, keySpecShortcut, lassoSelectAction, linear, listGradientKinds, listMarkers, listPaintKinds, makePinchZoomAction, makeViewportWheelPanAction, makeViewportZoomAction, markerInset, markerKeyOf, markerRegistry, markerSites, mat3, matchAlignment, meanScale, mergeAlphaFromPrev, mergeContributions, meshBounds, meshFromStops, meshGradientXml, meshStops, minimapCenterAction, minimapPanAction, modeDecorationLayer, modeIn, modeIs, modeNot, modifierHeld, momentum, moveAction, multiActive, nearest, nearestWithin, nestedHitTester, never, nodeHasFlag, none, normalizeHex, normalizeView, normalizeZoom, not, nurbs, onEmptyCanvas, openFilePicker, or, paintAlpha, paintKindOf, paintKindRegistry, paintWithAlpha, paintWithColor, parseColor, parseColorToRgba255, parseDebugFlags, patchBounds, patchCorner, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathDistanceToPoint, pathDivide, pathExclude, pathFromD, pathInPoseFrame, pathInWorld, pathIntersect, pathIntersectsPolygon, pathIntersectsRect, pathOriginProjection, pathSubtract, pathToAnchors, pathUnion, pickTopMostHit, pinchZoomAction, planPixelRender, pointInTextPose, poseRotationOf, prefUnit, pressureToWidth, programSourceRegistry, rainbowVertexColors, rebaseLocalPose, rectMarkerPath, registerContentHandler, registerEffect, registerMarker, registerNodeShape, registerPaintKind, registerProgram, renderLabel, renderSceneToCanvas, renderSceneToPixels, resizeAction, resolveColor, resolveEasing, resolveFillPattern, resolveMarkerSize, resolveOverlays, resolvePatternSpec, resolvePreviews, resolveSkeleton, resolveStrokeWidth, resolveVisibility, rgbaToHex, rigidRigApply, rotateAction, rotateAroundAABBCenter, rotatePathAround, rotationDegreesUnit, rotationHandle, roundRectPath, roundToCell, runsToDom, sampleGradientStops, sampleTrack, sceneFromJSON, sceneNodeClientRect, sceneSelectionStore, sceneToAdapter, screenToWorld, seedMeshPatch, selectFromLasso, selectionAtLeast, selectionEmpty, selectionIs, selectionMoveBindings, selectionMoveContribution, selectionTransformBindings, selectionTransformContribution, setFlagOverRange, shapeCoversPoint, slewToward, sliceAction, snapPoint, solid, solidVertexColors, spiro, splitPathBySegment, splitSubpaths, springPose, springVertexColors, squarePath, staggerVertexColors, startThresholdDrag, strokeInsets, strokeOf, strokeWith, styleAtRange, subscribeImageReady, subscribeToSources, switchGradientKind, tessellate, tessellateStroke, textCommand, textCommandFromPose, textCommandFromRuns, tileGrid, tiledProject, toHex8, translateRectPose, trimPolyline, tweenPose, tweenVertexColors, unionBoundsPath, unionOfChildren, unionOfChildrenVia, useAlign, useAnimator, useArrayAdapter, useAutoCenter, useBooleans, useBooleansAdapter, useCanvasFocus, useCanvasSize, useDecayLoop, useDeviceProfile, useDistribute, useDragGesture, useDragHandle, useDragRadial, useDragRect, useDropZone, useEllipseTool, useEyedropperTool, useGridCellHover, useGuides, useHandTool, useHandleDrag, useHostAnchor, useHoverTracking, useImageTool, useKeyState, useKeybindings, useLassoTool, useLineTool, useNodeOverlayFrame, usePenTool, usePencilTool, usePointerStylus, usePolygonTool, usePoseCompositionDepSource, usePoseDescriptorDepSource, usePoseRun, usePublishSelection, useRectTool, useResizePolicy, useRig, useScene, useSceneAdapter, useSceneTextEdit, useSelectTool, useSelection, useSelectionContext, useSimulation, useSliceDep, useStandardActions, useStarTool, useTextEdit, useTextTool, useTools, useVelocityTracker, useViewAnimation, useViewAnimationOn, useVisibleRaf, viewToMat3, viewToTransform, viewZoom, viewportDragPanAction, viewportWheelPanAction, viewportZoomAction, viewportsAt, vignette, wheelPan, wheelZoom, wheelZoomFactor, when, withAlpha01, withCoord, withGradientKind, workspaceTintLayer, worldEditToStorage, worldPoseLookup, worldToScreen, zoomAt, zoomAtLeast };
+//# sourceMappingURL=chunk-G4ZGQMY7.js.map
+//# sourceMappingURL=chunk-G4ZGQMY7.js.map