@backbencher/brain 0.0.0-stage → 0.1.1

package/dist/real-go-analyzer-UKGI43YS.js

@@ -0,0 +1,4126 @@
+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-go-analyzer.ts
+function stringIncludes(str, val) {
+  if (!str) return false;
+  return str.indexOf(val) !== -1;
+}
+function inArray(arr, val) {
+  if (!arr) return false;
+  for (let i = 0; i < arr.length; i++) {
+    if (arr[i] === val) return true;
+  }
+  return false;
+}
+function filterSymbols(symbols, predicate) {
+  const result = [];
+  if (!symbols) return result;
+  for (let i = 0; i < symbols.length; i++) {
+    if (predicate(symbols[i])) result.push(symbols[i]);
+  }
+  return result;
+}
+function mapSymbols(arr, mapper) {
+  const result = [];
+  if (!arr) return result;
+  for (let i = 0; i < arr.length; i++) {
+    result.push(mapper(arr[i]));
+  }
+  return result;
+}
+function someSymbol(arr, predicate) {
+  if (!arr) return false;
+  for (let i = 0; i < arr.length; i++) {
+    if (predicate(arr[i])) return true;
+  }
+  return false;
+}
+function findSymbol(arr, predicate) {
+  if (!arr) return void 0;
+  for (let i = 0; i < arr.length; i++) {
+    if (predicate(arr[i])) return arr[i];
+  }
+  return void 0;
+}
+function forEachSymbol(arr, fn) {
+  if (!arr) return;
+  for (let i = 0; i < arr.length; i++) {
+    fn(arr[i]);
+  }
+}
+function getObjectKeysLength(obj) {
+  if (!obj) return 0;
+  let count = 0;
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      count++;
+    }
+  }
+  return count;
+}
+var GO_SUB_UNIT_REASON = {
+  // The callee's LEAF name is recorded; the receiver or package that owns it is
+  // not, and a leaf is a per-file-analyzer limit rather than a property of the
+  // call. Measured endpoint resolution: 19.4% of `calls` targets bind to a
+  // symbol in the same file.
+  "calls|go_function_call": "callee_recorded_as_a_leaf_name_whose_owner_is_not_resolved_per_file",
+  "calls|go_package_scope_call": "callee_recorded_as_a_leaf_name_whose_owner_is_not_resolved_per_file",
+  // A selector read names the FIELD leaf. Whether the receiver is the declared
+  // type, an embedded one, or an interface value is not resolved here.
+  "uses|go_selector_use": "field_leaf_read_whose_receiver_type_is_not_resolved_per_file",
+  // Channel send/receive records the channel's leaf name; the direction is in
+  // `operationType` and the element type is not read.
+  "uses|go_channel_operation": "channel_leaf_read_without_its_element_type",
+  // A declared/return type position records the type's leaf. Measured: 32.0% of
+  // `references` targets bind within the file.
+  "references|declared_type": "declared_type_leaf_whose_declaring_file_is_out_of_scope",
+  "references|return_type": "declared_type_leaf_whose_declaring_file_is_out_of_scope",
+  // `struct { E }` promotes E's method set. Go has no inheritance declaration,
+  // so the edge records a promotion that the compiler resolves, not an
+  // extends-clause the author wrote. THE STORED TYPE IS `mixes_in` because that
+  // same fact IS the mixin contract — composition of E's IMPLEMENTATION into
+  // T's method set, no single base, no inheritance clause. The
+  // `go_struct_embedding` construct id is KEPT: metadata identifies the
+  // construct, so the label move is 1:1 and this reason still states the fact.
+  "mixes_in|go_struct_embedding": "promotion_by_embedding_not_a_declared_supertype",
+  "extends|go_interface_embedding": "interface_method_set_inclusion_not_a_declared_supertype",
+  // The target is an import PATH (`net/http`, `encoding/json`), which names a
+  // module and not any symbol this analyzer can bind.
+  "imports|*": "target_is_a_module_path_not_a_symbol",
+  // A composite literal's type is a real declared type, read from the tree.
+  "instantiates|go_composite_literal_construction": "type_read_from_a_composite_literal_whose_declaration_may_be_in_another_file",
+  // PascalCase naming is Go's constructor CONVENTION with no declaration behind
+  // it. Measured false-positive class: `instantiates bitSizeError -> Itoa` at
+  // src/strconv/number.go:285 is `strconv.Itoa`, a formatting function whose
+  // name merely starts upper-case.
+  "instantiates|go_instantiation": "pascal_case_name_is_a_constructor_convention_with_no_declaration",
+  "instantiates|go_package_scope_instantiation": "pascal_case_name_is_a_constructor_convention_with_no_declaration",
+  // ── THE BIND REASONS  — the same eleven facts, asked of a second question.
+  //
+  // The table above answers "WHY IS THIS EDGE BELOW 1.0". The D7 wall needs a
+  // different answer: "WHY DID THE ARBITER NOT BIND THIS EDGE's TARGET" — and
+  // those are NOT the same question, because an edge can be at confidence 1.0
+  // (the analyzer is certain the edge is real) and still have a target the
+  // arbiter cannot resolve to a declaration.
+  //
+  // MEASURED on the gql-gqlgen chunk (888 files, the gate's own run at the
+  // pre-claim analyzer): 3,820 wall rows carried NO reasonCode, and EVERY ONE
+  // OF THEM WAS confidence 1.0 — so the reasonCode publication loop, which
+  // skips `conf >= 1.0`, CANNOT reach them, and a reasonCode stamped there
+  // would break this analyzer's own invariant (a confidence-1.0 row must carry
+  // no code — see the census at script/m14/go9-census.ts).
+  //
+  // SO THE BIND REASON IS A SECOND FIELD, `metadata.bindReason`, published on
+  // every edge whose target is a REFERENCE to something rather than the
+  // declaration itself. `contains` is excluded: its target IS the declaration
+  // it contains, so there is no binding question to answer.
+  //
+  // The two fields share this table on purpose. One vocabulary, two questions.
+  // A per-type `*` fallback makes the publication COMPLETE BY CONSTRUCTION:
+  // no edge of a covered type can escape a named class, which is the property
+  // the D7 census needs.
+  //
+  // A used identifier is a plain name; the file that declares it is not read.
+  "uses|identifier_usage": "used_identifier_recorded_as_a_leaf_whose_declaring_file_is_out_of_scope",
+  // A goroutine's call and a deferred call are calls; their owner is not
+  // resolved per file, exactly as for a direct call.
+  "uses|go_goroutine": "goroutine_call_recorded_as_a_leaf_name_whose_owner_is_not_resolved_per_file",
+  "uses|go_defer": "deferred_call_recorded_as_a_leaf_name_whose_owner_is_not_resolved_per_file",
+  // An exported name is the package's own; the edge records the name alone, so
+  // which of the project's same-named exports it is, is not carried.
+  "exports|go_exported_identifier": "exported_name_recorded_as_a_leaf_whose_owning_package_is_not_the_target",
+  // An implemented interface is named by its leaf; the file that declares it is
+  // not read here.
+  "implements|go_interface_implementation": "implemented_interface_recorded_as_a_leaf_whose_declaring_file_is_out_of_scope",
+  // A promoted method is recorded with its qualified owner (`Type.Method`);
+  // the file declaring that type is not read.
+  "overrides|go_method_promotion_shadowing": "promoted_method_recorded_with_its_qualified_owner_whose_declaring_file_is_out_of_scope",
+  // A qualified type reference names a package and a type; the package's own
+  // file is not carried on the edge.
+  "references|reference_qualified": "qualified_type_reference_whose_declaring_file_is_out_of_scope",
+  // ── THE PER-TYPE FALLBACKS: the general truth for the type, used when a
+  // label of that type has no specific entry above. They make the bind
+  // publication complete: a NEW label of a covered type still gets a named
+  // class instead of escaping unclassified.
+  "calls|*": "callee_recorded_as_a_leaf_name_whose_owner_is_not_resolved_per_file",
+  "uses|*": "used_name_recorded_as_a_leaf_whose_declaring_file_is_out_of_scope",
+  "references|*": "declared_type_leaf_whose_declaring_file_is_out_of_scope",
+  "exports|*": "exported_name_recorded_as_a_leaf_whose_owning_package_is_not_the_target",
+  "extends|*": "embedded_name_recorded_as_a_promotion_rather_than_a_declared_supertype",
+  "implements|*": "implemented_interface_recorded_as_a_leaf_whose_declaring_file_is_out_of_scope",
+  "overrides|*": "promoted_method_recorded_with_its_qualified_owner_whose_declaring_file_is_out_of_scope",
+  "instantiates|*": "instantiated_name_recorded_as_a_leaf_whose_declaring_file_is_out_of_scope",
+  "mixes_in|*": "embedded_name_recorded_as_a_promotion_rather_than_a_declared_supertype",
+  // The rendered component is a template SYMBOL whose template-ness is read from
+  // its own constructor call (tree-sitter-go has no type resolution), and the
+  // execution is a method call — the render relation is inferred from those two
+  // facts rather than declared by the language, which is why this row is 0.9.
+  "renders|go_template_render": "render_relation_inferred_from_an_html_template_execution_and_the_template_symbols_own_construction"
+};
+var GO_STDLIB_SINGLE_SEGMENT = /* @__PURE__ */ new Set([
+  "bufio",
+  "bytes",
+  "cmp",
+  "context",
+  "crypto",
+  "embed",
+  "encoding",
+  "errors",
+  "expvar",
+  "flag",
+  "fmt",
+  "hash",
+  "html",
+  "image",
+  "io",
+  "iter",
+  "log",
+  "maps",
+  "math",
+  "mime",
+  "net",
+  "os",
+  "path",
+  "plugin",
+  "reflect",
+  "regexp",
+  "runtime",
+  "slices",
+  "sort",
+  "strconv",
+  "strings",
+  "structs",
+  "sync",
+  "syscall",
+  "testing",
+  "time",
+  "unicode",
+  "unique",
+  "unsafe",
+  "weak"
+]);
+var GO_STDLIB_TOP_LEVEL = /* @__PURE__ */ new Set([
+  "archive",
+  "bufio",
+  "bytes",
+  "cmp",
+  "compress",
+  "container",
+  "context",
+  "crypto",
+  "database",
+  "debug",
+  "embed",
+  "encoding",
+  "errors",
+  "expvar",
+  "flag",
+  "fmt",
+  "go",
+  "hash",
+  "html",
+  "image",
+  "index",
+  "io",
+  "iter",
+  "log",
+  "maps",
+  "math",
+  "mime",
+  "net",
+  "os",
+  "path",
+  "plugin",
+  "reflect",
+  "regexp",
+  "runtime",
+  "slices",
+  "sort",
+  "strconv",
+  "strings",
+  "structs",
+  "sync",
+  "syscall",
+  "testing",
+  "text",
+  "time",
+  "unicode",
+  "unique",
+  "unsafe",
+  "weak"
+]);
+function isGoStdlibModulePath(module) {
+  const first = module.split("/")[0];
+  return first.length > 0 && GO_STDLIB_TOP_LEVEL.has(first);
+}
+var GO_FRAMEWORK_RULES = [
+  {
+    name: "gin",
+    confidence: 1,
+    listed: true,
+    matches: (p) => stringIncludes(p, "gin-gonic/gin")
+  },
+  {
+    name: "echo",
+    confidence: 1,
+    listed: true,
+    matches: (p) => stringIncludes(p, "labstack/echo")
+  },
+  {
+    name: "fiber",
+    confidence: 1,
+    listed: true,
+    matches: (p) => stringIncludes(p, "gofiber/fiber")
+  },
+  {
+    name: "net_http",
+    // The only standard-library entry, and the only row that must NOT be a
+    // substring test: `net/http` is a complete path, and a substring match
+    // would also fire on a third-party module whose path merely contains it.
+    confidence: 0.8,
+    listed: true,
+    matches: (p) => p === "net/http" || stringIncludes(p, "net/http/")
+  },
+  {
+    name: "gorilla_mux",
+    confidence: 1,
+    listed: true,
+    matches: (p) => stringIncludes(p, "gorilla/mux")
+  },
+  {
+    name: "grpc",
+    confidence: 1,
+    listed: true,
+    matches: (p) => stringIncludes(p, "google.golang.org/grpc")
+  },
+  {
+    name: "testify",
+    confidence: 1,
+    listed: true,
+    matches: (p) => stringIncludes(p, "stretchr/testify")
+  },
+  {
+    name: "gorm",
+    confidence: 1,
+    listed: true,
+    matches: (p) => stringIncludes(p, "gorm.io/gorm")
+  },
+  {
+    name: "sqlx",
+    confidence: 1,
+    listed: true,
+    matches: (p) => stringIncludes(p, "jmoiron/sqlx")
+  },
+  {
+    name: "ent",
+    confidence: 1,
+    listed: true,
+    matches: (p) => stringIncludes(p, "entgo.io/ent")
+  },
+  {
+    name: "fx",
+    confidence: 1,
+    listed: true,
+    matches: (p) => p === "go.uber.org/fx" || stringIncludes(p, "go.uber.org/fx/")
+  },
+  {
+    name: "wire",
+    confidence: 1,
+    listed: true,
+    matches: (p) => stringIncludes(p, "google/wire")
+  },
+  {
+    name: "zap",
+    confidence: 1,
+    listed: true,
+    matches: (p) => p === "go.uber.org/zap" || stringIncludes(p, "go.uber.org/zap/")
+  },
+  {
+    name: "logrus",
+    confidence: 1,
+    listed: true,
+    matches: (p) => stringIncludes(p, "sirupsen/logrus")
+  },
+  {
+    name: "golang_extended",
+    // Category marker, not a framework — see the table's comment.
+    confidence: 1,
+    listed: false,
+    matches: (p) => p === "golang.org/x" || stringIncludes(p, "golang.org/x/")
+  }
+];
+function getUniqueStrings(arr) {
+  const seen = /* @__PURE__ */ Object.create(null);
+  const result = [];
+  if (!arr) return result;
+  for (let i = 0; i < arr.length; i++) {
+    if (!seen[arr[i]]) {
+      seen[arr[i]] = true;
+      result.push(arr[i]);
+    }
+  }
+  return result;
+}
+var RealGoAnalyzer = class {
+  /**
+   * the CALLEE node of each deduped call, keyed by the enclosing
+   * function's `startIndex` and then by the call text. The calls lane iterates
+   * `symbol.qualified_calls` — a deduped STRING list by design (M37 #604, GOD9)
+   * — so the node an edge's line comes from has to be recorded where the scan
+   * still holds it. Reset at the top of every `analyze()`: a `startIndex` is
+   * file-local, so a retained map would attribute another file's line.
+   */
+  goCallSites = /* @__PURE__ */ new Map();
+  /**
+   * The canonical signature text of each method symbol, keyed by the method
+   * node's `startIndex` (file-local, so it cannot collide) — see `goCallSites`
+   * for the same discipline. The pre-fix code re-derived it on EVERY
+   * comparison: `checkGoInterfaceImplementation` compares each interface method
+   * against every candidate method, and `collectGoPromotedMethods` re-derives it
+   * again in each of its two shadowing tests, so one pass over a file with I
+   * interfaces and C candidates rebuilt the same string O(I × C × methods) times
+   * — the second half of the superlinear implements cost described at the hoist
+   * site below. Reset per `analyze()` with the same reason: a `startIndex` is
+   * file-local, so a retained map would leak one file's signatures into
+   * another's comparison.
+   */
+  goSignatures = /* @__PURE__ */ new Map();
+  analyze(rootNode, content, filePath) {
+    const ctx = { filePath, content };
+    this.goCallSites = /* @__PURE__ */ new Map();
+    this.goSignatures = /* @__PURE__ */ new Map();
+    const symbols = [];
+    const relationships = [];
+    const imports = [];
+    const exports = [];
+    const errors = [];
+    if (rootNode.hasError) {
+      const stack = [rootNode];
+      while (stack.length > 0) {
+        const n = stack.pop();
+        if (n.type === "ERROR" || n.isMissing) {
+          errors.push({
+            message: "Brain Engine (Go): Bypassed resilient parser error node",
+            range: {
+              startLine: n.startPosition.row + 1,
+              startColumn: n.startPosition.column + 1,
+              endLine: n.endPosition.row + 1,
+              endColumn: n.endPosition.column + 1
+            },
+            severity: `warning`
+          });
+        }
+        for (let i = n.childCount - 1; i >= 0; i--) {
+          const child = n.child(i);
+          if (child) stack.push(child);
+        }
+      }
+    }
+    const packageClause = this.findGoPackageClause(rootNode);
+    const packageName = packageClause ? this.goPackageClauseName(packageClause) : void 0;
+    if (packageName && packageClause) {
+      symbols.push({
+        name: packageName,
+        kind: ASTEngine.SymbolKind.Module,
+        // The PACKAGE CLAUSE's own range, read from the node. The pre-fix code
+        // hand-built the range from the NAME LENGTH — `startLine: 1,
+        // startColumn: 1, startIndex: 0, endIndex: packageName.length + 8` —
+        // which is only right when the clause is the first thing in the file.
+        // Go puts a `//go:build` / `// +build` header ABOVE the clause, and
+        // 158 of the pinned corpora's 3,924 files and 2,462 of kubernetes's
+        // 17,848 do, so every byte of the published range pointed into the
+        // build-tag comment: the symbol claimed line 1, column 1, bytes 0..8.
+        // GO4's finding stands and is now structural rather than arithmetic —
+        // `nodeToRange` derives the exclusive `endIndex` and the 1-based
+        // `endColumn` from the node's own end position, and for a clause at
+        // byte 0 those are byte-identical to the old hand-built values
+        // (`endIndex: len+8`, `endColumn: len+9`), so the common case is
+        // unchanged output and the header case becomes correct.
+        range: this.nodeToRange(packageClause),
+        visibility: "public",
+        metadata: {
+          nodeType: "package_clause",
+          isGoPackage: true
+        }
+      });
+    }
+    this.extractGoSymbols(rootNode, symbols);
+    this.processGoImports(rootNode, imports);
+    const stdlibQualifiers = this.collectGoStdlibQualifiers(imports);
+    this.analyzeGoRelationships(rootNode, relationships, symbols, ctx, stdlibQualifiers);
+    this.analyzeGoTemplateRenders(rootNode, imports, relationships);
+    let invalidImportPathCount = 0;
+    for (const imp of imports) {
+      if ((imp.module ?? "").length === 0) {
+        invalidImportPathCount++;
+        continue;
+      }
+      const importModule = String(imp.module ?? "");
+      const moduleSegments = importModule.split("/");
+      const stdlibRoot = moduleSegments.length >= 2 ? moduleSegments[0] ?? "" : "";
+      const isMultiSegmentStdlib = stdlibRoot.length > 0 && stdlibRoot !== "." && stdlibRoot !== ".." && GO_STDLIB_TOP_LEVEL.has(stdlibRoot);
+      relationships.push({
+        source: packageName || filePath,
+        target: imp.module || "",
+        // The FAMILY'S first-class `imports` kind, not a `references` edge
+        // (#799 round). An import names a MODULE, not a symbol: with the edge
+        // labelled `references`, every import path landed in the lane's
+        // references target surface, and an import path is a string literal
+        // (`net/http`, `github.com/google/go-cmp/cmp`) whose separators — `/`,
+        // `.`, `-` — no Go declaration may contain. R10 asks whether a target is
+        // a NAME; the answer for a module specifier is that it is a dependency,
+        // and the family's label for a dependency is `imports` (c moved to it in
+        // #910; go's own requiredKinds has named `imports` since the wave). The
+        // references surface is now separator-free, so a future foreign spelling
+        // there fails R10 immediately instead of hiding behind a recorded
+        // import-path convention.
+        type: ASTEngine.RelationshipType.Imports,
+        confidence: 0.9,
+        // isImport:true + isGoImportDep keep the edge pinnable as the "imports"
+        // relationship kind by completeness section B, which reads the MARKER
+        // (script/m14/completeness-inventory.ts, section B) — so the kind is
+        // claimed twice over and the evidence tier stays import_based.
+        // the import_spec, whose line is the path's line for a
+        // single import and for each entry of a grouped one (the spec starts
+        // at its path — an alias would share the line).
+        ...imp.range?.startLine ? { line_number: imp.range.startLine } : {},
+        metadata: {
+          isGoImportDep: true,
+          isImport: true,
+          packageName: imp.metadata?.packageName,
+          // THE ONE EXTERNAL CLAIM AN IMPORT EDGE CAN CARRY, and it is a claim about the NAME'S
+          // ORIGIN that the corpus cannot falsify because it is not about the corpus: the module is
+          // a member of the Go standard library's own package set (`GO_STDLIB_SINGLE_SEGMENT`
+          // above). `isStdlib` is one of the gate's recognised EXTERNAL_KEYS, so this converts a
+          // silent hole into a STATED, verifiable claim — never into a resolution, and the rule
+          // reads it only where the target names nothing, so no `resolved` row can move.
+          //
+          // ATTACHED ONLY TO SINGLE-SEGMENT PATHS, because the rule reaches a multi-segment one
+          // (`encoding/json`) as a PATH: `pathLikeTarget` sends it to `externalUnverified`, which
+          // is a clause-1 failure exactly as `unresolved` is. Claiming there would move an edge
+          // from one failure column into another and make the table look better without answering
+          // anything — so it is not done. MEASURED on the 400-file stride: this covers 830 of the
+          // lane's 25,215 unresolved edges and all 830 verify; the other 24,385 are untouched.
+          ...GO_STDLIB_SINGLE_SEGMENT.has(imp.module ?? "") ? { isStdlib: true } : {},
+          // Multi-segment stdlib citation (ruled mechanism above; imports edges only). The root
+          // listed is the MATCHED first segment, so the claim's vocabulary is exactly what the
+          // closed set proved; `stdlibModule` is evidence kept beside the claim for a reviewer
+          // (not a claim key). `isStdlib` is deliberately NOT added here: one claim family per
+          // edge, and `externalClaimOf` resolves the namespace claim first anyway.
+          ...isMultiSegmentStdlib ? {
+            languageNamespace: [stdlibRoot],
+            languageNamespacePolicy: "strict-absent",
+            languageNamespaceSlash: true,
+            stdlibModule: importModule
+          } : {}
+        }
+      });
+    }
+    const frameworks = this.detectGoFrameworks(imports);
+    const patterns = this.detectGoPatterns(rootNode, symbols);
+    const seenExportNames = /* @__PURE__ */ new Set();
+    for (let i = 0; i < symbols.length; i++) {
+      const s = symbols[i];
+      const isPrivate = s.visibility === "private";
+      const isVar = s.kind === ASTEngine.SymbolKind.Variable;
+      const isMethod = s.kind === ASTEngine.SymbolKind.Method;
+      if (!isPrivate && !isVar && !isMethod && !s.ownerName && !seenExportNames.has(s.name)) {
+        seenExportNames.add(s.name);
+        exports.push({ name: s.name, kind: s.kind, range: s.range, visibility: s.visibility || "public" });
+      }
+    }
+    if (packageName) {
+      const packageScopeNames = this.collectGoPackageScopeNames(rootNode);
+      for (const e of exports) {
+        if (!e.name || e.name === packageName) continue;
+        if (!packageScopeNames.has(e.name)) continue;
+        relationships.push({
+          source: packageName,
+          target: e.name,
+          type: ASTEngine.RelationshipType.Exports,
+          confidence: 1,
+          // the exported declaration's own line.
+          ...e.range?.startLine ? { line_number: e.range.startLine } : {},
+          metadata: {
+            relationshipType: "go_exported_identifier",
+            exportForm: "capitalized_package_scope_name",
+            symbolKind: String(e.kind ?? "")
+          }
+        });
+      }
+    }
+    this.extractDeclaredTypeRefs(rootNode, relationships, stdlibQualifiers, symbols);
+    let r7DroppedEdges = 0;
+    {
+      const kept = [];
+      for (const r of relationships) {
+        if (String(r.source ?? "").length > 0 && String(r.target ?? "").length > 0) kept.push(r);
+        else r7DroppedEdges++;
+      }
+      if (r7DroppedEdges > 0) relationships.splice(0, relationships.length, ...kept);
+    }
+    this.classifyEvidenceTier(relationships);
+    const cyclomaticComplexity = this.calculateCyclomaticComplexity(rootNode);
+    return {
+      language: "go",
+      symbols,
+      relationships,
+      imports,
+      exports,
+      errors,
+      metadata: {
+        // GO6 (go review): `complexity` was the synthetic
+        // symbols+relationships heuristic while a real per-file
+        // cyclomaticComplexity sat beside it — the exact disease the
+        // family removed everywhere else. One contract: both report the
+        // real cyclomatic number.
+        complexity: cyclomaticComplexity,
+        linesOfCode: ctx.content.split("\n").length,
+        // GO26 (round 5): computed ONCE. The pre-fix code called the counter
+        // twice on the same node, and each call is a full recursive walk of the
+        // tree — one wasted whole-file traversal per file, for two keys of the
+        // same object literal that must agree by construction.
+        cyclomaticComplexity,
+        framework: frameworks[0]?.name,
+        // Primary framework
+        patterns,
+        // Go intelligence metadata
+        detectedFrameworks: mapSymbols(frameworks, (f) => f.name),
+        frameworkPatterns: this.getGoFrameworkPatterns(
+          mapSymbols(frameworks, (f) => f.name),
+          symbols
+        ),
+        architecturalInsights: this.generateGoArchitecturalInsights(symbols, relationships),
+        architecturalScore: this.calculateArchitecturalScore(symbols, relationships, patterns),
+        codeQuality: this.assessCodeQuality(symbols, relationships, patterns),
+        hasTypeInference: true,
+        hasFrameworkIntelligence: true,
+        analysisVersion: "3.0.1-go-iterative-stateless",
+        // R7's two counters, published because a suppression a consumer cannot see is a
+        // suppression it cannot trust: `r7DroppedEdges` is every relationship the choke point
+        // refused for an empty source or target, `invalidImportPathCount` is the import subset of
+        // them. A valid file reports 0/0, which is what makes a non-zero value evidence.
+        r7DroppedEdges,
+        invalidImportPathCount
+      }
+    };
+  }
+  /**
+   * #419-D evidence-tier classification for EVERY emitted relationship
+   * (family rules — mirrors rust/c/cpp so the go analyzer is not the one
+   * sibling that leaves edges untagged, keeping completeness section D
+   * achievable). Metadata tags already set by the emitter are left intact.
+   */
+  classifyEvidenceTier(relationships) {
+    for (const r of relationships) {
+      const md = r.metadata ?? (r.metadata = {});
+      if (md.evidenceClass) continue;
+      const t = String(r.type ?? "");
+      const conf = typeof r.confidence === "number" ? r.confidence : 1;
+      if (t === "contains" || t === "exports") {
+        md.evidenceClass = "structural";
+        continue;
+      }
+      if (t === "imports") {
+        md.evidenceClass = "import_based";
+        continue;
+      }
+      if (t === "references") {
+        md.evidenceClass = md.relationshipType === "declared_type" || md.relationshipType === "return_type" ? "reference_qualified" : "usage_contextual";
+        continue;
+      }
+      if (t === "extends" || t === "implements" || t === "overrides" || t === "mixes_in") {
+        md.evidenceClass = conf >= 1 ? "structural" : conf >= 0.85 ? "usage_contextual" : "inferred";
+        continue;
+      }
+      if (t === "instantiates") {
+        md.evidenceClass = "structural";
+        continue;
+      }
+      md.evidenceClass = "usage_contextual";
+    }
+    for (const r of relationships) {
+      const conf = typeof r.confidence === "number" ? r.confidence : 1;
+      if (conf >= 1) continue;
+      const md = r.metadata ?? (r.metadata = {});
+      if (typeof md.reasonCode === "string" && md.reasonCode.length) continue;
+      const t = String(r.type ?? "");
+      const label = String(md.relationshipType ?? "");
+      const code = GO_SUB_UNIT_REASON[`${t}|${label}`] ?? GO_SUB_UNIT_REASON[`${t}|*`];
+      if (code) md.reasonCode = code;
+    }
+    for (const r of relationships) {
+      const t = String(r.type ?? "");
+      if (t === "contains" || t === "renders") continue;
+      const md = r.metadata ?? (r.metadata = {});
+      if (typeof md.bindReason === "string" && md.bindReason.length) continue;
+      const label = String(md.relationshipType ?? "");
+      const code = GO_SUB_UNIT_REASON[`${t}|${label}`] ?? GO_SUB_UNIT_REASON[`${t}|*`];
+      if (code) md.bindReason = code;
+    }
+  }
+  /**
+   * The names this file declares at PACKAGE SCOPE, read from the grammar.
+   *
+   * WHY POSITION AND NOT THE SYMBOL TABLE. The lane publishes a function-local
+   * `type` as a symbol on purpose (the declared-type pass attributes that type's
+   * field types to it, so dropping the symbol would publish a `references` edge
+   * whose SOURCE names nothing), and such a symbol carries no `ownerName`. So
+   * the symbol table cannot answer "is this name in package scope" — nothing in a
+   * `type_spec` symbol distinguishes line 10 from line 2946. The declaration's
+   * position can, and position is what Go's own scoping rule is written about.
+   *
+   * WHY THE DIRECT CHILDREN OF `source_file`. That is the grammar's own
+   * statement of package scope: `package_clause`, `import_declaration`, and the
+   * declarations are its direct named children, and everything else is reachable
+   * only by descending into a `function_declaration`, `method_declaration` or
+   * `func_literal` body — a `block`, which is not a direct child of `source_file`
+   * by construction.
+   *
+   * WHY ONE LEVEL OF SPEC DESCENT AND NO FURTHER. `type_declaration`,
+   * `var_declaration` and `const_declaration` nest their `type_spec`,
+   * `type_alias`, `var_spec`/`const_spec` children directly, and those two
+   * levels are all a package-scope declaration needs. A nested
+   * `function_declaration` is unreachable from here because it would be a child
+   * of a `block`.
+   *
+   * `type_alias` IS a sibling of `type_spec`, not a variant of it:
+   * `type_declaration` holds a choice of the two, so `type WidgetList =
+   * []*Widget` arrives as `type_alias` and `type Widget struct{}` as
+   * `type_spec`. Handling only `type_spec` dropped every exported ALIAS, which
+   * the pre-existing fixture `exports-contract` caught on the first run — see
+   * the commit for that row.
+   *
+   * `_` is the BLANK identifier. It has no name and names no graph node, so it is
+   * left out: the answer to "is this name at package scope" is not yes.
+   *
+   * `Set<string>`, so a declaration named `constructor` or `toString` cannot be
+   * confused with an inherited member — the same Object.prototype hazard the
+   * interface and promotion passes defend against separately.
+   */
+  collectGoPackageScopeNames(root) {
+    const names = /* @__PURE__ */ new Set();
+    const addSpecNames = (spec) => {
+      for (let i = 0; i < spec.namedChildCount; i++) {
+        const c = spec.namedChild(i);
+        if (!c) continue;
+        if (c.type !== "identifier" && c.type !== "type_identifier") continue;
+        const text = String(c.text ?? "");
+        if (text.length === 0 || text === "_") continue;
+        names.add(text);
+      }
+    };
+    for (let i = 0; i < root.namedChildCount; i++) {
+      const d = root.namedChild(i);
+      if (!d) continue;
+      if (d.type === "function_declaration" || d.type === "method_declaration") {
+        const nm = d.childForFieldName?.("name");
+        if (nm) {
+          const text = String(nm.text ?? "");
+          if (text.length > 0) names.add(text);
+        }
+        continue;
+      }
+      if (d.type !== "type_declaration" && d.type !== "var_declaration" && d.type !== "const_declaration") continue;
+      for (let j = 0; j < d.namedChildCount; j++) {
+        const spec = d.namedChild(j);
+        if (!spec) continue;
+        if (spec.type === "type_spec" || spec.type === "type_alias") {
+          const nm = spec.childForFieldName?.("name");
+          if (nm) {
+            const text = String(nm.text ?? "");
+            if (text.length > 0) names.add(text);
+          }
+          continue;
+        }
+        if (spec.type === "var_spec" || spec.type === "const_spec") {
+          addSpecNames(spec);
+        }
+      }
+    }
+    return names;
+  }
+  /**
+   * M14 — declared-type reference graph. Go type positions: struct fields,
+   * parameter declarations (params, receivers, and the SECOND parameter_list
+   * holding return values), var/const specs, and composite literal types.
+   * qualified_type keeps its dotted pkg.Type form per the M14 dotted-name
+   * convention; pointer/array/map/etc. wrappers descend; builtins excluded.
+   */
+  extractDeclaredTypeRefs(rootNode, relationships, stdlibQualifiers = /* @__PURE__ */ new Map(), symbols = []) {
+    const ownPackageName = this.goOwnPackageName(rootNode);
+    const emitted = /* @__PURE__ */ new Set();
+    const BUILTINS = /* @__PURE__ */ new Set(["int", "int8", "int16", "int32", "int64", "uint", "uint8", "uint16", "uint32", "uint64", "uintptr", "float32", "float64", "complex64", "complex128", "string", "bool", "byte", "rune", "error", "any", "comparable"]);
+    const collectTypeNameNodes = (n, out, qualified) => {
+      if (n.type === "qualified_type" || n.type === "type_identifier") {
+        if (!BUILTINS.has(n.text) && !out.some((x) => x.text === n.text)) out.push(n);
+        return;
+      }
+      if (n.type === "block" || n.type === "expression_list") return;
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) collectTypeNameNodes(c, out, qualified);
+      }
+    };
+    const resolveSource = (start) => {
+      let p = start.type === "field_declaration" ? start : start.parent;
+      let sawTypeSpec = false;
+      while (p) {
+        if (!sawTypeSpec && (p.type === "type_spec" || p.type === "type_alias")) {
+          for (let i = 0; i < p.namedChildCount; i++) {
+            const c = p.namedChild(i);
+            if (c && c.type === "type_identifier") return c.text;
+          }
+          sawTypeSpec = true;
+        }
+        if (p.type === "function_declaration" || p.type === "method_declaration") {
+          for (let i = 0; i < p.namedChildCount; i++) {
+            const c = p.namedChild(i);
+            if (!c) continue;
+            if (p.type === "method_declaration" && c.type === "field_identifier" || p.type === "function_declaration" && c.type === "identifier") return c.text;
+          }
+        }
+        p = p.parent;
+      }
+      return "global";
+    };
+    const emit = (source, roots, relType) => {
+      for (const r of roots) {
+        if (!r) continue;
+        const names = [];
+        collectTypeNameNodes(r, names);
+        for (const t of names) {
+          const qualified = t.type === "qualified_type" ? t.text : void 0;
+          const dot = qualified ? qualified.lastIndexOf(".") : -1;
+          const target = qualified && dot > 0 ? qualified.slice(dot + 1) : t.text;
+          const key = `${source}|${target}|${relType}`;
+          if (emitted.has(key)) continue;
+          emitted.add(key);
+          const stdlibModule = qualified !== void 0 ? this.goStdlibTypeClaim(qualified, target, symbols, stdlibQualifiers, ownPackageName) : null;
+          relationships.push({
+            source,
+            target,
+            type: ASTEngine.RelationshipType.References,
+            confidence: 0.95,
+            ...this.nodeLine(t) ? { line_number: this.nodeLine(t) } : {},
+            metadata: {
+              relationshipType: relType,
+              ...qualified ? { qualifiedType: qualified } : {},
+              ...stdlibModule !== null ? { isStdlib: true, stdlibPath: stdlibModule } : {}
+            }
+          });
+        }
+      }
+    };
+    const isGoResultParameter = (decl) => {
+      const list = decl.parent;
+      if (!list || list.type !== "parameter_list") return false;
+      const owner = list.parent;
+      if (!owner) return false;
+      if (owner.type !== "function_declaration" && owner.type !== "method_declaration" && owner.type !== "method_spec" && owner.type !== "func_literal") return false;
+      const result = owner.childForFieldName("result");
+      return !!result && result.id === list.id;
+    };
+    const walk = (n) => {
+      switch (n.type) {
+        case "field_declaration": {
+          emit(resolveSource(n), [n], "declared_type");
+          break;
+        }
+        case "function_declaration":
+        case "method_declaration":
+        case "func_literal":
+        case "method_spec": {
+          const result = n.childForFieldName("result");
+          if (result && result.type !== "parameter_list") emit(resolveSource(result), [result], "return_type");
+          break;
+        }
+        case "parameter_declaration":
+        case "variadic_parameter_declaration": {
+          emit(resolveSource(n), [n], isGoResultParameter(n) ? "return_type" : "declared_type");
+          break;
+        }
+        case "var_spec":
+        case "const_spec": {
+          const inFunction = (x) => {
+            for (let q = x; q; q = q.parent) {
+              if (q.type === "function_declaration" || q.type === "method_declaration" || q.type === "func_literal") return true;
+            }
+            return false;
+          };
+          if (!inFunction(n)) {
+            const declared = [];
+            for (let i = 0; i < n.namedChildCount; i++) {
+              const c = n.namedChild(i);
+              if (c && c.type === "identifier" && String(c.text ?? "") !== "_") declared.push(String(c.text ?? ""));
+            }
+            if (declared.length === 0) emit(resolveSource(n), [n], "declared_type");
+            else for (const name of declared) emit(name, [n], "declared_type");
+          } else {
+            emit(resolveSource(n), [n], "declared_type");
+          }
+          break;
+        }
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) walk(c);
+      }
+    };
+    walk(rootNode);
+  }
+  /**
+   * PHASE 1: Extract Go symbols with proper Go semantics understanding
+   */
+  extractGoSymbols(node, symbols) {
+    const stack = [{ node, inFunction: false }];
+    while (stack.length > 0) {
+      const { node: current, inFunction } = stack.pop();
+      switch (current.type) {
+        case "function_declaration":
+          this.extractGoFunction(current, symbols);
+          break;
+        case "method_declaration":
+          this.extractGoMethod(current, symbols);
+          break;
+        case "type_declaration":
+          this.extractGoTypeDeclaration(current, symbols);
+          break;
+        case "var_declaration":
+        case "const_declaration":
+          if (!inFunction) this.extractGoVariables(current, symbols);
+          break;
+        case "import_declaration":
+          break;
+      }
+      const nextInFunction = inFunction || current.type === "block" || current.type === "function_declaration" || current.type === "method_declaration" || current.type === "func_literal";
+      for (let i = current.namedChildCount - 1; i >= 0; i--) {
+        const child = current.namedChild(i);
+        if (child) stack.push({ node: child, inFunction: nextInFunction });
+      }
+    }
+  }
+  /**
+   * Extract Go function declarations
+   */
+  extractGoFunction(node, symbols) {
+    const nameNode = node.childForFieldName("name");
+    if (!nameNode) return;
+    const functionName = nameNode.text;
+    const parameters = this.extractGoParameters(node);
+    const returnType = this.extractGoReturnType(node);
+    const qualifiedCalls = this.findGoFunctionCalls(node);
+    const bodyText = node.childForFieldName("body")?.text || "";
+    const apiContractPath = this.extractGoApiContractPathFromComments(node);
+    symbols.push({
+      name: functionName,
+      kind: ASTEngine.SymbolKind.Function,
+      range: this.nodeToRange(node),
+      parameters,
+      returnType,
+      qualified_calls: qualifiedCalls,
+      apiContractPath,
+      // Per-symbol cyclomatic complexity (family contract — rust/c/cpp all
+      // emit symbol.complexity; go was the only sibling that didn't, so the
+      // completeness section-C payload pin was impossible. Added go wave
+      // 2026-08-28, same counter as calculateCyclomaticComplexity).
+      complexity: this.calculateCyclomaticComplexity(node),
+      visibility: this.isGoExported(functionName) ? "public" : "private",
+      // A package-scope Go function has no owner, and that is a property of
+      // the language rather than of a missing argument: Go declares functions
+      // and methods at package scope only, and a nested function is a
+      // `func_literal`, which LocalsAreNotSymbols keeps out of the symbol set
+      // entirely. The two `!s.ownerName` constructor filters below are
+      // therefore correct on a fact about Go, not by accident of a dead
+      // parameter (GO26).
+      metadata: {
+        nodeType: node.type,
+        isGoFunction: true,
+        isExported: this.isGoExported(functionName),
+        hasErrorHandling: this.hasGoErrorHandling(bodyText),
+        isInit: functionName === "init",
+        hasGenerics: !!findSymbol(node.children, (c) => c && c.type === "type_parameter_list")
+      }
+    });
+  }
+  /**
+   * Extract Go method declarations (methods with receivers)
+   */
+  extractGoMethod(node, symbols) {
+    const nameNode = node.childForFieldName("name");
+    if (!nameNode) return;
+    const methodName = nameNode.text;
+    const receiver = this.extractGoReceiver(node);
+    const parameters = this.extractGoParameters(node);
+    const returnType = this.extractGoReturnType(node);
+    const qualifiedCalls = this.findGoFunctionCalls(node);
+    const bodyText = node.childForFieldName("body")?.text || "";
+    const apiContractPath = this.extractGoApiContractPathFromComments(node);
+    symbols.push({
+      name: methodName,
+      kind: ASTEngine.SymbolKind.Method,
+      range: this.nodeToRange(node),
+      parameters,
+      returnType,
+      qualified_calls: qualifiedCalls,
+      apiContractPath,
+      // Per-symbol cyclomatic complexity (family contract, go wave 2026-08-28).
+      complexity: this.calculateCyclomaticComplexity(node),
+      visibility: this.isGoExported(methodName) ? "public" : "private",
+      ownerName: receiver?.typeName,
+      ownerKind: ASTEngine.SymbolKind.Struct,
+      metadata: {
+        nodeType: node.type,
+        isGoMethod: true,
+        receiver,
+        receiverType: receiver?.typeName,
+        receiverKind: receiver?.isPointer ? "pointer" : "value",
+        isPointerReceiver: receiver?.isPointer || false,
+        isExported: this.isGoExported(methodName),
+        hasErrorHandling: this.hasGoErrorHandling(bodyText),
+        hasGenerics: !!findSymbol(node.children, (c) => c && c.type === "type_parameter_list")
+      }
+    });
+  }
+  /**
+   * Extract Go type declarations (structs, interfaces, type aliases)
+   */
+  extractGoTypeDeclaration(node, symbols) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const typeSpec = node.namedChild(i);
+      if (typeSpec?.type === "type_spec" || typeSpec?.type === "type_alias") {
+        this.extractGoTypeSpec(typeSpec, symbols);
+      }
+    }
+  }
+  /**
+   * Extract individual type specifications (struct, interface, etc.)
+   */
+  extractGoTypeSpec(node, symbols) {
+    const nameNode = node.childForFieldName("name");
+    if (!nameNode) return;
+    const typeName = nameNode.text;
+    const typeNode = node.childForFieldName("type");
+    if (!typeNode) return;
+    const typeParamsNode = findSymbol(node.children, (c) => c && c.type === "type_parameter_list");
+    const hasGenerics = !!typeParamsNode;
+    let kind;
+    let isInterface = false;
+    switch (typeNode.type) {
+      case "struct_type":
+        kind = ASTEngine.SymbolKind.Struct;
+        break;
+      case "interface_type":
+        kind = ASTEngine.SymbolKind.Interface;
+        isInterface = true;
+        break;
+      default:
+        kind = ASTEngine.SymbolKind.Type;
+    }
+    symbols.push({
+      name: typeName,
+      kind,
+      range: this.nodeToRange(node),
+      visibility: this.isGoExported(typeName) ? "public" : "private",
+      metadata: {
+        nodeType: node.type,
+        goType: typeNode.type,
+        isInterface,
+        isStruct: typeNode.type === "struct_type",
+        isGoStruct: typeNode.type === "struct_type",
+        isExported: this.isGoExported(typeName),
+        isTypeAlias: node.type === "type_alias",
+        hasGenerics
+      }
+    });
+    if (typeNode.type === "struct_type") {
+      this.extractStructFields(typeNode, symbols, typeName);
+    } else if (typeNode.type === "interface_type") {
+      this.extractInterfaceMethods(typeNode, symbols, typeName);
+    }
+  }
+  /**
+   * Extract struct fields
+   */
+  extractStructFields(structNode, symbols, structName) {
+    for (let i = 0; i < structNode.namedChildCount; i++) {
+      const child = structNode.namedChild(i);
+      if (child?.type === "field_declaration_list") {
+        for (let j = 0; j < child.namedChildCount; j++) {
+          const fieldDecl = child.namedChild(j);
+          if (fieldDecl?.type === "field_declaration") {
+            const fieldTypeNode = fieldDecl.childForFieldName("type");
+            const declaredNameNodes = [];
+            const seenFieldStart = /* @__PURE__ */ new Set();
+            const addDeclaredName = (n) => {
+              if (!n) return;
+              const at = n.startIndex ?? -1;
+              if (seenFieldStart.has(at)) return;
+              seenFieldStart.add(at);
+              declaredNameNodes.push(n);
+            };
+            addDeclaredName(fieldDecl.childForFieldName("name"));
+            for (let k = 0; k < fieldDecl.namedChildCount; k++) {
+              const c = fieldDecl.namedChild(k);
+              if (c && c.type === "field_identifier") addDeclaredName(c);
+            }
+            const fieldNameNodes = declaredNameNodes.filter((n) => n.text !== "_");
+            const hasDeclaredName = declaredNameNodes.length > 0;
+            const tagNode = fieldDecl.childForFieldName("tag");
+            let structTags = /* @__PURE__ */ Object.create(null);
+            if (tagNode) {
+              const tagText = this.stripRawStringDelimiters(tagNode.text);
+              structTags = this.parseStructTags(tagText);
+            }
+            if (!hasDeclaredName && fieldTypeNode) {
+              const embeddedName = this.goEmbeddedFieldName(fieldTypeNode);
+              if (embeddedName) {
+                symbols.push({
+                  name: embeddedName,
+                  kind: ASTEngine.SymbolKind.Property,
+                  range: this.nodeToRange(fieldTypeNode),
+                  returnType: fieldTypeNode.text,
+                  visibility: this.isGoExported(embeddedName) ? "public" : "private",
+                  ownerName: structName,
+                  ownerKind: ASTEngine.SymbolKind.Struct,
+                  metadata: {
+                    structTags: getObjectKeysLength(structTags) > 0 ? structTags : void 0,
+                    nodeType: fieldDecl.type,
+                    isStructField: true,
+                    fieldType: fieldTypeNode.text,
+                    isExported: this.isGoExported(embeddedName),
+                    isEmbeddedField: true,
+                    embeddedField: fieldTypeNode.text
+                  }
+                });
+              }
+            }
+            for (const fieldNameNode of fieldNameNodes) {
+              symbols.push({
+                name: fieldNameNode.text,
+                kind: ASTEngine.SymbolKind.Property,
+                // The FIELD's own span, not the whole declaration: `A, B int`
+                // names two fields at two positions, and a consumer that jumps
+                // to `B` must land on `B` (#919's range rule).
+                range: this.nodeToRange(fieldNameNode),
+                returnType: fieldTypeNode?.text,
+                visibility: this.isGoExported(fieldNameNode.text) ? "public" : "private",
+                ownerName: structName,
+                ownerKind: ASTEngine.SymbolKind.Struct,
+                metadata: {
+                  structTags: getObjectKeysLength(structTags) > 0 ? structTags : void 0,
+                  nodeType: fieldDecl.type,
+                  isStructField: true,
+                  fieldType: fieldTypeNode?.text,
+                  isExported: this.isGoExported(fieldNameNode.text),
+                  // #889: this field shares its declaration with others
+                  groupedFieldDeclaration: fieldNameNodes.length > 1
+                }
+              });
+            }
+          }
+        }
+        break;
+      }
+    }
+  }
+  /**
+   * The NAME an embedded field declares.
+   *
+   * Go's spec: "A field declared with a type but no explicit field name is
+   * called an embedded field ... The unqualified type name acts as the field
+   * name." So `io.Reader` declares a field `Reader`, `*S2` declares `S2`, and
+   * `T[P]` declares `T` — the same LEAF rule the embedded-INTERFACE path in
+   * `extractInterfaceMethods` already applies. Wrappers are transparent; only
+   * the leaf names the field.
+   */
+  goEmbeddedFieldName(typeNode) {
+    let cur = typeNode;
+    for (let guard = 0; guard < 8 && cur; guard++) {
+      const t = cur.type;
+      if (t === "pointer_type") {
+        cur = (cur.namedChildCount > 0 ? cur.namedChild(0) : void 0) ?? void 0;
+        continue;
+      }
+      if (t === "generic_type") {
+        cur = (cur.namedChildCount > 0 ? cur.namedChild(0) : void 0) ?? void 0;
+        continue;
+      }
+      break;
+    }
+    if (!cur) return void 0;
+    if (cur.type !== "type_identifier" && cur.type !== "qualified_type") return void 0;
+    const raw = cur.text;
+    const dot = raw.lastIndexOf(".");
+    const leaf = dot !== -1 ? raw.slice(dot + 1) : raw;
+    return this.isPlainGoIdentifier(leaf) ? leaf : void 0;
+  }
+  /**
+   * Extract interface methods
+   */
+  extractInterfaceMethods(interfaceNode, symbols, interfaceName) {
+    for (let i = 0; i < interfaceNode.namedChildCount; i++) {
+      const method = interfaceNode.namedChild(i);
+      if (method?.type === "method_spec") {
+        const methodName = method.childForFieldName("name");
+        if (methodName) {
+          const parameters = this.extractGoMethodSpecParameters(method);
+          const returnType = this.extractGoMethodSpecReturnType(method);
+          symbols.push({
+            name: methodName.text,
+            kind: ASTEngine.SymbolKind.Method,
+            range: this.nodeToRange(method),
+            isAbstract: true,
+            // Interface methods are abstract
+            parameters,
+            returnType,
+            visibility: this.isGoExported(methodName.text) ? "public" : "private",
+            ownerName: interfaceName,
+            ownerKind: ASTEngine.SymbolKind.Interface,
+            metadata: {
+              nodeType: method.type,
+              isInterfaceMethod: true,
+              isExported: this.isGoExported(methodName.text)
+            }
+          });
+        }
+        continue;
+      }
+      if (method?.type === "constraint_elem") {
+        const embeddedNode = method.namedChildCount > 0 ? method.namedChild(0) : void 0;
+        if (embeddedNode && (embeddedNode.type === "type_identifier" || embeddedNode.type === "qualified_type")) {
+          const rawText = embeddedNode.text;
+          const leaf = rawText.lastIndexOf(".") !== -1 ? rawText.slice(rawText.lastIndexOf(".") + 1) : rawText;
+          if (leaf && this.isPlainGoIdentifier(leaf)) {
+            symbols.push({
+              name: leaf,
+              kind: ASTEngine.SymbolKind.Interface,
+              range: this.nodeToRange(method),
+              visibility: "public",
+              ownerName: interfaceName,
+              ownerKind: ASTEngine.SymbolKind.Interface,
+              metadata: {
+                nodeType: method.type,
+                isEmbeddedInterface: true,
+                embeddedInterface: rawText
+              }
+            });
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Extract Go variables and constants
+   */
+  extractGoVariables(node, symbols) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const spec = node.namedChild(i);
+      if (spec?.type === "var_spec" || spec?.type === "const_spec") {
+        const nameNodes = [];
+        for (let j = 0; j < spec.namedChildCount; j++) {
+          const c = spec.namedChild(j);
+          if (c && c.type === "identifier" && c.text !== "_") nameNodes.push(c);
+        }
+        if (nameNodes.length > 0) {
+          const isConst = spec.type === "const_spec";
+          for (const nameNode of nameNodes) {
+            if (!nameNode) continue;
+            symbols.push({
+              name: nameNode.text,
+              kind: isConst ? ASTEngine.SymbolKind.Constant : ASTEngine.SymbolKind.Variable,
+              // The NAME's own span, not the whole `var_spec` — the same
+              // #919 range rule the struct-field path applies (and the reason
+              // it exists: `A, B int` names two fields at two positions, and a
+              // consumer that jumps to `B` must land on `B`). The var/const
+              // path kept the declaration's range, so on
+              // `var alpha,\n\tbeta int` BOTH names reported `3:5` — `beta`'s
+              // own position never appeared anywhere in the index.
+              range: this.nodeToRange(nameNode),
+              visibility: this.isGoExported(nameNode.text) ? "public" : "private",
+              metadata: {
+                nodeType: spec.type,
+                isConst,
+                isExported: this.isGoExported(nameNode.text)
+              }
+            });
+          }
+        }
+      }
+    }
+  }
+  // HELPER METHODS
+  /** GO3: file has a dot-import (`import . "fmt"`) — bare identifiers may
+   *  name dot-imported package members, which no local symbol can resolve.
+   *  Calls resolve leniently (documented); bare READS stay strict. */
+  hasGoDotImport(rootNode) {
+    const stack = [rootNode];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "import_spec") {
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (c && c.type === "dot") return true;
+        }
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return false;
+  }
+  /** GO1: identifiers under a qualified_type (`pkg.Foo`) name types, never
+   *  values — the composite-literal and declared-type passes own those. */
+  hasGoQualifiedAncestor(node) {
+    let cur = node.parent;
+    while (cur) {
+      if (cur.type === "qualified_type") return true;
+      if (cur.type === "call_expression" || cur.type === "field_declaration" || cur.type === "function_declaration" || cur.type === "method_declaration" || cur.type === "block" || cur.type === "composite_literal" || cur.type === "var_spec" || cur.type === "const_spec" || cur.type === "short_var_declaration" || cur.type === "assignment_statement") return false;
+      cur = cur.parent;
+    }
+    return false;
+  }
+  nodeToRange(node) {
+    return {
+      startLine: node.startPosition.row + 1,
+      startColumn: node.startPosition.column + 1,
+      endLine: node.endPosition.row + 1,
+      endColumn: node.endPosition.column + 1,
+      startIndex: node.startIndex,
+      endIndex: node.endIndex
+    };
+  }
+  /**
+   * Is a Go identifier EXPORTED?
+   *
+   * Go's spec: "An identifier is exported if the first character of the
+   * identifier's name is a Unicode upper case letter" — the rule is
+   * `unicode.IsUpper`, NOT an ASCII range. The old test here was
+   * `name[0] >= "A" && name[0] <= "Z"`, so every legal Go identifier with a
+   * non-ASCII head (`Ünï`, `Ö`, `Ñ`) was published `visibility: "private"`,
+   * which fails the PHASE-5 export predicate below and removed it from the
+   * public-API list the product serves. Go identifiers may use any Unicode
+   * letter (spec, Identifiers), so this was a real hole in the export
+   * surface, not a cosmetic classification.
+   *
+   * The implementation is a no-regex upper-case test on the FIRST CODE POINT
+   * using the JS runtime's own Unicode case mappings (the same ICU tables the
+   * grammar's identifier rule is written against):
+   *
+   *     c is an UPPER CASE letter  <=>  toUpperCase(c) === c  AND  toLowerCase(c) !== c
+   *
+   * which is exactly `unicode.IsUpper`'s definition — Go's own spec words the
+   * category test as "the uppercase version of the letter is different from
+   * its lowercase version". Spot-checked against the categories that matter:
+   * `A` upper, `a` not, `Ü` upper, `ü` not, `ß` not (Go: Ll, not Lu), CJK
+   * `U+4E2D` not (Lo, not Lu), titlecase `Dž` not (Lt, not Lu). The only residual is
+   * a code point the runtime's tables do not know, which is then not-upper —
+   * the conservative direction (a symbol stays private rather than being
+   * published as public API on a guess).
+   */
+  isGoExported(name) {
+    if (!name) return false;
+    const c = String.fromCodePoint(name.codePointAt(0));
+    if (c.length === 0) return false;
+    if (c === "\uFFFD" && name.charCodeAt(0) >= 55296 && name.charCodeAt(0) <= 57343) return false;
+    const upper = c.toUpperCase();
+    if (upper !== c) return false;
+    return c.toLowerCase() !== c;
+  }
+  extractGoApiContractPathFromComments(node) {
+    let prevNode = node.previousNamedSibling;
+    const comments = [];
+    while (prevNode && prevNode.type === "comment") {
+      comments.unshift(prevNode.text);
+      prevNode = prevNode.previousNamedSibling;
+    }
+    for (const comment of comments) {
+      const router = this.parseRouterAnnotation(comment);
+      if (router) return router;
+    }
+    return void 0;
+  }
+  extractGoReceiver(methodNode) {
+    let receiverList = null;
+    for (let i = 0; i < methodNode.namedChildCount; i++) {
+      const child = methodNode.namedChild(i);
+      if (child?.type === "parameter_list") {
+        receiverList = child;
+        break;
+      }
+    }
+    if (!receiverList) return void 0;
+    const receiverParam = receiverList.namedChild(0);
+    if (!receiverParam || receiverParam.type !== "parameter_declaration") return void 0;
+    const receiverName = receiverParam.childForFieldName("name");
+    const receiverType = receiverParam.childForFieldName("type");
+    if (!receiverType) return void 0;
+    const typeName = receiverType.text;
+    const isPointer = typeName.startsWith("*");
+    let actualTypeName = isPointer ? typeName.substring(1) : typeName;
+    const lt = actualTypeName.indexOf("[");
+    if (lt > 0) actualTypeName = actualTypeName.slice(0, lt);
+    return {
+      name: receiverName?.text || "",
+      typeName: actualTypeName,
+      isPointer
+    };
+  }
+  extractGoParameters(node) {
+    const parameters = [];
+    let paramLists = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child?.type === "parameter_list") {
+        paramLists.push(child);
+      }
+    }
+    const targetParamList = node.type === "method_declaration" ? paramLists[1] : paramLists[0];
+    if (!targetParamList) return parameters;
+    for (let i = 0; i < targetParamList.namedChildCount; i++) {
+      const param = targetParamList.namedChild(i);
+      if (param?.type === "parameter_declaration" || param?.type === "variadic_parameter_declaration") {
+        const isVariadic = param.type === "variadic_parameter_declaration";
+        const nameNodes = [];
+        for (let j = 0; j < param.namedChildCount; j++) {
+          const c = param.namedChild(j);
+          if (c && c.type === "identifier") nameNodes.push(c);
+        }
+        const typeNode = param.childForFieldName("type");
+        if (nameNodes.length > 0) {
+          for (const nameNode of nameNodes) {
+            if (!nameNode) continue;
+            parameters.push({
+              name: nameNode.text,
+              type: typeNode?.text,
+              isOptional: false,
+              // Go doesn't have optional parameters
+              ...isVariadic ? { isVariadic: true } : {}
+            });
+          }
+        } else if (typeNode) {
+          parameters.push({
+            name: `arg${parameters.length}`,
+            type: typeNode?.text,
+            isOptional: false,
+            // Go doesn't have optional parameters
+            ...isVariadic ? { isVariadic: true } : {}
+          });
+        }
+      }
+    }
+    return parameters;
+  }
+  extractGoReturnType(node) {
+    const resultNode = node.childForFieldName("result");
+    if (resultNode) {
+      if (resultNode.type === "parameter_list") {
+        const types = [];
+        for (let i = 0; i < resultNode.namedChildCount; i++) {
+          const p = resultNode.namedChild(i);
+          if (!p || p.type !== "parameter_declaration") continue;
+          const t = p.childForFieldName("type");
+          if (!t) continue;
+          let names = 0;
+          for (let j = 0; j < p.namedChildCount; j++) {
+            const c = p.namedChild(j);
+            if (c && c.type === "identifier") names++;
+          }
+          for (let k = 0; k < Math.max(1, names); k++) types.push(t.text);
+        }
+        if (types.length === 1) return types[0];
+        if (types.length > 1) return `(${types.join(", ")})`;
+        return resultNode.text;
+      }
+      return resultNode.text;
+    }
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child && inArray(
+        [
+          "type_identifier",
+          "qualified_type",
+          "pointer_type",
+          "slice_type",
+          "array_type",
+          "map_type",
+          "channel_type",
+          "function_type"
+        ],
+        child.type
+      )) {
+        return child.text;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * the 1-based line of a syntax node, or `undefined` when the
+   * node is absent. Never 0 — a site that cannot be named is OMITTED from the
+   * edge (the #820 rule), so a reader can tell "no line" from "line 1".
+   */
+  nodeLine(node) {
+    if (!node || !node.startPosition || typeof node.startPosition.row !== "number") return void 0;
+    return node.startPosition.row + 1;
+  }
+  /**
+   * the node that NAMES a call. A `selector_expression` starts at
+   * its RECEIVER, and a receiver-continued chain is valid Go — `.` does not
+   * insert a semicolon, so `builder.` + newline + `Reset()` parses — which makes
+   * the selector's own start the wrong site exactly as the c lane measured on a
+   * newline-continued function-pointer call. The `field` child is the leaf the
+   * edge's target is built from, so it is the leaf that carries the line.
+   */
+  goCalleeNameNode(funcNode) {
+    if (!funcNode) return void 0;
+    if (funcNode.type === "selector_expression") {
+      return funcNode.childForFieldName("field") ?? funcNode;
+    }
+    return funcNode;
+  }
+  /**
+   * the callee leaf of a STATEMENT-level call — `defer`/`go`
+   * statements. The statement starts at its keyword (and `defer` does not insert
+   * a semicolon, so `defer` + newline + `cleanup()` is valid Go), so the keyword
+   * is not where the target is named.
+   */
+  goStatementCalleeNode(node) {
+    const callExpr = this.findChildByType(node, "call_expression");
+    return callExpr ? this.goCalleeNameNode(callExpr.childForFieldName("function")) : void 0;
+  }
+  findGoFunctionCalls(functionNode) {
+    const calls = [];
+    const sites = /* @__PURE__ */ new Map();
+    const seen = /* @__PURE__ */ new Set();
+    const bodyNode = functionNode.childForFieldName("body");
+    if (bodyNode) {
+      const stack = [bodyNode];
+      while (stack.length > 0) {
+        const node = stack.pop();
+        if (node.type === "call_expression") {
+          const funcNode = node.childForFieldName("function");
+          if (funcNode) {
+            const callExpression = this.buildGoCallExpression(funcNode);
+            if (callExpression && !this.isGoBuiltin(callExpression) && !seen.has(callExpression)) {
+              seen.add(callExpression);
+              calls.push(callExpression);
+              sites.set(callExpression, this.goCalleeNameNode(funcNode) ?? funcNode);
+            }
+          }
+        }
+        for (let i = node.namedChildCount - 1; i >= 0; i--) {
+          const child = node.namedChild(i);
+          if (child) stack.push(child);
+        }
+      }
+    }
+    this.goCallSites.set(functionNode.startIndex, sites);
+    return calls;
+  }
+  buildGoCallExpression(funcNode) {
+    switch (funcNode.type) {
+      case "identifier":
+        return funcNode.text;
+      case "selector_expression":
+        return this.buildGoSelectorExpression(funcNode);
+      default:
+        return void 0;
+    }
+  }
+  buildGoSelectorExpression(node) {
+    const object = node.childForFieldName("operand");
+    const field = node.childForFieldName("field");
+    if (!object || !field) return node.text;
+    const objectText = object.type === "selector_expression" ? this.buildGoSelectorExpression(object) : object.text;
+    return `${objectText}.${field.text}`;
+  }
+  isGoBuiltin(call) {
+    const builtins = [
+      "make",
+      "new",
+      "len",
+      "cap",
+      "append",
+      "copy",
+      "delete",
+      "panic",
+      "recover",
+      "print",
+      "println",
+      "close"
+    ];
+    const segs = call.split(".");
+    return inArray(builtins, segs[segs.length - 1]);
+  }
+  /**
+   * Resolve a goroutine/defer call target through the SAME bare-call symbol
+   * contract as analyzeGoFunctionCalls: package-qualified (has a dot) emits
+   * the leaf unconditionally; bare names emit only if they name an in-file
+   * declared function/method symbol. This drops closure-variable callees
+   * (`go done()`, `defer release()` where done/release are var-assigned
+   * funcs, NOT declared symbols) so goroutine/defer edges stay consistent
+   * with the analyzer's own call resolution and with the differential
+   * oracle — which derives only declared-function + qualified leaves.
+   * GO3: with a dot-import in the file, bare names may be dot-imported
+   * members — resolve leniently (besides builtins, filtered by callers).
+   */
+  /**
+   * Is this symbol a name a BARE call expression in this file could resolve to?
+   *
+   * A Go `method_spec` is published as `kind: Method` (it is a method
+   * declaration, in an interface body), and both the bare-call resolver and the
+   * package-scope-call predicate accepted it. So a name that exists in the file
+   * ONLY as an interface method — `type I interface{ Handle(x int) error }`
+   * with no `func Handle` anywhere — resolved as a package-scope callable and
+   * the analyzer emitted `calls global -> Handle`.
+   *
+   * That edge is a FABRICATION, and the differential called it one
+   * (`UNEXPLAINED`): the F5 oracle's `declaredFns` is built from
+   * `function_declaration` + `method_declaration` only, because those are the
+   * only two forms a bare callee can name in Go. A `method_spec` is not in
+   * scope as a package identifier at all — `Handle(1)` in that file does not
+   * compile. The two sides disagreed, which is the C5 asymmetry class (the
+   * mirror-image defect the lane hit in round 4), and the corpora could not
+   * see it: a file that declares an interface method and calls that name bare
+   * is not a shape either pinned corpus happens to contain.
+   *
+   * The rule is one predicate, applied at all three call-resolution sites, so
+   * the resolver and the two go/defer handlers cannot drift apart again.
+   */
+  isGoPackageCallable(s) {
+    if (s.kind !== ASTEngine.SymbolKind.Function && s.kind !== ASTEngine.SymbolKind.Method) return false;
+    if (s.metadata?.isInterfaceMethod) return false;
+    return true;
+  }
+  isGoResolvableCallTarget(target, symbols, dotImported = false) {
+    if (!target) return false;
+    if (target.indexOf(".") !== -1) return true;
+    if (dotImported) return true;
+    return someSymbol(symbols, (s) => this.isGoPackageCallable(s) && s.name === target);
+  }
+  /**
+   * Resolve the callable LEAF name of a callee node, for goroutine/defer/
+   * channel handlers. Anonymous func-literal callees (`go func(){...}()`,
+   * `defer func(){...}()`) and non-named callees have NO static name and
+   * must be skipped — the pre-fix handlers returned the whole func-literal
+   * text / "anonymous_closure", fabricating garbage calls targets (found
+   * #261-family Go wave 2026-08-28, same class as Rust's `(self.0)` fix).
+   * Selector callees (`s.start`) resolve to the field LEAF (family contract).
+   */
+  resolveGoCallLeaf(funcNode) {
+    if (!funcNode) return void 0;
+    if (funcNode.type === "identifier") return funcNode.text;
+    if (funcNode.type === "selector_expression") {
+      const field = funcNode.childForFieldName("field");
+      return field?.text;
+    }
+    return void 0;
+  }
+  // Framework detection
+  detectGoFrameworks(imports) {
+    const frameworks = [];
+    const modules = mapSymbols(imports, (imp) => imp.module || "");
+    forEachSymbol(GO_FRAMEWORK_RULES, (rule) => {
+      if (!rule.listed) return;
+      if (!someSymbol(modules, (m) => rule.matches(m))) return;
+      frameworks.push({ name: rule.name, confidence: rule.confidence, patterns: [rule.name] });
+    });
+    return frameworks;
+  }
+  detectGoPatterns(rootNode, symbols) {
+    const patterns = [];
+    const stack = [rootNode];
+    while (stack.length > 0) {
+      const node = stack.pop();
+      switch (node.type) {
+        case "go_statement":
+          if (!inArray(patterns, "goroutines")) patterns.push("goroutines");
+          break;
+        case "defer_statement":
+          if (!inArray(patterns, "defer")) patterns.push("defer");
+          break;
+        case "send_statement":
+        case "receive_statement":
+        case "communication_case":
+        case "channel_type":
+          if (!inArray(patterns, "channels")) patterns.push("channels");
+          break;
+        case "interface_type":
+          if (node.namedChildCount === 0) {
+            if (!inArray(patterns, "empty_interface")) patterns.push("empty_interface");
+          }
+          break;
+        case "if_statement":
+          const condition = node.childForFieldName("condition");
+          if (condition && stringIncludes(condition.text, "err") && stringIncludes(condition.text, "!=")) {
+            if (!inArray(patterns, "error_handling")) patterns.push("error_handling");
+          }
+          break;
+      }
+      for (let i = node.namedChildCount - 1; i >= 0; i--) {
+        const child = node.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+    if (someSymbol(symbols, (s) => s.metadata?.isInterface)) {
+      if (!inArray(patterns, "interfaces")) patterns.push("interfaces");
+    }
+    if (someSymbol(symbols, (s) => s.metadata?.isStruct)) {
+      if (!inArray(patterns, "structs")) patterns.push("structs");
+    }
+    return patterns;
+  }
+  /**
+   * Go Relationship Analysis
+   * Analyzes Go-specific relationships: struct embedding, interface implementation, method receivers, package dependencies
+   */
+  analyzeGoRelationships(rootNode, relationships, symbols, _ctx, stdlibQualifiers = /* @__PURE__ */ new Map()) {
+    this.analyzeGoStructEmbedding(rootNode, relationships);
+    this.analyzeGoMethodPromotionShadowing(relationships, symbols);
+    this.analyzeGoInterfaceImplementation(rootNode, relationships, symbols);
+    this.analyzeGoFunctionCalls(rootNode, relationships, symbols, stdlibQualifiers);
+    this.analyzeGoPackageScopeCalls(rootNode, relationships, symbols, stdlibQualifiers);
+    this.analyzeGoCompositeLiteralConstruction(rootNode, relationships, symbols, stdlibQualifiers);
+    this.analyzeGoSpecificPatterns(rootNode, relationships, symbols);
+    this.analyzeGoSelectorUses(rootNode, relationships, symbols);
+    this.analyzeGoBareIdentifierUses(rootNode, relationships, symbols);
+    for (const s of symbols) {
+      const owner = s.ownerName;
+      if (owner && owner !== s.name) {
+        relationships.push({
+          source: owner,
+          target: s.name,
+          type: ASTEngine.RelationshipType.Contains,
+          confidence: 1,
+          // the member's own declaration line (its name node, so
+          // a wrapped declaration reports where the name is written).
+          ...s.range?.startLine ? { line_number: s.range.startLine } : {},
+          metadata: {}
+        });
+      }
+    }
+  }
+  /**
+   * Go method promotion SHADOWING — the `overrides` relationship.
+   *
+   * WHY THIS IS AN OVERRIDE AND NOT AN INVENTED EDGE. Go has no `override`
+   * keyword, but it has the SEMANTIC: a method declared on the outer type at
+   * depth 0 replaces the promoted method of the same name at depth 1 for every
+   * selector `x.M` (Go spec, selectors: the shallowest depth wins). The family
+   * already models this half — the embedding itself is a `mixes_in` edge
+   * (`go_struct_embedding`: the STRUCT half; the interface half is `extends`).
+   * What was missing is the second half: the analyzer
+   * COMPUTED the shadowing inside `collectGoPromotedMethods` and THREW IT AWAY,
+   * dropping the promoted method from the method set without recording that it
+   * had been displaced. So the relationship was derivable from this file's own
+   * evidence, was never emitted, and the differential could not charge for it —
+   * the exact shape `overrides` was omitted for in bash.
+   *
+   * MEASURED, not ruled — `script/m14/go-ontology-census.ts` probe B2/B3 on
+   * go-stdlib + cobra. See docs/analyzers/go.md for the counts.
+   *
+   * ENDPOINT SPELLING follows the family: a method has no package-scope name of
+   * its own, so the SHADOWING end is `Receiver.Method` (perl, objc, python,
+   * kotlin, dart, swift, php, cpp all publish `overrides|.` as a recorded
+   * separator triple in validation/m60/target-spelling-register.json).
+   *
+   * THE TARGET IS THE MEMBER NAME ALONE (name-surface round, #924). A
+   * relationship target is a NAME the lane publishes, and `Embedder.Method` is a
+   * selector chain — Go has no qualified declaration names. So the promoted
+   * method publishes as its bare name, with `metadata.embedder` and
+   * `metadata.targetQualified` preserving the pair `Embedder.Method` that names
+   * WHICH declaration was displaced. The source keeps its qualified spelling
+   * because a Go method has no package-scope name of its own (the endpoint
+   * ambiguity the fixtures pin); only the target was ever source text on a
+   * name-bearing surface, and this is the rule that built it, fixed at the
+   * source rather than filtered afterwards.
+   *
+   * THE NAME RULE IS GO's, not the family's: the match is on the method NAME
+   * alone. A signature-compatible shadow is the only shape other languages
+   * accept, but Go permits `T.M` and `E.M` to have different signatures, and
+   * `x.M` selects T's either way — so name-only is the fact, and a
+   * signature-matching subset would under-report it. `sameSignature` records
+   * which of the two it is, so a consumer can tell a substitutable shadow from a
+   * hiding one without re-deriving the signature.
+   *
+   * CONFIDENCE 0.95, BELOW 1.0 AND NOT 1.0, with a reason code per the M14
+   * contract : the two declarations are read from this file, but the outer
+   * type's promoted set is resolved against the embedding closure as THIS FILE
+   * declares it. A method promoted from another file of the same package is not
+   * in the closure, so this edge's absence is not evidence of absence — see the
+   * lane's declared limitations.
+   */
+  analyzeGoMethodPromotionShadowing(relationships, symbols) {
+    const embeddedOf = /* @__PURE__ */ Object.create(null);
+    for (const r of relationships) {
+      {
+        const rt = String(r.type || r.relationshipType || "");
+        const constructId = r.metadata?.relationshipType;
+        if (constructId !== "go_struct_embedding" || rt !== ASTEngine.RelationshipType.MixesIn && rt !== ASTEngine.RelationshipType.Extends) {
+          continue;
+        }
+      }
+      const src = String(r.source ?? r.from ?? "");
+      const tgt = String(r.target ?? r.to ?? r.toSymbol ?? "");
+      if (!src || !tgt) continue;
+      const raw = String(r.metadata?.embeddedStruct ?? tgt);
+      if (raw.includes(".")) continue;
+      if (!embeddedOf[src]) embeddedOf[src] = [];
+      if (!embeddedOf[src].includes(tgt)) embeddedOf[src].push(tgt);
+    }
+    if (Object.keys(embeddedOf).length === 0) return;
+    const methods = filterSymbols(symbols, (s) => s.kind === ASTEngine.SymbolKind.Method);
+    const byReceiver = /* @__PURE__ */ Object.create(null);
+    for (const m of methods) {
+      const r = m.metadata?.receiverType || m.metadata?.receiver?.typeName;
+      if (typeof r !== "string" || !r) continue;
+      if (!byReceiver[r]) byReceiver[r] = [];
+      byReceiver[r].push(m);
+    }
+    if (Object.keys(byReceiver).length === 0) return;
+    const depths = /* @__PURE__ */ new Map();
+    for (const m of methods) {
+      const outer = m.metadata?.receiverType || m.metadata?.receiver?.typeName;
+      if (typeof outer !== "string" || !outer) continue;
+      const ownSig = this.normalizeGoSignature(this.buildGoMethodSignature(m));
+      const promoted = (tname, depth, visiting) => {
+        const out = [];
+        if (depth > 4 || visiting.has(tname)) return out;
+        visiting.add(tname);
+        for (const et of embeddedOf[tname] ?? []) {
+          for (const em of byReceiver[et] ?? []) out.push({ m: em, depth: depth + 1 });
+          for (const em of promoted(et, depth + 1, visiting)) out.push(em);
+        }
+        visiting.delete(tname);
+        return out;
+      };
+      for (const entry of promoted(outer, 0, /* @__PURE__ */ new Set())) {
+        const em = entry.m;
+        if (!em || em.name !== m.name) continue;
+        const embedder = em.metadata?.receiverType || em.metadata?.receiver?.typeName;
+        if (typeof embedder !== "string" || !embedder || embedder === outer) continue;
+        const key = `${outer}.${m.name}|${embedder}.${em.name}`;
+        const prior = depths.get(key);
+        if (prior !== void 0 && prior <= entry.depth) continue;
+        depths.set(key, entry.depth);
+        relationships.push({
+          source: `${outer}.${m.name}`,
+          // THE TARGET IS THE MEMBER NAME, NOT A SELECTOR CHAIN (name-surface
+          // round, #924): a relationship target is a NAME the lane publishes,
+          // and `Embedder.Method` is source text with a separator in it — Go has
+          // no qualified declaration names. The SHADOWING declaration keeps its
+          // qualified spelling on the SOURCE (a Go method has no package-scope
+          // name of its own; that is the endpoint-ambiguity rule the fixtures
+          // pin), and the promoting pair moves to `metadata.targetQualified` /
+          // `metadata.embedder` so no fact is lost with the spelling.
+          target: em.name,
+          type: ASTEngine.RelationshipType.Overrides,
+          confidence: 0.95,
+          // the SHADOWING declaration's own line — the site that
+          // makes `x.M` select this method rather than the promoted one.
+          ...m.range?.startLine ? { line_number: m.range.startLine } : {},
+          metadata: {
+            relationshipType: "go_method_promotion_shadowing",
+            isOverride: true,
+            // THE PROMOTING TYPE, and the pair spelling it used to publish as the
+            // TARGET before the name-surface round. The target is now the member
+            // name alone, so these two fields carry the identity that distinguishes
+            // two embedders declaring the same method name.
+            embedder,
+            targetQualified: `${embedder}.${em.name}`,
+            // contract : confidence < 1.0 carries a machine-readable reason.
+            reasonCode: "promoted-method-shadowed-by-outer-declaration",
+            // True when the two signatures match, i.e. this is a substitutable
+            // override; false when the outer method merely HIDES the promoted one
+            // (legal in Go, and still the method `x.M` selects).
+            sameSignature: this.normalizeGoSignature(this.buildGoMethodSignature(em)) === ownSig,
+            shadowedAtDepth: 0,
+            promotedAtDepth: entry.depth
+          }
+        });
+      }
+    }
+  }
+  /**
+   * Go Struct Embedding Analysis
+   * Analyzes struct embedding (anonymous fields) which is Go's composition pattern
+   */
+  analyzeGoStructEmbedding(rootNode, relationships) {
+    const stack = [rootNode];
+    while (stack.length > 0) {
+      const node = stack.pop();
+      if (node.type === "type_declaration") {
+        const typeSpecs = [];
+        for (let ti = 0; ti < node.namedChildCount; ti++) {
+          const ts = node.namedChild(ti);
+          if (ts?.type === "type_spec" || ts?.type === "type_alias") typeSpecs.push(ts);
+        }
+        for (const typeSpec of typeSpecs) {
+          const nameNode = typeSpec.childForFieldName("name");
+          const typeName = nameNode?.text;
+          if (!typeName) continue;
+          const structSpec = this.findChildByType(typeSpec, "struct_type");
+          if (structSpec) {
+            const embeddedTypeNodes = this.extractGoEmbeddedTypeNodes(structSpec);
+            forEachSymbol(embeddedTypeNodes, (embeddedType) => {
+              const rawEmbedded = String(embeddedType.text);
+              const embedLeaf = this.goEmbeddedFieldName(embeddedType);
+              if (!embedLeaf) return;
+              relationships.push({
+                source: typeName,
+                target: embedLeaf,
+                // THE RELABEL: stored type `extends` -> `mixes_in`, with the
+                // confidence (0.8) and therefore the evidenceClass UNCHANGED —
+                // that is the relabel contract, and it is what keeps this a
+                // label move rather than a distribution change.
+                type: ASTEngine.RelationshipType.MixesIn,
+                confidence: 0.8,
+                // the EMBEDDED TYPE's line — the site the
+                // embedded declaration is written on.
+                ...this.nodeLine(embeddedType) ? { line_number: this.nodeLine(embeddedType) } : {},
+                metadata: {
+                  // THE CONSTRUCT ID IS KEPT: `go_struct_embedding` names the
+                  // construct and is what every consumer (including this
+                  // analyzer's own two passes) keys on, so the label move does
+                  // not need a metadata move as well.
+                  relationshipType: "go_struct_embedding",
+                  isEmbedding: true,
+                  isAnonymous: true,
+                  isMixin: true,
+                  embedType: "struct_composition_mixes_in",
+                  embeddedStruct: rawEmbedded
+                }
+              });
+            });
+          }
+          const interfaceSpec = this.findChildByType(typeSpec, "interface_type");
+          if (interfaceSpec) {
+            for (let j = 0; j < interfaceSpec.namedChildCount; j++) {
+              const elem = interfaceSpec.namedChild(j);
+              if (!elem || elem.type !== "constraint_elem") continue;
+              const inner = elem.namedChildCount > 0 ? elem.namedChild(0) : void 0;
+              if (!inner) continue;
+              if (inner.type !== "type_identifier" && inner.type !== "qualified_type") continue;
+              const raw = inner.text;
+              const leaf = raw.lastIndexOf(".") !== -1 ? raw.slice(raw.lastIndexOf(".") + 1) : raw;
+              if (!leaf || !this.isPlainGoIdentifier(leaf)) continue;
+              relationships.push({
+                source: typeName,
+                target: leaf,
+                type: ASTEngine.RelationshipType.Extends,
+                confidence: 0.8,
+                // the embedded interface reference's own line.
+                ...this.nodeLine(inner) ? { line_number: this.nodeLine(inner) } : {},
+                metadata: {
+                  relationshipType: "go_interface_embedding",
+                  isEmbedding: true,
+                  isAnonymous: true,
+                  embedType: "interface_inheritance_extends",
+                  embeddedInterface: raw
+                }
+              });
+            }
+          }
+        }
+      }
+      for (let i = node.namedChildCount - 1; i >= 0; i--) {
+        const child = node.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+  }
+  /**
+   * RENDERS — Go's render host is the TEMPLATE EXECUTION, and the rendered
+   * component must be a PUBLISHED SYMBOL.
+   *
+   * WHY THIS IS A RELATION AND NOT A CALL. `pageTemplate.Execute(w, data)` is a
+   * method call and the `calls` pass already publishes it; `renders` asserts the
+   * DIFFERENT fact the call performs: this symbol puts THIS template's output on
+   * the wire. The family's renders contract is "the symbol whose body creates
+   * the rendered component renders it" (jsx/tsx; dart's build method returning a
+   * Widget), and Go's standard-library equivalent is `html/template` execution —
+   * the template IS the rendered component. The call edge stays: it is a real
+   * invocation, and one site can honestly carry both facts.
+   *
+   * THE RENDER HOST FILTER IS THE IMPORT, NOT THE NAME. The file must import
+   * `html/template`, the HTML renderer. `text/template` is the measured IMPOSTOR
+   * class — 151 of the corpus's template-importing files use it and almost all
+   * are CODE GENERATORS, not renderers — so a text/template-only file publishes
+   * no renders row, and a file that aliases text/template as a SECOND import
+   * cannot smuggle one in: the constructor's QUALIFIER is resolved against the
+   * html/template import's own local name, never against the spelling
+   * "template". A dot-imported (`import . "html/template"`) constructor cannot
+   * be qualified, so it publishes no row — declared MUST-NOT, not a guess.
+   *
+   * THE TARGET MUST BE A PUBLISHED SYMBOL. A template value is a component only
+   * when the program NAMES it: a package-level var whose initializer constructs
+   * a template (`var page = template.Must(template.New("page").Parse(...))`).
+   * A local template (`tpl := template.Must(...)`), a parameter, a struct field,
+   * a call result or an expression receiver publishes NO row: Go locals are not
+   * symbols (LocalsAreNotSymbols), and a NAME STRING would let the arbiter bind
+   * an unrelated declaration — the false-edge direction this programme refuses.
+   * Cross-file execution is therefore silent too: a per-file analyzer cannot
+   * prove that a bare identifier from ANOTHER file of the package is a template,
+   * and the limitation is declared rather than fabricated around.
+   *
+   * LINE: the OPERAND's line — the rendered symbol's own name at the call site.
+   * A method selector can wrap (`pageTemplate.\n\tExecute(...)`), so the Execute
+   * token's line is a different, wrong site (a row's line is the
+   * name-bearing node's line).
+   *
+   * CONFIDENCE 0.9 / usage_contextual, the render family's tier: both ends are
+   * read from this file, but the template's identity is recognised from its
+   * CONSTRUCTOR CALL rather than a declared type (tree-sitter-go has no type
+   * resolution), so the row is not `structural`.
+   */
+  analyzeGoTemplateRenders(rootNode, imports, relationships) {
+    let hostName;
+    let dotImported = false;
+    for (const imp of imports) {
+      if ((imp.module ?? "") !== "html/template") continue;
+      const alias = typeof imp.alias === "string" ? String(imp.alias) : "";
+      if (alias === "_") continue;
+      if (alias === ".") {
+        dotImported = true;
+        continue;
+      }
+      hostName = alias.length > 0 ? alias : "template";
+      break;
+    }
+    if (!hostName || dotImported) return;
+    const templateSymbols = /* @__PURE__ */ new Map();
+    for (let i = 0; i < rootNode.namedChildCount; i++) {
+      const decl = rootNode.namedChild(i);
+      if (!decl || decl.type !== "var_declaration") continue;
+      for (let j = 0; j < decl.namedChildCount; j++) {
+        const spec = decl.namedChild(j);
+        if (!spec || spec.type !== "var_spec") continue;
+        const value = spec.childForFieldName?.("value");
+        if (!value) continue;
+        const constructed = this.goTemplateConstructionName(value, hostName);
+        if (constructed === null) continue;
+        for (let k = 0; k < spec.namedChildCount; k++) {
+          const c = spec.namedChild(k);
+          if (!c || c.type !== "identifier") continue;
+          const text = String(c.text ?? "");
+          if (text.length === 0 || text === "_") continue;
+          templateSymbols.set(text, constructed);
+        }
+      }
+    }
+    if (templateSymbols.size === 0) return;
+    const seen = /* @__PURE__ */ new Set();
+    const stack = [rootNode];
+    while (stack.length > 0) {
+      const node = stack.pop();
+      if (node.type === "call_expression") {
+        const fn = node.childForFieldName("function");
+        if (fn && fn.type === "selector_expression") {
+          const field = fn.childForFieldName("field");
+          const operand = fn.childForFieldName("operand");
+          const method = field ? String(field.text ?? "") : "";
+          if ((method === "Execute" || method === "ExecuteTemplate") && operand && operand.type === "identifier") {
+            const target = String(operand.text ?? "");
+            const constructedName = templateSymbols.get(target);
+            if (constructedName !== void 0) {
+              const source = this.findContainingGoFunction(node);
+              const key = `${source ?? ""}|${target}`;
+              if (source && !seen.has(key)) {
+                seen.add(key);
+                const templateName = method === "ExecuteTemplate" ? this.goTemplateRenderNameArgument(node, constructedName) : constructedName;
+                relationships.push({
+                  source,
+                  target,
+                  type: ASTEngine.RelationshipType.Renders,
+                  confidence: 0.9,
+                  ...this.nodeLine(operand) ? { line_number: this.nodeLine(operand) } : {},
+                  metadata: {
+                    relationshipType: "go_template_render",
+                    isRenderHost: true,
+                    renderHost: "html/template",
+                    renderMethod: method,
+                    ...templateName ? { templateName } : {}
+                  }
+                });
+              }
+            }
+          }
+        }
+      }
+      for (let i = node.namedChildCount - 1; i >= 0; i--) {
+        const child = node.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+  }
+  /**
+   * Does this initializer construct an `html/template` through the import's own
+   * local name? `null` when it does not construct a template at all; the
+   * template's own `template.New("<literal>")` name when it does; `""` when it
+   * constructs one whose name is a runtime value.
+   *
+   * Recognised root constructors are the standard library's own: Must, New,
+   * ParseFiles, ParseGlob, ParseFS. `Parse` is deliberately NOT a root
+   * constructor: it is a METHOD on a template (`tpl.Parse(...)`), so an
+   * initializer whose root call is `Parse` is not constructing one; the
+   * `template.Must(template.New(...).Parse(...))` chain is recognised through
+   * Must and its arguments are searched for the `New` literal.
+   */
+  goTemplateConstructionName(node, hostName) {
+    const constructors = ["Must", "New", "ParseFiles", "ParseGlob", "ParseFS"];
+    const asHostCall = (n) => {
+      if (n.type !== "call_expression") return null;
+      const fn = n.childForFieldName("function");
+      if (!fn || fn.type !== "selector_expression") return null;
+      const operand = fn.childForFieldName("operand");
+      const field = fn.childForFieldName("field");
+      if (!operand || operand.type !== "identifier") return null;
+      if (String(operand.text ?? "") !== hostName) return null;
+      if (!field || !inArray(constructors, String(field.text ?? ""))) return null;
+      return n;
+    };
+    const nameOfNew = (call) => {
+      const args = call.childForFieldName("arguments");
+      const first = args?.namedChild(0);
+      if (!first || first.type !== "interpreted_string_literal") return "";
+      return this.stripQuotedString(String(first.text ?? ""));
+    };
+    const found = (n, depth) => {
+      if (depth > 6) return null;
+      const root = asHostCall(n);
+      if (root) {
+        const field = root.childForFieldName("function")?.childForFieldName("field");
+        if (String(field?.text ?? "") === "New") return nameOfNew(root);
+        const args = root.childForFieldName("arguments");
+        for (const a of args?.namedChildren ?? []) {
+          if (!a) continue;
+          const r = found(a, depth + 1);
+          if (r !== null && r.length > 0) return r;
+        }
+        return "";
+      }
+      let sawConstruction = false;
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (!c) continue;
+        const r = found(c, depth + 1);
+        if (r !== null) {
+          sawConstruction = true;
+          if (r.length > 0) return r;
+        }
+      }
+      if (!sawConstruction) return null;
+      return "";
+    };
+    return found(node, 0);
+  }
+  /**
+   * The rendered sub-template's name, for `ExecuteTemplate(w, "name", data)`:
+   * its SECOND argument when that argument is a string literal; otherwise the
+   * template's own construction name. `undefined` when neither names it — no
+   * NAME is ever invented for metadata.
+   */
+  goTemplateRenderNameArgument(call, constructedName) {
+    const args = call.childForFieldName("arguments");
+    const second = args?.namedChild(1);
+    if (second && second.type === "interpreted_string_literal") {
+      const name = this.stripQuotedString(String(second.text ?? ""));
+      if (name.length > 0) return name;
+    }
+    return constructedName.length > 0 ? constructedName : void 0;
+  }
+  /**
+   * Go Interface Implementation Analysis
+   * Analyzes implicit interface implementation (Go's duck typing)
+   */
+  analyzeGoInterfaceImplementation(rootNode, relationships, symbols) {
+    const interfaces = filterSymbols(symbols, (s) => s.metadata?.isInterface);
+    const structs = filterSymbols(
+      symbols,
+      (s) => (s.kind === ASTEngine.SymbolKind.Struct || s.kind === ASTEngine.SymbolKind.Type) && !s.metadata?.isInterface
+    );
+    const methods = filterSymbols(symbols, (s) => s.kind === ASTEngine.SymbolKind.Method);
+    const declaredTypeNames = /* @__PURE__ */ new Set();
+    for (const s of symbols) {
+      if (s.kind === ASTEngine.SymbolKind.Struct || s.kind === ASTEngine.SymbolKind.Interface || s.kind === ASTEngine.SymbolKind.Type) {
+        declaredTypeNames.add(s.name);
+      }
+    }
+    const candidates = mapSymbols(structs, (s) => ({
+      name: s.name,
+      hasGenerics: !!s.metadata?.hasGenerics
+    }));
+    for (const m of methods) {
+      const receiverType = m.metadata?.receiverType || m.metadata?.receiver?.typeName;
+      if (typeof receiverType !== "string" || !receiverType) continue;
+      if (declaredTypeNames.has(receiverType)) continue;
+      if (someSymbol(candidates, (c) => c.name === receiverType)) continue;
+      candidates.push({ name: receiverType, hasGenerics: false });
+    }
+    const embeddedOf = /* @__PURE__ */ Object.create(null);
+    for (const r of relationships) {
+      {
+        const rt = String(r.type || r.relationshipType || "");
+        const constructId = r.metadata?.relationshipType;
+        if (constructId !== "go_struct_embedding" || rt !== ASTEngine.RelationshipType.MixesIn && rt !== ASTEngine.RelationshipType.Extends) {
+          continue;
+        }
+        const src = String(r.source ?? r.from ?? "");
+        const tgt = String(r.target ?? r.to ?? r.toSymbol ?? "");
+        if (src && tgt) {
+          if (!embeddedOf[src]) embeddedOf[src] = [];
+          embeddedOf[src].push(tgt);
+        }
+      }
+    }
+    const promotedByCandidate = /* @__PURE__ */ new Map();
+    forEachSymbol(candidates, (candidate) => {
+      promotedByCandidate.set(
+        candidate.name,
+        this.collectGoPromotedMethods(candidate.name, methods, symbols, embeddedOf, /* @__PURE__ */ new Set())
+      );
+    });
+    forEachSymbol(interfaces, (interfaceSymbol) => {
+      if (interfaceSymbol.metadata?.hasGenerics) return;
+      const interfaceMethods = this.getGoInterfaceMethods(interfaceSymbol, symbols);
+      forEachSymbol(candidates, (candidate) => {
+        if (candidate.hasGenerics) return;
+        const structName = candidate.name;
+        if (structName === interfaceSymbol.name) return;
+        const promoted = promotedByCandidate.get(structName) ?? [];
+        const valueMethods = [
+          ...filterSymbols(methods, (m) => {
+            const receiverType = m.metadata?.receiverType || m.metadata?.receiver?.typeName;
+            const isPointer = !!(m.metadata?.isPointerReceiver || m.metadata?.receiver?.isPointer);
+            return receiverType === structName && !isPointer;
+          }),
+          ...promoted
+        ];
+        const pointerMethods = [
+          ...filterSymbols(methods, (m) => {
+            const receiverType = m.metadata?.receiverType || m.metadata?.receiver?.typeName;
+            return receiverType === structName;
+          }),
+          ...promoted
+        ];
+        const valueImpl = this.checkGoInterfaceImplementation(interfaceMethods, valueMethods);
+        const pointerImpl = this.checkGoInterfaceImplementation(interfaceMethods, pointerMethods);
+        if (valueImpl.implements) {
+          relationships.push({
+            source: structName,
+            target: interfaceSymbol.name,
+            type: ASTEngine.RelationshipType.Implements,
+            confidence: valueImpl.confidence,
+            // the interface declaration's own line — the site
+            // that NAMES the target (the struct's line would name the source).
+            ...interfaceSymbol.range?.startLine ? { line_number: interfaceSymbol.range.startLine } : {},
+            metadata: {
+              relationshipType: "go_interface_implementation",
+              isImplicit: true,
+              matchedMethods: valueImpl.matchedMethods,
+              implementationType: "duck_typing",
+              receiverSet: "value"
+            }
+          });
+        }
+        if (!valueImpl.implements && pointerImpl.implements) {
+          relationships.push({
+            source: structName,
+            target: interfaceSymbol.name,
+            type: ASTEngine.RelationshipType.Implements,
+            confidence: pointerImpl.confidence,
+            ...interfaceSymbol.range?.startLine ? { line_number: interfaceSymbol.range.startLine } : {},
+            metadata: {
+              relationshipType: "go_interface_implementation",
+              isImplicit: true,
+              matchedMethods: pointerImpl.matchedMethods,
+              implementationType: "duck_typing",
+              receiverSet: "pointer"
+            }
+          });
+        }
+      });
+    });
+  }
+  /**
+   * Go embedded-struct method promotion (Go spec, promoted methods).
+   * Returns the method-symbol set reachable on `structName` through embedded
+   * structs (the go_struct_embedding closure built in
+   * analyzeGoInterfaceImplementation). `worker struct { *shape; name string }`
+   * promotes shape's methods into worker's method set, so worker satisfies
+   * any interface shape satisfies. Transitive and cycle-safe. NOTE: deduped
+   * by method signature (name+params+return); a struct defining its own
+   * method with the same signature as a promoted one shadows the promotion
+   * (Go rule: a promoted method at shallower depth wins / is shadowed by an
+   * explicit method).
+   */
+  collectGoPromotedMethods(structName, methods, symbols, embeddedOf, visiting) {
+    if (visiting.has(structName)) return [];
+    visiting.add(structName);
+    const acc = [];
+    const embeddedTypes = embeddedOf[structName];
+    if (embeddedTypes) {
+      for (const et of embeddedTypes) {
+        const embeddedMethods = filterSymbols(
+          methods,
+          (m) => (m.metadata?.receiverType || m.metadata?.receiver?.typeName) === et
+        );
+        const ownSig = (m) => this.buildGoMethodSignature(m);
+        forEachSymbol(embeddedMethods, (m) => {
+          const shadowed = someSymbol(
+            [...filterSymbols(methods, (sm) => (sm.metadata?.receiverType || sm.metadata?.receiver?.typeName) === structName), ...acc],
+            (x) => x !== m && this.buildGoMethodSignature(x) === ownSig(m)
+          );
+          if (!shadowed && !someSymbol(acc, (x) => this.buildGoMethodSignature(x) === ownSig(m))) {
+            acc.push(m);
+          }
+        });
+        const transitive = this.collectGoPromotedMethods(et, methods, symbols, embeddedOf, visiting);
+        forEachSymbol(transitive, (m) => {
+          const shadowed = someSymbol(
+            [...filterSymbols(methods, (sm) => (sm.metadata?.receiverType || sm.metadata?.receiver?.typeName) === structName), ...acc],
+            (x) => x !== m && this.buildGoMethodSignature(x) === this.buildGoMethodSignature(m)
+          );
+          if (!shadowed && !someSymbol(acc, (x) => this.buildGoMethodSignature(x) === this.buildGoMethodSignature(m))) {
+            acc.push(m);
+          }
+        });
+      }
+    }
+    visiting.delete(structName);
+    return acc;
+  }
+  /**
+   * THE FILE'S STDLIB PACKAGE QUALIFIERS: the spelling a call site may use for an imported stdlib
+   * package -> that package's import path.
+   *
+   * Go lets a file qualify a package member by the import's LOCAL NAME: the alias when written
+   * (`j "encoding/json"`), otherwise the package's own name, which for the standard library is the
+   * last path segment except for the few packages whose name differs from their directory (and
+   * those are aliased by every consumer that needs the distinction). `_` and `.` imports qualify
+   * nothing and are skipped; two distinct modules claiming one qualifier cannot be distinguished at
+   * a call site, so the qualifier is dropped rather than guessed.
+   */
+  collectGoStdlibQualifiers(imports) {
+    const out = /* @__PURE__ */ new Map();
+    const conflicted = /* @__PURE__ */ new Set();
+    for (const imp of imports) {
+      const module = String(imp.module ?? "");
+      if (module.length === 0 || !isGoStdlibModulePath(module)) continue;
+      const alias = typeof imp.alias === "string" ? imp.alias : "";
+      if (alias === "_" || alias === ".") continue;
+      const packageName = String(imp.metadata?.packageName ?? this.getGoPackageName(module));
+      const qualifier = alias.length > 0 ? alias : packageName;
+      if (qualifier.length === 0) continue;
+      if (out.has(qualifier) && out.get(qualifier) !== module) {
+        conflicted.add(qualifier);
+        continue;
+      }
+      if (!conflicted.has(qualifier)) out.set(qualifier, module);
+    }
+    for (const q of conflicted) out.delete(q);
+    return out;
+  }
+  /**
+   * THE ONE CLAIM A LEAF CALL TARGET CAN CARRY — `isStdlib` when the call is a DIRECT member of a
+   * standard-library package this file imports.
+   *
+   * WHY THIS IS THE CHANNEL. The gate reads `metadata.reasonCode` nowhere; the claims it reads are
+   * `EXTERNAL_KEYS` (verified against the key space) and `baseBeyondRunScope` (verified by spelling
+   * + owner consistency). This lane's unresolved calls are BARE LEAVES (`fmt.Println` publishes
+   * `Println`), and `targetOwner("Println")` is null, so a declared cause can never be attached to
+   * one: measured over the 400-file stride, all 24,385 unresolved edges read `causeRefuted` when
+   * their own reason is placed on that key. The external channel is different by construction — a
+   * bare identifier is looked up directly and, because the claim is read only where the target names
+   * nothing, the lookup returns 0 and the claim verifies without ever being able to manufacture a
+   * refutation. What makes it HONEST is the proof in front of it, not the arbiter: the qualifier is
+   * a package the file itself imports, and the import path's first segment is a member of the Go
+   * standard library's closed top-level set. A receiver variable (`r.reader.SearchWhere`), a local
+   * shadow of an import name, a project-local package and a third-party module all fail that proof
+   * and are left silent.
+   *
+   * WHAT IT DOES NOT DO. It never raises `resolved`, it does not change the emitted target, and it
+   * does not claim anything about a leaf this FILE publishes (then the edge is not external at the
+   * per-file scope the analyzer actually knows). Returns the import path when the claim is true.
+   */
+  goStdlibCallClaim(callExpression, leaf, symbols, qualifiers, ownPackageName) {
+    const firstDot = callExpression.indexOf(".");
+    if (firstDot <= 0) return null;
+    if (callExpression.indexOf(".", firstDot + 1) !== -1) return null;
+    const qualifier = callExpression.slice(0, firstDot);
+    const module = qualifiers.get(qualifier);
+    if (module === void 0) return null;
+    if (qualifier === ownPackageName) return null;
+    if (findSymbol(symbols, (s) => s.name === qualifier)) return null;
+    if (findSymbol(symbols, (s) => this.isGoPackageCallable(s) && s.name === leaf)) return null;
+    return module;
+  }
+  /**
+   * THE SAME PROOF FOR A QUALIFIED TYPE SPELLING — the shared shape behind the `references` and
+   * `instantiates` claims: `context.Context`, `http.Server`, `time.Duration`.
+   *
+   * The differences from `goStdlibCallClaim` are deliberate and are the two ways a type use differs
+   * from a call: the leaf is a TYPE, so any declaration of that name in this file is enough to stop
+   * the claim (a call needs a callable); and a qualified spelling is held for the USE even when the
+   * file also declares the leaf, which is exactly the case where the edge may bind to the wrong
+   * declaration — so the guard matters more here, not less. A deeper chain (`pkg.Sub.Type`) is not
+   * a direct package member and is refused, as on the call surface.
+   */
+  goStdlibTypeClaim(qualified, leaf, symbols, qualifiers, ownPackageName) {
+    const firstDot = qualified.indexOf(".");
+    if (firstDot <= 0) return null;
+    if (qualified.indexOf(".", firstDot + 1) !== -1) return null;
+    const qualifier = qualified.slice(0, firstDot);
+    const module = qualifiers.get(qualifier);
+    if (module === void 0) return null;
+    if (qualifier === ownPackageName) return null;
+    if (findSymbol(symbols, (s) => s.name === qualifier)) return null;
+    if (findSymbol(symbols, (s) => s.name === leaf)) return null;
+    return module;
+  }
+  /**
+   * Go Function Call Analysis
+   * Analyzes Go function calls including package-qualified calls.
+   * Family contract (Rust M12.18): calls emit LEAF targets — a receiver chain
+   * `s.repo.Save(user)` emits `calls Save -> Save` exactly like Rust's
+   * `self.repository.find(id)` emits `calls find -> find`, and stdlib calls
+   * (`strings.ToUpper`) emit `calls transform -> ToUpper` like Rust's
+   * `calls normalize -> println`. Instantiates fires ONLY for PascalCase
+   * top-level FUNCTION symbols (Go constructor convention `NewXxx`) — never
+   * for methods or unresolved stdlib leaves.
+   */
+  analyzeGoFunctionCalls(rootNode, relationships, symbols, stdlibQualifiers) {
+    const functions = filterSymbols(
+      symbols,
+      (s) => s.kind === ASTEngine.SymbolKind.Function || s.kind === ASTEngine.SymbolKind.Method
+    );
+    const dotImported = this.hasGoDotImport(rootNode);
+    const ownPackageName = this.goOwnPackageName(rootNode);
+    forEachSymbol(functions, (func) => {
+      const qualifiedCalls = func.qualified_calls || [];
+      const callSites = this.goCallSites.get(func.range?.startIndex ?? -1);
+      forEachSymbol(qualifiedCalls, (call) => {
+        const callLine = this.nodeLine(callSites?.get(call));
+        const targetFunction = this.resolveGoFunctionCall(call, symbols, dotImported);
+        if (targetFunction && this.isGoBuiltin(targetFunction)) {
+          return;
+        }
+        if (targetFunction) {
+          const stdlibModule = this.goStdlibCallClaim(call, targetFunction, symbols, stdlibQualifiers, ownPackageName);
+          relationships.push({
+            source: func.name,
+            target: targetFunction,
+            type: ASTEngine.RelationshipType.Calls,
+            confidence: 0.8,
+            ...callLine ? { line_number: callLine } : {},
+            metadata: {
+              relationshipType: "go_function_call",
+              callExpression: call,
+              isPackageQualified: stringIncludes(call, "."),
+              // `isStdlib` is one of the gate's recognised EXTERNAL_KEYS, and the PROOF is the
+              // import written in this file plus the closed top-level stdlib set (`stdlibPath` is
+              // the evidence, kept beside the claim for a reviewer; it is not a claim key).
+              ...stdlibModule !== null ? { isStdlib: true, stdlibPath: stdlibModule } : {}
+            }
+          });
+          const ctorSymbol = findSymbol(
+            symbols,
+            (s) => s.name === targetFunction && s.kind === ASTEngine.SymbolKind.Function && !s.ownerName
+          );
+          const calleeLeaf = callSites?.get(call);
+          const calleeNode = calleeLeaf && calleeLeaf.parent?.type === "selector_expression" ? calleeLeaf.parent : calleeLeaf;
+          if (ctorSymbol && this.isGoTopLevelFunctionCallee(calleeNode, ownPackageName) && ctorSymbol.name[0] === ctorSymbol.name[0].toUpperCase() && ctorSymbol.name[0] !== ctorSymbol.name[0].toLowerCase()) {
+            relationships.push({
+              source: func.name,
+              target: targetFunction,
+              type: ASTEngine.RelationshipType.Instantiates,
+              confidence: 0.6,
+              ...callLine ? { line_number: callLine } : {},
+              metadata: { relationshipType: "go_instantiation", callExpression: call }
+            });
+          }
+        }
+      });
+    });
+  }
+  /**
+   * Package-scope call analysis. Captures call_expression nodes that sit at
+   * package level (var/const initializers, top-level assignments) — e.g.
+   * `var _ = intVar(123)`, `var r = regexp.MustCompile(...)`, or
+   * `keys.NewString("view_type", "")`. findGoFunctionCalls only walks
+   * function/method bodies, so these real calls were NEVER emitted (Go wave
+   * 2026-08-28: newexpr.go, session.go NewString, semtok.go MustCompile all
+   * leaked as differential MISSING). Emitted with source = package/"global"
+   * (no enclosing function). Mirrors resolveGoFunctionCall: bare callee emits
+   * only if it names an in-file declared function/method; qualified callee
+   * emits the leaf unconditionally; builtins and func-literals skipped.
+   */
+  analyzeGoPackageScopeCalls(rootNode, relationships, symbols, stdlibQualifiers) {
+    const declared = /* @__PURE__ */ new Set();
+    const dotImported = this.hasGoDotImport(rootNode);
+    const ownPackageName = this.goOwnPackageName(rootNode);
+    const ctorFns = /* @__PURE__ */ new Set();
+    for (const s of symbols) {
+      if (this.isGoPackageCallable(s)) {
+        declared.add(s.name);
+      }
+      if (s.kind === ASTEngine.SymbolKind.Function && !s.ownerName) {
+        ctorFns.add(s.name);
+      }
+    }
+    const stack = [rootNode];
+    const emitted = /* @__PURE__ */ new Set();
+    while (stack.length > 0) {
+      const node = stack.pop();
+      if (node.type === "function_declaration" || node.type === "method_declaration") continue;
+      if (node.type === "func_literal" && node.parent?.type !== "call_expression") continue;
+      if (node.type === "call_expression") {
+        const fn = node.childForFieldName("function");
+        if (fn) {
+          const leaf = this.resolveGoCallLeaf(fn);
+          if (fn.type === "func_literal") {
+            for (let i = fn.namedChildCount - 1; i >= 0; i--) {
+              const fc = fn.namedChild(i);
+              if (fc) stack.push(fc);
+            }
+            continue;
+          }
+          if (!leaf) {
+            for (let i = node.namedChildCount - 1; i >= 0; i--) {
+              const child = node.namedChild(i);
+              if (child) stack.push(child);
+            }
+            continue;
+          }
+          const qualified = fn.type === "selector_expression";
+          const isCtor = leaf[0] === leaf[0].toUpperCase() && leaf[0] !== leaf[0].toLowerCase();
+          const emit = !this.isGoBuiltin(leaf) && (qualified || dotImported || declared.has(leaf));
+          const callSrc = this.resolveGoWorkSource(node);
+          const callKey = `call:${callSrc}:${leaf}`;
+          if (emit && !emitted.has(callKey)) {
+            emitted.add(callKey);
+            const stdlibModule = this.goStdlibCallClaim(fn.text, leaf, symbols, stdlibQualifiers, ownPackageName);
+            relationships.push({
+              source: callSrc,
+              target: leaf,
+              type: ASTEngine.RelationshipType.Calls,
+              confidence: 0.8,
+              // the package-scope walk holds the callee node
+              // directly — its LEAF's line, not the statement's.
+              ...this.nodeLine(this.goCalleeNameNode(fn)) ? { line_number: this.nodeLine(this.goCalleeNameNode(fn)) } : {},
+              metadata: {
+                relationshipType: "go_package_scope_call",
+                callExpression: fn.text,
+                isPackageQualified: qualified,
+                ...stdlibModule !== null ? { isStdlib: true, stdlibPath: stdlibModule } : {}
+              }
+            });
+          }
+          if (isCtor && ctorFns.has(leaf) && this.isGoTopLevelFunctionCallee(fn, ownPackageName) && !emitted.has("inst:" + leaf)) {
+            emitted.add("inst:" + leaf);
+            relationships.push({
+              source: "global",
+              target: leaf,
+              type: ASTEngine.RelationshipType.Instantiates,
+              confidence: 0.6,
+              ...this.nodeLine(this.goCalleeNameNode(fn)) ? { line_number: this.nodeLine(this.goCalleeNameNode(fn)) } : {},
+              metadata: { relationshipType: "go_package_scope_instantiation", callExpression: fn.text }
+            });
+          }
+        }
+      }
+      for (let i = node.namedChildCount - 1; i >= 0; i--) {
+        const child = node.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+  }
+  /**
+   * Go-Specific Pattern Analysis
+   * Analyzes goroutines, channels, defer statements, and Go idioms
+   */
+  /**
+   * Go composite-literal construction analysis. `Foo{...}`, `&Foo{...}` and
+   * `pkg.Foo{...}` are Go's primary construction syntax — but before M37
+   * #604 instantiates fired ONLY for NewXxx constructor calls, so struct
+   * construction by literal was invisible to the graph (65,843 composite
+   * literals across go-tools+terraform with zero construction edges). Rust
+   * emits instantiates for struct literals (`Foo { ... }`), csharp for
+   * `new Foo()` — this is family parity, not a new edge kind. Target is the
+   * literal's type LEAF (dotted pkg.Foo -> Foo, matching the calls leaf
+   * contract); source is the containing fn/method or "global" at package
+   * scope. Slice/map/array literals carry a wrapper type child (not a named
+   * type) and elided element literals have no type child — both are skipped
+   * naturally by the type-child gate below.
+   */
+  analyzeGoCompositeLiteralConstruction(rootNode, relationships, symbols = [], stdlibQualifiers = /* @__PURE__ */ new Map()) {
+    const ownPackageName = this.goOwnPackageName(rootNode);
+    const stack = [rootNode];
+    const seen = /* @__PURE__ */ new Set();
+    while (stack.length > 0) {
+      const node = stack.pop();
+      if (node.type === "ERROR" || node.isMissing) continue;
+      if (node.type === "func_literal" && node.parent?.type !== "call_expression" && !this.findContainingGoFunction(node)) {
+        continue;
+      }
+      if (node.type === "composite_literal") {
+        const typeNode = node.childForFieldName("type") ?? (node.namedChildCount > 0 ? node.namedChild(0) : void 0);
+        let target;
+        let qualifiedRaw;
+        if (typeNode) {
+          if (typeNode.type === "type_identifier") {
+            target = typeNode.text;
+          } else if (typeNode.type === "qualified_type") {
+            const raw = typeNode.text;
+            qualifiedRaw = raw;
+            const dot = raw.lastIndexOf(".");
+            target = dot !== -1 ? raw.slice(dot + 1) : raw;
+          } else if (typeNode.type === "generic_type") {
+            const base = typeNode.namedChildCount > 0 ? typeNode.namedChild(0) : void 0;
+            if (base && (base.type === "type_identifier" || base.type === "qualified_type")) {
+              const raw = base.text;
+              if (base.type === "qualified_type") qualifiedRaw = raw;
+              const dot = raw.lastIndexOf(".");
+              target = dot !== -1 ? raw.slice(dot + 1) : raw;
+            }
+          }
+        }
+        if (target && !this.isGoBuiltin(target)) {
+          const src = this.resolveGoWorkSource(node);
+          const key = `${src}.${target}`;
+          if (!seen.has(key)) {
+            seen.add(key);
+            const stdlibModule = qualifiedRaw !== void 0 ? this.goStdlibTypeClaim(qualifiedRaw, target, symbols, stdlibQualifiers, ownPackageName) : null;
+            relationships.push({
+              source: src,
+              target,
+              type: ASTEngine.RelationshipType.Instantiates,
+              confidence: 0.8,
+              // the constructed TYPE's line.
+              ...this.nodeLine(typeNode) ? { line_number: this.nodeLine(typeNode) } : {},
+              metadata: {
+                relationshipType: "go_composite_literal_construction",
+                isConstructor: true,
+                ...qualifiedRaw !== void 0 ? { qualifiedType: qualifiedRaw } : {},
+                ...stdlibModule !== null ? { isStdlib: true, stdlibPath: stdlibModule } : {}
+              }
+            });
+          }
+        }
+      }
+      for (let i = node.namedChildCount - 1; i >= 0; i--) {
+        const child = node.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+  }
+  /**
+   * Go-Specific Pattern Analysis
+   * Analyzes goroutines, channels, defer statements, and Go idioms
+   */
+  analyzeGoSpecificPatterns(rootNode, relationships, symbols) {
+    const dotImported = this.hasGoDotImport(rootNode);
+    const emittedCalls = /* @__PURE__ */ new Set();
+    for (const r of relationships) {
+      if ((r.type || r.relationshipType || "") === ASTEngine.RelationshipType.Calls) {
+        emittedCalls.add(`${r.source}->${r.target}`);
+      }
+    }
+    const emittedChannelUses = /* @__PURE__ */ new Set();
+    const stack = [rootNode];
+    while (stack.length > 0) {
+      const node = stack.pop();
+      if (node.type === "go_statement") {
+        const functionCall = this.extractGoRoutineFunction(node);
+        if (functionCall && this.isGoResolvableCallTarget(functionCall, symbols, dotImported)) {
+          if (this.isGoBuiltin(functionCall.split(".").pop() ?? functionCall)) {
+            continue;
+          }
+          const containingFunction = this.findContainingGoFunction(node);
+          if (containingFunction && !emittedCalls.has(`${containingFunction}->${functionCall}`)) {
+            emittedCalls.add(`${containingFunction}->${functionCall}`);
+            relationships.push({
+              source: containingFunction,
+              target: functionCall,
+              type: ASTEngine.RelationshipType.Calls,
+              confidence: 0.9,
+              // the callee leaf of the `go` statement.
+              ...this.nodeLine(this.goStatementCalleeNode(node)) ? { line_number: this.nodeLine(this.goStatementCalleeNode(node)) } : {},
+              metadata: {
+                relationshipType: "go_goroutine",
+                isAsynchronous: true,
+                pattern: "goroutine_spawn"
+              }
+            });
+          }
+        }
+      }
+      if (node.type === "send_statement" || node.type === "receive_statement" || this.isGoReceiveExpression(node)) {
+        const channelVar = this.extractGoChannelVariable(node);
+        const containingFunction = this.findContainingGoFunction(node) ?? "global";
+        if (channelVar && (channelVar.member || this.isGoDeclaredPackageVar(channelVar.name, symbols))) {
+          const isSend = node.type === "send_statement";
+          const key = `${containingFunction}->${channelVar.name}->${isSend ? "send" : "receive"}`;
+          if (!emittedChannelUses.has(key)) {
+            emittedChannelUses.add(key);
+            relationships.push({
+              source: containingFunction,
+              target: channelVar.name,
+              type: ASTEngine.RelationshipType.Uses,
+              confidence: 0.8,
+              // the send/receive statement's line.
+              ...this.nodeLine(node) ? { line_number: this.nodeLine(node) } : {},
+              metadata: {
+                relationshipType: "go_channel_operation",
+                operationType: isSend ? "send" : "receive",
+                pattern: "channel_communication"
+              }
+            });
+          }
+        }
+      }
+      if (node.type === "defer_statement") {
+        const deferredFunction = this.extractDeferredFunction(node);
+        const containingFunction = this.findContainingGoFunction(node);
+        if (deferredFunction && this.isGoResolvableCallTarget(deferredFunction, symbols, dotImported) && !this.isGoBuiltin(deferredFunction.split(".").pop() ?? deferredFunction) && containingFunction && !emittedCalls.has(`${containingFunction}->${deferredFunction}`)) {
+          emittedCalls.add(`${containingFunction}->${deferredFunction}`);
+          relationships.push({
+            source: containingFunction,
+            target: deferredFunction,
+            type: ASTEngine.RelationshipType.Calls,
+            confidence: 0.9,
+            // the callee leaf of the `defer` statement.
+            ...this.nodeLine(this.goStatementCalleeNode(node)) ? { line_number: this.nodeLine(this.goStatementCalleeNode(node)) } : {},
+            metadata: {
+              relationshipType: "go_defer",
+              isDeferred: true,
+              pattern: "defer_cleanup"
+            }
+          });
+        }
+      }
+      for (let i = node.namedChildCount - 1; i >= 0; i--) {
+        const child = node.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+  }
+  /**
+   * GO1: bare-identifier value reads. Every bare `identifier` that names a
+   * file-visible VALUE (package-scope var/const/func) is a Uses edge, with:
+   * -walked with a lexical scope stack (function/method/func-literal
+   *  params+receivers bind at entry; block/short-var/var/range/for/if-init/
+   *  select-assign/type-switch-guard bindings bind in walk order, so reads
+   *  before any binding still resolve outward — C-family flow discipline);
+   * - declaration positions never read (entity names via first-identifier
+   *  rule; composite-literal struct keys skipped; labels/package/import
+   *  paths/blank `_` excluded);
+   * - call callees (span-matched; generic/index wrappers climbed),
+   *  member leaves (selector path owns them; objects stay readable),
+   *  qualified non-leaves, channel operands (channel pass owns them),
+   *  assignment/inc/dec LHS writes, go/defer callees all excluded;
+   * - resolvability required: unknown names (std/dot-imported/external)
+   *  stay silent — no junk edges.
+   */
+  analyzeGoBareIdentifierUses(rootNode, relationships, symbols) {
+    const fileValues = /* @__PURE__ */ new Set();
+    for (const s of symbols) {
+      if (!s.ownerName && (s.kind === ASTEngine.SymbolKind.Variable || s.kind === ASTEngine.SymbolKind.Constant || s.kind === ASTEngine.SymbolKind.Function)) {
+        fileValues.add(s.name);
+      }
+    }
+    const emitted = /* @__PURE__ */ new Set();
+    const scopeStack = [];
+    const isShadowed = (name) => {
+      for (let i = scopeStack.length - 1; i >= 0; i--) {
+        if (scopeStack[i].names.has(name)) return true;
+      }
+      return false;
+    };
+    const bindNamesUnder = (node, frame) => {
+      const walk = [node];
+      while (walk.length > 0) {
+        const m = walk.pop();
+        if (m !== node && (m.type === "call_expression" || m.type === "composite_literal" || m.type === "func_literal")) {
+          continue;
+        }
+        if (m.type === "identifier" && m.text !== "_") frame.names.add(m.text);
+        for (let i = m.namedChildCount - 1; i >= 0; i--) {
+          const c = m.namedChild(i);
+          if (c) walk.push(c);
+        }
+      }
+    };
+    const bindParamsOf = (declNode, frame) => {
+      if (!declNode) return;
+      const seen = [declNode];
+      while (seen.length > 0) {
+        const m = seen.pop();
+        if (m.type === "parameter_declaration" || m.type === "variadic_parameter_declaration") {
+          for (let i = 0; i < m.namedChildCount; i++) {
+            const c = m.namedChild(i);
+            if (!c) continue;
+            if (c.type === "identifier") {
+              if (c.text !== "_") frame.names.add(c.text);
+            } else {
+              break;
+            }
+          }
+          continue;
+        }
+        for (let i = m.namedChildCount - 1; i >= 0; i--) {
+          const c = m.namedChild(i);
+          if (c) seen.push(c);
+        }
+      }
+    };
+    const isCompositeKey = (node) => {
+      let cur = node.parent;
+      let keyed = null;
+      while (cur) {
+        if (cur.type === "keyed_element") {
+          const first = cur.namedChildCount > 0 ? cur.namedChild(0) : null;
+          if (first && node.startIndex >= first.startIndex && node.endIndex <= first.endIndex) {
+            keyed = cur;
+            break;
+          }
+          return false;
+        }
+        if (cur.type === "composite_literal" || cur.type === "call_expression" || cur.type === "field_declaration" || cur.type === "function_declaration" || cur.type === "method_declaration" || cur.type === "block") return false;
+        cur = cur.parent;
+      }
+      if (!keyed) return false;
+      cur = keyed.parent;
+      while (cur) {
+        if (cur.type === "composite_literal") {
+          for (let i = 0; i < cur.namedChildCount; i++) {
+            const c = cur.namedChild(i);
+            if (c && c.type === "map_type") return false;
+          }
+          return true;
+        }
+        if (cur.type === "call_expression" || cur.type === "field_declaration" || cur.type === "function_declaration" || cur.type === "method_declaration" || cur.type === "block") return true;
+        cur = cur.parent;
+      }
+      return true;
+    };
+    const isChannelOperand = (node) => {
+      let cur = node.parent;
+      let steps = 0;
+      while (cur && steps < 4) {
+        if (cur.type === "send_statement") {
+          const ch = cur.childForFieldName("channel");
+          return !!ch && node.startIndex >= ch.startIndex && node.endIndex <= ch.endIndex;
+        }
+        if (cur.type === "unary_expression") {
+          const op = cur.child(0);
+          if (op && op.type === "<-") return true;
+        }
+        if (cur.type === "receive_statement" || cur.type === "communication_case") return true;
+        if (cur.type === "call_expression" || cur.type === "field_declaration" || cur.type === "function_declaration" || cur.type === "method_declaration" || cur.type === "block" || cur.type === "expression_list") return false;
+        cur = cur.parent;
+        steps++;
+      }
+      return false;
+    };
+    const isCallCallee = (node) => {
+      let top = node;
+      let p = node.parent;
+      while (p && (p.type === "index_expression" || p.type === "generic_type")) {
+        top = p;
+        p = p.parent;
+      }
+      if (!p || p.type !== "call_expression") return false;
+      const fnField = p.childForFieldName("function");
+      if (fnField) return fnField.startIndex === top.startIndex && fnField.endIndex >= top.endIndex;
+      const first = p.namedChild(0);
+      return !!first && first.startIndex === top.startIndex && first.endIndex >= top.endIndex;
+    };
+    const isAssignLhsWrite = (node) => {
+      let cur = node;
+      let p = node.parent;
+      while (p && p.type === "expression_list") {
+        const gp = p.parent;
+        if (gp && gp.type === "assignment_statement") {
+          const lhs = gp.namedChild(0);
+          return !!lhs && cur.startIndex >= lhs.startIndex && cur.endIndex <= lhs.endIndex;
+        }
+        cur = p;
+        p = p.parent;
+      }
+      return false;
+    };
+    const isEntityName = (node) => {
+      const p = node.parent;
+      if (!p) return false;
+      if (p.type === "function_declaration" || p.type === "method_declaration" || p.type === "type_spec" || p.type === "field_declaration" || p.type === "package_clause" || p.type === "label_name") {
+        for (let i = 0; i < p.namedChildCount; i++) {
+          const c = p.namedChild(i);
+          if (c && (c.type === "identifier" || c.type === "type_identifier" || c.type === "field_identifier")) {
+            return c.startIndex === node.startIndex && c.endIndex === node.endIndex;
+          }
+        }
+      }
+      if (p.type === "var_spec" || p.type === "const_spec") {
+        let seenIdent = false;
+        let isFirstIdent = false;
+        let laterNonIdent = false;
+        let found = false;
+        for (let i = 0; i < p.namedChildCount; i++) {
+          const c = p.namedChild(i);
+          if (!c) continue;
+          if (c.type === "identifier") {
+            if (c.startIndex === node.startIndex && c.endIndex === node.endIndex) {
+              if (!seenIdent) isFirstIdent = true;
+              found = true;
+            }
+            seenIdent = true;
+          } else if (found) {
+            laterNonIdent = true;
+          }
+        }
+        return isFirstIdent || laterNonIdent;
+      }
+      if (p.type === "short_var_declaration" || p.type === "expression_list" && p.parent && p.parent.type === "short_var_declaration") {
+        const decl = p.type === "short_var_declaration" ? p : p.parent;
+        const left = decl.childForFieldName("left") ?? decl.namedChild(0);
+        return !!left && node.startIndex >= left.startIndex && node.endIndex <= left.endIndex;
+      }
+      if (p.type === "goto_statement" || p.type === "break_statement" || p.type === "continue_statement" || p.type === "labeled_statement") return true;
+      return false;
+    };
+    const stack = [{ node: rootNode, exit: false, pushed: false }];
+    while (stack.length > 0) {
+      const { node, exit, pushed } = stack.pop();
+      if (exit) {
+        if (pushed) scopeStack.pop();
+        continue;
+      }
+      const t = node.type;
+      let pushedScope = false;
+      if (t === "function_declaration" || t === "method_declaration" || t === "func_literal") {
+        const frame = { names: /* @__PURE__ */ new Set() };
+        for (let i = 0; i < node.namedChildCount; i++) {
+          const c = node.namedChild(i);
+          if (!c) continue;
+          if (c.type === "parameter_list" || c.type === "type_parameter_list") bindParamsOf(c, frame);
+        }
+        scopeStack.push(frame);
+        pushedScope = true;
+      } else if (t === "block") {
+        scopeStack.push({ names: /* @__PURE__ */ new Set() });
+        pushedScope = true;
+      } else if (t === "var_spec" || t === "const_spec" || t === "short_var_declaration" || t === "range_clause" || t === "type_switch_statement") {
+        const top = scopeStack.length > 0 ? scopeStack[scopeStack.length - 1] : null;
+        if (top) {
+          if (t === "range_clause") {
+            for (let i = 0; i < node.namedChildCount - 1; i++) {
+              const c = node.namedChild(i);
+              if (c) bindNamesUnder(c, top);
+            }
+          } else if (t === "type_switch_statement") {
+            if (node.namedChildCount > 2) {
+              const first = node.namedChild(0);
+              if (first) bindNamesUnder(first, top);
+            }
+          } else {
+            const walk = [node];
+            while (walk.length > 0) {
+              const m = walk.pop();
+              if (m !== node && (m.type === "call_expression" || m.type === "composite_literal" || m.type === "func_literal")) {
+                continue;
+              }
+              if (m.type === "identifier" && m.text !== "_" && isEntityName(m)) top.names.add(m.text);
+              for (let i = m.namedChildCount - 1; i >= 0; i--) {
+                const c = m.namedChild(i);
+                if (c) walk.push(c);
+              }
+            }
+          }
+        }
+      } else if (t === "receive_statement") {
+        const top = scopeStack.length > 0 ? scopeStack[scopeStack.length - 1] : null;
+        if (top) {
+          for (let i = 0; i < node.namedChildCount; i++) {
+            const c = node.namedChild(i);
+            if (c && c.type === "expression_list") bindNamesUnder(c, top);
+          }
+        }
+      } else if (t === "identifier") {
+        const name = node.text;
+        const p = node.parent;
+        if (name && name !== "_" && !isEntityName(node) && !isCompositeKey(node) && !isChannelOperand(node) && !isCallCallee(node) && // F6 audit: `field_expression` is not a tree-sitter-go type (that is
+        // rust's name for the shape `r.cfg` here — go uses
+        // `selector_expression`), so the old guard could never fire. It is
+        // also not needed: a selector's receiver is a genuine read
+        // (`x := db.cfg` reads db — probe-verified `f->cfg f->db`), and a
+        // selector that is a call callee is already excluded by
+        // isCallCallee above. Removed rather than re-pointed at
+        // selector_expression, which would silently drop the receiver read.
+        !this.hasGoQualifiedAncestor(node) && // GO9 (second review): assignment LHS is a WRITE — but EVERY
+        // side of every assignment wraps in expression_list, so the old
+        // direct-parent check never fired (see isAssignLhsWrite above).
+        !isAssignLhsWrite(node) && !(p && (p.type === "inc_statement" || p.type === "dec_statement")) && !(p && (p.type === "goto_statement" || p.type === "break_statement" || p.type === "continue_statement" || p.type === "labeled_statement")) && !isShadowed(name) && fileValues.has(name)) {
+          const src = this.resolveGoWorkSource(node);
+          const key = `${src}::uses::${name}`;
+          if (!emitted.has(key)) {
+            emitted.add(key);
+            relationships.push({
+              source: src,
+              target: name,
+              type: ASTEngine.RelationshipType.Uses,
+              confidence: 1,
+              // the identifier's own line.
+              ...this.nodeLine(node) ? { line_number: this.nodeLine(node) } : {},
+              metadata: { relationshipType: "identifier_usage", nodeType: node.type }
+            });
+          }
+        }
+      }
+      stack.push({ node, exit: true, pushed: pushedScope });
+      for (let i = node.namedChildCount - 1; i >= 0; i--) {
+        const child = node.namedChild(i);
+        if (child) stack.push({ node: child, exit: false, pushed: false });
+      }
+    }
+  }
+  /**
+   * Go Selector Expression Uses Analysis
+   * Tracks field access on structs (e.g., b.name, s.users).
+   * Family contract (Rust M12.18): source = containing function/method,
+   * target = FIELD LEAF (not the receiver variable). Selectors that are the
+   * callee of a call_expression (`s.repo.Save(...)`, `strings.ToUpper(...)`)
+   * are handled by the calls analysis and skipped here — one edge per pair.
+   */
+  analyzeGoSelectorUses(rootNode, relationships, symbols) {
+    const stack = [rootNode];
+    const seen = /* @__PURE__ */ new Set();
+    while (stack.length > 0) {
+      const node = stack.pop();
+      if (node.type === "selector_expression") {
+        const operand = node.childForFieldName("operand");
+        const field = node.childForFieldName("field");
+        const isWritePos = node.parent?.type === "inc_statement" || node.parent?.type === "dec_statement" || node.parent?.type === "expression_list" && node.parent.parent?.type === "assignment_statement" && node.parent.parent?.namedChild(0)?.id === node.parent.id;
+        const isChannelOperand = node.parent?.type === "send_statement" || node.parent?.type === "communication_case" || node.parent?.type === "unary_expression" && node.parent.child(0)?.type === "<-" || node.parent?.type === "receive_statement" && node.parent.parent?.type === "communication_case";
+        if (operand && field && node.parent?.type !== "call_expression" && !isWritePos && !isChannelOperand) {
+          const src = this.resolveGoWorkSource(node);
+          const tgt = field.text;
+          const key = `${src}.${tgt}`;
+          if (!seen.has(key)) {
+            seen.add(key);
+            relationships.push({
+              source: src,
+              target: tgt,
+              type: ASTEngine.RelationshipType.Uses,
+              confidence: 0.7,
+              // the FIELD identifier's line, not the receiver's —
+              // the c lane's receiver-start lesson applied to `a.b`.
+              ...this.nodeLine(field) ? { line_number: this.nodeLine(field) } : {},
+              metadata: { relationshipType: "go_selector_use", selectorExpression: key }
+            });
+          }
+        }
+      }
+      for (let i = node.namedChildCount - 1; i >= 0; i--) {
+        const child = node.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+  }
+  /**
+   * Go Import Processing
+   * Handles Go module paths, vendor imports, and package resolution
+   */
+  processGoImports(rootNode, imports) {
+    const stack = [rootNode];
+    while (stack.length > 0) {
+      const node = stack.pop();
+      let claimed = false;
+      if (node.type === "import_spec") {
+        this.processGoImportSpec(node, imports);
+        claimed = true;
+      } else if (node.type === "import_declaration") {
+        this.extractGoImportStatement(node, imports);
+        claimed = true;
+      }
+      if (!claimed) {
+        for (let i = node.namedChildCount - 1; i >= 0; i--) {
+          const child = node.namedChild(i);
+          if (child) stack.push(child);
+        }
+      }
+    }
+  }
+  /**
+   * Extract Go import statement with proper module path handling
+   */
+  extractGoImportStatement(node, imports) {
+    const specs = [];
+    const stack = [node];
+    while (stack.length > 0) {
+      const current = stack.pop();
+      if (current.type === "import_spec") {
+        specs.push(current);
+        continue;
+      }
+      for (let i = current.namedChildCount - 1; i >= 0; i--) {
+        const child = current.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+    for (const spec of specs) {
+      this.processGoImportSpec(spec, imports);
+    }
+  }
+  /**
+   * Process individual Go import specification
+   */
+  processGoImportSpec(spec, imports) {
+    const pathNode = spec.childForFieldName("path");
+    const aliasNode = spec.childForFieldName("name");
+    if (pathNode) {
+      const importPath = this.stripQuotedString(pathNode.text);
+      const alias = aliasNode?.text;
+      const packageName = this.getGoPackageName(importPath);
+      const framework = this.detectFrameworkFromGoImport(importPath);
+      imports.push({
+        module: importPath,
+        isDefault: false,
+        alias,
+        items: [packageName],
+        range: this.nodeToRange(spec),
+        metadata: {
+          isGoImport: true,
+          packageName,
+          framework,
+          isStandardLibrary: this.isGoStandardLibrary(importPath),
+          isThirdParty: this.isGoThirdPartyPackage(importPath)
+        }
+      });
+    }
+  }
+  /**
+   * Go Framework Pattern Analysis
+   */
+  getGoFrameworkPatterns(frameworks, symbols) {
+    const patterns = [];
+    for (const framework of frameworks) {
+      switch (framework) {
+        case "gin":
+          patterns.push({
+            framework: "Gin Web Framework",
+            type: "web_framework",
+            patterns: this.detectGinPatterns(symbols),
+            confidence: 0.9,
+            characteristics: {
+              hasRoutes: someSymbol(
+                symbols,
+                (s) => someSymbol(s.qualified_calls || [], (c) => stringIncludes(c, "gin.") || stringIncludes(c, "router."))
+              ),
+              hasMiddleware: someSymbol(
+                symbols,
+                (s) => someSymbol(s.qualified_calls || [], (c) => stringIncludes(c, "Use("))
+              ),
+              hasHandlers: someSymbol(symbols, (s) => stringIncludes(s.name.toLowerCase(), "handler"))
+            }
+          });
+          break;
+        case "echo":
+          patterns.push({
+            framework: "Echo Web Framework",
+            type: "web_framework",
+            patterns: this.detectEchoPatterns(symbols),
+            confidence: 0.9,
+            characteristics: {
+              hasRoutes: someSymbol(
+                symbols,
+                (s) => someSymbol(s.qualified_calls || [], (c) => stringIncludes(c, "echo.") || stringIncludes(c, "e."))
+              ),
+              hasMiddleware: someSymbol(
+                symbols,
+                (s) => someSymbol(s.qualified_calls || [], (c) => stringIncludes(c, "Use("))
+              ),
+              hasContext: someSymbol(
+                symbols,
+                (s) => someSymbol(s.parameters || [], (p) => stringIncludes(p.type || "", "Context"))
+              )
+            }
+          });
+          break;
+        case "fiber":
+          patterns.push({
+            framework: "Fiber Web Framework",
+            type: "web_framework",
+            patterns: this.detectFiberPatterns(symbols),
+            confidence: 0.9,
+            characteristics: {
+              hasRoutes: someSymbol(
+                symbols,
+                (s) => someSymbol(s.qualified_calls || [], (c) => stringIncludes(c, "fiber.") || stringIncludes(c, "app."))
+              ),
+              hasFastHTTP: someSymbol(
+                symbols,
+                (s) => someSymbol(s.qualified_calls || [], (c) => stringIncludes(c, "fasthttp"))
+              )
+            }
+          });
+          break;
+        case "gorilla_mux":
+          patterns.push({
+            framework: "Gorilla Mux Router",
+            type: "router",
+            patterns: this.detectGorillaMuxPatterns(symbols),
+            confidence: 0.8,
+            characteristics: {
+              hasRoutes: someSymbol(
+                symbols,
+                (s) => someSymbol(
+                  s.qualified_calls || [],
+                  (c) => stringIncludes(c, "mux.") || stringIncludes(c, "HandleFunc")
+                )
+              ),
+              hasSubrouters: someSymbol(
+                symbols,
+                (s) => someSymbol(s.qualified_calls || [], (c) => stringIncludes(c, "PathPrefix"))
+              )
+            }
+          });
+          break;
+        case "gorm":
+          patterns.push({
+            framework: "GORM ORM",
+            type: "orm",
+            patterns: this.detectGORMPatterns(symbols),
+            confidence: 0.9,
+            characteristics: {
+              hasModels: someSymbol(symbols, (s) => s.kind === ASTEngine.SymbolKind.Struct && s.metadata?.isGoStruct),
+              hasMigrations: someSymbol(
+                symbols,
+                (s) => someSymbol(s.qualified_calls || [], (c) => stringIncludes(c, "AutoMigrate"))
+              ),
+              hasQueries: someSymbol(
+                symbols,
+                (s) => someSymbol(s.qualified_calls || [], (c) => stringIncludes(c, "Find") || stringIncludes(c, "Create"))
+              )
+            }
+          });
+          break;
+        case "grpc":
+          patterns.push({
+            framework: "gRPC",
+            type: "rpc_framework",
+            patterns: this.detectGRPCPatterns(symbols),
+            confidence: 0.9,
+            characteristics: {
+              hasServices: someSymbol(symbols, (s) => stringIncludes(s.name.toLowerCase(), "service")),
+              hasProtobuf: someSymbol(
+                symbols,
+                (s) => someSymbol(s.qualified_calls || [], (c) => stringIncludes(c, "proto"))
+              ),
+              hasStreamingMethods: someSymbol(
+                symbols,
+                (s) => someSymbol(s.qualified_calls || [], (c) => stringIncludes(c, "stream"))
+              )
+            }
+          });
+          break;
+      }
+    }
+    return patterns;
+  }
+  /**
+   * Go Architectural Insights
+   */
+  generateGoArchitecturalInsights(symbols, relationships) {
+    const insights = [];
+    const complexFunctions = filterSymbols(
+      symbols,
+      (s) => (s.kind === ASTEngine.SymbolKind.Function || s.kind === ASTEngine.SymbolKind.Method) && !!s.qualified_calls && s.qualified_calls.length > 12
+    );
+    if (complexFunctions.length > 0) {
+      insights.push({
+        type: "complexity_analysis",
+        category: "function_complexity",
+        message: `${complexFunctions.length} functions with high complexity detected`,
+        functions: mapSymbols(complexFunctions, (f) => f.name),
+        recommendation: "Consider breaking down complex functions into smaller, focused functions",
+        severity: "warning"
+      });
+    }
+    const goroutineFunctions = getUniqueStrings(
+      mapSymbols(
+        filterSymbols(relationships, (r) => r.metadata?.relationshipType === "go_goroutine" && !!r.source),
+        (r) => r.source
+      )
+    );
+    if (goroutineFunctions.length > 0) {
+      insights.push({
+        type: "concurrency_pattern",
+        category: "goroutines",
+        message: `Goroutine usage detected in ${goroutineFunctions.length} functions`,
+        functions: goroutineFunctions,
+        recommendation: "Ensure proper goroutine lifecycle management and channel synchronization"
+      });
+    }
+    const channelFunctions = getUniqueStrings(
+      mapSymbols(
+        filterSymbols(relationships, (r) => r.metadata?.relationshipType === "go_channel_operation" && !!r.source),
+        (r) => r.source
+      )
+    );
+    if (channelFunctions.length > 0) {
+      insights.push({
+        type: "concurrency_pattern",
+        category: "channels",
+        message: `Channel communication pattern detected in ${channelFunctions.length} functions`,
+        functions: channelFunctions,
+        recommendation: "Follow channel ownership patterns and avoid goroutine leaks"
+      });
+    }
+    const structs = filterSymbols(symbols, (s) => s.kind === ASTEngine.SymbolKind.Struct && s.metadata?.isGoStruct);
+    const methods = filterSymbols(symbols, (s) => s.kind === ASTEngine.SymbolKind.Method);
+    if (structs.length > 0) {
+      const methodToStructRatio = methods.length / structs.length;
+      insights.push({
+        type: "design_pattern",
+        category: "struct_design",
+        message: `${structs.length} structs with ${methods.length} methods (ratio: ${methodToStructRatio.toFixed(2)})`,
+        structs: mapSymbols(structs, (s) => s.name),
+        quality: methodToStructRatio > 3 ? "rich_behavior" : methodToStructRatio > 1 ? "balanced" : "anemic_structs",
+        recommendation: methodToStructRatio < 1 ? "Consider adding methods to structs for better encapsulation" : "Good struct-method balance"
+      });
+    }
+    const errorHandling = this.analyzeGoErrorHandling(symbols);
+    if (errorHandling.functions > 0) {
+      insights.push({
+        type: "error_handling",
+        category: "go_errors",
+        message: `Error handling detected in ${errorHandling.functions} functions`,
+        coverage: `${(errorHandling.withErrorHandling / errorHandling.functions * 100).toFixed(1)}%`,
+        recommendation: errorHandling.withErrorHandling / errorHandling.functions < 0.7 ? "Improve error handling coverage" : "Good error handling practices"
+      });
+    }
+    const interfaces = filterSymbols(symbols, (s) => s.kind === ASTEngine.SymbolKind.Interface);
+    if (interfaces.length > 0) {
+      insights.push({
+        type: "design_pattern",
+        category: "interfaces",
+        message: `${interfaces.length} interfaces promoting loose coupling`,
+        interfaces: mapSymbols(interfaces, (i) => i.name),
+        recommendation: "Good use of Go interfaces for abstraction"
+      });
+    }
+    return insights;
+  }
+  // ======================== GO FRAMEWORK DETECTION METHODS ========================
+  detectGinPatterns(symbols) {
+    const patterns = [];
+    if (someSymbol(
+      symbols,
+      (s) => someSymbol(s.qualified_calls || [], (c) => stringIncludes(c, "gin.Default") || stringIncludes(c, "gin.New"))
+    )) {
+      patterns.push("gin_router_setup");
+    }
+    if (someSymbol(
+      symbols,
+      (s) => someSymbol(
+        s.qualified_calls || [],
+        (c) => stringIncludes(c, "GET") || stringIncludes(c, "POST") || stringIncludes(c, "PUT")
+      )
+    )) {
+      patterns.push("rest_endpoints");
+    }
+    if (someSymbol(symbols, (s) => someSymbol(s.qualified_calls || [], (c) => stringIncludes(c, "Group(")))) {
+      patterns.push("route_grouping");
+    }
+    if (someSymbol(symbols, (s) => someSymbol(s.qualified_calls || [], (c) => stringIncludes(c, "Use(")))) {
+      patterns.push("middleware_usage");
+    }
+    return patterns;
+  }
+  detectEchoPatterns(symbols) {
+    const patterns = [];
+    if (someSymbol(symbols, (s) => someSymbol(s.qualified_calls || [], (c) => stringIncludes(c, "echo.New")))) {
+      patterns.push("echo_setup");
+    }
+    if (someSymbol(symbols, (s) => someSymbol(s.parameters || [], (p) => stringIncludes(p.type || "", "echo.Context")))) {
+      patterns.push("echo_context_usage");
+    }
+    if (someSymbol(symbols, (s) => someSymbol(s.qualified_calls || [], (c) => stringIncludes(c, "Bind(")))) {
+      patterns.push("request_binding");
+    }
+    return patterns;
+  }
+  detectFiberPatterns(symbols) {
+    const patterns = [];
+    if (someSymbol(symbols, (s) => someSymbol(s.qualified_calls || [], (c) => stringIncludes(c, "fiber.New")))) {
+      patterns.push("fiber_app_setup");
+    }
+    if (someSymbol(symbols, (s) => someSymbol(s.qualified_calls || [], (c) => stringIncludes(c, "BodyParser(")))) {
+      patterns.push("request_parsing");
+    }
+    return patterns;
+  }
+  detectGorillaMuxPatterns(symbols) {
+    const patterns = [];
+    if (someSymbol(symbols, (s) => someSymbol(s.qualified_calls || [], (c) => stringIncludes(c, "mux.NewRouter")))) {
+      patterns.push("gorilla_router_setup");
+    }
+    if (someSymbol(symbols, (s) => someSymbol(s.qualified_calls || [], (c) => stringIncludes(c, "HandleFunc(")))) {
+      patterns.push("route_handlers");
+    }
+    if (someSymbol(symbols, (s) => someSymbol(s.qualified_calls || [], (c) => stringIncludes(c, "PathPrefix(")))) {
+      patterns.push("path_prefixes");
+    }
+    return patterns;
+  }
+  detectGORMPatterns(symbols) {
+    const patterns = [];
+    if (someSymbol(symbols, (s) => someSymbol(s.qualified_calls || [], (c) => stringIncludes(c, "gorm.Open")))) {
+      patterns.push("gorm_connection");
+    }
+    if (someSymbol(symbols, (s) => someSymbol(s.qualified_calls || [], (c) => stringIncludes(c, "AutoMigrate(")))) {
+      patterns.push("auto_migration");
+    }
+    if (someSymbol(
+      symbols,
+      (s) => someSymbol(s.qualified_calls || [], (c) => stringIncludes(c, "Create(") || stringIncludes(c, "Find("))
+    )) {
+      patterns.push("crud_operations");
+    }
+    return patterns;
+  }
+  detectGRPCPatterns(symbols) {
+    const patterns = [];
+    if (someSymbol(
+      symbols,
+      (s) => stringIncludes(s.name.toLowerCase(), "service") && s.kind === ASTEngine.SymbolKind.Struct
+    )) {
+      patterns.push("grpc_services");
+    }
+    if (someSymbol(symbols, (s) => someSymbol(s.qualified_calls || [], (c) => stringIncludes(c, "grpc.NewServer")))) {
+      patterns.push("grpc_server_setup");
+    }
+    return patterns;
+  }
+  // ======================== GO HELPER METHODS ========================
+  // GO2: plain-identifier shape check (no regex): letter/underscore head,
+  // word-class tail. Recovery-artifact names (qualified, templated,
+  // operator-soup like `~int | ~string`) fail and emit no symbol/edge.
+  isPlainGoIdentifier(s) {
+    if (s.length === 0) return false;
+    const c0 = s.charCodeAt(0);
+    const firstOk = c0 >= 65 && c0 <= 90 || c0 >= 97 && c0 <= 122 || c0 === 95;
+    if (!firstOk) return false;
+    for (let i = 1; i < s.length; i++) {
+      const c = s.charCodeAt(i);
+      const ok = c >= 65 && c <= 90 || c >= 97 && c <= 122 || c >= 48 && c <= 57 || c === 95;
+      if (!ok) return false;
+    }
+    return true;
+  }
+  // ---- Pure-string helpers (M12.22: no regex in this analyzer) ----
+  /** Strip surrounding backticks/quote chars from a raw string literal. */
+  stripRawStringDelimiters(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;
+  }
+  /** Strip surrounding double quotes from an interpreted string literal. */
+  stripQuotedString(text) {
+    const q = text.length >= 2 ? text[0] : "";
+    if ((q === '"' || q === "`") && text[text.length - 1] === q) {
+      return text.slice(1, -1);
+    }
+    return text;
+  }
+  /** Parse struct tags `json:"name" db:"x"` into key -> value (no regex). */
+  parseStructTags(tagText) {
+    const result = /* @__PURE__ */ Object.create(null);
+    let i = 0;
+    const n = tagText.length;
+    while (i < n) {
+      while (i < n && (tagText[i] === " " || tagText[i] === "	")) i++;
+      if (i >= n) break;
+      const keyStart = i;
+      while (i < n && tagText[i] !== ":" && tagText[i] !== " " && tagText[i] !== "	") i++;
+      if (i >= n || tagText[i] !== ":") break;
+      const key = tagText.slice(keyStart, i);
+      i++;
+      if (i < n && tagText[i] === '"') {
+        i++;
+        let value = "";
+        while (i < n && tagText[i] !== '"') {
+          if (tagText[i] === "\\" && i + 1 < n) {
+            value += tagText[i + 1];
+            i += 2;
+          } else {
+            value += tagText[i];
+            i++;
+          }
+        }
+        i++;
+        if (key) result[key] = value;
+      }
+    }
+    return result;
+  }
+  /**
+   * Swaggo @Router annotation: `@Router /path/to/endpoint [method]`.
+   * Case-insensitive marker, whitespace-tolerant pure scan (no regex).
+   */
+  parseRouterAnnotation(comment) {
+    const marker = "@Router";
+    const idx = this.indexOfIgnoreCase(comment, marker);
+    if (idx < 0) return void 0;
+    const after = comment.slice(idx + marker.length);
+    const path = this.readToken(after);
+    if (!path) return void 0;
+    const open = after.indexOf("[", after.indexOf(path) + path.length);
+    if (open < 0) return void 0;
+    const close = after.indexOf("]", open);
+    if (close < 0) return void 0;
+    const method = after.slice(open + 1, close).trim();
+    if (!method) return void 0;
+    return `${method.toUpperCase()} ${path}`;
+  }
+  indexOfIgnoreCase(text, search) {
+    const lower = text.toLowerCase();
+    const target = search.toLowerCase();
+    return lower.indexOf(target);
+  }
+  /** Read the next whitespace-delimited token. */
+  readToken(text) {
+    const n = text.length;
+    let i = 0;
+    while (i < n && (text[i] === " " || text[i] === "	")) i++;
+    if (i >= n) return void 0;
+    const start = i;
+    while (i < n && text[i] !== " " && text[i] !== "	") i++;
+    return text.slice(start, i);
+  }
+  /** Normalize a Go signature: collapse whitespace, variadic, interface{} (no regex). */
+  normalizeGoSignature(sig) {
+    let collapsed = "";
+    let prevSpace = false;
+    for (let i = 0; i < sig.length; i++) {
+      const ch = sig[i];
+      if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") {
+        if (!prevSpace && collapsed.length > 0) collapsed += " ";
+        prevSpace = true;
+      } else {
+        collapsed += ch;
+        prevSpace = false;
+      }
+    }
+    let variadic = "";
+    for (let i = 0; i < collapsed.length; i++) {
+      const ch = collapsed[i];
+      if (ch === "." && collapsed[i + 1] === "." && collapsed[i + 2] === ".") {
+        if (variadic.length > 0 && variadic[variadic.length - 1] === " ") {
+          variadic = variadic.slice(0, -1);
+        }
+        variadic += "...";
+        i += 2;
+      } else {
+        variadic += ch;
+      }
+    }
+    let result = "";
+    let k = 0;
+    while (k < variadic.length) {
+      if (variadic[k] === "i" && variadic.slice(k, k + 11) === "interface{}") {
+        result += "any";
+        k += 11;
+      } else {
+        result += variadic[k];
+        k++;
+      }
+    }
+    let start = 0;
+    let end = result.length;
+    while (start < end && result[start] === " ") start++;
+    while (end > start && result[end - 1] === " ") end--;
+    return result.slice(start, end);
+  }
+  getGoPackageName(importPath) {
+    const parts = importPath.split("/");
+    return parts[parts.length - 1];
+  }
+  detectFrameworkFromGoImport(importPath) {
+    for (const rule of GO_FRAMEWORK_RULES) {
+      if (rule.matches(importPath)) return rule.name;
+    }
+    return void 0;
+  }
+  isGoStandardLibrary(importPath) {
+    const stdLibPrefixes = [
+      "fmt",
+      "net/http",
+      "os",
+      "io",
+      "strings",
+      "strconv",
+      "time",
+      "json",
+      "context",
+      "sync",
+      "log",
+      "bufio",
+      "bytes",
+      "crypto",
+      "database/sql",
+      "encoding",
+      "errors",
+      "flag",
+      "html",
+      "math",
+      "path",
+      "reflect",
+      "regexp",
+      "runtime",
+      "sort",
+      "testing",
+      "unicode",
+      "unsafe"
+    ];
+    return someSymbol(stdLibPrefixes, (prefix) => importPath === prefix || importPath.startsWith(prefix + "/")) || !stringIncludes(importPath, ".");
+  }
+  isGoThirdPartyPackage(importPath) {
+    return stringIncludes(importPath, ".") && !this.isGoStandardLibrary(importPath);
+  }
+  analyzeGoErrorHandling(symbols) {
+    const functions = filterSymbols(
+      symbols,
+      (s) => s.kind === ASTEngine.SymbolKind.Function || s.kind === ASTEngine.SymbolKind.Method
+    );
+    let withErrorHandling = 0;
+    for (const func of functions) {
+      if (func.metadata?.hasErrorHandling) {
+        withErrorHandling++;
+      }
+    }
+    return { functions: functions.length, withErrorHandling };
+  }
+  /**
+   * Go Architectural Score Calculation
+   */
+  calculateArchitecturalScore(symbols, relationships, patterns) {
+    let score = 75;
+    if (inArray(patterns, "error_handling")) score += 8;
+    if (inArray(patterns, "goroutines")) score += 6;
+    if (inArray(patterns, "channels")) score += 6;
+    if (inArray(patterns, "interfaces")) score += 5;
+    if (inArray(patterns, "dependency_injection")) score += 4;
+    const structs = filterSymbols(symbols, (s) => s.kind === ASTEngine.SymbolKind.Struct && s.metadata?.isGoStruct);
+    const methods = filterSymbols(symbols, (s) => s.kind === ASTEngine.SymbolKind.Method);
+    if (structs.length > 0) {
+      const methodToStructRatio = methods.length / structs.length;
+      if (methodToStructRatio >= 1 && methodToStructRatio <= 5) score += 3;
+    }
+    const interfaces = filterSymbols(symbols, (s) => s.kind === ASTEngine.SymbolKind.Interface);
+    if (interfaces.length > 0) {
+      score += Math.min(interfaces.length * 2, 6);
+    }
+    const complexFunctions = filterSymbols(symbols, (s) => !!s.qualified_calls && s.qualified_calls.length > 12);
+    score -= complexFunctions.length * 2;
+    return Math.max(40, Math.min(100, score));
+  }
+  /**
+   * Go Code Quality Assessment
+   */
+  assessCodeQuality(symbols, relationships, patterns) {
+    const score = this.calculateArchitecturalScore(symbols, relationships, patterns);
+    if (score >= 90) return "exceptional";
+    if (score >= 80) return "excellent";
+    if (score >= 70) return "good";
+    if (score >= 60) return "fair";
+    if (score >= 50) return "needs_improvement";
+    return "poor";
+  }
+  /**
+   * Go Cyclomatic Complexity Calculation
+   * Calculates complexity for Go code including goroutines, channels, defer, type switches, and Go-specific patterns
+   */
+  calculateCyclomaticComplexity(node) {
+    let complexity = 1;
+    const traverse = (n) => {
+      switch (n.type) {
+        case "if_statement":
+        case "for_statement":
+        case "expression_case":
+        case "type_case":
+        case "communication_case":
+        case "default_case":
+          complexity++;
+          break;
+        case "binary_expression": {
+          const txt = n.text;
+          if (stringIncludes(txt, "&&") || stringIncludes(txt, "||")) complexity++;
+          break;
+        }
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const child = n.namedChild(i);
+        if (child) traverse(child);
+      }
+    };
+    traverse(node);
+    return complexity;
+  }
+  // ===== GO HELPER METHODS FOR RELATIONSHIP ANALYSIS =====
+  /**
+   * Find child node by type
+   */
+  findChildByType(node, type) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child?.type === type) return child;
+    }
+    return null;
+  }
+  findChildrenByType(node, type) {
+    const results = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child?.type === type) results.push(child);
+    }
+    return results;
+  }
+  /**
+   * The embedded fields of a struct, as NODES. the `extends`
+   * edge these feed carries the embedded TYPE's own line, so the walk has to
+   * return the node the name is written on and not just its text.
+   *
+   * GO26 (round 5): the `extractGoEmbeddedTypes` TEXT form is removed. It was
+   * defined to delegate here and had no call site anywhere in the repository —
+   * a second entry point onto the same walk, and therefore a second thing that
+   * could drift from it. There is now exactly one.
+   */
+  extractGoEmbeddedTypeNodes(structNode) {
+    const embeddedTypes = [];
+    const fieldList = this.findChildByType(structNode, "field_declaration_list");
+    if (fieldList) {
+      for (let i = 0; i < fieldList.namedChildCount; i++) {
+        const field = fieldList.namedChild(i);
+        if (field?.type === "field_declaration") {
+          const fieldNames = [];
+          for (let j = 0; j < field.namedChildCount; j++) {
+            const c = field.namedChild(j);
+            if (c && (c.type === "field_identifier" || c.type === "identifier")) fieldNames.push(c);
+          }
+          if (fieldNames.length === 0) {
+            const typeNode = field.childForFieldName("type") || this.findChildByType(field, "type_identifier");
+            if (typeNode) {
+              embeddedTypes.push(typeNode);
+            }
+          }
+        }
+      }
+    }
+    return embeddedTypes;
+  }
+  /**
+   * Get interface methods from interface symbol
+   */
+  getGoInterfaceMethods(interfaceSymbol, symbols, visiting) {
+    const seen = visiting ?? /* @__PURE__ */ new Set();
+    if (seen.has(interfaceSymbol.name)) return [];
+    seen.add(interfaceSymbol.name);
+    const interfaceMethods = [];
+    const methods = filterSymbols(
+      symbols,
+      (s) => s.kind === ASTEngine.SymbolKind.Method && s.ownerName === interfaceSymbol.name
+    );
+    forEachSymbol(methods, (method) => {
+      const signature = this.buildGoMethodSignature(method);
+      interfaceMethods.push({
+        name: method.name,
+        signature
+      });
+    });
+    const embedded = filterSymbols(
+      symbols,
+      (s) => s.ownerName === interfaceSymbol.name && s.ownerKind === ASTEngine.SymbolKind.Interface && s.metadata?.isEmbeddedInterface
+    );
+    forEachSymbol(embedded, (entry) => {
+      const target = findSymbol(
+        symbols,
+        (s) => s.kind === ASTEngine.SymbolKind.Interface && s.name === entry.name && !s.metadata?.isEmbeddedInterface
+      );
+      if (!target) return;
+      const inherited = this.getGoInterfaceMethods(target, symbols, seen);
+      forEachSymbol(inherited, (m) => {
+        if (!someSymbol(interfaceMethods, (x) => x.name === m.name && x.signature === m.signature)) {
+          interfaceMethods.push(m);
+        }
+      });
+    });
+    seen.delete(interfaceSymbol.name);
+    return interfaceMethods;
+  }
+  /**
+   * Check if struct implements interface (Go's implicit interface implementation)
+   */
+  checkGoInterfaceImplementation(interfaceMethods, structMethods) {
+    const matchedMethods = [];
+    const totalMethods = interfaceMethods.length;
+    if (totalMethods === 0) {
+      return { implements: false, confidence: 0, matchedMethods: [] };
+    }
+    const available = /* @__PURE__ */ new Set();
+    forEachSymbol(structMethods, (m) => {
+      available.add(`${m.name}\0${this.normalizeGoSignature(this.buildGoMethodSignature(m))}`);
+    });
+    forEachSymbol(interfaceMethods, (interfaceMethod) => {
+      if (available.has(`${interfaceMethod.name}\0${this.normalizeGoSignature(interfaceMethod.signature)}`)) {
+        matchedMethods.push(interfaceMethod.name);
+      }
+    });
+    const doesImplement = matchedMethods.length === totalMethods;
+    const confidence = doesImplement ? 1 : matchedMethods.length / totalMethods;
+    return { implements: doesImplement, confidence, matchedMethods };
+  }
+  /**
+   * Build Go method signature for comparison
+   */
+  buildGoMethodSignature(method) {
+    const key = method.range?.startIndex;
+    if (typeof key === "number") {
+      const hit = this.goSignatures.get(key);
+      if (hit !== void 0) return hit;
+    }
+    const params = mapSymbols(method.parameters || [], (p) => (p.isVariadic ? "..." : "") + (p.type || "interface{}")).join(", ") || "";
+    const returnType = method.returnType || "void";
+    const sig = `${method.name}(${params}) ${returnType}`;
+    if (typeof key === "number") this.goSignatures.set(key, sig);
+    return sig;
+  }
+  /**
+   * The name of THIS file's own package, read from the grammar.
+   *
+   * `package_clause` has NO fields in tree-sitter-go 0.25.0's node-types.json:
+   * the identifier is a plain named child. Reading `childForFieldName("name")`
+   * here returns "" and the caller would then reject EVERY selector callee,
+   * silently deleting the self-qualified constructions the edge is supposed to
+   * carry — the same class of silent total loss the oracle hit on its first run.
+   */
+  goOwnPackageName(rootNode) {
+    const pkgClause = this.findChildByType(rootNode, "package_clause");
+    if (!pkgClause) return "";
+    for (let i = 0; i < pkgClause.namedChildCount; i++) {
+      const c = pkgClause.namedChild(i);
+      if (c && c.type === "package_identifier") return String(c.text ?? "");
+    }
+    return "";
+  }
+  /**
+   * Can this call's callee be the top-level function THIS FILE declares?
+   *
+   * The `instantiates` edge's target is always a symbol from this file's own
+   * symbol table, so the question is not "is this a package-qualified call" —
+   * it is "does this call select something this file could be responsible for".
+   * Two shapes qualify:
+   *
+   *   `NewReader(1)`          a bare identifier call. In Go a bare call at
+   *                           package scope can only reach a name in this
+   *                           package (or a dot-imported one, which the
+   *                           leniency parameter already handles).
+   *   `calleeshape.NewReader(3)` the file's OWN package name as the qualifier.
+   *                           Legal Go — `src/html/template/escape.go:977` is
+   *                           `func HTMLEscape(...) { template.HTMLEscape(w, b) }`
+   *                           — and it selects this file's top-level function.
+   *
+   * Any OTHER qualifier does not qualify, and the reason is the bug this method
+   * exists for. `bufio.NewReader(r)` is a top-level function of `bufio`, but the
+   * `instantiates` target had to come from THIS file's symbol table, so a file
+   * that happened to declare its own `NewReader` published
+   * `instantiates ReceiverCollision -> NewReader` for a construction it did not
+   * perform. The callee's shape was right; the callee's PACKAGE was not the one
+   * the target symbol lives in. Counting import aliases as qualifiers does not
+   * fix this — an alias can collide with a same-named local function just as
+   * easily as a package name can.
+   *
+   * Measured over a 500-file stride sample of go-stdlib: 155 `instantiates`
+   * edges at confidence 0.6, 8 of them (6 files) naming a symbol in the wrong
+   * package. See validation/m14/go/go-mislabel-probe.ts and the fixture
+   * `instantiates-callee-shape`.
+   */
+  isGoTopLevelFunctionCallee(calleeNode, ownPackageName) {
+    if (!calleeNode) return false;
+    if (calleeNode.type === "identifier") return true;
+    if (calleeNode.type !== "selector_expression") return false;
+    const operand = calleeNode.childForFieldName("operand");
+    if (!operand || operand.type !== "identifier") return false;
+    if (ownPackageName.length === 0) return false;
+    return String(operand.text ?? "") === ownPackageName;
+  }
+  /**
+   * Resolve Go function call to find target
+   */
+  resolveGoFunctionCall(callExpression, symbols, dotImported = false) {
+    if (stringIncludes(callExpression, ".")) {
+      const parts = callExpression.split(".");
+      const functionName = parts[parts.length - 1];
+      if (!functionName) return void 0;
+      const fallback = findSymbol(symbols, (s) => this.isGoPackageCallable(s) && s.name === functionName);
+      return fallback?.name ?? functionName;
+    }
+    if (dotImported) return callExpression || void 0;
+    const targetFunction = findSymbol(symbols, (s) => this.isGoPackageCallable(s) && s.name === callExpression);
+    return targetFunction?.name;
+  }
+  /**
+   * Extract Go package name from content
+   */
+  findGoPackageClause(rootNode) {
+    return this.findChildByType(rootNode, "package_clause") ?? void 0;
+  }
+  /**
+   * The package name a `package_clause` declares. M14.0.F1 (#880):
+   * `package_clause` declares NO fields in this grammar, so the old
+   * `childForFieldName("package_identifier")` could never match (that is a
+   * node TYPE, not a field) and the named-child fallback carried the value all
+   * along. Read the node by TYPE, so the audit's field table and this lookup
+   * agree.
+   */
+  goPackageClauseName(clause) {
+    const pkgId = this.findChildByType(clause, "package_identifier") ?? clause.namedChild(0);
+    return pkgId ? pkgId.text : void 0;
+  }
+  /**
+   * Extract function called in goroutine
+   */
+  extractGoRoutineFunction(node) {
+    const callExpr = this.findChildByType(node, "call_expression");
+    if (callExpr) {
+      const functionNode = callExpr.childForFieldName("function");
+      return this.resolveGoCallLeaf(functionNode);
+    }
+    return void 0;
+  }
+  /**
+   * Find containing Go function for a node
+   */
+  findContainingGoFunction(node) {
+    let current = node.parent;
+    while (current) {
+      if (current.type === "function_declaration" || current.type === "method_declaration") {
+        const nameNode = current.childForFieldName("name");
+        return nameNode?.text;
+      }
+      current = current.parent;
+    }
+    return void 0;
+  }
+  /**
+   * GOD12 (round 7): the SOURCE for work done inside a PACKAGE-SCOPE initializer.
+   *
+   * `findContainingGoFunction` walks up for a `function_declaration` or
+   * `method_declaration` and returns undefined when there is none, and every
+   * caller turned that into the `global` pseudo-source. That is correct for a
+   * statement at file scope and wrong for the very common
+   *
+   *     var re = regexp.MustCompile(`...`)
+   *     var api = http.Client{Timeout: time.Second}
+   *     var host = os.Getenv("HOST") + ".example.com"
+   *
+   * where the call, the construction and the selector read are all work the
+   * DECLARATION is doing, for a binding the analyzer has already published as a
+   * symbol. At full extent that was 6,723 edges whose source named nothing:
+   * 3,396 `uses`, 1,391 `calls`, 985 `instantiates`, 947 `references`.
+   *
+   * The rule is the one the declared-type pass already follows: a declaration
+   * attributes to what it declares. `global` remains the answer for work that is
+   * genuinely at file scope, and a FUNCTION-LOCAL `var` deliberately does not
+   * use its name — LocalsAreNotSymbols makes a local var not a symbol, so
+   * naming it would trade one unresolvable source for another. A `func_literal`
+   * is skipped rather than treated as a stop, which is the pre-existing
+   * behaviour and is also what makes `var y = func() { f() }()` attribute to `y`.
+   */
+  resolveGoWorkSource(node) {
+    const declaredNameOf = (spec) => {
+      for (let q = spec.parent; q; q = q.parent) {
+        if (q.type === "function_declaration" || q.type === "method_declaration" || q.type === "func_literal") return void 0;
+      }
+      for (let i = 0; i < spec.namedChildCount; i++) {
+        const c = spec.namedChild(i);
+        if (c && c.type === "identifier" && String(c.text ?? "") !== "_") return String(c.text ?? "");
+      }
+      return void 0;
+    };
+    for (let q = node; q; q = q.parent) {
+      if (q.type === "function_declaration" || q.type === "method_declaration") {
+        for (let i = 0; i < q.namedChildCount; i++) {
+          const c = q.namedChild(i);
+          if (!c) continue;
+          if (q.type === "method_declaration" && c.type === "field_identifier" || q.type === "function_declaration" && c.type === "identifier") return String(c.text ?? "");
+        }
+        return "global";
+      }
+      if (q.type === "var_spec" || q.type === "const_spec") {
+        const nm = declaredNameOf(q);
+        if (nm) return nm;
+      }
+    }
+    return "global";
+  }
+  /**
+   * Extract channel variable from channel operation
+   */
+  // GOD8 (M37 #604 wave-3): channel-op target resolution. Returns the
+  // channel's declared-name LEAF for (a) a bare identifier naming a
+  // PACKAGE-scope var/const (caller gates via isGoDeclaredPackageVar) and
+  // (b) a member selector (leaf = field name — the channel-op pass owns
+  // member channel edges with send/receive direction, so the selector pass
+  // skips channel operands). Call results (`<-ctx.Done()`) and bare
+  // LOCAL/param channels (`c <- v`) have no declared channel symbol and
+  // return undefined (LocalsAreNotSymbols — same resolvability gate the
+  // goroutine/defer branches apply via isGoResolvableCallTarget).
+  extractGoChannelVariable(node) {
+    const operandNode = (n) => {
+      if (n.type === "send_statement") {
+        const c = n.childForFieldName("channel");
+        return c?.type === "identifier" || c?.type === "selector_expression" ? c : void 0;
+      }
+      const direct = n.childForFieldName("operand") || (n.namedChildCount > 0 ? n.namedChild(0) : void 0);
+      const unwrapped = direct && (direct.type === "unary_expression" || direct.type === "receive_statement") ? direct.namedChildCount > 0 ? direct.namedChild(0) : void 0 : direct;
+      return unwrapped?.type === "identifier" || unwrapped?.type === "selector_expression" ? unwrapped : void 0;
+    };
+    if (node.type === "send_statement" || node.type === "receive_statement" || this.isGoReceiveExpression(node)) {
+      const op = operandNode(node);
+      if (!op) return void 0;
+      if (op.type === "identifier") return { name: op.text, member: false };
+      if (op.type === "selector_expression") {
+        const f = op.childForFieldName("field");
+        return f ? { name: f.text, member: true } : void 0;
+      }
+    }
+    return void 0;
+  }
+  isGoReceiveExpression(node) {
+    return node.type === "unary_expression" && node.child(0)?.type === "<-";
+  }
+  // GOD8: a bare identifier is a valid channel-op target only when it names a
+  // declared PACKAGE-scope var/const (LocalsAreNotSymbols — locals/params
+  // never qualify; the same resolvability gate the goroutine/defer branches
+  // apply via isGoResolvableCallTarget). Member selectors (member=true) are
+  // always valid — the field is a declared member.
+  isGoDeclaredPackageVar(name, symbols) {
+    return someSymbol(
+      symbols,
+      (s) => s.name === name && (s.kind === ASTEngine.SymbolKind.Variable || s.kind === ASTEngine.SymbolKind.Constant) && !s.ownerName
+    );
+  }
+  /**
+   * Extract deferred function from defer statement
+   */
+  extractDeferredFunction(node) {
+    const callExpr = this.findChildByType(node, "call_expression");
+    if (callExpr) {
+      const functionNode = callExpr.childForFieldName("function");
+      return this.resolveGoCallLeaf(functionNode);
+    }
+    return void 0;
+  }
+  extractGoMethodSpecParameters(node) {
+    const parameters = [];
+    const paramList = this.findChildByType(node, "parameter_list");
+    if (!paramList) return parameters;
+    for (let i = 0; i < paramList.namedChildCount; i++) {
+      const param = paramList.namedChild(i);
+      const isVariadic = param?.type === "variadic_parameter_declaration";
+      if (param?.type !== "parameter_declaration" && !isVariadic) continue;
+      const typeNode = param.childForFieldName("type");
+      const nameNodes = [];
+      for (let j = 0; j < param.namedChildCount; j++) {
+        const c = param.namedChild(j);
+        if (c && c.type === "identifier") nameNodes.push(c);
+      }
+      if (nameNodes.length > 0) {
+        for (const nameNode of nameNodes) {
+          if (!nameNode) continue;
+          parameters.push({
+            name: nameNode.text,
+            type: typeNode?.text,
+            isOptional: false,
+            ...isVariadic ? { isVariadic: true } : {}
+          });
+        }
+      } else if (typeNode) {
+        parameters.push({
+          name: `arg${parameters.length}`,
+          type: typeNode.text,
+          isOptional: false,
+          ...isVariadic ? { isVariadic: true } : {}
+        });
+      }
+    }
+    return parameters;
+  }
+  extractGoMethodSpecReturnType(node) {
+    const resultNode = node.childForFieldName("result");
+    if (resultNode) {
+      if (resultNode.type === "parameter_list") {
+        const types = [];
+        for (let i = 0; i < resultNode.namedChildCount; i++) {
+          const p = resultNode.namedChild(i);
+          if (!p || p.type !== "parameter_declaration") continue;
+          const t = p.childForFieldName("type");
+          if (!t) continue;
+          let names = 0;
+          for (let j = 0; j < p.namedChildCount; j++) {
+            const c = p.namedChild(j);
+            if (c && c.type === "identifier") names++;
+          }
+          for (let k = 0; k < Math.max(1, names); k++) types.push(t.text);
+        }
+        if (types.length === 1) return types[0];
+        if (types.length > 1) return `(${types.join(", ")})`;
+        return resultNode.text;
+      }
+      return resultNode.text;
+    }
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child && inArray(
+        [
+          "type_identifier",
+          "qualified_type",
+          "pointer_type",
+          "slice_type",
+          "array_type",
+          "map_type",
+          "channel_type",
+          "function_type"
+        ],
+        child.type
+      )) {
+        return child.text;
+      }
+    }
+    return void 0;
+  }
+  hasGoErrorHandling(text) {
+    if (!text) return false;
+    return stringIncludes(text, "err != nil") || stringIncludes(text, "fmt.Errorf(") || stringIncludes(text, "errors.New(") || stringIncludes(text, "panic(");
+  }
+};
+export {
+  GO_STDLIB_TOP_LEVEL,
+  RealGoAnalyzer
+};