@hankchen/canvas-editor 0.4.0 → 0.5.0

package/dist/index.js

@@ -602,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();
@@ -616,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" };
@@ -631,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 };
@@ -672,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(".");
@@ -712,6 +732,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 +746,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 +777,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 +818,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 +830,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 +890,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 +924,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);
   }
@@ -3084,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);
@@ -3104,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) {
@@ -3135,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);
@@ -3213,7 +3276,8 @@ var EditorSession = class {
    * 原地不动——事务后派生列表在被替换处缩一位，原下标即「下一处」（「替换后
    * 自动跳下一处」靠派生天然成立，末处替换则钳位停在尾）。写值经 replaceHitsInDraft
    * 与文本编辑提交同门（text 直写 + expression 保持 null）。无文档/空 query/
-   * 无命中空转返回 false。
+   * 无命中空转返回 false。命中编辑层时草稿接管（会话内容独占，工单 02——
+   * 替换结果出现在正在编辑的框里）。
    */
   replaceOne() {
     const doc = this.store.doc;
@@ -3222,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;
@@ -3231,7 +3295,8 @@ var EditorSession = class {
    * 全部替换（查找条「全部替换」按钮）：命中（path + 偏移对）在事务前按原文
    * 快照一次算定，单事务内按同字段偏移降序应用、替换产物不重扫（replacement
    * 含查询串不死循环）——一次调用 = 一步历史，undo 一次全回。返回应用处数
-   * （计数反馈「已替换 N 处」）；无文档/空 query 空转返回 0。
+   * （计数反馈「已替换 N 处」）；无文档/空 query 空转返回 0。命中编辑层时
+   * 草稿接管（会话内容独占，工单 02）。
    */
   replaceAll() {
     const doc = this.store.doc;
@@ -3240,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;
@@ -3294,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) {
@@ -3327,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) {
@@ -3350,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) => {
@@ -3361,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(
@@ -4241,6 +4371,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 +4425,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 +4436,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 +4447,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 +4465,7 @@ function functionCandidates() {
     path: fn.signature,
     segment: `${fn.name}()`,
     cursorBack: 1,
+    kind: "function",
     description: fn.summary,
     type: "\u51FD\u6570"
   }));
@@ -4325,12 +4481,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 +4515,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 +4545,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 +4575,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 +4593,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 +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;
@@ -4475,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;
@@ -4632,6 +4782,7 @@ export {
   enumerateExpressionCandidates,
   enumerateRowsPathCandidates,
   expressionCallSlotAtEnd,
+  expressionDiagnostics,
   expressionFragmentAtCursor,
   fitRect,
   fitViewport,
@@ -4683,6 +4834,7 @@ export {
   resolveRowsPathStartSchema,
   resolveSnap,
   resolveSnapPoints,
+  resourcePathDiagnostics,
   rootLayerOf,
   scanExpressionFragments,
   scanTextMatches,