@hankchen/canvas-editor 0.1.0

package/dist/index.js

@@ -0,0 +1,4256 @@
+// src/session/editor.ts
+import {
+  docPathToViewPath,
+  lineHeightPx as lineHeightPx2,
+  renderCanvas,
+  textOrigin,
+  viewPathToDocPath,
+  withTemplatePreview
+} from "@hankchen/canvas";
+
+// src/spatial/camera.ts
+var DEFAULT_ZOOM_BOUNDS = { min: 0.05, max: 8 };
+function sceneToScreen(viewport, sceneX, sceneY) {
+  return {
+    x: (sceneX - viewport.x) * viewport.zoom,
+    y: (sceneY - viewport.y) * viewport.zoom
+  };
+}
+function screenToScene(viewport, screenX, screenY) {
+  return {
+    x: screenX / viewport.zoom + viewport.x,
+    y: screenY / viewport.zoom + viewport.y
+  };
+}
+function clampZoom(zoom, bounds) {
+  return Math.min(bounds.max, Math.max(bounds.min, zoom));
+}
+function panBy(viewport, deltaScreenX, deltaScreenY) {
+  return {
+    x: viewport.x - deltaScreenX / viewport.zoom,
+    y: viewport.y - deltaScreenY / viewport.zoom,
+    zoom: viewport.zoom
+  };
+}
+function zoomAtPoint(viewport, screenX, screenY, nextZoom, bounds) {
+  const zoom = clampZoom(nextZoom, bounds);
+  if (zoom === viewport.zoom) return viewport;
+  return {
+    x: screenX / viewport.zoom + viewport.x - screenX / zoom,
+    y: screenY / viewport.zoom + viewport.y - screenY / zoom,
+    zoom
+  };
+}
+function fitViewport(canvas, surface, bounds, margin) {
+  return fitRect({ x: 0, y: 0, width: canvas.width, height: canvas.height }, surface, bounds, margin);
+}
+function fitRect(rect, surface, bounds, margin) {
+  const innerW = surface.width - margin * 2;
+  const innerH = surface.height - margin * 2;
+  if (rect.width <= 0 || rect.height <= 0 || innerW <= 0 || innerH <= 0) {
+    return { x: 0, y: 0, zoom: 1 };
+  }
+  const zoom = Math.min(bounds.max, Math.min(innerW / rect.width, innerH / rect.height));
+  return {
+    // 矩形中心 (rect.cx, rect.cy) 落在视口中心 (surface/2)：cam = 中心 - 视口中心 / zoom
+    x: rect.x + rect.width / 2 - surface.width / 2 / zoom,
+    y: rect.y + rect.height / 2 - surface.height / 2 / zoom,
+    zoom
+  };
+}
+var PAN_TO_BOX_MARGIN_PX = 12;
+function panToBox(viewport, box, surface, margin) {
+  if (surface.width <= 0 || surface.height <= 0 || !(viewport.zoom > 0)) return viewport;
+  const panAxis = (boxPos, boxSize, surfaceSize, cam) => {
+    const left = (boxPos - cam) * viewport.zoom;
+    const right = left + boxSize * viewport.zoom;
+    if (left >= 0 && right <= surfaceSize) return cam;
+    const slack = surfaceSize - boxSize * viewport.zoom;
+    if (slack >= margin * 2) {
+      const lo = boxPos + boxSize - (surfaceSize - margin) / viewport.zoom;
+      const hi = boxPos - margin / viewport.zoom;
+      return Math.min(hi, Math.max(lo, cam));
+    }
+    if (slack >= 0) {
+      const lo = boxPos + boxSize - surfaceSize / viewport.zoom;
+      const hi = boxPos;
+      return Math.min(hi, Math.max(lo, cam));
+    }
+    return boxPos - margin / viewport.zoom;
+  };
+  const x = panAxis(box.x, box.width, surface.width, viewport.x);
+  const y = panAxis(box.y, box.height, surface.height, viewport.y);
+  if (x === viewport.x && y === viewport.y) return viewport;
+  return { x, y, zoom: viewport.zoom };
+}
+function snapViewportToPhysicalPixels(viewport, dpr) {
+  if (!(dpr > 0)) return viewport;
+  const gridX = viewport.zoom * dpr;
+  return {
+    x: Math.round(viewport.x * gridX) / gridX,
+    y: Math.round(viewport.y * gridX) / gridX,
+    zoom: viewport.zoom
+  };
+}
+var WHEEL_ZOOM_STEP = 0.1;
+function nextZoomByWheel(zoom, deltaY, bounds) {
+  if (deltaY === 0) return clampZoom(zoom, bounds);
+  const sign = Math.sign(deltaY);
+  const absDelta = Math.abs(deltaY);
+  const delta = Math.min(absDelta, WHEEL_ZOOM_STEP * 100) * sign;
+  let next = zoom - delta / 100;
+  next += Math.log10(Math.max(1, zoom)) * -sign * Math.min(1, absDelta / 20);
+  return clampZoom(next, bounds);
+}
+
+// src/spatial/hitTest.ts
+import { resolveChildAt as resolveChildAt2, resolveLayerBox as resolveLayerBox2 } from "@hankchen/canvas";
+
+// src/shared/layerPath.ts
+import { resolveChildAt, resolveLayerBox } from "@hankchen/canvas";
+function isIndexSegment(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function isLayerPath(value) {
+  if (!Array.isArray(value) || value.length < 2) return false;
+  if (value[0] !== "layers" || !isIndexSegment(value[1])) return false;
+  const descent = ["rows", "cells", "content"];
+  let stage = 0;
+  let i = 2;
+  while (i < value.length) {
+    const key = value[i];
+    if (stage === 0 && key === "template") {
+      if (i === value.length - 1) return true;
+      if (value[i + 1] !== "cells") return false;
+      stage = 1;
+      i += 1;
+      continue;
+    }
+    const expected = descent[stage];
+    if (key !== expected) return false;
+    if (expected === "content") return i === value.length - 1;
+    if (!isIndexSegment(value[i + 1])) return false;
+    stage += 1;
+    i += 2;
+  }
+  return true;
+}
+function isTemplateSubtreePath(path) {
+  return path.includes("template");
+}
+function isRootLayerPath(path) {
+  return isLayerPath(path) && path.length === 2;
+}
+function pathsEqual(a, b) {
+  if (a === b) return true;
+  if (!a || !b || a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i += 1) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+function pathStartsWith(path, prefix) {
+  if (path.length < prefix.length) return false;
+  for (let i = 0; i < prefix.length; i += 1) {
+    if (path[i] !== prefix[i]) return false;
+  }
+  return true;
+}
+function isLockedPath(path, lockedPaths) {
+  return lockedPaths.some((locked) => pathStartsWith(path, locked));
+}
+function navigate(root, path) {
+  let current = root;
+  let i = 0;
+  while (i < path.length) {
+    const container = current;
+    if (container === null || typeof container !== "object") return null;
+    const key = path[i];
+    if (typeof key !== "string") return null;
+    current = container[key];
+    if (current === null || current === void 0) return null;
+    if (key === "template") {
+      i += 1;
+      continue;
+    }
+    if (i + 1 >= path.length) break;
+    const list = current;
+    const index = path[i + 1];
+    if (!Array.isArray(list) || typeof index !== "number") return null;
+    current = list[index];
+    if (current === null || current === void 0) return null;
+    i += 2;
+  }
+  return current;
+}
+function resolveLayer(doc, path) {
+  if (!isLayerPath(path)) return null;
+  const layer = navigate(doc, path);
+  if (layer === null || typeof layer !== "object" || !("type" in layer)) return null;
+  return layer;
+}
+function rootLayerOf(doc, path) {
+  const index = path[1];
+  if (typeof index !== "number" || !Number.isSafeInteger(index) || index < 0) return null;
+  return doc.layers[index] ?? null;
+}
+function selectionParentPath(path) {
+  if (path.length < 2) return null;
+  if (path[path.length - 1] === "content") return path.slice(0, -1);
+  if (path[path.length - 1] === "template") return path.slice(0, -1);
+  if (path.length > 2) {
+    return path.slice(0, -2);
+  }
+  return null;
+}
+function layerBoxByPath(doc, path, policies) {
+  if (!isLayerPath(path)) return null;
+  const rootIndex = path[1];
+  const root = doc.layers[rootIndex];
+  if (root === void 0) return null;
+  let layer = root;
+  let box = resolveLayerBox(root, 0, 0, doc.width, doc.height, policies);
+  let i = 2;
+  while (i < path.length) {
+    const key = path[i];
+    if (key === "template") {
+      const child2 = resolveChildAt(layer, box, "template", 0, policies);
+      if (!child2) return null;
+      layer = child2.layer;
+      box = child2.box;
+      i += 1;
+      continue;
+    }
+    const index = path[i + 1];
+    const child = resolveChildAt(layer, box, key, index, policies);
+    if (!child) return null;
+    layer = child.layer;
+    box = child.box;
+    i += 2;
+  }
+  return box;
+}
+function remapPathAfterSplice(path, containerPath, key, from, to) {
+  if (path.length < containerPath.length + 2) return path;
+  for (let i = 0; i < containerPath.length; i += 1) {
+    if (path[i] !== containerPath[i]) return path;
+  }
+  if (path[containerPath.length] !== key) return path;
+  const index = path[containerPath.length + 1];
+  if (typeof index !== "number") return path;
+  const rest = path.slice(containerPath.length + 2);
+  const head = [...containerPath, key];
+  if (from === to) {
+    if (index === from) return null;
+    return index > from ? [...head, index - 1, ...rest] : path;
+  }
+  if (index === from) return [...head, to, ...rest];
+  if (from < index && index <= to) return [...head, index - 1, ...rest];
+  if (to <= index && index < from) return [...head, index + 1, ...rest];
+  return path;
+}
+
+// src/spatial/hitTest.ts
+function contains(box, x, y) {
+  return box.width > 0 && box.height > 0 && x >= box.x && x < box.x + box.width && y >= box.y && y < box.y + box.height;
+}
+function coversCanvas(box, canvasWidth, canvasHeight) {
+  return box.x <= 0 && box.y <= 0 && box.x + box.width >= canvasWidth && box.y + box.height >= canvasHeight;
+}
+function hitWalk(layer, path, box, x, y, policies, skipOwnBox = false) {
+  switch (layer.type) {
+    case "TableLayer":
+      for (let i = layer.rows.length - 1; i >= 0; i -= 1) {
+        const child = resolveChildAt2(layer, box, "rows", i, policies);
+        if (!child) continue;
+        const hit = hitWalk(child.layer, [...path, "rows", i], child.box, x, y, policies);
+        if (hit) return hit;
+      }
+      break;
+    case "TableRowLayer":
+      for (let i = layer.cells.length - 1; i >= 0; i -= 1) {
+        const child = resolveChildAt2(layer, box, "cells", i, policies);
+        if (!child) continue;
+        const hit = hitWalk(child.layer, [...path, "cells", i], child.box, x, y, policies);
+        if (hit) return hit;
+      }
+      break;
+    case "TableCellLayer":
+      if (layer.content) {
+        const child = resolveChildAt2(layer, box, "content", 0, policies);
+        if (child) {
+          const hit = hitWalk(child.layer, [...path, "content"], child.box, x, y, policies);
+          if (hit) return hit;
+        }
+      }
+      break;
+    case "ImageLayer":
+    case "TextLayer":
+    case "QrCodeLayer":
+    case "TableRowTemplate":
+      break;
+  }
+  return !skipOwnBox && contains(box, x, y) ? path : null;
+}
+function hitTest(canvas, sceneX, sceneY, policies, options) {
+  const lockedPaths = options?.lockedPaths;
+  for (let i = canvas.layers.length - 1; i >= 0; i -= 1) {
+    const layer = canvas.layers[i];
+    if (layer.visible === false) continue;
+    const rootPath = ["layers", i];
+    if (lockedPaths !== void 0 && isLockedPath(rootPath, lockedPaths)) continue;
+    const box = resolveLayerBox2(layer, 0, 0, canvas.width, canvas.height, policies);
+    const skipOwnBox = i === 0 && coversCanvas(box, canvas.width, canvas.height);
+    const hit = hitWalk(layer, rootPath, box, sceneX, sceneY, policies, skipOwnBox);
+    if (hit) return hit;
+  }
+  return null;
+}
+
+// src/spatial/snap.ts
+import { resolveLayerBox as resolveLayerBox3 } from "@hankchen/canvas";
+var SNAP_THRESHOLD_SCREEN_PX = 6;
+function snapThresholdScene(zoom) {
+  return SNAP_THRESHOLD_SCREEN_PX / zoom;
+}
+function visibleRootBoxes(doc, excludeRootIndex, policies) {
+  const boxes = [];
+  for (let i = 0; i < doc.layers.length; i += 1) {
+    if (excludeRootIndex !== null && i === excludeRootIndex) continue;
+    const layer = doc.layers[i];
+    if (layer.visible === false) continue;
+    boxes.push(resolveLayerBox3(layer, 0, 0, doc.width, doc.height, policies));
+  }
+  return boxes;
+}
+function snapAxesFromBoxes(canvasWidth, canvasHeight, boxes, guides) {
+  const axes = [];
+  for (const box of boxes) {
+    axes.push(
+      { orientation: "vertical", position: box.x, source: "layer" },
+      { orientation: "vertical", position: box.x + box.width / 2, source: "layer" },
+      { orientation: "vertical", position: box.x + box.width, source: "layer" },
+      { orientation: "horizontal", position: box.y, source: "layer" },
+      { orientation: "horizontal", position: box.y + box.height / 2, source: "layer" },
+      { orientation: "horizontal", position: box.y + box.height, source: "layer" }
+    );
+  }
+  axes.push(
+    { orientation: "vertical", position: canvasWidth / 2, source: "canvas-center" },
+    { orientation: "horizontal", position: canvasHeight / 2, source: "canvas-center" }
+  );
+  for (const guide of guides) {
+    axes.push({ orientation: guide.orientation, position: guide.position, source: "guide" });
+  }
+  return axes;
+}
+function nearestAxisHit(points, axes, orientation, threshold) {
+  let best = null;
+  for (const axis of axes) {
+    if (axis.orientation !== orientation) continue;
+    for (const point of points) {
+      const delta = axis.position - point;
+      const distance = Math.abs(delta);
+      if (distance > threshold) continue;
+      if (best === null || distance < Math.abs(best.delta)) best = { delta, axis };
+    }
+  }
+  return best;
+}
+function resolveSnapPoints(points, axes, threshold) {
+  const vertical = nearestAxisHit(points.vertical, axes, "vertical", threshold);
+  const horizontal = nearestAxisHit(points.horizontal, axes, "horizontal", threshold);
+  return {
+    dx: vertical ? vertical.delta : 0,
+    dy: horizontal ? horizontal.delta : 0,
+    axes: [
+      ...vertical ? [vertical.axis] : [],
+      ...horizontal ? [horizontal.axis] : []
+    ]
+  };
+}
+function resolveSnap(box, axes, threshold) {
+  return resolveSnapPoints(
+    {
+      vertical: [box.x, box.x + box.width / 2, box.x + box.width],
+      horizontal: [box.y, box.y + box.height / 2, box.y + box.height]
+    },
+    axes,
+    threshold
+  );
+}
+
+// src/spatial/create.ts
+var CREATE_DEAD_ZONE_SCREEN_PX = 4;
+function createRubberBandRect(type, start, current, axes, threshold) {
+  const x = Math.min(start.x, current.x);
+  const y = Math.min(start.y, current.y);
+  const width = Math.abs(current.x - start.x);
+  const height = type === "QrCodeLayer" ? width : Math.abs(current.y - start.y);
+  const resolution = resolveSnapPoints(
+    { vertical: [x, x + width], horizontal: [y, y + height] },
+    axes,
+    threshold
+  );
+  return {
+    rect: { x: x + resolution.dx, y: y + resolution.dy, width, height },
+    axes: resolution.axes
+  };
+}
+
+// src/spatial/resize.ts
+import "@hankchen/canvas";
+var RESIZE_HANDLES = ["nw", "n", "ne", "e", "se", "s", "sw", "w"];
+var RESIZE_MIN_SIZE_PX = 1;
+var WEST_HANDLES = /* @__PURE__ */ new Set(["nw", "w", "sw"]);
+var EAST_HANDLES = /* @__PURE__ */ new Set(["ne", "e", "se"]);
+var NORTH_HANDLES = /* @__PURE__ */ new Set(["nw", "n", "ne"]);
+var SOUTH_HANDLES = /* @__PURE__ */ new Set(["sw", "s", "se"]);
+function handleResizesWidth(handle) {
+  return WEST_HANDLES.has(handle) || EAST_HANDLES.has(handle);
+}
+function handleResizesHeight(handle) {
+  return NORTH_HANDLES.has(handle) || SOUTH_HANDLES.has(handle);
+}
+function resizeBox(start, handle, dx, dy, minSize = RESIZE_MIN_SIZE_PX) {
+  const west = WEST_HANDLES.has(handle);
+  const north = NORTH_HANDLES.has(handle);
+  const width = west ? start.width - dx : EAST_HANDLES.has(handle) ? start.width + dx : start.width;
+  const height = north ? start.height - dy : SOUTH_HANDLES.has(handle) ? start.height + dy : start.height;
+  const clampedWidth = Math.max(width, minSize);
+  const clampedHeight = Math.max(height, minSize);
+  return {
+    x: west ? start.x + start.width - clampedWidth : start.x,
+    y: north ? start.y + start.height - clampedHeight : start.y,
+    width: clampedWidth,
+    height: clampedHeight
+  };
+}
+function resizeSnapPoints(start, handle, dx, dy) {
+  const vertical = [];
+  const horizontal = [];
+  if (WEST_HANDLES.has(handle)) vertical.push(start.x + dx);
+  if (EAST_HANDLES.has(handle)) vertical.push(start.x + start.width + dx);
+  if (NORTH_HANDLES.has(handle)) horizontal.push(start.y + dy);
+  if (SOUTH_HANDLES.has(handle)) horizontal.push(start.y + start.height + dy);
+  return { vertical, horizontal };
+}
+var NO_AXES = { width: false, height: false };
+function resizableAxesAt(doc, path) {
+  const layer = resolveLayer(doc, path);
+  if (!layer) return NO_AXES;
+  if (path[path.length - 1] === "content") {
+    const templateContent = path.length > 4 && path[path.length - 4] === "template";
+    return templateContent ? { width: false, height: true } : NO_AXES;
+  }
+  if (path[path.length - 1] === "template") return NO_AXES;
+  const containerKey = path[path.length - 2];
+  if (containerKey === "rows") return { width: false, height: true };
+  if (containerKey === "cells") return { width: true, height: true };
+  return { width: true, height: true };
+}
+function resizeHandlesAt(doc, path) {
+  const axes = resizableAxesAt(doc, path);
+  return RESIZE_HANDLES.filter((handle) => {
+    const needsWidth = handleResizesWidth(handle);
+    const needsHeight = handleResizesHeight(handle);
+    return (!needsWidth || axes.width) && (!needsHeight || axes.height);
+  });
+}
+var RESIZE_HANDLE_HIT_PX = 6;
+function resizeHandlePoint(box, handle) {
+  const right = box.x + box.width;
+  const bottom = box.y + box.height;
+  switch (handle) {
+    case "nw":
+      return { x: box.x, y: box.y };
+    case "n":
+      return { x: box.x + box.width / 2, y: box.y };
+    case "ne":
+      return { x: right, y: box.y };
+    case "e":
+      return { x: right, y: box.y + box.height / 2 };
+    case "se":
+      return { x: right, y: bottom };
+    case "s":
+      return { x: box.x + box.width / 2, y: bottom };
+    case "sw":
+      return { x: box.x, y: bottom };
+    case "w":
+      return { x: box.x, y: box.y + box.height / 2 };
+  }
+}
+function resizeHandleAt(handles, box, sceneX, sceneY, zoom) {
+  const tolerance = RESIZE_HANDLE_HIT_PX / zoom;
+  for (const handle of handles) {
+    const point = resizeHandlePoint(box, handle);
+    if (Math.hypot(sceneX - point.x, sceneY - point.y) <= tolerance) return handle;
+  }
+  return null;
+}
+
+// src/session/editor.ts
+import { anchorOffset as anchorOffset2, layerHeight as layerHeight2, layerWidth } from "@hankchen/canvas";
+
+// src/shared/expressionSchema.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeSchemaType(value) {
+  if (typeof value === "string") return value === "" ? void 0 : value;
+  const primary = value.find((entry) => entry !== "null" && entry !== "");
+  return primary;
+}
+function annotationsOf(raw) {
+  const node = {};
+  const rawType = raw["type"];
+  if (typeof rawType === "string") {
+    const type = normalizeSchemaType(rawType);
+    if (type !== void 0) node.type = type;
+  } else if (Array.isArray(rawType)) {
+    const type = normalizeSchemaType(rawType.filter((entry) => typeof entry === "string"));
+    if (type !== void 0) node.type = type;
+  }
+  const rawDescription = raw["description"];
+  if (typeof rawDescription === "string") node.description = rawDescription;
+  const rawTitle = raw["title"];
+  if (typeof rawTitle === "string") node.title = rawTitle;
+  return node;
+}
+function pointerEscape(key) {
+  return key.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function unescapePointerToken(token) {
+  let out = "";
+  for (let i = 0; i < token.length; i += 1) {
+    const ch = token[i];
+    if (ch === "~" && (token[i + 1] === "0" || token[i + 1] === "1")) {
+      out += token[i + 1] === "0" ? "~" : "/";
+      i += 1;
+    } else {
+      out += ch;
+    }
+  }
+  return out;
+}
+function resolveInternalRef(ref, root) {
+  let fragment = ref.slice(1);
+  try {
+    fragment = decodeURIComponent(fragment);
+  } catch {
+    return { ok: false, why: "\u6307\u9488\u7247\u6BB5\u542B\u65E0\u6548\u767E\u5206\u53F7\u7F16\u7801" };
+  }
+  const tokens = fragment === "" ? [] : fragment.replace(/^\//, "").split("/");
+  let current = root;
+  for (const token of tokens) {
+    if (!isPlainObject(current)) return { ok: false, why: `\u6307\u9488\u9014\u7ECF\u975E\u5BF9\u8C61\uFF08\u6BB5 "${token}"\uFF09` };
+    const key = unescapePointerToken(token);
+    if (!(key in current)) return { ok: false, why: `\u6307\u9488\u6BB5\u672A\u547D\u4E2D\uFF08"${token}"\uFF09` };
+    current = current[key];
+  }
+  return { ok: true, target: current };
+}
+function degradeWithDiagnostic(ctx, raw, path, code, detail) {
+  ctx.diagnostics.push({ path, code, detail });
+  return annotationsOf(raw);
+}
+function compileSchemaNode(raw, declPath, ctx) {
+  if (ctx.activePath.has(raw)) {
+    return degradeWithDiagnostic(ctx, raw, declPath, "circular_ref", "\u8282\u70B9\u5728\u6D3B\u8DC3\u8DEF\u5F84\u4E0A\u91CD\u5165\uFF08\u73AF\u5F15\u7528\uFF09\uFF0C\u964D\u7EA7\u4E3A\u53F6\u5B50");
+  }
+  ctx.activePath.add(raw);
+  try {
+    const rawRef = raw["$ref"];
+    if (rawRef !== void 0) return compileRefNode(raw, rawRef, declPath, ctx);
+    return compileInlineNode(raw, declPath, ctx);
+  } finally {
+    ctx.activePath.delete(raw);
+  }
+}
+function compileRefNode(raw, rawRef, declPath, ctx) {
+  if (typeof rawRef !== "string") {
+    return degradeWithDiagnostic(ctx, raw, declPath, "broken_ref", "$ref \u5FC5\u987B\u662F string\uFF0C\u8282\u70B9\u964D\u7EA7\u4E3A\u53F6\u5B50");
+  }
+  if (!rawRef.startsWith("#")) {
+    return degradeWithDiagnostic(
+      ctx,
+      raw,
+      declPath,
+      "external_ref",
+      `$ref \u6307\u5411\u5916\u90E8/\u8FDC\u7A0B\u76EE\u6807 "${rawRef}"\uFF08\u4EC5\u652F\u6301\u5185\u90E8 #/ \u6307\u9488\uFF0C\u5F52\u5BBF\u4E3B\u9884\u5185\u8054\uFF09\uFF0C\u8282\u70B9\u964D\u7EA7\u4E3A\u53F6\u5B50`
+    );
+  }
+  const resolved = resolveInternalRef(rawRef, ctx.root);
+  if (!resolved.ok) {
+    return degradeWithDiagnostic(ctx, raw, declPath, "broken_ref", `$ref \u5185\u90E8\u6307\u9488\u89E3\u6790\u5931\u8D25\uFF08${resolved.why}\uFF09\uFF0C\u8282\u70B9\u964D\u7EA7\u4E3A\u53F6\u5B50`);
+  }
+  if (!isPlainObject(resolved.target)) {
+    return degradeWithDiagnostic(ctx, raw, declPath, "target_shape_mismatch", `$ref \u76EE\u6807\u4E0D\u662F schema \u5BF9\u8C61\uFF0C\u8282\u70B9\u964D\u7EA7\u4E3A\u53F6\u5B50`);
+  }
+  if (ctx.activePath.has(resolved.target)) {
+    return degradeWithDiagnostic(ctx, raw, declPath, "circular_ref", `$ref \u76EE\u6807\u5728\u6D3B\u8DC3\u8DEF\u5F84\u4E0A\uFF08\u73AF\u5F15\u7528\uFF09"${rawRef}"\uFF0C\u8282\u70B9\u964D\u7EA7\u4E3A\u53F6\u5B50`);
+  }
+  const base = compileSchemaNode(resolved.target, rawRef, ctx);
+  const localDescription = raw["description"];
+  if (typeof localDescription === "string") base.description = localDescription;
+  return base;
+}
+function compileInlineNode(raw, declPath, ctx) {
+  const node = annotationsOf(raw);
+  if (raw["additionalProperties"] === true) node.open = true;
+  const rawProperties = raw["properties"];
+  if (isPlainObject(rawProperties)) {
+    const properties = /* @__PURE__ */ new Map();
+    for (const [key, child] of Object.entries(rawProperties)) {
+      if (!isPlainObject(child)) continue;
+      properties.set(key, compileSchemaNode(child, `${declPath}/properties/${pointerEscape(key)}`, ctx));
+    }
+    node.properties = properties;
+  }
+  const rawItems = raw["items"];
+  if (isPlainObject(rawItems)) node.items = compileSchemaNode(rawItems, `${declPath}/items`, ctx);
+  return node;
+}
+function parseExpressionSchema(raw) {
+  if (!isPlainObject(raw)) {
+    return { ok: false, reason: "invalid_schema", detail: "schema \u6839\u5FC5\u987B\u662F\u5BF9\u8C61\u58F0\u660E" };
+  }
+  const rawProperties = raw["properties"];
+  if (isPlainObject(rawProperties)) {
+    for (const key of Object.keys(rawProperties)) {
+      if (key === "row" || key.startsWith("$")) {
+        return { ok: false, reason: "reserved_root_key", detail: `\u6839\u7EA7\u952E "${key}" \u4FDD\u7559\uFF08row. \u524D\u7F00/$ \u540D\u4E0E\u6C42\u503C\u4E0A\u4E0B\u6587\u51B2\u7A81\uFF09` };
+      }
+    }
+  }
+  if (!isPlainObject(rawProperties)) {
+    return { ok: false, reason: "invalid_schema", detail: "\u6839\u58F0\u660E\u7F3A properties \u5C42\u7EA7\uFF08schema \u5373\u8F7D\u8377\u5F62\u72B6\uFF0C\u5FC5\u987B\u58F0\u660E\u9876\u5C42\u952E\uFF09" };
+  }
+  const diagnostics = [];
+  const schema = compileSchemaNode(raw, "#", { root: raw, diagnostics, activePath: /* @__PURE__ */ new Set() });
+  return { ok: true, schema, diagnostics };
+}
+function normalizeExpressionSchemaSource(raw) {
+  const parsed = parseExpressionSchema(raw);
+  if (!parsed.ok) {
+    console.warn(
+      `[canvas-editor] \u6570\u636E\u6E90 schema \u58F0\u660E\u964D\u7EA7\u4E3A\u65E0\u5019\u9009\uFF08${parsed.reason}: ${parsed.detail}\uFF09\u2014\u2014\u8865\u5168\u662F\u8F85\u52A9\u58F0\u660E\u4E0D\u4F5C\u6743\u5A01\uFF0C\u4E0D\u5F39\u9519`
+    );
+    return null;
+  }
+  if (parsed.diagnostics.length > 0) {
+    const lines = parsed.diagnostics.map((diagnostic) => `- ${diagnostic.path}\uFF1A${diagnostic.code}\u2014\u2014${diagnostic.detail}`);
+    console.warn(
+      `[canvas-editor] \u6570\u636E\u6E90 schema \u7F16\u8BD1\u8BCA\u65AD ${parsed.diagnostics.length} \u6761\uFF08\u5C40\u90E8\u964D\u7EA7\u4E3A\u53F6\u5B50\uFF0C\u6811\u5176\u4F59\u90E8\u5206\u7167\u5E38\u670D\u52A1\uFF09\uFF1A
+${lines.join("\n")}`
+    );
+  }
+  return parsed.schema;
+}
+function objectShapeOf(node) {
+  let cursor = node;
+  while (cursor !== void 0) {
+    if (cursor.properties !== void 0) return cursor.properties;
+    cursor = cursor.items;
+  }
+  return null;
+}
+function schemaNodeAtPath(node, segments) {
+  let current = node;
+  for (const segment of segments) {
+    const child = objectShapeOf(current)?.get(segment);
+    if (child === void 0) return null;
+    current = child;
+  }
+  return current;
+}
+function schemaChildEntries(node) {
+  if (node.type === "array" || node.items !== void 0) return { entries: [] };
+  const entries = node.properties !== void 0 ? [...node.properties].map(([key, child]) => ({ key, node: child })) : [];
+  return node.open === true ? { entries, open: true } : { entries };
+}
+function resolveRowSchema(root, rowsPath) {
+  const segments = rowsPath.split(".");
+  if (rowsPath === "" || segments.includes("")) return null;
+  const node = schemaNodeAtPath(root, segments);
+  return node?.items ?? null;
+}
+
+// src/shared/expressionPath.ts
+function parseExpressionPath(expr) {
+  if (expr === "") {
+    return { ok: false, error: "expression_syntax_error" };
+  }
+  const segments = expr.split(".");
+  if (segments.includes("")) {
+    return { ok: false, error: "expression_syntax_error" };
+  }
+  const head = segments[0];
+  const rest = segments.slice(1);
+  if (head === "row") return { ok: true, head: { kind: "row" }, rest };
+  if (head === "$root") return { ok: true, head: { kind: "root" }, rest };
+  return { ok: true, head: { kind: "bare", name: head }, rest };
+}
+
+// src/shared/expressionScan.ts
+var PHP_TRIM_CHARS = " 	\n\r\0\v";
+function phpTrim(value) {
+  let start = 0;
+  let end = value.length;
+  while (start < end && PHP_TRIM_CHARS.includes(value[start])) start += 1;
+  while (end > start && PHP_TRIM_CHARS.includes(value[end - 1])) end -= 1;
+  return value.slice(start, end);
+}
+function scanExpressionFragments(template) {
+  const parts = [];
+  let pos = 0;
+  let open = template.indexOf("{{");
+  while (open !== -1) {
+    const close = template.indexOf("}}", open + 2);
+    if (close === -1) {
+      if (open > pos) {
+        parts.push({ kind: "literal", start: pos, end: open, text: template.slice(pos, open) });
+      }
+      const text = template.slice(open);
+      parts.push({ kind: "open", start: open, end: template.length, text, expr: phpTrim(text.slice(2)) });
+      return { template, parts };
+    }
+    if (open > pos) {
+      parts.push({ kind: "literal", start: pos, end: open, text: template.slice(pos, open) });
+    }
+    const raw = template.slice(open + 2, close);
+    const expr = phpTrim(raw);
+    const error = parseExpressionPath(expr).ok ? null : "expression_syntax_error";
+    parts.push({ kind: "fragment", start: open, end: close + 2, raw, expr, error });
+    pos = close + 2;
+    open = template.indexOf("{{", pos);
+  }
+  if (pos < template.length) {
+    parts.push({ kind: "literal", start: pos, end: template.length, text: template.slice(pos) });
+  }
+  return { template, parts };
+}
+function expressionFragmentAtCursor(scan, cursor) {
+  for (const part of scan.parts) {
+    if (part.kind === "literal") continue;
+    const inside = part.kind === "open" ? cursor > part.start && cursor <= part.end : cursor > part.start && cursor < part.end;
+    if (inside) return part;
+  }
+  return null;
+}
+
+// src/editing/alignCanvas.ts
+var ALIGN_CORNER_MARGIN_PX = 40;
+function alignToCanvasTarget(mode, box, canvasWidth, canvasHeight, margin) {
+  switch (mode) {
+    case "left":
+      return { x: 0, y: box.y };
+    case "right":
+      return { x: canvasWidth - box.width, y: box.y };
+    case "top":
+      return { x: box.x, y: 0 };
+    case "bottom":
+      return { x: box.x, y: canvasHeight - box.height };
+    case "h-center":
+      return { x: (canvasWidth - box.width) / 2, y: box.y };
+    case "v-center":
+      return { x: box.x, y: (canvasHeight - box.height) / 2 };
+    case "corner-tl":
+      return { x: margin, y: margin };
+    case "corner-tr":
+      return { x: canvasWidth - box.width - margin, y: margin };
+    case "corner-bl":
+      return { x: margin, y: canvasHeight - box.height - margin };
+    case "corner-br":
+      return { x: canvasWidth - box.width - margin, y: canvasHeight - box.height - margin };
+    default:
+      return null;
+  }
+}
+
+// src/editing/clipboard.ts
+import { anchorOffset } from "@hankchen/canvas";
+var PASTE_OFFSET_PX = 20;
+var ROOT_PASTEABLE_TYPES = /* @__PURE__ */ new Set([
+  "TextLayer",
+  "ImageLayer",
+  "QrCodeLayer",
+  "TableLayer"
+]);
+function isRootPasteableType(type) {
+  return ROOT_PASTEABLE_TYPES.has(type);
+}
+function canCopyLayerAt(doc, path) {
+  const layer = resolveLayer(doc, path);
+  return layer !== null && isRootPasteableType(layer.type);
+}
+function cloneLayerSubtree(layer) {
+  return JSON.parse(JSON.stringify(layer));
+}
+function pastePosition(sourceBox, anchor, docWidth, docHeight, dx, dy) {
+  const offset = anchorOffset(anchor, docWidth, docHeight, sourceBox.width, sourceBox.height);
+  return { x: sourceBox.x + dx - offset.x, y: sourceBox.y + dy - offset.y };
+}
+function prepareRootPaste(layer, sourceBox, docWidth, docHeight, dx, dy) {
+  const copy = cloneLayerSubtree(layer);
+  const position = pastePosition(sourceBox, copy.position.anchor, docWidth, docHeight, dx, dy);
+  return { ...copy, position: { ...copy.position, ...position } };
+}
+
+// src/editing/findReplace.ts
+function collectFieldHits(layer, path, query, out) {
+  let from = 0;
+  for (; ; ) {
+    const index = layer.text.indexOf(query, from);
+    if (index === -1) return;
+    out.push({ path, start: index, end: index + query.length });
+    from = index + query.length;
+  }
+}
+function collectLayerHits(layer, path, query, out) {
+  switch (layer.type) {
+    case "TableLayer":
+      if (layer.template) {
+        for (let i = layer.template.cells.length - 1; i >= 0; i -= 1) {
+          collectLayerHits(layer.template.cells[i], [...path, "template", "cells", i], query, out);
+        }
+      }
+      for (let i = layer.rows.length - 1; i >= 0; i -= 1) {
+        collectLayerHits(layer.rows[i], [...path, "rows", i], query, out);
+      }
+      break;
+    case "TableRowLayer":
+      for (let i = layer.cells.length - 1; i >= 0; i -= 1) {
+        collectLayerHits(layer.cells[i], [...path, "cells", i], query, out);
+      }
+      break;
+    case "TableRowTemplate":
+      for (let i = layer.cells.length - 1; i >= 0; i -= 1) {
+        collectLayerHits(layer.cells[i], [...path, "cells", i], query, out);
+      }
+      break;
+    case "TableCellLayer":
+      if (layer.content) collectLayerHits(layer.content, [...path, "content"], query, out);
+      break;
+    case "TextLayer":
+      if (layer.expression === null) collectFieldHits(layer, path, query, out);
+      break;
+    case "ImageLayer":
+    case "QrCodeLayer":
+      break;
+  }
+}
+function scanTextMatches(doc, query) {
+  const hits = [];
+  if (query === "") return hits;
+  for (let i = doc.layers.length - 1; i >= 0; i -= 1) {
+    collectLayerHits(doc.layers[i], ["layers", i], query, hits);
+  }
+  return hits;
+}
+function replaceHitsInDraft(draft, hits, replacement) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const hit of hits) {
+    const key = hit.path.map(String).join("\0");
+    const group = byPath.get(key);
+    if (group) group.push(hit);
+    else byPath.set(key, [hit]);
+  }
+  let applied = 0;
+  for (const group of byPath.values()) {
+    const layer = resolveLayer(draft, group[0].path);
+    if (!layer || layer.type !== "TextLayer") continue;
+    let text = layer.text;
+    for (const { start, end } of [...group].sort((a, b) => b.start - a.start)) {
+      if (start < 0 || end > text.length || start > end) continue;
+      text = text.slice(0, start) + replacement + text.slice(end);
+      applied += 1;
+    }
+    layer.text = text;
+    layer.expression = null;
+  }
+  return applied;
+}
+
+// src/editing/layerPanel.ts
+function childLists(layer) {
+  switch (layer.type) {
+    case "TableLayer":
+      if (layer.template !== null) return [{ key: "template", layers: [layer.template] }];
+      return [{ key: "rows", layers: layer.rows }];
+    case "TableRowLayer":
+      return [{ key: "cells", layers: layer.cells }];
+    case "TableCellLayer":
+      return layer.content ? [{ key: "content", layers: [layer.content] }] : [];
+    case "ImageLayer":
+    case "TextLayer":
+    case "QrCodeLayer":
+      return [];
+    case "TableRowTemplate":
+      return [{ key: "cells", layers: layer.cells }];
+  }
+}
+function markedExpressionOf(layer) {
+  switch (layer.type) {
+    case "TextLayer":
+    case "ImageLayer":
+    case "QrCodeLayer":
+      return layer.expression;
+    default:
+      return null;
+  }
+}
+var EXPRESSION_PREFIX_PLACEHOLDER = "{{\u2026}}";
+function expressionPrefixFor(layer) {
+  const expression = markedExpressionOf(layer);
+  if (expression === null) return "";
+  const exprs = scanExpressionFragments(expression).parts.flatMap(
+    (part) => part.kind === "fragment" && part.expr !== "" ? [part.expr] : []
+  );
+  if (exprs.length === 0) return EXPRESSION_PREFIX_PLACEHOLDER;
+  return exprs.map((expr) => `{{${expr}}}`).join(" ");
+}
+function outlineWalk(layer, path, role, lockedPaths) {
+  const children = [];
+  for (const { key, layers } of childLists(layer)) {
+    for (let i = 0; i < layers.length; i += 1) {
+      const roleOfChild = key === "rows" ? "row" : key === "cells" ? "cell" : key === "template" ? "templateRow" : "content";
+      const childPath = key === "content" ? [...path, "content"] : key === "template" ? [...path, "template"] : [...path, key, i];
+      children.push(outlineWalk(layers[i], childPath, roleOfChild, lockedPaths));
+    }
+  }
+  return {
+    type: layer.type,
+    path,
+    role,
+    name: layer.name,
+    visible: layer.visible,
+    locked: isLockedPath(path, lockedPaths),
+    expressionPrefix: expressionPrefixFor(layer),
+    ...layer.type === "TableLayer" ? { templated: layer.template !== null } : null,
+    children
+  };
+}
+function buildLayerOutline(doc, lockedPaths = []) {
+  const roots = [];
+  for (let i = doc.layers.length - 1; i >= 0; i -= 1) {
+    roots.push(outlineWalk(doc.layers[i], ["layers", i], "root", lockedPaths));
+  }
+  return roots;
+}
+function createDefaultLayer(type) {
+  const base = {
+    // name/visible 缺省态（layer-panel-ux 工单 01）：未命名 + 可见，wire 键省略
+    name: "",
+    visible: true,
+    priority: 0,
+    shape: {
+      width: 0,
+      height: 0,
+      autoWidth: false,
+      autoHeight: false,
+      lineHeight: 1.2,
+      padding: { top: 0, bottom: 0, left: 0, right: 0 },
+      border: { top: null, bottom: null, left: null, right: null },
+      backgroundColor: null
+    },
+    align: { horizontal: "left", vertical: "top" },
+    position: { anchor: "top-left", x: 0, y: 0 }
+  };
+  switch (type) {
+    case "TextLayer":
+      return {
+        ...base,
+        type,
+        shape: { ...base.shape, width: 200, height: 60 },
+        text: "\u6587\u672C",
+        expression: null,
+        font: "",
+        fontSize: 24,
+        fontColor: "#111827",
+        angle: 0,
+        autowrap: false
+      };
+    case "ImageLayer":
+      return { ...base, type, shape: { ...base.shape, width: 200, height: 150 }, src: null, expression: null };
+    case "QrCodeLayer":
+      return { ...base, type, shape: { ...base.shape, width: 120, height: 120 }, value: "canvas-web", expression: null };
+    case "TableLayer":
+      return { ...base, type, shape: { ...base.shape, width: 400, height: 120 }, template: null, rowsPath: "", rows: [] };
+    case "TableRowLayer":
+      return { ...base, type, shape: { ...base.shape, width: 400, height: 60 }, cells: [] };
+    case "TableRowTemplate":
+      return { ...base, type, shape: { ...base.shape, width: 400, height: 60 }, cells: [] };
+    case "TableCellLayer":
+      return { ...base, type, shape: { ...base.shape, width: 200, height: 60 }, content: null };
+  }
+}
+function createTemplateTable(options) {
+  const table = createDefaultLayer("TableLayer");
+  const templateBase = createDefaultLayer("TableRowTemplate");
+  const cellBase = createDefaultLayer("TableCellLayer");
+  const contentBase = createDefaultLayer("TextLayer");
+  const cell = {
+    ...cellBase,
+    shape: { ...cellBase.shape, width: table.shape.width },
+    content: { ...contentBase, shape: { ...contentBase.shape, width: table.shape.width, autoWidth: false } }
+  };
+  const template = {
+    ...templateBase,
+    shape: { ...templateBase.shape, width: table.shape.width, autoWidth: false, autoHeight: true, height: 0 },
+    cells: [cell]
+  };
+  return { ...table, template, rows: [], rowsPath: options.rowsPath };
+}
+function moveGuard(n, from, to) {
+  if (!Number.isSafeInteger(from) || !Number.isSafeInteger(to)) return null;
+  if (from < 0 || from >= n || to < 0 || to > n) return null;
+  if (to === from || to === from + 1) return null;
+  return to <= from ? to : to - 1;
+}
+function moveRootLayerInDraft(draft, fromPanel, toPanel) {
+  const layers = draft.layers;
+  const n = layers.length;
+  const reduced = moveGuard(n, fromPanel, toPanel);
+  if (reduced === null) return null;
+  const arrFrom = n - 1 - fromPanel;
+  const arrTo = n - 1 - reduced;
+  const [movedRaw] = layers.splice(arrFrom, 1);
+  const moved = movedRaw;
+  layers.splice(arrTo, 0, moved);
+  const below = arrTo > 0 ? layers[arrTo - 1].priority : null;
+  const above = arrTo < n - 1 ? layers[arrTo + 1].priority : null;
+  const priority = midpointPriority(below, above);
+  if (priority !== null) {
+    moved.priority = priority;
+  } else {
+    normalizeRootPriorities(layers);
+  }
+  return { from: arrFrom, to: arrTo };
+}
+function midpointPriority(below, above) {
+  if (below !== null && above !== null) {
+    return below - above >= 2 ? Math.floor((below + above) / 2) : null;
+  }
+  if (below !== null) return below - 1;
+  return above === null ? null : above + 1;
+}
+var ROOT_PRIORITY_GAP = 1024;
+function normalizeRootPriorities(layers) {
+  for (let i = 0; i < layers.length; i += 1) {
+    layers[i].priority = (layers.length - 1 - i) * ROOT_PRIORITY_GAP;
+  }
+}
+function moveTableRowInDraft(draft, tablePath, fromRow, toRow) {
+  const table = resolveLayer(draft, tablePath);
+  if (!table || table.type !== "TableLayer") return null;
+  const rows = table.rows;
+  const reduced = moveGuard(rows.length, fromRow, toRow);
+  if (reduced === null) return null;
+  const [moved] = rows.splice(fromRow, 1);
+  rows.splice(reduced, 0, moved);
+  return { from: fromRow, to: reduced };
+}
+function addRootLayerInDraft(draft, type) {
+  return insertRootLayerInDraft(draft, createDefaultLayer(type));
+}
+function insertRootLayerInDraft(draft, layer) {
+  let min = Number.POSITIVE_INFINITY;
+  for (const existing of draft.layers) min = Math.min(min, existing.priority);
+  layer.priority = Number.isFinite(min) ? min - 1 : 0;
+  draft.layers.push(layer);
+  return draft.layers.length - 1;
+}
+function insertRootLayerAdjacentInDraft(draft, layer, source) {
+  const rootIndex = typeof source === "number" ? source : source[1];
+  if (typeof rootIndex !== "number" || !Number.isSafeInteger(rootIndex)) return null;
+  const layers = draft.layers;
+  if (rootIndex < 0 || rootIndex >= layers.length) return null;
+  const sourcePriority = layers[rootIndex].priority;
+  const above = rootIndex + 1 < layers.length ? layers[rootIndex + 1].priority : null;
+  layers.splice(rootIndex + 1, 0, layer);
+  const priority = midpointPriority(sourcePriority, above);
+  if (priority !== null) {
+    layer.priority = priority;
+  } else {
+    normalizeRootPriorities(layers);
+  }
+  return rootIndex + 1;
+}
+function deleteLayerInDraft(draft, path) {
+  if (!isLayerPath(path)) return null;
+  if (path[path.length - 1] === "content") {
+    const cell = resolveLayer(draft, path.slice(0, -1));
+    if (!cell || cell.type !== "TableCellLayer" || cell.content === null) return null;
+    cell.content = null;
+    return { kind: "content", path };
+  }
+  if (path.length === 2) {
+    const index2 = path[1];
+    const layers = draft.layers;
+    if (typeof index2 !== "number" || index2 >= layers.length) return null;
+    layers.splice(index2, 1);
+    return { kind: "list", containerPath: [], key: "layers", index: index2 };
+  }
+  const index = path[path.length - 1];
+  const key = path[path.length - 2];
+  if (typeof index !== "number" || key !== "rows" && key !== "cells") return null;
+  if (key === "rows") {
+    const table = resolveLayer(draft, path.slice(0, -2));
+    if (!table || table.type !== "TableLayer" || index >= table.rows.length) return null;
+    table.rows.splice(index, 1);
+    return { kind: "list", containerPath: path.slice(0, -2), key: "rows", index };
+  }
+  const row = resolveLayer(draft, path.slice(0, -2));
+  if (!row || row.type !== "TableRowLayer" && row.type !== "TableRowTemplate" || index >= row.cells.length) {
+    return null;
+  }
+  ;
+  row.cells.splice(index, 1);
+  return { kind: "list", containerPath: path.slice(0, -2), key: "cells", index };
+}
+
+// src/editing/tableEditing.ts
+import { layerHeight, lineHeightPx, textLines } from "@hankchen/canvas";
+function resolveDraft(root, path) {
+  return resolveLayer(root, path);
+}
+function normZero(value) {
+  return value === 0 ? 0 : value;
+}
+function contentDynamicHeight(content, policies) {
+  if (content.type === "TextLayer") {
+    const padHeight = normZero(Math.trunc(content.shape.padding.top + content.shape.padding.bottom));
+    if (content.autowrap) {
+      return lineHeightPx(content) * textLines(content, policies).length + padHeight;
+    }
+    return content.text === "" ? padHeight : lineHeightPx(content) + padHeight;
+  }
+  return layerHeight(content, policies);
+}
+function syncRowWidthInDraft(row, tableWidth) {
+  row.shape.width = tableWidth;
+  row.shape.autoWidth = false;
+}
+function syncTemplateContentWidthInDraft(content, cell) {
+  content.shape.width = cell.shape.width;
+  content.shape.autoWidth = false;
+}
+function growRowToCellInDraft(row, cellHeight) {
+  if (row.shape.height < cellHeight) {
+    row.shape.height = cellHeight;
+    row.shape.autoHeight = false;
+  }
+}
+function syncContentIntoCellInDraft(content, cell, policies) {
+  content.shape.width = cell.shape.width;
+  content.shape.autoWidth = false;
+  if (cell.shape.autoHeight) {
+    cell.shape.height = contentDynamicHeight(content, policies);
+    cell.shape.autoHeight = false;
+  } else {
+    content.shape.height = cell.shape.height;
+    content.shape.autoHeight = false;
+  }
+}
+function maxCellHeight(row, policies) {
+  let max = 0;
+  for (const cell of row.cells) {
+    const height = layerHeight(cell, policies);
+    if (height > max) max = height;
+  }
+  return max;
+}
+function growRowOfCellInDraft(cellPath, cellHeight, root) {
+  const row = resolveDraft(root, cellPath.slice(0, -2));
+  if (row && row.type === "TableRowLayer") growRowToCellInDraft(row, cellHeight);
+}
+function buildDefaultCellIntoRowInDraft(row, fallbackWidth) {
+  const cells = row.cells;
+  const cell = createDefaultLayer("TableCellLayer");
+  cell.shape.width = cells.length > 0 ? cells[cells.length - 1].shape.width : fallbackWidth;
+  const content = createDefaultLayer("TextLayer");
+  syncContentIntoCellInDraft(content, cell);
+  cell.content = content;
+  growRowToCellInDraft(row, cell.shape.height);
+  return cell;
+}
+function addTableRowInDraft(draft, tablePath) {
+  const table = resolveDraft(draft, tablePath);
+  if (!table || table.type !== "TableLayer") return null;
+  if (table.template !== null) return null;
+  const rows = table.rows;
+  const row = createDefaultLayer("TableRowLayer");
+  syncRowWidthInDraft(row, table.shape.width);
+  const cell = buildDefaultCellIntoRowInDraft(row, row.shape.width);
+  row.cells = [cell];
+  rows.push(row);
+  return rows.length - 1;
+}
+function addTableCellInDraft(draft, rowPath) {
+  const row = resolveDraft(draft, rowPath);
+  if (!row || row.type !== "TableRowLayer") return null;
+  const cells = row.cells;
+  const cell = buildDefaultCellIntoRowInDraft(row, row.shape.width);
+  cells.push(cell);
+  return cells.length - 1;
+}
+function addTemplateCellInDraft(draft, tablePath) {
+  const table = resolveDraft(draft, tablePath);
+  if (!table || table.type !== "TableLayer" || table.template === null) return null;
+  const template = table.template;
+  const cells = template.cells;
+  const cell = createDefaultLayer("TableCellLayer");
+  cell.shape.width = cells.length > 0 ? cells[cells.length - 1].shape.width : template.shape.width;
+  const content = createDefaultLayer("TextLayer");
+  syncTemplateContentWidthInDraft(content, cell);
+  cell.content = content;
+  cells.push(cell);
+  return cells.length - 1;
+}
+function convertTableToTemplateInDraft(draft, tablePath, rowsPath) {
+  const table = resolveDraft(draft, tablePath);
+  if (!table || table.type !== "TableLayer" || table.template !== null) return null;
+  if (rowsPath === "") return null;
+  const rows = table.rows;
+  const last = rows[rows.length - 1];
+  if (last === void 0 || last.cells.length === 0) return null;
+  const template = JSON.parse(JSON.stringify(last));
+  template.type = "TableRowTemplate";
+  syncRowWidthInDraft(template, table.shape.width);
+  table.rows = [];
+  table.template = template;
+  table.rowsPath = rowsPath;
+  return true;
+}
+function convertTableToRowsInDraft(draft, tablePath, policies) {
+  const table = resolveDraft(draft, tablePath);
+  if (!table || table.type !== "TableLayer" || table.template === null) return null;
+  const row = JSON.parse(JSON.stringify(table.template));
+  row.type = "TableRowLayer";
+  syncRowWidthInDraft(row, table.shape.width);
+  for (const cell of row.cells) {
+    if (cell.content !== null) {
+      if (cell.shape.autoHeight) {
+        cell.shape.height = contentDynamicHeight(cell.content, policies);
+        cell.shape.autoHeight = false;
+      }
+      syncContentIntoCellInDraft(cell.content, cell, policies);
+    } else if (cell.shape.autoHeight) {
+      cell.shape.height = 0;
+    }
+  }
+  if (row.shape.autoHeight) row.shape.height = 0;
+  growRowToCellInDraft(row, maxCellHeight(row, policies));
+  table.template = null;
+  table.rowsPath = "";
+  table.rows = [row];
+  return true;
+}
+function moveTableCellInDraft(draft, rowPath, fromCell, toCell) {
+  const row = resolveDraft(draft, rowPath);
+  if (!row || row.type !== "TableRowLayer" && row.type !== "TableRowTemplate") return null;
+  const cells = row.cells;
+  const reduced = moveGuard(cells.length, fromCell, toCell);
+  if (reduced === null) return null;
+  const [moved] = cells.splice(fromCell, 1);
+  cells.splice(reduced, 0, moved);
+  return { from: fromCell, to: reduced };
+}
+function moveTableRowToTableInDraft(draft, rowPath, targetTablePath, toIndex) {
+  const sourceTablePath = rowPath.slice(0, -2);
+  if (pathsEqual(sourceTablePath, targetTablePath)) return null;
+  const from = rowPath[rowPath.length - 1];
+  if (typeof from !== "number") return null;
+  const sourceTable = resolveDraft(draft, sourceTablePath);
+  const targetTable = resolveDraft(draft, targetTablePath);
+  if (!sourceTable || !targetTable || sourceTable.type !== "TableLayer" || targetTable.type !== "TableLayer") {
+    return null;
+  }
+  if (targetTable.template !== null) return null;
+  if (!Number.isSafeInteger(toIndex) || toIndex < 0 || toIndex > targetTable.rows.length) return null;
+  const sourceRows = sourceTable.rows;
+  if (from >= sourceRows.length) return null;
+  const [movedRaw] = sourceRows.splice(from, 1);
+  const moved = movedRaw;
+  syncRowWidthInDraft(moved, targetTable.shape.width);
+  const targetRows = targetTable.rows;
+  const finalTo = Math.min(toIndex, targetRows.length);
+  targetRows.splice(finalTo, 0, moved);
+  return {
+    fromPath: rowPath,
+    toPath: [...targetTablePath, "rows", finalTo],
+    source: { containerPath: sourceTablePath, key: "rows", from, to: from },
+    // 目标容器是纯插入：remap 的 from 取插入前长度（该长度不受源删除影响）
+    target: { containerPath: targetTablePath, key: "rows", from: targetRows.length - 1, to: finalTo }
+  };
+}
+function moveTableCellToRowInDraft(draft, cellPath, targetRowPath, toIndex, policies) {
+  const sourceRowPath = cellPath.slice(0, -2);
+  if (pathsEqual(sourceRowPath, targetRowPath)) return null;
+  const from = cellPath[cellPath.length - 1];
+  if (typeof from !== "number") return null;
+  const sourceRow = resolveDraft(draft, sourceRowPath);
+  const targetRow = resolveDraft(draft, targetRowPath);
+  if (!sourceRow || !targetRow || sourceRow.type !== "TableRowLayer" || targetRow.type !== "TableRowLayer") {
+    return null;
+  }
+  if (!Number.isSafeInteger(toIndex) || toIndex < 0 || toIndex > targetRow.cells.length) return null;
+  const sourceCells = sourceRow.cells;
+  if (from >= sourceCells.length) return null;
+  const [movedRaw] = sourceCells.splice(from, 1);
+  const moved = movedRaw;
+  growRowToCellInDraft(targetRow, moved.shape.height);
+  if (moved.content !== null) {
+    syncContentIntoCellInDraft(moved.content, moved, policies);
+  }
+  const targetCells = targetRow.cells;
+  const finalTo = Math.min(toIndex, targetCells.length);
+  targetCells.splice(finalTo, 0, moved);
+  return {
+    fromPath: cellPath,
+    toPath: [...targetRowPath, "cells", finalTo],
+    source: { containerPath: sourceRowPath, key: "cells", from, to: from },
+    target: { containerPath: targetRowPath, key: "cells", from: targetCells.length - 1, to: finalTo }
+  };
+}
+function setCellAutoHeightInDraft(draft, cellPath, on, policies) {
+  const cell = resolveDraft(draft, cellPath);
+  if (!cell || cell.type !== "TableCellLayer") return false;
+  if (on && cell.content !== null) {
+    cell.shape.height = contentDynamicHeight(cell.content, policies);
+    cell.shape.autoHeight = false;
+    syncContentIntoCellInDraft(cell.content, cell, policies);
+  } else if (on) {
+    cell.shape.height = 0;
+    cell.shape.autoHeight = true;
+  } else {
+    cell.shape.autoHeight = false;
+  }
+  growRowOfCellInDraft(cellPath, cell.shape.height, draft);
+  return true;
+}
+function canonicalizeTableSyncInDraft(draft, path, key, policies) {
+  if (path[path.length - 1] === "content") {
+    const cellPath = path.slice(0, -1);
+    const cell = resolveDraft(draft, cellPath);
+    if (!cell || cell.type !== "TableCellLayer" || cell.content === null) return;
+    if (isTemplateSubtreePath(path)) {
+      syncTemplateContentWidthInDraft(cell.content, cell);
+      return;
+    }
+    syncContentIntoCellInDraft(cell.content, cell, policies);
+    growRowOfCellInDraft(cellPath, cell.shape.height, draft);
+    return;
+  }
+  const containerKey = path[path.length - 2];
+  if (containerKey === "rows") {
+    const row = resolveDraft(draft, path);
+    if (!row || row.type !== "TableRowLayer") return;
+    const table = resolveDraft(draft, path.slice(0, -2));
+    if (table && table.type === "TableLayer") syncRowWidthInDraft(row, table.shape.width);
+    if (row.shape.autoHeight) row.shape.height = 0;
+    growRowToCellInDraft(row, maxCellHeight(row, policies));
+    return;
+  }
+  if (containerKey === "cells") {
+    const cell = resolveDraft(draft, path);
+    if (!cell || cell.type !== "TableCellLayer") return;
+    if (isTemplateSubtreePath(path)) {
+      if (cell.content !== null) syncTemplateContentWidthInDraft(cell.content, cell);
+      return;
+    }
+    if (cell.content !== null) syncContentIntoCellInDraft(cell.content, cell, policies);
+    else if (cell.shape.autoHeight) cell.shape.height = 0;
+    growRowOfCellInDraft(path, cell.shape.height, draft);
+    return;
+  }
+  if (path[0] === "layers" && typeof path[1] === "number" && key[0] === "shape" && (key[1] === "width" || key[1] === "autoWidth")) {
+    const layer = draft.layers[path[1]];
+    if (!layer || layer.type !== "TableLayer") return;
+    if (layer.shape.autoHeight) layer.shape.height = 0;
+    if (layer.template !== null) syncRowWidthInDraft(layer.template, layer.shape.width);
+    for (const row of layer.rows) syncRowWidthInDraft(row, layer.shape.width);
+  }
+}
+
+// src/session/store.ts
+import { applyPatches, enablePatches, produceWithPatches, setAutoFreeze } from "immer";
+enablePatches();
+setAutoFreeze(false);
+var initialFindSession = () => ({ open: false, query: "", replacement: "", cursor: 0 });
+var MAX_HISTORY_STEPS = 100;
+function snapAxesEqual(a, b) {
+  if (a === b) return true;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i += 1) {
+    const x = a[i];
+    const y = b[i];
+    if (x.orientation !== y.orientation || x.position !== y.position || x.source !== y.source) return false;
+  }
+  return true;
+}
+function lockedPathsEqual(a, b) {
+  if (a === b) return true;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i += 1) {
+    if (!pathsEqual(a[i], b[i])) return false;
+  }
+  return true;
+}
+function resourceStatusesEqual(a, b) {
+  if (a === b) return true;
+  const aKeys = Object.keys(a);
+  if (aKeys.length !== Object.keys(b).length) return false;
+  for (const key of aKeys) {
+    if (a[key] !== b[key]) return false;
+  }
+  return true;
+}
+var EditorStore = class {
+  docValue = null;
+  uiValue = {
+    viewport: { x: 0, y: 0, zoom: 1 },
+    selection: null,
+    hovered: null,
+    drag: null,
+    resize: null,
+    armedCreate: null,
+    create: null,
+    editing: null,
+    renaming: null,
+    anchorExpanded: false,
+    dataSourceSchema: null,
+    guides: [],
+    rulersVisible: true,
+    snapAxes: [],
+    lockedPaths: [],
+    find: initialFindSession(),
+    resourceStatuses: {}
+  };
+  /** undo 栈：已提交步，栈尾最新 */
+  undoSteps = [];
+  /** redo 栈：被撤销步，栈尾最近一次撤销；transact 落新事务时整体改写 */
+  redoSteps = [];
+  listeners = /* @__PURE__ */ new Set();
+  get doc() {
+    return this.docValue;
+  }
+  get ui() {
+    return this.uiValue;
+  }
+  /** 已提交步（undo 栈，栈尾最新）；可撤销性走 canUndo */
+  get history() {
+    return this.undoSteps;
+  }
+  get canUndo() {
+    return this.undoSteps.length > 0;
+  }
+  get canRedo() {
+    return this.redoSteps.length > 0;
+  }
+  /** 打开/替换文档：ui 选择/编辑/重命名会话与双向历史一并重置（新文档不继承旧路径/旧事务）；
+   *  参考线/锁定集合/查找会话/建层武装与画拉会话随当次会话清空（对位轴/文档内容防护/
+   *  查询词/待命层型不跨文档），标尺显隐作为偏好保留 */
+  openDocument(canvas) {
+    this.docValue = canvas;
+    this.undoSteps = [];
+    this.redoSteps = [];
+    this.uiValue = {
+      ...this.uiValue,
+      selection: null,
+      hovered: null,
+      drag: null,
+      resize: null,
+      armedCreate: null,
+      create: null,
+      editing: null,
+      renaming: null,
+      guides: [],
+      snapAxes: [],
+      lockedPaths: [],
+      find: initialFindSession(),
+      resourceStatuses: {}
+    };
+    this.notify({ scope: "doc", patches: [], inversePatches: [] });
+  }
+  /**
+   * 文档事务唯一入口：produceWithPatches 求新树，无变化即空转（不进历史不通知）；
+   * 有变化则浅替换 doc、按 mergeKey 合并或追加 undo 栈（超限丢最旧步）、
+   * 改写 redo 栈（undo 后的新事务弃用被撤销分支，Figma 语义）、广播 patch 组。
+   */
+  transact(recipe, options = {}) {
+    if (this.docValue === null) return;
+    const [next, patches, inversePatches] = produceWithPatches(this.docValue, recipe);
+    if (patches.length === 0) return;
+    this.redoSteps = [];
+    const mergeKey = options.mergeKey ?? null;
+    const last = this.undoSteps[this.undoSteps.length - 1];
+    if (mergeKey !== null && last !== void 0 && last.mergeKey === mergeKey) {
+      this.undoSteps[this.undoSteps.length - 1] = {
+        mergeKey,
+        patches: [...last.patches, ...patches],
+        inversePatches: [...inversePatches, ...last.inversePatches]
+      };
+    } else {
+      this.undoSteps.push({ mergeKey, patches, inversePatches });
+      if (this.undoSteps.length > MAX_HISTORY_STEPS) this.undoSteps.shift();
+    }
+    this.docValue = next;
+    this.notify({ scope: "doc", patches, inversePatches });
+  }
+  /** 撤销最近一步：逆向 patch 回放，该步整体移入 redo 栈 */
+  undo() {
+    const step = this.undoSteps[this.undoSteps.length - 1];
+    if (step === void 0 || this.docValue === null) return;
+    this.undoSteps.pop();
+    this.redoSteps.push(step);
+    this.closeMerge();
+    this.docValue = applyPatches(this.docValue, step.inversePatches);
+    this.notify({ scope: "doc", patches: step.inversePatches, inversePatches: step.patches });
+  }
+  /** 重做最近一次撤销：正向 patch 回放，该步移回 undo 栈 */
+  redo() {
+    const step = this.redoSteps[this.redoSteps.length - 1];
+    if (step === void 0 || this.docValue === null) return;
+    this.redoSteps.pop();
+    this.undoSteps.push(step);
+    this.closeMerge();
+    this.docValue = applyPatches(this.docValue, step.patches);
+    this.notify({ scope: "doc", patches: step.patches, inversePatches: step.inversePatches });
+  }
+  /**
+   * 闭合拖动/滑杆事务（pointerup、blur 提交，undo/redo 导航同理）：最后一步的
+   * mergeKey 清空后，同键的后续事务不再并入。给键名时只在键匹配时闭合
+   * （防误伤其它键的开放步）。
+   */
+  closeMerge(mergeKey) {
+    const last = this.undoSteps[this.undoSteps.length - 1];
+    if (last === void 0 || last.mergeKey === null) return;
+    if (mergeKey !== void 0 && last.mergeKey !== mergeKey) return;
+    this.undoSteps[this.undoSteps.length - 1] = { ...last, mergeKey: null };
+  }
+  /** 视口更新：ui 分支整体替换，旧切片引用保持原值（computed 引用短路依赖此语义） */
+  setViewport(viewport) {
+    this.uiValue = { ...this.uiValue, viewport };
+    this.notify({ scope: "ui", branch: "viewport" });
+  }
+  /** 选中：值等短路（重复点选同一层不重绘） */
+  setSelection(path) {
+    this.setUiPath("selection", path);
+  }
+  /** 悬停：值等短路（指针在同一层内移动不重绘覆盖层） */
+  setHovered(path) {
+    this.setUiPath("hovered", path);
+  }
+  /** 路径类 ui 切片的共同形状：值等短路 → 整体替换 → 分支通知 */
+  setUiPath(branch, path) {
+    if (pathsEqual(this.uiValue[branch], path)) return;
+    this.uiValue = { ...this.uiValue, [branch]: path };
+    this.notify({ scope: "ui", branch });
+  }
+  /** 拖动会话开始/结束（null）；会话对象住 ui 分支，文档只收位置事务 */
+  setDrag(gesture) {
+    this.uiValue = { ...this.uiValue, drag: gesture };
+    this.notify({ scope: "ui", branch: "drag" });
+  }
+  /** 缩放会话开始/结束（null，工单 07）；会话对象住 ui 分支，文档只收缩放事务 */
+  setResize(gesture) {
+    this.uiValue = { ...this.uiValue, resize: gesture };
+    this.notify({ scope: "ui", branch: "resize" });
+  }
+  /** 建层武装置/解除（null，drag-create 工单 01）；标量值等短路（重复武装同型不通知） */
+  setArmedCreate(type) {
+    if (this.uiValue.armedCreate === type) return;
+    this.uiValue = { ...this.uiValue, armedCreate: type };
+    this.notify({ scope: "ui", branch: "armedCreate" });
+  }
+  /** 画拉橡皮筋会话开始/更新/结束（null）；会话对象住 ui 分支，落库在 endCreate 单事务 */
+  setCreate(gesture) {
+    this.uiValue = { ...this.uiValue, create: gesture };
+    this.notify({ scope: "ui", branch: "create" });
+  }
+  /** 文本编辑会话开始/结束（null）；会话住 ui 分支，文本经 commitTextEdit 一次性落文档 */
+  setEditing(session) {
+    this.uiValue = { ...this.uiValue, editing: session };
+    this.notify({ scope: "ui", branch: "editing" });
+  }
+  /** 重命名会话开始/结束（null）；路径类切片，值等短路（重复 begin 同一路径不重绘） */
+  setRenaming(path) {
+    this.setUiPath("renaming", path);
+  }
+  /** 锚点折叠区开合：布尔值等短路（重复点击同一态不重绘） */
+  setAnchorExpanded(open) {
+    if (this.uiValue.anchorExpanded === open) return;
+    this.uiValue = { ...this.uiValue, anchorExpanded: open };
+    this.notify({ scope: "ui", branch: "anchorExpanded" });
+  }
+  /**
+   * 数据源 schema 声明替换（归一产物或降级 null，校验收口在注入缝不在这里）：
+   * 同引用短路（重复注入同一归一产物不惊动订阅方）；仅 ui 通知，不参与重绘
+   * 脏标（onStoreChange 对该分支短路）。
+   */
+  setDataSourceSchema(schema) {
+    if (this.uiValue.dataSourceSchema === schema) return;
+    this.uiValue = { ...this.uiValue, dataSourceSchema: schema };
+    this.notify({ scope: "ui", branch: "dataSourceSchema" });
+  }
+  /** 参考线列表替换（增删动作在会话门面收口）；仅 ui 通知，不参与历史 */
+  setGuides(guides) {
+    this.uiValue = { ...this.uiValue, guides };
+    this.notify({ scope: "ui", branch: "guides" });
+  }
+  /** 标尺显隐：布尔值等短路（重复置同态不重绘） */
+  setRulersVisible(visible) {
+    if (this.uiValue.rulersVisible === visible) return;
+    this.uiValue = { ...this.uiValue, rulersVisible: visible };
+    this.notify({ scope: "ui", branch: "rulersVisible" });
+  }
+  /** 当次命中吸附轴替换（dragTo 副产物 / endDrag 清空）；内容等短路（未命中步不重绘） */
+  setSnapAxes(axes) {
+    if (snapAxesEqual(this.uiValue.snapAxes, axes)) return;
+    this.uiValue = { ...this.uiValue, snapAxes: axes };
+    this.notify({ scope: "ui", branch: "snapAxes" });
+  }
+  /** 锁定集合替换（toggleLayerLock 收口，翻转逻辑在会话门面）；内容等短路（集合未变不重绘） */
+  setLockedPaths(paths) {
+    if (lockedPathsEqual(this.uiValue.lockedPaths, paths)) return;
+    this.uiValue = { ...this.uiValue, lockedPaths: paths };
+    this.notify({ scope: "ui", branch: "lockedPaths" });
+  }
+  /**
+   * 查找会话替换（beginFind/closeFind/输入写入经会话门面收口到这里）；内容等
+   * 短路（重复开合/同词写入不通知）。仅 ui 通知，不参与历史。
+   */
+  setFind(find) {
+    const current = this.uiValue.find;
+    if (current.open === find.open && current.query === find.query && current.replacement === find.replacement && current.cursor === find.cursor) {
+      return;
+    }
+    this.uiValue = { ...this.uiValue, find };
+    this.notify({ scope: "ui", branch: "find" });
+  }
+  /**
+   * 资源物化状态替换（placeholder-padding-hint 工单 02）：宿主从渲染端物化状态机
+   * 桥接注入的唯一写入口，整体替换语义；内容等短路（同态快照不惊动订阅方，
+   * 桥接的高频整体替换零噪声）。仅 ui 通知，不参与历史、不写 graph（红线 3 延伸）。
+   */
+  setResourceStatuses(statuses) {
+    if (resourceStatusesEqual(this.uiValue.resourceStatuses, statuses)) return;
+    this.uiValue = { ...this.uiValue, resourceStatuses: statuses };
+    this.notify({ scope: "ui", branch: "resourceStatuses" });
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  notify(change) {
+    for (const listener of this.listeners) listener(change);
+  }
+};
+
+// src/session/shortcuts.ts
+var ARM_CREATE_LAYER_TYPES = {
+  armCreateText: "TextLayer",
+  armCreateTable: "TableLayer",
+  armCreateQrCode: "QrCodeLayer",
+  armCreateImage: "ImageLayer"
+};
+var DEFAULT_EDITOR_SHORTCUTS = [
+  { combo: { key: "z", mod: true, shift: false }, action: "undo", label: "\u64A4\u9500", group: "history" },
+  { combo: { key: "z", mod: true, shift: true }, action: "redo", label: "\u91CD\u505A", group: "history" },
+  { combo: { key: "y", mod: true, shift: false }, action: "redo", label: "\u91CD\u505A", group: "history" },
+  { combo: { key: "c", mod: true, shift: false }, action: "copy", label: "\u590D\u5236", group: "clipboard" },
+  { combo: { key: "v", mod: true, shift: false }, action: "paste", label: "\u7C98\u8D34", group: "clipboard" },
+  { combo: { key: "d", mod: true, shift: false }, action: "duplicate", label: "\u521B\u5EFA\u526F\u672C", group: "clipboard" },
+  // 样式粘贴（canvas-web-style-paste 工单 01）：⌥⌘C/⌥⌘V 复制/粘贴样式（Figma/
+  // Sketch 同构，行业同键位）。⌥ 修饰下 mac event.key 是变体字符（US 布局
+  // ⌥C = 'ç'），key 匹配不可靠——按物理键 code 匹配（kbd-nav 括号条目同门）；
+  // alt 精确匹配使 ⌘C（无 ⌥）不失配到样式条目、⌥⌘C 也不吞 ⌘C（undo/redo
+  // 只差 shift 的先例扩展到 alt）。浏览器 DevTools 占 ⌥⌘C 时右键菜单保底
+  {
+    combo: { key: "c", mod: true, shift: false, alt: true, code: "KeyC" },
+    action: "copyStyle",
+    label: "\u590D\u5236\u6837\u5F0F",
+    group: "clipboard"
+  },
+  {
+    combo: { key: "v", mod: true, shift: false, alt: true, code: "KeyV" },
+    action: "pasteStyle",
+    label: "\u7C98\u8D34\u6837\u5F0F",
+    group: "clipboard"
+  },
+  { combo: { key: "delete", mod: false, shift: false }, action: "delete", label: "\u5220\u9664\u56FE\u5C42", group: "layer" },
+  { combo: { key: "backspace", mod: false, shift: false }, action: "delete", label: "\u5220\u9664\u56FE\u5C42", group: "layer" },
+  { combo: { key: "f2", mod: false, shift: false }, action: "rename", label: "\u91CD\u547D\u540D\u56FE\u5C42", group: "layer" },
+  // 查找替换（canvas-web-find-replace 工单 01，CONTEXT「查找替换」词条）：⌘F
+  // 呼出画布顶部浮动查找条（Canva 同构；浏览器页内查找可 preventDefault 拦截，
+  // ⌘D 抢书签先例）。mod+shift 精确匹配先例——⇧⌘F 变体不入表
+  {
+    combo: { key: "f", mod: true, shift: false },
+    action: "findReplace",
+    label: "\u67E5\u627E\u66FF\u6362",
+    group: "text"
+  },
+  // 标尺显隐（ruler-guides-snap 工单 01）：裸键 + shift（mod 变体不占用，
+  // 不抢浏览器刷新等既有语义）
+  { combo: { key: "r", mod: false, shift: true }, action: "toggleRulers", label: "\u6807\u5C3A\u663E\u9690", group: "view" },
+  // 锁定 ⇧⌘L / 显隐 ⇧⌘H（canvas-web-layer-lock 工单 02，显隐键位系 feature-status
+  // §一挂账补位）：行业趋同（Figma/Sketch 同款）；mod+shift 组合不抢浏览器
+  // ⌘L 地址栏、⌘H 历史页既有语义
+  { combo: { key: "l", mod: true, shift: true }, action: "toggleLayerLock", label: "\u9501\u5B9A/\u89E3\u9501\u56FE\u5C42", group: "layer" },
+  {
+    combo: { key: "h", mod: true, shift: true },
+    action: "toggleLayerVisibility",
+    label: "\u663E\u793A/\u9690\u85CF\u56FE\u5C42",
+    group: "layer"
+  },
+  // z 序四件套（kbd-nav 工单 01）：⌘]/⌘[ 前移/后移一格，⌥⌘]/⌥⌘[ 置顶/置底
+  // （Canva/Sketch 同构）；⌥ 变体字符下 key 不可靠，置顶/置底按物理键 code 匹配
+  { combo: { key: "]", mod: true, shift: false }, action: "bringForward", label: "\u524D\u79FB\u4E00\u5C42", group: "layer" },
+  { combo: { key: "[", mod: true, shift: false }, action: "sendBackward", label: "\u540E\u79FB\u4E00\u5C42", group: "layer" },
+  {
+    combo: { key: "]", mod: true, shift: false, alt: true, code: "BracketRight" },
+    action: "bringToFront",
+    label: "\u7F6E\u9876",
+    group: "layer"
+  },
+  {
+    combo: { key: "[", mod: true, shift: false, alt: true, code: "BracketLeft" },
+    action: "sendToBack",
+    label: "\u7F6E\u5E95",
+    group: "layer"
+  },
+  // 微调（kbd-nav 工单 02）：裸方向键 1px 基础步、⇧+方向键 10px 大步，方向 ×
+  // 步长独立 action id（shift 精确匹配先例所致，undo/redo 同款）；mod/alt 修饰
+  // 不入表（⌘←/→ 浏览器历史导航、⌥+方向既有语义不抢）
+  { combo: { key: "arrowup", mod: false, shift: false }, action: "nudgeUp", label: "\u5FAE\u8C03\u4E0A\u79FB", group: "layer" },
+  { combo: { key: "arrowdown", mod: false, shift: false }, action: "nudgeDown", label: "\u5FAE\u8C03\u4E0B\u79FB", group: "layer" },
+  { combo: { key: "arrowleft", mod: false, shift: false }, action: "nudgeLeft", label: "\u5FAE\u8C03\u5DE6\u79FB", group: "layer" },
+  { combo: { key: "arrowright", mod: false, shift: false }, action: "nudgeRight", label: "\u5FAE\u8C03\u53F3\u79FB", group: "layer" },
+  { combo: { key: "arrowup", mod: false, shift: true }, action: "nudgeUpCoarse", label: "\u5927\u6B65\u4E0A\u79FB", group: "layer" },
+  { combo: { key: "arrowdown", mod: false, shift: true }, action: "nudgeDownCoarse", label: "\u5927\u6B65\u4E0B\u79FB", group: "layer" },
+  {
+    combo: { key: "arrowleft", mod: false, shift: true },
+    action: "nudgeLeftCoarse",
+    label: "\u5927\u6B65\u5DE6\u79FB",
+    group: "layer"
+  },
+  {
+    combo: { key: "arrowright", mod: false, shift: true },
+    action: "nudgeRightCoarse",
+    label: "\u5927\u6B65\u53F3\u79FB",
+    group: "layer"
+  },
+  // 循环选层（kbd-nav 工单 03）：Tab 朝面板垫底方向、⇧Tab 反向（shift 精确
+  // 匹配先例——⇧Tab 不落裸 Tab 条目）；mod/alt 修饰不入表（⌘Tab/⌥Tab 浏览器
+  // 与系统既有语义不抢）。文本编辑/输入框中的 Tab 由让路规则天然放行原生焦点
+  // 移动，不劫持
+  { combo: { key: "tab", mod: false, shift: false }, action: "selectNextLayer", label: "\u5FAA\u73AF\u9009\u4E0B\u4E00\u5C42", group: "layer" },
+  { combo: { key: "tab", mod: false, shift: true }, action: "selectPrevLayer", label: "\u5FAA\u73AF\u9009\u4E0A\u4E00\u5C42", group: "layer" },
+  // 画拉建层武装四条目（canvas-web-drag-create 工单 03，CONTEXT「武装」词条）：
+  // T/G/Q/I 层型待命——下一次画布按下即开画拉，建层或 Esc 即解除（一次性待命，
+  // 无粘性工具）。按物理键 code 匹配（⇧1/⇧2 数字行同门先例）：非拉丁布局的
+  // key 是本地字符（西里尔布局 T 位产出 'т'），code 恒 KeyT 两边通吃；mod/shift/
+  // alt 精确匹配（⌘T 新标签、⇧T、⌥T 变体不入表）。文本编辑态/输入框焦点由让路
+  // 规则天然放行（编辑文本时 T 打字不武装）——绑定层 useShortcuts 桥对命中条目
+  // 直写状态栏瞬时提示，不经本表
+  { combo: { key: "t", mod: false, shift: false, code: "KeyT" }, action: "armCreateText", label: "\u753B\u62C9\u5EFA\u6587\u672C\u5C42", group: "layer" },
+  { combo: { key: "g", mod: false, shift: false, code: "KeyG" }, action: "armCreateTable", label: "\u753B\u62C9\u5EFA\u8868\u683C", group: "layer" },
+  { combo: { key: "q", mod: false, shift: false, code: "KeyQ" }, action: "armCreateQrCode", label: "\u753B\u62C9\u5EFA\u4E8C\u7EF4\u7801", group: "layer" },
+  { combo: { key: "i", mod: false, shift: false, code: "KeyI" }, action: "armCreateImage", label: "\u753B\u62C9\u5EFA\u56FE\u7247", group: "layer" },
+  // 缩放（kbd-nav 工单 01）：⌘0 复位 100%（视口中心为锚；浏览器吞键时的降级
+  // 预案 = Figma 纯 shift ⇧0/1/2，宿主注入亦可覆盖）；⇧1/⇧2 适应画布/选区，
+  // 数字行按 code 匹配（US 布局 ⇧1 的 key 是 '!'，法国布局是 '1'，code 恒
+  // Digit1 两边通吃）
+  { combo: { key: "0", mod: true, shift: false }, action: "zoomReset", label: "\u7F29\u653E\u590D\u4F4D 100%", group: "view" },
+  { combo: { key: "1", mod: false, shift: true, code: "Digit1" }, action: "fitToSurface", label: "\u9002\u5E94\u753B\u5E03", group: "view" },
+  {
+    combo: { key: "2", mod: false, shift: true, code: "Digit2" },
+    action: "fitToSelection",
+    label: "\u9002\u5E94\u9009\u533A",
+    group: "view"
+  },
+  // 帮助面板（kbd-nav 工单 04）：⌘/ 开合快捷键帮助。UI 面动作——对话态是 UI
+  // 关注点，绑定层桥（useShortcuts）拦截路由到 useShortcutsHelp 单例态，不经
+  // 内核 dispatcher、不进内核 store；注册表是键位唯一事实源，条目在列帮助面板
+  // 才渲染（group 'help' 系元数据扩展时预留的归组）
+  {
+    combo: { key: "/", mod: true, shift: false },
+    action: "helpShortcuts",
+    label: "\u5FEB\u6377\u952E\u5E2E\u52A9",
+    group: "help"
+  }
+];
+function classifyEditorShortcut(input, bindings = DEFAULT_EDITOR_SHORTCUTS) {
+  if (input.composing || input.editing || input.editableTarget) return null;
+  const key = input.key.toLowerCase();
+  const alt = input.alt ?? false;
+  for (const binding of bindings) {
+    const keyMatches = binding.combo.code !== void 0 ? binding.combo.code === input.code : binding.combo.key === key;
+    if (keyMatches && binding.combo.mod === input.mod && binding.combo.shift === input.shift && (binding.combo.alt ?? false) === alt) {
+      return binding.action;
+    }
+  }
+  return null;
+}
+
+// src/editing/fontCatalog.ts
+var FontCatalog = class {
+  builtin;
+  custom = [];
+  listeners = /* @__PURE__ */ new Set();
+  constructor(builtin = []) {
+    this.builtin = [...builtin];
+  }
+  /** 当前清单：内置在前（配置序），自定义追加在后（上传序） */
+  get entries() {
+    return [...this.builtin, ...this.custom];
+  }
+  /** 追加自定义条目；同引用去重（重复上传不产生重复项，首见条目胜出） */
+  addCustom(entry) {
+    if (this.entries.some((existing) => existing.ref === entry.ref)) return false;
+    this.custom = [...this.custom, entry];
+    this.notify();
+    return true;
+  }
+  /** 订阅清单变更（整体快照推送，绑定层的响应式 ref 据此联动）；返回退订函数 */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  notify() {
+    const entries = this.entries;
+    for (const listener of this.listeners) listener(entries);
+  }
+};
+
+// src/editing/upload.ts
+function uploadDisplayName(file) {
+  const base = file.name.replace(/\.[^.]+$/, "");
+  return base === "" ? file.name : base;
+}
+var UploadHandlerMissingError = class extends Error {
+  constructor() {
+    super("\u672A\u6CE8\u5165\u4E0A\u4F20\u5B9E\u73B0\uFF08uploadHandler\uFF09\uFF1A\u5BBF\u4E3B\u53EF\u5728\u521B\u5EFA EditorSession \u65F6\u63D0\u4F9B\u672C\u673A\u8D44\u6E90 \u2192 \u53EF\u7269\u5316\u5F15\u7528\u7684\u5B9E\u73B0");
+    this.name = "UploadHandlerMissingError";
+  }
+};
+
+// src/shared/specField.ts
+function readSpecField(target, key) {
+  let node = target;
+  for (let i = 0; i < key.length - 1; i += 1) {
+    if (node === null || typeof node !== "object") return void 0;
+    node = node[key[i]];
+  }
+  if (node === null || typeof node !== "object") return void 0;
+  return node[key[key.length - 1]];
+}
+function writeSpecField(target, key, value) {
+  if (target === null || typeof target !== "object") return false;
+  let node = target;
+  for (let i = 0; i < key.length - 1; i += 1) {
+    const next = node[key[i]];
+    if (next === null || typeof next !== "object") return false;
+    node = next;
+  }
+  ;
+  node[key[key.length - 1]] = value;
+  return true;
+}
+
+// src/editing/styleClipboard.ts
+var ALIGN_FAMILY = [
+  ["align", "horizontal"],
+  ["align", "vertical"]
+];
+var SKIN_FAMILY = [
+  ["shape", "backgroundColor"],
+  ["shape", "border"],
+  ["shape", "padding"]
+];
+var TEXT_FAMILY = [
+  ["font"],
+  ["fontSize"],
+  ["fontColor"],
+  ["autowrap"],
+  ["angle"],
+  ["shape", "lineHeight"]
+];
+var STYLE_FIELD_KEYS_BY_TYPE = {
+  TextLayer: [...ALIGN_FAMILY, ...SKIN_FAMILY, ...TEXT_FAMILY],
+  ImageLayer: [...ALIGN_FAMILY, ...SKIN_FAMILY],
+  QrCodeLayer: [...ALIGN_FAMILY, ...SKIN_FAMILY],
+  TableLayer: [...ALIGN_FAMILY, ...SKIN_FAMILY],
+  TableRowLayer: [...ALIGN_FAMILY, ...SKIN_FAMILY],
+  TableCellLayer: [...ALIGN_FAMILY, ...SKIN_FAMILY],
+  TableRowTemplate: []
+};
+var fieldId = (key) => key.join(".");
+function deepClone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function jsonEqual(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function captureStyleSnapshot(layer) {
+  const fields = STYLE_FIELD_KEYS_BY_TYPE[layer.type];
+  if (fields.length === 0) return null;
+  const values = {};
+  for (const key of fields) {
+    const value = readSpecField(layer, key);
+    if (value !== void 0) values[fieldId(key)] = deepClone(value);
+  }
+  return { sourceType: layer.type, values };
+}
+function applyStyleFieldsInDraft(layer, snapshot) {
+  const written = [];
+  for (const key of STYLE_FIELD_KEYS_BY_TYPE[layer.type]) {
+    const value = snapshot.values[fieldId(key)];
+    if (value === void 0) continue;
+    const current = readSpecField(layer, key);
+    if (jsonEqual(current, value)) continue;
+    if (writeSpecField(layer, key, deepClone(value))) written.push(key);
+  }
+  return written;
+}
+
+// src/session/editor.ts
+var DRAG_MERGE_KEY = "drag";
+var RESIZE_MERGE_KEY = "resize";
+var ALT_DRAG_DEAD_ZONE_SCREEN_PX = 4;
+var NUDGE_STEP_PX = 1;
+var NUDGE_COARSE_STEP_PX = 10;
+var nudgeMergeKey = (path) => `nudge:${path.join(":")}`;
+function clampFindCursor(cursor, count) {
+  if (count <= 0) return 0;
+  return Math.min(Math.max(cursor, 0), count - 1);
+}
+function hasValidExpressionFragment(template) {
+  return scanExpressionFragments(template).parts.some(
+    (part) => part.kind === "fragment" && part.error === null
+  );
+}
+function renormalizeAutoHeightInDraft(layer) {
+  if (layer.shape?.autoHeight === true) {
+    ;
+    layer.shape.height = 0;
+  }
+}
+var EditorSession = class {
+  store;
+  scheduleFrame;
+  zoomBounds;
+  fitMargin;
+  /**
+   * 生效的文本布局策略（构造注入值，缺省 undefined = 启发式对齐版）：公开只读，
+   * 供导出等旁路面复用同一注入值——导出与编辑画布的断行/盒高才不分叉（工单 13）。
+   */
+  textPolicies;
+  uploadHandler;
+  fontCatalogValue;
+  backend = null;
+  overlayPainter = null;
+  dpr = 1;
+  surfaceSize = { width: 0, height: 0 };
+  dirty = { content: false, overlay: false };
+  frameQueued = false;
+  cancelFrame = null;
+  unsubscribeStore;
+  /**
+   * 预览视图 memo（决策 2026-09）：模板态表格实例化一行预览行的文档衍生画布，
+   * 画布渲染/命中/导出消费，永不写回 graph（红线 3 延伸）。Canvas 不可变 +
+   * 结构共享，doc 引用相等即视图仍有效（与 skipContent 的引用比较同纪律）。
+   */
+  previewSource = null;
+  previewValue = null;
+  /**
+   * 会话级剪贴板（工单 14；alt-drag-paste 工单 02 收窄）：复制源的子树深拷贝
+   * 快照 + 复制时点绝对盒（粘贴落位基准，格内容的格内相对 position 据此换算
+   * 画布绝对落位）+ 源路径（粘贴时紧邻插入的解析凭据）。不跨会话、不碰 OS
+   * 剪贴板；openDocument 不清空——粘贴进另一份文档是合法用法（条目是与源树
+   * 断开引用的普通对象；他文档 sourcePath 必失配 → 粘贴退化置顶）。
+   */
+  clipboardEntry = null;
+  /**
+   * 样式剪贴板（canvas-web-style-paste 工单 01）：源类型 + 适用面逐字段值快照。
+   * 与图层剪贴板**分立互不覆盖**（⌘C 与 ⌥⌘C 并存）；不碰 OS 剪贴板、不进历史
+   * （剪贴板态不是文档态）；openDocument 不清空——跨文档粘贴样式合法（图层
+   * 剪贴板同门，快照是与源树断开引用的普通对象）。
+   */
+  styleClipboardEntry = null;
+  /** 参考线 id 自增序（会话内唯一即可，不持久化——参考线不写 graph） */
+  guideIdSeq = 0;
+  constructor(options) {
+    this.scheduleFrame = options.scheduleFrame;
+    this.zoomBounds = options.zoomBounds ?? DEFAULT_ZOOM_BOUNDS;
+    this.fitMargin = options.fitMargin ?? 0;
+    this.textPolicies = options.textPolicies;
+    this.uploadHandler = options.uploadHandler ?? null;
+    this.fontCatalogValue = new FontCatalog(options.fontCatalog);
+    this.store = new EditorStore();
+    this.unsubscribeStore = this.store.subscribe((change) => this.onStoreChange(change));
+  }
+  // ---- 组装与呈现参数（DOM 侧由绑定层调用） ----
+  attachContentBackend(backend) {
+    this.backend = backend;
+    this.invalidate("content");
+  }
+  setOverlayPainter(painter) {
+    this.overlayPainter = painter;
+    this.invalidate("overlay");
+  }
+  /** 解绑绘制面（surface 卸载时）；挂起帧 flush 空转，可重新挂载 */
+  detachSurfaces() {
+    this.backend = null;
+    this.overlayPainter = null;
+  }
+  setDevicePixelRatio(dpr) {
+    if (dpr === this.dpr) return;
+    this.dpr = dpr;
+    this.invalidate("both");
+  }
+  setSurfaceSize(width, height) {
+    if (width === this.surfaceSize.width && height === this.surfaceSize.height) return;
+    this.surfaceSize = { width, height };
+    this.invalidate("both");
+  }
+  getSurfaceSize() {
+    return this.surfaceSize;
+  }
+  // ---- 相机动作（视口 {x, y, zoom} 走 ui 分支，不进历史） ----
+  /** 打开/替换文档（转发 store；解码在宿主侧完成，内核只消费领域结构） */
+  openDocument(canvas) {
+    this.store.openDocument(canvas);
+  }
+  /**
+   * 预览视图（只读衍生）：模板态表格在视图中获得一行预览行（文本格 = 表达式
+   * 原文、标记图片/二维码格走占位盒），渲染/命中/导出据此呈现「一行输出效果」；
+   * 文档本身不被改写。宿主（如导出）与内核内部共用同一 memo。
+   */
+  get previewCanvas() {
+    const doc = this.store.doc;
+    if (doc === null) return null;
+    if (doc !== this.previewSource) {
+      this.previewValue = withTemplatePreview(doc, this.textPolicies);
+      this.previewSource = doc;
+    }
+    return this.previewValue;
+  }
+  /** 平移：屏幕位移按 zoom 折算 */
+  panBy(deltaScreenX, deltaScreenY) {
+    this.store.setViewport(panBy(this.store.ui.viewport, deltaScreenX, deltaScreenY));
+  }
+  /** 缩放至指定倍率，以屏幕点（视口坐标系的 css 像素）为锚 */
+  zoomAt(screenX, screenY, nextZoom) {
+    this.store.setViewport(zoomAtPoint(this.store.ui.viewport, screenX, screenY, nextZoom, this.zoomBounds));
+  }
+  /** 滚轮/捏合：曲线见 camera.nextZoomByWheel，缩放以指针为中心 */
+  zoomByWheel(screenX, screenY, deltaY) {
+    const viewport = this.store.ui.viewport;
+    const nextZoom = nextZoomByWheel(viewport.zoom, deltaY, this.zoomBounds);
+    this.store.setViewport(zoomAtPoint(viewport, screenX, screenY, nextZoom, this.zoomBounds));
+  }
+  /**
+   * 缩放复位 100%（⌘0，kbd-nav 工单 01）：以视口中心为锚回到 1.0——中心场景点
+   * 不动、平移不跳变（Sketch Actual Size 同构，playground zoomTo100 先例收编为
+   * 内核面）；已在 100% 时 zoomAtPoint 恒等短路。视口走 ui 分支不进历史。
+   */
+  resetZoom() {
+    const { width, height } = this.surfaceSize;
+    this.zoomAt(width / 2, height / 2, 1);
+  }
+  /** 一键适应画布：整页可见、居中（表面尺寸未知时 no-op） */
+  fitToSurface() {
+    const doc = this.store.doc;
+    if (!doc || this.surfaceSize.width <= 0 || this.surfaceSize.height <= 0) return;
+    this.store.setViewport(fitViewport(doc, this.surfaceSize, this.zoomBounds, this.fitMargin));
+  }
+  /**
+   * 路径处图层盒：模板子树路径经预览视图解析（auto 高在视图里合成，文档侧
+   * 声明高为零），其余路径直接解析文档——非模板子树结构共享，两棵树同盒。
+   * gizmo/命中/适应选区/文本编辑 overlay 共用，与绘制不漂移。
+   */
+  boxByPath(path) {
+    const doc = this.store.doc;
+    if (!doc) return null;
+    if (isTemplateSubtreePath(path)) {
+      const view = this.previewCanvas;
+      const viewPath = view ? docPathToViewPath(doc, path) : null;
+      return view && viewPath ? layerBoxByPath(view, viewPath, this.textPolicies) : null;
+    }
+    return layerBoxByPath(doc, path, this.textPolicies);
+  }
+  /** 自适应选区视图：视口适配选中盒；无选择/退化盒回落适应画布 */
+  fitToSelection() {
+    const doc = this.store.doc;
+    if (!doc) return;
+    const selection = this.store.ui.selection;
+    const box = selection ? this.boxByPath(selection) : null;
+    if (!box || box.width <= 0 || box.height <= 0 || this.surfaceSize.width <= 0 || this.surfaceSize.height <= 0) {
+      this.fitToSurface();
+      return;
+    }
+    this.store.setViewport(fitRect(box, this.surfaceSize, this.zoomBounds, this.fitMargin));
+  }
+  /**
+   * 保 zoom 平移入视（canvas-web-find-replace 工单 02，spec 决策 6）：查找导航
+   * 的视口跟随——目标盒完全在视口内视口不动，出视才最小平移使整盒入视（入视
+   * 小边距与盒大于视口对齐盒左上的边界语义在 camera.panToBox 纯函数内定死）。
+   * 与 fitToSelection 分立不混用：那是变焦语义（fitRect），这是保 zoom 的跟随
+   * 语义。盒几何由调用方解析（工单 03 命中导航经 layerBoxAt 同一解析缝，模板
+   * 子树走预览视图）；视口走 ui 分支不进历史，视内不动经恒等短路零通知；表面
+   * 尺寸未知 no-op（fitToSurface 同门）。
+   */
+  panToBox(box) {
+    if (this.surfaceSize.width <= 0 || this.surfaceSize.height <= 0) return;
+    const viewport = this.store.ui.viewport;
+    const next = panToBox(viewport, box, this.surfaceSize, PAN_TO_BOX_MARGIN_PX);
+    if (next !== viewport) this.store.setViewport(next);
+  }
+  // ---- 选择与拖动（工单 06）：命中/选择/拖动几何全部经内核纯函数 ----
+  /** 屏幕（css 像素）→ 场景：绑定层的唯一坐标入口（zoom 折算收口在此） */
+  toScenePoint(screenX, screenY) {
+    return screenToScene(this.store.ui.viewport, screenX, screenY);
+  }
+  /**
+   * 场景点命中查询（不产生副作用）：在预览视图上执行——模板态表格的预览行
+   * 可命中，命中路径经视图→文档映射落回模板子树身份（选中/属性编辑写文档）。
+   * 锁定集合（canvas-web-layer-lock 工单 01）随 ui 分支传入纯函数：锁定的根层
+   * 整子树退出命中面，selectAt/hoverAt/右键/双击全经此一条缝自动生效。
+   */
+  hitTest(sceneX, sceneY) {
+    const view = this.previewCanvas;
+    if (!view) return null;
+    const hit = hitTest(view, sceneX, sceneY, this.textPolicies, {
+      lockedPaths: this.store.ui.lockedPaths
+    });
+    if (hit === null) return null;
+    const docPath = viewPathToDocPath(view, hit);
+    return docPath ? docPath : null;
+  }
+  /** 路径处图层的绝对盒（gizmo 选择框与后续面板共用；与命中同一布局策略） */
+  layerBoxAt(path) {
+    return this.boxByPath(path);
+  }
+  /** 点选：命中即选中并返回路径，未中清空选择（画布与后续面板同源） */
+  selectAt(sceneX, sceneY) {
+    const path = this.hitTest(sceneX, sceneY);
+    this.store.setSelection(path);
+    return path;
+  }
+  /** 直接设置选择（面板/键盘入口） */
+  setSelection(path) {
+    this.store.setSelection(path);
+  }
+  /** Escape 升级：沿归属链 cell→row→table 逐级取父，链尽清空选择 */
+  escapeSelection() {
+    const selection = this.store.ui.selection;
+    if (!selection) return;
+    this.store.setSelection(selectionParentPath(selection));
+  }
+  /**
+   * 循环选层（kbd-nav 工单 03，CONTEXT「循环选层」词条 / spec 决策 4）：Tab
+   * 沿面板序朝更垫底方向移动选中（面板顶 = 视觉最上层 = 数组尾，故数组下标 −1），
+   * ⇧Tab 反向（selectPrevLayer），端点 wrap 回绕；空选从视觉最上层（面板首行）
+   * 开始（spec 决策 4 字面口径，⇧Tab 同一起点）；子层选中以根祖先为基准取相邻
+   * 根层（不下钻表格，循环只落根路径）。跳过面与命中面同门（hitTest 同款判定）：
+   * 隐藏根层整子树排除（visible=false 是排除语义非保护语义）、锁定根层整子树
+   * 退出交互面（isLocked 谓词——Tab 是命中面的键盘投影，「画布挡误触」同门，
+   * layer-lock 合入后随谓词自动生效）；全部根层被跳过时空转返回 false。
+   * 选中变更走 setSelection（ui 分支零历史步；值等短路使单根层 wrap 自身无害
+   * ——不通知）。返回是否落到选中（executeShortcut 可用态口径）。
+   */
+  selectNextLayer() {
+    return this.cycleRootSelection(1);
+  }
+  /** ⇧Tab 反向循环选层（语义见 selectNextLayer） */
+  selectPrevLayer() {
+    return this.cycleRootSelection(-1);
+  }
+  /** 循环选层的共同游走：direction = 1 朝数组头（垫底）、−1 朝数组尾（最上），模 count 回绕 */
+  cycleRootSelection(direction) {
+    const doc = this.store.doc;
+    const count = doc?.layers.length ?? 0;
+    if (doc === null || count === 0) return false;
+    const selection = this.store.ui.selection;
+    const baseline = selection !== null && rootLayerOf(doc, selection) !== null ? selection[1] : null;
+    const startIndex = baseline === null ? count - 1 : baseline - direction;
+    for (let step = 0; step < count; step += 1) {
+      const index = ((startIndex - direction * step) % count + count) % count;
+      const path = ["layers", index];
+      if (doc.layers[index].visible === false || this.isLocked(path)) continue;
+      this.store.setSelection(path);
+      return true;
+    }
+    return false;
+  }
+  /** 悬停命中（指针移动时调用；离场传 null 或用 setHovered） */
+  hoverAt(sceneX, sceneY) {
+    this.store.setHovered(this.hitTest(sceneX, sceneY));
+  }
+  /** 设置悬停路径 */
+  setHovered(path) {
+    this.store.setHovered(path);
+  }
+  /**
+   * 开始拖动会话：记录目标路径、起点场景坐标、起始 position 偏移与起始盒
+   * （吸附求位基准，ui 分支）。已在拖动中、路径或盒几何无法解析时返回 false；
+   * 路径落在锁定子树同样拒绝（canvas-web-layer-lock 工单 01：拖动是变更类
+   * 动作的 guard 入口——画布命中面已过滤锁定层，此守卫兜住其余手势来源，
+   * 缩放手势接入 resize feature 时同用此门）。
+   *
+   * Alt+拖快速复制（alt-drag-paste 工单 01）：options.copy 起手一次性判定——
+   * 源不可复制（canCopyLayerAt 为 false：行/格等容器内结构）静默忽略 Alt 走
+   * 普通拖动（spec 决策 1）；置位后 copyMode 会话内定死，首移越过死区才插入
+   * 副本（dragTo 消费，见 ALT_DRAG_DEAD_ZONE_SCREEN_PX）。
+   */
+  beginDrag(path, sceneX, sceneY, options = {}) {
+    if (this.store.ui.drag || this.store.ui.resize || this.store.ui.create) return false;
+    if (this.isLocked(path)) return false;
+    const doc = this.store.doc;
+    const layer = doc ? resolveLayer(doc, path) : null;
+    if (!doc || !layer) return false;
+    const box = this.boxByPath(path);
+    if (!box) return false;
+    const copy = options.copy === true && canCopyLayerAt(doc, path);
+    this.store.setDrag({
+      path,
+      startScene: { x: sceneX, y: sceneY },
+      startPosition: { x: layer.position.x, y: layer.position.y },
+      startBox: box,
+      ...copy ? { copy: true, copyPending: true } : {}
+    });
+    return true;
+  }
+  /**
+   * 拖动进行中：position = 起点 + 场景位移，再按吸附修正（工单 01，ADR 0012）。
+   * 吸附求位：暂定盒（startBox + 本步位移）九点对轴集合——其他可见根层盒缘与
+   * 中心、画布水平/垂直中轴、参考线轴——屏幕 6px 阈值按当前缩放换算场景值，
+   * 多轴取最近，至多一垂直 + 一水平；修正并入同一位置事务（同一 mergeKey，
+   * 跟随拖动既有历史合并语义）。命中的吸附轴回写会话态供吸附线呈现（瞬时
+   * 回显，endDrag 清空）。九锚点一视同仁——锚点偏移不动，只累加 x/y（x += dx/
+   * zoom 的 zoom 折算已由 toScenePoint 收口）；一次拖动的全部位移经同 mergeKey
+   * 事务并成一步历史，属性面板读同一文档数据即联动。
+   *
+   * Alt+拖 copyMode（alt-drag-paste 工单 01）：副本未插入前（copyPending）源层
+   * 不动——未越死区零事务，首移越阈交 dragCopyFirstMove 单事务完成插入 + 位移，
+   * 此后 path 已重指向副本、走普通拖动流程（吸附排除副本、源层供轴）。
+   */
+  dragTo(sceneX, sceneY) {
+    const drag = this.store.ui.drag;
+    if (!drag) return;
+    const doc = this.store.doc;
+    if (!doc || resolveLayer(doc, drag.path) === null) return;
+    if (drag.copy === true && drag.copyPending === true) {
+      this.dragCopyFirstMove(drag, sceneX, sceneY);
+      return;
+    }
+    const dx = sceneX - drag.startScene.x;
+    const dy = sceneY - drag.startScene.y;
+    const resolution = resolveSnap(
+      {
+        x: drag.startBox.x + dx,
+        y: drag.startBox.y + dy,
+        width: drag.startBox.width,
+        height: drag.startBox.height
+      },
+      this.snapAxesForGesture(drag.path),
+      snapThresholdScene(this.store.ui.viewport.zoom)
+    );
+    this.store.transact((draft) => {
+      const layer = resolveLayer(draft, drag.path);
+      if (!layer) return;
+      const position = layer.position;
+      position.x = drag.startPosition.x + dx + resolution.dx;
+      position.y = drag.startPosition.y + dy + resolution.dy;
+    }, { mergeKey: DRAG_MERGE_KEY });
+    this.store.setSnapAxes(resolution.axes);
+  }
+  /**
+   * copyMode 首移（alt-drag-paste 工单 01，spec 决策 1/3）：先过死区——位移按
+   * 屏幕 4px 阈值折算（缩放无关），未越阈零事务、源层不动（Alt+点击退化）；
+   * 越阈则单事务完成「插入副本（紧邻源层）+ 副本自源盒起步位移」：副本 = 源
+   * 子树深拷贝，落位按根层语义反解（pastePosition——根层源退化为 position +
+   * 位移、格内容源把格内相对 position 换算画布绝对落位），与吸附修正一并写入，
+   * mergeKey 沿用 DRAG_MERGE_KEY，后续 move 同键合并——undo 一次副本整体消失。
+   * 吸附求位在副本入库前：吸附源 = 全部可见根层（副本尚不存在、源层天然在列
+   * ——重叠起步，spec 决策 4）；插入后手势重指向副本（startPosition 换基准为
+   * 副本起步位 = 源绝对盒的根层语义反解，startBox 即副本起步盒不变），副本自动
+   * 选中，命中轴照常回显。
+   */
+  dragCopyFirstMove(drag, sceneX, sceneY) {
+    const doc = this.store.doc;
+    if (!doc) return;
+    const source = resolveLayer(doc, drag.path);
+    if (!source) return;
+    const dx = sceneX - drag.startScene.x;
+    const dy = sceneY - drag.startScene.y;
+    if (Math.hypot(dx, dy) <= ALT_DRAG_DEAD_ZONE_SCREEN_PX / this.store.ui.viewport.zoom) return;
+    const resolution = resolveSnap(
+      {
+        x: drag.startBox.x + dx,
+        y: drag.startBox.y + dy,
+        width: drag.startBox.width,
+        height: drag.startBox.height
+      },
+      this.snapAxesForGesture(null),
+      snapThresholdScene(this.store.ui.viewport.zoom)
+    );
+    const copyIndex = { v: -1 };
+    this.store.transact((draft) => {
+      const sourceInDraft = resolveLayer(draft, drag.path);
+      if (!sourceInDraft) return;
+      const prepared = prepareRootPaste(
+        sourceInDraft,
+        drag.startBox,
+        doc.width,
+        doc.height,
+        dx + resolution.dx,
+        dy + resolution.dy
+      );
+      copyIndex.v = insertRootLayerAdjacentInDraft(draft, prepared, drag.path) ?? -1;
+    }, { mergeKey: DRAG_MERGE_KEY });
+    if (copyIndex.v < 0) return;
+    const copyPath = ["layers", copyIndex.v];
+    this.store.setDrag({
+      ...drag,
+      path: copyPath,
+      startPosition: pastePosition(drag.startBox, source.position.anchor, doc.width, doc.height, 0, 0),
+      copyPending: false
+    });
+    this.store.setSelection(copyPath);
+    this.store.setSnapAxes(resolution.axes);
+  }
+  /** 结束拖动：闭合合并事务（下一步历史定格），会话态与命中轴回显清空 */
+  endDrag() {
+    if (!this.store.ui.drag) return;
+    this.store.setDrag(null);
+    this.store.setSnapAxes([]);
+    this.store.closeMerge(DRAG_MERGE_KEY);
+  }
+  /**
+   * 手势可用的吸附轴集合（dragTo/resizeTo 每步重算，几何与其余消费同源）：
+   * 可见根层盒（hitTest 同款 visible 过滤）排除手势目标层自身根 + 画布中轴 +
+   * 当前参考线。自身根排除对缩放同样正确——被缩放层的自缘不供轴（对缘与移动
+   * 缘都在自身盒上，供轴只会命中自己）。gesturePath 传 null = 排除面为空
+   * （copyMode 首移：副本未入库，源层供轴，alt-drag-paste 工单 01）。
+   */
+  snapAxesForGesture(gesturePath) {
+    const doc = this.store.doc;
+    if (!doc) return [];
+    const excludeRootIndex = gesturePath === null ? null : gesturePath[1];
+    if (excludeRootIndex !== null && typeof excludeRootIndex !== "number") return [];
+    return snapAxesFromBoxes(
+      doc.width,
+      doc.height,
+      visibleRootBoxes(doc, excludeRootIndex, this.textPolicies),
+      this.store.ui.guides
+    );
+  }
+  /** 当次手势命中的吸附轴（只读查询，吸附线呈现消费）；非手势态/未命中为空 */
+  listSnapAxes() {
+    return this.store.ui.snapAxes;
+  }
+  // ---- 八柄缩放（工单 07）：几何纯函数在 spatial/resize，写回/吸附/采纳在此收口 ----
+  /**
+   * 路径处图层当前可用的八柄集合（gizmo 柄渲染与手势起点同缝）：角色权威
+   * 过滤（行宽=表宽、格内容尺寸强同步面不可经柄改，语义见
+   * spatial/resize.resizableAxesAt）+ 锁定子树不出柄（锁定层只画选中框，
+   * gizmo 同门——柄是变换入口，锁定=可定位不可变换）。
+   */
+  resizeHandlesAt(path) {
+    const doc = this.store.doc;
+    if (!doc || path === null || this.isLocked(path)) return [];
+    return resizeHandlesAt(doc, path);
+  }
+  /**
+   * 场景点命中选中层的可用柄（hitTest/hoverAt 同门的意图级查询，画布接线
+   * 与 gizmo 消费）：命中半径按屏幕 6px 常量折算（RESIZE_HANDLE_HIT_PX，随
+   * zoom 收放）；无选中/盒不可解析/未命中返回 null。命中判定以当前可用柄
+   * 集合为面——角色过滤与锁定折叠在此一条缝生效。
+   */
+  resizeHandleAt(sceneX, sceneY) {
+    const selection = this.store.ui.selection;
+    if (selection === null) return null;
+    const box = this.boxByPath(selection);
+    if (!box) return null;
+    return resizeHandleAt(
+      this.resizeHandlesAt(selection),
+      box,
+      sceneX,
+      sceneY,
+      this.store.ui.viewport.zoom
+    );
+  }
+  /**
+   * 开始缩放会话：记录目标路径、柄、起点场景坐标与起始解析盒（ui 分支）。
+   * 起点记录指针位置而非柄中心——位移以抓取点为基准，移动缘不跳到指针下
+   * （与拖动保留抓取偏移同语义，两种主流做法中取不跳变侧）。
+   * 已在手势中（拖动/缩放互斥）、路径或盒几何无法解析、路径落在锁定子树、
+   * 柄的任一作用轴不在角色可缩放面内（行上拖 e/w、格内容上任意柄）时返回
+   * false——gizmo 只渲染可用柄，此守卫兜其余手势来源（键盘/宿主直调）。
+   */
+  beginResize(path, handle, sceneX, sceneY) {
+    if (this.store.ui.drag || this.store.ui.resize || this.store.ui.create) return false;
+    if (this.isLocked(path)) return false;
+    if (!RESIZE_HANDLES.includes(handle)) return false;
+    const doc = this.store.doc;
+    if (!doc || resolveLayer(doc, path) === null) return false;
+    const axes = resizableAxesAt(doc, path);
+    if (handleResizesWidth(handle) && !axes.width) return false;
+    if (handleResizesHeight(handle) && !axes.height) return false;
+    const box = this.boxByPath(path);
+    if (!box) return false;
+    this.store.setResize({ path, handle, startScene: { x: sceneX, y: sceneY }, startBox: box });
+    return true;
+  }
+  /**
+   * 缩放进行中（工单 07）：八柄几何求位 + 移动缘吸附 + 文档写回，一个 mergeKey
+   * 事务合并成一步历史。
+   *
+   * 几何：移动缘 = 起始缘 + 场景位移，对缘固定，minSize 钳位不翻转
+   * （resizeBox）；非本柄轴的位移分量忽略。
+   * 吸附：移动缘位点（resizeSnapPoints，角柄双缘、边柄单缘；盒中心不参与缩放
+   * 吸附）对轴集合求位——轴集合与拖动同源（snapAxesForGesture），屏幕 6px 阈值
+   * 随 zoom 折算；修正施加在指针位移上、再进钳位，吸附不破「对缘固定 + minSize」
+   * 语义，吸附结果只改坐标不改尺寸语义（auto 标志采纳是手势起点的轴选择，不随
+   * 吸附翻转）。命中的吸附轴回写会话态供吸附线呈现（瞬时回显，endResize 清空）。
+   * 写回（工单验收项 2 的语义收口）：被拖轴写声明尺寸并清 auto 标志——autoWidth/
+   * autoHeight 图层首个位移事务把解析尺寸落地为声明值（「改尺寸标志」语义，
+   * 属性面板 auto 前缀输入框的可编辑化同门）；未被拖的轴零接触——autoWidth
+   * 文本层拖 s 柄后仍随文本自然宽、QR 拖 e 柄高随宽保持正方形（从动轴不采纳）。
+   * 写后重断言（updateSpec 同门）：autoHeight⟹声明高归零的解码不变量 + 表格
+   * 强同步 canonicalize（根表宽联动行宽、格内容宽同步、行高取最高格——行高缩到
+   * 最高格以下被不变量顶回属预期）。position 按目标盒反解（锚点偏移随新尺寸
+   * 重算，任意锚点/任意父级下落点都精确）：同步完成后以草稿内的解析尺寸与
+   * 父级盒求锚点偏移，position = 目标盒坐标 − 偏移 − 父级原点（嵌套路径的
+   * position 是父级相对量，父级原点经 gestureParentOrigin 在写前状态反解——
+   * 根层原点恒 (0,0)，行为不变）。
+   *
+   * 拖不动写不动的同门守卫：无会话、目标层被结构编辑移除（悬空路径）整体
+   * 空转（不发事务、不发布命中轴）。
+   */
+  resizeTo(sceneX, sceneY) {
+    const gesture = this.store.ui.resize;
+    if (!gesture) return;
+    const doc = this.store.doc;
+    const current = doc ? resolveLayer(doc, gesture.path) : null;
+    if (!doc || !current) return;
+    const dx = sceneX - gesture.startScene.x;
+    const dy = sceneY - gesture.startScene.y;
+    const widthActive = handleResizesWidth(gesture.handle);
+    const heightActive = handleResizesHeight(gesture.handle);
+    const resolution = resolveSnapPoints(
+      resizeSnapPoints(gesture.startBox, gesture.handle, dx, dy),
+      this.snapAxesForGesture(gesture.path),
+      snapThresholdScene(this.store.ui.viewport.zoom)
+    );
+    const target = resizeBox(
+      gesture.startBox,
+      gesture.handle,
+      widthActive ? dx + resolution.dx : dx,
+      heightActive ? dy + resolution.dy : dy
+    );
+    const origin = this.gestureParentOrigin(gesture.path, current);
+    this.store.transact((draft) => {
+      const layer = resolveLayer(draft, gesture.path);
+      if (!layer) return;
+      const shape = layer.shape;
+      if (widthActive) {
+        shape.width = target.width;
+        shape.autoWidth = false;
+      }
+      if (heightActive) {
+        shape.height = target.height;
+        shape.autoHeight = false;
+      }
+      renormalizeAutoHeightInDraft(layer);
+      canonicalizeTableSyncInDraft(
+        draft,
+        gesture.path,
+        widthActive ? ["shape", "width"] : ["shape", "height"],
+        this.textPolicies
+      );
+      const resolvedWidth = layerWidth(layer, this.textPolicies);
+      const resolvedHeight = layerHeight2(layer, this.textPolicies);
+      const parent = this.parentDimsInDraft(draft, gesture.path);
+      const offset = anchorOffset2(
+        layer.position.anchor,
+        parent.width,
+        parent.height,
+        resolvedWidth,
+        resolvedHeight
+      );
+      const position = layer.position;
+      position.x = target.x - offset.x - origin.x;
+      position.y = target.y - offset.y - origin.y;
+    }, { mergeKey: RESIZE_MERGE_KEY });
+    this.store.setSnapAxes(resolution.axes);
+  }
+  /**
+   * 结束缩放：闭合合并事务（下一步历史定格），会话态与命中轴回显清空。
+   * 无会话空转（幂等，pointercancel 与 pointerup 双路同达）。
+   */
+  endResize() {
+    if (!this.store.ui.resize) return;
+    this.store.setResize(null);
+    this.store.setSnapAxes([]);
+    this.store.closeMerge(RESIZE_MERGE_KEY);
+  }
+  // ---- 画拉建层（drag-create 工单 01）：武装 + 橡皮筋纯视觉 + pointerup 落库 ----
+  /**
+   * 武装建层（面板新增项/层型快捷键的统一入口，CONTEXT「武装」词条）：置 ui
+   * 分支待命层型，下一次画布按下即开画拉；建层提交或 Esc 即解除——一次性
+   * 待命态，无粘性工具（spec 决策 2）。重复武装同型值等短路零通知。
+   */
+  armLayerCreate(type) {
+    this.store.setArmedCreate(type);
+  }
+  /** 解除建层武装（取消入口）：仅清待命态，零副作用。 */
+  cancelArmLayerCreate() {
+    this.store.setArmedCreate(null);
+  }
+  /**
+   * 开始画拉会话：须已武装（未武装空转防御——画布手势态机的分派前置，此守卫
+   * 兜其余调用来源），与拖动/缩放会话互斥（手势起点一次性定死，beginDrag/
+   * beginResize 同门），文档未打开空转。层型在起点一次性捕获进会话（spec
+   * 决策 7：拖拽中改主意 = Esc 重武装，v1 不做拖拽中层型切换）。会话只进
+   * ui 分支——拖拽期纯视觉、文档零变更（spec 决策 4）。
+   */
+  beginLayerCreate(sceneX, sceneY) {
+    const armed = this.store.ui.armedCreate;
+    if (armed === null || this.store.ui.drag || this.store.ui.resize || this.store.ui.create) return false;
+    if (!this.store.doc) return false;
+    const point = { x: sceneX, y: sceneY };
+    this.store.setCreate({
+      type: armed,
+      startScene: point,
+      currentScene: point,
+      rect: { x: sceneX, y: sceneY, width: 0, height: 0 }
+    });
+    return true;
+  }
+  /**
+   * 画拉进行中：橡皮筋求位（spatial/create.createRubberBandRect——两点正规化
+   * + QR 钳 height := width + 左右/上下缘各两点进 resolveSnapPoints，吸附数学
+   * 零新增）写回会话 rect 供 overlay 直读（虚线矩形 + W×H 气泡），命中轴回写
+   * ui.snapAxes 走 GuidesOverlay 既有通道回显（dragTo 同门）。吸附排除面为空
+   * （snapAxesForGesture(null)——新层尚未入库，全部可见根层供轴，copyMode
+   * 首移同门）。零文档事务：修正只进会话几何，落库在 endCreate。
+   */
+  createTo(sceneX, sceneY) {
+    const gesture = this.store.ui.create;
+    const doc = this.store.doc;
+    if (!gesture || !doc) return;
+    const resolution = createRubberBandRect(
+      gesture.type,
+      gesture.startScene,
+      { x: sceneX, y: sceneY },
+      this.snapAxesForGesture(null),
+      snapThresholdScene(this.store.ui.viewport.zoom)
+    );
+    this.store.setCreate({
+      ...gesture,
+      currentScene: { x: sceneX, y: sceneY },
+      rect: resolution.rect
+    });
+    this.store.setSnapAxes(resolution.axes);
+  }
+  /**
+   * 结束画拉：按死区分流落库（一次手势 = 一步历史，undo 整体回退落位 + 尺寸
+   * + priority）。先清会话再落文档（commitTextEdit 同门——退出路径级联时幂等）：
+   * - 死区外：单事务写入「createDefaultLayer 缺省形态 + position 左上角对准
+   *   橡皮筋矩形（含吸附修正）+ shape.width/height」并 insertRootLayerInDraft
+   *   置顶（priority min−1、push 数组尾）；
+   * - 死区内（点击兜底，位移按 CREATE_DEAD_ZONE_SCREEN_PX 屏幕 px 随 zoom 折算，
+   *   ALT_DRAG_DEAD_ZONE_SCREEN_PX 同门）：缺省尺寸、左上角对准点击点。
+   * 落库后自动选中新层并解除武装；返回新层路径（绑定层消费：文本层据此自动
+   * 进文本编辑，spec 决策 6）。无会话/无文档空转返回 null。点击兜底不产生
+   * 零尺寸层（缺省形态自带可见尺寸）。
+   */
+  endCreate() {
+    const gesture = this.store.ui.create;
+    if (!gesture) return null;
+    this.store.setCreate(null);
+    this.store.setSnapAxes([]);
+    this.store.setArmedCreate(null);
+    if (!this.store.doc) return null;
+    const dx = gesture.currentScene.x - gesture.startScene.x;
+    const dy = gesture.currentScene.y - gesture.startScene.y;
+    const deadZoneScene = CREATE_DEAD_ZONE_SCREEN_PX / this.store.ui.viewport.zoom;
+    const clicked = Math.hypot(dx, dy) <= deadZoneScene;
+    const index = { v: -1 };
+    this.store.transact((draft) => {
+      const layer = createDefaultLayer(gesture.type);
+      if (clicked) {
+        layer.position = { ...layer.position, x: gesture.startScene.x, y: gesture.startScene.y };
+      } else {
+        layer.position = { ...layer.position, x: gesture.rect.x, y: gesture.rect.y };
+        layer.shape.width = gesture.rect.width;
+        layer.shape.height = gesture.rect.height;
+      }
+      index.v = insertRootLayerInDraft(draft, layer);
+    });
+    if (index.v < 0) return null;
+    const path = ["layers", index.v];
+    this.store.setSelection(path);
+    return path;
+  }
+  /**
+   * 取消画拉（Esc 语义）：清橡皮筋会话、命中轴回显与武装态——零文档写入、
+   * 零历史步（拖拽期纯视觉因此取消零回退成本，spec 决策 4）。幂等：无会话时
+   * 仅解除武装（待命态 Esc 同走此口）。
+   */
+  cancelCreate() {
+    this.store.setCreate(null);
+    this.store.setSnapAxes([]);
+    this.store.setArmedCreate(null);
+  }
+  /**
+   * 手势空间父级原点（嵌套路径 position 反解的坐标基准，resizeTo 专用）：布局
+   * 不变量 box = 父级原点 + 锚点偏移 + position（render.resolveLayerBox 同式）
+   * 对被拖层成立，且父级原点在自身缩放中不动——兄弟/祖先几何不被自身尺寸写回
+   * 牵动（格宽累加/行高累加只受前序兄弟影响）。故以手势同空间（模板子树经预览
+   * 视图解析，与 startBox/startScene 同一坐标系）的当前盒线性反解：原点 = 当前
+   * 盒 − 锚点偏移（手势空间父级盒尺寸入参）− 当前 position。根层恒 (0,0)——
+   * 既有根层语义（父级 = 画布、原点即画布原点）不变；盒不可解析回落实地 (0,0)
+   * （与根层同参，写回仍自洽）。须以写前状态调用：盒/position/解析尺寸三者
+   * 同源才能精确反解。
+   */
+  gestureParentOrigin(path, layer) {
+    if (isRootLayerPath(path)) return { x: 0, y: 0 };
+    const doc = this.store.doc;
+    if (!doc) return { x: 0, y: 0 };
+    const box = this.boxByPath(path);
+    if (!box) return { x: 0, y: 0 };
+    const parentPath = path[path.length - 1] === "content" ? path.slice(0, -1) : path.slice(0, -2);
+    const parentBox = this.boxByPath(parentPath);
+    const offset = anchorOffset2(
+      layer.position.anchor,
+      parentBox?.width ?? doc.width,
+      parentBox?.height ?? doc.height,
+      layerWidth(layer, this.textPolicies),
+      layerHeight2(layer, this.textPolicies)
+    );
+    return {
+      x: box.x - offset.x - layer.position.x,
+      y: box.y - offset.y - layer.position.y
+    };
+  }
+  /**
+   * 草稿内求缩放目标的父级盒尺寸（position 反解的锚点偏移入参）：根层 = 画布
+   * 尺寸（resolveLayerBox 根层语义同参）；行/格取容器路径（rows/cells 段成对、
+   * content 单段），经 layerBoxByPath 在草稿内解析——同步完成后的父级盒（行高
+   * 增长等同步效应已含）。悬空回落画布尺寸（与根层同参，position 仍自洽）。
+   */
+  parentDimsInDraft(draft, path) {
+    if (isRootLayerPath(path)) return { width: draft.width, height: draft.height };
+    const parentPath = path[path.length - 1] === "content" ? path.slice(0, -1) : path.slice(0, -2);
+    const box = layerBoxByPath(draft, parentPath, this.textPolicies);
+    return box ?? { width: draft.width, height: draft.height };
+  }
+  /**
+   * 方向键微调（kbd-nav 工单 02）：选中层 position 按场景增量位移（注册表 8
+   * 条目方向 × 步长归并到此，executeShortcut 传 ±1/±10）。作用面与拖动同门——
+   * 选中什么微调什么，位置写法与 dragTo 同一语义（position 原位 += 增量）；
+   * 拖不动的空转（无选择/无文档/路径不可解析）。**不吸附**：吸附是拖动过程的
+   * 连续行为（CONTEXT「微调」词条边界），微调是可预测的定量位移，不走
+   * resolveSnap、不回显命中轴。
+   * 连续微调合并一条历史：mergeKey 含选中层路径、方向无关——同层连按（跨方向）
+   * 并成一步，undo 一次回连按前；换层即换步（mergeKey 随路径变）；undo/redo
+   * 走 store 既有断开规则（closeMerge）。断开是键控而非选择事件驱动：选择往返
+   * （A→B→A 中途无文档变更）会并回 A 的原串，机制既有规则同款。拖动/缩放会话
+   * 进行中空转（防插入事务拆分开放中的合并步，工单 07 缩放同门）。
+   * 守卫（canvas-web-layer-lock 工单 01 挂账兑现）：锁定子树空转（isLocked
+   * 谓词同门——微调是变更类动作）。空转返回 false（executeShortcut 可用态口径）。
+   */
+  nudge(deltaX, deltaY) {
+    const path = this.store.ui.selection;
+    if (path === null || this.store.ui.drag !== null || this.store.ui.resize !== null) return false;
+    if (this.isLocked(path)) return false;
+    const doc = this.store.doc;
+    if (!doc || resolveLayer(doc, path) === null) return false;
+    this.store.transact((draft) => {
+      const layer = resolveLayer(draft, path);
+      if (!layer) return;
+      const position = layer.position;
+      position.x += deltaX;
+      position.y += deltaY;
+    }, { mergeKey: nudgeMergeKey(path) });
+    return true;
+  }
+  // ---- 参考线与标尺（ruler-guides-snap 工单 01）：会话态住 ui 分支，零契约面 ----
+  /**
+   * 新增参考线（标尺拖出落线的写入口，工单 03 消费）：水平/垂直轴、场景坐标。
+   * 住 ui 分支——不进历史、不写 graph（ADR 0012）；id 会话内自增供删除寻址。
+   * 非有限坐标空转返回 null（绑定层异常输入防御，不产生通知）。
+   */
+  addGuide(guide) {
+    if (!Number.isFinite(guide.position)) return null;
+    const stored = { id: ++this.guideIdSeq, orientation: guide.orientation, position: guide.position };
+    this.store.setGuides([...this.store.ui.guides, stored]);
+    return stored;
+  }
+  /** 删除参考线（拖回标尺语义）：按 id 移除；未知 id 空转返回 false */
+  removeGuide(id) {
+    const guides = this.store.ui.guides;
+    const next = guides.filter((guide) => guide.id !== id);
+    if (next.length === guides.length) return false;
+    this.store.setGuides(next);
+    return true;
+  }
+  /**
+   * 清空全部参考线（工具栏「清空参考线」写入口，工单 03 消费）：ui 分支整体置空，
+   * 与 removeGuide 同型广播 guides 分支通知（覆盖层失效重绘）。会话级语义同门——
+   * 不进历史、不写 graph（ADR 0012），不可撤销；无文档或已空时空转（不产生通知）。
+   */
+  clearGuides() {
+    if (!this.store.doc) return;
+    if (this.store.ui.guides.length === 0) return;
+    this.store.setGuides([]);
+  }
+  /** 参考线列表（只读查询，呈现与吸附供轴同源） */
+  listGuides() {
+    return this.store.ui.guides;
+  }
+  /** 标尺显隐开关（⇧R 分派口）：翻转 ui 偏好，不进历史 */
+  toggleRulers() {
+    this.store.setRulersVisible(!this.store.ui.rulersVisible);
+  }
+  // ---- 对齐画布（layer-align-snap 工单 01）：图层盒整体对齐画布几何 ----
+  /**
+   * 对齐画布 action 族（对齐画布/贴边/贴角，ADR 0011）：把 path 处图层盒整体
+   * 对齐到画布几何——mode 十种：贴边 left/right/top/bottom（零边距）、居中
+   * h-center/v-center、贴角 corner-tl/tr/bl/br（opts.margin 统一边距，缺省
+   * ALIGN_CORNER_MARGIN_PX）。与属性面板「盒内对齐」（写 align 字段移动盒内
+   * 内容）是两类动作，并存不回退。
+   * 几何以 layerBoxAt(path) 解析的图层盒为唯一来源、画布尺寸取 doc.canvas；
+   * 盒坐标对 position 线性（box = origin + anchorOffset + position），「目标
+   * 盒坐标 − 当前盒坐标」的位移原样写 position 偏移、anchor 不动；盒大于画布
+   * 不钳位（偏移可为负的领域语义，溢出侧按公式确定）。一次调用 = 一步历史
+   * （无 mergeKey，连续点击不合并）；已对齐（零位移）经 store 空 patch 短路
+   * 不进历史；文档未打开/路径不可解析/未知 mode 空转（无历史步）。
+   */
+  alignToCanvas(path, mode, options = {}) {
+    const doc = this.store.doc;
+    if (!doc) return;
+    const box = this.boxByPath(path);
+    if (!box) return;
+    const target = alignToCanvasTarget(
+      mode,
+      box,
+      doc.width,
+      doc.height,
+      options.margin ?? ALIGN_CORNER_MARGIN_PX
+    );
+    if (!target) return;
+    const dx = target.x - box.x;
+    const dy = target.y - box.y;
+    this.store.transact((draft) => {
+      const layer = resolveLayer(draft, path);
+      if (!layer) return;
+      const position = layer.position;
+      position.x += dx;
+      position.y += dy;
+    });
+  }
+  // ---- 文本编辑会话（工单 11）：会话住 ui 分支，提交经漏斗一次性落文档 ----
+  /**
+   * 进入文本编辑：路径必须解析到 TextLayer。会话只进 ui 分支（不进历史），
+   * live 文本住在绑定层的 textarea，内容层随即跳绘该层文本（防重影）。
+   *
+   * 内容类型会话标志（canvas-web-expression-editing 工单 01，spec 决策 2）按
+   * 进入瞬间 `layer.expression !== null` 锚定进会话快照——「进入时计、编辑中
+   * 稳定」（verticalAnchorY 同门）：编辑中面板改标记不回写标志，提交去向由
+   * 快照裁决（打标是显式动作，内容判定制已否决）。同路径重复进入短路（快照
+   * 不重锚）；换层进入按新层现状重锚。
+   */
+  beginTextEdit(path) {
+    const layer = this.textLayerAt(path);
+    if (layer === null) return false;
+    const current = this.store.ui.editing;
+    if (current && pathsEqual(current.path, path)) return true;
+    this.store.setEditing({ path, expression: layer.expression !== null });
+    return true;
+  }
+  /**
+   * 提交漏斗的统一出口：Esc / Ctrl+Enter / blur / 点画布他处四条退出路径都收拢
+   * 到这里。先清会话再落文档——退出路径可能级联触发（画布点按的 pointerdown
+   * 提交与随后 blur 竞态），会话清空后后续调用幂等，保证一次退出恰一步历史。
+   *
+   * 提交矩阵（canvas-web-expression-editing 工单 01，spec 决策 3，空串判定先于
+   * 片段判定）：
+   * - 串与文档一致：不进历史（进出编辑零噪声），返回 false——对比对象随会话
+   *   模式取：表达式会话对比 `layer.expression`、字面会话对比 `layer.text`（现行
+   *   语义）；
+   * - 空串：删除该图层（复用 deleteLayer 的 splice/重映射语义），任何模式同语义；
+   * - 表达式会话且串含 ≥1 语法有效闭合片段（hasValidExpressionFragment）：
+   *   updateDataExpression 标记写（保持标记、text 自动重镜像）；
+   * - 其余（字面会话恒走此支；表达式会话无合法片段回落）：updateData 字面写、
+   *   字面接管解标——含 `{{...}}` 按字面保留，杜绝无片段标记层。
+   */
+  commitTextEdit(text) {
+    const editing = this.store.ui.editing;
+    if (!editing) return false;
+    this.store.setEditing(null);
+    const layer = this.textLayerAt(editing.path);
+    if (!layer) return false;
+    if (editing.expression ? text === layer.expression : text === layer.text) return false;
+    if (text === "") {
+      this.deleteLayer(editing.path);
+      return true;
+    }
+    if (editing.expression && hasValidExpressionFragment(text)) {
+      this.updateDataExpression(editing.path, text);
+      return true;
+    }
+    this.updateData(editing.path, text);
+    return true;
+  }
+  /**
+   * 编辑 overlay 的布局描述：与绘制/命中同一套布局策略求出的盒几何与排版字段
+   * （textarea 以盒左上对位、盒尺寸占位，字号/行高/内边距按场景像素交给 CSS
+   * transform 缩放）。verticalAnchorY 按进入编辑时的文档文本计算，编辑中保持
+   * 稳定不随键入跳动。非文本层/路径失效返回 null。
+   */
+  textEditLayout(path) {
+    const layer = this.textLayerAt(path);
+    const doc = this.store.doc;
+    if (!layer || !doc) return null;
+    const box = this.boxByPath(path);
+    if (!box) return null;
+    const editing = this.store.ui.editing;
+    return {
+      box,
+      text: layer.text,
+      font: layer.font,
+      fontColor: layer.fontColor,
+      fontSize: layer.fontSize,
+      lineHeightPx: lineHeightPx2(layer),
+      padding: layer.shape.padding,
+      horizontalAlign: layer.align.horizontal,
+      verticalAlign: layer.align.vertical,
+      verticalAnchorY: textOrigin(layer, this.textPolicies).y,
+      autowrap: layer.autowrap,
+      expressionMode: editing !== null && pathsEqual(editing.path, path) ? editing.expression : layer.expression !== null
+    };
+  }
+  /** 编辑会话的目标图层查询：路径须解析到 TextLayer，其余（含无文档）返回 null */
+  textLayerAt(path) {
+    const doc = this.store.doc;
+    const layer = doc ? resolveLayer(doc, path) : null;
+    return layer && layer.type === "TextLayer" ? layer : null;
+  }
+  // ---- 查找替换（canvas-web-find-replace 工单 01）：会话态住 ui 分支，扫描/替换纯函数在 editing/findReplace ----
+  /**
+   * 打开查找会话（⌘F 分派口）：无文档空转返回 false；已开时值等短路零通知
+   * （重复 ⌘F 的重新聚焦归绑定层）。查询词/替换词/游标跨关开保留（closeFind
+   * →beginFind 同文档连续改字），openDocument 才整体重置。
+   */
+  beginFind() {
+    if (!this.store.doc) return false;
+    this.store.setFind({ ...this.store.ui.find, open: true });
+    return true;
+  }
+  /** 关闭查找会话（Esc 归面板组件调用）：仅翻开合面，查询词与游标保留 */
+  closeFind() {
+    this.store.setFind({ ...this.store.ui.find, open: false });
+  }
+  /** 查找词写入（查找条输入即扫的源头）：查询词变更即重置游标（旧下标对新命中集无意义） */
+  setFindQuery(query) {
+    const find = this.store.ui.find;
+    this.store.setFind({ ...find, query, cursor: find.query === query ? find.cursor : 0 });
+  }
+  /** 替换词写入 */
+  setFindReplacement(replacement) {
+    this.store.setFind({ ...this.store.ui.find, replacement });
+  }
+  /** 游标写入（上一个/下一个导航口）：存原值，越界在读侧钳位 */
+  setFindCursor(cursor) {
+    this.store.setFind({ ...this.store.ui.find, cursor });
+  }
+  /**
+   * 派生命中列表（overlay 高亮与查找条计数同源消费）：每次从 doc + query 现算、
+   * 不驻留（树小无压力，免 pruneDanglingPaths 式失配维护）；视觉序 = 数组尾→头
+   * （hitTest 同门），命中 = path + 偏移对。
+   */
+  listFindMatches() {
+    const doc = this.store.doc;
+    if (!doc) return [];
+    return scanTextMatches(doc, this.store.ui.find.query);
+  }
+  /** 当前游标（读侧钳位到派生命中列表：越界落末处/首处，空命中为 0） */
+  get findCursor() {
+    return clampFindCursor(this.store.ui.find.cursor, this.listFindMatches().length);
+  }
+  /**
+   * 替换当前命中（查找条「替换」按钮）：一次无 mergeKey 事务 = 一步历史；游标
+   * 原地不动——事务后派生列表在被替换处缩一位，原下标即「下一处」（「替换后
+   * 自动跳下一处」靠派生天然成立，末处替换则钳位停在尾）。写值经 replaceHitsInDraft
+   * 与文本编辑提交同门（text 直写 + expression 保持 null）。无文档/空 query/
+   * 无命中空转返回 false。
+   */
+  replaceOne() {
+    const doc = this.store.doc;
+    const query = this.store.ui.find.query;
+    if (!doc || query === "") return false;
+    const matches = scanTextMatches(doc, query);
+    const hit = matches[clampFindCursor(this.store.ui.find.cursor, matches.length)];
+    if (!hit) return false;
+    this.store.transact((draft) => {
+      replaceHitsInDraft(draft, [hit], this.store.ui.find.replacement);
+    });
+    return true;
+  }
+  /**
+   * 全部替换（查找条「全部替换」按钮）：命中（path + 偏移对）在事务前按原文
+   * 快照一次算定，单事务内按同字段偏移降序应用、替换产物不重扫（replacement
+   * 含查询串不死循环）——一次调用 = 一步历史，undo 一次全回。返回应用处数
+   * （计数反馈「已替换 N 处」）；无文档/空 query 空转返回 0。
+   */
+  replaceAll() {
+    const doc = this.store.doc;
+    const query = this.store.ui.find.query;
+    if (!doc || query === "") return 0;
+    const hits = scanTextMatches(doc, query);
+    if (hits.length === 0) return 0;
+    let applied = 0;
+    this.store.transact((draft) => {
+      applied = replaceHitsInDraft(draft, hits, this.store.ui.find.replacement);
+    });
+    return applied;
+  }
+  // ---- 属性写入（工单 09）：面板零直改，一切文档字段编辑经这三个 action ----
+  /**
+   * 更新图层 spec 子树字段（属性面板的权威写入口）：key 为图层内字段路径
+   * （领域形态，如 ['shape','backgroundColor']、['position','x']、单段 ['fontSize']），
+   * 拼上图层路径即 patch path。数值收整/钳位等取值策略由注册表层负责，内核透传。
+   * 路径无法解析或字段悬空时静默空转；连续输入经 mergeKey 合并为一步历史。
+   *
+   * 表格子树的权威收口（工单 12）：格 autoHeight 是带重算的切换（采纳内容动态高
+   * 并固化，非裸标志写）；其余写入后按解码强同步的不变量重断言（行宽=表宽、
+   * 内容宽/高重同步、行高取最高格）——往返恒等在任何字段编辑后不破。
+   */
+  updateSpec(path, key, value, options = {}) {
+    this.store.transact((draft) => {
+      const layer = resolveLayer(draft, path);
+      if (!layer) return;
+      if (layer.type === "TableCellLayer" && !isTemplateSubtreePath(path) && key.length === 2 && key[0] === "shape" && key[1] === "autoHeight") {
+        setCellAutoHeightInDraft(draft, path, Boolean(value), this.textPolicies);
+        return;
+      }
+      writeSpecField(layer, key, value);
+      renormalizeAutoHeightInDraft(layer);
+      canonicalizeTableSyncInDraft(draft, path, key, this.textPolicies);
+    }, options);
+  }
+  /**
+   * 更新图层数据字段（wire data.value 的领域展开，按 type 分派）：
+   * TextLayer → text、ImageLayer → src、QrCodeLayer → value；
+   * 空串/null 归空语义与解码逐条对齐（Image null、Text/Qr 空串）。
+   * 字面写解除标记（工票 02，镜像 PHP 三内容层 setter）：写值即置 expression =
+   * null，值与标记的镜像关系随之解除——标记态文档经字面编辑退化为字面态，
+   * 不可自动恢复属预期（spec §3.7 兼容面）。
+   * 表/行/格无数据字段，空转。
+   */
+  updateData(path, value, options = {}) {
+    this.store.transact((draft) => {
+      const layer = resolveLayer(draft, path);
+      if (!layer) return;
+      switch (layer.type) {
+        case "TextLayer":
+          layer.text = value == null ? "" : String(value);
+          layer.expression = null;
+          break;
+        case "ImageLayer":
+          layer.src = value == null || value === "" ? null : String(value);
+          layer.expression = null;
+          break;
+        case "QrCodeLayer":
+          layer.value = value == null ? "" : String(value);
+          layer.expression = null;
+          break;
+        default:
+          break;
+      }
+    }, options);
+  }
+  /**
+   * 数据字段表达式标记写入口（打标/解标，spec：canvas-web-expression-marking §1；
+   * 镜像 PHP 三内容层 setExpression 与 decode 标记/未标记分支）：
+   * - expression 非 null = 打标：expression 原文 + 值字段恒镜像原文（Text.text /
+   *   Image.src / QrCode.value）；标记态不做空串 →null 归一（decodeImageLayer
+   *   标记分支同门）。
+   * - expression = null = 解标：值字段保持现值退字面，`expression = null`；
+   *   字面态空值归一交给 updateData/decode 分支（这里不清值，字面接管语义）。
+   * - 仅三内容层生效，表/行/格/行模板空转（与 updateData 同门）。
+   * - updateData 语义不变：字面写解除标记仍成立（spec §1 明示两者并排）。
+   */
+  updateDataExpression(path, expression, options = {}) {
+    this.store.transact((draft) => {
+      const layer = resolveLayer(draft, path);
+      if (!layer) return;
+      switch (layer.type) {
+        case "TextLayer":
+          layer.expression = expression == null ? null : String(expression);
+          if (layer.expression !== null) layer.text = layer.expression;
+          break;
+        case "ImageLayer":
+          layer.expression = expression == null ? null : String(expression);
+          if (layer.expression !== null) layer.src = layer.expression;
+          break;
+        case "QrCodeLayer":
+          layer.expression = expression == null ? null : String(expression);
+          if (layer.expression !== null) layer.value = layer.expression;
+          break;
+        default:
+          break;
+      }
+    }, options);
+  }
+  /** 更新画布级字段（未选中图层时面板的宽/高写入口）；键由类型收窄为 width/height */
+  updateCanvasProp(key, value, options = {}) {
+    this.store.transact((draft) => {
+      draft[key] = value;
+    }, options);
+  }
+  // ---- 数据源 schema 声明（content-completion 工单 03/08）：D2 宿主随会话注入 ----
+  /**
+   * 注入数据源 schema 声明（载荷形态，D1 钉定：声明即 compile(canvas, dataset)
+   * 收到的 data 载荷形状，根上下文候选 = 载荷顶层键）。声明经
+   * normalizeExpressionSchemaSource 一次性编译收口——根级结构性问题（保留键
+   * row/$ 前缀，前移填充期 reserved_root_key；根非对象/缺 properties 层级）降级
+   * 为无候选 + console 警告，局部故障（$ref 断链/外部指针/环引用/目标形态不符）
+   * 不拒绝：该节点降叶子 + 注入期汇总告警一次，树其余部分照常服务，不抛错不
+   * 弹错（辅助声明不作权威）；null/undefined = 清除声明。声明只住 store ui 分支：
+   * 不进 graph、不落 localStorage、不进 wire；openDocument 换文档不重置，
+   * 重注入/清除走同一入口。签名与「注入即整体替换」语义不变（D6）。
+   */
+  setDataSourceSchema(raw) {
+    this.store.setDataSourceSchema(
+      raw === null || raw === void 0 ? null : normalizeExpressionSchemaSource(raw)
+    );
+  }
+  // ---- 上传（工单 13）：本机资源 → 可物化引用，实现经 uploadHandler 注入 ----
+  /** 上传可用性：未注入 uploadHandler 时为 false（宿主据此隐藏/禁用上传入口） */
+  get canUpload() {
+    return this.uploadHandler !== null;
+  }
+  /** 字体清单（内置可配置 + 自定义上传追加；清单 ≠ 物化，加载走渲染端物化管线） */
+  get fontCatalog() {
+    return this.fontCatalogValue;
+  }
+  /**
+   * 本机图片 → 新增图片图层并写入可物化引用（全流程 = 一步历史）：上传经注入
+   * 实现，引用与 addRootLayerInDraft 落同一事务（撤销一次即回退整个上传建层），
+   * 完成后自动选中新层。文档未打开直接返回 null（不产生上传副作用——字节不离开
+   * 本机）；上传失败异常上抛、文档不动。placement（kbd-nav 工单 05）缺省 =
+   * 编辑器缺省盒；`at` 图层盒左上角对准场景点、`size` 1:1 落盒不缩放（拖文件
+   * 入画布语义，自然尺寸由绑定层解码传入——内核无 DOM）。
+   */
+  async uploadImageAsLayer(file, placement = {}) {
+    if (!this.store.doc) return null;
+    const ref = await this.requireUpload(file);
+    const index = { v: -1 };
+    this.store.transact((draft) => {
+      index.v = addRootLayerInDraft(draft, "ImageLayer");
+      if (index.v < 0) return;
+      const layer = draft.layers[index.v];
+      layer.src = ref;
+      if (placement.at) layer.position = { ...layer.position, x: placement.at.x, y: placement.at.y };
+      if (placement.size) {
+        layer.shape.width = placement.size.width;
+        layer.shape.height = placement.size.height;
+      }
+    });
+    if (index.v < 0) return null;
+    const path = ["layers", index.v];
+    this.store.setSelection(path);
+    return path;
+  }
+  /**
+   * 本机图片 → 可物化引用（裸上传，不建层不写文档）：引用落到哪个图片层由
+   * 消费方决定（属性面板图片控件），与 uploadFont 同门的 bare 形态。文档未打开
+   * 直接返回 null（不产生上传副作用——字节不离开本机）；未注入 uploadHandler
+   * 抛 UploadHandlerMissingError；handler 失败异常上抛。
+   */
+  async uploadImage(file) {
+    if (!this.store.doc) return null;
+    return this.requireUpload(file);
+  }
+  /**
+   * 本机字体 → 可物化引用并加入字体清单（自定义条目，上传后即可选可用）。
+   * 不写文档：引用落到哪个文本层由宿主/绑定层决定（属性面板字体控件）。
+   */
+  async uploadFont(file) {
+    const ref = await this.requireUpload(file);
+    this.fontCatalogValue.addCustom({ label: uploadDisplayName(file), ref });
+    return ref;
+  }
+  requireUpload(file) {
+    if (this.uploadHandler === null) return Promise.reject(new UploadHandlerMissingError());
+    return this.uploadHandler(file);
+  }
+  // ---- 图层面板结构编辑（工单 10）：重排/增删走单一 action，重排两套语义分立 ----
+  /**
+   * 根层重排（图层面板拖动）：面板坐标（0 = 视觉最上层），to 为 insert-before
+   * 落点。数组序 splice + 移动层 priority 中点插值（保持「数组按 priority 降序」
+   * 的契约语义，保存再打开顺序不变），一次调用 = 一步历史。语义细节见
+   * layerPanel.moveRootLayerInDraft。
+   */
+  moveRootLayer(fromPanel, toPanel) {
+    if (!this.store.doc) return;
+    const moved = { v: null };
+    this.store.transact((draft) => {
+      moved.v = moveRootLayerInDraft(draft, fromPanel, toPanel);
+    });
+    if (moved.v === null) return;
+    this.remapPathSlices([], "layers", moved.v.from, moved.v.to);
+  }
+  /**
+   * 表格行重排（图层面板行拖动）：直接改 rows 数组序（容器内嵌套数组序语义，
+   * priority 不参与，与根层语义分立），一次调用 = 一步历史。行内后代的选择/
+   * 悬停路径随行重映射。
+   */
+  moveTableRow(tablePath, fromRow, toRow) {
+    if (!this.store.doc) return;
+    const moved = { v: null };
+    this.store.transact((draft) => {
+      moved.v = moveTableRowInDraft(draft, tablePath, fromRow, toRow);
+    });
+    if (moved.v === null) return;
+    this.remapPathSlices(tablePath, "rows", moved.v.from, moved.v.to);
+  }
+  /**
+   * 新增根层（图层面板「新增」入口）：工厂缺省形态 + 置顶 priority = min − 1
+   * （空画布 0），push 到数组尾（视觉最上层）并自动选中新层；一次调用 = 一步历史。
+   */
+  addRootLayer(type) {
+    if (!this.store.doc) return;
+    const index = { v: -1 };
+    this.store.transact((draft) => {
+      index.v = addRootLayerInDraft(draft, type);
+    });
+    if (index.v >= 0) this.store.setSelection(["layers", index.v]);
+  }
+  /**
+   * 删除图层（含子树）：根层整删、行/格 splice、格内容置 null（语义见
+   * layerPanel.deleteLayerInDraft）；选中/悬停落在被删子树内即清空，其余路径
+   * 平移重映射。一次调用 = 一步历史。
+   * 模板子树删除面（spec §3.2）：cells/content 两级放行（内核两型 union），
+   * 仅行模板替身（template 收尾路径）拦截——删行模板 = 表退出模板态，归转换
+   * 入口（convertTableToRows），不混入删除。
+   * 锁定 guard（canvas-web-layer-lock 工单 01）：路径落在锁定子树（锁定的根层
+   * 及其行/格/内容）即静默空转——Delete/⌫ 与面板删除按钮的权威挡点，无历史步。
+   */
+  deleteLayer(path) {
+    if (!this.store.doc || path[path.length - 1] === "template") return;
+    if (this.isLocked(path)) return;
+    const removed = { v: null };
+    this.store.transact((draft) => {
+      removed.v = deleteLayerInDraft(draft, path);
+    });
+    if (removed.v === null) return;
+    if (removed.v.kind === "list") {
+      this.remapPathSlices(removed.v.containerPath, removed.v.key, removed.v.index, removed.v.index);
+      return;
+    }
+    if (pathsEqual(this.store.ui.selection, removed.v.path)) this.store.setSelection(null);
+    if (pathsEqual(this.store.ui.hovered, removed.v.path)) this.store.setHovered(null);
+  }
+  /**
+   * 重命名根图层（layer-panel-ux 工单 09）：一次调用 = 一步历史（可撤销）。
+   * 仅根图层——行/格是容器内结构（显示层「行 N / 格 N」派生标签），路径非根
+   * 或不可解析一律空转（无历史步）；空名 = 回退缺省（文档 name 归空串，
+   * wire 键随之省略，显示层回落派生标签）。不改结构与 priority，选择/悬停
+   * 路径不受影响。
+   */
+  renameLayer(path, name) {
+    if (!this.store.doc || !isRootLayerPath(path)) return;
+    this.store.transact((draft) => {
+      const layer = resolveLayer(draft, path);
+      if (!layer) return;
+      layer.name = name;
+    });
+  }
+  /**
+   * 开始重命名会话（图层面板双击/铅笔/F2 的统一入口）：路径必须解析到根图层。
+   * 会话只进 ui 分支（不进历史），输入框的草稿文本住绑定层，提交经
+   * commitRename 漏斗一次性落文档。
+   */
+  beginRename(path) {
+    if (path === null || !this.store.doc || !isRootLayerPath(path)) return false;
+    if (resolveLayer(this.store.doc, path) === null) return false;
+    this.store.setRenaming(path);
+    return true;
+  }
+  /**
+   * 重命名提交漏斗的统一出口：Enter / blur 两条退出路径都收拢到这里。先清
+   * 会话再落文档——退出路径可能级联触发（Enter 提交后 input 卸载的 blur），
+   * 会话清空后后续调用幂等，保证一次退出恰一步历史。空名直传 renameLayer
+   * （回退缺省语义在内核）；与现名相同不产生历史步（进出编辑零噪声）。
+   */
+  commitRename(name) {
+    const renaming = this.store.ui.renaming;
+    if (renaming === null) return false;
+    this.store.setRenaming(null);
+    const layer = this.store.doc ? resolveLayer(this.store.doc, renaming) : null;
+    if (!layer || layer.name === name) return false;
+    this.renameLayer(renaming, name);
+    return true;
+  }
+  /** 取消重命名会话：清 ui 态不落文档（Esc 语义） */
+  cancelRename() {
+    this.store.setRenaming(null);
+  }
+  /**
+   * 切换根图层显示/隐藏（layer-panel-ux 工单 10）：一次调用 = 一步历史（可撤销）。
+   * 仅根图层——visible 在 LayerBase 面（渲染端整层跳过，行/格是容器内结构无独立
+   * 可见性），路径非根或不可解析一律空转（无历史步），与 renameLayer 同门。
+   * 隐藏的下游语义：渲染跳过（工单 01 契约）+ 命中/gizmo 过滤（spatial/hitTest、
+   * 绑定层 gizmo），编辑器 UI 只消费这里的写入口。
+   */
+  toggleLayerVisibility(path) {
+    if (!this.store.doc || !isRootLayerPath(path)) return;
+    this.store.transact((draft) => {
+      const layer = resolveLayer(draft, path);
+      if (!layer) return;
+      layer.visible = !layer.visible;
+    });
+  }
+  /**
+   * 切换根图层锁定（canvas-web-layer-lock 工单 01）：会话级锁定态，ui 分支
+   * 变更——不进历史、不写 graph、wire 零键（红线 3 同门），openDocument 重置。
+   * 仅根图层——行/格是容器内结构（锁定语义只在 LayerBase 面），路径非根或
+   * 不可解析一律空转（renameLayer/toggleLayerVisibility 同门）。
+   * 下游语义：锁定层整子树退出画布命中面（hitTest 过滤）、拖动起点/删除在
+   * 内核空转（方向键微调已随 kbd-nav 工单 02 接入同一谓词）；属性编辑/duplicate/
+   * 显隐/改名/z 序等刻意通道不受限；⌘D 副本新路径天然无锁。
+   */
+  toggleLayerLock(path) {
+    if (!this.store.doc || !isRootLayerPath(path)) return;
+    if (resolveLayer(this.store.doc, path) === null) return;
+    const current = this.store.ui.lockedPaths;
+    const next = current.some((locked) => pathsEqual(locked, path)) ? current.filter((locked) => !pathsEqual(locked, path)) : [...current, path];
+    this.store.setLockedPaths(next);
+  }
+  /**
+   * 锁定谓词（canvas-web-layer-lock 工单 01，ui 分支读取口）：路径落在锁定
+   * 子树即 true，判定收口 isLockedPath——hitTest 过滤、动作 guard、gizmo、
+   * 面板投影共用，绑定层不得自行手写锁定路径比对。
+   */
+  isLocked(path) {
+    return path !== null && isLockedPath(path, this.store.ui.lockedPaths);
+  }
+  // ---- 剪贴板与置顶/置底（工单 14）：子树深拷贝语义见 clipboard.ts ----
+  /**
+   * 复制当前选中层：子树深拷贝快照进会话剪贴板，并捕获复制时点的绝对盒（粘贴
+   * 落位基准）与源路径（sourcePath——粘贴时紧邻插入的解析凭据，alt-drag-paste
+   * 工单 02）。源须为可落根层的类型（行/格是容器内结构，v1 不可复制）；无选择/
+   * 不可复制为 false。
+   */
+  copySelection() {
+    if (!this.canCopySelection) return false;
+    const path = this.store.ui.selection;
+    const doc = this.store.doc;
+    const box = this.boxByPath(path);
+    if (!box) return false;
+    this.clipboardEntry = {
+      layer: cloneLayerSubtree(resolveLayer(doc, path)),
+      sourceBox: box,
+      sourcePath: path
+    };
+    return true;
+  }
+  /** 复制可用态（右键菜单「副本」的可用判定与 copySelection 同一语义） */
+  get canCopySelection() {
+    const path = this.store.ui.selection;
+    return path !== null && this.canCopyLayerAt(path);
+  }
+  /**
+   * 路径处图层可复制（alt-drag-paste 工单 01，Alt+拖 copyMode 的绑定层判定面）：
+   * 可解析且类型可落根层（canCopyLayerAt 同门——行/格是容器内结构不可复制，
+   * 格内容可复制）。无文档为 false。
+   */
+  canCopyLayerAt(path) {
+    const doc = this.store.doc;
+    return doc !== null && canCopyLayerAt(doc, path);
+  }
+  /**
+   * 粘贴剪贴板（alt-drag-paste 工单 02 真原位）：子树深拷贝插入根层——落点 =
+   * 复制时点绝对盒、零偏移（重复粘贴同位叠放；锚点补偿保留：dx=0 时根层源
+   * position 恒等原位、格内容源落其视觉位置）；z 序紧邻源层（sourcePath 解析
+   * 与退化置顶见 insertRootCopy）；自动选中新层；一次调用 = 一步历史。空剪贴板
+   * 为 null。每次粘贴从剪贴板快照重新克隆：粘贴产物之间以及与源文档都不共享
+   * 引用。
+   */
+  pasteFromClipboard() {
+    const entry = this.clipboardEntry;
+    const doc = this.store.doc;
+    if (!entry || !doc) return null;
+    const prepared = prepareRootPaste(entry.layer, entry.sourceBox, doc.width, doc.height, 0, 0);
+    return this.insertRootCopy(prepared, entry.sourcePath);
+  }
+  /**
+   * 创建副本 = 复制当前选中层 + 固定一格偏移（+20）+ 置顶 + 自动选中，一步历史。
+   * 落位以当前绝对盒为基准（连续副本基于选中的副本链式偏移，天然不重叠）。
+   * **不覆盖剪贴板**（先复制 A 再副本 B，粘贴仍出 A）。无选择/不可复制为 null。
+   */
+  duplicateSelection() {
+    const path = this.store.ui.selection;
+    const doc = this.store.doc;
+    if (!path || !doc || !canCopyLayerAt(doc, path)) return null;
+    const box = this.boxByPath(path);
+    if (!box) return null;
+    const prepared = prepareRootPaste(
+      resolveLayer(doc, path),
+      box,
+      doc.width,
+      doc.height,
+      PASTE_OFFSET_PX,
+      PASTE_OFFSET_PX
+    );
+    return this.insertRootCopy(prepared);
+  }
+  /**
+   * 粘贴/副本的公共落库尾：根层插入 + 自动选中新层；一次调用 = 一步历史。
+   * source 给定时先试紧邻源层（源仍可解析且为根层——alt-drag-paste 工单 02 的
+   * ⌘V 紧邻消费；路径寻址尽力而为：删源后同下标兄弟层/他文档同下标层会顶替
+   * 解析，紧邻彼层是可接受的近似，工单 Comments 记档）——原语返回 null 或条件
+   * 不满足回落置顶；source 缺省恒置顶（⌘D 语义不动）。
+   */
+  insertRootCopy(prepared, source) {
+    const index = { v: -1 };
+    this.store.transact((draft) => {
+      index.v = source !== void 0 && resolveLayer(draft, source) !== null && isRootLayerPath(source) ? insertRootLayerAdjacentInDraft(draft, prepared, source) ?? -1 : -1;
+      if (index.v < 0) index.v = insertRootLayerInDraft(draft, prepared);
+    });
+    if (index.v < 0) return null;
+    const path = ["layers", index.v];
+    this.store.setSelection(path);
+    return path;
+  }
+  // ---- 样式粘贴（canvas-web-style-paste 工单 01）：样式集/适用面常量与快照/落地纯函数在 editing/styleClipboard ----
+  /**
+   * 复制样式（⌥⌘C / 右键菜单）：按源类型适用面抓逐字段深拷贝快照进会话私有
+   * 槽（{sourceType, values}）。源为**任意可解析路径**（根/行/格/格内容/模板
+   * 子树皆可）；无文档/路径不可解析/源无样式面（行模板替身，适用面为空）空转
+   * 返回 false——空快照不占槽，已拷贝的样式不被无样式源清掉。拷贝不进历史
+   * （剪贴板态不是文档态）。
+   */
+  copyStyle(path) {
+    const doc = this.store.doc;
+    const layer = doc ? resolveLayer(doc, path) : null;
+    if (!layer) return false;
+    const snapshot = captureStyleSnapshot(layer);
+    if (!snapshot) return false;
+    this.styleClipboardEntry = snapshot;
+    return true;
+  }
+  /** 复制可用态（右键菜单）：有可解析选择且源类型有样式面 */
+  get canCopyStyle() {
+    const path = this.store.ui.selection;
+    const doc = this.store.doc;
+    if (path === null || doc === null) return false;
+    const layer = resolveLayer(doc, path);
+    return layer !== null && STYLE_FIELD_KEYS_BY_TYPE[layer.type].length > 0;
+  }
+  /**
+   * 粘贴样式（⌥⌘V / 右键菜单）：按目标类型适用面 ∩ 快照逐字段 verbatim 覆盖
+   * （null 即值、Border 整对象；快照没有的字段 = 源不适型，静默跳过）。目标为
+   * **任意可解析路径**——模板子树与格内容放行（尺寸字段不在样式集，行/格/
+   * 内容宽高强同步天然不冲突）；锁定语义天然放行（属性写通道，CONTEXT「锁定」
+   * 词条）。单事务内循环写入 + autoHeight⟹height=0 断言 + canonicalizeTableSync
+   * 一次收口（updateSpec 同门）——一次粘贴 = 一步历史，连续粘贴不合并（无
+   * mergeKey）；全等字段跳写、整事务零变化经 store 空 patch 短路不进历史；
+   * 无文档/空槽/路径不可解析空转返回 false。
+   */
+  pasteStyle(path) {
+    const entry = this.styleClipboardEntry;
+    if (!entry || !this.store.doc) return false;
+    const written = { v: [] };
+    this.store.transact((draft) => {
+      const layer = resolveLayer(draft, path);
+      if (!layer) return;
+      const keys = applyStyleFieldsInDraft(layer, entry);
+      if (keys.length === 0) return;
+      renormalizeAutoHeightInDraft(layer);
+      canonicalizeTableSyncInDraft(draft, path, keys[keys.length - 1], this.textPolicies);
+      written.v = keys;
+    });
+    return written.v.length > 0;
+  }
+  /** 粘贴可用态（右键菜单）：样式槽非空且有可解析选择；交集为零变化的空转在动作面兜底 */
+  get canPasteStyle() {
+    const path = this.store.ui.selection;
+    const doc = this.store.doc;
+    return this.styleClipboardEntry !== null && path !== null && doc !== null && resolveLayer(doc, path) !== null;
+  }
+  /**
+   * z 序四件套（右键菜单语义 + kbd-nav 工单 01 键位）：根层重排，v1 只作用根层
+   * （行/格是数组序语义）。全部复用 moveRootLayer（priority 中点插值同款——
+   * 置顶 = min−1、置底 = max+1、无整数间隙全表归一化兜底），一次调用 = 一步
+   * 历史；已在目标端为无操作（不产生历史步）。返回是否发生移动（executeShortcut
+   * 的可用态口径；右键菜单直调忽略返回值）。锁定层 z 序放行（锁定谓词的刻意
+   * 通道，canvas-web-layer-lock 工单 01 同口径）。
+   */
+  bringToFront() {
+    const panel = this.selectedRootPanelIndex();
+    if (panel === null || panel === 0) return false;
+    this.moveRootLayer(panel, 0);
+    return true;
+  }
+  sendToBack() {
+    const panel = this.selectedRootPanelIndex();
+    const count = this.store.doc?.layers.length ?? 0;
+    if (panel === null || panel === count - 1) return false;
+    this.moveRootLayer(panel, count);
+    return true;
+  }
+  /**
+   * 前移/后移一格（kbd-nav 工单 01）：面板序号 ±1 的单格重排——与置顶/置底、
+   * 面板拖动同一 moveRootLayer 语义（中点插值优先、无间隙全表归一化兜底），仅
+   * 根层（isRoot 同门），已最前/最后空转。连按各成一步历史（无 mergeKey，
+   * shortcut action 不合步的先例）。落点按「insert-before 原始序号」折算：
+   * 前移 = 插到原 panel−1 层之前（to = panel−1），后移 = 插到原 panel+1 层之后
+   * （to = panel+2）。
+   */
+  bringForward() {
+    const panel = this.selectedRootPanelIndex();
+    if (panel === null || panel <= 0) return false;
+    this.moveRootLayer(panel, panel - 1);
+    return true;
+  }
+  sendBackward() {
+    const panel = this.selectedRootPanelIndex();
+    const count = this.store.doc?.layers.length ?? 0;
+    if (panel === null || panel >= count - 1) return false;
+    this.moveRootLayer(panel, panel + 2);
+    return true;
+  }
+  /** 选中根层的面板序号（0 = 视觉最上层）；非根层选择/无文档为 null */
+  selectedRootPanelIndex() {
+    const path = this.store.ui.selection;
+    const doc = this.store.doc;
+    if (!path || !doc || !isRootLayerPath(path)) return null;
+    return doc.layers.length - 1 - path[1];
+  }
+  /**
+   * 可分派的选中根层路径（⇧⌘L/⇧⌘H 分派口守卫，工单 02）：无选择/无文档/非根
+   * 形状/悬空（不可解析）一律 null——分派口「空转返回 false」与内核 action 的
+   * 静默空转同口径（悬空窗口来自 prune 之外的结构步，兜底裁定可用态）。
+   */
+  selectableRootPath() {
+    const path = this.store.ui.selection;
+    const doc = this.store.doc;
+    if (path === null || doc === null || !isRootLayerPath(path)) return null;
+    return resolveLayer(doc, path) === null ? null : path;
+  }
+  // ---- 快捷键分派（工单 14）：注册表分类（shortcuts.ts）→ 这里执行 ----
+  /**
+   * 执行快捷键动作（注册表分类的出口）：undo/redo/delete/copy/paste/duplicate/
+   * copyStyle/pasteStyle（⌥⌘C/⌥⌘V，canvas-web-style-paste 工单 01）/
+   * rename/findReplace（⌘F，canvas-web-find-replace 工单 01）/
+   * toggleRulers/toggleLayerLock/toggleLayerVisibility 的统一分派面，以及
+   * z 序四件套与缩放三件（kbd-nav 工单 01：bringForward/sendBackward/
+   * bringToFront/sendToBack/zoomReset/fitToSurface/fitToSelection）、微调八动作
+   * （kbd-nav 工单 02：nudgeUp/Down/Left/Right + Coarse 变体，归并到同一 nudge
+   * 实现）与循环选层两动作（kbd-nav 工单 03：selectNextLayer/selectPrevLayer）；
+   * helpShortcuts（kbd-nav 工单 04）是 UI 面动作，由绑定层桥拦截路由
+   * 帮助面板、不经此处。让路规则在
+   * 分类器（classifyEditorShortcut）裁决，到达这里的动作不再重复判态；动作为
+   * 空转（无选择/空剪贴板/非根层/已在端点）返回 false，其余 true。rename 开
+   * 选中根层的重命名会话（F2，工单 09），不直接写文档；锁定/显隐作用于选中根层
+   * （canvas-web-layer-lock 工单 02 + feature-status 显隐键位挂账补位），非根/
+   * 无选择按可用态裁剪返回 false；相机三件不进历史、恒 true（surface 未知时
+   * 内核静默空转，同 toggleRulers 的无条件口径）。
+   */
+  executeShortcut(action) {
+    switch (action) {
+      case "undo":
+        this.undo();
+        return true;
+      case "redo":
+        this.redo();
+        return true;
+      case "copy":
+        return this.copySelection();
+      case "paste":
+        return this.pasteFromClipboard() !== null;
+      case "duplicate":
+        return this.duplicateSelection() !== null;
+      case "copyStyle": {
+        const path = this.store.ui.selection;
+        return path !== null && this.copyStyle(path);
+      }
+      case "pasteStyle": {
+        const path = this.store.ui.selection;
+        return path !== null && this.pasteStyle(path);
+      }
+      case "rename":
+        return this.beginRename(this.store.ui.selection);
+      case "findReplace":
+        return this.beginFind();
+      case "armCreateText":
+      case "armCreateTable":
+      case "armCreateQrCode":
+      case "armCreateImage":
+        this.armLayerCreate(ARM_CREATE_LAYER_TYPES[action]);
+        return true;
+      case "toggleRulers":
+        this.toggleRulers();
+        return true;
+      case "toggleLayerLock": {
+        const path = this.selectableRootPath();
+        if (path === null) return false;
+        this.toggleLayerLock(path);
+        return true;
+      }
+      case "toggleLayerVisibility": {
+        const path = this.selectableRootPath();
+        if (path === null) return false;
+        this.toggleLayerVisibility(path);
+        return true;
+      }
+      case "bringForward":
+        return this.bringForward();
+      case "sendBackward":
+        return this.sendBackward();
+      case "bringToFront":
+        return this.bringToFront();
+      case "sendToBack":
+        return this.sendToBack();
+      case "nudgeUp":
+        return this.nudge(0, -NUDGE_STEP_PX);
+      case "nudgeDown":
+        return this.nudge(0, NUDGE_STEP_PX);
+      case "nudgeLeft":
+        return this.nudge(-NUDGE_STEP_PX, 0);
+      case "nudgeRight":
+        return this.nudge(NUDGE_STEP_PX, 0);
+      case "nudgeUpCoarse":
+        return this.nudge(0, -NUDGE_COARSE_STEP_PX);
+      case "nudgeDownCoarse":
+        return this.nudge(0, NUDGE_COARSE_STEP_PX);
+      case "nudgeLeftCoarse":
+        return this.nudge(-NUDGE_COARSE_STEP_PX, 0);
+      case "nudgeRightCoarse":
+        return this.nudge(NUDGE_COARSE_STEP_PX, 0);
+      case "selectNextLayer":
+        return this.selectNextLayer();
+      case "selectPrevLayer":
+        return this.selectPrevLayer();
+      case "zoomReset":
+        this.resetZoom();
+        return true;
+      case "fitToSurface":
+        this.fitToSurface();
+        return true;
+      case "fitToSelection":
+        this.fitToSelection();
+        return true;
+      case "helpShortcuts":
+        return false;
+      case "delete": {
+        const path = this.store.ui.selection;
+        if (!path) return false;
+        this.deleteLayer(path);
+        return true;
+      }
+    }
+  }
+  // ---- 表格容器结构编辑（工单 12）：重建路径与 graph 解码同一套 add 同步语义 ----
+  /**
+   * 新增表格行（面板「加行」入口）：缺省行 + 缺省格（带文本内容）走重建路径
+   * （行宽=表宽、内容宽=格宽、固定格压平内容高、行高取最高格——语义见
+   * tableEditing.addTableRowInDraft），并自动选中新行；一次调用 = 一步历史。
+   */
+  addTableRow(tablePath) {
+    if (!this.store.doc) return;
+    const index = { v: -1 };
+    this.store.transact((draft) => {
+      index.v = addTableRowInDraft(draft, tablePath) ?? -1;
+    });
+    if (index.v >= 0) this.store.setSelection([...tablePath, "rows", index.v]);
+  }
+  /**
+   * 新增表格单元格（面板「加格」入口）：缺省格 + 缺省文本内容走重建路径
+   * （内容宽=格宽、固定格压平内容高、行高取最高格），并自动选中新格；
+   * 一次调用 = 一步历史。
+   */
+  addTableCell(rowPath) {
+    if (!this.store.doc) return;
+    const index = { v: -1 };
+    this.store.transact((draft) => {
+      index.v = addTableCellInDraft(draft, rowPath) ?? -1;
+    });
+    if (index.v >= 0) this.store.setSelection([...rowPath, "cells", index.v]);
+  }
+  /**
+   * 新增模板表（「+」选择器入口，spec §2.1）：createTemplateTable 缺省形态 +
+   * 置顶 + 自动选中；一次调用 = 一步历史。rowsPath 必填（解码 rows_path_missing
+   * 硬约束的对齐兜底，表单校验前置），空串 no-op。
+   */
+  addTemplateTable(rowsPath) {
+    if (!this.store.doc || rowsPath === "") return;
+    const index = { v: -1 };
+    this.store.transact((draft) => {
+      index.v = insertRootLayerInDraft(draft, createTemplateTable({ rowsPath }));
+    });
+    if (index.v >= 0) this.store.setSelection(["layers", index.v]);
+  }
+  /**
+   * 模板行加格（spec §3.1）：addTemplateCellInDraft 重建路径（末格宽/首格行宽、
+   * 零高度耦合），自动选中新格；一次调用 = 一步历史。非模板态 no-op。
+   */
+  addTemplateCell(tablePath) {
+    if (!this.store.doc) return;
+    const index = { v: -1 };
+    this.store.transact((draft) => {
+      index.v = addTemplateCellInDraft(draft, tablePath) ?? -1;
+    });
+    if (index.v >= 0) this.store.setSelection([...tablePath, "template", "cells", index.v]);
+  }
+  /**
+   * V1→V2 转换（spec §2.3）：rowsPath 必填（空串 no-op，表单校验前置）；rows
+   * 子树内的选择/悬停回落表路径（rows 已清空不悬空）。一次调用 = 一步历史。
+   */
+  convertTableToTemplate(tablePath, rowsPath) {
+    if (!this.store.doc || rowsPath === "") return;
+    const done = { v: false };
+    this.store.transact((draft) => {
+      done.v = convertTableToTemplateInDraft(draft, tablePath, rowsPath) === true;
+    });
+    if (done.v) this.clampSubtreeSelection(tablePath);
+  }
+  /**
+   * V2→V1 逆向转换（spec §2.3）：模板实例化为单行（V1 归一重断言——auto 格
+   * 采纳/固化、行高取最高格）；模板子树内的选择/悬停回落表路径。一次调用 =
+   * 一步历史。
+   */
+  convertTableToRows(tablePath) {
+    if (!this.store.doc) return;
+    const done = { v: false };
+    this.store.transact((draft) => {
+      done.v = convertTableToRowsInDraft(draft, tablePath, this.textPolicies) === true;
+    });
+    if (done.v) this.clampSubtreeSelection(tablePath);
+  }
+  /** 子树内选择/悬停回落到子树根（容器清空后不悬空）；子树外原样不动 */
+  clampSubtreeSelection(rootPath) {
+    const selection = this.store.ui.selection;
+    if (selection !== null && selection.length > rootPath.length && pathStartsWith(selection, rootPath)) {
+      this.store.setSelection(rootPath);
+    }
+    const hovered = this.store.ui.hovered;
+    if (hovered !== null && hovered.length > rootPath.length && pathStartsWith(hovered, rootPath)) {
+      this.store.setHovered(rootPath);
+    }
+  }
+  /**
+   * 单元格移动：落点为「insert-before 原始序号」的目标行 + 序号。同行退化为
+   * 数组序重排（与行重排同款 moveGuard 语义），跨行走重建路径（目标行高取
+   * 最高格、内容层归属随格重同步）。一次调用 = 一步历史。
+   */
+  moveTableCellToRow(cellPath, targetRowPath, toCell) {
+    if (!this.store.doc) return;
+    const sourceRowPath = cellPath.slice(0, -2);
+    if (pathsEqual(sourceRowPath, targetRowPath)) {
+      const from = cellPath[cellPath.length - 1];
+      if (typeof from === "number") this.moveTableCell(sourceRowPath, from, toCell);
+      return;
+    }
+    const moved = { v: null };
+    this.store.transact((draft) => {
+      moved.v = moveTableCellToRowInDraft(draft, cellPath, targetRowPath, toCell, this.textPolicies);
+    });
+    if (moved.v !== null) this.remapMovedSubtree(moved.v);
+  }
+  /** 同行单元格重排（直接改 cells 数组序，容器内嵌套数组序语义） */
+  moveTableCell(rowPath, fromCell, toCell) {
+    if (!this.store.doc) return;
+    const moved = { v: null };
+    this.store.transact((draft) => {
+      moved.v = moveTableCellInDraft(draft, rowPath, fromCell, toCell);
+    });
+    if (moved.v === null) return;
+    this.remapPathSlices(rowPath, "cells", moved.v.from, moved.v.to);
+  }
+  /**
+   * 行移动：落点为「insert-before 原始序号」的目标表 + 序号。同表退化为数组序
+   * 重排（moveTableRow），跨表走重建路径（行宽同步目标表宽——addRow 副作用）。
+   * 一次调用 = 一步历史。
+   */
+  moveTableRowToTable(rowPath, targetTablePath, toRow) {
+    if (!this.store.doc) return;
+    const sourceTablePath = rowPath.slice(0, -2);
+    if (pathsEqual(sourceTablePath, targetTablePath)) {
+      const from = rowPath[rowPath.length - 1];
+      if (typeof from === "number") this.moveTableRow(sourceTablePath, from, toRow);
+      return;
+    }
+    const moved = { v: null };
+    this.store.transact((draft) => {
+      moved.v = moveTableRowToTableInDraft(draft, rowPath, targetTablePath, toRow);
+    });
+    if (moved.v !== null) this.remapMovedSubtree(moved.v);
+  }
+  /**
+   * 格 autoHeight 切换：开且带内容 = 采纳内容动态高（autowrap 文本即
+   * 「行数×行高+padding」）并固化（解码对带内容的格恒归一为固定高）；开且空格 =
+   * 置标志；关 = 清标志。采纳可能增高，行高随之取最高格。一次调用 = 一步历史。
+   */
+  setCellAutoHeight(cellPath, on) {
+    if (!this.store.doc) return;
+    const applied = { v: false };
+    this.store.transact((draft) => {
+      applied.v = setCellAutoHeightInDraft(draft, cellPath, on, this.textPolicies);
+    });
+    if (applied.v) this.pruneDanglingPaths();
+  }
+  // ---- 撤销/重做（工单 08）：双栈语义全在 store，会话只透传查询与动作 ----
+  get canUndo() {
+    return this.store.canUndo;
+  }
+  get canRedo() {
+    return this.store.canRedo;
+  }
+  undo() {
+    this.store.undo();
+    this.pruneDanglingPaths();
+  }
+  redo() {
+    this.store.redo();
+    this.pruneDanglingPaths();
+  }
+  // ---- 订阅与失效 ----
+  subscribe(listener) {
+    return this.store.subscribe(listener);
+  }
+  /** 外部脏源入口（如资源物化完成 → 'content'） */
+  invalidate(target = "both") {
+    if (target === "content") this.dirty.content = true;
+    else if (target === "overlay") this.dirty.overlay = true;
+    else {
+      this.dirty.content = true;
+      this.dirty.overlay = true;
+    }
+    this.requestFrame();
+  }
+  /**
+   * 挂起帧同步排空（canvas-web-render-perf 工单 01）：绑定层在「物理缓冲已被清空、
+   * 需要背靠背补绘」的时机调用（CanvasSurface 的 resizeBuffers 赋 canvas.width 清屏
+   * 后——ResizeObserver 回调在本帧 rAF 之后，等下帧重绘必现一帧空白）。有挂起帧即
+   * 取消排定并按当前脏标立即 flush；无挂起帧空转幂等。内核保持无 DOM：只操作既有
+   * cancelFrame/flush，不感知帧源（rAF 语义归绑定层注入的调度器）。
+   */
+  flushPendingFrames() {
+    if (!this.frameQueued) return;
+    this.cancelFrame?.();
+    this.flush();
+  }
+  /** 取消挂起帧、退订 store、解绑绘制面 */
+  dispose() {
+    if (this.cancelFrame) this.cancelFrame();
+    this.cancelFrame = null;
+    this.frameQueued = false;
+    this.unsubscribeStore();
+    this.detachSurfaces();
+  }
+  // ---- 内部：合帧与重绘 ----
+  /**
+   * 结构变更后重映射 ui 分支的路径态（选择/悬停/重命名会话/锁定集合）：路径是
+   * 数组下标身份，容器 splice 后按 remapPathAfterSplice 平移，被移出子树的路径
+   * 落地为清除。ui 整体替换、不进历史；值未变的路径 set* 内部值等短路。
+   * 锁定集合（canvas-web-layer-lock 工单 01）作为集合平移——锁「胶在层上」走过
+   * splice（兄弟增删/根层重排后锁仍指原层），被移出容器的锁定路径落地解锁。
+   */
+  remapPathSlices(containerPath, key, from, to) {
+    const remap = (path) => path === null ? null : remapPathAfterSplice(path, containerPath, key, from, to);
+    const selection = remap(this.store.ui.selection);
+    if (selection !== this.store.ui.selection) this.store.setSelection(selection);
+    const hovered = remap(this.store.ui.hovered);
+    if (hovered !== this.store.ui.hovered) this.store.setHovered(hovered);
+    const renaming = remap(this.store.ui.renaming);
+    if (renaming !== this.store.ui.renaming) this.store.setRenaming(renaming);
+    this.store.setLockedPaths(this.remappedLocks(this.store.ui.lockedPaths, remap));
+  }
+  /**
+   * 锁定集合经映射平移（canvas-web-layer-lock 工单 01）：逐路径过 map、滤除
+   * 落地 null 的悬空路径；集合未变时 setLockedPaths 内容等短路（无锁/未变
+   * 不通知）。remapPathSlices 的 splice 平移与 remapMovedSubtree 的前缀重挂
+   * 共用同一形状——后者必须传移动前捕获的集合（源 splice 步已丢掉移动子树
+   * 内的锁）。
+   */
+  remappedLocks(paths, map) {
+    return paths.reduce((kept, locked) => {
+      const mapped = map(locked);
+      if (mapped !== null) kept.push(mapped);
+      return kept;
+    }, []);
+  }
+  /**
+   * 跨容器移动后的选择/悬停/锁定集合重映射（工单 12 + canvas-web-layer-lock
+   * 工单 01）：先做源容器纯删除与目标容器纯插入的索引平移（移动子树内的路径
+   * 在源删除步被置 null，不参与平移），再把移动前落在移动子树内的路径按前缀
+   * 重挂到新位置（子树内部相对结构不变，仅容器段整体替换）。锁定集合的重挂
+   * 当前是不变量兜底——锁定恒为根层路径、跨容器移动的子树恒为行/格子树，两集
+   * 天然不相交；将来锁面扩展或根层跨容器移动接入时语义已在。
+   */
+  remapMovedSubtree(moved) {
+    const selectionBefore = this.store.ui.selection;
+    const hoveredBefore = this.store.ui.hovered;
+    const lockedBefore = this.store.ui.lockedPaths;
+    this.remapPathSlices(moved.source.containerPath, moved.source.key, moved.source.from, moved.source.to);
+    this.remapPathSlices(moved.target.containerPath, moved.target.key, moved.target.from, moved.target.to);
+    const rebase = (before) => {
+      if (before === null || !pathStartsWith(before, moved.fromPath)) return null;
+      return [...moved.toPath, ...before.slice(moved.fromPath.length)];
+    };
+    const selection = rebase(selectionBefore);
+    if (selection !== null && !pathsEqual(this.store.ui.selection, selection)) {
+      this.store.setSelection(selection);
+    }
+    const hovered = rebase(hoveredBefore);
+    if (hovered !== null && !pathsEqual(this.store.ui.hovered, hovered)) {
+      this.store.setHovered(hovered);
+    }
+    const rebasedLocks = this.remappedLocks(lockedBefore, rebase);
+    if (rebasedLocks.length > 0) {
+      this.store.setLockedPaths([...this.store.ui.lockedPaths, ...rebasedLocks]);
+    }
+  }
+  /**
+   * 悬空路径清理：选择/悬停/重命名会话指向已不存在的图层即清空（撤销/重做与
+   * 采纳类收口共用）。锁定集合同门（canvas-web-layer-lock 工单 01）：锁定路径
+   * 悬空即解锁。已知限制（spec §3 记档不修）：undo/redo 只有 prune 无平移——
+   * 跨结构步撤销后锁可能错位（路径仍可解析、指到别的层）或清失，锁定钮常显
+   * 可目视纠正；wire 持久化（锁长在层对象上）根治。
+   */
+  pruneDanglingPaths() {
+    const doc = this.store.doc;
+    if (!doc) return;
+    const { selection, hovered, renaming } = this.store.ui;
+    if (selection !== null && resolveLayer(doc, selection) === null) this.store.setSelection(null);
+    if (hovered !== null && resolveLayer(doc, hovered) === null) this.store.setHovered(null);
+    if (renaming !== null && resolveLayer(doc, renaming) === null) this.store.setRenaming(null);
+    this.store.setLockedPaths(
+      this.store.ui.lockedPaths.filter((locked) => resolveLayer(doc, locked) !== null)
+    );
+  }
+  onStoreChange(change) {
+    if (change.scope === "doc") this.invalidate("both");
+    else if (change.branch === "viewport") this.invalidate("both");
+    else if (change.branch === "editing") this.invalidate("both");
+    else if (change.branch === "resourceStatuses") this.invalidate("both");
+    else if (change.branch === "dataSourceSchema") return;
+    else this.invalidate("overlay");
+  }
+  requestFrame() {
+    if (this.frameQueued) return;
+    this.frameQueued = true;
+    this.cancelFrame = this.scheduleFrame(() => this.flush());
+  }
+  flush() {
+    this.frameQueued = false;
+    this.cancelFrame = null;
+    const { content, overlay } = this.dirty;
+    this.dirty = { content: false, overlay: false };
+    if (content) this.repaintContent();
+    if (overlay) this.repaintOverlay();
+  }
+  presentedViewport() {
+    return snapViewportToPhysicalPixels(this.store.ui.viewport, this.dpr);
+  }
+  repaintContent() {
+    const doc = this.store.doc;
+    const view = this.previewCanvas;
+    if (!doc || !view || !this.backend) return;
+    const viewport = this.presentedViewport();
+    const transform = {
+      dpr: this.dpr,
+      zoom: viewport.zoom,
+      x: viewport.x,
+      y: viewport.y
+    };
+    this.backend.setViewportTransform?.(transform);
+    const editing = this.store.ui.editing;
+    let editingLayer = null;
+    if (editing) {
+      const viewPath = docPathToViewPath(doc, editing.path);
+      editingLayer = viewPath ? resolveLayer(view, viewPath) : null;
+    }
+    renderCanvas(view, this.backend, this.textPolicies, editingLayer ? { skipContent: (layer) => layer === editingLayer } : void 0);
+  }
+  repaintOverlay() {
+    if (!this.overlayPainter) return;
+    this.overlayPainter({
+      viewport: this.presentedViewport(),
+      dpr: this.dpr,
+      doc: this.store.doc
+    });
+  }
+};
+
+// src/spatial/wheel.ts
+function classifyWheel(input) {
+  if (input.ctrlKey || input.metaKey) return "zoom";
+  if (input.shiftKey) return "pan-x";
+  return "pan";
+}
+
+// src/shared/expressionCandidates.ts
+function headName(head) {
+  if (head.kind === "row") return "row";
+  if (head.kind === "root") return "$root";
+  return head.name;
+}
+function candidateMeta(node) {
+  const meta = {};
+  if (node.description !== void 0) meta.description = node.description;
+  if (node.title !== void 0) meta.title = node.title;
+  if (node.type !== void 0) meta.type = node.type;
+  return meta;
+}
+function childCandidate(entry, prefix) {
+  const path = prefix === "" ? entry.key : `${prefix}.${entry.key}`;
+  return { path, segment: entry.key, ...candidateMeta(entry.node) };
+}
+function headCandidates(schema, context, rowSchema) {
+  const view = schemaChildEntries(schema);
+  const candidates = view.entries.map((entry) => childCandidate(entry, ""));
+  candidates.push({ path: "$root", segment: "$root" });
+  if (context === "row") {
+    candidates.push(rowSchema ? { path: "row", segment: "row", ...candidateMeta(rowSchema) } : { path: "row", segment: "row" });
+    candidates.push({ path: "$index", segment: "$index" });
+  }
+  return view.open === true ? { candidates, open: true } : { candidates };
+}
+function enumerateExpressionCandidates(schema, query) {
+  if (schema === null) {
+    return { ok: true, prefix: "", partial: "", candidates: [] };
+  }
+  const hadTrailingDot = query.expr.endsWith(".");
+  const stripped = hadTrailingDot ? query.expr.slice(0, -1) : query.expr;
+  if (stripped === "") {
+    if (query.expr === "") {
+      return { ok: true, prefix: "", partial: "", ...headCandidates(schema, query.context, query.rowSchema) };
+    }
+    return { ok: false, reason: "expression_syntax_error" };
+  }
+  const parsed = parseExpressionPath(stripped);
+  if (!parsed.ok) {
+    return { ok: false, reason: "expression_syntax_error" };
+  }
+  const { head, rest } = parsed;
+  let prefixPath;
+  let partial;
+  if (hadTrailingDot) {
+    prefixPath = [headName(head), ...rest];
+    partial = "";
+  } else if (rest.length > 0) {
+    prefixPath = [headName(head), ...rest.slice(0, -1)];
+    partial = rest[rest.length - 1];
+  } else {
+    prefixPath = [];
+    partial = headName(head);
+  }
+  if (prefixPath.length === 0) {
+    return { ok: true, prefix: "", partial, ...headCandidates(schema, query.context, query.rowSchema) };
+  }
+  let base;
+  let segments;
+  if (head.kind === "row") {
+    if (query.context !== "row") {
+      return { ok: true, prefix: prefixPath.join("."), partial, candidates: [] };
+    }
+    base = query.rowSchema ?? null;
+    segments = prefixPath.slice(1);
+  } else if (head.kind === "root") {
+    base = schema;
+    segments = prefixPath.slice(1);
+  } else if (head.name === "$index") {
+    return { ok: true, prefix: prefixPath.join("."), partial, candidates: [] };
+  } else {
+    base = schema;
+    segments = prefixPath;
+  }
+  const node = base === null ? null : schemaNodeAtPath(base, segments);
+  const prefix = prefixPath.join(".");
+  if (node === null) {
+    return { ok: true, prefix, partial, candidates: [] };
+  }
+  const view = schemaChildEntries(node);
+  return {
+    ok: true,
+    prefix,
+    partial,
+    candidates: view.entries.map((entry) => childCandidate(entry, prefix)),
+    ...view.open === true ? { open: true } : {}
+  };
+}
+
+// src/shared/rowsPathCandidates.ts
+function isArrayNode(node) {
+  return node.type === "array" || node.items !== void 0;
+}
+function isScalarNode(node) {
+  return !isArrayNode(node) && node.properties === void 0 && node.open !== true;
+}
+function childCandidate2(key, node, prefix) {
+  const candidate = {
+    path: prefix === "" ? key : `${prefix}.${key}`,
+    segment: key
+  };
+  if (node.description !== void 0) candidate.description = node.description;
+  if (node.title !== void 0) candidate.title = node.title;
+  if (isArrayNode(node)) candidate.type = "array";
+  return candidate;
+}
+function levelCandidates(base, prefix) {
+  const candidates = [];
+  if (base.properties !== void 0) {
+    for (const [key, child] of base.properties) {
+      if (isScalarNode(child)) continue;
+      candidates.push(childCandidate2(key, child, prefix));
+    }
+  }
+  return base.open === true ? { candidates, open: true } : { candidates };
+}
+function enumerateRowsPathCandidates(startSchema, input) {
+  if (startSchema === null) return null;
+  const segments = input.split(".");
+  const partial = input.endsWith(".") ? "" : segments[segments.length - 1];
+  const completed = segments.slice(0, -1);
+  let base = startSchema;
+  for (const segment of completed) {
+    if (isArrayNode(base)) return null;
+    const child = schemaNodeAtPath(base, [segment]);
+    if (child === null) return null;
+    base = child;
+  }
+  if (isArrayNode(base) || isScalarNode(base)) return null;
+  const view = levelCandidates(base, completed.join("."));
+  return {
+    partial,
+    candidates: view.candidates,
+    ...view.open === true ? { open: true } : {}
+  };
+}
+function resolveRowsPathStartSchema(doc, path, rootSchema) {
+  if (rootSchema === null) return null;
+  if (doc === null || path === null) return rootSchema;
+  let current = null;
+  for (let i = 0; i < path.length; i += 1) {
+    if (path[i] !== "template") continue;
+    const table = resolveLayer(doc, path.slice(0, i));
+    if (table === null || table.type !== "TableLayer") return null;
+    current = resolveRowSchema(current ?? rootSchema, table.rowsPath);
+    if (current === null) return null;
+  }
+  return current ?? rootSchema;
+}
+
+// src/shared/textPoliciesMemo.ts
+import {
+  createUax14LineBreaker,
+  heuristicMeasurerFactory
+} from "@hankchen/canvas";
+var DEFAULT_LINE_ENTRIES = 512;
+var DEFAULT_MEASURE_ENTRIES = 2048;
+var LruCache = class {
+  constructor(capacity) {
+    this.capacity = capacity;
+  }
+  capacity;
+  entries = /* @__PURE__ */ new Map();
+  get(key) {
+    const hit = this.entries.get(key);
+    if (hit !== void 0) {
+      this.entries.delete(key);
+      this.entries.set(key, hit);
+    }
+    return hit;
+  }
+  put(key, value) {
+    if (this.entries.size >= this.capacity) {
+      const oldest = this.entries.keys().next().value;
+      if (oldest !== void 0) this.entries.delete(oldest);
+    }
+    this.entries.set(key, value);
+  }
+};
+function memoizeTextPolicies(policies = {}, options = {}) {
+  const linesCache = new LruCache(options.maxLineEntries ?? DEFAULT_LINE_ENTRIES);
+  const measureCache = new LruCache(options.maxMeasureEntries ?? DEFAULT_MEASURE_ENTRIES);
+  let context = { font: "", fontSize: 0 };
+  const measureMemoFactory = (font, fontSize) => {
+    context = { font, fontSize };
+    const base = (policies.measurerFactory ?? heuristicMeasurerFactory)(font, fontSize);
+    return {
+      measure(text) {
+        const key = `${font}\0${fontSize}\0${text}`;
+        const hit = measureCache.get(key);
+        if (hit !== void 0) return hit;
+        const width = base.measure(text);
+        measureCache.put(key, width);
+        return width;
+      }
+    };
+  };
+  const lineBreakerMemo = (text, width, measurer) => {
+    const key = `${context.font}\0${context.fontSize}\0${width}\0${text}`;
+    const hit = linesCache.get(key);
+    if (hit !== void 0) return hit;
+    const lines = (policies.lineBreaker ?? createUax14LineBreaker())(text, width, measurer);
+    linesCache.put(key, lines);
+    return lines;
+  };
+  return { lineBreaker: lineBreakerMemo, measurerFactory: measureMemoFactory };
+}
+
+// src/shared/resourceStatus.ts
+import { contentHeight, contentWidth } from "@hankchen/canvas";
+function isImageContentUndrawn(layer, statuses) {
+  if (layer.type !== "ImageLayer") return false;
+  if (layer.expression !== null) return true;
+  if (layer.src === null) return true;
+  if (contentWidth(layer) <= 0 || contentHeight(layer) <= 0) return true;
+  if (statuses !== void 0) {
+    const status = statuses[layer.src];
+    if (status !== void 0 && status !== "done") return true;
+  }
+  return false;
+}
+
+// src/index.ts
+import {
+  ANCHORS,
+  HORIZONTAL_ALIGNS,
+  LAYER_TYPES,
+  VERTICAL_ALIGNS
+} from "@hankchen/canvas";
+import { canvasFontCssFamily } from "@hankchen/canvas-browser-renderer";
+var PACKAGE_NAME = "@hankchen/canvas-editor";
+export {
+  ALIGN_CORNER_MARGIN_PX,
+  ALT_DRAG_DEAD_ZONE_SCREEN_PX,
+  ANCHORS,
+  ARM_CREATE_LAYER_TYPES,
+  CREATE_DEAD_ZONE_SCREEN_PX,
+  DEFAULT_EDITOR_SHORTCUTS,
+  DEFAULT_ZOOM_BOUNDS,
+  EditorSession,
+  EditorStore,
+  FontCatalog,
+  HORIZONTAL_ALIGNS,
+  LAYER_TYPES,
+  MAX_HISTORY_STEPS,
+  PACKAGE_NAME,
+  PAN_TO_BOX_MARGIN_PX,
+  PASTE_OFFSET_PX,
+  PHP_TRIM_CHARS,
+  RESIZE_HANDLES,
+  RESIZE_HANDLE_HIT_PX,
+  RESIZE_MIN_SIZE_PX,
+  SNAP_THRESHOLD_SCREEN_PX,
+  STYLE_FIELD_KEYS_BY_TYPE,
+  UploadHandlerMissingError,
+  VERTICAL_ALIGNS,
+  WHEEL_ZOOM_STEP,
+  addRootLayerInDraft,
+  addTableCellInDraft,
+  addTableRowInDraft,
+  addTemplateCellInDraft,
+  alignToCanvasTarget,
+  applyStyleFieldsInDraft,
+  buildLayerOutline,
+  canCopyLayerAt,
+  canonicalizeTableSyncInDraft,
+  canvasFontCssFamily,
+  captureStyleSnapshot,
+  clampZoom,
+  classifyEditorShortcut,
+  classifyWheel,
+  cloneLayerSubtree,
+  convertTableToRowsInDraft,
+  convertTableToTemplateInDraft,
+  createDefaultLayer,
+  createRubberBandRect,
+  createTemplateTable,
+  deleteLayerInDraft,
+  enumerateExpressionCandidates,
+  enumerateRowsPathCandidates,
+  expressionFragmentAtCursor,
+  fitRect,
+  fitViewport,
+  growRowToCellInDraft,
+  handleResizesHeight,
+  handleResizesWidth,
+  hitTest,
+  insertRootLayerAdjacentInDraft,
+  insertRootLayerInDraft,
+  isImageContentUndrawn,
+  isLayerPath,
+  isLockedPath,
+  isRootLayerPath,
+  isRootPasteableType,
+  isTemplateSubtreePath,
+  layerBoxByPath,
+  memoizeTextPolicies,
+  moveGuard,
+  moveRootLayerInDraft,
+  moveTableCellInDraft,
+  moveTableCellToRowInDraft,
+  moveTableRowInDraft,
+  moveTableRowToTableInDraft,
+  nextZoomByWheel,
+  normalizeExpressionSchemaSource,
+  panBy,
+  panToBox,
+  parseExpressionPath,
+  parseExpressionSchema,
+  pastePosition,
+  pathStartsWith,
+  pathsEqual,
+  prepareRootPaste,
+  readSpecField,
+  remapPathAfterSplice,
+  replaceHitsInDraft,
+  resizableAxesAt,
+  resizeBox,
+  resizeHandleAt,
+  resizeHandlePoint,
+  resizeHandlesAt,
+  resizeSnapPoints,
+  resolveLayer,
+  resolveRowSchema,
+  resolveRowsPathStartSchema,
+  resolveSnap,
+  resolveSnapPoints,
+  rootLayerOf,
+  scanExpressionFragments,
+  scanTextMatches,
+  sceneToScreen,
+  schemaChildEntries,
+  schemaNodeAtPath,
+  screenToScene,
+  selectionParentPath,
+  setCellAutoHeightInDraft,
+  snapAxesFromBoxes,
+  snapThresholdScene,
+  snapViewportToPhysicalPixels,
+  syncContentIntoCellInDraft,
+  syncRowWidthInDraft,
+  uploadDisplayName,
+  visibleRootBoxes,
+  writeSpecField,
+  zoomAtPoint
+};
+//# sourceMappingURL=index.js.map