@hankchen/canvas-editor 0.4.0 → 0.6.0

package/dist/index.js

@@ -382,11 +382,22 @@ function resolveSnap(box, axes, threshold) {
 
 // src/spatial/create.ts
 var CREATE_DEAD_ZONE_SCREEN_PX = 4;
-function createRubberBandRect(type, start, current, axes, threshold) {
+function createRubberBandRect(type, start, current, axes, threshold, ratio) {
   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 dx = Math.abs(current.x - start.x);
+  const dy = Math.abs(current.y - start.y);
+  let width = dx;
+  let height = dy;
+  if (type === "QrCodeLayer") {
+    height = width;
+  } else if (ratio) {
+    if (dx >= dy) {
+      height = Math.round(dx * ratio.h / ratio.w);
+    } else {
+      width = Math.round(dy * ratio.w / ratio.h);
+    }
+  }
   const resolution = resolveSnapPoints(
     { vertical: [x, x + width], horizontal: [y, y + height] },
     axes,
@@ -435,6 +446,38 @@ function resizeSnapPoints(start, handle, dx, dy) {
   if (SOUTH_HANDLES.has(handle)) horizontal.push(start.y + start.height + dy);
   return { vertical, horizontal };
 }
+function proportionalDrivingAxis(handle, dx, dy) {
+  const corner = handleResizesWidth(handle) && handleResizesHeight(handle);
+  if (corner) return Math.abs(dx) >= Math.abs(dy) ? "width" : "height";
+  return handleResizesWidth(handle) ? "width" : "height";
+}
+function resizeBoxProportional(start, handle, reference, driving, dx, dy, minSize = RESIZE_MIN_SIZE_PX) {
+  const west = WEST_HANDLES.has(handle);
+  const north = NORTH_HANDLES.has(handle);
+  let width;
+  let height;
+  if (driving === "width") {
+    width = Math.max(west ? start.width - dx : start.width + dx, minSize);
+    height = Math.max(Math.round(width * reference.h / reference.w), minSize);
+  } else {
+    height = Math.max(north ? start.height - dy : start.height + dy, minSize);
+    width = Math.max(Math.round(height * reference.w / reference.h), minSize);
+  }
+  return {
+    x: west ? start.x + start.width - width : start.x,
+    y: north ? start.y + start.height - height : start.y,
+    width,
+    height
+  };
+}
+function resizeProportionalSnapPoints(start, handle, driving, dx, dy) {
+  if (driving === "width") {
+    const vertical = WEST_HANDLES.has(handle) ? [start.x + dx] : EAST_HANDLES.has(handle) ? [start.x + start.width + dx] : [];
+    return { vertical, horizontal: [] };
+  }
+  const horizontal = NORTH_HANDLES.has(handle) ? [start.y + dy] : SOUTH_HANDLES.has(handle) ? [start.y + start.height + dy] : [];
+  return { vertical: [], horizontal };
+}
 var NO_AXES = { width: false, height: false };
 function resizableAxesAt(doc, path) {
   const layer = resolveLayer(doc, path);
@@ -602,7 +645,6 @@ function compileRefNode(raw, rawRef, declPath, ctx) {
 }
 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();
@@ -616,6 +658,23 @@ function compileInlineNode(raw, declPath, ctx) {
   if (isPlainObject(rawItems)) node.items = compileSchemaNode(rawItems, `${declPath}/items`, ctx);
   return node;
 }
+var OPEN_MAP_DETAIL_SUFFIX = "\u2014\u2014\u5F00\u653E\u6620\u5C04\u5951\u7EA6\u5DF2\u5E9F\u9664\uFF0C\u52A8\u6001\u952E\u8BF7\u7531\u5BBF\u4E3B\u7EC4\u88C5\u6210\u5177\u4F53 properties \u540E\u6CE8\u5165";
+function findOpenMapping(raw, path) {
+  if (Array.isArray(raw)) {
+    for (let i = 0; i < raw.length; i += 1) {
+      const hit = findOpenMapping(raw[i], `${path}/${i}`);
+      if (hit !== null) return hit;
+    }
+    return null;
+  }
+  if (!isPlainObject(raw)) return null;
+  if (raw["additionalProperties"] === true) return path;
+  for (const [key, value] of Object.entries(raw)) {
+    const hit = findOpenMapping(value, `${path}/${pointerEscape(key)}`);
+    if (hit !== null) return hit;
+  }
+  return null;
+}
 function parseExpressionSchema(raw) {
   if (!isPlainObject(raw)) {
     return { ok: false, reason: "invalid_schema", detail: "schema \u6839\u5FC5\u987B\u662F\u5BF9\u8C61\u58F0\u660E" };
@@ -631,6 +690,10 @@ function parseExpressionSchema(raw) {
   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 openPath = findOpenMapping(raw, "#");
+  if (openPath !== null) {
+    return { ok: false, reason: "open_map_unsupported", detail: `"${openPath}" \u58F0\u660E\u4E86 additionalProperties: true${OPEN_MAP_DETAIL_SUFFIX}` };
+  }
   const diagnostics = [];
   const schema = compileSchemaNode(raw, "#", { root: raw, diagnostics, activePath: /* @__PURE__ */ new Set() });
   return { ok: true, schema, diagnostics };
@@ -672,7 +735,7 @@ function schemaNodeAtPath(node, segments) {
 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 };
+  return { entries };
 }
 function resolveRowSchema(root, rowsPath) {
   const segments = rowsPath.split(".");
@@ -712,6 +775,9 @@ function skipWs(expr, pos) {
   while (pos < expr.length && WS_CHARS.includes(expr[pos])) pos += 1;
   return pos;
 }
+function fail(kind, start, end) {
+  return { ok: false, error: "expression_syntax_error", kind, at: { start, end } };
+}
 function isCallFragment(expr) {
   let head = 0;
   while (head < expr.length && !HEAD_STOP_CHARS.includes(expr[head])) head += 1;
@@ -723,26 +789,30 @@ function isCallFragment(expr) {
 function parseExpressionCall(expr) {
   let head = 0;
   while (head < expr.length && !HEAD_STOP_CHARS.includes(expr[head])) head += 1;
-  if (head === 0) return { ok: false, error: "expression_syntax_error" };
+  if (head === 0) return fail("invalid_path", 0, expr.length);
   const name = expr.slice(0, head);
   let pos = skipWs(expr, head);
-  if (pos >= expr.length || expr[pos] !== "(") return { ok: false, error: "expression_syntax_error" };
+  if (pos >= expr.length || expr[pos] !== "(") return fail("missing_open_paren", head, expr.length);
+  const openParen = pos;
   pos = skipWs(expr, pos + 1);
   const args = [];
+  const spans = [];
   if (pos < expr.length && expr[pos] === ")") {
     pos += 1;
   } else {
     for (; ; ) {
-      if (pos >= expr.length) return { ok: false, error: "expression_syntax_error" };
+      if (pos >= expr.length) return fail("unbalanced_paren", openParen, expr.length);
       const arg = parseCallArg(expr, pos);
       if (!arg.ok) return arg;
       args.push(arg.value);
+      spans.push({ start: arg.start, end: arg.end });
       pos = skipWs(expr, arg.end);
-      if (pos >= expr.length) return { ok: false, error: "expression_syntax_error" };
+      if (pos >= expr.length) return fail("unbalanced_paren", openParen, expr.length);
       if (expr[pos] === ",") {
+        const comma = pos;
         pos = skipWs(expr, pos + 1);
         if (pos < expr.length && expr[pos] === ")") {
-          return { ok: false, error: "expression_syntax_error" };
+          return fail("empty_arg_slot", comma + 1, pos);
         }
         continue;
       }
@@ -750,26 +820,35 @@ function parseExpressionCall(expr) {
         pos += 1;
         break;
       }
-      return { ok: false, error: "expression_syntax_error" };
+      return fail("bad_arg_syntax", pos, pos + 1);
     }
   }
-  if (skipWs(expr, pos) !== expr.length) return { ok: false, error: "expression_syntax_error" };
-  if (args[0] !== void 0 && args[0].type !== "path") return { ok: false, error: "expression_syntax_error" };
-  for (const arg of args) {
+  pos = skipWs(expr, pos);
+  if (pos !== expr.length) return fail("trailing_after_call", pos, expr.length);
+  if (args[0] !== void 0 && args[0].type !== "path") {
+    const span = spans[0];
+    return fail("first_arg_not_path", span.start, span.end);
+  }
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    const span = spans[i];
     if (arg.type === "path" && !parseExpressionPath(arg.value).ok) {
-      return { ok: false, error: "expression_syntax_error" };
+      return fail("invalid_path_arg", span.start, span.end);
     }
   }
   return { ok: true, name, args };
 }
 function parseCallArg(expr, pos) {
   const len = expr.length;
+  const start = pos;
   const ch = expr[pos];
   if (ch === "'") {
     let cursor = pos + 1;
     let buf = "";
     for (; ; ) {
-      if (cursor >= len) return { ok: false, error: "expression_syntax_error" };
+      if (cursor >= len) {
+        return { ok: false, error: "expression_syntax_error", kind: "unterminated_string", at: { start, end: len } };
+      }
       if (expr[cursor] === "'") {
         if (cursor + 1 < len && expr[cursor + 1] === "'") {
           buf += "'";
@@ -782,10 +861,9 @@ function parseCallArg(expr, pos) {
       buf += expr[cursor];
       cursor += 1;
     }
-    return { ok: true, value: { type: "string", value: buf }, end: cursor };
+    return { ok: true, value: { type: "string", value: buf }, start, end: cursor };
   }
   if (ch >= "0" && ch <= "9") {
-    const start2 = pos;
     const isDigitAt = (index) => {
       const c = expr[index];
       return c !== void 0 && c >= "0" && c <= "9";
@@ -795,13 +873,14 @@ function parseCallArg(expr, pos) {
       pos += 1;
       while (isDigitAt(pos)) pos += 1;
     }
-    return { ok: true, value: { type: "number", value: expr.slice(start2, pos) }, end: pos };
+    return { ok: true, value: { type: "number", value: expr.slice(start, pos) }, start, end: pos };
   }
-  const start = pos;
   while (pos < len && expr[pos] !== "," && expr[pos] !== ")") pos += 1;
   const raw = phpTrim(expr.slice(start, pos));
-  if (raw === "") return { ok: false, error: "expression_syntax_error" };
-  return { ok: true, value: { type: "path", value: raw }, end: pos };
+  if (raw === "") {
+    return { ok: false, error: "expression_syntax_error", kind: "empty_arg_slot", at: { start, end: pos } };
+  }
+  return { ok: true, value: { type: "path", value: raw }, start, end: pos };
 }
 function expressionCallSlotAtEnd(expr) {
   let head = 0;
@@ -854,12 +933,20 @@ function phpTrim2(value) {
   while (end > start && PHP_TRIM_CHARS.includes(value[end - 1])) end -= 1;
   return value.slice(start, end);
 }
-function fragmentSyntaxError(expr) {
-  if (expr === "") return "expression_syntax_error";
+function fragmentDiagnostic(expr) {
+  if (expr === "") return { kind: "empty_fragment", at: { start: 0, end: 0 } };
   if (isCallFragment(expr)) {
-    return parseExpressionCall(expr).ok ? null : "expression_syntax_error";
+    const parsed = parseExpressionCall(expr);
+    if (parsed.ok) return null;
+    return { kind: parsed.kind, at: parsed.at };
   }
-  return parseExpressionPath(expr).ok ? null : "expression_syntax_error";
+  if (parseExpressionPath(expr).ok) return null;
+  return { kind: "invalid_path", at: { start: 0, end: expr.length } };
+}
+function leadingPhpTrim(value) {
+  let start = 0;
+  while (start < value.length && PHP_TRIM_CHARS.includes(value[start])) start += 1;
+  return start;
 }
 function scanExpressionFragments(template) {
   const parts = [];
@@ -880,8 +967,26 @@ function scanExpressionFragments(template) {
     }
     const raw = template.slice(open + 2, close);
     const expr = phpTrim2(raw);
-    const error = fragmentSyntaxError(expr);
-    parts.push({ kind: "fragment", start: open, end: close + 2, raw, expr, error });
+    let diagnostic = null;
+    const found = fragmentDiagnostic(expr);
+    if (found) {
+      const exprStart = open + 2 + leadingPhpTrim(raw);
+      diagnostic = {
+        kind: found.kind,
+        start: open,
+        end: close + 2,
+        at: { start: exprStart + found.at.start, end: exprStart + found.at.end }
+      };
+    }
+    parts.push({
+      kind: "fragment",
+      start: open,
+      end: close + 2,
+      raw,
+      expr,
+      error: diagnostic !== null ? "expression_syntax_error" : null,
+      diagnostic
+    });
     pos = close + 2;
     open = template.indexOf("{{", pos);
   }
@@ -1113,6 +1218,27 @@ function defaultNextTextStyle() {
     lineHeight: base.shape.lineHeight
   };
 }
+var RATIO_PRESETS = [
+  { id: "free", ratio: null },
+  { id: "1:1", ratio: { w: 1, h: 1 } },
+  { id: "4:3", ratio: { w: 4, h: 3 } },
+  { id: "3:4", ratio: { w: 3, h: 4 } },
+  { id: "16:9", ratio: { w: 16, h: 9 } },
+  { id: "9:16", ratio: { w: 9, h: 16 } }
+];
+function defaultNextLayerRatio() {
+  return "free";
+}
+function ratioValue(id) {
+  const entry = RATIO_PRESETS.find((candidate) => candidate.id === id);
+  return entry?.ratio ? { ...entry.ratio } : null;
+}
+function pickNextLayerRatio(raw) {
+  return RATIO_PRESETS.some((candidate) => candidate.id === raw) ? raw : "free";
+}
+function defaultSizeForRatio(ratio) {
+  return ratio.w >= ratio.h ? { width: 200, height: Math.round(200 * ratio.h / ratio.w) } : { width: Math.round(200 * ratio.w / ratio.h), height: 200 };
+}
 function pickNextTextStylePatch(raw) {
   const out = {};
   if (raw === null || typeof raw !== "object") return out;
@@ -1181,7 +1307,8 @@ function createDefaultLayer(type, textDefaults) {
   }
 }
 function createTemplateTable(options) {
-  const table = createDefaultLayer("TableLayer");
+  const defaultTable = createDefaultLayer("TableLayer");
+  const table = options.shape ? { ...defaultTable, shape: { ...defaultTable.shape, width: options.shape.width, height: options.shape.height } } : defaultTable;
   const templateBase = createDefaultLayer("TableRowTemplate");
   const cellBase = createDefaultLayer("TableCellLayer");
   const contentBase = createDefaultLayer("TextLayer");
@@ -1614,11 +1741,13 @@ var EditorStore = class {
     drag: null,
     resize: null,
     armedCreate: null,
+    armedCreateRowsPath: "",
     create: null,
     editing: null,
     renaming: null,
     anchorExpanded: false,
     nextTextStyle: defaultNextTextStyle(),
+    nextLayerRatio: defaultNextLayerRatio(),
     dataSourceSchema: null,
     guides: [],
     rulersVisible: true,
@@ -1650,7 +1779,7 @@ var EditorStore = class {
   }
   /** 打开/替换文档：ui 选择/编辑/重命名会话与双向历史一并重置（新文档不继承旧路径/旧事务）；
    *  参考线/锁定集合/查找会话/建层武装与画拉会话随当次会话清空（对位轴/文档内容防护/
-   *  查询词/待命层型不跨文档），标尺显隐/锚点折叠/新层样式作为偏好保留 */
+   *  查询词/待命层型不跨文档），标尺显隐/锚点折叠/新层样式/建层比例作为偏好保留 */
   openDocument(canvas) {
     this.docValue = canvas;
     this.undoSteps = [];
@@ -1662,6 +1791,7 @@ var EditorStore = class {
       drag: null,
       resize: null,
       armedCreate: null,
+      armedCreateRowsPath: "",
       create: null,
       editing: null,
       renaming: null,
@@ -1758,10 +1888,15 @@ var EditorStore = class {
     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 };
+  /**
+   * 建层武装置/解除（null，drag-create 工单 01）；标量值等短路（重复武装同型
+   * 不通知）。rowsPath（template-table-drag-create 工单 01）：模板表风味载荷
+   * 与层型一体写——同层型同载荷才短路（重复武装同型换载荷要更新），解除
+   * （null）一律清载荷。
+   */
+  setArmedCreate(type, rowsPath = "") {
+    if (this.uiValue.armedCreate === type && this.uiValue.armedCreateRowsPath === rowsPath) return;
+    this.uiValue = { ...this.uiValue, armedCreate: type, armedCreateRowsPath: type === null ? "" : rowsPath };
     this.notify({ scope: "ui", branch: "armedCreate" });
   }
   /** 画拉橡皮筋会话开始/更新/结束（null）；会话对象住 ui 分支，落库在 endCreate 单事务 */
@@ -1794,6 +1929,15 @@ var EditorStore = class {
     this.uiValue = { ...this.uiValue, nextTextStyle: next };
     this.notify({ scope: "ui", branch: "nextTextStyle" });
   }
+  /**
+   * 建层比例槽写入（image-ratio-preset 工单 01：比例预设应用 / prefs 恢复的
+   * 统一写入口）：值等短路（重复写同档零通知），仅 ui 通知、不进历史。
+   */
+  setNextLayerRatio(id) {
+    if (this.uiValue.nextLayerRatio === id) return;
+    this.uiValue = { ...this.uiValue, nextLayerRatio: id };
+    this.notify({ scope: "ui", branch: "nextLayerRatio" });
+  }
   /**
    * 数据源 schema 声明替换（归一产物或降级 null，校验收口在注入缝不在这里）：
    * 同引用短路（重复注入同一归一产物不惊动订阅方）；仅 ui 通知，不参与重绘
@@ -2678,8 +2822,17 @@ var EditorSession = class {
    *
    * 拖不动写不动的同门守卫：无会话、目标层被结构编辑移除（悬空路径）整体
    * 空转（不发事务、不发布命中轴）。
+   *
+   * Shift 等比（image-ratio-preset 工单 01，spec 决策 5）：仅 ImageLayer 生效
+   * （其余层型 shift 空转走现状——自适应与尺寸耦合面不被触碰），且须双轴皆在
+   * 可缩放面（格内容等强同步面派生轴写不出去，不进等比模式）、起始盒零维空转
+   * （无比例可参照，回落自由）。参照手势起始盒实际宽高比；驱动轴 = 角柄取位
+   * 移较大轴、边中柄取被拖轴；派生维 = round(驱动维 × 短比)（钳后驱动维跟随，
+   * 最小钳位随动）；对缘/对角固定照旧；吸附只在驱动轴移动缘候选（派生轴是算
+   * 术产物不独立吸附，钳先于吸附同门）。等比模式双轴都落声明值（派生轴写算
+   * 术积并清 auto 标志），canonicalize 以驱动轴键收口。
    */
-  resizeTo(sceneX, sceneY) {
+  resizeTo(sceneX, sceneY, shift = false) {
     const gesture = this.store.ui.resize;
     if (!gesture) return;
     const doc = this.store.doc;
@@ -2689,12 +2842,21 @@ var EditorSession = class {
     const dy = sceneY - gesture.startScene.y;
     const widthActive = handleResizesWidth(gesture.handle);
     const heightActive = handleResizesHeight(gesture.handle);
+    const axes = resizableAxesAt(doc, gesture.path);
+    const proportionalDriving = shift && current.type === "ImageLayer" && gesture.startBox.width > 0 && gesture.startBox.height > 0 && axes.width && axes.height ? proportionalDrivingAxis(gesture.handle, dx, dy) : null;
     const resolution = resolveSnapPoints(
-      resizeSnapPoints(gesture.startBox, gesture.handle, dx, dy),
+      proportionalDriving !== null ? resizeProportionalSnapPoints(gesture.startBox, gesture.handle, proportionalDriving, dx, dy) : resizeSnapPoints(gesture.startBox, gesture.handle, dx, dy),
       this.snapAxesForGesture(gesture.path),
       snapThresholdScene(this.store.ui.viewport.zoom)
     );
-    const target = resizeBox(
+    const target = proportionalDriving !== null ? resizeBoxProportional(
+      gesture.startBox,
+      gesture.handle,
+      { w: gesture.startBox.width, h: gesture.startBox.height },
+      proportionalDriving,
+      dx + resolution.dx,
+      dy + resolution.dy
+    ) : resizeBox(
       gesture.startBox,
       gesture.handle,
       widthActive ? dx + resolution.dx : dx,
@@ -2705,11 +2867,11 @@ var EditorSession = class {
       const layer = resolveLayer(draft, gesture.path);
       if (!layer) return;
       const shape = layer.shape;
-      if (widthActive) {
+      if (widthActive || proportionalDriving !== null) {
         shape.width = target.width;
         shape.autoWidth = false;
       }
-      if (heightActive) {
+      if (heightActive || proportionalDriving !== null) {
         shape.height = target.height;
         shape.autoHeight = false;
       }
@@ -2717,7 +2879,7 @@ var EditorSession = class {
       canonicalizeTableSyncInDraft(
         draft,
         gesture.path,
-        widthActive ? ["shape", "width"] : ["shape", "height"],
+        proportionalDriving === "height" || proportionalDriving === null && !widthActive ? ["shape", "height"] : ["shape", "width"],
         this.textPolicies
       );
       const resolvedWidth = layerWidth(layer, this.textPolicies);
@@ -2752,22 +2914,42 @@ var EditorSession = class {
    * 分支待命层型，下一次画布按下即开画拉；建层提交或 Esc 即解除——一次性
    * 待命态，无粘性工具（spec 决策 2）。重复武装同型值等短路零通知。
    *
-   * preset（text-defaults 工单 01，CONTEXT「文本预设」词条）：文本预设 = 写
-   * 新层样式槽的快捷方式——命中档位先把档位值并入槽（v1 只 fontSize），再
-   * 武装；仅 TextLayer 生效；未知 id = 跳过写槽、武装照常（评审口径统一：
-   * 「空转」只指写槽，武装层型本身仍合法）。
+   * preset（text-defaults 工单 01 + image-ratio-preset 工单 01）：层型相关预设 =
+   * 写槽的快捷方式——命中档位先把档位值并入对应偏好槽再武装；未知 id = 跳过
+   * 写槽、武装照常（评审口径统一：「空转」只指写槽，武装层型本身仍合法）。
+   * - TextLayer + 文本预设档：写新层样式槽（v1 只 fontSize）；
+   * - ImageLayer + 比例预设档：写建层比例槽（'free' 即显式重置档）；QR 恒方
+   *   是层型硬钳、无比例槽（spec 豁免面）；
+   * - 交叉类型（文本层带比例档/图片层带文本档）各在对方清单查无此档、天然
+   *   跳写槽。
    */
   armLayerCreate(type, preset) {
     if (preset !== void 0 && type === "TextLayer") {
       const entry = TEXT_PRESETS.find((candidate) => candidate.id === preset);
       if (entry) this.store.setNextTextStyle({ fontSize: entry.fontSize });
     }
+    if (preset !== void 0 && type === "ImageLayer") {
+      const entry = RATIO_PRESETS.find((candidate) => candidate.id === preset);
+      if (entry) this.store.setNextLayerRatio(entry.id);
+    }
     this.store.setArmedCreate(type);
   }
-  /** 解除建层武装（取消入口）：仅清待命态，零副作用。 */
+  /** 解除建层武装（取消入口）：仅清待命态（含模板表风味载荷），零副作用。 */
   cancelArmLayerCreate() {
     this.store.setArmedCreate(null);
   }
+  /**
+   * 武装模板表建层（canvas-web-template-table-drag-create 工单 01，spec 决策 3）：
+   * 行路径表单确认即武装——rowsPath 随武装进 ui 瞬态载荷（armedCreate 仍为
+   * 'TableLayer'、不新增 LayerType、不进 graph），下一次画拉或死区点击落模板表。
+   * 空串 no-op（内核防御，表单层已拦）；重复武装同 rowsPath 值等短路，换
+   * rowsPath 更新载荷。TableLayer 的 G 武装语义（V1 普通表，armLayerCreate 走
+   * 空载荷）不受染指。
+   */
+  armTemplateTableCreate(rowsPath) {
+    if (rowsPath === "") return;
+    this.store.setArmedCreate("TableLayer", rowsPath);
+  }
   /**
    * 开始画拉会话：须已武装（未武装空转防御——画布手势态机的分派前置，此守卫
    * 兜其余调用来源），与拖动/缩放会话互斥（手势起点一次性定死，beginDrag/
@@ -2780,8 +2962,10 @@ var EditorSession = class {
     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 };
+    const templateRowsPath = armed === "TableLayer" && this.store.ui.armedCreateRowsPath !== "" ? this.store.ui.armedCreateRowsPath : void 0;
     this.store.setCreate({
       type: armed,
+      templateRowsPath,
       startScene: point,
       currentScene: point,
       rect: { x: sceneX, y: sceneY, width: 0, height: 0 }
@@ -2790,22 +2974,31 @@ var EditorSession = class {
   }
   /**
    * 画拉进行中：橡皮筋求位（spatial/create.createRubberBandRect——两点正规化
-   * + QR 钳 height := width + 左右/上下缘各两点进 resolveSnapPoints，吸附数学
-   * 零新增）写回会话 rect 供 overlay 直读（虚线矩形 + W×H 气泡），命中轴回写
-   * ui.snapAxes 走 GuidesOverlay 既有通道回显（dragTo 同门）。吸附排除面为空
-   * （snapAxesForGesture(null)——新层尚未入库，全部可见根层供轴，copyMode
-   * 首移同门）。零文档事务：修正只进会话几何，落库在 endCreate。
+   * + QR 钳 height := width / 比例钳长轴驱动 + 左右/上下缘各两点进
+   * resolveSnapPoints，吸附数学零新增）写回会话 rect 供 overlay 直读（虚线
+   * 矩形 + W×H 气泡），命中轴回写 ui.snapAxes 走 GuidesOverlay 既有通道回显
+   * （dragTo 同门）。吸附排除面为空（snapAxesForGesture(null)——新层尚未入库，
+   * 全部可见根层供轴，copyMode 首移同门）。零文档事务：修正只进会话几何，
+   * 落库在 endCreate。
+   *
+   * 建层比例槽（image-ratio-preset 工单 01，spec 决策 3/4）：仅 ImageLayer 按槽
+   * 钳制（QR 层不传 ratio、恒方语义不动，两钳互斥；其余层型无槽）；Shift 瞬时
+   * 反转槽态——槽非自由按 Shift = 临时自由、槽自由按 Shift = 临时钳 1:1，按住
+   * 生效松开还原（逐帧求位、不写槽、不改武装态，Figma 惯例的手势瞬时语义）。
    */
-  createTo(sceneX, sceneY) {
+  createTo(sceneX, sceneY, shift = false) {
     const gesture = this.store.ui.create;
     const doc = this.store.doc;
     if (!gesture || !doc) return;
+    const slotRatio = gesture.type === "ImageLayer" ? ratioValue(this.store.ui.nextLayerRatio) : null;
+    const ratio = gesture.type === "ImageLayer" ? shift ? slotRatio === null ? { w: 1, h: 1 } : null : slotRatio : null;
     const resolution = createRubberBandRect(
       gesture.type,
       gesture.startScene,
       { x: sceneX, y: sceneY },
       this.snapAxesForGesture(null),
-      snapThresholdScene(this.store.ui.viewport.zoom)
+      snapThresholdScene(this.store.ui.viewport.zoom),
+      ratio
     );
     this.store.setCreate({
       ...gesture,
@@ -2819,12 +3012,19 @@ var EditorSession = class {
    * + priority）。先清会话再落文档（commitTextEdit 同门——退出路径级联时幂等）：
    * - 死区外：单事务写入「createDefaultLayer 缺省形态 + position 左上角对准
    *   橡皮筋矩形（含吸附修正）+ shape.width/height」并 insertRootLayerInDraft
-   *   置顶（priority min−1、push 数组尾）；
+   *   置顶（priority min−1、push 数组尾）——尺寸取手势末态钳制结果（含 Shift
+   *   反转末态，image-ratio-preset 工单 01 spec 决策 4）；
    * - 死区内（点击兜底，位移按 CREATE_DEAD_ZONE_SCREEN_PX 屏幕 px 随 zoom 折算，
-   *   ALT_DRAG_DEAD_ZONE_SCREEN_PX 同门）：缺省尺寸、左上角对准点击点。
+   *   ALT_DRAG_DEAD_ZONE_SCREEN_PX 同门）：左上角对准点击点；尺寸按槽派生缺省
+   *   盒（image-ratio-preset 工单 01：ImageLayer 长边 200 定短边，自由 = 工厂
+   *   200×150 现状；忽略 shift——无位移可供等比约束；其余层型保持工厂缺省）。
    * 落库后自动选中新层并解除武装；返回新层路径（绑定层消费：文本层据此自动
    * 进文本编辑，spec 决策 6）。无会话/无文档空转返回 null。点击兜底不产生
    * 零尺寸层（缺省形态自带可见尺寸）。
+   *
+   * 模板表风味（template-table-drag-create 工单 01）：会话载荷 templateRowsPath
+   * 非空即分派 createTemplateTable 工厂（死区外 shape = 手势正规化矩形，死区内
+   * 缺省壳 400×120、左上角对准点击点）；模板层不自动进文本编辑（文本层专属）。
    */
   endCreate() {
     const gesture = this.store.ui.create;
@@ -2838,9 +3038,23 @@ var EditorSession = class {
     const deadZoneScene = CREATE_DEAD_ZONE_SCREEN_PX / this.store.ui.viewport.zoom;
     const clicked = Math.hypot(dx, dy) <= deadZoneScene;
     const index = { v: -1 };
+    const templateRowsPath = gesture.templateRowsPath;
     this.store.transact((draft) => {
-      const layer = createDefaultLayer(gesture.type, this.store.ui.nextTextStyle);
+      const layer = templateRowsPath !== void 0 ? createTemplateTable(
+        clicked ? { rowsPath: templateRowsPath } : {
+          rowsPath: templateRowsPath,
+          shape: { width: gesture.rect.width, height: gesture.rect.height }
+        }
+      ) : createDefaultLayer(gesture.type, this.store.ui.nextTextStyle);
       if (clicked) {
+        if (gesture.type === "ImageLayer") {
+          const ratio = ratioValue(this.store.ui.nextLayerRatio);
+          if (ratio) {
+            const size = defaultSizeForRatio(ratio);
+            layer.shape.width = size.width;
+            layer.shape.height = size.height;
+          }
+        }
         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 };
@@ -3028,19 +3242,23 @@ var EditorSession = class {
     return {
       rulersVisible: ui.rulersVisible,
       anchorExpanded: ui.anchorExpanded,
-      nextTextStyle: ui.nextTextStyle
+      nextTextStyle: ui.nextTextStyle,
+      nextLayerRatio: ui.nextLayerRatio
     };
   }
   /**
    * 应用偏好（会话建立时一次性，跨会话恢复 prefs 的写入口）：整体替换
    * rulersVisible/anchorExpanded，不进历史；值等写入经 store 短路零通知。
    * 新层样式（text-defaults 工单 01）走宽容读逐字段合并（pickNextTextStylePatch
-   * 共享谓词——与捕获同门，缺字/类型不符保留现值）。
+   * 共享谓词——与捕获同门，缺字/类型不符保留现值）；建层比例（image-ratio-preset
+   * 工单 01）走宽容读枚举收口（pickNextLayerRatio——非六档枚举值/旧快照缺字段
+   * 回落 'free'）。
    */
   applyEditorPrefs(prefs) {
     this.store.setRulersVisible(prefs.rulersVisible);
     this.store.setAnchorExpanded(prefs.anchorExpanded);
     this.store.setNextTextStyle(pickNextTextStylePatch(prefs.nextTextStyle));
+    this.store.setNextLayerRatio(pickNextLayerRatio(prefs.nextLayerRatio));
   }
   // ---- 对齐画布（layer-align-snap 工单 01）：图层盒整体对齐画布几何 ----
   /**
@@ -3084,11 +3302,10 @@ var EditorSession = class {
    * 进入文本编辑：路径必须解析到 TextLayer。会话只进 ui 分支（不进历史），
    * live 文本住在绑定层的 textarea，内容层随即跳绘该层文本（防重影）。
    *
-   * 内容类型会话标志（canvas-web-expression-editing 工单 01，spec 决策 2）按
-   * 进入瞬间 `layer.expression !== null` 锚定进会话快照——「进入时计、编辑中
-   * 稳定」（verticalAnchorY 同门）：编辑中面板改标记不回写标志，提交去向由
-   * 快照裁决（打标是显式动作，内容判定制已否决）。同路径重复进入短路（快照
-   * 不重锚）；换层进入按新层现状重锚。
+   * 内容模式活标志（ADR 0019）初值按进入瞬间 `layer.expression !== null` 取定
+   * （与文档现态一致），此后不再冻结——pill 切换与内核 toggleDataMode 会话期
+   * 都只翻标志，提交去向由退出时现态裁决（见 commitTextEdit）。同路径重复进入
+   * 短路（会话不重建，接管序号延续）；换层进入按新层现状取初值。
    */
   beginTextEdit(path) {
     const layer = this.textLayerAt(path);
@@ -3104,14 +3321,14 @@ var EditorSession = class {
    * 提交与随后 blur 竞态），会话清空后后续调用幂等，保证一次退出恰一步历史。
    *
    * 提交矩阵（canvas-web-expression-editing 工单 01，spec 决策 3，空串判定先于
-   * 片段判定）：
-   * - 串与文档一致：不进历史（进出编辑零噪声），返回 false——对比对象随会话
-   *   模式取：表达式会话对比 `layer.expression`、字面会话对比 `layer.text`（现行
-   *   语义）；
+   * 片段判定；对比对象与去向裁决按会话标志**退出时现态**——活标志语义，ADR
+   * 0019，取代旧「进入时快照」）：
+   * - 串与文档一致：不进历史（进出编辑零噪声），返回 false——对比对象随退出时
+   *   会话标志取：表达式现态对比 `layer.expression`、静态现态对比 `layer.text`；
    * - 空串：删除该图层（复用 deleteLayer 的 splice/重映射语义），任何模式同语义；
-   * - 表达式会话且串含 ≥1 语法有效闭合片段（hasValidExpressionFragment）：
+   * - 表达式现态且串含 ≥1 语法有效闭合片段（hasValidExpressionFragment）：
    *   updateDataExpression 标记写（保持标记、text 自动重镜像）；
-   * - 其余（字面会话恒走此支；表达式会话无合法片段回落）：updateData 字面写、
+   * - 其余（静态现态恒走此支；表达式现态无合法片段回落）：updateData 字面写、
    *   字面接管解标——含 `{{...}}` 按字面保留，杜绝无片段标记层。
    */
   commitTextEdit(text) {
@@ -3135,8 +3352,10 @@ var EditorSession = class {
   /**
    * 编辑 overlay 的布局描述：与绘制/命中同一套布局策略求出的盒几何与排版字段
    * （textarea 以盒左上对位、盒尺寸占位，字号/行高/内边距按场景像素交给 CSS
-   * transform 缩放）。verticalAnchorY 按进入编辑时的文档文本计算，编辑中保持
-   * 稳定不随键入跳动。非文本层/路径失效返回 null。
+   * transform 缩放）。对当前文档现算（canvas-web-edit-overlay-toolbar 工单 01，
+   * ADR 0019 布局现算）：会话期样式/几何权威写实时反映到查询值；verticalAnchorY
+   * 按当前文档文本计算——live 键入只住 textarea 草稿不落文档，键入不触发文档
+   * 变更，锚点天然稳定不跳。非文本层/路径失效返回 null。
    */
   textEditLayout(path) {
     const layer = this.textLayerAt(path);
@@ -3213,7 +3432,8 @@ var EditorSession = class {
    * 原地不动——事务后派生列表在被替换处缩一位，原下标即「下一处」（「替换后
    * 自动跳下一处」靠派生天然成立，末处替换则钳位停在尾）。写值经 replaceHitsInDraft
    * 与文本编辑提交同门（text 直写 + expression 保持 null）。无文档/空 query/
-   * 无命中空转返回 false。
+   * 无命中空转返回 false。命中编辑层时草稿接管（会话内容独占，工单 02——
+   * 替换结果出现在正在编辑的框里）。
    */
   replaceOne() {
     const doc = this.store.doc;
@@ -3222,7 +3442,7 @@ var EditorSession = class {
     const matches = scanTextMatches(doc, query);
     const hit = matches[clampFindCursor(this.store.ui.find.cursor, matches.length)];
     if (!hit) return false;
-    this.store.transact((draft) => {
+    this.transactContent([hit.path], (draft) => {
       replaceHitsInDraft(draft, [hit], this.store.ui.find.replacement);
     });
     return true;
@@ -3231,7 +3451,8 @@ var EditorSession = class {
    * 全部替换（查找条「全部替换」按钮）：命中（path + 偏移对）在事务前按原文
    * 快照一次算定，单事务内按同字段偏移降序应用、替换产物不重扫（replacement
    * 含查询串不死循环）——一次调用 = 一步历史，undo 一次全回。返回应用处数
-   * （计数反馈「已替换 N 处」）；无文档/空 query 空转返回 0。
+   * （计数反馈「已替换 N 处」）；无文档/空 query 空转返回 0。命中编辑层时
+   * 草稿接管（会话内容独占，工单 02）。
    */
   replaceAll() {
     const doc = this.store.doc;
@@ -3240,7 +3461,7 @@ var EditorSession = class {
     const hits = scanTextMatches(doc, query);
     if (hits.length === 0) return 0;
     let applied = 0;
-    this.store.transact((draft) => {
+    this.transactContent(hits.map((hit) => hit.path), (draft) => {
       applied = replaceHitsInDraft(draft, hits, this.store.ui.find.replacement);
     });
     return applied;
@@ -3294,9 +3515,13 @@ var EditorSession = class {
    * null，值与标记的镜像关系随之解除——标记态文档经字面编辑退化为字面态，
    * 不可自动恢复属预期（spec §3.7 兼容面）。
    * 表/行/格无数据字段，空转。
+   *
+   * 会话内容独占（工单 02，ADR 0019 内核底线面）：命中编辑层的写落文档的同时
+   * 草稿接管（draftSeq 递增，绑定层全量替换 textarea 草稿）——旁门程序化写的
+   * 结果进编辑框草稿而非被退出提交覆盖，任何方向不丢字。
    */
   updateData(path, value, options = {}) {
-    this.store.transact((draft) => {
+    this.transactContent([path], (draft) => {
       const layer = resolveLayer(draft, path);
       if (!layer) return;
       switch (layer.type) {
@@ -3327,9 +3552,11 @@ var EditorSession = class {
    *   字面态空值归一交给 updateData/decode 分支（这里不清值，字面接管语义）。
    * - 仅三内容层生效，表/行/格/行模板空转（与 updateData 同门）。
    * - updateData 语义不变：字面写解除标记仍成立（spec §1 明示两者并排）。
+   * - 命中编辑层的旁门打标同走草稿接管（draftSeq 递增；会话标志不随动——
+   *   活标志只归 pill/toggleDataMode 翻，见 toggleDataMode）。
    */
   updateDataExpression(path, expression, options = {}) {
-    this.store.transact((draft) => {
+    this.transactContent([path], (draft) => {
       const layer = resolveLayer(draft, path);
       if (!layer) return;
       switch (layer.type) {
@@ -3350,6 +3577,63 @@ var EditorSession = class {
       }
     }, options);
   }
+  /**
+   * 数据字段取值方式切换（静态 ⇆ 表达式，工单 02 自面板收编内核）：表达式现态
+   * → 字面接管（updateData，值保持现镜像）；静态现态 → 打标（updateDataExpression，
+   * 初值 = 值字段原文）。各为独立一步历史（无 mergeKey）。三内容层分派各取值
+   * 字段，表/行/格/悬空路径空转。
+   *
+   * 活标志防御路由（ADR 0019）：路径即编辑中的层时只翻会话活标志（零文档变更
+   * 零历史步）——会话期内容模式切换的唯一写入口是会话标志，文档面锁定归编辑框
+   * 草稿；面板锁定段/pill 显式调用与宿主旁路调用都安全收敛到同一语义。
+   */
+  toggleDataMode(path) {
+    const editing = this.store.ui.editing;
+    if (editing && pathsEqual(editing.path, path)) {
+      this.store.setEditing({ ...editing, expression: !editing.expression });
+      return;
+    }
+    const layer = this.store.doc ? resolveLayer(this.store.doc, path) : null;
+    if (!layer) return;
+    switch (layer.type) {
+      case "TextLayer":
+        if (layer.expression !== null) this.updateData(path, layer.text);
+        else this.updateDataExpression(path, layer.text);
+        return;
+      case "ImageLayer":
+        if (layer.expression !== null) this.updateData(path, layer.src ?? "");
+        else this.updateDataExpression(path, layer.src ?? "");
+        return;
+      case "QrCodeLayer":
+        if (layer.expression !== null) this.updateData(path, layer.value);
+        else this.updateDataExpression(path, layer.value);
+        return;
+      default:
+        return;
+    }
+  }
+  /**
+   * 内容写事务的统一形（会话内容独占工单 02）：transact 落库 + 命中编辑层的
+   * 草稿接管收口——updateData/updateDataExpression/replaceOne/replaceAll 四个
+   * 旁门写入口同门（接管判定见 takeoverDraftIfNeeded；零变更事务天然短路）。
+   */
+  transactContent(paths, recipe, options = {}) {
+    const docBefore = this.store.doc;
+    this.store.transact(recipe, options);
+    this.takeoverDraftIfNeeded(paths, docBefore);
+  }
+  /**
+   * 草稿接管收口（工单 02）：paths 中有编辑层且文档确实变更（引用比较——零变更
+   * 事务 transact 空转不通知，接管序号也不动）时递增会话 draftSeq 并广播
+   * ui.editing。绑定层据此全量替换 textarea 草稿为文档新值并刷新表达式诊断。
+   * commitTextEdit 先清会话再落库，天然不复入接管。
+   */
+  takeoverDraftIfNeeded(paths, docBefore) {
+    const editing = this.store.ui.editing;
+    if (!editing || this.store.doc === docBefore) return;
+    if (!paths.some((path) => pathsEqual(path, editing.path))) return;
+    this.store.setEditing({ ...editing, draftSeq: (editing.draftSeq ?? 0) + 1 });
+  }
   /** 更新画布级字段（未选中图层时面板的宽/高写入口）；键由类型收窄为 width/height */
   updateCanvasProp(key, value, options = {}) {
     this.store.transact((draft) => {
@@ -3361,12 +3645,14 @@ var EditorSession = class {
    * 注入数据源 schema 声明（载荷形态，D1 钉定：声明即 compile(canvas, dataset)
    * 收到的 data 载荷形状，根上下文候选 = 载荷顶层键）。声明经
    * normalizeExpressionSchemaSource 一次性编译收口——根级结构性问题（保留键
-   * row/$ 前缀，前移填充期 reserved_root_key；根非对象/缺 properties 层级）降级
-   * 为无候选 + console 警告，局部故障（$ref 断链/外部指针/环引用/目标形态不符）
-   * 不拒绝：该节点降叶子 + 注入期汇总告警一次，树其余部分照常服务，不抛错不
-   * 弹错（辅助声明不作权威）；null/undefined = 清除声明。声明只住 store ui 分支：
-   * 不进 graph、不落 localStorage、不进 wire；openDocument 换文档不重置，
-   * 重注入/清除走同一入口。签名与「注入即整体替换」语义不变（D6）。
+   * row/$ 前缀，前移填充期 reserved_root_key；根非对象/缺 properties 层级）
+   * 与开放映射契约废除（open_map_unsupported，ADR 0020：文档任意层
+   * additionalProperties: true 显式拒绝，动态键归宿主组装成具体 properties 后
+   * 注入）降级为无候选 + console 警告，局部故障（$ref 断链/外部指针/环引用/
+   * 目标形态不符）不拒绝：该节点降叶子 + 注入期汇总告警一次，树其余部分照常
+   * 服务，不抛错不弹错（辅助声明不作权威）；null/undefined = 清除声明。声明只
+   * 住 store ui 分支：不进 graph、不落 localStorage、不进 wire；openDocument
+   * 换文档不重置，重注入/清除走同一入口。签名与「注入即整体替换」语义不变（D6）。
    */
   setDataSourceSchema(raw) {
     this.store.setDataSourceSchema(
@@ -3928,19 +4214,6 @@ var EditorSession = class {
     });
     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。
@@ -4241,6 +4514,29 @@ function classifyWheel(input) {
   return "pan";
 }
 
+// src/shared/expressionDiagnostics.ts
+function expressionDiagnostics(template) {
+  const found = [];
+  for (const part of scanExpressionFragments(template).parts) {
+    if (part.kind === "fragment" && part.diagnostic !== null) found.push(part.diagnostic);
+  }
+  return found;
+}
+
+// src/shared/resourcePath.ts
+function wholeTemplateDiagnostic(template, kind) {
+  return { kind, start: 0, end: template.length, at: { start: 0, end: template.length } };
+}
+function resourcePathDiagnostics(template) {
+  const anchored = template.endsWith("\n") ? template.slice(0, -1) : template;
+  const matched = /^\{\{([^{}]*)\}\}$/.exec(anchored);
+  if (matched === null) return [wholeTemplateDiagnostic(template, "resource_not_single_ref")];
+  const path = phpTrim2(matched[1] ?? "");
+  if (path === "") return [wholeTemplateDiagnostic(template, "empty_fragment")];
+  if (path.includes("(")) return [wholeTemplateDiagnostic(template, "resource_function_call")];
+  return [];
+}
+
 // src/shared/expressionFunctions.ts
 var EXPRESSION_FUNCTIONS = [
   { name: "date", signature: "date(path[, format])", summary: "\u65E5\u671F\u683C\u5F0F\u5316\uFF08moment \u98CE\u683C token\uFF0C\u9884\u8BBE date/datetime\uFF09" },
@@ -4272,7 +4568,7 @@ function candidateMeta(node) {
 }
 function childCandidate(entry, prefix) {
   const path = prefix === "" ? entry.key : `${prefix}.${entry.key}`;
-  return { path, segment: entry.key, ...candidateMeta(entry.node) };
+  return { path, segment: entry.key, kind: "path", ...candidateMeta(entry.node) };
 }
 function callCandidatesFor(entry, path, exprLen) {
   const extras = [];
@@ -4283,6 +4579,7 @@ function callCandidatesFor(entry, path, exprLen) {
       cursorBack: 2,
       replaceLen: exprLen,
       filterKey: entry.key,
+      kind: "function",
       description: "\u65E5\u671F\u683C\u5F0F\u5316",
       type: "\u51FD\u6570"
     });
@@ -4293,6 +4590,7 @@ function callCandidatesFor(entry, path, exprLen) {
         segment: `${fn.name}(${path})`,
         replaceLen: exprLen,
         filterKey: entry.key,
+        kind: "function",
         description: fn.summary,
         type: "\u51FD\u6570"
       });
@@ -4310,6 +4608,7 @@ function functionCandidates() {
     path: fn.signature,
     segment: `${fn.name}()`,
     cursorBack: 1,
+    kind: "function",
     description: fn.summary,
     type: "\u51FD\u6570"
   }));
@@ -4325,12 +4624,12 @@ function dateFormatCandidates() {
 function headCandidates(schema, context, rowSchema, exprLen, withBuckets) {
   const view = schemaChildEntries(schema);
   const candidates = view.entries.flatMap((entry) => childCandidates(entry, "", exprLen, withBuckets));
-  candidates.push({ path: "$root", segment: "$root" });
+  candidates.push({ path: "$root", segment: "$root", kind: "path" });
   if (context === "row") {
-    candidates.push(rowSchema ? { path: "row", segment: "row", ...candidateMeta(rowSchema) } : { path: "row", segment: "row" });
-    candidates.push({ path: "$index", segment: "$index" });
+    candidates.push(rowSchema ? { path: "row", segment: "row", kind: "path", ...candidateMeta(rowSchema) } : { path: "row", segment: "row", kind: "path" });
+    candidates.push({ path: "$index", segment: "$index", kind: "path" });
   }
-  return view.open === true ? { candidates, open: true } : { candidates };
+  return candidates;
 }
 function callSlotResult(schema, query) {
   const slot = expressionCallSlotAtEnd(query.expr);
@@ -4359,7 +4658,7 @@ function enumeratePathCandidates(schema, query, expr, allowCallSuggestions) {
         ok: true,
         prefix: "",
         partial: "",
-        ...headCandidates(schema, query.context, query.rowSchema, expr.length, false)
+        candidates: headCandidates(schema, query.context, query.rowSchema, expr.length, false)
       };
     }
     return { ok: false, reason: "expression_syntax_error" };
@@ -4389,8 +4688,7 @@ function enumeratePathCandidates(schema, query, expr, allowCallSuggestions) {
       ok: true,
       prefix: "",
       partial,
-      candidates: [...view2.candidates, ...fns],
-      ...view2.open === true ? { open: true } : {}
+      candidates: [...view2, ...fns]
     };
   }
   let base;
@@ -4420,8 +4718,7 @@ function enumeratePathCandidates(schema, query, expr, allowCallSuggestions) {
     ok: true,
     prefix,
     partial,
-    candidates: view.entries.flatMap((entry) => childCandidates(entry, prefix, expr.length, withBuckets)),
-    ...view.open === true ? { open: true } : {}
+    candidates: view.entries.flatMap((entry) => childCandidates(entry, prefix, expr.length, withBuckets))
   };
 }
 function enumerateExpressionCandidates(schema, query) {
@@ -4439,7 +4736,7 @@ function isArrayNode(node) {
   return node.type === "array" || node.items !== void 0;
 }
 function isScalarNode(node) {
-  return !isArrayNode(node) && node.properties === void 0 && node.open !== true;
+  return !isArrayNode(node) && node.properties === void 0;
 }
 function childCandidate2(key, node, prefix) {
   const candidate = {
@@ -4459,7 +4756,7 @@ function levelCandidates(base, prefix) {
       candidates.push(childCandidate2(key, child, prefix));
     }
   }
-  return base.open === true ? { candidates, open: true } : { candidates };
+  return candidates;
 }
 function enumerateRowsPathCandidates(startSchema, input) {
   if (startSchema === null) return null;
@@ -4475,11 +4772,7 @@ function enumerateRowsPathCandidates(startSchema, input) {
   }
   if (isArrayNode(base) || isScalarNode(base)) return null;
   const view = levelCandidates(base, completed.join("."));
-  return {
-    partial,
-    candidates: view.candidates,
-    ...view.open === true ? { open: true } : {}
-  };
+  return { partial, candidates: view };
 }
 function resolveRowsPathStartSchema(doc, path, rootSchema) {
   if (rootSchema === null) return null;
@@ -4598,6 +4891,7 @@ export {
   PAN_TO_BOX_MARGIN_PX,
   PASTE_OFFSET_PX,
   PHP_TRIM_CHARS,
+  RATIO_PRESETS,
   RESIZE_HANDLES,
   RESIZE_HANDLE_HIT_PX,
   RESIZE_MIN_SIZE_PX,
@@ -4627,11 +4921,14 @@ export {
   createDefaultLayer,
   createRubberBandRect,
   createTemplateTable,
+  defaultNextLayerRatio,
   defaultNextTextStyle,
+  defaultSizeForRatio,
   deleteLayerInDraft,
   enumerateExpressionCandidates,
   enumerateRowsPathCandidates,
   expressionCallSlotAtEnd,
+  expressionDiagnostics,
   expressionFragmentAtCursor,
   fitRect,
   fitViewport,
@@ -4667,22 +4964,28 @@ export {
   pathStartsWith,
   pathsEqual,
   phpTrim2 as phpTrim,
+  pickNextLayerRatio,
   pickNextTextStylePatch,
   prepareRootPaste,
+  proportionalDrivingAxis,
+  ratioValue,
   readSpecField,
   remapPathAfterSplice,
   replaceHitsInDraft,
   resizableAxesAt,
   resizeBox,
+  resizeBoxProportional,
   resizeHandleAt,
   resizeHandlePoint,
   resizeHandlesAt,
+  resizeProportionalSnapPoints,
   resizeSnapPoints,
   resolveLayer,
   resolveRowSchema,
   resolveRowsPathStartSchema,
   resolveSnap,
   resolveSnapPoints,
+  resourcePathDiagnostics,
   rootLayerOf,
   scanExpressionFragments,
   scanTextMatches,