@backbencher/brain 0.0.0-stage → 0.1.1

package/dist/real-markdown-analyzer-TEJK2JXJ.js

@@ -0,0 +1,1215 @@
+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-markdown-analyzer.ts
+import { existsSync } from "fs";
+import * as path from "path";
+var MD_REPO_ROOT = /* @__PURE__ */ new Map();
+function markdownRepoRootOf(filePath) {
+  const abs = path.resolve(filePath);
+  const dir = path.dirname(abs);
+  const cached = MD_REPO_ROOT.get(dir);
+  if (cached !== void 0) return cached;
+  let probe = dir;
+  for (let i = 0; i < 64; i++) {
+    if (existsSync(path.join(probe, ".git"))) {
+      MD_REPO_ROOT.set(dir, probe);
+      return probe;
+    }
+    const parent = path.dirname(probe);
+    if (parent === probe) break;
+    probe = parent;
+  }
+  MD_REPO_ROOT.set(dir, "");
+  return "";
+}
+function markdownRepoRelativeOf(filePath) {
+  const root = markdownRepoRootOf(filePath);
+  if (root === "") return "";
+  const rel = path.relative(root, path.resolve(filePath));
+  if (rel.startsWith("..") || rel === "") return "";
+  return rel.split(path.sep).join("/");
+}
+function markdownResolveRelativeLink(dest, filePath) {
+  const root = markdownRepoRootOf(filePath);
+  if (root === "") return null;
+  const bare = dest.split("#")[0].split("?")[0];
+  if (bare.length === 0) return null;
+  const abs = path.resolve(path.dirname(path.resolve(filePath)), bare);
+  if (!existsSync(abs)) return null;
+  const rel = path.relative(root, abs);
+  if (rel.startsWith("..") || rel === "") return null;
+  return rel.split(path.sep).join("/");
+}
+var RealMarkdownAnalyzer = class {
+  /** The file being analyzed, for the file model: `walkInlineTree` has no path parameter and
+   *  a relative link's resolution needs one. Set once per `analyze` run. */
+  currentFilePath = "";
+  analyze(rootNode, content, filePath, context) {
+    this.currentFilePath = filePath;
+    const symbols = [];
+    const relationships = [];
+    const imports = [];
+    const errors = [];
+    const patterns = [];
+    const siteOccurrences = /* @__PURE__ */ new Map();
+    const relIds = /* @__PURE__ */ new Set();
+    const siteId = (qualifiedBase, name) => {
+      const n = (siteOccurrences.get(qualifiedBase) ?? 0) + 1;
+      siteOccurrences.set(qualifiedBase, n);
+      return {
+        id: n === 1 ? qualifiedBase : `${qualifiedBase}#${n}`,
+        target: n === 1 ? name : `${name}#${n}`,
+        repeat: n > 1
+      };
+    };
+    const anchorSlug = (text) => {
+      let out = "";
+      for (let i = 0; i < text.length; i++) {
+        const c = text.charCodeAt(i);
+        const ch = text[i];
+        if (c >= 65 && c <= 90 || c >= 97 && c <= 122 || c >= 48 && c <= 57) out += ch.toLowerCase();
+        else if (c === 32 || c === 9 || c === 45) out += "-";
+      }
+      return out;
+    };
+    const addRel = (source, type, target, metadata, line, distinctSites = false) => {
+      if (!source || !target) return;
+      if (source === target && !distinctSites) return;
+      const at = typeof line === "number" && line > 0 ? line : 0;
+      const id = `${source}\0${type}\0${target}\0${at}`;
+      if (relIds.has(id)) return;
+      relIds.add(id);
+      relationships.push({
+        source,
+        target,
+        type,
+        confidence: 1,
+        metadata,
+        ...at > 0 ? { line_number: at } : {}
+      });
+    };
+    const mdInlineTrees = context?.mdInlineTrees ?? [];
+    const mdInlineStarts = context?.mdInlineStarts ?? [];
+    const mdInlineLines = context?.mdInlineLines ?? [];
+    const inlineByStart = /* @__PURE__ */ new Map();
+    for (let i = 0; i < mdInlineStarts.length; i++) {
+      inlineByStart.set(mdInlineStarts[i], { tree: mdInlineTrees[i], line: mdInlineLines[i] });
+    }
+    const headingStack = [];
+    let currentOwner = void 0;
+    let currentOwnerId = void 0;
+    const DOC = "document";
+    let publishedHeadings = 0;
+    const anchorMap = /* @__PURE__ */ new Map();
+    const anchorOccurrences = /* @__PURE__ */ new Map();
+    const pendingAnchors = [];
+    const inlineStarts = new Set(mdInlineStarts);
+    const definitions = /* @__PURE__ */ new Map();
+    this.collectReferenceDefinitions(rootNode, definitions);
+    const stack = [rootNode];
+    while (stack.length > 0) {
+      const node = stack.pop();
+      const type = node.type;
+      if (type === "atx_heading" || type === "setext_heading") {
+        const level = this.headingLevel(node);
+        const name = this.headingText(node);
+        if (name) {
+          publishedHeadings++;
+          while (headingStack.length > 0 && headingStack[headingStack.length - 1].level >= level) {
+            headingStack.pop();
+          }
+          const owner = headingStack.length > 0 ? headingStack[headingStack.length - 1].name : void 0;
+          const ownerId = headingStack.length > 0 ? headingStack[headingStack.length - 1].id : void 0;
+          const base = ownerId ? `${ownerId}.${name}` : name;
+          const { id, target, repeat } = siteId(base, name);
+          const range = this.nodeToRange(node);
+          symbols.push({
+            // The site's RESOLVED spelling, which is the bare text for a first
+            // occurrence and `Text#n` for a repeat. It has to be this and not the
+            // bare text: the edge below already says `target`, the store resolves
+            // an endpoint by symbol NAME, and publishing the bare text while the
+            // edge says `Text#2` is a name nothing declares. Measured on this lane's
+            // own corpus, 120 scala3 markdown files: 529 of 1,843 relationships
+            // (28.7%) named a symbol that did not exist, every one of them a
+            // repeated site. A first occurrence is unchanged, which is why
+            // `heading-identity` and `code-block-site-identity` still read as they
+            // always did and this went unmeasured for a full review cycle.
+            name: target,
+            kind: ASTEngine.SymbolKind.Type,
+            id,
+            qualifiedName: id,
+            range,
+            visibility: "public",
+            ownerName: owner,
+            ownerKind: owner ? ASTEngine.SymbolKind.Type : void 0,
+            scope: owner,
+            metadata: {
+              nodeType: type,
+              headingLevel: level,
+              isMarkdownHeading: true,
+              // A repeated heading is a fact about the document (`## Example` in
+              // every section), not a duplicate to be swallowed.
+              isRepeatedSite: repeat || void 0
+            }
+          });
+          if (owner) addRel(owner, ASTEngine.RelationshipType.Contains, target, { role: "heading_hierarchy" }, range.startLine, ownerId !== id);
+          const slug = anchorSlug(name);
+          if (slug) {
+            const seen = (anchorOccurrences.get(slug) ?? 0) + 1;
+            anchorOccurrences.set(slug, seen);
+            const key = seen === 1 ? slug : `${slug}-${seen - 1}`;
+            if (!anchorMap.has(key)) anchorMap.set(key, { name: target, line: range.startLine });
+          }
+          headingStack.push({ name: target, id, level });
+          currentOwner = target;
+          currentOwnerId = id;
+        }
+        patterns.push("Markdown headings");
+        this.emitInlineUses(node, inlineByStart, addRel, currentOwner ?? DOC, definitions, pendingAnchors, imports);
+        continue;
+      }
+      if (type === "inline") {
+        const inline = inlineByStart.get(node.startIndex);
+        if (inline?.tree?.rootNode) {
+          const source = currentOwner ?? DOC;
+          this.walkInlineTree(inline.tree.rootNode, addRel, source, inline.line, definitions, pendingAnchors);
+          this.emitIncludeImports(String(inline.tree.rootNode.text ?? ""), addRel, source, inline.line, imports);
+        }
+        continue;
+      }
+      if (type === "pipe_table") {
+        const name = this.tableName(node, content);
+        const owner = currentOwner ?? DOC;
+        const ownerId = currentOwnerId ?? DOC;
+        const base = ownerId === DOC ? name : `${ownerId}.${name}`;
+        const { id, target, repeat } = siteId(base, name);
+        const range = this.nodeToRange(node);
+        symbols.push({
+          name: target,
+          kind: ASTEngine.SymbolKind.Class,
+          id,
+          qualifiedName: id,
+          range,
+          visibility: "public",
+          ownerName: owner === DOC ? void 0 : owner,
+          ownerKind: owner === DOC ? void 0 : ASTEngine.SymbolKind.Type,
+          scope: owner === DOC ? void 0 : owner,
+          metadata: {
+            nodeType: type,
+            isMarkdownTable: true,
+            isRepeatedSite: repeat || void 0
+          }
+        });
+        addRel(owner, ASTEngine.RelationshipType.Contains, target, { role: "table_under_heading" }, range.startLine);
+        const header = this.findChildByType(node, /* @__PURE__ */ new Set(["pipe_table_header"]));
+        if (header) {
+          for (let i = 0; i < header.namedChildCount; i++) {
+            const cell = header.namedChild(i);
+            if (cell?.type === "pipe_table_cell") {
+              const col = cell.text.trim();
+              if (!col) continue;
+              const cSite = siteId(`${id}.${col}`, col);
+              symbols.push({
+                name: cSite.target,
+                kind: ASTEngine.SymbolKind.Property,
+                id: cSite.id,
+                qualifiedName: cSite.id,
+                range: this.nodeToRange(cell),
+                visibility: "public",
+                ownerName: target,
+                ownerKind: ASTEngine.SymbolKind.Class,
+                scope: target,
+                metadata: {
+                  nodeType: "pipe_table_cell",
+                  isMarkdownTableColumn: true,
+                  isRepeatedSite: cSite.repeat || void 0
+                }
+              });
+              addRel(target, ASTEngine.RelationshipType.Contains, cSite.target, { role: "table_column" }, range.startLine, cSite.id !== id);
+            }
+          }
+        }
+        patterns.push("Markdown tables");
+        continue;
+      }
+      if (type === "fenced_code_block" || type === "indented_code_block") {
+        const infoNode = this.findChildByType(node, /* @__PURE__ */ new Set(["info_string"]));
+        const langNode = infoNode ? this.findChildByType(infoNode, /* @__PURE__ */ new Set(["language"])) : null;
+        const lang = langNode?.text?.trim() ?? infoNode?.text?.trim() ?? "text";
+        const owner = currentOwner ?? DOC;
+        const ownerId = currentOwnerId ?? DOC;
+        const name = lang === "text" ? "code_block" : `code_block.${lang}`;
+        const base = ownerId === DOC ? name : `${ownerId}.${name}`;
+        const { id, target, repeat } = siteId(base, name);
+        const range = this.nodeToRange(node);
+        const declaredLang = langNode?.text?.trim() ?? infoNode?.text?.trim();
+        symbols.push({
+          name: target,
+          kind: ASTEngine.SymbolKind.Function,
+          id,
+          qualifiedName: id,
+          range,
+          visibility: "public",
+          ownerName: owner === DOC ? void 0 : owner,
+          ownerKind: owner === DOC ? void 0 : ASTEngine.SymbolKind.Type,
+          scope: owner === DOC ? void 0 : owner,
+          metadata: {
+            nodeType: type,
+            ...declaredLang ? { language: declaredLang } : {},
+            isMarkdownCodeBlock: true,
+            isRepeatedSite: repeat || void 0
+          }
+        });
+        addRel(owner, ASTEngine.RelationshipType.Contains, target, { role: "code_block_under_heading" }, range.startLine);
+        patterns.push("Markdown code blocks");
+        this.emitIncludeFencePartOf(node, addRel, owner, range.startLine, patterns);
+        continue;
+      }
+      if (type === "minus_metadata") {
+        const name = "front_matter";
+        const owner = DOC;
+        const { id, target, repeat } = siteId(`${owner}.${name}`, name);
+        const range = this.nodeToRange(node);
+        symbols.push({
+          // Same rule as every other site: the published name is the RESOLVED
+          // spelling, so a document with two front-matter blocks publishes
+          // `front_matter` and `front_matter#2` and any edge naming the second
+          // resolves. A first occurrence — every document until the second block
+          // exists — is byte-identical to what it always was.
+          name: target,
+          kind: ASTEngine.SymbolKind.Namespace,
+          id,
+          qualifiedName: id,
+          range,
+          visibility: "public",
+          ownerName: owner,
+          ownerKind: void 0,
+          metadata: {
+            nodeType: type,
+            isMarkdownFrontMatter: true,
+            isRepeatedSite: repeat || void 0
+          }
+        });
+        patterns.push("Markdown front matter");
+        continue;
+      }
+      for (let i = node.namedChildCount - 1; i >= 0; i--) {
+        const child = node.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+    let anchorsResolved = 0;
+    let anchorsUndefined = 0;
+    for (const p of pendingAnchors) {
+      const frag = this.decodeFragment(p.fragment);
+      const hit = frag ? anchorMap.get(frag) : void 0;
+      if (!hit) {
+        anchorsUndefined++;
+        continue;
+      }
+      anchorsResolved++;
+      addRel(
+        p.source,
+        ASTEngine.RelationshipType.References,
+        hit.name,
+        {
+          role: "markdown_internal_anchor",
+          linkText: p.literal,
+          linkForm: "internal_anchor",
+          anchor: frag,
+          ...p.line ? { linkLine: p.line } : {}
+        },
+        hit.line
+      );
+    }
+    if (anchorsResolved > 0) patterns.push("Markdown internal anchor references");
+    if (anchorsUndefined > 0) patterns.push(`Markdown undefined internal anchors: ${anchorsUndefined}`);
+    this.classifyEvidenceTier(relationships);
+    const selfRepoRel = markdownRepoRelativeOf(filePath);
+    if (selfRepoRel.length > 0) {
+      const lineCount = content.split("\n").length;
+      symbols.push({
+        name: selfRepoRel,
+        kind: ASTEngine.SymbolKind.Module,
+        id: selfRepoRel,
+        qualifiedName: selfRepoRel,
+        range: { startLine: 1, startColumn: 0, endLine: lineCount, endColumn: 0 },
+        visibility: "public",
+        scope: "",
+        metadata: { nodeType: "document", isMarkdownDocument: true }
+      });
+    }
+    return {
+      language: "markdown",
+      symbols,
+      relationships,
+      imports,
+      exports: [],
+      errors,
+      metadata: {
+        complexity: symbols.length,
+        linesOfCode: content.split("\n").length,
+        patterns,
+        framework: "Markdown",
+        headingCount: publishedHeadings,
+        inlineBlockCount: mdInlineTrees.length
+      }
+    };
+  }
+  /**
+   * M14 #419-D: assign `metadata.evidenceClass` from the closed five-tier vocabulary,
+   * applied centrally so an emission site cannot skip it (the shape 22 sibling lanes
+   * use; typescript's `classifyEvidenceTier` is the reference).
+   *
+   * This lane's absence was not cosmetic. With no stored class, the read-time
+   * derivation in `graph-core.ts` decides instead, and its `STRUCTURAL_TYPES` set is
+   * `{calls, inherits, implements, overrides}` — it does NOT contain `contains`. So
+   * every heading-hierarchy, table and code-block edge, which is a direct AST
+   * parent/child relation and cannot be anything but structural, was rendered to
+   * users as `inferred`: "a guess (heuristic or confidence < 0.7) — treat as a hint,
+   * never as fact". The graph was telling the reader to distrust the one class of edge
+   * in this lane that is derived from the tree itself.
+   *
+   * The markdown mapping, and why each row is what it is:
+   *   contains -> structural       a parent/child relation read off the block tree.
+   *   uses     -> reference_qualified
+   *     A link destination is not a guess about a NAME: the destination is a node's
+   *     own text and, for a reference link, it is the destination the document's own
+   *     `link_reference_definition` declares. That is qualifier evidence — stronger
+   *     than `usage_contextual` ("the name appears in context"), weaker than structure
+   *     — which is exactly what the tier is for. Every published `uses` edge in this
+   *     lane resolves a destination the grammar read out of a node, so the
+   *     `resolved === false` arm that other lanes need is unreachable here and is
+   *     deliberately not invented.
+   *   references -> reference_qualified
+   *     The same tier as `uses`, for the same reason, and deliberately NOT
+   *     `structural`: the edge is not a parent/child relation read off the tree. A
+   *     `#fragment` names a heading, the analyzer recomputes that heading's anchor and
+   *     looks it up, and the edge exists because the lookup HIT. The lookup is the
+   *     qualification.
+   */
+  classifyEvidenceTier(relationships) {
+    for (const r of relationships) {
+      const md = r.metadata ?? (r.metadata = {});
+      if (md.evidenceClass) continue;
+      const t = String(r.type ?? "");
+      if (t === "contains") {
+        md.evidenceClass = "structural";
+        continue;
+      }
+      if (t === "uses") {
+        md.evidenceClass = "reference_qualified";
+        continue;
+      }
+      if (t === "references") {
+        md.evidenceClass = "reference_qualified";
+        continue;
+      }
+      if (t === "imports") {
+        md.evidenceClass = "import_based";
+        continue;
+      }
+      if (t === "part_of") {
+        md.evidenceClass = "import_based";
+        continue;
+      }
+      md.evidenceClass = "usage_contextual";
+    }
+  }
+  /**
+   * Collect `link_reference_definition` nodes into `label -> destination`.
+   *
+   * A reference link (`[text][ref]`, `[ref][]`, `[ref]`) carries only its LABEL; the
+   * destination lives in a definition elsewhere in the document, and CommonMark puts
+   * definitions at BLOCK level, so they are found here rather than in the inline tree.
+   * Before this, a document's reference links produced no `uses` edge at all —
+   * measured on this lane's pinned corpus (scala3@18df09c0, 738 tracked .md files) at
+   * 671 sites (44 uses + 627 definitions) across 66 files, while the lane doc claimed
+   * "Links (inline and reference destinations)".
+   *
+   * The walk descends named children but SKIPS `inline` subtrees: a definition cannot
+   * live inside one, and skipping keeps this pass off the inline grammar's node count,
+   * which is the expensive half of a markdown file. First definition of a label wins,
+   * which is CommonMark's own rule.
+   */
+  collectReferenceDefinitions(root, into) {
+    const s = [root];
+    while (s.length > 0) {
+      const n = s.pop();
+      if (n.type === "inline") continue;
+      if (n.type === "link_reference_definition") {
+        const labelNode = this.findChildByType(n, /* @__PURE__ */ new Set(["link_label"]));
+        const destNode = this.findChildByType(n, /* @__PURE__ */ new Set(["link_destination"]));
+        if (labelNode && destNode) {
+          const label = this.stripBrackets(labelNode.text);
+          const destination = this.stripAngleBrackets(destNode.text.trim()).trim();
+          if (label && destination && !into.has(label)) {
+            into.set(label, { destination, line: labelNode.startPosition.row + 1 });
+          }
+        }
+        continue;
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) s.push(c);
+      }
+    }
+  }
+  /**
+   * A heading's OWN `inline` node, which the two heading forms do not hold the same way.
+   *
+   * MD-DEFECT-1 (2026-10-03, the M60 pass-2 review). The ATX form puts the heading text in
+   * a DIRECT `inline` child:
+   *
+   *     atx_heading > atx_h1_marker, inline
+   *
+   * and the SETEXT form does not — the text lives one level down, inside the paragraph the
+   * underline terminates:
+   *
+   *     setext_heading > paragraph > inline , setext_h1_underline
+   *
+   * Both shapes are measured on the pinned wasm, not read off a spec. `emitInlineUses`
+   * resolved the heading's inline with `findChildByType`, which walks DIRECT named
+   * children only, so it returned null for every setext heading and the method returned
+   * before emitting anything: **every link, image, autolink and reference link inside a
+   * setext heading was silently dropped.** The `if (!inline) return` read as a guard
+   * against a heading with no text, and it was in fact a guard that matched half the
+   * heading forms.
+   *
+   * The population is small and it is stated rather than inflated: 76 setext headings in a
+   * 1,200-file corpus draw, of which 17 files carry one, and a whole-corpus scan of every
+   * line whose FOLLOWING line is a setext underline and which itself contains a link found
+   * **3** — `docker/vendor/github.com/hashicorp/go-immutable-radix/README.md:1`,
+   * `docker/vendor/github.com/hashicorp/go-immutable-radix/v2/README.md:1`, and
+   * `packer/README.md:4`. All three are H1 badge banners. Three instances is small; the
+   * asymmetry inside ONE construct is the defect, and the same argument closed MD-G1 for
+   * indented code blocks at a population the lane's own first estimate understated by 100x.
+   * It is also a dead branch in the sense the workstream names — reachable, and always
+   * taking the early return for one of the two heading forms.
+   *
+   * The engine already supplies the tree. `extractMarkdownInlineBlocks` walks the WHOLE
+   * block tree and collects every `inline` node, so the setext paragraph's inline is in
+   * `context.mdInlineStarts` under its own byte offset; nothing but this lookup was
+   * missing, and no shared file changes.
+   *
+   * Depth is bounded to one `paragraph` hop on purpose. A heading's text is the inline
+   * inside that paragraph, and reaching further would start picking up inline blocks that
+   * are body content rather than heading text.
+   */
+  headingInline(node) {
+    const direct = this.findChildByType(node, /* @__PURE__ */ new Set(["inline"]));
+    if (direct) return direct;
+    const paragraph = this.findChildByType(node, /* @__PURE__ */ new Set(["paragraph"]));
+    if (!paragraph) return null;
+    return this.findChildByType(paragraph, /* @__PURE__ */ new Set(["inline"]));
+  }
+  /**
+   * Walk a heading node's own inline child and emit `uses` edges for every
+   * link/image/autolink in the companion inline tree matched by byte offset.
+   *
+   * `headingInline` rather than a direct-child lookup, for the reason its own comment
+   * gives: an ATX heading holds its `inline` directly and a setext heading holds it inside
+   * a `paragraph`, and reading only the direct form dropped every link in every setext
+   * heading in the corpus.
+   */
+  emitInlineUses(node, inlineByStart, addRel, source, definitions, pendingAnchors, imports) {
+    const inline = this.headingInline(node);
+    if (!inline) return;
+    const entry = inlineByStart.get(inline.startIndex);
+    if (entry?.tree?.rootNode) {
+      this.walkInlineTree(entry.tree.rootNode, addRel, source, entry.line, definitions, pendingAnchors);
+      this.emitIncludeImports(String(entry.tree.rootNode.text ?? ""), addRel, source, entry.line, imports);
+    }
+  }
+  /**
+   * A template include directive, and the `imports` edge it carries (MD-G3).
+   *
+   * ## Why this is a text rule in a lane whose measured property is zero regexes
+   *
+   * Zero regex literals is a property this lane publishes and a probe measures
+   * (`validation/m12/results/regex-census.json`, markdown 4 → 0). Keeping it is not
+   * stubbornness: it is what makes "every fact this analyzer publishes is AST-derived"
+   * a checkable claim rather than a habit. This method is the one place where the fact
+   * cannot be AST-derived, and it is a character-code scan of ONE node's own text for a
+   * construct the grammar does not model — which is a different thing from scanning a
+   * file for a pattern. `stripAngleBrackets`, `stripAtxClosingSequence`, `anchorSlug` and
+   * `decodeFragment` are all the same technique, and they are why the property survived
+   * this round.
+   *
+   * ## What it reads, and what it refuses to read
+   *
+   * `{%` … `%}`, whose first word is `include` (optionally `include-markdown` or
+   * `include_relative`), whose argument is either a quoted string or a bare token, and
+   * whose argument **ends in a known file extension**.
+   *
+   * That last clause is the whole discipline. The corpus carries 1,030+ `{% include %}`
+   * directives and most are Jinja/pymdownx MACRO calls naming no file —
+   * `{% include type t="Number" %}` (317 occurrences), `{% include tag ver="5.0" %}`
+   * (60+), `{% include example spec=… %}` (94). Publishing `imports -> Number` or
+   * `imports -> 5.0` would be exactly the fabrication the workstream forbids, and it
+   * would be invisible to the differential only because the oracle would have to repeat
+   * the same mistake. The extension test is the discriminator, and it is measured: 68
+   * directives on the pinned corpus name a file, and those 68 are the population.
+   *
+   * ## Confidence and evidence class
+   *
+   * `1.0` and `import_based`. Nothing here is inferred: the path is the author's own
+   * text, read verbatim, and the edge says this document pulls that path in. The
+   * confidence is NOT a claim that the file exists — a per-file analyzer cannot know,
+   * and 0 of the 68 were checked for existence by this lane. It is a claim about how the
+   * edge was derived, which is what the number means everywhere else in this lane.
+   */
+  emitIncludeImports(text, addRel, source, baseLine, imports) {
+    const n = text.length;
+    let row = 0;
+    let scannedTo = 0;
+    for (let i = 0; i + 1 < n; i++) {
+      if (text.charCodeAt(i) !== 123 || text.charCodeAt(i + 1) !== 37) continue;
+      let p = i + 2;
+      if (p < n && text.charCodeAt(p) === 45) p++;
+      while (p < n && this.isSpaceCode(text.charCodeAt(p))) p++;
+      const wordAt = p;
+      if (!this.consumeWord(text, p, "include")) continue;
+      p += 7;
+      while (p < n) {
+        const c = text.charCodeAt(p);
+        const wordChar = c >= 65 && c <= 90 || c >= 97 && c <= 122 || c >= 48 && c <= 57 || c === 45 || c === 95;
+        if (!wordChar) break;
+        p++;
+      }
+      const wordEnd = p;
+      while (p < n && this.isSpaceCode(text.charCodeAt(p))) p++;
+      const arg = this.readIncludeArgument(text, p, wordAt, wordEnd);
+      if (!arg.path || !this.namesAFile(arg.path)) continue;
+      for (let k = scannedTo; k < i; k++) if (text.charCodeAt(k) === 10) row++;
+      scannedTo = i;
+      const line = typeof baseLine === "number" && baseLine > 0 ? baseLine + row : void 0;
+      const offset = baseLine > 0 ? row : 0;
+      imports.push({
+        path: arg.path,
+        importType: "template-include",
+        localName: arg.path,
+        range: {
+          startLine: line ?? 0,
+          startColumn: 0,
+          endLine: (line ?? 0) + arg.lines - 1,
+          endColumn: 0,
+          startIndex: 0,
+          endIndex: 0
+        },
+        metadata: { directive: arg.directive, quoted: arg.quoted, inlineBlockLine: offset }
+      });
+      addRel(
+        source,
+        ASTEngine.RelationshipType.Imports,
+        arg.path,
+        { role: "markdown_template_include", directive: arg.directive, ...arg.quoted ? { quoted: true } : {} },
+        line
+      );
+      i = i + 2;
+      continue;
+    }
+  }
+  isSpaceCode(c) {
+    return c === 32 || c === 9 || c === 10 || c === 13;
+  }
+  /**
+   * `word` at `at`, by character code.
+   *
+   * The boundary rule is asymmetric on purpose and the first version got it wrong in the
+   * direction that loses real edges: it treated `-` and `_` as word characters, so
+   * `include-markdown` and `include_relative` — 53 of the corpus's 68 file-naming
+   * directives between them — did not match, and only the bare `{% include x.md %}` form
+   * published. A letter or a digit after the word still ends the match, so `{% includes
+   * x.md %}` is not a directive; that is the case the fixture's near-miss section pins.
+   */
+  consumeWord(text, at, word) {
+    for (let k = 0; k < word.length; k++) if (text.charCodeAt(at + k) !== word.charCodeAt(k)) return false;
+    const after = text.charCodeAt(at + word.length);
+    if (after >= 65 && after <= 90 || after >= 97 && after <= 122 || after >= 48 && after <= 57) return false;
+    return true;
+  }
+  /**
+   * The directive's argument: a quoted string if there is one, else the bare token up to
+   * whitespace or `%}`. Returns `lines` so the emitted range can cover a multi-line
+   * directive, which `{% include` with a long argument list does produce.
+   */
+  readIncludeArgument(text, at, wordAt, wordEnd) {
+    const n = text.length;
+    const directive = wordEnd > wordAt ? text.slice(wordAt, wordEnd) : "include";
+    let p = at;
+    let quoted = false;
+    if (p < n && (text.charCodeAt(p) === 34 || text.charCodeAt(p) === 39)) {
+      const q = text.charCodeAt(p);
+      quoted = true;
+      p++;
+      let out2 = "";
+      while (p < n && text.charCodeAt(p) !== q) {
+        out2 += text[p];
+        p++;
+      }
+      return { path: out2.trim() || void 0, directive, quoted, lines: 1 };
+    }
+    let out = "";
+    while (p < n && !this.isSpaceCode(text.charCodeAt(p)) && text.charCodeAt(p) !== 37) {
+      out += text[p];
+      p++;
+    }
+    let lines = 1;
+    for (let k = at; k < p && k < n; k++) if (text.charCodeAt(k) === 10) lines++;
+    return { path: out || void 0, directive, quoted: false, lines };
+  }
+  /**
+   * Does this argument name a FILE rather than a macro keyword?
+   *
+   * The extension list is by character code and closed, and every entry is an extension
+   * that appears in the corpus's own include directives. It is a ROLE test rather than a
+   * shape test: the role is "a path to another file this build will read", and the
+   * discriminator the corpus supports is the extension, because that is the only part of
+   * the argument that differs between `properties.md` and `t="Number"`.
+   */
+  namesAFile(path2) {
+    const dot = path2.lastIndexOf(".");
+    if (dot <= 0 || dot === path2.length - 1) return false;
+    const ext = path2.slice(dot + 1).toLowerCase();
+    const known = ["md", "markdown", "html", "htm", "txt", "yml", "yaml", "json", "toml", "svg", "png", "jpg", "jpeg", "gif", "csv", "ini", "conf", "pdf"];
+    for (const k of known) if (ext === k) return true;
+    return false;
+  }
+  /**
+   * Walk a parsed inline tree and emit `uses` edges for links, images, autolinks and
+   * reference links.
+   *
+   * Two structural facts about the companion inline grammar make this correct rather
+   * than merely working, and both were measured against the pinned wasm rather than
+   * read off a spec:
+   *
+   * 1. A link inside a `code_span` is UNREACHABLE here, structurally. The grammar
+   *    gives `code_span` only ANONYMOUS children (`[`, `]`, `(`, `:`, `/`, `.`,
+   *    `code_span_delimiter`) — no `link_destination` — and this walk descends NAMED
+   *    children only. A `[nope](https://bad.example)` inside backticks therefore
+   *    cannot be emitted, which is correct, and it is correct for a reason a reader
+   *    can check rather than for the absence of a filter.
+   *
+   * 2. A link inside `strong_emphasis`/`emphasis` IS reachable, because those are
+   *    named nodes with named children. That is also correct: `**a [x](u)**` is a link.
+   *
+   * `baseLine` is the 1-based FILE line of this inline block. A node row inside this
+   * sub-tree is relative to the SUBSTRING the engine parsed, so `baseLine + row` is
+   * the file line, and it is the only correct conversion available — which is why the
+   * engine hands `mdInlineLines` over at all.
+   */
+  walkInlineTree(root, addRel, source, baseLine, definitions, pendingAnchors) {
+    const fileLine = (node) => {
+      if (typeof baseLine !== "number" || baseLine <= 0) return void 0;
+      return baseLine + (typeof node.startPosition?.row === "number" ? node.startPosition.row : 0);
+    };
+    const s = [root];
+    while (s.length > 0) {
+      const inn = s.pop();
+      switch (inn.type) {
+        case "link_destination": {
+          const target = this.stripAngleBrackets(inn.text.trim()).trim();
+          if (target) {
+            if (pendingAnchors && target.charCodeAt(0) === 35) {
+              pendingAnchors.push({ source, fragment: target.slice(1), literal: target, line: fileLine(inn) });
+            } else {
+              addRel(
+                source,
+                ASTEngine.RelationshipType.Uses,
+                // THE FILE MODEL'S TARGET. A relative destination is resolved against the
+                // containing document — CommonMark's own rule — and when it names a file on
+                // disk the edge targets that file's published document symbol instead of a
+                // string that names nothing. The destination AS WRITTEN stays on the edge as
+                // `linkDestination`, which is the half the lane's earlier ruling was protecting;
+                // nothing is fabricated and nothing is lost. A destination that resolves to no
+                // file, or to one outside the repository, is left exactly as written.
+                this.linkKindOf(target).targetKind === "repoRelativePath" ? markdownResolveRelativeLink(target, this.currentFilePath) ?? target : target,
+                { role: "markdown_link", linkText: target, linkDestination: target, ...this.linkKindOf(target) },
+                fileLine(inn)
+              );
+            }
+          }
+          break;
+        }
+        case "uri_autolink":
+        case "email_autolink": {
+          const target = this.stripAngleBrackets(inn.text);
+          if (target) {
+            const kind = this.linkTargetMetadata(target);
+            addRel(
+              source,
+              ASTEngine.RelationshipType.Uses,
+              target,
+              { role: "markdown_autolink", isExternal: true, targetKind: this.uriSchemeOf(target) === null ? "emailAutolink" : kind.targetKind, ...kind.externalScheme !== void 0 ? { externalScheme: kind.externalScheme } : {} },
+              fileLine(inn)
+            );
+          }
+          break;
+        }
+        case "full_reference_link":
+        case "collapsed_reference_link":
+        case "shortcut_link": {
+          this.emitReferenceLink(inn, addRel, source, definitions, fileLine(inn), void 0, pendingAnchors);
+          break;
+        }
+        case "image": {
+          const labelNode = this.findChildByTypeAny(inn, /* @__PURE__ */ new Set(["link_label"]));
+          if (labelNode) {
+            this.emitReferenceLink(inn, addRel, source, definitions, fileLine(inn), this.stripBrackets(labelNode.text), pendingAnchors);
+          }
+          break;
+        }
+      }
+      for (let i = inn.namedChildCount - 1; i >= 0; i--) {
+        const c = inn.namedChild(i);
+        if (c) s.push(c);
+      }
+    }
+  }
+  /**
+   * A reference link's edge points at the DESTINATION the document declares.
+   *
+   * A reference link with NO matching `link_reference_definition` is NOT published,
+   * and that is the specification rather than a noise heuristic. CommonMark: "If a
+   * link reference definition has not been defined for the link label, then it is not
+   * a link" — the construct renders as literal text. So `[1]` in a legal notice, or
+   * `[missing closing paren](url` with the paren never closed, is not a link and
+   * emitting an edge to a target named `1` would be a fabricated endpoint.
+   *
+   * Measured, not assumed: publishing the undefined case produced 171 edges across 34
+   * of the lane's 738 corpus files, and sampling them showed them dominated by bare
+   * bracketed citation markers — `NOTICE.md: document -> 1` six times over. Those are
+   * also an R10 target-spelling problem: `1` is not a name this lane spells its
+   * symbols with. Suppressing the undefined case removed 171 fabricated endpoints and
+   * left the 213 genuinely-resolved reference links, which are the whole point.
+   *
+   * The consequence worth stating: an undefined reference is invisible rather than
+   * flagged. That is a real limitation and it is a DECISION, taken because the
+   * alternative measures as fabrication.
+   */
+  emitReferenceLink(node, addRel, source, definitions, line, knownLabel, pendingAnchors) {
+    const label = knownLabel ?? this.referenceLabelOf(node);
+    if (!label) return;
+    const defined = definitions.get(label);
+    if (!defined) return;
+    const destination = defined.destination;
+    if (pendingAnchors && destination.charCodeAt(0) === 35) {
+      pendingAnchors.push({ source, fragment: destination.slice(1), literal: destination, line });
+      return;
+    }
+    const target = this.linkKindOf(destination).targetKind === "repoRelativePath" ? markdownResolveRelativeLink(destination, this.currentFilePath) ?? destination : destination;
+    addRel(
+      source,
+      ASTEngine.RelationshipType.Uses,
+      target,
+      {
+        role: "markdown_link",
+        linkText: label,
+        linkForm: node.type,
+        resolvedVia: "link_reference_definition",
+        linkDestination: destination,
+        // The destination, not the label. A reference link resolves its LABEL
+        // through the definition and its DESTINATION is what the edge points at, so
+        // classifying the label would answer a question nobody asked — `[home]` is
+        // not a path and `http://example.com` is not a heading.
+        ...this.linkTargetMetadata(destination)
+      },
+      line
+    );
+  }
+  /** The reference label of a reference link: its `link_label`, else its link text. */
+  referenceLabelOf(node) {
+    const labelNode = this.findChildByTypeAny(node, /* @__PURE__ */ new Set(["link_label"]));
+    if (labelNode) {
+      const t = this.stripBrackets(labelNode.text);
+      if (t) return t;
+    }
+    const textNode = this.findChildByTypeAny(node, /* @__PURE__ */ new Set(["link_text"]));
+    if (textNode) {
+      const t = textNode.text.trim();
+      if (t) return t;
+    }
+    return void 0;
+  }
+  /** Strip surrounding square brackets by position, no regex. */
+  stripBrackets(text) {
+    const t = text.trim();
+    if (t.length >= 2 && t.charCodeAt(0) === 91 && t.charCodeAt(t.length - 1) === 93) {
+      return t.slice(1, -1).trim();
+    }
+    return t;
+  }
+  /** `findChildByType` over a sub-parse node, which is typed `any` not `Node`. */
+  findChildByTypeAny(node, types) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child && types.has(child.type)) return child;
+    }
+    return null;
+  }
+  /** Strip surrounding angle brackets by position, no regex. */
+  stripAngleBrackets(text) {
+    const t = text.trim();
+    if (t.length >= 2 && t.charCodeAt(0) === 60 && t.charCodeAt(t.length - 1) === 62) {
+      return t.slice(1, -1);
+    }
+    return t;
+  }
+  /**
+   * A link destination's RFC 3986 scheme, or `null` when it has none.
+   *
+   * By the RFC's own rule rather than by pattern: `ALPHA *( ALPHA / DIGIT / "+" /
+   * "-" / "." ) ":"`, with `/`, `?` or `#` ending the scan because none of them may
+   * appear in a scheme. `https://x` has one; `docs/a.md` does not — the segment
+   * before its colon contains a `/`.
+   *
+   * TWO constraints, both measured rather than assumed:
+   *
+   *  - **Two characters minimum.** RFC 3986 admits `X:`, so a Windows drive path
+   *    `X:/src` classified as a URI scheme. It is a path in this repository, and
+   *    calling it external would be a false statement about where the target lives.
+   *  - **One balanced PARENTHESIS pair stripped first.** `[x]((https://…))` is
+   *    legal CommonMark and its destination really is `(https://…)` — the inner
+   *    pair is balanced, so the parentheses are part of the destination rather than
+   *    delimiters — so the scan has to see through them to find the scheme.
+   *
+   * An ANGLE pair is NOT stripped here, and that is deliberate: the `<...>`
+   * destination form is unwrapped at its source instead (`walkInlineTree`'s
+   * `link_destination` case and `collectReferenceDefinitions`), because CommonMark
+   * says those brackets are not part of the destination at all. Stripping them a
+   * second time here would be a branch that never fires, and a rule the
+   * implementation cannot reach is not a rule.
+   */
+  uriSchemeOf(dest) {
+    let body = dest.trim();
+    for (let guard = 0; guard < 2; guard++) {
+      if (body.length < 2) break;
+      if (body.charCodeAt(0) !== 40 || body.charCodeAt(body.length - 1) !== 41) break;
+      body = body.slice(1, -1).trim();
+    }
+    if (body.length >= 2 && body.charCodeAt(0) === 47 && body.charCodeAt(1) === 47) return "network-path";
+    let colon = -1;
+    for (let i = 0; i < body.length; i++) {
+      const c = body.charCodeAt(i);
+      if (c === 58) {
+        colon = i;
+        break;
+      }
+      if (c === 47 || c === 63 || c === 35) return null;
+    }
+    if (colon < 2) return null;
+    const first = body.charCodeAt(0);
+    const alpha = first >= 65 && first <= 90 || first >= 97 && first <= 122;
+    if (!alpha) return null;
+    for (let k = 1; k < colon; k++) {
+      const d = body.charCodeAt(k);
+      const ok = d >= 65 && d <= 90 || d >= 97 && d <= 122 || d >= 48 && d <= 57 || d === 43 || d === 45 || d === 46;
+      if (!ok) return null;
+    }
+    return body.slice(0, colon);
+  }
+  /**
+   * What KIND of place a link destination names, as metadata on the `uses` edge.
+   *
+   * Why this exists, measured on the 600-file prefix of this lane's 17,456-file
+   * admitted population (production `parseFile`, `validation/m60/markdown/
+   * abc-before-600.json`): 4,107 of the 4,951 edge targets that bind to no local
+   * declaration carry a URI scheme — 3,996 `https`, 110 `http`, 1 `some` — and a
+   * consumer reading a resolution rate cannot tell them apart from a reference to a
+   * heading that failed to bind. The column therefore overstated this lane's
+   * defects by 82.9% before the split existed.
+   *
+   * The three-way split is the substance, not a detail:
+   *
+   *  - `externalUri` — a remote resource. Outside the corpus by construction, so
+   *    it can never bind to a local declaration and must not be scored as a miss.
+   *  - `repoRelativePath` — 572 targets, a link to a sibling file in the SAME
+   *    repository (`CHANGELOG.md`, `docs/src/contributing.md`). Marking these
+   *    external would be a false statement: the file is in the corpus, the analyzer
+   *    simply has no document-target model. They are named so they are countable as
+   *    what they are — a modelling gap, not an external reference.
+   *  - `bareToken` — 272 targets, dominated by Documenter.jl's `@ref`
+   *    cross-reference placeholder (262 of them). A template directive, not a path.
+   *
+   * What this deliberately does NOT do, because each would be a fabrication or a
+   * contract break:
+   *
+   *  - It does not change the TARGET STRING. The endpoint is the link destination
+   *    as written; a consumer that wants a file target needs a file model, not a
+   *    renamed endpoint.
+   *  - It does not change the TYPE LABEL. `uses` over a URL is the lane's pinned
+   *    contract (`markdown-mutants.ts` mutant MD-L1 relabels these in place, and
+   *    `internal-anchor-links` forbids `uses` over an in-document anchor), so the
+   *    label is untouched and only metadata is added.
+   *  - It does not SUPPRESS the edge. A markdown link to a website is a real use of
+   *    that resource and belongs in the graph; dropping 4,107 edges to make a
+   *    column look better is the opposite of the point.
+   *
+   * Character scanning throughout, no regex, for the reason `anchorSlug` documents:
+   * 0 regex literals is a pinned property of this analyzer and
+   * `script/m12/verify-regex-census.ts` is the gate that decides it.
+   */
+  /** `linkTargetMetadata` for an edge site that needs the classification before the metadata
+   *  literal is built. One call, one rule: this delegates rather than duplicating it. */
+  linkKindOf(dest) {
+    return this.linkTargetMetadata(dest);
+  }
+  linkTargetMetadata(dest) {
+    const scheme = this.uriSchemeOf(dest);
+    if (scheme !== null) return { isExternal: true, externalScheme: scheme, targetKind: "externalUri" };
+    const body = dest.trim();
+    if (body.indexOf("/") >= 0 || body.indexOf(".") >= 0) return { isExternal: false, targetKind: "repoRelativePath" };
+    return { isExternal: false, targetKind: "bareToken" };
+  }
+  /**
+   * A link fragment, percent-decoded and lowercased, for comparison against a heading
+   * anchor. No regex, and no `decodeURIComponent` either: that throws on a malformed
+   * escape (`#100%`), and a document with a typo in a link would then fail to parse
+   * rather than fail to resolve. The decode is skipped for any escape that is not a
+   * valid pair of hex digits and the raw text is used instead — a fragment that
+   * cannot be decoded cannot match a slug that contains only letters, digits and
+   * hyphens anyway, so the fallback loses nothing that could have resolved.
+   */
+  decodeFragment(frag) {
+    let out = "";
+    for (let i = 0; i < frag.length; i++) {
+      const c = frag.charCodeAt(i);
+      if (c === 37 && i + 2 < frag.length) {
+        const hi = this.hexVal(frag.charCodeAt(i + 1));
+        const lo = this.hexVal(frag.charCodeAt(i + 2));
+        if (hi >= 0 && lo >= 0) {
+          out += String.fromCharCode(hi * 16 + lo);
+          i += 2;
+          continue;
+        }
+      }
+      out += frag[i];
+    }
+    return out.toLowerCase();
+  }
+  /** -1 for anything that is not a hex digit. */
+  hexVal(c) {
+    if (c >= 48 && c <= 57) return c - 48;
+    if (c >= 97 && c <= 102) return c - 87;
+    if (c >= 65 && c <= 70) return c - 55;
+    return -1;
+  }
+  /**
+   * `part_of` from a brace-directive inclusion fence (MD-G5) — the emission half.
+   *
+   * The whole argument is at the call site; this method is the mechanism. It is
+   * called from the fenced-code-block arm for EVERY fence, so the first thing it
+   * does is decline everything that is not a splice inclusion, by a rule a reader
+   * can check against the measured census
+   * (validation/m14/fixtures/markdown/measurements/extended-construct-census.json):
+   *
+   *   1. the info string must exist and begin `{` — else this is an ordinary fence
+   *      with a language or no info at all (the census counted 72,786 fences and
+   *      317 brace rows, so 99.6% of fences decline here);
+   *   2. the directive inside the braces must be `include` or `literalinclude` —
+   *      else this is an admonition/nav/etc. brace directive (`{note}` 93 sites,
+   *      `{contents}` 84, `{eval-rst}` 79, `{code-block}` 20, ... — all counted,
+   *      all declined);
+   *   3. the argument must be a non-empty path — `{include}` bare names nothing;
+   *   4. the fence must carry no FRAGMENT option (`:lines:`, `:start-after:`,
+   *      `:end-before:`, ...) — a fragment-quoted include is a QUOTE of part of a
+   *      file, not a splice of the file into this document's scope, and the census
+   *      counts that split (1 splice / 1 fragment-quoted over the whole population).
+   *
+   * THE TARGET IS SYMBOL-SHAPED. A path target resolves 0 rows — the cpp lane
+   * measured 0 of 4,612 — because the arbiter resolves target strings against
+   * symbol names. The edge therefore targets the included file's MODULE STEM (the
+   * basename without its extension, which is the name a document symbol of that
+   * file would publish), and the path as written is kept on the row as
+   * `metadata.partPath`.
+   *
+   * `metadata.partRole: "library"` is MANDATORY on every `part_of` row the
+   * vocabulary's own contract defines (src/ast/types.ts): this file is the
+   * including document — the library — and the directive names the part.
+   */
+  emitIncludeFencePartOf(node, addRel, source, line, patterns) {
+    const infoNode = this.findChildByType(node, /* @__PURE__ */ new Set(["info_string"]));
+    if (!infoNode) return;
+    const info = infoNode.text.trim();
+    if (info.charCodeAt(0) !== 123) return;
+    const closeBrace = info.indexOf("}");
+    if (closeBrace < 2) return;
+    const directive = info.slice(1, closeBrace).trim();
+    if (directive !== "include" && directive !== "literalinclude") return;
+    const argument = info.slice(closeBrace + 1).trim();
+    if (!argument || !this.namesAFile(argument)) return;
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (!child || child.type !== "code_fence_content") continue;
+      const body = String(child.text ?? "");
+      let lineStart = 0;
+      while (lineStart < body.length) {
+        let lineEnd = lineStart;
+        while (lineEnd < body.length && body.charCodeAt(lineEnd) !== 10) lineEnd++;
+        const line2 = body.slice(lineStart, lineEnd).trim();
+        if (line2.length > 0 && line2.charCodeAt(0) === 58) {
+          const key = line2.slice(1).split(":")[0].split(" ")[0].trim().toLowerCase();
+          if (key === "lines" || key === "start-after" || key === "end-before" || key === "start-line" || key === "end-line" || key === "lineno-start" || key === "lineno-end" || key === "lineno-match" || key === "lineno" || key === "start" || key === "end") {
+            patterns.push("Markdown fragment-quoted include (not part_of)");
+            return;
+          }
+        }
+        lineStart = lineEnd + 1;
+      }
+    }
+    const slash = argument.lastIndexOf("/");
+    const base = slash >= 0 ? argument.slice(slash + 1) : argument;
+    const dot = base.lastIndexOf(".");
+    const stem = dot > 0 ? base.slice(0, dot) : base;
+    if (!stem) return;
+    patterns.push("Markdown include fences (part_of)");
+    addRel(
+      source,
+      ASTEngine.RelationshipType.PartOf,
+      stem,
+      {
+        role: "markdown_include_fence",
+        directive,
+        partPath: argument,
+        partRole: "library"
+      },
+      line
+    );
+  }
+  headingLevel(node) {
+    const marker = this.findChildByType(
+      node,
+      /* @__PURE__ */ new Set([
+        "atx_h1_marker",
+        "atx_h2_marker",
+        "atx_h3_marker",
+        "atx_h4_marker",
+        "atx_h5_marker",
+        "atx_h6_marker",
+        "setext_h1_underline",
+        "setext_h2_underline"
+      ])
+    );
+    if (marker) {
+      const t = marker.type;
+      if (t.includes("h1")) return 1;
+      if (t.includes("h2")) return 2;
+      if (t.includes("h3")) return 3;
+      if (t.includes("h4")) return 4;
+      if (t.includes("h5")) return 5;
+      if (t.includes("h6")) return 6;
+    }
+    return 1;
+  }
+  /** Heading display text: the inline child's raw text (no marker, no regex). */
+  /**
+   * A heading's display text.
+   *
+   * Three grammar facts, each a defect before this round, all resolved by position
+   * rather than by pattern (the lane's zero-regex property is the reason these reads
+   * exist at all, and none of them needed a regex to fix).
+   *
+   * 1. ATX CLOSING SEQUENCE. `# H #` is the heading `H`. The grammar already splits
+   *    the marker out as a named `atx_hN_marker` child, so the closing run is removed
+   *    by position: everything after the last space, when that remainder is only `#`
+   *    characters. Before this, such a heading published a symbol named `H #`, so a
+   *    document that closed its headings and one that did not produced two different
+   *    symbols for the same section.
+   *
+   * 2. A NAME NEVER CONTAINS A NEWLINE. A multi-line setext heading's text is its
+   *    PARAGRAPH, and the paragraph holds the text plus the underline, so the
+   *    previous "node text minus the last line" fallback returned every line but the
+   *    underline. Measured: a two-line setext heading published
+   *    `"Multi Line Title\nsecond line of paragraph"` — a name carrying an embedded
+   *    newline into `ownerName`, the qualified path and every display surface. Only
+   *    the first line is the heading.
+   *
+   * 3. AN EMPTY HEADING IS ABSENCE, NOT A NAME. `#` with no content returns undefined
+   *    here, so nothing is published for it. The previous fallback returned the marker
+   *    itself, so a document of empty headings published a `contains` chain of
+   *    symbols named `#`, `##`, `###` — which is the M60 R7 class (a name that is
+   *    not a name), one step short of the register's own `MARKER` pattern, and two
+   *    sibling `##` headings named `##` collided and lost a level of hierarchy.
+   *
+   *    The empty case has to be caught by TYPE, not by an empty inline child: a bare
+   *    `#` is `atx_heading > atx_h1_marker` with NO `inline` child at all (measured on
+   *    the pinned wasm), so a guard written as "if the inline text is empty, stop"
+   *    never runs for the one case it was written for, and the setext fallback
+   *    rescues the marker. That is why the first attempt at this fix appeared to do
+   *    nothing.
+   */
+  headingText(node) {
+    if (node.type === "atx_heading") {
+      const inline = this.findChildByType(node, /* @__PURE__ */ new Set(["inline"]));
+      if (!inline) return void 0;
+      const text = this.stripAtxClosingSequence(inline.text.trim());
+      return text ? text : void 0;
+    }
+    const raw = node.text.trim();
+    if (!raw) return void 0;
+    const nl = raw.indexOf("\n");
+    const first = (nl >= 0 ? raw.slice(0, nl) : raw).trim();
+    return first ? first : void 0;
+  }
+  /**
+   * Remove an ATX heading's optional closing `#` run, by position and by
+   * character code — no regex. CommonMark: "The optional closing sequence of #s
+   * must be preceded by spaces or tabs and may be followed by spaces or tabs only."
+   * A `#` that is preceded by no space (`a#b`) is part of the text and is kept; a run
+   * that is followed by other text is part of the text and is kept.
+   */
+  stripAtxClosingSequence(text) {
+    if (text.length === 0 || text.charCodeAt(text.length - 1) !== 35) return text;
+    let end = text.length;
+    while (end > 0 && text.charCodeAt(end - 1) === 35) end--;
+    if (end === text.length) return text;
+    const before = text.charCodeAt(end - 1);
+    if (before !== 32 && before !== 9) return text;
+    return text.slice(0, end).trim();
+  }
+  /** Table identity: header cell text joined by `/` (no regex). */
+  tableName(node, content) {
+    const header = this.findChildByType(node, /* @__PURE__ */ new Set(["pipe_table_header"]));
+    if (header) {
+      const parts = [];
+      for (let i = 0; i < header.namedChildCount; i++) {
+        const cell = header.namedChild(i);
+        if (cell?.type === "pipe_table_cell") {
+          const t = cell.text.trim();
+          if (t) parts.push(t);
+        }
+      }
+      if (parts.length > 0) return parts.join("/");
+    }
+    return "table";
+  }
+  findChildByType(node, types) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child && types.has(child.type)) return child;
+    }
+    return null;
+  }
+  nodeToRange(node) {
+    return {
+      startLine: node.startPosition.row + 1,
+      startColumn: node.startPosition.column,
+      endLine: node.endPosition.row + 1,
+      endColumn: node.endPosition.column,
+      startIndex: node.startIndex,
+      endIndex: node.endIndex
+    };
+  }
+};
+export {
+  RealMarkdownAnalyzer
+};