@backbencher/brain 0.0.0-stage → 0.1.0

package/dist/real-java-analyzer-CHCW3EKA.js

@@ -0,0 +1,4677 @@
+import {
+  findDeclaringParent,
+  localEdgeLabel,
+  localEdgeName
+} from "./chunk-OWISBAOF.js";
+import {
+  ASTEngine
+} from "./chunk-V44PGPA6.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-java-analyzer.ts
+function stringIncludes(str, val) {
+  return str.indexOf(val) !== -1;
+}
+function isPlainJavaIdentifier(name) {
+  if (name.length === 0) return false;
+  const isStart = (c) => c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === 36 || c === 95;
+  const isPart = (c) => isStart(c) || c >= 48 && c <= 57;
+  if (!isStart(name.charCodeAt(0))) return false;
+  for (let i = 1; i < name.length; i++) {
+    if (!isPart(name.charCodeAt(i))) return false;
+  }
+  return true;
+}
+function javaSigHasTypeVar(sig) {
+  const n = sig.length;
+  let i = 0;
+  while (i < n) {
+    const c = sig[i];
+    if (c === "(" || c === "," || c === ":" || c === "|" || c === "[" || c === "<" || c === "&" || i === 0) {
+      let j = i;
+      while (j < n && (sig[j] === "(" || sig[j] === "[" || sig[j] === " " || sig[j] === ":" || sig[j] === ",")) j++;
+      if (j < n && sig[j] >= "A" && sig[j] <= "Z") {
+        let end = j + 1;
+        while (end < n && (sig[end] >= "A" && sig[end] <= "Z" || sig[end] >= "a" && sig[end] <= "z" || sig[end] >= "0" && sig[end] <= "9" || sig[end] === "_")) end++;
+        if (end === j + 1) return true;
+        i = end;
+        continue;
+      }
+      i = j > i ? j : i + 1;
+      continue;
+    }
+    i++;
+  }
+  return false;
+}
+function splitByChar(text, delim) {
+  const out = [];
+  let start = 0;
+  for (let i = 0; i < text.length; i++) {
+    if (text[i] === delim) {
+      out.push(text.slice(start, i));
+      start = i + 1;
+    }
+  }
+  out.push(text.slice(start));
+  return out;
+}
+function tokenizeWhitespace(text) {
+  const out = [];
+  let cur = "";
+  const flush = () => {
+    if (cur) {
+      out.push(cur);
+      cur = "";
+    }
+  };
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === "\f" || ch === "\v") {
+      flush();
+    } else {
+      cur += ch;
+    }
+  }
+  flush();
+  return out;
+}
+function stripJavaAnnotations(text) {
+  let out = "";
+  let i = 0;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === "@") {
+      i++;
+      while (i < text.length) {
+        const c = text[i];
+        const isWord = c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c >= "0" && c <= "9" || c === "_" || c === "." || c === "$";
+        if (!isWord) break;
+        i++;
+      }
+      while (i < text.length && (text[i] === " " || text[i] === "	" || text[i] === "\n" || text[i] === "\r")) i++;
+      if (text[i] === "(") {
+        let depth = 0;
+        while (i < text.length) {
+          if (text[i] === "(") depth++;
+          else if (text[i] === ")") {
+            depth--;
+            if (depth === 0) {
+              i++;
+              break;
+            }
+          }
+          i++;
+        }
+      }
+      while (i < text.length && (text[i] === " " || text[i] === "	" || text[i] === "\n" || text[i] === "\r")) i++;
+      continue;
+    }
+    out += ch;
+    i++;
+  }
+  return out;
+}
+var JAVA_FRAMEWORK_PRIORITY = [
+  "spring_data",
+  "spring_mvc",
+  "spring_core",
+  "spring",
+  "jpa",
+  "hibernate",
+  "mybatis",
+  "quarkus",
+  "micronaut",
+  "jackson",
+  "slf4j"
+];
+var JAVA_RESERVED = /* @__PURE__ */ new Set([
+  "abstract",
+  "assert",
+  "boolean",
+  "break",
+  "byte",
+  "case",
+  "catch",
+  "char",
+  "class",
+  "const",
+  "continue",
+  "default",
+  "do",
+  "double",
+  "else",
+  "enum",
+  "extends",
+  "final",
+  "finally",
+  "float",
+  "for",
+  "goto",
+  "if",
+  "implements",
+  "import",
+  "instanceof",
+  "int",
+  "interface",
+  "long",
+  "native",
+  "new",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "return",
+  "short",
+  "static",
+  "strictfp",
+  "super",
+  "switch",
+  "synchronized",
+  "this",
+  "throw",
+  "throws",
+  "transient",
+  "try",
+  "void",
+  "volatile",
+  "while",
+  "true",
+  "false",
+  "null",
+  "_",
+  "var",
+  "yield",
+  "record",
+  "sealed",
+  "permits",
+  "non-sealed"
+]);
+var JAVA_LANG_TYPES = /* @__PURE__ */ new Set([
+  "AbstractMethodError",
+  "AbstractStringBuilder",
+  "Appendable",
+  "ApplicationShutdownHooks",
+  "ArithmeticException",
+  "ArrayIndexOutOfBoundsException",
+  "ArrayStoreException",
+  "AssertionError",
+  "AssertionStatusDirectives",
+  "AutoCloseable",
+  "Boolean",
+  "BootstrapMethodError",
+  "Byte",
+  "Character",
+  "CharacterData",
+  "CharacterData00",
+  "CharacterData01",
+  "CharacterData02",
+  "CharacterData03",
+  "CharacterData0E",
+  "CharacterDataLatin1",
+  "CharacterDataPrivateUse",
+  "CharacterDataUndefined",
+  "CharacterName",
+  "CharSequence",
+  "Class",
+  "ClassCastException",
+  "ClassCircularityError",
+  "ClassFormatError",
+  "ClassLoader",
+  "ClassNotFoundException",
+  "ClassValue",
+  "Cloneable",
+  "CloneNotSupportedException",
+  "Comparable",
+  "Compiler",
+  "CompoundEnumeration",
+  "ConditionalSpecialCasing",
+  "Deprecated",
+  "Double",
+  "Enum",
+  "EnumConstantNotPresentException",
+  "Error",
+  "Exception",
+  "ExceptionInInitializerError",
+  "FdLibm",
+  "Float",
+  "FunctionalInterface",
+  "IllegalAccessError",
+  "IllegalAccessException",
+  "IllegalArgumentException",
+  "IllegalCallerException",
+  "IllegalMonitorStateException",
+  "IllegalStateException",
+  "IllegalThreadStateException",
+  "IncompatibleClassChangeError",
+  "IndexOutOfBoundsException",
+  "InheritableThreadLocal",
+  "InstantiationError",
+  "InstantiationException",
+  "Integer",
+  "InternalError",
+  "InterruptedException",
+  "Iterable",
+  "LayerInstantiationException",
+  "LinkageError",
+  "LiveStackFrame",
+  "LiveStackFrameInfo",
+  "Long",
+  "Math",
+  "Module",
+  "ModuleLayer",
+  "NamedPackage",
+  "NegativeArraySizeException",
+  "NoClassDefFoundError",
+  "NoSuchFieldError",
+  "NoSuchFieldException",
+  "NoSuchMethodError",
+  "NoSuchMethodException",
+  "NullPointerException",
+  "Number",
+  "NumberFormatException",
+  "Object",
+  "OutOfMemoryError",
+  "Override",
+  "Package",
+  "Process",
+  "ProcessBuilder",
+  "ProcessEnvironment",
+  "ProcessHandle",
+  "ProcessHandleImpl",
+  "ProcessImpl",
+  "PublicMethods",
+  "Readable",
+  "Record",
+  "ReflectiveOperationException",
+  "Runnable",
+  "Runtime",
+  "RuntimeException",
+  "RuntimePermission",
+  "SafeVarargs",
+  "SecurityException",
+  "SecurityManager",
+  "Short",
+  "Shutdown",
+  "StackFrameInfo",
+  "StackOverflowError",
+  "StackStreamFactory",
+  "StackTraceElement",
+  "StackWalker",
+  "StrictMath",
+  "String",
+  "StringBuffer",
+  "StringBuilder",
+  "StringCoding",
+  "StringConcatHelper",
+  "StringIndexOutOfBoundsException",
+  "StringLatin1",
+  "StringUTF16",
+  "SuppressWarnings",
+  "System",
+  "Terminator",
+  "Thread",
+  "ThreadDeath",
+  "ThreadGroup",
+  "ThreadLocal",
+  "Throwable",
+  "TypeNotPresentException",
+  "UnknownError",
+  "UnsatisfiedLinkError",
+  "UnsupportedClassVersionError",
+  "UnsupportedOperationException",
+  "VerifyError",
+  "VersionProps",
+  "VirtualMachineError",
+  "Void",
+  "WeakPairMap"
+]);
+function pickJavaFramework(frameworks) {
+  for (let i = 0; i < JAVA_FRAMEWORK_PRIORITY.length; i++) {
+    if (inArray(frameworks, JAVA_FRAMEWORK_PRIORITY[i])) return JAVA_FRAMEWORK_PRIORITY[i];
+  }
+  const sorted = [...frameworks].sort();
+  return sorted[0];
+}
+function inArray(arr, val) {
+  for (let i = 0; i < arr.length; i++) {
+    if (arr[i] === val) return true;
+  }
+  return false;
+}
+var JAVA_MODULE_DIRECTIVE_FIELDS = {
+  // requires [transitive|static] MODULE ;
+  requires_module_directive: [{ field: "module", role: "requires_module" }],
+  // exports PACKAGE [to field('modules', M) (, field('modules', M))*] ;
+  exports_module_directive: [
+    { field: "package", role: "module_exports_package" },
+    { field: "modules", role: "module_exports_package_to", unfieldedAfter: "package" }
+  ],
+  // opens PACKAGE [to field('modules', M) (, field('modules', M))*] ;
+  opens_module_directive: [
+    { field: "package", role: "module_opens_package" },
+    { field: "modules", role: "module_opens_package_to", unfieldedAfter: "package" }
+  ],
+  // uses TYPE ;
+  uses_module_directive: [{ field: "type", role: "module_uses_provided_type" }],
+  // provides field('provided', S) with I (, field('provider', I))* ;  <- first I unfielded
+  provides_module_directive: [
+    { field: "provided", role: "module_provides_service" },
+    { field: "provider", role: "module_provides_service_with", unfieldedAfter: "provided" }
+  ]
+};
+function isJavaNameNode(n) {
+  return !!n && (n.type === "identifier" || n.type === "scoped_identifier");
+}
+function javaTypeBaseName(node) {
+  if (!node) return "";
+  const t = node.type;
+  if (t === "type_identifier" || t === "identifier") return node.text;
+  if (t === "integral_type" || t === "floating_point_type" || t === "boolean_type" || t === "void_type") return node.text;
+  if (t === "generic_type") {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (!c) continue;
+      if (c.type === "type_identifier" || c.type === "scoped_type_identifier" || c.type === "generic_type") {
+        const b = javaTypeBaseName(c);
+        if (b) return b;
+      }
+    }
+    return "";
+  }
+  if (t === "scoped_type_identifier") {
+    const parts = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (!c) continue;
+      if (c.type === "annotation" || c.type === "marker_annotation") continue;
+      const b = javaTypeBaseName(c);
+      if (b) parts.push(b);
+    }
+    return parts.join(".");
+  }
+  if (t === "annotated_type") {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (!c) continue;
+      if (c.type === "annotation" || c.type === "marker_annotation") continue;
+      const b = javaTypeBaseName(c);
+      if (b) return b;
+    }
+    return "";
+  }
+  if (t === "array_type") {
+    return javaTypeBaseName(node.childForFieldName("element"));
+  }
+  if (t === "field_access") {
+    const links = [];
+    let cur = node;
+    let guard = 0;
+    let done = false;
+    while (cur && guard++ < 64) {
+      if (cur.type === "field_access") {
+        const f = cur.childForFieldName("field");
+        const o = cur.childForFieldName("object");
+        if (!f || f.type !== "identifier") return "";
+        links.unshift(f.text);
+        cur = o;
+        continue;
+      }
+      if (cur.type === "identifier" || cur.type === "type_identifier" || cur.type === "scoped_identifier") {
+        links.unshift(cur.text);
+        done = true;
+        break;
+      }
+      return "";
+    }
+    if (!done) return "";
+    return links.join(".");
+  }
+  return "";
+}
+var JAVA_LIBRARY_NAMESPACE_CITATIONS = ["jakarta", "androidx", "dotty.tools", "org.yaml"];
+var JAVA_EXTERNAL_STATIC_IMPORT_ROOTS = ["java.", "javax.", "jakarta.", "jdk.", "sun.", "com.sun.", "androidx.", "dotty.tools.", "org.yaml."];
+var RealJavaAnalyzer = class _RealJavaAnalyzer {
+  analyze(rootNode, content, filePath, context) {
+    const symbols = [];
+    const relationships = [];
+    const imports = [];
+    const exports = [];
+    const errors = [];
+    const frameworks = {};
+    const patterns = {};
+    let currentPackage = "";
+    let moduleName = "";
+    let cyclomaticComplexity = 0;
+    const symbolMap = /* @__PURE__ */ new Map();
+    const classHierarchy = /* @__PURE__ */ new Map();
+    const overrideTasks = [];
+    const methodsByOwner = /* @__PURE__ */ new Map();
+    const scopeStack = [];
+    const stack = [{ node: rootNode }];
+    const receiverTypes = this.collectJavaReceiverTypeIndex(rootNode);
+    while (stack.length > 0) {
+      const item = stack.pop();
+      const { node, parentContext, isExit } = item;
+      if (isExit) {
+        if (parentContext) {
+          this.processPhantomSymbols(parentContext, symbols, symbolMap, frameworks);
+          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;
+      if (type === "if_statement" || type === "for_statement" || type === "enhanced_for_statement" || type === "while_statement" || type === "do_statement" || type === "catch_clause" || type === "switch_block_statement_group" || type === "switch_rule" || type === "ternary_expression") {
+        cyclomaticComplexity++;
+      } else if (type === "binary_expression") {
+        const op = node.childForFieldName("operator")?.text;
+        if (op === "&&" || op === "||") cyclomaticComplexity++;
+      }
+      if (type === "package_declaration") {
+        const pkgName = this.childText(node, "scoped_identifier") || this.childText(node, "identifier");
+        if (pkgName) currentPackage = pkgName;
+      } else if (type === "module_declaration") {
+        moduleName = node.childForFieldName("name")?.text ?? "";
+        this.emitJavaModuleDeclaration(node, symbols, relationships, imports);
+      } else if (type === "import_declaration") {
+        let isStatic = false;
+        let isAsterisk = false;
+        for (let k = 0; k < node.childCount; k++) {
+          const kid = node.child(k);
+          if (!kid) continue;
+          if (kid.type === "static") isStatic = true;
+          else if (kid.type === "asterisk") isAsterisk = true;
+        }
+        let moduleName2 = this.childText(node, "scoped_identifier") || this.childText(node, "identifier");
+        if (moduleName2) {
+          imports.push({
+            module: moduleName2,
+            items: [],
+            isDefault: false,
+            range: this.nodeToRange(node),
+            isNamespace: isAsterisk,
+            metadata: { isWildcard: isAsterisk, isStatic }
+          });
+          this.detectFrameworksFromImport(moduleName2, frameworks);
+          relationships.push({
+            source: currentPackage || "root",
+            target: moduleName2,
+            type: ASTEngine.RelationshipType.Imports,
+            confidence: 1,
+            // M59 (#825): the line the imported module is NAMED on. 1.0 and not
+            // 0.9: `import_declaration` names the module in the grammar's own
+            // `scoped_identifier`, so this is the dependency the module pass reads,
+            // not a name matched from text. The `references` mention beside it keeps
+            // 0.9, which is the tier the family uses for a name-resolved mention.
+            //
+            // THE TARGET STAYS THE MODULE PATH, and the re-spelling tried here is
+            // MEASURED AND REJECTED rather than forgotten. `d5385c960` restated local
+            // imports to their leaf (+ `module` metadata) and measured "0 false locals" —
+            // a true statement about LOCALITY that is not this gate's question. Re-measured
+            // at cap 400 with `--index`: the gate indexes 4,020 qualifiedName aliases, so
+            // `com.example.core.Foo` ALREADY resolves to the declaration's qualified name,
+            // and the re-spelling moved `imports` resolved 104 → 64 with amb(decl) 0 → 40
+            // (unresolved unchanged at 263). A leaf whose FQN was unique can collide by
+            // name; the FQN cannot. The declaration is reached; the re-spelling lost it.
+            ...this.lineField(this.findChildByType(node, "scoped_identifier") || this.findChildByType(node, "identifier"), node),
+            metadata: { relationshipType: "import_declaration", isJavaImport: true, isWildcard: isAsterisk, isStatic, isModuleDependency: true }
+          });
+          relationships.push({
+            source: currentPackage || "root",
+            target: moduleName2,
+            type: ASTEngine.RelationshipType.References,
+            confidence: 0.9,
+            // M59 (#825): the line the imported module is NAMED on.
+            ...this.lineField(this.findChildByType(node, "scoped_identifier") || this.findChildByType(node, "identifier"), node),
+            metadata: { relationshipType: "import_declaration_mention", isJavaImport: true, isWildcard: isAsterisk, isStatic }
+          });
+          relationships.push({
+            source: currentPackage || "root",
+            target: moduleName2,
+            type: ASTEngine.RelationshipType.Imports,
+            confidence: 1,
+            ...this.lineField(this.findChildByType(node, "scoped_identifier") || this.findChildByType(node, "identifier"), node),
+            metadata: {
+              relationshipType: isStatic ? "static_member_import" : isAsterisk ? "type_on_demand_import" : "single_type_import",
+              isJavaImport: true,
+              isWildcard: isAsterisk,
+              isStatic,
+              fileLevel: true
+            }
+          });
+        }
+      } else if (type === "class_declaration" || type === "record_declaration" || type === "interface_declaration" || type === "enum_declaration" || type === "annotation_type_declaration") {
+        const name = this.childText(node, "identifier");
+        if (name) {
+          const kind = this.mapTypeToSymbolKind(type);
+          const modifiers = this.getJavaModifiers(node);
+          const annotations = this.getJavaAnnotations(node);
+          const visibility = this.getJavaVisibility(modifiers);
+          const fqn = this.buildFqn(currentPackage, scopeStack, name);
+          const inheritance = this.extractJavaInheritance(node);
+          const parents = [];
+          if (inheritance.extendsClass && inheritance.extendsClass.name) parents.push(inheritance.extendsClass.name);
+          for (let i = 0; i < inheritance.extendsInterfaces.length; i++) {
+            if (inheritance.extendsInterfaces[i].name) parents.push(inheritance.extendsInterfaces[i].name);
+          }
+          for (let i = 0; i < inheritance.implementsInterfaces.length; i++) {
+            if (inheritance.implementsInterfaces[i].name) parents.push(inheritance.implementsInterfaces[i].name);
+          }
+          classHierarchy.set(fqn, parents);
+          for (let k = 0; k < inheritance.permitsSubtypes.length; k++) {
+            if (!inheritance.permitsSubtypes[k].name) continue;
+            relationships.push({
+              source: name,
+              target: inheritance.permitsSubtypes[k].name,
+              type: ASTEngine.RelationshipType.References,
+              confidence: 1,
+              // M59 (#825): the subtype is named in the `permits` clause.
+              line_number: inheritance.permitsSubtypes[k].line,
+              metadata: { relationshipType: "permits" }
+            });
+          }
+          if (inheritance.extendsClass && inheritance.extendsClass.name) {
+            relationships.push({
+              source: name,
+              target: inheritance.extendsClass.name,
+              type: ASTEngine.RelationshipType.Inheritance,
+              confidence: 1,
+              // M59 (#825): the parent's OWN line — a long `extends A\n implements B`
+              // list puts each parent on its own line, and the clause's start line
+              // named only the first of them.
+              line_number: inheritance.extendsClass.line,
+              metadata: { relationshipType: type === "interface_declaration" ? "extends_interface" : "extends" }
+            });
+          }
+          for (let k = 0; k < inheritance.extendsInterfaces.length; k++) {
+            const iface = inheritance.extendsInterfaces[k];
+            if (!iface.name) continue;
+            relationships.push({
+              source: name,
+              target: iface.name,
+              type: ASTEngine.RelationshipType.Inheritance,
+              confidence: 1,
+              line_number: iface.line,
+              metadata: { relationshipType: "extends_interface" }
+            });
+          }
+          for (let k = 0; k < inheritance.implementsInterfaces.length; k++) {
+            const iface = inheritance.implementsInterfaces[k];
+            if (!iface.name) continue;
+            relationships.push({
+              source: name,
+              target: iface.name,
+              type: ASTEngine.RelationshipType.Implementation,
+              confidence: 1,
+              line_number: iface.line,
+              metadata: { relationshipType: "implements" }
+            });
+          }
+          const annNames = this.getJavaAnnotationNames(node);
+          let isSpringBean = false;
+          let isEntity = false;
+          for (let i = 0; i < annNames.length; i++) {
+            const n = annNames[i];
+            if (n === "Service" || n === "Repository" || n === "RestController" || n === "Component") isSpringBean = true;
+            if (n === "Entity" || n === "Table") isEntity = true;
+          }
+          let tableName = name.toLowerCase();
+          let tableNameIsDeclared = false;
+          if (isEntity) {
+            frameworks["jpa"] = true;
+            patterns["entity_pattern"] = true;
+            if (inArray(annNames, "Table")) {
+              const n = this.getAnnotationValue(node, "Table", "name");
+              if (n) {
+                tableName = n;
+                tableNameIsDeclared = true;
+              }
+            }
+            relationships.push({
+              source: name,
+              target: tableName,
+              type: ASTEngine.RelationshipType.Uses,
+              // JD-J9 (M60 java deep review, 2026-09-27): a DECLARED table name
+              // is written in this file, so 1.0 is honest. The bare-`@Entity`
+              // default is not: `@Entity class Item` contains the string "item"
+              // nowhere, and JPA's documented default is the ENTITY NAME
+              // UNCHANGED (`AuctionItem`), so the lowercased form matches no
+              // standard naming strategy either. Publishing that at 1.0 with no
+              // marker states a certainty the source does not contain — and
+              // bb_graph, bb_impact and hover all repeat it verbatim as a real
+              // relationship to a table that may not exist.
+              //
+              // Measured consequence: it was also a standing FALSE FABRICATION in
+              // the corpus. `uses` joined java's compare set in this same wave
+              // (JD-J2), and the very first fresh draw reported
+              // `UNEXPLAINED Item.java :: uses Item -> item` at conf 1.0 — an
+              // unmatched CONFIDENT edge, which the harness counts as a
+              // fabrication, not a heuristic. No language-derived oracle can
+              // match it, because no language rule declares that name.
+              //
+              // So: declared stays 1.0; the inferred default drops below the
+              // 0.7 fabrication threshold and is marked, making it declared
+              // suspicion — visible in the heuristic bucket (surfaced by JD-J1)
+              // rather than counted as a relationship. Nothing is lost: the
+              // edge still exists, and a consumer can filter on `inferred`.
+              confidence: tableNameIsDeclared ? 1 : 0.6,
+              // M59 (#825): the table is named inside `@Table`, so that is the
+              // line the name is written on. Absent for the inferred default —
+              // there is no line to point at, and borrowing the class
+              // declaration's line would invent one (#823).
+              ...this.annotationLine(node, "Table") ? { line_number: this.annotationLine(node, "Table") } : {},
+              metadata: { isDatabase: true, relationshipType: "mapped_table", table: tableName, inferred: !tableNameIsDeclared }
+            });
+          }
+          if (isSpringBean) {
+            frameworks["spring"] = true;
+            for (let i = 0; i < annNames.length; i++) {
+              const a = annNames[i];
+              if (a === "Service") {
+                patterns["service_layer"] = true;
+                break;
+              }
+              if (a === "Repository") {
+                patterns["repository_pattern"] = true;
+                break;
+              }
+              if (a === "RestController" || a === "Controller") {
+                patterns["mvc_pattern"] = true;
+                break;
+              }
+            }
+          }
+          if (inArray(annNames, "FeignClient")) {
+            const targetService = this.getAnnotationValue(node, "FeignClient", "name") || this.getAnnotationValue(node, "FeignClient", "value");
+            if (targetService) {
+              relationships.push({
+                source: name,
+                target: targetService,
+                type: ASTEngine.RelationshipType.Calls,
+                confidence: 1,
+                // M59 (#825): the service is named inside `@FeignClient`.
+                ...this.annotationLine(node, "FeignClient") ? { line_number: this.annotationLine(node, "FeignClient") } : {},
+                metadata: { isFeignClient: true, microservice: targetService }
+              });
+            }
+          }
+          const javadoc = this.extractJavadocComment(node);
+          const sym = {
+            name,
+            kind,
+            // M14 INCOMING — the declaration's QUALIFIED name, published.
+            //
+            // The analyzer has always computed this (`buildFqn`, above, is the
+            // JLS name: package + nesting + own name) and used it internally for
+            // `classHierarchy`, then dropped it: no java symbol carried a
+            // `qualifiedName`, so `pool-worker.ts:1154` filled the field with its
+            // last-resort fallback and `script/m14/incoming-gate.ts` measured
+            // `qualifiedNameAliases: 0` for this lane — against 33,750 for
+            // typescript. What that costs is resolution, not tidiness: an edge
+            // whose target is spelled `com.acme.Foo` (a fully-qualified reference,
+            // an import's module, another package's type) has nothing to match,
+            // because the only key the pool publishes for this declaration is the
+            // leaf `Foo`.
+            qualifiedName: fqn,
+            // M59 (#825): the declaration's line, annotations skipped.
+            range: this.symbolRange(node),
+            visibility,
+            comments: javadoc ? [javadoc] : [],
+            decorators: annotations,
+            genericParameters: this.getJavaGenericParameters(node),
+            ownerName: parentContext?.name,
+            ownerKind: parentContext?.kind,
+            metadata: {
+              nodeType: type,
+              modifiers,
+              annotations,
+              isPublic: visibility === "public",
+              isAbstract: modifiers.indexOf("abstract") !== -1 || type === "interface_declaration",
+              ...isSpringBean ? { spring_bean: true } : {}
+            }
+          };
+          if (type === "record_declaration") {
+            sym.parameters = this.extractJavaParameters(node, relationships, name);
+            const formalParams = this.findChildByType(node, "formal_parameters");
+            if (formalParams) {
+              for (let i = 0; i < formalParams.namedChildCount; i++) {
+                const comp = formalParams.namedChild(i);
+                if (!comp) continue;
+                if (comp.type !== "formal_parameter" && comp.type !== "spread_parameter") continue;
+                const compName = comp.type === "spread_parameter" ? (() => {
+                  const decl = this.findChildByType(comp, "variable_declarator");
+                  return decl ? this.findChildByType(decl, "identifier") : null;
+                })() : comp.childForFieldName("name");
+                if (!compName) continue;
+                let compReturnType = void 0;
+                if (comp.type === "spread_parameter") {
+                  for (let cIdx = 0; cIdx < comp.namedChildCount; cIdx++) {
+                    const c = comp.namedChild(cIdx);
+                    if (c && c.type !== "modifiers" && !stringIncludes(c.type, "annotation") && c.type !== "variable_declarator") {
+                      compReturnType = c.text + "[]";
+                      break;
+                    }
+                  }
+                } else {
+                  compReturnType = this.extractJavaParameterType(comp);
+                }
+                const compSym = {
+                  name: compName.text,
+                  kind: ASTEngine.SymbolKind.Property,
+                  // M59 (#825): a record component's own line (its modifiers,
+                  // which carry any parameter annotations, are skipped).
+                  range: this.symbolRange(comp),
+                  returnType: compReturnType,
+                  visibility: "public",
+                  ownerName: name,
+                  ownerKind: kind,
+                  metadata: { nodeType: "record_component" }
+                };
+                symbols.push(compSym);
+              }
+            }
+          }
+          symbols.push(sym);
+          symbolMap.set(fqn, sym);
+          if (!symbolMap.has(name)) symbolMap.set(name, sym);
+          this.emitJavaTypeParameterSymbols(node, name, kind, type, symbols);
+          newContext = {
+            node,
+            name,
+            kind,
+            fqn,
+            symbolRef: sym,
+            visibility,
+            isAbstract: inArray(modifiers, "abstract"),
+            isInterface: type === "interface_declaration",
+            isRecord: type === "record_declaration",
+            annotations,
+            fields: [],
+            parents
+          };
+          scopeStack.push(newContext);
+          pushedScope = true;
+        }
+      } else if (type === "method_declaration" || type === "constructor_declaration" || type === "compact_constructor_declaration" || type === "annotation_type_element_declaration") {
+        const nameNode = this.findChildByType(node, "identifier");
+        const name = nameNode ? nameNode.text : null;
+        if (name) {
+          const isConstructor = type === "constructor_declaration" || type === "compact_constructor_declaration";
+          const isCompactCtor = type === "compact_constructor_declaration";
+          const modifiers = this.getJavaModifiers(node);
+          const annotations = this.getJavaAnnotations(node);
+          const visibility = this.getJavaVisibility(modifiers);
+          const parameters = isCompactCtor && parentContext ? this.extractJavaParameters(parentContext.node, relationships, parentContext.name) : this.extractJavaParameters(node, relationships, parentContext ? parentContext.name : void 0);
+          let sigParams = "";
+          for (let i = 0; i < parameters.length; i++) {
+            if (i > 0) sigParams += ",";
+            sigParams += parameters[i].type || "unknown";
+          }
+          const signature = `(${sigParams})`;
+          const fqn = parentContext ? `${parentContext.fqn}.${name}${signature}` : `${name}${signature}`;
+          const localOwnerPrefix = parentContext ? `${parentContext.name}.${name}${signature}` : `${name}${signature}`;
+          const returnType = isConstructor ? void 0 : this.extractJavaReturnType(node);
+          if (!isConstructor && parentContext) {
+            const retTypeNode = node.childForFieldName("type");
+            if (retTypeNode) {
+              for (const { name: t, line } of this.collectJavaTypeNames(retTypeNode)) {
+                if (t === "var") continue;
+                relationships.push({
+                  source: parentContext.name,
+                  target: t,
+                  type: ASTEngine.RelationshipType.References,
+                  confidence: 0.95,
+                  // M59 (#825): the line the return TYPE is named on.
+                  line_number: line,
+                  metadata: { relationshipType: "declared_type", declaredOn: "return_type" }
+                });
+              }
+            }
+          }
+          let isApiEndpoint = false;
+          let fullRoute = "";
+          let mappingAnnotation = "";
+          const methodAnnNames = this.getJavaAnnotationNames(node);
+          for (let i = 0; i < methodAnnNames.length; i++) {
+            const n = methodAnnNames[i];
+            if (n === "GetMapping" || n === "PostMapping" || n === "PutMapping" || n === "DeleteMapping" || n === "PatchMapping" || n === "RequestMapping" || n === "Path") {
+              mappingAnnotation = n;
+              break;
+            }
+          }
+          if (mappingAnnotation) {
+            isApiEndpoint = true;
+            let httpMethod = "GET";
+            if (mappingAnnotation === "PostMapping") httpMethod = "POST";
+            else if (mappingAnnotation === "PutMapping") httpMethod = "PUT";
+            else if (mappingAnnotation === "DeleteMapping") httpMethod = "DELETE";
+            else if (mappingAnnotation === "PatchMapping") httpMethod = "PATCH";
+            else if (mappingAnnotation === "Path") httpMethod = "ANY";
+            else if (mappingAnnotation === "RequestMapping") {
+              const m = this.getAnnotationValue(node, "RequestMapping", "method");
+              if (m) {
+                let verb = "";
+                for (let ci = 0; ci < m.length; ci++) {
+                  const c = m[ci];
+                  if (c >= "A" && c <= "Z" || c >= "a" && c <= "z") verb += c;
+                }
+                verb = verb.toUpperCase();
+                if (verb === "GET" || verb === "POST" || verb === "PUT" || verb === "DELETE" || verb === "PATCH" || verb === "HEAD" || verb === "OPTIONS") httpMethod = verb;
+                else httpMethod = "ANY";
+              } else httpMethod = "ANY";
+            }
+            const methodRoute = this.getAnnotationValue(node, mappingAnnotation, "value") || this.getAnnotationValue(node, mappingAnnotation, "path") || "";
+            let basePath = "";
+            if (parentContext) {
+              const classAnnNames = this.getJavaAnnotationNames(parentContext.node);
+              let classMapping = "";
+              for (let i = 0; i < classAnnNames.length; i++) {
+                if (classAnnNames[i] === "RequestMapping" || classAnnNames[i] === "Path") {
+                  classMapping = classAnnNames[i];
+                  break;
+                }
+              }
+              if (classMapping) {
+                basePath = this.getAnnotationValue(parentContext.node, classMapping, "value") || this.getAnnotationValue(parentContext.node, classMapping, "path") || "";
+              }
+            }
+            if (basePath || methodRoute) {
+              fullRoute = "";
+              for (let i = 0; i < basePath.length + methodRoute.length; i++) {
+                const ch = i < basePath.length ? basePath[i] : methodRoute[i - basePath.length];
+                if (ch === "/" && fullRoute.length > 0 && fullRoute[fullRoute.length - 1] === "/") continue;
+                fullRoute += ch;
+              }
+              if (!fullRoute.startsWith("/")) fullRoute = "/" + fullRoute;
+              relationships.push({
+                source: localOwnerPrefix,
+                target: fullRoute,
+                type: ASTEngine.RelationshipType.Exports,
+                confidence: 1,
+                // M59 (#825): the route text is written inside the mapping
+                // annotation, so that is the line that carries the name.
+                ...this.annotationLine(node, mappingAnnotation) ? { line_number: this.annotationLine(node, mappingAnnotation) } : {},
+                metadata: { isApiEndpoint: true, httpMethod, route: fullRoute, relationshipType: "api_endpoint" }
+              });
+            } else {
+              isApiEndpoint = false;
+            }
+            if (isApiEndpoint) frameworks["spring_mvc"] = true;
+          }
+          let dbMapping = "";
+          const methodDbAnnNames = this.getJavaAnnotationNames(node);
+          for (let idx = 0; idx < methodDbAnnNames.length; idx++) {
+            const n = methodDbAnnNames[idx];
+            if (n === "Column" || n === "OneToMany" || n === "ManyToOne" || n === "OneToOne" || n === "ManyToMany") {
+              dbMapping = n;
+              break;
+            }
+          }
+          if (dbMapping && parentContext) {
+            let target = name.startsWith("get") ? name.charAt(3).toLowerCase() + name.slice(4) : name;
+            const explicit = this.getAnnotationValue(node, dbMapping, "name");
+            if (explicit) target = explicit;
+            relationships.push({
+              source: localOwnerPrefix,
+              target,
+              type: ASTEngine.RelationshipType.Uses,
+              confidence: 1,
+              // M59 (#825): the column is named inside its mapping annotation.
+              ...this.annotationLine(node, dbMapping) ? { line_number: this.annotationLine(node, dbMapping) } : {},
+              metadata: { isDatabase: true, relationshipType: "mapped_column" }
+            });
+          }
+          const hasBody = !!this.findChildByType(node, "block");
+          const isAbstract = modifiers.indexOf("abstract") !== -1 || !!(parentContext?.isInterface && !hasBody && modifiers.indexOf("default") === -1);
+          const effectiveVisibility = visibility ?? (parentContext?.isInterface ? "public" : void 0);
+          const isAnnotatedOverride = annotations.indexOf("@Override") !== -1;
+          if (isAnnotatedOverride && parentContext) {
+            overrideTasks.push({
+              fqn,
+              methodName: name,
+              signature,
+              ownerFqn: parentContext.fqn,
+              arity: parameters.length,
+              explicit: true,
+              // M59 (#825): the OVERRIDING declaration's own line (annotations
+              // skipped, so an `@Override` method does not report the
+              // annotation) — captured here while the node is in hand rather
+              // than resolved later by name, which could match namesakes.
+              line: this.declarationLineNode(node).startPosition.row + 1
+            });
+          } else if (parentContext && !isConstructor && modifiers.indexOf("static") === -1 && visibility !== "private") {
+            overrideTasks.push({
+              fqn,
+              methodName: name,
+              signature,
+              ownerFqn: parentContext.fqn,
+              arity: parameters.length,
+              explicit: false,
+              line: this.declarationLineNode(node).startPosition.row + 1
+            });
+          }
+          const methodDoc = this.extractJavadocComment(node);
+          const memberName = isConstructor ? parentContext?.name ?? name : name;
+          const sym = {
+            name: memberName,
+            kind: isConstructor ? ASTEngine.SymbolKind.Constructor : ASTEngine.SymbolKind.Method,
+            // M14 INCOMING — the member's QUALIFIED name, WITHOUT the signature.
+            //
+            // `fqn` above carries it (`Owner.method(int,String)`) and that is the
+            // right key for the override BFS, but no edge spells a signature: an
+            // `overrides` target is `Owner.method` and a `calls` target is
+            // `receiver.method`. Publishing the signature-bearing form would add a
+            // key nothing can match. Overloads therefore share one qualified name —
+            // correct for the JLS (a method's qualified name is `Type.method`;
+            // overloading is a signature matter) and harmless to the candidate
+            // count, which counts DECLARING FILES, so N overloads in one file are
+            // still one candidate.
+            qualifiedName: parentContext ? `${parentContext.fqn}.${memberName}` : memberName,
+            // M59 (#825): the declaration's line, annotations skipped.
+            range: this.symbolRange(node),
+            comments: methodDoc ? [methodDoc] : [],
+            complexity: this.calculateJavaMethodComplexity(node),
+            visibility: effectiveVisibility,
+            parameters,
+            returnType,
+            qualified_calls: [],
+            apiContractPath: isApiEndpoint ? fullRoute : void 0,
+            isStatic: modifiers.indexOf("static") !== -1,
+            isAbstract,
+            decorators: annotations,
+            genericParameters: this.getJavaGenericParameters(node),
+            ownerName: parentContext?.name,
+            ownerKind: parentContext?.kind,
+            metadata: { nodeType: type, modifiers, annotations }
+          };
+          symbols.push(sym);
+          symbolMap.set(fqn, sym);
+          symbolMap.set(localOwnerPrefix, sym);
+          if (parentContext?.fqn) {
+            const leaf = parentContext.fqn.slice(parentContext.fqn.lastIndexOf(".") + 1);
+            for (const key of parentContext.fqn === leaf ? [leaf] : [parentContext.fqn, leaf]) {
+              let byName = methodsByOwner.get(key);
+              if (!byName) {
+                byName = /* @__PURE__ */ new Map();
+                methodsByOwner.set(key, byName);
+              }
+              const arr = byName.get(name);
+              if (arr) arr.push(sym);
+              else byName.set(name, [sym]);
+            }
+          }
+          this.emitJavaTypeParameterSymbols(node, name, ASTEngine.SymbolKind.Method, type, symbols);
+          newContext = {
+            node,
+            name,
+            kind: ASTEngine.SymbolKind.Method,
+            fqn,
+            symbolRef: sym,
+            visibility: effectiveVisibility,
+            isAbstract,
+            isInterface: false,
+            isRecord: false,
+            annotations,
+            fields: [],
+            parents: []
+          };
+          scopeStack.push(newContext);
+          pushedScope = true;
+        }
+      } else if (type === "constant_declaration") {
+        const fieldType = this.extractJavaFieldType(node);
+        for (let decIdx = 0; decIdx < node.namedChildCount; decIdx++) {
+          const declarator = node.namedChild(decIdx);
+          if (!declarator || declarator.type !== "variable_declarator") continue;
+          const nameNode = this.findChildByType(declarator, "identifier");
+          if (!nameNode || !parentContext) continue;
+          symbols.push({
+            name: nameNode.text,
+            kind: ASTEngine.SymbolKind.Constant,
+            range: this.nodeToRange(declarator),
+            returnType: fieldType,
+            visibility: "public",
+            ownerName: parentContext.name,
+            ownerKind: parentContext.kind,
+            metadata: { nodeType: type }
+          });
+        }
+        const constTypeNode = node.childForFieldName("type");
+        if (constTypeNode && parentContext) {
+          for (const { name: t, line } of this.collectJavaTypeNames(constTypeNode)) {
+            relationships.push({
+              source: parentContext.name,
+              target: t,
+              type: ASTEngine.RelationshipType.References,
+              confidence: 0.95,
+              // M59 (#825): the line the constant's TYPE is named on.
+              line_number: line,
+              metadata: { relationshipType: "declared_type", declaredOn: type }
+            });
+          }
+        }
+      } else if (type === "field_declaration") {
+        const modifiers = this.getJavaModifiers(node);
+        const annotations = this.getJavaAnnotations(node);
+        const visibility = this.getJavaVisibility(modifiers);
+        const isStatic = inArray(modifiers, "static");
+        const isConstant = modifiers.indexOf("final") !== -1 && isStatic;
+        const fieldType = this.extractJavaFieldType(node);
+        const fieldTypeNode = node.childForFieldName("type");
+        if (fieldTypeNode && parentContext) {
+          for (const { name: t, line } of this.collectJavaTypeNames(fieldTypeNode)) {
+            relationships.push({
+              source: parentContext.name,
+              target: t,
+              type: ASTEngine.RelationshipType.References,
+              confidence: 0.95,
+              // M59 (#825): the line the field's TYPE is named on.
+              line_number: line,
+              metadata: { relationshipType: "declared_type", declaredOn: type }
+            });
+          }
+        }
+        const declarators = this.findAllChildrenByType(node, "variable_declarator");
+        for (let decIdx = 0; decIdx < declarators.length; decIdx++) {
+          const declarator = declarators[decIdx];
+          const nameNode = this.findChildByType(declarator, "identifier");
+          if (nameNode && parentContext) {
+            const fieldName = nameNode.text;
+            const localOwnerPrefix = `${parentContext.name}.${fieldName}`;
+            const fieldDbAnnNames = this.getJavaAnnotationNames(node);
+            let dbMapping = "";
+            for (let idx = 0; idx < fieldDbAnnNames.length; idx++) {
+              const n = fieldDbAnnNames[idx];
+              if (n === "Column" || n === "OneToMany" || n === "ManyToOne" || n === "OneToOne" || n === "ManyToMany") {
+                dbMapping = n;
+                break;
+              }
+            }
+            if (dbMapping) {
+              const explicit = this.getAnnotationValue(node, dbMapping, "name");
+              const target = explicit ?? fieldName;
+              const columnNameIsDeclared = !!explicit;
+              relationships.push({
+                source: localOwnerPrefix,
+                target,
+                type: ASTEngine.RelationshipType.Uses,
+                confidence: columnNameIsDeclared ? 1 : 0.6,
+                // M59 (#825): the column name is written inside its mapping annotation when explicit; the field line when implicit.
+                ...explicit ? { line_number: this.annotationLine(node, dbMapping, explicit) } : { line_number: nameNode.startPosition.row + 1 },
+                metadata: { isDatabase: true, relationshipType: "mapped_column", inferred: !columnNameIsDeclared }
+              });
+            }
+            if (inArray(this.getJavaAnnotationNames(node), "Value")) {
+              const valMatch = this.getAnnotationValue(node, "Value", "value");
+              if (valMatch && valMatch.startsWith("${") && valMatch.endsWith("}")) {
+                let configKey = valMatch.substring(2, valMatch.length - 1);
+                if (stringIncludes(configKey, ":")) configKey = configKey.split(":")[0];
+                relationships.push({
+                  source: localOwnerPrefix,
+                  target: configKey,
+                  type: ASTEngine.RelationshipType.Uses,
+                  confidence: 1,
+                  // M59 (#825): the key is written inside `@Value`.
+                  ...this.annotationLine(node, "Value") ? { line_number: this.annotationLine(node, "Value") } : {},
+                  metadata: { isConfiguration: true, relationshipType: "config_property" }
+                });
+              }
+            }
+            const fieldDoc = this.extractJavadocComment(node);
+            const sym = {
+              name: fieldName,
+              kind: isConstant ? ASTEngine.SymbolKind.Constant : ASTEngine.SymbolKind.Property,
+              range: this.nodeToRange(declarator),
+              comments: fieldDoc ? [fieldDoc] : [],
+              returnType: fieldType,
+              visibility,
+              isStatic,
+              decorators: annotations,
+              genericParameters: this.getJavaGenericParameters(node),
+              ownerName: parentContext.name,
+              ownerKind: parentContext.kind,
+              metadata: { nodeType: type, modifiers, annotations, isConstant }
+            };
+            symbols.push(sym);
+            parentContext.fields.push(sym);
+          }
+        }
+      } else if (type === "enum_constant") {
+        const nameNode = this.findChildByType(node, "identifier");
+        if (nameNode && parentContext) {
+          symbols.push({
+            name: nameNode.text,
+            kind: ASTEngine.SymbolKind.EnumMember,
+            // M59 (#825): the constant's own line, annotations skipped.
+            range: this.symbolRange(node),
+            visibility: "public",
+            ownerName: parentContext.name,
+            ownerKind: parentContext.kind,
+            metadata: { nodeType: type }
+          });
+          const constantBody = this.findChildByType(node, "class_body");
+          if (constantBody) {
+            const anonName = `anonymous_${nameNode.text}`;
+            const anonFqn = parentContext.fqn ? `${parentContext.fqn}.${anonName}` : anonName;
+            const anonSym = {
+              name: anonName,
+              kind: ASTEngine.SymbolKind.Class,
+              range: this.nodeToRange(constantBody),
+              visibility: "package-private",
+              ownerName: parentContext.name,
+              ownerKind: parentContext.kind,
+              metadata: { nodeType: type, isAnonymousClass: true, enumConstantBody: true, superTypes: [parentContext.name] }
+            };
+            symbols.push(anonSym);
+            symbolMap.set(anonFqn, anonSym);
+            classHierarchy.set(anonFqn, [parentContext.name]);
+            newContext = {
+              node: constantBody,
+              name: anonName,
+              kind: ASTEngine.SymbolKind.Class,
+              fqn: anonFqn,
+              symbolRef: anonSym,
+              // A Scope's visibility union has no `package-private` member (the
+              // SYMBOL can spell it; the scope carries the enclosing declaration's
+              // visibility, exactly as the object_creation anonymous-class site does).
+              visibility: parentContext.visibility,
+              isAbstract: false,
+              isInterface: false,
+              isRecord: false,
+              annotations: [],
+              fields: [],
+              parents: [parentContext.name]
+            };
+            scopeStack.push(newContext);
+            pushedScope = true;
+          }
+        }
+      } else if (type === "method_invocation") {
+        const callExpression = this.buildJavaCallExpression(node);
+        if (callExpression && !this.isJavaBuiltin(callExpression)) {
+          const receiverOwner = this.javaReceiverOwnerType(node, receiverTypes, context?.projectIndex);
+          const receiverMetadata = receiverOwner ? { owner: receiverOwner.type, ownerEvidence: receiverOwner.evidence } : {};
+          if (parentContext && parentContext.kind === ASTEngine.SymbolKind.Method && parentContext.symbolRef) {
+            if (!parentContext.symbolRef.qualified_calls) parentContext.symbolRef.qualified_calls = [];
+            parentContext.symbolRef.qualified_calls.push(callExpression);
+            let argumentCount;
+            const argsNode = node.childForFieldName("arguments");
+            if (argsNode) {
+              argumentCount = 0;
+              for (let ai = 0; ai < argsNode.namedChildCount; ai++) {
+                const ac = argsNode.namedChild(ai);
+                if (ac && ac.type !== "line_comment" && ac.type !== "block_comment") argumentCount++;
+              }
+            }
+            relationships.push({
+              source: parentContext.name || parentContext.symbolRef.name,
+              target: callExpression.split(".").pop() || callExpression,
+              type: ASTEngine.RelationshipType.Calls,
+              confidence: 0.7,
+              // M59 (#825): the line is where the CALL IS WRITTEN — the name
+              // field of the method_invocation, not the invocation node's own
+              // start. Measured with the M59 oracle on real java: a
+              // `method_invocation` starts at its RECEIVER, so `a.b()\n  .c()`
+              // put c on the line a.b() opened on. java, kotlin and groovy
+              // share this node shape, so this is the family pattern.
+              ...this.lineField(node.childForFieldName("name"), node),
+              metadata: { javaCallExpression: callExpression, ...argumentCount !== void 0 ? { argumentCount } : {}, ...receiverMetadata }
+            });
+          } else {
+            const typeScope = this.resolveEnclosingTypeScope(scopeStack);
+            if (typeScope && typeScope.name) {
+              relationships.push({
+                source: typeScope.name,
+                target: callExpression.split(".").pop() || callExpression,
+                type: ASTEngine.RelationshipType.Calls,
+                confidence: 0.7,
+                // M59 (#825): same rule as the in-method branch above.
+                ...this.lineField(node.childForFieldName("name"), node),
+                metadata: { javaCallExpression: callExpression, callSite: parentContext?.node?.type ?? node.parent?.type, inInitializer: true, ...receiverMetadata }
+              });
+            }
+          }
+        }
+      } else if (type === "explicit_constructor_invocation") {
+        const text = node.text.trim();
+        const source = parentContext?.name || parentContext?.symbolRef?.name || "global";
+        let target = "super";
+        let ctorKind = "super";
+        if (text.startsWith("this")) {
+          target = "this";
+          ctorKind = "this";
+        } else if (text.startsWith("super")) {
+          target = "super";
+          ctorKind = "super";
+        } else {
+          const q = text.split("(")[0].trim().split(".");
+          target = q[0] + ".super";
+          ctorKind = "qualified";
+        }
+        relationships.push({
+          source,
+          target,
+          type: ASTEngine.RelationshipType.Calls,
+          confidence: 1,
+          // M59 (#825): the delegation is written exactly where the node is, and
+          // `super`/`this` are unnamed keyword children — the invocation node's
+          // own line is the only site that carries the name.
+          line_number: node.startPosition.row + 1,
+          metadata: { relationshipType: "constructor_invocation", constructorReceiver: ctorKind, callExpression: text }
+        });
+      } else if (type === "object_creation_expression") {
+        const typeNode = this.findChildByType(node, "type_identifier") || this.findChildByType(node, "generic_type") || this.findChildByType(node, "scoped_type_identifier") || this.findChildByType(node, "identifier");
+        if (typeNode) {
+          const source = parentContext?.name || parentContext?.symbolRef?.name || "global";
+          const typeName = typeNode.type === "identifier" ? typeNode.text : this.extractJavaTypeBaseName(typeNode);
+          if (!typeName) continue;
+          relationships.push({
+            source,
+            target: typeName,
+            type: ASTEngine.RelationshipType.Instantiates,
+            confidence: 0.95,
+            // M59 (#825): the instantiated type is NAMED by its type node — that
+            // node's line, not the statement's, which matters for
+            // `new\n  Foo()` and for a type named inside a multi-line argument.
+            line_number: typeNode.startPosition.row + 1,
+            metadata: { relationshipType: "instantiates", isNew: true }
+          });
+          const classBody = this.findChildByType(node, "class_body");
+          if (classBody && parentContext) {
+            const anonName = typeName ? `anonymous_${typeName}` : "anonymous_class";
+            const anonFqn = parentContext.fqn ? `${parentContext.fqn}.${anonName}` : anonName;
+            const anonSym = {
+              name: anonName,
+              kind: ASTEngine.SymbolKind.Class,
+              range: this.nodeToRange(node),
+              visibility: parentContext.visibility || "package-private",
+              ownerName: parentContext.name,
+              ownerKind: parentContext.kind,
+              metadata: { nodeType: type, isAnonymousClass: true, superTypes: typeName ? [typeName] : [] }
+            };
+            symbols.push(anonSym);
+            symbolMap.set(anonFqn, anonSym);
+            classHierarchy.set(anonFqn, typeName ? [typeName] : []);
+            newContext = {
+              node: classBody,
+              name: anonName,
+              kind: ASTEngine.SymbolKind.Class,
+              fqn: anonFqn,
+              symbolRef: anonSym,
+              visibility: parentContext.visibility,
+              isAbstract: false,
+              isInterface: false,
+              isRecord: false,
+              annotations: [],
+              fields: [],
+              parents: typeName ? [typeName] : []
+            };
+            scopeStack.push(newContext);
+            pushedScope = true;
+          }
+        }
+      } else if (type === "cast_expression" || type === "instanceof_expression" || type === "class_literal") {
+        const typeNode = node.childForFieldName("type") || node.childForFieldName("right") || this.findChildByType(node, "type_identifier") || this.findChildByType(node, "generic_type") || this.findChildByType(node, "scoped_type_identifier") || // EXPORTS_JAVA2: `Foo[].class` — a class literal over an ARRAY type.
+        // The `array_type` was missing from this list, and because the three
+        // searches above only look at DIRECT children, `Foo[].class` resolved
+        // to nothing and emitted NO edge at all (probe: `class X { Object o =
+        // Foo[].class; }` produced only the `declared_type` edge for Object).
+        // That is a missing edge rather than a wrong one, and it also left
+        // `javaTypeBaseName`'s `array_type` branch unreachable from every
+        // emission site — a branch that cannot match is dead code, which is
+        // the question this lane is here to answer.
+        this.findChildByType(node, "array_type");
+        if (typeNode) {
+          const typeName = typeNode.type === "type_identifier" ? typeNode.text : this.extractJavaTypeBaseName(typeNode);
+          if (typeName && typeName !== "var") {
+            const castTarget = typeName;
+            relationships.push({
+              source: parentContext?.name || parentContext?.symbolRef?.name || "global",
+              // Cast arrays: `(String[]) o` — the EDGE TARGET is the element
+              // type (String), not the JVM-erasure text with brackets
+              // (probe 2026-09-08: `String[]` target joined nothing). The
+              // declaredOn shape stays visible in metadata below.
+              target: castTarget,
+              type: ASTEngine.RelationshipType.References,
+              confidence: 0.95,
+              // M59 (#825): the cast/instanceof/class-literal type is named by
+              // its type node.
+              ...this.lineField(typeNode, node),
+              metadata: {
+                relationshipType: type === "cast_expression" ? "cast_target" : type === "instanceof_expression" ? "instanceof_check" : "class_literal"
+              }
+            });
+          }
+        }
+      } else if (type === "record_pattern") {
+        for (let i = 0; i < node.namedChildCount; i++) {
+          const c = node.namedChild(i);
+          if (c && c.type !== "record_pattern_body") {
+            const typeName = c.type === "type_identifier" ? c.text : this.extractJavaTypeBaseName(c);
+            if (typeName && typeName !== "var") {
+              relationships.push({
+                source: parentContext?.name || parentContext?.symbolRef?.name || "global",
+                target: typeName,
+                type: ASTEngine.RelationshipType.References,
+                confidence: 0.95,
+                // M59 (#825): the pattern's type is named by the pattern node.
+                ...this.lineField(c, node),
+                metadata: { relationshipType: "record_pattern" }
+              });
+            }
+            break;
+          }
+        }
+      } else if (type === "array_creation_expression") {
+        const elemNode = node.childForFieldName("type");
+        if (elemNode) {
+          const typeBearing = elemNode.type === "type_identifier" || elemNode.type === "scoped_type_identifier" || elemNode.type === "generic_type";
+          const typeName = typeBearing ? elemNode.type === "type_identifier" ? elemNode.text : this.extractJavaTypeBaseName(elemNode) : null;
+          if (typeName) {
+            relationships.push({
+              source: parentContext?.name || parentContext?.symbolRef?.name || "global",
+              target: typeName,
+              type: ASTEngine.RelationshipType.References,
+              confidence: 0.95,
+              // M59 (#825): `new T[...]` names T on the element-type node.
+              ...this.lineField(elemNode, node),
+              metadata: { relationshipType: "array_creation" }
+            });
+          }
+        }
+      } else if (type === "method_reference") {
+        const kids = [];
+        for (let i = 0; i < node.namedChildCount; i++) {
+          const k = node.namedChild(i);
+          if (k) kids.push(k);
+        }
+        const refSource = parentContext?.name || parentContext?.symbolRef?.name || "global";
+        if (kids.length > 0) {
+          const recv = kids[0];
+          const recvType = recv.type;
+          const recvName = recvType === "type_identifier" || recvType === "identifier" ? recv.text : recvType === "scoped_type_identifier" || recvType === "generic_type" || recvType === "field_access" ? this.extractJavaTypeBaseName(recv) : null;
+          const isKeywordReceiver = recvName === "this" || recvName === "super";
+          const isArrayTypeRef = recv.type === "array_type" || recv.text.endsWith("[]");
+          const isQualifiedThis = recvName !== null && (recvName === "this" || recvName.endsWith(".this"));
+          if (recvName && !isKeywordReceiver && !isArrayTypeRef && !isQualifiedThis && this.isJavaNameShape(recvName)) {
+            relationships.push({
+              source: refSource,
+              target: recvName,
+              type: ASTEngine.RelationshipType.References,
+              confidence: 0.9,
+              // M59 (#825): the referenced type is named by the receiver.
+              ...this.lineField(recv, node),
+              metadata: { relationshipType: "method_reference_receiver", javaCallExpression: node.text }
+            });
+          }
+        }
+        if (kids.length >= 2) {
+          relationships.push({
+            source: refSource,
+            target: kids[kids.length - 1].text,
+            type: ASTEngine.RelationshipType.Calls,
+            confidence: 0.8,
+            // M59 (#825): the referenced method is named by its own node.
+            ...this.lineField(kids[kids.length - 1], node),
+            metadata: { javaCallExpression: node.text }
+          });
+        }
+      } else if (type === "switch_label") {
+        const pat = this.findChildByType(node, "pattern");
+        if (pat) {
+          const tp = this.findChildByType(pat, "type_pattern") || pat;
+          const tnode = this.findChildByType(tp, "type_identifier") || this.findChildByType(tp, "generic_type") || this.findChildByType(tp, "scoped_type_identifier");
+          if (tnode) {
+            const typeName = tnode.type === "type_identifier" ? tnode.text : this.extractJavaTypeBaseName(tnode);
+            if (typeName) {
+              relationships.push({
+                source: parentContext?.name || parentContext?.symbolRef?.name || "global",
+                target: typeName,
+                type: ASTEngine.RelationshipType.References,
+                confidence: 0.95,
+                // M59 (#825): the case pattern's type is named by its node.
+                ...this.lineField(tnode, node),
+                metadata: { relationshipType: "switch_pattern" }
+              });
+            }
+          }
+        }
+      } else if (type === "local_variable_declaration" || type === "formal_parameter" || type === "spread_parameter" || type === "catch_formal_parameter" || // JD-J10 (M60 java deep review, 2026-09-27): two MORE declared-variable
+      // positions were missing, so the branch above did not implement the rule
+      // its own comment states. Both name a type in a declaration:
+      //   `for (Widget b : xs)`      JLS 14.14 — the for-each variable
+      //   `try (Widget w = open())`  JLS 14.20.3 — a try-with-resources
+      // Both are `enhanced_for_statement` and `resource` in this grammar, and
+      // NEITHER was in the list, so neither emitted a References edge.
+      //
+      // Found by turning `references` comparable for the first time (JD-J3):
+      // the truth derives the for-each loop type, the analyzer had no edge for
+      // it, and the differential reported it as MISSING. Verified with controls
+      // so the finding could not be an artifact of the probe — `Widget` in a
+      // local, a formal parameter and a catch parameter all emit, and `Widget`
+      // appears ONLY in the loop variable and is silently absent. (An earlier
+      // probe of mine appeared to show the for-each working; it was wrong —
+      // the `Object` it saw came from a `List<Object>` in the method SIGNATURE,
+      // emitted as `formal_parameter`. The loop type was missing in both
+      // cases. Recording that because the first measurement was the misleading
+      // one.)
+      type === "enhanced_for_statement" || type === "resource") {
+        const typeNode = node.childForFieldName("type") || this.findChildByType(node, "catch_type") || this.findChildByType(node, "type_identifier");
+        if (typeNode) {
+          for (const { name: t, line } of this.collectJavaTypeNames(typeNode)) {
+            if (t === "var") continue;
+            relationships.push({
+              source: parentContext?.name || parentContext?.symbolRef?.name || "global",
+              target: t,
+              type: ASTEngine.RelationshipType.References,
+              confidence: 0.95,
+              // M59 (#825): the line the declared TYPE is named on.
+              line_number: line,
+              metadata: { relationshipType: "declared_type", declaredOn: type }
+            });
+          }
+        }
+      } else if (type === "annotation" || type === "marker_annotation") {
+        const annotationNameNode = this.javaAnnotationNameNode(node);
+        if (annotationNameNode) {
+          const annotationSources = this.javaAnnotatedDeclarationSources(node, parentContext);
+          for (let annotationIdx = 0; annotationIdx < annotationSources.length; annotationIdx++) {
+            const annotationSource = annotationSources[annotationIdx];
+            relationships.push({
+              source: annotationSource.name,
+              target: annotationNameNode.text,
+              type: ASTEngine.RelationshipType.References,
+              confidence: 0.95,
+              // M59 (#825): the annotation TYPE is named by its name node — the
+              // `@` sigil and an argument list are not the name.
+              line_number: annotationNameNode.startPosition.row + 1,
+              metadata: {
+                relationshipType: "annotation",
+                isAnnotation: true,
+                annotatedKind: annotationSource.declKind,
+                evidenceClass: "structural"
+              }
+            });
+          }
+        }
+      } else if (type === "type_parameter") {
+        const boundNode = this.findChildByType(node, "type_bound");
+        if (boundNode) {
+          const paramNameNode = node.childForFieldName("name") || this.findChildByType(node, "type_identifier") || this.findChildByType(node, "identifier");
+          const boundReadSource = parentContext?.name || parentContext?.symbolRef?.name || "global";
+          for (const { name: boundType, line } of this.collectJavaTypeNames(boundNode)) {
+            relationships.push({
+              source: boundReadSource,
+              target: boundType,
+              type: ASTEngine.RelationshipType.References,
+              confidence: 0.95,
+              // M59 (#825): the line the BOUND type is named on.
+              line_number: line,
+              metadata: {
+                relationshipType: "type_parameter_bound",
+                ...paramNameNode ? { boundFor: paramNameNode.text } : {},
+                evidenceClass: "structural"
+              }
+            });
+          }
+        }
+      } else if (type === "throws") {
+        for (let i = 0; i < node.namedChildCount; i++) {
+          const child = node.namedChild(i);
+          if (!child) continue;
+          for (const { name: t, line } of this.collectJavaTypeNames(child)) {
+            relationships.push({
+              source: parentContext?.name || parentContext?.symbolRef?.name || "global",
+              target: t,
+              type: ASTEngine.RelationshipType.References,
+              confidence: 0.95,
+              // M59 (#825): the line the THROWN type is named on.
+              line_number: line,
+              metadata: { relationshipType: "throws_type" }
+            });
+          }
+        }
+      }
+      if (type === "identifier") {
+        const pt = node.parent?.type;
+        if (pt === "class_declaration" || pt === "interface_declaration" || pt === "enum_declaration" || pt === "record_declaration") {
+          const pat = node.text.endsWith("Factory") ? "factory" : node.text === "Singleton" ? "singleton" : node.text.endsWith("Builder") ? "builder" : null;
+          if (pat) patterns[pat] = true;
+        }
+      }
+      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 });
+        }
+      }
+    }
+    this.resolveOverrides(overrideTasks, classHierarchy, symbolMap, relationships, context?.overrideCompanion, methodsByOwner);
+    const primaryType = symbols.find((s) => {
+      if (s.ownerName || s.scope) return false;
+      return s.kind === ASTEngine.SymbolKind.Class || s.kind === ASTEngine.SymbolKind.Interface || s.kind === ASTEngine.SymbolKind.Enum;
+    });
+    if (primaryType) {
+      for (const rel of relationships) {
+        const isFileLevel = (rel.metadata ?? {}).fileLevel === true;
+        if (!isFileLevel && (rel.type === ASTEngine.RelationshipType.References || rel.type === ASTEngine.RelationshipType.Imports) && (rel.source === currentPackage || rel.source === "root")) {
+          rel.source = primaryType.name;
+          continue;
+        }
+        if (!isFileLevel && rel.type === ASTEngine.RelationshipType.Imports && (rel.metadata ?? {}).isJavaImport === true && (rel.source === currentPackage || rel.source === "root")) {
+          rel.source = primaryType.name;
+        }
+      }
+    }
+    const finalFrameworks = [];
+    for (const k in frameworks) finalFrameworks.push(k);
+    const finalPatterns = [];
+    for (const k in patterns) finalPatterns.push(k);
+    let hasSpring = false;
+    for (let i = 0; i < finalFrameworks.length; i++) {
+      if (finalFrameworks[i] === "spring") {
+        hasSpring = true;
+        break;
+      }
+    }
+    if (hasSpring) {
+      let hasSpringCore = false;
+      for (let i = 0; i < symbols.length; i++) {
+        if (this.hasJavaAnnotation(symbols[i], "Service") || this.hasJavaAnnotation(symbols[i], "Repository") || this.hasJavaAnnotation(symbols[i], "Component")) {
+          hasSpringCore = true;
+          break;
+        }
+      }
+      if (hasSpringCore) finalFrameworks.push("spring_core");
+    }
+    for (const s of symbols) {
+      const _owner = s.ownerName || s.scope;
+      if (_owner) {
+        const isPhantomMember = s.metadata?.isPhantom === true;
+        relationships.push({
+          source: _owner,
+          target: s.name,
+          type: ASTEngine.RelationshipType.Contains,
+          confidence: isPhantomMember ? 0.6 : 1,
+          // M59 (#825): a containment edge has no call site, but it does have a
+          // navigable one — the member's own declaration line, taken from the
+          // symbol so the edge and the symbol cannot disagree. Omitted, never
+          // zeroed, when the symbol has no line (#820/#821).
+          //
+          // A SYNTHESISED member has no declaration at all: java's phantoms
+          // (Spring-Data repository methods carry the INTERFACE's range, lombok
+          // getters/setters carry the FIELD's) name methods that are written
+          // nowhere in the source, so the class/field line can never be the site
+          // of the name. Same contract and same reasoning as kotlin's data-class
+          // phantoms — the line is omitted, not guessed.
+          ...s.metadata?.isPhantom !== true && s.range?.startLine ? { line_number: s.range.startLine } : {},
+          metadata: { isContained: true, ...isPhantomMember ? { inferred: true } : {} }
+        });
+      }
+    }
+    this.collectFieldAccessUses(rootNode, relationships, symbols, receiverTypes, context?.projectIndex);
+    this.attachJavaImportedFrom(relationships, receiverTypes, symbols);
+    this.attachJavaLibraryNamespaceCitations(relationships, symbols, receiverTypes, context?.projectIndex);
+    this.attachJavaImportedBindingClaims(relationships, symbols, receiverTypes);
+    this.attachJavaSingleTypeImportBindingClaims(relationships, symbols, receiverTypes, context?.projectIndex);
+    for (let i = 0; i < symbols.length; i++) {
+      const s = symbols[i];
+      const exportNodeType = String(s.metadata?.nodeType ?? "");
+      const isTopLevelTypeDecl = exportNodeType === "class_declaration" || exportNodeType === "interface_declaration" || exportNodeType === "enum_declaration" || exportNodeType === "record_declaration" || exportNodeType === "annotation_type_declaration" || // JLS 7.7 — a MODULE is an importable unit too, named by another
+      // module's `requires M` clause: `module com.example.widget` is written
+      // once, in this file, and that is the name a `requires` directive binds.
+      // java/module-exports-jpms pins it in `exports[]` with `kind: module`.
+      // (The module symbol carries no package, so the export-EDGE post-pass
+      // below declines it — `exportsWithNoPackage` — rather than fabricating a
+      // `package -> module` row; the Namespace symbols it owns are members and
+      // ride `contains`.)
+      exportNodeType === "module_declaration";
+      if (!s.metadata?.isPhantom && !s.ownerName && isTopLevelTypeDecl) {
+        exports.push({ name: s.name, kind: s.kind, range: s.range, visibility: s.visibility });
+      }
+    }
+    let exportsWithNoPackage = 0;
+    if (exports.length > 0) {
+      const exported = /* @__PURE__ */ new Set();
+      for (let i = 0; i < exports.length; i++) {
+        const e = exports[i];
+        const target = e.name;
+        if (!target) continue;
+        if (exported.has(target)) continue;
+        exported.add(target);
+        const isPublic = e.visibility === "public";
+        if (!currentPackage) {
+          exportsWithNoPackage++;
+          continue;
+        }
+        relationships.push({
+          source: currentPackage,
+          target,
+          type: ASTEngine.RelationshipType.Exports,
+          confidence: isPublic ? 1 : 0.6,
+          // M59 (#825): the exported DECLARATION's own line — the name is
+          // written there, not at whatever construct encloses it. Absent rather
+          // than 0 when the symbol carried no range (#823).
+          ...e.range?.startLine ? { line_number: e.range.startLine } : {},
+          metadata: {
+            relationshipType: "java_exportable_unit",
+            exportForm: isPublic ? "public_top_level_type" : "package_private_top_level_type",
+            ...isPublic ? {} : { reasonCode: "package_private_top_level_type" },
+            // The folded site's keys (see the note at the type-declaration
+            // branch, where this edge used to be emitted a second time).
+            //
+            // `isJavaExport` is TRUE only on the importable tier: JLS 7.6 makes a
+            // PUBLIC top-level type importable from another package, while a
+            // package-private one is reachable by name only from its own package
+            // (JLS 6.6.1) — which is exactly the claim the 0.6 tier and its
+            // `reasonCode` discount, and marking it as an export outright would
+            // assert the stronger fact.
+            ...isPublic ? { isJavaExport: true } : {},
+            kind: String(e.kind ?? ""),
+            // The join key, stated because it is not obvious: an `exports` edge is
+            // `package -> simpleName`, so `source + "." + target` reconstructs the
+            // dotted path an `imports` edge targets and the two labels meet without
+            // a resolver.
+            dottedName: `${currentPackage}.${target}`
+          }
+        });
+      }
+    }
+    this.classifyEvidenceTier(relationships);
+    this.markExternalTargets(relationships, symbols, imports, context);
+    return {
+      symbols,
+      relationships,
+      imports,
+      exports,
+      errors,
+      metadata: {
+        // +1 base: the walk above counts raw decision points; the stored
+        // metric is textbook cyclomatic complexity (family contract).
+        complexity: cyclomaticComplexity + 1,
+        linesOfCode: content.split("\n").length,
+        cyclomaticComplexity: cyclomaticComplexity + 1,
+        // Deterministic single-framework pick (hygiene 2026-09-08): the old
+        // finalFrameworks[0] depended on import ORDER. Fixed priority list,
+        // alphabetical tiebreak — same file always reports the same value.
+        framework: pickJavaFramework(finalFrameworks),
+        patterns: finalPatterns,
+        currentPackage,
+        // EXPORTS_JAVA2: the JPMS module this file declares ("" when the file is
+        // not a module-info.java). Absent means "no module declared"; it never
+        // means "a module nobody read" — that distinction is the whole reason the
+        // field exists.
+        ...moduleName ? { moduleName } : {},
+        detectedFrameworks: finalFrameworks,
+        frameworkPatterns: this.getJavaFrameworkPatterns(finalFrameworks, symbols),
+        hasTypeInference: true,
+        hasFrameworkIntelligence: true,
+        analysisVersion: "4.0.0-java-single-pass-stateless"
+      }
+    };
+  }
+  /**
+   * M14 #299 - evidence-tier classification for EVERY emitted relationship.
+   * Tiers: structural (grammar clauses, conf 1.0) | usage_contextual (calls,
+   * field access, companion-apply idioms) | import_based | reference_qualified
+   * | inferred (sub-1.0 resolutions). Applied centrally at end of analyze()
+   * so no emission site can forget it.
+   */
+  classifyEvidenceTier(relationships) {
+    for (const r of relationships) {
+      const md = r.metadata ?? (r.metadata = {});
+      if (md.evidenceClass) continue;
+      const t = String(r.type ?? r.relationshipType ?? "");
+      const conf = typeof r.confidence === "number" ? r.confidence : 1;
+      if (t === "contains" || t === "exports") {
+        md.evidenceClass = "structural";
+        continue;
+      }
+      if (t === "imports" || t === "brain_import") {
+        md.evidenceClass = "import_based";
+        continue;
+      }
+      if (t === "references") {
+        md.evidenceClass = md.isJavaImport || md.isGroovyImport || md.isImport || md.isModuleDirective ? "import_based" : "reference_qualified";
+        continue;
+      }
+      if (t === "extends" || t === "implements") {
+        md.evidenceClass = conf >= 1 ? "structural" : "inferred";
+        continue;
+      }
+      if (t === "overrides") {
+        md.evidenceClass = conf >= 1 ? "structural" : conf >= 0.85 ? "usage_contextual" : "inferred";
+        continue;
+      }
+      if (t === "instantiates") {
+        md.evidenceClass = md.isNew || conf >= 0.9 ? "structural" : "usage_contextual";
+        continue;
+      }
+      if (t === "imports") {
+        md.evidenceClass = "import_based";
+        continue;
+      }
+      md.evidenceClass = "usage_contextual";
+    }
+  }
+  /**
+   * EXPORTS_JAVA2: one JPMS module-directive edge.
+   *
+   * `source` is the module that writes the directive and `target` is the name the
+   * directive names — a package for `exports`/`opens`, a module for `requires`, a
+   * type for `uses`, a service and its implementations for `provides`. The line is
+   * the DIRECTIVE's own line, because that is where the name is written; the
+   * grammar gives the named target a span inside it, and a `to a, b` list puts
+   * every target on the directive's line anyway.
+   *
+   * Confidence 1.0 and `reasonCode: "module_directive"`: the dependency is
+   * written in the file. Nothing here is inferred — the one thing a static reader
+   * cannot know (whether the required module is on the module path at compile
+   * time) is not what this edge claims.
+   */
+  pushModuleDirective(relationships, module, targetNode, role) {
+    const target = targetNode.text;
+    if (!module || !target) return;
+    const line = targetNode.startPosition.row >= 0 ? { line_number: targetNode.startPosition.row + 1 } : {};
+    relationships.push({
+      source: module,
+      target,
+      type: ASTEngine.RelationshipType.References,
+      confidence: 1,
+      ...line,
+      metadata: {
+        relationshipType: role,
+        isModuleDirective: true,
+        isJavaModuleDirective: true,
+        reasonCode: "module_directive",
+        moduleName: module
+      }
+    });
+  }
+  findChild(node, predicate) {
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (child && predicate(child)) return child;
+    }
+    return null;
+  }
+  resolveOverrides(tasks, classHierarchy, symbolMap, relationships, companion, methodsByOwner) {
+    let suffixIndex = null;
+    for (let taskIdx = 0; taskIdx < tasks.length; taskIdx++) {
+      const task = tasks[taskIdx];
+      let targetFqn = null;
+      let confidence = 1;
+      let reasonCode = "exact-in-file";
+      if (!suffixIndex) {
+        suffixIndex = /* @__PURE__ */ new Map();
+        for (const fqn of classHierarchy.keys()) {
+          const bare = fqn.slice(fqn.lastIndexOf(".") + 1);
+          const arr = suffixIndex.get(bare);
+          if (arr) arr.push(fqn);
+          else suffixIndex.set(bare, [fqn]);
+        }
+      }
+      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();
+      let head = 0;
+      while (head < queue.length && !targetFqn) {
+        const parent = queue[head++];
+        if (seen.has(parent)) continue;
+        seen.add(parent);
+        const candidates = suffixIndex.get(parent) ?? [parent];
+        for (const cand of candidates) {
+          const potentialTargetFqn = `${cand}.${task.methodName}${task.signature}`;
+          const baseSym = symbolMap.get(potentialTargetFqn);
+          if (baseSym) {
+            if (baseSym.visibility !== "private") {
+              targetFqn = potentialTargetFqn;
+              break;
+            }
+            continue;
+          }
+          const members = methodsByOwner?.get(cand)?.get(task.methodName);
+          if (members) {
+            for (const member of members) {
+              if (member.visibility === "private") continue;
+              const params = member.parameters ?? [];
+              if (params.length !== task.arity) continue;
+              const baseSig = `(${params.map((p) => p.type || "unknown").join(",")})`;
+              if (!javaSigHasTypeVar(baseSig) && !javaSigHasTypeVar(task.signature)) continue;
+              targetFqn = `${cand}.${task.methodName}${task.signature}`;
+              confidence = 0.9;
+              reasonCode = "generic-substitution";
+              break;
+            }
+            if (targetFqn) break;
+          }
+        }
+        if (targetFqn) break;
+        for (const cand of candidates) {
+          const pH = classHierarchy.get(cand);
+          if (pH) {
+            for (let i = 0; i < pH.length; i++) queue.push(pH[i]);
+          }
+        }
+      }
+      if (!targetFqn && companion && ownerH && ownerH.length > 0) {
+        const declaring = findDeclaringParent(
+          task.methodName,
+          ownerH,
+          companion,
+          (t) => classHierarchy.get(t) ?? []
+        );
+        if (declaring) {
+          targetFqn = `${declaring}.${task.methodName}${task.signature}`;
+          confidence = 0.85;
+          reasonCode = "companion-index";
+        }
+      }
+      if (!targetFqn && task.explicit && ownerH && ownerH.length > 0) {
+        targetFqn = `${ownerH[0]}.${task.methodName}${task.signature}`;
+        confidence = 0.5;
+        reasonCode = "first-parent-guess";
+      }
+      if (targetFqn) {
+        const localSource = localEdgeLabel(task.fqn);
+        const localTarget = localEdgeName(targetFqn);
+        const localQualified = localEdgeLabel(targetFqn);
+        const declaringType = localQualified.lastIndexOf(".") > 0 ? localQualified.slice(0, localQualified.lastIndexOf(".")) : "";
+        relationships.push({
+          source: localSource,
+          target: localTarget,
+          type: ASTEngine.RelationshipType.Overrides,
+          confidence,
+          // M59 (#825): the override occurs at the OVERRIDING declaration, which
+          // the task carries from the node itself. Omitted, never zeroed, when it
+          // is somehow absent (#821).
+          ...task.line ? { line_number: task.line } : {},
+          metadata: {
+            relationshipType: "method_override",
+            isJavaOverride: true,
+            reasonCode,
+            ...declaringType ? { declaringType } : {}
+          }
+        });
+      }
+    }
+  }
+  processPhantomSymbols(scope, symbols, symbolMap, frameworks) {
+    const isSpringData = frameworks["spring_data"] || frameworks["spring"];
+    if (isSpringData && scope.isInterface) {
+      let isRepo = false;
+      for (let i = 0; i < scope.parents.length; i++) {
+        if (scope.parents[i].indexOf("JpaRepository") !== -1 || scope.parents[i].indexOf("CrudRepository") !== -1) {
+          isRepo = true;
+          break;
+        }
+      }
+      if (isRepo) {
+        const defaultMethods = ["save", "findById", "findAll", "deleteById", "delete", "count"];
+        for (let j = 0; j < defaultMethods.length; j++) {
+          const method = defaultMethods[j];
+          const sym = {
+            name: method,
+            kind: ASTEngine.SymbolKind.Method,
+            scope: scope.name,
+            ownerName: scope.name,
+            ownerKind: ASTEngine.SymbolKind.Interface,
+            modifiers: ["phantom", "framework_generated", "spring-data"],
+            range: scope.node ? this.nodeToRange(scope.node) : { startLine: 0, startColumn: 0, endLine: 0, endColumn: 0 },
+            // Payload consistency (claim 21): the symbolMap key carries the
+            // REAL signature (findById(Object), save(Object)) while the symbol
+            // payload said parameters:[] — resolution and display disagreed.
+            // A phantom method with an arity-carrying key has arity.
+            parameters: method === "findById" || method === "deleteById" || method === "save" || method === "delete" ? [{ name: "entity", type: "Object", isOptional: false }] : [],
+            returnType: "Object",
+            metadata: { isPhantom: true }
+          };
+          symbols.push(sym);
+          let phantomSig = "()";
+          if (method === "findById" || method === "deleteById" || method === "save" || method === "delete") {
+            phantomSig = "(Object)";
+          }
+          symbolMap.set(`${scope.fqn}.${method}${phantomSig}`, sym);
+        }
+      }
+    }
+    if (!scope.isInterface && !scope.isEnum) {
+      let isDataOrGetter = false;
+      let isDataOrSetter = false;
+      for (let i = 0; i < scope.annotations.length; i++) {
+        const d = scope.annotations[i];
+        let shortName = d.startsWith("@") ? d.slice(1) : d;
+        const paren = shortName.indexOf("(");
+        if (paren !== -1) shortName = shortName.slice(0, paren);
+        const lastDot = shortName.lastIndexOf(".");
+        if (lastDot !== -1) shortName = shortName.slice(lastDot + 1);
+        if (shortName === "Data" || shortName === "Getter") isDataOrGetter = true;
+        if (shortName === "Data" || shortName === "Setter") isDataOrSetter = true;
+      }
+      if (isDataOrGetter || isDataOrSetter) {
+        for (let idx = 0; idx < scope.fields.length; idx++) {
+          const prop = scope.fields[idx];
+          const capitalizedName = prop.name.charAt(0).toUpperCase() + prop.name.slice(1);
+          if (isDataOrGetter) {
+            const sym = {
+              name: `get${capitalizedName}`,
+              kind: ASTEngine.SymbolKind.Method,
+              scope: scope.name,
+              ownerName: scope.name,
+              ownerKind: ASTEngine.SymbolKind.Class,
+              modifiers: ["phantom", "lombok_generated"],
+              range: prop.range,
+              parameters: [],
+              returnType: prop.returnType || "Object",
+              metadata: { isPhantom: true }
+            };
+            symbols.push(sym);
+            symbolMap.set(`${scope.fqn}.get${capitalizedName}()`, sym);
+          }
+          if (isDataOrSetter) {
+            const sym = {
+              name: `set${capitalizedName}`,
+              kind: ASTEngine.SymbolKind.Method,
+              scope: scope.name,
+              ownerName: scope.name,
+              ownerKind: ASTEngine.SymbolKind.Class,
+              modifiers: ["phantom", "lombok_generated"],
+              range: prop.range,
+              parameters: [{ name: "value", type: prop.returnType || "Object" }],
+              returnType: "void",
+              metadata: { isPhantom: true }
+            };
+            symbols.push(sym);
+            symbolMap.set(`${scope.fqn}.set${capitalizedName}(${prop.returnType || "Object"})`, sym);
+          }
+        }
+      }
+    }
+  }
+  detectFrameworksFromImport(mod, frameworks) {
+    if (mod.startsWith("org.springframework")) frameworks["spring"] = true;
+    if (mod.startsWith("org.springframework.web")) frameworks["spring_mvc"] = true;
+    if (mod.startsWith("org.springframework.data")) frameworks["spring_data"] = true;
+    if (mod.startsWith("javax.persistence") || mod.startsWith("jakarta.persistence")) frameworks["jpa"] = true;
+    if (mod.startsWith("org.hibernate")) frameworks["hibernate"] = true;
+    if (mod.startsWith("org.mybatis")) frameworks["mybatis"] = true;
+    if (mod.startsWith("io.quarkus")) frameworks["quarkus"] = true;
+    if (mod.startsWith("io.micronaut")) frameworks["micronaut"] = true;
+    if (mod.startsWith("org.junit")) frameworks["junit"] = true;
+    if (mod.startsWith("org.mockito")) frameworks["mockito"] = true;
+    if (mod.startsWith("javax.servlet") || mod.startsWith("jakarta.servlet")) frameworks["servlet"] = true;
+    if (mod.startsWith("javax.ws.rs") || mod.startsWith("jakarta.ws.rs")) frameworks["jax_rs"] = true;
+  }
+  mapTypeToSymbolKind(type) {
+    if (type === "class_declaration" || type === "record_declaration") return ASTEngine.SymbolKind.Class;
+    if (type === "interface_declaration") return ASTEngine.SymbolKind.Interface;
+    if (type === "enum_declaration") return ASTEngine.SymbolKind.Enum;
+    return ASTEngine.SymbolKind.Class;
+  }
+  buildFqn(pkg, scopeStack, name) {
+    const parts = [];
+    if (pkg) parts.push(pkg);
+    for (let idx = 0; idx < scopeStack.length; idx++) {
+      const scope = scopeStack[idx];
+      if (scope.kind !== ASTEngine.SymbolKind.Method) {
+        parts.push(scope.name);
+      }
+    }
+    parts.push(name);
+    return parts.join(".");
+  }
+  /**
+   * Javadoc extraction: block_comment starting with '/**' immediately
+   * preceding the declaration (previous sibling). Previously java symbols
+   * carried NO comments - docstrings were silently lost (M14 #383).
+   */
+  /**
+   * Per-method cyclomatic complexity (1 + decision points). Previously java
+   * method symbols stored complexity=1 always - only the file-level counter
+   * was real. Kotlin parity (M14 #301 prerequisite).
+   */
+  calculateJavaMethodComplexity(node) {
+    let complexity = 1;
+    const stack = [node];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "if_statement" || n.type === "for_statement" || n.type === "enhanced_for_statement" || n.type === "while_statement" || n.type === "do_statement" || n.type === "switch_rule" || n.type === "switch_block_statement_group" || n.type === "catch_clause" || n.type === "ternary_expression") {
+        complexity++;
+      } else if (n.type === "binary_expression") {
+        const op = n.childForFieldName("operator")?.text;
+        if (op === "&&" || op === "||") complexity++;
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const child = n.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+    return complexity;
+  }
+  extractJavadocComment(node) {
+    const parent = node.parent;
+    if (!parent) return void 0;
+    let selfIdx = -1;
+    for (let i = 0; i < parent.namedChildCount; i++) {
+      const c = parent.namedChild(i);
+      if (c && c.startIndex === node.startIndex && c.endIndex === node.endIndex) {
+        selfIdx = i;
+        break;
+      }
+    }
+    for (let i = selfIdx - 1; i >= 0; i--) {
+      const sibling = parent.namedChild(i);
+      if (!sibling) continue;
+      if (sibling.type === "block_comment" && sibling.text.startsWith("/**")) return sibling.text;
+      break;
+    }
+    return void 0;
+  }
+  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
+    };
+  }
+  /**
+   * M59 (#825): the `line_number` field for a relationship, taken from the node
+   * that CARRIES THE NAME the edge is about.
+   *
+   * java shared scala's defect class in full: a `method_invocation` starts at
+   * its receiver, a type expression's start is not the line of the types inside
+   * it, and a definition node can start at its modifiers. The rule that holds in
+   * all cases is one sentence — the line belongs to the name, never to the
+   * construct that contains it — so callers pass the NAME node and this returns
+   * nothing at all when there is none (never 0: #820/#821, 0 means "unknown" to
+   * every reader, so unknown must be absent).
+   *
+   * `fallback` exists for sites where the analyzed construct has no name-bearing
+   * child at all (a `this(...)`/`super(...)` delegation, a `new` with a diamond).
+   */
+  lineField(nameNode, fallback) {
+    const n = nameNode ?? fallback;
+    return n ? { line_number: n.startPosition.row + 1 } : {};
+  }
+  /**
+   * M59 (#825): the node whose start is the DECLARATION's own line.
+   *
+   * An annotation is a modifier — `@SuppressWarnings("unused")` decorates the
+   * class, it is not where the class is written. Measured, not assumed: on a
+   * 300-file real java sample, **25 of 93 symbols (27%)** had their line on an
+   * annotation, so a tool navigating to a java symbol landed on `@Override` or
+   * `@SuppressWarnings` instead of the declaration. tree-sitter-java nests the
+   * annotations in a `modifiers` child, which is what is skipped here; the
+   * contract is scala's (settled first and pinned there), applied to java's node
+   * shape so kotlin and groovy can copy one rule instead of two.
+   *
+   * The symbol range and its `contains` edge move together, exactly as in scala:
+   * a symbol and the edge that names it must never disagree about the line.
+   */
+  declarationLineNode(node) {
+    const named = this.declarationNameNode(node);
+    if (named) return named;
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (!c) continue;
+      if (c.type === "modifiers") continue;
+      if (c.type === "line_comment" || c.type === "block_comment") continue;
+      return c;
+    }
+    return node;
+  }
+  /**
+   * The NAME node of a declaration, or null when the shape has none.
+   *
+   * `childForFieldName("name")` is the grammar's own answer for every shape that
+   * has one — class/interface/enum/record/annotation-type declarations, methods,
+   * constructors, enum constants and type parameters. A FIELD is the exception:
+   * its name lives in a nested `variable_declarator`, so the declarator is asked
+   * instead. Multi-declarator fields (`int a, b;`) carry one declarator each; the
+   * FIRST one is the declaration's own line, which is also the line the field
+   * symbol is published under.
+   */
+  declarationNameNode(node) {
+    const field = node.childForFieldName?.("name");
+    if (field && (field.type === "identifier" || field.type === "type_identifier")) return field;
+    if (node.type === "field_declaration") {
+      const declarator = this.findChildByType(node, "variable_declarator");
+      const name = declarator?.childForFieldName?.("name");
+      if (name) return name;
+    }
+    return null;
+  }
+  /**
+   * M59 (#825): the line of the ANNOTATION that names this edge's target.
+   *
+   * Annotation-derived edges (a JPA table, a mapped column, a FeignClients
+   * service, a `@Value` config key, a route) carry a target whose NAME IS WRITTEN
+   * INSIDE THE ANNOTATION. The declaration's line is not where that name is, so
+   * pointing the edge at the declaration would fail the very source check this
+   * milestone exists for — the check looks for the target name on the claimed
+   * line. Returns undefined when the annotation is absent, and callers omit the
+   * field rather than writing 0 (#821).
+   */
+  annotationLine(node, name, targetName) {
+    const mods = this.findChildByType(node, "modifiers") ?? node;
+    for (let i = 0; i < mods.namedChildCount; i++) {
+      const c = mods.namedChild(i);
+      if (!c) continue;
+      if (c.type !== "annotation" && c.type !== "marker_annotation") continue;
+      const id = c.childForFieldName?.("name") ?? this.findChildByType(c, "identifier") ?? this.findChildByType(c, "scoped_identifier");
+      const leaf = id ? String(id.text).split(".").pop() : "";
+      if (leaf === name) {
+        if (targetName) {
+          const quoted = `"${targetName}"`;
+          const found = this.findStringToken(c, quoted);
+          if (found) return found.startPosition.row + 1;
+        }
+        return c.startPosition.row + 1;
+      }
+    }
+    return void 0;
+  }
+  /** First descendant whose text is exactly the quoted token (the string literal that carries an annotation target name). */
+  findStringToken(node, quoted) {
+    if (node.text === quoted) return node;
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (!c) continue;
+      const hit = this.findStringToken(c, quoted);
+      if (hit) return hit;
+    }
+    return null;
+  }
+  /** The range of a SYMBOL (not of an import or an error): annotations skipped. */
+  symbolRange(node) {
+    const decl = this.declarationLineNode(node);
+    const base = this.nodeToRange(node);
+    return {
+      ...base,
+      startLine: decl.startPosition.row + 1,
+      startColumn: decl.startPosition.column + 1,
+      startIndex: decl.startIndex
+    };
+  }
+  findChildByType(node, type) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child && child.type === type) return child;
+    }
+    return null;
+  }
+  findAllChildrenByType(node, type) {
+    const results = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child && child.type === type) results.push(child);
+    }
+    return results;
+  }
+  /**
+   * All named types referenced inside a type subtree: the base of a generic
+   * (`List<X>` → List), each type argument recursively (`Map<String,
+   * List<X>>` → Map, String, X), scoped names in full dotted form per the
+   * M14 dotted-name convention (`java.util.List` stays dotted), and array
+   * element types. Union catch types are visited via their catch_type parent.
+   * Primitives never match these node shapes and are correctly excluded.
+   */
+  /**
+   * M59 (#825): `{name, line}` pairs, not bare names.
+   *
+   * Every edge these names feed is a `references` edge, and its line must be the
+   * line the TYPE IS NAMED — not the line the enclosing type expression starts
+   * on. java writes long type expressions across lines (`Map<String,\n  List<X>>`),
+   * so the two differ in exactly the places a tool would point at the wrong code.
+   * The shape is the one scala settled on for the same reason: collect the node
+   * with the name, then the line cannot be taken from the parent by accident.
+   */
+  collectJavaTypeNames(node) {
+    const out = [];
+    const seen = /* @__PURE__ */ new Set();
+    const visit = (n) => {
+      if (n.type === "type_identifier" || n.type === "scoped_type_identifier") {
+        const nm = n.type === "type_identifier" ? n.text : javaTypeBaseName(n);
+        if (nm && !seen.has(nm)) {
+          seen.add(nm);
+          out.push({ name: nm, line: n.startPosition.row + 1 });
+        }
+        return;
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const child = n.namedChild(i);
+        if (child) visit(child);
+      }
+    };
+    visit(node);
+    return out;
+  }
+  /**
+   * THE IMPORTED-BINDING CLAIM FOR STATIC IMPORTS (Lead claim kind, live 2026-10-19).
+   *
+   * Two halves, and BOTH are needed because the arbiter verifies one against the other:
+   *
+   * 1. EVIDENCE ON THE IMPORT EDGE. For every `import static pkg.Type.member;` the analyzer
+   *    publishes `metadata.importedBindings = [member]` and `metadata.module = pkg.Type` (the
+   *    CONTAINER as written — the gate's evidence map is keyed by exactly that specifier). The
+   *    written target stays the full member path; this is additive metadata.
+   *
+   * 2. THE CLAIM ON THE USE EDGE. A calls row whose call expression is a BARE name (no receiver)
+   *    or a uses row that is a BARE READ, whose target is the bound name and whose import's
+   *    container root is EXTERNAL, carries
+   *       metadata.importedBinding = { specifier: pkg.Type, binding: member }.
+   *    The arbiter verifies it against the evidence map (own column: bindOK), never folds it into
+   *    resolved, and refutes a claim whose evidence contradicts it.
+   *
+   * REFUSALS, each a way the claim could become FALSE: a container that is NOT external (a project
+   * class's static member is project code and must resolve internally); a name the FILE itself
+   * declares (the declaration shadows the import — the call/read is not the imported binding); a
+   * receiver-carrying call (its target is a member leaf, not the bound name); an on-demand static
+   * import (`import static X.*` binds no name this file states).
+   */
+  attachJavaImportedBindingClaims(relationships, symbols, index) {
+    if (index.staticImportPaths.size === 0) return;
+    const fileDeclared = /* @__PURE__ */ new Set();
+    for (const s of symbols) if (s && s.name) fileDeclared.add(s.name);
+    const isExternalContainer = (container) => {
+      for (const root of JAVA_EXTERNAL_STATIC_IMPORT_ROOTS) if (container.startsWith(root)) return true;
+      for (const root of JAVA_LIBRARY_NAMESPACE_CITATIONS) if (container.startsWith(`${root}.`)) return true;
+      return false;
+    };
+    for (const r of relationships) {
+      if (String(r.type ?? "") !== "imports") continue;
+      const md = r.metadata;
+      if (!md || typeof md !== "object") continue;
+      if (md.isStatic !== true || md.isWildcard === true) continue;
+      const target = String(r.target ?? "");
+      const dot = target.lastIndexOf(".");
+      if (dot <= 0 || dot >= target.length - 1) continue;
+      const container = target.slice(0, dot);
+      const member = target.slice(dot + 1);
+      if (!isExternalContainer(container)) continue;
+      md.importedBindings = [member];
+      md.module = container;
+    }
+    for (const r of relationships) {
+      const label = String(r.type ?? "");
+      if (label !== "calls" && label !== "uses") continue;
+      const md = r.metadata;
+      if (!md || typeof md !== "object") continue;
+      if (md.importedBinding !== void 0) continue;
+      const target = String(r.target ?? "");
+      if (!isPlainJavaIdentifier(target)) continue;
+      if (fileDeclared.has(target)) continue;
+      const container = index.staticImportPaths.get(target);
+      if (!container || !isExternalContainer(container)) continue;
+      if (label === "calls") {
+        const callExpr = typeof md.javaCallExpression === "string" ? md.javaCallExpression : "";
+        if (callExpr.length === 0 || callExpr.indexOf(".") !== -1) continue;
+      } else if (md.isBareRead !== true) {
+        continue;
+      }
+      md.importedBinding = { specifier: container, binding: target };
+    }
+  }
+  /**
+   * THE PROJECT'S OWN KEY SPACE, read the way the ARBITER reads it: how many declarations answer
+   * to a name. The arbiter's key space counts every published symbol by its SIMPLE name — a type,
+   * a method, a field, a constant, an enum constant, a constructor — and a declaration's simple
+   * name is exactly what the name-keyed resolver looks up.
+   *
+   * THE INDEX'S TWO CHANNELS ARE THE SAME COUNT, SPLIT. `symbolCounts` holds the TYPES by name;
+   * `typeMembers` holds the MEMBERS by owner. A name the project declares ONCE as a type and ONCE
+   * as a field — the `public static final Foo Foo = new Foo();` idiom, which is what most of the
+   * lane's AMBIGUOUS type-shaped rows are (measured: 34,306 of 39,779) — answers to the name
+   * TWICE, and the type channel alone would say once. So the count is the sum of the two, and it
+   * is cached per index because the index is per REPOSITORY and the answer is per name.
+   */
+  static javaDeclCountCache = /* @__PURE__ */ new WeakMap();
+  static javaDeclCounts(index) {
+    const hit = _RealJavaAnalyzer.javaDeclCountCache.get(index);
+    if (hit) return hit;
+    const counts = /* @__PURE__ */ new Map();
+    for (const [name, n] of index.symbolCounts) counts.set(name, (counts.get(name) ?? 0) + n);
+    for (const members of index.typeMembers.values()) {
+      for (const name of members) counts.set(name, (counts.get(name) ?? 0) + 1);
+    }
+    _RealJavaAnalyzer.javaDeclCountCache.set(index, counts);
+    return counts;
+  }
+  /**
+   * THE EXTERNAL SINGLE-TYPE-IMPORT BINDING CLAIM (java lane, 2026-10-20).
+   *
+   * THE SHAPE IS THE ARBITER'S, NOT THIS LANE'S. `metadata.importedBinding = { specifier, binding }`
+   * says *"the name `binding` is bound, in this file, by the import `specifier`"*, and the arbiter
+   * verifies it against the run's OWN import evidence — the `importedBindings` + `module` metadata
+   * an `imports` edge publishes — in its OWN column (`bindOK`), never in `resolved`. The
+   * static-import arm proved the shape on this lane: **391 verified claims, bindFAIL 0** (the
+   * `java/library-import-binding` fixture, 76/0). This method applies the SAME shape to the OTHER
+   * import form java has: the SINGLE-TYPE import, `import java.util.List;`, which binds the simple
+   * name `List`.
+   *
+   * WHY IT IS A TRUE STATEMENT (JLS 6.4.1). A single-type-import declaration d in a compilation unit
+   * c of package p that imports a type named n shadows, throughout c, the declarations of any top
+   * level type named n declared in another compilation unit of p, and any type named n imported on
+   * demand in c. A type in another package is not in scope at all unless it is imported. So INSIDE
+   * THE FILE the simple name is UNAMBIGUOUS: it names the imported type and nothing else. The
+   * store's key space is NAME-KEYED and repo-wide, so it answers a different question ("how many
+   * declarations in this repo are called `List`?") — which is why the row stays a tie, and why the
+   * tie is a NAME-MODEL artefact rather than a fact about the file.
+   *
+   * THE CLAIM IS A TIE-BREAKER, AND IT IS ONLY EMITTED WHERE A TIE EXISTS. Three conditions, each
+   * one a way the claim could become FALSE or pointless:
+   *
+   *   1. **THE PROJECT'S KEY SPACE GIVES THE SIMPLE NAME MORE THAN ONE ANSWER.** This is the wall
+   *      the claim exists to close. With EXACTLY ONE answer the name model RESOLVES the row, and a
+   *      claim there would trade a resolution for a claim — the campaign's "claims are never
+   *      merged into resolution", read in the direction that keeps the strongest class. With NO
+   *      answer the analyzer's own external claim ("the project declares no such name") already
+   *      verifies the row, and a second claim on it would replace one verified claim with another
+   *      and move the row between two verified columns for no gain at all. So the claim is emitted
+   *      for the TIE and for nothing else.
+   *      **A COMPLETE PROJECT INDEX IS REQUIRED TO SEE A TIE AT ALL**, so the rule is fail-closed:
+   *      no complete index ⇒ no claim ⇒ the no-index arm is byte-identical to its previous value.
+   *   2. **THE IMPORTED TYPE IS OUTSIDE THE PROJECT.** With the complete index in hand, the
+   *      project must NOT declare the qualified path: the index saw the project's whole admitted
+   *      file set, so "the project declares no such type" is a STATEMENT and not a guess — and it
+   *      REFUTES the claim when the project DOES declare it. A project-internal import names
+   *      project code, which must resolve through the owner/name model.
+   *   3. **THE FILE DOES NOT DECLARE THE NAME, AND NO STATIC IMPORT BINDS IT.** A name the file
+   *      declares shadows the import (JLS 6.4.1); a name a static import also binds is the static
+   *      arm's shape (two imports of one name is a compile error).
+   *
+   * AND THE CLAIM IS ONLY PUT ON A ROW WHERE THE TARGET IS THE BOUND NAME, IN A TYPE POSITION.
+   * `references` / `instantiates` / `extends` / `implements` only: a read or a call target is a
+   * member leaf, and a local variable may shadow a type name in an expression (JLS 6.5.5.1), so
+   * only a type position is safe. A dotted target is not the bound name either.
+   */
+  attachJavaSingleTypeImportBindingClaims(relationships, symbols, index, projectIndex) {
+    if (projectIndex?.complete !== true) return;
+    if (index.importSinglePaths.size === 0) return;
+    const fileDeclared = /* @__PURE__ */ new Set();
+    for (const s of symbols) if (s && s.name) fileDeclared.add(s.name);
+    const declCounts = _RealJavaAnalyzer.javaDeclCounts(projectIndex);
+    const eligible = /* @__PURE__ */ new Map();
+    for (const [leaf, path] of index.importSinglePaths) {
+      if (leaf.length === 0 || path.length === 0) continue;
+      if (fileDeclared.has(leaf)) continue;
+      if (index.staticImportPaths.has(leaf)) continue;
+      if ((declCounts.get(leaf) ?? 0) < 2) continue;
+      if (projectIndex.typeKinds.has(path) || projectIndex.symbolNames.has(path)) continue;
+      eligible.set(leaf, path);
+    }
+    if (eligible.size === 0) return;
+    for (const r of relationships) {
+      if (String(r.type ?? "") !== "imports") continue;
+      const md = r.metadata;
+      if (!md || typeof md !== "object") continue;
+      if (md.isStatic === true || md.isWildcard === true) continue;
+      const target = String(r.target ?? "");
+      const dot = target.lastIndexOf(".");
+      if (dot <= 0 || dot >= target.length - 1) continue;
+      const leaf = target.slice(dot + 1);
+      const path = eligible.get(leaf);
+      if (!path || path !== target) continue;
+      md.importedBindings = [leaf];
+      md.module = path;
+    }
+    const TYPE_LABELS = /* @__PURE__ */ new Set(["references", "instantiates", "extends", "implements"]);
+    for (const r of relationships) {
+      const label = String(r.type ?? "");
+      if (!TYPE_LABELS.has(label)) continue;
+      const md = r.metadata;
+      if (!md || typeof md !== "object") continue;
+      if (md.importedBinding !== void 0) continue;
+      const target = String(r.target ?? "");
+      if (!isPlainJavaIdentifier(target)) continue;
+      const path = eligible.get(target);
+      if (!path) continue;
+      md.importedBinding = { specifier: path, binding: target };
+    }
+  }
+  /**
+   * LIBRARY-NAMESPACE CITATIONS — attach the arbiter's `languageNamespace` claim to targets whose
+   * LEADING SEGMENTS name a root in the shared registry `java-platform-libraries`.
+   *
+   * WHAT IT MOVES AND WHAT IT CANNOT. The arbiter's namespace claim is a CITATION: a target whose
+   * leading segments equal a declared root is `externalVerified` (`verifiedBy: "namespace"`), is
+   * counted in `extOK`, and is NEVER folded into `resolved`. It is refutable by construction (a
+   * root not in the declared list REFUTES), which is why the declared list is the registry's
+   * subset and nothing else. A BARE target (a type name with no dots) can never match a prefix
+   * segment and is therefore NOT claimed here — those rows need the imported-binding claim kind
+   * (Lead task-19), which is why the depth wave leaves them as a sized residual.
+   *
+   * Measured before this: the depth residual `ext?` 2,446 carried 1,160 non-reserved dotted rows
+   * (jakarta 1,114 · androidx.media3 10 · org.yaml 4 · dotty.tools 2) whose roots are exactly this
+   * registry entry. Nothing is claimed for roots outside it.
+   */
+  attachJavaLibraryNamespaceCitations(relationships, symbols, index, projectIndex) {
+    if (projectIndex?.complete !== true) return;
+    const projectOwnsQualified = (qualified) => projectIndex.typeKinds.has(qualified) || projectIndex.symbolNames.has(qualified);
+    const fileDeclared = /* @__PURE__ */ new Set();
+    for (const s of symbols) if (s && s.name) fileDeclared.add(s.name);
+    const roots = [...JAVA_LIBRARY_NAMESPACE_CITATIONS].sort((a, b) => b.length - a.length);
+    for (const r of relationships) {
+      const md = r.metadata;
+      if (!md || typeof md !== "object") continue;
+      if (md.languageNamespace !== void 0) continue;
+      const target = String(r.target ?? "");
+      if (target.length === 0) continue;
+      for (const root of roots) {
+        if (target !== root && !target.startsWith(`${root}.`)) continue;
+        if (projectOwnsQualified(target)) return;
+        md.languageNamespace = [root];
+        break;
+      }
+      if (md.languageNamespace !== void 0) continue;
+      if (fileDeclared.has(target)) continue;
+      const importedPath = index.importSinglePaths.get(target);
+      if (!importedPath) continue;
+      for (const root of roots) {
+        if (!importedPath.startsWith(`${root}.`)) continue;
+        if (projectOwnsQualified(importedPath)) return;
+        md.languageNamespace = [target];
+        break;
+      }
+    }
+  }
+  /**
+   * THE IMPORTED-NAME SEAM — `metadata.importedFrom` on type-shaped reference edges whose
+   * first name segment is a KNOWN single-type import of this file.
+   *
+   * WHAT IT IS FOR (task-17 item 2 / D7): the wall `references type-shaped` is 84,751
+   * ambiguous+unresolved rows whose targets are bare type names; for 32,176 of them the
+   * FILE's own import states which package the name comes from. The store's name-keyed
+   * resolver cannot see the file's imports, so the row stays a tie — but joining the
+   * import path to the target yields the declaration's QUALIFIED NAME, which the store's
+   * symbol table already carries (`qualifiedName` aliases are indexed). This method is the
+   * ANALYZER HALF of that instrument: it publishes the seam; the resolver change that
+   * consumes it is Lead-owned (`parallel-indexer.resolveRelationships`), and the sizing
+   * comes from the lane's ambiguity classifier (same-file 81,448 · single-type-import
+   * 39,828 over all labels).
+   *
+   * ADDITIVE ONLY: the target spelling is untouched (JD20's bare-leaf contract and the
+   * differential oracle both stay), the key is not in any claim channel, and a row that
+   * already carries `importedFrom` keeps it. Nested spellings join the remainder too —
+   * `Map.Entry` under `import java.util.Map` publishes `java.util.Map.Entry`, which is
+   * exactly the qualified form of the nested type.
+   */
+  attachJavaImportedFrom(relationships, index, symbols) {
+    if (index.importSinglePaths.size === 0) return;
+    const declared = /* @__PURE__ */ new Set();
+    for (const s of symbols) if (s && s.name) declared.add(s.name);
+    const TYPE_LABELS = /* @__PURE__ */ new Set(["references", "instantiates", "extends", "implements"]);
+    const MEMBER_LABELS = /* @__PURE__ */ new Set(["calls", "uses"]);
+    for (const r of relationships) {
+      const label = String(r.type ?? "");
+      if (!TYPE_LABELS.has(label) && !MEMBER_LABELS.has(label)) continue;
+      const md = r.metadata;
+      if (!md || typeof md !== "object" || md.importedFrom !== void 0) continue;
+      const target = String(r.target ?? "");
+      if (target.length === 0) continue;
+      if (MEMBER_LABELS.has(label) && index.staticImportPaths.has(target) && !declared.has(target)) {
+        md.importedFrom = `${index.staticImportPaths.get(target)}.${target}`;
+        continue;
+      }
+      if (!TYPE_LABELS.has(label)) continue;
+      const first = target.split(".")[0];
+      if (first.length === 0 || declared.has(first)) continue;
+      const imported = index.importSinglePaths.get(first);
+      if (!imported) continue;
+      const remainder = target.length > first.length ? target.slice(first.length) : "";
+      if (remainder.length > 0) {
+        let shapeOk = remainder.startsWith(".");
+        for (let i = 1; shapeOk && i < remainder.length; i++) {
+          const code = remainder.charCodeAt(i);
+          if (code === 46) continue;
+          const isStart = code >= 65 && code <= 90 || code >= 97 && code <= 122 || code === 36 || code === 95;
+          const isPart = isStart || code >= 48 && code <= 57;
+          if (!isPart) {
+            shapeOk = false;
+            break;
+          }
+          if (i > 0 && code !== 46) {
+            const prev = remainder.charCodeAt(i - 1);
+            const prevIsDot = prev === 46;
+            if (prevIsDot && !isStart) {
+              shapeOk = false;
+              break;
+            }
+          }
+        }
+        if (!shapeOk) continue;
+      }
+      md.importedFrom = remainder.length > 0 ? `${imported}${remainder}` : imported;
+    }
+  }
+  /**
+   * Collect Uses relationships from field_access expressions (this.name, obj.method)
+   */
+  collectFieldAccessUses(rootNode, relationships, symbols, receiverTypes, projectIndex) {
+    const membersByOwner = /* @__PURE__ */ new Map();
+    for (const s of symbols) {
+      const o = s.ownerName || s.scope;
+      if (!o) continue;
+      const set = membersByOwner.get(o);
+      if (set) set.add(s.name);
+      else membersByOwner.set(o, /* @__PURE__ */ new Set([s.name]));
+    }
+    const stack = [
+      { node: rootNode, owner: null, method: null, locals: /* @__PURE__ */ new Set() }
+    ];
+    const seen = /* @__PURE__ */ new Set();
+    while (stack.length > 0) {
+      const item = stack.pop();
+      const { node, owner, method, locals } = item;
+      if (node.type === "class_declaration" || node.type === "interface_declaration" || node.type === "enum_declaration" || node.type === "record_declaration" || // M37.21 C17: member reads INSIDE an @interface body previously kept
+      // the outer owner — @interface is a type declaration like the others,
+      // so its member declarations must rebind the read owner.
+      node.type === "annotation_type_declaration") {
+        const nameNode = this.findChildByType(node, "identifier");
+        const nextOwner = nameNode ? nameNode.text : owner;
+        for (let i = node.namedChildCount - 1; i >= 0; i--) {
+          const child = node.namedChild(i);
+          if (child) stack.push({ node: child, owner: nextOwner, method: null, locals: /* @__PURE__ */ new Set() });
+        }
+        continue;
+      }
+      let nextMethod = method;
+      let nextLocals = locals;
+      if (node.type === "method_declaration" || node.type === "constructor_declaration" || node.type === "compact_constructor_declaration") {
+        const nameNode = node.childForFieldName("name") || this.findChildByType(node, "identifier");
+        nextMethod = node.type === "constructor_declaration" || node.type === "compact_constructor_declaration" ? owner ?? "constructor" : nameNode?.text ?? method;
+        nextLocals = this.collectBoundNames(node);
+      }
+      if (node.type === "field_access") {
+        const parts = node.text.split(".");
+        if (parts.length >= 2) {
+          const first = parts[0];
+          const readOwner = method ?? owner;
+          const source = first === "this" || first === "super" ? method ?? owner ?? first : readOwner ?? first;
+          const parent = node.parent;
+          const lhs = parent && parent.type === "assignment_expression" ? parent.namedChild(0) : null;
+          const isWrite = !!lhs && lhs.startIndex === node.startIndex && lhs.endIndex === node.endIndex;
+          const key = `${source}.${parts[parts.length - 1]}`;
+          if (!isWrite && !seen.has(key)) {
+            seen.add(key);
+            const readReceiver = this.javaReceiverOwnerType(node, receiverTypes, projectIndex, "uses");
+            relationships.push({
+              source,
+              target: parts[parts.length - 1],
+              type: ASTEngine.RelationshipType.Uses,
+              confidence: 0.6,
+              // M59 (#825): the READ is where the field NAME is written — the
+              // `field` node, not the field_access (which starts at its
+              // receiver, the same defect class as the call site).
+              ...this.lineField(node.childForFieldName("field"), node),
+              metadata: {
+                isFieldAccess: true,
+                ...readReceiver ? { owner: readReceiver.type, ownerEvidence: readReceiver.evidence } : {}
+              }
+            });
+          }
+        }
+      }
+      if (node.type === "array_access") {
+        const arrayNode = node.childForFieldName("array");
+        if (arrayNode) {
+          const parent = node.parent;
+          const lhs = parent && parent.type === "assignment_expression" ? parent.namedChild(0) : null;
+          const isWrite = !!lhs && lhs.startIndex === node.startIndex && lhs.endIndex === node.endIndex;
+          const at = arrayNode.type;
+          let source = null;
+          let target = null;
+          if (at === "identifier") {
+            const readOwner = method ?? owner;
+            source = readOwner ?? arrayNode.text;
+            target = arrayNode.text;
+          } else if (at === "field_access" || at === "scoped_identifier") {
+            const parts = arrayNode.text.split(".");
+            if (parts.length >= 2) {
+              const first = parts[0];
+              const readOwner = method ?? owner;
+              source = first === "this" || first === "super" ? method ?? owner ?? first : readOwner ?? first;
+              target = parts[parts.length - 1];
+            }
+          }
+          if (source && target && !isWrite) {
+            const key = `${source}.${target}`;
+            if (!seen.has(key)) {
+              seen.add(key);
+              relationships.push({
+                source,
+                target,
+                type: ASTEngine.RelationshipType.Uses,
+                confidence: 0.6,
+                // M59 (#825): the array read is named by the array expression.
+                ...this.lineField(arrayNode, node),
+                metadata: { isArrayAccess: true }
+              });
+            }
+          }
+        }
+      }
+      if (node.type === "identifier") {
+        const txt = node.text;
+        if (txt !== "this" && txt !== "super") {
+          const parent = node.parent;
+          const memberish = parent?.type === "field_access" || parent?.type === "method_invocation" || parent?.type === "scoped_identifier" || parent?.type === "array_access";
+          const annotationName = parent?.type === "marker_annotation" || parent?.type === "annotation";
+          const declName = (parent?.type === "variable_declarator" || parent?.type === "formal_parameter" || parent?.type === "method_declaration" || parent?.type === "constructor_declaration" || parent?.type === "class_declaration" || parent?.type === "interface_declaration" || parent?.type === "enum_declaration" || parent?.type === "record_declaration" || parent?.type === "annotation_type_declaration" || parent?.type === "enum_constant" || parent?.type === "catch_formal_parameter" || parent?.type === "enhanced_for_statement" || // A COMPACT CONSTRUCTOR (JLS 8.10.4) and an ANNOTATION TYPE ELEMENT
+          // (JLS 9.6.1) both NAME a member: `R { ... }` and `Class<?> value();`.
+          // The first is the constructor's own name and the second is an element
+          // declaration, so neither is a read of an enclosing member — but the
+          // list above did not include them and probe on the pinned grammar
+          // showed both fabricated a bare read: record R(int x) { R { ... } }
+          // emitted `uses R -> R` and `@interface Ann { List<String> list(); }`
+          // emitted `uses Ann -> list`. A name is not a read; GATE A below then
+          // let the fabricated edge through because the member map carried it.
+          parent?.type === "compact_constructor_declaration" || parent?.type === "annotation_type_element_declaration") && parent.childForFieldName("name")?.startIndex === node.startIndex;
+          let isWrite = false;
+          if (parent?.type === "assignment_expression") {
+            const lhs = parent.childForFieldName("left") ?? parent.namedChild(0);
+            isWrite = !!lhs && lhs.startIndex === node.startIndex;
+          }
+          const isDeclaredMember = !!owner && (membersByOwner.get(owner)?.has(txt) ?? false);
+          const readSource = method ?? owner;
+          const key = readSource ? `${readSource}.#${txt}` : null;
+          if (!memberish && !annotationName && !declName && !isWrite && !locals.has(txt) && isDeclaredMember && readSource && key && !seen.has(key)) {
+            seen.add(key);
+            let bareOwner = null;
+            if (owner && this.javaTypeEligible(owner, receiverTypes, projectIndex) && this.javaOwnerResolvable(owner, txt, "uses", receiverTypes, projectIndex)) {
+              bareOwner = owner;
+            }
+            relationships.push({
+              source: readSource,
+              target: txt,
+              type: ASTEngine.RelationshipType.Uses,
+              // 1.0, not the 0.6 an inferred read carries. This edge is gated on
+              // `isDeclaredMember`, i.e. the owner was CHECKED to declare the member
+              // (`membersByOwner`), so "this type declares this field" is verified rather
+              // than guessed. At 0.6 the harness classified it as emitted-but-not-claimed
+              // (below the 0.7 threshold) while truth says "resolved" -- a false negative
+              // for a correct edge.
+              confidence: 1,
+              // M59 (#825): the bare read IS its identifier node.
+              line_number: node.startPosition.row + 1,
+              metadata: { isBareRead: true, ...bareOwner ? { owner: bareOwner, ownerEvidence: "this" } : {} }
+            });
+          }
+        }
+      }
+      for (let i = node.namedChildCount - 1; i >= 0; i--) {
+        const child = node.namedChild(i);
+        if (child) stack.push({ node: child, owner, method: nextMethod, locals: nextLocals });
+      }
+    }
+  }
+  /**
+   * M49 #739 GATE B: the names a function body BINDS — parameters, locals,
+   * catch/enhanced-for/lambda/resource bindings. A bare read of any of these
+   * is not a member read (CGD15 family rule shared with c/cpp).
+   *
+   * Deliberately method-wide rather than block-scoped: a local declared AFTER
+   * a use still suppresses that use, which can only LOSE an edge, never
+   * fabricate one — the correct direction under the precision rule. Nested
+   * type bodies reset this set (the class branch above), so a nested class's
+   * member reads are never suppressed by the enclosing method.
+   */
+  collectBoundNames(fnNode) {
+    const names = /* @__PURE__ */ new Set();
+    const stack = [fnNode];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "variable_declarator" || n.type === "formal_parameter" || n.type === "catch_formal_parameter" || n.type === "enhanced_for_statement" || n.type === "resource") {
+        const nm = n.childForFieldName("name") || this.findChildByType(n, "identifier");
+        if (nm) names.add(nm.text);
+      } else if (n.type === "lambda_expression") {
+        const params = n.childForFieldName("parameters");
+        if (params) {
+          if (params.type === "identifier") names.add(params.text);
+          else for (let i = 0; i < params.namedChildCount; i++) {
+            const c = params.namedChild(i);
+            if (c) names.add(c.text);
+          }
+        }
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return names;
+  }
+  childText(node, type) {
+    const child = this.findChildByType(node, type);
+    return child ? child.text : null;
+  }
+  getJavaModifiers(node) {
+    const modifiers = [];
+    const modifiersNode = this.findChildByType(node, "modifiers");
+    if (modifiersNode) {
+      for (let i = 0; i < modifiersNode.childCount; i++) {
+        const modifier = modifiersNode.child(i);
+        if (modifier && !stringIncludes(modifier.type, "annotation")) {
+          modifiers.push(modifier.text);
+        }
+      }
+    }
+    return modifiers;
+  }
+  getJavaAnnotations(node) {
+    const annotations = [];
+    const modifiersNode = this.findChildByType(node, "modifiers");
+    const target = modifiersNode || node;
+    for (let i = 0; i < target.namedChildCount; i++) {
+      const child = target.namedChild(i);
+      if (child && (child.type === "annotation" || child.type === "marker_annotation")) {
+        annotations.push(child.text);
+      }
+    }
+    return annotations;
+  }
+  /**
+   * The NAME child of an annotation / marker_annotation node — the annotation
+   * TYPE as the file wrote it. The grammar serializes it as
+   * `$._name = choice(identifier, scoped_identifier)` (probe-verified: `@Override`
+   * has a direct `identifier`, `@org.springframework.stereotype.Service` a
+   * `scoped_identifier`), and `findChildByType` only inspects DIRECT children, so
+   * an identifier inside an argument list can never be mistaken for the name.
+   */
+  javaAnnotationNameNode(ann) {
+    return this.findChildByType(ann, "identifier") || this.findChildByType(ann, "scoped_identifier");
+  }
+  /** The declaration kinds whose annotations this lane attributes to a published
+   *  name. Every entry is a node type of the pinned tree-sitter-java grammar; the
+   *  list is exhaustive for the positions Java permits a type annotation in
+   *  (`modifiers`, type-use, parameter, type-parameter, receiver, record
+   *  component, enum constant). */
+  static JAVA_ANNOTATED_DECLARATIONS = /* @__PURE__ */ new Set([
+    "class_declaration",
+    "interface_declaration",
+    "enum_declaration",
+    "record_declaration",
+    "annotation_type_declaration",
+    "module_declaration",
+    "method_declaration",
+    "constructor_declaration",
+    "compact_constructor_declaration",
+    "annotation_type_element_declaration",
+    "field_declaration",
+    "constant_declaration",
+    "local_variable_declaration",
+    "enum_constant",
+    "formal_parameter",
+    "spread_parameter",
+    "catch_formal_parameter",
+    "receiver_parameter",
+    "type_parameter"
+  ]);
+  /** Positions whose annotated thing is NOT a published symbol of its own: the
+   *  annotation belongs to the declaration that carries the position. */
+  static JAVA_ANNOTATION_CARRIER_POSITIONS = /* @__PURE__ */ new Set([
+    "formal_parameter",
+    "spread_parameter",
+    "catch_formal_parameter",
+    "receiver_parameter",
+    "type_parameter",
+    "local_variable_declaration"
+  ]);
+  /**
+   * The declaration an annotation node decorates, found by climbing ancestors to
+   * the first node type in JAVA_ANNOTATED_DECLARATIONS.
+   *
+   * WHY A CLIMB AND NOT `parent.parent`: a declaration annotation sits under the
+   * declaration's `modifiers` child (one hop), but a TYPE-USE annotation
+   * (`List<@Nullable String>`, JLS 9.7.4) is nested inside the type node
+   * (`annotated_type` > `type_arguments` > `generic_type` > …), and a parameter /
+   * record-component annotation sits under `formal_parameter`'s modifiers. The
+   * fixed-hop version would work for exactly one of those shapes and silently
+   * emit nothing for the others.
+   */
+  javaAnnotatedDeclarationNode(ann) {
+    let cur = ann.parent;
+    let guard = 0;
+    while (cur && guard++ < 64) {
+      if (_RealJavaAnalyzer.JAVA_ANNOTATED_DECLARATIONS.has(cur.type)) return cur;
+      cur = cur.parent;
+    }
+    return null;
+  }
+  /** The name of the nearest enclosing named declaration (method / constructor /
+   *  type), used for positions that publish no symbol of their own. */
+  javaEnclosingDeclarationName(node) {
+    let cur = node.parent;
+    let guard = 0;
+    while (cur && guard++ < 64) {
+      const named = this.findChildByType(cur, "type_identifier");
+      if (cur.type === "class_declaration" || cur.type === "interface_declaration" || cur.type === "enum_declaration" || cur.type === "record_declaration" || cur.type === "annotation_type_declaration" || cur.type === "module_declaration" || cur.type === "method_declaration" || cur.type === "constructor_declaration" || cur.type === "compact_constructor_declaration" || cur.type === "annotation_type_element_declaration") {
+        const namedChild = cur.childForFieldName("name") || this.findChildByType(cur, "identifier") || named;
+        if (namedChild) return namedChild.text;
+      }
+      cur = cur.parent;
+    }
+    return void 0;
+  }
+  /**
+   * The names an annotation edge is emitted FROM, with the annotated declaration's
+   * node type beside each. See the `annotation` branch in the walk for the
+   * contract; this helper exists so the branch reads as one edge shape.
+   */
+  javaAnnotatedDeclarationSources(ann, parentContext) {
+    const fallback = parentContext?.name ? [{ name: String(parentContext.name), declKind: "enclosing_scope" }] : [];
+    const decl = this.javaAnnotatedDeclarationNode(ann);
+    if (!decl) {
+      let root = ann;
+      let rootGuard = 0;
+      while (root.parent && root.type !== "program" && rootGuard++ < 64) root = root.parent;
+      if (root.type === "program") {
+        for (let i = 0; i < root.namedChildCount; i++) {
+          const top = root.namedChild(i);
+          if (!top || top.type !== "package_declaration") continue;
+          const pkgName = this.findChildByType(top, "scoped_identifier") || this.findChildByType(top, "identifier");
+          if (pkgName) return [{ name: pkgName.text, declKind: "package_declaration" }];
+        }
+      }
+      return fallback;
+    }
+    const declKind = decl.type;
+    if (declKind === "field_declaration" || declKind === "constant_declaration") {
+      const names = [];
+      for (let i = 0; i < decl.namedChildCount; i++) {
+        const c = decl.namedChild(i);
+        if (!c || c.type !== "variable_declarator") continue;
+        const n = c.childForFieldName("name") || this.findChildByType(c, "identifier");
+        if (n) names.push({ name: n.text, declKind });
+      }
+      return names.length > 0 ? names : fallback;
+    }
+    if (_RealJavaAnalyzer.JAVA_ANNOTATION_CARRIER_POSITIONS.has(declKind)) {
+      const carrier = this.javaEnclosingDeclarationName(decl);
+      return carrier ? [{ name: carrier, declKind }] : fallback;
+    }
+    const ownName = decl.childForFieldName("name") || this.findChildByType(decl, "identifier") || this.findChildByType(decl, "type_identifier");
+    return ownName ? [{ name: ownName.text, declKind }] : fallback;
+  }
+  // ── RECEIVER TYPING — the pre-pass and the resolver ─────────────────────────────────────────────
+  /**
+   * Build the per-file receiver-type index in ONE pre-pass over the same tree.
+   *
+   * WHY A PRE-PASS. The main walk is single-pass and visits a call site before it
+   * visits declarations written BELOW it — `x.foo()` above `void foo()` is the
+   * normal shape, not the exception — and Java allows fields and methods in any
+   * order. Reading what the file states therefore has to happen before the
+   * emission that consumes it. The pre-pass visits the same tree and emits nothing.
+   *
+   * WHAT IS INDEXED, and each entry is a DECLARATION, not an inference:
+   *   * type scopes (class/interface/enum/record/@interface bodies, plus anonymous
+   *     class bodies) with their FIELDS;
+   *   * method/constructor scopes with their FORMAL PARAMETERS, and their LOCALS
+   *     (a local is recorded with its enclosing block's range, so a declaration in
+   *     a sibling block cannot bind a use outside it);
+   *   * method name -> declared return type, only when this file declares it and
+   *     the name has ONE distinct return type in the file (an overload set with
+   *     differing return types is refused, not guessed);
+   *   * type names declared in the file and single-type-import local names, which
+   *     is how a CLASS-QUALIFIED static call (`Helper.help()`) is told apart from a
+   *     variable read.
+   */
+  collectJavaReceiverTypeIndex(rootNode) {
+    const index = {
+      methodScopes: [],
+      typeScopes: [],
+      typeNames: /* @__PURE__ */ new Set(),
+      typeKindsByName: /* @__PURE__ */ new Map(),
+      importSingleTypes: /* @__PURE__ */ new Set(),
+      importSinglePaths: /* @__PURE__ */ new Map(),
+      methodReturns: /* @__PURE__ */ new Map(),
+      typeScopesByName: /* @__PURE__ */ new Map(),
+      staticImportLeaves: /* @__PURE__ */ new Set(),
+      hasStaticOnDemand: false,
+      staticImportPaths: /* @__PURE__ */ new Map()
+    };
+    const TYPE_DECLARATIONS = /* @__PURE__ */ new Set([
+      "class_declaration",
+      "interface_declaration",
+      "enum_declaration",
+      "record_declaration",
+      "annotation_type_declaration"
+    ]);
+    const BLOCK_NODES = /* @__PURE__ */ new Set([
+      "block",
+      "constructor_body",
+      "switch_block",
+      "for_statement",
+      "enhanced_for_statement",
+      "try_statement",
+      "catch_clause",
+      "finally_clause",
+      "synchronized_statement",
+      "lambda_expression",
+      "static_initializer"
+    ]);
+    const addFields = (scope, body) => {
+      for (let i = 0; i < body.namedChildCount; i++) {
+        const child = body.namedChild(i);
+        if (!child) continue;
+        if (child.type === "enum_body_declarations") {
+          for (let j = 0; j < child.namedChildCount; j++) {
+            const inner = child.namedChild(j);
+            if (inner && (inner.type === "field_declaration" || inner.type === "constant_declaration")) {
+              this.addJavaDeclaredMembers(inner, "field", scope, body, index);
+            }
+          }
+          continue;
+        }
+        if (child.type === "field_declaration" || child.type === "constant_declaration") {
+          this.addJavaDeclaredMembers(child, "field", scope, body, index);
+        }
+      }
+    };
+    const addMemberNamesAndEnumConstants = (scope, body) => {
+      const names = scope.memberNames;
+      const methods = scope.methodNames;
+      if (!names) return;
+      const addName = (decl) => {
+        if (!decl) return;
+        const nameNode = decl.childForFieldName("name");
+        if (nameNode && nameNode.text) {
+          names.add(nameNode.text);
+          if (decl.type === "method_declaration" || decl.type === "constructor_declaration" || decl.type === "annotation_type_element_declaration") {
+            methods?.add(nameNode.text);
+          }
+          return;
+        }
+        if (decl.type === "field_declaration" || decl.type === "constant_declaration") {
+          for (let k = 0; k < decl.namedChildCount; k++) {
+            const d = decl.namedChild(k);
+            if (!d || d.type !== "variable_declarator") continue;
+            const n = d.childForFieldName("name");
+            if (n && n.text) names.add(n.text);
+          }
+        }
+      };
+      for (let i = 0; i < body.namedChildCount; i++) {
+        const child = body.namedChild(i);
+        if (!child) continue;
+        if (child.type === "enum_body_declarations") {
+          for (let j = 0; j < child.namedChildCount; j++) addName(child.namedChild(j));
+          continue;
+        }
+        if (child.type === "method_declaration" || child.type === "constructor_declaration" || child.type === "compact_constructor_declaration" || child.type === "field_declaration" || child.type === "constant_declaration" || TYPE_DECLARATIONS.has(child.type)) {
+          addName(child);
+          continue;
+        }
+        if (child.type === "enum_constant") {
+          const nameNode = child.childForFieldName("name") || this.findChildByType(child, "identifier");
+          if (!nameNode || !nameNode.text) continue;
+          names.add(nameNode.text);
+          if (scope.name) {
+            scope.members.set(nameNode.text, {
+              type: scope.name,
+              evidence: "field",
+              declStart: child.startIndex,
+              scopeStart: scope.start,
+              scopeEnd: scope.end
+            });
+          }
+        }
+      }
+    };
+    const makeTypeScope = (body, name, parents) => {
+      const scope = {
+        start: body.startIndex,
+        end: body.endIndex,
+        members: /* @__PURE__ */ new Map(),
+        name,
+        parents,
+        memberNames: /* @__PURE__ */ new Set(),
+        methodNames: /* @__PURE__ */ new Set()
+      };
+      addFields(scope, body);
+      addMemberNamesAndEnumConstants(scope, body);
+      if (name) index.typeScopesByName.set(name, scope);
+      index.typeScopes.push(scope);
+      return scope;
+    };
+    const makeBodyScope = (n) => {
+      const body = this.findChildByType(n, "block") || this.findChildByType(n, "constructor_body");
+      const scope = {
+        start: body ? body.startIndex : n.startIndex,
+        end: body ? body.endIndex : n.endIndex,
+        members: /* @__PURE__ */ new Map()
+      };
+      const params = this.findChildByType(n, "formal_parameters");
+      if (params) {
+        for (let i = 0; i < params.namedChildCount; i++) {
+          const p = params.namedChild(i);
+          if (!p) continue;
+          if (p.type !== "formal_parameter" && p.type !== "spread_parameter") continue;
+          const typeNode = p.childForFieldName("type");
+          const nameNode = p.childForFieldName("name") || this.findChildByType(p, "identifier");
+          const typeName = this.javaDeclaredTypeBaseName(typeNode);
+          if (typeName && nameNode) {
+            scope.members.set(nameNode.text, {
+              type: typeName,
+              evidence: "param",
+              declStart: p.startIndex,
+              scopeStart: scope.start,
+              scopeEnd: scope.end
+            });
+          }
+        }
+      }
+      index.methodScopes.push(scope);
+      return scope;
+    };
+    const visit = (n, methodScope, typeScopes, block) => {
+      const t = n.type;
+      let nextMethod = methodScope;
+      let nextTypeScopes = typeScopes;
+      const nextBlock = BLOCK_NODES.has(t) ? n : block;
+      if (TYPE_DECLARATIONS.has(t)) {
+        const nameNode = n.childForFieldName("name");
+        const typeName = nameNode?.text;
+        if (typeName) {
+          index.typeNames.add(typeName);
+          index.typeKindsByName.set(typeName, t);
+        }
+        const body = this.findChildByType(n, "class_body") || this.findChildByType(n, "enum_body") || this.findChildByType(n, "interface_body") || this.findChildByType(n, "annotation_type_body");
+        if (body) {
+          nextTypeScopes = [...typeScopes, makeTypeScope(body, typeName, typeName ? this.javaDeclaredParentNames(n) : void 0)];
+        }
+      }
+      if (t === "object_creation_expression") {
+        const body = this.findChildByType(n, "class_body");
+        if (body) {
+          const superNode = this.findChildByType(n, "type_identifier") || this.findChildByType(n, "generic_type") || this.findChildByType(n, "scoped_type_identifier");
+          const superName = superNode ? this.javaDeclaredTypeBaseName(superNode) : null;
+          nextTypeScopes = [...typeScopes, makeTypeScope(body, void 0, superName ? [superName] : void 0)];
+        }
+      }
+      if (t === "method_declaration" || t === "constructor_declaration" || t === "compact_constructor_declaration") {
+        nextMethod = makeBodyScope(n);
+        if (t === "method_declaration") {
+          const nameNode = n.childForFieldName("name");
+          const returnType = this.javaDeclaredTypeBaseName(n.childForFieldName("type"));
+          if (nameNode && returnType) {
+            const set = index.methodReturns.get(nameNode.text) ?? /* @__PURE__ */ new Set();
+            set.add(returnType);
+            index.methodReturns.set(nameNode.text, set);
+          }
+        }
+      }
+      if (t === "import_declaration") {
+        let isStatic = false;
+        for (let ci = 0; ci < n.childCount; ci++) {
+          const childNode = n.child(ci);
+          if (childNode && childNode.type === "static") {
+            isStatic = true;
+            break;
+          }
+        }
+        const isWildcard = this.findChildByType(n, "asterisk") !== null;
+        if (isStatic) {
+          const staticName = this.findChildByType(n, "scoped_identifier") || this.findChildByType(n, "identifier");
+          if (staticName) {
+            const text = staticName.text;
+            const leaf = text.slice(text.lastIndexOf(".") + 1);
+            if (isWildcard) index.hasStaticOnDemand = true;
+            else if (leaf) {
+              index.staticImportLeaves.add(leaf);
+              const container = text.slice(0, text.lastIndexOf("."));
+              if (container.length > 0) index.staticImportPaths.set(leaf, container);
+            }
+          }
+        }
+        if (!isStatic && !isWildcard) {
+          const nameNode = this.findChildByType(n, "scoped_identifier") || this.findChildByType(n, "identifier");
+          if (nameNode) {
+            const text = nameNode.text;
+            const leaf = text.slice(text.lastIndexOf(".") + 1);
+            if (leaf) {
+              index.importSingleTypes.add(leaf);
+              index.importSinglePaths.set(leaf, text);
+            }
+          }
+        }
+      }
+      if (t === "lambda_expression") {
+        const lambdaScope = { start: n.startIndex, end: n.endIndex, members: /* @__PURE__ */ new Map() };
+        const paramsNode = n.childForFieldName("parameters");
+        const paramChildren = paramsNode ? paramsNode.type === "identifier" ? [paramsNode] : Array.from({ length: paramsNode.namedChildCount }, (_, i) => paramsNode.namedChild(i)) : [];
+        for (const p of paramChildren) {
+          if (!p) continue;
+          if (p.type !== "formal_parameter" && p.type !== "spread_parameter" && p.type !== "identifier") continue;
+          const typeNode = p.type === "identifier" ? null : p.childForFieldName("type");
+          const nameNode = p.type === "identifier" ? p : p.childForFieldName("name") || this.findChildByType(p, "identifier");
+          const lambdaType = this.javaDeclaredTypeBaseName(typeNode);
+          if (lambdaType && nameNode) {
+            lambdaScope.members.set(nameNode.text, {
+              type: lambdaType,
+              evidence: "param",
+              declStart: p.startIndex,
+              scopeStart: lambdaScope.start,
+              scopeEnd: lambdaScope.end
+            });
+          }
+        }
+        index.methodScopes.push(lambdaScope);
+        nextMethod = lambdaScope;
+      }
+      if (t === "local_variable_declaration" && methodScope) {
+        const scopeNode = block ?? (n.parent ?? n);
+        this.addJavaDeclaredMembers(n, "local", methodScope, scopeNode, index);
+      }
+      if (methodScope && t === "catch_formal_parameter") {
+        const typeNode = n.childForFieldName("type") || this.findChildByType(n, "catch_type");
+        const nameNode = n.childForFieldName("name") || this.findChildByType(n, "identifier");
+        const catchNames = typeNode && typeNode.type === "catch_type" ? this.collectJavaTypeNames(typeNode) : [];
+        const catchType = catchNames.length === 1 ? catchNames[0].name : this.javaDeclaredTypeBaseName(typeNode);
+        if (catchType && nameNode) {
+          let catchScopeNode = n;
+          let catchClimb = n.parent;
+          let catchGuard = 0;
+          while (catchClimb && catchGuard++ < 8) {
+            if (catchClimb.type === "catch_clause") {
+              catchScopeNode = catchClimb;
+              break;
+            }
+            catchClimb = catchClimb.parent;
+          }
+          methodScope.members.set(nameNode.text, {
+            type: catchType,
+            evidence: "local",
+            declStart: n.startIndex,
+            scopeStart: catchScopeNode.startIndex,
+            scopeEnd: catchScopeNode.endIndex
+          });
+        }
+      }
+      if (methodScope && t === "enhanced_for_statement") {
+        const typeNode = n.childForFieldName("type");
+        const nameNode = n.childForFieldName("name");
+        const forType = this.javaDeclaredTypeBaseName(typeNode);
+        if (forType && nameNode) {
+          methodScope.members.set(nameNode.text, {
+            type: forType,
+            evidence: "local",
+            declStart: n.startIndex,
+            scopeStart: n.startIndex,
+            scopeEnd: n.endIndex
+          });
+        }
+      }
+      if (methodScope && t === "resource") {
+        const typeNode = n.childForFieldName("type");
+        const nameNode = n.childForFieldName("name") || this.findChildByType(n, "identifier");
+        const resType = this.javaDeclaredTypeBaseName(typeNode);
+        if (resType && nameNode) {
+          let scopeNode = n;
+          let climb = n.parent;
+          let guard = 0;
+          while (climb && guard++ < 8) {
+            if (climb.type === "try_statement" || climb.type === "try_with_resources_statement") {
+              scopeNode = climb;
+              break;
+            }
+            climb = climb.parent;
+          }
+          methodScope.members.set(nameNode.text, {
+            type: resType,
+            evidence: "local",
+            declStart: n.startIndex,
+            scopeStart: scopeNode.startIndex,
+            scopeEnd: scopeNode.endIndex
+          });
+        }
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const child = n.namedChild(i);
+        if (child) visit(child, nextMethod, nextTypeScopes, nextBlock);
+      }
+    };
+    visit(rootNode, null, [], null);
+    return index;
+  }
+  /** Record every declarator a field/constant/local declaration binds, with the
+   *  declaration's written type and the range in which the binding is legal. A
+   *  declaration whose type is not a named type (a primitive, `var`) records
+   *  nothing: a primitive receiver has no type whose members could be resolved. */
+  addJavaDeclaredMembers(decl, evidence, scope, scopeNode, index) {
+    const typeNode = decl.childForFieldName("type");
+    const isVarForm = typeNode?.type === "type_identifier" && typeNode.text === "var";
+    let arrayElement = null;
+    if (typeNode?.type === "array_type") {
+      for (let i = 0; i < typeNode.namedChildCount; i++) {
+        const c = typeNode.namedChild(i);
+        if (!c) continue;
+        if (c.type === "type_identifier" || c.type === "generic_type" || c.type === "scoped_type_identifier") {
+          const base = this.javaDeclaredTypeBaseName(c);
+          if (base) {
+            arrayElement = base;
+            break;
+          }
+        }
+      }
+    }
+    const typeName = isVarForm ? null : arrayElement ?? this.javaDeclaredTypeBaseName(typeNode);
+    if (!typeName && !isVarForm) return;
+    for (let i = 0; i < decl.namedChildCount; i++) {
+      const declarator = decl.namedChild(i);
+      if (!declarator || declarator.type !== "variable_declarator") continue;
+      const nameNode = declarator.childForFieldName("name") || this.findChildByType(declarator, "identifier");
+      if (!nameNode) continue;
+      let memberType = typeName;
+      let memberEvidence = evidence;
+      if (isVarForm) {
+        if (!index) continue;
+        const inferred = this.javaInferVarInitializerType(declarator, index);
+        if (!inferred) continue;
+        memberType = inferred;
+        memberEvidence = "initializer";
+      }
+      if (!memberType) continue;
+      scope.members.set(nameNode.text, {
+        type: memberType,
+        evidence: memberEvidence,
+        declStart: declarator.startIndex,
+        scopeStart: evidence === "field" ? scope.start : scopeNode.startIndex,
+        scopeEnd: evidence === "field" ? scope.end : scopeNode.endIndex,
+        ...arrayElement !== null ? { isArray: true } : {}
+      });
+    }
+  }
+  /**
+   * The statically stated type of a `var` declarator's INITIALIZER (JLS 14.4 / 10.3.2:
+   * `var` takes the type of its initializer, it is not inferred from later use).
+   *
+   * Only shapes whose type the FILE WRITES are read: `new Foo()`, a cast's type, and a
+   * method invocation whose name has exactly ONE declared return type in this file (an
+   * overload set with differing returns is refused, the same rule the `return` evidence
+   * class already states). String literals, chained calls on foreign types, lambdas and
+   * arrays are refused: their type is not written in this file, and a wrong owner is
+   * worse than none.
+   */
+  javaInferVarInitializerType(declarator, index) {
+    let value = declarator.childForFieldName("value");
+    for (let guard = 0; guard < 8 && value; guard++) {
+      if (value.type !== "parenthesized_expression") break;
+      value = value.namedChild(0);
+    }
+    if (!value) return null;
+    if (value.type === "object_creation_expression") {
+      const typeNode = this.findChildByType(value, "type_identifier") || this.findChildByType(value, "generic_type") || this.findChildByType(value, "scoped_type_identifier");
+      return typeNode ? this.javaDeclaredTypeBaseName(typeNode) : null;
+    }
+    if (value.type === "cast_expression") {
+      return this.javaDeclaredTypeBaseName(value.childForFieldName("type"));
+    }
+    if (value.type === "method_invocation") {
+      const nameNode = value.childForFieldName("name");
+      const name = nameNode ? nameNode.text : "";
+      if (!name || this.isJavaBuiltin(name)) return null;
+      const returns = index.methodReturns.get(name);
+      return returns && returns.size === 1 ? [...returns][0] : null;
+    }
+    return null;
+  }
+  /** The type name a declared-type node writes, or null when the node is a
+   *  primitive / `var` / malformed. `javaTypeBaseName` keeps a qualified spelling
+   *  (`java.util.List`) as written, which is what "the receiver's statically known
+   *  type" means to this lane. */
+  javaDeclaredTypeBaseName(typeNode) {
+    if (!typeNode) return null;
+    const t = typeNode.type;
+    if (t === "integral_type" || t === "floating_point_type" || t === "boolean_type" || t === "void_type") return null;
+    const base = javaTypeBaseName(typeNode);
+    if (!base || base === "var" || base === "void") return null;
+    return base;
+  }
+  /** The innermost scope of `scopes` whose range contains `pos` (innermost = the one
+   *  that starts latest; equal starts keep the first seen, which is deterministic
+   *  over one tree). */
+  javaInnermostScope(scopes, pos) {
+    let best = null;
+    for (const scope of scopes) {
+      if (scope.start <= pos && pos <= scope.end) {
+        if (!best || scope.start >= best.start) best = scope;
+      }
+    }
+    return best;
+  }
+  /** The base names a type declaration writes in its heritage clauses (JLS 8.1.4/8.1.5,
+   *  9.1.3, 8.10.3): superclass first, then the interface list. Used ONLY by the depth
+   *  campaign's `super` receiver class — ancestry is otherwise never inferred. */
+  javaDeclaredParentNames(declNode) {
+    const inheritance = this.extractJavaInheritance(declNode);
+    const names = [];
+    if (inheritance.extendsClass?.name) names.push(inheritance.extendsClass.name);
+    for (const p of inheritance.extendsInterfaces) if (p.name) names.push(p.name);
+    for (const p of inheritance.implementsInterfaces) if (p.name) names.push(p.name);
+    return names;
+  }
+  /** The declared type a bare identifier is BOUND to: method/lambda scopes first (innermost
+   *  first, with the declaration-before-use rule of JLS 6.3), then the enclosing types' fields.
+   *  Extracted from the receiver resolver so the array-element class can reuse the SAME schema
+   *  walk — a second, divergent copy is what this file's audits exist to catch. */
+  javaResolveIdentifierBinding(name, pos, index) {
+    const coveringMethods = [];
+    for (const scope of index.methodScopes) {
+      if (scope.start <= pos && pos <= scope.end) coveringMethods.push(scope);
+    }
+    coveringMethods.sort((a, b) => b.start - a.start);
+    for (const methodScope of coveringMethods) {
+      const hit = methodScope.members.get(name);
+      if (hit && hit.declStart < pos && hit.scopeStart <= pos && pos <= hit.scopeEnd) return hit;
+    }
+    const coveringTypes = [];
+    for (const scope of index.typeScopes) {
+      if (scope.start <= pos && pos <= scope.end) coveringTypes.push(scope);
+    }
+    coveringTypes.sort((a, b) => b.start - a.start);
+    for (const scope of coveringTypes) {
+      const hit = scope.members.get(name);
+      if (hit) return hit;
+    }
+    return null;
+  }
+  /** The innermost TYPE scope containing `pos` that has a NAME. An anonymous class body
+   *  deliberately has none: it is not a project declaration, so it can never be an owner. */
+  javaEnclosingTypeScope(index, pos) {
+    let best = null;
+    for (const scope of index.typeScopes) {
+      if (!scope.name) continue;
+      if (scope.start <= pos && pos <= scope.end) {
+        if (!best || scope.start >= best.start) best = scope;
+      }
+    }
+    return best;
+  }
+  /** WOULD THE OWNER CHANNEL RESOLVE THIS ROW? — the guard, now shaped exactly like
+   *  `member-owner-resolution.ts` rather than merely "some member of that name exists".
+   *
+   *  The channel's candidate model (its own code, mirrored):
+   *   1. candidates are the owner's members with the relationship's KIND filter —
+   *      `calls` accepts function/method/constructor, `uses` accepts any member;
+   *   2. if the OWNER declares the name, the row resolves there (even when an ancestor
+   *      also declares it: the direct hit wins);
+   *   3. otherwise the members collected across the ancestor chain must be EXACTLY ONE —
+   *      two ancestors declaring the name is `ambiguousInChain`, a decline.
+   *
+   *  Java's ProjectIndex CARRIES ancestry since 2026-10-20 — the spec-local `baseResolver` in
+   *  `JAVA_DECLARATION_SPEC` reads each type's DIRECT bases (measured: java's `typeBases` went
+   *  from EMPTY to populated; the fix is confined to the java spec block, and the other
+   *  languages' `typeBases` are byte-identical before and after). **THIS CHANNEL STILL WALKS
+   *  ONLY IN-FILE ANCESTRY**: the walk below reads `index.typeScopesByName`, and when a parent
+   *  is not in this file it consults the project's MEMBERS for that parent but does not walk
+   *  the PROJECT's ancestry. So a row whose only chance is a CROSS-FILE inherited member is
+   *  still refused (missing, never wrong).
+   *
+   *  **THE PROJECT ANCESTRY IS NOW AVAILABLE TO BE USED HERE — AND THAT IS A SEPARATE INSTRUMENT,
+   *  NOT THIS COMMENT.** Walking `projectIndex.typeBases` would let this channel decide the
+   *  cross-file inherited-member rows the project index now knows the shape of; it would also
+   *  change the lane's recorded arm, so it is not a lane's unilateral change. Until it is
+   *  decided, the behaviour is exactly what it was. */
+  javaOwnerResolvable(ownerName, memberName, rowType, index, projectIndex) {
+    if (!ownerName || !memberName) return false;
+    const wantsMethod = rowType === "calls";
+    const fileScope = index.typeScopesByName.get(ownerName);
+    const directFile = wantsMethod ? fileScope?.methodNames?.has(memberName) ?? false : fileScope?.memberNames?.has(memberName) ?? false;
+    const directProject = projectIndex?.complete === true ? projectIndex.typeMembers.get(ownerName)?.has(memberName) ?? false : false;
+    if (directFile || directProject) return true;
+    let hits = 0;
+    const walk = (name, depth) => {
+      if (depth > 8) return;
+      const scope = index.typeScopesByName.get(name);
+      for (const parent of scope?.parents ?? []) {
+        const parentScope = index.typeScopesByName.get(parent);
+        if (parentScope) {
+          const has = wantsMethod ? parentScope.methodNames?.has(memberName) ?? false : parentScope.memberNames?.has(memberName) ?? false;
+          if (has) hits++;
+          walk(parent, depth + 1);
+          continue;
+        }
+        if (projectIndex?.complete === true && (projectIndex.typeMembers.get(parent)?.has(memberName) ?? false)) hits++;
+      }
+    };
+    walk(ownerName, 0);
+    return hits === 1;
+  }
+  /** Can an owner spelled `ownerName` be attached at all?
+   *
+   *  A type DECLARED IN THIS FILE is eligible: the enclosing-type classes are exactly the
+   *  declarations this file contains. A type declared only in the PROJECT is eligible when a
+   *  COMPLETE index declares it exactly once; completeness is the bit that turns "declared
+   *  once in the project" from a fragment's opinion into a statement. When the complete
+   *  index shows the simple name declared MORE THAN ONCE the owner is refused: the channel
+   *  reports `ownerAmbiguous` and would withdraw the name binding for nothing. */
+  javaTypeEligible(ownerName, index, projectIndex) {
+    if (!ownerName) return false;
+    const inFile = index.typeNames.has(ownerName);
+    if (projectIndex?.complete === true) {
+      const count = projectIndex.symbolCounts.get(ownerName) ?? 0;
+      if (count > 1) return false;
+      if (inFile) return true;
+      return projectIndex.typeKinds.has(ownerName) && count === 1;
+    }
+    return inFile;
+  }
+  /**
+   * The declared type of a call's receiver — the depth campaign's evidence classes.
+   *
+   * The 2026-10-18 contract classes (field / param / local / return) are read from THE
+   * FILE'S OWN DECLARATIONS by `javaReceiverOwnerTypeFromFile` and are byte-identical to
+   * that contract.
+   *
+   * The 2026-10-19 depth classes are evidence the file states, each guarded by
+   * `javaOwnerResolvable` (the owner channel's own kind + ancestor rule) and
+   * `javaTypeEligible`:
+   *   * `this`        — an implicit-`this` call (JLS 15.12.1) and an explicit `this.m()`;
+   *                     also implicit-`this` READS. Refused when an unqualified name could
+   *                     come from a static import (JLS 7.5.3/7.5.4).
+   *   * `super`       — `super.m()`: the first IN-FILE base that declares the member.
+   *   * `enum`        — `Mode.ONE.act()` and a READ of the constant: its static type IS the
+   *                     enum (JLS 8.9.1).
+   *   * `initializer` — `var` whose initializer states the type (JLS 14.4).
+   *   * `new`         — a receiver that IS an object-creation expression (`new Foo().m()`):
+   *                     the created type is written.
+   *   * `cast`        — a receiver that is a cast (`((Foo) x).m()`): the cast type is written.
+   *   * `element`     — an array-element receiver (`foos[i].m()`): the declared element type
+   *                     of the array binding is written (the binding comes from the schema
+   *                     classes above).
+   *
+   * Returns null — never a guess — for a receiver whose type no static evidence here states:
+   * an inherited field, a chained call on a foreign/unknown return type, a library-typed
+   * parameter, an untyped lambda parameter, multi-catch, and a CLASS-QUALIFIED STATIC CALL
+   * (`Helper.help()` — its receiver already names its owner, which the 2026-10-18 contract
+   * and its fixture deliberately keep owner-less).
+   */
+  javaReceiverOwnerType(callNode, index, projectIndex, rowType = "calls") {
+    const fieldLocal = this.javaReceiverOwnerTypeFromFile(callNode, index);
+    const targetNode = callNode.childForFieldName("name") ?? callNode.childForFieldName("field");
+    const targetName = targetNode ? targetNode.text : "";
+    if (fieldLocal) {
+      if (fieldLocal.evidence !== "initializer") return fieldLocal;
+      if (!this.javaTypeEligible(fieldLocal.type, index, projectIndex)) return null;
+      if (!this.javaOwnerResolvable(fieldLocal.type, targetName, rowType, index, projectIndex)) return null;
+      return fieldLocal;
+    }
+    if (!targetName) return null;
+    const objectNode = callNode.childForFieldName("object");
+    const pos = callNode.startIndex;
+    const enclosing = this.javaEnclosingTypeScope(index, pos);
+    const emit = (type, evidence) => {
+      if (!this.javaTypeEligible(type, index, projectIndex)) return null;
+      if (!this.javaOwnerResolvable(type, targetName, rowType, index, projectIndex)) return null;
+      return { type, evidence };
+    };
+    if (!objectNode) {
+      if (!enclosing?.name) return null;
+      if (index.staticImportLeaves.has(targetName) || index.hasStaticOnDemand) return null;
+      return emit(enclosing.name, "this");
+    }
+    const ot = objectNode.type;
+    if (ot === "this") {
+      if (!enclosing?.name) return null;
+      return emit(enclosing.name, "this");
+    }
+    if (ot === "super") {
+      if (!enclosing?.name) return null;
+      for (const parent of enclosing.parents ?? []) {
+        const hit = emit(parent, "super");
+        if (hit) return hit;
+      }
+      return null;
+    }
+    if (ot === "object_creation_expression") {
+      const createdNode = this.findChildByType(objectNode, "type_identifier") || this.findChildByType(objectNode, "generic_type") || this.findChildByType(objectNode, "scoped_type_identifier");
+      const created = createdNode ? this.javaDeclaredTypeBaseName(createdNode) : null;
+      if (!created) return null;
+      return emit(created, "new");
+    }
+    if (ot === "cast_expression" || ot === "parenthesized_expression") {
+      let expr = objectNode;
+      for (let guard = 0; guard < 8 && expr && expr.type === "parenthesized_expression"; guard++) {
+        expr = expr.namedChild(0);
+      }
+      if (expr && expr.type === "cast_expression") {
+        const castType = this.javaDeclaredTypeBaseName(expr.childForFieldName("type"));
+        if (!castType) return null;
+        return emit(castType, "cast");
+      }
+      return null;
+    }
+    if (ot === "array_access") {
+      const arrayNode = objectNode.childForFieldName("array");
+      if (!arrayNode || arrayNode.type !== "identifier") return null;
+      const binding = this.javaResolveIdentifierBinding(arrayNode.text, pos, index);
+      if (!binding || !binding.isArray) return null;
+      return emit(binding.type, "element");
+    }
+    if (ot === "identifier" && callNode.type === "field_access") {
+      const enumName = objectNode.text;
+      if (index.typeKindsByName.get(enumName) !== "enum_declaration") return null;
+      return emit(enumName, "enum") ?? null;
+    }
+    if (ot === "field_access") {
+      const parts = objectNode.text.split(".");
+      if (parts.length === 2 && index.typeKindsByName.get(parts[0]) === "enum_declaration") {
+        if (!index.typeScopesByName.get(parts[0])?.memberNames?.has(parts[1])) return null;
+        const enumName = parts[0];
+        return emit(enumName, "enum");
+      }
+      return null;
+    }
+    return null;
+  }
+  /**
+   * The 2026-10-18 contract: the declared type of a receiver from THE FILE'S OWN
+   * DECLARATIONS. Returns null — never a guess — for every receiver whose type this file
+   * does not state: an implicit `this`, a class-qualified static call, `super`, chained
+   * access on an untyped receiver, an inherited field, and a `var` local. The four
+   * evidence classes are the declarations the contract names: field / param /
+   * local / return.
+   */
+  javaReceiverOwnerTypeFromFile(callNode, index) {
+    const objectNode = callNode.childForFieldName("object");
+    if (!objectNode) return null;
+    const pos = callNode.startIndex;
+    if (objectNode.type === "identifier") {
+      const binding = this.javaResolveIdentifierBinding(objectNode.text, pos, index);
+      if (binding && !binding.isArray) return { type: binding.type, evidence: binding.evidence };
+      return null;
+    }
+    if (objectNode.type === "field_access") {
+      const parts = objectNode.text.split(".");
+      if (parts.length === 2 && parts[0] === "this") {
+        const name = parts[1];
+        for (const scope of index.typeScopes) {
+          if (!(scope.start <= pos && pos <= scope.end)) continue;
+          const hit = scope.members.get(name);
+          if (hit) return { type: hit.type, evidence: "field" };
+        }
+      }
+      return null;
+    }
+    if (objectNode.type === "method_invocation") {
+      const nameNode = objectNode.childForFieldName("name");
+      const name = nameNode ? nameNode.text : null;
+      if (!name || this.isJavaBuiltin(name)) return null;
+      const returns = index.methodReturns.get(name);
+      if (returns && returns.size === 1) {
+        const only = [...returns][0];
+        return { type: only, evidence: "return" };
+      }
+      return null;
+    }
+    return null;
+  }
+  /**
+   * Short annotation name from an annotation/marker_annotation node's name
+   * child. The pinned grammar serializes the name as $._name =
+   * choice(identifier, scoped_identifier) — probe-verified: `@Override` has a
+   * direct identifier, `@org.springframework.stereotype.Service` has a
+   * scoped_identifier. The short name is the last dotted segment; bare names
+   * pass through unchanged.
+   *
+   * F6 audit: a third `_reserved_identifier` fallback had been added here on
+   * the claim that the grammar's `_name` was a triple choice including it.
+   * That name is an underscore-prefixed HIDDEN rule, so `.type` can never
+   * equal it and `findChildByType` can never match it — a branch that could
+   * not fire. Removed; the two real shapes cover every annotation name.
+   */
+  getJavaAnnotationShortName(ann) {
+    const nameNode = this.findChildByType(ann, "identifier") || this.findChildByType(ann, "scoped_identifier");
+    if (!nameNode) return null;
+    const text = nameNode.text;
+    const lastDot = text.lastIndexOf(".");
+    return lastDot === -1 ? text : text.slice(lastDot + 1);
+  }
+  /**
+   * Bare annotation names extracted from the AST (@Service → Service), read
+   * from the identifier field of each annotation node — never from text.
+   */
+  getJavaAnnotationNames(node) {
+    const names = [];
+    const modifiersNode = this.findChildByType(node, "modifiers");
+    const target = modifiersNode || node;
+    for (let i = 0; i < target.namedChildCount; i++) {
+      const child = target.namedChild(i);
+      if (child && (child.type === "annotation" || child.type === "marker_annotation")) {
+        const name = this.getJavaAnnotationShortName(child);
+        if (name) names.push(name);
+      }
+    }
+    return names;
+  }
+  /**
+   * Semantic text of a value node: for string_literal nodes the concatenated
+   * string_fragment children (unquoted) instead of raw quoted text; for all
+   * other node types the raw text.
+   */
+  extractStringValue(node) {
+    if (!node) return void 0;
+    if (node.type === "string_literal") {
+      let fragmentText = "";
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (c && (c.type === "string_fragment" || c.type === "multiline_string_fragment")) fragmentText += c.text;
+      }
+      if (fragmentText) return fragmentText;
+    }
+    if (node.type === "binary_expression") {
+      return this.extractJavaConstantString(node);
+    }
+    return node.text;
+  }
+  /** Strict constant-string folder: literals/text blocks/parens/+ chains
+   *  only. Any non-literal operand makes the whole expression unresolved. */
+  extractJavaConstantString(node) {
+    if (node.type === "parenthesized_expression") {
+      const inner = node.namedChild(0);
+      return inner ? this.extractJavaConstantString(inner) : void 0;
+    }
+    if (node.type === "string_literal") {
+      let fragmentText = "";
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (c && (c.type === "string_fragment" || c.type === "multiline_string_fragment")) fragmentText += c.text;
+      }
+      return fragmentText || void 0;
+    }
+    if (node.type === "binary_expression") {
+      const op = node.childForFieldName("operator")?.text;
+      if (op !== "+") return void 0;
+      const l = node.namedChild(0);
+      const r = node.namedChild(1);
+      if (!l || !r) return void 0;
+      const lt = this.extractJavaConstantString(l);
+      const rt = this.extractJavaConstantString(r);
+      if (lt === void 0 || rt === void 0) return void 0;
+      const joined = lt + rt;
+      return joined || void 0;
+    }
+    return void 0;
+  }
+  getJavaVisibility(modifiers) {
+    if (modifiers.indexOf("public") !== -1) return "public";
+    if (modifiers.indexOf("private") !== -1) return "private";
+    if (modifiers.indexOf("protected") !== -1) return "protected";
+    return void 0;
+  }
+  /**
+   * Extract the base type name from a type node, stripping type arguments so
+   * inheritance targets are clean symbol names (Repository<T> → Repository).
+   * A scoped type (BaseService.Entity) keeps its full dotted name.
+   */
+  /**
+   * M14 #419 G4: nearest enclosing type scope for call attribution when a
+   * method_invocation sits outside any method body (initializer blocks,
+   * field initializers, enum constant bodies). Scans the scope stack from
+   * the top, skipping member-level scopes (Property/Constant/EnumMember),
+   * and returns the nearest type-level scope. Defined in-class so the
+   * handler above can reach it without exposing Scope publicly.
+   */
+  resolveEnclosingTypeScope(scopeStack) {
+    for (let i = scopeStack.length - 1; i >= 0; i--) {
+      const s = scopeStack[i];
+      if (s.kind === ASTEngine.SymbolKind.Class || s.kind === ASTEngine.SymbolKind.Interface || s.kind === ASTEngine.SymbolKind.Enum || s.kind === ASTEngine.SymbolKind.Type) {
+        return { name: s.name, kind: s.kind };
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Can this string be a java NAME? Letters, digits, `_`, `$`, and `.` for a
+   * qualified name. No regex (analyzers carry no regex literals, R2 register) —
+   * a character walk, the same shape as the census instrument's.
+   *
+   * Used to refuse an edge whose target is not a name at all, rather than to
+   * invent one. `newArrayList(v3(), v4())` and `"com.google.common."` both fail
+   * it; `V`, `com.google.common.collect`, `ImmutableList.Builder` and
+   * `CollectionFeature.NONE` all pass.
+   */
+  isJavaNameShape(s) {
+    if (!s) return false;
+    for (let i = 0; i < s.length; i++) {
+      const c = s[i];
+      const ok = c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c >= "0" && c <= "9" || c === "_" || c === "$" || c === ".";
+      if (!ok) return false;
+    }
+    return true;
+  }
+  extractJavaTypeBaseName(typeNode) {
+    return javaTypeBaseName(typeNode);
+  }
+  /**
+   * M59 (#825): every parent is `{name, line}` — the line the PARENT IS NAMED on.
+   *
+   * java writes a long heritage list on separate lines
+   * (`class A extends B\n    implements C, D`), so a clause-start line named only
+   * the first entry. Same rule as scala's `extractSupertypes` and the reason the
+   * shape is pairs rather than names.
+   */
+  extractJavaInheritance(classNode) {
+    const inheritance = {
+      extendsClass: null,
+      // interface_declaration > extends_interfaces > type_list: EVERY parent is an extends (JLS 9.1.3)
+      extendsInterfaces: [],
+      implementsInterfaces: [],
+      // sealed class permits clause (JLS 8.1.1.2): permitted subtypes are
+      // CHILDREN of the sealed class, not ancestors — kept out of parents[]
+      // and surfaced separately so callers can emit directional edges.
+      permitsSubtypes: []
+    };
+    const superclass = this.findChildByType(classNode, "superclass");
+    if (superclass) {
+      const typeIdentifier = this.findChildByType(superclass, "scoped_type_identifier") || this.findChildByType(superclass, "generic_type") || this.findChildByType(superclass, "type_identifier");
+      if (typeIdentifier) inheritance.extendsClass = { name: this.extractJavaTypeBaseName(typeIdentifier), line: typeIdentifier.startPosition.row + 1 };
+    }
+    const superInterfaces = this.findChildByType(classNode, "super_interfaces") || this.findChildByType(classNode, "extends_interfaces");
+    if (superInterfaces) {
+      const targetList = this.findChildByType(superInterfaces, "type_list") || superInterfaces;
+      const isInterfaceExtends = superInterfaces.type === "extends_interfaces";
+      const bucket = isInterfaceExtends ? inheritance.extendsInterfaces : inheritance.implementsInterfaces;
+      for (let i = 0; i < targetList.namedChildCount; i++) {
+        const interfaceType = targetList.namedChild(i);
+        if (interfaceType && (interfaceType.type === "type_identifier" || interfaceType.type === "generic_type" || interfaceType.type === "scoped_type_identifier")) {
+          bucket.push({ name: this.extractJavaTypeBaseName(interfaceType), line: interfaceType.startPosition.row + 1 });
+        }
+      }
+    }
+    const permitsNode = this.findChildByType(classNode, "permits");
+    if (permitsNode) {
+      const permitsList = this.findChildByType(permitsNode, "type_list") || permitsNode;
+      for (let i = 0; i < permitsList.namedChildCount; i++) {
+        const subtype = permitsList.namedChild(i);
+        if (subtype && (subtype.type === "type_identifier" || subtype.type === "generic_type" || subtype.type === "scoped_type_identifier")) {
+          inheritance.permitsSubtypes.push({ name: this.extractJavaTypeBaseName(subtype), line: subtype.startPosition.row + 1 });
+        }
+      }
+    }
+    return inheritance;
+  }
+  extractJavaParameters(node, relationships, ownerPrefix) {
+    const parameters = [];
+    const formalParams = this.findChildByType(node, "formal_parameters");
+    const targetNode = formalParams ? formalParams : node;
+    for (let i = 0; i < targetNode.namedChildCount; i++) {
+      const param = targetNode.namedChild(i);
+      if (param && param.type === "formal_parameter") {
+        const nameNode = param.childForFieldName("name") || this.findChildByType(param, "identifier");
+        if (nameNode) {
+          const paramType = this.extractJavaParameterType(param);
+          parameters.push({ name: nameNode.text, type: paramType, isOptional: false });
+          if (relationships && ownerPrefix) {
+            const valueAnn = inArray(this.getJavaAnnotationNames(param), "Value");
+            if (valueAnn) {
+              const valMatch = this.getAnnotationValue(param, "Value", "value");
+              if (valMatch && valMatch.startsWith("${") && valMatch.endsWith("}")) {
+                relationships.push({
+                  source: ownerPrefix + "." + nameNode.text,
+                  target: valMatch.substring(2, valMatch.length - 1).split(":")[0],
+                  type: ASTEngine.RelationshipType.Uses,
+                  confidence: 1,
+                  // M59 (#825): the key is written in the PARAMETER's own
+                  // `@Value` — the parameter is the node that carries it.
+                  ...this.annotationLine(param, "Value") ? { line_number: this.annotationLine(param, "Value") } : {},
+                  metadata: { isConfiguration: true, relationshipType: "config_property" }
+                });
+              }
+            }
+          }
+        }
+      } else if (param && param.type === "spread_parameter") {
+        const decl = this.findChildByType(param, "variable_declarator");
+        const nameNode = decl ? this.findChildByType(decl, "identifier") : null;
+        if (nameNode) {
+          let spreadType = void 0;
+          for (let cIdx = 0; cIdx < param.namedChildCount; cIdx++) {
+            const c = param.namedChild(cIdx);
+            if (c && c.type !== "modifiers" && !stringIncludes(c.type, "annotation") && c.type !== "variable_declarator") {
+              spreadType = c.text;
+              break;
+            }
+          }
+          parameters.push({ name: nameNode.text, type: (spreadType || "unknown") + "[]", isOptional: false });
+        }
+      } else if (param && param.type === "ERROR") {
+        let rawText = param.text;
+        if (rawText.startsWith(",")) rawText = rawText.slice(1);
+        rawText = rawText.trim();
+        if (rawText) {
+          const parts = splitByChar(rawText, ",");
+          for (const p of parts) {
+            const pt = p.trim();
+            if (!pt) continue;
+            const tokens = tokenizeWhitespace(pt);
+            let name = tokens[tokens.length - 1];
+            let cleanName = "";
+            for (let ci = 0; ci < name.length; ci++) {
+              const ch = name[ci];
+              if (ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch >= "0" && ch <= "9" || ch === "_") cleanName += ch;
+            }
+            name = cleanName;
+            if (name) {
+              const lastToken = tokens[tokens.length - 1];
+              let typeGuess = pt.length > lastToken.length ? pt.slice(0, pt.length - lastToken.length).trim() : "";
+              typeGuess = stripJavaAnnotations(typeGuess).split("...").join("[]").trim() || "unknown";
+              parameters.push({ name, type: typeGuess, isOptional: false });
+            }
+          }
+        }
+      }
+    }
+    return parameters;
+  }
+  extractJavaParameterType(paramNode) {
+    const typeNode = paramNode.childForFieldName("type");
+    if (typeNode) return typeNode.text;
+    for (let i = 0; i < paramNode.namedChildCount; i++) {
+      const child = paramNode.namedChild(i);
+      if (child && child.type !== "identifier" && child.type !== "modifiers" && !stringIncludes(child.type, "annotation")) return child.text;
+    }
+    return void 0;
+  }
+  extractJavaReturnType(node) {
+    const typeNode = node.childForFieldName("type");
+    if (typeNode) return typeNode.text;
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child && (child.type === "type_identifier" || child.type === "generic_type" || child.type === "array_type" || child.type === "scoped_type_identifier" || child.type === "void_type" || child.type === "integral_type" || child.type === "floating_point_type" || child.type === "boolean_type")) {
+        return child.text;
+      }
+    }
+    return void 0;
+  }
+  extractJavaFieldType(fieldNode) {
+    return this.extractJavaReturnType(fieldNode);
+  }
+  buildJavaCallExpression(invocationNode) {
+    const objectNode = invocationNode.childForFieldName("object");
+    const nameNode = invocationNode.childForFieldName("name");
+    if (!nameNode) {
+      const text = invocationNode.text;
+      const paren = text.indexOf("(");
+      return paren === -1 ? text : text.slice(0, paren);
+    }
+    if (objectNode) {
+      const objectText = objectNode.type === "method_invocation" ? this.buildJavaCallExpression(objectNode) : objectNode.text;
+      return `${objectText}.${nameNode.text}`;
+    }
+    return nameNode.text;
+  }
+  isJavaBuiltin(call) {
+    const builtins = [
+      "System.out.println",
+      "System.out.print",
+      "System.out.printf",
+      "System.err.println",
+      "System.err.print",
+      "System.exit",
+      "System.gc",
+      "System.currentTimeMillis",
+      "System.nanoTime",
+      "System.getProperty",
+      "System.getenv",
+      "System.identityHashCode",
+      "System.arraycopy",
+      "toString",
+      "hashCode",
+      "equals",
+      "getClass",
+      "notify",
+      "notifyAll",
+      "wait",
+      "clone",
+      "finalize"
+    ];
+    for (let i = 0; i < builtins.length; i++) {
+      if (builtins[i] === call) return true;
+    }
+    const firstDot = call.indexOf(".");
+    const root = firstDot > 0 ? call.slice(0, firstDot) : call;
+    const STDLIB_ROOTS = /* @__PURE__ */ new Set([
+      // java.lang
+      "System",
+      "String",
+      "Integer",
+      "Long",
+      "Double",
+      "Float",
+      "Boolean",
+      "Byte",
+      "Short",
+      "Character",
+      "Math",
+      "StrictMath",
+      "Object",
+      "Class",
+      "Thread",
+      "Runnable",
+      "Runtime",
+      "Process",
+      "ProcessBuilder",
+      "Throwable",
+      "Error",
+      "Exception",
+      "StackTraceElement",
+      "Enum",
+      "Void",
+      "Compiler",
+      "Package",
+      // java.util
+      "ArrayList",
+      "LinkedList",
+      "HashMap",
+      "HashSet",
+      "TreeMap",
+      "TreeSet",
+      "LinkedHashMap",
+      "LinkedHashSet",
+      "WeakHashMap",
+      "IdentityHashMap",
+      "Collections",
+      "Arrays",
+      "Objects",
+      "Optional",
+      "OptionalInt",
+      "OptionalLong",
+      "OptionalDouble",
+      "Stream",
+      "Collectors",
+      "Comparator",
+      "Iterator",
+      "ListIterator",
+      "Spliterator",
+      "Random",
+      "UUID",
+      "Date",
+      "Calendar",
+      "TimeZone",
+      "Locale",
+      "Currency",
+      "Base64",
+      "Scanner",
+      "Formatter",
+      "StringJoiner",
+      "AbstractList",
+      "AbstractMap",
+      "AbstractSet",
+      "AbstractCollection",
+      "EnumMap",
+      "EnumSet",
+      "Queue",
+      "Deque",
+      "Stack",
+      "Vector",
+      "Hashtable",
+      "Properties",
+      "BitSet",
+      "Dictionary",
+      "List",
+      "Map",
+      "Set",
+      "Collection",
+      "Iterable",
+      // java.io / java.nio
+      "File",
+      "Files",
+      "Path",
+      "Paths",
+      "InputStream",
+      "OutputStream",
+      "Reader",
+      "Writer",
+      "BufferedReader",
+      "BufferedWriter",
+      "FileInputStream",
+      "FileOutputStream",
+      "FileReader",
+      "FileWriter",
+      "ByteArrayInputStream",
+      "ByteArrayOutputStream",
+      "StringReader",
+      "StringWriter",
+      "PrintWriter",
+      "PrintStream",
+      "IOException",
+      "FileNotFoundException",
+      "EOFException",
+      // java.net / java.sql / javax
+      "URL",
+      "URI",
+      "HttpURLConnection",
+      "URLEncoder",
+      "URLDecoder",
+      "Connection",
+      "DriverManager",
+      "ResultSet",
+      "Statement",
+      "PreparedStatement",
+      "SQLException",
+      "DataSource",
+      "javax",
+      "jakarta",
+      // kotlin stdlib
+      "kotlin",
+      "Unit",
+      "Nothing",
+      "Any",
+      "Int",
+      "String",
+      // Common JDK prefixes
+      "java",
+      "jdk",
+      "sun",
+      // Logger frameworks (always stdlib when called by these names)
+      "Logger",
+      "LoggerFactory",
+      "LogManager",
+      "Level",
+      "LogRecord",
+      "Marker",
+      "MDC",
+      "NDC",
+      // Common annotations (never architectural)
+      "Override",
+      "Deprecated",
+      "SuppressWarnings",
+      "SafeVarargs",
+      "FunctionalInterface",
+      "Nullable",
+      "NotNull",
+      "NonNls",
+      "Test",
+      "Before",
+      "After",
+      "BeforeClass",
+      "AfterClass",
+      "Ignore",
+      "RunWith",
+      "Suite",
+      "Parameterized",
+      // org.slf4j / logging
+      "slf4j",
+      "log4j",
+      "logback"
+    ]);
+    const segments = call.split(".");
+    if (segments.length > 0 && STDLIB_ROOTS.has(segments[0])) return true;
+    if (STDLIB_ROOTS.has(call)) return true;
+    return false;
+  }
+  /**
+   * M14 incoming — the external-target marker, and only for the PROVABLE cases.
+   *
+   * `script/m14/incoming-gate.ts` counts an edge as resolved (one declaration), ambiguous
+   * (several), or unresolved. A JDK symbol is a fourth thing — legitimately outside the
+   * corpus — and an unmarked edge of that kind is indistinguishable from a broken one, so it
+   * counts against the lane. Measured before this marker existed on java (200 files,
+   * `npx tsx script/m14/incoming-gate.ts java java 200 --json`): **16,021 unresolved of 26,095
+   * edges, `markedExternal 0` on EVERY type**, and `imports` 2,716 of 2,716 unresolved.
+   *
+   * Only two facts are provable from a single file, so only two are asserted:
+   *   - the target carries a JVM-platform / Kotlin-stdlib qualifier (`java.`, `javax.`,
+   *     `jakarta.`, `jdk.`, `sun.`, `com.sun.`, `kotlin.`, `kotlinx.`);
+   *   - the target's ROOT segment is a local name the file IMPORTS from such a module, and the
+   *     file does not declare that name itself.
+   *
+   * Deliberately NOT marked, because the prefix proves nothing about a single file:
+   *   - `org.` / `com.` third-party packages — in a multi-module build `com.acme` IS project
+   *     source, the same reason `com.sun` and `com.mycompany` were separated in `isJavaBuiltin`;
+   *   - wildcard imports (`import java.util.*`) — the file never names the type;
+   *   - java.lang simple names used with no import (`String`, `Object`, `System`). They are
+   *     *probably* the platform types, and "probably" is what this marker must not say: an
+   *     unproven marker hides a genuine unresolved edge behind a claim the file cannot make.
+   *     They stay counted against the lane until a rule can prove them.
+   */
+  markExternalTargets(relationships, symbols, imports, context) {
+    const JVM_ROOTS = ["java.", "javax.", "jakarta.", "jdk.", "sun.", "com.sun."];
+    const isJvmModule = (name) => JVM_ROOTS.some((r) => name.startsWith(r));
+    const declared = /* @__PURE__ */ new Set();
+    for (const s of symbols) {
+      const n = String(s?.name ?? "");
+      if (n.length > 0) declared.add(n);
+      const q = String(s?.qualifiedName ?? "");
+      if (q.length > 0) declared.add(q);
+    }
+    const importedFromJvm = /* @__PURE__ */ new Map();
+    for (const im of imports) {
+      const module = String(im?.module ?? "");
+      if (module.length === 0 || !isJvmModule(module)) continue;
+      if (im?.isNamespace === true || im?.metadata?.isWildcard === true || module.endsWith(".*")) continue;
+      const items = Array.isArray(im?.items) ? im.items : [];
+      let named = false;
+      for (const it of items) {
+        const n = String(it?.name ?? it?.alias ?? "");
+        if (n.length > 0) {
+          importedFromJvm.set(n, module);
+          named = true;
+        }
+      }
+      if (!named) {
+        const leaf = module.slice(module.lastIndexOf(".") + 1);
+        if (leaf.length > 0 && leaf !== "*") importedFromJvm.set(leaf, module);
+      }
+    }
+    let marked = 0;
+    for (const r of relationships) {
+      const target = String(r?.target ?? "");
+      if (target.length === 0) continue;
+      const md = r.metadata ?? (r.metadata = {});
+      if (md.isExternalTarget === true) continue;
+      if (declared.has(target)) continue;
+      if (String(r?.type ?? "") === "references" && md.relationshipType === "import_declaration_mention" && isJvmModule(target) && !declared.has(target)) {
+        md.languageNamespace = [target];
+        marked++;
+        continue;
+      }
+      const CLAIMED_KINDS = /* @__PURE__ */ new Set(["references", "extends", "implements", "instantiates"]);
+      if (JAVA_LANG_TYPES.has(target) && !importedFromJvm.has(target) && CLAIMED_KINDS.has(String(r?.type ?? ""))) {
+        md.languageNamespace = [target];
+        marked++;
+        continue;
+      }
+      const colon = target.indexOf(":");
+      if (colon > 0 && !target.startsWith("/") && !target.includes("/")) {
+        const module2 = target.slice(0, colon);
+        if (isJvmModule(module2)) {
+          md.isExternalTarget = true;
+          md.externalReason = "builtin-module";
+          md.externalSpecifier = module2;
+          marked++;
+        }
+        continue;
+      }
+      if (isJvmModule(target)) {
+        md.isExternalTarget = true;
+        md.externalReason = "builtin-lib-type";
+        md.externalSpecifier = JVM_ROOTS.find((p) => target.startsWith(p)) ?? "";
+        marked++;
+        continue;
+      }
+      const root = target.split(".")[0];
+      if (root.length === 0 || declared.has(root)) continue;
+      const module = importedFromJvm.get(root);
+      if (module !== void 0) {
+        md.isExternalTarget = true;
+        md.externalReason = "builtin-lib-type";
+        md.externalReceiver = root;
+        md.externalSpecifier = module;
+        marked++;
+        continue;
+      }
+      if (md.isExternalTarget === true) continue;
+      if (context?.projectIndex?.complete !== true) continue;
+      if (String(r?.type ?? "") === "imports" || String(r?.type ?? "") === "brain_import") continue;
+      if (!isPlainJavaIdentifier(target)) continue;
+      if (JAVA_RESERVED.has(target)) continue;
+      if (context.projectIndex.symbolNames.has(target)) continue;
+      md.isExternalTarget = true;
+      md.externalReason = "project-scope-bare-name";
+      md.externalProof = `ProjectIndex.complete === true; symbolNames has no "${target}"`;
+      marked++;
+    }
+    return marked;
+  }
+  getAnnotationValue(node, annotationName, key) {
+    const findAllAnnotations = (n) => {
+      const results = [];
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const child = n.namedChild(i);
+        if (child && (child.type === "annotation" || child.type === "marker_annotation")) results.push(child);
+      }
+      return results;
+    };
+    let annotations = findAllAnnotations(node);
+    const modifiersNode = (() => {
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child && child.type === "modifiers") return child;
+      }
+      return null;
+    })();
+    if (modifiersNode) {
+      annotations = annotations.concat(findAllAnnotations(modifiersNode));
+    }
+    for (let j = 0; j < annotations.length; j++) {
+      const ann = annotations[j];
+      const name = this.getJavaAnnotationShortName(ann);
+      if (name && name === annotationName) {
+        const argsNode = this.findChildByType(ann, "annotation_argument_list");
+        if (!argsNode) return void 0;
+        for (let i = 0; i < argsNode.namedChildCount; i++) {
+          const arg = argsNode.namedChild(i);
+          if (!arg) continue;
+          if (arg.type === "element_value_pair") {
+            const keyNode = this.findChildByType(arg, "identifier");
+            if (keyNode && keyNode.text === key) {
+              const valNode = arg.namedChild(arg.namedChildCount - 1);
+              return this.extractStringValue(valNode);
+            }
+          } else if (key === "value" && arg.type === "element_value_array_initializer") {
+            const first = arg.namedChild(0);
+            if (first) return this.extractStringValue(first);
+            return void 0;
+          } else if (key === "value" && arg.type !== "element_value_pair") {
+            return this.extractStringValue(arg);
+          }
+        }
+      }
+    }
+    return void 0;
+  }
+  getJavaGenericParameters(node) {
+    const typeParamsNode = this.findChildByType(node, "type_parameters");
+    if (!typeParamsNode) return void 0;
+    const params = [];
+    for (let i = 0; i < typeParamsNode.namedChildCount; i++) {
+      const child = typeParamsNode.namedChild(i);
+      if (child && child.type === "type_parameter") {
+        const nameChild = child.childForFieldName("name") || this.findChildByType(child, "type_identifier");
+        params.push(nameChild ? nameChild.text : child.text);
+      }
+    }
+    return params.length > 0 ? params : void 0;
+  }
+  /**
+   * JLS 7.7 — a `module-info.java` compilation unit. The ONE implementation.
+   *
+   * WHAT IS EMITTED, PER DIRECTIVE SHAPE, and every row below is pinned by a
+   * fixture (three of them are INCOMING_JAVA fixtures written for this file):
+   *
+   *   `module M { … }`        a `Module` symbol. It carries no `ownerName`, so
+   *                           the existing post-pass also lists it in `exports[]`
+   *                           — correct, because `requires M` is how another
+   *                           module names it (java/module-exports-jpms).
+   *   `exports P [to M…];`    a `Namespace` symbol for P owned by M, an `exports`
+   *                           edge M -> P (`module_exports`, with the `to` list in
+   *                           `qualifiedTo`), a `references` MENTION of P
+   *                           (`module_exports_mention`), and a `references` row
+   *                           per `to` module (`module_exports_package_to`).
+   *   `requires [t|s] M2;`    an `imports` edge M -> M2 (`module_requires`), a
+   *                           `references` mention (`module_requires_mention`),
+   *                           and an `imports[]` entry (ImportInfo) — the channel
+   *                           `brain_import` reads.
+   *   `opens`/`uses`/`provides`  one `references` row per named target, labelled
+   *                           from JAVA_MODULE_DIRECTIVE_FIELDS.
+   *
+   * BOTH LABELS PER DIRECTIVE is the family rule this lane already states for
+   * `import` declarations at the analyzer's import site ("`imports` is the
+   * DEPENDENCY … and `references` is the MENTION"), and erlang's analyzer states
+   * it for its own `-import`. java/jpms-module-exports pins it row by row; the
+   * `mentions` are what the reference-resolution surface joins against, the
+   * dependencies are what the module-dependency pass reads.
+   *
+   * WHY `requires` IS AN `imports` EDGE AND `exports` AN `exports` EDGE. JLS 7.7.1
+   * makes `requires M` a compile-time MODULE DEPENDENCY, which is the same fact an
+   * `import` states, so it takes the same kind — the two halves of JPMS must not
+   * share a label or "what does this file depend on" becomes unanswerable
+   * (java/jpms-module-exports forbids an `imports` row for an exported package,
+   * and an `exports` row for a required module). JLS 7.7.2 makes `exports P`
+   * "this unit makes P visible to importers", which is exactly the `exports`
+   * kind's claim, and java/module-info + java/jpms-module-exports pin the row.
+   *
+   * `opens` grants deep REFLECTIVE access and is not an export in any sense the
+   * `exports` kind asserts, so no `exports` row is emitted for it (pinned by
+   * java/jpms-module-exports' forbid); it keeps its `references` row. The `to`
+   * clause RESTRICTS who may read P, so an `exports` edge from M to a `to` target
+   * would assert the opposite of what the clause says: it stays a mention plus
+   * `qualifiedTo` metadata.
+   *
+   * `requires static` is an OPTIONAL dependency at compile time and REQUIRED at
+   * run time, which is a different claim from a plain `requires`, so it is
+   * published at 0.9 with `inferred: true` and
+   * `reasonCode: "optional-module-dependency"` (java/module-info pins
+   * confidenceMin AND confidenceMax at 0.9 for exactly that row) rather than
+   * being spelled as a second label.
+   *
+   * `provides`/`uses` rows are the two remaining directive shapes in the grammar.
+   * This corpus contains 0 of both (probe: 0 `opens_module_directive`, 0
+   * `provides_module_directive`, 0 `uses_module_directive` over 3,275 files), so
+   * their labels are pinned by fixtures rather than by corpus frequency and are
+   * recorded as such.
+   *
+   * Node shapes are probe-verified against the pinned wasm, not assumed
+   * (java-node-shape-probe.mts):
+   *   module_declaration         field `name` -> scoped_identifier | identifier,
+   *                              field `body` -> module_body
+   *   exports_module_directive   FIRST named child is the package; any `to`
+   *                              clause follows the anonymous `to` token
+   *   requires_module_directive  first named child is the module name, UNLESS a
+   *                              `requires_modifier` (`transitive`/`static`)
+   *                              comes first — so the modifier is skipped by node
+   *                              type, never by position
+   */
+  emitJavaModuleDeclaration(declNode, symbols, relationships, imports) {
+    const nameNode = declNode.childForFieldName("name") || this.findChildByType(declNode, "scoped_identifier") || this.findChildByType(declNode, "identifier");
+    if (!nameNode) return;
+    const moduleName = nameNode.text;
+    if (!moduleName) return;
+    symbols.push({
+      name: moduleName,
+      kind: ASTEngine.SymbolKind.Module,
+      range: this.nodeToRange(nameNode),
+      visibility: "public",
+      comments: [],
+      metadata: { nodeType: "module_declaration", isJavaModule: true }
+    });
+    const body = declNode.childForFieldName("body") || this.findChildByType(declNode, "module_body");
+    if (!body) return;
+    const emittedPackages = /* @__PURE__ */ new Set();
+    for (let i = 0; i < body.namedChildCount; i++) {
+      const n = body.namedChild(i);
+      if (!n) continue;
+      if (n.type === "exports_module_directive") {
+        const pkgNode = this.findChildByType(n, "scoped_identifier") || this.findChildByType(n, "identifier");
+        if (pkgNode && pkgNode.text && !emittedPackages.has(pkgNode.text)) {
+          const pkgName = pkgNode.text;
+          emittedPackages.add(pkgName);
+          const qualifiedTo = this.readJavaQualifiedExportTargets(n);
+          symbols.push({
+            name: pkgName,
+            kind: ASTEngine.SymbolKind.Namespace,
+            // The package is named on the `exports` line, not on `module`.
+            range: this.nodeToRange(pkgNode),
+            visibility: "public",
+            ownerName: moduleName,
+            ownerKind: ASTEngine.SymbolKind.Module,
+            metadata: { nodeType: "exports_module_directive", isExportedPackage: true }
+          });
+          relationships.push({
+            source: moduleName,
+            target: pkgName,
+            type: ASTEngine.RelationshipType.Exports,
+            // JLS 7.7.2 is structural syntax: the directive is written, so this
+            // is a parse fact and not a heuristic.
+            confidence: 1,
+            // The line the PACKAGE is named on — the directive's own name node.
+            line_number: pkgNode.startPosition.row + 1,
+            metadata: {
+              relationshipType: "module_exports",
+              isModuleDirective: true,
+              isJavaModuleDirective: true,
+              moduleName,
+              ...qualifiedTo ? { qualifiedTo } : {}
+            }
+          });
+          relationships.push({
+            source: moduleName,
+            target: pkgName,
+            type: ASTEngine.RelationshipType.References,
+            confidence: 1,
+            line_number: pkgNode.startPosition.row + 1,
+            metadata: {
+              relationshipType: "module_exports_mention",
+              isModuleDirective: true,
+              isJavaModuleDirective: true,
+              reasonCode: "module_directive",
+              moduleName
+            }
+          });
+        }
+      } else if (n.type === "requires_module_directive") {
+        let modNode = null;
+        let transitive = false;
+        let isStatic = false;
+        for (let j = 0; j < n.namedChildCount; j++) {
+          const c = n.namedChild(j);
+          if (!c) continue;
+          if (c.type === "requires_modifier") {
+            if (c.text.trim() === "transitive") transitive = true;
+            else if (c.text.trim() === "static") isStatic = true;
+            continue;
+          }
+          if (isJavaNameNode(c)) {
+            modNode = c;
+            break;
+          }
+        }
+        const required = modNode?.text ?? "";
+        if (!required) continue;
+        const line = modNode.startPosition.row + 1;
+        const shared = {
+          isModuleDirective: true,
+          isJavaModuleDirective: true,
+          moduleName,
+          isModuleRequires: true
+        };
+        relationships.push({
+          source: moduleName,
+          target: required,
+          type: ASTEngine.RelationshipType.Imports,
+          // 0.9 for `requires static`: the module is OPTIONAL at compile time and
+          // required at run time, so the dependency claim is discounted and the
+          // reason is machine-readable rather than silent (honesty contract §4).
+          confidence: isStatic ? 0.9 : 1,
+          line_number: line,
+          metadata: {
+            relationshipType: "module_requires",
+            ...shared,
+            isStatic,
+            isTransitive: transitive,
+            fileLevel: true,
+            ...isStatic ? { inferred: true, reasonCode: "optional-module-dependency" } : { reasonCode: "module_directive" }
+          }
+        });
+        relationships.push({
+          source: moduleName,
+          target: required,
+          type: ASTEngine.RelationshipType.References,
+          confidence: 1,
+          line_number: line,
+          metadata: {
+            relationshipType: "module_requires_mention",
+            ...shared,
+            reasonCode: "module_directive"
+          }
+        });
+        imports.push({
+          module: required,
+          items: [],
+          isDefault: false,
+          range: this.nodeToRange(modNode),
+          metadata: {
+            isModuleRequires: true,
+            ...transitive ? { transitive: true } : {},
+            ...isStatic ? { isStatic: true } : {}
+          },
+          importType: transitive ? "java-module-requires-transitive" : "java-module-requires"
+        });
+        continue;
+      }
+      const shape = JAVA_MODULE_DIRECTIVE_FIELDS[n.type];
+      if (!shape) continue;
+      for (let k = 0; k < shape.length; k++) {
+        const { field, role, unfieldedAfter } = shape[k];
+        if (role === "module_exports_package") continue;
+        const targets = n.childrenForFieldName?.(field) ?? [];
+        if (unfieldedAfter) {
+          const anchor = n.childForFieldName(unfieldedAfter);
+          for (let j = 0; j < n.namedChildCount; j++) {
+            const c = n.namedChild(j);
+            if (isJavaNameNode(c) && c.startIndex !== anchor?.startIndex && c.endIndex !== anchor?.endIndex) {
+              targets.push(c);
+            }
+          }
+        }
+        for (let j = 0; j < targets.length; j++) {
+          const t = targets[j];
+          if (t) this.pushModuleDirective(relationships, moduleName, t, role);
+        }
+      }
+    }
+  }
+  /** The `to M1, M2` target list of a qualified export, or null when unqualified. */
+  readJavaQualifiedExportTargets(directive) {
+    const out = [];
+    let seenPackage = false;
+    for (let i = 0; i < directive.namedChildCount; i++) {
+      const c = directive.namedChild(i);
+      if (!c) continue;
+      const isName = c.type === "scoped_identifier" || c.type === "identifier";
+      if (!isName) continue;
+      if (!seenPackage) {
+        seenPackage = true;
+        continue;
+      }
+      out.push(c.text);
+    }
+    return out.length > 0 ? out : null;
+  }
+  /**
+   * JLS 4.4 — publish each DECLARED type variable as a `SymbolKind.Type` symbol.
+   *
+   * WHY. The analyzer already read every one of them: `getJavaGenericParameters`
+   * above put `["K","V"]` on the class symbol's `genericParameters`, and the
+   * declared-type walk emitted a `references` edge to each string it met in a
+   * field type, parameter type, return type, cast or `throws` clause. So the
+   * GRAPH already asserted that `Box` references `K` — and no symbol named `K`
+   * existed anywhere, so the assertion had nothing to bind to. The rule-R7 /
+   * endpoint question ("do both ends resolve to a real symbol?") could not be
+   * answered for those edges at any rate above zero, and the honest cause was
+   * not cross-file reach: the declaration was in the SAME FILE and was simply
+   * never published.
+   *
+   * MEASURED, not assumed (instrument
+   * `validation/m14/measurements/java/java-construct-probe.mts`, whole corpus,
+   * 3,275 `.java` files, all parsed, 0 failed): 9,780 `type_parameter` nodes
+   * over 1,543 files (47.1% of the corpus), 55 distinct declared variable
+   * names. On the 250-file store slice this produced 1,588 `references` rows
+   * naming a declaration that existed nowhere in the index (`V` 815, `K` 773).
+   *
+   * WHY `Type` AND NOT SOMETHING ELSE. `SymbolKind.Type = "type"` is declared
+   * at `src/ast/types.ts:18`, `CONTAINER_TYPES_LOOKUP` in parallel-indexer
+   * already treats `type` as a container kind, and this analyzer's own
+   * evidence classifier at `resolveEnclosingTypeScope` already tests for it.
+   *
+   * THE CONTAINMENT EDGE IS NOT INVENTED HERE. The symbol carries `ownerName`,
+   * so the existing post-pass (`for (const s of symbols) { const _owner =
+   * s.ownerName || s.scope; … }`) emits `owner -> variable` at confidence 1.0
+   * with the variable's own declaration line — one code path for every member,
+   * not a second spelling of containment.
+   *
+   * WHY THE NAME STAYS BARE. A `references -> V` edge names `V`. Publishing
+   * the symbol as `Box.V` would leave every one of those edges unresolved
+   * again, which is the defect being fixed. The cost is honest and recorded:
+   * a class type variable and a method type variable that share a spelling in
+   * one file (`class A<T> { <T> T m(T t) {} }`) are two symbols with one name,
+   * and the store's name resolution picks one. That is a genuine ambiguity, not
+   * a fabrication — both declarations are real, and JLS 6.3 scopes both to the
+   * body that names them.
+   *
+   * The `contains` post-pass skips nothing here: `ownerName` is set, so these
+   * do NOT reach the `exports[]` channel (a type variable is not an importable
+   * top-level unit — `requires Box.V` is not a thing any module can write).
+   */
+  emitJavaTypeParameterSymbols(declNode, ownerName, ownerKind, declaredOn, symbols) {
+    const typeParamsNode = this.findChildByType(declNode, "type_parameters");
+    if (!typeParamsNode) return;
+    for (let i = 0; i < typeParamsNode.namedChildCount; i++) {
+      const tp = typeParamsNode.namedChild(i);
+      if (!tp || tp.type !== "type_parameter") continue;
+      const nameNode = tp.childForFieldName("name") || this.findChildByType(tp, "type_identifier");
+      if (!nameNode) continue;
+      const tpName = nameNode.text;
+      if (!tpName) continue;
+      const bound = this.findChildByType(tp, "type_bound");
+      symbols.push({
+        name: tpName,
+        kind: ASTEngine.SymbolKind.Type,
+        // The VARIABLE's own line, so the symbol and the `contains` edge that
+        // names it cannot disagree (M59 #825's rule, applied to the position).
+        range: this.nodeToRange(nameNode),
+        ownerName,
+        ownerKind,
+        metadata: {
+          nodeType: "type_parameter",
+          isTypeParameter: true,
+          declaredOn,
+          declarationOrder: i,
+          ...bound ? { bound: bound.text } : {}
+        }
+      });
+    }
+  }
+  /**
+   * Exact short-name annotation test on a symbol's decorators. Decorator text
+   * is raw source ("@Service", "@org.x.Service", "@Service(...)") — normalize
+   * to the short name before comparing so fully-qualified and parameterized
+   * annotations match exactly like bare ones.
+   */
+  hasJavaAnnotation(symbol, annotationName) {
+    if (!symbol.decorators) return false;
+    for (let i = 0; i < symbol.decorators.length; i++) {
+      let t = symbol.decorators[i];
+      if (t.startsWith("@")) t = t.slice(1);
+      const paren = t.indexOf("(");
+      if (paren !== -1) t = t.slice(0, paren);
+      const dot = t.lastIndexOf(".");
+      if (dot !== -1) t = t.slice(dot + 1);
+      if (t === annotationName) return true;
+    }
+    return false;
+  }
+  getJavaFrameworkPatterns(frameworks, symbols) {
+    const patterns = [];
+    if (inArray(frameworks, "spring")) {
+      const springPatterns = [];
+      let hasService = false, hasRepo = false, hasController = false;
+      for (let i = 0; i < symbols.length; i++) {
+        if (!hasService && this.hasJavaAnnotation(symbols[i], "Service")) hasService = true;
+        if (!hasRepo && this.hasJavaAnnotation(symbols[i], "Repository")) hasRepo = true;
+        if (!hasController && (this.hasJavaAnnotation(symbols[i], "Controller") || this.hasJavaAnnotation(symbols[i], "RestController"))) hasController = true;
+      }
+      if (hasService) springPatterns.push("service_layer");
+      if (hasRepo) springPatterns.push("repository_pattern");
+      if (hasController) {
+        springPatterns.push("mvc_pattern");
+        springPatterns.push("api_endpoints");
+      }
+      if (springPatterns.length > 0) patterns.push({ framework: "Spring Framework", patterns: springPatterns });
+    }
+    if (inArray(frameworks, "spring_mvc")) {
+      patterns.push({ framework: "Spring MVC", patterns: ["mvc_pattern", "api_endpoints"] });
+    }
+    if (inArray(frameworks, "spring_data")) {
+      patterns.push({ framework: "Spring Data", patterns: ["repository_pattern", "orm_mapping"] });
+    } else if (inArray(frameworks, "jpa")) {
+      patterns.push({ framework: "JPA", patterns: ["orm_mapping"] });
+    } else if (inArray(frameworks, "hibernate")) {
+      patterns.push({ framework: "Hibernate", patterns: ["orm_mapping"] });
+    }
+    return patterns;
+  }
+};
+export {
+  RealJavaAnalyzer
+};