@weasel-js/core 1.5.1 → 1.6.0

package/dist/{chunk-GREL4MVO.js → chunk-THCSDHII.js}

@@ -1,8 +1,8 @@
-import { rotatePoint, aabbCenter, extractPolylines, createSimulation } from './chunk-LXJDWBEL.js';
-import { createReparentOp, createTransformOp, snap } from './chunk-P6MGECVO.js';
-import { fixedCornerOf, DEFAULT_RESIZE_BEHAVIORS, CORNER_ANCHORS, cornerPoint } from './chunk-XXQ6FLCJ.js';
-import { resolveUnit, ANGLE_RADIANS, withinPxRadius, scaleDelta, pxExtent, withinPxBox, pointToGridCell } from './chunk-HAGOFNP5.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-3LPQ2XZG.js';
+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 } from './chunk-T3UQ3F6R.js';
 import { createSetSelectionOp } from './chunk-DOBSZOPR.js';
 import { registerOpFactory, createInsertOp, createDeleteOp, rebuildOp } from './chunk-4RJP2N2L.js';
@@ -10,17 +10,17 @@ import { getTexture, chunks, dots, crosshatch, hatch } from './chunk-BJN5ZRIJ.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';
-import { dashForStrokeStyle, strokeDashStyleOf, resolveScreenLength, alignedStrokeRect, lerpColorArray, srgbU8ToOklab, oklabToOklch, oklchToOklab, oklabToSrgbU8 } from '@weasel-js/paint';
-export { STROKE_DASH_RATIOS, alignedStrokeRect, dashForStrokeStyle, lerpColorArray, lerpOklab, lerpOklch, oklabToOklch, oklabToSrgbU8, oklchToOklab, resolveScreenLength, srgbU8ToOklab, strokeDashStyleOf } from '@weasel-js/paint';
+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';
-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, verticalAlignOffset } 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, clientToCanvasRect, isEditableTarget } from '@weasel-js/routing';
-export { ALWAYS, ActionDisabledReason, COARSE_TARGET_SCALE, DEFAULT_ALLOWED_CAPABILITIES, DEFAULT_DEVICE_PROFILE, NEVER, actionBindings, buildRuleCtx, clientToCanvas, createDispatcher, deleteScratch, describeRule, evaluate, evaluateEnabled, getScratch, isEditableTarget, liveScope, matchesKeyBinding, mergeContributions, openPointerSession, resolveDeviceProfile, resolveParams, scopeBindings, scratchKey, setScratch, specificity } 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, mergeContributions, openPointerSession, resolveDeviceProfile, resolveParams, scopeBindings, scratchKey, setScratch, specificity } from '@weasel-js/routing';
 import { ActiveToolContextProviderIfRoot, useOptionalActiveToolContext, useTools as useTools$1, useOptionalDepRegistry, DepRegistryProvider, useActionsRegistry, ActionsScope, ActionsProvider, useDepRegistry, useGestureDispatcher, useDepSource, ActiveToolContextProvider } from '@weasel-js/routing/react';
-export { ActionsProvider, ActionsScope, ActiveToolContextProvider, ActiveToolContextProviderIfRoot, DepRegistryProvider, useAction, useActionsRegistry, useActiveToolContext, useDepRegistry, useDepSource, useGestureDispatcher, useOptionalActiveToolContext, useOptionalDepRegistry } from '@weasel-js/routing/react';
-import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+export { ActionsProvider, ActionsScope, ActiveToolContextProvider, ActiveToolContextProviderIfRoot, DepRegistryProvider, useAction, useActionsRegistry, useActiveToolContext, useDepRegistry, useDepSource, useGestureDispatcher, useOngoingAction, useOptionalActiveToolContext, useOptionalDepRegistry } 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';
 import { createPaintedCursorState, GLYPHS, cursorWorldSize, cursorPaintOps, chromeLineWidthScale, cursorPaintMatrix, resolveCursorTier, cursorFor } from '@weasel-js/cursor';
@@ -29,7 +29,7 @@ import { createHistory } from '@weasel-js/history';
 export * from '@weasel-js/history';
 
 // src/version.ts
-var VERSION = "1.5.1" ;
+var VERSION = "1.6.0" ;
 
 // src/features/grid/roundToCell.ts
 function roundToCell(value, cellSize) {
@@ -757,6 +757,16 @@ var GLTextureCache = class {
 };
 
 // src/renderer/cache/GLImageCache.ts
+var DEFAULT_MAX_TEXTURE_SIDE = 4096;
+var live = /* @__PURE__ */ new Set();
+function releaseImageSource(key) {
+  for (const cache7 of live) cache7.release(key);
+}
+function maxImageTextureSide() {
+  let side = Infinity;
+  for (const cache7 of live) side = Math.min(side, cache7.maxTextureSide);
+  return Number.isFinite(side) ? side : DEFAULT_MAX_TEXTURE_SIDE;
+}
 var GLImageCache = class {
   /** `minification` selects the MIN_FILTER strategy for uploaded textures.
    *  `'linear'` (default) is the screen path's existing behavior. `'mipmap'`
@@ -767,9 +777,14 @@ var GLImageCache = class {
   constructor(gl, minification = "linear") {
     this.gl = gl;
     this.minification = minification;
+    const reported = gl.getParameter(gl.MAX_TEXTURE_SIZE);
+    this.maxTextureSide = typeof reported === "number" && reported > 0 ? reported : DEFAULT_MAX_TEXTURE_SIDE;
+    live.add(this);
   }
   gl;
   minification;
+  /** This context's `MAX_TEXTURE_SIZE`. */
+  maxTextureSide;
   map = /* @__PURE__ */ new WeakMap();
   /**
    * MAG_FILTER each texture currently carries, so a redundant write can be
@@ -788,6 +803,19 @@ var GLImageCache = class {
    * was redundant either way.
    */
   magFilters = /* @__PURE__ */ new WeakMap();
+  /** Delete `key`'s texture, if it has one. */
+  release(key) {
+    const tex = this.map.get(key);
+    if (!tex) return;
+    this.gl.deleteTexture(tex);
+    this.map.delete(key);
+    this.magFilters.delete(key);
+  }
+  /** Stop answering {@link releaseImageSource} and {@link maxImageTextureSide}.
+   *  Call when the context is disposed or lost. */
+  dispose() {
+    live.delete(this);
+  }
   upload(key, source, repetition) {
     const existing = this.map.get(key);
     if (existing) return existing;
@@ -839,8 +867,6 @@ function wrapModes(gl, rep) {
       return [gl.CLAMP_TO_EDGE, gl.CLAMP_TO_EDGE];
   }
 }
-
-// src/renderer/math/color.ts
 function parseColor(input) {
   const cached = CACHE.get(input);
   if (cached !== void 0) return cached;
@@ -1033,21 +1059,7 @@ function parsePercentOrNumber(tok) {
   const n = Number(tok);
   return Number.isFinite(n) ? clamp01(n) : null;
 }
-function hslToRgb(h, s, l) {
-  if (s === 0) return [l, l, l];
-  const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
-  const p = 2 * l - q;
-  const hk = h / 360;
-  return [hueToChannel(p, q, hk + 1 / 3), hueToChannel(p, q, hk), hueToChannel(p, q, hk - 1 / 3)];
-}
-function hueToChannel(p, q, t) {
-  if (t < 0) t += 1;
-  if (t > 1) t -= 1;
-  if (t < 1 / 6) return p + (q - p) * 6 * t;
-  if (t < 1 / 2) return q;
-  if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
-  return p;
-}
+var hslToRgb = hslToSrgb;
 function clamp01(n) {
   return n < 0 ? 0 : n > 1 ? 1 : n;
 }
@@ -1517,9 +1529,15 @@ function scaled(m, sx, sy) {
   const s = create(sx, 0, 0, sy, 0, 0);
   return multiply(m, s);
 }
+function toAffine(m) {
+  return [m[0], m[1], m[3], m[4], m[6], m[7]];
+}
+function fromAffine(a) {
+  return create(a[0], a[1], a[2], a[3], a[4], a[5]);
+}
 function invert(m) {
-  const inv = invert$1([m[0], m[1], m[3], m[4], m[6], m[7]]);
-  return inv && create(inv[0], inv[1], inv[2], inv[3], inv[4], inv[5]);
+  const inv = invert$1(toAffine(m));
+  return inv && fromAffine(inv);
 }
 function apply(m, x, y) {
   const a = m[0], b = m[1];
@@ -1548,6 +1566,8 @@ function meanScaleOf(m) {
 }
 var mat3 = {
   identity,
+  toAffine,
+  fromAffine,
   multiply,
   translated,
   scaled,
@@ -5009,31 +5029,217 @@ var EffectTargets = class {
   }
 };
 
-// src/renderer/WeaselRenderer.ts
-var UNIFORM_QUALIFIER = /^(?:lowp|mediump|highp|precise|invariant|centroid|flat|smooth|noperspective)$/;
+// src/renderer/shaders/extractUniformNames.ts
+var QUALIFIERS = /* @__PURE__ */ new Set([
+  "lowp",
+  "mediump",
+  "highp",
+  "precise",
+  "invariant",
+  "centroid",
+  "flat",
+  "smooth",
+  "noperspective"
+]);
+var IDENT = /^[A-Za-z_]\w*$/;
+var MAX_DEPTH = 16;
 function extractUniformNames(glsl) {
-  const re = /\buniform\s+([^;{]+);/g;
-  const names = [];
-  let m;
-  while ((m = re.exec(glsl)) !== null) {
-    const words = m[1].trim().split(/\s+/);
-    let i = 0;
-    while (i < words.length && UNIFORM_QUALIFIER.test(words[i])) i++;
-    i++;
-    const declarators = words.slice(i).join(" ");
-    if (!declarators) continue;
-    for (const raw of declarators.split(",")) {
-      const d = raw.trim();
-      const arr = /^(\w+)\s*\[\s*(\d+)\s*\]$/.exec(d);
-      if (arr) {
-        const size = parseInt(arr[2], 10);
-        for (let k = 0; k < size; k++) names.push(`${arr[1]}[${k}]`);
-      } else if (/^\w+$/.test(d)) {
-        names.push(d);
-      }
-    }
-  }
-  return names;
+  const { code, defines } = preprocess(glsl);
+  const toks = tokenize2(code);
+  const consts = /* @__PURE__ */ new Map();
+  const structs = /* @__PURE__ */ new Map();
+  const out = /* @__PURE__ */ new Set();
+  const resolveName = (name, depth2) => {
+    if (depth2 > MAX_DEPTH) return null;
+    let best = null;
+    for (const body of defines.get(name) ?? []) {
+      const v = evalInt(tokenize2(body), (n) => resolveName(n, depth2 + 1));
+      if (v !== null && (best === null || v > best)) best = v;
+    }
+    return best ?? consts.get(name) ?? null;
+  };
+  const evalSize = (from, to) => evalInt(toks.slice(from, to), (n) => resolveName(n, 0));
+  const closer = (open) => {
+    let depth2 = 0;
+    for (let k = open; k < toks.length; k++) {
+      if (toks[k] === "(" || toks[k] === "[" || toks[k] === "{") depth2++;
+      else if (toks[k] === ")" || toks[k] === "]" || toks[k] === "}") {
+        if (--depth2 === 0) return k;
+      }
+    }
+    return toks.length;
+  };
+  const arraySuffix = (j) => {
+    if (toks[j] !== "[") return [void 0, j];
+    const end = closer(j);
+    return [evalSize(j + 1, end), end + 1];
+  };
+  const declarators = (j, typeSize) => {
+    const found = [];
+    while (j < toks.length && toks[j] !== ";" && toks[j] !== "}") {
+      const name = toks[j];
+      const [size, next] = arraySuffix(j + 1);
+      j = next;
+      if (IDENT.test(name)) found.push({ name, size: size === void 0 ? typeSize : size });
+      while (j < toks.length && toks[j] !== "," && toks[j] !== ";" && toks[j] !== "}") {
+        j = toks[j] === "(" || toks[j] === "[" || toks[j] === "{" ? closer(j) + 1 : j + 1;
+      }
+      if (toks[j] === ",") j++;
+    }
+    return [found, j];
+  };
+  const structSpecifier = (i) => {
+    let j = i + 1;
+    const name = toks[j] !== "{" ? toks[j++] : void 0;
+    const members = [];
+    if (toks[j] !== "{") return [members, j];
+    const end = closer(j);
+    j++;
+    while (j < end) {
+      while (QUALIFIERS.has(toks[j])) j++;
+      let type;
+      if (toks[j] === "struct") [type, j] = structSpecifier(j);
+      else type = toks[j++];
+      const [typeSize, afterType] = arraySuffix(j);
+      const [decls, term] = declarators(afterType, typeSize);
+      for (const d of decls) if (d.size !== null) members.push({ type, name: d.name, size: d.size ?? null });
+      j = term + 1;
+    }
+    if (name) {
+      const prior = structs.get(name) ?? [];
+      for (const m of members) if (!prior.some((p) => p.name === m.name)) prior.push(m);
+      structs.set(name, prior);
+    }
+    return [members, end + 1];
+  };
+  const expand = (name, type, size, depth2) => {
+    if (depth2 > MAX_DEPTH) return;
+    if (size !== null) {
+      for (let k = 0; k < size; k++) expand(`${name}[${k}]`, type, null, depth2 + 1);
+      return;
+    }
+    const members = typeof type === "string" ? structs.get(type) : type;
+    if (!members) {
+      out.add(name);
+      return;
+    }
+    for (const m of members) expand(`${name}.${m.name}`, m.type, m.size, depth2 + 1);
+  };
+  let depth = 0;
+  for (let i = 0; i < toks.length; i++) {
+    const t = toks[i];
+    if (t === "{") depth++;
+    else if (t === "}") depth--;
+    else if (t === "struct") i = structSpecifier(i)[1] - 1;
+    else if (depth === 0 && t === "const") {
+      let j = i + 1;
+      while (QUALIFIERS.has(toks[j])) j++;
+      if ((toks[j] === "int" || toks[j] === "uint") && IDENT.test(toks[j + 1] ?? "") && toks[j + 2] === "=") {
+        let end = j + 3;
+        while (end < toks.length && toks[end] !== ";") end++;
+        const v = evalSize(j + 3, end);
+        const prior = consts.get(toks[j + 1]);
+        if (v !== null && (prior === void 0 || v > prior)) consts.set(toks[j + 1], v);
+      }
+    } else if (depth === 0 && t === "uniform") {
+      let j = i + 1;
+      while (QUALIFIERS.has(toks[j])) j++;
+      let type;
+      if (toks[j] === "struct") {
+        [type, j] = structSpecifier(j);
+      } else if (toks[j + 1] === "{") {
+        j = closer(j + 1) + 1;
+        while (j < toks.length && toks[j] !== ";") j++;
+        i = j;
+        continue;
+      } else {
+        type = toks[j++];
+      }
+      const [typeSize, afterType] = arraySuffix(j);
+      const [decls, term] = declarators(afterType, typeSize);
+      for (const d of decls) if (d.size !== null) expand(d.name, type, d.size ?? null, 0);
+      i = term;
+    }
+  }
+  return [...out];
+}
+function preprocess(glsl) {
+  const spliced = glsl.replace(/\\\r?\n/g, "");
+  let stripped = "";
+  for (let k = 0; k < spliced.length; k++) {
+    if (spliced[k] === "/" && spliced[k + 1] === "/") {
+      while (k < spliced.length && spliced[k] !== "\n") k++;
+      stripped += "\n";
+    } else if (spliced[k] === "/" && spliced[k + 1] === "*") {
+      const end = spliced.indexOf("*/", k + 2);
+      k = end < 0 ? spliced.length : end + 1;
+      stripped += " ";
+    } else {
+      stripped += spliced[k];
+    }
+  }
+  const defines = /* @__PURE__ */ new Map();
+  const lines = stripped.split("\n").map((line) => {
+    if (!/^\s*#/.test(line)) return line;
+    const def = /^\s*#\s*define\s+([A-Za-z_]\w*)(\(?)(.*)$/.exec(line);
+    if (def && !def[2]) defines.set(def[1], [...defines.get(def[1]) ?? [], def[3].trim()]);
+    return "";
+  });
+  return { code: lines.join("\n"), defines };
+}
+function tokenize2(src) {
+  return src.match(/[A-Za-z_]\w*|\d[\w.]*|\S/g) ?? [];
+}
+function intLiteral(tok) {
+  const m = /^(?:0[xX]([0-9a-fA-F]+)|(0[0-7]*)|([1-9]\d*))[uU]?$/.exec(tok);
+  if (!m) return null;
+  if (m[1] !== void 0) return parseInt(m[1], 16);
+  if (m[2] !== void 0) return parseInt(m[2], 8);
+  return parseInt(m[3], 10);
+}
+function evalInt(toks, lookup) {
+  let p = 0;
+  const primary = () => {
+    const t = toks[p++];
+    if (t === "(") {
+      const v2 = sum();
+      return toks[p++] === ")" ? v2 : null;
+    }
+    if (t === "-") {
+      const v2 = primary();
+      return v2 === null ? null : -v2;
+    }
+    if (t === "+") return primary();
+    if (t === void 0) return null;
+    return intLiteral(t) ?? (IDENT.test(t) ? lookup(t) : null);
+  };
+  const product = () => {
+    let v2 = primary();
+    while (v2 !== null && (toks[p] === "*" || toks[p] === "/" || toks[p] === "%")) {
+      const op = toks[p++];
+      const r = primary();
+      if (r === null || op !== "*" && r === 0) return null;
+      v2 = op === "*" ? v2 * r : op === "/" ? Math.trunc(v2 / r) : v2 % r;
+    }
+    return v2;
+  };
+  const sum = () => {
+    let v2 = product();
+    while (v2 !== null && (toks[p] === "+" || toks[p] === "-")) {
+      const op = toks[p++];
+      const r = product();
+      if (r === null) return null;
+      v2 = op === "+" ? v2 + r : v2 - r;
+    }
+    return v2;
+  };
+  const v = sum();
+  return p === toks.length && v !== null && v >= 0 ? v : null;
+}
+
+// src/renderer/WeaselRenderer.ts
+function customUniformNames(vertSrc, fragSrc) {
+  return [...CUSTOM_KIT_UNIFORMS, ...extractUniformNames(vertSrc), ...extractUniformNames(fragSrc)];
 }
 var WeaselRenderer = class {
   gl;
@@ -5170,11 +5376,7 @@ var WeaselRenderer = class {
     const vertSrc = src.vert === "" ? CUSTOM_VERT_SRC : src.vert;
     const fragSrc = src.frag;
     const program = new ShaderProgram(this.gl, vertSrc, fragSrc);
-    program.lookupUniforms([
-      ...CUSTOM_KIT_UNIFORMS,
-      ...extractUniformNames(vertSrc),
-      ...extractUniformNames(fragSrc)
-    ]);
+    program.lookupUniforms(customUniformNames(vertSrc, fragSrc));
     program.lookupAttributes(CUSTOM_ATTRIBUTES);
     const previous = this.programRegistry.get(handle.id);
     if (previous) this.gl.deleteProgram(previous.handle);
@@ -5269,6 +5471,7 @@ var WeaselRenderer = class {
     if (aPos === void 0) throw new Error("a_position missing after restore");
     this.meshCache = new GLMeshCache(this.gl, aPos);
     this.textureCache = new GLTextureCache(this.gl);
+    this.imageCache.dispose();
     this.imageCache = new GLImageCache(this.gl, this.imageMinification);
     this.gradRamps = new GradientRampAtlas(this.gl);
     markAllFontsNotUploaded();
@@ -5281,7 +5484,7 @@ var WeaselRenderer = class {
       const vertSrc = src.vert === "" ? CUSTOM_VERT_SRC : src.vert;
       try {
         const program = new ShaderProgram(this.gl, vertSrc, src.frag);
-        program.lookupUniforms([...CUSTOM_KIT_UNIFORMS, ...extractUniformNames(src.frag)]);
+        program.lookupUniforms(customUniformNames(vertSrc, src.frag));
         program.lookupAttributes(CUSTOM_ATTRIBUTES);
         this.programRegistry.set(id, program);
       } catch (e) {
@@ -5331,6 +5534,7 @@ var WeaselRenderer = class {
     }
     this.programRegistry.clear();
     this.textureCache.free();
+    this.imageCache.dispose();
     this.gradRamps.free();
     if (this.quadVbo) gl.deleteBuffer(this.quadVbo);
     if (this.quadIbo) gl.deleteBuffer(this.quadIbo);
@@ -5835,32 +6039,32 @@ function drawLayers(layers, data, visibility, order, view, dims, cache7, onLayer
   }
   const groupOf = groupMembership(groups, layerById.keys());
   const bracketed = /* @__PURE__ */ new Set();
-  let run = null;
+  let run2 = null;
   const closeRun = () => {
-    if (!run) return;
-    for (const c of wrapGroup(run.group, run.children, v, dims)) out.push(c);
-    run = null;
+    if (!run2) return;
+    for (const c of wrapGroup(run2.group, run2.children, v, dims)) out.push(c);
+    run2 = null;
   };
   for (const layer of sequence) {
     if (!isLayerVisible(layer, visibility)) continue;
     const cmds = drawOneLayer(layer, data, v, dims, cache7, onLayerError);
     if (cmds.length === 0) continue;
     const group = groupOf?.get(layer.id);
-    if (run && run.group !== group) closeRun();
+    if (run2 && run2.group !== group) closeRun();
     if (!group) {
       for (const c of cmds) out.push(c);
       continue;
     }
-    if (!run) {
+    if (!run2) {
       if (bracketed.has(group)) {
         console.warn(
           `[weasel] layer group "${group.id}" is not one run \u2014 another layer is drawn between its members, so it composites as more than one pass over more than one buffer. Move its members together in the layer order.`
         );
       }
       bracketed.add(group);
-      run = { group, children: [] };
+      run2 = { group, children: [] };
     }
-    for (const c of cmds) run.children.push(c);
+    for (const c of cmds) run2.children.push(c);
   }
   closeRun();
   return out;
@@ -6656,7 +6860,7 @@ function composeWorldPose(adapter, id, compose2) {
   while (cursor !== null) {
     if (seen.has(cursor)) break;
     seen.add(cursor);
-    chain.push(cursor);
+    if (adapter.definesFrame?.(cursor) ?? true) chain.push(cursor);
     cursor = adapter.getParent(cursor);
   }
   let world = adapter.getPose(chain[chain.length - 1]);
@@ -6676,9 +6880,19 @@ function translateRectPose(pose, dx, dy) {
   return { ...pose, x: pose.x + dx, y: pose.y + dy };
 }
 function rebaseLocalPose(adapter, worldPose, newParentId, compose2, decompose) {
-  if (newParentId === null) return worldPose;
-  const parentWorld = composeWorldPose(adapter, newParentId, compose2);
-  return decompose(parentWorld, worldPose);
+  const frame = frameAtOrAbove(adapter, newParentId);
+  if (frame === null) return worldPose;
+  return decompose(composeWorldPose(adapter, frame, compose2), worldPose);
+}
+function frameAtOrAbove(adapter, id) {
+  const seen = /* @__PURE__ */ new Set();
+  let cursor = id;
+  while (cursor !== null && !seen.has(cursor)) {
+    if (adapter.definesFrame?.(cursor) ?? true) return cursor;
+    seen.add(cursor);
+    cursor = adapter.getParent(cursor);
+  }
+  return null;
 }
 function decomposeRectPose(parent, world) {
   return {
@@ -6744,6 +6958,88 @@ function worldPoseLookup(adapter, compose2) {
   };
 }
 
+// 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);
+}
+function snapshotPose(value, depth = DEPTH) {
+  if (depth <= 0) return value;
+  if (Array.isArray(value)) {
+    return value.map((v) => snapshotPose(v, depth - 1));
+  }
+  if (isTypedArray(value)) return value.slice();
+  if (isPlainObject(value)) {
+    const out = { ...value };
+    for (const key in out) {
+      const field = out[key];
+      if (typeof field === "object" && field !== null) out[key] = snapshotPose(field, depth - 1);
+    }
+    return out;
+  }
+  return value;
+}
+function samePoseValue(snapshot, value, depth = DEPTH) {
+  if (snapshot === value) return true;
+  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;
+    const a = snapshot;
+    const b = value;
+    let count = 0;
+    for (const key in a) {
+      count++;
+      const left = a[key];
+      const right = b[key];
+      if (left === right) {
+        if (right === void 0 && !(key in b)) return false;
+        continue;
+      }
+      if (!samePoseValue(left, right, depth - 1)) return false;
+    }
+    for (const _key in b) if (--count < 0) return false;
+    return true;
+  }
+  if (Array.isArray(snapshot) || isTypedArray(snapshot)) {
+    const a = snapshot;
+    if (!(Array.isArray(value) || isTypedArray(value))) return false;
+    const b = value;
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!samePoseValue(a[i], b[i], depth - 1)) return false;
+    }
+    return true;
+  }
+  return false;
+}
+
+// src/core/scene/depMemo.ts
+function recordDeps(into, deps) {
+  into.nodes.length = 0;
+  into.poses.length = 0;
+  for (const dep of deps) {
+    into.nodes.push(dep?.node);
+    into.poses.push(dep === void 0 ? void 0 : snapshotPose(dep.pose));
+  }
+}
+function sameDeps2(record, ids, depOf2) {
+  if (record.nodes.length !== ids.length) return false;
+  for (let i = 0; i < ids.length; i++) {
+    const dep = depOf2(ids[i]);
+    if (record.nodes[i] !== (dep === void 0 ? void 0 : dep.node)) return false;
+    if (dep !== void 0 && !samePoseValue(record.poses[i], dep.pose)) return false;
+  }
+  return true;
+}
+
 // src/core/scene/dependents.ts
 var NONE = Object.freeze([]);
 function dependencyIdsOf(node, childrenOf) {
@@ -6817,69 +7113,6 @@ function sameDependsOn(a, b) {
   return true;
 }
 
-// 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);
-}
-function snapshotPose(value, depth = DEPTH) {
-  if (depth <= 0) return value;
-  if (Array.isArray(value)) {
-    return value.map((v) => snapshotPose(v, depth - 1));
-  }
-  if (isTypedArray(value)) return value.slice();
-  if (isPlainObject(value)) {
-    const out = { ...value };
-    for (const key in out) {
-      const field = out[key];
-      if (typeof field === "object" && field !== null) out[key] = snapshotPose(field, depth - 1);
-    }
-    return out;
-  }
-  return value;
-}
-function samePoseValue(snapshot, value, depth = DEPTH) {
-  if (snapshot === value) return true;
-  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;
-    const a = snapshot;
-    const b = value;
-    let count = 0;
-    for (const key in a) {
-      count++;
-      const left = a[key];
-      const right = b[key];
-      if (left === right) {
-        if (right === void 0 && !(key in b)) return false;
-        continue;
-      }
-      if (!samePoseValue(left, right, depth - 1)) return false;
-    }
-    for (const _key in b) if (--count < 0) return false;
-    return true;
-  }
-  if (Array.isArray(snapshot) || isTypedArray(snapshot)) {
-    const a = snapshot;
-    if (!(Array.isArray(value) || isTypedArray(value))) return false;
-    const b = value;
-    if (a.length !== b.length) return false;
-    for (let i = 0; i < a.length; i++) {
-      if (!samePoseValue(a[i], b[i], depth - 1)) return false;
-    }
-    return true;
-  }
-  return false;
-}
-
 // src/core/scene/derivedPath.ts
 var SLOT = "kit:derivedPath";
 var resolving = /* @__PURE__ */ new Set();
@@ -6901,7 +7134,7 @@ function resolveDerivedPath(node, depOf2, childrenOf, memoSlot = SLOT) {
       computed = true;
       return draw(node, derivePath, ids.map(depOf2), { nodes: [], poses: [], path: null });
     });
-    if (!computed && !matches(record, ids, depOf2)) {
+    if (!computed && !sameDeps2(record, ids, depOf2)) {
       draw(node, derivePath, ids.map(depOf2), record);
     }
     if (cycleHits !== hitsBefore) dropPoseKeyedMemoSlots(node);
@@ -6912,23 +7145,9 @@ function resolveDerivedPath(node, depOf2, childrenOf, memoSlot = SLOT) {
 }
 function draw(node, derivePath, deps, into) {
   into.path = derivePath(node, deps);
-  into.nodes.length = 0;
-  into.poses.length = 0;
-  for (const dep of deps) {
-    into.nodes.push(dep?.node);
-    into.poses.push(dep === void 0 ? void 0 : snapshotPose(dep.pose));
-  }
+  recordDeps(into, deps);
   return into;
 }
-function matches(record, ids, depOf2) {
-  if (record.nodes.length !== ids.length) return false;
-  for (let i = 0; i < ids.length; i++) {
-    const dep = depOf2(ids[i]);
-    if (record.nodes[i] !== (dep === void 0 ? void 0 : dep.node)) return false;
-    if (dep !== void 0 && !samePoseValue(record.poses[i], dep.pose)) return false;
-  }
-  return true;
-}
 
 // src/core/scene/effectivePose.ts
 var POSE_SLOT = {
@@ -6956,18 +7175,26 @@ function derivedPoseIn(source, node, reading) {
   resolving2.add(node.id);
   const hitsBefore = cycleHits2;
   try {
-    const value = nodeMemo(
-      node,
-      POSE_SLOT[reading],
-      node.pose,
-      () => derive(node, ids.map((id) => depIn(source, id, reading)))
-    );
+    const depOf2 = (id) => depIn(source, id, reading);
+    let computed = false;
+    const record = nodeMemo(node, POSE_SLOT[reading], node.pose, () => {
+      computed = true;
+      return run(node, derive, ids.map(depOf2), { nodes: [], poses: [], value: null });
+    });
+    if (!computed && !sameDeps2(record, ids, depOf2)) {
+      run(node, derive, ids.map(depOf2), record);
+    }
     if (cycleHits2 !== hitsBefore) dropPoseKeyedMemoSlots(node);
-    return value;
+    return record.value;
   } finally {
     resolving2.delete(node.id);
   }
 }
+function run(node, derive, deps, into) {
+  into.value = derive(node, deps);
+  recordDeps(into, deps);
+  return into;
+}
 function derivedDepOf(source, id) {
   return depIn(source, id, "effective");
 }
@@ -7012,6 +7239,9 @@ function documentPose(source, node) {
 function effectivePose(source, node) {
   return poseIn(source, node, "effective");
 }
+function definesFrame(node) {
+  return !(node.dependsOn === "children" && node.derivePose !== void 0);
+}
 function poseRotationOf(pose) {
   const p = pose;
   if (p.rotation && p.x != null && p.y != null && p.width != null && p.height != null) {
@@ -7222,14 +7452,14 @@ function defaultRectEl(target) {
 }
 function useHandleDrag(opts) {
   const { onMove, onStart, onEnd, onCancel, getRect } = opts;
-  const live = useRef(null);
+  const live2 = useRef(null);
   useEffect(() => () => {
-    live.current?.cancel();
+    live2.current?.cancel();
   }, []);
   const onPointerDown = useCallback(
     (e) => {
       e.preventDefault();
-      live.current?.cancel();
+      live2.current?.cancel();
       const target = e.currentTarget;
       const rectEl = getRect ? getRect(target) : defaultRectEl(target);
       const rect = rectEl.getBoundingClientRect();
@@ -7238,17 +7468,17 @@ function useHandleDrag(opts) {
         return { x, y };
       };
       let moved = false;
-      live.current = openPointerSession(target, e, {
+      live2.current = openPointerSession(target, e, {
         onMove: (ev) => {
           moved = true;
           onMove(localOf(ev.clientX, ev.clientY), ev);
         },
         onEnd: (ev) => {
-          live.current = null;
+          live2.current = null;
           onEnd?.({ point: localOf(ev.clientX, ev.clientY), moved, event: ev });
         },
         onCancel: (reason) => {
-          live.current = null;
+          live2.current = null;
           onCancel?.(reason);
         }
       });
@@ -7354,9 +7584,9 @@ var DRAG_THRESHOLD_PX_SQ = 25;
 function useDragHandle(getPayload, options) {
   const optsRef = useRef(options);
   optsRef.current = options;
-  const live = useRef(null);
+  const live2 = useRef(null);
   useEffect(() => () => {
-    live.current?.cancel();
+    live2.current?.cancel();
   }, []);
   const onPointerDown = useCallback((e) => {
     if (e.pointerType === "mouse" && e.button !== 0) return;
@@ -7366,7 +7596,7 @@ function useDragHandle(getPayload, options) {
     const startY = e.clientY;
     let ghost = null;
     let past = false;
-    live.current = openPointerSession(target, e, {
+    live2.current = openPointerSession(target, e, {
       onMove: (ev) => {
         if (ghost) {
           ghost.move(ev);
@@ -7396,11 +7626,11 @@ function useDragHandle(getPayload, options) {
         );
       },
       onEnd: (ev) => {
-        live.current = null;
+        live2.current = null;
         ghost?.drop(ev);
       },
       onCancel: () => {
-        live.current = null;
+        live2.current = null;
         ghost?.cancel();
       }
     }, { capture: false });
@@ -7763,10 +7993,11 @@ function keySpecShortcut(spec) {
     shift: mods?.shift === true
   };
 }
-function actionShortcuts(action) {
+function actionShortcuts(action, params) {
   const out = [];
   const seen = /* @__PURE__ */ new Set();
-  for (const { spec } of actionBindings(action)) {
+  for (const { spec, opts } of actionBindings(action)) {
+    if (params && !paramsMatch(opts?.params, params)) continue;
     const shortcut = keySpecShortcut(spec);
     if (!shortcut) continue;
     const token = `${shortcut.key}|${shortcut.mod}|${shortcut.alt}|${shortcut.shift}`;
@@ -7776,6 +8007,10 @@ function actionShortcuts(action) {
   }
   return out;
 }
+function paramsMatch(bound, wanted) {
+  if (typeof bound !== "object" || bound === null) return false;
+  return Object.entries(wanted).every(([k, v]) => bound[k] === v);
+}
 
 // src/core/scene/types.ts
 var asNodeId = (s) => s;
@@ -7975,7 +8210,11 @@ function runLayoutPass(scratch, moveCtx) {
     y: moveCtx.drag.current.y - selectionCenter.y
   };
   const candidates = [];
-  const testInside = (cPose, aabb, layout2) => {
+  const mode = layoutDep.dropTarget ?? "innermost";
+  const testInside = (id, cPose, aabb, layout2) => {
+    const region = layout2.dropRegion?.({ id, bounds: aabb }) ?? null;
+    if (region) return regionContains(region, aabb, selectionCenter);
+    if (mode === "region") return false;
     if (layout2.contains) return layout2.contains(cPose, selectionCenter);
     return selectionCenter.x >= aabb.x && selectionCenter.x < aabb.x + aabb.width && selectionCenter.y >= aabb.y && selectionCenter.y < aabb.y + aabb.height;
   };
@@ -7987,7 +8226,7 @@ function runLayoutPass(scratch, moveCtx) {
     if (!node) return;
     const worldPose = composeWorldPose(poseAdapter, id, pc.compose);
     const worldAABB = poseDescriptorForNode(d, node).getBounds(worldPose);
-    if (!testInside(worldPose, worldAABB, layout2)) return;
+    if (!testInside(id, worldPose, worldAABB, layout2)) return;
     if (layout2.acceptsDrop) {
       const arg = { id, bounds: worldAABB };
       for (const c of dragged) if (!layout2.acceptsDrop(arg, c.arg)) return;
@@ -8010,28 +8249,33 @@ function runLayoutPass(scratch, moveCtx) {
   };
   walk(null, []);
   let dest = null;
-  for (const c of candidates) {
-    if (dest === null) {
-      dest = c;
-      continue;
-    }
-    if (c.depth > dest.depth) {
-      dest = c;
-      continue;
-    }
-    if (c.depth < dest.depth) continue;
-    let cAfter = false;
-    for (let i = 0; i < c.zPath.length; i++) {
-      if (c.zPath[i] > dest.zPath[i]) {
-        cAfter = true;
-        break;
+  if (mode === "topmost") {
+    const byId = new Map(candidates.map((c) => [c.id, c]));
+    for (const id of scene.renderOrder()) dest = byId.get(id) ?? dest;
+  } else {
+    for (const c of candidates) {
+      if (dest === null) {
+        dest = c;
+        continue;
       }
-      if (c.zPath[i] < dest.zPath[i]) {
-        cAfter = false;
-        break;
+      if (c.depth > dest.depth) {
+        dest = c;
+        continue;
+      }
+      if (c.depth < dest.depth) continue;
+      let cAfter = false;
+      for (let i = 0; i < c.zPath.length; i++) {
+        if (c.zPath[i] > dest.zPath[i]) {
+          cAfter = true;
+          break;
+        }
+        if (c.zPath[i] < dest.zPath[i]) {
+          cAfter = false;
+          break;
+        }
       }
+      if (cAfter) dest = c;
     }
-    if (cAfter) dest = c;
   }
   if (!dest) return;
   const layout = dest.layout;
@@ -8098,6 +8342,10 @@ function runLayoutPass(scratch, moveCtx) {
   }
   scratch.layoutPass = { layout, container, placements, sourceReflow, reflowIds };
 }
+function regionContains(region, bounds, point) {
+  const local = { x: point.x - bounds.x, y: point.y - bounds.y };
+  return typeof region === "function" ? region(local) : pointInPath(region, local.x, local.y);
+}
 function groupBySourceContainer(dragged, exclude) {
   const out = /* @__PURE__ */ new Map();
   for (const d of dragged) {
@@ -8113,17 +8361,18 @@ function groupBySourceContainer(dragged, exclude) {
   return out;
 }
 function translateCommitOps(scratch, ids, dx, dy) {
-  const m = [1, 0, 0, 1, dx, dy];
   const ops = [];
   for (const id of ids) {
-    if (!scratch.startPoses.has(id)) continue;
+    if (!scratch.startPoses.has(id) || scratch.carried.has(id)) continue;
     const node = scratch.scene.get(id);
     if (!node) continue;
+    const l = localDelta(scratch, id, dx, dy);
+    const m = [1, 0, 0, 1, l.dx, l.dy];
     const authored = node.pose;
     ops.push(createTransformOp({
       id,
       from: authored,
-      to: translatePoseViaDescriptor(authored, dx, dy, scratch.projection),
+      to: translatePoseViaDescriptor(authored, l.dx, l.dy, scratch.projection),
       label: "Move"
     }));
     if (scratch.geometryProjection) {
@@ -8138,6 +8387,16 @@ function translateCommitOps(scratch, ids, dx, dy) {
   }
   return ops;
 }
+function localDelta(scratch, id, dx, dy) {
+  const f = scratch.frames.get(id);
+  if (f === void 0) return { dx, dy };
+  const { pc, projection: d } = scratch;
+  const from = d.getBounds(pc.decompose(f.frameWorld, f.world));
+  const to = d.getBounds(
+    pc.decompose(f.frameWorld, translatePoseViaDescriptor(f.world, dx, dy, d))
+  );
+  return { dx: to.x - from.x, dy: to.y - from.y };
+}
 function unreleasedIds(scratch, released) {
   const selected = new Set(scratch.ids);
   const out = scratch.ids.filter((id) => !released.has(id));
@@ -8159,7 +8418,11 @@ function unreleasedIds(scratch, released) {
 function scenePoseAdapter(scene) {
   return {
     getPose: (id) => documentPose(scene, scene.get(id)),
-    getParent: (id) => scene.get(id)?.parent ?? null
+    getParent: (id) => scene.get(id)?.parent ?? null,
+    definesFrame: (id) => {
+      const node = scene.get(id);
+      return node === void 0 || definesFrame(node);
+    }
   };
 }
 function resolveDropTarget(endCtx, scratch) {
@@ -8264,6 +8527,23 @@ var moveAction = {
           queue.push(childId);
         }
       }
+      const carried = /* @__PURE__ */ new Set();
+      const frames = /* @__PURE__ */ new Map();
+      if (pc.closure !== "identity") {
+        const poseAdapter = scenePoseAdapter(scene);
+        for (const id of startPoses.keys()) {
+          const frame = frameAtOrAbove(poseAdapter, scene.get(id)?.parent ?? null);
+          if (frame === null) continue;
+          if (startPoses.has(asNodeId(frame))) {
+            carried.add(id);
+            continue;
+          }
+          frames.set(id, {
+            world: composeWorldPose(poseAdapter, id, pc.compose),
+            frameWorld: composeWorldPose(poseAdapter, frame, pc.compose)
+          });
+        }
+      }
       const behaviors = opts?.behaviors ?? [];
       const adapter = moveGestureAdapter(scene);
       const origin = /* @__PURE__ */ new Map();
@@ -8283,6 +8563,8 @@ var moveAction = {
         startPoses,
         ids,
         cascadeIds,
+        carried,
+        frames,
         scene,
         currentDelta: { dx: 0, dy: 0 },
         previews: /* @__PURE__ */ new Map(),
@@ -8335,7 +8617,12 @@ var moveAction = {
           scratch.currentDelta = { dx, dy };
           scratch.previews.clear();
           for (const [id, ori] of scratch.startPoses) {
-            scratch.previews.set(id, translatePoseViaDescriptor(ori, dx, dy, scratch.projection));
+            if (scratch.carried.has(id)) {
+              scratch.previews.set(id, ori);
+              continue;
+            }
+            const l = localDelta(scratch, id, dx, dy);
+            scratch.previews.set(id, translatePoseViaDescriptor(ori, l.dx, l.dy, scratch.projection));
           }
           scratch.layoutPass = null;
           runLayoutPass(scratch, moveCtx);
@@ -8534,15 +8821,18 @@ var moveAction = {
 };
 
 // src/interactions/actions/defaultCommitAdapter.ts
-function defaultCommitAdapter(scene) {
+function defaultCommitAdapter(scene, selection) {
   return {
     getNode: (id) => scene.get(asNodeId(id)),
     getNodes: () => {
       return [...scene.renderOrderNodes()];
     },
     getPose: (id) => documentPose(scene, scene.get(asNodeId(id))),
-    getSelection: () => [...scene.getSelection()],
-    setSelection: (ids) => scene.setSelection(ids.map(asNodeId)),
+    getSelection: () => [...selection ? selection.getSelection() : scene.getSelection()],
+    setSelection: (ids) => {
+      if (selection) selection.setSelection(ids.map(asNodeId));
+      else scene.setSelection(ids.map(asNodeId));
+    },
     getParent: (id) => scene.get(asNodeId(id))?.parent ?? null,
     getRemovalClosure: (ids) => [...scene.removalClosure(ids.map(asNodeId))],
     getChildren: (parentId) => parentId === null ? [...scene.roots] : [...scene.childrenOf(asNodeId(parentId))],
@@ -8586,8 +8876,8 @@ function poseFrame(adapter, pc) {
     pc,
     world: (id) => composeWorldPose(adapter, id, pc.compose),
     parentWorld: (id) => {
-      const parent = adapter.getParent(id);
-      return parent === null ? null : composeWorldPose(adapter, parent, pc.compose);
+      const frame = frameAtOrAbove(adapter, adapter.getParent(id));
+      return frame === null ? null : composeWorldPose(adapter, frame, pc.compose);
     },
     local: (id, worldPose) => rebaseLocalPose(adapter, worldPose, adapter.getParent(id), pc.compose, pc.decompose),
     localUnder: (parentId, worldPose) => rebaseLocalPose(adapter, worldPose, parentId, pc.compose, pc.decompose)
@@ -8601,7 +8891,11 @@ function scenePoseFrame(scene, poseComposition) {
       const node = scene.get(id);
       return node === void 0 ? { x: 0, y: 0, width: 0, height: 0 } : effectivePose(source, node);
     },
-    getParent: (id) => scene.get(id)?.parent ?? null
+    getParent: (id) => scene.get(id)?.parent ?? null,
+    definesFrame: (id) => {
+      const node = scene.get(id);
+      return node === void 0 || definesFrame(node);
+    }
   };
   return poseFrame(adapter, pc);
 }
@@ -8958,7 +9252,7 @@ var resizeAction = {
           }
           if (ops.length > 0) {
             if (scratch.applyOps) scratch.applyOps(ops, "Resize");
-            else scratch.scene.applyBatch(ops, "Resize", defaultCommitAdapter(scratch.scene));
+            else scratch.scene.applyBatch(ops, "Resize", defaultCommitAdapter(scratch.scene, selection.adapterMethods));
           }
           dropPreviewOverrides(scratch);
           scratch.previews.clear();
@@ -9114,7 +9408,7 @@ var rotateAction = {
           }
           if (ops.length > 0) {
             if (scratch.applyOps) scratch.applyOps(ops, "Rotate");
-            else scratch.scene.applyBatch(ops, "Rotate", defaultCommitAdapter(scratch.scene));
+            else scratch.scene.applyBatch(ops, "Rotate", defaultCommitAdapter(scratch.scene, selection.adapterMethods));
           }
           dropPreviewOverrides(scratch);
           scratch.previews.clear();
@@ -9581,7 +9875,7 @@ var cloneAction = {
           }
           if (ops.length > 0) {
             if (scratch.applyOps) scratch.applyOps(ops, "Clone");
-            else scratch.scene.applyBatch(ops, "Clone", defaultCommitAdapter(scratch.scene));
+            else scratch.scene.applyBatch(ops, "Clone", defaultCommitAdapter(scratch.scene, selection.adapterMethods));
           }
           scratch.previews.clear();
         },
@@ -9618,6 +9912,14 @@ function createVelocityTracker() {
 }
 
 // src/interactions/actions/defaults/viewportDragPan.ts
+function screenDeltaFromWorld(drag, scratch) {
+  const v0 = scratch.startView;
+  const now = scratch.view.get();
+  return {
+    x: (drag.current.x - now.x - (drag.start.x - v0.x)) * v0.scale.x,
+    y: (drag.current.y - now.y - (drag.start.y - v0.y)) * v0.scale.y
+  };
+}
 var viewportDragPanAction = {
   id: "viewport.dragPan",
   label: "Drag to pan viewport",
@@ -9655,7 +9957,7 @@ var viewportDragPanAction = {
         kind: "pan",
         onMove(moveCtx) {
           if (!moveCtx.drag) return;
-          const screen = moveCtx.drag.screenDelta ?? moveCtx.drag.delta;
+          const screen = moveCtx.drag.screenDelta ?? screenDeltaFromWorld(moveCtx.drag, scratch);
           const screenDx = scratch.axis === "y" ? 0 : screen.x;
           const screenDy = scratch.axis === "x" ? 0 : screen.y;
           if (scratch.tracker) {
@@ -9753,6 +10055,11 @@ function makeViewportZoomAction(opts = {}) {
         spec: { kind: "wheel", mods: { ctrl: true } },
         opts: { params: { kind: "wheel" } }
       },
+      // Safari's trackpad pinch, reported as a scale rather than a wheel.
+      {
+        spec: { kind: "pinch" },
+        opts: { params: { kind: "pinch" } }
+      },
       // Cmd+= → zoom in (also accepts Cmd+Shift+= which is Cmd++ on many keyboards)
       {
         spec: { kind: "key", key: "=", mods: { mod: true, shift: "optional" } },
@@ -9786,14 +10093,21 @@ function makeViewportZoomAction(opts = {}) {
           view.animate(target, { ...tweenOpts, ms: ms ?? tweenOpts.ms });
         };
         const stepFrom = () => canAnimate && view.animationTarget?.() || current;
+        const focal = () => ({
+          x: params?.clientX ?? 0,
+          y: params?.clientY ?? 0
+        });
+        const scaleBy = (factor) => {
+          if (!(factor > 0) || !Number.isFinite(factor)) return;
+          view.set(zoomAt(current, focal(), factor, clamp));
+        };
         switch (kind) {
-          case "wheel": {
-            const deltaY = params?.deltaY ?? 0;
-            const clientX = params?.clientX ?? 0;
-            const clientY = params?.clientY ?? 0;
-            view.set(wheelZoom(current, { x: clientX, y: clientY }, deltaY, clamp));
+          case "wheel":
+            scaleBy(wheelZoomFactor(params?.deltaY ?? 0));
+            break;
+          case "pinch":
+            scaleBy(params?.scale ?? Number.NaN);
             break;
-          }
           case "in":
             stepTo(zoomAt(stepFrom(), keyAnchor(view), KEY_STEP, clamp));
             break;
@@ -10594,6 +10908,150 @@ function makePinchZoomAction(opts = {}) {
   };
 }
 var pinchZoomAction = makePinchZoomAction();
+var SVG_BASE = {
+  viewBox: "0 0 20 20",
+  width: 20,
+  height: 20,
+  fill: "none",
+  stroke: "currentColor",
+  strokeWidth: 1.5,
+  "aria-hidden": true
+};
+function CutIcon() {
+  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE, children: [
+    /* @__PURE__ */ jsx("circle", { cx: "6", cy: "14", r: "2.5" }),
+    /* @__PURE__ */ jsx("circle", { cx: "14", cy: "14", r: "2.5" }),
+    /* @__PURE__ */ jsx("path", { d: "M8 12 L16 4", strokeLinecap: "round" }),
+    /* @__PURE__ */ jsx("path", { d: "M12 12 L4 4", strokeLinecap: "round" })
+  ] });
+}
+function CopyIcon() {
+  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE, children: [
+    /* @__PURE__ */ jsx("path", { d: "M6 14 H3 V3 H14 V6", strokeLinejoin: "round" }),
+    /* @__PURE__ */ jsx("rect", { x: "6", y: "6", width: "11", height: "11" })
+  ] });
+}
+function PasteIcon() {
+  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE, children: [
+    /* @__PURE__ */ jsx("rect", { x: "4", y: "5", width: "12", height: "13", rx: "1" }),
+    /* @__PURE__ */ jsx("rect", { x: "7.5", y: "2.5", width: "5", height: "4", rx: "0.5", fill: "currentColor", stroke: "none" })
+  ] });
+}
+function DuplicateIcon() {
+  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE, children: [
+    /* @__PURE__ */ jsx("rect", { x: "3", y: "3", width: "10", height: "10" }),
+    /* @__PURE__ */ jsx("rect", { x: "7", y: "7", width: "10", height: "10", fill: "currentColor", stroke: "none" })
+  ] });
+}
+function GroupIcon() {
+  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE, children: [
+    /* @__PURE__ */ jsx("path", { d: "M 2 5 L 2 2 L 5 2" }),
+    /* @__PURE__ */ jsx("path", { d: "M 18 5 L 18 2 L 15 2" }),
+    /* @__PURE__ */ jsx("path", { d: "M 2 15 L 2 18 L 5 18" }),
+    /* @__PURE__ */ jsx("path", { d: "M 18 15 L 18 18 L 15 18" }),
+    /* @__PURE__ */ jsx("rect", { x: "5", y: "6", width: "4.5", height: "8", fill: "currentColor", stroke: "none" }),
+    /* @__PURE__ */ jsx("rect", { x: "11", y: "6", width: "4", height: "8", fill: "currentColor", stroke: "none" })
+  ] });
+}
+function UngroupIcon() {
+  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE, children: [
+    /* @__PURE__ */ jsx("path", { d: "M 2 5 L 2 2 L 5 2", strokeDasharray: "1.5 1.5" }),
+    /* @__PURE__ */ jsx("path", { d: "M 18 15 L 18 18 L 15 18", strokeDasharray: "1.5 1.5" }),
+    /* @__PURE__ */ jsx("rect", { x: "3", y: "5", width: "4.5", height: "8", fill: "currentColor", stroke: "none" }),
+    /* @__PURE__ */ jsx("rect", { x: "13", y: "7", width: "4", height: "8", fill: "currentColor", stroke: "none" })
+  ] });
+}
+function BringForwardIcon() {
+  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE, children: [
+    /* @__PURE__ */ jsx("rect", { x: "3", y: "3", width: "11", height: "11" }),
+    /* @__PURE__ */ jsx("rect", { x: "6", y: "6", width: "11", height: "11", fill: "currentColor", stroke: "none" })
+  ] });
+}
+function BringToFrontIcon() {
+  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE, children: [
+    /* @__PURE__ */ jsx("rect", { x: "2", y: "2", width: "9", height: "9" }),
+    /* @__PURE__ */ jsx("rect", { x: "6", y: "6", width: "9", height: "9" }),
+    /* @__PURE__ */ jsx("rect", { x: "9", y: "9", width: "9", height: "9", fill: "currentColor", stroke: "none" })
+  ] });
+}
+function SendBackwardIcon() {
+  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE, children: [
+    /* @__PURE__ */ jsx("rect", { x: "3", y: "3", width: "11", height: "11", fill: "currentColor", stroke: "none" }),
+    /* @__PURE__ */ jsx("rect", { x: "6", y: "6", width: "11", height: "11" })
+  ] });
+}
+function SendToBackIcon() {
+  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE, children: [
+    /* @__PURE__ */ jsx("rect", { x: "2", y: "2", width: "9", height: "9", fill: "currentColor", stroke: "none" }),
+    /* @__PURE__ */ jsx("rect", { x: "6", y: "6", width: "9", height: "9" }),
+    /* @__PURE__ */ jsx("rect", { x: "9", y: "9", width: "9", height: "9" })
+  ] });
+}
+function FlipXIcon() {
+  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE, children: [
+    /* @__PURE__ */ jsx("line", { x1: "10", y1: "2", x2: "10", y2: "18", strokeDasharray: "2 1.5" }),
+    /* @__PURE__ */ jsx("path", { d: "M 8 4 L 3 10 L 8 16 Z" }),
+    /* @__PURE__ */ jsx("path", { d: "M 12 4 L 17 10 L 12 16 Z", fill: "currentColor", stroke: "none" })
+  ] });
+}
+function FlipYIcon() {
+  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE, children: [
+    /* @__PURE__ */ jsx("line", { x1: "2", y1: "10", x2: "18", y2: "10", strokeDasharray: "2 1.5" }),
+    /* @__PURE__ */ jsx("path", { d: "M 4 8 L 10 3 L 16 8 Z" }),
+    /* @__PURE__ */ jsx("path", { d: "M 4 12 L 10 17 L 16 12 Z", fill: "currentColor", stroke: "none" })
+  ] });
+}
+
+// src/interactions/actions/defaults/icons/actionGlyphs.ts
+var ACTION_GLYPHS = {
+  delete: `<path d="M3.6 5.8h12.8M8 5.8V4.5A1.1 1.1 0 0 1 9.1 3.4h1.8A1.1 1.1 0 0 1 12 4.5v1.3"/><path d="M5.2 5.8v9.6A1.6 1.6 0 0 0 6.8 17h6.4a1.6 1.6 0 0 0 1.6-1.6V5.8"/><path d="M8.4 8.8v5.2M11.6 8.8v5.2" stroke-width="1"/>`,
+  undo: `<path d="M4.4 8.4h6.8a3.6 3.6 0 0 1 0 7.2H8.6"/><path d="M6.47 10.14 4.4 8.4 6.47 6.66"/>`,
+  redo: `<path d="M15.6 8.4H8.8a3.6 3.6 0 0 0 0 7.2H11.4"/><path d="M13.53 6.66 15.6 8.4 13.53 10.14"/>`
+};
+var SVG_BASE2 = {
+  viewBox: "0 0 20 20",
+  fill: "none",
+  stroke: "currentColor",
+  strokeWidth: 1.5,
+  strokeLinecap: "round",
+  strokeLinejoin: "round"
+};
+var MARKUP = {
+  delete: { __html: ACTION_GLYPHS.delete },
+  undo: { __html: ACTION_GLYPHS.undo },
+  redo: { __html: ACTION_GLYPHS.redo }
+};
+function renderGlyph(name, { className, size = 20, label }) {
+  return /* @__PURE__ */ jsx(
+    "svg",
+    {
+      ...SVG_BASE2,
+      className,
+      width: size,
+      height: size,
+      role: label ? "img" : void 0,
+      "aria-label": label,
+      "aria-hidden": label ? void 0 : true,
+      dangerouslySetInnerHTML: MARKUP[name]
+    }
+  );
+}
+function UndoIcon(p) {
+  return renderGlyph("undo", p);
+}
+function RedoIcon(p) {
+  return renderGlyph("redo", p);
+}
+function DeleteIcon(p) {
+  return renderGlyph("delete", p);
+}
+function requiresSelection(deps) {
+  const selection = deps?.selection;
+  if (!selection || selection.get().length === 0) {
+    return ActionDisabledReason.SelectionRequired;
+  }
+  return true;
+}
 
 // src/interactions/actions/defaults/delete.ts
 function hostIndex(scene, id) {
@@ -10620,6 +11078,8 @@ function buildDeleteOps(scene, ids, label) {
 var deleteAction = {
   id: "delete",
   label: "Delete",
+  icon: createElement(DeleteIcon),
+  group: "edit",
   // Suppressed while any tool is mid-gesture — accidentally hitting
   // Delete during a drag shouldn't wipe the selection out from under
   // the in-flight handle.
@@ -10642,25 +11102,20 @@ var deleteAction = {
       const ops = buildDeleteOps(scene, ids, "Delete");
       if (ops.length > 0) {
         if (applyOps) applyOps(ops, "Delete");
-        else scene.applyBatch(ops, "Delete", defaultCommitAdapter(scene));
+        else scene.applyBatch(ops, "Delete", defaultCommitAdapter(scene, selection.adapterMethods));
       }
       selection.set([]);
     }
   },
-  enabled: () => true
+  enabled: requiresSelection
 };
-function requiresSelection(deps) {
-  const selection = deps?.selection;
-  if (!selection || selection.get().length === 0) {
-    return ActionDisabledReason.SelectionRequired;
-  }
-  return true;
-}
 
 // src/interactions/actions/defaults/clipboard.ts
 var clipboardCopyAction = {
   id: "clipboard.copy",
   label: "Copy",
+  icon: createElement(CopyIcon),
+  group: "clipboard",
   defaultBinding: { kind: "key", key: "c", mods: { mod: true } },
   // Same gate as `duplicate`: a mode that can neither edit the page nor own a
   // selection has nothing to copy. Notably excludes `text-edit`, where Cmd+C
@@ -10680,6 +11135,8 @@ var clipboardCopyAction = {
 var clipboardCutAction = {
   id: "clipboard.cut",
   label: "Cut",
+  icon: createElement(CutIcon),
+  group: "clipboard",
   defaultBinding: { kind: "key", key: "x", mods: { mod: true } },
   eligible: { capability: "edits-page" },
   requires: ["clipboard", "scene", "selection", "applyOps"],
@@ -10697,13 +11154,31 @@ var clipboardCutAction = {
       const ops = buildDeleteOps(scene, ids, "Cut");
       if (ops.length > 0) {
         if (applyOps) applyOps(ops, "Cut");
-        else scene.applyBatch(ops, "Cut", defaultCommitAdapter(scene));
+        else scene.applyBatch(ops, "Cut", defaultCommitAdapter(scene, selection.adapterMethods));
       }
       selection.set([]);
     }
   },
   enabled: requiresSelection
 };
+var clipboardPasteAction = {
+  id: "clipboard.paste",
+  label: "Paste",
+  icon: createElement(PasteIcon),
+  group: "clipboard",
+  eligible: { capability: "edits-page" },
+  requires: ["clipboard"],
+  invoker: {
+    timing: "immediate",
+    run: (deps) => {
+      deps.clipboard?.paste();
+    }
+  },
+  enabled: (deps) => {
+    const clipboard = deps?.clipboard;
+    return clipboard && !clipboard.isEmpty() ? true : ActionDisabledReason.NotApplicable;
+  }
+};
 
 // src/interactions/actions/defaults/enterTextEdit.ts
 var enterTextEditAction = {
@@ -10798,8 +11273,6 @@ var selectAllAction = {
     }
   }
 };
-
-// src/interactions/actions/defaults/duplicate.ts
 var DUPLICATE_OFFSET = 12;
 function hasSelectedAncestor(scene, id, set) {
   let parent = scene.get(id)?.parent ?? null;
@@ -10829,6 +11302,8 @@ function copySubtree(scene, id, parent, offset, offsetDescendants, ops, d) {
 var duplicateAction = {
   id: "duplicate",
   label: "Duplicate",
+  icon: createElement(DuplicateIcon),
+  group: "edit",
   defaultBinding: { kind: "key", key: "d", mods: { mod: true } },
   eligible: { capability: ["edits-page", "creates-selection"] },
   // `selection` is read by the `enabled` gate as well as the invoker. An
@@ -10859,7 +11334,7 @@ var duplicateAction = {
       }
       if (ops.length === 0) return;
       if (applyOps) applyOps(ops, "Duplicate");
-      else scene.applyBatch(ops, "Duplicate", defaultCommitAdapter(scene));
+      else scene.applyBatch(ops, "Duplicate", defaultCommitAdapter(scene, selection.adapterMethods));
       selection.set(newIds);
     }
   },
@@ -10895,8 +11370,6 @@ function withKitRegistry(registry2) {
     }
   };
 }
-
-// src/interactions/actions/defaults/group.ts
 var containerIdCounter = 0;
 function freshContainerId() {
   return asNodeId(`n${(containerIdCounter++).toString(36)}-${Math.random().toString(36).slice(2, 8)}`);
@@ -10904,6 +11377,8 @@ function freshContainerId() {
 var groupAction = {
   id: "group",
   label: "Group",
+  icon: createElement(GroupIcon),
+  group: "structure",
   defaultBinding: { kind: "key", key: "g", mods: { mod: true } },
   eligible: { capability: "edits-page" },
   requires: ["scene", "selection", "applyOps", "poseDescriptor", "poseComposition"],
@@ -10963,15 +11438,17 @@ var groupAction = {
         }));
       }
       if (applyOps) applyOps(ops, "Group");
-      else scene.applyBatch(ops, "Group", defaultCommitAdapter(scene));
+      else scene.applyBatch(ops, "Group", defaultCommitAdapter(scene, selection.adapterMethods));
       selection.set([containerId]);
     }
   },
-  enabled: () => true
+  enabled: requiresSelection
 };
 var ungroupAction = {
   id: "ungroup",
   label: "Ungroup",
+  icon: createElement(UngroupIcon),
+  group: "structure",
   defaultBinding: { kind: "key", key: "g", mods: { mod: true, shift: true } },
   eligible: { capability: "edits-page" },
   requires: ["scene", "selection", "poseComposition"],
@@ -11012,13 +11489,22 @@ var ungroupAction = {
       });
     }
   },
-  enabled: () => true
+  enabled: (deps) => {
+    const selection = deps?.selection;
+    const scene = deps?.scene;
+    const any = selection?.get().some((id) => scene?.get(id)?.kind === "container");
+    return any ? true : ActionDisabledReason.NotApplicable;
+  }
 };
-
-// src/interactions/actions/defaults/undoRedo.ts
+function historyCan(deps, which) {
+  const history = deps?.history;
+  return history?.[which]?.() ? true : ActionDisabledReason.NotApplicable;
+}
 var undoAction = {
   id: "undo",
   label: "Undo",
+  icon: createElement(UndoIcon),
+  group: "history",
   defaultBinding: { kind: "key", key: "z", mods: { mod: true } },
   requires: ["history"],
   invoker: {
@@ -11026,11 +11512,14 @@ var undoAction = {
     run: (deps) => {
       deps.history?.undo?.();
     }
-  }
+  },
+  enabled: (deps) => historyCan(deps, "canUndo")
 };
 var redoAction = {
   id: "redo",
   label: "Redo",
+  icon: createElement(RedoIcon),
+  group: "history",
   defaultBinding: { kind: "key", key: "z", mods: { mod: true, shift: true } },
   requires: ["history"],
   invoker: {
@@ -11038,7 +11527,8 @@ var redoAction = {
     run: (deps) => {
       deps.history?.redo?.();
     }
-  }
+  },
+  enabled: (deps) => historyCan(deps, "canRedo")
 };
 
 // src/interactions/actions/flip/helpers.ts
@@ -11142,8 +11632,8 @@ function localMirror(axis, frame, id, pivotWorld) {
     rotation: 0
   });
   const theta = at.rotation ?? 0;
-  const mirror2 = axis === "x" ? [-1, 0, 0, 1, 0, 0] : [1, 0, 0, -1, 0, 0];
-  const turned = multiply$1(multiply$1(rotate(theta), mirror2), rotate(-theta));
+  const mirror = axis === "x" ? [-1, 0, 0, 1, 0, 0] : [1, 0, 0, -1, 0, 0];
+  const turned = multiply$1(multiply$1(rotate(theta), mirror), rotate(-theta));
   return multiply$1(translate$1(at.x, at.y), multiply$1(turned, translate$1(-at.x, -at.y)));
 }
 function flipSelection(selection, scene, axis, pivot, applyOps, geometryProjection, geom, poseComposition) {
@@ -11178,11 +11668,16 @@ function flipSelection(selection, scene, axis, pivot, applyOps, geometryProjecti
   }
   if (ops.length === 0) return;
   if (applyOps) applyOps(ops, "Flip");
-  else scene.applyBatch(ops, "Flip", defaultCommitAdapter(scene));
+  else scene.applyBatch(ops, "Flip", defaultCommitAdapter(scene, selection.adapterMethods));
 }
 var flipAction = {
   id: "flip",
   label: "Flip",
+  group: "flip",
+  variants: [
+    { key: "x", label: "Flip Horizontal", icon: createElement(FlipXIcon), params: { axis: "x" } },
+    { key: "y", label: "Flip Vertical", icon: createElement(FlipYIcon), params: { axis: "y" } }
+  ],
   defaultBinding: [
     { spec: { kind: "key", key: ["h", "H"], mods: { shift: true } }, opts: { params: { axis: "x" } } },
     { spec: { kind: "key", key: ["v", "V"], mods: { shift: true } }, opts: { params: { axis: "y" } } }
@@ -11265,7 +11760,7 @@ function nudgeSelection(selection, scene, dx, dy, applyOps, geometryProjection,
   }
   if (ops.length === 0) return;
   if (applyOps) applyOps(ops, "Nudge");
-  else scene.applyBatch(ops, "Nudge", defaultCommitAdapter(scene));
+  else scene.applyBatch(ops, "Nudge", defaultCommitAdapter(scene, selection.adapterMethods));
 }
 function makeNudgeAction(dir2) {
   return {
@@ -11495,20 +11990,22 @@ function createMoveToIndexOp(args) {
   };
 }
 registerOpFactory("moveToIndex", (args) => createMoveToIndexOp(args));
-
-// src/interactions/actions/defaults/reorder.ts
 function reorderSelection(selection, scene, direction, distance, applyOps) {
   const ids = selection.get();
   if (ids.length === 0) return;
   const reorderDir = direction === "forward" ? distance === "extreme" ? "front" : "forward" : distance === "extreme" ? "back" : "backward";
   const op = createReorderOp({ ids, direction: reorderDir, label: "Reorder" });
   if (applyOps) applyOps([op], "Reorder");
-  else scene.applyBatch([op], "Reorder", defaultCommitAdapter(scene));
+  else scene.applyBatch([op], "Reorder", defaultCommitAdapter(scene, selection.adapterMethods));
 }
 var reorderForwardAction = {
   id: "reorder.forward",
   label: "Bring Forward",
   group: "reorder",
+  variants: [
+    { key: "adjacent", label: "Bring Forward", icon: createElement(BringForwardIcon), params: { distance: "adjacent" } },
+    { key: "extreme", label: "Bring to Front", icon: createElement(BringToFrontIcon), params: { distance: "extreme" } }
+  ],
   defaultBinding: [
     {
       // Modifier matching is strict, so Shift must be absent here — listing
@@ -11554,6 +12051,10 @@ var reorderBackwardAction = {
   id: "reorder.backward",
   label: "Send Backward",
   group: "reorder",
+  variants: [
+    { key: "adjacent", label: "Send Backward", icon: createElement(SendBackwardIcon), params: { distance: "adjacent" } },
+    { key: "extreme", label: "Send to Back", icon: createElement(SendToBackIcon), params: { distance: "extreme" } }
+  ],
   defaultBinding: [
     {
       spec: { kind: "key", key: ["["], mods: { mod: true } },
@@ -11586,7 +12087,7 @@ var reorderBackwardAction = {
   },
   enabled: requiresSelection
 };
-var SVG_BASE = {
+var SVG_BASE3 = {
   viewBox: "0 0 16 16",
   width: 16,
   height: 16,
@@ -11599,42 +12100,42 @@ var AXIS = {
   fill: "none"
 };
 function AlignLeftIcon() {
-  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE, children: [
+  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE3, children: [
     /* @__PURE__ */ jsx("line", { x1: "2", y1: "2", x2: "2", y2: "14", ...AXIS }),
     /* @__PURE__ */ jsx("rect", { x: "2.5", y: "3", width: "9", height: "3" }),
     /* @__PURE__ */ jsx("rect", { x: "2.5", y: "9", width: "6", height: "3" })
   ] });
 }
 function AlignRightIcon() {
-  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE, children: [
+  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE3, children: [
     /* @__PURE__ */ jsx("line", { x1: "14", y1: "2", x2: "14", y2: "14", ...AXIS }),
     /* @__PURE__ */ jsx("rect", { x: "4.5", y: "3", width: "9", height: "3" }),
     /* @__PURE__ */ jsx("rect", { x: "7.5", y: "9", width: "6", height: "3" })
   ] });
 }
 function AlignTopIcon() {
-  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE, children: [
+  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE3, children: [
     /* @__PURE__ */ jsx("line", { x1: "2", y1: "2", x2: "14", y2: "2", ...AXIS }),
     /* @__PURE__ */ jsx("rect", { x: "3", y: "2.5", width: "3", height: "9" }),
     /* @__PURE__ */ jsx("rect", { x: "9", y: "2.5", width: "3", height: "6" })
   ] });
 }
 function AlignBottomIcon() {
-  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE, children: [
+  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE3, children: [
     /* @__PURE__ */ jsx("line", { x1: "2", y1: "14", x2: "14", y2: "14", ...AXIS }),
     /* @__PURE__ */ jsx("rect", { x: "3", y: "4.5", width: "3", height: "9" }),
     /* @__PURE__ */ jsx("rect", { x: "9", y: "7.5", width: "3", height: "6" })
   ] });
 }
 function AlignCenterXIcon() {
-  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE, children: [
+  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE3, children: [
     /* @__PURE__ */ jsx("line", { x1: "8", y1: "2", x2: "8", y2: "14", ...AXIS }),
     /* @__PURE__ */ jsx("rect", { x: "3.5", y: "3", width: "9", height: "3" }),
     /* @__PURE__ */ jsx("rect", { x: "5", y: "9", width: "6", height: "3" })
   ] });
 }
 function AlignCenterYIcon() {
-  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE, children: [
+  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE3, children: [
     /* @__PURE__ */ jsx("line", { x1: "2", y1: "8", x2: "14", y2: "8", ...AXIS }),
     /* @__PURE__ */ jsx("rect", { x: "3", y: "3.5", width: "3", height: "9" }),
     /* @__PURE__ */ jsx("rect", { x: "9", y: "5", width: "3", height: "6" })
@@ -11748,7 +12249,7 @@ function planDistribute(bounds, axis, mode) {
   }
   return targets;
 }
-var SVG_BASE2 = {
+var SVG_BASE4 = {
   viewBox: "0 0 16 16",
   width: 16,
   height: 16,
@@ -11756,14 +12257,14 @@ var SVG_BASE2 = {
   "aria-hidden": true
 };
 function DistributeHorizontalIcon() {
-  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE2, children: [
+  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE4, children: [
     /* @__PURE__ */ jsx("rect", { x: "1", y: "4", width: "3", height: "8" }),
     /* @__PURE__ */ jsx("rect", { x: "6.5", y: "4", width: "3", height: "8" }),
     /* @__PURE__ */ jsx("rect", { x: "12", y: "4", width: "3", height: "8" })
   ] });
 }
 function DistributeVerticalIcon() {
-  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE2, children: [
+  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE4, children: [
     /* @__PURE__ */ jsx("rect", { x: "4", y: "1", width: "8", height: "3" }),
     /* @__PURE__ */ jsx("rect", { x: "4", y: "6.5", width: "8", height: "3" }),
     /* @__PURE__ */ jsx("rect", { x: "4", y: "12", width: "8", height: "3" })
@@ -11933,7 +12434,7 @@ function applyBooleanOp(adapter, op) {
   dispatchApplyBatch(adapter, ops, LABEL[op]);
   return { kind: "applied", resultIds: newNodes.map((n) => n.id) };
 }
-var SVG_BASE3 = {
+var SVG_BASE5 = {
   viewBox: "0 0 20 20",
   width: 20,
   height: 20,
@@ -11943,7 +12444,7 @@ var SVG_BASE3 = {
   "aria-hidden": true
 };
 function UnionIcon() {
-  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE3, children: [
+  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE5, children: [
     /* @__PURE__ */ jsx("circle", { cx: "7", cy: "10", r: "5", fill: "currentColor", stroke: "none" }),
     /* @__PURE__ */ jsx("circle", { cx: "13", cy: "10", r: "5", fill: "currentColor", stroke: "none" }),
     /* @__PURE__ */ jsx("circle", { cx: "7", cy: "10", r: "5" }),
@@ -11951,7 +12452,7 @@ function UnionIcon() {
   ] });
 }
 function IntersectIcon() {
-  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE3, children: [
+  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE5, children: [
     /* @__PURE__ */ jsx("circle", { cx: "7", cy: "10", r: "5" }),
     /* @__PURE__ */ jsx("circle", { cx: "13", cy: "10", r: "5" }),
     /* @__PURE__ */ jsx(
@@ -11965,7 +12466,7 @@ function IntersectIcon() {
   ] });
 }
 function SubtractIcon() {
-  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE3, children: [
+  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE5, children: [
     /* @__PURE__ */ jsx("circle", { cx: "7", cy: "10", r: "5" }),
     /* @__PURE__ */ jsx("circle", { cx: "13", cy: "10", r: "5" }),
     /* @__PURE__ */ jsx(
@@ -11979,7 +12480,7 @@ function SubtractIcon() {
   ] });
 }
 function ExcludeIcon() {
-  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE3, children: [
+  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE5, children: [
     /* @__PURE__ */ jsx("circle", { cx: "7", cy: "10", r: "5" }),
     /* @__PURE__ */ jsx("circle", { cx: "13", cy: "10", r: "5" }),
     /* @__PURE__ */ jsx(
@@ -11994,14 +12495,14 @@ function ExcludeIcon() {
   ] });
 }
 function DivideIcon() {
-  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE3, children: [
+  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE5, children: [
     /* @__PURE__ */ jsx("circle", { cx: "7", cy: "10", r: "5" }),
     /* @__PURE__ */ jsx("circle", { cx: "13", cy: "10", r: "5" }),
     /* @__PURE__ */ jsx("line", { x1: "10", y1: "6", x2: "10", y2: "14" })
   ] });
 }
 function CropIcon() {
-  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE3, children: [
+  return /* @__PURE__ */ jsxs("svg", { ...SVG_BASE5, children: [
     /* @__PURE__ */ jsx("defs", { children: /* @__PURE__ */ jsx("clipPath", { id: "weasel-default-crop-mask", children: /* @__PURE__ */ jsx("rect", { x: "9", y: "5", width: "8", height: "10" }) }) }),
     /* @__PURE__ */ jsx("circle", { cx: "9", cy: "10", r: "5" }),
     /* @__PURE__ */ jsx(
@@ -12457,7 +12958,7 @@ function createPaintAction(spec) {
             }
             if (ops.length > 0) {
               if (scratch.applyOps) scratch.applyOps(ops, spec.label);
-              else scratch.scene.applyBatch(ops, spec.label, defaultCommitAdapter(scratch.scene));
+              else scratch.scene.applyBatch(ops, spec.label, defaultCommitAdapter(scratch.scene, selection.adapterMethods));
             }
             scratch.previews.clear();
           },
@@ -12508,14 +13009,23 @@ function mergeAlphaFromPrev(picked, prev) {
 // src/util/paint.ts
 var DEFAULT_FILL_COLOR = "#ffffffff";
 var DEFAULT_STROKE_COLOR = "#000000ff";
-var DEFAULT_PALETTE = [
-  "#7fb069",
-  "#d4a574",
-  "#a48bd4",
-  "#7ab8d4",
-  "#d47a7a"
-];
-var GHOST_STROKE = DEFAULT_PALETTE[0];
+var srgb = (hex) => hexToColorLiteral(hex);
+var DEFAULT_PALETTE = {
+  entries: [
+    { name: "sage", color: srgb("#7fb069") },
+    { name: "tan", color: srgb("#d4a574") },
+    { name: "lavender", color: srgb("#a48bd4") },
+    { name: "sky", color: srgb("#7ab8d4") },
+    { name: "rose", color: srgb("#d47a7a") }
+  ]
+};
+function cycleFill(seq, palette = DEFAULT_PALETTE, fallback = DEFAULT_FILL_COLOR) {
+  const { entries } = palette;
+  const entry = entries[(seq % entries.length + entries.length) % entries.length];
+  const color = entry && resolvePaletteColor(palette, { ref: entry.name });
+  return (color && colorLiteralToHex(color)) ?? fallback;
+}
+var GHOST_STROKE = cycleFill(0);
 function solid(color) {
   const a = getAlpha01(color);
   const rgb = color.length === 9 && color.startsWith("#") ? color.slice(0, 7) : color;
@@ -13018,7 +13528,7 @@ var ingestAction = {
         insert,
         applyOps: (ops, label) => {
           if (applyOps) applyOps(ops, label ?? "Ingest");
-          else scene.applyBatch(ops, label ?? "Ingest", { ...defaultCommitAdapter(scene), ...selection.adapterMethods });
+          else scene.applyBatch(ops, label ?? "Ingest", defaultCommitAdapter(scene, selection.adapterMethods));
         },
         scene,
         selection,
@@ -13045,8 +13555,8 @@ var KIT_STANDARD_DESCRIPTORS = [
   escapeAction,
   cancelGestureAction,
   selectAllAction,
-  deleteAction,
   duplicateAction,
+  deleteAction,
   groupAction,
   ungroupAction,
   undoAction,
@@ -13059,11 +13569,11 @@ var KIT_STANDARD_DESCRIPTORS = [
   reorderForwardAction,
   reorderBackwardAction,
   alignLeftAction,
+  alignCenterXAction,
   alignRightAction,
   alignTopAction,
-  alignBottomAction,
-  alignCenterXAction,
   alignCenterYAction,
+  alignBottomAction,
   distributeHorizontalAction,
   distributeVerticalAction,
   pathfinderUnionAction,
@@ -13101,8 +13611,9 @@ var KIT_STANDARD_DESCRIPTORS = [
   setFillOpacityAction,
   setStrokeOpacityAction,
   ingestAction,
+  clipboardCutAction,
   clipboardCopyAction,
-  clipboardCutAction
+  clipboardPasteAction
 ];
 var KIT_STANDARD_ACTION_IDS = KIT_STANDARD_DESCRIPTORS.map((a) => a.id);
 function useStandardActions(opts) {
@@ -14075,7 +14586,7 @@ function createTimeline(register, id, opts) {
   let playhead = 0;
   let prevPlayhead = -Infinity;
   let done = false;
-  let live = true;
+  let live2 = true;
   let cancelled = false;
   let wantPaused = opts.autoplay === false;
   let wantScale = 1;
@@ -14163,12 +14674,12 @@ function createTimeline(register, id, opts) {
       opts.onDone?.();
     }
     if (playhead < duration) return false;
-    live = false;
+    live2 = false;
     return true;
   };
   const onCancel = () => {
     cancelled = true;
-    live = false;
+    live2 = false;
     booker?.retract();
   };
   const base = register({ id, cancelKey: opts.cancelKey, tick, onCancel });
@@ -14176,11 +14687,11 @@ function createTimeline(register, id, opts) {
   const rearm = () => {
     if (cancelled || playhead >= duration) return;
     done = false;
-    if (live) return;
+    if (live2) return;
     booker?.rearm();
     lastVirtual = 0;
     offset = playhead;
-    live = true;
+    live2 = true;
     register({ id, cancelKey: opts.cancelKey, keepExisting: true, tick, onCancel });
     if (wantPaused) base.pause();
     base.setTimeScale(wantScale);
@@ -14208,8 +14719,8 @@ function createTimeline(register, id, opts) {
       wantScale = s;
       base.setTimeScale(s);
     },
-    timeScale: () => live ? base.timeScale() : wantScale,
-    isPaused: () => live ? base.isPaused() : wantPaused,
+    timeScale: () => live2 ? base.timeScale() : wantScale,
+    isPaused: () => live2 ? base.isPaused() : wantPaused,
     seek(t) {
       booker?.retract();
       offset = t - lastVirtual;
@@ -14890,22 +15401,34 @@ function useKeybindings(tools, options = {}) {
 
 // src/tools/prefs.ts
 function prefUnit(system, display, opts) {
-  const factor = system.units[display];
-  if (factor === void 0) {
-    const known = Object.keys(system.units).join(", ") || "(none)";
-    throw new Error(
-      `prefUnit: unknown unit '${display}' (system base: '${system.base}', known units: ${known})`
-    );
+  let self;
+  try {
+    self = unitScale(system, display);
+  } catch (e) {
+    throw new Error(`prefUnit: ${e instanceof Error ? e.message : String(e)}`);
   }
   const scale = opts?.precision === void 0 ? void 0 : 10 ** opts.precision;
   const suffix = opts?.suffix ?? display;
   const accepts = { [suffix]: 1 };
-  for (const [name, f] of Object.entries(system.units)) accepts[name] = f / factor;
+  for (const name of Object.keys(system.units)) {
+    const other = unitScale(system, name);
+    const factor = other.factor / self.factor;
+    const offset = (other.offset - self.offset) / self.factor;
+    accepts[name] = offset === 0 ? factor : { factor, offset };
+  }
+  const toDisplay = (stored) => {
+    const shown = (stored - self.offset) / self.factor;
+    return scale === void 0 ? shown : Math.round(shown * scale) / scale;
+  };
   return {
-    toDisplay: (stored) => scale === void 0 ? stored / factor : Math.round(stored / factor * scale) / scale,
-    fromDisplay: (shown) => shown * factor,
+    toDisplay,
+    fromDisplay: (shown) => shown * self.factor + self.offset,
     suffix,
-    accepts
+    accepts,
+    format: (stored) => `${formatUnit(stored, display, system, {
+      precision: opts?.precision ?? 2,
+      suffix: false
+    })}${suffix}`
   };
 }
 var TOOL_PREF_KINDS = {
@@ -15609,17 +16132,53 @@ function resolveFillPattern(fill) {
 }
 
 // src/features/images/imageCache.ts
+var MAX_VECTOR_RASTER_PIXELS = 4096 * 4096;
+var SHRINK_SLACK = 4;
+var FALLBACK_WIDTH = 300;
+var FALLBACK_HEIGHT = 150;
 var cache6 = /* @__PURE__ */ new Map();
 var subscribers = /* @__PURE__ */ new Set();
-var defaultLoader = async (src) => {
+var decodedVectors = /* @__PURE__ */ new Map();
+function isVectorImageSrc(src) {
+  if (/^data:image\/svg\+xml[;,]/i.test(src)) return true;
+  if (/^(data|blob):/i.test(src)) return false;
+  return /\.svgz?$/i.test(src.replace(/[?#].*$/, ""));
+}
+function requireDom() {
   if (typeof Image === "undefined" || typeof createImageBitmap === "undefined") {
     throw new Error("weasel imageCache: no DOM image loader in this environment");
   }
+}
+async function decodeImage(src) {
   const img = new Image();
   img.crossOrigin = "anonymous";
   img.src = src;
   await img.decode();
-  return createImageBitmap(img);
+  return img;
+}
+function decodeVector(src) {
+  let decoded = decodedVectors.get(src);
+  if (!decoded) {
+    decoded = decodeImage(src);
+    decodedVectors.set(src, decoded);
+    decoded.catch(() => decodedVectors.delete(src));
+  }
+  return decoded;
+}
+async function rasterizeVector(src, size) {
+  const img = await decodeVector(src);
+  const width = size?.width ?? (img.naturalWidth || FALLBACK_WIDTH);
+  const height = size?.height ?? (img.naturalHeight || FALLBACK_HEIGHT);
+  const canvas = typeof OffscreenCanvas !== "undefined" ? new OffscreenCanvas(width, height) : Object.assign(document.createElement("canvas"), { width, height });
+  const c2d = canvas.getContext("2d");
+  if (!c2d) throw new Error("weasel imageCache: no 2D context to rasterize an SVG");
+  c2d.drawImage(img, 0, 0, width, height);
+  return createImageBitmap(canvas);
+}
+var defaultLoader = async (src, size) => {
+  requireDom();
+  if (isVectorImageSrc(src)) return rasterizeVector(src, size);
+  return createImageBitmap(await decodeImage(src));
 };
 var loader = defaultLoader;
 function notify() {
@@ -15631,7 +16190,11 @@ function startLoad(src) {
   loader(src).then(
     (bitmap) => {
       if (cache6.get(src) !== entry) return;
-      cache6.set(src, { status: "ready", bitmap });
+      cache6.set(src, {
+        status: "ready",
+        bitmap,
+        ...isVectorImageSrc(src) ? { vector: { natural: { width: bitmap.width, height: bitmap.height }, scale: 1, failed: /* @__PURE__ */ new Set() } } : {}
+      });
       notify();
     },
     () => {
@@ -15641,11 +16204,54 @@ function startLoad(src) {
     }
   );
 }
-function getImageBitmap(src) {
+function rasterScaleFor(natural, drawnAt) {
+  const need = Math.max(drawnAt.width / natural.width, drawnAt.height / natural.height);
+  if (!(need > 0) || !Number.isFinite(need)) return void 0;
+  const side = maxImageTextureSide();
+  const cap = Math.min(
+    side / natural.width,
+    side / natural.height,
+    Math.sqrt(MAX_VECTOR_RASTER_PIXELS / (natural.width * natural.height))
+  );
+  return Math.min(2 ** Math.ceil(Math.log2(need)), cap);
+}
+function maybeReraster(src, entry, v, drawnAt) {
+  if (v.pending !== void 0) return;
+  const target = rasterScaleFor(v.natural, drawnAt);
+  if (target === void 0) return;
+  const grow = target > v.scale;
+  if (!grow && target * SHRINK_SLACK > v.scale) return;
+  for (const f of v.failed) if (target === f || grow && f > v.scale && target >= f) return;
+  v.pending = target;
+  const size = {
+    width: Math.max(1, Math.round(v.natural.width * target)),
+    height: Math.max(1, Math.round(v.natural.height * target))
+  };
+  loader(src, size).then(
+    (bitmap) => {
+      if (cache6.get(src) !== entry) return;
+      v.pending = void 0;
+      const old = entry.bitmap;
+      entry.bitmap = bitmap;
+      v.scale = target;
+      if (old && old !== bitmap) releaseImageSource(old);
+      notify();
+    },
+    () => {
+      if (cache6.get(src) !== entry) return;
+      v.pending = void 0;
+      v.failed.add(target);
+    }
+  );
+}
+function getImageBitmap(src, drawnAt) {
   const entry = cache6.get(src);
-  if (entry) return entry.bitmap;
-  startLoad(src);
-  return void 0;
+  if (!entry) {
+    startLoad(src);
+    return void 0;
+  }
+  if (drawnAt && entry.vector) maybeReraster(src, entry, entry.vector, drawnAt);
+  return entry.bitmap;
 }
 function imageStatus(src) {
   return cache6.get(src)?.status ?? "idle";
@@ -15967,6 +16573,21 @@ function pathForShape(d, p) {
       return { kind: "rect", x: p.x, y: p.y, width: p.width, height: p.height };
   }
 }
+function sourceInPixels(s, bmp) {
+  return {
+    x: s.x * bmp.width,
+    y: s.y * bmp.height,
+    w: s.width * bmp.width,
+    h: s.height * bmp.height
+  };
+}
+function drawnSize(pose, source, pixelScale) {
+  if (!(pixelScale && pixelScale > 0)) return void 0;
+  return {
+    width: Math.abs(pose.width) * pixelScale / (source?.width || 1),
+    height: Math.abs(pose.height) * pixelScale / (source?.height || 1)
+  };
+}
 var IMAGE_PAINTER = {
   id: "kit:image",
   matches: (node) => {
@@ -15977,7 +16598,7 @@ var IMAGE_PAINTER = {
   paint: (node, pose, ctx) => {
     const d = node.data;
     const p = pose;
-    const bmp = ctx?.resolveImage ? ctx.resolveImage(node) : getImageBitmap(d.image.src);
+    const bmp = ctx?.resolveImage ? ctx.resolveImage(node) : getImageBitmap(d.image.src, drawnSize(p, d.image.source, ctx?.pixelScale));
     if (bmp) {
       return [{
         kind: "image",
@@ -15986,7 +16607,10 @@ var IMAGE_PAINTER = {
         y: p.y,
         w: p.width,
         h: p.height,
-        ...d.image.opacity !== void 0 ? { opacity: d.image.opacity } : {}
+        ...d.image.opacity !== void 0 ? { opacity: d.image.opacity } : {},
+        ...d.image.source ? { source: sourceInPixels(d.image.source, bmp) } : {},
+        ...d.image.flipX ? { flipX: true } : {},
+        ...d.image.flipY ? { flipY: true } : {}
       }];
     }
     const error = ctx?.resolveImage ? false : imageStatus(d.image.src) === "error";
@@ -16232,7 +16856,11 @@ function scenePickSource(scene, opts = {}) {
       const n = scene.get(asNodeId(id));
       return n ? effectivePose(scene, n) : void 0;
     },
-    getParent: (id) => scene.get(asNodeId(id))?.parent ?? null
+    getParent: (id) => scene.get(asNodeId(id))?.parent ?? null,
+    definesFrame: (id) => {
+      const n = scene.get(asNodeId(id));
+      return n === void 0 || definesFrame(n);
+    }
   } : null;
   const poseOf = getPose ? (node) => getPose(node.id) : chain ? (node) => composeWorldPose(chain, node.id, composition.compose) : (node) => effectivePose(scene, node);
   const childrenOf = (id) => scene.childrenOf(id);
@@ -16683,6 +17311,92 @@ function useTextTool() {
     []
   );
 }
+var PERCENT = {
+  toDisplay: (v) => Math.round(v * 1e3) / 10,
+  // Rounded rather than divided: 33.3 / 100 is 0.33299999999999996, and that
+  // dust would be written into the document and shown back on the next read.
+  fromDisplay: (v) => Math.round(v * 1e3) / 1e5,
+  suffix: "%"
+};
+var flag = (name, icon) => ({
+  kind: "boolean",
+  name,
+  description: `${name} for the characters in the range.`,
+  icon,
+  control: "toggle",
+  pair: "Character style",
+  default: false
+});
+useTextTool.options = {
+  name: "Text",
+  description: "Character styling for the selected range.",
+  children: {
+    bold: flag("Bold", "bold"),
+    italic: flag("Italic", "italic"),
+    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.
+    script: {
+      kind: "script",
+      name: "Script",
+      description: "Raise or lower the range off the baseline, at a smaller size.",
+      default: void 0
+    },
+    textTransform: {
+      kind: "enum",
+      name: "Case",
+      description: "Draw the range in capitals, lowercase or title case. The text itself is unchanged.",
+      control: "toggle",
+      default: "none",
+      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" }]
+    },
+    fontFamily: {
+      kind: "font-family",
+      name: "Font",
+      description: "Typeface for the range.",
+      default: void 0
+    },
+    fontSize: { kind: "number", name: "Size", description: "Type size.", min: 1, step: 1, default: 16 },
+    letterSpacing: {
+      kind: "number",
+      name: "Tracking",
+      // The typographic term, short enough for a strip; `name` stays the
+      // accessible one.
+      short: "VA",
+      description: "Space added between characters.",
+      step: 0.1,
+      default: 0
+    },
+    baselineShift: {
+      kind: "number",
+      name: "Baseline shift",
+      short: "Shift",
+      description: "Raise or lower the range, in ems of the inherited size.",
+      step: 1e-3,
+      unit: PERCENT,
+      default: 0
+    },
+    fontScale: {
+      kind: "number",
+      name: "Scale",
+      description: "Size of the range against the inherited size.",
+      min: 0.01,
+      step: 1e-3,
+      unit: PERCENT,
+      default: 1
+    },
+    fill: {
+      kind: "color",
+      name: "Color",
+      description: "Ink for the range.",
+      alpha: true,
+      default: "#000000"
+    }
+  }
+};
 
 // src/features/paths/nearestAnchor.ts
 function nearestPathAnchor(paths, point, px, scale, accept) {
@@ -16748,44 +17462,9 @@ function anchorCount(s) {
   return (s.current ? s.current.anchors.length : 0) + s.finishedSubpaths.reduce((n, sp) => n + sp.anchors.length, 0);
 }
 function buildPath(subpaths, trailing) {
-  const b = new PathBuilder();
   const all = [...subpaths];
   if (trailing && trailing.anchors.length > 0) all.push(trailing);
-  for (const sp of all) {
-    if (sp.anchors.length === 0) continue;
-    const first = sp.anchors[0];
-    b.moveTo(first.x, first.y);
-    for (let i = 1; i < sp.anchors.length; i++) {
-      const prev = sp.anchors[i - 1];
-      const curr = sp.anchors[i];
-      const out = prev.outHandle;
-      const inH = curr.inHandle ?? mirrorHandle(prev, out);
-      if (out || curr.inHandle) {
-        const c1 = out ?? { x: prev.x, y: prev.y };
-        const c2 = inH ?? { x: curr.x, y: curr.y };
-        b.curveTo(c1.x, c1.y, c2.x, c2.y, curr.x, curr.y);
-      } else {
-        b.lineTo(curr.x, curr.y);
-      }
-    }
-    if (sp.closed) {
-      const last = sp.anchors[sp.anchors.length - 1];
-      const first0 = sp.anchors[0];
-      const out = last.outHandle;
-      const inH = first0.inHandle ?? mirrorHandle(last, out);
-      if (out || first0.inHandle) {
-        const c1 = out ?? { x: last.x, y: last.y };
-        const c2 = inH ?? { x: first0.x, y: first0.y };
-        b.curveTo(c1.x, c1.y, c2.x, c2.y, first0.x, first0.y);
-      }
-      b.close();
-    }
-  }
-  return b.build();
-}
-function mirrorHandle(anchor, out) {
-  if (!out || anchor.altBroken) return void 0;
-  return { x: 2 * anchor.x - out.x, y: 2 * anchor.y - out.y };
+  return anchorsToPath(all.map((sp) => sp.anchors), all.map((sp) => sp.closed));
 }
 function usePenTool(options) {
   const { wrapPath, adapter, autoSelect = true, autoCommitOnClose = true, closeHitRadius = 8, anchorSnapRadius = 8, snapPoint: snapPoint2 } = options;
@@ -16830,6 +17509,64 @@ function usePenTool(options) {
     if (optsRef.current.autoSelect) optsRef.current.adapter.setSelection([id]);
     resetScratch(s);
   }, [commitContinuation]);
+  const joinable = useCallback((s, deps, hit) => {
+    if (!hit || hit.end === null || !s.current || s.current.anchors.length === 0) return false;
+    const cont = s.continuing;
+    if (cont && hit.id === cont.id && hit.sub === cont.sub) return false;
+    const scene = deps.scene;
+    if (!scene && !deps.applyOps) return false;
+    if (!(cont ? deps.editAnchors.editOps : optsRef.current.adapter.makeNode)) return false;
+    return cont?.id === hit.id || scene?.get(hit.id) !== void 0;
+  }, []);
+  const commitJoin = useCallback((s, deps, hit) => {
+    const edit = deps.editAnchors;
+    const scene = deps.scene;
+    const current = s.current;
+    const { anchors: added, closed: addedClosed } = pathToAnchors(buildPath([...s.finishedSubpaths, current], null));
+    const other = edit.getEditablePath(hit.id);
+    const otherSet = pathToAnchors(other);
+    const tail = hit.end === "last" ? reverseAnchors(otherSet.anchors[hit.sub]) : otherSet.anchors[hit.sub];
+    const joined = added[added.length - 1];
+    const joint = joined[joined.length - 1];
+    const out = current.anchors[current.anchors.length - 1].outHandle ?? tail[0].outHandle;
+    if (out) joint.outHandle = { ...out };
+    joined.push(...tail.slice(1));
+    const cont = s.continuing;
+    const sameNode = cont?.id === hit.id;
+    const rest = sameNode ? { anchors: [], closed: [] } : {
+      anchors: otherSet.anchors.filter((_, i) => i !== hit.sub),
+      closed: otherSet.closed.filter((_, i) => i !== hit.sub)
+    };
+    const label = "Join paths";
+    const ops = [];
+    let keptId;
+    if (cont) {
+      if (cont.reversed) added[0] = reverseAnchors(added[0]);
+      const set = pathToAnchors(cont.original);
+      set.anchors.splice(cont.sub, 1, added[0]);
+      set.closed.splice(cont.sub, 1, addedClosed[0]);
+      set.anchors.push(...added.slice(1), ...rest.anchors);
+      set.closed.push(...addedClosed.slice(1), ...rest.closed);
+      if (sameNode) {
+        set.anchors.splice(hit.sub, 1);
+        set.closed.splice(hit.sub, 1);
+      }
+      const next = { ...anchorsToPath(set.anchors, set.closed), fillRule: cont.original.fillRule };
+      ops.push(...edit.editOps(cont.id, next, label));
+      keptId = cont.id;
+    } else {
+      const path = anchorsToPath([...added, ...rest.anchors], [...addedClosed, ...rest.closed]);
+      const node = optsRef.current.adapter.makeNode(optsRef.current.wrapPath(path, { closed: false }));
+      ops.push(createInsertOp({ node }));
+      keptId = node.id;
+    }
+    if (!sameNode) ops.push(createDeleteOp({ node: scene.get(hit.id) }));
+    const applyOps = deps.applyOps;
+    if (applyOps) applyOps(ops, label);
+    else scene.applyBatch(ops, label, defaultCommitAdapter(scene));
+    if (optsRef.current.autoSelect) optsRef.current.adapter.setSelection([keptId]);
+    resetScratch(s);
+  }, []);
   const pickUpEndpoint = useCallback((deps, wx, wy) => {
     const scratch = scratchRef.current;
     if (scratch.current || scratch.finishedSubpaths.length > 0) return false;
@@ -16852,9 +17589,9 @@ function usePenTool(options) {
     const radius = optsRef.current.anchorSnapRadius;
     if (radius > 0) {
       const hit = nearestPathAnchor(pathsNear(deps, x, y, radius), { x, y }, radius, viewScale(deps));
-      if (hit) return { x: hit.x, y: hit.y };
+      if (hit) return { x: hit.x, y: hit.y, hit };
     }
-    return snap2(x, y);
+    return { ...snap2(x, y), hit: null };
   }, [snap2]);
   const withinCloseRadius = useCallback(
     (deps, ax, ay, wx, wy) => {
@@ -16869,7 +17606,7 @@ function usePenTool(options) {
         id: "pen.placeAnchor",
         label: "Pen \u2014 place anchor",
         eligible: { capability: "creates-paths" },
-        requires: ["view", "areaSelect", "editAnchors"],
+        requires: ["view", "areaSelect", "editAnchors", "scene", "applyOps"],
         invoker: {
           timing: "immediate",
           run: (deps, params) => {
@@ -16879,7 +17616,7 @@ function usePenTool(options) {
               forceRenderRef.current();
               return;
             }
-            const { x: wx, y: wy } = placeAt(deps, p.pressX, p.pressY);
+            const { x: wx, y: wy, hit } = placeAt(deps, p.pressX, p.pressY);
             const scratch = s();
             if (scratch.current && scratch.current.anchors.length >= 3) {
               const first = scratch.current.anchors[0];
@@ -16893,8 +17630,10 @@ function usePenTool(options) {
                 return;
               }
             }
+            const join = joinable(scratch, deps, hit);
             if (!scratch.current) scratch.current = { anchors: [], closed: false };
             scratch.current.anchors.push({ x: wx, y: wy });
+            if (join) commitJoin(scratch, deps, hit);
             forceRenderRef.current();
           }
         }
@@ -16926,32 +17665,35 @@ function usePenTool(options) {
         id: "pen.dragHandle",
         label: "Pen \u2014 drag out a bezier handle",
         eligible: { capability: "creates-paths" },
-        requires: ["view", "areaSelect", "editAnchors"],
+        requires: ["view", "areaSelect", "editAnchors", "scene", "applyOps"],
         invoker: {
           timing: "ongoing",
           start: (ctx) => {
             const scratch = s();
             const origin = ctx.drag?.start ?? ctx.world;
             const pickedUp = pickUpEndpoint(ctx.deps, origin.x, origin.y);
+            let joinHit = null;
             if (!pickedUp) {
-              const { x: ax, y: ay } = placeAt(ctx.deps, origin.x, origin.y);
+              const { x: ax, y: ay, hit } = placeAt(ctx.deps, origin.x, origin.y);
+              if (joinable(scratch, ctx.deps, hit)) joinHit = hit;
               if (!scratch.current) scratch.current = { anchors: [], closed: false };
               scratch.current.anchors.push({ x: ax, y: ay });
             }
             scratch.draggingHandleAt = scratch.current.anchors.length - 1;
-            applyOutHandle(scratch, ctx.world, ctx.modifiers.shift, optsRef.current.snapPoint);
             if (ctx.modifiers.alt) {
               scratch.current.anchors[scratch.draggingHandleAt].altBroken = true;
             }
+            const linked = !pickedUp;
+            applyOutHandle(scratch, ctx.world, ctx.modifiers.shift, linked, optsRef.current.snapPoint);
             forceRenderRef.current();
             return {
               onMove: (moveCtx) => {
                 const sm = s();
                 if (sm.draggingHandleAt === null) return;
-                applyOutHandle(sm, moveCtx.world, moveCtx.modifiers.shift, optsRef.current.snapPoint);
                 if (moveCtx.modifiers.alt && sm.current) {
                   sm.current.anchors[sm.draggingHandleAt].altBroken = true;
                 }
+                applyOutHandle(sm, moveCtx.world, moveCtx.modifiers.shift, linked, optsRef.current.snapPoint);
                 forceRenderRef.current();
               },
               onEnd: (endCtx, reason) => {
@@ -16968,12 +17710,13 @@ function usePenTool(options) {
                   return;
                 }
                 if (se.draggingHandleAt !== null) {
-                  applyOutHandle(se, endCtx.world, endCtx.modifiers.shift, optsRef.current.snapPoint);
                   if (endCtx.modifiers.alt && se.current) {
                     se.current.anchors[se.draggingHandleAt].altBroken = true;
                   }
+                  applyOutHandle(se, endCtx.world, endCtx.modifiers.shift, linked, optsRef.current.snapPoint);
                   se.draggingHandleAt = null;
                 }
+                if (joinHit && se.current) commitJoin(se, ctx.deps, joinHit);
                 forceRenderRef.current();
               }
             };
@@ -17014,7 +17757,7 @@ function usePenTool(options) {
         }
       }
     ];
-  }, [commit, placeAt, withinCloseRadius, pickUpEndpoint]);
+  }, [commit, placeAt, withinCloseRadius, pickUpEndpoint, joinable, commitJoin]);
   return useMemo(() => {
     return defineTool({
       id: "pen",
@@ -17072,7 +17815,7 @@ usePenTool.prefs = {
     }
   }
 };
-function applyOutHandle(s, target, shift, snap2) {
+function applyOutHandle(s, target, shift, linked, snap2) {
   if (s.current === null || s.draggingHandleAt === null) return;
   const anchor = s.current.anchors[s.draggingHandleAt];
   const to = snap2 ? snap2(target) : target;
@@ -17084,6 +17827,7 @@ function applyOutHandle(s, target, shift, snap2) {
     dy = c.dy;
   }
   anchor.outHandle = { x: anchor.x + dx, y: anchor.y + dy };
+  if (linked && !anchor.altBroken) anchor.inHandle = { x: anchor.x - dx, y: anchor.y - dy };
 }
 function viewScale(deps) {
   return deps.view?.get().scale ?? { x: 1, y: 1 };
@@ -17536,9 +18280,24 @@ function usePencilTool() {
 }
 
 // src/canvas/defaultDrawOne.ts
-function defaultDrawOne(node, pose, _view, ctx) {
+function pixelScaleOf(view) {
+  const dpr = typeof window !== "undefined" && window.devicePixelRatio || 1;
+  return Math.max(Math.abs(view.scale.x), Math.abs(view.scale.y)) * dpr;
+}
+var lastView;
+var lastViewCtx = {};
+function viewOnlyCtx(view) {
+  const pixelScale = pixelScaleOf(view);
+  if (view !== lastView || lastViewCtx.pixelScale !== pixelScale) {
+    lastView = view;
+    lastViewCtx = { pixelScale };
+  }
+  return lastViewCtx;
+}
+function defaultDrawOne(node, pose, view, ctx) {
   const painter = findNodeShape(node);
-  const primary = painter ? painter.paint(node, pose, ctx) : [];
+  const paintCtx = !view || ctx?.pixelScale !== void 0 ? ctx : ctx ? { ...ctx, pixelScale: pixelScaleOf(view) } : viewOnlyCtx(view);
+  const primary = painter ? painter.paint(node, pose, paintCtx) : [];
   const data = node.data;
   if (data?.label && data.text == null) {
     const p = pose;
@@ -18604,11 +19363,11 @@ function buildSceneTree(adapter, drawOne, view, forLayer, derivedPathOf) {
   const buckets = /* @__PURE__ */ new Map();
   for (const l of layers) buckets.set(l.id, []);
   const compose2 = adapter.composePose?.bind(adapter);
-  function visit(id, ancestorClips, parentWorld) {
+  function visit(id, ancestorClips, parentFrame) {
     const node = adapter.getNode(id);
     if (!node) return;
     const local = adapter.getPose(id);
-    const pose = compose2 && parentWorld !== null ? compose2(parentWorld, local) : local;
+    const pose = compose2 && parentFrame !== null ? compose2(parentFrame, local) : local;
     const paints = forLayer === void 0 || node.layer === forLayer;
     const self = paints ? drawOne(node, pose, view) : [];
     let ownClips = ancestorClips;
@@ -18632,7 +19391,8 @@ function buildSceneTree(adapter, drawOne, view, forLayer, derivedPathOf) {
         bucket.push(ownClips.length > 0 ? wrapInClips(self, ownClips) : { kind: "group", children: self });
       }
     }
-    for (const cid of adapter.getChildren(id)) visit(cid, ownClips, pose);
+    const childFrame = definesFrame(node) ? pose : parentFrame;
+    for (const cid of adapter.getChildren(id)) visit(cid, ownClips, childFrame);
   }
   for (const rootId of adapter.getChildren(null)) visit(rootId, [], null);
   const out = [];
@@ -19842,219 +20602,641 @@ function wireSceneSlotToScene(slot, scene, alphaFor, colorOverrides) {
     alphaFor: composeAlphaFor(scene, alphaFor)
   };
 }
-
-// src/core/scene/poseOverrides.ts
-function createPoseOverrides(getNode, onInvalidate) {
-  const entries = /* @__PURE__ */ new Map();
-  const listeners = /* @__PURE__ */ new Set();
-  let generation2 = 0;
-  function invalidate(id) {
-    const node = getNode(id);
-    if (node) dropPoseKeyedMemoSlots(node);
-    onInvalidate?.(id);
+function 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 published() {
-    generation2++;
-    for (const listener of listeners) listener();
+  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;
   }
-  return {
-    set(id, entry) {
-      entries.set(id, entry);
-      invalidate(id);
-      published();
+  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;
+}
+
+// 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)}`;
+}
+var pasteIdCounter = 0;
+function pasteNodeId() {
+  return `paste-${(pasteIdCounter++).toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function copyField(value) {
+  if (Array.isArray(value)) return [...value];
+  if (value !== null && typeof value === "object") return { ...value };
+  return value;
+}
+function sceneToAdapter(scene, options = {}) {
+  const visibleLayers = () => {
+    const out = /* @__PURE__ */ new Set();
+    for (const layer of scene.layers) {
+      if (layer.visible) out.add(layer.id);
+    }
+    return out;
+  };
+  const sel = options.selection;
+  const getSelection = sel?.getSelection ?? sel?.get ?? (() => []);
+  const setSelection = sel?.setSelection ?? sel?.set ?? (() => {
+  });
+  const d = options.poseDescriptor ?? AUTO_POSE_DESCRIPTOR;
+  const poseBounds = (p) => visualBoundsViaDescriptor(p, d);
+  const translate3 = (p, dx, dy, node) => translatePoseViaDescriptor(
+    p,
+    dx,
+    dy,
+    node === void 0 ? d : poseDescriptorForNode(d, node)
+  );
+  const composition = options.poseComposition;
+  const composes = composition !== void 0 && composition.closure !== "identity";
+  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."
+    );
+  }
+  const adapter = {
+    getNode(id) {
+      return scene.get(asNodeId(id));
     },
-    get(id) {
-      return entries.get(id);
+    getNodes() {
+      const visible = visibleLayers();
+      const out = [];
+      for (const n of scene.renderOrderNodes()) {
+        if (visible.has(n.layer)) out.push(n);
+      }
+      return out;
     },
-    has(id) {
-      return entries.has(id);
+    getPose(id) {
+      const nid = asNodeId(id);
+      const n = scene.get(nid);
+      if (!n) throw new Error(`sceneToAdapter: unknown node "${id}"`);
+      return effectivePose(scene, n);
     },
-    ids() {
-      return [...entries.keys()];
+    getParent(id) {
+      const n = scene.get(asNodeId(id));
+      return n?.parent ?? null;
     },
-    clear(id) {
-      if (!entries.delete(id)) return;
-      invalidate(id);
-      published();
+    definesFrame(id) {
+      const n = scene.get(asNodeId(id));
+      return n === void 0 || definesFrame(n);
     },
-    clearAll() {
-      if (entries.size === 0) return;
-      for (const id of entries.keys()) invalidate(id);
-      entries.clear();
-      published();
+    getWorldPose(id) {
+      if (!composes) return adapter.getPose(id);
+      return composeWorldPose(adapter, id, composition.compose);
     },
-    commit() {
-      for (const id of entries.keys()) invalidate(id);
-      published();
+    // Only present when it would do something: the render walk skips the fold
+    // entirely when this is absent, which is the absolute-pose path.
+    ...composes ? { composePose: composition.compose } : {},
+    setPose(id, pose) {
+      if (options.cascadeContainerPose) {
+        const node = scene.get(asNodeId(id));
+        if (node && node.kind === "container") {
+          const g = poseDescriptorForNode(d, node);
+          const before = g.getBounds(node.pose);
+          const after = g.getBounds(pose);
+          const dx = after.x - before.x;
+          const dy = after.y - before.y;
+          if (dx !== 0 || dy !== 0) {
+            const descIds = [];
+            const collect = (rootId) => {
+              for (const cid of scene.childrenOf(asNodeId(rootId))) {
+                descIds.push(cid);
+                collect(cid);
+              }
+            };
+            collect(id);
+            scene.batch("move container", () => {
+              scene.setPose(asNodeId(id), pose);
+              for (const cid of descIds) {
+                const cn = scene.get(asNodeId(cid));
+                if (!cn) continue;
+                scene.setPose(asNodeId(cid), translate3(cn.pose, dx, dy, cn));
+              }
+            });
+            return;
+          }
+        }
+      }
+      scene.setPose(asNodeId(id), pose);
     },
-    subscribe(fn) {
-      listeners.add(fn);
-      return () => {
-        listeners.delete(fn);
-      };
+    setParent(id, parentId) {
+      scene.move(asNodeId(id), parentId === null ? null : asNodeId(parentId));
     },
-    getGeneration() {
-      return generation2;
-    }
-  };
-}
-
-// src/core/scene/scene.ts
-var defaultIdCounter = 0;
-var defaultGenerateId = () => asNodeId(`n${(defaultIdCounter++).toString(36)}-${Math.random().toString(36).slice(2, 8)}`);
-function layerFromSerialized(spec) {
-  const base = {
-    id: spec.id,
-    visible: spec.visible ?? true,
-    locked: spec.locked ?? false
-  };
-  return spec.kind === "user" ? { ...base, kind: "user", name: spec.name ?? spec.id } : { ...base, kind: "system" };
-}
-function createScene(options) {
-  if (!options.systemLayers || options.systemLayers.length === 0) {
-    throw new Error("useScene: systemLayers must declare at least one layer");
-  }
-  const state = {
-    nodes: /* @__PURE__ */ new Map(),
-    roots: [],
-    layers: [],
-    layerIndex: /* @__PURE__ */ new Map()
-  };
-  const registry2 = withKitRegistry(options.registry ?? {});
-  const fnFields = createNodeFnFields(registry2);
-  const fnField = (name) => fnFields.find((f) => f.spec.field === name);
-  const dependents = createDependentsIndex();
-  const childDerived = /* @__PURE__ */ new Set();
-  function invalidateDependents(id) {
-    invalidateChildDerivedFrom(state.nodes.get(id)?.parent ?? null);
-    if (dependents.isEmpty()) return;
-    const subtree = [id];
-    descendants(id, subtree);
-    for (const src of subtree) {
-      for (const dep of dependents.transitiveDependentsOf(src)) {
-        const node = state.nodes.get(dep);
-        if (node !== void 0) dropPoseKeyedMemoSlots(node);
-      }
-    }
-  }
-  function invalidateChildDerivedFrom(start) {
-    if (childDerived.size === 0) return;
-    let cursor = start;
-    while (cursor !== null) {
-      const node = state.nodes.get(cursor);
-      if (node === void 0) return;
-      if (childDerived.has(cursor)) {
-        dropPoseKeyedMemoSlots(node);
-        for (const dep of dependents.transitiveDependentsOf(cursor)) {
-          const d = state.nodes.get(dep);
-          if (d !== void 0) dropPoseKeyedMemoSlots(d);
+    getChildren(id) {
+      if (id === null) return [...scene.roots];
+      return [...scene.childrenOf(asNodeId(id))];
+    },
+    setChildOrder(parentId, ids) {
+      scene.batch("Reorder", () => {
+        for (let i = 0; i < ids.length; i++) {
+          const current = parentId === null ? scene.roots : scene.childrenOf(asNodeId(parentId));
+          if (current[i] === ids[i]) continue;
+          scene.reorder(asNodeId(ids[i]), i);
         }
+      });
+    },
+    getLayers() {
+      return scene.layers.map((l) => ({ id: l.id, visible: l.visible }));
+    },
+    ...options.layouts ? {
+      getLayout: typeof options.layouts === "function" ? options.layouts : (id) => options.layouts[id] ?? null
+    } : {},
+    // Unified applyOps: when a label is supplied the ops are wrapped in a
+    // batch checkpoint (history-aware path used by Move/Resize/Rotate/Insert/
+    // Delete tools). When a journal is active (via scene's getActiveJournal
+    // option), scene.applyBatch routes to the journal instead of recording a
+    // new parent-history entry. Without a label the ops are applied transiently
+    // via applyOpsTo (AreaSelectAdapter contract — no checkpoint).
+    applyOps(ops, label) {
+      if (label !== void 0) {
+        scene.applyBatch(ops, label, this);
+      } else {
+        applyOpsTo(this, ops);
       }
-      cursor = node.parent;
-    }
-  }
-  function trackChildDerived(id, dependsOn) {
-    if (dependsOn === "children") childDerived.add(id);
-    else childDerived.delete(id);
-  }
-  function retarget(id, dependsOn) {
-    const node = requireNode(id);
-    if (dependsOn === void 0) delete node.dependsOn;
-    else node.dependsOn = dependsOn;
-    dependents.add(id, dependsOn === void 0 || dependsOn === "children" ? [] : dependsOn);
-    trackChildDerived(id, dependsOn);
-    dropPoseKeyedMemoSlots(requireNode(id));
-    invalidateDependents(id);
-  }
-  for (let i = 0; i < options.systemLayers.length; i++) {
-    const spec = options.systemLayers[i];
-    if (state.layerIndex.has(spec.id)) {
-      throw new Error(`useScene: duplicate system layer id "${spec.id}"`);
-    }
-    state.layers.push({
-      kind: "system",
-      id: spec.id,
-      visible: spec.visible ?? true,
-      locked: spec.locked ?? false
-    });
-    state.layerIndex.set(spec.id, i);
-  }
-  const generateId = options.generateId ?? defaultGenerateId;
-  const listeners = /* @__PURE__ */ new Set();
-  const registered = /* @__PURE__ */ new Map();
-  let historyAdapterAccessor = null;
-  function bindOpToHistoryAdapter(op) {
-    return {
-      name: op.name,
-      args: op.args,
-      label: op.label,
-      coalesceKey: op.coalesceKey,
-      apply: () => {
-        const get = historyAdapterAccessor;
-        if (!get) {
-          dwarn("scene", `restored op "${op.name ?? "?"}" has no history adapter \u2014 skipping (setHistoryAdapter was not wired)`);
-          return "noop";
-        }
-        try {
-          return op.apply(get());
-        } catch (err) {
-          dwarn("scene", `restored op "${op.name ?? "?"}" failed against the history adapter \u2014 skipping: ${String(err)}`);
-          return "noop";
+    },
+    // Node-mutation surface used by kit InsertOps / DeleteOps (e.g.
+    // useNest wrapping the selection in a new container node, or its
+    // inverse). Re-adds via the full structural spec so the round-trip
+    // survives undo/redo; removes by id.
+    insertNode(node, index) {
+      scene.add({
+        kind: node.kind,
+        layer: node.layer,
+        pose: node.pose,
+        data: node.data,
+        id: node.id,
+        ...index !== void 0 ? { index } : {},
+        ...node.parent !== null ? { parent: node.parent } : {},
+        // Derivation travels with the node, or undo of a delete brings an
+        // edge back as a static path that never follows its endpoints again.
+        ...node.dependsOn !== void 0 ? { dependsOn: node.dependsOn } : {},
+        ...fnFieldsOfNode(node)
+      });
+    },
+    removeNode(id) {
+      scene.remove(asNodeId(id));
+    },
+    setData(id, data) {
+      scene.update(asNodeId(id), { data });
+    },
+    getRemovalClosure(ids) {
+      return [...scene.removalClosure(ids.map(asNodeId))];
+    },
+    // AreaSelectAdapter surface — included unconditionally so plain
+    // `useSelectTool(sceneToAdapter(scene, { selection }))` Just Works for the
+    // marquee gesture. `applyOps` (above) dispatches transiently when called
+    // without a label, matching the AreaSelectAdapter contract; `hitTestArea`
+    // does an AABB-vs-AABB scan over `scene.renderOrder()`, reading bounds
+    // through the pose descriptor.
+    getSelection,
+    setSelection,
+    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);
+    },
+    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);
+    },
+    // commitInsert (gesture-time leaf insert) is opt-in: present only when
+    // `options.commitInsert` is. The full insertNode/removeNode mutators
+    // above are always present so kit-side InsertOp / DeleteOp round-trip
+    // through scene.add / scene.remove regardless.
+    //
+    // Contract: this is a pure factory — it constructs a Node spec but does
+    // NOT touch the scene. `useInsert`'s onEnd dispatches an `InsertOp`
+    // whose apply() calls `adapter.insertNode` → `scene.add`, which is the
+    // sole insertion path. Calling `scene.add` here too would double-insert,
+    // and the second add throws on id collision (silently dropping the
+    // gesture's pointer-up cleanup and breaking the next drag).
+    ...options.commitInsert ? {
+      commitInsert: (bounds) => {
+        const created = options.commitInsert(bounds);
+        if (!created) return null;
+        const layer = options.insertLayer ?? "default";
+        const id = asNodeId(created.id ?? adapterFallbackId());
+        return {
+          kind: "leaf",
+          id,
+          layer,
+          pose: created.pose,
+          data: created.data,
+          parent: null
+        };
+      }
+    } : {},
+    // Clipboard seam (`useClipboardOps` / the paste ingestion path).
+    //
+    // `snapshotSelection` captures adapter-shaped node copies; `commitPaste`
+    // is a pure factory like `commitInsert` above — it mints fresh nodes but
+    // NEVER touches the scene. Insertion happens via the hook's InsertOps
+    // (one per created node, parents before children), which is what makes a
+    // whole paste a single undo entry.
+    snapshotSelection(ids) {
+      const idSet = new Set(ids);
+      const taken = /* @__PURE__ */ new Set();
+      const items = [];
+      const poseFor = (n, isRoot) => {
+        if (!composes) return n.pose;
+        if (isRoot) return adapter.getWorldPose(n.id);
+        const frame = frameAtOrAbove(adapter, n.parent);
+        return frame !== null && taken.has(frame) ? n.pose : adapter.getWorldPose(n.id);
+      };
+      const derivation = (n) => n.dependsOn === "children" && n.derivePose ? { dependsOn: n.dependsOn, derivePose: n.derivePose } : {};
+      const capture = (id, isRoot = false) => {
+        if (taken.has(id)) return;
+        const n = scene.get(asNodeId(id));
+        if (!n) return;
+        taken.add(id);
+        if (n.kind === "container") {
+          items.push({
+            kind: "container",
+            id: n.id,
+            layer: n.layer,
+            parent: n.parent,
+            pose: copyField(poseFor(n, isRoot)),
+            data: copyField(n.data),
+            children: [...n.children],
+            ...n.clipFromPose ? { clipFromPose: n.clipFromPose } : {},
+            ...derivation(n)
+          });
+          for (const cid of scene.childrenOf(asNodeId(id))) capture(cid);
+        } else {
+          items.push({
+            kind: "leaf",
+            id: n.id,
+            layer: n.layer,
+            parent: n.parent,
+            pose: copyField(poseFor(n, isRoot)),
+            data: copyField(n.data)
+          });
         }
-      },
-      invert: () => bindOpToHistoryAdapter(op.invert())
-    };
-  }
-  let selection = [];
-  const overrides = createPoseOverrides(
-    (id) => state.nodes.get(id),
-    invalidateDependents
-  );
-  const history = createHistory(void 0, {
-    selection: {
-      get: () => selection,
-      set: (ids) => {
-        selection = reachable(ids);
-        notify2();
+      };
+      for (const id of ids) {
+        if (scene.ancestorsOf(asNodeId(id)).some((a) => idSet.has(a))) continue;
+        capture(id, true);
       }
+      return { items };
     },
-    ...options.coalesceWindowMs !== void 0 ? { coalesceWindowMs: options.coalesceWindowMs } : {},
-    ...options.historyLimit !== void 0 ? { historyLimit: options.historyLimit } : {},
-    onEvict: (entry) => {
-      pruneCacheForDroppedOps(entry.forwardOps);
-      pruneCacheForDroppedOps(entry.baseOps);
+    commitPaste(clipboard, offset, ctx) {
+      const src = clipboard.items;
+      if (src.length === 0) return [];
+      const idMap = /* @__PURE__ */ new Map();
+      for (const item of src) idMap.set(item.id, asNodeId(pasteNodeId()));
+      const isRoot = (item) => item.parent === null || !idMap.has(item.parent);
+      const byId = new Map(src.map((item) => [item.id, item]));
+      const ridesPastedFrame = (item) => {
+        if (!composes) return false;
+        let p = item.parent === null ? void 0 : byId.get(item.parent);
+        while (p !== void 0) {
+          if (definesFrame(p)) return true;
+          p = p.parent === null ? void 0 : byId.get(p.parent);
+        }
+        return false;
+      };
+      let dx = offset.dx;
+      let dy = offset.dy;
+      if (ctx?.dropPoint) {
+        let minX = Infinity;
+        let minY = Infinity;
+        for (const item of src) {
+          if (!isRoot(item)) continue;
+          const b = poseBounds(item.pose);
+          if (b.x < minX) minX = b.x;
+          if (b.y < minY) minY = b.y;
+        }
+        if (Number.isFinite(minX) && Number.isFinite(minY)) {
+          dx = ctx.dropPoint.worldX - minX;
+          dy = ctx.dropPoint.worldY - minY;
+        }
+      }
+      const out = [];
+      for (const item of src) {
+        const base = {
+          id: idMap.get(item.id),
+          layer: item.layer,
+          parent: isRoot(item) ? null : idMap.get(item.parent),
+          pose: ridesPastedFrame(item) ? copyField(item.pose) : translate3(copyField(item.pose), dx, dy),
+          data: copyField(item.data)
+        };
+        if (item.kind === "container") {
+          out.push({
+            ...base,
+            kind: "container",
+            children: item.children.filter((c) => idMap.has(c)).map((c) => idMap.get(c)),
+            ...item.clipFromPose ? { clipFromPose: item.clipFromPose } : {},
+            ...item.dependsOn === "children" && item.derivePose ? { dependsOn: item.dependsOn, derivePose: item.derivePose } : {}
+          });
+        } else {
+          out.push({ ...base, kind: "leaf" });
+        }
+      }
+      return out;
     },
-    // Restore-time rebuild: scene-registered kinds (kit:* + consumer
-    // registerOp) rebuild via makeOp; external ops rebuild via the global
-    // op-factory registry, wrapped in the lazy history-adapter binding.
-    // Return null only when the global registry also misses — the engine
-    // then places its no-op placeholder. (The engine's own global-registry
-    // fallback never fires for scene histories: this hook already
-    // consulted it.)
-    rebuildOp: (name, args) => {
-      if (registered.has(name)) return makeOp(name, args);
-      const rebuilt = rebuildOp(name, args);
-      return rebuilt === null ? null : bindOpToHistoryAdapter(rebuilt);
-    }
-  });
-  let version = 0;
-  let batchDepth = 0;
-  let currentBatch = null;
-  let suppressRecording = false;
-  let untrackedDepth = 0;
-  let lockBypass = 0;
-  let appliedLog = null;
-  let batchDirty = false;
-  let activeJournalAccessor = options.getActiveJournal ?? null;
-  function isLockedInternal(id) {
-    if (!state.layers.some((l) => l.locked)) return false;
-    let cur = state.nodes.get(id);
-    while (cur !== void 0) {
-      if (state.layers[state.layerIndex.get(cur.layer) ?? -1]?.locked) return true;
-      cur = cur.parent === null ? void 0 : state.nodes.get(cur.parent);
+    // Constant cascade: the hook re-snapshots the just-created items, so
+    // repeated pastes stack +12/+12 each time.
+    getPasteOffset() {
+      return { dx: 12, dy: 12 };
     }
-    return false;
-  }
+  };
+  return adapter;
+}
+function useSceneAdapter(scene, options = {}) {
+  const {
+    selection,
+    commitInsert,
+    insertLayer,
+    layouts,
+    poseDescriptor,
+    cascadeContainerPose,
+    poseComposition
+  } = options;
+  return useMemo(
+    () => sceneToAdapter(scene, {
+      selection,
+      commitInsert,
+      insertLayer,
+      layouts,
+      poseDescriptor,
+      cascadeContainerPose,
+      poseComposition
+    }),
+    [scene, selection, commitInsert, insertLayer, layouts, poseDescriptor, cascadeContainerPose, poseComposition]
+  );
+}
+
+// src/core/scene/poseOverrides.ts
+function createPoseOverrides(getNode, onInvalidate) {
+  const entries = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  let generation2 = 0;
+  function invalidate(id) {
+    const node = getNode(id);
+    if (node) dropPoseKeyedMemoSlots(node);
+    onInvalidate?.(id);
+  }
+  function published() {
+    generation2++;
+    for (const listener of listeners) listener();
+  }
+  return {
+    set(id, entry) {
+      entries.set(id, entry);
+      invalidate(id);
+      published();
+    },
+    get(id) {
+      return entries.get(id);
+    },
+    has(id) {
+      return entries.has(id);
+    },
+    ids() {
+      return [...entries.keys()];
+    },
+    clear(id) {
+      if (!entries.delete(id)) return;
+      invalidate(id);
+      published();
+    },
+    clearAll() {
+      if (entries.size === 0) return;
+      for (const id of entries.keys()) invalidate(id);
+      entries.clear();
+      published();
+    },
+    commit() {
+      for (const id of entries.keys()) invalidate(id);
+      published();
+    },
+    subscribe(fn) {
+      listeners.add(fn);
+      return () => {
+        listeners.delete(fn);
+      };
+    },
+    getGeneration() {
+      return generation2;
+    }
+  };
+}
+
+// src/core/scene/scene.ts
+var defaultIdCounter = 0;
+var defaultGenerateId = () => asNodeId(`n${(defaultIdCounter++).toString(36)}-${Math.random().toString(36).slice(2, 8)}`);
+function layerFromSerialized(spec) {
+  const base = {
+    id: spec.id,
+    visible: spec.visible ?? true,
+    locked: spec.locked ?? false
+  };
+  return spec.kind === "user" ? { ...base, kind: "user", name: spec.name ?? spec.id } : { ...base, kind: "system" };
+}
+function createScene(options) {
+  if (!options.systemLayers || options.systemLayers.length === 0) {
+    throw new Error("useScene: systemLayers must declare at least one layer");
+  }
+  const state = {
+    nodes: /* @__PURE__ */ new Map(),
+    roots: [],
+    layers: [],
+    layerIndex: /* @__PURE__ */ new Map()
+  };
+  const registry2 = withKitRegistry(options.registry ?? {});
+  const fnFields = createNodeFnFields(registry2);
+  const fnField = (name) => fnFields.find((f) => f.spec.field === name);
+  const dependents = createDependentsIndex();
+  const childDerived = /* @__PURE__ */ new Set();
+  function invalidateDependents(id) {
+    invalidateChildDerivedFrom(state.nodes.get(id)?.parent ?? null);
+    if (dependents.isEmpty()) return;
+    const subtree = [id];
+    descendants(id, subtree);
+    for (const src of subtree) {
+      for (const dep of dependents.transitiveDependentsOf(src)) {
+        const node = state.nodes.get(dep);
+        if (node !== void 0) dropPoseKeyedMemoSlots(node);
+      }
+    }
+  }
+  function invalidateChildDerivedFrom(start) {
+    if (childDerived.size === 0) return;
+    let cursor = start;
+    while (cursor !== null) {
+      const node = state.nodes.get(cursor);
+      if (node === void 0) return;
+      if (childDerived.has(cursor)) {
+        dropPoseKeyedMemoSlots(node);
+        for (const dep of dependents.transitiveDependentsOf(cursor)) {
+          const d = state.nodes.get(dep);
+          if (d !== void 0) dropPoseKeyedMemoSlots(d);
+        }
+      }
+      cursor = node.parent;
+    }
+  }
+  function trackChildDerived(id, dependsOn) {
+    if (dependsOn === "children") childDerived.add(id);
+    else childDerived.delete(id);
+  }
+  function retarget(id, dependsOn) {
+    const node = requireNode(id);
+    if (dependsOn === void 0) delete node.dependsOn;
+    else node.dependsOn = dependsOn;
+    dependents.add(id, dependsOn === void 0 || dependsOn === "children" ? [] : dependsOn);
+    trackChildDerived(id, dependsOn);
+    dropPoseKeyedMemoSlots(requireNode(id));
+    invalidateDependents(id);
+  }
+  for (let i = 0; i < options.systemLayers.length; i++) {
+    const spec = options.systemLayers[i];
+    if (state.layerIndex.has(spec.id)) {
+      throw new Error(`useScene: duplicate system layer id "${spec.id}"`);
+    }
+    state.layers.push({
+      kind: "system",
+      id: spec.id,
+      visible: spec.visible ?? true,
+      locked: spec.locked ?? false
+    });
+    state.layerIndex.set(spec.id, i);
+  }
+  const generateId = options.generateId ?? defaultGenerateId;
+  const listeners = /* @__PURE__ */ new Set();
+  const registered = /* @__PURE__ */ new Map();
+  let historyAdapterAccessor = null;
+  function bindOpToHistoryAdapter(op) {
+    return {
+      name: op.name,
+      args: op.args,
+      label: op.label,
+      coalesceKey: op.coalesceKey,
+      apply: () => {
+        const get = historyAdapterAccessor;
+        if (!get) {
+          dwarn("scene", `restored op "${op.name ?? "?"}" has no history adapter \u2014 skipping (setHistoryAdapter was not wired)`);
+          return "noop";
+        }
+        try {
+          return op.apply(get());
+        } catch (err) {
+          dwarn("scene", `restored op "${op.name ?? "?"}" failed against the history adapter \u2014 skipping: ${String(err)}`);
+          return "noop";
+        }
+      },
+      invert: () => bindOpToHistoryAdapter(op.invert())
+    };
+  }
+  let selection = [];
+  const overrides = createPoseOverrides(
+    (id) => state.nodes.get(id),
+    invalidateDependents
+  );
+  const history = createHistory(void 0, {
+    selection: {
+      get: () => selection,
+      set: (ids) => {
+        selection = reachable(ids);
+        notify2();
+      }
+    },
+    ...options.coalesceWindowMs !== void 0 ? { coalesceWindowMs: options.coalesceWindowMs } : {},
+    ...options.historyLimit !== void 0 ? { historyLimit: options.historyLimit } : {},
+    onEvict: (entry) => {
+      pruneCacheForDroppedOps(entry.forwardOps);
+      pruneCacheForDroppedOps(entry.baseOps);
+    },
+    // Restore-time rebuild: scene-registered kinds (kit:* + consumer
+    // registerOp) rebuild via makeOp; external ops rebuild via the global
+    // op-factory registry, wrapped in the lazy history-adapter binding.
+    // Return null only when the global registry also misses — the engine
+    // then places its no-op placeholder. (The engine's own global-registry
+    // fallback never fires for scene histories: this hook already
+    // consulted it.)
+    rebuildOp: (name, args) => {
+      if (registered.has(name)) return makeOp(name, args);
+      const rebuilt = rebuildOp(name, args);
+      return rebuilt === null ? null : bindOpToHistoryAdapter(rebuilt);
+    }
+  });
+  let version = 0;
+  let batchDepth = 0;
+  let currentBatch = null;
+  let suppressRecording = false;
+  let untrackedDepth = 0;
+  let lockBypass = 0;
+  let appliedLog = null;
+  let batchDirty = false;
+  let activeJournalAccessor = options.getActiveJournal ?? null;
+  function isLockedInternal(id) {
+    if (!state.layers.some((l) => l.locked)) return false;
+    let cur = state.nodes.get(id);
+    while (cur !== void 0) {
+      if (state.layers[state.layerIndex.get(cur.layer) ?? -1]?.locked) return true;
+      cur = cur.parent === null ? void 0 : state.nodes.get(cur.parent);
+    }
+    return false;
+  }
   function refuseUntracked(verb) {
     if (untrackedDepth > 0) throw new Error(`Scene: cannot ${verb} inside untracked() \u2014 it records`);
   }
@@ -21899,7 +23081,7 @@ function CanvasView(props) {
   const viewSelection = selectionProp ?? (selectionOptions ? ownSelection : void 0);
   const [internalView, setInternalView] = useState(() => normalizeView(defaultView ?? IDENTITY_VIEW2));
   const effectiveView = viewProp ?? internalView;
-  const live = useRef({
+  const live2 = useRef({
     view: effectiveView,
     bounds,
     layers,
@@ -21913,8 +23095,8 @@ function CanvasView(props) {
     // surface's otherwise. Filled in below, once the surface's is in hand.
     selection: viewSelection ?? ownSelection
   });
-  live.current = {
-    ...live.current,
+  live2.current = {
+    ...live2.current,
     view: effectiveView,
     bounds,
     layers,
@@ -21926,7 +23108,7 @@ function CanvasView(props) {
     viewSelection
   };
   const rectAt = useCallback((outer, dims) => {
-    const b = live.current.bounds;
+    const b = live2.current.bounds;
     return typeof b === "function" ? b(outer, dims) : b;
   }, []);
   const rectNow = useCallback(() => {
@@ -21934,18 +23116,18 @@ function CanvasView(props) {
     return rectAt(surface?.view() ?? IDENTITY_VIEW2, surface?.dims() ?? UNMEASURED_DIMS);
   }, [registry2, rectAt]);
   const cameraAt = useCallback((outer, dims) => {
-    const v = live.current.view;
+    const v = live2.current.view;
     return normalizeView(typeof v === "function" ? v(outer, dims) : v);
   }, []);
   const camera = useCallback(() => {
     const surface = registry2?.surface();
     return cameraAt(surface?.view() ?? IDENTITY_VIEW2, surface?.dims() ?? UNMEASURED_DIMS);
   }, [registry2, cameraAt]);
-  const drawnLayers = useCallback(() => paintedLayers(registry2?.surface()?.layers() ?? [], live.current), [registry2]);
+  const drawnLayers = useCallback(() => paintedLayers(registry2?.surface()?.layers() ?? [], live2.current), [registry2]);
   const [sceneLayerGate] = useState(createSceneLayerGate);
-  const layerIsPainted = useCallback((layerId) => sceneLayerGate(registry2?.surface()?.layers() ?? [], live.current)(layerId), [registry2, sceneLayerGate]);
+  const layerIsPainted = useCallback((layerId) => sceneLayerGate(registry2?.surface()?.layers() ?? [], live2.current)(layerId), [registry2, sceneLayerGate]);
   const setView = useCallback((next) => {
-    const { viewBounds: vb, onViewChange: cb, viewProp: controlled } = live.current;
+    const { viewBounds: vb, onViewChange: cb, viewProp: controlled } = live2.current;
     const rect = rectNow();
     const valid = normalizeView(next);
     const clamped = vb ? clampView(valid, vb, { width: rect.w, height: rect.h }) : valid;
@@ -21988,11 +23170,11 @@ function CanvasView(props) {
     ...createDispatcherPreviewSources(() => dispatcherRef.current)
   }), []);
   const selection = viewSelection ?? inputs?.selectionApi ?? ownSelection;
-  live.current.selection = selection;
+  live2.current.selection = selection;
   const inputsRef = useRef(inputs);
   inputsRef.current = inputs;
   const ruleInputs = useCallback(() => ({
-    selection: live.current.selection.get(),
+    selection: live2.current.selection.get(),
     view: camera(),
     action: dispatcherRef.current.getActiveAction()
   }), [camera]);
@@ -22036,550 +23218,166 @@ function CanvasView(props) {
         helpersRef.current,
         drawnLayers()
       );
-      if (extra) {
-        const claim = extra.hit;
-        return {
-          kind: `layer:${extra.layerId}`,
-          owner: extra.layerId,
-          strength: claim.strength ?? "shared",
-          ...claim.claimedKinds !== void 0 ? { claimedKinds: claim.claimedKinds } : {},
-          ...claim.cursor !== void 0 ? { cursor: claim.cursor } : {},
-          ...claim.initialScratch !== void 0 ? { payload: claim.initialScratch } : {}
-        };
-      }
-      return inner(world);
-    };
-  }, [getAnchorState, rectNow, registry2, targetScale, camera, drawnLayers]);
-  const classifyTarget = useMemo(() => {
-    const inner = buildClassifyTarget(
-      () => live.current.selection.get(),
-      (wx, wy) => {
-        const i = inputsRef.current;
-        const frame = { ...camera(), layerIsPainted };
-        if (i?.pickBest) return i.pickBest(wx, wy, frame);
-        const ids = i?.pickEvery?.(wx, wy, frame) ?? [];
-        return ids.length > 0 ? ids[ids.length - 1] : null;
-      },
-      (id2) => inputsRef.current?.kindOfNode?.(id2)
-    );
-    return (world) => inner(world);
-  }, [camera, layerIsPainted]);
-  const registration = useMemo(() => ({
-    id,
-    order,
-    interactive,
-    paint,
-    layer: createViewportLayer({
-      id,
-      label: label ?? id,
-      source: drawnLayers,
-      view: cameraAt,
-      bounds: (outer, dims) => rectAt(outer, dims),
-      // The surface half of the envelope passes through; the view half is
-      // this view's, so its layers paint its chrome rather than the
-      // surface's.
-      data: (outer) => ({ ...outer, ...helpersRef.current }),
-      ...background !== void 0 ? { background } : {}
-    }),
-    layerIsPainted,
-    target: {
-      dispatcher: dispatcherRef.current,
-      affordanceAt,
-      classifyTarget,
-      clientToWorld: clientToWorldHere,
-      deps: () => ({
-        view: viewApi,
-        ingestion: ingestionApi,
-        // An Escape here cancels what is in flight here.
-        dispatcher: { cancelAll: (reason) => dispatcherRef.current.cancelAll(reason) },
-        // Only a view with its own selection overlays that one; otherwise the
-        // surface's answer stands, wrappers (`selectionMode`) included.
-        ...live.current.viewSelection ? { selection: live.current.viewSelection } : {}
-      }),
-      // Action eligibility is chrome-caps evaluated against this view, so a
-      // rule that hides an action in one panel cannot decline a gesture in
-      // another.
-      getRuleCtx: () => inputsRef.current?.chromeCaps?.ruleCtx(ruleInputs())
-    }
-  }), [
-    id,
-    order,
-    interactive,
-    paint,
-    label,
-    background,
-    rectAt,
-    cameraAt,
-    viewApi,
-    affordanceAt,
-    classifyTarget,
-    clientToWorldHere,
-    ruleInputs,
-    ingestionApi,
-    drawnLayers,
-    layerIsPainted
-  ]);
-  useEffect(() => {
-    if (!registry2) return;
-    return registry2.register(registration);
-  }, [registry2, registration]);
-  useEffect(() => {
-    registry2?.surface()?.requestRedraw();
-  }, [registry2, effectiveView]);
-  return null;
-}
-function ActionsProviderIfRoot({ children }) {
-  const parent = useActionsRegistry();
-  if (parent) return /* @__PURE__ */ jsx(ActionsScope, { children });
-  return /* @__PURE__ */ jsx(ActionsProvider, { children });
-}
-function useToolActions(tools) {
-  const registry2 = useActionsRegistry();
-  useEffect(() => {
-    if (!registry2) return;
-    const unregisters = [];
-    for (const tool of [...Object.values(tools.registry), ...tools.ambient]) {
-      for (const action of tool.actions ?? []) {
-        unregisters.push(registry2.register(action));
-      }
-    }
-    return () => {
-      for (const u of unregisters) u();
-    };
-  }, [registry2, tools.registry, tools.ambient]);
-}
-function PointerProviderIfRoot({ children }) {
-  const parent = usePointerContext();
-  if (parent) return /* @__PURE__ */ jsx(Fragment, { children });
-  return /* @__PURE__ */ jsx(PointerContextProvider, { children });
-}
-function PointerPublisher({
-  canvasRef
-}) {
-  const ctx = usePointerContext();
-  const registry2 = useOptionalViewRegistry();
-  useEffect(() => {
-    if (!ctx) return;
-    const el = canvasRef.current;
-    if (!el) return;
-    const publish = (pointerId, clientX, clientY) => {
-      const target = registry2?.resolver.at(pointerId, clientX, clientY);
-      const rect = el.getBoundingClientRect();
-      const [worldX, worldY] = clientToWorld(
-        clientX,
-        clientY,
-        target?.origin ?? rect,
-        target?.view ?? { x: 0, y: 0, scale: { x: 1, y: 1 } }
-      );
-      ctx.pointerRef.current = { worldX, worldY };
-    };
-    const onMove = (e) => publish(e.pointerId, e.clientX, e.clientY);
-    const onLeave = (e) => {
-      if (e.buttons !== 0) {
-        publish(e.pointerId, e.clientX, e.clientY);
-        return;
-      }
-      ctx.pointerRef.current = null;
-    };
-    const onDocMove = (e) => {
-      if (e.target === el) return;
-      if (e.buttons === 0) return;
-      publish(e.pointerId, e.clientX, e.clientY);
-    };
-    el.addEventListener("pointermove", onMove);
-    el.addEventListener("pointerleave", onLeave);
-    document.addEventListener("pointermove", onDocMove);
-    return () => {
-      el.removeEventListener("pointermove", onMove);
-      el.removeEventListener("pointerleave", onLeave);
-      document.removeEventListener("pointermove", onDocMove);
-    };
-  }, [ctx, canvasRef, registry2]);
-  return null;
-}
-function flattenVerts2(poly2) {
-  const flat = new Array(poly2.length * 2);
-  for (let i = 0; i < poly2.length; i++) {
-    flat[i * 2] = poly2[i].x;
-    flat[i * 2 + 1] = poly2[i].y;
-  }
-  return flat;
-}
-function polygonContainsRectCenter(poly2, rect) {
-  return pointInPolygon(flattenVerts2(poly2), rect.x + rect.width / 2, rect.y + rect.height / 2);
-}
-function polygonContainsRect(poly2, rect) {
-  if (poly2.length < 3) return false;
-  const flat = flattenVerts2(poly2);
-  if (!pointInPolygon(flat, rect.x, rect.y)) return false;
-  if (!pointInPolygon(flat, rect.x + rect.width, rect.y)) return false;
-  if (!pointInPolygon(flat, rect.x + rect.width, rect.y + rect.height)) return false;
-  if (!pointInPolygon(flat, rect.x, rect.y + rect.height)) return false;
-  return !anyPolyEdgeCrossesRect(poly2, rect);
-}
-function polygonIntersectsRect(poly2, rect) {
-  if (poly2.length < 3) return false;
-  const ab = polygonAabb(poly2);
-  if (ab.x + ab.width < rect.x || ab.x > rect.x + rect.width) return false;
-  if (ab.y + ab.height < rect.y || ab.y > rect.y + rect.height) return false;
-  for (const v of poly2) {
-    if (v.x >= rect.x && v.x <= rect.x + rect.width && v.y >= rect.y && v.y <= rect.y + rect.height) return true;
-  }
-  const flat = flattenVerts2(poly2);
-  if (pointInPolygon(flat, rect.x, rect.y)) return true;
-  if (pointInPolygon(flat, rect.x + rect.width, rect.y)) return true;
-  if (pointInPolygon(flat, rect.x + rect.width, rect.y + rect.height)) return true;
-  if (pointInPolygon(flat, rect.x, rect.y + rect.height)) return true;
-  return anyPolyEdgeCrossesRect(poly2, rect);
-}
-function polygonAabb(poly2) {
-  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
-  for (const v of poly2) {
-    if (v.x < minX) minX = v.x;
-    if (v.y < minY) minY = v.y;
-    if (v.x > maxX) maxX = v.x;
-    if (v.y > maxY) maxY = v.y;
-  }
-  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
-}
-function anyPolyEdgeCrossesRect(poly2, rect) {
-  const r0x = rect.x, r0y = rect.y;
-  const r1x = rect.x + rect.width, r1y = rect.y;
-  const r2x = rect.x + rect.width, r2y = rect.y + rect.height;
-  const r3x = rect.x, r3y = rect.y + rect.height;
-  for (let i = 0, j = poly2.length - 1; i < poly2.length; j = i++) {
-    const a = poly2[j], b = poly2[i];
-    if (segmentsCross(a.x, a.y, b.x, b.y, r0x, r0y, r1x, r1y)) return true;
-    if (segmentsCross(a.x, a.y, b.x, b.y, r1x, r1y, r2x, r2y)) return true;
-    if (segmentsCross(a.x, a.y, b.x, b.y, r2x, r2y, r3x, r3y)) return true;
-    if (segmentsCross(a.x, a.y, b.x, b.y, r3x, r3y, r0x, r0y)) return true;
-  }
-  return false;
-}
-
-// 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)}`;
-}
-var pasteIdCounter = 0;
-function pasteNodeId() {
-  return `paste-${(pasteIdCounter++).toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-}
-function copyField(value) {
-  if (Array.isArray(value)) return [...value];
-  if (value !== null && typeof value === "object") return { ...value };
-  return value;
-}
-function sceneToAdapter(scene, options = {}) {
-  const visibleLayers = () => {
-    const out = /* @__PURE__ */ new Set();
-    for (const layer of scene.layers) {
-      if (layer.visible) out.add(layer.id);
-    }
-    return out;
-  };
-  const sel = options.selection;
-  const getSelection = sel?.getSelection ?? sel?.get ?? (() => []);
-  const setSelection = sel?.setSelection ?? sel?.set ?? (() => {
-  });
-  const d = options.poseDescriptor ?? AUTO_POSE_DESCRIPTOR;
-  const poseBounds = (p) => visualBoundsViaDescriptor(p, d);
-  const translate3 = (p, dx, dy, node) => translatePoseViaDescriptor(
-    p,
-    dx,
-    dy,
-    node === void 0 ? d : poseDescriptorForNode(d, node)
-  );
-  const composition = options.poseComposition;
-  const composes = composition !== void 0 && composition.closure !== "identity";
-  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."
-    );
-  }
-  const adapter = {
-    getNode(id) {
-      return scene.get(asNodeId(id));
-    },
-    getNodes() {
-      const visible = visibleLayers();
-      const out = [];
-      for (const n of scene.renderOrderNodes()) {
-        if (visible.has(n.layer)) out.push(n);
-      }
-      return out;
-    },
-    getPose(id) {
-      const nid = asNodeId(id);
-      const n = scene.get(nid);
-      if (!n) throw new Error(`sceneToAdapter: unknown node "${id}"`);
-      return effectivePose(scene, n);
-    },
-    getParent(id) {
-      const n = scene.get(asNodeId(id));
-      return n?.parent ?? null;
-    },
-    getWorldPose(id) {
-      if (!composes) return adapter.getPose(id);
-      return composeWorldPose(adapter, id, composition.compose);
-    },
-    // Only present when it would do something: the render walk skips the fold
-    // entirely when this is absent, which is the absolute-pose path.
-    ...composes ? { composePose: composition.compose } : {},
-    setPose(id, pose) {
-      if (options.cascadeContainerPose) {
-        const node = scene.get(asNodeId(id));
-        if (node && node.kind === "container") {
-          const g = poseDescriptorForNode(d, node);
-          const before = g.getBounds(node.pose);
-          const after = g.getBounds(pose);
-          const dx = after.x - before.x;
-          const dy = after.y - before.y;
-          if (dx !== 0 || dy !== 0) {
-            const descIds = [];
-            const collect = (rootId) => {
-              for (const cid of scene.childrenOf(asNodeId(rootId))) {
-                descIds.push(cid);
-                collect(cid);
-              }
-            };
-            collect(id);
-            scene.batch("setPose", () => {
-              scene.setPose(asNodeId(id), pose);
-              for (const cid of descIds) {
-                const cn = scene.get(asNodeId(cid));
-                if (!cn) continue;
-                scene.setPose(asNodeId(cid), translate3(cn.pose, dx, dy, cn));
-              }
-            });
-            return;
-          }
-        }
-      }
-      scene.setPose(asNodeId(id), pose);
-    },
-    setParent(id, parentId) {
-      scene.move(asNodeId(id), parentId === null ? null : asNodeId(parentId));
-    },
-    getChildren(id) {
-      if (id === null) return [...scene.roots];
-      return [...scene.childrenOf(asNodeId(id))];
-    },
-    setChildOrder(parentId, ids) {
-      scene.batch("Reorder", () => {
-        for (let i = 0; i < ids.length; i++) {
-          const current = parentId === null ? scene.roots : scene.childrenOf(asNodeId(parentId));
-          if (current[i] === ids[i]) continue;
-          scene.reorder(asNodeId(ids[i]), i);
-        }
-      });
-    },
-    getLayers() {
-      return scene.layers.map((l) => ({ id: l.id, visible: l.visible }));
-    },
-    ...options.layouts ? {
-      getLayout: typeof options.layouts === "function" ? options.layouts : (id) => options.layouts[id] ?? null
-    } : {},
-    // Unified applyOps: when a label is supplied the ops are wrapped in a
-    // batch checkpoint (history-aware path used by Move/Resize/Rotate/Insert/
-    // Delete tools). When a journal is active (via scene's getActiveJournal
-    // option), scene.applyBatch routes to the journal instead of recording a
-    // new parent-history entry. Without a label the ops are applied transiently
-    // via applyOpsTo (AreaSelectAdapter contract — no checkpoint).
-    applyOps(ops, label) {
-      if (label !== void 0) {
-        scene.applyBatch(ops, label, this);
-      } else {
-        applyOpsTo(this, ops);
-      }
-    },
-    // Node-mutation surface used by kit InsertOps / DeleteOps (e.g.
-    // useNest wrapping the selection in a new container node, or its
-    // inverse). Re-adds via the full structural spec so the round-trip
-    // survives undo/redo; removes by id.
-    insertNode(node, index) {
-      scene.add({
-        kind: node.kind,
-        layer: node.layer,
-        pose: node.pose,
-        data: node.data,
-        id: node.id,
-        ...index !== void 0 ? { index } : {},
-        ...node.parent !== null ? { parent: node.parent } : {},
-        // Derivation travels with the node, or undo of a delete brings an
-        // edge back as a static path that never follows its endpoints again.
-        ...node.dependsOn !== void 0 ? { dependsOn: node.dependsOn } : {},
-        ...fnFieldsOfNode(node)
-      });
-    },
-    removeNode(id) {
-      scene.remove(asNodeId(id));
-    },
-    setData(id, data) {
-      scene.update(asNodeId(id), { data });
-    },
-    getRemovalClosure(ids) {
-      return [...scene.removalClosure(ids.map(asNodeId))];
-    },
-    // AreaSelectAdapter surface — included unconditionally so plain
-    // `useSelectTool(sceneToAdapter(scene, { selection }))` Just Works for the
-    // marquee gesture. `applyOps` (above) dispatches transiently when called
-    // without a label, matching the AreaSelectAdapter contract; `hitTestArea`
-    // does an AABB-vs-AABB scan over `scene.renderOrder()`, reading bounds
-    // through the pose descriptor.
-    getSelection,
-    setSelection,
-    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);
-    },
-    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);
-    },
-    // commitInsert (gesture-time leaf insert) is opt-in: present only when
-    // `options.commitInsert` is. The full insertNode/removeNode mutators
-    // above are always present so kit-side InsertOp / DeleteOp round-trip
-    // through scene.add / scene.remove regardless.
-    //
-    // Contract: this is a pure factory — it constructs a Node spec but does
-    // NOT touch the scene. `useInsert`'s onEnd dispatches an `InsertOp`
-    // whose apply() calls `adapter.insertNode` → `scene.add`, which is the
-    // sole insertion path. Calling `scene.add` here too would double-insert,
-    // and the second add throws on id collision (silently dropping the
-    // gesture's pointer-up cleanup and breaking the next drag).
-    ...options.commitInsert ? {
-      commitInsert: (bounds) => {
-        const created = options.commitInsert(bounds);
-        if (!created) return null;
-        const layer = options.insertLayer ?? "default";
-        const id = asNodeId(created.id ?? adapterFallbackId());
-        return {
-          kind: "leaf",
-          id,
-          layer,
-          pose: created.pose,
-          data: created.data,
-          parent: null
-        };
-      }
-    } : {},
-    // Clipboard seam (`useClipboardOps` / the paste ingestion path).
-    //
-    // `snapshotSelection` captures adapter-shaped node copies; `commitPaste`
-    // is a pure factory like `commitInsert` above — it mints fresh nodes but
-    // NEVER touches the scene. Insertion happens via the hook's InsertOps
-    // (one per created node, parents before children), which is what makes a
-    // whole paste a single undo entry.
-    snapshotSelection(ids) {
-      const idSet = new Set(ids);
-      const taken = /* @__PURE__ */ new Set();
-      const items = [];
-      const poseFor = (n, isRoot) => isRoot && composes ? adapter.getWorldPose(n.id) : n.pose;
-      const capture = (id, isRoot = false) => {
-        if (taken.has(id)) return;
-        const n = scene.get(asNodeId(id));
-        if (!n) return;
-        taken.add(id);
-        if (n.kind === "container") {
-          items.push({
-            kind: "container",
-            id: n.id,
-            layer: n.layer,
-            parent: n.parent,
-            pose: copyField(poseFor(n, isRoot)),
-            data: copyField(n.data),
-            children: [...n.children],
-            ...n.clipFromPose ? { clipFromPose: n.clipFromPose } : {}
-          });
-          for (const cid of scene.childrenOf(asNodeId(id))) capture(cid);
-        } else {
-          items.push({
-            kind: "leaf",
-            id: n.id,
-            layer: n.layer,
-            parent: n.parent,
-            pose: copyField(poseFor(n, isRoot)),
-            data: copyField(n.data)
-          });
-        }
-      };
-      for (const id of ids) {
-        if (scene.ancestorsOf(asNodeId(id)).some((a) => idSet.has(a))) continue;
-        capture(id, true);
-      }
-      return { items };
-    },
-    commitPaste(clipboard, offset, ctx) {
-      const src = clipboard.items;
-      if (src.length === 0) return [];
-      const idMap = /* @__PURE__ */ new Map();
-      for (const item of src) idMap.set(item.id, asNodeId(pasteNodeId()));
-      const isRoot = (item) => item.parent === null || !idMap.has(item.parent);
-      let dx = offset.dx;
-      let dy = offset.dy;
-      if (ctx?.dropPoint) {
-        let minX = Infinity;
-        let minY = Infinity;
-        for (const item of src) {
-          if (!isRoot(item)) continue;
-          const b = poseBounds(item.pose);
-          if (b.x < minX) minX = b.x;
-          if (b.y < minY) minY = b.y;
-        }
-        if (Number.isFinite(minX) && Number.isFinite(minY)) {
-          dx = ctx.dropPoint.worldX - minX;
-          dy = ctx.dropPoint.worldY - minY;
-        }
-      }
-      const out = [];
-      for (const item of src) {
-        const base = {
-          id: idMap.get(item.id),
-          layer: item.layer,
-          parent: isRoot(item) ? null : idMap.get(item.parent),
-          pose: translate3(copyField(item.pose), dx, dy),
-          data: copyField(item.data)
+      if (extra) {
+        const claim = extra.hit;
+        return {
+          kind: `layer:${extra.layerId}`,
+          owner: extra.layerId,
+          strength: claim.strength ?? "shared",
+          ...claim.claimedKinds !== void 0 ? { claimedKinds: claim.claimedKinds } : {},
+          ...claim.cursor !== void 0 ? { cursor: claim.cursor } : {},
+          ...claim.initialScratch !== void 0 ? { payload: claim.initialScratch } : {}
         };
-        if (item.kind === "container") {
-          out.push({
-            ...base,
-            kind: "container",
-            children: item.children.filter((c) => idMap.has(c)).map((c) => idMap.get(c)),
-            ...item.clipFromPose ? { clipFromPose: item.clipFromPose } : {}
-          });
-        } else {
-          out.push({ ...base, kind: "leaf" });
-        }
       }
-      return out;
-    },
-    // Constant cascade: the hook re-snapshots the just-created items, so
-    // repeated pastes stack +12/+12 each time.
-    getPasteOffset() {
-      return { dx: 12, dy: 12 };
+      return inner(world);
+    };
+  }, [getAnchorState, rectNow, registry2, targetScale, camera, drawnLayers]);
+  const classifyTarget = useMemo(() => {
+    const inner = buildClassifyTarget(
+      () => live2.current.selection.get(),
+      (wx, wy) => {
+        const i = inputsRef.current;
+        const frame = { ...camera(), layerIsPainted };
+        if (i?.pickBest) return i.pickBest(wx, wy, frame);
+        const ids = i?.pickEvery?.(wx, wy, frame) ?? [];
+        return ids.length > 0 ? ids[ids.length - 1] : null;
+      },
+      (id2) => inputsRef.current?.kindOfNode?.(id2)
+    );
+    return (world) => inner(world);
+  }, [camera, layerIsPainted]);
+  const registration = useMemo(() => ({
+    id,
+    order,
+    interactive,
+    paint,
+    layer: createViewportLayer({
+      id,
+      label: label ?? id,
+      source: drawnLayers,
+      view: cameraAt,
+      bounds: (outer, dims) => rectAt(outer, dims),
+      // The surface half of the envelope passes through; the view half is
+      // this view's, so its layers paint its chrome rather than the
+      // surface's.
+      data: (outer) => ({ ...outer, ...helpersRef.current }),
+      ...background !== void 0 ? { background } : {}
+    }),
+    layerIsPainted,
+    target: {
+      dispatcher: dispatcherRef.current,
+      affordanceAt,
+      classifyTarget,
+      clientToWorld: clientToWorldHere,
+      deps: () => ({
+        view: viewApi,
+        ingestion: ingestionApi,
+        // An Escape here cancels what is in flight here.
+        dispatcher: { cancelAll: (reason) => dispatcherRef.current.cancelAll(reason) },
+        // Only a view with its own selection overlays that one; otherwise the
+        // surface's answer stands, wrappers (`selectionMode`) included.
+        ...live2.current.viewSelection ? { selection: live2.current.viewSelection } : {}
+      }),
+      // Action eligibility is chrome-caps evaluated against this view, so a
+      // rule that hides an action in one panel cannot decline a gesture in
+      // another.
+      getRuleCtx: () => inputsRef.current?.chromeCaps?.ruleCtx(ruleInputs())
     }
-  };
-  return adapter;
+  }), [
+    id,
+    order,
+    interactive,
+    paint,
+    label,
+    background,
+    rectAt,
+    cameraAt,
+    viewApi,
+    affordanceAt,
+    classifyTarget,
+    clientToWorldHere,
+    ruleInputs,
+    ingestionApi,
+    drawnLayers,
+    layerIsPainted
+  ]);
+  useEffect(() => {
+    if (!registry2) return;
+    return registry2.register(registration);
+  }, [registry2, registration]);
+  useEffect(() => {
+    registry2?.surface()?.requestRedraw();
+  }, [registry2, effectiveView]);
+  return null;
 }
-function useSceneAdapter(scene, options = {}) {
-  const { selection, commitInsert, insertLayer, layouts, poseDescriptor, cascadeContainerPose } = options;
-  return useMemo(
-    () => sceneToAdapter(scene, { selection, commitInsert, insertLayer, layouts, poseDescriptor, cascadeContainerPose }),
-    [scene, selection, commitInsert, insertLayer, layouts, poseDescriptor, cascadeContainerPose]
-  );
+function ActionsProviderIfRoot({ children }) {
+  const parent = useActionsRegistry();
+  if (parent) return /* @__PURE__ */ jsx(ActionsScope, { children });
+  return /* @__PURE__ */ jsx(ActionsProvider, { children });
+}
+function useToolActions(tools) {
+  const registry2 = useActionsRegistry();
+  useEffect(() => {
+    if (!registry2) return;
+    const unregisters = [];
+    for (const tool of [...Object.values(tools.registry), ...tools.ambient]) {
+      for (const action of tool.actions ?? []) {
+        unregisters.push(registry2.register(action));
+      }
+    }
+    return () => {
+      for (const u of unregisters) u();
+    };
+  }, [registry2, tools.registry, tools.ambient]);
+}
+function PointerProviderIfRoot({ children }) {
+  const parent = usePointerContext();
+  if (parent) return /* @__PURE__ */ jsx(Fragment, { children });
+  return /* @__PURE__ */ jsx(PointerContextProvider, { children });
+}
+function PointerPublisher({
+  canvasRef
+}) {
+  const ctx = usePointerContext();
+  const registry2 = useOptionalViewRegistry();
+  useEffect(() => {
+    if (!ctx) return;
+    const el = canvasRef.current;
+    if (!el) return;
+    const publish = (pointerId, clientX, clientY) => {
+      const target = registry2?.resolver.at(pointerId, clientX, clientY);
+      const rect = el.getBoundingClientRect();
+      const [worldX, worldY] = clientToWorld(
+        clientX,
+        clientY,
+        target?.origin ?? rect,
+        target?.view ?? { x: 0, y: 0, scale: { x: 1, y: 1 } }
+      );
+      ctx.pointerRef.current = { worldX, worldY };
+    };
+    const onMove = (e) => publish(e.pointerId, e.clientX, e.clientY);
+    const onLeave = (e) => {
+      if (e.buttons !== 0) {
+        publish(e.pointerId, e.clientX, e.clientY);
+        return;
+      }
+      ctx.pointerRef.current = null;
+    };
+    const onDocMove = (e) => {
+      if (e.target === el) return;
+      if (e.buttons === 0) return;
+      publish(e.pointerId, e.clientX, e.clientY);
+    };
+    el.addEventListener("pointermove", onMove);
+    el.addEventListener("pointerleave", onLeave);
+    document.addEventListener("pointermove", onDocMove);
+    return () => {
+      el.removeEventListener("pointermove", onMove);
+      el.removeEventListener("pointerleave", onLeave);
+      document.removeEventListener("pointermove", onDocMove);
+    };
+  }, [ctx, canvasRef, registry2]);
+  return null;
 }
 function aabbOfPose(pose, descriptor = AUTO_POSE_DESCRIPTOR) {
   return descriptor.getBounds(pose);
@@ -22612,18 +23410,7 @@ function rotationAboutCenter(pose, descriptor) {
 // src/canvas/SceneCanvas/useSceneSelectTool.ts
 var DEFAULT_PICK_TOLERANCE_PX = 4;
 function useSceneSelectTool(args) {
-  const {
-    scene,
-    selection,
-    geometry,
-    selectTool: opts,
-    insertTool,
-    layouts,
-    poseComposition,
-    getView,
-    alphaOf,
-    layerIsPainted
-  } = args;
+  const { scene, adapter, geometry, selectTool: opts, getView, alphaOf, layerIsPainted } = args;
   const d = args.poseDescriptor ?? AUTO_POSE_DESCRIPTOR;
   const pickEveryProp = geometry?.pickEvery;
   const boundsOfProp = geometry?.boundsOf;
@@ -22631,62 +23418,6 @@ function useSceneSelectTool(args) {
   const pickTolerancePx = geometry?.pickTolerancePx ?? DEFAULT_PICK_TOLERANCE_PX;
   const moveOptions = opts?.move;
   const snap2 = opts?.snap;
-  const commitInsert = insertTool?.create;
-  const insertLayer = insertTool?.layer;
-  const adapter = useMemo(() => {
-    const base = sceneToAdapter(scene, {
-      commitInsert,
-      insertLayer,
-      layouts,
-      poseDescriptor: d,
-      ...poseComposition ? { poseComposition } : {}
-    });
-    const framed = poseComposition !== void 0 && poseComposition.closure !== "identity";
-    const collectDescendants = (id, out) => {
-      for (const cid of scene.childrenOf(asNodeId(id))) {
-        out.push(cid);
-        collectDescendants(cid, out);
-      }
-    };
-    return {
-      ...base,
-      setPose(id, pose) {
-        const n = scene.get(asNodeId(id));
-        if (framed || !n || n.kind !== "container") {
-          base.setPose(id, pose);
-          return;
-        }
-        const g = poseDescriptorForNode(d, n);
-        const prev = g.getBounds(n.pose);
-        const next = g.getBounds(pose);
-        const dx = next.x - prev.x;
-        const dy = next.y - prev.y;
-        if (dx === 0 && dy === 0) {
-          base.setPose(id, pose);
-          return;
-        }
-        const desc = [];
-        collectDescendants(id, desc);
-        scene.batch("move container", () => {
-          base.setPose(id, pose);
-          for (const cid of desc) {
-            const cn = scene.get(asNodeId(cid));
-            if (!cn) continue;
-            base.setPose(
-              cid,
-              translatePoseViaDescriptor(cn.pose, dx, dy, poseDescriptorForNode(d, cn))
-            );
-          }
-        });
-      },
-      // Selection methods, widened to `string[]` so the synthesized adapter
-      // satisfies `AreaSelectAdapter` (which keeps the kit-internal adapter
-      // contract on plain `string[]`; the brand lives on the public selection
-      // surface, not on adapter shapes).
-      getSelection: () => [...selection.adapterMethods.getSelection()],
-      setSelection: (ids) => selection.adapterMethods.setSelection(ids)
-    };
-  }, [scene, commitInsert, insertLayer, layouts, selection, d, poseComposition]);
   const wiredMoveOptions = useMemo(() => {
     const merged = { ...moveOptions ?? {} };
     if (snap2) {
@@ -22761,7 +23492,6 @@ function useSceneSelectTool(args) {
     };
   }, [wiredHitBody, adapter]);
   return {
-    adapter,
     selectTool,
     pickEvery: wiredHitBody,
     pickBest: wiredPickBest,
@@ -23218,60 +23948,21 @@ var CLOSE_HINT_RADIUS_PX = 8;
 function w2s(wx, wy, view) {
   return [(wx - view.x) * view.scale.x, (wy - view.y) * view.scale.y];
 }
-function mirror(anchor, out) {
-  if (!out || anchor.altBroken) return void 0;
-  return { x: 2 * anchor.x - out.x, y: 2 * anchor.y - out.y };
-}
 function approximateCircle(cx, cy, r) {
   return circlePath(cx, cy, r);
 }
 function subpathToPath(sp, view) {
   if (sp.anchors.length === 0) return null;
-  const cmds = [];
-  const xs = [];
-  const [sx, sy] = w2s(sp.anchors[0].x, sp.anchors[0].y, view);
-  cmds.push(PATH_M);
-  xs.push(sx, sy);
-  for (let i = 1; i < sp.anchors.length; i++) {
-    const prev = sp.anchors[i - 1];
-    const curr = sp.anchors[i];
-    const out = prev.outHandle;
-    const inH = curr.inHandle ?? mirror(prev, out);
-    const [tx, ty] = w2s(curr.x, curr.y, view);
-    if (out || curr.inHandle) {
-      const c1 = out ?? prev;
-      const c2 = inH ?? curr;
-      const [c1x, c1y] = w2s(c1.x, c1.y, view);
-      const [c2x, c2y] = w2s(c2.x, c2.y, view);
-      cmds.push(PATH_C);
-      xs.push(c1x, c1y, c2x, c2y, tx, ty);
-    } else {
-      cmds.push(PATH_L);
-      xs.push(tx, ty);
-    }
-  }
-  if (sp.closed) {
-    const last = sp.anchors[sp.anchors.length - 1];
-    const first = sp.anchors[0];
-    const out = last.outHandle;
-    const inH = first.inHandle ?? mirror(last, out);
-    if (out || first.inHandle) {
-      const c1 = out ?? last;
-      const c2 = inH ?? first;
-      const [c1x, c1y] = w2s(c1.x, c1.y, view);
-      const [c2x, c2y] = w2s(c2.x, c2.y, view);
-      const [tx, ty] = w2s(first.x, first.y, view);
-      cmds.push(PATH_C);
-      xs.push(c1x, c1y, c2x, c2y, tx, ty);
-    }
-    cmds.push(PATH_Z);
-  }
-  return {
-    kind: "polygon",
-    commands: new Uint8Array(cmds),
-    coords: new Float32Array(xs),
-    fillRule: "nonzero"
+  const pt = (p) => {
+    const [x, y] = w2s(p.x, p.y, view);
+    return { x, y };
   };
+  const anchors = sp.anchors.map((a) => ({
+    ...pt(a),
+    ...a.inHandle ? { inHandle: pt(a.inHandle) } : {},
+    ...a.outHandle ? { outHandle: pt(a.outHandle) } : {}
+  }));
+  return anchorsToPath([anchors], [sp.closed]);
 }
 function createPenPreviewLayer(opts) {
   const style = { ...DEFAULT_STYLE2, ...opts.style ?? {} };
@@ -23360,10 +24051,10 @@ function createPenPreviewLayer(opts) {
               path: approximateCircle(hx, hy, HANDLE_DOT_RADIUS_PX),
               fill: { fill: "solid", color: style.handleStroke }
             });
-            const inSide = mirror(a, a.outHandle);
+            const inSide = a.inHandle;
             if (inSide) {
               const [mx, my] = w2s(inSide.x, inSide.y, view);
-              const mirrorLine = {
+              const inLine = {
                 kind: "polygon",
                 commands: new Uint8Array([PATH_M, PATH_L]),
                 coords: new Float32Array([ax, ay, mx, my]),
@@ -23371,7 +24062,7 @@ function createPenPreviewLayer(opts) {
               };
               out.push({
                 kind: "path",
-                path: mirrorLine,
+                path: inLine,
                 stroke: { paint: { fill: "solid", color: style.handleStroke }, width: 1 }
               });
               out.push({
@@ -23587,7 +24278,7 @@ function useBuiltinShapeTools(args) {
   const { scene, adapter, options } = args;
   const seqRef = useRef(0);
   const freshId = (prefix) => asNodeId(`${prefix}-${++seqRef.current}`);
-  const nextFill = () => DEFAULT_PALETTE[seqRef.current % DEFAULT_PALETTE.length];
+  const nextFill = () => cycleFill(seqRef.current);
   const layerOf = () => scene.layers[0]?.id ?? "default";
   const makeLeaf = (id, pose, data) => ({
     id,
@@ -23604,6 +24295,15 @@ function useBuiltinShapeTools(args) {
   const polygon = usePolygonTool();
   const star = useStarTool();
   const pencil = usePencilTool();
+  const makePenLeaf = (carrier) => {
+    const id = freshId("pn");
+    const color = nextFill();
+    return makeLeaf(id, carrier.bounds, {
+      path: carrier.path,
+      fill: carrier.closed ? solid(nextFill()) : null,
+      stroke: strokeOf(color, 2)
+    });
+  };
   const pen = usePenTool({
     snapPoint: snapPoint2,
     wrapPath: (path, { closed }) => {
@@ -23612,16 +24312,11 @@ function useBuiltinShapeTools(args) {
     },
     adapter: {
       addNode: (carrier) => {
-        const id = freshId("pn");
-        const color = nextFill();
-        const node = makeLeaf(id, carrier.bounds, {
-          path: carrier.path,
-          fill: carrier.closed ? solid(nextFill()) : null,
-          stroke: strokeOf(color, 2)
-        });
+        const node = makePenLeaf(carrier);
         adapter.insertNode(node);
-        return String(id);
+        return String(node.id);
       },
+      makeNode: (carrier) => makePenLeaf(carrier),
       setSelection: (ids) => adapter.setSelection(ids)
     }
   });
@@ -23891,6 +24586,19 @@ function useEditAnchorsDepSource(scene, selection, adapter, externalState, optio
     }
     const selectedAnchors = effectiveId ? ext?.getSelectedAnchors() ?? EMPTY_ANCHOR_SELECTION : EMPTY_ANCHOR_SELECTION;
     const marquee = effectiveId ? ext?.getMarquee() ?? null : null;
+    const editOps = (id, worldPath, label) => {
+      const wp = worldPath;
+      const node = sc.get(id);
+      if (!node) return [];
+      const storage = classifyStorage(node);
+      if (!storage) return [];
+      if (storage.kind === "pose") return [createTransformOp({ id, from: node.pose, to: wp, label })];
+      const { pose: newPose, path: aligned } = worldEditToStorage(storage.pose, wp);
+      return [
+        createTransformOp({ id, from: node.pose, to: newPose, label }),
+        createSetDataOp({ id, from: node.data, to: { ...node.data, path: aligned }, label })
+      ];
+    };
     return {
       editingId: effectiveId,
       setEditingId(id) {
@@ -23933,24 +24641,10 @@ function useEditAnchorsDepSource(scene, selection, adapter, externalState, optio
         return { pose: node.pose, data: node.data };
       },
       applyEdit(id, worldPath, label) {
-        const wp = worldPath;
-        const node = sc.get(id);
-        if (!node) return;
-        const storage = classifyStorage(node);
-        if (!storage) return;
-        if (storage.kind === "pose") {
-          ad.applyOps([createTransformOp({ id, from: node.pose, to: wp, label })], label);
-          return;
-        }
-        const { pose: newPose, path: aligned } = worldEditToStorage(storage.pose, wp);
-        ad.applyOps(
-          [
-            createTransformOp({ id, from: node.pose, to: newPose, label }),
-            createSetDataOp({ id, from: node.data, to: { ...node.data, path: aligned }, label })
-          ],
-          label
-        );
-      }
+        const ops = editOps(id, worldPath, label);
+        if (ops.length > 0) ad.applyOps(ops, label);
+      },
+      editOps
     };
   });
 }
@@ -24143,7 +24837,7 @@ function useInsertDepSource(scene, adapter, factories) {
           seq = ++insertSeqRef.current;
           id = asNodeId(`kit-${kind}-${seq}`);
         }
-        const color = DEFAULT_PALETTE[seq % DEFAULT_PALETTE.length];
+        const color = cycleFill(seq);
         const fill = solid(color);
         const layer = sc.layers[0]?.id ?? "default";
         const extent = insertPreviewExtent({ shape: kind, bounds, extras });
@@ -24239,15 +24933,16 @@ function useDispatcherDepSource(dispatcher) {
     cancelAll: (reason) => ref.current.cancelAll(reason)
   }));
 }
-function useLayoutDepSource(layouts) {
-  const ref = useRef(layouts);
-  ref.current = layouts;
+function useLayoutDepSource(layouts, dropTarget) {
+  const ref = useRef({ layouts, dropTarget });
+  ref.current = { layouts, dropTarget };
   useDepSource("layout", () => ({
     getLayout: (containerId) => {
-      const l = ref.current;
+      const l = ref.current.layouts;
       if (!l) return null;
       return typeof l === "function" ? l(containerId) : l[containerId] ?? null;
-    }
+    },
+    dropTarget: ref.current.dropTarget
   }));
 }
 function useGeometryProjection(projection) {
@@ -24348,8 +25043,8 @@ var kitImageHandler = {
 
 // src/features/ingestion/svgHandler.ts
 var SVG_MIME = "image/svg+xml";
-var FALLBACK_WIDTH = 300;
-var FALLBACK_HEIGHT = 150;
+var FALLBACK_WIDTH2 = 300;
+var FALLBACK_HEIGHT2 = 150;
 function isSvgFileItem(item) {
   if (item.kind !== "file") return false;
   if (item.mime === SVG_MIME) return true;
@@ -24387,8 +25082,8 @@ var defaultMeasure2 = async (file) => {
     img.src = url;
     await img.decode();
     return {
-      width: img.naturalWidth || FALLBACK_WIDTH,
-      height: img.naturalHeight || FALLBACK_HEIGHT
+      width: img.naturalWidth || FALLBACK_WIDTH2,
+      height: img.naturalHeight || FALLBACK_HEIGHT2
     };
   } finally {
     URL.revokeObjectURL(url);
@@ -24932,6 +25627,7 @@ function SceneCanvasInner(props, ref) {
     insertNodeFactories,
     ingestion,
     layouts,
+    layoutDropTarget,
     poseComposition,
     geometryProjection,
     routing,
@@ -25063,6 +25759,12 @@ function SceneCanvasInner(props, ref) {
   }, [scene, selectionOptions, selectionMode]);
   const internalSelection = useSelection(derivedSelectionOptions);
   const baseSelection = selectionProp ?? internalSelection;
+  const baseAdapterMethods = baseSelection.adapterMethods;
+  const readOnlyAdapterMethods = useMemo(() => ({
+    getSelection: () => baseAdapterMethods.getSelection(),
+    setSelection: () => {
+    }
+  }), [baseAdapterMethods]);
   const selection = useMemo(() => {
     if (selectionMode !== "none") return baseSelection;
     const noopSet = () => {
@@ -25074,9 +25776,10 @@ function SceneCanvasInner(props, ref) {
       remove: noopSet,
       toggle: noopSet,
       clear: noopSet,
-      applyClick: noopSet
+      applyClick: noopSet,
+      adapterMethods: readOnlyAdapterMethods
     };
-  }, [baseSelection, selectionMode]);
+  }, [baseSelection, selectionMode, readOnlyAdapterMethods]);
   const currentSelection = selection.current;
   const selectionKinds = useMemo(() => {
     if (currentSelection.length === 0) return void 0;
@@ -25168,9 +25871,20 @@ function SceneCanvasInner(props, ref) {
   const [sceneLayerGate] = useState(createSceneLayerGate);
   const layerIsPainted = useCallback((layerId) => sceneLayerGate(surfaceViewRegistry?.surface()?.layers() ?? [], layerPaintRef.current)(layerId), [surfaceViewRegistry, sceneLayerGate]);
   const viewLayerGate = layerVisibility !== void 0 || layerOrder !== void 0 ? layerIsPainted : void 0;
-  const { adapter, selectTool: internalSelect, pickEvery: internalPickEvery, pickBest: internalPickBest, boundsOf: internalBoundsOf } = useSceneSelectTool({
+  const framed = poseComposition !== void 0 && poseComposition.closure !== "identity";
+  const adapter = useSceneAdapter(scene, {
+    // `adapterMethods` is memoized; `selection` itself is a fresh object each render.
+    selection: selection.adapterMethods,
+    poseDescriptor: descriptor,
+    commitInsert: insertTool?.create,
+    insertLayer: insertTool?.layer,
+    layouts,
+    poseComposition,
+    cascadeContainerPose: !framed
+  });
+  const { selectTool: internalSelect, pickEvery: internalPickEvery, pickBest: internalPickBest, boundsOf: internalBoundsOf } = useSceneSelectTool({
     scene,
-    selection,
+    adapter,
     poseDescriptor: descriptor,
     geometry,
     // The pick tolerance is declared in screen pixels; this is what converts it.
@@ -25180,10 +25894,7 @@ function SceneCanvasInner(props, ref) {
     // that once per walk instead of once per candidate.
     ...alphaFor ? { alphaOf: composedAlphaFor } : {},
     ...viewLayerGate ? { layerIsPainted: viewLayerGate } : {},
-    selectTool: selectToolWithDefaults,
-    ...insertTool ? { insertTool } : {},
-    ...layouts ? { layouts } : {},
-    ...poseComposition ? { poseComposition } : {}
+    selectTool: selectToolWithDefaults
   });
   const getNodeAtPoint = useMemo(() => {
     if (!internalPickEvery) return void 0;
@@ -25695,6 +26406,7 @@ function SceneCanvasInner(props, ref) {
         editAnchorsExternalState,
         anchorEditingAllowed,
         layouts,
+        layoutDropTarget,
         poseComposition,
         insertNodeFactories,
         snapPoint: toolOptions?.snapPoint,
@@ -25945,6 +26657,7 @@ function StandardActionsRegistrar({
   anchorEditingAllowed,
   poseComposition,
   layouts,
+  layoutDropTarget,
   insertNodeFactories,
   snapPoint: snapPoint2,
   canvasRef,
@@ -25993,7 +26706,7 @@ function StandardActionsRegistrar({
   useViewportActions({ pan: viewportPanEnabled, zoom: viewportZoom, pinchZoom: viewportPinchZoom });
   useAreaSelectDepSource(scene, selection, poseDescriptor, poseComposition, alphaOf);
   useNodeAtPointDepSource(pickEvery);
-  useLayoutDepSource(layouts);
+  useLayoutDepSource(layouts, layoutDropTarget);
   useInsertDepSource(scene, adapter, insertNodeFactories);
   useSnapDepSource(snapPoint2);
   useIngestionDepSource(canvasRef, () => currentViewRef.current, ingestionResolveSrc, ingestionSvg, ingestionClipboard);
@@ -26186,7 +26899,8 @@ function shapeSchema(opts = {}) {
                     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" }
+                    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: {
@@ -27213,6 +27927,20 @@ function createTextLayer(opts) {
     }
   };
 }
+function sourceClusters(cells) {
+  const out = [];
+  for (const c of cells) {
+    const prev = out[out.length - 1];
+    if (prev && prev.srcIndex === c.srcIndex && prev.srcEnd === c.srcEnd) {
+      const x0 = Math.min(prev.x, c.x);
+      const x1 = Math.max(prev.x + prev.advance, c.x + c.advance);
+      out[out.length - 1] = { ...prev, x: x0, advance: x1 - x0 };
+    } else {
+      out.push(c);
+    }
+  }
+  return out;
+}
 function pointInTextPose(x, y, pose, opts = {}) {
   const p = opts.padding ?? 0;
   return x >= pose.x - p && x <= pose.x + pose.width + p && y >= pose.y - p && y <= pose.y + pose.height + p;
@@ -27231,8 +27959,8 @@ function caretIndexAt(x, y, pose) {
       break;
     }
   }
-  const { cells } = line;
-  if (cells.length === 0) return line.srcEnd;
+  if (line.cells.length === 0) return line.srcEnd;
+  const cells = sourceClusters(line.cells);
   const visual = cells.map((_, i) => i).sort((a, b) => cells[a].x - cells[b].x);
   for (const i of visual) {
     const c = cells[i];
@@ -27265,6 +27993,7 @@ function solidColor(p) {
   if ("color" in p) return p.color;
   return null;
 }
+var TRANSFORMS = /* @__PURE__ */ new Set(["none", "uppercase", "lowercase", "capitalize"]);
 var EMPTY_STYLE = {
   bold: false,
   italic: false,
@@ -27320,6 +28049,8 @@ function styleStateFromElement(el, parent) {
       const shift = parseFloat(rawShift);
       if (Number.isFinite(shift)) next.baselineShift = shift;
     }
+    const tt = el.style.textTransform;
+    if (TRANSFORMS.has(tt)) next.textTransform = tt;
     if (el.style.fontFamily) next.fontFamily = el.style.fontFamily;
     if (el.style.color) next.color = el.style.color;
     const ls = el.style.letterSpacing;
@@ -27333,23 +28064,24 @@ function styleStateFromElement(el, parent) {
   return next;
 }
 function styleEquals(a, b) {
-  return a.bold === b.bold && a.italic === b.italic && a.underline === b.underline && a.strikethrough === b.strikethrough && a.overline === b.overline && a.fontSize === b.fontSize && a.fontFamily === b.fontFamily && a.color === b.color && a.letterSpacing === b.letterSpacing && a.script === b.script && a.baselineShift === b.baselineShift && a.fontScale === b.fontScale;
+  return a.bold === b.bold && a.italic === b.italic && a.underline === b.underline && a.strikethrough === b.strikethrough && a.overline === b.overline && a.fontSize === b.fontSize && a.fontFamily === b.fontFamily && a.color === b.color && a.letterSpacing === b.letterSpacing && a.script === b.script && a.baselineShift === b.baselineShift && a.fontScale === b.fontScale && a.textTransform === b.textTransform;
 }
 function toRun(text, style) {
-  const run = { text };
-  if (style.bold) run.bold = true;
-  if (style.italic) run.italic = true;
-  if (style.fontSize != null) run.fontSize = style.fontSize;
-  if (style.fontFamily != null) run.fontFamily = style.fontFamily;
-  if (style.color != null) run.fill = { fill: "solid", color: style.color };
-  if (style.letterSpacing != null) run.letterSpacing = style.letterSpacing;
-  if (style.underline) run.underline = true;
-  if (style.strikethrough) run.strikethrough = true;
-  if (style.overline) run.overline = true;
-  if (style.script != null) run.script = style.script;
-  if (style.baselineShift != null) run.baselineShift = style.baselineShift;
-  if (style.fontScale != null) run.fontScale = style.fontScale;
-  return run;
+  const run2 = { text };
+  if (style.bold) run2.bold = true;
+  if (style.italic) run2.italic = true;
+  if (style.fontSize != null) run2.fontSize = style.fontSize;
+  if (style.fontFamily != null) run2.fontFamily = style.fontFamily;
+  if (style.color != null) run2.fill = { fill: "solid", color: style.color };
+  if (style.letterSpacing != null) run2.letterSpacing = style.letterSpacing;
+  if (style.underline) run2.underline = true;
+  if (style.strikethrough) run2.strikethrough = true;
+  if (style.overline) run2.overline = true;
+  if (style.script != null) run2.script = style.script;
+  if (style.baselineShift != null) run2.baselineShift = style.baselineShift;
+  if (style.fontScale != null) run2.fontScale = style.fontScale;
+  if (style.textTransform != null) run2.textTransform = style.textTransform;
+  return run2;
 }
 function domToRuns(parent) {
   const fragments = [];
@@ -27391,27 +28123,28 @@ function domToRuns(parent) {
 }
 function runsToDom(runs, parent) {
   parent.replaceChildren();
-  for (const run of runs) {
+  for (const run2 of runs) {
     const span = document.createElement("span");
     span.setAttribute("data-run", "");
-    span.textContent = run.text;
-    if (run.bold) span.style.fontWeight = "700";
-    if (run.italic) span.style.fontStyle = "italic";
-    if (run.fontSize != null) span.style.fontSize = `${run.fontSize}px`;
-    else if (run.fontScale != null) span.style.fontSize = `${run.fontScale * 100}%`;
-    if (run.fontFamily != null) span.style.fontFamily = run.fontFamily;
-    const color = solidColor(run.fill);
+    span.textContent = run2.text;
+    if (run2.bold) span.style.fontWeight = "700";
+    if (run2.italic) span.style.fontStyle = "italic";
+    if (run2.fontSize != null) span.style.fontSize = `${run2.fontSize}px`;
+    else if (run2.fontScale != null) span.style.fontSize = `${run2.fontScale * 100}%`;
+    if (run2.fontFamily != null) span.style.fontFamily = run2.fontFamily;
+    const color = solidColor(run2.fill);
     if (color != null) span.style.color = color;
     const decorations = [];
-    if (run.underline) decorations.push("underline");
-    if (run.strikethrough) decorations.push("line-through");
-    if (run.overline) decorations.push("overline");
+    if (run2.underline) decorations.push("underline");
+    if (run2.strikethrough) decorations.push("line-through");
+    if (run2.overline) decorations.push("overline");
     if (decorations.length > 0) span.style.textDecoration = decorations.join(" ");
-    if (run.script != null) span.style.verticalAlign = run.script;
-    if (run.baselineShift != null) {
-      span.setAttribute("data-baseline-shift", String(run.baselineShift));
+    if (run2.script != null) span.style.verticalAlign = run2.script;
+    if (run2.baselineShift != null) {
+      span.setAttribute("data-baseline-shift", String(run2.baselineShift));
     }
-    if (run.letterSpacing != null) span.style.letterSpacing = `${run.letterSpacing}px`;
+    if (run2.letterSpacing != null) span.style.letterSpacing = `${run2.letterSpacing}px`;
+    if (run2.textTransform != null) span.style.textTransform = run2.textTransform;
     parent.appendChild(span);
   }
 }
@@ -27471,7 +28204,8 @@ var STYLE_KEYS = [
   "stroke",
   "script",
   "baselineShift",
-  "fontScale"
+  "fontScale",
+  "textTransform"
 ];
 var FLAG_KEYS = /* @__PURE__ */ new Set([
   "bold",
@@ -27495,8 +28229,8 @@ function deepEqual(a, b) {
   }
   return false;
 }
-function valueAt(run, key) {
-  const value = run[key];
+function valueAt(run2, key) {
+  const value = run2[key];
   if (FLAG_KEYS.has(key)) return value ?? false;
   return value;
 }
@@ -27509,7 +28243,7 @@ function sameStyle(a, b) {
 }
 function totalLength(runs) {
   let n = 0;
-  for (const run of runs) n += run.text.length;
+  for (const run2 of runs) n += run2.text.length;
   return n;
 }
 function styleAtRange(runs, start, end) {
@@ -27520,14 +28254,14 @@ function styleAtRange(runs, start, end) {
   const mixed = /* @__PURE__ */ new Set();
   let seen = false;
   let pos = 0;
-  for (const run of runs) {
-    const runEnd = pos + run.text.length;
+  for (const run2 of runs) {
+    const runEnd = pos + run2.text.length;
     const a = Math.max(pos, lo);
     const b = Math.min(runEnd, hi);
     pos = runEnd;
     if (!(a < b)) continue;
     for (const key of STYLE_KEYS) {
-      const value = valueAt(run, key);
+      const value = valueAt(run2, key);
       if (!seen) first.set(key, value);
       else if (!mixed.has(key) && !sameValue(key, first.get(key), value)) {
         mixed.add(key);
@@ -27548,14 +28282,14 @@ function styleAtRange(runs, start, end) {
 }
 function runsCarryStyling(runs) {
   return runs.some(
-    (run) => STYLE_KEYS.some((key) => {
-      const value = run[key];
+    (run2) => STYLE_KEYS.some((key) => {
+      const value = run2[key];
       return value !== void 0 && value !== false;
     })
   );
 }
-function patchRun(run, patch) {
-  const next = { ...run };
+function patchRun(run2, patch) {
+  const next = { ...run2 };
   for (const key of STYLE_KEYS) {
     if (!(key in patch)) continue;
     const value = patch[key];
@@ -27566,11 +28300,11 @@ function patchRun(run, patch) {
 }
 function coalesceRuns(runs) {
   const out = [];
-  for (const run of runs) {
-    if (run.text.length === 0) continue;
+  for (const run2 of runs) {
+    if (run2.text.length === 0) continue;
     const prev = out[out.length - 1];
-    if (prev && sameStyle(prev, run)) prev.text += run.text;
-    else out.push({ ...run });
+    if (prev && sameStyle(prev, run2)) prev.text += run2.text;
+    else out.push({ ...run2 });
   }
   return out;
 }
@@ -27580,16 +28314,16 @@ function applyStyleToRange(runs, start, end, patch) {
   if (!(lo < hi)) return coalesceRuns(runs);
   const out = [];
   let pos = 0;
-  for (const run of runs) {
-    const runEnd = pos + run.text.length;
+  for (const run2 of runs) {
+    const runEnd = pos + run2.text.length;
     const a = Math.max(pos, lo);
     const b = Math.min(runEnd, hi);
     if (a < b) {
-      if (pos < a) out.push({ ...run, text: run.text.slice(0, a - pos) });
-      out.push(patchRun({ ...run, text: run.text.slice(a - pos, b - pos) }, patch));
-      if (b < runEnd) out.push({ ...run, text: run.text.slice(b - pos) });
+      if (pos < a) out.push({ ...run2, text: run2.text.slice(0, a - pos) });
+      out.push(patchRun({ ...run2, text: run2.text.slice(a - pos, b - pos) }, patch));
+      if (b < runEnd) out.push({ ...run2, text: run2.text.slice(b - pos) });
     } else {
-      out.push({ ...run });
+      out.push({ ...run2 });
     }
     pos = runEnd;
   }
@@ -27685,7 +28419,7 @@ function patchForToggle(current, toggle, nodeStyle) {
 function styleAtCaret(runs, at) {
   return at > 0 ? styleAtRange(runs, at - 1, at) : styleAtRange(runs, 0, 1);
 }
-function spliceRunAt(runs, at, run) {
+function spliceRunAt(runs, at, run2) {
   const out = [];
   let pos = 0;
   let placed2 = false;
@@ -27694,7 +28428,7 @@ function spliceRunAt(runs, at, run) {
     if (!placed2 && at <= end) {
       const k = at - pos;
       if (k > 0) out.push({ ...r, text: r.text.slice(0, k) });
-      out.push(run);
+      out.push(run2);
       if (k < r.text.length) out.push({ ...r, text: r.text.slice(k) });
       placed2 = true;
     } else {
@@ -27702,7 +28436,7 @@ function spliceRunAt(runs, at, run) {
     }
     pos = end;
   }
-  if (!placed2) out.push(run);
+  if (!placed2) out.push(run2);
   return applyStyleToRange(out, 0, 0, {});
 }
 function restoreOverlayFocus(overlay, range) {
@@ -28112,6 +28846,7 @@ function applyOverlayStyle(el, style) {
   if (style.underline) decorations.push("underline");
   if (style.strikethrough) decorations.push("line-through");
   el.style.textDecoration = decorations.length > 0 ? decorations.join(" ") : "none";
+  el.style.textTransform = style.textTransform;
   el.style.whiteSpace = style.wrap ? "pre-wrap" : "pre";
   el.style.overflowWrap = "normal";
   el.style.wordBreak = "normal";
@@ -28313,7 +29048,8 @@ var OVERRIDES = [
   "fill",
   "script",
   "baselineShift",
-  "fontScale"
+  "fontScale",
+  "textTransform"
 ];
 function effectiveRangeStyle(range, style, paint) {
   const resolved = resolveTextStyle(style, paint);
@@ -28321,13 +29057,14 @@ function effectiveRangeStyle(range, style, paint) {
   const out = {
     fontFamily: resolved.fontFamily,
     fontSize: resolved.fontSize,
-    letterSpacing: resolved.letterSpacing
+    letterSpacing: resolved.letterSpacing,
+    textTransform: resolved.textTransform
   };
   if (resolved.fill !== null) out.fill = resolved.fill;
   for (const key of FLAGS) {
     const on = nodeHasFlag(node, key);
-    const run = range?.[key];
-    out[key] = on || run === void 0 ? on : run;
+    const run2 = range?.[key];
+    out[key] = on || run2 === void 0 ? on : run2;
   }
   if (range === null) return out;
   for (const key of OVERRIDES) {
@@ -28567,7 +29304,7 @@ function asMesh(fill) {
 }
 function shifted(color, dL, cScale, dHueDeg) {
   const [r, g, b, a] = resolveColor(color);
-  const [L, A, B] = srgbU8ToOklab(r * 255, g * 255, b * 255);
+  const [L, A, B] = srgbFloatToOklab(r, g, b);
   const [, C, h] = oklabToOklch(L, A, B);
   const [nL, nA, nB] = oklchToOklab(
     Math.min(1, Math.max(0, L + dL)),
@@ -30541,19 +31278,19 @@ var isDev2 = typeof import.meta !== "undefined" && import.meta.env?.DEV;
 function useBooleans(adapter, _options = {}) {
   const adapterRef = useRef(adapter);
   adapterRef.current = adapter;
-  const run = useCallback((op) => {
+  const run2 = useCallback((op) => {
     const result = applyBooleanOp(adapterRef.current, op);
     if (isDev2 && result.kind === "noop" && result.reason === "too-few-for-subtract") {
       console.warn("[useBooleans] subtract requires at least 2 selected paths");
     }
   }, []);
   return {
-    union: useCallback(() => run("union"), [run]),
-    intersect: useCallback(() => run("intersect"), [run]),
-    subtract: useCallback(() => run("subtract"), [run]),
-    exclude: useCallback(() => run("exclude"), [run]),
-    divide: useCallback(() => run("divide"), [run]),
-    crop: useCallback(() => run("crop"), [run])
+    union: useCallback(() => run2("union"), [run2]),
+    intersect: useCallback(() => run2("intersect"), [run2]),
+    subtract: useCallback(() => run2("subtract"), [run2]),
+    exclude: useCallback(() => run2("exclude"), [run2]),
+    divide: useCallback(() => run2("divide"), [run2]),
+    crop: useCallback(() => run2("crop"), [run2])
   };
 }
 function useBooleansAdapter(adapter) {
@@ -31244,9 +31981,6 @@ function cellRectAt(bounds, cols, rows, gap, col, row) {
     height: ch
   };
 }
-function sortedChildIds(children) {
-  return children.map((c) => c.id).sort();
-}
 function tileGrid(opts) {
   const { cols, rows } = opts;
   const gap = opts.gap ?? 0;
@@ -31297,12 +32031,18 @@ function tileGrid(opts) {
     snap: snap2,
     childPoses(container, children) {
       const out = /* @__PURE__ */ new Map();
-      const ids = sortedChildIds(children);
-      const byId = new Map(children.map((c) => [c.id, c.pose]));
-      for (let i = 0; i < ids.length && i < capacity; i++) {
+      const ordered = children.map((c) => ({ c, cell: cellIndexOf(container.bounds, c.pose) })).sort((a, b) => {
+        if (a.cell !== b.cell) {
+          if (a.cell === null) return 1;
+          if (b.cell === null) return -1;
+          return a.cell - b.cell;
+        }
+        return a.c.id < b.c.id ? -1 : a.c.id > b.c.id ? 1 : 0;
+      });
+      for (let i = 0; i < ordered.length && i < capacity; i++) {
         const col = i % cols;
         const row = Math.floor(i / cols);
-        out.set(ids[i], cellPose(container.bounds, col, row, byId.get(ids[i])));
+        out.set(ordered[i].c.id, cellPose(container.bounds, col, row, ordered[i].c.pose));
       }
       return out;
     },
@@ -31438,6 +32178,6 @@ function snapPoint(opts) {
   };
 }
 
-export { ANCHOR_HIT_BASE_PX, ActionsProviderIfRoot, ArrowIcon, BUILTIN_MARKERS, BUNDLE_TOOLS, CURVE_REPS, CanvasView, ColorOverrideRegistry, CropIcon, CursorCoordsHud, 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, DepRegistryProviderIfRoot, DeviceProfileProvider, DivideIcon, EASINGS, EFFECT_KIT_UNIFORMS, EFFECT_VERT_SRC, EllipseIcon, ExcludeIcon, EyedropperIcon, FALLBACK_FIT_VIEW, GHOST_STROKE, HANDLE_BASE_PX, HandIcon, IDENTITY_COLOR_MATRIX, IDENTITY_JOINT, IDENTITY_POSE_COMPOSITION, ImageIcon, IntersectIcon, KIT_SHAPE_KINDS, KIT_STANDARD_ACTION_IDS, LassoIcon, LineIcon, MESH_BAKE_SIZE, MESH_GRADIENT_KIND, MIXED, MOVE_ANCHORS, MinimapCanvas, OUTLINE_MIN_SCREEN_PX, PAINTED_CURSOR_LAYER_ID, PATH_ANCHOR_CHROME_ID, PenIcon, PencilIcon, PickHud, PointerProviderIfRoot, PolygonIcon, RECT_POSE_COMPOSITION, RIGID_POSE_COMPOSITION, ROTATION_HANDLE_BASE_PX, RectIcon, SPRING_PRESETS, SPRITE_STRIDE, SceneCanvas, SceneViewCanvas, SelectIcon, SelectionContextProvider, SelectionContextProviderIfRoot, ShaderCompileError, StarIcon, SubtractIcon, TOOL_PREF_KINDS, TextIcon, UNION_OF_CHILDREN, UnionIcon, UnknownIcon, VERSION, VIEW_ANIMATION_KEY, WHEEL_ZOOM_STEP, WeaselProvider, WeaselRenderer, 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, charOffsetToDomPosition, circlePath, clampView, clearSelectionAction, clipboardCopyAction, clipboardCutAction, 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, 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, cubicBezierEasing, cullDrawCommands, cycleVertexColors, decomposePath, decomposeRectPose, decomposeRigidPose, defaultCommitAdapter, defaultDrawOne, defaultLabelTextRenderer, defaultNodeProperties, defaultNodeRouting, defaultVisibilityRules, defineTool, defineViewportTool, 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, keySpecShortcut, lassoSelectAction, linear, listMarkers, listPaintKinds, makePinchZoomAction, makeViewportWheelPanAction, makeViewportZoomAction, markerDrawCommands, markerInset, markerKeyOf, markerSites, mat3, matchAlignment, meanScale, mergeAlphaFromPrev, meshBounds, meshGradientXml, 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-GREL4MVO.js.map
-//# sourceMappingURL=chunk-GREL4MVO.js.map
+export { ACTION_GLYPHS, ANCHOR_HIT_BASE_PX, ActionsProviderIfRoot, AlignBottomIcon, AlignCenterXIcon, AlignCenterYIcon, AlignLeftIcon, AlignRightIcon, AlignTopIcon, ArrowIcon, BUILTIN_MARKERS, BUNDLE_TOOLS, BringForwardIcon, BringToFrontIcon, 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, 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, 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, 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, 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, meshBounds, meshGradientXml, 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-THCSDHII.js.map
+//# sourceMappingURL=chunk-THCSDHII.js.map