@backbencher/brain 0.0.0-stage → 0.1.1

package/dist/real-csharp-analyzer-ZBNLNJZJ.js

@@ -0,0 +1,3298 @@
+import {
+  findDeclaringParent,
+  localEdgeLabel,
+  localEdgeName
+} from "./chunk-OWISBAOF.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-csharp-analyzer.ts
+function csharpCleanTypeLeaf(text) {
+  const lt = text.indexOf("<");
+  const base = lt > 0 ? text.slice(0, lt) : text;
+  const q = base.indexOf("?");
+  const noQ = q > 0 ? base.slice(0, q) : base;
+  const br = noQ.indexOf("[");
+  return (br > 0 ? noQ.slice(0, br) : noQ).trim();
+}
+function isCSharpNameSeparator(ch) {
+  return ch === "." || ch === "<" || ch === ">" || ch === "," || ch === "[" || ch === "]";
+}
+function csharpTypeNameText(text) {
+  const out = [];
+  let pendingSpace = false;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === "\f" || ch === "\v") {
+      if (out.length > 0) pendingSpace = true;
+      continue;
+    }
+    if (pendingSpace) {
+      const last = out[out.length - 1];
+      if (!isCSharpNameSeparator(last) && !isCSharpNameSeparator(ch)) out.push(" ");
+      pendingSpace = false;
+    }
+    out.push(ch);
+  }
+  return out.join("");
+}
+var CSHARP_DECLARED_TYPE_NODES = /* @__PURE__ */ new Set([
+  "identifier",
+  "generic_name",
+  "qualified_name",
+  "predefined_type",
+  "array_type",
+  "pointer_type",
+  "nullable_type",
+  "ref_type",
+  "tuple_type",
+  // C2a: a `global::`-qualified name with a SINGLE segment is an `alias_qualified_name` — the
+  // grammar only wraps it in a `qualified_name` when the path has a dot after the qualifier. The
+  // set's two consumers are the return-type and indexer-type fallback scans, so without this the
+  // declared-type graph lost the dependency for exactly the qualified spelling it exists to
+  // normalise (measured: `public global::Root RetAlias()` published NO `return_type` ref while
+  // `public Root RetPlain()` published one — script/m14/tmp/cs-alias-position-battery3.ts).
+  "alias_qualified_name"
+]);
+var CSHARP_SYMBOL_DECLARATIONS = /* @__PURE__ */ new Set([
+  "namespace_declaration",
+  "file_scoped_namespace_declaration",
+  "class_declaration",
+  "struct_declaration",
+  "interface_declaration",
+  "record_declaration",
+  "enum_declaration",
+  "enum_member_declaration",
+  "delegate_declaration",
+  "event_declaration",
+  "operator_declaration",
+  "conversion_operator_declaration",
+  "method_declaration",
+  "constructor_declaration",
+  "property_declaration",
+  "indexer_declaration"
+]);
+function csharpMemberDeclaredTypeText(memberLike) {
+  const TYPES = CSHARP_DECLARED_TYPE_NODES;
+  const resolveHolder = (holder2, nameFieldChild2) => {
+    const tf = holder2?.childForFieldName?.("type");
+    if (tf) return String(tf.text ?? "").trim();
+    for (const c of holder2?.namedChildren ?? []) {
+      if (!c || !TYPES.has(c.type)) continue;
+      if (nameFieldChild2 && c.startIndex === nameFieldChild2.startIndex && c.endIndex === nameFieldChild2.endIndex) continue;
+      return String(c.text ?? "").trim();
+    }
+    return null;
+  };
+  if (memberLike.type === "field_declaration") {
+    const vd = memberLike.namedChildren?.find((c) => c.type === "variable_declaration");
+    if (vd) {
+      const t = resolveHolder(vd, null);
+      if (t) return t;
+    }
+  }
+  if (memberLike.type === "variable_declarator") {
+    const parentDecl = memberLike.parent;
+    if (parentDecl && parentDecl.type === "variable_declaration") {
+      const t = resolveHolder(parentDecl, null);
+      if (t) return t;
+    }
+  }
+  const nameFieldChild = memberLike.childForFieldName?.("name") ?? null;
+  const holder = memberLike.type === "field_declaration" ? memberLike.namedChildren?.find((c) => c.type === "variable_declaration") : memberLike;
+  return resolveHolder(holder, nameFieldChild);
+}
+function csharpTargetTypedNewSite(nodeLike) {
+  let isElement = false;
+  let cur = nodeLike.parent;
+  while (cur) {
+    if (cur.type === "collection_expression" || cur.type === "collection_element" || cur.type === "expression_element" || cur.type === "initializer_expression" || cur.type === "array_creation_expression") {
+      isElement = isElement || cur.type === "collection_element" || cur.type === "expression_element" || cur.type === "collection_expression" || cur.type === "initializer_expression" || cur.type === "array_creation_expression";
+    }
+    if (cur.type === "object_creation_expression" || cur.type === "implicit_object_creation_expression" || cur.type === "anonymous_object_creation_expression") {
+      return null;
+    }
+    if (cur.type === "invocation_expression" || cur.type === "argument_list" || // ≡ /^(binary|conditional|prefix_unary|postfix_unary|cast|as_|await|coalesce|conditional_access|element_access|member_access)_expression$/ —
+    // anchored alternation over the fixed expression-node set: endsWith("_expression") + membership excludes arbitrary *_expression node types (equals-check per disjunct; as_* is startsWith).
+    CSHARP_TARGETISH_EXPRESSIONS.has(cur.type)) {
+      return null;
+    }
+    if (cur.type === "variable_declarator" || cur.type === "property_declaration" || cur.type === "indexer_declaration" || cur.type === "field_declaration") {
+      return { kind: "declaration", decl: cur, isElement };
+    }
+    if (cur.type === "assignment_expression") {
+      const lhs = cur.childForFieldName?.("left");
+      if (!lhs) return null;
+      const name = lhs.type === "identifier" ? lhs.text : lhs.childForFieldName?.("name")?.text ?? "";
+      return name ? { kind: "assignment", memberName: name, isElement } : null;
+    }
+    cur = cur.parent;
+  }
+  return null;
+}
+function csharpResolveTargetTypedNew(nodeLike, memberTypes) {
+  const site = csharpTargetTypedNewSite(nodeLike);
+  if (!site) return null;
+  if (site.kind === "declaration") {
+    const declared2 = csharpMemberDeclaredTypeText(site.decl);
+    if (!declared2) return null;
+    if (declared2 === "var") return null;
+    return csharpTargetFromDeclaredType(declared2, site.isElement);
+  }
+  const declared = memberTypes?.get(site.memberName);
+  return declared ? csharpTargetFromDeclaredType(declared, site.isElement) : null;
+}
+function csharpTargetFromDeclaredType(typeText, isElement) {
+  let t = csharpTypeSpelling(typeText).trim();
+  if (t === "var") return "";
+  if (t.endsWith("?")) t = t.slice(0, -1).trim();
+  if (isElement) {
+    const br = t.indexOf("[");
+    if (br > 0) return csharpCleanTypeLeaf(t.slice(0, br));
+    const lt = t.indexOf("<");
+    if (lt > 0 && t.endsWith(">")) {
+      const inner = t.slice(lt + 1, -1);
+      const first = inner.split(",")[0].trim();
+      return csharpCleanTypeLeaf(first);
+    }
+    return csharpCleanTypeLeaf(t);
+  }
+  return csharpCleanTypeLeaf(t);
+}
+var CSHARP_KEYWORDS = /* @__PURE__ */ new Set([
+  "if",
+  "for",
+  "foreach",
+  "while",
+  "do",
+  "switch",
+  "case",
+  "else",
+  "return",
+  "throw",
+  "using",
+  "new",
+  "delegate",
+  "in",
+  "is",
+  "as",
+  "sizeof",
+  "fixed",
+  "lock",
+  "checked",
+  "unchecked",
+  "params",
+  "ref",
+  "out",
+  "base",
+  "this",
+  // CS-B2 (csharp review): `nameof(x)` parses as an invocation_expression
+  // with an identifier callee — without this entry every nameof site
+  // fabricated a `calls -> nameof` edge (probe-verified). `typeof`/`default`
+  // never parse as invocations (dedicated nodes), so only nameof belongs.
+  "get",
+  "set",
+  "nameof"
+]);
+var CSHARP_TARGETISH_EXPRESSIONS = /* @__PURE__ */ new Set([
+  "binary_expression",
+  "conditional_expression",
+  "prefix_unary_expression",
+  "postfix_unary_expression",
+  "cast_expression",
+  "as_expression",
+  "await_expression",
+  "coalesce_expression",
+  "conditional_access_expression",
+  "element_access_expression",
+  "member_access_expression"
+]);
+var CSHARP_BUILTINS = /* @__PURE__ */ new Set([
+  // Console output — filtered (like Java's System.out.println)
+  "Console.WriteLine",
+  "Console.Write",
+  "Console.WriteAsync",
+  "Console.Error.WriteLine",
+  "Console.Error.Write",
+  "Console.Error.WriteAsync",
+  "Console.Out.WriteLine",
+  "Console.Out.Write",
+  "Console.Out.WriteAsync",
+  // System-level noise
+  "Environment.Exit",
+  "Environment.GetEnvironmentVariable",
+  "Environment.GetEnvironmentVariables",
+  "Environment.SetEnvironmentVariable",
+  "GC.Collect",
+  "GC.SuppressFinalize",
+  "GC.WaitForPendingFinalizers",
+  "Debug.WriteLine",
+  "Debug.Write",
+  "Debug.Print",
+  "Trace.WriteLine",
+  "Trace.Write",
+  // Object methods (C# equivalent of Java's Object methods)
+  "ToString",
+  "GetHashCode",
+  "Equals",
+  "GetType",
+  "ReferenceEquals"
+]);
+function csharpUsingDirectiveTarget(node) {
+  if (!node) return null;
+  if (node.hasError) return null;
+  const firstNamed = (pred) => {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c && pred(c)) return c;
+    }
+    return null;
+  };
+  const nameNode = firstNamed((n) => n.type === "identifier" || n.type === "qualified_name" || n.type === "alias_qualified_name");
+  if (!nameNode) return null;
+  let eq = null;
+  for (let i = 0; i < node.childCount; i++) {
+    const c = node.child(i);
+    if (c && c.type === "=") {
+      eq = c;
+      break;
+    }
+  }
+  const aliasNode = eq ? node.childForFieldName?.("name") ?? null : null;
+  let targetAfterEq = null;
+  if (eq) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c && c.startIndex >= eq.endIndex) {
+        targetAfterEq = c;
+        break;
+      }
+    }
+  }
+  const targetNode = targetAfterEq ?? firstNamed((n) => n.type === "qualified_name" || n.type === "alias_qualified_name") ?? nameNode;
+  const spelled = csharpTypeNameText(csharpTypeSpelling(String(targetNode?.text ?? "")));
+  const module = csharpCleanTypeLeaf(spelled);
+  if (!module) return null;
+  return {
+    module: csharpUsingDirectiveModule(targetNode, module),
+    typeArguments: csharpTypeExpressionArguments(targetNode),
+    targetNode,
+    alias: aliasNode ? csharpTypeNameText(String(aliasNode.text ?? "")) : null,
+    kind: csharpUsingDirectiveKind(node, aliasNode != null)
+  };
+}
+function csharpUsingDirectiveModule(targetNode, fallback) {
+  if (targetNode?.type !== "tuple_type") return fallback;
+  const parts = [];
+  for (const el of targetNode.namedChildren ?? []) {
+    if (el?.type !== "tuple_element") continue;
+    const ty = el.childForFieldName?.("type") ?? el.namedChild(0);
+    if (!ty) continue;
+    const leaf = csharpCleanTypeLeaf(csharpTypeNameText(csharpTypeSpelling(String(ty.text ?? ""))));
+    if (leaf) parts.push(leaf);
+  }
+  return parts.length ? `(${parts.join(",")})` : fallback;
+}
+function csharpUsingDirectiveKind(node, hasAlias) {
+  let isGlobal = false;
+  let isStatic = false;
+  for (let i = 0; i < (node?.childCount ?? 0); i++) {
+    const c = node.child(i);
+    if (!c || c.isNamed) continue;
+    if (c.type === "global") isGlobal = true;
+    else if (c.type === "static") isStatic = true;
+  }
+  if (hasAlias) return isGlobal ? "global_alias" : "alias";
+  if (isStatic) return isGlobal ? "global_static" : "static";
+  return isGlobal ? "global_namespace" : "namespace";
+}
+function csharpTypeExpressionArguments(targetNode) {
+  if (!targetNode) return [];
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (raw) => {
+    const name = csharpCleanTypeLeaf(csharpTypeNameText(csharpTypeSpelling(raw)));
+    if (!name || name === "var" || name === "dynamic" || name === "nint" || name === "nuint") return;
+    if (seen.has(name)) return;
+    seen.add(name);
+    out.push(name);
+  };
+  const walkArgument = (n) => {
+    if (!n) return;
+    const t = n.type;
+    if (t === "predefined_type" || t === "implicit_type" || t === "void_keyword") return;
+    if (t === "identifier") {
+      add(String(n.text ?? ""));
+      return;
+    }
+    if (t === "tuple_type") {
+      for (const el of n.namedChildren ?? []) {
+        if (el.type !== "tuple_element") continue;
+        walkArgument(el.childForFieldName?.("type") ?? el.namedChild(0));
+      }
+      return;
+    }
+    if (t === "generic_name") {
+      const base = n.namedChild(0);
+      if (base) walkArgument(base);
+      const args = (n.namedChildren ?? []).find((c) => c.type === "type_argument_list");
+      if (args) for (const a of args.namedChildren ?? []) walkArgument(a);
+      return;
+    }
+    if (t === "qualified_name" || t === "alias_qualified_name") {
+      const leaf = csharpTypeLeafNode(n);
+      if (leaf) {
+        add(String(leaf.text ?? ""));
+        const owner = n.namedChild(n.namedChildCount - 1);
+        if (owner && owner.type === "generic_name") {
+          const args = (owner.namedChildren ?? []).find((c) => c.type === "type_argument_list");
+          if (args) for (const a of args.namedChildren ?? []) walkArgument(a);
+        }
+      }
+      return;
+    }
+    for (const c of n.namedChildren ?? []) walkArgument(c);
+  };
+  const collectFromTarget = (n) => {
+    if (!n) return;
+    const t = n.type;
+    if (t === "generic_name") {
+      const args = (n.namedChildren ?? []).find((c) => c.type === "type_argument_list");
+      if (args) for (const a of args.namedChildren ?? []) walkArgument(a);
+      return;
+    }
+    if (t === "qualified_name" || t === "alias_qualified_name") {
+      const last = n.namedChild(n.namedChildCount - 1);
+      if (last && last.type === "generic_name") collectFromTarget(last);
+      return;
+    }
+    if (t === "array_type" || t === "pointer_type" || t === "nullable_type" || t === "ref_type") {
+      const inner = n.namedChild(0);
+      if (inner) collectFromTarget(inner);
+      return;
+    }
+    if (t === "tuple_type") {
+      for (const el of n.namedChildren ?? []) {
+        if (el.type !== "tuple_element") continue;
+        collectFromTarget(el.childForFieldName?.("type") ?? el.namedChild(0));
+      }
+    }
+  };
+  collectFromTarget(targetNode);
+  return out;
+}
+var CSHARP_BUILTIN_TYPE_SPELLINGS = /* @__PURE__ */ new Set(["dynamic", "nint", "nuint", "var"]);
+var CSHARP_RENDER_HOSTS = /* @__PURE__ */ new Set(["RenderComponent", "RenderChild"]);
+var DOTNET_CITATION_ROOTS = [
+  "System.Text.Json",
+  "Newtonsoft.Json",
+  "System.Xml",
+  "System.Net.Http.Json",
+  "Microsoft.AspNetCore.Http.Json",
+  "BenchmarkDotNet.Exporters.Csv",
+  "BenchmarkDotNet.Exporters.Json"
+];
+function dotnetCitationRoots(target) {
+  const t = String(target ?? "");
+  if (t.length === 0) return [];
+  return DOTNET_CITATION_ROOTS.filter((root) => t === root || t.startsWith(`${root}.`));
+}
+var CSHARP_CALLABLE_DECLARATIONS = /* @__PURE__ */ new Set([
+  "method_declaration",
+  "constructor_declaration",
+  "delegate_declaration",
+  "operator_declaration",
+  "conversion_operator_declaration",
+  "local_function_statement"
+]);
+var CSHARP_TYPE_DECLARATIONS = /* @__PURE__ */ new Set([
+  "class_declaration",
+  "struct_declaration",
+  "interface_declaration",
+  "record_declaration",
+  "enum_declaration"
+]);
+function csharpTypeSpelling(text) {
+  const GLOBAL = "global";
+  if (text.length <= GLOBAL.length + 2) return text;
+  for (let i2 = 0; i2 < GLOBAL.length; i2++) {
+    if (text.charCodeAt(i2) !== GLOBAL.charCodeAt(i2)) return text;
+  }
+  const isWs = (c) => c === 32 || c === 9 || c === 10 || c === 13;
+  let i = GLOBAL.length;
+  while (i < text.length && isWs(text.charCodeAt(i))) i++;
+  if (text.charCodeAt(i) !== 58 || text.charCodeAt(i + 1) !== 58) return text;
+  i += 2;
+  while (i < text.length && isWs(text.charCodeAt(i))) i++;
+  return i < text.length ? text.slice(i) : text;
+}
+function csharpTypeDeclarationKind(node) {
+  switch (node.type) {
+    case "class_declaration":
+      return ASTEngine.SymbolKind.Class;
+    case "record_declaration": {
+      for (let i = 0; i < node.childCount; i++) {
+        const c = node.child(i);
+        if (c && !c.isNamed && c.type === "struct") return ASTEngine.SymbolKind.Struct;
+      }
+      return ASTEngine.SymbolKind.Class;
+    }
+    case "struct_declaration":
+      return ASTEngine.SymbolKind.Struct;
+    case "interface_declaration":
+      return ASTEngine.SymbolKind.Interface;
+    case "enum_declaration":
+      return ASTEngine.SymbolKind.Enum;
+    default:
+      return null;
+  }
+}
+function csharpTypeLeafNode(n) {
+  if (!n) return void 0;
+  const t = n.type;
+  if (t === "identifier") return n;
+  if (t === "generic_name" || t === "primary_constructor_base_type") return csharpTypeLeafNode(n.namedChild(0));
+  if (t === "qualified_name" || t === "alias_qualified_name") return csharpTypeLeafNode(n.namedChild(n.namedChildCount - 1));
+  return void 0;
+}
+function csharpDeclaredTypeLeaves(typeRoot, isBoundTypeParameter) {
+  const acc = [];
+  const accept = (node, raw) => {
+    const name = raw.trim();
+    if (!name || CSHARP_BUILTIN_TYPE_SPELLINGS.has(name)) return;
+    if (isBoundTypeParameter(node, name)) return;
+    acc.push({ node, name });
+  };
+  const walk = (n) => {
+    if (!n) return;
+    const t = n.type;
+    if (t === "predefined_type" || t === "implicit_type" || t === "void_keyword") return;
+    if (t === "identifier") {
+      accept(n, String(n.text ?? ""));
+      return;
+    }
+    if (t === "qualified_name" || t === "alias_qualified_name") {
+      const leaf = csharpTypeLeafNode(n);
+      if (leaf) accept(leaf, String(leaf.text ?? ""));
+      const lastSegment = n.namedChild(n.namedChildCount - 1);
+      if (lastSegment && lastSegment.type === "generic_name") {
+        const args = lastSegment.namedChildren.find((c) => c.type === "type_argument_list");
+        if (args) for (const a of args.namedChildren) walk(a);
+      }
+      return;
+    }
+    if (t === "generic_name" || t === "primary_constructor_base_type") {
+      walk(n.namedChild(0));
+      const args = n.namedChildren.find((c) => c.type === "type_argument_list");
+      if (args) for (const a of args.namedChildren) walk(a);
+      return;
+    }
+    if (t === "tuple_element") {
+      walk(n.childForFieldName("type") ?? n.namedChild(0));
+      return;
+    }
+    for (const c of n.namedChildren) walk(c);
+  };
+  walk(typeRoot);
+  return acc;
+}
+function csharpDeclaredTypeRefs(root) {
+  const out = [];
+  const emitted = /* @__PURE__ */ new Set();
+  const isBoundTypeParameter = (from, name) => {
+    let cur = from;
+    while (cur) {
+      if (cur.type === "class_declaration" || cur.type === "struct_declaration" || cur.type === "interface_declaration" || cur.type === "record_declaration" || cur.type === "method_declaration" || cur.type === "delegate_declaration" || cur.type === "local_function_statement" || cur.type === "operator_declaration" || cur.type === "conversion_operator_declaration") {
+        const tp = cur.childForFieldName("type_parameters") ?? cur.namedChildren.find((c) => c.type === "type_parameter_list");
+        if (tp) {
+          const w = [tp];
+          while (w.length > 0) {
+            const m = w.pop();
+            if ((m.type === "type_parameter" || m.type === "identifier") && m.text.trim() === name) return true;
+            for (const c of m.namedChildren) w.push(c);
+          }
+        }
+      }
+      cur = cur.parent;
+    }
+    return false;
+  };
+  const enclosing = (from, kinds) => {
+    let cur = from.parent;
+    while (cur) {
+      if (kinds.has(cur.type)) {
+        const nm = cur.childForFieldName("name")?.text;
+        if (nm) return nm;
+      }
+      cur = cur.parent;
+    }
+    return "";
+  };
+  const push = (source, typeNode, relationshipType, declaredOn) => {
+    if (!source || !typeNode) return;
+    for (const leaf of csharpDeclaredTypeLeaves(typeNode, isBoundTypeParameter)) {
+      const line = leaf.node.startPosition.row + 1;
+      const key = `${source}\0${leaf.name}\0${line}`;
+      if (emitted.has(key)) continue;
+      emitted.add(key);
+      out.push({ source, target: leaf.name, line, relationshipType, declaredOn });
+    }
+  };
+  const typeRootOf = (n) => {
+    if (!n) return null;
+    const tf = n.childForFieldName("type");
+    if (tf) return tf;
+    if (n.type === "field_declaration" || n.type === "event_field_declaration") {
+      const vd = n.namedChildren.find((c) => c.type === "variable_declaration");
+      return vd ? typeRootOf(vd) : null;
+    }
+    return null;
+  };
+  const returnTypeNode = (n) => {
+    const tf = n.childForFieldName("type");
+    if (tf) return tf;
+    const nameChild = n.childForFieldName("name");
+    for (const c of n.namedChildren) {
+      if (c.type === "modifier" || c.type === "attribute_list" || c.type === "parameter_list" || c.type === "type_parameter_list" || c.type === "block" || c.type === "arrow_expression_clause" || c.type === "where_clause" || c.type === "constructor_initializer" || c.type === "type_parameter_constraints_clause") continue;
+      if (nameChild && c.startIndex === nameChild.startIndex && c.endIndex === nameChild.endIndex) continue;
+      if (CSHARP_DECLARED_TYPE_NODES.has(c.type)) return c;
+    }
+    return null;
+  };
+  const stack = [root];
+  while (stack.length > 0) {
+    const n = stack.pop();
+    switch (n.type) {
+      case "field_declaration":
+      case "event_field_declaration": {
+        const vd = n.namedChildren.find((c) => c.type === "variable_declaration");
+        push(enclosing(n, CSHARP_TYPE_DECLARATIONS), typeRootOf(vd), "declared_type", n.type);
+        break;
+      }
+      case "property_declaration":
+      case "indexer_declaration":
+      case "event_declaration": {
+        push(enclosing(n, CSHARP_TYPE_DECLARATIONS), typeRootOf(n), "declared_type", n.type);
+        break;
+      }
+      case "method_declaration":
+      case "delegate_declaration":
+      case "operator_declaration":
+      case "conversion_operator_declaration": {
+        const owner = n.childForFieldName("name")?.text ?? enclosing(n, CSHARP_TYPE_DECLARATIONS);
+        push(owner, returnTypeNode(n), "return_type", "return_type");
+        break;
+      }
+      case "parameter": {
+        push(enclosing(n, CSHARP_CALLABLE_DECLARATIONS), typeRootOf(n), "declared_type", "parameter");
+        break;
+      }
+      case "variable_declaration": {
+        if (n.parent?.type === "local_declaration_statement") {
+          push(
+            enclosing(n, CSHARP_CALLABLE_DECLARATIONS),
+            typeRootOf(n),
+            "declared_type",
+            "local_declaration_statement"
+          );
+        }
+        break;
+      }
+    }
+    for (const c of n.namedChildren) stack.push(c);
+  }
+  return out;
+}
+var RealCSharpAnalyzer = class {
+  analyze(rootNode, content, filePath, context) {
+    const symbols = [];
+    const relationships = [];
+    const imports = [];
+    const exports = [];
+    const errors = [];
+    const symbolMap = /* @__PURE__ */ new Map();
+    const classHierarchy = /* @__PURE__ */ new Map();
+    const overrideTasks = [];
+    const interfaceTasks = [];
+    const interfaceMembers = /* @__PURE__ */ new Map();
+    const classMembers = /* @__PURE__ */ new Map();
+    const typeKinds = /* @__PURE__ */ new Map();
+    this.collectDeclaredTypeKinds(rootNode, typeKinds);
+    const memberTypes = /* @__PURE__ */ new Map();
+    const memberTypeNodes = /* @__PURE__ */ new Map();
+    this.collectMemberTypes(rootNode, memberTypes, memberTypeNodes);
+    const scopeStack = [];
+    let fileScopedNamespace = void 0;
+    const stack = [{ node: rootNode }];
+    let cyclomaticComplexity = 1;
+    while (stack.length > 0) {
+      const item = stack.pop();
+      const { node, parentContext, isExit } = item;
+      if (isExit) {
+        if (parentContext) {
+          if (scopeStack.length > 0 && scopeStack[scopeStack.length - 1] === parentContext) {
+            scopeStack.pop();
+          }
+        }
+        continue;
+      }
+      if (node.isMissing || node.hasError) {
+        if (node.type === "ERROR" || node.type === "MISSING") {
+          errors.push({
+            message: `Syntax ${node.type} detected.`,
+            range: this.nodeToRange(node),
+            severity: "warning"
+          });
+        }
+      }
+      let newContext = parentContext;
+      const type = node.type;
+      let pushedScope = false;
+      const complexityNodes = /* @__PURE__ */ new Set([
+        "if_statement",
+        "for_statement",
+        "foreach_statement",
+        "while_statement",
+        // CS-B3 (csharp review): BOTH catch forms parse as `catch_clause`
+        // (which CONTAINS an optional `catch_declaration`) — counting the
+        // inner declaration counted typed catches but never bare `catch { }`.
+        // Count the clause instead (exactly once either way); matches
+        // swift's catch_block.
+        "case_switch_label",
+        "catch_clause",
+        "conditional_expression",
+        "logical_and_expression",
+        "logical_or_expression",
+        // CSD2 (re-review 2026-09-04, probe): switch EXPRESSION arms are
+        // decision points exactly like case labels — a 3-arm switch
+        // expression measured complexity 1 (its legacy statement twin
+        // counted every case_switch_label). 42 arms in the first 400 corpus
+        // files were systematically undercounted.
+        "switch_expression_arm"
+      ]);
+      if (complexityNodes.has(type)) cyclomaticComplexity++;
+      if (type === "using_directive") {
+        const nameNode = this.findChild(
+          node,
+          (n) => n.type === "identifier" || n.type === "qualified_name" || n.type === "alias_qualified_name"
+        );
+        if (nameNode) {
+          const usingTarget = csharpUsingDirectiveTarget(node);
+          if (!usingTarget) {
+            if (node.hasError) {
+              errors.push({
+                message: "Syntax ERROR detected in using directive.",
+                range: this.nodeToRange(node),
+                severity: "warning"
+              });
+            }
+            continue;
+          }
+          const { module: text, typeArguments, targetNode: nameNode2, alias: usingAlias, kind: usingKind } = usingTarget;
+          imports.push({
+            module: text,
+            source: text,
+            imported: [],
+            range: this.nodeToRange(node),
+            isTypeOnly: false
+          });
+          relationships.push({
+            source: "root",
+            target: text,
+            type: ASTEngine.RelationshipType.References,
+            confidence: 0.9,
+            // M59.A7 (#825): the line of the node that NAMES the target — the
+            // qualified_name / identifier the using directive writes, which for
+            // the alias form (`using A = B.C;`) is the TARGET, never the alias.
+            // `nodeNamingToken` descends to the last segment's own node, so a
+            // WRAPPED qualified name stamps the line its leaf is written on
+            // rather than the line the name starts on.
+            line_number: this.nodeLine(this.nodeNamingToken(nameNode2, text) ?? nameNode2),
+            // isImport (family contract — c/go emit import deps with isImport)
+            // lets the completeness section-B `imports` pin and the tier
+            // classifier mark this import_based.
+            metadata: {
+              isUsingDirective: true,
+              isImport: true,
+              ...usingAlias ? { isUsingAlias: true, usingAlias } : {}
+            }
+          });
+          for (const arg of typeArguments) {
+            if (arg === text) continue;
+            relationships.push({
+              source: "root",
+              target: arg,
+              type: ASTEngine.RelationshipType.References,
+              confidence: 0.9,
+              line_number: this.nodeLine(this.nodeNamingToken(nameNode2, arg) ?? nameNode2),
+              metadata: { relationshipType: "using_type_argument" }
+            });
+          }
+          const citationRoots = dotnetCitationRoots(text);
+          relationships.push({
+            source: "root",
+            target: text,
+            type: ASTEngine.RelationshipType.Imports,
+            confidence: 1,
+            line_number: this.nodeLine(this.nodeNamingToken(nameNode2, text) ?? nameNode2),
+            metadata: {
+              isUsingDirective: true,
+              isImport: true,
+              relationshipType: "using_import",
+              importKind: usingKind,
+              ...usingAlias ? { isUsingAlias: true, usingAlias } : {},
+              ...citationRoots.length > 0 ? { languageNamespace: citationRoots, languageNamespacePolicy: "strict-absent" } : {}
+            }
+          });
+        }
+      }
+      if (type === "extern_alias_directive") {
+        const aliasNode = node.childForFieldName?.("name") ?? this.findChild(node, "identifier");
+        const aliasText = aliasNode ? csharpTypeNameText(String(aliasNode.text ?? "")) : "";
+        if (aliasText) {
+          imports.push({
+            module: aliasText,
+            source: aliasText,
+            imported: [],
+            range: this.nodeToRange(node),
+            isTypeOnly: false
+          });
+          relationships.push({
+            source: "root",
+            target: aliasText,
+            type: ASTEngine.RelationshipType.Imports,
+            confidence: 1,
+            line_number: this.nodeLine(aliasNode),
+            metadata: {
+              isImport: true,
+              isExternAlias: true,
+              relationshipType: "extern_alias_import",
+              importKind: "extern_alias"
+            }
+          });
+        }
+      }
+      if (type === "namespace_declaration") {
+        if (fileScopedNamespace) {
+          const fi = scopeStack.indexOf(fileScopedNamespace);
+          if (fi >= 0) scopeStack.splice(fi, 1);
+          fileScopedNamespace = void 0;
+        }
+        const rawName = this.extractNamespaceName(node);
+        const fullName = rawName.indexOf(".") >= 0 ? rawName : this.buildFullName(scopeStack, rawName);
+        symbols.push({
+          name: rawName,
+          kind: ASTEngine.SymbolKind.Namespace,
+          range: this.nodeToRange(node),
+          visibility: "public",
+          metadata: { isCSharpNamespace: true, fullName }
+        });
+        newContext = {
+          node,
+          name: rawName,
+          rawName,
+          kind: ASTEngine.SymbolKind.Namespace,
+          fqn: fullName,
+          visibility: "public",
+          isInterface: false,
+          parents: []
+        };
+        scopeStack.push(newContext);
+        pushedScope = true;
+      } else if (type === "file_scoped_namespace_declaration") {
+        if (fileScopedNamespace) {
+          const fi = scopeStack.indexOf(fileScopedNamespace);
+          if (fi >= 0) scopeStack.splice(fi, 1);
+          fileScopedNamespace = void 0;
+        }
+        const rawName = this.extractNamespaceName(node);
+        const fullName = rawName.indexOf(".") >= 0 ? rawName : this.buildFullName(scopeStack, rawName);
+        symbols.push({
+          name: rawName,
+          kind: ASTEngine.SymbolKind.Namespace,
+          range: this.nodeToRange(node),
+          visibility: "public",
+          metadata: { isCSharpNamespace: true, fullName, isFileScoped: true }
+        });
+        fileScopedNamespace = {
+          node,
+          name: rawName,
+          rawName,
+          kind: ASTEngine.SymbolKind.Namespace,
+          fqn: fullName,
+          visibility: "public",
+          isInterface: false,
+          parents: []
+        };
+        newContext = fileScopedNamespace;
+        scopeStack.push(newContext);
+        pushedScope = false;
+      } else if (type === "class_declaration" || type === "struct_declaration" || type === "interface_declaration" || type === "record_declaration") {
+        let rawName = node.childForFieldName("name")?.text || this.childText(node, "identifier") || "anonymous";
+        const fullName = this.buildFullName(scopeStack, rawName);
+        const isInterface = type === "interface_declaration";
+        const kind = csharpTypeDeclarationKind(node) ?? ASTEngine.SymbolKind.Class;
+        const visibility = this.extractVisibility(node);
+        typeKinds.set(rawName, kind);
+        const ownerScope = parentContext?.kind === ASTEngine.SymbolKind.Namespace ? parentContext : fileScopedNamespace && !parentContext ? fileScopedNamespace : void 0;
+        const parents = [];
+        const baseList = this.findChild(node, "base_list");
+        if (baseList) {
+          const baseTypes = [];
+          const baseNodes = [];
+          for (let i = 0; i < baseList.namedChildCount; i++) {
+            const baseType = baseList.namedChild(i);
+            if (!baseType) continue;
+            if (baseType.type === "primary_constructor_base_type") {
+              const tn = this.findChild(baseType, (n) => n.type === "identifier" || n.type === "generic_name");
+              if (tn) {
+                baseTypes.push(this.cleanTypeName(tn.text));
+                baseNodes.push(tn);
+              }
+              continue;
+            }
+            if (baseType.type === "argument_list") continue;
+            baseTypes.push(this.cleanTypeName(csharpTypeNameText(baseType.text)));
+            baseNodes.push(baseType);
+          }
+          if (isInterface) {
+            for (let i = 0; i < baseTypes.length; i++) {
+              const b = baseTypes[i];
+              parents.push(b);
+              relationships.push({
+                source: this.declarationPath(scopeStack, rawName),
+                target: b,
+                type: ASTEngine.RelationshipType.Extends,
+                confidence: 1,
+                line_number: this.nodeLine(this.nodeNamingToken(baseNodes[i], b) ?? baseNodes[i]),
+                metadata: { isInterfaceBase: true }
+              });
+            }
+          } else {
+            const crossFileKinds = context?.typeKinds;
+            for (let i = 0; i < baseTypes.length; i++) {
+              const b = baseTypes[i];
+              parents.push(b);
+              const dotIdx = b.lastIndexOf(".");
+              const leaf = dotIdx > 0 ? b.slice(dotIdx + 1) : b;
+              const declaredKind = typeKinds.get(b) || crossFileKinds?.get(b) || typeKinds.get(leaf) || crossFileKinds?.get(leaf);
+              const isStruct = kind === ASTEngine.SymbolKind.Struct;
+              const looksLikeInterface = !declaredKind && (isStruct || i === 0 && leaf.charCodeAt(0) === 73 && leaf.charCodeAt(1) >= 65 && leaf.charCodeAt(1) <= 90 && leaf.length > 2);
+              const isImplements = declaredKind === ASTEngine.SymbolKind.Interface || looksLikeInterface || i > 0 && !declaredKind;
+              relationships.push({
+                source: this.declarationPath(scopeStack, rawName),
+                target: b,
+                type: isImplements ? ASTEngine.RelationshipType.Implements : ASTEngine.RelationshipType.Extends,
+                confidence: 1,
+                // the leaf's own node: a wrapped qualified base writes its last
+                // segment on a different line than the name starts on
+                line_number: this.nodeLine(this.nodeNamingToken(baseNodes[i], b) ?? baseNodes[i]),
+                metadata: { isImplements }
+              });
+            }
+          }
+        }
+        classHierarchy.set(fullName, parents);
+        if (rawName !== fullName && !classHierarchy.has(rawName)) classHierarchy.set(rawName, parents);
+        const typeParamsNode = this.findChild(node, "type_parameter_list");
+        const genericTypes = [];
+        if (typeParamsNode) {
+          for (let i = 0; i < typeParamsNode.namedChildCount; i++) {
+            const child = typeParamsNode.namedChild(i);
+            if (child) genericTypes.push(child.text);
+          }
+        }
+        const isRecord = stringIncludes(type, "record");
+        const paramList = this.findChild(node, "parameter_list");
+        if (isRecord && paramList) {
+          for (let i = 0; i < paramList.namedChildCount; i++) {
+            const p = paramList.namedChild(i);
+            if (p && p.type === "parameter") {
+              const pName = p.childForFieldName("name")?.text || this.childText(p, "identifier") || "anonymous";
+              const pType = this.extractTypeString(p);
+              symbols.push({
+                name: pName,
+                kind: ASTEngine.SymbolKind.Property,
+                range: this.nodeToRange(p),
+                visibility: "public",
+                ownerName: rawName,
+                ownerKind: kind,
+                metadata: { hasGet: true, hasInit: true, dataType: pType, isRecordProperty: true }
+              });
+            }
+          }
+        }
+        const sym = {
+          name: rawName,
+          kind,
+          range: this.nodeToRange(node),
+          visibility,
+          ownerName: ownerScope ? ownerScope.rawName : parentContext?.rawName,
+          ownerKind: ownerScope ? ownerScope.kind : parentContext?.kind,
+          decorators: this.extractAttributes(node),
+          metadata: {
+            isCSharpType: true,
+            isStruct: kind === ASTEngine.SymbolKind.Struct,
+            isValueType: kind === ASTEngine.SymbolKind.Struct,
+            isRecord,
+            genericTypes: genericTypes.length > 0 ? genericTypes : void 0,
+            fullName,
+            isInterface
+          }
+        };
+        symbols.push(sym);
+        const exportTopLevel = (!parentContext || parentContext.kind === ASTEngine.SymbolKind.Namespace) && !this.hasModifier(node, "file") && visibility === "public";
+        if (exportTopLevel) {
+          this.pushExportInfo(exports, fullName, genericTypes.length, this.nodeLine(node.childForFieldName("name") ?? this.declarationNameNode(node)), kind, visibility);
+        }
+        newContext = {
+          node,
+          name: fullName,
+          rawName,
+          kind,
+          fqn: fullName,
+          visibility,
+          symbolRef: sym,
+          isInterface,
+          parents
+        };
+        scopeStack.push(newContext);
+        pushedScope = true;
+      } else if (type === "enum_declaration") {
+        const rawName = node.childForFieldName("name")?.text || this.childText(node, "identifier") || "anonymous";
+        const fullName = this.buildFullName(scopeStack, rawName);
+        const visibility = this.extractVisibility(node);
+        typeKinds.set(rawName, ASTEngine.SymbolKind.Enum);
+        const ownerScope = parentContext?.kind === ASTEngine.SymbolKind.Namespace ? parentContext : fileScopedNamespace && !parentContext ? fileScopedNamespace : void 0;
+        let baseType;
+        const baseList = this.findChild(node, "base_list");
+        if (baseList) baseType = baseList.namedChild(0)?.text;
+        symbols.push({
+          name: rawName,
+          kind: ASTEngine.SymbolKind.Enum,
+          range: this.nodeToRange(node),
+          visibility,
+          ownerName: ownerScope ? ownerScope.rawName : parentContext?.rawName,
+          ownerKind: ownerScope ? ownerScope.kind : parentContext?.kind,
+          decorators: this.extractAttributes(node),
+          metadata: { isEnum: true, baseType, fullName }
+        });
+        if ((!parentContext || parentContext.kind === ASTEngine.SymbolKind.Namespace) && visibility === "public") {
+          this.pushExportInfo(exports, fullName, 0, this.nodeLine(node.childForFieldName("name") ?? this.declarationNameNode(node)), ASTEngine.SymbolKind.Enum, visibility);
+        }
+        newContext = {
+          node,
+          name: rawName,
+          rawName,
+          kind: ASTEngine.SymbolKind.Enum,
+          fqn: fullName,
+          visibility,
+          isInterface: false,
+          parents: []
+        };
+        scopeStack.push(newContext);
+        pushedScope = true;
+      } else if (type === "enum_member_declaration") {
+        const name = node.childForFieldName("name")?.text || this.childText(node, "identifier") || "anonymous";
+        symbols.push({
+          name,
+          kind: ASTEngine.SymbolKind.EnumMember,
+          range: this.nodeToRange(node),
+          visibility: "public",
+          ownerName: parentContext?.rawName,
+          ownerKind: parentContext?.kind,
+          metadata: {}
+        });
+      } else if (type === "delegate_declaration") {
+        const name = node.childForFieldName("name")?.text || this.childText(node, "identifier") || "anonymous";
+        const returnType = node.childForFieldName("type")?.text || "void";
+        const parameters = [];
+        const paramList = this.findChild(node, "parameter_list");
+        if (paramList) {
+          for (let i = 0; i < paramList.namedChildCount; i++) {
+            const parameter = paramList.namedChild(i);
+            if (parameter?.type !== "parameter") continue;
+            const parameterName = parameter.childForFieldName("name")?.text || "anonymous";
+            parameters.push({ name: parameterName, type: parameter.childForFieldName("type")?.text });
+          }
+        }
+        const visibility = this.extractVisibility(node);
+        const ownerScope = parentContext?.kind === ASTEngine.SymbolKind.Namespace ? parentContext : fileScopedNamespace && !parentContext ? fileScopedNamespace : void 0;
+        const delegateFullName = this.buildFullName(scopeStack, name);
+        const delegateTypeParams = this.findChild(node, "type_parameter_list");
+        const delegateArity = delegateTypeParams ? delegateTypeParams.namedChildCount : 0;
+        symbols.push({
+          name,
+          kind: ASTEngine.SymbolKind.Delegate,
+          range: this.nodeToRange(node),
+          visibility,
+          ownerName: ownerScope ? ownerScope.rawName : parentContext?.rawName,
+          ownerKind: ownerScope ? ownerScope.kind : parentContext?.kind,
+          parameters,
+          returnType,
+          decorators: this.extractAttributes(node),
+          metadata: { isDelegate: true, returnType, fullName: delegateFullName, genericTypes: delegateArity > 0 ? delegateArity : void 0 }
+        });
+        if ((!parentContext || parentContext.kind === ASTEngine.SymbolKind.Namespace) && !this.hasModifier(node, "file") && visibility === "public") {
+          this.pushExportInfo(exports, delegateFullName, delegateArity, this.nodeLine(node.childForFieldName("name") ?? this.declarationNameNode(node)), ASTEngine.SymbolKind.Delegate, visibility);
+        }
+      } else if (type === "event_field_declaration") {
+        const varDecl = this.findChild(node, "variable_declaration");
+        const visibility = this.extractVisibility(node);
+        if (varDecl) {
+          for (let i = 0; i < varDecl.namedChildCount; i++) {
+            const child = varDecl.namedChild(i);
+            if (child && child.type === "variable_declarator") {
+              const name = this.childText(child, "identifier") || "anonymous";
+              this.collectMemberContract(
+                node,
+                name,
+                parentContext,
+                parentContext ? parentContext.fqn : "",
+                parentContext ? `${parentContext.rawName}.${name}` : name,
+                interfaceTasks,
+                interfaceMembers,
+                classMembers,
+                this.findChild(child, (n) => n.type === "identifier") ?? void 0
+              );
+              symbols.push({
+                name,
+                kind: ASTEngine.SymbolKind.Event,
+                range: this.nodeToRange(node),
+                visibility,
+                ownerName: parentContext?.rawName,
+                ownerKind: parentContext?.kind,
+                decorators: this.extractAttributes(node),
+                metadata: { isEvent: true }
+              });
+              if (this.hasModifier(node, "override")) {
+                overrideTasks.push({
+                  fqn: parentContext ? `${parentContext.rawName}.${name}` : name,
+                  methodName: name,
+                  signature: "",
+                  memberKind: "event",
+                  ownerFqn: parentContext ? parentContext.fqn : "",
+                  line: this.nodeLine(this.findChild(child, (n) => n.type === "identifier") ?? child)
+                });
+              }
+            }
+          }
+        }
+      } else if (type === "operator_declaration" || type === "conversion_operator_declaration") {
+        const opField = node.childForFieldName("operator");
+        const convTargetNode = type === "conversion_operator_declaration" ? node.childForFieldName("type") : null;
+        const modifierKeyword = this.anonymousChildNode(node, "implicit") ?? this.anonymousChildNode(node, "explicit");
+        const checkedKeyword = this.anonymousChildNode(node, "checked");
+        const opName = modifierKeyword ? `${modifierKeyword.type}${convTargetNode ? ` ${csharpTypeNameText(csharpTypeSpelling(convTargetNode.text))}` : ""}` : opField ? `operator ${checkedKeyword ? "checked " : ""}${opField.text}` : "operator";
+        const visibility = this.extractVisibility(node);
+        symbols.push({
+          name: opName,
+          kind: ASTEngine.SymbolKind.Method,
+          range: this.nodeToRange(node),
+          visibility,
+          ownerName: parentContext?.rawName,
+          ownerKind: parentContext?.kind,
+          complexity: this.calculateCyclomaticComplexity(node),
+          metadata: { isOperatorOverload: true, isConversionOperator: type === "conversion_operator_declaration" }
+        });
+      } else if (type === "event_declaration") {
+        const nameNode = node.childForFieldName("name");
+        const name = nameNode?.text || this.childText(node, "identifier") || "anonymous";
+        const typeNode = this.findChild(
+          node,
+          (n) => n.type === "qualified_name" || (n.type === "identifier" || n.type === "generic_name") && n.id !== nameNode?.id
+        );
+        this.collectMemberContract(
+          node,
+          name,
+          parentContext,
+          parentContext ? parentContext.fqn : "",
+          parentContext ? `${parentContext.rawName}.${name}` : name,
+          interfaceTasks,
+          interfaceMembers,
+          classMembers
+        );
+        symbols.push({
+          name,
+          kind: ASTEngine.SymbolKind.Event,
+          range: this.nodeToRange(node),
+          visibility: this.extractVisibility(node),
+          ownerName: parentContext?.rawName,
+          ownerKind: parentContext?.kind,
+          decorators: this.extractAttributes(node),
+          metadata: { isEvent: true, isAccessorForm: true, dataType: typeNode?.text }
+        });
+        if (this.hasModifier(node, "override")) {
+          overrideTasks.push({
+            fqn: parentContext ? `${parentContext.rawName}.${name}` : name,
+            methodName: name,
+            signature: "",
+            memberKind: "event",
+            ownerFqn: parentContext ? parentContext.fqn : "",
+            line: this.nodeLine(nameNode ?? this.declarationNameNode(node))
+          });
+        }
+      } else if (type === "constructor_initializer") {
+        const target = this.matchesBaseInitializer(node.text) ? "base" : "this";
+        if (parentContext?.name) {
+          relationships.push({
+            source: parentContext.name === "constructor" ? parentContext.rawName || "constructor" : parentContext.name,
+            target,
+            type: ASTEngine.RelationshipType.Calls,
+            confidence: 0.95,
+            // M59.A7 (#825): the `base`/`this` KEYWORD, not the initializer: the
+            // node starts at the `:` and a wrapped initializer writes the
+            // keyword on the next line. Both tokens are anonymous children.
+            line_number: this.nodeLine(this.initializerKeywordNode(node)),
+            metadata: { isConstructorInitializer: true }
+          });
+        }
+      } else if (type === "method_declaration" || type === "constructor_declaration" || type === "destructor_declaration") {
+        let name = node.childForFieldName("name")?.text || this.childText(node, "identifier") || (type === "constructor_declaration" ? parentContext?.rawName : "anonymous") || "anonymous";
+        if (type === "constructor_declaration") name = "constructor";
+        if (type === "destructor_declaration") name = "Finalize";
+        const visibility = this.extractVisibility(node);
+        const returnType = type === "constructor_declaration" || type === "destructor_declaration" ? "void" : node.childForFieldName("type")?.text || this.extractTypeString(node) || "void";
+        const parameters = [];
+        let isExtensionMethod = false;
+        let sigParams = "";
+        const paramList = this.findChild(node, "parameter_list");
+        if (paramList) {
+          let inParamsForm = false;
+          let paramsTypeNode = null;
+          for (let i = 0; i < paramList.childCount; i++) {
+            const child = paramList.child(i);
+            if (!child) continue;
+            const childType = child.type;
+            if (childType === "params") {
+              inParamsForm = true;
+              paramsTypeNode = null;
+              continue;
+            }
+            if (childType === "parameter") {
+              inParamsForm = false;
+              paramsTypeNode = null;
+              const pName = child.childForFieldName("name")?.text || this.childText(child, "identifier") || "anonymous";
+              const pTypeField = child.childForFieldName("type")?.text;
+              let pType = pTypeField || this.extractTypeString(child) || void 0;
+              if (!pTypeField && pType && pType === pName) pType = void 0;
+              if (child.text.startsWith("this ")) isExtensionMethod = true;
+              parameters.push(pType ? { name: pName, type: pType } : { name: pName });
+              if (sigParams.length > 0) sigParams += ",";
+              sigParams += pType ?? csharpTypeNameText(child.text);
+              continue;
+            }
+            if (!inParamsForm) continue;
+            if (!paramsTypeNode && CSHARP_DECLARED_TYPE_NODES.has(childType)) {
+              paramsTypeNode = child;
+              continue;
+            }
+            if (childType === "identifier" || childType === "generic_name" || childType === "qualified_name") {
+              const pName = csharpTypeNameText(child.text);
+              if (pName.length > 0) {
+                const pType = paramsTypeNode ? csharpTypeNameText(paramsTypeNode.text) : void 0;
+                parameters.push(pType ? { name: pName, type: pType } : { name: pName });
+                if (sigParams.length > 0) sigParams += ",";
+                sigParams += pType ?? pName;
+              }
+              inParamsForm = false;
+              paramsTypeNode = null;
+            }
+          }
+        }
+        const signature = `(${sigParams})`;
+        const ownerFqn = parentContext ? parentContext.fqn : "";
+        const fqn = parentContext ? `${ownerFqn}.${name}${signature}` : `${name}${signature}`;
+        const localOwnerPrefix = parentContext ? `${parentContext.rawName}.${name}${signature}` : `${name}${signature}`;
+        const sym = {
+          name,
+          kind: type === "constructor_declaration" ? ASTEngine.SymbolKind.Constructor : ASTEngine.SymbolKind.Method,
+          range: this.nodeToRange(node),
+          visibility,
+          ownerName: parentContext?.rawName,
+          ownerKind: parentContext?.kind,
+          parameters,
+          returnType,
+          decorators: this.extractAttributes(node),
+          // Per-symbol cyclomatic complexity (family contract — JVM/rust/go/c
+          // all emit symbol.complexity; csharp only had file-level complexity, so
+          // the completeness section-C payload pin was impossible. Added csharp
+          // #264 wave, same counter as the file-level one).
+          complexity: this.calculateCyclomaticComplexity(node),
+          metadata: {
+            returnType,
+            isExtensionMethod,
+            isVirtual: this.hasModifier(node, "virtual"),
+            isOverride: this.hasModifier(node, "override"),
+            isAbstract: this.hasModifier(node, "abstract"),
+            isStatic: this.hasModifier(node, "static")
+          }
+        };
+        symbols.push(sym);
+        symbolMap.set(fqn, sym);
+        symbolMap.set(localOwnerPrefix, sym);
+        this.collectMemberContract(node, name, parentContext, ownerFqn, localOwnerPrefix, interfaceTasks, interfaceMembers, classMembers);
+        if (this.hasModifier(node, "override")) {
+          overrideTasks.push({
+            fqn: localOwnerPrefix,
+            methodName: name,
+            signature,
+            memberKind: "method",
+            ownerFqn,
+            // M59.A7 (#825): the NAME node, not the declaration's start — an
+            // attribute above the override would otherwise be the claimed site
+            // of a name written on the next line.
+            line: this.nodeLine(this.declarationNameNode(node))
+          });
+        }
+        newContext = {
+          node,
+          name,
+          rawName: name,
+          kind: type === "constructor_declaration" ? ASTEngine.SymbolKind.Constructor : ASTEngine.SymbolKind.Method,
+          fqn: ownerFqn,
+          visibility,
+          symbolRef: sym,
+          isInterface: parentContext?.isInterface ?? false,
+          parents: []
+        };
+        scopeStack.push(newContext);
+        pushedScope = true;
+      } else if (type === "invocation_expression") {
+        let inPattern = false;
+        {
+          let q = node.parent;
+          while (q) {
+            const t = q.type;
+            if (t === "constant_pattern" || t === "is_pattern_expression") {
+              inPattern = true;
+              break;
+            }
+            if (t === "invocation_expression" || t.includes("statement") || t.includes("declaration") || t.includes("block") || t.includes("function") || t === "lambda_expression" || t === "local_function_statement" || t === "query_expression" || t === "method_declaration" || t === "constructor_declaration") break;
+            q = q.parent;
+          }
+        }
+        if (inPattern) {
+          for (let i = node.namedChildCount - 1; i >= 0; i--) {
+            const child = node.namedChild(i);
+            if (child) stack.push({ node: child, parentContext: newContext });
+          }
+          continue;
+        }
+        const callExpr = this.buildCSharpCallExpression(node);
+        const calleeNode = this.csharpCallCalleeNode(node);
+        const enclosingKind = parentContext?.kind;
+        const isCallSite = enclosingKind === ASTEngine.SymbolKind.Method || enclosingKind === ASTEngine.SymbolKind.Constructor || enclosingKind === ASTEngine.SymbolKind.Property || // Class-body expression contexts (field/type-member initializers and
+        // attribute arguments) — csharp #264 Station-6: calls like
+        // `Thread.AllocateDataSlot()`, `PSTraceSource.GetTracer(...)`,
+        // `DependencyProperty.Register(...)` in static field initializers
+        // live at class scope, so the enclosing context is the Class/Struct/
+        // Interface, not a method. Previously dropped, the differential
+        // oracle surfaced them ALL as MISSING (it derives every
+        // invocation_expression leaf from `(expr)`).
+        enclosingKind === ASTEngine.SymbolKind.Class || enclosingKind === ASTEngine.SymbolKind.Struct || enclosingKind === ASTEngine.SymbolKind.Interface;
+        const callSource = parentContext?.rawName || "global";
+        if (callExpr && callSource && (isCallSite || !parentContext)) {
+          const target = String(callExpr.split(".").pop() || callExpr).split("<")[0];
+          const isCSharpKeyword = CSHARP_KEYWORDS.has(target);
+          if (!isCSharpKeyword && this.isPlainIdentifier(target) && !this.isCSharpBuiltin(callExpr) && this.isCSharpCalleeNameNode(calleeNode)) {
+            relationships.push({
+              source: callSource,
+              target,
+              type: ASTEngine.RelationshipType.Calls,
+              confidence: 0.9,
+              // M59.A7 (#825): the CALLEE LEAF, never the call node — an
+              // invocation starts at its receiver, so `helper\n  .Strip()`
+              // would otherwise be stamped on the receiver's line.
+              line_number: this.nodeLine(this.csharpCallCalleeNode(node)),
+              metadata: { csharpCallExpression: callExpr }
+            });
+          }
+        }
+        {
+          const fn = node.childForFieldName("function");
+          const nameNode = fn && fn.type === "member_access_expression" ? fn.childForFieldName("name") : fn;
+          if (nameNode && (nameNode.type === "generic_name" || nameNode.type === "identifier")) {
+            const idNode = nameNode.type === "generic_name" ? nameNode.childForFieldName("name") ?? nameNode.namedChild(0) : nameNode;
+            const host = (idNode?.text ?? "").split("<")[0];
+            if (CSHARP_RENDER_HOSTS.has(host)) {
+              const renderSource = parentContext?.rawName || "global";
+              const tal = nameNode.type === "generic_name" ? nameNode.namedChildren.find((c) => c && c.type === "type_argument_list") : void 0;
+              const typeArg = tal?.namedChild(0);
+              if (typeArg) {
+                relationships.push({
+                  source: renderSource,
+                  target: this.cleanTypeName(csharpTypeNameText(typeArg.text)),
+                  type: ASTEngine.RelationshipType.Renders,
+                  confidence: 0.9,
+                  line_number: this.nodeLine(typeArg),
+                  metadata: { isRenderHost: true, renderHost: host }
+                });
+              }
+              const args = node.childForFieldName("arguments");
+              const findTypeof = (n, depth) => {
+                if (depth > 3) return null;
+                for (let i = 0; i < n.namedChildCount; i++) {
+                  const c = n.namedChild(i);
+                  if (!c) continue;
+                  if (c.type === "typeof_expression") return c;
+                  const deeper = findTypeof(c, depth + 1);
+                  if (deeper) return deeper;
+                }
+                return null;
+              };
+              for (const a of args?.namedChildren ?? []) {
+                if (!a) continue;
+                const to = findTypeof(a, 0);
+                if (!to) continue;
+                const tn = this.findChild(to, (n) => n.type === "identifier" || n.type === "qualified_name" || n.type === "generic_name");
+                if (!tn) continue;
+                relationships.push({
+                  source: renderSource,
+                  target: this.cleanTypeName(csharpTypeNameText(tn.text)),
+                  type: ASTEngine.RelationshipType.Renders,
+                  confidence: 0.9,
+                  line_number: this.nodeLine(tn),
+                  metadata: { isRenderHost: true, renderHost: host }
+                });
+              }
+            }
+          }
+        }
+      } else if (type === "object_creation_expression") {
+        const typeNode = this.findChild(
+          node,
+          (n) => n.type === "identifier" || n.type === "generic_name" || n.type === "qualified_name" || n.type === "predefined_type" || // C2a: `new global::Root()` — single-segment alias shape. Without this the edge was
+          // not merely mis-spelled, it was ABSENT (measured: `new Root()` published
+          // `instantiates -> Root` while `new global::Root()` published nothing).
+          n.type === "alias_qualified_name"
+        );
+        if (typeNode) {
+          const source = parentContext?.rawName || "global";
+          relationships.push({
+            source,
+            target: this.cleanTypeName(typeNode.text),
+            type: ASTEngine.RelationshipType.Instantiates,
+            confidence: 0.95,
+            line_number: this.nodeLine(typeNode),
+            metadata: { isNew: true }
+          });
+        }
+      } else if (type === "implicit_object_creation_expression") {
+        const declaredType = this.resolveImplicitNewType(node, memberTypes);
+        if (declaredType) {
+          const source = parentContext?.rawName || "global";
+          relationships.push({
+            source,
+            target: declaredType,
+            type: ASTEngine.RelationshipType.Instantiates,
+            confidence: 0.95,
+            line_number: this.nodeLine(
+              this.targetTypedNewTypeNode(node, memberTypes, memberTypeNodes, declaredType)
+            ),
+            metadata: { isNew: true, isImplicit: true }
+          });
+        }
+      } else if (type === "property_declaration" || type === "indexer_declaration") {
+        const name = type === "indexer_declaration" ? "this" : node.childForFieldName("name")?.text || this.childText(node, "identifier") || "anonymous";
+        const dataType = this.extractTypeString(node);
+        const visibility = this.extractVisibility(node);
+        let hasGet = false;
+        let hasSet = false;
+        let hasInit = false;
+        let isAutoProperty = false;
+        const accessorList = this.findChild(node, "accessor_list");
+        if (accessorList) {
+          isAutoProperty = true;
+          for (let i = 0; i < accessorList.namedChildCount; i++) {
+            const acc = accessorList.namedChild(i);
+            if (acc && acc.type === "accessor_declaration") {
+              const accText = acc.text;
+              if (stringIncludes(accText, "get")) hasGet = true;
+              if (stringIncludes(accText, "set")) hasSet = true;
+              if (stringIncludes(accText, "init")) hasInit = true;
+              if (this.findChild(acc, "block") || this.findChild(acc, "arrow_expression_clause")) {
+                isAutoProperty = false;
+              }
+            }
+          }
+        } else if (this.findChild(node, "arrow_expression_clause")) {
+          hasGet = true;
+        }
+        symbols.push({
+          name,
+          kind: ASTEngine.SymbolKind.Property,
+          range: this.nodeToRange(node),
+          visibility,
+          ownerName: parentContext?.rawName,
+          ownerKind: parentContext?.kind,
+          decorators: this.extractAttributes(node),
+          complexity: this.calculateCyclomaticComplexity(node),
+          metadata: { hasGet, hasSet, hasInit, isAutoProperty, dataType }
+        });
+        this.collectMemberContract(
+          node,
+          name,
+          parentContext,
+          parentContext ? parentContext.fqn : "",
+          parentContext ? `${parentContext.rawName}.${name}` : name,
+          interfaceTasks,
+          interfaceMembers,
+          classMembers
+        );
+        if (this.hasModifier(node, "override")) {
+          overrideTasks.push({
+            fqn: parentContext ? `${parentContext.rawName}.${name}` : name,
+            methodName: name,
+            signature: "",
+            memberKind: type === "indexer_declaration" ? "indexer" : "property",
+            ownerFqn: parentContext ? parentContext.fqn : "",
+            line: this.nodeLine(this.declarationNameNode(node))
+          });
+        }
+        newContext = {
+          node,
+          name,
+          rawName: name,
+          kind: ASTEngine.SymbolKind.Property,
+          fqn: parentContext ? `${parentContext.fqn}.${name}` : name,
+          visibility,
+          symbolRef: symbols[symbols.length - 1],
+          isInterface: parentContext?.isInterface ?? false,
+          parents: []
+        };
+        scopeStack.push(newContext);
+        pushedScope = true;
+      } else if (type === "field_declaration") {
+        const dataType = this.extractTypeString(node);
+        const varDecl = this.findChild(node, "variable_declaration");
+        const visibility = this.extractVisibility(node);
+        if (varDecl) {
+          for (let i = 0; i < varDecl.namedChildCount; i++) {
+            const child = varDecl.namedChild(i);
+            if (child && child.type === "variable_declarator") {
+              const name = this.childText(child, "identifier") || "anonymous";
+              symbols.push({
+                name,
+                kind: ASTEngine.SymbolKind.Property,
+                range: this.nodeToRange(node),
+                visibility,
+                ownerName: parentContext?.rawName,
+                ownerKind: parentContext?.kind,
+                decorators: this.extractAttributes(node),
+                metadata: { dataType, isField: true }
+              });
+              if (this.hasModifier(node, "override")) {
+                const declNameNode = this.findChild(child, (n) => n.type === "identifier") ?? child;
+                overrideTasks.push({
+                  fqn: parentContext ? `${parentContext.rawName}.${name}` : name,
+                  methodName: name,
+                  signature: "",
+                  memberKind: "field",
+                  ownerFqn: parentContext ? parentContext.fqn : "",
+                  line: this.nodeLine(declNameNode)
+                });
+              }
+            }
+          }
+        }
+      }
+      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 membersByOwner = /* @__PURE__ */ new Map();
+    for (const sym of symbols) {
+      if (!sym.ownerName || !sym.name) continue;
+      let set = membersByOwner.get(sym.ownerName);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        membersByOwner.set(sym.ownerName, set);
+      }
+      set.add(sym.name);
+    }
+    this.resolveOverrides(overrideTasks, classHierarchy, symbolMap, relationships, membersByOwner, context?.overrideCompanion);
+    this.resolveInterfaceImplementations(interfaceTasks, classHierarchy, interfaceMembers, classMembers, relationships);
+    const primaryType = symbols.find((s) => {
+      if (s.kind === ASTEngine.SymbolKind.Namespace) return false;
+      if (s.ownerKind && s.ownerKind !== ASTEngine.SymbolKind.Namespace) return false;
+      return s.kind === ASTEngine.SymbolKind.Class || s.kind === ASTEngine.SymbolKind.Interface || s.kind === ASTEngine.SymbolKind.Enum || s.kind === ASTEngine.SymbolKind.Struct || s.kind === ASTEngine.SymbolKind.Delegate;
+    });
+    if (primaryType) {
+      for (const rel of relationships) {
+        if (rel.type === ASTEngine.RelationshipType.References && rel.source === "root") {
+          rel.source = primaryType.name;
+        }
+      }
+    }
+    const containmentSites = this.collectContainmentSites(rootNode);
+    for (const s of symbols) {
+      const _owner = s.ownerName || s.scope;
+      if (_owner) {
+        relationships.push({
+          source: _owner,
+          target: s.name,
+          type: ASTEngine.RelationshipType.Contains,
+          confidence: 1,
+          // M59.A7 (#825): the member's own declaration — but the line its NAME
+          // is written on, which is NOT always the declaration's start line: an
+          // attribute (`[Parameter]`) or a wrapped signature puts the name a
+          // line or more later. Measured on a 200-file draw: the range-start
+          // stamp claimed a line the target is not written on for 653 of 23,924
+          // relationships, every one of them this shape.
+          line_number: this.containmentLine(s, containmentSites),
+          metadata: {}
+        });
+      }
+    }
+    for (const e of exports) {
+      if (typeof e.name !== "string" || typeof e.arity !== "number") continue;
+      relationships.push({
+        source: "root",
+        target: e.name,
+        type: ASTEngine.RelationshipType.Exports,
+        confidence: 1,
+        line_number: typeof e.line === "number" ? e.line : void 0,
+        metadata: {
+          relationshipType: "assembly_public_surface",
+          evidenceClass: "structural",
+          exportForm: "public_top_level_type",
+          visibility: "public",
+          arity: e.arity
+        }
+      });
+    }
+    this.analyzeFieldAccessUses(rootNode, relationships, symbols);
+    this.analyzeCSharpBareIdentifierUses(rootNode, relationships, symbols, classHierarchy);
+    for (const ref of csharpDeclaredTypeRefs(rootNode)) {
+      relationships.push({
+        source: ref.source,
+        target: ref.target,
+        type: ASTEngine.RelationshipType.References,
+        confidence: 0.9,
+        ...ref.line ? { line_number: ref.line } : {},
+        metadata: { relationshipType: ref.relationshipType, declaredOn: ref.declaredOn }
+      });
+    }
+    this.classifyEvidenceTier(relationships);
+    const { detectedFrameworks, frameworkPatterns } = this.detectCSharpFrameworks(rootNode);
+    return {
+      symbols,
+      relationships,
+      imports,
+      exports,
+      errors,
+      metadata: {
+        cyclomaticComplexity,
+        complexity: cyclomaticComplexity,
+        linesOfCode: content.split("\n").length,
+        hasTypeInference: true,
+        framework: detectedFrameworks.length > 0 ? detectedFrameworks[0] : void 0,
+        detectedFrameworks,
+        frameworkPatterns,
+        hasFrameworkIntelligence: true,
+        analysisVersion: "4.1.0-pure-ast-m12"
+      }
+    };
+  }
+  /**
+   * Evidence-tier classification (family contract — mirrors JVM/rust/zig; M14
+   * section D requires >=2 distinct evidenceClass values). Same rules as the
+   * JVM family: structural (grammar clauses, conf 1.0) | usage_contextual
+   * (calls, field access) | import_based (using-directive dependencies) |
+   * reference_qualified (type references) | inferred (confidence < 1 edges).
+   */
+  classifyEvidenceTier(relationships) {
+    for (const r of relationships) {
+      const type = r.type ?? r.relationshipType ?? "";
+      const md = r.metadata ?? {};
+      if (type === "contains") {
+        md.evidenceClass = "structural";
+        continue;
+      }
+      if (type === "references") {
+        md.evidenceClass = md.isUsingDirective || md.isImport ? "import_based" : "reference_qualified";
+        continue;
+      }
+      if (type === "imports") {
+        md.evidenceClass = "import_based";
+        continue;
+      }
+      if (type === "calls" || type === "uses") {
+        md.evidenceClass = (r.confidence ?? 0) >= 0.85 ? "usage_contextual" : "inferred";
+        continue;
+      }
+      if (type === "instantiates" || type === "extends" || type === "implements") {
+        md.evidenceClass = (r.confidence ?? 0) >= 0.9 ? "structural" : "inferred";
+        continue;
+      }
+      if (type === "overrides") {
+        md.evidenceClass = "structural";
+        continue;
+      }
+      if (type === "exports") {
+        md.evidenceClass = "structural";
+        continue;
+      }
+      md.evidenceClass = "usage_contextual";
+    }
+  }
+  /**
+   * CONV-CS-2 (#751): framework detection — the family contract (java
+   * sibling): metadata carries `framework` (deterministic primary pick),
+   * `detectedFrameworks` (always an array, [] when none) and
+   * `frameworkPatterns`. Markers are grammar-level: using-directive roots
+   * (incl. static / alias / global forms), base-list type names and
+   * attribute names. The emitted order is the fixed CS_FRAMEWORK_ORDER
+   * (application frameworks most-specific first, test frameworks last), so
+   * source/import order can never change the payload. String ops only (R2
+   * shrink-only: no new regex literals); edges are untouched — fixtures +
+   * mutants gate this surface.
+   */
+  detectCSharpFrameworks(rootNode) {
+    const usings = /* @__PURE__ */ new Set();
+    const bases = /* @__PURE__ */ new Set();
+    const attributes = /* @__PURE__ */ new Set();
+    const stack = [rootNode];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      const t = n.type;
+      if (t === "using_directive") {
+        const path = csharpUsingDirectivePath(n.text);
+        if (path) usings.add(path);
+        continue;
+      }
+      if (t === "base_list") {
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const leaf = csharpTypeLeafName(n.namedChild(i));
+          if (leaf) bases.add(leaf);
+        }
+      }
+      if (t === "attribute") {
+        const first = n.namedChild(0);
+        const leaf = first ? csharpTypeLeafName(first) : void 0;
+        if (leaf) attributes.add(leaf);
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    const detected = [];
+    for (let i = 0; i < CS_FRAMEWORK_ORDER.length; i++) {
+      const fw = CS_FRAMEWORK_ORDER[i];
+      if (CS_FRAMEWORK_MARKERS[fw](usings, bases, attributes)) detected.push(fw);
+    }
+    return {
+      detectedFrameworks: detected,
+      frameworkPatterns: detected.map((fw) => ({ framework: fw, patterns: CS_FRAMEWORK_PATTERNS[fw] }))
+    };
+  }
+  /**
+   * Per-symbol cyclomatic complexity (family contract — csharp #264 wave).
+   * Same node set as the file-level counter above so per-symbol and
+   * file-level agree; base complexity 1.
+   */
+  calculateCyclomaticComplexity(node) {
+    let complexity = 1;
+    const complexityNodes = /* @__PURE__ */ new Set([
+      "if_statement",
+      "for_statement",
+      "foreach_statement",
+      "while_statement",
+      // CS-B3: `catch_clause` (not `catch_declaration`) — both catch forms
+      // parse as catch_clause containing an optional declaration.
+      "case_switch_label",
+      "catch_clause",
+      "conditional_expression",
+      "logical_and_expression",
+      "logical_or_expression",
+      // CSD2: keep per-symbol in sync with the file-level counter above.
+      "switch_expression_arm"
+    ]);
+    const stack = [node];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (complexityNodes.has(n.type)) complexity++;
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return complexity;
+  }
+  /** Pre-pass: record every type declaration's kind for in-file base-list resolution. */
+  // CSD11: declarator name -> declared type for fields and properties.
+  // Feeds assignment-form target-typed `new()` resolution (see
+  // resolveImplicitNewType). Locals are NOT collected — a local resolved
+  // through an assignment LHS would need a locals map with block scoping;
+  // out of scope here, honestly unresolved instead.
+  collectMemberTypes(rootNode, memberTypes, memberTypeNodes) {
+    const stack = [rootNode];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      const t = n.type;
+      if (t === "field_declaration" || t === "property_declaration") {
+        const isField = t === "field_declaration";
+        const declaredType = csharpMemberDeclaredTypeText(n) ?? void 0;
+        const names = [];
+        if (isField) {
+          const varDecl = this.findChild(n, "variable_declaration");
+          if (varDecl) {
+            for (let i = 0; i < varDecl.namedChildCount; i++) {
+              const d = varDecl.namedChild(i);
+              if (d?.type === "variable_declarator") {
+                const nm = this.childText(d, "identifier");
+                if (nm) names.push(nm);
+              }
+            }
+          }
+        } else {
+          const nm = n.childForFieldName("name")?.text || this.childText(n, "identifier");
+          if (nm) names.push(nm);
+        }
+        const declaredTypeNode = this.memberDeclaredTypeNode(n);
+        if (declaredType) {
+          for (const nm of names) if (!memberTypes.has(nm)) memberTypes.set(nm, declaredType);
+        }
+        if (declaredTypeNode) {
+          for (const nm of names) if (!memberTypeNodes.has(nm)) memberTypeNodes.set(nm, declaredTypeNode);
+        }
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const child = n.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+  }
+  /**
+   * M59.A7 (#825): where each SYMBOL's name is written.
+   *
+   * The containment edge's contract is "the line of the node that NAMES the
+   * target", and for a member that node is the declaration's NAME — which the
+   * symbol's `range` cannot stand in for, because the range starts at the
+   * declaration node and a C# declaration can begin a line or more before its
+   * name (attributes such as `[Parameter]`, modifiers on their own line, a
+   * wrapped signature). One walk over the declarations this analyzer turns into
+   * symbols, keyed by the declaration's start index AND its name, because the
+   * start index alone is ambiguous: a multi-declarator field (`int a, b;`)
+   * produces two symbols that share the field_declaration's range. Keying by
+   * name is also what makes the mapping self-protecting — a symbol whose name the
+   * declaration does NOT write (a constructor is named `constructor`, an
+   * operator `operator +`) finds no entry here and so can never claim a line the
+   * target is not written on.
+   */
+  collectContainmentSites(rootNode) {
+    const named = /* @__PURE__ */ new Map();
+    const synthesized = /* @__PURE__ */ new Set();
+    const stack = [rootNode];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      const t = n.type;
+      if (t === "field_declaration" || t === "event_field_declaration") {
+        const varDecl = this.findChild(n, "variable_declaration");
+        if (varDecl) {
+          for (let i = 0; i < varDecl.namedChildCount; i++) {
+            const d = varDecl.namedChild(i);
+            if (!d || d.type !== "variable_declarator") continue;
+            const id = this.findChild(d, "identifier");
+            if (id) named.set(`${n.startIndex}\0${id.text}`, id.startPosition.row + 1);
+          }
+        }
+      } else if (t === "destructor_declaration" || t === "constructor_declaration") {
+        synthesized.add(n.startIndex);
+      } else if (CSHARP_SYMBOL_DECLARATIONS.has(t)) {
+        const nameNode = this.declarationNameNode(n);
+        if (nameNode) named.set(`${n.startIndex}\0${nameNode.text}`, nameNode.startPosition.row + 1);
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const child = n.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+    return { named, synthesized };
+  }
+  /**
+   * The containment edge's line: the NAME node where the declaration writes the
+   * symbol's name, the declaration's own start line otherwise (a synthesised or
+   * rewritten name still has a navigable declaration, and the oracle classifies
+   * an uncheckable target as `notCheckable` rather than as a failed claim), and
+   * NO line for a declaration whose symbol name is written nowhere in the file.
+   */
+  containmentLine(s, sites) {
+    const start = s.range?.startIndex;
+    if (typeof start !== "number") return void 0;
+    if (sites.synthesized.has(start)) return void 0;
+    return sites.named.get(`${start}\0${s.name}`) ?? s.range?.startLine;
+  }
+  /**
+   * The node that WRITES a declaration's name — the symbol pass's own rule
+   * (`childForFieldName("name")`, then the first identifier), plus the one shape
+   * where the name is not a field: an indexer's symbol is named `this`, which the
+   * grammar writes as an anonymous keyword child.
+   */
+  declarationNameNode(node) {
+    const field = node.childForFieldName("name");
+    if (field) return field;
+    if (node.type === "indexer_declaration") {
+      for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child && child.type === "this") return child;
+      }
+      return null;
+    }
+    return this.findChild(node, "identifier");
+  }
+  collectDeclaredTypeKinds(rootNode, typeKinds) {
+    const stack = [rootNode];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      const t = n.type;
+      if (t === "class_declaration" || t === "struct_declaration" || t === "interface_declaration" || t === "record_declaration" || t === "enum_declaration") {
+        const name = n.childForFieldName("name")?.text || this.childText(n, "identifier");
+        if (name) {
+          const kind = t === "interface_declaration" ? ASTEngine.SymbolKind.Interface : t === "enum_declaration" ? ASTEngine.SymbolKind.Enum : csharpTypeDeclarationKind(n) ?? ASTEngine.SymbolKind.Class;
+          typeKinds.set(name, kind);
+        }
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const child = n.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+  }
+  /**
+   * C923 (#923): record one member declaration for the interface-implementation contract — or,
+   * when the declaration IS the interface's, record the CONTRACT it declares.
+   *
+   * The contract side is indexed under BOTH the interface's FQN and its local name, because a
+   * base-list entry is written either way (`class C : IFoo` / `class C : Ns.IFoo`), and the
+   * resolution below looks the ancestor up by the name the base list actually wrote.
+   */
+  collectMemberContract(node, name, parentContext, ownerFqn, localLabel, tasks, members, classMembers, lineNode) {
+    if (!parentContext) return;
+    const kind = parentContext.kind;
+    if (kind !== ASTEngine.SymbolKind.Class && kind !== ASTEngine.SymbolKind.Struct && kind !== ASTEngine.SymbolKind.Interface) {
+      return;
+    }
+    if (parentContext.isInterface) {
+      for (const key of [parentContext.fqn, parentContext.rawName]) {
+        if (!key) continue;
+        let set = members.get(key);
+        if (!set) {
+          set = /* @__PURE__ */ new Set();
+          members.set(key, set);
+        }
+        set.add(name);
+      }
+      return;
+    }
+    for (const key of [parentContext.fqn, parentContext.rawName]) {
+      if (!key) continue;
+      let set = classMembers.get(key);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        classMembers.set(key, set);
+      }
+      set.add(name);
+    }
+    tasks.push({
+      fqn: localLabel,
+      ownerFqn,
+      memberName: name,
+      explicitIface: this.explicitInterfaceName(node),
+      // M59.A7: the NAME node's line. A field-like event writes its name on a
+      // `variable_declarator`, not on the declaration's `name` field, so the caller passes that
+      // node — otherwise the edge is stamped with an honest-but-avoidable no-line.
+      line: this.nodeLine(lineNode ?? this.declarationNameNode(node))
+    });
+  }
+  /**
+   * The interface an explicit interface member writes (`void IFoo.M()` → `IFoo`). The trailing
+   * `.` is punctuation, not part of the name, so it is cut by a linear scan (no regex).
+   */
+  explicitInterfaceName(node) {
+    const spec = this.findChild(node, (n) => n.type === "explicit_interface_specifier");
+    if (!spec) return null;
+    const cleaned = this.cleanTypeName(spec.text);
+    let end = cleaned.length;
+    while (end > 0) {
+      const c = cleaned.charCodeAt(end - 1);
+      if (c === 46 || c === 32 || c === 9 || c === 10 || c === 13) end--;
+      else break;
+    }
+    const name = cleaned.slice(0, end);
+    return name.length > 0 ? name : null;
+  }
+  /**
+   * C923 (#923): the member-level implements contract, mirroring the family's five-lane
+   * precedent (`overrides M -> I.m`, measured in java, kotlin, typescript, dart and python).
+   *
+   *   explicit (`void IFoo.M()`): ALWAYS. The interface is written in the declaration, so the
+   *     edge is derivable from the tree alone at any scope — measured on csharp's two pinned
+   *     corpora, 215 of 352 explicit members name an interface the corpus text never declares,
+   *     so requiring resolution would drop 61% of a class that needs none.
+   *   implicit (a member that satisfies a base-list interface): only where the member set of
+   *     that interface is KNOWN, which is the case exactly when the interface is declared in
+   *     this file. An interface the analyzer cannot see stays an honest no-edge (measured in the
+   *     full extent: 273 member declarations whose contract lives in another file, and 2,107
+   *     types whose bases are not in the corpus text at all — both disclosed, neither guessed).
+   *
+   * No caller context is consulted, deliberately: a rule that changes with an optional companion
+   * would be a rule a fixture cannot pin (fixtures pass no context), and the family's own doctrine
+   * is that nothing ships unverified. The cross-file extension is measured and registered as an
+   * open scope limit instead (issue #923).
+   *
+   * First ancestor in declaration order that both IS an interface and declares the member wins —
+   * the family's rule for a name-keyed target (cf. findDeclaringParent).
+   */
+  resolveInterfaceImplementations(tasks, classHierarchy, interfaceMembers, classMembers, relationships) {
+    if (tasks.length === 0) return;
+    const declaresMember = (iface, member) => interfaceMembers.get(iface)?.has(member) === true;
+    const emitted = /* @__PURE__ */ new Set();
+    for (const task of tasks) {
+      let target = null;
+      if (task.explicitIface) {
+        target = `${task.explicitIface}.${task.memberName}`;
+      } else if (task.ownerFqn) {
+        const queue = [...classHierarchy.get(task.ownerFqn) ?? []];
+        const seen = /* @__PURE__ */ new Set();
+        while (queue.length > 0) {
+          const parent = queue.shift();
+          if (seen.has(parent)) continue;
+          seen.add(parent);
+          if (declaresMember(parent, task.memberName)) {
+            target = `${parent}.${task.memberName}`;
+            break;
+          }
+          if (classMembers.get(parent)?.has(task.memberName)) continue;
+          for (const next of classHierarchy.get(parent) ?? []) {
+            if (!seen.has(next)) queue.push(next);
+          }
+        }
+      }
+      if (!target) continue;
+      const source = localEdgeLabel(task.fqn);
+      const label = localEdgeName(target);
+      if (!source || !label) continue;
+      const key = `${source}|${label}`;
+      if (emitted.has(key)) continue;
+      emitted.add(key);
+      relationships.push({
+        source,
+        target: label,
+        type: ASTEngine.RelationshipType.Overrides,
+        confidence: 1,
+        line_number: task.line,
+        metadata: {
+          relationshipType: "interface_member_implementation",
+          isCSharpInterfaceImpl: true,
+          explicitInterfaceMember: task.explicitIface != null
+        }
+      });
+    }
+  }
+  resolveOverrides(tasks, classHierarchy, symbolMap, relationships, membersByOwner, companion) {
+    for (const task of tasks) {
+      let targetFqn = null;
+      const memberKind = task.memberKind ?? "method";
+      const isMethod = memberKind === "method";
+      const queue = [];
+      const ownerH = classHierarchy.get(task.ownerFqn);
+      if (ownerH) {
+        for (let i = 0; i < ownerH.length; i++) queue.push(ownerH[i]);
+      }
+      const seen = /* @__PURE__ */ new Set();
+      while (queue.length > 0) {
+        const parent = queue.shift();
+        if (seen.has(parent)) continue;
+        seen.add(parent);
+        if (isMethod) {
+          const potentialTargetFqn = `${parent}.${task.methodName}${task.signature}`;
+          if (symbolMap.has(potentialTargetFqn)) {
+            targetFqn = potentialTargetFqn;
+            break;
+          }
+        } else if (membersByOwner.get(parent)?.has(task.methodName)) {
+          targetFqn = `${parent}.${task.methodName}`;
+          break;
+        }
+        const pH = classHierarchy.get(parent);
+        if (pH) {
+          for (let i = 0; i < pH.length; i++) queue.push(pH[i]);
+        }
+      }
+      if (!targetFqn && isMethod && companion && ownerH && ownerH.length > 0) {
+        const declaring = findDeclaringParent(
+          task.methodName,
+          ownerH,
+          companion,
+          (t) => classHierarchy.get(t) ?? []
+        );
+        if (declaring) targetFqn = `${declaring}.${task.methodName}${task.signature}`;
+      }
+      if (!targetFqn && ownerH && ownerH.length > 0) {
+        targetFqn = `${ownerH[0]}.${task.methodName}${isMethod ? task.signature : ""}`;
+      }
+      if (targetFqn) {
+        const localSource = localEdgeLabel(task.fqn);
+        const localTarget = localEdgeName(targetFqn);
+        relationships.push({
+          source: localSource,
+          target: localTarget,
+          type: ASTEngine.RelationshipType.Overrides,
+          confidence: 1,
+          line_number: task.line,
+          metadata: {
+            relationshipType: isMethod ? "method_override" : `${memberKind}_override`,
+            isCSharpOverride: true,
+            overriddenMemberKind: memberKind
+          }
+        });
+      }
+    }
+  }
+  /**
+   * Field-access Uses pass (csharp #264 wave, Station 3). Emits `uses
+   * containingFn -> field` for member_access_expression on a field (e.g.
+   * `this.Name`, `obj.Radius`) that is NOT the callee of a call. Mirror of the
+   * go/rust selector-uses family contract. Call-callee member accesses are
+   * skipped (calls analysis emits the leaf-target calls edge instead).
+   */
+  analyzeFieldAccessUses(rootNode, relationships, symbols) {
+    const stack = [rootNode];
+    const seen = /* @__PURE__ */ new Set();
+    while (stack.length > 0) {
+      const node = stack.pop();
+      if (node.type === "member_access_expression" || node.type === "member_binding_expression") {
+        let isCallee = false;
+        const parent = node.parent;
+        if (parent && parent.type === "invocation_expression") {
+          const fn = parent.childForFieldName("function");
+          if (fn && fn.id === node.id) isCallee = true;
+        } else if (parent && parent.type === "conditional_access_expression") {
+          const gp = parent.parent;
+          if (gp && gp.type === "invocation_expression" && gp.childForFieldName("function")?.id === parent.id) isCallee = true;
+        }
+        let isLhsWrite = false;
+        {
+          let a = node.parent;
+          while (a && (a.type === "member_access_expression" || a.type === "member_binding_expression")) a = a.parent;
+          if (a && a.type === "assignment_expression") {
+            const lhs = a.childForFieldName("left");
+            if (lhs && lhs.startIndex <= node.startIndex && lhs.endIndex >= node.endIndex) isLhsWrite = true;
+          }
+        }
+        if (!isCallee && !isLhsWrite) {
+          const field = node.childForFieldName("name");
+          const expr = node.childForFieldName("expression");
+          if (field && (expr || node.type === "member_binding_expression")) {
+            const containing = this.findContainingCSharpFunction(node);
+            const src = containing || "global";
+            const tgt = field.text;
+            const key = `${src}.${tgt}`;
+            if (!seen.has(key)) {
+              seen.add(key);
+              relationships.push({
+                source: src,
+                target: tgt,
+                type: ASTEngine.RelationshipType.Uses,
+                confidence: 0.7,
+                // M59.A7 (#825): the member-access NAME field (`obj\n  .Radius`
+                // writes Radius on line 2, the access node starts on line 1).
+                line_number: this.nodeLine(field),
+                metadata: { relationshipType: "csharp_field_access", fieldAccess: key }
+              });
+            }
+          }
+        }
+      }
+      for (let i = node.namedChildCount - 1; i >= 0; i--) {
+        const child = node.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+  }
+  /**
+   * CS-R1: bare-identifier value reads (see the call site for the contract).
+   * Inventory = Property-kind member names keyed by owner (full name and
+   * leaf); resolution walks the lexical class chain innermost-first, then
+   * base classes transitively (capped), then lexically enclosing classes.
+   * Methods, enum members, events and delegates never resolve bare
+   * (method groups, qualified-only members, ruled boundaries).
+   */
+  analyzeCSharpBareIdentifierUses(rootNode, relationships, symbols, classHierarchy) {
+    const importSpans = [];
+    {
+      const importStack = [rootNode];
+      while (importStack.length > 0) {
+        const n = importStack.pop();
+        if (n.type === "using_directive" || n.type === "extern_alias_directive") {
+          importSpans.push([n.startIndex, n.endIndex]);
+          continue;
+        }
+        for (let k = 0; k < n.childCount; k++) {
+          const kid = n.child(k);
+          if (kid) importStack.push(kid);
+        }
+      }
+    }
+    const leafOf = (s) => {
+      const segs = [];
+      for (const a of s.split("::")) {
+        for (const b of a.split(".")) {
+          if (b) segs.push(b);
+        }
+      }
+      return segs.length > 0 ? segs[segs.length - 1] : s;
+    };
+    const membersByOwner = /* @__PURE__ */ new Map();
+    const addMember = (owner, name) => {
+      if (!owner || !name || name === "_") return;
+      for (const key of [owner, leafOf(owner)]) {
+        let s = membersByOwner.get(key);
+        if (!s) {
+          s = /* @__PURE__ */ new Set();
+          membersByOwner.set(key, s);
+        }
+        s.add(name);
+      }
+    };
+    for (const s of symbols) {
+      if (s.kind === ASTEngine.SymbolKind.Property && s.ownerName) addMember(s.ownerName, s.name);
+    }
+    const emitted = /* @__PURE__ */ new Set();
+    const scopeStack = [];
+    scopeStack.push({ names: /* @__PURE__ */ new Set(), cls: null });
+    const isShadowed = (name) => {
+      for (let i = scopeStack.length - 1; i >= 0; i--) {
+        if (scopeStack[i].names.has(name)) return true;
+      }
+      return false;
+    };
+    const isResolvableRead = (name) => {
+      for (let i = scopeStack.length - 1; i >= 0; i--) {
+        const fr = scopeStack[i];
+        if (!fr.cls) continue;
+        const seen = /* @__PURE__ */ new Set();
+        const queue = [fr.cls];
+        let depth = 0;
+        while (queue.length > 0 && depth < 10) {
+          depth++;
+          const cur = queue.shift();
+          if (seen.has(cur)) continue;
+          seen.add(cur);
+          const mm = membersByOwner.get(cur) ?? membersByOwner.get(leafOf(cur));
+          if (mm && mm.has(name)) return true;
+          for (const b of classHierarchy.get(cur) ?? classHierarchy.get(leafOf(cur)) ?? []) {
+            if (!seen.has(b)) queue.push(b);
+          }
+        }
+      }
+      return false;
+    };
+    const firstIdent = (n) => {
+      if (!n) return null;
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c && c.type === "identifier") return c;
+      }
+      return null;
+    };
+    const declaratorName = (declNode) => {
+      let cur = declNode;
+      while (cur) {
+        if (cur.type === "identifier") return cur;
+        let next = null;
+        for (let i = 0; i < cur.namedChildCount; i++) {
+          const c = cur.namedChild(i);
+          if (c && (c.type === "identifier" || c.type.endsWith("declarator"))) {
+            next = c;
+            break;
+          }
+        }
+        if (!next || next === cur) return null;
+        cur = next;
+      }
+      return null;
+    };
+    const declaratorRole = (declNode) => {
+      let cur = declNode.parent;
+      while (cur) {
+        const t = cur.type;
+        if (t === "method_declaration" || t === "constructor_declaration" || t === "destructor_declaration" || t === "operator_declaration" || t === "conversion_operator_declaration" || t === "local_function_statement" || t === "lambda_expression" || t === "block" || t === "accessor_declaration") return "local";
+        if (t === "class_declaration" || t === "struct_declaration" || t === "interface_declaration" || t === "record_declaration" || t === "enum_declaration") return "member";
+        cur = cur.parent;
+      }
+      return "local";
+    };
+    const hasEqualsAfter = (parent, node) => {
+      let sawSelf = false;
+      for (let i = 0; i < parent.childCount; i++) {
+        const c = parent.child(i);
+        if (!c) continue;
+        if (c.startIndex === node.startIndex && c.endIndex === node.endIndex) {
+          sawSelf = true;
+          continue;
+        }
+        if (!c.isNamed && sawSelf && (c.type === "=" || c.type === ":")) return true;
+      }
+      return false;
+    };
+    const stack = [{ node: rootNode, exit: false, pushed: false }];
+    while (stack.length > 0) {
+      const { node, exit, pushed } = stack.pop();
+      if (exit) {
+        if (pushed) scopeStack.pop();
+        continue;
+      }
+      const t = node.type;
+      let pushedScope = false;
+      const top = () => scopeStack.length > 0 ? scopeStack[scopeStack.length - 1] : null;
+      if (t === "method_declaration" || t === "constructor_declaration" || t === "destructor_declaration" || t === "operator_declaration" || t === "conversion_operator_declaration" || t === "local_function_statement") {
+        const frame = { names: /* @__PURE__ */ new Set(), cls: null };
+        const plist = this.findChild(node, (n) => n.type === "parameter_list");
+        if (plist) {
+          for (let i = 0; i < plist.namedChildCount; i++) {
+            const p = plist.namedChild(i);
+            if (!p || p.type !== "parameter") continue;
+            const nm = p.childForFieldName("name") ?? firstIdent(p);
+            if (nm && nm.text !== "_") frame.names.add(nm.text);
+          }
+        }
+        if (t === "local_function_statement") {
+          const nm = node.childForFieldName("name") ?? firstIdent(node);
+          const outer = top();
+          if (outer && nm && nm.text !== "_") outer.names.add(nm.text);
+        }
+        scopeStack.push(frame);
+        pushedScope = true;
+      } else if (t === "block" || t === "lambda_expression" || t === "switch_expression_arm" || t === "query_expression" || t === "foreach_statement" || t === "for_statement" || t === "using_statement" || t === "catch_clause") {
+        if (t === "lambda_expression") {
+          const frame = { names: /* @__PURE__ */ new Set(), cls: null };
+          const walk = [node];
+          while (walk.length > 0) {
+            const m = walk.pop();
+            if (m !== node && (m.type === "block" || m.type === "lambda_expression")) continue;
+            if (m.type === "parameter") {
+              const pn = m.childForFieldName("name") ?? firstIdent(m);
+              if (pn && pn.text !== "_") frame.names.add(pn.text);
+            } else if (m.type === "implicit_parameter") {
+              for (let i = 0; i < m.namedChildCount; i++) {
+                const c = m.namedChild(i);
+                if (c && c.type === "identifier" && c.text !== "_") frame.names.add(c.text);
+              }
+            }
+            for (let i = m.namedChildCount - 1; i >= 0; i--) {
+              const c = m.namedChild(i);
+              if (c) walk.push(c);
+            }
+          }
+          scopeStack.push(frame);
+          pushedScope = true;
+        } else if (t === "foreach_statement") {
+          const frame = { names: /* @__PURE__ */ new Set(), cls: null };
+          const isTypeish = (c) => c.type === "implicit_type" || c.type === "predefined_type" || c.type === "generic_name" || c.type === "qualified_name" || c.type === "nullable_type" || c.type === "array_type" || c.type === "pointer_type" || c.type === "tuple_type" || c.type === "ref_type";
+          const kids = [];
+          for (let i = 0; i < node.namedChildCount; i++) {
+            const c = node.namedChild(i);
+            if (!c || c.type === "block") break;
+            kids.push(c);
+          }
+          const hasType = kids.some((c) => isTypeish(c));
+          if (hasType) {
+            let bound = false;
+            let seen = false;
+            for (const c of kids) {
+              if (isTypeish(c)) {
+                seen = true;
+                continue;
+              }
+              if (!bound && seen && c.type === "identifier" && c.text !== "_") {
+                frame.names.add(c.text);
+                bound = true;
+              }
+            }
+          } else {
+            const ids = kids.filter((c) => c.type === "identifier" && c.text !== "_");
+            for (let i = 1; i + 1 < ids.length; i++) frame.names.add(ids[i].text);
+          }
+          scopeStack.push(frame);
+          pushedScope = true;
+        } else {
+          scopeStack.push({ names: /* @__PURE__ */ new Set(), cls: null });
+          pushedScope = true;
+        }
+      } else if (t === "class_declaration" || t === "struct_declaration" || t === "interface_declaration" || t === "record_declaration") {
+        const frame = { names: /* @__PURE__ */ new Set(), cls: null };
+        const nm = node.childForFieldName("name")?.text ?? firstIdent(node)?.text ?? null;
+        if (nm) frame.cls = nm;
+        if (t !== "record_declaration") {
+          for (let i = 0; i < node.namedChildCount; i++) {
+            const c = node.namedChild(i);
+            if (c && c.type === "parameter_list") {
+              for (let k = 0; k < c.namedChildCount; k++) {
+                const p = c.namedChild(k);
+                if (!p || p.type !== "parameter") continue;
+                const pn = p.childForFieldName("name") ?? firstIdent(p);
+                if (pn && pn.text !== "_") frame.names.add(pn.text);
+              }
+            }
+          }
+        }
+        scopeStack.push(frame);
+        pushedScope = true;
+      } else if (t === "variable_declarator") {
+        if (declaratorRole(node) === "local") {
+          const f = top();
+          const nm = declaratorName(node);
+          if (f && nm && nm.text !== "_") f.names.add(nm.text);
+        }
+      } else if (t === "declaration_pattern") {
+        const f = top();
+        if (f) {
+          for (let i = 1; i < node.namedChildCount; i++) {
+            const c = node.namedChild(i);
+            if (c && c.type === "identifier" && c.text !== "_") f.names.add(c.text);
+          }
+        }
+      } else if (t === "declaration_expression") {
+        const f = top();
+        if (f) {
+          let last = null;
+          for (let i = 0; i < node.namedChildCount; i++) {
+            const c = node.namedChild(i);
+            if (c && c.type === "identifier") last = c;
+          }
+          if (last && last.text !== "_") f.names.add(last.text);
+        }
+      } else if (t === "from_clause" || t === "join_clause" || t === "let_clause") {
+        const f = top();
+        if (f) {
+          const id = firstIdent(node);
+          if (id && id.text !== "_") f.names.add(id.text);
+        }
+      } else if (t === "catch_declaration") {
+        const f = top();
+        if (f) {
+          for (let i = 0; i < node.namedChildCount; i++) {
+            const c = node.namedChild(i);
+            if (!c || c.type !== "identifier" || c.text === "_") continue;
+            let earlier = false;
+            for (let k = 0; k < i; k++) {
+              if (node.namedChild(k)) {
+                earlier = true;
+                break;
+              }
+            }
+            if (earlier) f.names.add(c.text);
+          }
+        }
+      } else if (t === "tuple_expression") {
+        const p = node.parent;
+        if (p && p.type === "assignment_expression" && p.namedChild(0) && node.startIndex >= p.namedChild(0).startIndex && node.endIndex <= (p.namedChild(0).endIndex ?? 0)) {
+          const f = top();
+          if (f) {
+            const isTypeish = (c) => c.type === "implicit_type" || c.type === "predefined_type" || c.type === "generic_name" || c.type === "qualified_name" || c.type === "nullable_type" || c.type === "array_type" || c.type === "pointer_type" || c.type === "tuple_type" || c.type === "ref_type";
+            for (let i = 0; i < node.namedChildCount; i++) {
+              const arg = node.namedChild(i);
+              if (!arg || arg.type !== "argument") continue;
+              const ids = [];
+              let typed = false;
+              for (let k = 0; k < arg.namedChildCount; k++) {
+                const c = arg.namedChild(k);
+                if (!c) continue;
+                if (isTypeish(c)) typed = true;
+                else if (c.type === "identifier" && c.text !== "_") ids.push(c);
+              }
+              const bind = typed ? ids : ids.slice(1);
+              for (const b of bind) f.names.add(b.text);
+            }
+          }
+        }
+      } else if (t === "identifier") {
+        const name = node.text;
+        const p = node.parent;
+        const isAttrName = !!p && p.type === "attribute" && (() => {
+          for (let i = 0; i < p.namedChildCount; i++) {
+            const c = p.namedChild(i);
+            if (c && (c.type === "identifier" || c.type === "generic_name" || c.type === "qualified_name")) {
+              return c.startIndex === node.startIndex && c.endIndex === node.endIndex;
+            }
+          }
+          return false;
+        })();
+        const isNamedArgDesignator = !!p && p.type === "attribute_argument" && (() => {
+          const first = firstIdent(p);
+          return !!first && first.startIndex === node.startIndex && first.endIndex === node.endIndex && hasEqualsAfter(p, node);
+        })();
+        const isAnonDesignator = !!p && (() => {
+          let q = p;
+          while (q && q.type !== "anonymous_object_creation_expression" && q.type !== "block" && q.type !== "method_declaration" && q.type !== "constructor_declaration" && q.type !== "local_function_statement" && q.type !== "lambda_expression") {
+            q = q.parent;
+          }
+          if (!q || q.type !== "anonymous_object_creation_expression") return false;
+          let fresh = true;
+          let foundFirst = false;
+          for (let i = 0; i < q.childCount; i++) {
+            const c = q.child(i);
+            if (!c) continue;
+            if (!c.isNamed) {
+              if (c.type === "," || c.type === ";" || c.type === "{" || c.type === "}") {
+                fresh = true;
+                foundFirst = false;
+              } else if (c.type === "=" || c.type === ":") fresh = false;
+              continue;
+            }
+            if (c.type === "identifier") {
+              if (!foundFirst && fresh) {
+                if (c.startIndex === node.startIndex && c.endIndex === node.endIndex) {
+                  return hasEqualsAfter(q, c);
+                }
+                foundFirst = true;
+              } else {
+                if (c.startIndex === node.startIndex && c.endIndex === node.endIndex) return false;
+              }
+            }
+          }
+          return false;
+        })();
+        const isMemberDesignator = !!p && (p.type === "with_initializer" || p.type === "subpattern") && (() => {
+          const first = firstIdent(p);
+          return !!first && first.startIndex === node.startIndex && first.endIndex === node.endIndex;
+        })();
+        const isOutWrite = !!p && p.type === "argument" && (() => {
+          let sawOut = false;
+          for (let i = 0; i < p.childCount; i++) {
+            const c = p.child(i);
+            if (!c) continue;
+            if (!c.isNamed && c.type === "out") {
+              sawOut = true;
+              continue;
+            }
+            if (c.isNamed) {
+              if (c.type === "declaration_expression") return false;
+              if (c.type === "identifier" && c.startIndex === node.startIndex && c.endIndex === node.endIndex) return sawOut;
+              return false;
+            }
+          }
+          return false;
+        })();
+        const isDeconWrite = (() => {
+          let cur = node;
+          let q = p;
+          while (q && (q.type === "tuple_expression" || q.type === "argument" || q.type === "parenthesized_expression")) {
+            cur = q;
+            q = q.parent;
+          }
+          if (!q || q.type !== "assignment_expression") return false;
+          const lhs = q.namedChild(0);
+          return !!lhs && cur.startIndex >= lhs.startIndex && cur.endIndex <= lhs.endIndex;
+        })();
+        const isMemberDeclName = (() => {
+          if (!p) return false;
+          if (p.type === "variable_declarator") {
+            const nm = declaratorName(p);
+            return !!nm && nm.startIndex === node.startIndex && nm.endIndex === node.endIndex && declaratorRole(p) === "member";
+          }
+          if (p.type === "field_declaration") {
+            const first = firstIdent(p);
+            return !!first && first.startIndex === node.startIndex && first.endIndex === node.endIndex;
+          }
+          return false;
+        })();
+        const isTypeContextName = (() => {
+          if (!p) return false;
+          if (p.type === "type_parameter_list") return true;
+          let q = p;
+          while (q) {
+            const t2 = q.type;
+            if (t2 === "type_parameter_constraints_clause" || t2 === "base_list") return true;
+            if (t2 === "tuple_type") return true;
+            if (t2.includes("statement") || t2.includes("declaration") || t2.includes("block") || t2.includes("function") || t2.includes("body") || t2.includes("clause") && t2 !== "type_parameter_constraints_clause") return false;
+            q = q.parent;
+          }
+          return false;
+        })();
+        const isForeachWrite = !!p && p.type === "foreach_statement" && (() => {
+          let last = null;
+          for (let i = p.namedChildCount - 1; i >= 0; i--) {
+            const c = p.namedChild(i);
+            if (c && c.type !== "block") {
+              last = c;
+              break;
+            }
+          }
+          if (!last || last.type === "block") return false;
+          for (let i = 0; i < p.namedChildCount; i++) {
+            const c = p.namedChild(i);
+            if (!c || c === last || c.type === "block") continue;
+            if (c.type === "identifier" && c.startIndex === node.startIndex && c.endIndex === node.endIndex) return true;
+          }
+          return false;
+        })();
+        const isDeconArgName = !!p && p.type === "argument" && (() => {
+          let q = p.parent;
+          while (q && q.type === "parenthesized_expression") q = q.parent;
+          if (!q || q.type !== "tuple_expression") return false;
+          const a = q.parent;
+          if (!a || a.type !== "assignment_expression") return false;
+          const lhs = a.namedChild(0);
+          if (!lhs || q.startIndex < lhs.startIndex || q.endIndex > (lhs.endIndex ?? 0)) return false;
+          return node.type === "identifier";
+        })();
+        const isImportName = (() => {
+          if (!p) return false;
+          for (let i = 0; i < importSpans.length; i++) {
+            const sp = importSpans[i];
+            if (p.startIndex >= sp[0] && p.endIndex <= sp[1]) return true;
+          }
+          return false;
+        })();
+        if (name && name !== "_" && !isAttrName && !isNamedArgDesignator && !isAnonDesignator && !isMemberDesignator && !isOutWrite && !isDeconWrite && !isDeconArgName && !isMemberDeclName && !isForeachWrite && !isImportName && !isTypeContextName && !this.isInValueSetter(node) && !this.isNameofOperand(node) && !this.isCSharpCallCalleeShaped(node) && !this.isCSharpMemberLeaf(node) && !this.isCSharpQualifiedNamePart(node) && !this.isCSharpNamePosition(node) && !this.isCSharpPreprocText(node) && !this.isCSharpLabelOrDiscard(node) && !this.isCSharpEntityName(node) && !this.isCSharpAssignLhs(node) && !isShadowed(name) && isResolvableRead(name)) {
+          let clsScope = null;
+          for (let i = scopeStack.length - 1; i >= 0; i--) {
+            if (scopeStack[i].cls) {
+              clsScope = scopeStack[i].cls;
+              break;
+            }
+          }
+          const src = this.findContainingCSharpFunction(node) || clsScope || "global";
+          const key = `${src}::uses::${name}`;
+          if (!emitted.has(key)) {
+            emitted.add(key);
+            relationships.push({
+              source: src,
+              target: name,
+              type: ASTEngine.RelationshipType.Uses,
+              confidence: 1,
+              // M59.A7 (#825): the identifier node IS the node that names the
+              // target (this pass visits the read itself).
+              line_number: this.nodeLine(node),
+              metadata: { relationshipType: "identifier_usage", nodeType: node.type }
+            });
+          }
+        }
+      }
+      stack.push({ node, exit: true, pushed: pushedScope });
+      for (let i = node.namedChildCount - 1; i >= 0; i--) {
+        const child = node.namedChild(i);
+        if (child) stack.push({ node: child, exit: false, pushed: false });
+      }
+    }
+  }
+  /**
+   * CS-R1 gate helpers (see analyzeCSharpBareIdentifierUses for the contract).
+   * All climb-based, span-compared (never object identity — web-tree-sitter
+   * wraps per retrieval), mirroring the family gates where they exist.
+   */
+  /** True when `node` is the implicit `value` parameter of a set/init/add/remove accessor. */
+  isInValueSetter(node) {
+    if (node.text !== "value") return false;
+    let cur = node.parent;
+    while (cur) {
+      const t = cur.type;
+      if (t === "accessor_declaration") {
+        for (let i = 0; i < cur.childCount; i++) {
+          const c = cur.child(i);
+          if (c && !c.isNamed && (c.type === "set" || c.type === "init" || c.type === "add" || c.type === "remove")) {
+            return true;
+          }
+        }
+        return false;
+      }
+      if (t === "method_declaration" || t === "constructor_declaration" || t === "local_function_statement" || t === "lambda_expression" || t === "class_declaration" || t === "struct_declaration" || t === "interface_declaration" || t === "record_declaration" || t === "enum_declaration") return false;
+      cur = cur.parent;
+    }
+    return false;
+  }
+  /** True when `node` is (part of) the callee the calls branch owns. */
+  isCSharpCallCalleeShaped(node) {
+    let top = node;
+    let p = node.parent;
+    while (p && (p.type === "generic_name" || p.type === "parenthesized_expression")) {
+      top = p;
+      p = p.parent;
+    }
+    if (p && p.type === "member_access_expression") {
+      const expr = p.childForFieldName("expression");
+      if (expr && node.startIndex >= expr.startIndex && node.endIndex <= expr.endIndex) return false;
+      top = p;
+      p = p.parent;
+    }
+    if (p && p.type === "member_binding_expression") {
+      top = p;
+      p = p.parent;
+      if (p && p.type === "conditional_access_expression") {
+        top = p;
+        p = p.parent;
+      }
+    }
+    if (!p || p.type !== "invocation_expression") return false;
+    const fn = p.childForFieldName("function");
+    return !!fn && top.startIndex >= fn.startIndex && top.endIndex <= fn.endIndex;
+  }
+  /** True when `node` is the member LEAF the field pass owns. */
+  isCSharpMemberLeaf(node) {
+    const p = node.parent;
+    if (!p || p.type !== "member_access_expression") return false;
+    const field = p.childForFieldName("name");
+    return !!field && field.startIndex === node.startIndex && field.endIndex === node.endIndex;
+  }
+  /** True when `node` sits under a qualified_name (types/namespaces — never value reads). */
+  isCSharpQualifiedNamePart(node) {
+    let cur = node.parent;
+    while (cur) {
+      if (cur.type === "qualified_name") return true;
+      cur = cur.parent;
+    }
+    return false;
+  }
+  /** True for name/type positions that never read values. */
+  isCSharpNamePosition(node) {
+    let cur = node.parent;
+    while (cur) {
+      const t = cur.type;
+      if (t === "typeof_expression" || t === "default_expression" || t === "sizeof_expression") return true;
+      if (t === "is_expression" || t === "as_expression") {
+        const first = cur.namedChild(0);
+        return !first || node.startIndex < first.startIndex || node.endIndex > first.endIndex;
+      }
+      if (t.includes("statement") || t.includes("declaration") || t.includes("expression") || t.includes("clause") || t.includes("function") || t.includes("body") || t.includes("pattern") || t.includes("argument")) return false;
+      cur = cur.parent;
+    }
+    return false;
+  }
+  /** True when `node` is the operand of a `nameof(...)` (names, never reads). */
+  isNameofOperand(node) {
+    const calleeIsNameof = (inv) => {
+      const fn = inv.childForFieldName("function");
+      return !!fn && fn.type === "identifier" && fn.text === "nameof";
+    };
+    const p0 = node.parent;
+    if (p0 && p0.type === "invocation_expression") return calleeIsNameof(p0);
+    let cur = p0;
+    while (cur && (cur.type === "argument_list" || cur.type === "argument" || cur.type === "parenthesized_expression")) {
+      cur = cur.parent;
+      if (cur && cur.type === "invocation_expression") return calleeIsNameof(cur);
+    }
+    return false;
+  }
+  /** True for preprocessor-directive text with no code container between (CGD11 contract). */
+  isCSharpPreprocText(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") || t.includes("class_body") || t.includes("field_declaration_list") || t.includes("block")) return false;
+      if (t.startsWith("preproc_")) return true;
+      cur = cur.parent;
+    }
+    return false;
+  }
+  /** True for goto/break/continue/label identifiers (never values). */
+  isCSharpLabelOrDiscard(node) {
+    const p = node.parent;
+    return !!p && (p.type === "goto_statement" || p.type === "break_statement" || p.type === "continue_statement" || p.type === "labeled_statement");
+  }
+  /** True when `node` is the defining NAME of its entity parent, or a TYPE it declares. */
+  /**
+   * CS-D8 helper: is this identifier inside a declared TYPE, judged by which declaration owns a
+   * `type` field that CONTAINS it? See the CS-D8 note in `isCSharpEntityName` for why the walk
+   * ascends through name-shaped wrappers and why it is bounded.
+   */
+  isDeclaredTypeSite(node) {
+    const DECL = "declaration";
+    let cur = node.parent;
+    for (let hops = 0; cur && hops < 12; hops++) {
+      const t = cur.type;
+      if (t === "variable_declaration" || t === "parameter" || t === "property_declaration" || t === "indexer_declaration" || t === "event_declaration" || t === "event_field_declaration" || t === "variable_declarator" || t === "base_list" || t === "type_parameter_list" || t === "type_parameter_constraints_clause" || t === "delegate_declaration") {
+        const tf = cur.childForFieldName("type");
+        if (tf && node.startIndex >= tf.startIndex && node.endIndex <= tf.endIndex) return true;
+        if (t === "variable_declarator") return false;
+      }
+      if (t.includes(DECL) || t === "class_body" || t === "block" || t.includes("statement")) return false;
+      cur = cur.parent;
+    }
+    return false;
+  }
+  isCSharpEntityName(node) {
+    const p = node.parent;
+    if (!p) return false;
+    if (this.isDeclaredTypeSite(node)) return true;
+    {
+      const nf0 = p?.childForFieldName?.("name");
+      if (nf0 && nf0.startIndex === node.startIndex && nf0.endIndex === node.endIndex) return true;
+    }
+    if (p.type === "parameter") {
+      const t = p.childForFieldName("type");
+      if (t && node.startIndex >= t.startIndex && node.endIndex <= t.endIndex) return true;
+    }
+    {
+      const nf = p.childForFieldName("name");
+      if (nf && nf.startIndex === node.startIndex && nf.endIndex === node.endIndex) return true;
+    }
+    switch (p.type) {
+      case "class_declaration":
+      case "struct_declaration":
+      case "interface_declaration":
+      case "record_declaration":
+      case "enum_declaration":
+      case "delegate_declaration":
+      case "method_declaration":
+      case "constructor_declaration":
+      case "destructor_declaration":
+      case "operator_declaration":
+      case "conversion_operator_declaration":
+      case "property_declaration":
+      case "indexer_declaration":
+      case "event_declaration":
+      case "event_field_declaration":
+      case "enum_member_declaration":
+      case "namespace_declaration":
+      case "file_scoped_namespace_declaration":
+        break;
+      default:
+        return false;
+    }
+    for (let i = 0; i < p.namedChildCount; i++) {
+      const c = p.namedChild(i);
+      if (c && c.type === "identifier") {
+        return c.startIndex === node.startIndex && c.endIndex === node.endIndex;
+      }
+    }
+    return false;
+  }
+  /** True when `node` is an assignment-LHS write (GO9-class climb). */
+  isCSharpAssignLhs(node) {
+    let cur = node;
+    let p = node.parent;
+    while (p && p.type === "parenthesized_expression") {
+      cur = p;
+      p = p.parent;
+    }
+    if (!p || p.type !== "assignment_expression") return false;
+    const lhs = p.namedChild(0);
+    return !!lhs && cur.startIndex >= lhs.startIndex && cur.endIndex <= lhs.endIndex;
+  }
+  /** Find the nearest enclosing method/constructor/property symbol name. */
+  findContainingCSharpFunction(node) {
+    let cur = node.parent;
+    while (cur) {
+      if (cur.type === "method_declaration" || cur.type === "constructor_declaration" || cur.type === "destructor_declaration") {
+        const name = cur.childForFieldName("name")?.text || this.childText(cur, "identifier") || (cur.type === "constructor_declaration" ? "constructor" : "anonymous");
+        if (cur.type === "constructor_declaration") return "constructor";
+        if (cur.type === "destructor_declaration") return "Finalize";
+        return name;
+      }
+      if (cur.type === "property_declaration" || cur.type === "indexer_declaration") {
+        return cur.type === "indexer_declaration" ? "this" : cur.childForFieldName("name")?.text || this.childText(cur, "identifier") || "anonymous";
+      }
+      cur = cur.parent;
+    }
+    return null;
+  }
+  buildCSharpCallExpression(node) {
+    const func = node.childForFieldName("function") || this.findChild(node, (n) => n.type === "identifier" || n.type === "generic_name" || n.type === "member_access_expression");
+    if (!func) return null;
+    if (func.type === "member_access_expression") {
+      const nameNode = func.childForFieldName("name");
+      const exprNode = func.childForFieldName("expression");
+      if (!nameNode) return null;
+      const leaf = nameNode.type === "generic_name" ? nameNode.childForFieldName("name")?.text || nameNode.text.split("<")[0] : nameNode.text;
+      if (exprNode) {
+        const expr = this.cleanTypeName(exprNode.text);
+        return `${expr}.${leaf}`;
+      }
+      return leaf;
+    }
+    if (func.type === "generic_name") {
+      return func.childForFieldName("name")?.text || func.text.split("<")[0];
+    }
+    return func.text;
+  }
+  resolveImplicitNewType(node, memberTypes) {
+    return csharpResolveTargetTypedNew(node, memberTypes);
+  }
+  // ≡ /^[A-Za-z_][A-Za-z0-9_]*$/.test(s) — zero-regex helper (M49 closure
+  // wave). \w ≡ [A-Za-z0-9_] in non-unicode mode.
+  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;
+  }
+  // ≡ /:\s*base\s*\(/ (zero-regex helper, M49 closure wave): colon, any
+  // whitespace run, "base", optional whitespace, open paren.
+  matchesBaseInitializer(text) {
+    let i = text.indexOf(":");
+    if (i === -1) return false;
+    i++;
+    while (i < text.length && (text[i] === " " || text[i] === "	" || text[i] === "\n" || text[i] === "\r")) i++;
+    if (!text.startsWith("base", i)) return false;
+    i += 4;
+    while (i < text.length && (text[i] === " " || text[i] === "	" || text[i] === "\n" || text[i] === "\r")) i++;
+    return i < text.length && text[i] === "(";
+  }
+  isCSharpBuiltin(call) {
+    if (CSHARP_BUILTINS.has(call)) return true;
+    const leaf = call.split(".").pop() || call;
+    if (leaf === "ToString" || leaf === "GetHashCode" || leaf === "Equals" || leaf === "GetType" || leaf === "ReferenceEquals") return true;
+    return false;
+  }
+  extractVisibility(node) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child && child.type === "modifier") {
+        const text = child.text;
+        if (text === "public") return "public";
+        if (text === "private") return "private";
+        if (text === "protected") return "protected";
+        if (text === "internal") return "internal";
+        if (text === "file") return "private";
+      }
+    }
+    return void 0;
+  }
+  hasModifier(node, modifier) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child && child.type === "modifier" && child.text === modifier) return true;
+    }
+    return false;
+  }
+  extractNamespaceName(node) {
+    const nameNode = this.findChild(node, (n) => n.type === "qualified_name" || n.type === "identifier");
+    return nameNode ? nameNode.text : "anonymous";
+  }
+  cleanTypeName(text) {
+    const spelled = csharpTypeSpelling(text);
+    const lt = spelled.indexOf("<");
+    const base = lt > 0 ? spelled.slice(0, lt) : spelled;
+    const q = base.indexOf("?");
+    return (q > 0 ? base.slice(0, q) : base).trim();
+  }
+  /**
+   * A type's DECLARATION path: itself, qualified by enclosing TYPE declarations only.
+   *
+   * `buildFullName` qualifies with every enclosing scope including NAMESPACES, which is
+   * right for an FQN and wrong for a relationship source. This lane's hand-audited truth
+   * labels an extends/implements edge at the declared name — `BaseService`, `UserService`,
+   * `Shape`, `IRepository` — and for a NESTED type it keeps the enclosing type but still
+   * drops the namespace: `UserService.User -> BaseService.Entity`, not
+   * `Example.Service.UserService.User`. That is why the nested row matched before this fix
+   * and the seven top-level ones did not: `UserService.User` happens to equal the declared
+   * path while `Example.Base.BaseService` does not.
+   *
+   * So seven false negatives were a label, not a missing edge.
+   */
+  declarationPath(scopeStack, name) {
+    const segs = [];
+    for (let i = 0; i < scopeStack.length; i++) {
+      if (scopeStack[i].kind === ASTEngine.SymbolKind.Namespace) continue;
+      segs.push(scopeStack[i].rawName);
+    }
+    segs.push(name);
+    return segs.join(".");
+  }
+  /**
+   * One assembly-export row per exported TYPE: the fully-qualified name, the declaration's
+   * ARITY (generic arity is identity — `Reporter` and `Reporter<T>` are two types), the NAME's
+   * own line, and the symbol kind. Deduped on (name, arity): `partial` declarations of one type
+   * are ONE exported unit (on the FIRST declaration's line), while a partial split that crosses
+   * arity stays two units. The M49 duplicate-provider invariant is why the dedupe is here.
+   */
+  pushExportInfo(exports, name, arity, line, kind, visibility) {
+    if (!name || visibility !== "public") return;
+    for (const e of exports) if (e.name === name && e.arity === arity) return;
+    exports.push({ name, kind, arity, line, visibility });
+  }
+  buildFullName(scopeStack, name) {
+    if (scopeStack.length === 0) return name;
+    let res = "";
+    for (let i = 0; i < scopeStack.length; i++) {
+      const raw = scopeStack[i].rawName;
+      if (raw.indexOf(".") >= 0) res = raw + ".";
+      else res += raw + ".";
+    }
+    return res + name;
+  }
+  extractTypeString(node) {
+    const typeNodes = [
+      "predefined_type",
+      "type_identifier",
+      "identifier",
+      "generic_name",
+      "array_type",
+      "nullable_type",
+      "tuple_type",
+      "implicit_type"
+    ];
+    for (let idx = 0; idx < typeNodes.length; idx++) {
+      const t = typeNodes[idx];
+      const found = this.findChild(node, (n) => n.type === t);
+      if (found) return found.text;
+    }
+    return void 0;
+  }
+  extractAttributes(node) {
+    const attrs = [];
+    const attrLists = this.findAllChildren(node, "attribute_list");
+    for (let idx = 0; idx < attrLists.length; idx++) {
+      const list = attrLists[idx];
+      for (let i = 0; i < list.namedChildCount; i++) {
+        const attr = list.namedChild(i);
+        if (attr && attr.type === "attribute") {
+          const nameNode = this.findChild(attr, (n) => n.type === "identifier" || n.type === "generic_name" || n.type === "qualified_name" || n.type === "alias_qualified_name");
+          if (nameNode) {
+            const name = csharpCleanTypeLeaf(csharpTypeNameText(csharpTypeSpelling(nameNode.text)));
+            if (name) attrs.push(name);
+          }
+        }
+      }
+    }
+    return attrs;
+  }
+  /**
+   * M59.A7 (#825): the 1-based line of the node that NAMES an edge's target.
+   *
+   * The contract is the family's, not this file's: a relationship's
+   * `line_number` is the line where the TARGET is written — the callee for a
+   * call, the read for a member use, the constructed type for an instantiation,
+   * the symbol's own declaration for contains/overrides. It is checked
+   * independently by script/m59/oracle-callsite.ts, which re-derives every edge
+   * from the tree and requires the target token to appear on the claimed line.
+   *
+   * Three shapes are traps and all three were measured on this lane (probe:
+   * script/m14/tmp/cs-line-shapes.ts) rather than assumed:
+   *   * an invocation node starts at its RECEIVER, so `helper\n  .Strip()` needs
+   *     the callee leaf, not the call node;
+   *   * a `constructor_initializer` starts at its `:` and `base`/`this` are
+   *     anonymous children, so a wrapped initializer needs the keyword token or
+   *     it lands one line early;
+   *   * a target-typed `new()` names NO type at the call site at all — the
+   *     target is written in the DECLARATION (see targetTypedNewTypeNode).
+   *
+   * `undefined` is a first-class answer. A node that does not exist contributes
+   * NO line rather than a fabricated 0, which is the rule `0 means unknown and
+   * unknown must be absent` (#820/#821) applied to this field.
+   */
+  nodeLine(node) {
+    if (!node) return void 0;
+    return node.startPosition.row + 1;
+  }
+  /**
+   * The `base` / `this` keyword of a constructor_initializer.
+   *
+   * Both are ANONYMOUS tokens in tree-sitter-c-sharp, so findChild (named
+   * children only) cannot see them, and the initializer node itself starts at
+   * the `:`. Measured: `public C(int x)\n  :\n    base(x)` puts the colon on 3
+   * and the keyword on 4 — the keyword is the node that names the target.
+   */
+  initializerKeywordNode(node) {
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (child && (child.type === "base" || child.type === "this")) return child;
+    }
+    return null;
+  }
+  /**
+   * The FIRST anonymous child whose text is `text` — an operator or punctuation
+   * token, which `findChild` (named children only) cannot see.
+   *
+   * Added for the M60.R1 paydown: a using directive's alias form is the only
+   * shape that contains an `=`, and position (not text) is what tells the ALIAS
+   * from the TARGET — see the using_directive branch. Returns the NODE, so the
+   * caller can then ask for the child after it as well as its presence.
+   */
+  anonymousChildNode(node, text) {
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (child && child.type === text) return child;
+    }
+    return null;
+  }
+  /** The first NAMED child that starts after `after` ends — the target of an
+   *  alias using, which the grammar writes after the `=`. */
+  firstNamedChildAfter(node, after) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child && child.startIndex >= after.endIndex) return child;
+    }
+    return null;
+  }
+  /**
+   * The node that CARRIES a declaration's declared type.
+   *
+   * Mirrors csharpMemberDeclaredTypeText's holder resolution exactly (the same
+   * three shapes: field_declaration > variable_declaration, a variable_declarator
+   * whose type lives on the enclosing variable_declaration, and property/
+   * indexer/other declarations that hold the type themselves), because the two
+   * must never disagree about WHICH declaration answered — one writes the text,
+   * the other is used for the line stamp.
+   */
+  memberDeclaredTypeNode(memberLike) {
+    if (!memberLike) return null;
+    let holder = memberLike;
+    if (memberLike.type === "field_declaration") {
+      holder = this.findChild(memberLike, "variable_declaration");
+    } else if (memberLike.type === "variable_declarator" && memberLike.parent?.type === "variable_declaration") {
+      holder = memberLike.parent;
+    }
+    if (!holder) return null;
+    const typeField = holder.childForFieldName("type");
+    if (typeField) return typeField;
+    const nameChild = holder.childForFieldName("name");
+    for (let i = 0; i < holder.namedChildCount; i++) {
+      const child = holder.namedChild(i);
+      if (!child || !CSHARP_DECLARED_TYPE_NODES.has(child.type)) continue;
+      if (nameChild && child.startIndex === nameChild.startIndex && child.endIndex === nameChild.endIndex) continue;
+      return child;
+    }
+    return null;
+  }
+  /**
+   * The narrowest node inside a type annotation whose text IS `target`.
+   *
+   * For `List<EnumSettingEntry> xs = new();` the target is the ELEMENT type, so
+   * the node that names it is the type argument, not the annotation. Matching is
+   * by exact text (then by csharpCleanTypeLeaf, which is the same unwrapping the
+   * target text went through), and the narrowest match wins. No match means the
+   * target was resolved from something other than a written name — an honest
+   * no-line, never a guess at a nearby line.
+   */
+  nodeNamingToken(typeNode, target) {
+    if (!typeNode) return null;
+    const parts = target.split(".");
+    const leaf = parts[parts.length - 1] || target;
+    let best = null;
+    const stack = [typeNode];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      const text = n.text;
+      if (text === leaf || csharpCleanTypeLeaf(text) === leaf) {
+        if (!best || n.endIndex - n.startIndex <= best.endIndex - best.startIndex) best = n;
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const child = n.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+    return best;
+  }
+  /**
+   * M59.A7 (#825), the target-typed-`new()` site.
+   *
+   * `List<T> xs = new();` writes its construction target in the DECLARATION, and
+   * the assignment form (`xs = new();`) writes it on the MEMBER's declaration,
+   * not on the assignment line. Both are reached through the shared walk
+   * (csharpTargetTypedNewSite) so the stamp and the resolved target can never
+   * describe different declarations; the member table carries the node for the
+   * assignment form, because the declaration is in another subtree.
+   */
+  targetTypedNewTypeNode(node, memberTypes, memberTypeNodes, target) {
+    const site = csharpTargetTypedNewSite(node);
+    if (!site) return null;
+    const holder = site.kind === "declaration" ? site.decl : memberTypeNodes.get(site.memberName) ?? null;
+    return this.nodeNamingToken(this.memberDeclaredTypeNode(holder), target);
+  }
+  /**
+   * Is a call's callee a node that NAMES something?
+   *
+   * Found by a depth draw rather than by reading the code: on powershell's
+   * `RunspaceConnectionInfo.cs` the grammar's error recovery (one ERROR node
+   * spanning `false; return StartSSHProcessImpl(...)`) produced an
+   * invocation_expression whose `function` field IS a `boolean_literal`, and the
+   * analyzer emitted `calls StartSSHProcess -> false` — a fabricated call to a
+   * literal, the only unexplained edge on a 900-file draw (line 2331, measured
+   * with script/m14/tmp/cs-u2331-probe.ts). The old hygiene checked the target
+   * STRING (keyword set + identifier shape + builtin set), and `false` is a
+   * well-formed identifier as far as a string check can see. The rule is
+   * structural instead: a callee names its target only if the node that carries
+   * it is a NAME node (an identifier or a generic_name) — which is what the
+   * existing keyword-list rejection encodes for the legal `if (...)` case, done
+   * once for every junk-callee shape.
+   */
+  isCSharpCalleeNameNode(node) {
+    if (!node) return false;
+    return node.type === "identifier" || node.type === "generic_name";
+  }
+  /**
+   * The node that names a call's target: the callee leaf.
+   *
+   * Mirrors buildCSharpCallExpression's leaf selection (the member-access NAME
+   * field, a generic_name's name field, else the callee node itself) — that
+   * function returns the text, this returns the node the text is written on.
+   */
+  csharpCallCalleeNode(node) {
+    const func = node.childForFieldName("function") || this.findChild(node, (n) => n.type === "identifier" || n.type === "generic_name" || n.type === "member_access_expression");
+    if (!func) return null;
+    if (func.type === "member_access_expression") {
+      const nameNode = func.childForFieldName("name");
+      if (!nameNode) return null;
+      return nameNode.type === "generic_name" ? nameNode.childForFieldName("name") ?? nameNode : nameNode;
+    }
+    if (func.type === "generic_name") return func.childForFieldName("name") ?? func;
+    if (func.type === "conditional_access_expression" || func.type === "member_binding_expression") {
+      const binding = func.type === "member_binding_expression" ? func : this.findChild(func, (n) => n.type === "member_binding_expression");
+      const leaf = binding ? this.csharpBindingLeaf(binding) : null;
+      return leaf ?? func;
+    }
+    return func;
+  }
+  /**
+   * The identifier a `member_binding_expression` binds: the member name after
+   * the dot (`.Invoke` -> `Invoke`). Walks the binding's children backwards
+   * because the dot is an anonymous token and the name is the last name node.
+   */
+  csharpBindingLeaf(binding) {
+    for (let i = binding.childCount - 1; i >= 0; i--) {
+      const child = binding.child(i);
+      if (!child) continue;
+      if (child.type === "identifier") return child;
+      if (child.type === "generic_name") return child.childForFieldName("name") ?? child;
+    }
+    return null;
+  }
+  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) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (!child) continue;
+      if (typeof type === "string" ? child.type === type : type(child)) 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;
+  }
+};
+function stringIncludes(str, val) {
+  return str.indexOf(val) !== -1;
+}
+var CS_FRAMEWORK_ORDER = [
+  "ASP.NET Core",
+  "Entity Framework Core",
+  "Unity",
+  "WPF",
+  "Windows Forms",
+  "xUnit",
+  "NUnit",
+  "MSTest"
+];
+var CS_FRAMEWORK_PATTERNS = {
+  "ASP.NET Core": ["mvc_pattern", "api_endpoints"],
+  "Entity Framework Core": ["orm_mapping", "repository_pattern"],
+  Unity: ["game_engine"],
+  WPF: ["ui_framework"],
+  "Windows Forms": ["ui_framework"],
+  xUnit: ["test_framework"],
+  NUnit: ["test_framework"],
+  MSTest: ["test_framework"]
+};
+function csharpSetHasAny(s, vs) {
+  for (let i = 0; i < vs.length; i++) if (s.has(vs[i])) return true;
+  return false;
+}
+function csharpUsingPrefix(usings, prefix) {
+  for (const u of usings) {
+    if (u === prefix || u.startsWith(prefix + ".")) return true;
+  }
+  return false;
+}
+var CS_FRAMEWORK_MARKERS = {
+  "ASP.NET Core": (u, b, a) => csharpUsingPrefix(u, "Microsoft.AspNetCore") || csharpSetHasAny(b, ["Controller", "ControllerBase", "PageModel", "Hub"]) || csharpSetHasAny(a, ["ApiController", "HttpGet", "HttpPost", "HttpPut", "HttpDelete", "HttpPatch"]),
+  "Entity Framework Core": (u, b) => csharpUsingPrefix(u, "Microsoft.EntityFrameworkCore") || b.has("DbContext"),
+  Unity: (u, b) => csharpUsingPrefix(u, "UnityEngine") || csharpSetHasAny(b, ["MonoBehaviour", "ScriptableObject"]),
+  WPF: (u, b) => {
+    for (const x of u) {
+      if ((x === "System.Windows" || x.startsWith("System.Windows.")) && !(x === "System.Windows.Forms" || x.startsWith("System.Windows.Forms."))) {
+        return true;
+      }
+    }
+    return csharpSetHasAny(b, ["Window", "UserControl"]);
+  },
+  "Windows Forms": (u, b) => csharpUsingPrefix(u, "System.Windows.Forms") || b.has("Form"),
+  xUnit: (u, _b, a) => csharpUsingPrefix(u, "Xunit") || csharpSetHasAny(a, ["Fact", "Theory"]),
+  NUnit: (u, _b, a) => csharpUsingPrefix(u, "NUnit") || a.has("TestFixture"),
+  MSTest: (u, _b, a) => csharpUsingPrefix(u, "Microsoft.VisualStudio.TestTools") || csharpSetHasAny(a, ["TestClass", "TestMethod"])
+};
+function csharpUsingDirectivePath(text) {
+  let t = text.trim();
+  const semi = t.indexOf(";");
+  if (semi >= 0) t = t.slice(0, semi);
+  t = t.trim();
+  for (; ; ) {
+    if (t.startsWith("global ")) {
+      t = t.slice(7).trim();
+      continue;
+    }
+    if (t.startsWith("using ")) {
+      t = t.slice(6).trim();
+      continue;
+    }
+    if (t.startsWith("static ")) {
+      t = t.slice(7).trim();
+      continue;
+    }
+    break;
+  }
+  const eq = t.indexOf("=");
+  if (eq >= 0) t = t.slice(eq + 1).trim();
+  const space = t.indexOf(" ");
+  if (space >= 0) t = t.slice(0, space);
+  return t.length > 0 ? t : void 0;
+}
+function csharpTypeLeafName(n) {
+  const leaf = csharpTypeLeafNode(n);
+  return leaf ? leaf.text : void 0;
+}
+export {
+  RealCSharpAnalyzer,
+  csharpCleanTypeLeaf,
+  csharpDeclaredTypeRefs,
+  csharpMemberDeclaredTypeText,
+  csharpResolveTargetTypedNew,
+  csharpTargetFromDeclaredType,
+  csharpTargetTypedNewSite,
+  csharpTypeNameText,
+  csharpTypeSpelling,
+  csharpUsingDirectiveKind,
+  csharpUsingDirectiveTarget
+};