gitnexus 1.6.10-rc.98 → 1.6.10

package/dist/core/ingestion/languages/dart/import-target.js

@@ -12,7 +12,34 @@
  * The `ScopeResolver` hook signature is `(targetRaw, fromFile, allFilePaths)`;
  * `targetRaw` arrives already quote-stripped from `interpretDartImport`.
  */
+import { perFileSet } from '../../import-resolvers/per-file-set.js';
 import { DART_HERITAGE_PREFIX } from './interpret.js';
+const getDartFileIndex = perFileSet((allFilePaths) => {
+    const byBasename = new Map();
+    for (const fp of allFilePaths) {
+        const base = fp.slice(fp.lastIndexOf('/') + 1);
+        let bucket = byBasename.get(base);
+        if (bucket === undefined) {
+            bucket = [];
+            byBasename.set(base, bucket);
+        }
+        bucket.push(fp);
+    }
+    return { byBasename };
+});
+/** First file (in Set-iteration order) that IS `candidate` or ends with
+ *  `/<candidate>` — the exact predicate of the scans this replaces. */
+function findByPathSuffix(allFilePaths, candidate) {
+    const bucket = getDartFileIndex(allFilePaths).byBasename.get(candidate.slice(candidate.lastIndexOf('/') + 1));
+    if (bucket === undefined)
+        return null;
+    const suffix = '/' + candidate;
+    for (const fp of bucket) {
+        if (fp === candidate || fp.endsWith(suffix))
+            return fp;
+    }
+    return null;
+}
 /** Resolve a relative path against the importer's directory, normalizing
  *  `.`/`..` segments, then confirm it exists in the workspace file set. */
 function resolveRelative(rel, fromFile, allFilePaths) {
@@ -31,11 +58,7 @@ function resolveRelative(rel, fromFile, allFilePaths) {
     if (allFilePaths.has(target))
         return target;
     // Suffix fallback for absolute/rooted workspace paths.
-    for (const fp of allFilePaths) {
-        if (fp === target || fp.endsWith('/' + target))
-            return fp;
-    }
-    return null;
+    return findByPathSuffix(allFilePaths, target);
 }
 export function resolveDartImportTarget(targetRaw, fromFile, allFilePaths) {
     if (targetRaw.startsWith(DART_HERITAGE_PREFIX))
@@ -52,11 +75,11 @@ export function resolveDartImportTarget(targetRaw, fromFile, allFilePaths) {
         if (slash === -1)
             return null;
         const relPath = targetRaw.slice(slash + 1);
+        // Candidate priority is load-bearing: `lib/<rel>` before bare `<rel>`.
         for (const candidate of [`lib/${relPath}`, relPath]) {
-            for (const fp of allFilePaths) {
-                if (fp === candidate || fp.endsWith('/' + candidate))
-                    return fp;
-            }
+            const hit = findByPathSuffix(allFilePaths, candidate);
+            if (hit !== null)
+                return hit;
         }
         return null; // external package
     }

package/dist/core/ingestion/languages/dart/index.d.ts

@@ -19,7 +19,7 @@
  *   - `scope-resolver.ts`    — `ScopeResolver` registered in `SCOPE_RESOLVERS`
  *   - `cache-stats.ts`       — PROF_SCOPE_RESOLUTION cache hit/miss counters
  */
-export { emitDartScopeCaptures } from './captures.js';
+export { emitDartScopeCaptures, dartScopeOwnsReceivers } from './captures.js';
 export { getDartCaptureCacheStats, resetDartCaptureCacheStats } from './cache-stats.js';
 export { interpretDartImport, interpretDartTypeBinding, normalizeDartType, DART_HERITAGE_PREFIX, } from './interpret.js';
 export { dartMergeBindings } from './merge-bindings.js';

package/dist/core/ingestion/languages/dart/index.js

@@ -19,7 +19,7 @@
  *   - `scope-resolver.ts`    — `ScopeResolver` registered in `SCOPE_RESOLVERS`
  *   - `cache-stats.ts`       — PROF_SCOPE_RESOLUTION cache hit/miss counters
  */
-export { emitDartScopeCaptures } from './captures.js';
+export { emitDartScopeCaptures, dartScopeOwnsReceivers } from './captures.js';
 export { getDartCaptureCacheStats, resetDartCaptureCacheStats } from './cache-stats.js';
 export { interpretDartImport, interpretDartTypeBinding, normalizeDartType, DART_HERITAGE_PREFIX, } from './interpret.js';
 export { dartMergeBindings } from './merge-bindings.js';

package/dist/core/ingestion/languages/dart/query.js

@@ -40,7 +40,15 @@ const DART_SCOPE_QUERY = `
 (enum_declaration) @scope.class
 
 ; ── Declarations — types ─────────────────────────────────────────────────────
-(class_definition name: (identifier) @declaration.name) @declaration.class
+; The type-parameter list is matched as an UNNAMED optional child: the Dart
+; grammar hangs \`type_parameters\` off \`class_definition\` without a field name.
+; Recording it is what lets instantiation-aware interface dispatch tell a type
+; VARIABLE (\`class Box<T> implements Validator<T>\`) from a concrete argument
+; (\`class V implements Validator<String>\`) — see #2912; absent parameters are
+; indistinguishable from a language that captures none, and read as unknown.
+(class_definition
+  name: (identifier) @declaration.name
+  (type_parameters)? @declaration.type-parameters) @declaration.class
 (mixin_declaration (identifier) @declaration.name) @declaration.trait
 (extension_declaration name: (identifier) @declaration.name) @declaration.class
 (enum_declaration name: (identifier) @declaration.name) @declaration.enum
@@ -90,6 +98,43 @@ const DART_SCOPE_QUERY = `
   (function_signature
     name: (identifier) @declaration.name) @declaration.function)
 
+; ── Declarations — closure bound to a local ──────────────────────────────────
+;
+; var handler = (int x) => target(x);   /   var blk = (int y) { ... };
+;
+; Anchor discipline (same contract as javascript/query.ts): @declaration.function
+; sits on the INNER function_expression, NOT on the local_variable_declaration
+; wrapper. Dart is the one language that declares NO @scope.function in this
+; file — its function scopes are SYNTHESIZED in captures.ts from
+; declNode + findFunctionBody(declNode). So this rule deliberately does not add
+; a @scope.function of its own: doing that would collide with the synthesized
+; one at identical range, and duplicate scope ids make buildScopeTree throw,
+; which drops the whole file. Instead findFunctionBody now understands a
+; closure's child function_expression_body, so the existing synthesis produces
+; exactly one scope, anchored on the same node as the declaration (#2699 S4).
+;; THREE binding shapes, not one. Dart wraps only the FIRST local declarator in
+;; initialized_variable_definition; a top-level var and every later declarator
+;; are initialized_identifier, and a top-level final/const is
+;; static_final_declaration. Matching only the first shape left idiomatic
+;; top-level closures and the g of "var f = ..., g = ..." with no declaration
+;; capture, so findFunctionBody never synthesized their scope and they could
+;; never be call SOURCES.
+;;
+;; This mirrors DART_CALLABLE_CAPTURE_OPTIONS.bindingNodeTypes in captures.ts,
+;; which already listed all three for callable-flow. The two lists must stay in
+;; step; dart-closure-binding-shapes.test.ts pins that.
+(initialized_variable_definition
+  (identifier) @declaration.name
+  (function_expression) @declaration.function)
+
+(initialized_identifier
+  (identifier) @declaration.name
+  (function_expression) @declaration.function)
+
+(static_final_declaration
+  (identifier) @declaration.name
+  (function_expression) @declaration.function)
+
 ; ── Declarations — methods (inside class/mixin/extension bodies) ─────────────
 (method_signature
   (function_signature
@@ -124,6 +169,58 @@ const DART_SCOPE_QUERY = `
     (initialized_identifier
       . (identifier) @declaration.name))) @declaration.property
 
+; Inference-typed fields — \`var b = Outer();\`, \`final b = Outer();\`,
+; \`late final b = Outer();\`, \`static var b = Outer();\` (#2807). The two
+; patterns above require a written type, so a field whose type comes from its
+; initializer produced NO property declaration at all — no Property node, and
+; nothing for captures.ts to hang a type binding on, so \`b.inner()\` could not
+; resolve its receiver while the annotated twin resolved fine.
+;
+; Dart spells the keyword as \`inferred_type\` for \`var\` and \`final_builtin\`
+; for \`final\` / \`late final\`; both are class fields and both are idiomatic,
+; so covering only one would leave the more common Dart style broken.
+(declaration
+  (inferred_type)
+  (initialized_identifier_list
+    (initialized_identifier
+      . (identifier) @declaration.name))) @declaration.property
+(declaration
+  (final_builtin)
+  (initialized_identifier_list
+    (initialized_identifier
+      . (identifier) @declaration.name))) @declaration.property
+
+; ── Declarations — closure bindings (#2693) ──────────────────────────────────
+; \`var f = (x) => x;\` binds a callable. Without a declaration the binding has
+; no SymbolDefinition, so callable-value-flow has nothing to attach its seed to
+; and \`f()\` stays unresolved even though the graph emits a Function node for it.
+;
+; Restricted to a function_expression value on purpose: declaring every Dart
+; variable would mint defs repo-wide for no resolution benefit. The top-level
+; rule is anchored under (program) — the same disambiguation the graph-node
+; query uses — so class-body fields, which reuse initialized_identifier_list
+; and are already @declaration.property, are never matched twice.
+(program
+  (initialized_identifier_list
+    (initialized_identifier
+      (identifier) @declaration.name
+      (function_expression))) @declaration.variable)
+(program
+  (static_final_declaration_list
+    (static_final_declaration
+      (identifier) @declaration.name
+      (function_expression))) @declaration.variable)
+(initialized_variable_definition
+  name: (identifier) @declaration.name
+  value: (function_expression)) @declaration.variable
+; Second and later declarators of \`var f = .., g = ..;\` are nested
+; initialized_identifier children of the same initialized_variable_definition,
+; which the field-based rule above only reaches for the first name.
+(initialized_variable_definition
+  (initialized_identifier
+    (identifier) @declaration.name
+    (function_expression)) @declaration.variable)
+
 ; ── Imports / re-exports ─────────────────────────────────────────────────────
 (import_or_export
   (library_import

package/dist/core/ingestion/languages/dart/scope-resolver.js

@@ -33,6 +33,7 @@ import { generateId } from '../../../../lib/utils.js';
 import { dartProvider } from '../dart.js';
 import { dartArityCompatibility, dartMergeBindings, resolveDartImportTarget } from './index.js';
 import { decodeMarker } from '../../utils/heritage-marker.js';
+import { typeApplicationArguments } from '../../utils/template-arguments.js';
 import { expandDartWildcardNames } from './expand-wildcards.js';
 /**
  * Resolve a class simple name to a graph id with FILE AFFINITY: prefer a
@@ -60,7 +61,7 @@ function pickClassByName(name, preferredFile, defsByName) {
  * which keeps cross-file same-name classes from collapsing (mirror of Ruby's
  * `emitRubyMixinEdges`, with the #1951-style file-affinity hardening).
  */
-function emitDartHeritageEdges(graph, parsedFiles, nodeLookup) {
+function emitDartHeritageEdges(graph, parsedFiles, nodeLookup, recordTypeArguments) {
     const defsByName = new Map();
     for (const parsed of parsedFiles) {
         for (const def of parsed.localDefs) {
@@ -97,11 +98,21 @@ function emitDartHeritageEdges(graph, parsedFiles, nodeLookup) {
             const parts = decoded.fields;
             if (parts.length < 3)
                 continue;
-            const [kind, baseName, childName] = parts;
+            const [kind, baseName, childName, rawTypeArguments] = parts;
             const childId = pickClassByName(childName, parsed.filePath, defsByName);
             const baseId = pickClassByName(baseName, parsed.filePath, defsByName);
             if (childId === undefined || baseId === undefined || childId === baseId)
                 continue;
+            // The instantiation this clause was written with — `implements
+            // Validator<String>` (#2912). Recorded before the dedup below, since the
+            // FIRST writer wins on both sides and an edge deduped here still needs
+            // its arguments. A marker from a pre-#2912 cache has no fourth field,
+            // which reads as unknown.
+            if (rawTypeArguments !== undefined) {
+                const typeArguments = typeApplicationArguments(rawTypeArguments);
+                if (typeArguments !== undefined)
+                    recordTypeArguments?.(childId, baseId, typeArguments);
+            }
             const key = `${childId}->${baseId}:${kind}`;
             if (emitted.has(key))
                 continue;
@@ -183,7 +194,7 @@ export const dartScopeResolver = {
     isSuperReceiver: (text) => text.trim() === 'super',
     // `implements` / `with` IMPLEMENTS edges (extends rides the generic
     // inherits pre-pass; these need an explicit, kind-independent edge type).
-    emitHeritageEdges: (graph, parsedFiles, nodeLookup) => emitDartHeritageEdges(graph, parsedFiles, nodeLookup),
+    emitHeritageEdges: (graph, parsedFiles, nodeLookup, _scopes, recordTypeArguments) => emitDartHeritageEdges(graph, parsedFiles, nodeLookup, recordTypeArguments),
     // Dart is statically typed — the field-fallback heuristic over-connects.
     fieldFallbackOnMethodLookup: false,
     propagatesReturnTypesAcrossImports: true,

package/dist/core/ingestion/languages/dart/simple-hooks.js

@@ -14,6 +14,7 @@
  *   - `dartReceiverBinding` — the implicit `this`/`super` receiver of a
  *     Function scope.
  */
+import { walkToScope } from '../../utils/scope-tree-walk.js';
 export function dartBindingScopeFor(decl, innermost, tree) {
     // (1) Return-type bindings hoist to the Module scope.
     if (decl['@type-binding.return'] !== undefined) {
@@ -28,6 +29,14 @@ export function dartBindingScopeFor(decl, innermost, tree) {
             return cur.id;
         return null;
     }
+    // (1b) A field typed from a constructor assigned to it (`r = Outer();` in a
+    // constructor body) must live on the CLASS scope — the assignment sits inside
+    // the constructor's own Function scope, where `typeOfMemberOnClass` never
+    // looks (#2807). Gated on the dedicated marker, never on
+    // `@type-binding.constructor` at large, which also fires for genuine locals.
+    if (decl['@type-binding.dart-field'] !== undefined) {
+        return walkToScope(innermost, tree, 'Class');
+    }
     // (2) Function/method/constructor names are visible in the enclosing scope.
     if (decl['@declaration.function'] !== undefined ||
         decl['@declaration.method'] !== undefined ||

package/dist/core/ingestion/languages/dart.js

@@ -27,7 +27,7 @@ import { createVariableExtractor } from '../variable-extractors/generic.js';
 import { dartVariableConfig } from '../variable-extractors/configs/dart.js';
 import { createCallExtractor } from '../call-extractors/generic.js';
 import { dartCallConfig } from '../call-extractors/configs/dart.js';
-import { emitDartScopeCaptures, interpretDartImport, interpretDartTypeBinding, dartBindingScopeFor, dartImportOwningScope, dartReceiverBinding, dartMergeBindings, dartArityCompatibility, } from './dart/index.js';
+import { emitDartScopeCaptures, dartScopeOwnsReceivers, interpretDartImport, interpretDartTypeBinding, dartBindingScopeFor, dartImportOwningScope, dartReceiverBinding, dartMergeBindings, dartArityCompatibility, } from './dart/index.js';
 import { DART_BUILT_INS } from './dart/built-ins.js';
 import { preprocessDartExtensionTypes } from './dart/extension-type-preprocess.js';
 /**
@@ -119,6 +119,11 @@ export const dartProvider = defineLanguage({
     // emit-side `ScopeResolver` lives in `dart/scope-resolver.ts`; the same
     // function references flow through both interfaces.
     emitScopeCaptures: emitDartScopeCaptures,
+    // Dart's `ownsReceivers` masks FIELD NAMES a member body rebinds, not `this`
+    // (which Dart binds lexically in every closure form, so there is nothing to
+    // own). See `dartShadowedFieldsCapture` in `dart/captures.ts` for why the
+    // read side needs the mask and what it deliberately does not cover.
+    scopeOwnsReceivers: dartScopeOwnsReceivers,
     cfgVisitor: createDartCfgVisitor(),
     interpretImport: interpretDartImport,
     interpretTypeBinding: interpretDartTypeBinding,

package/dist/core/ingestion/languages/go/captures.js

@@ -8,6 +8,44 @@ import { synthesizeGoTypeBindings, extractSimpleTypeNameText } from './type-bind
 import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
 import { synthesizeCallableFlowCaptures } from '../../utils/callable-flow-captures.js';
+import { synthesizeReceiverChainCapture } from '../../utils/receiver-chain-captures.js';
+/** Range for a capture that marks no source span. */
+const ZERO_RANGE = Object.freeze({ startLine: 0, startCol: 0, endLine: 0, endCol: 0 });
+/**
+ * The callee-position marker, allocated once for the whole process.
+ *
+ * This capture is a PRESENCE FLAG, not a payload: `scope-extractor.ts` reads it
+ * only as `match['@reference.callee-position'] !== undefined`, and the tag is
+ * listed in `KNOWN_SUB_TAGS`, so `anchorCaptureFor` never considers its range
+ * when picking a reference anchor. Nothing else in the pipeline touches it.
+ * (Its range used to duplicate `@reference.read`'s exactly, and that capture is
+ * still emitted, so the one place that scans every capture's range — the
+ * synthetic Module-scope span in `scope-extractor.ts` — sees the same maximum.)
+ *
+ * Minting it per site from the read node was therefore pure cost, and not a
+ * cheap one: `node.text` is an `input.substring` behind N-API index marshals,
+ * and `startPosition` / `endPosition` are two more round-trips each. A frozen
+ * singleton carries exactly the same information — its presence — for free.
+ */
+const CALLEE_POSITION_MARKER = Object.freeze({
+    name: '@reference.callee-position',
+    range: ZERO_RANGE,
+    text: '',
+});
+/**
+ * Presence-only marker for an embedded field written as `*T` rather than `T`.
+ *
+ * Go's method-set rules treat the two forms differently — `S{T}` promotes only
+ * the value-receiver methods of `T` into `MS(S)`, while `S{*T}` promotes both
+ * value- and pointer-receiver ones (go.dev/ref/spec#Struct_types). Structural
+ * interface detection cannot give an exact answer without knowing which was
+ * written, so the spelling is recorded here and interpreted downstream.
+ */
+const EMBEDDED_POINTER_MARKER = Object.freeze({
+    name: '@reference.embedded-pointer',
+    range: ZERO_RANGE,
+    text: '',
+});
 const GO_CALLABLE_CAPTURE_OPTIONS = {
     functionNodeTypes: new Set(['function_declaration', 'method_declaration', 'func_literal']),
     callNodeTypes: new Set(['call_expression']),
@@ -40,6 +78,25 @@ const GO_CALLABLE_CAPTURE_OPTIONS = {
         return destinations.map((destination, index) => ({ destination, source: sources[index] }));
     },
 };
+/**
+ * Is this `selector_expression` in CALLEE position — the `function` child of an
+ * enclosing `call_expression` — rather than free-standing?
+ *
+ * `h.dep.Work` in `h.dep.Work()` is in callee position; `f := h.dep.Work` (a
+ * method value, or a func-typed field value) is not.
+ *
+ * Callee position alone does NOT make the selector a non-read. Go dispatches
+ * `h.dep.Work()` through a func-typed struct field just as readily as through a
+ * method, and this predicate cannot tell the two apart — `call_expression` has
+ * the same shape either way, and the tail's declaration may live in another
+ * package. See {@link emitGoScopeCaptures} for what is done with the answer.
+ */
+function isCalleeOfMemberCall(node) {
+    const parent = node.parent;
+    if (parent === null || parent.type !== 'call_expression')
+        return false;
+    return parent.childForFieldName('function')?.id === node.id;
+}
 export function emitGoScopeCaptures(sourceText, _filePath, cachedTree) {
     let tree = cachedTree;
     if (tree === undefined) {
@@ -127,6 +184,12 @@ export function emitGoScopeCaptures(sourceText, _filePath, cachedTree) {
                     grouped['@declaration.return-type'] = syntheticCapture('@declaration.return-type', fnNode, arity.returnType);
                 }
             }
+            // Structural receiver chain for a call whose receiver is itself an
+            // expression, so resolution can type it by folding over structure
+            // instead of re-parsing the receiver's source text. Self-gating: a
+            // non-call match, an absent receiver, or a chain with no nameable base
+            // all leave `grouped` untouched.
+            synthesizeReceiverChainCapture(grouped, nodeMap['@reference.receiver']);
             out.push(grouped);
             continue;
         }
@@ -141,6 +204,39 @@ export function emitGoScopeCaptures(sourceText, _filePath, cachedTree) {
                 grouped['@reference.arity'] = syntheticCapture('@reference.arity', callNode, String(computeGoCallArity(callNode)));
             }
         }
+        // Mark — do NOT drop — the read site on a member call's callee.
+        //
+        // The `@reference.read` pattern matches every `selector_expression`, so
+        // `h.dep.Work()` yields THREE sites: the call on `Work`, a read on the inner
+        // `h.dep` (the genuine field read), and a read on the OUTER `h.dep.Work`.
+        //
+        // That third site is a phantom ONLY when `Work` is a method: it then
+        // resolves through `findOwnedMember` (which prefers methods over fields) and
+        // emits an ACCESSES edge to the METHOD duplicating the CALLS edge at the
+        // same position — `v.impl.DoWork()` emitting both `CALLS -> DoWork` and
+        // `ACCESSES -> DoWork`.
+        //
+        // When `Work` is a FUNC-TYPED STRUCT FIELD (`Work func() error` — callback
+        // structs, hook structs, hand-rolled mocks) the very same syntax is a
+        // genuine field read followed by an indirect call through the value it
+        // holds, and that read is the field's only ACCESSES evidence. Dropping the
+        // site here deleted it (#2782 review).
+        //
+        // Method-vs-field is not knowable at capture: `call_expression` has the same
+        // shape either way and the tail's declaration may live in another package.
+        // So the capture layer records the POSITION and edge emission — which knows
+        // the resolved target's kind — decides. See `ReferenceSite.inCalleePosition`
+        // and `tryEmitEdge`.
+        const readNode = nodeMap['@reference.read'];
+        if (readNode !== undefined && isCalleeOfMemberCall(readNode)) {
+            grouped['@reference.callee-position'] = CALLEE_POSITION_MARKER;
+        }
+        // Structural receiver chain for a call whose receiver is itself an
+        // expression, so resolution can type it by folding over structure
+        // instead of re-parsing the receiver's source text. Self-gating: a
+        // non-call match, an absent receiver, or a chain with no nameable base
+        // all leave `grouped` untouched.
+        synthesizeReceiverChainCapture(grouped, nodeMap['@reference.receiver']);
         out.push(grouped);
     }
     // Layer on type-binding synthesis (new/make/qualified composite literal)
@@ -241,7 +337,12 @@ function synthesizeGoInheritanceReferences(root) {
                         continue;
                     // `field.type` is the embedded base — bare/qualified/generic, with any
                     // `*` pointer marker as an unnamed sibling token (already unwrapped).
-                    emitGoEmbedInheritance(field.childForFieldName('type'), out);
+                    // That token is the ONLY record of `*T` versus `T`, and the two have
+                    // different method sets, so read it off the field text before it is
+                    // lost. An embedded field has no name, so a leading `*` can only be
+                    // the pointer marker.
+                    const embeddedAsPointer = field.text.trimStart().startsWith('*');
+                    emitGoEmbedInheritance(field.childForFieldName('type'), out, embeddedAsPointer);
                 }
             }
             else if (typeNode.type === 'interface_type') {
@@ -252,7 +353,8 @@ function synthesizeGoInheritanceReferences(root) {
                     // `shouldSkipExtends`); a single-element `type_elem` is the embed.
                     if (elem.type !== 'type_elem' || elem.namedChildCount !== 1)
                         continue;
-                    emitGoEmbedInheritance(elem.namedChild(0), out);
+                    // An interface embed is never a pointer form.
+                    emitGoEmbedInheritance(elem.namedChild(0), out, false);
                 }
             }
         }
@@ -264,7 +366,7 @@ function synthesizeGoInheritanceReferences(root) {
  * node, reducing the name to its bare simple identifier. No-ops when `baseNode`
  * is null or not one of the embed shapes.
  */
-function emitGoEmbedInheritance(baseNode, out) {
+function emitGoEmbedInheritance(baseNode, out, embeddedAsPointer) {
     if (baseNode === null)
         return;
     const nameNode = goEmbedBaseNameNode(baseNode);
@@ -273,6 +375,9 @@ function emitGoEmbedInheritance(baseNode, out) {
     out.push({
         '@reference.inherits': nodeToCapture('@reference.inherits', baseNode),
         '@reference.name': nodeToCapture('@reference.name', nameNode),
+        // Added ONLY for the pointer form, so a value embed's capture set is
+        // byte-identical to what it was before this marker existed.
+        ...(embeddedAsPointer ? { '@reference.embedded-pointer': EMBEDDED_POINTER_MARKER } : {}),
     });
 }
 /**

package/dist/core/ingestion/languages/go/generic-type-parameters.d.ts

@@ -0,0 +1,31 @@
+import type { ParsedFile, SymbolDefinition } from '../../../../_shared/index.js';
+/**
+ * Stamp every generic interface in `parsedFiles` with its type-parameter names,
+ * read out of the declaration's own source text.
+ *
+ * WHY SOURCE TEXT AND NOT A CAPTURE. The tree has the list right there
+ * (`type_spec` carries a `type_parameters` field), and capturing it would be two
+ * lines. But captures run inside the PARSE WORKER, whose script is resolved from
+ * the compiled `dist/` build, and their output is additionally memoized by the
+ * parse cache and the durable ParsedFile store — so a capture-side change is
+ * invisible until a rebuild AND a cache-version bump, and silently wrong in
+ * between. Everything here runs on the main thread from data the pipeline
+ * already materialized, so it is correct on the first run and needs neither.
+ *
+ * The scan is exact rather than a grep over the file: an interface declaration
+ * owns a `Class` scope whose range spans exactly its `type_spec`
+ * (`Repo[T any] interface{ … }`), so the text is sliced by that range and the
+ * type parameters are, by grammar, whatever sits between the brackets that
+ * IMMEDIATELY follow the name. Comments and strings elsewhere in the file cannot
+ * reach it.
+ */
+export declare function stampGoInterfaceTypeParameters(parsedFiles: readonly ParsedFile[], fileContents: ReadonlyMap<string, string>): void;
+/** Read back a stamp, rejecting anything whose shape does not match — the
+ *  sidecar is optional and a hand-built fixture def carries none. */
+export declare function readGoTypeParameters(def: SymbolDefinition): readonly string[] | undefined;
+/** Index of the delimiter closing the one at `open`, or -1 when unbalanced.
+ *  Tracks `[]`, `{}` and `()` together so an `interface{ M(a, b int) }`
+ *  constraint cannot end the list early. */
+export declare function matchingGoDelimiter(text: string, open: number): number;
+/** Split on commas that are not nested inside brackets, braces or parens. */
+export declare function splitTopLevelGoList(text: string): string[];

package/dist/core/ingestion/languages/go/generic-type-parameters.js

@@ -0,0 +1,140 @@
+/**
+ * Stamp every generic interface in `parsedFiles` with its type-parameter names,
+ * read out of the declaration's own source text.
+ *
+ * WHY SOURCE TEXT AND NOT A CAPTURE. The tree has the list right there
+ * (`type_spec` carries a `type_parameters` field), and capturing it would be two
+ * lines. But captures run inside the PARSE WORKER, whose script is resolved from
+ * the compiled `dist/` build, and their output is additionally memoized by the
+ * parse cache and the durable ParsedFile store — so a capture-side change is
+ * invisible until a rebuild AND a cache-version bump, and silently wrong in
+ * between. Everything here runs on the main thread from data the pipeline
+ * already materialized, so it is correct on the first run and needs neither.
+ *
+ * The scan is exact rather than a grep over the file: an interface declaration
+ * owns a `Class` scope whose range spans exactly its `type_spec`
+ * (`Repo[T any] interface{ … }`), so the text is sliced by that range and the
+ * type parameters are, by grammar, whatever sits between the brackets that
+ * IMMEDIATELY follow the name. Comments and strings elsewhere in the file cannot
+ * reach it.
+ */
+export function stampGoInterfaceTypeParameters(parsedFiles, fileContents) {
+    for (const parsed of parsedFiles) {
+        // Deferred so a file with no interface declaration never indexes its lines.
+        let lines;
+        for (const scope of parsed.scopes) {
+            if (scope.kind !== 'Class')
+                continue;
+            const iface = scope.ownedDefs.find((def) => def.type === 'Interface');
+            if (iface?.qualifiedName === undefined)
+                continue;
+            if (lines === undefined) {
+                const source = fileContents.get(parsed.filePath);
+                if (source === undefined)
+                    break;
+                lines = { source, starts: buildLineStarts(source) };
+            }
+            const declaration = sliceRange(lines.source, lines.starts, scope.range);
+            if (declaration === undefined)
+                continue;
+            const names = goTypeParameterNames(declaration, simpleGoName(iface.qualifiedName));
+            if (names === undefined)
+                continue;
+            iface.goTypeParameters = names;
+        }
+    }
+}
+/** Read back a stamp, rejecting anything whose shape does not match — the
+ *  sidecar is optional and a hand-built fixture def carries none. */
+export function readGoTypeParameters(def) {
+    const names = def.goTypeParameters;
+    if (!Array.isArray(names) || names.length === 0)
+        return undefined;
+    return names.every((name) => typeof name === 'string') ? names : undefined;
+}
+/**
+ * The declared type-parameter names of `Name[…] interface{…}`, in source order,
+ * or `undefined` when the declaration is not generic.
+ *
+ * Go spec, Type parameter declarations: the list is comma-separated and one
+ * entry may declare SEVERAL names sharing one constraint — `[K, V any]` declares
+ * `K` and `V`, and `[S ~[]E, E any]` declares `S` and `E`. Each entry therefore
+ * contributes exactly its FIRST token as a name; anything after it is the
+ * constraint, which is not needed here (satisfaction of a constraint is a
+ * separate question from implementation of an interface, and constraints are
+ * never harvested as instantiations — see `interface-impls.ts`).
+ */
+function goTypeParameterNames(declaration, interfaceName) {
+    if (!declaration.startsWith(interfaceName))
+        return undefined;
+    if (declaration[interfaceName.length] !== '[')
+        return undefined;
+    const close = matchingGoDelimiter(declaration, interfaceName.length);
+    if (close === -1)
+        return undefined;
+    const names = [];
+    for (const entry of splitTopLevelGoList(declaration.slice(interfaceName.length + 1, close))) {
+        const name = /^[A-Za-z_][A-Za-z0-9_]*/.exec(entry)?.[0];
+        if (name === undefined)
+            return undefined;
+        names.push(name);
+    }
+    return names.length === 0 ? undefined : names;
+}
+/** Index of the delimiter closing the one at `open`, or -1 when unbalanced.
+ *  Tracks `[]`, `{}` and `()` together so an `interface{ M(a, b int) }`
+ *  constraint cannot end the list early. */
+export function matchingGoDelimiter(text, open) {
+    let depth = 0;
+    for (let i = open; i < text.length; i += 1) {
+        const ch = text[i];
+        if (ch === '[' || ch === '{' || ch === '(')
+            depth += 1;
+        else if (ch === ']' || ch === '}' || ch === ')') {
+            depth -= 1;
+            if (depth === 0)
+                return i;
+        }
+    }
+    return -1;
+}
+/** Split on commas that are not nested inside brackets, braces or parens. */
+export function splitTopLevelGoList(text) {
+    const parts = [];
+    let depth = 0;
+    let start = 0;
+    for (let i = 0; i < text.length; i += 1) {
+        const ch = text[i];
+        if (ch === '[' || ch === '{' || ch === '(')
+            depth += 1;
+        else if (ch === ']' || ch === '}' || ch === ')')
+            depth -= 1;
+        else if (ch === ',' && depth === 0) {
+            parts.push(text.slice(start, i));
+            start = i + 1;
+        }
+    }
+    parts.push(text.slice(start));
+    return parts.map((part) => part.trim()).filter((part) => part.length > 0);
+}
+function simpleGoName(qualifiedName) {
+    const dot = qualifiedName.lastIndexOf('.');
+    return dot === -1 ? qualifiedName : qualifiedName.slice(dot + 1);
+}
+/** Offsets at which each 1-based line begins. */
+function buildLineStarts(source) {
+    const starts = [0, 0];
+    for (let i = 0; i < source.length; i += 1) {
+        if (source[i] === '\n')
+            starts.push(i + 1);
+    }
+    return starts;
+}
+/** `Range` is 1-based on lines and 0-based on columns (`syntheticCapture`). */
+function sliceRange(source, lineStarts, range) {
+    const start = lineStarts[range.startLine];
+    const end = lineStarts[range.endLine];
+    if (start === undefined || end === undefined)
+        return undefined;
+    return source.slice(start + range.startCol, end + range.endCol);
+}

package/dist/core/ingestion/languages/go/import-target.d.ts

@@ -1,4 +1,3 @@
-import type { GoModuleConfig } from '../../language-config.js';
 /**
  * Resolve a Go import path to ALL .go files in the matching package directory.
  *
@@ -8,14 +7,8 @@ import type { GoModuleConfig } from '../../language-config.js';
  * IMPORTS edge fanout AND binding materialization for every exported symbol in
  * the package.
  *
- * Strategy (first match wins):
- *   1. go.mod-based: strip module prefix, match package directory
- *   2. Non-go.mod / GOPATH: progressively shorter directory suffixes
+ * Strategy:
+ *   1. With go.mod: resolve only imports owned by that module
+ *   2. Without go.mod / GOPATH: progressively shorter directory suffixes
  */
 export declare function resolveGoImportTarget(targetRaw: string, _fromFile: string, allFilePaths: ReadonlySet<string>, resolutionConfig?: unknown): string | readonly string[] | null;
-/** Preserved for backward compat. */
-export interface GoResolveContext {
-    readonly fromFile: string;
-    readonly allFilePaths: ReadonlySet<string>;
-    readonly goModule?: GoModuleConfig;
-}