yamlover 0.3.13 → 0.3.14

package/dist/server.js

@@ -62535,7 +62535,7 @@ function pathOf(chain) {
 
 // ../engine/ts/src/store.ts
 import { DatabaseSync } from "node:sqlite";
-var SCHEMA_VERSION = 4;
+var SCHEMA_VERSION = 5;
 var SCHEMA = `
 CREATE TABLE IF NOT EXISTS node (
   path         TEXT PRIMARY KEY,
@@ -62568,6 +62568,18 @@ CREATE TABLE IF NOT EXISTS dangling (
   reason    TEXT NOT NULL                -- why it did not resolve
 );
 `;
+function encodeScalarValue(v) {
+  if (typeof v === "number" && !Number.isFinite(v)) return JSON.stringify({ "@nonfinite": String(v) });
+  return JSON.stringify(v);
+}
+function decodeScalarValue(s2) {
+  const v = JSON.parse(s2);
+  if (v && typeof v === "object" && !Array.isArray(v) && "@nonfinite" in v) {
+    const n2 = v["@nonfinite"];
+    return n2 === "Infinity" ? Infinity : n2 === "-Infinity" ? -Infinity : NaN;
+  }
+  return v;
+}
 var Store = class {
   db;
   /** True while the DB holds no usable index (a new file, or a schema-version mismatch dropped
@@ -62612,7 +62624,7 @@ var Store = class {
         const meta = node.meta ? JSON.stringify(node.meta) : null;
         const owned = node.entries?.filter((e3) => e3.edge !== "back") ?? [];
         const isArray = node.array || node.kind === "mapping" && owned.length > 0 && owned.every((e3) => e3.key === null);
-        const value = node.kind === "scalar" ? JSON.stringify(node.value) : null;
+        const value = node.kind === "scalar" ? encodeScalarValue(node.value) : null;
         const format = node.kind === "blob" ? node.format : formatFromMeta(node);
         const hash = node.kind === "blob" ? node.contentHash : null;
         const size = node.kind === "blob" ? node.size : null;
@@ -62679,7 +62691,7 @@ var Store = class {
         const meta = node.meta ? JSON.stringify(node.meta) : null;
         const owned = node.entries?.filter((e3) => e3.edge !== "back") ?? [];
         const isArray = node.array || node.kind === "mapping" && owned.length > 0 && owned.every((e3) => e3.key === null);
-        const value = node.kind === "scalar" ? JSON.stringify(node.value) : null;
+        const value = node.kind === "scalar" ? encodeScalarValue(node.value) : null;
         const format = node.kind === "blob" ? node.format : formatFromMeta(node);
         const hash = node.kind === "blob" ? node.contentHash : null;
         const size = node.kind === "blob" ? node.size : null;
@@ -62720,7 +62732,7 @@ var Store = class {
       walkNodes(doc.root, annStorePath, (p2, node, parent, label, pos) => {
         const meta = node.meta ? JSON.stringify(node.meta) : null;
         const isArray = node.array || node.kind === "mapping" && (node.entries?.every((e3) => e3.key === null) ?? false);
-        const value = node.kind === "scalar" ? JSON.stringify(node.value) : null;
+        const value = node.kind === "scalar" ? encodeScalarValue(node.value) : null;
         const format = p2 === annStorePath ? "x-yamlover-annotation" : node.kind === "blob" ? node.format : formatFromMeta(node);
         const hash = node.kind === "blob" ? node.contentHash : null;
         const size = node.kind === "blob" ? node.size : null;
@@ -62919,7 +62931,7 @@ function rowToNode(r2) {
     path: r2.path,
     type: r2.type,
     format: r2.format ?? null,
-    value: r2.value != null ? JSON.parse(r2.value) : null,
+    value: r2.value != null ? decodeScalarValue(r2.value) : null,
     content_hash: r2.content_hash ?? null,
     size: r2.size ?? null,
     is_array: !!r2.is_array,
@@ -62981,7 +62993,11 @@ async function e() {
 
 // ../parser/ts/src/pointer.ts
 var LINK_RE = /^(?:[A-Za-z][A-Za-z0-9+.-]*:)?\/\//;
-function parsePointer(raw) {
+function parsePointer(raw, yaml = false) {
+  if (yaml) {
+    const p2 = parsePointer(raw);
+    return p2.base.scope === "current" ? { ...p2, base: { scope: "document" } } : p2;
+  }
   if (looksColon(raw)) return parseColon(raw);
   const lm = LINK_RE.exec(raw);
   if (lm) {
@@ -63268,13 +63284,13 @@ function unescape(s2) {
   }
   return out;
 }
-function makeAnchor(body, fail) {
+function makeAnchor(body, fail, yaml = false) {
   let ordinal = false;
   if (body.endsWith("[]") && !body.endsWith("\\[]")) {
     ordinal = true;
     body = body.slice(0, -2);
   }
-  const path11 = parsePointer(body);
+  const path11 = parsePointer(body, yaml);
   if (!ordinal) {
     const last = path11.steps[path11.steps.length - 1];
     if (last === void 0) fail('an anchor path needs a key segment (or a trailing "[]" for ordinal membership)');
@@ -63287,8 +63303,117 @@ function escapeSegment(name) {
   return name.replace(/[\\/:[\]*&#~?!()<>=|]/g, (c3) => "\\" + c3);
 }
 
+// ../parser/ts/src/comments.ts
+function attachComments(doc, raws, src, uri) {
+  if (raws.length === 0) return;
+  raws.sort((a2, b) => a2.start - b.start);
+  const entries = [];
+  const parentOf2 = /* @__PURE__ */ new Map();
+  const collect = (n2) => {
+    for (const e3 of n2.entries ?? []) {
+      if (e3.meta?.span) {
+        entries.push(e3);
+        parentOf2.set(e3, n2);
+      }
+      if (!isPointer(e3.value)) collect(e3.value);
+    }
+  };
+  collect(doc.root);
+  const firstStart = entries.length ? Math.min(...entries.map((e3) => e3.meta.span.start)) : src.length;
+  const lineOf = lineIndexer(src);
+  const blankBetween = (a2, b) => b > a2 && /\r?\n[ \t]*\r?\n/.test(src.slice(a2, b));
+  const make = (r2, placement) => ({
+    text: r2.text,
+    span: { uri, start: r2.start, end: r2.end },
+    placement,
+    style: r2.style,
+    ...precededByBlank(src, r2.start) ? { blankBefore: true } : {}
+  });
+  const push = (host, c3) => {
+    host.comments = [...host.comments ?? [], c3];
+  };
+  const used = /* @__PURE__ */ new Set();
+  const pre = raws.filter((r2) => r2.ownLine && r2.start < firstStart);
+  if (pre.length > 0) {
+    let m = 0;
+    while (m + 1 < pre.length && !blankBetween(pre[m].end, pre[m + 1].start)) m++;
+    const after = m + 1 < pre.length ? pre[m + 1].start : firstStart;
+    if (blankBetween(pre[m].end, after)) {
+      doc.head = pre.slice(0, m + 1).map((r2) => make(r2, "leading"));
+      for (let i2 = 0; i2 <= m; i2++) used.add(pre[i2]);
+    }
+  }
+  for (const r2 of raws) {
+    if (used.has(r2)) continue;
+    if (!r2.ownLine) {
+      const rl = lineOf(r2.start);
+      let best;
+      for (const e3 of entries) {
+        const s2 = e3.meta.span;
+        if (s2.end > r2.start || lineOf(s2.end) !== rl) continue;
+        const b = best ? best.meta.span : void 0;
+        if (!b || s2.end > b.end || s2.end === b.end && s2.start > b.start) best = e3;
+      }
+      if (best) {
+        push(best.meta, make(r2, "trailing"));
+        used.add(r2);
+        continue;
+      }
+      const next = nextEntryAfter(entries, r2.start);
+      if (next && lineOf(next.meta.span.start) === rl) {
+        push(next.meta, make(r2, "leading"));
+        used.add(r2);
+        continue;
+      }
+      const host = next ? parentOf2.get(next) : doc.root;
+      host.meta = host.meta ?? {};
+      push(host.meta, make(r2, "trailing"));
+      used.add(r2);
+      continue;
+    }
+    const target = nextEntryAfter(entries, r2.start);
+    if (target) {
+      push(target.meta, make(r2, "leading"));
+      used.add(r2);
+      continue;
+    }
+    doc.root.meta = doc.root.meta ?? {};
+    push(doc.root.meta, make(r2, r2.ownLine ? "leading" : "trailing"));
+    used.add(r2);
+  }
+}
+function nextEntryAfter(entries, off) {
+  let best;
+  for (const e3 of entries) {
+    const st = e3.meta.span.start;
+    if (st > off && (!best || st < best.meta.span.start)) best = e3;
+  }
+  return best;
+}
+function lineIndexer(src) {
+  const starts = [0];
+  for (let i2 = 0; i2 < src.length; i2++) if (src[i2] === "\n") starts.push(i2 + 1);
+  return (off) => {
+    let lo = 0;
+    let hi = starts.length - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >> 1;
+      if (starts[mid] <= off) lo = mid;
+      else hi = mid - 1;
+    }
+    return lo;
+  };
+}
+function precededByBlank(src, off) {
+  const ls = src.lastIndexOf("\n", off - 1);
+  if (ls < 0) return false;
+  const ps = src.lastIndexOf("\n", ls - 1);
+  return /^[ \t\r]*$/.test(src.slice(ps + 1, ls));
+}
+
 // ../parser/ts/src/yamlover.ts
-function parseYamlover(src, uri = "<yamlover>") {
+function parseYamlover(src, uri = "<yamlover>", opts = {}) {
+  const yaml = opts.yaml === true;
   const raw = [];
   const lineStarts = [];
   const sep2 = /\r\n|\r|\n/g;
@@ -63300,7 +63425,8 @@ function parseYamlover(src, uri = "<yamlover>") {
   }
   raw.push(src.slice(at));
   lineStarts.push(at);
-  const p2 = new Block(lex(raw), raw, uri, lineStarts);
+  const lexed = lex(raw, lineStarts, uri);
+  const p2 = new Block(lexed.lines, raw, uri, lineStarts, yaml);
   for (let k = 0; k < p2.lines.length; k++) {
     const l2 = p2.lines[k];
     if (l2.indent === 0 && (l2.text === "---" || l2.text.startsWith("--- ") || l2.text === "...")) {
@@ -63321,21 +63447,46 @@ function parseYamlover(src, uri = "<yamlover>") {
   }
   if (p2.i < p2.lines.length) p2.fail("unexpected content");
   if (rootSchema !== void 0) root.meta = { ...root.meta, schema: rootSchema };
-  return { root, source: { concrete: "yamlover", uri } };
+  root.meta = { ...root.meta, span: { uri, start: 0, end: src.length } };
+  const doc = { root, source: { concrete: yaml ? "yaml" : "yamlover", uri } };
+  const comments = lexed.comments.filter((c3) => !p2.blockLines.has(c3.n)).map(({ n: _n, ...r2 }) => r2);
+  attachComments(doc, comments, src, uri);
+  return doc;
 }
-function lex(raw) {
+function lex(raw, lineStarts, uri) {
   const out = [];
+  const comments = [];
+  let prevBlank = false;
   for (let n2 = 0; n2 < raw.length; n2++) {
     const line = raw[n2];
     let indent = 0;
     while (indent < line.length && line[indent] === " ") indent++;
-    const content = stripComment(line.slice(indent)).replace(/\s+$/, "");
-    if (content === "") continue;
-    out.push({ indent, text: content, n: n2 });
+    const body = line.slice(indent);
+    const at = commentStart(body);
+    const content = (at >= 0 ? body.slice(0, at) : body).replace(/\s+$/, "");
+    if (at >= 0) {
+      const base = lineStarts[n2] ?? 0;
+      comments.push({
+        start: base + indent + at,
+        end: base + line.replace(/\s+$/, "").length,
+        // through the last non-blank char
+        text: body.slice(at + 1).replace(/\s+$/, ""),
+        // body after `#`, trailing ws trimmed
+        ownLine: content === "",
+        style: "line",
+        n: n2
+      });
+    }
+    if (content === "") {
+      prevBlank = at < 0;
+      continue;
+    }
+    out.push({ indent, text: content, n: n2, ...prevBlank ? { blankBefore: true } : {} });
+    prevBlank = false;
   }
-  return out;
+  return { lines: out, comments };
 }
-function stripComment(s2) {
+function commentStart(s2) {
   let inS = false;
   let inD = false;
   for (let i2 = 0; i2 < s2.length; i2++) {
@@ -63347,10 +63498,10 @@ function stripComment(s2) {
     if (c3 === "'" && !inD) inS = !inS;
     else if (c3 === '"' && !inS) inD = !inD;
     else if (c3 === "#" && !inS && !inD && (i2 === 0 || s2[i2 - 1] === " " || s2[i2 - 1] === "	")) {
-      return s2.slice(0, i2);
+      return i2;
     }
   }
-  return s2;
+  return -1;
 }
 var Block = class {
   lines;
@@ -63360,12 +63511,17 @@ var Block = class {
   // source path/id, surfaced in parse-error messages
   lineStarts;
   // absolute offset of each raw line's first character
+  blockLines = /* @__PURE__ */ new Set();
+  // raw lines consumed by a block scalar (their `#` is content)
+  yaml;
+  // YAML concrete: bare `&`/`*` resolve at the document root
   i = 0;
-  constructor(lines, raw, uri = "<yamlover>", lineStarts = []) {
+  constructor(lines, raw, uri = "<yamlover>", lineStarts = [], yaml = false) {
     this.lines = lines;
     this.raw = raw;
     this.uri = uri;
     this.lineStarts = lineStarts;
+    this.yaml = yaml;
   }
   /** Absolute span of `len` chars starting at column `col` of raw line `lineN`. Valid
    *  because every Line.text is a prefix-aligned slice of its raw line (lex strips only
@@ -63415,7 +63571,7 @@ var Block = class {
       body = text.slice(1, j);
       tokenLen = j;
     }
-    const anchor = makeAnchor(body, (m) => this.fail(m));
+    const anchor = makeAnchor(body, (m) => this.fail(m), this.yaml);
     anchor.path.span = this.spanAt(lineN, col, tokenLen);
     const a2 = adv(text, tokenLen, col);
     return { anchor, rest: a2.rest, col: a2.col };
@@ -63489,6 +63645,9 @@ var Block = class {
     for (; ; ) {
       const l2 = this.peek();
       if (!l2 || l2.indent !== indent) break;
+      const startLineN = l2.n;
+      const startCol = l2.indent;
+      const startBlank = l2.blankBefore === true;
       let value;
       let entry;
       if (l2.text.startsWith("&")) {
@@ -63570,6 +63729,10 @@ var Block = class {
         value = this.valueAfter(kv.rest, indent, l2.n, l2.indent + kv.restCol);
         entry = { key: unquoteKey(key), edge: back ? "back" : isPointer(value) ? "ref" : "contain", value };
       }
+      const endLine = this.lines[this.i - 1];
+      const start = (this.lineStarts[startLineN] ?? 0) + startCol;
+      const end = endLine ? (this.lineStarts[endLine.n] ?? 0) + endLine.indent + endLine.text.length : start;
+      entry.meta = { ...entry.meta, span: { uri: this.uri, start, end }, ...startBlank ? { blankBefore: true } : {} };
       entries.push(entry);
     }
     const owned = entries.filter((e3) => e3.edge !== "back");
@@ -63662,6 +63825,7 @@ var Block = class {
       if (ind >= r2.length) {
         lines.push("");
         lastN = n2;
+        this.blockLines.add(n2);
         continue;
       }
       if (ind <= parentIndent) break;
@@ -63669,6 +63833,7 @@ var Block = class {
       if (blockIndent < 0) blockIndent = ind;
       lines.push(r2.slice(blockIndent));
       lastN = n2;
+      this.blockLines.add(n2);
     }
     while (this.peek() && this.peek().n <= lastN) this.i++;
     let last = -1;
@@ -63685,10 +63850,10 @@ var Block = class {
     ({ rest: text, col } = adv(text, 0, col));
     const c3 = text[0];
     if (c3 === "{" || c3 === "[") {
-      return new Flow(text, this.uri, (this.lineStarts[lineN] ?? 0) + col).parse();
+      return new Flow(text, this.uri, (this.lineStarts[lineN] ?? 0) + col, this.yaml).parse();
     }
     if (c3 === "*") {
-      const p2 = parsePointer(unquoteIfQuoted(text.slice(1)));
+      const p2 = parsePointer(unquoteIfQuoted(text.slice(1)), this.yaml);
       p2.span = this.spanAt(lineN, col, text.length);
       return p2;
     }
@@ -63715,10 +63880,12 @@ var Flow = class {
   uri;
   base;
   // absolute offset of s[0] in the source (span tracking)
-  constructor(s2, uri = "<flow>", base = 0) {
+  yaml;
+  constructor(s2, uri = "<flow>", base = 0, yaml = false) {
     this.s = s2;
     this.uri = uri;
     this.base = base;
+    this.yaml = yaml;
   }
   fail(msg) {
     throw new SyntaxError(`yamlover (flow): ${msg} at offset ${this.i}`);
@@ -63761,7 +63928,7 @@ var Flow = class {
         }
         txt = this.s.slice(st, this.i).trim();
       }
-      const p2 = parsePointer(txt);
+      const p2 = parsePointer(txt, this.yaml);
       p2.span = { uri: this.uri, start: this.base + start, end: this.base + this.i };
       return p2;
     }
@@ -63779,7 +63946,7 @@ var Flow = class {
         }
         body = this.s.slice(st, this.i);
       }
-      const anchor = makeAnchor(body, (m) => this.fail(m));
+      const anchor = makeAnchor(body, (m) => this.fail(m), this.yaml);
       anchor.path.span = { uri: this.uri, start: this.base + start, end: this.base + this.i };
       this.ws();
       const v = this.value();
@@ -64011,6 +64178,8 @@ function plainScalar(text) {
   if (t3 === "" || t3 === "~" || t3 === "null" || t3 === "Null" || t3 === "NULL") return { kind: "scalar", value: null, raw: text };
   if (t3 === "true" || t3 === "True" || t3 === "TRUE") return { kind: "scalar", value: true, raw: text };
   if (t3 === "false" || t3 === "False" || t3 === "FALSE") return { kind: "scalar", value: false, raw: text };
+  if (/^[-+]?\.(?:inf|Inf|INF)$/.test(t3)) return { kind: "scalar", value: t3[0] === "-" ? -Infinity : Infinity, raw: text };
+  if (/^\.(?:nan|NaN|NAN)$/.test(t3)) return { kind: "scalar", value: NaN, raw: text };
   if (/^[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/.test(t3)) return { kind: "scalar", value: Number(t3), raw: text };
   if (/^[-+]?0x[0-9a-fA-F]+$/.test(t3)) return { kind: "scalar", value: Number(t3), raw: text };
   return { kind: "scalar", value: t3, raw: text };
@@ -64040,12 +64209,17 @@ function parseJson5p(src, uri = "<json5p>") {
   p2.ws();
   if (p2.i < src.length) p2.fail("trailing characters");
   if (isPointer(root)) return p2.fail("a top-level pointer is not allowed");
-  return { root, source: { concrete: "json5p", uri } };
+  root.meta = { ...root.meta, span: { uri, start: 0, end: src.length } };
+  const doc = { root, source: { concrete: "json5p", uri } };
+  attachComments(doc, p2.comments, src, uri);
+  return doc;
 }
 var Parser = class {
   src;
   uri;
   i = 0;
+  comments = [];
+  // captured in ws(); placed onto the tree after the parse
   constructor(src, uri) {
     this.src = src;
     this.uri = uri;
@@ -64068,20 +64242,29 @@ var Parser = class {
         continue;
       }
       if (c3 === "/" && this.src[this.i + 1] === "/") {
+        const start = this.i;
         this.i += 2;
         while (this.i < this.src.length && this.src[this.i] !== "\n" && this.src[this.i] !== "\r") this.i++;
+        this.comments.push({ start, end: this.i, text: this.src.slice(start + 2, this.i).replace(/\s+$/, ""), ownLine: this.atLineStart(start), style: "line" });
         continue;
       }
       if (c3 === "/" && this.src[this.i + 1] === "*") {
+        const start = this.i;
         this.i += 2;
         while (this.i < this.src.length && !(this.src[this.i] === "*" && this.src[this.i + 1] === "/")) this.i++;
         if (this.i >= this.src.length) this.fail("unterminated block comment");
         this.i += 2;
+        this.comments.push({ start, end: this.i, text: this.src.slice(start + 2, this.i - 2).trim(), ownLine: this.atLineStart(start), style: "block" });
         continue;
       }
       return;
     }
   }
+  /** True when only whitespace precedes `off` on its line (so a comment there is own-line). */
+  atLineStart(off) {
+    const ls = this.src.lastIndexOf("\n", off - 1);
+    return /^[ \t\r]*$/.test(this.src.slice(ls + 1, off));
+  }
   value() {
     const c3 = this.peek();
     if (c3 === void 0) this.fail("unexpected end of input");
@@ -64103,13 +64286,14 @@ var Parser = class {
         break;
       }
       if (c3 === void 0) this.fail("unterminated object");
+      const entryStart = this.i;
       let back = false;
       if (this.peek() === "~") {
         back = true;
         this.i++;
       }
       if (back && this.peek() === "*") {
-        entries.push({ key: null, edge: "back", value: this.pointer() });
+        entries.push(withSpan({ key: null, edge: "back", value: this.pointer() }, this.uri, entryStart, this.i));
       } else {
         const key = this.key();
         this.ws();
@@ -64117,7 +64301,7 @@ var Parser = class {
         this.i++;
         this.ws();
         const v = this.value();
-        entries.push(makeEntry(key, back, v));
+        entries.push(withSpan(makeEntry(key, back, v), this.uri, entryStart, this.i));
       }
       this.ws();
       const n2 = this.peek();
@@ -64144,12 +64328,13 @@ var Parser = class {
         break;
       }
       if (c3 === void 0) this.fail("unterminated array");
+      const entryStart = this.i;
       if (c3 === "~") {
         this.i++;
         if (this.peek() !== "*") this.fail('expected a pointer after "~" (keyless back member)');
-        entries.push({ key: null, edge: "back", value: this.pointer() });
+        entries.push(withSpan({ key: null, edge: "back", value: this.pointer() }, this.uri, entryStart, this.i));
       } else {
-        entries.push(makeEntry(null, false, this.value()));
+        entries.push(withSpan(makeEntry(null, false, this.value()), this.uri, entryStart, this.i));
       }
       this.ws();
       const n2 = this.peek();
@@ -64286,6 +64471,10 @@ function makeEntry(key, back, v) {
   const edge = back ? "back" : isPointer(v) ? "ref" : "contain";
   return { key, edge, value: v };
 }
+function withSpan(e3, uri, start, end) {
+  e3.meta = { ...e3.meta, span: { uri, start, end } };
+  return e3;
+}
 function scalar(value, raw) {
   return { kind: "scalar", value, raw };
 }
@@ -64734,14 +64923,15 @@ function textScalar(abs, format, ctx) {
   return { kind: "scalar", value: text, raw: text, meta: { schema: inlineFormat(format) } };
 }
 function parsedScalar(abs, ext, ctx) {
-  return parsedDoc(abs, ext === ".json" || ext === ".json5" || ext === ".json5p" ? "json5p" : "yamlover", ctx);
+  const lang = ext === ".json" || ext === ".json5" || ext === ".json5p" ? "json5p" : ext === ".yaml" || ext === ".yml" ? "yaml" : "yamlover";
+  return parsedDoc(abs, lang, ctx);
 }
 function parsedDoc(abs, lang, ctx) {
   const text = readTracked(ctx, abs).toString("utf8");
   try {
-    const doc = lang === "json5p" ? parseJson5p(text, abs) : parseYamlover(text, abs);
+    const doc = lang === "json5p" ? parseJson5p(text, abs) : parseYamlover(text, abs, { yaml: lang === "yaml" });
     const root = doc.root;
-    root.meta = { ...root.meta, documentRoot: true };
+    root.meta = { ...root.meta, documentRoot: true, ...doc.head?.length ? { head: doc.head } : {} };
     return root;
   } catch {
     return { kind: "scalar", value: text, raw: text };
@@ -64826,12 +65016,13 @@ function applyBody(dir, node, ctx) {
   if (!fs2.existsSync(file)) return node;
   const bodyDoc = parseYamlover(readTracked(ctx, file).toString("utf8"), file);
   const body = bodyDoc.root;
-  if (body.kind !== "mapping" && body.kind !== "scalar" || !body.entries) return node;
-  const meta = { ...node.meta, ...body.meta, documentRoot: true };
-  if (body.kind === "mapping" && (body.array || body.entries.length > 0 && body.entries.every((e3) => e3.key === null))) {
+  if (body.kind !== "mapping" && body.kind !== "scalar") return node;
+  const bodyEntries = body.entries ?? [];
+  const meta = { ...node.meta, ...body.meta, documentRoot: true, ...bodyDoc.head?.length ? { head: bodyDoc.head } : {} };
+  if (body.kind === "mapping" && (body.array || bodyEntries.length > 0 && bodyEntries.every((e3) => e3.key === null))) {
     const byKey = new Map(node.entries.map((e3) => [e3.key, e3]));
     const ordered = [];
-    for (const e3 of body.entries) {
+    for (const e3 of bodyEntries) {
       const targetKey = isPointer(e3.value) ? pointerLeafKey(e3.value) : null;
       const hit = targetKey != null ? byKey.get(targetKey) : null;
       if (hit) {
@@ -64844,7 +65035,7 @@ function applyBody(dir, node, ctx) {
   }
   const merged = new Map(node.entries.map((e3) => [e3.key, e3]));
   const order = node.entries.map((e3) => e3.key);
-  for (const e3 of body.entries) {
+  for (const e3 of bodyEntries) {
     const existing = merged.get(e3.key);
     if (!existing) {
       order.push(e3.key);
@@ -64940,9 +65131,9 @@ var EXT_FORMAT = {
 var TEXT_FORMATS = /* @__PURE__ */ new Set(["text/markdown", "text/asciidoc", "text/x-plantuml", "text/csv", "text/tab-separated-values"]);
 var DOC_FORMATS = {
   "yamlover": "yamlover",
-  "yaml": "yamlover",
+  "yaml": "yaml",
   "yamlover/meta": "yamlover",
-  "yaml/meta": "yamlover",
+  "yaml/meta": "yaml",
   "json": "json5p",
   "json5": "json5p",
   "json5p": "json5p",
@@ -64954,6 +65145,11 @@ var DOC_FORMATS = {
 // ../engine/ts/src/rewrite.ts
 import * as path3 from "node:path";
 
+// ../parser/ts/src/serialize-common.ts
+function anchorBody(a2) {
+  return renderPointer(a2.path) + (a2.ordinal ? "[]" : "");
+}
+
 // ../parser/ts/src/serialize-yamlover.ts
 function pointerToken(raw) {
   if (raw !== raw.trim()) return `*'${raw.replace(/'/g, "''")}'`;
@@ -65967,6 +66163,36 @@ function removeAnnotation(text, within, predicate) {
   return text;
 }
 
+// src/concrete.ts
+var JSON_FAMILY = /* @__PURE__ */ new Set(["json", "json5", "json5p"]);
+var YAML_FAMILY = /* @__PURE__ */ new Set(["yaml", "yamlover"]);
+function isDirConcrete(c3) {
+  return c3 === "dir" || c3 === "dir/yamlover";
+}
+function baseLanguage(c3) {
+  if (!c3) return null;
+  const bare = c3.startsWith("file/") ? c3.slice("file/".length) : c3;
+  return JSON_FAMILY.has(bare) || YAML_FAMILY.has(bare) ? bare : null;
+}
+function interiorOf(c3) {
+  return baseLanguage(c3) ?? "yaml";
+}
+var EXT_FILE_CONCRETE = {
+  ".yamlover": "file/yamlover",
+  ".yaml": "file/yaml",
+  ".yml": "file/yaml",
+  ".json": "file/json",
+  ".json5": "file/json5",
+  ".json5p": "file/json5p"
+};
+function dataFileConcrete(filePath) {
+  const slash = Math.max(filePath.lastIndexOf("/"), filePath.lastIndexOf("\\"));
+  const base = filePath.slice(slash + 1);
+  const dot = base.lastIndexOf(".");
+  const ext = dot > 0 ? base.slice(dot).toLowerCase() : "";
+  return EXT_FILE_CONCRETE[ext] ?? null;
+}
+
 // src/server/extract/types.ts
 var byFormat = (...fmts) => (format) => format !== null && fmts.includes(format);
 
@@ -66226,6 +66452,9 @@ var TaskRegistry = class {
 var LINK_KEY = "$yamloverLink";
 var BINARY_KEY = "$yamloverBinary";
 var MIXED_KEY = "$yamloverMixed";
+var REF_KEY = "$yamloverRef";
+var NUM_KEY = "$yamloverNum";
+var wireScalar = (v) => typeof v === "number" && !Number.isFinite(v) ? { [NUM_KEY]: String(v) } : v;
 function createHandlers(dataRoot, opts = {}) {
   const rootName = path10.basename(path10.resolve(dataRoot)) || "/";
   const dbPath = path10.join(dataRoot, ".yamlover", "index.db");
@@ -66692,8 +66921,8 @@ function createHandlers(dataRoot, opts = {}) {
       }
       const row = s2.node(p2);
       if (!row) return notFound(res, url);
-      const viewDepth = depth ?? 1;
       const kind = displayKind(s2, p2, row);
+      const viewDepth = depth === void 0 ? defaultDepth(s2, dataRoot, segs, row, kind) : depth;
       if (url.pathname === "/api/json") {
         const wantBytes = row.type === "blob" && url.searchParams.get("binary") === "1";
         sendJson(res, 200, {
@@ -66702,13 +66931,14 @@ function createHandlers(dataRoot, opts = {}) {
           format: row.format ?? null,
           ...facetsOf(s2, p2, row),
           // valueType / hasKeyed / hasOrdinal — the renderer dispatch facets (TYPES.md §9)
-          concrete: concreteOf(dataRoot, segs, row),
-          // dir | yamlover | null (stat-derived; engine tracks no per-node concrete yet)
+          concrete: concreteOf(s2, dataRoot, segs, row),
+          // the full per-node concrete taxonomy (stat + document language)
           documentPath: documentPath(s2, segs),
           // nearest enclosing document root (for `/…` links)
           title: titleOf(s2, p2),
           description: null,
           value: wantBytes ? binaryContent(dataRoot, segs, row) : projectValue(dataRoot, s2, segs, viewDepth, true),
+          comments: cachedDoc && !wantBytes ? collectComments(cachedDoc, segs, viewDepth) : {},
           relations: buildRelations(dataRoot, s2, segs)
         });
       } else if (url.pathname === "/api/schema") {
@@ -66734,30 +66964,23 @@ function createHandlers(dataRoot, opts = {}) {
 function tocType(s2, p2, row) {
   return typeName(s2, p2, row);
 }
-var JSON_EXT = { ".json": "json", ".json5": "json5", ".json5p": "json5p" };
-function concreteOf(dataRoot, segs, row) {
-  const last = segs[segs.length - 1];
-  if (typeof last === "string") {
-    const json = JSON_EXT[path10.extname(last).toLowerCase()];
-    if (json) {
-      const abs2 = path10.resolve(dataRoot, ...segs.map(String));
-      try {
-        if (fs10.statSync(abs2).isFile()) return json;
-      } catch {
-      }
+function concreteOf(s2, dataRoot, segs, row) {
+  if (segs.every((g) => typeof g === "string")) {
+    const abs = path10.resolve(dataRoot, ...segs.map(String));
+    let st;
+    try {
+      st = fs10.statSync(abs);
+    } catch {
     }
+    if (st?.isDirectory()) return fs10.existsSync(path10.join(abs, ".yamlover")) ? "dir/yamlover" : "dir";
+    if (st?.isFile()) return dataFileConcrete(abs) ?? (row.type === "blob" ? "file/binary" : "file/yaml");
   }
-  if (row.type !== "mapping") return null;
-  if (segs.some((g) => typeof g === "number")) return null;
-  const abs = path10.resolve(dataRoot, ...segs.map(String));
-  let st;
+  const docAbs = path10.resolve(dataRoot, ...documentRootSegs(s2, segs).map(String));
   try {
-    st = fs10.statSync(abs);
+    if (fs10.statSync(docAbs).isFile()) return interiorOf(dataFileConcrete(docAbs) ?? "file/yaml");
   } catch {
-    return null;
   }
-  if (!st.isDirectory()) return null;
-  return fs10.existsSync(path10.join(abs, ".yamlover")) ? "yamlover" : "dir";
+  return "yamlover";
 }
 var relKey = (label, other) => `${label ?? ""}\0${other}`;
 var isHidden = (s2, to2) => !!s2.node(to2)?.meta?.hidden;
@@ -66795,12 +67018,17 @@ function projectValue(dataRoot, s2, segs, depth, top) {
   if (k === "binary" && !top) return linkMarker(dataRoot, s2, segs);
   if (k === "binary") return { size: row.size, format: row.format };
   const kids = downstreamEntries(s2, p2);
-  const project = (c3) => c3.kind === "contain" ? projectValue(dataRoot, s2, [...segs, c3.label ?? c3.pos ?? 0], depth - 1, false) : linkMarker(dataRoot, s2, storePathToSegs(c3.to));
+  const currentDoc = documentRootSegs(s2, segs);
+  const project = (c3) => {
+    if (c3.kind === "contain") return projectValue(dataRoot, s2, [...segs, c3.label ?? c3.pos ?? 0], depth - 1, false);
+    const targetSegs = storePathToSegs(c3.to);
+    return depth === Infinity ? refMarker(refPointerText(s2, targetSegs, currentDoc), segsToStr(targetSegs)) : linkMarker(dataRoot, s2, targetSegs);
+  };
   if (k === "array") return kids.map(project);
   if (k === "omni" || k === "mix") {
     const entries = kids.map((c3) => ({ key: c3.label, value: project(c3) }));
     const marker = { kind: k, entries };
-    if (k === "omni") marker.value = row.value;
+    if (k === "omni") marker.value = wireScalar(row.value);
     return { [MIXED_KEY]: marker };
   }
   if (k === "object") {
@@ -66808,7 +67036,77 @@ function projectValue(dataRoot, s2, segs, depth, top) {
     for (const c3 of kids) out[c3.label ?? String(c3.pos)] = project(c3);
     return out;
   }
-  return row.value;
+  return wireScalar(row.value);
+}
+function irNodeAt(doc, segs) {
+  let node = doc.root;
+  for (const seg of segs) {
+    const entries = node.entries ?? [];
+    let val;
+    if (typeof seg === "number") {
+      const e3 = entries[seg];
+      if (!e3 || e3.key !== null || e3.edge !== "contain") return void 0;
+      val = e3.value;
+    } else {
+      val = entries.find((en) => en.key === seg && en.edge === "contain")?.value;
+    }
+    if (!val || isPointer(val)) return void 0;
+    node = val;
+  }
+  return node;
+}
+function tagOf(n2) {
+  if (n2.meta?.set) return "!!set";
+  const owned = (n2.entries ?? []).filter((e3) => e3.edge !== "back");
+  if (n2.kind === "mapping" && owned.some((e3) => e3.key != null) && owned.some((e3) => e3.key === null)) return "!!mix";
+  if (n2.kind === "scalar" && owned.length > 0) return "!!var";
+  return void 0;
+}
+function nodeDeco(bucket, node) {
+  const anchors = (node.meta?.anchors ?? []).map(anchorBody);
+  if (anchors.length > 0) bucket.anchors = anchors;
+  const tag = tagOf(node);
+  if (tag) bucket.tag = tag;
+  const vt = (node.meta?.comments ?? []).filter((c3) => c3.placement === "trailing").map((c3) => c3.text);
+  if (vt.length > 0) bucket.valueTrailing = vt;
+}
+function collectComments(doc, segs, depth) {
+  const out = {};
+  const root = irNodeAt(doc, segs);
+  if (!root) return out;
+  {
+    const self2 = {};
+    nodeDeco(self2, root);
+    if (self2.anchors || self2.tag || self2.valueTrailing) out[""] = self2;
+  }
+  const head = (root.meta?.head ?? []).map((c3) => c3.text);
+  if (head.length > 0) out.$head = head;
+  const tail = (root.meta?.comments ?? []).filter((c3) => c3.placement === "leading").map((c3) => c3.text);
+  if (tail.length > 0) out.$tail = tail;
+  const placed = (cs, p2) => (cs ?? []).filter((c3) => c3.placement === p2).map((c3) => c3.text);
+  const walk = (node, rel, d, top) => {
+    if (!top && d <= 0) return;
+    let i2 = 0;
+    for (const e3 of node.entries ?? []) {
+      if (e3.edge === "back") continue;
+      if (e3.edge === "contain" && !isPointer(e3.value) && e3.value.meta?.hidden) continue;
+      const cont = e3.key != null ? `/${e3.key}` : `[${i2}]`;
+      i2++;
+      const bucket = {};
+      const lead = placed(e3.meta?.comments, "leading");
+      const trail = placed(e3.meta?.comments, "trailing");
+      if (lead.length > 0) bucket.leading = lead;
+      if (trail.length > 0) bucket.trailing = trail;
+      const leadComment = e3.meta?.comments?.find((c3) => c3.placement === "leading");
+      if (e3.meta?.blankBefore || leadComment?.blankBefore) bucket.blankBefore = true;
+      if (isPointer(e3.value)) bucket.pointer = renderPointer(e3.value);
+      else nodeDeco(bucket, e3.value);
+      if (Object.keys(bucket).length > 0) out[rel + cont] = bucket;
+      if (e3.edge === "contain" && !isPointer(e3.value)) walk(e3.value, rel + cont, d - 1, false);
+    }
+  };
+  walk(root, "", depth, true);
+  return out;
 }
 function projectSchema(dataRoot, s2, segs, depth, top) {
   const p2 = storePath(segs);
@@ -66843,15 +67141,14 @@ function linkMarker(dataRoot, s2, segs) {
   const k = displayKind(s2, p2, row);
   const info = { kind: k, type: tocType(s2, p2, row), ...facetsOf(s2, p2, row), path: segsToStr(segs) };
   if (row.format) info.format = row.format;
-  const concrete = concreteOf(dataRoot, segs, row);
-  if (concrete) info.concrete = concrete;
+  info.concrete = concreteOf(s2, dataRoot, segs, row);
   const title = titleOf(s2, p2);
   if (title) info.title = title;
   if (k === "binary") info.size = row.size;
-  else if (k === "scalar") info.value = row.value;
+  else if (k === "scalar") info.value = wireScalar(row.value);
   else if (k === "omni" || k === "mix") {
     info.count = ownedEntries(s2, p2).length;
-    if (k === "omni") info.value = row.value;
+    if (k === "omni") info.value = wireScalar(row.value);
   } else info.count = s2.children(p2).filter((c3) => !isHidden(s2, c3.to)).length;
   if (row.format === TAG_FORMAT) {
     const c3 = s2.node(p2 + ":color")?.value;
@@ -66864,6 +67161,14 @@ function scopedPath(s2, src, currentDoc) {
   if (segsEqual(documentRootSegs(s2, src), currentDoc)) return segsToStr(src.slice(currentDoc.length));
   return "::" + segsToStr(src).slice(1);
 }
+function refPointerText(s2, src, currentDoc) {
+  const seg = (x2) => typeof x2 === "number" ? `[${x2}]` : `: ${x2}`;
+  if (segsEqual(documentRootSegs(s2, src), currentDoc)) {
+    const tail = src.slice(currentDoc.length);
+    return "*" + (tail.length > 0 ? tail.map(seg).join("") : ":");
+  }
+  return "*:" + src.map(seg).join("");
+}
 function buildRelations(dataRoot, s2, segs) {
   const p2 = storePath(segs);
   const out = {};
@@ -66872,7 +67177,7 @@ function buildRelations(dataRoot, s2, segs) {
     for (let i2 = 2; k in out; i2++) k = `${label} (${i2})`;
     out[k] = marker;
   };
-  if (segs.length > 0) put("..", linkMarker(dataRoot, s2, segs.slice(0, -1)));
+  if (segs.length > 0) put("..", refMarker("..", segsToStr(segs.slice(0, -1))));
   const currentDoc = documentRootSegs(s2, segs);
   const { out: outEdges, in: inEdges } = s2.relationships(p2);
   const upstream = /* @__PURE__ */ new Map();
@@ -66883,7 +67188,8 @@ function buildRelations(dataRoot, s2, segs) {
   for (const e3 of outEdges) if (e3.kind === "back") addUp(e3.to, e3.label);
   for (const src of upstream.values()) {
     const segs2 = storePathToSegs(src);
-    put(scopedPath(s2, segs2, currentDoc), linkMarker(dataRoot, s2, segs2));
+    const key = scopedPath(s2, segs2, currentDoc);
+    put(key, s2.node(src)?.format === TAG_FORMAT ? linkMarker(dataRoot, s2, segs2) : refMarker(key, segsToStr(segs2)));
   }
   return out;
 }
@@ -66901,7 +67207,7 @@ function buildTree(dataRoot, s2, segs, label, depth) {
     type: tocType(s2, p2, row),
     format: row.format ?? null,
     ...facetsOf(s2, p2, row),
-    concrete: concreteOf(dataRoot, segs, row),
+    concrete: concreteOf(s2, dataRoot, segs, row),
     hasChildren: visibleHasChildren(s2, p2),
     children: []
   };
@@ -67533,9 +67839,17 @@ function formatFromExt(file) {
   return EXT_CT[path10.extname(file).toLowerCase()] ?? null;
 }
 function parseDepth(raw) {
-  if (raw == null || raw === "") return null;
+  if (raw == null || raw === "") return void 0;
+  if (raw === ".inf" || raw === "inf") return Infinity;
   const n2 = Number(raw);
-  return Number.isInteger(n2) && n2 >= 0 ? n2 : null;
+  return Number.isInteger(n2) && n2 >= 0 ? n2 : void 0;
+}
+function defaultDepth(s2, dataRoot, segs, row, kind) {
+  if (kind === "binary") return 1;
+  return isDirConcrete(concreteOf(s2, dataRoot, segs, row)) ? 1 : Infinity;
+}
+function refMarker(text, path11) {
+  return { [REF_KEY]: { text, path: path11 } };
 }
 function clampThumbDim(raw, def) {
   const n2 = raw == null ? NaN : Math.round(Number(raw));