@hankchen/canvas-editor 0.3.0 → 0.5.0

package/dist/index.js

@@ -501,6 +501,7 @@ function normalizeSchemaType(value) {
   const primary = value.find((entry) => entry !== "null" && entry !== "");
   return primary;
 }
+var FORMAT_ANNOTATIONS = /* @__PURE__ */ new Set(["date", "date-time"]);
 function annotationsOf(raw) {
   const node = {};
   const rawType = raw["type"];
@@ -515,6 +516,10 @@ function annotationsOf(raw) {
   if (typeof rawDescription === "string") node.description = rawDescription;
   const rawTitle = raw["title"];
   if (typeof rawTitle === "string") node.title = rawTitle;
+  const rawFormat = raw["format"];
+  if (node.type === "string" && typeof rawFormat === "string" && FORMAT_ANNOTATIONS.has(rawFormat)) {
+    node.format = rawFormat;
+  }
   return node;
 }
 function pointerEscape(key) {
@@ -597,7 +602,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();
@@ -611,6 +615,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" };
@@ -626,6 +647,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 };
@@ -667,7 +692,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(".");
@@ -692,15 +717,194 @@ function parseExpressionPath(expr) {
   return { ok: true, head: { kind: "bare", name: head }, rest };
 }
 
+// src/shared/expressionCall.ts
+var TRIM_CHARS = " 	\n\r\0\v";
+var WS_CHARS = " 	\n\r";
+var HEAD_STOP_CHARS = `()',.${TRIM_CHARS}`;
+function phpTrim(value) {
+  let start = 0;
+  let end = value.length;
+  while (start < end && TRIM_CHARS.includes(value[start])) start += 1;
+  while (end > start && TRIM_CHARS.includes(value[end - 1])) end -= 1;
+  return value.slice(start, end);
+}
+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;
+  if (head === 0) return false;
+  let pos = head;
+  while (pos < expr.length && TRIM_CHARS.includes(expr[pos])) pos += 1;
+  return expr[pos] === "(";
+}
+function parseExpressionCall(expr) {
+  let head = 0;
+  while (head < expr.length && !HEAD_STOP_CHARS.includes(expr[head])) head += 1;
+  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 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 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 fail("unbalanced_paren", openParen, expr.length);
+      if (expr[pos] === ",") {
+        const comma = pos;
+        pos = skipWs(expr, pos + 1);
+        if (pos < expr.length && expr[pos] === ")") {
+          return fail("empty_arg_slot", comma + 1, pos);
+        }
+        continue;
+      }
+      if (expr[pos] === ")") {
+        pos += 1;
+        break;
+      }
+      return fail("bad_arg_syntax", pos, pos + 1);
+    }
+  }
+  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 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", kind: "unterminated_string", at: { start, end: len } };
+      }
+      if (expr[cursor] === "'") {
+        if (cursor + 1 < len && expr[cursor + 1] === "'") {
+          buf += "'";
+          cursor += 2;
+          continue;
+        }
+        cursor += 1;
+        break;
+      }
+      buf += expr[cursor];
+      cursor += 1;
+    }
+    return { ok: true, value: { type: "string", value: buf }, start, end: cursor };
+  }
+  if (ch >= "0" && ch <= "9") {
+    const isDigitAt = (index) => {
+      const c = expr[index];
+      return c !== void 0 && c >= "0" && c <= "9";
+    };
+    while (isDigitAt(pos)) pos += 1;
+    if (pos < len && expr[pos] === "." && isDigitAt(pos + 1)) {
+      pos += 1;
+      while (isDigitAt(pos)) pos += 1;
+    }
+    return { ok: true, value: { type: "number", value: expr.slice(start, pos) }, start, end: 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", 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;
+  while (head < expr.length && !HEAD_STOP_CHARS.includes(expr[head])) head += 1;
+  if (head === 0) return null;
+  let pos = skipWs(expr, head);
+  if (pos >= expr.length || expr[pos] !== "(") return null;
+  pos = skipWs(expr, pos + 1);
+  let index = 0;
+  for (; ; ) {
+    if (pos >= expr.length) return { name: expr.slice(0, head), index, text: "", stringSlot: false };
+    const ch = expr[pos];
+    if (ch === "'") {
+      let cursor = pos + 1;
+      for (; ; ) {
+        if (cursor >= expr.length) {
+          return { name: expr.slice(0, head), index, text: expr.slice(pos + 1), stringSlot: true };
+        }
+        if (expr[cursor] === "'") {
+          if (cursor + 1 < expr.length && expr[cursor + 1] === "'") {
+            cursor += 2;
+            continue;
+          }
+          cursor += 1;
+          break;
+        }
+        cursor += 1;
+      }
+      pos = cursor;
+    } else if (ch !== "," && ch !== ")") {
+      const argStart = pos;
+      while (pos < expr.length && expr[pos] !== "," && expr[pos] !== ")") pos += 1;
+      if (pos >= expr.length) {
+        return { name: expr.slice(0, head), index, text: phpTrim(expr.slice(argStart)), stringSlot: false };
+      }
+    }
+    if (pos >= expr.length) return { name: expr.slice(0, head), index: index + 1, text: "", stringSlot: false };
+    if (expr[pos] === ")") return null;
+    index += 1;
+    pos = skipWs(expr, pos + 1);
+  }
+}
+
 // src/shared/expressionScan.ts
 var PHP_TRIM_CHARS = " 	\n\r\0\v";
-function phpTrim(value) {
+function phpTrim2(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 fragmentDiagnostic(expr) {
+  if (expr === "") return { kind: "empty_fragment", at: { start: 0, end: 0 } };
+  if (isCallFragment(expr)) {
+    const parsed = parseExpressionCall(expr);
+    if (parsed.ok) return null;
+    return { kind: parsed.kind, at: parsed.at };
+  }
+  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 = [];
   let pos = 0;
@@ -712,16 +916,34 @@ function scanExpressionFragments(template) {
         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)) });
+      parts.push({ kind: "open", start: open, end: template.length, text, expr: phpTrim2(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 });
+    const expr = phpTrim2(raw);
+    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);
   }
@@ -2924,11 +3146,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);
@@ -2944,14 +3165,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) {
@@ -2975,8 +3196,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);
@@ -3053,7 +3276,8 @@ var EditorSession = class {
    * 原地不动——事务后派生列表在被替换处缩一位，原下标即「下一处」（「替换后
    * 自动跳下一处」靠派生天然成立，末处替换则钳位停在尾）。写值经 replaceHitsInDraft
    * 与文本编辑提交同门（text 直写 + expression 保持 null）。无文档/空 query/
-   * 无命中空转返回 false。
+   * 无命中空转返回 false。命中编辑层时草稿接管（会话内容独占，工单 02——
+   * 替换结果出现在正在编辑的框里）。
    */
   replaceOne() {
     const doc = this.store.doc;
@@ -3062,7 +3286,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;
@@ -3071,7 +3295,8 @@ var EditorSession = class {
    * 全部替换（查找条「全部替换」按钮）：命中（path + 偏移对）在事务前按原文
    * 快照一次算定，单事务内按同字段偏移降序应用、替换产物不重扫（replacement
    * 含查询串不死循环）——一次调用 = 一步历史，undo 一次全回。返回应用处数
-   * （计数反馈「已替换 N 处」）；无文档/空 query 空转返回 0。
+   * （计数反馈「已替换 N 处」）；无文档/空 query 空转返回 0。命中编辑层时
+   * 草稿接管（会话内容独占，工单 02）。
    */
   replaceAll() {
     const doc = this.store.doc;
@@ -3080,7 +3305,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;
@@ -3134,9 +3359,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) {
@@ -3167,9 +3396,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) {
@@ -3190,6 +3421,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) => {
@@ -3201,12 +3489,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(
@@ -4081,6 +4371,45 @@ 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" },
+  { name: "number", signature: "number(path[, n])", summary: "\u5343\u5206\u4F4D\u5206\u7EC4" },
+  { name: "fixed", signature: "fixed(path[, n])", summary: "\u5B9A\u70B9\u8865\u96F6\uFF08\u7F3A\u7701 2 \u4F4D\uFF09" },
+  { name: "percent", signature: "percent(path[, n])", summary: "\u767E\u5206\u6BD4\uFF08\u4E58 100\uFF09" }
+];
+var NUMBER_FUNCTION_SUGGESTIONS = EXPRESSION_FUNCTIONS.filter(
+  (fn) => fn.name !== "date"
+);
+var DATE_FORMAT_SUGGESTIONS = [
+  { segment: "date", description: "\u9884\u8BBE \u2192 YYYY-MM-DD" },
+  { segment: "datetime", description: "\u9884\u8BBE \u2192 YYYY-MM-DD HH:mm:ss" },
+  { segment: "YYYY\u5E74MM\u6708DD\u65E5", description: "\u4E2D\u6587\u6A21\u677F\uFF08\u5199\u5373\u6240\u5F97\uFF09" }
+];
+
 // src/shared/expressionCandidates.ts
 function headName(head) {
   if (head.kind === "row") return "row";
@@ -4096,27 +4425,98 @@ function candidateMeta(node) {
 }
 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) {
+  return { path, segment: entry.key, kind: "path", ...candidateMeta(entry.node) };
+}
+function callCandidatesFor(entry, path, exprLen) {
+  const extras = [];
+  if (entry.node.format === "date" || entry.node.format === "date-time") {
+    extras.push({
+      path: `date(${path}, '')`,
+      segment: `date(${path}, '')`,
+      cursorBack: 2,
+      replaceLen: exprLen,
+      filterKey: entry.key,
+      kind: "function",
+      description: "\u65E5\u671F\u683C\u5F0F\u5316",
+      type: "\u51FD\u6570"
+    });
+  } else if (entry.node.type === "number") {
+    for (const fn of NUMBER_FUNCTION_SUGGESTIONS) {
+      extras.push({
+        path: `${fn.name}(${path})`,
+        segment: `${fn.name}(${path})`,
+        replaceLen: exprLen,
+        filterKey: entry.key,
+        kind: "function",
+        description: fn.summary,
+        type: "\u51FD\u6570"
+      });
+    }
+  }
+  return extras;
+}
+function childCandidates(entry, prefix, exprLen, withBuckets) {
+  const base = childCandidate(entry, prefix);
+  if (!withBuckets) return [base];
+  return [base, ...callCandidatesFor(entry, base.path, exprLen)];
+}
+function functionCandidates() {
+  return EXPRESSION_FUNCTIONS.map((fn) => ({
+    path: fn.signature,
+    segment: `${fn.name}()`,
+    cursorBack: 1,
+    kind: "function",
+    description: fn.summary,
+    type: "\u51FD\u6570"
+  }));
+}
+function dateFormatCandidates() {
+  return DATE_FORMAT_SUGGESTIONS.map((suggestion) => ({
+    path: suggestion.segment,
+    segment: suggestion.segment,
+    description: suggestion.description,
+    type: "\u683C\u5F0F"
+  }));
+}
+function headCandidates(schema, context, rowSchema, exprLen, withBuckets) {
   const view = schemaChildEntries(schema);
-  const candidates = view.entries.map((entry) => childCandidate(entry, ""));
-  candidates.push({ path: "$root", segment: "$root" });
+  const candidates = view.entries.flatMap((entry) => childCandidates(entry, "", exprLen, withBuckets));
+  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 enumerateExpressionCandidates(schema, query) {
+function callSlotResult(schema, query) {
+  const slot = expressionCallSlotAtEnd(query.expr);
+  if (slot === null) {
+    return { ok: true, prefix: "", partial: "", candidates: [] };
+  }
+  if (slot.stringSlot && slot.index >= 1 && slot.name === "date") {
+    return { ok: true, prefix: "", partial: slot.text, candidates: dateFormatCandidates() };
+  }
+  if (slot.index === 0 && !isCallFragment(slot.text)) {
+    const sub = enumeratePathCandidates(schema, query, slot.text, false);
+    if (!sub.ok) return { ok: true, prefix: "", partial: "", candidates: [] };
+    return sub;
+  }
+  return { ok: true, prefix: "", partial: "", candidates: [] };
+}
+function enumeratePathCandidates(schema, query, expr, allowCallSuggestions) {
   if (schema === null) {
     return { ok: true, prefix: "", partial: "", candidates: [] };
   }
-  const hadTrailingDot = query.expr.endsWith(".");
-  const stripped = hadTrailingDot ? query.expr.slice(0, -1) : query.expr;
+  const hadTrailingDot = expr.endsWith(".");
+  const stripped = hadTrailingDot ? expr.slice(0, -1) : expr;
   if (stripped === "") {
-    if (query.expr === "") {
-      return { ok: true, prefix: "", partial: "", ...headCandidates(schema, query.context, query.rowSchema) };
+    if (expr === "") {
+      return {
+        ok: true,
+        prefix: "",
+        partial: "",
+        candidates: headCandidates(schema, query.context, query.rowSchema, expr.length, false)
+      };
     }
     return { ok: false, reason: "expression_syntax_error" };
   }
@@ -4137,8 +4537,16 @@ function enumerateExpressionCandidates(schema, query) {
     prefixPath = [];
     partial = headName(head);
   }
+  const withBuckets = allowCallSuggestions && partial !== "";
   if (prefixPath.length === 0) {
-    return { ok: true, prefix: "", partial, ...headCandidates(schema, query.context, query.rowSchema) };
+    const view2 = headCandidates(schema, query.context, query.rowSchema, expr.length, withBuckets);
+    const fns = allowCallSuggestions && expr !== "" ? functionCandidates() : [];
+    return {
+      ok: true,
+      prefix: "",
+      partial,
+      candidates: [...view2, ...fns]
+    };
   }
   let base;
   let segments;
@@ -4167,17 +4575,25 @@ function enumerateExpressionCandidates(schema, query) {
     ok: true,
     prefix,
     partial,
-    candidates: view.entries.map((entry) => childCandidate(entry, prefix)),
-    ...view.open === true ? { open: true } : {}
+    candidates: view.entries.flatMap((entry) => childCandidates(entry, prefix, expr.length, withBuckets))
   };
 }
+function enumerateExpressionCandidates(schema, query) {
+  if (schema === null) {
+    return { ok: true, prefix: "", partial: "", candidates: [] };
+  }
+  if (isCallFragment(query.expr)) {
+    return callSlotResult(schema, query);
+  }
+  return enumeratePathCandidates(schema, query, query.expr, 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;
+  return !isArrayNode(node) && node.properties === void 0;
 }
 function childCandidate2(key, node, prefix) {
   const candidate = {
@@ -4197,7 +4613,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;
@@ -4213,11 +4629,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;
@@ -4320,15 +4732,18 @@ export {
   ANCHORS,
   ARM_CREATE_LAYER_TYPES,
   CREATE_DEAD_ZONE_SCREEN_PX,
+  DATE_FORMAT_SUGGESTIONS,
   DEFAULT_EDITOR_SHORTCUTS,
   DEFAULT_ZOOM_BOUNDS,
   EDITOR_STATE_SCHEMA_VERSION,
+  EXPRESSION_FUNCTIONS,
   EditorSession,
   EditorStore,
   FontCatalog,
   HORIZONTAL_ALIGNS,
   LAYER_TYPES,
   MAX_HISTORY_STEPS,
+  NUMBER_FUNCTION_SUGGESTIONS,
   PACKAGE_NAME,
   PAN_TO_BOX_MARGIN_PX,
   PASTE_OFFSET_PX,
@@ -4366,6 +4781,8 @@ export {
   deleteLayerInDraft,
   enumerateExpressionCandidates,
   enumerateRowsPathCandidates,
+  expressionCallSlotAtEnd,
+  expressionDiagnostics,
   expressionFragmentAtCursor,
   fitRect,
   fitViewport,
@@ -4375,6 +4792,7 @@ export {
   hitTest,
   insertRootLayerAdjacentInDraft,
   insertRootLayerInDraft,
+  isCallFragment,
   isImageContentUndrawn,
   isLayerPath,
   isLockedPath,
@@ -4393,11 +4811,13 @@ export {
   normalizeExpressionSchemaSource,
   panBy,
   panToBox,
+  parseExpressionCall,
   parseExpressionPath,
   parseExpressionSchema,
   pastePosition,
   pathStartsWith,
   pathsEqual,
+  phpTrim2 as phpTrim,
   pickNextTextStylePatch,
   prepareRootPaste,
   readSpecField,
@@ -4414,6 +4834,7 @@ export {
   resolveRowsPathStartSchema,
   resolveSnap,
   resolveSnapPoints,
+  resourcePathDiagnostics,
   rootLayerOf,
   scanExpressionFragments,
   scanTextMatches,