@backbencher/brain 0.0.0-stage → 0.1.1

package/dist/real-groovy-analyzer-W26VACFW.js

@@ -0,0 +1,2285 @@
+import {
+  findDeclaringParent,
+  localEdgeLabel,
+  localEdgeName
+} from "./chunk-OWISBAOF.js";
+import {
+  ASTEngine
+} from "./chunk-3ZTOHHSW.js";
+import "./chunk-BQ3OVQ3P.js";
+import "./chunk-SK6YVHFZ.js";
+import "./chunk-2BSKD7O3.js";
+import "./chunk-KAET47ZL.js";
+import "./chunk-KCDECRJY.js";
+import "./chunk-MLKGABMK.js";
+
+// src/ast/real-groovy-analyzer.ts
+var INTERPOLATION_OWNED_BY_MEMBER_WALK = /* @__PURE__ */ new Set([
+  "field_access",
+  "method_invocation",
+  "juxt_function_call",
+  "array_access",
+  "object_creation_expression"
+]);
+var GROOVY_BUILTINS = /* @__PURE__ */ new Set([
+  // Groovy language builtins
+  "println",
+  "print",
+  "printf",
+  "sprintf",
+  "assert",
+  "sleep",
+  "synchronized",
+  // JVM Object methods
+  "toString",
+  "hashCode",
+  "equals",
+  "getClass",
+  "notify",
+  "notifyAll",
+  "wait",
+  "clone",
+  "finalize",
+  // Common java.* entry points
+  "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",
+  "System.lineSeparator"
+]);
+var GROOVY_DECLARATION_TYPES = /* @__PURE__ */ new Set([
+  "method_declaration",
+  "constructor_declaration",
+  "function_definition",
+  "class_declaration",
+  "trait_declaration",
+  "enum_declaration"
+]);
+var TOP_LEVEL_TYPE_NODES = /* @__PURE__ */ new Set([
+  "class_declaration",
+  "interface_declaration",
+  "trait_declaration",
+  "enum_declaration",
+  "record_declaration",
+  "annotation_type_declaration"
+]);
+var RealGroovyAnalyzer = class _RealGroovyAnalyzer {
+  analyze(rootNode, content, filePath, context) {
+    const symbols = [];
+    const relationships = [];
+    const imports = [];
+    const exports = [];
+    const errors = [];
+    const symbolMap = /* @__PURE__ */ new Map();
+    const classHierarchy = /* @__PURE__ */ new Map();
+    const overrideTasks = [];
+    const scopeStack = [];
+    const stack = [{ node: rootNode }];
+    const walk = {
+      content,
+      symbols,
+      relationships,
+      imports,
+      symbolMap,
+      classHierarchy,
+      overrideTasks,
+      scopeStack,
+      parentContext: void 0,
+      newContext: void 0,
+      pushedScope: false,
+      currentPackage: ""
+    };
+    while (stack.length > 0) {
+      const item = stack.pop();
+      const { node, parentContext, isExit } = item;
+      if (isExit) {
+        if (parentContext) {
+          if (scopeStack.length > 0 && scopeStack[scopeStack.length - 1] === parentContext) {
+            scopeStack.pop();
+          }
+        }
+        continue;
+      }
+      if (node.isMissing || node.hasError) {
+        if (node.type === "ERROR" || node.type === "MISSING") {
+          errors.push({
+            message: `Syntax ${node.type} detected.`,
+            range: this.nodeToRange(node),
+            severity: "warning"
+          });
+        }
+      }
+      walk.parentContext = parentContext;
+      walk.newContext = parentContext;
+      walk.pushedScope = false;
+      const handler = this.nodeHandlers.get(node.type);
+      if (handler) handler(node, walk);
+      if (walk.pushedScope) {
+        stack.push({ node, parentContext: walk.newContext, isExit: true });
+      }
+      for (let i = node.namedChildCount - 1; i >= 0; i--) {
+        const child = node.namedChild(i);
+        if (child) {
+          stack.push({ node: child, parentContext: walk.newContext });
+        }
+      }
+    }
+    this.recoverDegradedClassShapes(rootNode, symbols, relationships, symbolMap, walk.currentPackage);
+    this.resolveOverrides(overrideTasks, classHierarchy, symbolMap, relationships, context?.overrideCompanion);
+    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 isImportMention = rel.type === ASTEngine.RelationshipType.References && rel.metadata?.isGroovyImport === true;
+        if (isImportMention && (rel.source === walk.currentPackage || rel.source === "(script)" || rel.source === "root")) {
+          rel.source = primaryType.name;
+        }
+      }
+    }
+    for (const s of symbols) {
+      const _owner = s.ownerName || s.scope;
+      if (_owner) {
+        relationships.push({
+          source: _owner,
+          target: s.name,
+          type: ASTEngine.RelationshipType.Contains,
+          confidence: 1,
+          // M59 (#825): the member's DECLARATION line, and the same line the
+          // member's own range carries — a symbol and the edge naming it must
+          // never disagree (java/scala contract). Never 0 (#820/#821).
+          ...s.range?.startLine ? { line_number: s.range.startLine } : {},
+          metadata: { isContained: true }
+        });
+      }
+    }
+    this.collectFieldAccessUses(rootNode, relationships, symbols);
+    this.collectDeclaredTypeRefs(rootNode, relationships);
+    const fw = this.detectGroovyFrameworks(content, symbols, imports);
+    for (let i = 0; i < symbols.length; i++) {
+      const s = symbols[i];
+      const nodeType = String(s.metadata?.nodeType ?? "");
+      const isTopLevelType = TOP_LEVEL_TYPE_NODES.has(nodeType);
+      const isTopLevelFunction = nodeType === "method_declaration" || nodeType === "function_definition";
+      if (!s.metadata?.isAnonymousClass && !s.metadata?.isPhantom && !s.ownerName && (isTopLevelType || isTopLevelFunction)) {
+        exports.push({
+          name: s.name,
+          kind: s.kind,
+          range: s.range,
+          visibility: s.visibility,
+          metadata: { exportForm: isTopLevelFunction ? "public_top_level_function" : "public_top_level_type" }
+        });
+      }
+    }
+    let exportsWithNoPackage = 0;
+    let exportsNotImportable = 0;
+    if (exports.length > 0) {
+      const published = /* @__PURE__ */ new Set();
+      for (let i = 0; i < exports.length; i++) {
+        const e = exports[i];
+        const target = e.name;
+        if (!target) continue;
+        if (published.has(target)) continue;
+        published.add(target);
+        if (!walk.currentPackage) {
+          exportsWithNoPackage++;
+          continue;
+        }
+        if (e.visibility === "private" || e.visibility === "protected") {
+          exportsNotImportable++;
+          continue;
+        }
+        const exportForm = String(e.metadata?.exportForm ?? "public_top_level_type");
+        relationships.push({
+          source: walk.currentPackage,
+          target,
+          type: ASTEngine.RelationshipType.Exports,
+          confidence: 1,
+          // 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: {
+            // The vocabulary is the java lane's, and it is the adjudicated
+            // one (java/exported-types, task-9, 2026-10-18): `exported_type` was
+            // superseded by `<lang>_exportable_unit` + `exportForm` when java's
+            // export edge was folded into ONE post-pass, and the surviving
+            // channel is the one with the RICHER metadata — `kind` + `dottedName`
+            // + the `is<Lang>Export` flag. groovy carries the same shape, and
+            // groovy/exports-publication-edge pins it.
+            relationshipType: "groovy_exportable_unit",
+            exportForm,
+            isGroovyExport: 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 (java's key, same meaning).
+            dottedName: `${walk.currentPackage}.${target}`
+          }
+        });
+      }
+    }
+    for (const sym of symbols) {
+      const decs = sym.decorators;
+      if (!decs || decs.length === 0) continue;
+      const lines = sym.metadata?.decoratorLines;
+      for (let i = 0; i < decs.length; i++) {
+        const line = lines?.[i];
+        relationships.push({
+          source: sym.name,
+          target: decs[i],
+          type: ASTEngine.RelationshipType.Decorates,
+          confidence: 1,
+          ...typeof line === "number" ? { line_number: line } : {},
+          metadata: {
+            isDecorator: true,
+            decoratorLine: typeof line === "number" ? line : null,
+            isGroovyDecorator: true
+          }
+        });
+      }
+    }
+    this.classifyEvidenceTier(relationships);
+    return {
+      symbols,
+      relationships,
+      imports,
+      exports,
+      errors,
+      metadata: {
+        // Real cyclomatic complexity — was the synthetic heuristic
+        // symbols.length + relationships.length, which is not a complexity
+        // metric at all (same defect class previously fixed on scala).
+        complexity: this.calculateGroovyMethodComplexity(rootNode),
+        cyclomaticComplexity: this.calculateGroovyMethodComplexity(rootNode),
+        linesOfCode: content.split("\n").length,
+        // Refusals, surfaced. A declaration whose name came back EMPTY (a MISSING node
+        // from error recovery) is dropped rather than published, because an empty name is
+        // not a name -- but a silent drop is a hole exactly like the one it closes, so the
+        // count travels with the result. Non-zero means the file had a parse that did not
+        // happen, which is worth knowing even when the symbol list looks clean.
+        emptyNameRefusals: walk.emptyNameRefusals ?? 0,
+        currentPackage: walk.currentPackage,
+        // DERIV_EXPORTS_GROOVY3: exportable units this file HAS but did not
+        // publish as an edge, because it declares no package and so has no
+        // truthful exporter to name. Zero means every exportable unit in the
+        // file reached the graph; non-zero is the count of export surface a
+        // reader of the relationship table cannot see, and it is reported
+        // rather than absorbed. Measured over the corpus: 266 of 2,817 files.
+        exportsWithNoPackage,
+        exportsNotImportable,
+        framework: fw.framework,
+        detectedFrameworks: fw.detected,
+        analysisVersion: "5.0.0-groovy-pure-ast"
+      }
+    };
+  }
+  // ── #896: node-type dispatch table ────────────────────────────────────────
+  // `analyze` walks (push/visit/pop); these handlers extract. Each is a named
+  // method taking the walk state, so a handler can be exercised on its own —
+  // which is what the review asked for and what the if/else chain prevented.
+  // The misparse guards (§ juxt_function_call / field_declaration) are named
+  // handlers here for the same reason: they stay individually testable, and
+  // #841 rounds 3/14/22 measured them as load-bearing, so they are kept.
+  nodeHandlersCache;
+  get nodeHandlers() {
+    if (!this.nodeHandlersCache) {
+      const m = /* @__PURE__ */ new Map();
+      const reg = (types, h) => {
+        for (const t of types) m.set(t, h);
+      };
+      reg(["package_declaration"], (n, s) => this.handlePackageDeclaration(n, s));
+      reg(["import_declaration"], (n, s) => this.handleImportDeclaration(n, s));
+      reg(["class_declaration", "interface_declaration", "trait_declaration", "enum_declaration", "record_declaration", "annotation_type_declaration"], (n, s) => this.handleTypeDeclaration(n, s));
+      reg(["method_declaration", "constructor_declaration", "function_definition"], (n, s) => this.handleMethodDeclaration(n, s));
+      reg(["field_declaration", "constant_declaration"], (n, s) => this.handleFieldDeclaration(n, s));
+      reg(["enum_constant"], (n, s) => this.handleEnumConstant(n, s));
+      reg(["method_invocation"], (n, s) => this.handleMethodInvocation(n, s));
+      reg(["explicit_constructor_invocation"], (n, s) => this.handleExplicitConstructorInvocation(n, s));
+      reg(["juxt_function_call"], (n, s) => this.handleJuxtFunctionCall(n, s));
+      reg(["leading_dot_call"], (n, s) => this.handleLeadingDotCall(n, s));
+      reg(["object_creation_expression"], (n, s) => this.handleObjectCreationExpression(n, s));
+      this.nodeHandlersCache = m;
+    }
+    return this.nodeHandlersCache;
+  }
+  handlePackageDeclaration(node, s) {
+    const type = node.type;
+    const nameNode = this.findChild(node, (n) => n.type === "scoped_identifier" || n.type === "identifier");
+    if (nameNode) s.currentPackage = nameNode.text;
+  }
+  handleImportDeclaration(node, s) {
+    const { relationships, imports } = s;
+    const type = node.type;
+    const nameNode = this.findChild(node, (n) => n.type === "scoped_identifier" || n.type === "identifier");
+    if (nameNode) {
+      const moduleName = nameNode.text;
+      let isStatic = false;
+      let isWildcard = false;
+      let hasAlias = false;
+      for (let i = 0; i < node.childCount; i++) {
+        const c = node.child(i);
+        if (!c) continue;
+        if (c.type === "static") isStatic = true;
+        else if (c.type === "asterisk") isWildcard = true;
+        else if (c.type === "as") hasAlias = true;
+      }
+      imports.push({
+        module: moduleName,
+        items: [],
+        isDefault: false,
+        range: this.nodeToRange(node),
+        isNamespace: isWildcard,
+        metadata: { isWildcard, isStatic }
+      });
+      const importMeta = { isGroovyImport: true, isWildcard, isStatic, hasAlias };
+      relationships.push({
+        source: s.currentPackage || "(script)",
+        target: moduleName,
+        type: ASTEngine.RelationshipType.References,
+        confidence: 0.9,
+        // M59 (#825): the line the imported MODULE is named on (java's rule).
+        ...this.lineField(nameNode, node),
+        metadata: importMeta
+      });
+      relationships.push({
+        source: s.currentPackage || "(script)",
+        target: moduleName,
+        type: ASTEngine.RelationshipType.Imports,
+        confidence: 0.9,
+        ...this.lineField(nameNode, node),
+        metadata: {
+          ...importMeta,
+          isImport: true,
+          relationshipType: isStatic ? isWildcard ? "static_on_demand" : "static_member" : isWildcard ? "on_demand_type" : "single_type"
+        }
+      });
+      relationships.push({
+        source: s.currentPackage || "(script)",
+        target: moduleName,
+        type: ASTEngine.RelationshipType.Imports,
+        confidence: 1,
+        ...this.lineField(nameNode, node),
+        metadata: {
+          relationshipType: isStatic ? "static_member_import" : isWildcard ? "type_on_demand_import" : "single_type_import",
+          isGroovyImport: true,
+          isWildcard,
+          isStatic,
+          fileLevel: true
+        }
+      });
+    }
+  }
+  handleTypeDeclaration(node, s) {
+    const { symbols, relationships, symbolMap, classHierarchy, scopeStack } = s;
+    const type = node.type;
+    const nameNode = this.findChild(node, (n) => n.type === "identifier");
+    if (nameNode) {
+      const name = nameNode.text;
+      if (name.trim() === "") {
+        s.emptyNameRefusals = (s.emptyNameRefusals ?? 0) + 1;
+        return;
+      }
+      const kind = type === "interface_declaration" || type === "trait_declaration" ? ASTEngine.SymbolKind.Interface : type === "enum_declaration" ? ASTEngine.SymbolKind.Enum : ASTEngine.SymbolKind.Class;
+      const fqn = this.buildFqn(s.currentPackage, scopeStack, name);
+      const visibility = this.extractVisibility(node);
+      const parents = this.extractInheritance(node, type);
+      classHierarchy.set(fqn, parents);
+      const classAnnotationRefs = this.extractAnnotationRefs(node);
+      const classAnnotations = classAnnotationRefs.map((a) => a.name);
+      if (type === "class_declaration") {
+        const superClass = this.findChild(node, (n) => n.type === "superclass");
+        if (superClass) {
+          const sc = this.findChild(superClass, (n) => n.type === "type_identifier" || n.type === "identifier" || n.type === "generic_type" || n.type === "scoped_type_identifier");
+          if (sc) {
+            relationships.push({
+              source: name,
+              target: this.baseTypeName(sc),
+              type: ASTEngine.RelationshipType.Extends,
+              confidence: 1,
+              // M59 (#825): the SUPERtype's own line, never the class header's.
+              ...this.lineField(sc, node),
+              metadata: { relationshipType: "extends" }
+            });
+          }
+        }
+      } else if (type === "interface_declaration") {
+        const ext = this.findChild(node, (n) => n.type === "extends_interfaces");
+        if (ext) {
+          for (const tid of this.collectTypeNodes(ext)) {
+            relationships.push({
+              source: name,
+              target: this.baseTypeName(tid),
+              type: ASTEngine.RelationshipType.Extends,
+              confidence: 1,
+              // M59 (#825): each interface parent is named on its OWN line.
+              ...this.lineField(tid, node),
+              metadata: { relationshipType: "extends_interface" }
+            });
+          }
+        }
+      } else if (type === "trait_declaration") {
+        const superClass = this.findChild(node, (n) => n.type === "superclass");
+        if (superClass) {
+          const sc = this.findChild(superClass, (n) => n.type === "type_identifier" || n.type === "identifier" || n.type === "generic_type" || n.type === "scoped_type_identifier");
+          if (sc) {
+            relationships.push({
+              source: name,
+              target: this.baseTypeName(sc),
+              type: ASTEngine.RelationshipType.Extends,
+              confidence: 1,
+              ...this.lineField(sc, node),
+              metadata: { relationshipType: "extends_trait" }
+            });
+          }
+        }
+      }
+      const superInterfaces = this.findChild(node, (n) => n.type === "super_interfaces");
+      if (superInterfaces) {
+        for (const tid of this.collectTypeNodes(superInterfaces)) {
+          relationships.push({
+            source: name,
+            target: this.baseTypeName(tid),
+            type: ASTEngine.RelationshipType.Implements,
+            confidence: 1,
+            // M59 (#825): each interface is named on its OWN line.
+            ...this.lineField(tid, node),
+            metadata: { relationshipType: "implements" }
+          });
+        }
+      }
+      const sym = {
+        name,
+        kind,
+        comments: (() => {
+          const d = this.extractGroovyDoc(node);
+          return d ? [d] : [];
+        })(),
+        genericParameters: (() => {
+          const tp = this.extractGroovyTypeParameters(node);
+          return tp.length > 0 ? tp : void 0;
+        })(),
+        // M59 (#825): annotations skipped — the class is written on its own line.
+        range: this.symbolRange(node),
+        visibility,
+        decorators: classAnnotations,
+        ownerName: scopeStack.length > 0 ? scopeStack[scopeStack.length - 1].name : void 0,
+        ownerKind: scopeStack.length > 0 ? scopeStack[scopeStack.length - 1].kind : void 0,
+        metadata: { nodeType: type, annotations: classAnnotations, isRecord: type === "record_declaration", decoratorLines: classAnnotationRefs.map((a) => a.line) }
+      };
+      symbols.push(sym);
+      symbolMap.set(fqn, sym);
+      symbolMap.set(name, sym);
+      if (type === "record_declaration") {
+        const fp = this.findChild(node, (n) => n.type === "formal_parameters");
+        if (fp) {
+          for (let i = 0; i < fp.namedChildCount; i++) {
+            const p = fp.namedChild(i);
+            if (!p || p.type !== "formal_parameter") continue;
+            const pName = this.findChild(p, (n) => n.type === "identifier");
+            const pType = this.findChild(p, (n) => n.type === "type_identifier" || n.type === "integral_type" || n.type === "floating_point_type" || n.type === "boolean_type" || n.type === "generic_type" || n.type === "array_type" || n.type === "scoped_type_identifier");
+            if (pName) {
+              symbols.push({
+                name: pName.text,
+                kind: ASTEngine.SymbolKind.Property,
+                range: this.symbolRange(p),
+                returnType: pType ? this.baseTypeName(pType) : void 0,
+                visibility: "public",
+                ownerName: name,
+                ownerKind: kind,
+                metadata: { nodeType: "record_component" }
+              });
+            }
+          }
+        }
+      }
+      s.newContext = {
+        node,
+        name,
+        kind,
+        fqn,
+        symbolRef: sym,
+        visibility,
+        isInterface: type === "interface_declaration" || type === "trait_declaration",
+        parents
+      };
+      scopeStack.push(s.newContext);
+      s.pushedScope = true;
+    }
+  }
+  handleMethodDeclaration(node, s) {
+    const { symbols, symbolMap, overrideTasks, scopeStack } = s;
+    const type = node.type;
+    const isConstructorRaw = type === "constructor_declaration";
+    const nameNode = this.findChild(node, (n) => n.type === "identifier" || n.type === "string_literal");
+    if (nameNode) {
+      const rawName = nameNode.type === "string_literal" ? this.stripQuotes(nameNode.text) : nameNode.text;
+      if (rawName.trim() === "") {
+        s.emptyNameRefusals = (s.emptyNameRefusals ?? 0) + 1;
+        return;
+      }
+      const name = "constructor";
+      const modifiers = this.extractModifiers(node);
+      const visibility = this.extractVisibility(node);
+      const annotationRefs = this.extractAnnotationRefs(node);
+      const annotations = annotationRefs.map((a) => a.name);
+      const enclosingScope = scopeStack.length > 0 ? scopeStack[scopeStack.length - 1] : void 0;
+      const enclosingName = enclosingScope && (enclosingScope.kind === ASTEngine.SymbolKind.Class || enclosingScope.kind === ASTEngine.SymbolKind.Enum || enclosingScope.kind === ASTEngine.SymbolKind.Interface) ? enclosingScope.name : void 0;
+      const isMisnamedCtor = isConstructorRaw && enclosingName !== void 0 && rawName !== enclosingName;
+      const isConstructor = isConstructorRaw && !isMisnamedCtor;
+      const memberName = rawName;
+      const parameters = [];
+      const paramList = this.findChild(node, (n) => n.type === "formal_parameters");
+      if (paramList) {
+        for (let i = 0; i < paramList.namedChildCount; i++) {
+          const p = paramList.namedChild(i);
+          if (!p || p.type !== "formal_parameter" && p.type !== "spread_parameter") continue;
+          const isSpread = p.type === "spread_parameter";
+          let pName = this.findChild(p, (n) => n.type === "identifier");
+          if (isSpread) {
+            const decl = this.findChild(p, (n) => n.type === "variable_declarator");
+            pName = decl ? this.findChild(decl, (n) => n.type === "identifier") : null;
+          }
+          const pType = this.findChild(p, (n) => n.type === "type_identifier" || n.type === "integral_type" || n.type === "floating_point_type" || n.type === "boolean_type" || n.type === "void_type" || n.type === "generic_type" || n.type === "array_type" || n.type === "scoped_type_identifier");
+          parameters.push({
+            name: pName?.text ?? "anonymous",
+            type: pType ? this.baseTypeName(pType) + (isSpread ? "[]" : "") : void 0
+          });
+        }
+      }
+      const signature = `(${parameters.map((p) => p.type ?? "").join(",")})`;
+      const ownerName = scopeStack.length > 0 ? scopeStack[scopeStack.length - 1].name : void 0;
+      const ownerKind = scopeStack.length > 0 ? scopeStack[scopeStack.length - 1].kind : void 0;
+      const fqn = this.buildFqn(s.currentPackage, scopeStack, memberName);
+      const hasBody = !!this.findChild(node, (n) => n.type === "block" || n.type === "closure" || n.type === "constructor_body");
+      const isAbstract = !hasBody || !!s.newContext?.isInterface && !hasBody;
+      const declLine = (node.childForFieldName("name") ?? nameNode ?? this.declarationLineNode(node)).startPosition.row + 1;
+      if (annotations.indexOf("Override") !== -1 && s.newContext) {
+        overrideTasks.push({
+          fqn,
+          methodName: memberName,
+          signature,
+          ownerFqn: s.newContext.fqn,
+          explicit: true,
+          line: declLine
+        });
+      } else if (s.newContext && !isConstructor && modifiers.indexOf("static") === -1 && visibility !== "private") {
+        overrideTasks.push({
+          fqn,
+          methodName: memberName,
+          signature,
+          ownerFqn: s.newContext.fqn,
+          explicit: false,
+          line: declLine
+        });
+      }
+      const sym = {
+        name: memberName,
+        kind: isConstructor ? ASTEngine.SymbolKind.Constructor : ASTEngine.SymbolKind.Method,
+        comments: (() => {
+          const d = this.extractGroovyDoc(node);
+          return d ? [d] : [];
+        })(),
+        complexity: this.calculateGroovyMethodComplexity(node),
+        // The M59 (#825) anchor for a method is its NAME, and it is its name
+        // ALWAYS — the annotation branch that used to sit here is gone.
+        //
+        // It existed because the symbol's range was being read as the
+        // DECLARATION's line, and the hand-audited truth recorded the
+        // ANNOTATION's line for an annotated method (`@Override` L16 /
+        // `format` L17 → truth 16). With the name as the anchor, the line is
+        // the line the method is SPELLED on, which is the contract the M59 note
+        // states ("the line the thing is spelled on, not the declaration's
+        // opening line") — and it is what the whole live family does
+        // (script/m14/groovy-family-line-anchor-probe.ts: java/kotlin/scala all
+        // report the declaration's line for an annotated method, groovy
+        // reported the annotation's).
+        //
+        // THIS LANE'S OWN FIXTURES pin it and forbid the other:
+        //   groovy/lines-825              contains[Wrapped->use] @26, @25 FORBIDDEN
+        //   groovy/anonymous-body-overrides overrides[anonymous_TypeCodec.bsonType->bsonType] @23
+        //   groovy/ctor-field-split-lines contains[Split->Split] @19 (the NAME's line)
+        //
+        // The tree-sitter-groovy field-absorb case is unchanged by this and is
+        // still the reason the NAME is the anchor: `final Distance distance` +
+        // `Sphere(...)` parse as one method_declaration starting at the field, so
+        // the node start is the field's line while the name is written 7 lines
+        // lower (measured: grails-core Sphere.groovy).
+        range: this.symbolRange(
+          node,
+          node.childForFieldName("name") ?? nameNode
+        ),
+        visibility,
+        genericParameters: (() => {
+          const tp = this.extractGroovyTypeParameters(node);
+          return tp.length > 0 ? tp : void 0;
+        })(),
+        parameters,
+        decorators: annotations,
+        ownerName,
+        ownerKind,
+        metadata: { nodeType: type, modifiers, annotations, isAbstract, decoratorLines: annotationRefs.map((a) => a.line) }
+      };
+      symbols.push(sym);
+      symbolMap.set(fqn, sym);
+      const rawKey = ownerName ? `${ownerName}.${memberName}${signature}` : `${memberName}${signature}`;
+      symbolMap.set(rawKey, sym);
+      s.newContext = {
+        node,
+        name: memberName,
+        kind: isConstructor ? ASTEngine.SymbolKind.Constructor : ASTEngine.SymbolKind.Method,
+        fqn,
+        symbolRef: sym,
+        visibility,
+        isInterface: false,
+        parents: []
+      };
+      scopeStack.push(s.newContext);
+      s.pushedScope = true;
+    }
+  }
+  handleFieldDeclaration(node, s) {
+    const { symbols, scopeStack } = s;
+    const type = node.type;
+    const modifiers = this.extractModifiers(node);
+    const visibility = this.extractVisibility(node);
+    const isStatic = modifiers.indexOf("static") !== -1;
+    const isConstant = modifiers.indexOf("final") !== -1 && isStatic;
+    const fieldAnnotationRefs = this.extractAnnotationRefs(node);
+    const fieldAnnotations = fieldAnnotationRefs.map((a) => a.name);
+    const ownerName = scopeStack.length > 0 ? scopeStack[scopeStack.length - 1].name : void 0;
+    const ownerKind = scopeStack.length > 0 ? scopeStack[scopeStack.length - 1].kind : void 0;
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child?.type !== "variable_declarator") continue;
+      const idNode = this.findChild(child, (n) => n.type === "identifier");
+      if (!idNode || !ownerName) continue;
+      if (idNode.text === "def") continue;
+      if (this.isDuplicateParseField(node, s.content)) continue;
+      const fieldName = idNode.text.trim();
+      if (fieldName === "") {
+        s.emptyNameRefusals = (s.emptyNameRefusals ?? 0) + 1;
+        continue;
+      }
+      symbols.push({
+        name: fieldName,
+        kind: isConstant ? ASTEngine.SymbolKind.Constant : ASTEngine.SymbolKind.Property,
+        range: this.symbolRange(child),
+        visibility,
+        ownerName,
+        ownerKind,
+        decorators: fieldAnnotations,
+        metadata: { nodeType: type, modifiers, isConstant, annotations: fieldAnnotations, decoratorLines: fieldAnnotationRefs.map((a) => a.line) }
+      });
+    }
+  }
+  handleEnumConstant(node, s) {
+    const { symbols, scopeStack } = s;
+    const type = node.type;
+    const nameNode = this.findChild(node, (n) => n.type === "identifier");
+    const ownerName = scopeStack.length > 0 ? scopeStack[scopeStack.length - 1].name : void 0;
+    const enumMemberName = nameNode?.text.trim() ?? "";
+    if (enumMemberName !== "" && ownerName) {
+      symbols.push({
+        name: enumMemberName,
+        kind: ASTEngine.SymbolKind.EnumMember,
+        range: this.symbolRange(node),
+        visibility: "public",
+        ownerName,
+        ownerKind: ASTEngine.SymbolKind.Enum,
+        metadata: { nodeType: type }
+      });
+    }
+  }
+  handleMethodInvocation(node, s) {
+    const { relationships } = s;
+    const type = node.type;
+    const nameNode = node.childForFieldName("name");
+    if (nameNode) {
+      const methodName = nameNode.text;
+      const objectNode = node.childForFieldName("object");
+      const callExpr = this.buildGroovyQualifiedCall(objectNode, methodName);
+      const sourceName = s.parentContext?.name ?? "(script)";
+      if (!this.isGroovyBuiltin(callExpr)) {
+        if (s.parentContext?.symbolRef) {
+          if (!s.parentContext.symbolRef.qualified_calls) s.parentContext.symbolRef.qualified_calls = [];
+          s.parentContext.symbolRef.qualified_calls.push(callExpr);
+        }
+        relationships.push({
+          source: sourceName,
+          target: methodName,
+          type: ASTEngine.RelationshipType.Calls,
+          confidence: 0.7,
+          // M59 (#825): the method NAME's line, not the receiver's — a
+          // multi-line chain opens on the receiver (scala's measured defect).
+          ...this.lineField(nameNode, node),
+          metadata: { groovyCallExpression: callExpr }
+        });
+      }
+    }
+  }
+  handleExplicitConstructorInvocation(node, s) {
+    const { relationships } = s;
+    const type = node.type;
+    const first = node.namedChild(0);
+    if (first && (first.type === "super" || first.type === "this")) {
+      relationships.push({
+        source: s.parentContext?.name ?? "(script)",
+        target: first.type,
+        type: ASTEngine.RelationshipType.Calls,
+        confidence: 1,
+        ...this.lineField(first, node),
+        metadata: { relationshipType: "constructor_invocation" }
+      });
+    }
+  }
+  handleJuxtFunctionCall(node, s) {
+    const { relationships } = s;
+    const type = node.type;
+    const nameNode = node.childForFieldName("name");
+    if (nameNode && !this.isGroovyBuiltin(nameNode.text)) {
+      if (this.looksLikeTypedClosureMisparse(node, nameNode, s.content)) {
+      } else {
+        const leafNode = nameNode.type === "field_access" ? nameNode.childForFieldName("field") ?? nameNode : nameNode;
+        relationships.push({
+          source: s.parentContext?.name ?? "(script)",
+          target: leafNode.text,
+          type: ASTEngine.RelationshipType.Calls,
+          confidence: 0.7,
+          ...this.lineField(leafNode, node),
+          // The callee expression AS WRITTEN (the sibling method_invocation
+          // branch's payload) — kept so the dotted form is recoverable by a
+          // consumer even though the edge itself names the bare leaf.
+          metadata: { relationshipType: "juxt_call", groovyCallExpression: nameNode.text }
+        });
+      }
+    }
+  }
+  handleLeadingDotCall(node, s) {
+    const { relationships } = s;
+    const type = node.type;
+    const nameNode = node.childForFieldName("name");
+    if (nameNode && !this.isGroovyBuiltin(nameNode.text)) {
+      const args = node.childForFieldName("arguments") ?? this.findChild(node, (n) => n.type === "argument_list");
+      if (args) {
+        relationships.push({
+          source: s.parentContext?.name ?? "(script)",
+          target: nameNode.text,
+          type: ASTEngine.RelationshipType.Calls,
+          confidence: 0.7,
+          ...this.lineField(nameNode, node),
+          metadata: { relationshipType: "leading_dot_call" }
+        });
+      } else {
+        relationships.push({
+          source: s.parentContext?.name ?? "(script)",
+          target: nameNode.text,
+          type: ASTEngine.RelationshipType.Uses,
+          confidence: 0.6,
+          ...this.lineField(nameNode, node),
+          metadata: { isFieldAccess: true }
+        });
+      }
+    }
+  }
+  handleObjectCreationExpression(node, s) {
+    const { symbols, relationships, symbolMap, classHierarchy, scopeStack } = s;
+    const type = node.type;
+    const typeNode = this.findChild(node, (n) => n.type === "type_identifier" || n.type === "generic_type" || n.type === "scoped_type_identifier" || n.type === "identifier");
+    if (typeNode) {
+      const source = s.parentContext?.name || s.parentContext?.symbolRef?.name || "(script)";
+      relationships.push({
+        source,
+        target: this.baseTypeName(typeNode),
+        type: ASTEngine.RelationshipType.Instantiates,
+        confidence: 0.95,
+        // M59 (#825): the constructed TYPE's own line.
+        ...this.lineField(typeNode, node),
+        metadata: { relationshipType: "instantiates", isNew: true }
+      });
+      const classBody = this.findChild(node, (n) => n.type === "class_body");
+      if (classBody && s.parentContext) {
+        const superName = this.baseTypeName(typeNode);
+        const anonName = superName ? `anonymous_${superName}` : "anonymous_class";
+        const anonFqn = s.parentContext.fqn ? `${s.parentContext.fqn}.${anonName}` : anonName;
+        const anonSym = {
+          name: anonName,
+          kind: ASTEngine.SymbolKind.Class,
+          range: this.symbolRange(node),
+          visibility: s.parentContext.visibility || "public",
+          ownerName: s.parentContext.name,
+          ownerKind: s.parentContext.kind,
+          // `synthesized: true` is a DECLARATION, not an exemption request. The name is
+          // invented from the supertype because an anonymous class has no spelling, and
+          // the M60 surface audit's "name not present in source" / "ghost target" rows
+          // cannot tell that from a name the analyzer made up and passed off. Declaring
+          // it moves both rows into the audit's own "named by contract, not by source
+          // spelling" category -- counted, disclosed, and still failing for any
+          // UNDECLARED synthesized name, which is the case that actually matters.
+          metadata: { nodeType: type, isAnonymousClass: true, synthesized: true, superTypes: superName ? [superName] : [] }
+        };
+        symbols.push(anonSym);
+        symbolMap.set(anonFqn, anonSym);
+        classHierarchy.set(anonFqn, superName ? [superName] : []);
+        s.newContext = {
+          node: classBody,
+          name: anonName,
+          kind: ASTEngine.SymbolKind.Class,
+          fqn: anonFqn,
+          symbolRef: anonSym,
+          visibility: s.parentContext.visibility,
+          isInterface: false,
+          parents: superName ? [superName] : []
+        };
+        scopeStack.push(s.newContext);
+        s.pushedScope = true;
+      }
+    }
+  }
+  /**
+   * Framework detection from imports + annotation short names. The mapping is
+   * MEASURED against the grails-core corpus (top imported packages):
+   * the "grails" / "org.grails" / "org.apache.grails", "spock.lang" and
+   * "org.springframework" import families dominate real Groovy code.
+   * result.framework flows to
+   * brain_file.framework_type which patterns/rules.ts ranks on — Groovy
+   * files previously got NULL there, hiding Grails projects from pattern
+   * analysis. Primary selection follows a fixed priority so the same file
+   * always yields the same primary.
+   */
+  /**
+   * 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") {
+        md.evidenceClass = "import_based";
+        continue;
+      }
+      if (t === "references") {
+        md.evidenceClass = md.isGroovyImport || md.isImport ? "import_based" : "reference_qualified";
+        continue;
+      }
+      if (t === "imports") {
+        md.evidenceClass = "import_based";
+        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 === "decorates") {
+        md.evidenceClass = "structural";
+        continue;
+      }
+      md.evidenceClass = "usage_contextual";
+    }
+  }
+  detectGroovyFrameworks(content, symbols, imports) {
+    const frameworks = /* @__PURE__ */ new Set();
+    for (let i = 0; i < imports.length; i++) {
+      const mod = imports[i].module || "";
+      if (mod.startsWith("grails.") || mod.startsWith("org.grails.") || mod.startsWith("org.apache.grails.")) frameworks.add("grails");
+      else if (mod.startsWith("org.springframework.")) frameworks.add("spring");
+      else if (mod.startsWith("spock.lang.")) frameworks.add("spock");
+      else if (mod.startsWith("javax.persistence.") || mod.startsWith("jakarta.persistence.")) frameworks.add("jpa");
+      else if (mod.startsWith("org.hibernate.")) frameworks.add("hibernate");
+      else if (mod.startsWith("org.junit.") || mod.startsWith("org.spockframework.")) frameworks.add("junit");
+    }
+    for (let i = 0; i < symbols.length; i++) {
+      const anns = symbols[i].metadata?.annotations ?? [];
+      for (let j = 0; j < anns.length; j++) {
+        const a = anns[j];
+        if (a === "Service" || a === "RestController" || a === "Controller" || a === "Repository" || a === "Component") frameworks.add("spring");
+      }
+    }
+    for (const priority of ["grails", "spring", "hibernate", "jpa", "spock", "junit"]) {
+      if (frameworks.has(priority)) return { framework: priority, detected: [...frameworks] };
+    }
+    return { framework: void 0, detected: [...frameworks] };
+  }
+  resolveOverrides(tasks, classHierarchy, symbolMap, relationships, companion) {
+    let suffixIndex = null;
+    for (let ti = 0; ti < tasks.length; ti++) {
+      const task = tasks[ti];
+      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) {
+          if (!classHierarchy.has(cand)) continue;
+          const ownerBare = cand.slice(cand.lastIndexOf(".") + 1);
+          const potential = `${ownerBare}.${task.methodName}${task.signature}`;
+          if (symbolMap.has(potential)) {
+            targetFqn = `${cand}.${task.methodName}${task.signature}`;
+            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 && task.explicit && 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 targetLabel = localEdgeLabel(targetFqn);
+        if (localSource === targetLabel) continue;
+        relationships.push({
+          source: localSource,
+          // THE TARGET IS THE DECLARED MEMBER, NOT `Owner.member` — this lane resolved 0 of 253 with
+          // the dotted spelling, and the label helper it was using is the one the four-lane fix now
+          // pairs with `localEdgeName`.
+          target: localEdgeName(targetFqn),
+          type: ASTEngine.RelationshipType.Overrides,
+          confidence,
+          // M59 (#825): the overriding declaration's line — captured while the
+          // node was in hand, not resolved later by name (namesakes collide).
+          ...task.line ? { line_number: task.line } : {},
+          metadata: {
+            relationshipType: "method_override",
+            isGroovyOverride: true,
+            reasonCode,
+            // THE OWNER IS CARRIED, not dropped — see the cpp site's note on why the four-lane fix
+            // needed it and did not have it.
+            overriddenOwner: targetLabel.includes(".") ? targetLabel.slice(0, targetLabel.lastIndexOf(".")) : ""
+          }
+        });
+      }
+    }
+  }
+  /**
+   * Declared-type reference graph (M14). References edges from the enclosing
+   * method/class to every named type in a declaration position. Collection
+   * descends but stops at value boundaries (variable_declarator values,
+   * closures, blocks) so initializer contents are never mistaken for the
+   * declared type clause.
+   */
+  collectDeclaredTypeRefs(rootNode, relationships) {
+    const emitted = /* @__PURE__ */ new Set();
+    const TYPE_STOP = /* @__PURE__ */ new Set(["variable_declarator", "closure", "block", "closure_expression"]);
+    const isPlainTypeName = (t) => {
+      if (t.length === 0) return false;
+      for (let i = 0; i < t.length; i++) {
+        const c = t.charCodeAt(i);
+        const ok = c >= 97 && c <= 122 || // a-z
+        c >= 65 && c <= 90 || // A-Z
+        c >= 48 && c <= 57 || // 0-9
+        c === 95 || // _
+        c === 36 || // $ (a legal groovy/java identifier character)
+        c === 46;
+        if (!ok) return false;
+      }
+      return true;
+    };
+    const collectTypeNames = (n, out) => {
+      if (n.type === "type_identifier") {
+        if (n.text !== "def" && n.text !== "as" && isPlainTypeName(n.text) && !out.some((o) => o.name === n.text)) out.push({ name: n.text, node: n });
+        return;
+      }
+      if (n.type === "record_pattern") {
+        const t = n.namedChild(0);
+        if (t && t.type === "identifier" && t.text !== "this" && !out.some((o) => o.name === t.text)) out.push({ name: t.text, node: t });
+        return;
+      }
+      if (n.type === "type_arguments") {
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (c) collectTypeNames(c, out);
+        }
+        return;
+      }
+      if (n.type === "scoped_type_identifier") {
+        const text = n.text;
+        if (!isPlainTypeName(text)) return;
+        if (!out.some((o) => o.name === text)) out.push({ name: text, node: n });
+        const args = this.findChild(n, (c) => c.type === "type_arguments");
+        if (args) collectTypeNames(args, out);
+        return;
+      }
+      if (TYPE_STOP.has(n.type)) return;
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) collectTypeNames(c, out);
+      }
+    };
+    const resolveSource = (start) => {
+      let p = GROOVY_DECLARATION_TYPES.has(start.type) ? start : start.parent;
+      while (p) {
+        if (p.type === "method_declaration" || p.type === "constructor_declaration" || p.type === "function_definition") {
+          const name = this.findChild(p, (c) => c.type === "identifier");
+          if (name) return name.text;
+        }
+        if (p.type === "class_declaration" || p.type === "trait_declaration" || p.type === "enum_declaration") {
+          const name = this.findChild(p, (c) => c.type === "identifier");
+          if (name) return name.text;
+        }
+        p = p.parent;
+      }
+      return "(script)";
+    };
+    const emit = (decl, roots, kind, relType = "declared_type") => {
+      const source = resolveSource(decl);
+      for (const r of roots) {
+        const names = [];
+        collectTypeNames(r, names);
+        for (const t of names) {
+          const key = `${source}|${t.name}|${kind}`;
+          if (emitted.has(key)) continue;
+          emitted.add(key);
+          relationships.push({
+            source,
+            target: t.name,
+            type: ASTEngine.RelationshipType.References,
+            confidence: 0.95,
+            // M59 (#825): the line the TYPE is named on. A wrapped generic
+            // (`List<\n    Map<String, Int>>`) opens on an earlier line than its
+            // arguments, so the enclosing type expression's line is wrong for
+            // every nested name (scala's measured defect class).
+            ...this.lineField(t.node, decl),
+            metadata: { relationshipType: relType, declaredOn: decl.type }
+          });
+        }
+      }
+    };
+    const visited = /* @__PURE__ */ new Set();
+    const walk = (n) => {
+      if (visited.has(n.id)) return;
+      visited.add(n.id);
+      switch (n.type) {
+        case "binary_expression": {
+          const asType = n.childForFieldName("type");
+          if (asType && n.childForFieldName("left")) {
+            emit(n, [asType], "as_coercion", "cast_type");
+            break;
+          }
+          break;
+        }
+        case "field_declaration":
+        case "formal_parameter":
+        case "local_variable_declaration": {
+          if (n.type === "local_variable_declaration") {
+            let asKw = null;
+            let asDecl = null;
+            for (let i = 0; i < n.namedChildCount; i++) {
+              const c = n.namedChild(i);
+              if (!c) continue;
+              if ((c.type === "type_identifier" || c.type === "identifier") && c.text === "as") asKw = c;
+              else if (c.type === "variable_declarator") asDecl = c;
+            }
+            if (asKw && asDecl) {
+              const names = [];
+              const tstack = [asDecl];
+              while (tstack.length > 0) {
+                const m = tstack.pop();
+                if (m.type === "type_identifier" || m.type === "identifier") {
+                  if (m.text !== "as" && m.text !== "def" && !names.some((o) => o.name === m.text)) names.push({ name: m.text, node: m });
+                } else {
+                  for (let i = 0; i < m.namedChildCount; i++) {
+                    const c = m.namedChild(i);
+                    if (c) tstack.push(c);
+                  }
+                }
+              }
+              const source = resolveSource(n);
+              for (const t of names) {
+                const key = `${source}|${t.name}|as_cast`;
+                if (emitted.has(key)) continue;
+                emitted.add(key);
+                relationships.push({
+                  source,
+                  target: t.name,
+                  type: ASTEngine.RelationshipType.References,
+                  confidence: 0.95,
+                  ...this.lineField(t.node, n),
+                  metadata: { relationshipType: "cast_type", declaredOn: "as_cast" }
+                });
+              }
+              break;
+            }
+          }
+          const roots = [];
+          for (let i = 0; i < n.namedChildCount; i++) {
+            const c = n.namedChild(i);
+            if (!c || TYPE_STOP.has(c.type)) continue;
+            if (c.type.endsWith("type") || c.type === "type_identifier" || c.type === "scoped_type_identifier") roots.push(c);
+          }
+          if (roots.length) emit(n, roots, n.type);
+          break;
+        }
+        case "throws": {
+          const kids = [];
+          for (let i = 0; i < n.namedChildCount; i++) {
+            const c = n.namedChild(i);
+            if (c) kids.push(c);
+          }
+          emit(n, kids, "throws", "throws_type");
+          break;
+        }
+        case "catch_formal_parameter": {
+          const catchType = this.findChild(n, (c) => c.type === "catch_type");
+          if (catchType) emit(n, [catchType], "catch_formal_parameter", "declared_type");
+          break;
+        }
+        case "instanceof_expression": {
+          for (let i = 0; i < n.namedChildCount; i++) {
+            const c = n.namedChild(i);
+            if (c) emit(n, [c], n.type, "instanceof_expression");
+          }
+          break;
+        }
+        case "cast_expression": {
+          const first = n.namedChild(0);
+          if (first) emit(n, [first], n.type, "cast_type");
+          break;
+        }
+        case "switch_label": {
+          for (let i = 0; i < n.namedChildCount; i++) {
+            const c = n.namedChild(i);
+            if (c && c.type === "pattern") emit(n, [c], "switch_pattern", "case_pattern");
+          }
+          break;
+        }
+        case "method_reference": {
+          const first = n.namedChild(0);
+          if (first && first.type === "identifier" && first.text !== "this") {
+            const source = resolveSource(n);
+            const key = `${source}|${first.text}|method_reference`;
+            if (!emitted.has(key)) {
+              emitted.add(key);
+              relationships.push({
+                source,
+                target: first.text,
+                type: ASTEngine.RelationshipType.References,
+                confidence: 0.9,
+                ...this.lineField(first, n),
+                metadata: { relationshipType: "method_reference" }
+              });
+            }
+          }
+          break;
+        }
+        case "juxt_function_call": {
+          const first = n.namedChild(0);
+          if (first && first.text === "as") {
+            for (let i = 0; i < n.namedChildCount; i++) {
+              const c = n.namedChild(i);
+              if (c && c.type === "argument_list") emit(n, [c], "as_expression", "cast_type");
+            }
+          }
+          break;
+        }
+        case "method_declaration": {
+          const roots = [];
+          for (let i = 0; i < n.namedChildCount; i++) {
+            const c = n.namedChild(i);
+            if (!c) continue;
+            if (c.type === "identifier") break;
+            if (c.type === "modifiers") continue;
+            if (c.type.endsWith("_type") || c.type === "type_identifier" || c.type === "scoped_type_identifier") roots.push(c);
+            else break;
+          }
+          if (roots.length) emit(n, roots, "return_type", "return_type");
+          break;
+        }
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) walk(c);
+      }
+    };
+    walk(rootNode);
+  }
+  collectFieldAccessUses(rootNode, relationships, symbols) {
+    const stack = [
+      { node: rootNode, owner: null, method: null }
+    ];
+    const seen = /* @__PURE__ */ new Set();
+    const boundCache = /* @__PURE__ */ new Map();
+    const boundNamesOf = (scope) => {
+      const cached = boundCache.get(scope.id);
+      if (cached) return cached;
+      const out = /* @__PURE__ */ new Set();
+      const push = (n) => {
+        if (n && n.type === "identifier") out.add(n.text);
+      };
+      const work = [];
+      for (let i = 0; i < scope.namedChildCount; i++) {
+        const c = scope.namedChild(i);
+        if (c) work.push(c);
+      }
+      while (work.length > 0) {
+        const n = work.pop();
+        if (n.type === "formal_parameter" || n.type === "catch_formal_parameter") push(n.childForFieldName("name"));
+        else if (n.type === "variable_declarator") push(n.childForFieldName("name"));
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (c) work.push(c);
+        }
+      }
+      if (scope.type === "closure") out.add("it");
+      boundCache.set(scope.id, out);
+      return out;
+    };
+    const locallyBoundNames = (n) => {
+      const acc = /* @__PURE__ */ new Set();
+      let p = n.parent;
+      let guard = 0;
+      while (p && guard++ < 24) {
+        if (p.type === "method_declaration" || p.type === "constructor_declaration" || p.type === "function_definition" || p.type === "lambda_expression" || p.type === "closure" || p.type === "program") {
+          for (const t of boundNamesOf(p)) acc.add(t);
+        }
+        if (p.type === "class_declaration" || p.type === "interface_declaration" || p.type === "trait_declaration" || p.type === "enum_declaration") break;
+        p = p.parent;
+      }
+      return acc;
+    };
+    while (stack.length > 0) {
+      const item = stack.pop();
+      const { node, owner, method } = item;
+      if (node.type === "class_declaration" || node.type === "interface_declaration" || node.type === "trait_declaration" || node.type === "enum_declaration") {
+        const nameNode = this.findChild(node, (n) => n.type === "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 });
+        }
+        continue;
+      }
+      let nextMethod = method;
+      if (node.type === "method_declaration" || node.type === "constructor_declaration" || node.type === "function_definition") {
+        const nameNode = this.findChild(node, (n) => n.type === "identifier");
+        const declaredName = nameNode?.text?.trim() ? nameNode.text : void 0;
+        const isRealCtor = node.type === "constructor_declaration" && (owner === void 0 || declaredName === owner);
+        nextMethod = isRealCtor ? "constructor" : declaredName ?? method;
+      }
+      if (node.type === "field_access") {
+        const parts = node.text.split(".").map((p) => p.endsWith("?") || p.endsWith("*") ? p.slice(0, -1) : p);
+        if (parts.length >= 2) {
+          const first = this.fieldAccessReceiverName(node);
+          const readOwner = method ?? owner;
+          const source = first === "this" || first === "super" ? owner ?? first : readOwner ?? first ?? owner ?? "(script)";
+          const pType = node.parent?.type;
+          let isWrite = false;
+          if (pType === "assignment_expression") {
+            const lhs = node.parent.namedChild(0);
+            isWrite = !!lhs && lhs.startIndex === node.startIndex && lhs.endIndex === node.endIndex;
+          }
+          const parentField = node.parent?.type === "juxt_function_call" ? node.parent.childForFieldName("name") : null;
+          const isCalleePosition = !!parentField && parentField.startIndex === node.startIndex && parentField.endIndex === node.endIndex;
+          const inConstructorBody = method === "constructor";
+          const thisLhsInConstructor = inConstructorBody && isWrite && (first === "this" || first === "super");
+          const leafNode = node.childForFieldName("field");
+          const leafName = leafNode ? leafNode.type === "string_literal" || leafNode.type === "character_literal" ? this.stripQuotes(leafNode.text) : leafNode.text : parts[parts.length - 1];
+          const key = `${source}.${leafName}`;
+          if ((!isWrite || thisLhsInConstructor) && !isCalleePosition && !seen.has(key)) {
+            seen.add(key);
+            relationships.push({
+              source,
+              target: leafName,
+              type: ASTEngine.RelationshipType.Uses,
+              // 0.6 for an ordinary read, but 1.0 for a `this.x = …` in a constructor. The 0.6 is
+              // a real claim-strength discount for an INFERRED read; this edge is not inferred.
+              // `this.<field>` names a member of the enclosing type by construction, the type is
+              // known statically, and the ground truth cites the exact source line for all four such
+              // rows (User->id, User->name, Robot->name, Counter->count). At 0.6 the harness
+              // classified the observed fact as state "unknown" -- anything below 0.7 is
+              // emitted-but-not-claimed (script/m12 relationshipFacts) -- while the truth row is
+              // "resolved", so a correct edge scored as a false NEGATIVE.
+              confidence: thisLhsInConstructor ? 1 : 0.6,
+              // M59 (#825): the `field` field of the access node names the
+              // member — measured populated in the pinned grammar
+              // (`repo.items` -> [identifier, identifier], field=identifier),
+              // so a multi-line receiver chain does not drag the read onto the
+              // receiver's line.
+              ...this.lineField(node.childForFieldName("field"), node),
+              metadata: { isFieldAccess: true }
+            });
+          }
+        }
+      }
+      if (node.type === "array_access") {
+        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 first = node.namedChild(0);
+        if (!isWrite && first && first.type === "identifier") {
+          const source = method ?? owner ?? first.text;
+          const key = `arr:${source}.${first.text}`;
+          if (!seen.has(key)) {
+            seen.add(key);
+            relationships.push({
+              source,
+              target: first.text,
+              type: ASTEngine.RelationshipType.Uses,
+              confidence: 0.6,
+              ...this.lineField(first, node),
+              metadata: { isArrayAccess: true }
+            });
+          }
+        }
+      }
+      if (node.type === "interpolated_identifier" || node.type === "string_interpolation") {
+        const source = method ?? owner;
+        const candidates = [];
+        if (node.type === "interpolated_identifier") {
+          const parentType = node.parent?.type ?? "";
+          if (parentType === "juxt_function_call" || parentType === "field_access") continue;
+          candidates.push(node);
+        } else {
+          const collect = (n) => {
+            if (n.type === "identifier") {
+              const pt = n.parent?.type ?? "";
+              if (!INTERPOLATION_OWNED_BY_MEMBER_WALK.has(pt)) candidates.push(n);
+              return;
+            }
+            for (let i = 0; i < n.namedChildCount; i++) {
+              const c = n.namedChild(i);
+              if (c) collect(c);
+            }
+          };
+          for (let i = 0; i < node.namedChildCount; i++) {
+            const c = node.namedChild(i);
+            if (c) collect(c);
+          }
+        }
+        for (const n of candidates) {
+          const name = n.text.startsWith("$") ? n.text.slice(1) : n.text;
+          if (!name || !source) continue;
+          if (locallyBoundNames(n).has(name)) continue;
+          const key = `interp:${source}.${name}`;
+          if (seen.has(key)) continue;
+          seen.add(key);
+          relationships.push({
+            source,
+            target: name,
+            type: ASTEngine.RelationshipType.Uses,
+            confidence: 0.9,
+            ...this.lineField(n, n),
+            metadata: { isInterpolationRead: true }
+          });
+        }
+      }
+      for (let i = node.namedChildCount - 1; i >= 0; i--) {
+        const child = node.namedChild(i);
+        if (child) stack.push({ node: child, owner, method: nextMethod });
+      }
+    }
+  }
+  /**
+   * M60 ontology pass: the NAMEABLE receiver of a `field_access`, or `undefined`
+   * when the receiver is an expression rather than a name.
+   *
+   * Nameable means the receiver's own text is an identifier the reader can look up:
+   *   `a`        -> "a"          `a.b`      -> "a"        `a.b.c` -> "a"
+   *   `this`     -> "this"       `super`    -> "super"    `i?.j`  -> "i"
+   *   `k*.l`     -> "k"          (safe-nav and spread receivers are plain identifiers)
+   *
+   * NOT nameable, and deliberately `undefined` rather than a text fragment:
+   *   `arr[0].f`          receiver is an `array_access`          -> undefined
+   *   `new File(x).g`     receiver is an `object_creation_expression`
+   *   `foo().h`           receiver is a `method_invocation`
+   *   `(m).n`             receiver is a `parenthesized_expression`
+   *
+   * Returning the raw text for those is what produced the measured defect: the
+   * `node.text.split(".")[0]` this replaces yielded `arr[0]`, `new File(x` and
+   * `(m)` as relationship SOURCES — strings no symbol carries and no consumer can
+   * resolve. `undefined` is the honest answer, and the call site then applies the
+   * rule the walk already used for an unresolvable receiver: attribute the read to
+   * the enclosing method.
+   *
+   * Probe-verified node shapes (`object`/`field` are populated for every one,
+   * including `?.` and `*.`): script/m14/tmp/gv-probe6.mts, and the corpus count is
+   * `script/m60/groovy-r7-census.ts`'s `malformedNameEndpoints`.
+   */
+  fieldAccessReceiverName(node) {
+    let cur = node.childForFieldName("object");
+    while (cur) {
+      if (cur.type === "identifier" || cur.type === "this" || cur.type === "super") return cur.text;
+      if (cur.type === "field_access") {
+        cur = cur.childForFieldName("object");
+        continue;
+      }
+      return void 0;
+    }
+    return void 0;
+  }
+  isGroovyBuiltin(call) {
+    if (GROOVY_BUILTINS.has(call)) return true;
+    const firstDot = call.indexOf(".");
+    const root = firstDot > 0 ? call.slice(0, firstDot) : call;
+    const STDLIB_ROOTS = /* @__PURE__ */ new Set([
+      "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",
+      "ArrayList",
+      "LinkedList",
+      "HashMap",
+      "HashSet",
+      "TreeMap",
+      "TreeSet",
+      "LinkedHashMap",
+      "LinkedHashSet",
+      "ArrayDeque",
+      "PriorityQueue",
+      "Collections",
+      "Arrays",
+      "Objects",
+      "Optional",
+      "Comparator",
+      "List",
+      "Map",
+      "Set",
+      "Collection",
+      "Iterator",
+      "Iterable",
+      "Calendar",
+      "Date",
+      "UUID",
+      "Locale",
+      "Currency",
+      "File",
+      "Path",
+      "Paths",
+      "Files",
+      "BigDecimal",
+      "BigInteger",
+      "AtomicInteger",
+      "AtomicLong",
+      "StringBuilder",
+      "StringBuffer",
+      "Pattern",
+      "Matcher",
+      "Random",
+      "Logger",
+      "Level",
+      "OutputStream",
+      "InputStream",
+      "Reader",
+      "Writer",
+      "URL",
+      "URI",
+      "Socket",
+      "ServerSocket"
+    ]);
+    if (STDLIB_ROOTS.has(root)) return true;
+    return false;
+  }
+  /**
+   * Groovydoc extraction: block_comment starting with '/**' immediately
+   * preceding the declaration. Previously groovy symbols carried NO
+   * comments (M14 #383).
+   */
+  /**
+   * Per-method cyclomatic complexity (1 + decision points) - java/kotlin
+   * parity (M14 #301 prerequisite). Previously always absent.
+   */
+  buildGroovyQualifiedCall(objectNode, methodName) {
+    if (!objectNode) return methodName;
+    if (objectNode.type === "method_invocation") {
+      const innerName = objectNode.childForFieldName("name");
+      const innerObject = objectNode.childForFieldName("object");
+      const base = this.buildGroovyQualifiedCall(innerObject, innerName?.text ?? "");
+      return `${base}.${methodName}`;
+    }
+    return `${objectNode.text}.${methodName}`;
+  }
+  calculateGroovyMethodComplexity(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" || // for-in loops parsed as this, not for_statement
+      n.type === "while_statement" || n.type === "do_statement" || // do-while (NOT "do_while")
+      n.type === "switch_block_statement_group" || // per-case granularity (family contract)
+      n.type === "catch_clause" || // NOT "catch_block"
+      n.type === "ternary_expression") {
+        complexity++;
+      } else if (n.type === "binary_expression") {
+        const op = n.childForFieldName("operator")?.text;
+        if (op === "&&" || op === "||" || op === "?:") complexity++;
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const child = n.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+    return complexity;
+  }
+  extractGroovyDoc(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;
+  }
+  extractInheritance(node, type) {
+    const parents = [];
+    if (type === "class_declaration" || type === "trait_declaration") {
+      const superClass = this.findChild(node, (n) => n.type === "superclass");
+      if (superClass) {
+        const sc = this.findChild(superClass, (n) => n.type === "type_identifier" || n.type === "identifier" || n.type === "generic_type" || n.type === "scoped_type_identifier");
+        if (sc) parents.push(this.baseTypeName(sc));
+      }
+    } else if (type === "interface_declaration") {
+      const ext = this.findChild(node, (n) => n.type === "extends_interfaces");
+      if (ext) {
+        for (const tid of this.collectTypeNodes(ext)) {
+          parents.push(this.baseTypeName(tid));
+        }
+      }
+    }
+    const superInterfaces = this.findChild(node, (n) => n.type === "super_interfaces");
+    if (superInterfaces) {
+      for (const tid of this.collectTypeNodes(superInterfaces)) {
+        parents.push(this.baseTypeName(tid));
+      }
+    }
+    return parents;
+  }
+  /** Collect type nodes within a type_list/super_interfaces/etc (DFS).
+   * scoped_type_identifier is accepted AS a complete type and NOT descended
+   * into — its nested type_identifiers are package/class segments, never
+   * independent types (collecting them fabricated garbage edges). */
+  collectTypeNodes(node) {
+    const out = [];
+    const stack = [node];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (!c) continue;
+        if (c.type === "type_identifier" || c.type === "generic_type" || c.type === "scoped_type_identifier") {
+          out.push(c);
+        } else {
+          stack.push(c);
+        }
+      }
+    }
+    return out;
+  }
+  stripQuotes(text) {
+    if (text.length >= 2) {
+      const first = text[0];
+      const last = text[text.length - 1];
+      if (first === '"' && last === '"' || first === "'" && last === "'") {
+        return text.slice(1, -1);
+      }
+    }
+    return text;
+  }
+  baseTypeName(node) {
+    if (node.type === "generic_type") {
+      const id = this.findChild(node, (n) => n.type === "type_identifier" || n.type === "identifier");
+      return id ? id.text : node.text;
+    }
+    return node.text;
+  }
+  extractModifiers(node) {
+    const mods = [];
+    const modifiers = this.findChild(node, (n) => n.type === "modifiers");
+    if (modifiers) {
+      for (let i = 0; i < modifiers.childCount; i++) {
+        const c = modifiers.child(i);
+        if (!c || !c.isNamed) {
+          if (c) mods.push(c.text);
+          continue;
+        }
+        if (c.type === "annotation" || c.type === "marker_annotation") continue;
+        mods.push(c.text);
+      }
+    }
+    return mods;
+  }
+  /**
+   * Generic type-parameter extraction from type_parameters nodes.
+   * Previously groovy symbols carried NO generic information (#383 fix).
+   */
+  extractGroovyTypeParameters(node) {
+    const tpNode = node.namedChildren.find((c) => c.type === "type_parameters");
+    if (!tpNode) return [];
+    const out = [];
+    for (let i = 0; i < tpNode.namedChildCount; i++) {
+      const c = tpNode.namedChild(i);
+      if (!c) continue;
+      if (c.type.includes("identifier")) {
+        out.push(c.text.trim());
+      } else if (c.type === "type_parameter") {
+        for (let j = 0; j < c.namedChildCount; j++) {
+          const gc = c.namedChild(j);
+          if (gc && gc.type.includes("identifier")) {
+            out.push(gc.text.trim());
+            break;
+          }
+        }
+      }
+    }
+    return out;
+  }
+  extractVisibility(node) {
+    const mods = this.extractModifiers(node);
+    if (mods.indexOf("private") !== -1) return "private";
+    if (mods.indexOf("protected") !== -1) return "protected";
+    return "public";
+  }
+  extractAnnotations(node) {
+    return this.extractAnnotationRefs(node).map((a) => a.name);
+  }
+  /**
+   * THE ANNOTATIONS, WITH THE LINE EACH IS WRITTEN ON — 2026-10-22.
+   *
+   * The `decorates` edge is the family shape for "a decorator is applied to a
+   * declaration" (src/ast/types.ts: the direction is the DECORATED DECLARATION
+   * → THE DECORATOR, and the family's emitters are javascript
+   * `src/ast/real-javascript-analyzer.ts:3003` and python
+   * `src/ast/real-python-analyzer.ts:6112`):
+   *
+   *     source = the decorated declaration's name
+   *     target = the decorator's NAME LEAF
+   *     line_number = the DECORATOR's own line
+   *     metadata = { isDecorator: true, decoratorLine }
+   *
+   * ⇒ SO THE NAME IS THE LEAF, NOT THE WRITTEN PATH: the same rule this
+   * method already applies to the symbol's `decorators` list (the last dotted
+   * segment), and the same rule the lane's own fixture pins
+   * (groovy/fq-annotations: `expectDecorators` says the class `FqService`
+   * "contains" `Service` for `@Service`, and the short-name normalizer is what
+   * the fixture's own rationale records: "The short-name normalizer (last
+   * dotted segment) must feed both"). ⇒ The EDGE and the SYMBOL LIST therefore
+   * agree, which is what lets a consumer join them.
+   *
+   * ⇒ AND THE LINE IS THE ANNOTATION'S OWN LINE, not the declaration's: the
+   * decorator is spelled there, and the family's emitters put the decorator's
+   * line on the row (javascript: `decoratorLine`).
+   */
+  extractAnnotationRefs(node) {
+    const anns = [];
+    const modifiers = this.findChild(node, (n) => n.type === "modifiers");
+    if (modifiers) {
+      for (let i = 0; i < modifiers.namedChildCount; i++) {
+        const c = modifiers.namedChild(i);
+        if (c && (c.type === "annotation" || c.type === "marker_annotation")) {
+          const nameNode = this.findChild(c, (n) => n.type === "identifier" || n.type === "scoped_identifier");
+          if (nameNode) {
+            const text = nameNode.text;
+            const dot = text.lastIndexOf(".");
+            anns.push({
+              name: dot === -1 ? text : text.slice(dot + 1),
+              line: nameNode.startPosition.row + 1
+            });
+          }
+        }
+      }
+    }
+    return anns;
+  }
+  buildFqn(currentPackage, scopeStack, name) {
+    if (scopeStack.length > 0) {
+      return `${scopeStack[scopeStack.length - 1].fqn}.${name}`;
+    }
+    return currentPackage ? `${currentPackage}.${name}` : name;
+  }
+  /**
+   * #841 round 14: does this juxt_function_call carry the typed-closure-
+   * parameter misparse shape? Measured on the pinned grammar, not assumed:
+   *   `{ Test task -> … }`            → name=Test,      args="task"
+   *   `{ String key, Object value → }` → name=String,    args="key, Object"
+   *   `{ Map<String,File> m -> … }`    → name=Map,       args="<String,File> m"  (generic)
+   *
+   * The decisive evidence is the SOURCE, measured over the whole groovy corpus
+   * (962 such juxt nodes, every one verified): what follows the node is at most
+   * further parameter names (the multi-param node stops before the last name —
+   * `String key, Object` then ` value`), commas, dots, generics, brackets and
+   * whitespace, and then the closure arrow `->`. A REAL juxtaposed call is
+   * never followed by an arrow — the arrow can only make the preceding text a
+   * closure parameter list (Groovy has no other `->`). The tree compositions
+   * (lambda sibling, arrow sibling, first child of closure/block) are the
+   * fallback when no source text is supplied — the same 962 sites fall into
+   * exactly those three compositions, with 139 of them ending before the last
+   * parameter name (which is why a sibling-only test under-covers by ~5×: it
+   * suppressed 115 of the 608 fabricated edges; the source test covers the
+   * rest).
+   */
+  /** The JS `\s` set, as a char test — kept exact so the char walks below are
+   * behaviour-identical to the regexes they replace (M49.R2: the AST regex
+   * census counted those three literals as review-class debt). */
+  static isRegexSpace(c, code) {
+    if (c === " " || c === "	" || c === "\n" || c === "\r" || c === "\v" || c === "\f") return true;
+    return code === 160 || code === 5760 || code >= 8192 && code <= 8202 || code === 8232 || code === 8233 || code === 8239 || code === 8287 || code === 12288 || code === 65279;
+  }
+  /** `/^[\s]*$/` as a char walk. */
+  static isWhitespaceOnly(text) {
+    for (let i = 0; i < text.length; i++) {
+      if (!_RealGroovyAnalyzer.isRegexSpace(text[i], text.charCodeAt(i))) return false;
+    }
+    return true;
+  }
+  /**
+   * `/^[A-Z][A-Za-z0-9_]*(\.[A-Z][A-Za-z0-9_]*)*$/` as a char walk: a
+   * type-cased name, optionally dotted, every segment starting uppercase and
+   * otherwise word characters. Lowercase juxt callees (`echo`, `sh`) never
+   * match, so ordinary Jenkins-style juxtaposition is untouched.
+   */
+  static isTypeCasedDottedName(text) {
+    if (text.length === 0) return false;
+    let i = 0;
+    while (i < text.length) {
+      const first = text[i];
+      if (!(first >= "A" && first <= "Z")) return false;
+      i++;
+      while (i < text.length && text[i] !== ".") {
+        const c = text[i];
+        if (!(c >= "A" && c <= "Z" || c >= "a" && c <= "z" || c >= "0" && c <= "9" || c === "_")) return false;
+        i++;
+      }
+      if (i < text.length) {
+        i++;
+        if (i >= text.length) return false;
+      }
+    }
+    return true;
+  }
+  /** Identifier start character (the regexes' `[A-Za-z_]`). */
+  static isIdentStart(c) {
+    return c >= "A" && c <= "Z" || c >= "a" && c <= "z" || c === "_";
+  }
+  /** Identifier continuation character (the regexes' `[A-Za-z0-9_]`). */
+  static isWordChar(c) {
+    return c >= "A" && c <= "Z" || c >= "a" && c <= "z" || c >= "0" && c <= "9" || c === "_";
+  }
+  /**
+   * `/^[A-Za-z_][A-Za-z0-9_]*\.[A-Za-z_][A-Za-z0-9_]*`-style list as a char
+   * walk: comma-separated items, each an identifier optionally dotted, with
+   * optional whitespace around the commas only (`Type name`, `a.b.C`,
+   * `x, y.Z`). Mirrors the regex exactly — leading and trailing whitespace are
+   * not accepted (the call site trims first), and a trailing comma fails.
+   */
+  static isDottedIdentifierList(text) {
+    let i = 0;
+    const spaced = () => {
+      while (i < text.length && _RealGroovyAnalyzer.isRegexSpace(text[i], text.charCodeAt(i))) i++;
+    };
+    const dotted = () => {
+      if (!_RealGroovyAnalyzer.isIdentStart(text[i])) return false;
+      i++;
+      while (i < text.length && _RealGroovyAnalyzer.isWordChar(text[i])) i++;
+      while (i < text.length && text[i] === ".") {
+        i++;
+        if (!_RealGroovyAnalyzer.isIdentStart(text[i])) return false;
+        i++;
+        while (i < text.length && _RealGroovyAnalyzer.isWordChar(text[i])) i++;
+      }
+      return true;
+    };
+    if (!dotted()) return false;
+    while (i < text.length) {
+      const save = i;
+      spaced();
+      if (i >= text.length) {
+        i = save;
+        break;
+      }
+      if (text[i] !== ",") return false;
+      i++;
+      spaced();
+      if (!dotted()) return false;
+    }
+    return i >= text.length;
+  }
+  /** `/^[\s,.<>\[\]A-Za-z0-9_]*$/` as a char walk: parameter-list material only. */
+  static isParamMaterialOnly(text) {
+    for (let i = 0; i < text.length; i++) {
+      const c = text[i];
+      if (_RealGroovyAnalyzer.isRegexSpace(c, text.charCodeAt(i))) continue;
+      if (c === "," || c === "." || c === "<" || c === ">" || c === "[" || c === "]") continue;
+      if (c >= "A" && c <= "Z" || c >= "a" && c <= "z" || c >= "0" && c <= "9" || c === "_") continue;
+      return false;
+    }
+    return true;
+  }
+  looksLikeTypedClosureMisparse(juxtNode, nameNode, content) {
+    const nameText = nameNode.text.trim();
+    if (!_RealGroovyAnalyzer.isTypeCasedDottedName(nameText)) return false;
+    const argsNode = juxtNode.childForFieldName("args");
+    if (!argsNode) return false;
+    if (!_RealGroovyAnalyzer.isDottedIdentifierList(argsNode.text.trim())) return false;
+    if (content != null) {
+      const tail = content.slice(juxtNode.endIndex, juxtNode.endIndex + 160);
+      const arrow = tail.indexOf("->");
+      if (arrow >= 0) {
+        const between = tail.slice(0, arrow);
+        if (_RealGroovyAnalyzer.isParamMaterialOnly(between)) return true;
+      }
+    }
+    const parent = juxtNode.parent;
+    if (!parent) return false;
+    if (juxtNode.nextSibling?.type === "->") return true;
+    const siblings = [];
+    for (let i = 0; i < parent.namedChildCount; i++) {
+      const c = parent.namedChild(i);
+      if (c) siblings.push(c);
+    }
+    const idx = siblings.findIndex((s) => s.id === juxtNode.id);
+    if (idx === -1) return false;
+    const next = siblings[idx + 1];
+    if (next != null && next.type === "lambda_expression") return true;
+    if (idx === 0 && (parent.type === "closure" || parent.type === "block")) return true;
+    return false;
+  }
+  /**
+   * #841 round 14 (analyzer-side recovery): when a typed closure parameter
+   * list collides inside a chained call, tree-sitter's recovery emits the
+   * class as ROOT-LEVEL fragments — the `class` keyword token, the name
+   * `identifier`, the `super_interfaces` node, and the member declarations
+   * as siblings — instead of a class_declaration node. The walk therefore
+   * never pushes a class scope, and the file loses its class symbol, its
+   * implements edges, and every contains edge: methods extract but ride
+   * ownerless/"(script)" (measured: 0 classes and 0 contains edges on
+   * 160–470-line build-logic plugin files). The grammar fix for the
+   * underlying construct is closed off by measurement (§7f–§7q), so this
+   * pass reconstructs the ownership graph AFTER the walk:
+   *   1. the class symbol, from the root `class` token + name fragment;
+   *   2. implements edges + classHierarchy from the surviving
+   *      super_interfaces fragment;
+   *   3. ownerName/ownerKind on the surviving member symbols inside the
+   *      body region (the existing contains loop then emits class → member);
+   *   4. method symbols synthesized for degraded method headers (modifiers +
+   *      type + identifier + formal_parameters + `{` fragments) so the
+   *      methods whose wrapper was dropped rejoin the graph;
+   *   5. "(script)"-sourced calls/uses edges inside the region re-parented
+   *      to the class.
+   * Runs only on trees with a root-level ERROR and the class fragment
+   * shape, so clean trees cannot enter (the shapes exist only where the
+   * parser failed). Parse errors are NOT suppressed — the tree keeps its
+   * ERROR nodes; only the ownership graph is restored.
+   */
+  recoverDegradedClassShapes(rootNode, symbols, relationships, symbolMap, currentPackage) {
+    if (!rootNode.hasError) return;
+    const allKids = rootNode.children;
+    const kids = [];
+    for (const c of allKids) {
+      if (c) kids.push(c);
+    }
+    if (!kids.some((k) => k.type === "ERROR")) return;
+    for (let i = 0; i < kids.length; i++) {
+      if (kids[i].type !== "class") continue;
+      const nameNode = kids[i + 1];
+      if (!nameNode || nameNode.type !== "identifier") continue;
+      const name = nameNode.text;
+      const classToken = kids[i];
+      const startLine = classToken.startPosition.row + 1;
+      let j = i + 2;
+      const headerFragments = [];
+      while (j < kids.length && kids[j].type !== "{") {
+        headerFragments.push(kids[j]);
+        j++;
+      }
+      if (j >= kids.length) continue;
+      const openBrace = kids[j];
+      let closeIdx = -1;
+      for (let k = kids.length - 1; k > j; k--) {
+        if (kids[k].type === "}") {
+          closeIdx = k;
+          break;
+        }
+      }
+      const endLine = closeIdx >= 0 ? kids[closeIdx].endPosition.row + 1 : rootNode.endPosition.row + 1;
+      const bodyChildren = kids.slice(j + 1, closeIdx >= 0 ? closeIdx : kids.length);
+      if (symbols.some((s) => s.name === name && s.range?.startLine === startLine)) continue;
+      const typeFragments = /* @__PURE__ */ new Set(["generic_type", "type_identifier", "scoped_type_identifier", "void_type", "integral_type", "floating_point_type", "boolean_type", "array_type"]);
+      const memberKinds = /* @__PURE__ */ new Set([ASTEngine.SymbolKind.Method, ASTEngine.SymbolKind.Constructor, ASTEngine.SymbolKind.Property]);
+      const members = symbols.filter((s) => !s.ownerName && !s.metadata?.isAnonymousClass && memberKinds.has(s.kind) && s.range?.startLine != null && s.range.startLine >= startLine && s.range.startLine <= endLine);
+      const hasFieldDecl = bodyChildren.some((k) => k.type === "field_declaration");
+      let hasDegradedHeader = false;
+      for (let b = 0; b < bodyChildren.length - 1 && !hasDegradedHeader; b++) {
+        let p = b;
+        if (bodyChildren[b].type === "modifiers") p = b + 1;
+        const typeFrag = bodyChildren[p];
+        if (!typeFrag || !typeFragments.has(typeFrag.type)) continue;
+        const nameFrag = bodyChildren[p + 1];
+        if (!nameFrag || nameFrag.type !== "identifier") continue;
+        const fp = bodyChildren[p + 2];
+        const brace = bodyChildren[p + 3];
+        if (fp && fp.type === "formal_parameters" && brace && brace.type === "{") hasDegradedHeader = true;
+      }
+      if (members.length === 0 && !hasDegradedHeader && !hasFieldDecl) continue;
+      let visibility = "public";
+      let annotations = [];
+      const before = kids[i - 1];
+      if (before && before.type === "modifiers") {
+        for (let m = 0; m < before.namedChildCount; m++) {
+          const mc = before.namedChild(m);
+          if (!mc) continue;
+          const t = mc.text ?? "";
+          if (t === "private") visibility = "private";
+          else if (t === "protected") visibility = "protected";
+          if (mc.type === "annotation" || mc.type === "marker_annotation") {
+            const annName = this.findChild(mc, (n) => n.type === "identifier" || n.type === "scoped_identifier");
+            if (annName) {
+              const text = annName.text;
+              const dot = text.lastIndexOf(".");
+              annotations.push(dot === -1 ? text : text.slice(dot + 1));
+            }
+          }
+        }
+      }
+      for (const frag of headerFragments) {
+        if (frag.type !== "super_interfaces") continue;
+        for (const tid of this.collectTypeNodes(frag)) {
+          relationships.push({
+            source: name,
+            target: this.baseTypeName(tid),
+            type: ASTEngine.RelationshipType.Implements,
+            confidence: 1,
+            ...this.lineField(tid, frag),
+            metadata: { relationshipType: "implements" }
+          });
+        }
+      }
+      const fqn = currentPackage ? `${currentPackage}.${name}` : name;
+      const sym = {
+        name,
+        kind: ASTEngine.SymbolKind.Class,
+        comments: [],
+        range: {
+          // The measured body extent: from the opening brace (start overridden
+          // to the class keyword's line, #825 rule) to the closing brace token
+          // when one was found — NOT the whole root node (fragments are
+          // root-level children, so the root's range is the entire file).
+          ...this.nodeToRange(closeIdx >= 0 ? kids[closeIdx] : openBrace.parent ?? rootNode),
+          startLine,
+          startColumn: classToken.startPosition.column + 1
+        },
+        visibility,
+        decorators: annotations.length > 0 ? annotations : void 0,
+        metadata: { nodeType: "class_declaration_recovered", annotations }
+      };
+      symbols.push(sym);
+      symbolMap.set(fqn, sym);
+      symbolMap.set(name, sym);
+      for (const s of members) {
+        s.ownerName = name;
+        s.ownerKind = ASTEngine.SymbolKind.Class;
+        if (!s.visibility) s.visibility = "public";
+      }
+      for (let b = 0; b < bodyChildren.length - 1; b++) {
+        let p = b;
+        const mods = bodyChildren[b].type === "modifiers" ? bodyChildren[b] : null;
+        if (mods) p = b + 1;
+        const typeFrag = bodyChildren[p];
+        if (!typeFrag || !typeFragments.has(typeFrag.type)) continue;
+        const nameFrag = bodyChildren[p + 1];
+        if (!nameFrag || nameFrag.type !== "identifier") continue;
+        const mName = nameFrag.text;
+        const mLine = nameFrag.startPosition.row + 1;
+        if (symbols.some((s) => s.name === mName && s.range?.startLine === mLine)) continue;
+        let q = p + 2;
+        let paramNode = null;
+        const fp = bodyChildren[q];
+        if (fp && fp.type === "formal_parameters") {
+          paramNode = fp;
+          q++;
+        }
+        const bodyBrace = bodyChildren[q];
+        if (!bodyBrace || bodyBrace.type !== "{") continue;
+        const parameters = [];
+        if (paramNode) {
+          for (let pc = 0; pc < paramNode.namedChildCount; pc++) {
+            const par = paramNode.namedChild(pc);
+            if (!par || par.type !== "formal_parameter" && par.type !== "spread_parameter") continue;
+            const isSpread = par.type === "spread_parameter";
+            let pName = this.findChild(par, (n) => n.type === "identifier");
+            if (isSpread) {
+              const decl = this.findChild(par, (n) => n.type === "variable_declarator");
+              pName = decl ? this.findChild(decl, (n) => n.type === "identifier") : null;
+            }
+            const pType = this.findChild(par, (n) => n.type === "type_identifier" || n.type === "integral_type" || n.type === "floating_point_type" || n.type === "boolean_type" || n.type === "void_type" || n.type === "generic_type" || n.type === "array_type" || n.type === "scoped_type_identifier");
+            parameters.push({
+              name: pName?.text ?? "anonymous",
+              type: pType ? this.baseTypeName(pType) + (isSpread ? "[]" : "") : void 0
+            });
+          }
+        }
+        let mVisibility = "public";
+        if (mods) {
+          for (let m2 = 0; m2 < mods.namedChildCount; m2++) {
+            const mc2 = mods.namedChild(m2);
+            const t2 = mc2?.text ?? "";
+            if (t2 === "private") mVisibility = "private";
+            else if (t2 === "protected") mVisibility = "protected";
+          }
+        }
+        symbols.push({
+          name: mName,
+          kind: ASTEngine.SymbolKind.Method,
+          comments: [],
+          parameters: parameters.length > 0 ? parameters : void 0,
+          returnType: typeFragments.has(typeFrag.type) ? this.baseTypeName(typeFrag) : void 0,
+          range: {
+            ...this.nodeToRange(typeFrag),
+            // The method is written on its NAME's line (#825 rule).
+            startLine: mLine,
+            startColumn: nameFrag.startPosition.column + 1
+          },
+          visibility: mVisibility,
+          ownerName: name,
+          ownerKind: ASTEngine.SymbolKind.Class,
+          metadata: { nodeType: "method_declaration_recovered" }
+        });
+        b = q;
+      }
+      for (const rel of relationships) {
+        if (rel.source !== "(script)") continue;
+        if (rel.type !== ASTEngine.RelationshipType.Calls && rel.type !== ASTEngine.RelationshipType.Uses) continue;
+        const line = rel.line_number;
+        if (line == null || line < startLine || line > endLine) continue;
+        rel.source = name;
+      }
+      break;
+    }
+  }
+  findChild(node, predicate) {
+    const count = node.namedChildCount;
+    for (let i = 0; i < count; i++) {
+      const child = node.namedChild(i);
+      if (child && predicate(child)) return child;
+    }
+    return null;
+  }
+  findAllChildren(node, predicate) {
+    const out = [];
+    const count = node.namedChildCount;
+    for (let i = 0; i < count; i++) {
+      const child = node.namedChild(i);
+      if (child && predicate(child)) out.push(child);
+    }
+    return out;
+  }
+  nodeToRange(node) {
+    return {
+      startLine: node.startPosition.row + 1,
+      // 1-based columns, consistent with java/kotlin/scala (M14 consistency gate)
+      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 NAMES the relationship's target — never from the construct that merely
+   * contains it. Returns nothing at all when no node is available: #820/#821,
+   * a stored 0 is a claim that the relationship occurs on line 0.
+   */
+  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 — `@Service` decorates the class, it is not
+   * where the class is written. Measured on the pinned grammar, not assumed:
+   * `class_declaration` for `@Service\nclass Svc` has children
+   * `[modifiers@5, identifier@6, class_body@6]`, so the class symbol's line was
+   * the ANNOTATION line. Same shape and same rule as java's
+   * `declarationLineNode` and scala's `declarationLineNode` — one rule for the
+   * whole JVM family rather than three dialects of it.
+   */
+  /** True when the field node is the same declaration as a sibling method, parsed twice (M59 #825 follow-up: `static Sphere valueOf` + the `final Distance distance`/ctor split). Proof, not heuristic: two distinct same-line declarations must be `;`-separated, so a sibling method starting after the field with only whitespace between them is the same tokens parsed twice — the full-span method wins. */
+  isDuplicateParseField(node, content) {
+    const parent = node.parent;
+    if (!parent) return false;
+    for (let i = 0; i < parent.namedChildCount; i++) {
+      const s = parent.namedChild(i);
+      if (!s || s.id === node.id) continue;
+      if (s.type !== "method_declaration" && s.type !== "constructor_declaration" && s.type !== "function_definition") continue;
+      if (s.startPosition.row !== node.startPosition.row) continue;
+      if (s.startIndex <= node.endIndex) continue;
+      if (_RealGroovyAnalyzer.isWhitespaceOnly(content.slice(node.endIndex, s.startIndex))) return true;
+    }
+    return false;
+  }
+  // A symbol is anchored at the DECLARATION, not at the annotation above it.
+  //
+  // THIS RULE WAS REVERSED ON 2026-10-22, and the reversal is measured, not
+  // preferred. The old rule ("anchor at the FIRST ANNOTATION") was adopted
+  // against a hand-audited truth file that records the annotation's line:
+  //     @Slf4j  L18 / class Counter        truth 18, was 19
+  //     @Override L16 / String format(…)  truth 16, was 17
+  // and it claimed the family convention — "the java analyzer anchors a symbol
+  // at its annotation line via `annotationLine`, so groovy was the outlier".
+  //
+  // BOTH CLAIMS ARE MEASURED FALSE TODAY (script/m14/groovy-family-line-anchor-probe.ts,
+  // the same annotated shape through all four JVM analyzers, the annotation on
+  // the line BEFORE each declaration):
+  //
+  //   java    class@2  label@4  use@6      ← the DECLARATION's line
+  //   kotlin  class@2  label@4  use@6      ← the DECLARATION's line
+  //   scala   class@2  label@4  use@6      ← the DECLARATION's line
+  //   groovy  class@1  label@4  use@5      ← the ANNOTATION's line
+  //
+  // java's `annotationLine` is not what java's SYMBOL range uses (java anchors
+  // the symbol on the declaration and uses the annotation line for a
+  // DIFFERENT edge), and the truth file the old rule cited is stale for the
+  // whole JVM family — the same file is stale for the constructor name (see
+  // the constructor comment) and `bun script/m12/verify-analyzer.ts java` /
+  // `kotlin` report the constructor FN/FP pair at HEAD.
+  //
+  // THIS LANE'S OWN m14 FIXTURES record the DECLARATION's line and FORBID the
+  // annotation's line, so the old anchor is pinned as the pre-fix shape:
+  // groovy/lines-825 pins `contains[Wrapped->use] @26` and FORBIDS @25 (the
+  // `@Deprecated` line), `contains[Wrapped->label] @23`, and the class at 19;
+  // groovy/anonymous-body-overrides pins `overrides[anonymous_TypeCodec.bsonType->bsonType] @23`
+  // and `contains[anonymous_TypeCodec->bsonType] @23` where the `@Override` is
+  // on 22.
+  //
+  // A `modifiers` child is skipped in BOTH cases — annotation-carrying or not —
+  // so `private String label` and `final int hex` stay on their own line, which
+  // is what the already-correct property rows require.
+  /** True when this declaration carries at least one annotation (directly or in `modifiers`). */
+  declarationHasAnnotation(node) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (!c) continue;
+      if (c.type === "annotation" || c.type === "marker_annotation") return true;
+      if (c.type === "modifiers" && this.findChild(c, (n) => n.type === "annotation" || n.type === "marker_annotation")) return true;
+    }
+    return false;
+  }
+  declarationLineNode(node) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (!c) continue;
+      if (c.type === "modifiers") {
+        continue;
+      }
+      if (c.type === "annotation" || c.type === "marker_annotation") continue;
+      if (c.type === "line_comment" || c.type === "block_comment") continue;
+      return c;
+    }
+    return node;
+  }
+  /** The range of a SYMBOL (not of an import, an error or a raw node), anchored per `declarationLineNode`. */
+  symbolRange(node, nameNode) {
+    const decl = nameNode ?? this.declarationLineNode(node);
+    const base = this.nodeToRange(node);
+    return {
+      ...base,
+      startLine: decl.startPosition.row + 1,
+      startColumn: decl.startPosition.column + 1,
+      startIndex: decl.startIndex
+    };
+  }
+};
+export {
+  RealGroovyAnalyzer
+};