@backbencher/brain 0.0.0-stage → 0.1.1

package/dist/real-toml-analyzer-66L7BDCQ.js

@@ -0,0 +1,929 @@
+import {
+  dirOf,
+  fileClaimForTarget,
+  projectRelativeOf
+} from "./chunk-EWMWK7WN.js";
+import {
+  applyDocumentScope,
+  documentDirScope
+} from "./chunk-2WXYNLBA.js";
+import {
+  ASTEngine
+} from "./chunk-3ZTOHHSW.js";
+import "./chunk-BQ3OVQ3P.js";
+import "./chunk-SK6YVHFZ.js";
+import "./chunk-2BSKD7O3.js";
+import "./chunk-KAET47ZL.js";
+import "./chunk-KCDECRJY.js";
+import "./chunk-MLKGABMK.js";
+
+// src/ast/real-toml-analyzer.ts
+import * as path from "path";
+import { readFileSync, statSync } from "fs";
+var DEPENDENCY_MANIFESTS = ["Cargo.toml", "Project.toml", "JuliaProject.toml", "pyproject.toml", "Package.toml"];
+var PUBLISH_SURFACE_KEYS = /* @__PURE__ */ new Set([
+  "export",
+  "exports",
+  "expose",
+  "exposed",
+  "pub",
+  "public",
+  "publish",
+  "main",
+  "module",
+  "mod",
+  "entrypoint"
+]);
+function isPathOrUriShaped(value) {
+  if (value.includes("/") || value.includes("\\")) return true;
+  for (let i = 0; i < value.length; i++) {
+    const c = value.charCodeAt(i);
+    const letter = c >= 65 && c <= 90 || c >= 97 && c <= 122;
+    if (i === 0) {
+      if (!letter) return false;
+      continue;
+    }
+    if (c === 58) return true;
+    if (!(letter || c >= 48 && c <= 57 || c === 43 || c === 45 || c === 46)) return false;
+  }
+  return false;
+}
+function dependencyFileClaim(written, filePath, projectRoot, base) {
+  if (projectRoot === null || projectRoot.length === 0) return null;
+  const root = path.resolve(projectRoot);
+  const fileRel = path.relative(root, filePath).split(path.sep).join("/");
+  const posix = projectRelativeOf(dirOf(fileRel), written.trim());
+  const extraCandidates = [];
+  if (posix !== null) {
+    for (const m of DEPENDENCY_MANIFESTS) extraCandidates.push(posix.length === 0 ? m : `${posix}/${m}`);
+    if (posix.length > 0) extraCandidates.push(posix);
+  }
+  const standard = fileClaimForTarget({
+    projectRoot: root,
+    filePath,
+    written,
+    admittedExtensions: ["toml"],
+    extraCandidates
+  });
+  if (standard !== null) return standard;
+  if (base === null) return null;
+  const baseCandidates = pathBaseCandidates(base, written, filePath, root);
+  if (baseCandidates.length === 0) return null;
+  return fileClaimForTarget({
+    projectRoot: root,
+    filePath,
+    written,
+    admittedExtensions: ["toml"],
+    extraCandidates: [...baseCandidates, ...extraCandidates]
+  });
+}
+function pathBaseValueIn(configText, base) {
+  let inSection = false;
+  let found = null;
+  for (const raw of configText.split("\n")) {
+    const uncommented = stripCommentOutsideQuotes(raw);
+    if (uncommented === null) return null;
+    const line = uncommented.trim();
+    if (line.length === 0) continue;
+    if (line.charCodeAt(0) === 91) {
+      const close = line.indexOf("]");
+      if (close < 0) return null;
+      inSection = line.slice(1, close).trim() === "path-bases";
+      continue;
+    }
+    if (!inSection) continue;
+    const eq = line.indexOf("=");
+    if (eq < 0) return null;
+    if (unquoteKey(line.slice(0, eq).trim()) !== base) continue;
+    const value = line.slice(eq + 1).trim();
+    if (value.length < 2) return null;
+    const q = value.charCodeAt(0);
+    if (q !== 34 && q !== 39 || value.charCodeAt(value.length - 1) !== q) return null;
+    const inner = value.slice(1, -1);
+    if (inner.includes("\\")) return null;
+    if (found !== null) return null;
+    found = inner;
+  }
+  return found;
+}
+function stripCommentOutsideQuotes(line) {
+  let quote = 0;
+  for (let i = 0; i < line.length; i++) {
+    const c = line.charCodeAt(i);
+    if (quote !== 0) {
+      if (c === 92) {
+        i++;
+        continue;
+      }
+      if (c === quote) quote = 0;
+      continue;
+    }
+    if (c === 34 || c === 39) {
+      quote = c;
+      continue;
+    }
+    if (c === 35) return line.slice(0, i);
+  }
+  return quote === 0 ? line : null;
+}
+function pathBaseCandidates(base, written, filePath, projectRoot) {
+  const root = path.resolve(projectRoot);
+  let dir = path.dirname(path.resolve(filePath));
+  for (let depth = 0; depth < 64; depth++) {
+    const configPath = path.join(dir, ".cargo", "config.toml");
+    let text = null;
+    try {
+      if (statSync(configPath).isFile()) text = readFileSync(configPath, "utf8");
+    } catch {
+      text = null;
+    }
+    if (text !== null) {
+      const value = pathBaseValueIn(text, base);
+      if (value !== null) {
+        const joined = path.resolve(path.resolve(dir, value), written.trim());
+        const rel = path.relative(root, joined).split(path.sep).join("/");
+        if (rel.length === 0 || rel === ".." || rel.startsWith("../")) return [];
+        const out = [];
+        for (const m of DEPENDENCY_MANIFESTS) out.push(`${rel}/${m}`);
+        out.push(rel);
+        return out;
+      }
+    }
+    const parent = path.dirname(dir);
+    if (dir === root || parent === dir) break;
+    dir = parent;
+  }
+  return [];
+}
+function workspaceDeclaredPaths(text) {
+  const paths = /* @__PURE__ */ new Set();
+  let table = "";
+  for (const raw of text.split("\n")) {
+    const line = raw.trim();
+    if (line.length === 0 || line.charAt(0) === "#") continue;
+    if (line.charAt(0) === "[") {
+      const close = line.indexOf("]");
+      table = close < 0 ? "" : line.slice(1, close).trim();
+      continue;
+    }
+    const eq = line.indexOf("=");
+    if (eq < 0) continue;
+    let key = line.slice(0, eq).trim();
+    if (key.length >= 2) {
+      const q = key.charCodeAt(0);
+      if ((q === 34 || q === 39) && key.charCodeAt(key.length - 1) === q) key = key.slice(1, -1);
+    }
+    if (key.length === 0) continue;
+    paths.add(table.length > 0 ? `${table}.${key}` : key);
+  }
+  return paths;
+}
+function declaresWorkspace(text) {
+  for (const raw of text.split("\n")) if (raw.trim() === "[workspace]") return true;
+  return false;
+}
+function findWorkspaceRoot(filePath, projectRoot) {
+  if (projectRoot === null || projectRoot.length === 0) return null;
+  const root = path.resolve(projectRoot);
+  let dir = path.dirname(path.resolve(filePath));
+  for (let depth = 0; depth < 64; depth++) {
+    for (const m of ["Cargo.toml", "Project.toml", "pyproject.toml", "Package.toml"]) {
+      const abs = path.join(dir, m);
+      let text = null;
+      try {
+        if (statSync(abs).isFile()) text = readFileSync(abs, "utf8");
+      } catch {
+        text = null;
+      }
+      if (text === null || !declaresWorkspace(text)) continue;
+      const stem = path.basename(abs, path.extname(abs)) || "document";
+      return { abs, moduleName: applyDocumentScope(stem, documentDirScope(abs, root)) };
+    }
+    const parent = path.dirname(dir);
+    if (dir === root || parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function unquoteKey(text) {
+  if (text.length < 2) return text;
+  const first = text.charCodeAt(0);
+  if (first !== 34 && first !== 39) return text;
+  const inner = text.slice(1, -1);
+  if (first === 39) return inner;
+  let out = "";
+  for (let i = 0; i < inner.length; i++) {
+    const c = inner.charCodeAt(i);
+    if (c !== 92) {
+      out += inner[i];
+      continue;
+    }
+    const n = inner.charCodeAt(i + 1);
+    i++;
+    if (n === 110) out += "\n";
+    else if (n === 116) out += "	";
+    else if (n === 114) out += "\r";
+    else if (n === 34) out += '"';
+    else if (n === 92) out += "\\";
+    else if (n === 117 || n === 85) {
+      const hex = inner.slice(i + 1, i + 5);
+      if (hex.length === 4) {
+        const v = Number.parseInt(hex, 16);
+        if (Number.isFinite(v)) {
+          out += String.fromCharCode(v);
+          i += 4;
+          continue;
+        }
+      }
+      out += "\\u";
+    } else {
+      out += "\\";
+      out += inner[i] ?? "";
+    }
+  }
+  return out;
+}
+function segmentsOf(node) {
+  const chain = [];
+  let cur = node;
+  while (cur.type === "dotted_key") {
+    chain.push(cur);
+    const first = (cur.namedChildren ?? [])[0];
+    if (!first) break;
+    cur = first;
+  }
+  const out = [];
+  if (cur.type === "bare_key" || cur.type === "quoted_key") out.push(unquoteKey(cur.text));
+  for (let i = chain.length - 1; i >= 0; i--) {
+    const kids = chain[i].namedChildren ?? [];
+    const rest = kids.length > 0 ? kids[kids.length - 1] : void 0;
+    if (rest && (rest.type === "bare_key" || rest.type === "quoted_key")) {
+      out.push(unquoteKey(rest.text));
+    } else if (rest) {
+      for (const seg of segmentsOf(rest)) out.push(seg);
+    }
+  }
+  return out;
+}
+function namesSomething(segments) {
+  for (const s of segments) if (s.length > 0) return true;
+  return false;
+}
+function joinPath(segments) {
+  let out = "";
+  for (let i = 0; i < segments.length; i++) {
+    if (i > 0) out += ".";
+    out += spellSegment(segments[i]);
+  }
+  return out;
+}
+function spellSegment(seg) {
+  let bare = seg.length > 0;
+  for (let k = 0; bare && k < seg.length; k++) {
+    const c = seg.charCodeAt(k);
+    bare = c >= 65 && c <= 90 || c >= 97 && c <= 122 || c >= 48 && c <= 57 || c === 95 || c === 45;
+  }
+  if (bare) return seg;
+  let out = '"';
+  for (let k = 0; k < seg.length; k++) {
+    const c = seg.charCodeAt(k);
+    if (c === 34 || c === 92) out += "\\";
+    out += seg[k];
+  }
+  return out + '"';
+}
+function valueOf(pair) {
+  const kids = pair.namedChildren ?? [];
+  for (let i = kids.length - 1; i >= 1; i--) {
+    const k = kids[i];
+    if (k.type === "comment") continue;
+    return k;
+  }
+  return null;
+}
+function keyOf(pair) {
+  const first = (pair.namedChildren ?? [])[0];
+  if (!first) return null;
+  return first.type === "bare_key" || first.type === "quoted_key" || first.type === "dotted_key" ? first : null;
+}
+function headerKeyOf(node) {
+  for (const child of node.namedChildren ?? []) {
+    if (child.type === "bare_key" || child.type === "quoted_key" || child.type === "dotted_key") return child;
+  }
+  return null;
+}
+function isScalarValueNode(node) {
+  if (!node) return false;
+  return node.type === "string" || node.type === "integer" || node.type === "float" || node.type === "boolean";
+}
+function stringValueOf(node) {
+  if (!node || node.type !== "string") return null;
+  const text = (node.text ?? "").trim();
+  if (text.length < 2) return null;
+  const q = text[0];
+  if (q !== "'" && q !== '"') return null;
+  if (text[text.length - 1] !== q) return null;
+  return text.slice(1, -1);
+}
+function inlineRefAliases(inlineTable) {
+  const out = [];
+  for (const child of inlineTable.namedChildren ?? []) {
+    if (child.type !== "pair") continue;
+    const ck = keyOf(child);
+    if (!ck) continue;
+    const segs = segmentsOf(ck);
+    if (segs.length === 0) continue;
+    if (segs[segs.length - 1] !== "ref") continue;
+    const alias = stringValueOf(valueOf(child));
+    if (!alias) continue;
+    out.push({ keyPath: joinPath(segs), alias });
+  }
+  return out;
+}
+function valueKind(node) {
+  if (!node) return "none";
+  switch (node.type) {
+    case "string":
+      return "string";
+    case "integer":
+      return "integer";
+    case "float":
+      return "float";
+    case "boolean":
+      return "boolean";
+    case "array":
+      return "array";
+    case "inline_table":
+      return "inline-table";
+    case "offset_date_time":
+    case "local_date_time":
+    case "local_date":
+    case "local_time":
+      return "datetime";
+    default:
+      return node.type;
+  }
+}
+var RealTomlAnalyzer = class {
+  analyze(rootNode, content, filePath, context) {
+    const stem = path.basename(filePath, path.extname(filePath)) || "document";
+    const moduleName = applyDocumentScope(stem, documentDirScope(filePath, context?.projectRoot));
+    const projectRoot = typeof context?.projectRoot === "string" && context.projectRoot.length > 0 ? context.projectRoot : null;
+    const qualified = (name) => name === moduleName ? moduleName : `${moduleName}.${name}`;
+    const symbols = [];
+    const relationships = [];
+    const errors = [];
+    const patterns = [];
+    const usedNames = { [moduleName]: 1 };
+    const declaredTables = {};
+    const allocate = (want) => {
+      const seen = usedNames[want];
+      if (seen === void 0) {
+        usedNames[want] = 1;
+        return want;
+      }
+      let n = seen;
+      let name = want;
+      do {
+        n++;
+        name = `${want}#${n}`;
+      } while (usedNames[name] !== void 0);
+      usedNames[name] = 1;
+      usedNames[want] = n;
+      return name;
+    };
+    const range = (node) => ({
+      startLine: node.startPosition.row + 1,
+      startColumn: node.startPosition.column + 1,
+      endLine: node.endPosition.row + 1,
+      endColumn: node.endPosition.column + 1,
+      startIndex: node.startIndex,
+      endIndex: node.endIndex
+    });
+    if (rootNode.hasError) {
+      const errStack = [rootNode];
+      while (errStack.length > 0) {
+        const n = errStack.pop();
+        if (n.type === "ERROR" || n.isMissing) {
+          errors.push({
+            message: `Syntax ${n.type} detected. The Brain Engine is bypassing this broken node.`,
+            range: range(n),
+            severity: "warning"
+          });
+        }
+        for (let i = n.childCount - 1; i >= 0; i--) {
+          const child = n.child(i);
+          if (child) errStack.push(child);
+        }
+      }
+    }
+    symbols.push({
+      name: moduleName,
+      qualifiedName: moduleName,
+      kind: ASTEngine.SymbolKind.Module,
+      range: range(rootNode),
+      scope: "",
+      visibility: "public",
+      ownerName: void 0,
+      ownerKind: void 0,
+      metadata: {
+        tomlSpecific: true,
+        isDocumentRoot: true,
+        evidenceClass: "structural"
+      }
+    });
+    let tableCount = 0;
+    let keyCount = 0;
+    let arrayOfTablesCount = 0;
+    let inlineTableCount = 0;
+    let maxDepth = 0;
+    const sectionRecords = [];
+    let reOwnedSections = 0;
+    const resolveOwner = (segments) => {
+      const implied = [];
+      let owner = moduleName;
+      const acc = [];
+      for (let i = 0; i < segments.length - 1; i++) {
+        acc.push(segments[i]);
+        const prefix = joinPath(acc);
+        const declared = declaredTables[prefix];
+        if (declared !== void 0) owner = declared;
+        else implied.push(prefix);
+      }
+      return { owner, implied };
+    };
+    const declaredByFinalSegment = /* @__PURE__ */ new Map();
+    const ambiguousFinalSegments = /* @__PURE__ */ new Set();
+    const pendingAliases = [];
+    const DEPENDENCY_SECTIONS = /* @__PURE__ */ new Set([
+      "dependencies",
+      "dev-dependencies",
+      "build-dependencies",
+      "workspace.dependencies",
+      "sources",
+      "patch.crates-io"
+    ]);
+    const pendingImports = [];
+    const pendingWorkspace = [];
+    const pendingPublishSurface = [];
+    const isBooleanTrue = (pair) => {
+      const v = valueOf(pair);
+      return v !== null && v.type === "boolean" && String(v.text).trim() === "true";
+    };
+    const containsWorkspaceTrue = (pair) => {
+      const v = valueOf(pair);
+      if (!v || v.type !== "inline_table") return false;
+      for (const inner of v.namedChildren ?? []) {
+        if (inner.type !== "pair") continue;
+        const ik = keyOf(inner);
+        if (!ik) continue;
+        if (segmentsOf(ik)[0] !== "workspace") continue;
+        if (isBooleanTrue(inner)) return true;
+      }
+      return false;
+    };
+    const inheritedPathOf = (pathSegs, keySegs, tableForm) => {
+      const DEP = /* @__PURE__ */ new Set(["dependencies", "dev-dependencies", "build-dependencies"]);
+      const depIndex = pathSegs.findIndex((s) => DEP.has(s));
+      const last = keySegs[keySegs.length - 1];
+      if (last !== "workspace") return null;
+      if (depIndex >= 0) {
+        const name = tableForm ? pathSegs[pathSegs.length - 1] : keySegs.length >= 2 ? keySegs[keySegs.length - 2] : "";
+        return name.length > 0 ? `workspace.dependencies.${name}` : null;
+      }
+      if (pathSegs.length === 1 && pathSegs[0] === "package" && keySegs.length >= 2) {
+        return `workspace.package.${keySegs.slice(0, -1).join(".")}`;
+      }
+      if (pathSegs.length === 1 && pathSegs[0] === "lints") return "workspace.lints";
+      return null;
+    };
+    const stringMemberOf = (pair, leaf) => {
+      const value = valueOf(pair);
+      if (!value || value.type !== "inline_table") return null;
+      for (const inner of value.namedChildren ?? []) {
+        if (inner.type !== "pair") continue;
+        const ik = keyOf(inner);
+        if (!ik) continue;
+        const isegs = segmentsOf(ik);
+        if (isegs[isegs.length - 1] !== leaf) continue;
+        const v = stringValueOf(valueOf(inner));
+        if (v && v.length > 0) return v;
+      }
+      return null;
+    };
+    const pathDependencyOf = (pair) => stringMemberOf(pair, "path");
+    const emitKey = (pair, path2, owner) => {
+      const keyNode = keyOf(pair);
+      if (!keyNode) return;
+      const name = allocate(path2);
+      const value = valueOf(pair);
+      const inlineKeys = [];
+      if (value && value.type === "inline_table") {
+        inlineTableCount++;
+        for (const child of value.namedChildren ?? []) {
+          const ck = keyOf(child);
+          if (ck) inlineKeys.push(joinPath(segmentsOf(ck)));
+        }
+      }
+      const line = keyNode.startPosition.row + 1;
+      {
+        const ksegs = segmentsOf(keyNode);
+        const leaf = ksegs.length > 0 ? ksegs[ksegs.length - 1] : "";
+        if (PUBLISH_SURFACE_KEYS.has(leaf) && value !== null && value.type === "string") {
+          const sv = stringValueOf(value);
+          if (sv !== null && sv.length > 0) pendingPublishSurface.push({ siteName: name, sitePath: path2, value: sv, line });
+        }
+      }
+      symbols.push({
+        name,
+        qualifiedName: qualified(name),
+        kind: ASTEngine.SymbolKind.Property,
+        range: range(pair),
+        scope: "",
+        visibility: "public",
+        ownerName: owner,
+        ownerKind: owner === moduleName ? ASTEngine.SymbolKind.Module : ASTEngine.SymbolKind.Namespace,
+        metadata: {
+          tomlSpecific: true,
+          isDocumentRoot: owner === moduleName,
+          keyText: joinPath(segmentsOf(keyNode)),
+          valueType: valueKind(value),
+          ...inlineKeys.length > 0 ? { inlineKeys } : {},
+          evidenceClass: "structural"
+        }
+      });
+      relationships.push({
+        // BOTH ENDS CARRY THE FILE-SCOPED IDENTITY. A document-relative target names N
+        // declarations the moment a project holds two manifests with the same shape, and
+        // the resolver can only bind an exact qualified-name match — see the header note.
+        source: qualified(owner),
+        target: qualified(name),
+        type: ASTEngine.RelationshipType.Contains,
+        confidence: 1,
+        line_number: line,
+        metadata: {
+          tomlSpecific: true,
+          isKeyContainment: true,
+          evidenceClass: "structural"
+        }
+      });
+      keyCount++;
+      if (isScalarValueNode(value)) {
+        const segs = segmentsOf(keyNode);
+        if (segs.length > 0) {
+          const finalSeg = segs[segs.length - 1];
+          if (!declaredByFinalSegment.has(finalSeg)) {
+            declaredByFinalSegment.set(finalSeg, name);
+          } else {
+            ambiguousFinalSegments.add(finalSeg);
+          }
+        }
+      }
+      if (value && value.type === "inline_table") {
+        for (const { keyPath, alias } of inlineRefAliases(value)) {
+          pendingAliases.push({ source: name, keyPath, alias, line });
+        }
+      }
+    };
+    for (const node of rootNode.namedChildren ?? []) {
+      if (node.type === "table" || node.type === "table_array_element") {
+        const header = headerKeyOf(node);
+        if (!header) continue;
+        const segments = segmentsOf(header);
+        if (!namesSomething(segments)) continue;
+        const path2 = joinPath(segments);
+        const { owner, implied } = resolveOwner(segments);
+        const isArray = node.type === "table_array_element";
+        if (isArray) arrayOfTablesCount++;
+        const name = allocate(path2);
+        declaredTables[path2] = name;
+        tableCount++;
+        if (segments.length > maxDepth) maxDepth = segments.length;
+        const symbolIndex = symbols.length;
+        const relIndex = relationships.length;
+        symbols.push({
+          name,
+          qualifiedName: qualified(name),
+          kind: ASTEngine.SymbolKind.Namespace,
+          // The section's whole span, from its `[` to the line before the next
+          // header — which is exactly the region its keys live in, so a key's
+          // range is inside its table's and containment is checkable.
+          range: range(node),
+          scope: "",
+          visibility: "public",
+          ownerName: owner,
+          ownerKind: owner === moduleName ? ASTEngine.SymbolKind.Module : ASTEngine.SymbolKind.Namespace,
+          metadata: {
+            tomlSpecific: true,
+            isDocumentRoot: owner === moduleName,
+            isArrayOfTables: isArray,
+            headerText: header.text,
+            keyPath: path2,
+            ...implied.length > 0 ? { impliedParents: implied } : {},
+            evidenceClass: "structural"
+          }
+        });
+        relationships.push({
+          source: qualified(owner),
+          target: qualified(name),
+          type: ASTEngine.RelationshipType.Contains,
+          confidence: 1,
+          line_number: node.startPosition.row + 1,
+          metadata: {
+            tomlSpecific: true,
+            isTableHeader: true,
+            isArrayOfTables: isArray,
+            ...implied.length > 0 ? { hasImpliedParents: true } : {},
+            evidenceClass: "structural"
+          }
+        });
+        sectionRecords.push({ segments, owner, symbolIndex, relIndex });
+        for (const child of node.namedChildren ?? []) {
+          if (child.type !== "pair") continue;
+          const ck = keyOf(child);
+          if (!ck) continue;
+          const segs = segmentsOf(ck);
+          if (!namesSomething(segs)) continue;
+          emitKey(child, `${name}.${joinPath(segs)}`, name);
+          if (DEPENDENCY_SECTIONS.has(path2)) {
+            const depPath = pathDependencyOf(child);
+            if (depPath !== null) {
+              pendingImports.push({
+                source: `${name}.${joinPath(segs)}`,
+                pathValue: depPath,
+                section: path2,
+                line: ck.startPosition.row + 1,
+                base: stringMemberOf(child, "base")
+              });
+            }
+          }
+          {
+            const keyLeafIsWorkspace = segs[segs.length - 1] === "workspace" && isBooleanTrue(child);
+            const valueHoldsWorkspace = containsWorkspaceTrue(child);
+            if (keyLeafIsWorkspace || valueHoldsWorkspace) {
+              const tableForm = keyLeafIsWorkspace && segs.length === 1;
+              const keySegs = valueHoldsWorkspace ? [...segs, "workspace"] : segs;
+              const inherited = inheritedPathOf(segments, keySegs, tableForm);
+              if (inherited !== null) {
+                pendingWorkspace.push({
+                  source: `${name}.${joinPath(segs)}`,
+                  tableName: name,
+                  inherited,
+                  line: ck.startPosition.row + 1
+                });
+              }
+            }
+          }
+        }
+      } else if (node.type === "pair") {
+        const ck = keyOf(node);
+        if (!ck) continue;
+        const segs = segmentsOf(ck);
+        if (!namesSomething(segs)) continue;
+        emitKey(node, joinPath(segs), moduleName);
+        if (segs.length > maxDepth) maxDepth = segs.length;
+      }
+    }
+    for (const rec of sectionRecords) {
+      const { owner, implied } = resolveOwner(rec.segments);
+      if (owner === rec.owner) continue;
+      const symbol = symbols[rec.symbolIndex];
+      symbol.ownerName = owner;
+      symbol.ownerKind = owner === moduleName ? ASTEngine.SymbolKind.Module : ASTEngine.SymbolKind.Namespace;
+      const meta = symbol.metadata ?? (symbol.metadata = {});
+      meta.isDocumentRoot = owner === moduleName;
+      if (implied.length > 0) meta.impliedParents = implied;
+      else delete meta.impliedParents;
+      const rel = relationships[rec.relIndex];
+      rel.source = qualified(owner);
+      const relMeta = rel.metadata ?? (rel.metadata = {});
+      if (implied.length > 0) relMeta.hasImpliedParents = true;
+      else delete relMeta.hasImpliedParents;
+      reOwnedSections++;
+    }
+    let aliasEdges = 0;
+    let aliasUnresolved = 0;
+    let aliasAmbiguous = 0;
+    for (const { source, keyPath, alias, line } of pendingAliases) {
+      const target = declaredByFinalSegment.get(alias);
+      if (ambiguousFinalSegments.has(alias)) {
+        aliasAmbiguous++;
+        continue;
+      }
+      if (!target) {
+        aliasUnresolved++;
+        continue;
+      }
+      aliasEdges++;
+      relationships.push({
+        source: qualified(source),
+        target: qualified(target),
+        type: ASTEngine.RelationshipType.References,
+        confidence: 1,
+        line_number: line,
+        metadata: {
+          tomlSpecific: true,
+          isAliasReference: true,
+          // WHICH key inside the owning inline table made the reference. The edge
+          // is anchored at `source` because `source.keyPath` is NOT a node: the
+          // analyzer publishes the inline table's keys as `inlineKeys` metadata on
+          // the owning symbol and never as symbols of their own. Measured over the
+          // corpus, 167 of 167 emitted edges carried a source that bound to 0
+          // symbols in its own file, against 167 of 167 targets binding to exactly
+          // 1 — an edge reachable by no incoming query, since `traceCallers` JOINs
+          // `brain_symbol` on the source. The anchor was carrying the specificity
+          // the metadata now carries.
+          aliasKeyPath: keyPath,
+          resolvedBy: "final-segment",
+          evidenceClass: "structural"
+        }
+      });
+    }
+    if (aliasEdges > 0) patterns.push(`alias-refs x${aliasEdges}`);
+    if (aliasUnresolved > 0) patterns.push(`alias-unresolved x${aliasUnresolved}`);
+    if (aliasAmbiguous > 0) patterns.push(`alias-ambiguous x${aliasAmbiguous}`);
+    let importEdges = 0;
+    let workspaceRefs = 0;
+    let workspaceSkippedLints = 0;
+    let workspaceSkippedNoRoot = 0;
+    let workspaceSkippedNoDecl = 0;
+    if (pendingWorkspace.length > 0) {
+      const wsRoot = findWorkspaceRoot(filePath, projectRoot);
+      if (wsRoot === null) workspaceSkippedNoRoot = pendingWorkspace.length;
+      else {
+        let declared = null;
+        for (const site of pendingWorkspace) {
+          if (site.inherited === null || site.inherited === "workspace.lints") {
+            workspaceSkippedLints++;
+            continue;
+          }
+          if (declared === null) {
+            try {
+              declared = workspaceDeclaredPaths(readFileSync(wsRoot.abs, "utf8"));
+            } catch {
+              declared = /* @__PURE__ */ new Set();
+            }
+          }
+          if (!declared.has(site.inherited)) {
+            workspaceSkippedNoDecl++;
+            continue;
+          }
+          workspaceRefs++;
+          relationships.push({
+            source: qualified(site.source),
+            target: `${wsRoot.moduleName}.${site.inherited}`,
+            type: ASTEngine.RelationshipType.References,
+            confidence: 1,
+            line_number: site.line,
+            metadata: {
+              tomlSpecific: true,
+              isWorkspaceInheritance: true,
+              inheritedFrom: wsRoot.moduleName,
+              inheritedPath: site.inherited,
+              evidenceClass: "structural"
+            }
+          });
+        }
+      }
+    }
+    if (workspaceRefs > 0) patterns.push(`workspace-inheritance-refs x${workspaceRefs}`);
+    let publishSurfaceSites = 0;
+    let publishSurfaceExports = 0;
+    if (pendingPublishSurface.length > 0) {
+      const declared = /* @__PURE__ */ new Set();
+      for (const s of symbols) {
+        const n = String(s.name ?? "");
+        if (n.length > 0) declared.add(n);
+      }
+      const seenTargets = /* @__PURE__ */ new Set();
+      for (const site of pendingPublishSurface) {
+        publishSurfaceSites++;
+        if (site.value === moduleName || site.value === site.siteName) continue;
+        if (site.value === site.sitePath || site.sitePath.startsWith(`${site.value}.`) || site.value.startsWith(`${site.sitePath}.`)) continue;
+        if (!declared.has(site.value)) continue;
+        const target = qualified(site.value);
+        if (seenTargets.has(target)) continue;
+        seenTargets.add(target);
+        publishSurfaceExports++;
+        relationships.push({
+          source: moduleName,
+          target,
+          type: ASTEngine.RelationshipType.Exports,
+          confidence: 1,
+          line_number: site.line,
+          metadata: {
+            tomlSpecific: true,
+            isPublishSurfaceExport: true,
+            exportForm: "manifest_publish_surface",
+            evidenceClass: "structural"
+          }
+        });
+      }
+    }
+    if (publishSurfaceExports > 0) patterns.push(`publish-surface-exports x${publishSurfaceExports}`);
+    for (const { source, pathValue, section, line, base } of pendingImports) {
+      importEdges++;
+      const fileClaim = dependencyFileClaim(pathValue, filePath, projectRoot, base);
+      relationships.push({
+        source: qualified(source),
+        target: pathValue,
+        type: ASTEngine.RelationshipType.Imports,
+        confidence: 1,
+        line_number: line,
+        metadata: {
+          tomlSpecific: true,
+          isPathDependency: true,
+          dependencySection: section,
+          // Still declared, not resolved: the consuming tool turns this path into a
+          // module and nothing in the document does. The claim below is about the
+          // PATH, not about a symbol.
+          resolvedBy: null,
+          ...fileClaim !== null ? { importProjectFile: fileClaim } : {},
+          // THE SOURCE-PATH CLAIM (task-24). When no admitted file answers this path, the claim states
+          // the ONE thing that can be checked about it: the source string does not resolve inside this
+          // project's admitted population — verified against that list, and REFUTED the moment the project
+          // ships the file (measured before it was built: adding the file flips `verifyFileClaim`).
+          //
+          // ONLY PATH-SHAPED TARGETS. A bare name (`"dependency"`, `"SubProjectB"`) has no shape to check
+          // and is never claimed — that is the laundering vector yaml's shape rule exists to refuse, and
+          // 27 of this lane's unresolved targets are bare. They stay `unresolved`, which is the honest
+          // outcome for a target nothing can check.
+          ...fileClaim === null && isPathOrUriShaped(pathValue) ? { sourcePathClaim: [pathValue] } : {},
+          // THE TIER IS `import_based`, NOT `structural` — section D of the completeness
+          // inventory requires the lane to pin MORE THAN ONE evidence class, and the lane
+          // was writing `structural` on every edge it emitted, so it could not. This one
+          // was the wrong classification, not a missing pin: the fleet's tier vocabulary
+          // (`script/m14/audit-analyzer-grammar.ts:146`: structural · import_based ·
+          // usage_contextual · inferred) defines `import_based` as "the target is a FILE,
+          // taken from a path the document itself writes", and a `path` dependency in
+          // Cargo.toml is exactly that — `core = { path = "../core" }` names a directory
+          // the manifest writes, and `dependencyFileClaim` even checks it against the
+          // project's admitted files. `structural` means the fact needs nothing outside
+          // the file; this edge's whole point is that it points outside it.
+          evidenceClass: "import_based"
+        }
+      });
+    }
+    if (importEdges > 0) patterns.push(`path-deps x${importEdges}`);
+    if (arrayOfTablesCount > 0) patterns.push(`array-of-tables x${arrayOfTablesCount}`);
+    if (inlineTableCount > 0) patterns.push(`inline-tables x${inlineTableCount}`);
+    return {
+      language: "toml",
+      symbols,
+      relationships,
+      imports: [],
+      exports: [],
+      errors,
+      rawContent: content,
+      metadata: {
+        // Structural depth is the DEEPEST key path, not a node count: a flat
+        // document with 10,000 sibling keys is not deeper than one with three
+        // levels, and reporting the former as complexity would be meaningless.
+        complexity: maxDepth,
+        linesOfCode: content.split("\n").length,
+        cyclomaticComplexity: 1 + tableCount,
+        framework: "TOML",
+        patterns,
+        detectedFrameworks: [],
+        frameworkPatterns: [],
+        architecturalInsights: [],
+        architecturalScore: 0,
+        codeQuality: "unknown",
+        hasTypeInference: false,
+        hasFrameworkIntelligence: false,
+        analysisVersion: "m14-toml-identity-v1",
+        documentMetrics: {
+          tableCount,
+          keyCount,
+          arrayOfTablesCount,
+          inlineTableCount,
+          maxKeyPathDepth: maxDepth,
+          // How many sections the second pass moved. Zero on every file whose
+          // headers declare their ancestors first, which is the overwhelming
+          // majority; a non-zero value names the count of sections in this file
+          // whose `contains` source was corrected.
+          reOwnedSections,
+          // WORKSPACE-INHERITANCE ACCOUNTING — the four numbers behind TOML-G1, so a reader (and the
+          // lane's own instrument) can sum them over the population instead of inferring the residual
+          // from a difference. `refs` are the `references` edges this file emitted; the three skips are
+          // the sites it deliberately did not, each with its own reason: `lints` has no single target,
+          // `noDecl` means the root does not declare the inherited path (Cargo errors on those), and
+          // `noRoot` means no ancestor manifest declares `[workspace]` (or no project root was given).
+          workspaceInheritanceRefs: workspaceRefs,
+          workspaceInheritanceSkippedLints: workspaceSkippedLints,
+          workspaceInheritanceSkippedNoDecl: workspaceSkippedNoDecl,
+          workspaceInheritanceSkippedNoRoot: workspaceSkippedNoRoot,
+          // THE `exports` ACCOUNTING: candidates seen by the conventional leaves, and the ones the
+          // DATA test turned into edges. Over the whole admitted population this reads 174 and 0 —
+          // the number the ruling is about, measured at the emission site instead of counted by a
+          // predicate that cannot tell a path from a name.
+          publishSurfaceSites,
+          publishSurfaceExports
+        }
+      }
+    };
+  }
+};
+export {
+  RealTomlAnalyzer
+};