@backbencher/brain 0.0.0-stage → 0.1.1

package/dist/real-cpp-analyzer-IVVOD25R.js

@@ -0,0 +1,4101 @@
+import {
+  buildResolutionTables
+} from "./chunk-2DE27DVC.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-cpp-analyzer.ts
+var CPP_CITATION_STDLIB_ROOTS = /* @__PURE__ */ new Set([
+  "move",
+  "string",
+  "max",
+  "infinity",
+  "min",
+  "quiet_NaN",
+  "make_pair",
+  "isnan",
+  "signaling_NaN",
+  "swap",
+  "make_tuple",
+  "sort",
+  "to_string",
+  "forward",
+  "make_shared",
+  "make_unique",
+  "size_t",
+  "vector",
+  "map",
+  "unordered_map",
+  "set",
+  "pair",
+  "tuple",
+  "optional",
+  "variant",
+  "function",
+  "shared_ptr",
+  "unique_ptr",
+  "string_view",
+  "numeric_limits",
+  "find",
+  "begin",
+  "end",
+  "size",
+  "copy",
+  "fill",
+  "count",
+  "abs",
+  "fabs",
+  "sqrt",
+  "pow",
+  "floor",
+  "ceil",
+  "round",
+  "log",
+  "exp"
+]);
+function cppCitationFacts(qualified, leaf) {
+  if (process.env.BB_CPP_CITATION !== "1") return {};
+  if (leaf === "" || !CPP_CITATION_STDLIB_ROOTS.has(leaf)) return {};
+  let t = String(qualified ?? "").trim();
+  if (t.startsWith("::")) t = t.slice(2);
+  const lt = t.indexOf("<");
+  if (lt > 0) t = t.slice(0, lt);
+  if (t.split("::")[0]?.trim() !== "std") return {};
+  return { languageNamespace: [leaf], languageNamespacePolicy: "strict-absent" };
+}
+function qualifiedOwnerSegment(qualified, leaf) {
+  if (qualified === "" || leaf === "") return null;
+  let depth = 0;
+  let flat = "";
+  for (let i = 0; i < qualified.length; i++) {
+    const ch = qualified[i];
+    if (ch === "<") depth++;
+    else if (ch === ">") depth = Math.max(0, depth - 1);
+    else if (depth === 0) flat += ch;
+  }
+  const t = flat.trim();
+  const cut = t.lastIndexOf("::");
+  if (cut <= 0) return null;
+  const segs = t.split("::").map((x) => x.trim());
+  for (const seg of segs) if (!isIdentifierShapeWithDollar(seg)) return null;
+  if (segs[segs.length - 1] !== leaf) return null;
+  return segs.length >= 2 ? segs[segs.length - 2] : null;
+}
+function isIdentifierShapeWithDollar(s) {
+  if (s.length === 0) return false;
+  const c0 = s.charCodeAt(0);
+  const headOk = c0 >= 65 && c0 <= 90 || c0 >= 97 && c0 <= 122 || c0 === 95 || c0 === 36;
+  if (!headOk) return false;
+  for (let i = 1; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    const ok = c >= 65 && c <= 90 || c >= 97 && c <= 122 || c >= 48 && c <= 57 || c === 95 || c === 36;
+    if (!ok) return false;
+  }
+  return true;
+}
+function collapseTypeNoise(t) {
+  let out = "";
+  let pending = false;
+  for (let i = 0; i < t.length; i++) {
+    const c = t[i];
+    const isNoise = c === "*" || c === "&" || c === " " || c === "	" || c === "\n" || c === "\r" || c === "\f" || c === "\v";
+    if (isNoise) {
+      if (out.length > 0) pending = true;
+      continue;
+    }
+    if (pending) {
+      out += " ";
+      pending = false;
+    }
+    out += c;
+  }
+  return out.trim();
+}
+function stringIncludes(str, val) {
+  return str.indexOf(val) !== -1;
+}
+function stripIncludeChars(text) {
+  let out = "";
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (c !== "<" && c !== ">" && c !== '"' && c !== "'") out += c;
+  }
+  return out;
+}
+function swapChar(text, from, to) {
+  let out = "";
+  for (let i = 0; i < text.length; i++) out += text[i] === from ? to : text[i];
+  return out;
+}
+function cppPackageScopeFacts(leaf, qualified, includeRoots, declaredPackages) {
+  if (process.env.BB_CPP_PACKAGE_SCOPE !== "1") return {};
+  if (leaf === "" || qualified === "" || includeRoots.size === 0 || declaredPackages.length === 0) return {};
+  const cut = qualified.lastIndexOf("::");
+  if (cut <= 0) return {};
+  const ns = qualified.slice(0, cut).trim().toLowerCase();
+  if (ns.length === 0) return {};
+  const sep = ns.indexOf("::");
+  const root = (sep >= 0 ? ns.slice(0, sep) : ns).trim();
+  if (root.length === 0) return {};
+  if (!includeRoots.has(root)) return {};
+  const matched = [];
+  for (const raw of declaredPackages) {
+    const pkg = String(raw ?? "").trim();
+    if (pkg.length === 0) continue;
+    const lower = pkg.toLowerCase();
+    if (root === lower || root === swapChar(lower, "_", "-") || root === swapChar(lower, "-", "_")) {
+      matched.push(pkg);
+      continue;
+    }
+    if (root.length >= 3 && lower.startsWith(root)) {
+      const next = lower.charAt(root.length);
+      if (next === "_" || next === "-" || next === "." || next === "/") matched.push(pkg);
+    }
+  }
+  if (matched.length !== 1) return {};
+  return { packageScope: { package: matched[0], name: leaf } };
+}
+function cppExternalIncludeRoots(root) {
+  const roots = /* @__PURE__ */ new Set();
+  const stack = [root];
+  while (stack.length > 0) {
+    const n = stack.pop();
+    if (!n) continue;
+    if (n.type === "preproc_include") {
+      const pathNode = n.childForFieldName("path");
+      const raw = (pathNode?.text ?? "").trim();
+      if (raw.startsWith("<")) {
+        const p = stripIncludeChars(raw).trim();
+        const slash = p.indexOf("/");
+        if (slash > 0) {
+          const seg = p.slice(0, slash).toLowerCase();
+          if (seg.length > 0) roots.add(seg);
+        }
+      }
+    }
+    for (let i = 0; i < n.childCount; i++) {
+      const c = n.child(i);
+      if (c) stack.push(c);
+    }
+  }
+  return roots;
+}
+function cppPartTargetPath(filePath, specifier) {
+  const dir = filePath.includes("/") ? filePath.slice(0, filePath.lastIndexOf("/")) : "";
+  const joined = dir === "" ? specifier : `${dir}/${specifier}`;
+  const absolute = joined.startsWith("/");
+  const out = [];
+  for (const seg of joined.split("/")) {
+    if (seg === "" || seg === ".") continue;
+    if (seg === "..") {
+      if (out.length > 0 && out[out.length - 1] !== "..") out.pop();
+      else out.push("..");
+      continue;
+    }
+    out.push(seg);
+  }
+  return `${absolute ? "/" : ""}${out.join("/")}`;
+}
+function cppPartSymbol(specifier) {
+  const slash = specifier.lastIndexOf("/");
+  const base = slash >= 0 ? specifier.slice(slash + 1) : specifier;
+  const dot = base.lastIndexOf(".");
+  const stem = dot > 0 ? base.slice(0, dot) : base;
+  return stem.trim();
+}
+function stripAccessSpecifier(text) {
+  const lower = text.toLowerCase();
+  if (lower.startsWith("public")) return text.slice("public".length).trim();
+  if (lower.startsWith("protected")) return text.slice("protected".length).trim();
+  if (lower.startsWith("private")) return text.slice("private".length).trim();
+  return text.trim();
+}
+function lastScopeSegment(text) {
+  let start = 0;
+  let out = "";
+  for (let i = 0; i <= text.length; i++) {
+    const atEnd = i === text.length;
+    const c = atEnd ? ":" : text[i];
+    const isSep = c === ":" || c === " " || c === "	" || c === "\n" || c === "\r";
+    if (isSep) {
+      if (i > start) out = text.slice(start, i);
+      start = i + 1;
+    }
+  }
+  return out;
+}
+function collapseSpaces(text) {
+  let out = "";
+  let pendingSpace = false;
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    const isWs = c === " " || c === "	" || c === "\n" || c === "\r" || c === "\f" || c === "\v";
+    if (isWs) {
+      if (out) pendingSpace = true;
+      continue;
+    }
+    if (pendingSpace) {
+      out += " ";
+      pendingSpace = false;
+    }
+    out += c;
+  }
+  return out;
+}
+function sameExtent(a, b) {
+  if (!a || !b) return false;
+  return a.startIndex === b.startIndex && a.endIndex === b.endIndex;
+}
+function isMacroDecoratedClassFunction(node) {
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const c = node.namedChild(i);
+    if (c && macroDecoratedClassDecl(c)) return true;
+  }
+  return false;
+}
+function isMacroSpelling(s) {
+  if (s.length < 1) return false;
+  const first = s.charCodeAt(0);
+  if (first < 65 || first > 90) return false;
+  for (let i = 1; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    const upper = c >= 65 && c <= 90;
+    const digit = c >= 48 && c <= 57;
+    if (!upper && !digit && c !== 95) return false;
+  }
+  return true;
+}
+var CPP_ANONYMOUS = "anonymous";
+function macroDecoratedClassDecl(spec) {
+  if (spec.type !== "class_specifier" && spec.type !== "struct_specifier" && spec.type !== "union_specifier") return null;
+  for (let i = 0; i < spec.namedChildCount; i++) {
+    const c = spec.namedChild(i);
+    if (c && c.type === "field_declaration_list") return null;
+  }
+  const nameField = spec.childForFieldName?.("name")?.text?.trim();
+  if (!nameField || !isMacroSpelling(nameField)) return null;
+  const parent = spec.parent;
+  if (!parent || parent.type !== "function_definition") return null;
+  let body = null;
+  for (let i = 0; i < parent.namedChildCount; i++) {
+    const c = parent.namedChild(i);
+    if (c && c.type === "compound_statement") {
+      body = c;
+      break;
+    }
+  }
+  if (!body) return null;
+  const siblings = [];
+  let prevWasMacro = false;
+  for (let i = 0; i < parent.namedChildCount; i++) {
+    const c = parent.namedChild(i);
+    if (!c) continue;
+    if (sameExtent(c, spec) || body && sameExtent(c, body)) continue;
+    if (c.endIndex > body.startIndex) continue;
+    if (c.type === "ERROR") {
+      let firstNamed = null;
+      let named = 0;
+      for (let k = 0; k < c.namedChildCount; k++) {
+        const kc = c.namedChild(k);
+        if (!kc || !kc.isNamed) continue;
+        named++;
+        if (firstNamed === null) firstNamed = kc;
+      }
+      let hasColon = false;
+      let colonAt = -1;
+      for (let k = 0; k < c.childCount; k++) {
+        const kc = c.child(k);
+        if (kc && kc.type === ":") {
+          hasColon = true;
+          colonAt = kc.startIndex;
+          break;
+        }
+      }
+      const colonFirst = hasColon && firstNamed !== null && colonAt >= 0 && colonAt < firstNamed.startIndex;
+      siblings.push({
+        node: c,
+        error: true,
+        errorName: firstNamed && firstNamed.type === "identifier" ? firstNamed : null,
+        hasColon,
+        colonFirst,
+        prevWasMacro,
+        namedCount: named
+      });
+      prevWasMacro = false;
+      continue;
+    }
+    siblings.push({ node: c, error: false, errorName: null, hasColon: false, colonFirst: false, prevWasMacro, namedCount: 0 });
+    prevWasMacro = c.type === "identifier" && isMacroSpelling(c.text.trim());
+  }
+  let nameNode = null;
+  const bases = [];
+  const colonArm = siblings.find((s) => s.error && s.errorName && s.hasColon && !s.colonFirst);
+  if (colonArm) {
+    nameNode = colonArm.errorName;
+    const at = siblings.indexOf(colonArm);
+    for (let i = at + 1; i < siblings.length; i++) {
+      const c = siblings[i].node;
+      if (c.type === "identifier" || c.type === "qualified_identifier" || c.type === "template_type") bases.push(c);
+    }
+  } else {
+    const attrArm = siblings.find((s) => s.error && s.errorName && s.prevWasMacro);
+    if (attrArm) {
+      nameNode = attrArm.errorName;
+    } else {
+      const names = siblings.filter((s) => !s.error && (s.node.type === "identifier" || s.node.type === "template_type"));
+      const nonMacro = names.find((s) => !isMacroSpelling(s.node.text.trim()));
+      nameNode = (nonMacro ?? names[0])?.node ?? null;
+    }
+  }
+  if (!colonArm) for (const s of siblings) {
+    if (!s.error || !s.colonFirst) continue;
+    for (let k = 0; k < s.node.namedChildCount; k++) {
+      const kc = s.node.namedChild(k);
+      if (kc && (kc.type === "identifier" || kc.type === "qualified_identifier" || kc.type === "template_type")) bases.push(kc);
+    }
+  }
+  if (!nameNode) return null;
+  const name = nameNode.text.trim();
+  if (!isCppSpelledName(name)) return null;
+  return { name, nameNode, body, owner: parent, bases };
+}
+function enclosingFriendDeclaration(node) {
+  let cur = node.parent;
+  let guard = 0;
+  while (cur && guard++ < 64) {
+    if (cur.type === "friend_declaration") return cur;
+    cur = cur.parent;
+  }
+  return null;
+}
+function friendBodyOwner(scopeStack, fallback) {
+  for (let i = scopeStack.length - 1; i >= 0; i--) {
+    const scope = scopeStack[i];
+    if (scope.kind === ASTEngine.SymbolKind.Class || scope.kind === ASTEngine.SymbolKind.Struct || scope.kind === ASTEngine.SymbolKind.Union) {
+      continue;
+    }
+    return scope;
+  }
+  return { node: fallback, name: "global", kind: ASTEngine.SymbolKind.Function };
+}
+function templateParameterNames(list) {
+  const names = /* @__PURE__ */ new Set();
+  for (let j = 0; j < list.namedChildCount; j++) {
+    const param = list.namedChild(j);
+    if (!param) continue;
+    let declared = null;
+    for (let k = 0; k < param.namedChildCount; k++) {
+      const c = param.namedChild(k);
+      if (c && (c.type === "identifier" || c.type === "type_identifier")) declared = c;
+    }
+    if (!declared) {
+      const stack = [param];
+      while (stack.length > 0) {
+        const n = stack.pop();
+        if (n.type === "identifier" || n.type === "type_identifier") declared = n;
+        for (let k = 0; k < n.namedChildCount; k++) {
+          const c = n.namedChild(k);
+          if (c) stack.push(c);
+        }
+      }
+    }
+    if (declared?.text) names.add(declared.text);
+  }
+  return names;
+}
+function isTemplateParameterListFrame(node) {
+  if (node.childCount < 3) return false;
+  if (node.child(0)?.type !== "<" || node.child(node.childCount - 1)?.type !== ">") return false;
+  for (let i = 1; i < node.childCount - 1; i++) {
+    const t = node.child(i)?.type;
+    if (t === "typename" || t === "class") return true;
+  }
+  return false;
+}
+function extendsTargetName(baseText, className) {
+  const leafOf = (raw) => {
+    let t = stripAccessSpecifier(raw);
+    const lt = t.indexOf("<");
+    if (lt !== -1) t = t.slice(0, lt).trim();
+    return lastScopeSegment(t);
+  };
+  const leaf = leafOf(baseText);
+  if (!leaf) return null;
+  if (leaf === leafOf(className)) return null;
+  return leaf;
+}
+var CPP_ORACLE_CONTRACT = [
+  "macroDeclaredBody",
+  // #919: a macro-declared BODY is a function body
+  "isCppSpelledName",
+  // D1: one set, three gates, one impossibility
+  "extendsTargetName",
+  // D2: a class definition is never a base
+  "qualifiedDeclaratorLeaf",
+  // the qualified declarator's LEAF is the name
+  "templateWrappedDeclaratorName",
+  // CPPD15/16: a wrapped declarator declares
+  "recoveredDeclaredName",
+  // D4: the name beside an error-recovered declarator
+  "specifierDeclaredName",
+  // D7: a specifier's name is its leaf
+  "attributeDisplacedEnumName"
+  // D7: an enum name the attribute displaced
+];
+function macroDeclaredBody(body) {
+  if (!body || body.type !== "compound_statement") return null;
+  let heading = body.previousSibling;
+  for (let i = 0; heading && i < 2 && (heading.isMissing || heading.type === ";"); i++) {
+    heading = heading.previousSibling;
+  }
+  if (!heading || heading.type !== "expression_statement") return null;
+  let missing = false;
+  for (let i = 0; i < heading.childCount; i++) {
+    const c = heading.child(i);
+    if (c && c.isMissing) {
+      missing = true;
+      break;
+    }
+  }
+  if (!missing) return null;
+  const call = heading.namedChild(0);
+  if (!call || call.type !== "call_expression") return null;
+  const macro = call.childForFieldName("function");
+  if (!macro || macro.type !== "identifier") return null;
+  const macroName = macro.text.trim();
+  if (!macroName) return null;
+  return { heading, macroName, nameNode: macro };
+}
+function isIdentifierChar(code) {
+  return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || code === 95;
+}
+function joinHeadingLines(text) {
+  let out = "";
+  let i = 0;
+  while (i < text.length) {
+    const c = text[i];
+    if (c === "\n") {
+      while (out.length > 0 && (out[out.length - 1] === " " || out[out.length - 1] === "	" || out[out.length - 1] === "\r")) out = out.slice(0, -1);
+      out += " ";
+      i++;
+      while (i < text.length && (text[i] === " " || text[i] === "	" || text[i] === "\r")) i++;
+      continue;
+    }
+    out += c;
+    i++;
+  }
+  return out.trim();
+}
+function phantomQualifierType(nameField) {
+  if (!nameField || nameField.type !== "qualified_identifier") return void 0;
+  const leaf = qualifiedDeclaratorLeaf(nameField);
+  if (!leaf || leaf.scopeQid !== null) return void 0;
+  const type = collapseSpaces(nameField.text.slice(0, leaf.nameNode.startIndex - nameField.startIndex));
+  return type || void 0;
+}
+function specifierTypeText(specifier) {
+  const parts = [];
+  for (let i = 0; i < specifier.namedChildCount; i++) {
+    const c = specifier.namedChild(i);
+    if (c && c.type !== "macro_specifier") parts.push(c.text);
+  }
+  return collapseSpaces(parts.join(" ")) || void 0;
+}
+var CPP_BUILTIN_TYPE_KEYWORDS = /* @__PURE__ */ new Set([
+  "void",
+  "bool",
+  "char",
+  "char8_t",
+  "char16_t",
+  "char32_t",
+  "wchar_t",
+  "short",
+  "int",
+  "long",
+  "float",
+  "double",
+  "signed",
+  "unsigned",
+  "auto"
+]);
+var CPP_NON_CLASS_STANDARD_TYPES = /* @__PURE__ */ new Set([
+  // <cstdint> exact-width
+  "int8_t",
+  "int16_t",
+  "int32_t",
+  "int64_t",
+  "uint8_t",
+  "uint16_t",
+  "uint32_t",
+  "uint64_t",
+  // <cstdint> least/fast variants
+  "int_least8_t",
+  "int_least16_t",
+  "int_least32_t",
+  "int_least64_t",
+  "uint_least8_t",
+  "uint_least16_t",
+  "uint_least32_t",
+  "uint_least64_t",
+  "int_fast8_t",
+  "int_fast16_t",
+  "int_fast32_t",
+  "int_fast64_t",
+  "uint_fast8_t",
+  "uint_fast16_t",
+  "uint_fast32_t",
+  "uint_fast64_t",
+  // <cstdint> pointer-width and widest
+  "intptr_t",
+  "uintptr_t",
+  "intmax_t",
+  "uintmax_t",
+  // <cstddef>
+  "size_t",
+  "ptrdiff_t",
+  "nullptr_t"
+]);
+var CPP_KEYWORDS = /* @__PURE__ */ new Set([
+  // declarations, types, specifiers
+  "alignas",
+  "auto",
+  "bool",
+  "char",
+  "char8_t",
+  "char16_t",
+  "char32_t",
+  "class",
+  "const",
+  "consteval",
+  "constexpr",
+  "constinit",
+  "decltype",
+  "double",
+  "enum",
+  "explicit",
+  "export",
+  "extern",
+  "float",
+  "friend",
+  "inline",
+  "int",
+  "long",
+  "mutable",
+  "namespace",
+  "register",
+  "short",
+  "signed",
+  "static",
+  "struct",
+  "template",
+  "thread_local",
+  "typedef",
+  "typeid",
+  "typename",
+  "union",
+  "unsigned",
+  "using",
+  "virtual",
+  "void",
+  "volatile",
+  "wchar_t",
+  // control flow
+  "break",
+  "case",
+  "catch",
+  "co_await",
+  "co_return",
+  "co_yield",
+  "continue",
+  "default",
+  "do",
+  "else",
+  "for",
+  "goto",
+  "if",
+  "return",
+  "switch",
+  "throw",
+  "try",
+  "while",
+  // expressions — the CAST family is what #924's type-only set missed
+  "const_cast",
+  "delete",
+  "dynamic_cast",
+  "new",
+  "noexcept",
+  "nullptr",
+  "reinterpret_cast",
+  "sizeof",
+  "static_assert",
+  "static_cast",
+  "this",
+  "true",
+  "false",
+  "operator",
+  "requires",
+  "concept",
+  // access
+  "private",
+  "protected",
+  "public",
+  // alternative tokens (ISO 14882 [lex.digraph], [lex.alternative])
+  "and",
+  "and_eq",
+  "bitand",
+  "bitor",
+  "compl",
+  "not",
+  "not_eq",
+  "or",
+  "or_eq",
+  "xor",
+  "xor_eq",
+  // implementation-reserved spellings and the standard preprocessor operators.
+  // None of these is a user-spellable identifier either, and each was measured
+  // producing an edge on the corpora (`defined` 34, `__has_include` 42,
+  // `__has_cpp_attribute` 6).
+  "defined",
+  "__has_include",
+  "__has_cpp_attribute",
+  "asm",
+  "__asm",
+  "__asm__",
+  "__declspec",
+  "__attribute__",
+  "__attribute",
+  "__inline",
+  "__inline__",
+  "__forceinline",
+  "__restrict",
+  "__restrict__",
+  "__extension__",
+  "__typeof__",
+  "__typeof",
+  "__cdecl",
+  "__stdcall",
+  "__thiscall",
+  "__vectorcall",
+  "__int8",
+  "__int16",
+  "__int32",
+  "__int64",
+  "__forceinline__",
+  "__declspec__",
+  "__builtin_offsetof",
+  "__builtin_va_arg",
+  "__builtin_types_compatible_p",
+  "__func__",
+  "__FUNCTION__",
+  "__PRETTY_FUNCTION__"
+]);
+function isCppSpelledName(text) {
+  if (!text) return false;
+  return !CPP_KEYWORDS.has(text);
+}
+function isPublishableFunctionName(name) {
+  if (!name) return false;
+  if (name.startsWith("operator")) return true;
+  const isStart = (c) => c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === 95 || c === 126;
+  const isContinue = (c) => isStart(c) || c >= 48 && c <= 57;
+  if (!isStart(name.charCodeAt(0))) return false;
+  for (let i = 1; i < name.length; i++) if (!isContinue(name.charCodeAt(i))) return false;
+  return true;
+}
+function sameTsNode(a, b) {
+  if (!a || !b) return false;
+  return a.type === b.type && a.startIndex === b.startIndex && a.endIndex === b.endIndex;
+}
+function cppPureVirtualDeclaration(node) {
+  if (!node) return false;
+  if (node.type !== "declaration" && node.type !== "field_declaration" && node.type !== "function_definition") return false;
+  const direct = node.childForFieldName?.("declarator");
+  if (direct?.type === "function_declarator" && hasZeroLiteralChild(node)) return true;
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const c = node.namedChild(i);
+    if (!c || c.type !== "init_declarator") continue;
+    const value = c.childForFieldName?.("value");
+    const inner = c.childForFieldName?.("declarator");
+    if (value?.type === "number_literal" && value.text.trim() === "0" && inner?.type === "function_declarator") return true;
+  }
+  return false;
+}
+function hasZeroLiteralChild(node) {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.type === "number_literal" && child.text.trim() === "0") return true;
+  }
+  return false;
+}
+var CPP_EXPORT_MARKER_COMPONENTS = /* @__PURE__ */ new Set([
+  "EXPORT",
+  "EXPORTS",
+  "EXPORTABLE",
+  "DLLEXPORT",
+  "API",
+  "VISIBILITY",
+  "PUBLIC_API"
+]);
+function identifierComponents(text) {
+  const out = [];
+  let cur = "";
+  for (let i = 0; i <= text.length; i++) {
+    const c = i < text.length ? text.charCodeAt(i) : 95;
+    if (c === 95) {
+      if (cur) out.push(cur);
+      cur = "";
+      continue;
+    }
+    cur += text[i];
+  }
+  return out;
+}
+function cppExportMarker(macro) {
+  if (!macro) return false;
+  const comps = identifierComponents(macro.trim());
+  if (comps.length === 0) return false;
+  for (const c of comps) if (CPP_EXPORT_MARKER_COMPONENTS.has(c)) return true;
+  return false;
+}
+function recoveredDeclaredName(declNode) {
+  if (!declNode.hasError) return null;
+  const declared = declNode.childForFieldName?.("declarator") ?? null;
+  if (!declared) return null;
+  let next = declared.nextSibling;
+  while (next && (next.isMissing || !next.isNamed)) next = next.nextSibling;
+  if (!next || next.type !== "ERROR" || next.namedChildCount !== 1) return null;
+  const inner = next.namedChild(0);
+  if (!inner || inner.type !== "identifier") return null;
+  if (inner.startIndex <= declared.startIndex) return null;
+  if (!isCppSpelledName(inner.text)) return null;
+  return inner;
+}
+function specifierDeclaredName(spec) {
+  const leafOf = (n, depth = 0) => {
+    if (!n || depth > 8) return null;
+    if (n.type === "type_identifier" || n.type === "identifier") {
+      return isCppSpelledName(n.text) ? n.text : null;
+    }
+    if (n.type === "template_type") {
+      const tn = n.childForFieldName?.("name") ?? null;
+      if (tn) return leafOf(tn, depth + 1);
+      const lt = n.text.indexOf("<");
+      return lt > 0 ? n.text.slice(0, lt).trim() : null;
+    }
+    if (n.type === "qualified_identifier") {
+      return leafOf(n.namedChild(n.namedChildCount - 1), depth + 1);
+    }
+    return null;
+  };
+  const nameField = spec.childForFieldName?.("name") ?? null;
+  if (nameField) {
+    if (nameField.type === "type_identifier" || nameField.type === "identifier") {
+      return isCppSpelledName(nameField.text) ? nameField.text : null;
+    }
+    if (nameField.type === "qualified_identifier" || nameField.type === "template_type") {
+      return leafOf(nameField);
+    }
+  }
+  return null;
+}
+function attributeDisplacedEnumName(enumSpec) {
+  const decl = enumSpec.parent ?? null;
+  if (!decl || decl.type !== "declaration" && decl.type !== "field_declaration") return null;
+  const outer = decl.childForFieldName?.("declarator") ?? null;
+  if (!outer || outer.type !== "init_declarator") return null;
+  const id = outer.childForFieldName?.("declarator") ?? null;
+  if (!id || id.type !== "identifier") return null;
+  if (id.startIndex <= enumSpec.endIndex) return null;
+  return isCppSpelledName(id.text) ? id.text : null;
+}
+function qualifiedDeclaratorLeaf(qid) {
+  let leaf = qid;
+  while (true) {
+    const last = leaf.namedChild(leaf.namedChildCount - 1);
+    if (last && last.type === "qualified_identifier") leaf = last;
+    else break;
+  }
+  const nameNode = leaf.namedChild(leaf.namedChildCount - 1);
+  if (!nameNode) return null;
+  let realJoin = false;
+  for (let i = 0; i < leaf.childCount; i++) {
+    const c = leaf.child(i);
+    if (c && !c.isNamed && c.type === "::") {
+      realJoin = c.text === "::";
+      break;
+    }
+  }
+  return { nameNode, scopeQid: realJoin ? leaf : null };
+}
+function templateWrappedDeclaratorName(nameNode) {
+  const p = nameNode.parent;
+  if (!p) return false;
+  if (p.type !== "template_function" && p.type !== "template_method" && p.type !== "dependent_name") return false;
+  const gp = p.parent;
+  if (!gp || gp.type !== "function_declarator" && gp.type !== "abstract_function_declarator") return false;
+  const decl = gp.childForFieldName?.("declarator");
+  return !!decl && decl.startIndex === p.startIndex && decl.endIndex === p.endIndex;
+}
+function macroInvocationText(content, nameStart) {
+  const CAP = 4e3;
+  let i = nameStart;
+  while (i < content.length && isIdentifierChar(content.charCodeAt(i))) i++;
+  const end = Math.min(content.length, i + CAP);
+  let open = -1;
+  while (i < end) {
+    const c = content[i];
+    if (c === "(") {
+      open = i;
+      break;
+    }
+    if (c === "/" && content[i + 1] === "/") {
+      const nl = content.indexOf("\n", i);
+      if (nl < 0) return null;
+      i = nl + 1;
+      continue;
+    }
+    if (c === "/" && content[i + 1] === "*") {
+      const cl = content.indexOf("*/", i);
+      if (cl < 0) return null;
+      i = cl + 2;
+      continue;
+    }
+    if (c === "{" || c === "}" || c === ";") return null;
+    i++;
+  }
+  if (open < 0) return null;
+  let depth = 0;
+  for (let k = open; k < end; k++) {
+    const c = content[k];
+    if (c === '"' || c === "'") {
+      k++;
+      while (k < end) {
+        if (content[k] === "\\") {
+          k += 2;
+          continue;
+        }
+        if (content[k] === c) break;
+        k++;
+      }
+      continue;
+    }
+    if (c === "/" && content[k + 1] === "/") {
+      const nl = content.indexOf("\n", k);
+      if (nl < 0) return null;
+      k = nl;
+      continue;
+    }
+    if (c === "/" && content[k + 1] === "*") {
+      const cl = content.indexOf("*/", k);
+      if (cl < 0) return null;
+      k = cl + 1;
+      continue;
+    }
+    if (c === "(") depth++;
+    else if (c === ")") {
+      depth--;
+      if (depth === 0) {
+        const text = joinHeadingLines(content.slice(nameStart, k + 1));
+        return text || null;
+      }
+    }
+  }
+  return null;
+}
+var RealCppAnalyzer = class {
+  analyze(rootNode, content, filePath, context) {
+    const symbols = [];
+    const relationships = [];
+    const imports = [];
+    const exports = [];
+    const errors = [];
+    const patterns = {};
+    const frameworks = {};
+    let memorySafetyScore = 100;
+    const usesSeen = /* @__PURE__ */ new Set();
+    const referencesSeen = /* @__PURE__ */ new Set();
+    const exportsSeen = /* @__PURE__ */ new Set();
+    const macroNames = /* @__PURE__ */ new Set();
+    let fileDecisions = 0;
+    const classVirtuals = /* @__PURE__ */ new Map();
+    const pendingOverrides = [];
+    const classBases = /* @__PURE__ */ new Map();
+    const classPureVirtuals = /* @__PURE__ */ new Map();
+    const pendingImplements = [];
+    const pendingExports = [];
+    const PACKAGE_SCOPE = process.env.BB_CPP_PACKAGE_SCOPE === "1";
+    const packageScopePackages = PACKAGE_SCOPE && Array.isArray(context?.cppPackageScopePackages) ? context.cppPackageScopePackages.map((x) => String(x ?? "").trim()).filter((x) => x.length > 0) : [];
+    const packageScopeRoots = PACKAGE_SCOPE && packageScopePackages.length > 0 ? cppExternalIncludeRoots(rootNode) : /* @__PURE__ */ new Set();
+    const INDEX_CONSUME = process.env.BB_CPP_INDEX_CONSUME === "1";
+    const indexCandidate = INDEX_CONSUME ? context?.projectIndex : void 0;
+    const indexUsable = !!indexCandidate && indexCandidate.complete === true;
+    const indexSymbols = indexUsable && indexCandidate.symbolNames instanceof Set ? indexCandidate.symbolNames : /* @__PURE__ */ new Set();
+    const indexCounts = indexUsable && indexCandidate.symbolCounts instanceof Map ? indexCandidate.symbolCounts : /* @__PURE__ */ new Map();
+    const indexTypeKinds = indexUsable && indexCandidate.typeKinds instanceof Map ? indexCandidate.typeKinds : /* @__PURE__ */ new Map();
+    const indexTypeBases = indexUsable && indexCandidate.typeBases instanceof Map ? indexCandidate.typeBases : /* @__PURE__ */ new Map();
+    let indexResolution = null;
+    if (indexUsable) {
+      try {
+        indexResolution = buildResolutionTables(indexCandidate);
+      } catch {
+        indexResolution = null;
+      }
+    }
+    const indexCallFacts = (targetName) => {
+      if (!indexUsable) return {};
+      const out = {};
+      if (indexSymbols.has(targetName)) out.declaredInProject = true;
+      const count = indexCounts.get(targetName);
+      if (count !== void 0) out.indexDeclarationCount = count;
+      const owners = indexResolution?.memberOwners.get(targetName);
+      if (owners && owners.size === 1) out.memberOfProjectType = [...owners][0];
+      return out;
+    };
+    const indexBaseFacts = (targetName) => {
+      if (!indexUsable) return {};
+      const kind = indexTypeKinds.get(targetName);
+      return kind === void 0 ? {} : { indexBaseKind: String(kind) };
+    };
+    const indexOwnerFacts = (qualified, leaf) => {
+      if (!indexUsable) return {};
+      const owner = qualifiedOwnerSegment(qualified, leaf);
+      if (owner === null) return {};
+      const kind = indexTypeKinds.get(owner);
+      if (kind !== "class" && kind !== "struct" && kind !== "union") return {};
+      const ownMembers = indexCandidate.typeMembers instanceof Map ? indexCandidate.typeMembers.get(owner) : void 0;
+      if (!(ownMembers instanceof Set) || !ownMembers.has(leaf)) return {};
+      return { owner };
+    };
+    const indexOverridesFacts = (base, method) => {
+      if (!indexUsable || indexResolution === null) return {};
+      const declares = indexResolution.memberOwners.get(method)?.has(base) === true;
+      return declares ? { indexDeclaresMethod: true } : {};
+    };
+    void indexTypeBases;
+    const fileScopeValues = /* @__PURE__ */ new Set();
+    const namespaceValues = /* @__PURE__ */ new Map();
+    const classMembers = /* @__PURE__ */ new Map();
+    const usedNamespaces = /* @__PURE__ */ new Set();
+    const pendingQualified = [];
+    {
+      const pre = [
+        { n: rootNode, ns: [], inFn: false, inClass: null }
+      ];
+      const addValue = (name, ns, cls) => {
+        if (!isCppSpelledName(name)) return;
+        if (!name) return;
+        if (cls) {
+          let s = classMembers.get(cls);
+          if (!s) {
+            s = /* @__PURE__ */ new Set();
+            classMembers.set(cls, s);
+          }
+          s.add(name);
+          return;
+        }
+        if (ns.length > 0) {
+          const top = ns[ns.length - 1];
+          let s = namespaceValues.get(top);
+          if (!s) {
+            s = /* @__PURE__ */ new Set();
+            namespaceValues.set(top, s);
+          }
+          s.add(name);
+          return;
+        }
+        fileScopeValues.add(name);
+      };
+      const leftmostId = (n) => {
+        let cur = n;
+        while (cur) {
+          if (cur.type === "identifier" || cur.type === "field_identifier") {
+            return isCppSpelledName(cur.text) ? cur.text : null;
+          }
+          cur = cur.childForFieldName("declarator") || cur.namedChild(0);
+        }
+        return null;
+      };
+      while (pre.length > 0) {
+        const { n, ns, inFn, inClass } = pre.pop();
+        const t = n.type;
+        if (t === "namespace_definition") {
+          const nm = this.childText(n, "namespace_identifier");
+          if (nm && nm !== CPP_ANONYMOUS) {
+            for (let i = n.namedChildCount - 1; i >= 0; i--) {
+              const c = n.namedChild(i);
+              if (c) pre.push({ n: c, ns: [...ns, nm], inFn, inClass });
+            }
+            continue;
+          }
+        } else if (t === "class_specifier" || t === "struct_specifier" || t === "union_specifier") {
+          const nm = this.childText(n, "type_identifier") || (() => {
+            const tt = this.findChild(n, "template_type");
+            if (!tt) return null;
+            const tn = tt.childForFieldName?.("name") || this.findChild(tt, "type_identifier") || this.findChild(tt, "qualified_identifier");
+            if (tn?.text) return tn.text;
+            const lt = tt.text.indexOf("<");
+            return lt > 0 ? tt.text.slice(0, lt).trim() : null;
+          })();
+          const body = this.findChild(n, "field_declaration_list");
+          if (nm && body) {
+            for (let i = n.namedChildCount - 1; i >= 0; i--) {
+              const c = n.namedChild(i);
+              if (c) pre.push({ n: c, ns, inFn, inClass: nm });
+            }
+            continue;
+          }
+        } else if (t === "function_definition") {
+          const det = this.getFunctionDetails(n);
+          if (det && !det.isDestructor && !det.name.startsWith("operator") && !this.isMacroFunctionShape(n, det.name)) {
+            const isCtor = inClass !== null && det.name === inClass || det.scope !== void 0 && det.name === det.scope;
+            if (!isCtor) {
+              if (det.scope) pendingQualified.push({ name: det.name, scope: det.scope });
+              else if (!inFn) addValue(det.name, ns, inClass);
+            }
+          }
+          for (let i = n.namedChildCount - 1; i >= 0; i--) {
+            const c = n.namedChild(i);
+            if (c) pre.push({ n: c, ns, inFn: true, inClass });
+          }
+          continue;
+        } else if (t === "compound_statement" && macroDeclaredBody(n)) {
+          for (let i = n.namedChildCount - 1; i >= 0; i--) {
+            const c = n.namedChild(i);
+            if (c) pre.push({ n: c, ns, inFn: true, inClass });
+          }
+          continue;
+        } else if (!inFn && (t === "declaration" || t === "field_declaration")) {
+          for (let i = 0; i < n.namedChildCount; i++) {
+            const c = n.namedChild(i);
+            if (!c) continue;
+            if (c.type === "init_declarator" && c.namedChild(0)?.type === "structured_binding_declarator") {
+              const sb = c.namedChild(0);
+              for (let k = 0; k < sb.namedChildCount; k++) {
+                const b = sb.namedChild(k);
+                if (b && (b.type === "identifier" || b.type === "field_identifier")) addValue(b.text, ns, inClass);
+              }
+            } else if (c.type === "init_declarator" || c.type === "identifier" || c.type === "field_identifier" || c.type === "pointer_declarator" || c.type === "reference_declarator" || c.type === "array_declarator") {
+              const nm = leftmostId(c);
+              if (nm) addValue(nm, ns, inClass);
+            } else if (c.type === "function_declarator") {
+              const nm = leftmostId(c);
+              if (nm) addValue(nm, ns, inClass);
+            }
+          }
+        } else if (!inFn && t === "enumerator") {
+          const nm = this.childText(n, "identifier");
+          if (nm) addValue(nm, [], null);
+        } else if (t === "using_declaration" && !inFn && !inClass) {
+          const txt = n.text;
+          if (txt.indexOf("using namespace") !== -1) {
+            const tgt = this.findChild(n, "qualified_identifier") || this.findChild(n, "identifier");
+            if (tgt) usedNamespaces.add(tgt.text.split("::").filter(Boolean).join("::"));
+          } else {
+            const leaf = this.findChild(n, "qualified_identifier") || this.findChild(n, "identifier");
+            if (leaf) {
+              const segs = leaf.text.split("::").filter(Boolean);
+              if (segs.length > 0) addValue(segs[segs.length - 1], [], null);
+            }
+          }
+        }
+        for (let i = n.namedChildCount - 1; i >= 0; i--) {
+          const c = n.namedChild(i);
+          if (c) pre.push({ n: c, ns, inFn, inClass });
+        }
+      }
+      for (const q of pendingQualified) {
+        if (classMembers.has(q.scope)) addValue(q.name, [], q.scope);
+        else if (namespaceValues.has(q.scope)) addValue(q.name, [q.scope], null);
+        else addValue(q.name, [], null);
+      }
+    }
+    const scopeStack = [];
+    const stack = [{ node: rootNode }];
+    const DECL_PARENT_TYPES = /* @__PURE__ */ new Set([
+      "declaration",
+      "field_declaration",
+      "parameter_declaration",
+      "init_declarator",
+      "function_declarator",
+      "pointer_declarator",
+      "reference_declarator",
+      "array_declarator",
+      "abstract_pointer_declarator",
+      "abstract_array_declarator",
+      "abstract_function_declarator",
+      "enumerator",
+      "using_declaration",
+      "alias_declaration",
+      "optional_parameter_declaration",
+      "type_parameter_declaration",
+      // CP6 (second review): `auto [x, y]` bindings declare (see the
+      // carve-out in isDeclarationPosition — all names, not first-only).
+      "structured_binding_declarator",
+      // A DESTRUCTOR's name is declared, never read: `~json_sax()` puts the
+      // class name inside a `destructor_name` node, and without this entry the
+      // guard below returned false and the class name read as a value use. The
+      // analyzer's behaviour was already correct — the destructor branch reads
+      // the name to BUILD the symbol and never emitted a `uses` for it — so
+      // this entry changes no output here; it is here so the SET matches the
+      // F5 oracle's, because the oracle was the side that got it wrong and the
+      // whole point of a shared set is that neither side can drift alone.
+      // Measured on the oracle: 27 `uses` truth rows for names that are all
+      // constructor/destructor declarations in nlohmann's ABI test header
+      // (`json_sax`, `lexer`, `binary_reader`, `iter_impl`, `nonesuch`,
+      // `file_input_adapter`, `input_stream_adapter`, `json_sax_dom_parser`) —
+      // the analyzer published ZERO `uses` for every one of them.
+      "destructor_name"
+      // F6 audit: `template_type_parameter` / `template_value_parameter` are
+      // NOT types in the pinned tree-sitter-cpp grammar — template parameters
+      // parse as `type_parameter_declaration` (`typename T` / `class T`) and
+      // `parameter_declaration` / `optional_parameter_declaration`
+      // (`int N`, `int N = M`), all live in this set above. Removed.
+    ]);
+    const isDeclaringChainLeftmost = (node) => {
+      const p = node.parent;
+      if (!p || !p.type.endsWith("declarator")) return false;
+      let cur = p;
+      while (cur) {
+        if (cur.type === "identifier" || cur.type === "field_identifier") {
+          return cur.startIndex === node.startIndex;
+        }
+        let next = null;
+        for (let k = 0; k < cur.namedChildCount; k++) {
+          const c = cur.namedChild(k);
+          if (c && (c.type.endsWith("declarator") || c.type === "identifier" || c.type === "field_identifier")) {
+            next = c;
+            break;
+          }
+        }
+        cur = next;
+      }
+      return false;
+    };
+    const isDeclarationPosition = (node) => {
+      const p = node.parent;
+      if (!p) return false;
+      if (templateWrappedDeclaratorName(node)) return true;
+      if (p.type === "optional_parameter_declaration" || p.type === "type_parameter_declaration") {
+        for (let k = 0; k < p.namedChildCount; k++) {
+          const c = p.namedChild(k);
+          if (c && (c.type === "identifier" || c.type === "field_identifier")) {
+            return c.startIndex === node.startIndex;
+          }
+        }
+        return false;
+      }
+      if (p.type === "field_declaration" || p.type === "enumerator") {
+        let fresh = true;
+        let foundFirst = false;
+        for (let k = 0; k < p.childCount; k++) {
+          const c = p.child(k);
+          if (!c) continue;
+          if (!c.isNamed) {
+            if (c.type === "," || c.type === ";") {
+              fresh = true;
+              foundFirst = false;
+            } else if (c.type === "=" || c.type === ":" || c.type === "{") fresh = false;
+            continue;
+          }
+          if (c.type === "identifier" || c.type === "field_identifier") {
+            if (!foundFirst && fresh) {
+              if (c.startIndex === node.startIndex && c.endIndex === node.endIndex) return true;
+              foundFirst = true;
+            } else {
+              if (c.startIndex === node.startIndex && c.endIndex === node.endIndex) return false;
+            }
+          }
+        }
+        return false;
+      }
+      if (!DECL_PARENT_TYPES.has(p.type)) return false;
+      if (p.type === "structured_binding_declarator") return true;
+      if (p.type.endsWith("declarator") || p.type === "init_declarator") {
+        return isDeclaringChainLeftmost(node);
+      }
+      return true;
+    };
+    const isPreprocText = (node) => {
+      let cur = node.parent;
+      while (cur) {
+        const t = cur.type;
+        if (t.includes("statement") || t.includes("declaration") || t.includes("declarator") || t.includes("specifier") || t.includes("enumerator") || t.includes("compound") || t.includes("argument_list") || t.includes("init") || t.includes("expression") || t.includes("function_definition") || t.includes("field_declaration_list")) return false;
+        if (t.startsWith("preproc_")) return true;
+        cur = cur.parent;
+      }
+      return false;
+    };
+    const hasQualifiedAncestor = (node) => {
+      let cur = node.parent;
+      while (cur) {
+        const t = cur.type;
+        if (t === "qualified_identifier") return true;
+        if (t.includes("statement") || t.includes("declaration") || t.includes("declarator") || t.includes("expression") || t.includes("function_definition") || t.includes("field_declaration_list") || t.includes("argument_list")) return false;
+        cur = cur.parent;
+      }
+      return false;
+    };
+    const hasAttributeAncestor = (node) => {
+      let cur = node.parent;
+      while (cur) {
+        const t = cur.type;
+        if (t === "attribute" || t === "attribute_declaration" || t === "attribute_specifier") return true;
+        if (t.includes("statement") || t.includes("declaration") || t.includes("function_definition") || t.includes("expression") || t.includes("field_declaration_list")) return false;
+        cur = cur.parent;
+      }
+      return false;
+    };
+    const memberLeafTop = (node) => {
+      let top = node;
+      let p = node.parent;
+      while (p && (p.type === "template_function" || p.type === "template_method" || p.type === "dependent_name")) {
+        top = p;
+        p = p.parent;
+      }
+      return top;
+    };
+    const isMemberLeaf = (node) => {
+      const top = memberLeafTop(node);
+      const p = top.parent;
+      if (!p || p.type !== "field_expression") return false;
+      const field = p.childForFieldName("field");
+      return !!field && field.startIndex === top.startIndex;
+    };
+    const isCallCallee = (node) => {
+      let top = node;
+      let p = node.parent;
+      while (p && (p.type === "template_function" || p.type === "template_method" || p.type === "dependent_name" || p.type === "parenthesized_expression")) {
+        top = p;
+        p = p.parent;
+      }
+      if (!p || p.type !== "call_expression") return false;
+      const fnField = p.childForFieldName("function");
+      if (fnField) return fnField.startIndex === top.startIndex && fnField.endIndex >= top.endIndex;
+      const first = p.namedChild(0);
+      return !!first && first.startIndex === top.startIndex && first.endIndex >= top.endIndex;
+    };
+    const isFunctionOwnName = (node) => {
+      let up = node.parent;
+      while (up) {
+        if (up.type === "parameter_list" || up.type === "parameter_declaration") return false;
+        if (up.type === "function_declarator" && up.parent && up.parent.type === "function_definition") return true;
+        up = up.parent;
+      }
+      return false;
+    };
+    const enclosingFunctionScope = () => {
+      for (let i = scopeStack.length - 1; i >= 0; i--) {
+        const s = scopeStack[i];
+        if (s.kind === ASTEngine.SymbolKind.Function || s.kind === ASTEngine.SymbolKind.Method || s.kind === ASTEngine.SymbolKind.Constructor) return s;
+      }
+      return null;
+    };
+    const ownerIsFunctionScope = (ctx) => !!ctx && (ctx.kind === ASTEngine.SymbolKind.Function || ctx.kind === ASTEngine.SymbolKind.Method || ctx.kind === ASTEngine.SymbolKind.Constructor);
+    const isResolvableRead = (name) => {
+      if (fileScopeValues.has(name)) return true;
+      const enclosingNs = [];
+      for (let i = scopeStack.length - 1; i >= 0; i--) {
+        const s = scopeStack[i];
+        if (s.kind === ASTEngine.SymbolKind.Class || s.kind === ASTEngine.SymbolKind.Struct) {
+          const mm = classMembers.get(s.name);
+          if (mm && mm.has(name)) return true;
+        }
+        if ((s.kind === ASTEngine.SymbolKind.Function || s.kind === ASTEngine.SymbolKind.Method || s.kind === ASTEngine.SymbolKind.Constructor) && s.classScope) {
+          const mm = classMembers.get(s.classScope);
+          if (mm && mm.has(name)) return true;
+        }
+        if (s.kind === ASTEngine.SymbolKind.Namespace && s.name !== CPP_ANONYMOUS) enclosingNs.push(s.name);
+      }
+      for (const ns of enclosingNs) {
+        const nm = namespaceValues.get(ns);
+        if (nm && nm.has(name)) return true;
+      }
+      for (const used of usedNamespaces) {
+        const nm = namespaceValues.get(used);
+        if (nm && nm.has(name)) return true;
+      }
+      return false;
+    };
+    const declaredNameNode = (node) => {
+      let cur = node;
+      while (cur) {
+        if (cur.type === "identifier" || cur.type === "field_identifier") {
+          if (!isCppSpelledName(cur.text)) return null;
+          return cur;
+        }
+        if (cur.type === "function_declarator" || cur.type === "abstract_function_declarator") {
+          const inner = cur.childForFieldName?.("declarator") ?? null;
+          if (!inner || inner.type === "identifier" || inner.type === "field_identifier" || inner.type === "qualified_identifier" || inner.type === "operator_name" || inner.type === "destructor_name" || inner.type === "type_identifier") {
+            return null;
+          }
+        }
+        const viaField = cur.childForFieldName?.("declarator") ?? null;
+        let next = viaField;
+        if (!next) {
+          for (let k = 0; k < cur.namedChildCount; k++) {
+            const c = cur.namedChild(k);
+            if (c && (c.type.endsWith("declarator") || c.type === "identifier" || c.type === "field_identifier")) {
+              next = c;
+              break;
+            }
+          }
+        }
+        cur = next;
+      }
+      return null;
+    };
+    const declaredValueName = (node) => {
+      const decl = node?.childForFieldName?.("declarator") ?? null;
+      if (!decl) return null;
+      if (decl.type === "function_declarator" || decl.type === "abstract_function_declarator") {
+        const inner = decl.childForFieldName?.("declarator") ?? null;
+        if (!inner || inner.type === "identifier" || inner.type === "field_identifier" || inner.type === "qualified_identifier" || inner.type === "operator_name" || inner.type === "destructor_name") {
+          return null;
+        }
+      }
+      return declaredNameNode(decl);
+    };
+    const declaratorParamNames = (decl) => {
+      const out = [];
+      if (!decl) return out;
+      const walk = [decl];
+      while (walk.length > 0) {
+        const m = walk.pop();
+        if (m.type === "parameter_declaration") {
+          const nm = declaredNameNode(m);
+          if (nm) out.push(nm.text);
+          continue;
+        }
+        for (let k = 0; k < m.namedChildCount; k++) {
+          const c = m.namedChild(k);
+          if (c) walk.push(c);
+        }
+      }
+      return out;
+    };
+    const declaratorParameters = (decl) => {
+      const out = [];
+      if (!decl) return out;
+      const paramsNode = decl.childForFieldName?.("parameters") ?? this.findChild(decl, "parameter_list") ?? null;
+      if (!paramsNode) return out;
+      for (let i = 0; i < paramsNode.namedChildCount; i++) {
+        const p = paramsNode.namedChild(i);
+        if (!p) continue;
+        if (p.type === "comment") continue;
+        if (p.type === "variadic_parameter_declaration") continue;
+        if (p.type !== "parameter_declaration" && p.type !== "optional_parameter_declaration") continue;
+        const nameNode = declaredNameNode(p);
+        if (!nameNode) continue;
+        const cut = nameNode.startIndex - p.startIndex;
+        const type = cut > 0 ? p.text.slice(0, cut).trim() : "";
+        const param = { name: nameNode.text };
+        if (type) param.type = type;
+        const defaultNode = p.childForFieldName?.("default_value") ?? null;
+        if (defaultNode || p.type === "optional_parameter_declaration") {
+          if (defaultNode) param.defaultValue = defaultNode.text;
+          param.isOptional = true;
+        }
+        out.push(param);
+      }
+      return out;
+    };
+    const buildParamSig = (parametersNode) => {
+      if (!parametersNode) return "";
+      const parts = [];
+      for (let i = 0; i < parametersNode.namedChildCount; i++) {
+        const pc = parametersNode.namedChild(i);
+        if (!pc) continue;
+        if (pc.type === "comment") continue;
+        if (pc.type === "variadic_parameter_declaration") {
+          parts.push("...");
+          continue;
+        }
+        if (pc.type !== "parameter_declaration" && pc.type !== "optional_parameter_declaration") {
+          continue;
+        }
+        const eqAt = pc.text.indexOf("=");
+        const nameNode = declaredNameNode(pc);
+        let t = pc.text;
+        if (nameNode) {
+          const cut = nameNode.startIndex - pc.startIndex;
+          if (cut > 0) t = t.slice(0, cut);
+        } else if (eqAt !== -1) {
+          t = t.slice(0, eqAt);
+        }
+        t = t.trim();
+        if (t) parts.push(t);
+      }
+      return parts.join(",");
+    };
+    const declaredReturnType = (node, declarator) => {
+      if (declarator) {
+        const tail = this.findChild(declarator, "trailing_return_type") ?? null;
+        const td = tail ? this.findChild(tail, "type_descriptor") ?? tail.namedChild(0) : null;
+        const t = td?.text?.trim();
+        if (t) return t;
+      }
+      const typeField = node?.childForFieldName?.("type") ?? null;
+      if (!typeField) return void 0;
+      if (typeField.type === "macro_prefixed_type_specifier") return specifierTypeText(typeField);
+      const stated = collapseSpaces(typeField.text);
+      if (!stated) return void 0;
+      if (!isMacroSpelling(stated)) return stated;
+      const rejoined = phantomQualifierType(declarator?.childForFieldName?.("declarator") ?? null);
+      if (rejoined) return rejoined;
+      if (!node) return stated;
+      const displaced = this.displacedReturnType(node, declarator);
+      if (displaced) return displaced;
+      return this.recoveredDecoratorHead(node, declarator) ? void 0 : stated;
+    };
+    const buildFunctionSymbol = (node, declarator, parts) => {
+      const parameters = declaratorParameters(declarator);
+      const returnType = declaredReturnType(node, declarator);
+      const ownerName = parts.ownerName === "global" ? void 0 : parts.ownerName;
+      const decorators = parts.decorators ?? [];
+      return {
+        name: parts.name,
+        kind: parts.kind,
+        range: this.nodeToRange(node),
+        complexity: this.methodComplexityCpp(node),
+        visibility: parts.visibility || "public",
+        // Absent for a construct with no linkage of its own (a friend definition),
+        // present-and-false for every member declaration: the store reads the KEY.
+        ...parts.isStatic === void 0 ? {} : { isStatic: parts.isStatic },
+        ownerName,
+        ownerKind: ownerName === void 0 ? void 0 : parts.ownerKind,
+        ...parameters.length > 0 ? { parameters } : {},
+        ...returnType ? { returnType } : {},
+        ...decorators.length > 0 ? { decorators } : {},
+        metadata: { isCppFunction: true, ...parts.metadata }
+      };
+    };
+    const INDEX_CLASS_KINDS = /* @__PURE__ */ new Set(["class", "struct", "union"]);
+    const enclosingClassForOwner = () => {
+      for (let i = scopeStack.length - 1; i >= 0; i--) {
+        const sc = scopeStack[i];
+        if (sc.kind === ASTEngine.SymbolKind.Class || sc.kind === ASTEngine.SymbolKind.Struct || sc.kind === ASTEngine.SymbolKind.Union) return sc.name;
+        if ((sc.kind === ASTEngine.SymbolKind.Function || sc.kind === ASTEngine.SymbolKind.Method || sc.kind === ASTEngine.SymbolKind.Constructor) && sc.classScope) return sc.classScope;
+      }
+      return "";
+    };
+    const indexDeclaresMemberForOwner = (owner, leaf) => {
+      if (!indexUsable || indexResolution === null) return false;
+      const kind = indexTypeKinds.get(owner);
+      if (typeof kind !== "string" || !INDEX_CLASS_KINDS.has(kind)) return false;
+      return indexResolution.allMembers.get(owner)?.has(leaf) === true;
+    };
+    const writtenTypeCache = /* @__PURE__ */ new Map();
+    const simpleDeclName = (decl, depth = 0) => {
+      if (!decl || depth > 6) return "";
+      const t = String(decl.type);
+      if (t === "identifier" || t === "field_identifier") return decl.text.trim();
+      if (t === "init_declarator" || t === "pointer_declarator" || t === "reference_declarator" || t === "array_declarator" || t === "parenthesized_declarator" || t === "attributed_declarator") {
+        const inner = decl.childForFieldName?.("declarator") ?? decl.namedChild(Math.max(0, decl.namedChildCount - 1));
+        return simpleDeclName(inner, depth + 1);
+      }
+      return "";
+    };
+    const writtenTypesOf = (fnNode) => {
+      const cached = writtenTypeCache.get(fnNode.id);
+      if (cached !== void 0) return cached;
+      const table = /* @__PURE__ */ new Map();
+      const add = (typeNode, declNode) => {
+        if (!typeNode) return;
+        const nm = simpleDeclName(declNode);
+        if (nm === "" || !isIdentifierShapeWithDollar(nm)) return;
+        if (!table.has(nm)) table.set(nm, String(typeNode.text ?? ""));
+      };
+      const scan = (n, depth = 0) => {
+        if (!n || depth > 30) return;
+        const t = String(n.type);
+        if (t === "parameter" || t === "parameter_declaration" || t === "optional_parameter_declaration") {
+          add(n.childForFieldName?.("type"), n.childForFieldName?.("declarator"));
+          return;
+        }
+        if (t === "declaration") {
+          const typeNode = n.childForFieldName?.("type");
+          const firstDecl = n.childForFieldName?.("declarator");
+          add(typeNode, firstDecl);
+          for (let i = 0; i < n.namedChildCount; i++) {
+            const c = n.namedChild(i);
+            if (sameTsNode(c, typeNode) || sameTsNode(c, firstDecl)) continue;
+            add(typeNode, c);
+          }
+          return;
+        }
+        if (t === "for_range_loop") {
+          const typeField = n.childForFieldName?.("type");
+          const declField = n.childForFieldName?.("declarator");
+          let written = null;
+          let declared = null;
+          for (let i = 0; i < n.namedChildCount; i++) {
+            const c = n.namedChild(i);
+            if (sameTsNode(c, typeField) || sameTsNode(c, declField)) continue;
+            if (!written) {
+              written = c;
+              continue;
+            }
+            if (!declared) {
+              declared = c;
+              break;
+            }
+          }
+          add(written, declared);
+        }
+        for (let i = 0; i < n.namedChildCount; i++) scan(n.namedChild(i), depth + 1);
+      };
+      const decl = fnNode.childForFieldName?.("declarator");
+      if (decl) scan(decl);
+      const body = fnNode.childForFieldName?.("body") ?? fnNode.namedChild(fnNode.namedChildCount - 1);
+      if (body) scan(body);
+      writtenTypeCache.set(fnNode.id, table);
+      return table;
+    };
+    const writtenTypeOfReceiver = (name) => {
+      const fnScope = enclosingFunctionScope();
+      const fnNode = fnScope?.node;
+      if (!fnNode) return "";
+      return writtenTypesOf(fnNode).get(name) ?? "";
+    };
+    const typeLeafOf = (typeText) => {
+      let t = String(typeText ?? "");
+      const lt = t.indexOf("<");
+      if (lt > 0) t = t.slice(0, lt);
+      for (const kw of ["const", "volatile", "static", "typename", "struct", "class", "union", "enum"]) t = t.split(kw).join(" ");
+      t = collapseTypeNoise(t);
+      const cut = Math.max(t.lastIndexOf("::"), t.lastIndexOf(" "));
+      const leaf = (cut >= 0 ? t.slice(cut + 1) : t).trim();
+      return isIdentifierShapeWithDollar(leaf) ? leaf : "";
+    };
+    const templatePointeeOf = (typeText) => {
+      const lt = typeText.indexOf("<");
+      const gt = typeText.lastIndexOf(">");
+      if (lt < 0 || gt <= lt) return "";
+      return typeLeafOf(typeText.slice(lt + 1, gt).split(",")[0] ?? "");
+    };
+    const OWNER_WRAPPER_TYPES = /* @__PURE__ */ new Set(["unique_ptr", "shared_ptr", "weak_ptr", "auto_ptr", "optional", "reference_wrapper", "atomic"]);
+    const ownerCallLeafName = (n, depth = 0) => {
+      if (!n || depth > 6) return "";
+      const t = String(n.type);
+      if (t === "identifier" || t === "field_identifier" || t === "type_identifier") return n.text.trim();
+      if (t === "qualified_identifier") {
+        const parts = String(n.text).split("::");
+        return parts[parts.length - 1].trim();
+      }
+      if (t === "template_function" || t === "template_method") return ownerCallLeafName(n.namedChild(0), depth + 1);
+      if (t === "field_expression") return ownerCallLeafName(n.childForFieldName?.("field"), depth + 1);
+      return "";
+    };
+    const indexReceiverOwnerFacts = (callee, leaf) => {
+      if (!indexUsable || leaf === "" || !callee) return {};
+      if (callee.type === "field_expression") {
+        const obj = callee.childForFieldName?.("argument") ?? callee.namedChild(0);
+        if (!obj) return {};
+        if (obj.type === "call_expression") {
+          const innerCallee = obj.childForFieldName?.("function") ?? obj.namedChild(0);
+          const owner = ownerCallLeafName(innerCallee);
+          return owner !== "" && indexDeclaresMemberForOwner(owner, leaf) ? { owner } : {};
+        }
+        if (obj.type === "new_expression") {
+          const typeNode = obj.childForFieldName?.("type") ?? null;
+          const owner = typeNode ? typeLeafOf(String(typeNode.text ?? "")) : "";
+          return owner !== "" && indexDeclaresMemberForOwner(owner, leaf) ? { owner } : {};
+        }
+        if (obj.type === "identifier") {
+          const written = writtenTypeOfReceiver(obj.text.trim());
+          if (written === "") return {};
+          const holder = typeLeafOf(written);
+          if (OWNER_WRAPPER_TYPES.has(holder)) {
+            const pointee = templatePointeeOf(written);
+            return pointee !== "" && indexDeclaresMemberForOwner(pointee, leaf) ? { owner: pointee } : {};
+          }
+          return holder !== "" && indexDeclaresMemberForOwner(holder, leaf) ? { owner: holder } : {};
+        }
+        return {};
+      }
+      if (callee.type === "identifier") {
+        if (enclosingFunctionScope() === null) return {};
+        const enclosing = enclosingClassForOwner();
+        return enclosing !== "" && indexDeclaresMemberForOwner(enclosing, leaf) ? { owner: enclosing } : {};
+      }
+      return {};
+    };
+    while (stack.length > 0) {
+      const item = stack.pop();
+      const { node, parentContext, isExit } = item;
+      if (isExit) {
+        if (parentContext?.symbolRef && parentContext.isAbstract) {
+          parentContext.symbolRef.isAbstract = true;
+          if (parentContext.symbolRef.metadata) {
+            parentContext.symbolRef.metadata.isAbstract = true;
+          }
+        }
+        if (parentContext && scopeStack.length > 0 && scopeStack[scopeStack.length - 1] === parentContext) {
+          scopeStack.pop();
+        }
+        continue;
+      }
+      if (node.isMissing || node.hasError) {
+        if (node.type === "ERROR" || node.type === "MISSING") {
+          if (errors.length < 3) errors.push({
+            message: `Syntax ${node.type} detected`,
+            range: this.nodeToRange(node),
+            severity: "warning"
+          });
+        }
+      }
+      let newContext = parentContext;
+      const type = node.type;
+      let pushedScope = false;
+      if (type === "identifier" || type === "qualified_identifier" || type === "type_identifier") {
+        const text = node.text;
+        if (text === "std::make_unique" || text === "std::make_shared") {
+          memorySafetyScore = Math.min(100, memorySafetyScore + 5);
+        }
+      }
+      if (type === "new_expression" || type === "delete_expression") {
+        memorySafetyScore = Math.max(0, memorySafetyScore - 5);
+      }
+      if (type === "if_statement" || type === "for_statement" || type === "while_statement" || type === "do_statement" || type === "case_statement" || type === "catch_clause" || type === "conditional_expression") {
+        fileDecisions++;
+      } else if (type === "binary_expression") {
+        const op = node.childForFieldName("operator")?.text;
+        if (op === "&&" || op === "||") fileDecisions++;
+      }
+      if (type === "using_declaration") {
+        const inClass = parentContext && (parentContext.kind === ASTEngine.SymbolKind.Class || parentContext.kind === ASTEngine.SymbolKind.Struct || parentContext.kind === ASTEngine.SymbolKind.Method || parentContext.kind === ASTEngine.SymbolKind.Function || parentContext.kind === ASTEngine.SymbolKind.Constructor);
+        if (!inClass) {
+          const targetNode = this.findChild(node, "qualified_identifier") || this.findChild(node, "identifier");
+          const raw = targetNode?.text ?? "";
+          const isNamespaceForm = node.text.indexOf("using namespace") !== -1;
+          if (raw && isCppSpelledName(raw)) {
+            const segs = raw.split("::").filter(Boolean);
+            imports.push({
+              module: raw,
+              items: isNamespaceForm ? ["*"] : segs.length > 1 ? [segs[segs.length - 1]] : [raw],
+              range: this.nodeToRange(node),
+              metadata: { isImport: true, isUsingDeclaration: true, isNamespaceImport: isNamespaceForm }
+            });
+            if (!referencesSeen.has(raw)) {
+              referencesSeen.add(raw);
+              relationships.push({
+                // File-level dependency statement → source "global" (same
+                // convention as the #include references edge above).
+                source: "global",
+                target: raw,
+                type: ASTEngine.RelationshipType.References,
+                confidence: 0.9,
+                // the written path names the edge, not the `using`
+                // keyword — `using namespace\n  std;` would otherwise name the line
+                // above the module.
+                line_number: this.nodeLine(targetNode ?? node),
+                // M14-HONESTY-CONTRACT : an edge below 1.0 carries a
+                // machine-readable reason code, and `classifyEvidenceTier` defaults
+                // a MISSING confidence to 1 — so a 0.9 with no code is a number a
+                // consumer can bucket but not explain. Measured over 929 corpus
+                // files before this field existed: 625 `references` rows at 0.9 and
+                // 0 of them with a code.
+                //
+                // What the 0.9 means here, stated so it is checkable: the edge
+                // binds the NAME the source spells, and nothing inside the named
+                // module. `using std::vector;` proves a dependency on `std`; it
+                // does not prove which declaration of `vector` is meant, and this
+                // analyzer does no header-level resolution to find out.
+                metadata: {
+                  isUsingDeclaration: true,
+                  isImport: true,
+                  relationshipType: "using_dependency",
+                  reasonCode: "using-dependency-name-only"
+                }
+              });
+            }
+          }
+        }
+      } else if (type === "alias_declaration") {
+        if (ownerIsFunctionScope(parentContext)) {
+          newContext = parentContext;
+          for (let i = node.namedChildCount - 1; i >= 0; i--) {
+            const child = node.namedChild(i);
+            if (child) stack.push({ node: child, parentContext: newContext });
+          }
+          continue;
+        }
+        const nameNode = node.childForFieldName("name") || this.findChild(node, "type_identifier");
+        const name = nameNode?.text;
+        if (name && isCppSpelledName(name)) {
+          symbols.push({
+            name,
+            kind: ASTEngine.SymbolKind.Type,
+            range: this.nodeToRange(node),
+            visibility: parentContext?.visibility || "public",
+            ownerName: parentContext?.name,
+            ownerKind: parentContext?.kind,
+            // #921: the type NAME's own line (a wrapped alias writes it below).
+            metadata: { isTypeAlias: true, isUsingDeclaration: true, nameLine: this.nodeLine(nameNode) }
+          });
+        }
+      } else if (type === "type_definition" || node.text.startsWith("typedef")) {
+        if (ownerIsFunctionScope(parentContext)) {
+          newContext = parentContext;
+          for (let i = node.namedChildCount - 1; i >= 0; i--) {
+            const child = node.namedChild(i);
+            if (child) stack.push({ node: child, parentContext: newContext });
+          }
+          continue;
+        }
+        const typeId = this.findChild(node, "type_identifier");
+        if (typeId && isCppSpelledName(typeId.text)) {
+          symbols.push({
+            name: typeId.text,
+            kind: ASTEngine.SymbolKind.Type,
+            range: this.nodeToRange(node),
+            visibility: parentContext?.visibility || "public",
+            ownerName: parentContext?.name,
+            ownerKind: parentContext?.kind,
+            metadata: { isTypeAlias: true, nameLine: this.nodeLine(typeId) }
+          });
+        }
+      } else if (type === "preproc_def" || type === "preproc_function_def") {
+        const nameNode = node.childForFieldName("name");
+        const macroName = nameNode?.text?.trim();
+        if (macroName && isCppSpelledName(macroName) && !symbols.some((s) => s.name === macroName)) {
+          const isFunctionLikeMacro = type === "preproc_function_def";
+          const parameters = [];
+          if (isFunctionLikeMacro) {
+            const paramsNode = node.childForFieldName("parameters") ?? this.findChild(node, "preproc_params");
+            if (paramsNode) {
+              for (let i = 0; i < paramsNode.childCount; i++) {
+                const param = paramsNode.child(i);
+                if (param && param.isNamed) parameters.push({ name: param.text, type: "any" });
+                else if (param && (param.type === "..." || param.text === "...")) {
+                  parameters.push({ name: "...", type: "variadic", modifiers: [] });
+                }
+              }
+            }
+          }
+          symbols.push({
+            name: macroName,
+            kind: isFunctionLikeMacro ? ASTEngine.SymbolKind.Macro : ASTEngine.SymbolKind.Constant,
+            range: this.nodeToRange(node),
+            scope: "global",
+            visibility: "public",
+            parameters: isFunctionLikeMacro ? parameters : void 0,
+            metadata: { isMacro: true, isFunctionLikeMacro, nameLine: this.nodeLine(nameNode) }
+          });
+        }
+      } else if (type === "preproc_include") {
+        const text = node.text;
+        let pathNode = node.childForFieldName("path");
+        if (pathNode && pathNode.type !== "string_literal" && pathNode.type !== "system_lib_string") pathNode = null;
+        if (!pathNode) {
+          pathNode = this.findChild(node, "string_literal") ?? this.findChild(node, "system_lib_string");
+        }
+        const rawPath = (pathNode?.text ?? "").trim();
+        const includePath = pathNode ? stripIncludeChars(rawPath).trim() : "";
+        const isSystem = rawPath.startsWith("<");
+        if (includePath) {
+          imports.push({
+            module: includePath,
+            items: ["*"],
+            range: this.nodeToRange(node),
+            metadata: { isSystemInclude: isSystem, isImport: true, isIncludeDependency: true }
+          });
+        }
+        if (includePath) {
+          if (!referencesSeen.has(includePath)) {
+            referencesSeen.add(includePath);
+            const isQuotedPart = !isSystem;
+            relationships.push({
+              source: "global",
+              // ★ THE TARGET IS A SYMBOL, NOT A PATH (per the measured ruling). MEASURED before this
+              // change: emitting the PATH gave 0 resolved of 4,612 `part_of` edges — 100 % unresolved —
+              // because the arbiter resolves TARGET STRINGS AGAINST SYMBOL NAMES and has no space for a
+              // path. The contract permits either ("the part's file or its module symbol"); the symbol is
+              // the only one that can bind.
+              target: isQuotedPart ? cppPartSymbol(includePath) : includePath,
+              type: isQuotedPart ? ASTEngine.RelationshipType.PartOf : ASTEngine.RelationshipType.Imports,
+              confidence: 1,
+              // , the C lane's rule: the include directive is the
+              // source construct and its WRITTEN NAME is the path token — take
+              // that node's line, not the directive's (a multi-line include puts
+              // the path last).
+              line_number: this.nodeLine(pathNode ?? node),
+              metadata: {
+                relationshipType: isQuotedPart ? "part_of_directive" : "include_dependency",
+                isSystem,
+                isSystemInclude: isSystem,
+                // A part is NOT an import: the contract keeps `imports` and `part_of` DISTINCT, and
+                // a quoted include that also claimed `isImport` would be the second fact that can
+                // differ from the first.
+                isImport: !isQuotedPart,
+                isIncludeDependency: true,
+                // THE MANDATORY PART ROLE (src/ast/types.ts:148-160). "part" is the directive that
+                // NAMES a part (`part 'x.dart'` / `#include "x.h"`); "library" is the directive that
+                // names the library a part belongs to (`part of 'y.dart'`). C++ has only the first
+                // written form: the including unit names its fragments, never the reverse.
+                ...isQuotedPart ? {
+                  partRole: "part",
+                  partFile: true,
+                  isQuotedInclude: true,
+                  // THE PATH IS EVIDENCE, THE STEM IS THE TARGET. Keeping both is what makes the
+                  // difference between them checkable rather than a reader's inference.
+                  partPath: cppPartTargetPath(filePath, includePath),
+                  partSymbol: cppPartSymbol(includePath)
+                } : {},
+                // THE SPECIFIER IS KEPT BESIDE THE PATH: the path is what might resolve, the
+                // specifier is what was WRITTEN, and only one of them is evidence.
+                specifier: includePath,
+                module: includePath,
+                fileLevel: true
+              }
+            });
+          }
+        }
+        const lowerText = text.toLowerCase();
+        if (stringIncludes(lowerText, "memory") || stringIncludes(lowerText, "unique_ptr") || stringIncludes(lowerText, "shared_ptr")) {
+          patterns["RAII"] = true;
+          patterns["Smart Pointers"] = true;
+        }
+        if (stringIncludes(lowerText, "qt") || stringIncludes(lowerText, "qobject") || stringIncludes(lowerText, "qstring") || stringIncludes(lowerText, "qwidget"))
+          frameworks["Qt"] = true;
+        if (stringIncludes(lowerText, "iostream") || stringIncludes(lowerText, "vector") || stringIncludes(lowerText, "algorithm"))
+          frameworks["stl"] = true;
+        if (stringIncludes(lowerText, "windows.h")) frameworks["win32"] = true;
+      }
+      if (type === "auto") patterns["auto"] = true;
+      if (type === "lambda_expression") patterns["lambda"] = true;
+      if (this.hasDirectModifier(node, "constexpr")) patterns["constexpr"] = true;
+      if (type === "access_specifier") {
+        if (parentContext) {
+          const t = node.text.replace(":", "").trim();
+          if (t === "public" || t === "private" || t === "protected") {
+            parentContext.visibility = t;
+          }
+        }
+      }
+      if (type === "namespace_definition") {
+        const name = this.childText(node, "namespace_identifier") || CPP_ANONYMOUS;
+        if (name === CPP_ANONYMOUS || !isCppSpelledName(name)) {
+          newContext = parentContext;
+          for (let i = node.namedChildCount - 1; i >= 0; i--) {
+            const child = node.namedChild(i);
+            if (child) stack.push({ node: child, parentContext: newContext });
+          }
+          continue;
+        }
+        symbols.push({
+          name,
+          kind: ASTEngine.SymbolKind.Namespace,
+          range: this.nodeToRange(node),
+          visibility: "public",
+          metadata: { isCppNamespace: true, fullName: this.buildFullName(scopeStack, name) }
+        });
+        newContext = {
+          node,
+          name,
+          kind: ASTEngine.SymbolKind.Namespace,
+          visibility: "public",
+          isTemplate: false,
+          isAbstract: false,
+          friends: []
+        };
+        scopeStack.push(newContext);
+        pushedScope = true;
+      } else if (type === "class_specifier" || type === "struct_specifier" || type === "union_specifier") {
+        let bodyNode = this.findChild(node, "field_declaration_list");
+        if (!bodyNode) {
+          const decorated = macroDecoratedClassDecl(node);
+          if (decorated) {
+            const ownerName = parentContext?.name;
+            const decorBases = [];
+            for (const b of decorated.bases) {
+              const target = extendsTargetName(b.text, decorated.name);
+              if (!target) continue;
+              decorBases.push(target);
+              relationships.push({
+                source: decorated.name,
+                target,
+                type: ASTEngine.RelationshipType.Extends,
+                confidence: 1,
+                line_number: this.nameLine(b),
+                metadata: { nodeType: b.type, macroDecoratedHead: true, ...indexBaseFacts(target) }
+              });
+            }
+            classBases.set(decorated.name, decorBases);
+            const decorMacro = node.childForFieldName?.("name")?.text?.trim() ?? "";
+            if (decorMacro && cppExportMarker(decorMacro)) {
+              const ek = `exports::${decorated.name}::${decorMacro}`;
+              if (!exportsSeen.has(ek)) {
+                exportsSeen.add(ek);
+                relationships.push({
+                  source: decorated.name,
+                  target: decorMacro,
+                  type: ASTEngine.RelationshipType.Exports,
+                  confidence: 1,
+                  line_number: this.nodeLine(node),
+                  metadata: { relationshipType: "module_export", exportMacro: decorMacro, reasonCode: "export-marker-in-specifier" }
+                });
+              }
+            }
+            const decoratedSym = {
+              name: decorated.name,
+              kind: ASTEngine.SymbolKind.Class,
+              range: {
+                startLine: node.startPosition.row + 1,
+                startColumn: node.startPosition.column + 1,
+                endLine: decorated.body.endPosition.row + 1,
+                endColumn: decorated.body.endPosition.column + 1,
+                startIndex: node.startIndex,
+                endIndex: decorated.body.endIndex
+              },
+              ...ownerName ? { ownerName, ownerKind: parentContext?.kind } : { scope: "global" },
+              visibility: parentContext?.visibility || "public",
+              metadata: {
+                isCppClass: true,
+                isTemplate: false,
+                nameLine: this.nodeLine(decorated.nameNode),
+                macroDecoratedHead: node.childForFieldName?.("name")?.text?.trim() ?? "",
+                baseClasses: decorated.bases.map((b) => extendsTargetName(b.text, decorated.name)).filter((x) => !!x)
+              }
+            };
+            symbols.push(decoratedSym);
+            newContext = {
+              node: decorated.owner,
+              name: decorated.name,
+              kind: ASTEngine.SymbolKind.Class,
+              visibility: "public",
+              isTemplate: false,
+              isAbstract: false,
+              friends: [],
+              symbolRef: decoratedSym,
+              locals: /* @__PURE__ */ new Set()
+            };
+            pushedScope = true;
+            stack.push({ node: decorated.owner, parentContext: newContext, isExit: true });
+            stack.push({ node: decorated.body, parentContext: newContext });
+            continue;
+          }
+          newContext = parentContext;
+          for (let i = node.namedChildCount - 1; i >= 0; i--) {
+            const child = node.child(i);
+            if (child) stack.push({ node: child, parentContext: newContext });
+          }
+          continue;
+        }
+        const name = this.childText(node, "type_identifier") || // D7 arm A: a `class`/`struct` may have a QUALIFIED name (an explicit
+        // specialization, `template <> struct fmt::formatter<T> : formatter<U>
+        // { … }`), which the direct-child `type_identifier` scan cannot see, so
+        // the class published as `anonymous` — the no-name sentinel. The rule
+        // is CPPD1's leaf, read off the grammar's `name` field.
+        specifierDeclaredName(node) || (() => {
+          const tt = this.findChild(node, "template_type");
+          if (tt) {
+            const tn = tt.childForFieldName?.("name") || this.findChild(tt, "type_identifier") || this.findChild(tt, "qualified_identifier");
+            if (tn?.text) return tn.text;
+            const lt = tt.text.indexOf("<");
+            return lt > 0 ? tt.text.slice(0, lt).trim() : null;
+          }
+          return null;
+        })() || CPP_ANONYMOUS;
+        const kind = ASTEngine.SymbolKind.Class;
+        const defaultVis = type === "class_specifier" ? "private" : "public";
+        if (name === CPP_ANONYMOUS) {
+          newContext = parentContext;
+          for (let i = node.namedChildCount - 1; i >= 0; i--) {
+            const child = node.namedChild(i);
+            if (child) stack.push({ node: child, parentContext: newContext });
+          }
+          continue;
+        }
+        if (!isCppSpelledName(name)) {
+          newContext = parentContext;
+          for (let i = node.namedChildCount - 1; i >= 0; i--) {
+            const child = node.namedChild(i);
+            if (child) stack.push({ node: child, parentContext: newContext });
+          }
+          continue;
+        }
+        const isTemplate = node.parent?.type === "template_declaration";
+        newContext = { node, name, kind, visibility: defaultVis, isTemplate, isAbstract: false, friends: [] };
+        scopeStack.push(newContext);
+        pushedScope = true;
+        const baseClasses = [];
+        const baseClause = this.findChild(node, "base_class_clause");
+        if (baseClause) {
+          for (let i = 0; i < baseClause.namedChildCount; i++) {
+            const bc = baseClause.namedChild(i);
+            if (!bc || bc.type === "access_specifier") continue;
+            const typeNode = this.findChild(bc, "type_identifier") || this.findChild(bc, "qualified_identifier") || this.findChild(bc, "template_type") || bc;
+            const target = extendsTargetName(typeNode.text, name);
+            if (target) {
+              baseClasses.push(target);
+              relationships.push({
+                source: name,
+                target,
+                type: ASTEngine.RelationshipType.Extends,
+                confidence: 1,
+                // a type expression's start is not always the
+                // line of the names inside it (a specifier starts at its
+                // KEYWORD) — `nameLine` prefers the grammar's `name` field.
+                line_number: this.nameLine(typeNode),
+                metadata: { nodeType: typeNode.type, ...indexBaseFacts(target) }
+              });
+              pendingImplements.push({ derived: name, base: target, line: this.nameLine(typeNode) ?? 1 });
+            }
+          }
+          classBases.set(name, [...baseClasses]);
+        }
+        const sym = {
+          name,
+          kind: ASTEngine.SymbolKind.Class,
+          range: this.nodeToRange(node),
+          visibility: parentContext?.visibility || "public",
+          ownerName: parentContext?.name,
+          ownerKind: parentContext?.kind,
+          metadata: {
+            isCppClass: true,
+            isTemplate,
+            baseClasses,
+            // #921: the class NAME's own line (`template <…>` puts it below).
+            nameLine: this.nameLine(node)
+          }
+        };
+        symbols.push(sym);
+        newContext.symbolRef = sym;
+        {
+          const spelling = this.exportAttributeSpelling(node);
+          if (spelling) {
+            pendingExports.push({
+              name,
+              owner: parentContext?.name ?? null,
+              line: this.nameLine(node) ?? 1,
+              spelling
+            });
+          }
+        }
+      } else if (type === "compound_statement" && enclosingFunctionScope() === null && macroDeclaredBody(node) && // D8: a trailing ANNOTATION's body reaches this branch looking exactly like
+      // a macro-declared heading's body, and publishing it here is what produced
+      // `function GTEST_LOCK_EXCLUDED_(mutex_)` with `expandedFrom:
+      // "macro-heading"` — a symbol for a macro, carrying the REAL function's
+      // statements. The `function_definition` branch refuses the annotation
+      // itself; this is the second half of the same suppression, because the body
+      // is a SEPARATE node and arrives here on its own.
+      //
+      // The body's statements are still walked (the branch is only skipped, not
+      // the subtree), so its reads keep a real owner instead of a macro's.
+      !this.isTrailingAnnotationMacro(node.parent, content)) {
+        const rec = macroDeclaredBody(node);
+        const headingText = macroInvocationText(content, rec.nameNode.startIndex);
+        if (headingText) {
+          const headingRange = this.nodeToRange(rec.heading);
+          const sym = {
+            name: headingText,
+            kind: ASTEngine.SymbolKind.Function,
+            range: {
+              ...headingRange,
+              endLine: node.endPosition.row + 1,
+              endColumn: node.endPosition.column + 1,
+              endIndex: node.endIndex
+            },
+            visibility: "public",
+            metadata: {
+              isCppFunction: false,
+              expandedFrom: "macro-heading",
+              macroName: rec.macroName,
+              headingText
+            }
+          };
+          symbols.push(sym);
+          newContext = {
+            node,
+            name: headingText,
+            kind: ASTEngine.SymbolKind.Function,
+            visibility: "public",
+            isTemplate: false,
+            isAbstract: false,
+            friends: [],
+            symbolRef: sym,
+            locals: /* @__PURE__ */ new Set()
+          };
+          scopeStack.push(newContext);
+          pushedScope = true;
+        }
+      } else if (type === "enum_specifier") {
+        const enumNameNode = node.childForFieldName("name") || this.findChild(node, "type_identifier");
+        const displaced = attributeDisplacedEnumName(node);
+        const name = displaced || this.childText(node, "type_identifier") || specifierDeclaredName(node) || CPP_ANONYMOUS;
+        if (name === CPP_ANONYMOUS || !isCppSpelledName(name)) {
+          newContext = parentContext;
+          for (let i = node.namedChildCount - 1; i >= 0; i--) {
+            const child = node.namedChild(i);
+            if (child) stack.push({ node: child, parentContext: newContext });
+          }
+          continue;
+        }
+        let isEnumClass = false;
+        for (let i = 0; i < node.childCount; i++) {
+          const child = node.child(i);
+          if (child && (child.text === "class" || child.text === "struct")) {
+            isEnumClass = true;
+            break;
+          }
+        }
+        symbols.push({
+          name,
+          kind: ASTEngine.SymbolKind.Enum,
+          range: this.nodeToRange(node),
+          visibility: parentContext?.visibility || "public",
+          ownerName: parentContext?.name,
+          ownerKind: parentContext?.kind,
+          metadata: { isCppEnum: true, isEnumClass, isScopedEnum: isEnumClass, nameLine: this.nodeLine(enumNameNode) }
+        });
+        newContext = {
+          node,
+          name,
+          kind: ASTEngine.SymbolKind.Enum,
+          visibility: "public",
+          isTemplate: false,
+          isAbstract: false,
+          friends: []
+        };
+        scopeStack.push(newContext);
+        pushedScope = true;
+      } else if (type === "function_definition" || type === "field_declaration" || type === "declaration") {
+        const friendDecl = enclosingFriendDeclaration(node);
+        if (friendDecl) {
+          const friendDefines = type === "function_definition";
+          const friendDetails = friendDefines ? this.getFunctionDetails(node) : null;
+          if (friendDetails && !friendDetails.isDestructor && !this.isMacroFunctionShape(node, friendDetails.name)) {
+            const owner = friendBodyOwner(scopeStack, friendDecl);
+            const fnDeclarator2 = friendDetails.declarator;
+            const sym = buildFunctionSymbol(node, fnDeclarator2, {
+              name: friendDetails.name,
+              kind: ASTEngine.SymbolKind.Function,
+              visibility: parentContext?.visibility,
+              // `global` (nothing published encloses the class) is the sentinel the
+              // builder turns into "no owner": the friend belongs to the FILE then.
+              ownerName: owner.name,
+              ownerKind: owner.kind,
+              metadata: {
+                isCppFriendDefinition: true,
+                isDestructor: false,
+                isOperatorOverload: friendDetails.isOperator,
+                // The friend's OWN template parameter list hangs one level higher
+                // than a member's: `template_declaration > friend_declaration >
+                // function_definition`, not `template_declaration >
+                // function_definition`. The outer class's template is the CLASS
+                // symbol's `isTemplate`, not this function's.
+                isTemplate: node.parent?.type === "template_declaration" || friendDecl.parent?.type === "template_declaration",
+                nameLine: this.nodeLine(friendDetails.nameNode)
+              }
+            });
+            symbols.push(sym);
+            newContext = {
+              node,
+              name: friendDetails.name,
+              kind: ASTEngine.SymbolKind.Function,
+              visibility: "public",
+              isTemplate: false,
+              isAbstract: false,
+              friends: [],
+              symbolRef: sym,
+              locals: new Set(declaratorParamNames(fnDeclarator2))
+            };
+            scopeStack.push(newContext);
+            pushedScope = true;
+            stack.push({ node, parentContext: newContext, isExit: true });
+          } else {
+            newContext = parentContext;
+            if (friendDefines) {
+              const outer = friendBodyOwner(scopeStack, friendDecl);
+              newContext = { ...parentContext, node: outer.node, name: outer.name, kind: outer.kind };
+            }
+          }
+          for (let i = node.namedChildCount - 1; i >= 0; i--) {
+            const child = node.namedChild(i);
+            if (child) stack.push({ node: child, parentContext: newContext });
+          }
+          continue;
+        }
+        const funcDetails = this.getFunctionDetails(node);
+        const fnDeclarator = funcDetails?.declarator ?? null;
+        const cppDecorators = this.declarationDecorators(node, fnDeclarator);
+        let isStatic = cppDecorators.includes("static");
+        let isConstexpr = cppDecorators.includes("constexpr");
+        let isConst = cppDecorators.includes("const");
+        let isVirtual = cppDecorators.includes("virtual") || cppDecorators.includes("override");
+        if (type === "function_definition" && this.isTrailingAnnotationMacro(node, content)) {
+          for (let i = node.namedChildCount - 1; i >= 0; i--) {
+            const child = node.namedChild(i);
+            if (child) stack.push({ node: child, parentContext });
+          }
+          continue;
+        }
+        if (type === "function_definition" && isMacroDecoratedClassFunction(node)) {
+          for (let i = node.namedChildCount - 1; i >= 0; i--) {
+            const child = node.namedChild(i);
+            if (!child || child.type === "compound_statement") continue;
+            stack.push({ node: child, parentContext });
+          }
+          continue;
+        }
+        if (type === "function_definition" && this.returnTypeIsClassDefinition(node)) {
+          for (let i = node.namedChildCount - 1; i >= 0; i--) {
+            const child = node.namedChild(i);
+            if (child) stack.push({ node: child, parentContext });
+          }
+          continue;
+        }
+        if (funcDetails) {
+          const { name: funcName, scope: explicitScope, isDestructor, isOperator, nameNode: funcNameNode } = funcDetails;
+          const ownerIsFunction = ownerIsFunctionScope(parentContext);
+          if (funcDetails) {
+            const marker = this.specifierExportMacro(node.childForFieldName?.("type") ?? null);
+            if (marker && cppExportMarker(marker) && isCppSpelledName(funcName)) {
+              const ek = `exports::${funcName}::${marker}`;
+              if (!exportsSeen.has(ek)) {
+                exportsSeen.add(ek);
+                relationships.push({
+                  source: funcName,
+                  target: marker,
+                  type: ASTEngine.RelationshipType.Exports,
+                  confidence: 1,
+                  line_number: this.nodeLine(funcNameNode ?? node),
+                  metadata: {
+                    relationshipType: "module_export",
+                    exportMacro: marker,
+                    reasonCode: "export-marker-in-specifier"
+                  }
+                });
+              }
+            }
+          }
+          if (ownerIsFunction && !explicitScope) {
+            const fnScope = enclosingFunctionScope();
+            if (fnScope && isCppSpelledName(funcName)) {
+              if (!fnScope.locals) fnScope.locals = /* @__PURE__ */ new Set();
+              fnScope.locals.add(funcName);
+            }
+            newContext = parentContext;
+            for (let i = node.namedChildCount - 1; i >= 0; i--) {
+              const child = node.namedChild(i);
+              if (child) stack.push({ node: child, parentContext: newContext });
+            }
+            continue;
+          }
+          if (!isDestructor && this.isMacroFunctionShape(node, funcName)) {
+            const annotation = this.isTrailingAnnotationMacro(node, content);
+            const macroHeading = annotation ? null : this.macroHeadingText(node, content, funcName);
+            let sym2 = null;
+            if (macroHeading) {
+              sym2 = {
+                name: macroHeading,
+                kind: ASTEngine.SymbolKind.Function,
+                range: this.nodeToRange(node),
+                visibility: "public",
+                metadata: {
+                  isCppFunction: false,
+                  expandedFrom: "macro-heading",
+                  macroName: funcName,
+                  headingText: macroHeading
+                }
+              };
+              symbols.push(sym2);
+            }
+            newContext = {
+              node,
+              name: macroHeading ?? "",
+              kind: ASTEngine.SymbolKind.Function,
+              visibility: "public",
+              isTemplate: false,
+              isAbstract: false,
+              friends: [],
+              ...sym2 ? { symbolRef: sym2 } : {},
+              locals: /* @__PURE__ */ new Set()
+            };
+            scopeStack.push(newContext);
+            pushedScope = true;
+            stack.push({ node, parentContext: newContext, isExit: true });
+            for (let i = node.namedChildCount - 1; i >= 0; i--) {
+              const child = node.namedChild(i);
+              if (child) stack.push({ node: child, parentContext: newContext });
+            }
+            continue;
+          }
+          const actualOwnerName = explicitScope || parentContext?.name;
+          const actualOwnerKind = explicitScope ? ASTEngine.SymbolKind.Class : parentContext?.kind;
+          const isConstructor = actualOwnerName === funcName && actualOwnerKind === ASTEngine.SymbolKind.Class;
+          const isPureVirtual = cppPureVirtualDeclaration(node);
+          if (isPureVirtual && parentContext && parentContext.name === actualOwnerName) {
+            parentContext.isAbstract = true;
+          }
+          const isTemplate = node.parent?.type === "template_declaration";
+          const kind = isConstructor ? ASTEngine.SymbolKind.Constructor : actualOwnerKind === ASTEngine.SymbolKind.Class ? ASTEngine.SymbolKind.Method : ASTEngine.SymbolKind.Function;
+          const sym = buildFunctionSymbol(node, fnDeclarator, {
+            name: isConstructor ? "constructor" : funcName,
+            kind,
+            // CP3 (cpp review, HC1 parity): file-scope `static` (internal linkage) is
+            // private. Class-member `static` is NOT internal linkage — members keep
+            // their access-specifier visibility.
+            visibility: isStatic && actualOwnerKind !== ASTEngine.SymbolKind.Class ? "private" : parentContext?.visibility,
+            isStatic,
+            ownerName: actualOwnerName,
+            ownerKind: actualOwnerKind,
+            decorators: cppDecorators,
+            metadata: {
+              isTemplate,
+              isVirtual,
+              isPureVirtual,
+              isConst,
+              isStatic,
+              isConstexpr,
+              isConstructor,
+              isDestructor,
+              isOperatorOverload: isOperator,
+              // #612 store-phase: DECLARATION vs DEFINITION. This branch is reached for
+              // all three node types that can name a function, and the type itself is
+              // the whole discriminator — the grammar parses a body as
+              // `function_definition` and a prototype (file-scope `int f(void);`, an
+              // in-class `int f();`, a field declaration) as
+              // `declaration`/`field_declaration`. Without this key the only signal the
+              // store had was the symbol NAME, so a cpp header prototype competed on
+              // equal footing with the .cpp definition in another file and name
+              // resolution could pick the prototype.
+              ...type === "function_definition" ? {} : { isDeclaration: true },
+              // #921 (M60): the line the declared NAME is written on. A wrapped return
+              // type puts it below the declaration's start (`void NORETURN` then
+              // `CheckFailed(const char *file, …)`), and the containment edge this
+              // symbol may own has to name THAT line — the rule every other
+              // relationship type already follows. Absent when the tree gives no name
+              // node (the containment edge then falls back to the symbol range, which
+              // is the pre-#921 behaviour).
+              nameLine: this.nodeLine(funcNameNode)
+            }
+          });
+          if (!isConstructor && kind === ASTEngine.SymbolKind.Method && parentContext?.kind === ASTEngine.SymbolKind.Class && funcName !== parentContext.name) {
+            const decl2 = this.functionDeclaratorOf(node);
+            const paramsNode = decl2?.childForFieldName("parameters") ?? null;
+            const normParams = buildParamSig(paramsNode);
+            const sigs = classVirtuals.get(parentContext.name) ?? /* @__PURE__ */ new Map();
+            const prev = sigs.get(funcName) ?? [];
+            if (!prev.includes(normParams)) sigs.set(funcName, [...prev, normParams]);
+            else sigs.set(funcName, prev);
+            classVirtuals.set(parentContext.name, sigs);
+            if (this.isPureVirtualDeclaration(node)) {
+              const pure = classPureVirtuals.get(parentContext.name) ?? /* @__PURE__ */ new Set();
+              pure.add(funcName);
+              classPureVirtuals.set(parentContext.name, pure);
+            }
+            const overrideKeyword = this.functionOverrideSpecifier(node);
+            if ((classBases.get(parentContext.name)?.length ?? 0) > 0) {
+              pendingOverrides.push({
+                cls: parentContext.name,
+                method: funcName,
+                params: normParams,
+                line: this.nodeLine(node),
+                ...overrideKeyword ? { keyword: overrideKeyword } : {}
+              });
+            }
+          }
+          {
+            const spelling = this.exportAttributeSpelling(node);
+            if (spelling) {
+              const owner = parentContext && parentContext.kind !== ASTEngine.SymbolKind.Function ? parentContext.name : null;
+              pendingExports.push({
+                name: funcName,
+                owner,
+                line: this.nodeLine(funcNameNode ?? node) ?? 1,
+                spelling
+              });
+            }
+          }
+          symbols.push(sym);
+          if (type === "function_definition") {
+            newContext = {
+              node,
+              // CPPD9 (deep review 2026-09-05): the scope NAME must match the
+              // emitted symbol name. Constructors were pushed as the raw
+              // class name (`Engine`) while their symbol was normalized to
+              // "constructor" — so ctor-body calls emitted source=Engine (the
+              // Class symbol) instead of the Constructor symbol, and the
+              // qualified_calls payload never reached the constructor. The
+              // family contract (groovy/java/csharp) scopes ctors under the
+              // normalized "constructor" name, which is why the scope takes the
+              // name off the SYMBOL rather than keeping a second copy of it.
+              name: sym.name,
+              kind,
+              visibility: "public",
+              isTemplate: false,
+              isAbstract: false,
+              friends: [],
+              symbolRef: sym,
+              // CP5: out-of-line class scope for member resolution.
+              classScope: explicitScope,
+              // CP1: parameters bind at function entry (flow-sensitive
+              // shadowing like the C family — reads before any local
+              // binding still resolve outward).
+              locals: new Set(declaratorParamNames(this.findChild(node, "function_declarator")))
+            };
+            scopeStack.push(newContext);
+            pushedScope = true;
+          }
+        } else if (type === "field_declaration" || type === "declaration") {
+          const decls = this.findAllChildren(node, "init_declarator");
+          if (decls.length === 0) {
+            if (declaredValueName(node)) decls.push(node);
+          }
+          for (let idx = 0; idx < decls.length; idx++) {
+            const d = decls[idx];
+            const idNode = recoveredDeclaredName(d) ?? (d.type === "init_declarator" ? declaredNameNode(d) : declaredValueName(d));
+            const name = idNode ? idNode.text : "";
+            const isDisplacedEnumName = (() => {
+              const holder = d.type === "init_declarator" ? d.parent ?? null : d;
+              const tf = holder?.childForFieldName?.("type") ?? null;
+              if (!tf || tf.type !== "enum_specifier") return false;
+              return attributeDisplacedEnumName(tf) === name;
+            })();
+            const insideFunction = parentContext && (parentContext.kind === ASTEngine.SymbolKind.Function || parentContext.kind === ASTEngine.SymbolKind.Method || parentContext.kind === ASTEngine.SymbolKind.Constructor);
+            if (name && insideFunction) {
+              const fnScope = enclosingFunctionScope();
+              if (fnScope) {
+                if (!fnScope.locals) fnScope.locals = /* @__PURE__ */ new Set();
+                fnScope.locals.add(name);
+              }
+            }
+            if (name && !isDisplacedEnumName && !stringIncludes(name, "(") && !insideFunction && !this.isBareMacroDeclaration(node, name)) {
+              const visStatic = isStatic && parentContext?.kind !== ASTEngine.SymbolKind.Class ? "private" : void 0;
+              const declDecorators = this.declarationDecorators(node, this.findChild(node, "function_declarator"));
+              symbols.push({
+                name,
+                kind: isConstexpr ? ASTEngine.SymbolKind.Constant : parentContext?.kind === ASTEngine.SymbolKind.Class ? ASTEngine.SymbolKind.Property : ASTEngine.SymbolKind.Variable,
+                range: this.nodeToRange(d),
+                visibility: visStatic || parentContext?.visibility || "public",
+                isStatic,
+                ownerName: parentContext?.name,
+                ownerKind: parentContext?.kind,
+                ...declDecorators.length > 0 ? { decorators: declDecorators } : {},
+                metadata: {
+                  isConstexpr,
+                  isStatic,
+                  isConst,
+                  // #921: the declared NAME's own line — `struct { … } options;`
+                  // and a wrapped type both write it below the declaration start.
+                  nameLine: this.nodeLine(idNode)
+                }
+              });
+            }
+          }
+        }
+      } else if (type === "enumerator") {
+        const enumeratorNameNode = node.childForFieldName("name") || this.findChild(node, "identifier");
+        const name = this.childText(node, "identifier");
+        if (name && isCppSpelledName(name)) {
+          const fnScope = enclosingFunctionScope();
+          if (fnScope && scopeStack.length > 0) {
+            if (this.insideFunctionBody(node.parent)) {
+              if (!fnScope.locals) fnScope.locals = /* @__PURE__ */ new Set();
+              fnScope.locals.add(name);
+            }
+          }
+          symbols.push({
+            name,
+            kind: ASTEngine.SymbolKind.EnumMember,
+            range: this.nodeToRange(node),
+            visibility: "public",
+            ownerName: parentContext?.name,
+            ownerKind: parentContext?.kind,
+            metadata: { isCppEnumMember: true, nameLine: this.nodeLine(enumeratorNameNode) }
+          });
+        }
+      } else if (type === "field_expression") {
+        const field = node.childForFieldName("field");
+        const obj = node.childForFieldName("argument") || node.namedChild(0);
+        const pType = node.parent?.type;
+        const lhsAssign = pType === "assignment_expression" && node.parent?.namedChild(0) && node.parent.namedChild(0).startIndex === node.startIndex;
+        if (field && field.text.trim() && isCppSpelledName(field.text) && pType !== "call_expression" && !lhsAssign) {
+          const source = parentContext?.name || "global";
+          const relKey = `${source}::uses::${field.text}`;
+          if (!usesSeen.has(relKey)) {
+            usesSeen.add(relKey);
+            relationships.push({
+              source,
+              target: field.text,
+              type: ASTEngine.RelationshipType.Uses,
+              confidence: 0.9,
+              // / #870: the FIELD LEAF names this edge. This row
+              // carried no line at all, which is the #870 measurement (a member
+              // read reported at line 0 in the fmt lane).
+              line_number: this.nodeLine(field),
+              // M14-HONESTY-CONTRACT , and the code says what the 0.9 means:
+              // the edge states that THIS SCOPE READS a member with this name, and
+              // the RECEIVER'S TYPE is not resolved — nothing here carries C++ type
+              // inference, so which class declares the member is unknown and a
+              // same-named member on an unrelated class is indistinguishable from
+              // the intended one. Measured before this field existed: 3,012 `uses`
+              // rows at 0.9, none carrying a code.
+              metadata: {
+                relationshipType: "field_access",
+                accessedFrom: obj?.text,
+                reasonCode: "member-read-receiver-type-unresolved"
+              }
+            });
+          }
+        }
+      } else if (type === "call_expression") {
+        const funcNode = node.childForFieldName("function") || node.namedChild(0);
+        if (funcNode) {
+          let targetName = funcNode.text;
+          let qualifiedName = targetName;
+          const NAME_BEARING = (t) => t === "identifier" || t === "field_identifier" || t === "type_identifier" || t === "operator_name" || t === "destructor_name" || t === "namespace_identifier";
+          const calleeLeafNode = (n) => {
+            let cur = n;
+            let guard = 0;
+            while (cur && guard++ < 8) {
+              const t = cur.type;
+              if (t === "field_expression") {
+                const f = cur.childForFieldName("field") ?? cur.namedChild(cur.namedChildCount - 1);
+                if (!f) return null;
+                cur = f;
+                continue;
+              }
+              if (t === "template_function" || t === "template_method") {
+                const base = cur.namedChild(0);
+                if (!base) return null;
+                cur = base;
+                continue;
+              }
+              if (t === "dependent_name" && cur.namedChildCount >= 1) {
+                const inner = cur.namedChild(0);
+                if (inner && (inner.type === "template_method" || inner.type === "template_function" || inner.type === "identifier" || inner.type === "field_identifier")) {
+                  cur = inner;
+                  continue;
+                }
+                return null;
+              }
+              if (t === "qualified_identifier" && cur.namedChildCount >= 1) {
+                cur = cur.namedChild(cur.namedChildCount - 1);
+                continue;
+              }
+              if (t === "parenthesized_expression" && cur.namedChildCount >= 1) {
+                cur = cur.namedChild(0);
+                continue;
+              }
+              if (!NAME_BEARING(t)) return null;
+              if (t === "identifier" && !isCppSpelledName(cur.text)) return null;
+              return cur;
+            }
+            return null;
+          };
+          const calleeLeaf = (n) => calleeLeafNode(n)?.text ?? "";
+          let calleeSite = calleeLeafNode(funcNode);
+          if (funcNode.type === "field_expression") {
+            const field = funcNode.childForFieldName("field");
+            const obj = funcNode.childForFieldName("argument") || funcNode.namedChild(0);
+            if (field) {
+              targetName = calleeLeaf(field);
+              qualifiedName = obj ? `${obj.text}.${field.text}` : field.text;
+              calleeSite = calleeLeafNode(field);
+            }
+          } else {
+            targetName = calleeLeaf(funcNode);
+            qualifiedName = funcNode.text;
+          }
+          const source = parentContext?.name || "global";
+          const calleeIsTempCall = funcNode.type === "call_expression";
+          const calleeIsUnnamed = calleeSite === null;
+          const calleeIsError = !!funcNode.hasError;
+          const ownerIsTypeScope = parentContext?.kind === ASTEngine.SymbolKind.Class || parentContext?.kind === ASTEngine.SymbolKind.Struct;
+          const classCallingItself = ownerIsTypeScope && parentContext?.name === targetName;
+          if (!targetName.startsWith("operator") && !calleeIsTempCall && !calleeIsUnnamed && !calleeIsError && !classCallingItself) {
+            relationships.push({
+              source,
+              target: targetName,
+              fromSymbol: source,
+              toSymbol: qualifiedName,
+              type: ASTEngine.RelationshipType.Calls,
+              // M14 ONTOLOGY (this round), question 6 ("is `confidence` right?").
+              // This row carried NO `confidence` at all, and it is the largest edge
+              // family in the lane: measured 101,340 `calls` rows over 929 corpus
+              // files, every one of them `undefined`, against a documentation
+              // table that claimed 1.0. A consumer reading `rel.confidence` got
+              // `undefined` on three quarters of the lane's output, and
+              // `classifyEvidenceTier` papered over it by defaulting a missing
+              // value to 1 — so the missing field was invisible from inside the
+              // analyzer and from the evidence tier at the same time.
+              //
+              // 1.0 is the honest value, and it is not a claim that the CALLEE is
+              // the function the author meant: it is a claim about what the edge
+              // IS. A `call_expression` whose callee leaf is a name is a
+              // deterministic AST fact, which is why `uses`/`extends`/
+              // `instantiates`/`references` all publish a number for the same kind
+              // of edge. Which overload a bare name selects is recorded separately
+              // and honestly, in `metadata.qualified` (the full callee path) — it
+              // is not a confidence question.
+              confidence: 1,
+              // / M60.P1 (#873): ONE line, ONE base, ONE node. The
+              // row's `line_number` is the callee leaf's line (the node that
+              // names the edge) and the metadata mirror repeats THAT value
+              // instead of the call node's — a mirror that named a different
+              // node would make "the row's line" ambiguous again, which is what
+              // #873 was about. Base stays 1-based (R6).
+              line_number: this.nodeLine(calleeSite),
+              // task-22 (flag-gated): the project index's declaration facts for this callee. Empty
+              // object = flag off / incomplete index, so the row is byte-identical to the verdict.
+              metadata: {
+                line: this.nodeLine(calleeSite),
+                qualified: qualifiedName,
+                ...indexCallFacts(targetName),
+                // task-22: a QUALIFIED callee names its owner syntactically; the owner channel can
+                // resolve the row through it. Emitted only under the flag + a complete index + the
+                // index agreeing the class-like owner DECLARES the member.
+                ...indexOwnerFacts(qualifiedName, targetName),
+                // task-22 milestone 5: the three declaration-bearing RECEIVER classes (constructor-temp,
+                // typed-local, implicit-this). Empty for opaque receivers — the owner is never guessed.
+                ...indexReceiverOwnerFacts(funcNode, targetName),
+                // ISO C++ citation claim (Lead vocabulary `iso-cpp-stdlib`, flag-gated): ONLY a listed
+                // symbol whose own spelling root is std; verified by the arbiter as extOK, never resolved.
+                ...cppCitationFacts(qualifiedName, targetName),
+                // The package-scope claim (flag-gated): the callee is a member of a dependency the
+                // GOVERNING MANIFEST declares, on the evidence of the translation unit's external
+                // include roots. The package name carried is the MANIFEST'S OWN SPELLING, so the
+                // arbiter's exact-match verification holds and the claim cannot refute itself.
+                ...cppPackageScopeFacts(targetName, qualifiedName, packageScopeRoots, packageScopePackages)
+              }
+            });
+            const caller = parentContext?.symbolRef;
+            if (caller && (caller.kind === ASTEngine.SymbolKind.Method || caller.kind === ASTEngine.SymbolKind.Function || caller.kind === ASTEngine.SymbolKind.Constructor)) {
+              if (!caller.qualified_calls) caller.qualified_calls = [];
+              caller.qualified_calls.push(qualifiedName);
+            }
+          }
+        }
+      } else if (type === "new_expression") {
+        const typeNode = node.namedChild(0);
+        if (typeNode) {
+          let typeName = typeNode.text;
+          let cur = typeNode;
+          while (cur && cur.type === "qualified_identifier" && cur.namedChildCount >= 1) {
+            const inner = cur.namedChild(cur.namedChildCount - 1);
+            if (!inner) break;
+            cur = inner;
+          }
+          if (cur && cur !== typeNode) typeName = cur.text;
+          const lt3 = typeName.indexOf("<");
+          if (lt3 !== -1) typeName = typeName.slice(0, lt3);
+          if (this.isPlainIdentifier(typeName) && isCppSpelledName(typeName) && !CPP_NON_CLASS_STANDARD_TYPES.has(typeName) && !this.isTemplateParameterName(node, typeName)) {
+            const source = parentContext?.name || "global";
+            relationships.push({
+              source,
+              target: typeName,
+              fromSymbol: source,
+              toSymbol: typeNode.text,
+              type: ASTEngine.RelationshipType.Instantiates,
+              confidence: typeNode.hasError ? 0.6 : 1,
+              // the constructed type's own node names this edge —
+              // `new` and its type can sit on different lines. Same value in the
+              // #873 mirror, 1-based.
+              line_number: this.nodeLine(typeNode),
+              metadata: { line: this.nodeLine(typeNode), isNew: true }
+            });
+          }
+        }
+      } else if (type === "identifier") {
+        const p = node.parent;
+        if (p && p.type === "lambda_capture_initializer" && p.namedChild(0)?.startIndex === node.startIndex) {
+          const fnScope = enclosingFunctionScope();
+          if (fnScope) {
+            if (!fnScope.locals) fnScope.locals = /* @__PURE__ */ new Set();
+            fnScope.locals.add(node.text);
+          }
+        } else if (isDeclarationPosition(node) && !isFunctionOwnName(node)) {
+          const fnScope = enclosingFunctionScope();
+          if (fnScope) {
+            if (this.insideFunctionBody(p)) {
+              if (!fnScope.locals) fnScope.locals = /* @__PURE__ */ new Set();
+              fnScope.locals.add(node.text);
+            }
+          }
+        } else if (node.text && // D1, EDGE GATE. The roster gate above is the structural fix; this is
+        // the edge-level guarantee, so the impossibility holds on the row
+        // itself even if a future path adds a name to a roster directly. A
+        // keyword names no value, so it is never a read.
+        isCppSpelledName(node.text) && !isDeclarationPosition(node) && !isPreprocText(node) && // Assignment LHS is a WRITE, never a read (C CGD1 / family
+        // write-is-not-a-use contract — plain and compound assignments
+        // both carry the LHS as first named child).
+        !(p && p.type === "assignment_expression" && p.namedChild(0)?.startIndex === node.startIndex && (p.namedChild(0)?.endIndex ?? 0) >= node.endIndex) && // Call callee (span-matched like C CGD17, climbing through
+        // template/dependent/parenthesized wrappers like the calls
+        // branch's calleeLeaf) — the calls branch owns it.
+        !isCallCallee(node) && // Member leaves — the field path owns them (both read and call
+        // positions). The OBJECT of a field access is a genuine read and
+        // stays (CGD31 contract): only the field-role leaf is skipped.
+        // CPPD14: seen through template wrappers (`key.get_ref<string_t&>()`).
+        !isMemberLeaf(node) && // Qualified reads (`ns::x`) — limitation, stays silent.
+        !hasQualifiedAncestor(node) && // Labels and attributes never name values.
+        !(p && (p.type === "goto_statement" || p.type === "labeled_statement")) && !hasAttributeAncestor(node)) {
+          const fnScope = enclosingFunctionScope();
+          const shadowed = !!fnScope?.locals?.has(node.text);
+          if (!shadowed && isResolvableRead(node.text)) {
+            const source = parentContext?.name || "global";
+            const relKey = `${source}::uses::${node.text}`;
+            if (!usesSeen.has(relKey)) {
+              usesSeen.add(relKey);
+              relationships.push({
+                source,
+                target: node.text,
+                type: ASTEngine.RelationshipType.Uses,
+                confidence: 1,
+                line_number: this.nodeLine(node),
+                metadata: { relationshipType: "identifier_usage", nodeType: node.type }
+              });
+            }
+          }
+        }
+      }
+      if (pushedScope) {
+        stack.push({ node, parentContext: newContext, isExit: true });
+      }
+      for (let i = node.namedChildCount - 1; i >= 0; i--) {
+        const child = node.namedChild(i);
+        if (child) {
+          stack.push({ node: child, parentContext: newContext });
+        }
+      }
+    }
+    const seenExportNames = /* @__PURE__ */ new Set();
+    for (const sym of symbols) {
+      if (!sym.ownerName && !sym.ownerKind) {
+        const isPrivate = sym.visibility === "private" || sym.isStatic;
+        const isMacroExpansion = sym.metadata?.expandedFrom === "macro-heading";
+        if (!isPrivate && !isMacroExpansion && sym.name !== CPP_ANONYMOUS && !seenExportNames.has(sym.name)) {
+          seenExportNames.add(sym.name);
+          exports.push({
+            name: sym.name,
+            kind: sym.kind,
+            range: sym.range,
+            visibility: sym.visibility || "public"
+          });
+        }
+      }
+    }
+    const companion = context?.overrideCompanion instanceof Map ? context.overrideCompanion : void 0;
+    {
+      const resolves = (startCls, method, params, keyword) => {
+        const found = [];
+        const seen = /* @__PURE__ */ new Set();
+        const queue = [startCls];
+        let depth = 0;
+        while (queue.length && depth < 10) {
+          depth++;
+          const cls = queue.shift();
+          if (seen.has(cls)) continue;
+          seen.add(cls);
+          for (const base of classBases.get(cls) ?? []) {
+            if (base === startCls) continue;
+            const baseSigs = classVirtuals.get(base);
+            const sigMatch = !!baseSigs && (baseSigs.get(method) ?? []).includes(params);
+            if (sigMatch) {
+              found.push({
+                base,
+                confidence: keyword ? 1 : 0.9,
+                reasonCode: keyword ? "override-keyword+signature-match" : "signature-match"
+              });
+            } else if (keyword && companion) {
+              const declared = companion.get(base);
+              if (declared && declared.has(method)) {
+                found.push({ base, confidence: 0.95, reasonCode: "override-keyword+companion-declares-method" });
+              }
+            }
+            queue.push(base);
+          }
+        }
+        return found;
+      };
+      const seenOv = /* @__PURE__ */ new Set();
+      for (const pend of pendingOverrides) {
+        for (const hit of resolves(pend.cls, pend.method, pend.params, !!pend.keyword)) {
+          const k = `${pend.cls}.${pend.method}|${hit.base}.${pend.method}`;
+          if (seenOv.has(k)) continue;
+          seenOv.add(k);
+          relationships.push({
+            source: `${pend.cls}.${pend.method}`,
+            // THE TARGET IS THE DECLARED MEMBER, NOT `Base.method`. The resolver matches an
+            // edge target against a SYMBOL NAME (or a qualified-name alias), and a cpp member
+            // symbol publishes only its leaf — `pool-worker.ts` normalises `qualifiedName` to
+            // `name` for a symbol with no `scope`/`fqn`, so `Base.method` is a spelling no
+            // declaration answers to. Measured before this spelling was restored: 1,875 of
+            // 1,875 `overrides` edges unresolved on the whole cpp population (CPP-RESIDUAL ).
+            // This is commit a29357562's landed fix ("the leaf spelling … WITH the owner carried
+            // in metadata", measured there as 86 edges: 86 unresolved -> 0), which the
+            // `0b597d2e4` take-main merge dropped and this iteration restores.
+            target: pend.method,
+            type: ASTEngine.RelationshipType.Overrides,
+            confidence: hit.confidence,
+            // the overriding method's own declaration site (the
+            // pending record carries the line captured where the method was
+            // walked — a post-loop resolution has no node to ask).
+            line_number: pend.line,
+            metadata: {
+              isVirtualOverride: true,
+              reasonCode: hit.reasonCode,
+              // THE OWNER CARRIES THE DISTINCTION THE TARGET NO LONGER CAN. Two methods named
+              // `run` in two classes are two declarations; the leaf names both, so the base
+              // that was actually matched by the signature/keyword evidence rides HERE rather
+              // than disappearing. This is the field the lane's own fixtures pin
+              // (`meta.overriddenOwner`), and it is the machine-readable answer to "which
+              // declaration did the resolver intend" when the leaf alone is ambiguous.
+              overriddenOwner: hit.base,
+              // task-22 (flag-gated): does the INDEX's inheritance-closed member view confirm this
+              // base declares the method? Absent when there is no complete index.
+              ...indexOverridesFacts(hit.base, pend.method),
+              // M14-HONESTY-CONTRACT : any edge under 1.0 carries a
+              // machine-readable reason code, and `override`/`final` is
+              // recorded so a reader can tell an asserted override from an
+              // inferred one without re-parsing the source.
+              ...pend.keyword ? { overrideSpecifier: pend.keyword } : {}
+            }
+          });
+        }
+      }
+    }
+    {
+      const seenImpl = /* @__PURE__ */ new Set();
+      for (const pend of pendingImplements) {
+        const k = `${pend.derived} ${pend.base}`;
+        if (seenImpl.has(k)) continue;
+        const pure = classPureVirtuals.get(pend.base);
+        if (!pure || pure.size === 0) continue;
+        seenImpl.add(k);
+        relationships.push({
+          source: pend.derived,
+          target: pend.base,
+          type: ASTEngine.RelationshipType.Implements,
+          confidence: 1,
+          line_number: pend.line,
+          metadata: {
+            // WHY this base is a contract, stated in machine-readable form so a
+            // consumer can re-derive it: the pure virtual members it declares.
+            reasonCode: "pure-virtual-base",
+            pureVirtuals: [...pure],
+            pureVirtualCount: pure.size,
+            ...indexBaseFacts(pend.base)
+          }
+        });
+      }
+    }
+    {
+      for (const pend of pendingExports) {
+        const target = pend.owner ? `${pend.owner}.${pend.name}` : pend.name;
+        if (exportsSeen.has(target)) continue;
+        exportsSeen.add(target);
+        relationships.push({
+          source: "global",
+          target,
+          type: ASTEngine.RelationshipType.Exports,
+          confidence: 1,
+          // the exported NAME's line, which is the declaration's
+          // `nameLine`, not the attribute's — `__declspec` precedes the type.
+          line_number: pend.line,
+          metadata: {
+            // WHICH spelling declared the export. Recorded because the two
+            // mechanisms have different reach — `dllexport` is MSVC and
+            // `visibility("default")` is GCC/Clang ELF — and a reader triaging
+            // a symbol's visibility needs to know which one the author used.
+            exportSpelling: pend.spelling,
+            relationshipType: "export_attribute"
+          }
+        });
+      }
+    }
+    const containsSeen = /* @__PURE__ */ new Set();
+    for (const s of symbols) {
+      const _owner = s.ownerName || s.scope;
+      if (!_owner) continue;
+      const relKey = `${_owner}\0${s.name}`;
+      if (containsSeen.has(relKey)) continue;
+      containsSeen.add(relKey);
+      relationships.push({
+        source: _owner,
+        target: s.name,
+        type: ASTEngine.RelationshipType.Contains,
+        confidence: 1,
+        // + #921 (M60): a contains edge takes the CHILD's line,
+        // and "the child's line" means the line that NAMES it — the rule every
+        // other relationship type already follows (`nameLine`) and the rule the
+        // Tier A oracle checks. The symbol's RANGE still starts at its whole
+        // declaration node (search, edit anchors and the M73 line base read
+        // that), so the two are no longer forced to agree: a wrapped return
+        // type used to put the edge on the declaration's first line, where the
+        // name is not written (`void NORETURN` then `CheckFailed(…)`).
+        line_number: s.metadata?.nameLine ?? s.range?.startLine,
+        metadata: {}
+      });
+    }
+    for (const sym of symbols) {
+      if (Array.isArray(sym.qualified_calls) && sym.qualified_calls.length > 1) {
+        sym.qualified_calls = [...new Set(sym.qualified_calls)];
+      }
+    }
+    this.classifyEvidenceTier(relationships);
+    for (const sym of symbols) {
+      const owner = String(sym?.ownerName ?? "").trim();
+      if (owner === "" || owner === "global") continue;
+      const name = String(sym?.name ?? "").trim();
+      if (name === "") continue;
+      const existing = sym?.qualifiedName;
+      if (typeof existing === "string" && existing !== "") continue;
+      sym.qualifiedName = `${owner}::${name}`;
+    }
+    return {
+      symbols,
+      relationships,
+      imports,
+      exports,
+      errors,
+      metadata: {
+        linesOfCode: content.split("\n").length,
+        cyclomaticComplexity: 1 + fileDecisions,
+        complexity: 1 + fileDecisions,
+        patterns: (() => {
+          const arr = [];
+          for (const p in patterns) arr.push(p);
+          return arr;
+        })(),
+        detectedFrameworks: (() => {
+          const arr = [];
+          for (const f in frameworks) arr.push(f);
+          return arr;
+        })(),
+        memorySafetyScore
+      }
+    };
+  }
+  // CP2 (cpp review): test/macro function shapes — `TEST(suite, name)
+  // {...}`, `BOOST_AUTO_TEST_CASE(x) {...}` parse as function_definitions
+  // whose declarator params are BARE identifiers (macro paste-tokens, no
+  // types). Minting a `TEST` Function symbol per site (11 in one file) and
+  // resolving reads against it fabricates API + edges for a preprocessor
+  // fiction (C-D2: no macro expansion). Detection: ALL-CAPS declarator
+  // name + a non-empty parameter list in which NO parameter carries a type
+  // node. Real functions always type their params (`void f()`/`f(void)`
+  // have empty/void lists and are kept); ALL-CAPS real functions with
+  // typed params (`WINAPI Foo(int)`) are kept.
+  // #919: the heading TEXT of a `function_definition`-spelled macro body — from
+  // the node's start to the end of its parameter list, i.e. exactly the text the
+  // source writes before the block (`TEST(my_case, keeps_its_locals)`). Returns
+  // null when the shape has no body (a decorator fragment such as gmock's
+  // `GTEST_LOCK_EXCLUDED_(g_gmock_mutex) = 0;`), because then there is no
+  // heading/body pair at all.
+  macroHeadingText(node, content, funcName) {
+    if (!node.childForFieldName("body")) return null;
+    const decl = this.findChild(node, "function_declarator");
+    if (!decl) return null;
+    let nameNode = null;
+    {
+      let cur = decl;
+      while (cur) {
+        if ((cur.type === "identifier" || cur.type === "field_identifier") && cur.text === funcName) {
+          nameNode = cur;
+          break;
+        }
+        let next = null;
+        for (let k = 0; k < cur.namedChildCount; k++) {
+          const c = cur.namedChild(k);
+          if (c && (c.type.endsWith("declarator") || c.type === "identifier" || c.type === "field_identifier")) {
+            next = c;
+            break;
+          }
+        }
+        cur = next;
+      }
+    }
+    if (!nameNode) return null;
+    return macroInvocationText(content, nameNode.startIndex);
+  }
+  // #919: is this node inside a function BODY? Two shapes qualify — a
+  // `function_definition`, and the body of a macro-declared heading (which has
+  // no `function_definition` at all: see `macroDeclaredBody`). A class/struct/
+  // union boundary ends the search, exactly as the inline walk did before this
+  // was factored out: a declaration inside a nested class belongs to that class,
+  // not to the enclosing function whose locals we are collecting.
+  insideFunctionBody(node) {
+    let cur = node;
+    while (cur) {
+      if (cur.type === "function_definition") return true;
+      if (cur.type === "class_specifier" || cur.type === "struct_specifier" || cur.type === "union_specifier") return false;
+      if (macroDeclaredBody(cur)) return true;
+      cur = cur.parent;
+    }
+    return false;
+  }
+  /**
+   * Is this `function_definition` actually a MACRO INVOCATION?
+   *
+   * Two independent signals, and the second is the one that catches the annotation
+   * class. The first is the historical one: an ALL-CAPS name whose parameters are
+   * typeless (`TEST(a, b) { … }`).
+   *
+   * D8: a THREAD-SAFETY ANNOTATION is recovered as a whole extra function
+   * definition. Given
+   *
+   *     virtual void SetReaction(int obj, long r) GTEST_LOCK_EXCLUDED_(mu) {}
+   *
+   * the grammar emits the real definition AND a second, phantom one whose entire
+   * text is `GTEST_LOCK_EXCLUDED_(mu) {}` — the annotation, parsed as a function
+   * named after the macro. The analyzer published that phantom as a real method,
+   * so `GTEST_LOCK_EXCLUDED_` and `GTEST_EXCLUSIVE_LOCK_REQUIRED_(m)` became
+   * members of the class. (In the second one the published name even carried the
+   * argument list, because the declarator is an identifier followed by a
+   * parenthesised argument the grammar reads as a function-pointer declarator.)
+   *
+   * Why the existing parameter test could not see it: the argument of an
+   * annotation is an EXPRESSION — a mutex variable, a member name — and
+   * `internal::g_mutex` is spelled exactly like a parameter that has a type, so
+   * `paramHasType` said yes and the function-shape test bailed. Testing the
+   * parameter was always a proxy for "is this a macro invocation", and the
+   * RETURN TYPE is the real thing: **C++ has no function definition without one.**
+   * A constructor or destructor has no return type either, but its declarator
+   * names the class, and a class name spelled in all caps is not a shape this
+   * codebase has to survive. Measured on this lane's corpora: the annotation
+   * phantoms are uniformly `type=(NONE)` while every real definition carries
+   * `primitive_type`, `sized_type_specifier`, `qualified_identifier` or a
+   * `macro_prefixed_type_specifier`.
+   */
+  isMacroFunctionShape(node, funcName) {
+    const decl = this.findChild(node, "function_declarator");
+    if (!decl) return false;
+    const bare = this.bareDeclaratorName(decl) ?? funcName;
+    if (!this.isAllCapsName(bare)) return false;
+    if (!node.childForFieldName?.("type")) {
+      const body = this.findChild(node, "compound_statement");
+      if (this.findChild(decl, "parameters") && body && body.namedChildCount === 0) return true;
+    }
+    const params = decl.childForFieldName("parameters");
+    if (!params || params.namedChildCount === 0) return false;
+    for (let i = 0; i < params.namedChildCount; i++) {
+      const p = params.namedChild(i);
+      if (!p) continue;
+      if (p.type === "comment") continue;
+      if (this.paramHasType(p)) return false;
+    }
+    return true;
+  }
+  /**
+   * The BARE name a declarator chain declares: the first `identifier` /
+   * `field_identifier` down the chain, with no argument list and no qualifier.
+   * For `GTEST_LOCK_EXCLUDED_(mu)` that is `GTEST_LOCK_EXCLUDED_`; for
+   * `namespace::detail::Widget` it is `Widget`. Returns null when the chain has
+   * no spelled name, so a caller can fall back to the name it already has.
+   */
+  /**
+   * D8: is this no-return-type `function_definition` a TRAILING ANNOTATION — one
+   * that decorates the declaration immediately before it and declares nothing?
+   *
+   * The shape is fixed by the grammar. Given
+   *
+   *     void SetReaction(int obj, long r) GTEST_LOCK_EXCLUDED_(mu) { …body… }
+   *
+   * the grammar ends the `declaration` at the `)` and starts a SECOND
+   * `function_definition` whose declarator is the annotation and whose BODY is the
+   * real function's body. So the node is not a phantom with an empty body — it
+   * carries the statements — and publishing it as a method both invents a symbol
+   * and misattributes every read in that body to the macro.
+   *
+   * The discriminator is structural and it is the only one that held up against
+   * the corpus. Everything else tried was confounded by real data:
+   *
+   *   * the annotation's ARGUMENT looks like a parameter type
+   *     (`internal::g_gmock_mutex`), so the historical "params are typeless" test
+   *     cannot see it
+   *   * the body's being empty does not hold — this node HAS the body
+   *   * the character before the macro in the SOURCE does not hold: it is `)` for
+   *     some sites and `t` (of a trailing `const`) for others, and a `TEST` macro
+   *     preceded by a comment ending in `)` reads as `)` too
+   *   * `prevNamedSibling` is `null` throughout this grammar
+   *
+   * What does hold: the annotation's immediately preceding NAMED SIBLING is the
+   * `declaration`/`field_declaration` of the function it decorates, and that
+   * declaration carries a `function_declarator` — the grammar cut it at the `)`.
+   * A `TEST(Suite, Name) { …body… }` heading has no such predecessor: it is the
+   * first thing in its statement, so its previous named sibling is a comment, a
+   * brace, or another `function_definition`. The `function_declarator` requirement
+   * is what keeps `int x;` immediately before a `TEST` from being read as a
+   * continuation.
+   *
+   * Node-only on purpose: it must be decidable WITHOUT `getFunctionDetails`, which
+   * is null for exactly the nodes this rule is about.
+   */
+  /**
+   * Is this `function_definition`'s return type a class DEFINITION?
+   *
+   * C++ has no such thing: a function cannot return a class *definition*, only a
+   * class type (by name, or an elaborated `class X` with no body). So a
+   * `function_definition` whose `type` field resolves to a `class_specifier` /
+   * `struct_specifier` / `union_specifier` that CARRIES A BODY is the recovery's
+   * invention.
+   *
+   * The unwrap matters: fork patch 2's `macro_prefixed_type_specifier` puts the
+   * class one level down, so the `type` field is that node and the specifier is its
+   * child. Requiring a body is what separates this from the legal
+   * `class X f() { ... }` (an elaborated return type), which has no body and must
+   * keep publishing its function.
+   */
+  returnTypeIsClassDefinition(node) {
+    const t = node.childForFieldName?.("type");
+    if (!t) return false;
+    const spec = t.type === "macro_prefixed_type_specifier" ? (t.namedChildren ?? []).find(
+      (c) => c.type === "class_specifier" || c.type === "struct_specifier" || c.type === "union_specifier"
+    ) : t;
+    if (!spec) return false;
+    if (spec.type !== "class_specifier" && spec.type !== "struct_specifier" && spec.type !== "union_specifier") {
+      return false;
+    }
+    return (spec.namedChildren ?? []).some((c) => c.type === "field_declaration_list");
+  }
+  isTrailingAnnotationMacro(node, content) {
+    if (node.childForFieldName?.("type")) return false;
+    const body = this.findChild(node, "compound_statement");
+    if (!body) return false;
+    const decl = this.findChild(node, "function_declarator");
+    if (!decl || !this.findChild(decl, "parameter_list")) return false;
+    const bare = this.bareDeclaratorName(decl);
+    if (bare === null || !this.isAllCapsName(bare)) return false;
+    return this.continuesADeclaration(node.startIndex, content);
+  }
+  /**
+   * D8's discriminator, and the only formulation that held up against the corpus:
+   * does this macro invocation CONTINUE the declaration in front of it?
+   *
+   * Everything structural was confounded by real data, and each was tried and
+   * measured before being dropped:
+   *
+   *   * the annotation's ARGUMENT looks like a parameter type
+   *     (`internal::g_gmock_mutex`), so the historical "params are typeless" test
+   *     cannot see it
+   *   * the body's being empty does not hold — the node CARRIES the real body
+   *   * the previous named sibling is unreliable: `prevNamedSibling` is `null`
+   *     throughout this grammar, and finding the predecessor by index in the
+   *     parent's child list yields `declaration` for a real annotation AND for a
+   *     `TEST` that happens to follow a function declaration — that version
+   *     deleted every gtest heading, which is the largest single loss available
+   *   * `TEST` is itself spelled in all caps, so the macro-name test cannot
+   *     separate the two families
+   *
+   * What separates them is where the invocation SITS. An annotation is trailing:
+   * it follows the parameter list (and possibly a trailing `const`/`&`/`noexcept`)
+   * of the declaration it decorates. A heading is a statement in its own right.
+   * So scan back over whitespace and comments; if the previous significant
+   * character could END a statement, this macro OPENS one and is not an
+   * annotation.
+   *
+   * Comments must be skipped, and that is not a refinement — the first attempt
+   * did not skip them and read a `TEST` preceded by a comment ending in `)` as an
+   * annotation, which is how the first version of this rule deleted the whole
+   * gtest suite's worth of headings.
+   */
+  continuesADeclaration(startIndex, content) {
+    let j = startIndex - 1;
+    while (j >= 0) {
+      const c2 = content[j];
+      if (c2 === " " || c2 === "	" || c2 === "\r" || c2 === "\n") {
+        j--;
+        continue;
+      }
+      break;
+    }
+    if (j < 0) return false;
+    const tail = content.slice(Math.max(0, j - 40), startIndex);
+    if (tail.indexOf("//") !== -1 || tail.indexOf("/*") !== -1) return false;
+    const c = content[j];
+    if (c === ")" || c === "&" || c === ">" || c === "*") return true;
+    const upTo = content.slice(Math.max(0, j - 12), j + 1).toLowerCase();
+    let letters = "";
+    for (let k = 0; k < upTo.length; k++) {
+      const ch = upTo[k];
+      if (ch >= "a" && ch <= "z") letters += ch;
+    }
+    for (const kw of ["const", "noexcept", "override", "final", "mutable", "volatile"]) {
+      if (letters.endsWith(kw)) return true;
+    }
+    return false;
+  }
+  bareDeclaratorName(decl) {
+    let cur = decl;
+    for (let i = 0; i < 8 && cur; i++) {
+      if (cur.type === "identifier" || cur.type === "field_identifier") return cur.text;
+      const next = cur.childForFieldName?.("declarator") ?? null;
+      if (!next) {
+        for (let k = 0; k < cur.namedChildCount; k++) {
+          const c = cur.namedChild(k);
+          if (c && (c.type === "identifier" || c.type === "field_identifier")) return c.text;
+        }
+        return null;
+      }
+      cur = next;
+    }
+    return null;
+  }
+  // #915: a bare top-level macro must not become a `variable`. Two consecutive
+  // macros at file scope are recovered by the grammar as a `declaration` whose
+  // "type" is itself a macro and whose terminator is MISSING
+  // (`FMT_END_EXPORT` / `FMT_END_NAMESPACE` -> type_identifier + identifier +
+  // MISSING `;`), and the declaration branch then names the symbol after the
+  // second macro. Measured on fmt: 13 such phantoms in a 58-file draw, all bare
+  // ALL-CAPS macro names (`variable FMT_END_NAMESPACE` x8, `GTEST_ATTRIBUTE_UNUSED_`
+  // x2, `RUN_ALL_TESTS`, `GTEST_DEFAULT_DEATH_TEST_STYLE`, `FMT_BEGIN_EXPORT`),
+  // and 0 on nlohmann-json. This is the BARE sibling of the call-shaped class
+  // `isMacroFunctionShape` already suppresses.
+  //
+  // Three conditions, each doing real work — the first two alone would lose a
+  // real symbol:
+  //   * the name is ALL-CAPS            (`MAX_SIZE` stays a symbol, `MAX_SIZE;`)
+  //   * the node is ERROR-RECOVERED     (a clean `MyType MAX_SIZE;` is kept,
+  //                                      because its terminator is real; only
+  //                                      already-broken code is affected)
+  //   * it carries NO hard type         (`int MAX_SIZE` and
+  //                                      `MyType *MAX_SIZE` are kept — a lone
+  //                                      `type_identifier` is the grammar's
+  //                                      classification of macro soup, not a type,
+  //                                      the same reading `paramHasType` uses)
+  isBareMacroDeclaration(node, name) {
+    if (!this.isAllCapsName(name)) return false;
+    let recovered = false;
+    const walkRecovered = [node];
+    while (walkRecovered.length > 0) {
+      const m = walkRecovered.pop();
+      if (m.isMissing || m.isError) {
+        recovered = true;
+        break;
+      }
+      for (let i = 0; i < m.childCount; i++) {
+        const c = m.child(i);
+        if (c) walkRecovered.push(c);
+      }
+    }
+    if (!recovered) return false;
+    const walkType = [node];
+    while (walkType.length > 0) {
+      const m = walkType.pop();
+      if (m.type === "primitive_type" || m.type === "sized_type_specifier" || m.type === "template_type" || m.type === "qualified_identifier" || m.type === "dependent_type" || m.type === "decltype" || m.type === "struct_specifier" || m.type === "union_specifier" || m.type === "enum_specifier" || m.type === "class_specifier" || m.type === "placeholder_type_specifier" || m.type === "macro_prefixed_type_specifier") {
+        return false;
+      }
+      for (let i = 0; i < m.childCount; i++) {
+        const c = m.child(i);
+        if (c) walkType.push(c);
+      }
+    }
+    return true;
+  }
+  isAllCapsName(name) {
+    let hasUpper = false;
+    for (let i = 0; i < name.length; i++) {
+      const c = name[i];
+      if (c >= "a" && c <= "z") return false;
+      if (c >= "A" && c <= "Z") hasUpper = true;
+    }
+    return hasUpper;
+  }
+  paramHasType(param) {
+    let sawHardType = false;
+    let sawTypeIdent = false;
+    let sawNameIdent = false;
+    const stack = [param];
+    while (stack.length > 0) {
+      const m = stack.pop();
+      if (m.type === "primitive_type" || m.type === "sized_type_specifier" || m.type === "template_type" || m.type === "qualified_identifier" || m.type === "dependent_type" || m.type === "decltype" || m.type === "struct_specifier" || m.type === "union_specifier" || m.type === "enum_specifier") {
+        sawHardType = true;
+        break;
+      }
+      if (m.type === "type_identifier") sawTypeIdent = true;
+      if (m.type === "identifier" || m.type === "field_identifier") sawNameIdent = true;
+      for (let i = 0; i < m.namedChildCount; i++) {
+        const c = m.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return sawHardType || sawTypeIdent && sawNameIdent;
+  }
+  /**
+   * M60.P1 `decorators`: a declaration's modifiers, as the SOURCE SPELLINGS the
+   * node carries, in source order — so a consumer reads `["static", "constexpr"]`
+   * instead of reversing four booleans back into words.
+   *
+   * This is the declared payload field, and the `metadata` flags
+   * (`isVirtual`/`isConst`/`isConstexpr`/`isStatic`) were duplicating its content
+   * without ever filling it: the M60 payload-seam matrix recorded
+   * `UniversalSymbol.decorators` as a DEAD emit cell for cpp while this file's own
+   * documentation claimed the row was supported.
+   *
+   * Shared by the function and the field/variable branch, because
+   * `static constexpr int kMax = 10;` carries exactly as much modifier
+   * information as `virtual int area() const = 0;` and a payload field that only
+   * answered for one of them is a field a consumer cannot rely on.
+   *
+   * A destructor and an operator overload are deliberately ABSENT: `~File` and
+   * `operator==` are part of the NAME, not modifiers applied to it, and listing
+   * them here would put a name in a field whose meaning is "applied to this
+   * declaration".
+   *
+   * The scan keys off the child's TEXT and EXCLUDES the declaration's own
+   * payload fields (`type`, `declarator`, `default_value`, …), not off
+   * `isNamed`. The grammar is inconsistent here and both forms occur in this
+   * lane's own fixtures: `virtual int area() const = 0;` exposes `virtual` as an
+   * UNNAMED token, while `static constexpr int kMax = 10;` exposes `static` and
+   * `constexpr` as NAMED `storage_class_specifier` / `type_qualifier` wrappers.
+   * A rule that only read unnamed tokens would find the modifier on the method
+   * and miss it on the field, which is the worst of both — a payload field that
+   * answers sometimes.
+   */
+  declarationDecorators(node, declarator = null) {
+    const out = [];
+    const MODIFIERS = /* @__PURE__ */ new Set([
+      "static",
+      "constexpr",
+      "const",
+      "inline",
+      "virtual",
+      "explicit",
+      "extern",
+      "friend",
+      "mutable",
+      "thread_local",
+      "volatile",
+      "override",
+      "final"
+    ]);
+    const PAYLOAD_FIELDS = /* @__PURE__ */ new Set([
+      "type",
+      "declarator",
+      "default_value",
+      "value",
+      "initializer",
+      "parameters",
+      "body",
+      "name",
+      "argument",
+      "condition",
+      "left",
+      "right",
+      "operator"
+    ]);
+    const seen = /* @__PURE__ */ new Set();
+    const scan = (n) => {
+      if (!n) return;
+      for (let i = 0; i < n.childCount; i++) {
+        const c = n.child(i);
+        if (!c) continue;
+        const field = n.fieldNameForChild ? n.fieldNameForChild(i) : null;
+        if (field && PAYLOAD_FIELDS.has(field)) continue;
+        if (MODIFIERS.has(c.text) && !seen.has(c.text)) {
+          seen.add(c.text);
+          out.push(c.text);
+        }
+      }
+    };
+    scan(node);
+    scan(declarator);
+    return out;
+  }
+  /**
+  * The `function_declarator` of a declaration, descending one `init_declarator`.
+  *
+  * ONTOLOGY `overrides`, second-order defect. `virtual bool ReportContext(const
+  * Context&) = 0;` — the PURE VIRTUAL, which is how C++ spells the interface a
+  * derived class implements — does not put the declarator where the shallow scan
+  * looks:
+  *
+  *   declaration [declarator=init_declarator type=primitive_type]
+  *     virtual, primitive_type "bool"
+  *     init_declarator [declarator=function_declarator value=number_literal]
+  *       function_declarator [declarator=identifier parameters=parameter_list]
+  *
+  * So `findChild(node, "function_declarator")` returned null, the signature
+  * normaliser registered the base method with an EMPTY parameter list, and no
+  * derived signature could ever equal it. `Finalize()` resolved only because it
+  * takes no parameters and `""` matched `""` — which is why the pre-fix count on
+  * `reporter.h` was 2 of 4 and both happened to be the zero-argument ones.
+  *
+  * Scoped to ONE level and ONE wrapper on purpose. A general "descend until you
+  * find a declarator" walk would also reach through `pointer_declarator` and
+  * `reference_declarator`, where the pointer/reference is part of the C++ type
+  * and dropping the wrapper would make `void f(Widget&)` and `void f(Widget)`
+  * hash alike — the exact defect D8 removed from the published `parameters`
+  * field. `init_declarator` carries no type, so descending through it loses
+  * nothing.
+  */
+  functionDeclaratorOf(node) {
+    if (!node) return null;
+    const direct = this.findChild(node, "function_declarator");
+    if (direct) return direct;
+    const init = this.findChild(node, "init_declarator");
+    return init ? this.findChild(init, "function_declarator") : null;
+  }
+  methodComplexityCpp(node) {
+    const decisionTypes = /* @__PURE__ */ new Set([
+      "if_statement",
+      "for_statement",
+      "while_statement",
+      "do_statement",
+      "case_statement",
+      "catch_clause",
+      "conditional_expression"
+    ]);
+    let c = 1;
+    const st = [node];
+    while (st.length) {
+      const n = st.pop();
+      if (decisionTypes.has(n.type)) c++;
+      else if (n.type === "binary_expression") {
+        const op = n.childForFieldName("operator")?.text;
+        if (op === "&&" || op === "||") c++;
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const ch = n.namedChild(i);
+        if (ch) st.push(ch);
+      }
+    }
+    return c;
+  }
+  /**
+   * #419-D - evidence-tier classification for EVERY emitted relationship
+   * (same rules as the JVM/web family).
+   */
+  classifyEvidenceTier(relationships) {
+    for (const r of relationships) {
+      const md = r.metadata ?? (r.metadata = {});
+      if (md.evidenceClass) continue;
+      const t = String(r.type ?? "");
+      const conf = typeof r.confidence === "number" ? r.confidence : 1;
+      if (t === "contains" || t === "exports") {
+        md.evidenceClass = "structural";
+        continue;
+      }
+      if (t === "imports") {
+        md.evidenceClass = "import_based";
+        continue;
+      }
+      if (t === "references") {
+        md.evidenceClass = md.isImport ? "import_based" : "reference_qualified";
+        continue;
+      }
+      if (t === "imports") {
+        md.evidenceClass = md.isImport ? "import_based" : "usage_contextual";
+        continue;
+      }
+      if (t === "extends" || t === "implements" || t === "overrides") {
+        md.evidenceClass = conf >= 1 ? "structural" : conf >= 0.85 ? "usage_contextual" : "inferred";
+        continue;
+      }
+      if (t === "instantiates") {
+        md.evidenceClass = "structural";
+        continue;
+      }
+      md.evidenceClass = "usage_contextual";
+    }
+  }
+  /**
+   * The EXPORT MARKER macro of a declaration-specifier, or `undefined`.
+   *
+   * The other half of `specifierTypeText`, and the reader for ONTOLOGY `exports`.
+   * Both walk the same node and neither imports the other, because they answer
+   * different questions — one asks what the type IS, the other asks what the
+   * declaration is DECORATED with — and a node can answer both at once only if
+   * both are asked. `cppExportMarker` decides whether the macro is an export
+   * marker; see its comment for the measured population that forced the rule.
+   */
+  specifierExportMacro(t) {
+    if (!t || t.type !== "macro_prefixed_type_specifier") return void 0;
+    for (let i = 0; i < t.namedChildCount; i++) {
+      const c = t.namedChild(i);
+      if (c && c.type === "macro_specifier") return c.text.trim();
+    }
+    return void 0;
+  }
+  /**
+   * the line of the node that NAMES a relationship, 1-based, or
+   * `undefined` when the site is not attributable — never a fabricated 0 and
+   * never an enclosing declaration's line. The C lane carries the identical
+   * helper; the contract is "call-site line or NULL" ().
+   */
+  nodeLine(node) {
+    if (!node || !node.startPosition || typeof node.startPosition.row !== "number") return void 0;
+    return node.startPosition.row + 1;
+  }
+  /**
+   * a type expression's start is not the line of the names inside
+   * it. A specifier starts at its KEYWORD, and a wrapped declaration puts the
+   * name on the following line:
+   *
+   *   struct          <- the specifier's start
+   *   Bigint {        <- where the name is written
+   *
+   * The grammar's `name` field is the site when it exists; otherwise the node is.
+   * (Mirror of the C lane's `nameLine`.)
+   */
+  nameLine(node) {
+    if (!node) return void 0;
+    const nameField = typeof node.childForFieldName === "function" ? node.childForFieldName("name") : null;
+    return this.nodeLine(nameField ?? node);
+  }
+  nodeToRange(node) {
+    return {
+      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
+    };
+  }
+  findChild(node, type, text) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child && child.type === type) {
+        if (text === void 0 || child.text === text) return child;
+      }
+    }
+    return null;
+  }
+  findAllChildren(node, type) {
+    const res = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child && child.type === type) res.push(child);
+    }
+    return res;
+  }
+  childText(node, type) {
+    const child = this.findChild(node, type);
+    return child ? child.text : null;
+  }
+  /**
+   * The `override` / `final` `virtual_specifier` on a function declaration, or
+   * null. Read from the DECLARATOR, because that is where the pinned grammar puts
+   * it: measured on the fork,
+   *
+   *   field_declaration[declarator="go() override"]
+   *     primitive_type
+   *     function_declarator[declarator="go"]
+   *       field_identifier
+   *       parameter_list
+   *       virtual_specifier "override"        <- a CHILD of the declarator
+   *
+   * so a declaration-level scan never fires — which is why the `decorators`
+   * payload needed its own second lookup, and why override RESOLUTION ignored the
+   * strongest evidence C++ offers until this round.
+   */
+  functionOverrideSpecifier(declaration) {
+    if (!declaration) return null;
+    const fd = declaration.type === "function_declarator" ? declaration : this.findChild(declaration, "function_declarator");
+    if (!fd) return null;
+    for (let i = 0; i < fd.childCount; i++) {
+      const c = fd.child(i);
+      if (c?.type !== "virtual_specifier") continue;
+      const txt = String(c.text ?? "").trim();
+      if (txt === "override" || txt === "final") return txt;
+    }
+    return null;
+  }
+  /**
+   * The EXPORT attribute a declaration carries, or null. Which spelling exists is
+   * a measurement, not a preference — see `docs/analyzers/cpp.md`
+   * "the exports construct, measured three ways".
+   *
+   * Two are readable on the pinned grammar and one of them is not:
+   *
+   *   1. `__declspec(dllexport)` — MSVC. The grammar keeps the paren group as a
+   *      `ms_declspec_modifier` node whose named children are the attribute names
+   *      (`ms_declspec_modifier [__declspec ( identifier)]`), so the spelling is a
+   *      node, not text.
+   *   2. `__attribute__((visibility("default")))` — GCC/Clang ELF. An
+   *      `attribute_specifier` holding an `argument_list` whose
+   *      `call_expression` names `visibility` with a `"default"` string argument.
+   *   3. `#define FOO __declspec(dllexport)` + `FOO void f();` — how both of the
+   *      above are ACTUALLY used. Measured over the corpus: 11 macro definitions
+   *      name `dllexport` and 0 declarations spell it inline except through one.
+   *      Reading that needs macro expansion, which is a DECLARED limitation of
+   *      this lane (M14-HONESTY-CONTRACT , "macro/template expansion
+   *      boundaries (c, cpp, rust, hcl)"), so the macro-mediated population is
+   *      reported with its count rather than resolved.
+   *
+   * `dllimport` is the opposite direction (this translation unit imports the
+   * symbol from another module) and `visibility("hidden")` is the opposite of
+   * default visibility, so neither is an export and neither is emitted.
+   */
+  exportAttributeSpelling(node) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (!c) continue;
+      if (c.type === "ms_declspec_modifier") {
+        for (let j = 0; j < c.namedChildCount; j++) {
+          const a = c.namedChild(j);
+          if (a?.type === "identifier" && a.text === "dllexport") return "declspec-dllexport";
+        }
+        continue;
+      }
+      if (c.type === "attribute_specifier") {
+        let hit = false;
+        const visit = (n) => {
+          if (hit) return;
+          if (n.type === "call_expression") {
+            const fn = n.childForFieldName?.("function");
+            if (fn && String(fn.text ?? "").trim() === "visibility") {
+              const args = n.childForFieldName?.("arguments");
+              if (args) {
+                for (let k = 0; k < args.namedChildCount; k++) {
+                  const arg = args.namedChild(k);
+                  const lit = arg?.type === "string_literal" ? arg : arg ? this.findChild(arg, "string_literal") : null;
+                  if (lit && stripIncludeChars(String(lit.text ?? "")).trim() === "default") {
+                    hit = true;
+                    return;
+                  }
+                }
+              }
+            }
+          }
+          for (let k = 0; k < n.namedChildCount; k++) {
+            const g = n.namedChild(k);
+            if (g) visit(g);
+          }
+        };
+        visit(c);
+        if (hit) return "attribute-visibility-default";
+      }
+      if (c.type === "attribute_declaration") {
+        const hit = this.attributeRoleExport(c);
+        if (hit) return hit;
+      }
+    }
+    return null;
+  }
+  /**
+   * Does an `attribute_declaration` (`[[...]]`) export its declaration?
+   *
+   * Returns the spelling, or null. Node walk only: the attribute's last
+   * `identifier` is its name, and the argument is read from the `argument_list`
+   * child rather than sliced out of the attribute's text — so a COMMENT naming
+   * `visibility` and a `visibility` inside a string literal cannot produce an
+   * edge, which is the whole reason this lane holds no regexes.
+   */
+  attributeRoleExport(attrDecl) {
+    for (let i = 0; i < attrDecl.namedChildCount; i++) {
+      const attr = attrDecl.namedChild(i);
+      if (attr?.type !== "attribute") continue;
+      let name = null;
+      for (let j = 0; j < attr.namedChildCount; j++) {
+        const c = attr.namedChild(j);
+        if (c?.type === "identifier") name = String(c.text ?? "");
+      }
+      if (name === "dllexport") return "attribute-dllexport";
+      if (name !== "visibility") continue;
+      const args = this.findChild(attr, "argument_list");
+      if (!args) continue;
+      for (let k = 0; k < args.namedChildCount; k++) {
+        const arg = args.namedChild(k);
+        const lit = arg?.type === "string_literal" ? arg : arg ? this.findChild(arg, "string_literal") : null;
+        if (lit && stripIncludeChars(String(lit.text ?? "")).trim() === "default") return "attribute-visibility-default";
+      }
+    }
+    return null;
+  }
+  /**
+   * Is this class-scope function declaration PURE VIRTUAL — `virtual void f() = 0;`?
+   *
+   * Structural, because the pinned grammar has no reachable node for it. The
+   * fork DOES declare a `pure_virtual_clause` rule, but reaches it only from
+   * `inline_method_definition` / `constructor_or_destructor_definition` and the
+   * corpus produces none of them, so the marker has to be read from the tree.
+   *
+   * TWO SHAPES, because the grammar produces two and they occur inside the same
+   * file (measured on cpp-example: 19 of 34 sites are the first, 15 the second):
+   *
+   *   field_declaration [declarator=function_declarator type=primitive_type]
+   *     virtual, primitive_type "bool", function_declarator …
+   *     "=", number_literal "0"                       <- `0` a DIRECT child
+   *
+   *   declaration [declarator=init_declarator type=primitive_type]
+   *     virtual, primitive_type "bool",
+   *       init_declarator [declarator=function_declarator value=number_literal]
+   *                                                     <- `0` nested under value
+   *
+   * D23: the first cut read the `=`/`0` pair off the declaration's own direct
+   * children only, which is why the second shape — the one `reporter.h` and
+   * `json.hpp` actually use — was never registered as an interface operation.
+   * A member variable initialised to zero (`virtual int x = 0;`) is NOT a pure
+   * virtual, and in both shapes the declarator must be a `function_declarator`;
+   * that pairing is what separates the two. A defaulted argument (`void f(int x =
+   * 0)`) puts its `=` inside the `parameter_list`, which no arm here reads.
+   */
+  isPureVirtualDeclaration(declaration) {
+    if (declaration.type !== "field_declaration" && declaration.type !== "declaration") return false;
+    const direct = declaration.childForFieldName?.("declarator");
+    if (direct?.type === "function_declarator" && hasZeroLiteralChild(declaration)) return true;
+    for (let i = 0; i < declaration.namedChildCount; i++) {
+      const c = declaration.namedChild(i);
+      if (!c || c.type !== "init_declarator") continue;
+      const value = c.childForFieldName?.("value");
+      const inner = c.childForFieldName?.("declarator");
+      if (value?.type === "number_literal" && String(value.text ?? "").trim() === "0" && inner?.type === "function_declarator") return true;
+    }
+    return false;
+  }
+  /**
+   * Truth guard for `instantiates`: is this constructed-type name bound by an
+   * enclosing template's parameter list?
+   *
+   * `new Reporter(n)` inside `template <typename Reporter> Reporter*
+   * reporterCreator(...)` constructs a TYPE PARAMETER, not a class, and the
+   * published row named a target no translation unit can declare — measured on
+   * cpp-example as `instantiates -> Reporter` from doctest's
+   * `reporterCreator<Reporter>`, next to `instantiates -> char` from
+   * `new char[4]` (refused by the keyword funnel beside this call). Both are
+   * fabricated rows in the sense the honesty contract cares about: they are
+   * stored, compared against nothing, and unresolvable in every file.
+   *
+   * TWO ARMS, because the binding survives in two spellings:
+   *
+   *   (1) the ORDINARY shape — an ancestor `template_declaration` whose
+   *       `template_parameter_list` is a real node. The walk ascends through every
+   *       one of them (a nested template's inner list can bind a name an outer list
+   *       does not), and the declared names come from `templateParameterNames`.
+   *   (2) the RECOVERY shape — the list is displaced out of the ancestor chain
+   *       entirely, left as a `< … >` frame among the preceding children of the ERROR
+   *       region the grammar produced (`isTemplateParameterListFrame`), introduced by
+   *       the `template` token beside it. Measured at `doctest.h:2104`: that whole
+   *       file is one ERROR region, no `template_declaration` node exists for
+   *       `reporterCreator`, and arm (1) can never see the binding — which is why
+   *       `instantiates -> Reporter` survived this guard's first cut. Both arms ask
+   *       `templateParameterNames` the same question, so the two spellings cannot
+   *       drift apart.
+   *
+   * Arm (2) reads only nodes that START before the construction: a frame written
+   * after it cannot have bound the name.
+   */
+  isTemplateParameterName(node, name) {
+    for (let cur = node.parent, i = 0; cur && i < 64; i++, cur = cur.parent) {
+      if (cur.type === "template_declaration") {
+        const params = this.findChild(cur, "template_parameter_list");
+        if (params && templateParameterNames(params).has(name)) return true;
+        continue;
+      }
+      if (cur.type !== "ERROR") continue;
+      for (let k = 0; k < cur.childCount; k++) {
+        const frame = cur.child(k);
+        if (!frame || frame.startIndex >= node.startIndex) break;
+        if (!isTemplateParameterListFrame(frame)) continue;
+        if (cur.child(k - 1)?.type !== "template") continue;
+        if (frame.startIndex <= node.startIndex && frame.endIndex >= node.endIndex) continue;
+        if (templateParameterNames(frame).has(name)) return true;
+      }
+    }
+    return false;
+  }
+  hasDirectModifier(node, modifier) {
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (!child) continue;
+      if (child.text === modifier) return true;
+      if ((child.type === "type_qualifier" || child.type === "storage_class_specifier" || child.type === "virtual_specifier") && child.text === modifier) {
+        return true;
+      }
+    }
+    const funcDecl = this.findChild(node, "function_declarator");
+    if (funcDecl) {
+      for (let i = 0; i < funcDecl.childCount; i++) {
+        const child = funcDecl.child(i);
+        if (child?.type === "virtual_specifier" && child.text === modifier) return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * #921 (M60): `nameNode` is the node whose text IS the declared name (the
+   * qualified form returns its LAST named child, the constructor/destructor and
+   * operator spellings included). The containment edge needs the line that
+   * NAMES the child — a wrapped return type puts the name one or more lines
+   * below the declaration's start (`void NORETURN` then `CheckFailed(…)`).
+   */
+  getFunctionDetails(node) {
+    let decl = this.findChild(node, "function_declarator");
+    if (!decl) {
+      const WRAPPERS = ["init_declarator", "pointer_declarator", "reference_declarator", "parenthesized_declarator"];
+      let cur = null;
+      for (const w of WRAPPERS) {
+        cur = this.findChild(node, w);
+        if (cur) break;
+      }
+      const enterRecovery = !!this.findChild(node, "compound_statement") || this.recoveryStatesType(cur);
+      for (let i = 0; cur && i < 8; i++) {
+        const found = this.firstDeclaratorIn(cur, enterRecovery);
+        if (found) {
+          decl = found;
+          break;
+        }
+        let next = null;
+        for (const w of WRAPPERS) {
+          next = this.findChild(cur, w);
+          if (next) break;
+        }
+        cur = next;
+      }
+    }
+    if (!decl) return null;
+    let nameNode = null;
+    {
+      let cur = decl;
+      for (let i = 0; cur && i < 8; i++) {
+        nameNode = this.findChild(cur, "identifier") || this.findChild(cur, "field_identifier") || this.findChild(cur, "destructor_name") || this.findChild(cur, "operator_name") || this.findChild(cur, "qualified_identifier");
+        if (nameNode) break;
+        cur = this.findChild(cur, "parenthesized_declarator");
+      }
+    }
+    if (!nameNode) return null;
+    let namedNode = nameNode;
+    let name = nameNode.text;
+    let scope = void 0;
+    let isDestructor = nameNode.type === "destructor_name" || name.startsWith("~");
+    let isOperator = nameNode.type === "operator_name" || name.startsWith("operator");
+    if (!isCppSpelledName(name)) return null;
+    if (nameNode.type === "qualified_identifier") {
+      const parts = qualifiedDeclaratorLeaf(nameNode);
+      const actualNameNode = parts?.nameNode ?? nameNode.namedChild(nameNode.namedChildCount - 1);
+      const scopeQid = parts?.scopeQid ?? null;
+      let scopeNode = null;
+      for (let i = 0; scopeQid && i < scopeQid.namedChildCount - 1; i++) {
+        const c = scopeQid.namedChild(i);
+        if (c && (c.type === "namespace_identifier" || c.type === "type_identifier" || c.type === "identifier")) {
+          scopeNode = c;
+          break;
+        }
+        if (c && c.type === "template_type") {
+          const tname = c.childForFieldName("name") || this.findChild(c, "type_identifier");
+          if (tname) {
+            scopeNode = tname;
+            break;
+          }
+        }
+      }
+      const firstChild = scopeQid?.namedChild(0);
+      if (!scopeNode && firstChild && firstChild.type === "qualified_identifier") {
+        scopeNode = firstChild;
+      }
+      if (actualNameNode) {
+        name = actualNameNode.text;
+        namedNode = actualNameNode;
+        if (scopeNode) scope = scopeNode.text;
+        if (actualNameNode.type === "destructor_name" || name.startsWith("~")) isDestructor = true;
+        if (actualNameNode.type === "operator_name" || name.startsWith("operator")) isOperator = true;
+      }
+    }
+    if (!isPublishableFunctionName(name)) return null;
+    return { name, scope, isDestructor, isOperator, nameNode: namedNode, declarator: decl };
+  }
+  /**
+   * The FIRST `function_declarator` in DOCUMENT order under a declarator wrapper.
+   * `findChild` scans one level, and inside a recovered head the wrapper's DIRECT
+   * children can hold a DECOY the recovery read out of a mem-initializer, while the
+   * declarator the source wrote sits one level deeper, in the grammar's own ERROR:
+   *
+   *   JSON_HEDLEY_NON_NULL(3)
+   *   invalid_iterator(int id_, const char* what_arg) : exception(id_, what_arg) {}
+   *     function_definition[type: JSON_HEDLEY_NON_NULL]
+   *       parenthesized_declarator            <- the macro's own parens
+   *         ERROR                             <- the recovery
+   *           number_literal(3)
+   *           function_declarator(invalid_iterator)   <- the DECLARED name
+   *         function_declarator(exception)            <- the base ctor CALL
+   *
+   * The recovery writes them in source order, so the first is the declared name;
+   * taking the direct child instead published `method invalid_iterator.exception` —
+   * a member named after the class's own BASE, with no parameters and a body it
+   * does not have, while the constructor itself stayed unpublished. Depth is bounded
+   * and the descent stays inside declarator wrappers, so a declarator inside the
+   * function's BODY can never be reached.
+   *
+   * `enterRecovery` gates the descent into an ERROR, and the caller sets it from the
+   * declaration's own evidence: a body, or a TYPE in the recovery. The same recovery
+   * wraps a macro INVOCATION in the macro's parens, and there the ERROR holds an
+   * EXPRESSION, not a declarator — `CHECK(p3.getHairColor() == "blue");` inside a
+   * test macro's body recovers with the CALL's own `function_declarator`, and reading
+   * it published a method nobody declared.
+   */
+  firstDeclaratorIn(container, enterRecovery, depth = 0) {
+    if (depth > 6) return null;
+    for (let i = 0; i < container.namedChildCount; i++) {
+      const c = container.namedChild(i);
+      if (!c) continue;
+      if (c.type === "function_declarator") return c;
+      if (c.type.endsWith("declarator")) {
+        const inner = this.firstDeclaratorIn(c, enterRecovery, depth + 1);
+        if (inner) return inner;
+      } else if (enterRecovery && c.type === "ERROR") {
+        const inner = this.firstDeclaratorIn(c, enterRecovery, depth + 1);
+        if (inner) return inner;
+      }
+    }
+    return null;
+  }
+  /**
+   * The other half of the declaration test for entering a recovery: does the wrapper
+   * the macro left behind STATE A TYPE? That is what separates the declaration the
+   * recovery swallowed from a macro INVOCATION, and the two are one node type apart:
+   *
+   *   JSON_HEDLEY_RETURNS_NON_NULL            CHECK(p3.getHairColor() == "blue");
+   *   char* to_chars(…)                       //  field_declaration
+   *     parenthesized_declarator                parenthesized_declarator
+   *       ERROR                                   ERROR
+   *         identifier(JSON_HEDLEY_…)               identifier(p3)
+   *         primitive_type(char)   <- the TYPE      function_declarator(getHairColor)
+   *         pointer_declarator       <-    (the call, no parameters)
+   *
+   * `char` is the discriminator: only a declaration of something states a type before
+   * its declarator, and `recoveredTypeSpelling` reads it with the same narrowness the
+   * return-type arm uses.
+   */
+  recoveryStatesType(wrapper) {
+    if (!wrapper) return false;
+    for (let i = 0; i < wrapper.namedChildCount; i++) {
+      const c = wrapper.namedChild(i);
+      if (c && c.type === "ERROR" && this.recoveredTypeSpelling(c)) return true;
+    }
+    return false;
+  }
+  /**
+   * D17's premise test: did the recovery leave material BETWEEN the decorator and
+   * the declarator? A decorated head does — the macro's own parens, or an ERROR
+   * holding the displaced type — while `HANDLE Open();` does not, and only the
+   * first can be a decorator. Stops at the declarator, so an unrelated ERROR inside
+   * the function's BODY cannot make a type look decorated.
+   */
+  recoveredDecoratorHead(node, declarator) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (!c || declarator && c.startIndex > declarator.startIndex) break;
+      if (c.type === "ERROR" || c.type === "parenthesized_declarator") return true;
+    }
+    return false;
+  }
+  /**
+   * D18 arm B: the return type the recovery DISPLACED out of the `type` field,
+   * visible as material between the decorator and the declarator:
+   *
+   *   JSON_HEDLEY_NON_NULL(1)                 JSON_HEDLEY_WARN_UNUSED_RESULT
+   *   void grisu2(char* buf, …)                 constexpr bool is_primitive() const
+   *     ERROR[number_literal(1),                  type_qualifier(constexpr)
+   *           primitive_type(void)]               ERROR[identifier(bool)]
+   *
+   * The type is the LAST type the recovery left before the declarator, read
+   * OUTWARD from the declarator (its own ERROR first, then each enclosing node up
+   * to the declaration) so the nearest evidence wins. Returns undefined when the
+   * recovery left no type at all — a constructor's decorated head, where the ERROR
+   * holds only the macro's argument and the declarator.
+   */
+  displacedReturnType(node, declarator) {
+    if (!declarator) return void 0;
+    let cur = declarator;
+    for (let depth = 0; cur && depth < 8; depth++) {
+      const parent = cur.parent;
+      if (!parent) break;
+      if (parent.startIndex < node.startIndex || parent.endIndex > node.endIndex) break;
+      let found = void 0;
+      for (let i = 0; i < parent.namedChildCount; i++) {
+        const c = parent.namedChild(i);
+        if (!c || c.startIndex >= declarator.startIndex) break;
+        const spelling = this.recoveredTypeSpelling(c);
+        if (spelling) found = spelling;
+      }
+      if (found) return found;
+      cur = parent;
+    }
+    return void 0;
+  }
+  /**
+   * The type ONE recovered node states, or undefined when it states none.
+   *
+   * A bare `identifier` counts only when the ERROR holds exactly one named child,
+   * the same narrowness `recoveredDeclaredName` uses for a displaced NAME: `bool`
+   * and `T` arrive that way (the recovery does not classify them as types), and
+   * anything richer is the recovery's own soup rather than a type. A macro
+   * spelling never counts — the decorator is not the type it decorates, which is
+   * the whole point of the arm.
+   */
+  recoveredTypeSpelling(n, depth = 0) {
+    if (depth > 6 || n.type === "function_declarator") return void 0;
+    if (n.type === "ERROR") {
+      if (n.namedChildCount === 1) {
+        const only = n.namedChild(0);
+        if (only && only.type === "identifier") {
+          const single = collapseSpaces(only.text);
+          return single && !isMacroSpelling(single) ? single : void 0;
+        }
+      }
+      let found = void 0;
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (!c || c.type === "function_declarator") break;
+        const spelling = this.recoveredTypeSpelling(c, depth + 1);
+        if (spelling) found = spelling;
+      }
+      return found;
+    }
+    if (n.type === "primitive_type" || n.type === "sized_type_specifier" || n.type === "template_type" || n.type === "qualified_identifier" || n.type === "dependent_type" || n.type === "decltype" || n.type === "struct_specifier" || n.type === "union_specifier" || n.type === "enum_specifier" || n.type === "placeholder_type_specifier" || n.type === "macro_prefixed_type_specifier" || n.type === "type_identifier") {
+      const text = n.type === "macro_prefixed_type_specifier" ? specifierTypeText(n) ?? "" : collapseSpaces(n.text);
+      return text && !isMacroSpelling(text) ? text : void 0;
+    }
+    return void 0;
+  }
+  // ≡ /^[A-Za-z_]\w*$/ (zero-regex helper, M49 closure wave) — full-string
+  // identifier shape: letter/underscore head, word-class tail. CGD19 class:
+  // recovery-artifact type names (qualified, templated, mangled) fail this
+  // and emit no edge.
+  isPlainIdentifier(s) {
+    if (s.length === 0) return false;
+    const c0 = s.charCodeAt(0);
+    const firstOk = c0 >= 65 && c0 <= 90 || c0 >= 97 && c0 <= 122 || c0 === 95;
+    if (!firstOk) return false;
+    for (let i = 1; i < s.length; i++) {
+      const c = s.charCodeAt(i);
+      const ok = c >= 65 && c <= 90 || c >= 97 && c <= 122 || c >= 48 && c <= 57 || c === 95;
+      if (!ok) return false;
+    }
+    return true;
+  }
+  buildFullName(scopeStack, name) {
+    const parts = [];
+    for (let i = 0; i < scopeStack.length; i++) {
+      if (scopeStack[i].kind === ASTEngine.SymbolKind.Namespace) {
+        parts.push(scopeStack[i].name);
+      }
+    }
+    parts.push(name);
+    return parts.join("::");
+  }
+};
+export {
+  CPP_ANONYMOUS,
+  CPP_BUILTIN_TYPE_KEYWORDS,
+  CPP_EXPORT_MARKER_COMPONENTS,
+  CPP_KEYWORDS,
+  CPP_NON_CLASS_STANDARD_TYPES,
+  CPP_ORACLE_CONTRACT,
+  RealCppAnalyzer,
+  attributeDisplacedEnumName,
+  cppExportMarker,
+  cppPureVirtualDeclaration,
+  extendsTargetName,
+  isCppSpelledName,
+  isPublishableFunctionName,
+  macroDeclaredBody,
+  macroInvocationText,
+  qualifiedDeclaratorLeaf,
+  recoveredDeclaredName,
+  sameTsNode,
+  specifierDeclaredName,
+  templateWrappedDeclaratorName
+};