gitnexus 1.6.11-rc.8 → 1.6.11

package/dist/core/ingestion/languages/zig.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Zig Language Provider.
+ *
+ * Key Zig traits:
+ *   - mroStrategy: default 'first-wins' is irrelevant — Zig has no inheritance,
+ *     and no heritage hooks are provided (Zig queries never produce
+ *     `@heritage.*` captures).
+ *   - exportChecker: walks to the enclosing variable_declaration /
+ *     function_declaration and looks for a `pub` or `export` keyword child.
+ *   - importResolver: resolves local `@import("./foo.zig")` paths and
+ *     build.zig.zon `.path` deps (root the dep's build.zig declares, then
+ *     src/root.zig, src/<name>.zig, src/main.zig); `@import("std")` and
+ *     `.url` packages are deliberately external.
+ *   - namedBindingExtractor: omitted — the scope side handles
+ *     `const Foo = @import("x").Foo` and `const Foo = ns.Foo` (ns an
+ *     @import binding) as NAMED imports instead (`zig/captures.ts`).
+ *   - scope-resolution hooks (Ring 3): `emitScopeCaptures` walks the file via
+ *     `zig/query.ts` (containers as Class scopes — including the container a
+ *     generic type constructor `fn List(comptime T: type) type` returns,
+ *     named after the fn; container-nested fns relabeled @declaration.method;
+ *     plain-variable groups filtered for container/import bindings and for
+ *     the keyword-less `variable_declaration`s tree-sitter-zig uses for
+ *     statement assignments); `interpretImport` maps `const x = @import("…")`
+ *     to a namespace import, member forms to named/alias imports and
+ *     `usingnamespace` to a wildcard; receiver types come from `self`
+ *     parameters, `T{…}` / `mod.T{…}` / `List(u8){…}` literals, `T.init()`
+ *     call returns, `x: T` annotations (incl. decl literals), container
+ *     FIELD types on the container's class scope (`self.session.name()`)
+ *     and one-level field aliases (`const s = self.session; s.name()`). The
+ *     emit-side wiring lives in `zig/scope-resolver.ts` (SCOPE_RESOLVERS).
+ */
+export declare const zigProvider: import("../language-provider.js").LanguageProvider;

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

@@ -0,0 +1,130 @@
+/**
+ * Zig Language Provider.
+ *
+ * Key Zig traits:
+ *   - mroStrategy: default 'first-wins' is irrelevant — Zig has no inheritance,
+ *     and no heritage hooks are provided (Zig queries never produce
+ *     `@heritage.*` captures).
+ *   - exportChecker: walks to the enclosing variable_declaration /
+ *     function_declaration and looks for a `pub` or `export` keyword child.
+ *   - importResolver: resolves local `@import("./foo.zig")` paths and
+ *     build.zig.zon `.path` deps (root the dep's build.zig declares, then
+ *     src/root.zig, src/<name>.zig, src/main.zig); `@import("std")` and
+ *     `.url` packages are deliberately external.
+ *   - namedBindingExtractor: omitted — the scope side handles
+ *     `const Foo = @import("x").Foo` and `const Foo = ns.Foo` (ns an
+ *     @import binding) as NAMED imports instead (`zig/captures.ts`).
+ *   - scope-resolution hooks (Ring 3): `emitScopeCaptures` walks the file via
+ *     `zig/query.ts` (containers as Class scopes — including the container a
+ *     generic type constructor `fn List(comptime T: type) type` returns,
+ *     named after the fn; container-nested fns relabeled @declaration.method;
+ *     plain-variable groups filtered for container/import bindings and for
+ *     the keyword-less `variable_declaration`s tree-sitter-zig uses for
+ *     statement assignments); `interpretImport` maps `const x = @import("…")`
+ *     to a namespace import, member forms to named/alias imports and
+ *     `usingnamespace` to a wildcard; receiver types come from `self`
+ *     parameters, `T{…}` / `mod.T{…}` / `List(u8){…}` literals, `T.init()`
+ *     call returns, `x: T` annotations (incl. decl literals), container
+ *     FIELD types on the container's class scope (`self.session.name()`)
+ *     and one-level field aliases (`const s = self.session; s.name()`). The
+ *     emit-side wiring lives in `zig/scope-resolver.ts` (SCOPE_RESOLVERS).
+ */
+import { SupportedLanguages } from '../../../_shared/index.js';
+import { defineLanguage } from '../language-provider.js';
+import { ZIG_QUERIES } from '../tree-sitter-queries.js';
+import { zigExportChecker } from '../export-detection.js';
+import { createImportResolver } from '../import-resolvers/resolver-factory.js';
+import { zigImportConfig } from '../import-resolvers/configs/zig.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { zigCallConfig } from '../call-extractors/configs/zig.js';
+import { createClassExtractor } from '../class-extractors/generic.js';
+import { zigClassConfig } from '../class-extractors/configs/zig.js';
+import { createFieldExtractor } from '../field-extractors/generic.js';
+import { zigFieldConfig } from '../field-extractors/configs/zig.js';
+import { createMethodExtractor } from '../method-extractors/generic.js';
+import { zigMethodConfig } from '../method-extractors/configs/zig.js';
+import { createVariableExtractor } from '../variable-extractors/generic.js';
+import { zigVariableConfig } from '../variable-extractors/configs/zig.js';
+import { zigTypeConfig } from '../type-extractors/zig.js';
+import { emitZigScopeCaptures, interpretZigImport, interpretZigTypeBinding, isZigContainerMethod, isZigFileStruct, isZigRedundantContainerCapture, isZigTypeShadowingBinding, zigArityCompatibility, zigContainerLabel, zigContainerName, zigFileStructName, zigBindingScopeFor, zigReceiverBinding, ZIG_CONTAINER_TYPES, } from './zig/index.js';
+export const zigProvider = defineLanguage({
+    id: SupportedLanguages.Zig,
+    extensions: ['.zig'],
+    entryPointPatterns: [
+        /^main$/, // standard executable entry point
+        /^build$/, // build.zig entry point
+    ],
+    astFrameworkPatterns: [],
+    treeSitterQueries: ZIG_QUERIES,
+    typeConfig: zigTypeConfig,
+    exportChecker: zigExportChecker,
+    importResolver: createImportResolver(zigImportConfig),
+    callExtractor: createCallExtractor(zigCallConfig),
+    classExtractor: createClassExtractor(zigClassConfig),
+    fieldExtractor: createFieldExtractor(zigFieldConfig),
+    methodExtractor: createMethodExtractor(zigMethodConfig),
+    variableExtractor: createVariableExtractor(zigVariableConfig),
+    // A `const`/`var` whose value is a container or an `@import` is the
+    // Struct/Enum/Union node or the import binding, not a Const beside it.
+    // Up to three ZIG_QUERIES rules match one container (wrapper, type
+    // constructor, bare container — F8); `zigContainerAnchor` names the one
+    // that mints it and the others are dropped here.
+    shouldSkipDefinitionCapture: (captureMap, defaultLabel) => {
+        if (defaultLabel === 'Const' || defaultLabel === 'Variable') {
+            const decl = captureMap['definition.const'] ?? captureMap['definition.variable'];
+            return decl !== undefined && isZigTypeShadowingBinding(decl);
+        }
+        if (defaultLabel === 'Struct' || defaultLabel === 'Enum' || defaultLabel === 'Union') {
+            const decl = captureMap['definition.struct'] ??
+                captureMap['definition.enum'] ??
+                captureMap['definition.union'];
+            if (decl === undefined)
+                return false;
+            // The file-struct rules over-match (a `@This` first parameter, a
+            // top-level `@This()` alias — see ZIG_QUERIES); the one predicate decides.
+            if (decl.type === 'source_file')
+                return !isZigFileStruct(decl);
+            return isZigRedundantContainerCapture(decl, captureMap['name']);
+        }
+        return false;
+    },
+    // A file whose top level declares fields IS a struct named after the file
+    // (`Page.zig` → `Page`): its top-level fns/fields are members of that
+    // Struct. Files without fields are namespaces and own nothing.
+    resolveFileTypeOwner: (root, filePath) => isZigFileStruct(root) ? { name: zigFileStructName(filePath), label: 'Struct' } : null,
+    // Every container's identity comes from `zigContainerName` — the binding
+    // name for `const T = struct {…}` at file/container level, the fn name for
+    // a generic type constructor, and (F8) `string$R` / `build$1` for
+    // function-local and anonymous containers, which no name child spells. The
+    // class extractor names the node from the same function, so a member's
+    // owner id (`Method:<file>:string$R.get`) and the node id agree.
+    resolveContainerTypeOwner: (container, filePath) => {
+        if (!ZIG_CONTAINER_TYPES.has(container.type))
+            return null;
+        const name = zigContainerName(container, filePath);
+        const label = zigContainerLabel(container);
+        return name !== undefined && label !== undefined ? { name, label } : null;
+    },
+    labelOverride: (functionNode, defaultLabel) => {
+        if (defaultLabel !== 'Function')
+            return defaultLabel;
+        if (isZigContainerMethod(functionNode))
+            return 'Method';
+        return defaultLabel;
+    },
+    // ── RFC #909 Ring 3: scope-based resolution hooks ──
+    emitScopeCaptures: emitZigScopeCaptures,
+    interpretImport: interpretZigImport,
+    // `@import` is compile-time name lookup, not an executed statement: one
+    // written inside a function body is resolved exactly as one at file scope
+    // (same answer as C `#include` and Rust `use`). Without this, a
+    // function-scoped `@import` would be marked `runsOnlyWhenCalled` and a
+    // real import cycle through it would be hidden from `check --cycles`.
+    importsExecuteWhereWritten: false,
+    interpretTypeBinding: interpretZigTypeBinding,
+    bindingScopeFor: zigBindingScopeFor,
+    receiverBinding: zigReceiverBinding,
+    // Provider contract is (def, callsite); the ScopeResolver contract is
+    // (callsite, def) — same function, adapted argument order.
+    arityCompatibility: (def, callsite) => zigArityCompatibility(callsite, def),
+});

package/dist/core/ingestion/method-extractors/configs/zig.d.ts

@@ -0,0 +1,2 @@
+import type { MethodExtractionConfig } from '../../method-types.js';
+export declare const zigMethodConfig: MethodExtractionConfig;

package/dist/core/ingestion/method-extractors/configs/zig.js

@@ -0,0 +1,120 @@
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { hasZigPubKeyword } from '../../export-detection.js';
+import { ZIG_CONTAINER_TYPES, zigContainerName, zigReceiverParameter, } from '../../languages/zig/captures.js';
+/**
+ * Zig method extraction.
+ *
+ * tree-sitter-zig containers (struct/enum/union/opaque) are anonymous; the
+ * binding name lives on the parent variable_declaration, or on the enclosing
+ * generic type constructor (`fn List(comptime T: type) type { return struct
+ * {…}; }`) — `zigContainerName` decides. Methods inside a container appear as
+ * plain `function_declaration` children of the container node.
+ *
+ * The first parameter is the receiver when it is named `self` OR typed as the
+ * enclosing container (`replica: *Replica`, `pool: *@This()`) — see
+ * `zigReceiverParameter`; unlike Rust, Zig has no dedicated `self_parameter`
+ * node type and `self` is a convention, not a rule.
+ */
+const extractZigOwnerName = (node, filePath) => zigContainerName(node, filePath);
+const extractZigName = (node) => {
+    const nameNode = node.childForFieldName('name');
+    return nameNode?.text;
+};
+/**
+ * The `parameters` node of a function_declaration. tree-sitter-zig 1.1.2
+ * attaches it as a plain named child — NOT under a `parameters:` field (only
+ * `name`, `type` and `body` are fields), so a field lookup is always null
+ * (and the grammar-literal gate flags it as a dead field). Reading it that
+ * way silently produced empty parameter lists, no receiver, and
+ * `isStatic: true` for every method.
+ */
+const zigParameterList = (node) => node.namedChildren.find((child) => child?.type === 'parameters') ?? null;
+const extractZigReturnType = (node) => {
+    // tree-sitter-zig labels the return type as the `type` field on
+    // function_declaration (the same field name used for parameter types).
+    const typeNode = node.childForFieldName('type');
+    return typeNode?.text?.trim();
+};
+/**
+ * Regular parameters only. The receiver parameter (`zigReceiverParameter`) is
+ * reported through `extractReceiverType`, not the parameter list (same split
+ * as Rust's `self_parameter` skip in `configs/rust.ts`). `filePath` is what
+ * names a file-struct (`fn add(ledger: *Ledger)` in `Ledger.zig`): without it
+ * the receiver rule cannot see the file stem and such a fn reads as static
+ * with the receiver in its arity — an id the scope side, which always has
+ * the path, never produces, so its CALLS edges went nowhere.
+ */
+const extractZigParameters = (node, filePath) => {
+    const paramList = zigParameterList(node);
+    if (!paramList)
+        return [];
+    const params = [];
+    const receiver = zigReceiverParameter(node, filePath);
+    for (let i = 0; i < paramList.namedChildCount; i++) {
+        const param = paramList.namedChild(i);
+        if (!param || param.type !== 'parameter')
+            continue;
+        if (receiver !== null && param.id === receiver.id)
+            continue;
+        const nameNode = param.childForFieldName('name');
+        const typeNode = param.childForFieldName('type');
+        params.push({
+            name: nameNode?.text ?? '?',
+            type: typeNode?.text?.trim() ?? null,
+            rawType: typeNode?.text?.trim() ?? null,
+            isOptional: false,
+            isVariadic: false,
+        });
+    }
+    return params;
+};
+const extractZigReceiverType = (node, filePath) => zigReceiverParameter(node, filePath)?.childForFieldName('type')?.text?.trim();
+/**
+ * Names a `test_declaration` during the enclosing-function walk (parse-worker
+ * `findEnclosingFunctionId`) with the SAME spelling ZIG_QUERIES captures as
+ * `@name` — the string node with its quotes — so calls inside `test "x" {}`
+ * attribute to the test's own Function node.
+ *
+ * Anonymous `test {}` and decl-tests `test add {}` are not graph nodes. They
+ * return `''`, not `null`: `null` falls through to `genericFuncName`, whose
+ * first-identifier scan would name `test add {}` "add" — the REAL `fn add`'s
+ * id — and hang the test body's calls on it. The empty name is falsy, so
+ * `findEnclosingFunctionId` skips this node WITHOUT attributing to it and
+ * keeps walking up; a test block can only sit at container level, so the walk
+ * reaches the file and the calls attribute to the File.
+ */
+const extractZigFunctionName = (node) => {
+    if (node.type !== 'test_declaration')
+        return null;
+    const nameString = node.namedChildren.find((child) => child?.type === 'string');
+    return { funcName: nameString?.text ?? '', label: 'Function' };
+};
+export const zigMethodConfig = {
+    language: SupportedLanguages.Zig,
+    // `source_file`: a file-struct's top-level fns are methods of the file's Struct.
+    typeDeclarationNodes: [...ZIG_CONTAINER_TYPES, 'source_file'],
+    methodNodeTypes: ['function_declaration'],
+    bodyNodeTypes: [],
+    extractOwnerName: extractZigOwnerName,
+    extractName: extractZigName,
+    extractFunctionName: extractZigFunctionName,
+    extractReturnType: extractZigReturnType,
+    extractParameters: extractZigParameters,
+    // `pub` only: `export fn` is C linkage, still private to other Zig files
+    // (isExported carries the FFI fact — see export-detection.ts).
+    extractVisibility: (node) => (hasZigPubKeyword(node) ? 'public' : 'private'),
+    extractReceiverType: extractZigReceiverType,
+    isStatic(node, filePath) {
+        // A Zig "method" is static when it has no receiver parameter — `self` OR
+        // a first parameter typed as the enclosing container (`replica:
+        // *Replica`, `pool: *@This()`, `ledger: *Ledger` in `Ledger.zig`); see
+        // `zigReceiverParameter`.
+        return zigReceiverParameter(node, filePath) === null;
+    },
+    isAbstract() {
+        return false;
+    },
+    isFinal() {
+        return false;
+    },
+};

package/dist/core/ingestion/method-extractors/generic.js

@@ -63,7 +63,7 @@ export function createMethodExtractor(config) {
             // Resolve owner name: config hook → field-based → type_identifier → simple_identifier → "Companion"
             let ownerName;
             if (config.extractOwnerName) {
-                ownerName = config.extractOwnerName(node);
+                ownerName = config.extractOwnerName(node, context.filePath);
             }
             if (!ownerName) {
                 const nameField = node.childForFieldName('name');
@@ -133,6 +133,17 @@ function findBodies(node, bodyNodeSet) {
         result.push(bodyField);
         addNestedBodies(bodyField, bodyNodeSet, result);
     }
+    // Grammars with no body wrapper at all: a config that declares NO
+    // `bodyNodeTypes` (tree-sitter-zig's struct_declaration holds its
+    // function_declaration children directly) uses the type-declaration node
+    // itself as the body. The downstream walk filters by `methodNodeTypes`, so
+    // unrelated children are ignored. Deliberately NOT a fallback for configs
+    // that do declare body wrappers: for them a node without its wrapper is a
+    // bodiless declaration (forward declaration, `declare class`), and scanning
+    // it would change every such language for no method it could find.
+    if (result.length === 0 && bodyNodeSet.size === 0) {
+        result.push(node);
+    }
     return result;
 }
 function addNestedBodies(parent, bodyNodeSet, out, seen) {
@@ -183,12 +194,13 @@ function buildMethod(node, ownerNode, context, config) {
         isFinal = false;
     // Static-owner detection is config-driven: each language declares which
     // container node types imply static (e.g. Ruby singleton_class, Kotlin companion_object).
-    const isStatic = (config.staticOwnerTypes?.has(ownerNode.type) ?? false) || config.isStatic(node);
+    const isStatic = (config.staticOwnerTypes?.has(ownerNode.type) ?? false) ||
+        config.isStatic(node, context.filePath);
     return {
         name,
-        receiverType: config.extractReceiverType?.(node) ?? null,
+        receiverType: config.extractReceiverType?.(node, context.filePath) ?? null,
         returnType: config.extractReturnType(node) ?? null,
-        parameters: config.extractParameters(node),
+        parameters: config.extractParameters(node, context.filePath),
         visibility: config.extractVisibility(node),
         isStatic,
         isAbstract,

package/dist/core/ingestion/method-types.d.ts

@@ -79,13 +79,19 @@ export interface MethodExtractionConfig {
     bodyNodeTypes: string[];
     extractName: (node: SyntaxNode) => string | undefined;
     extractReturnType: (node: SyntaxNode) => string | undefined;
-    extractParameters: (node: SyntaxNode) => ParameterInfo[];
+    /** The optional `filePath` (the extractor context's) is passed to
+     *  `extractParameters`, `isStatic` and `extractReceiverType` for languages
+     *  whose receiver rule depends on the file — Zig's file-struct, whose type
+     *  name is the file stem, so `fn incr(counter: *Counter)` in `Counter.zig`
+     *  is a method only when the file is known. Same optional-trailing-argument
+     *  shape as `extractOwnerName`; every other config ignores it. */
+    extractParameters: (node: SyntaxNode, filePath?: string) => ParameterInfo[];
     extractVisibility: (node: SyntaxNode) => MethodVisibility;
-    isStatic: (node: SyntaxNode) => boolean;
+    isStatic: (node: SyntaxNode, filePath?: string) => boolean;
     isAbstract: (node: SyntaxNode, ownerNode: SyntaxNode) => boolean;
     isFinal: (node: SyntaxNode) => boolean;
     extractAnnotations?: (node: SyntaxNode) => string[];
-    extractReceiverType?: (node: SyntaxNode) => string | undefined;
+    extractReceiverType?: (node: SyntaxNode, filePath?: string) => string | undefined;
     isVirtual?: (node: SyntaxNode) => boolean;
     isOverride?: (node: SyntaxNode) => boolean;
     isAsync?: (node: SyntaxNode) => boolean;
@@ -97,7 +103,7 @@ export interface MethodExtractionConfig {
      *  When the ownerNode matches one of these types, isStatic is forced true. */
     staticOwnerTypes?: ReadonlySet<string>;
     /** Resolve the owner name from a standalone method node (e.g. Go receiver type). */
-    extractOwnerName?: (node: SyntaxNode) => string | undefined;
+    extractOwnerName?: (node: SyntaxNode, filePath?: string) => string | undefined;
     /** Extract a primary constructor from the owner node itself (e.g. C# 12 class Point(int x, int y)). */
     extractPrimaryConstructor?: (ownerNode: SyntaxNode, context: MethodExtractorContext) => MethodInfo | null;
     /** Extract function name + label from an AST node during parent-walk.

package/dist/core/ingestion/model/field-registry.d.ts

@@ -2,9 +2,9 @@
  * Field Registry
  *
  * Owner-scoped field/property index extracted from SymbolTable.
- * Stores Property / Variable / Const / Static symbols keyed by
- * `ownerNodeId\0fieldName` for O(1) lookup. Supports multiple defs
- * under the same (owner, name) — e.g. legacy Property plus a
+ * Stores Property / Variable / Const / Static symbols in a nested
+ * `Map<ownerNodeId, Map<fieldName, defs[]>>` for O(1) lookup. Supports
+ * multiple defs under the same (owner, name) — e.g. legacy Property plus a
  * scope-resolution Variable reconciliation entry.
  */
 import type { SymbolDefinition } from '../../../_shared/index.js';

package/dist/core/ingestion/model/field-registry.js

@@ -2,9 +2,9 @@
  * Field Registry
  *
  * Owner-scoped field/property index extracted from SymbolTable.
- * Stores Property / Variable / Const / Static symbols keyed by
- * `ownerNodeId\0fieldName` for O(1) lookup. Supports multiple defs
- * under the same (owner, name) — e.g. legacy Property plus a
+ * Stores Property / Variable / Const / Static symbols in a nested
+ * `Map<ownerNodeId, Map<fieldName, defs[]>>` for O(1) lookup. Supports
+ * multiple defs under the same (owner, name) — e.g. legacy Property plus a
  * scope-resolution Variable reconciliation entry.
  */
 const EMPTY = Object.freeze([]);
@@ -14,20 +14,24 @@ const EMPTY = Object.freeze([]);
 export const createFieldRegistry = () => {
     const fieldByOwner = new Map();
     const lookupAllByOwner = (ownerNodeId, fieldName) => {
-        return fieldByOwner.get(`${ownerNodeId}\0${fieldName}`) ?? EMPTY;
+        return fieldByOwner.get(ownerNodeId)?.get(fieldName) ?? EMPTY;
     };
     const lookupFieldByOwner = (ownerNodeId, fieldName) => {
         const pool = lookupAllByOwner(ownerNodeId, fieldName);
         return pool.length === 0 ? undefined : pool[0];
     };
     const register = (ownerNodeId, fieldName, def) => {
-        const key = `${ownerNodeId}\0${fieldName}`;
-        const existing = fieldByOwner.get(key);
+        let byName = fieldByOwner.get(ownerNodeId);
+        if (!byName) {
+            byName = new Map();
+            fieldByOwner.set(ownerNodeId, byName);
+        }
+        const existing = byName.get(fieldName);
         if (existing) {
             existing.push(def);
         }
         else {
-            fieldByOwner.set(key, [def]);
+            byName.set(fieldName, [def]);
         }
     };
     const clear = () => {

package/dist/core/ingestion/model/method-registry.d.ts

@@ -2,9 +2,9 @@
  * Method Registry
  *
  * Owner-scoped method index extracted from SymbolTable.
- * Stores Method/Constructor/Function-with-ownerId symbols keyed by
- * `ownerNodeId\0methodName` for O(1) lookup. Supports overloads
- * (array values) and arity-based filtering.
+ * Stores Method/Constructor/Function-with-ownerId symbols in a nested
+ * `Map<ownerNodeId, Map<methodName, defs[]>>` for O(1) lookup. Supports
+ * overloads (array values) and arity-based filtering.
  */
 import type { SymbolDefinition } from '../../../_shared/index.js';
 export interface MethodRegistry {

package/dist/core/ingestion/model/method-registry.js

@@ -2,9 +2,9 @@
  * Method Registry
  *
  * Owner-scoped method index extracted from SymbolTable.
- * Stores Method/Constructor/Function-with-ownerId symbols keyed by
- * `ownerNodeId\0methodName` for O(1) lookup. Supports overloads
- * (array values) and arity-based filtering.
+ * Stores Method/Constructor/Function-with-ownerId symbols in a nested
+ * `Map<ownerNodeId, Map<methodName, defs[]>>` for O(1) lookup. Supports
+ * overloads (array values) and arity-based filtering.
  */
 // ---------------------------------------------------------------------------
 // Factory
@@ -19,8 +19,9 @@ export const createMethodRegistry = () => {
     // Set once when a Function+ownerId def lands here, powers the Tier 3
     // dedup fast-path. Monotonic: never unset except on `clear()`.
     let hasFunctionMethodsFlag = false;
+    const ownerDefs = (ownerNodeId, methodName) => methodByOwner.get(ownerNodeId)?.get(methodName);
     const lookupMethodByOwner = (ownerNodeId, methodName, argCount) => {
-        const defs = methodByOwner.get(`${ownerNodeId}\0${methodName}`);
+        const defs = ownerDefs(ownerNodeId, methodName);
         if (!defs || defs.length === 0)
             return undefined;
         // Arity narrowing: when an argCount is provided and there are multiple
@@ -89,16 +90,20 @@ export const createMethodRegistry = () => {
         return methodsByName.get(name) ?? EMPTY;
     };
     const lookupAllByOwner = (ownerNodeId, methodName) => {
-        return methodByOwner.get(`${ownerNodeId}\0${methodName}`) ?? EMPTY;
+        return ownerDefs(ownerNodeId, methodName) ?? EMPTY;
     };
     const register = (ownerNodeId, methodName, def) => {
-        const key = `${ownerNodeId}\0${methodName}`;
-        const existing = methodByOwner.get(key);
+        let owned = methodByOwner.get(ownerNodeId);
+        if (!owned) {
+            owned = new Map();
+            methodByOwner.set(ownerNodeId, owned);
+        }
+        const existing = owned.get(methodName);
         if (existing) {
             existing.push(def);
         }
         else {
-            methodByOwner.set(key, [def]);
+            owned.set(methodName, [def]);
         }
         const byName = methodsByName.get(methodName);
         if (byName) {

package/dist/core/ingestion/model/registration-table.js

@@ -116,6 +116,9 @@ const LABEL_BEHAVIOR = {
     Section: 'inert',
     Route: 'inert',
     Tool: 'inert',
+    // A broker address, not a symbol: nothing in any language resolves a name to
+    // it, so it stays out of the dispatch and callable indexes like `Route`.
+    Destination: 'inert',
     // Taint/PDG substrate (issue #2080) — a control-flow node, never a
     // symbol-resolution target. Inert: file index only, no owner scope.
     BasicBlock: 'inert',

package/dist/core/ingestion/model/type-registry.js

@@ -24,7 +24,7 @@ export const createTypeRegistry = () => {
         return implByName.get(name) ?? [];
     };
     const lookupAllByOwner = (ownerNodeId, simpleName) => {
-        return nestedByOwner.get(`${ownerNodeId}\0${simpleName}`) ?? EMPTY;
+        return nestedByOwner.get(ownerNodeId)?.get(simpleName) ?? EMPTY;
     };
     const registerClass = (name, qualifiedName, def) => {
         const existing = classByName.get(name);
@@ -52,13 +52,17 @@ export const createTypeRegistry = () => {
         }
     };
     const registerByOwner = (ownerNodeId, simpleName, def) => {
-        const key = `${ownerNodeId}\0${simpleName}`;
-        const existing = nestedByOwner.get(key);
+        let byName = nestedByOwner.get(ownerNodeId);
+        if (!byName) {
+            byName = new Map();
+            nestedByOwner.set(ownerNodeId, byName);
+        }
+        const existing = byName.get(simpleName);
         if (existing) {
             existing.push(def);
         }
         else {
-            nestedByOwner.set(key, [def]);
+            byName.set(simpleName, [def]);
         }
     };
     const clear = () => {

package/dist/core/ingestion/pipeline-phases/di.js

@@ -48,6 +48,9 @@ function providerCandidates(ids, providers) {
     // candidates when none are known instead of dropping the injection entirely.
     return recognized.length > 0 ? recognized : all;
 }
+function isConcreteTypeNode(node) {
+    return node?.label === 'Class' || node?.label === 'Record' || node?.label === 'Enum';
+}
 export const diPhase = {
     name: 'di',
     deps: ['mro'],
@@ -103,21 +106,25 @@ export const diPhase = {
                 ambiguousInjections: 0,
             };
         }
-        const interfaceToImplementers = new Map();
+        const directSubtypes = new Map();
         const directSupertypes = new Map();
         for (const rel of ctx.graph.iterRelationshipsByType('IMPLEMENTS')) {
-            const set = interfaceToImplementers.get(rel.targetId) ?? new Set();
-            set.add(rel.sourceId);
-            interfaceToImplementers.set(rel.targetId, set);
+            const subtypes = directSubtypes.get(rel.targetId) ?? new Set();
+            subtypes.add(rel.sourceId);
+            directSubtypes.set(rel.targetId, subtypes);
             const supertypes = directSupertypes.get(rel.sourceId) ?? new Set();
             supertypes.add(rel.targetId);
             directSupertypes.set(rel.sourceId, supertypes);
         }
         for (const rel of ctx.graph.iterRelationshipsByType('EXTENDS')) {
+            const subtypes = directSubtypes.get(rel.targetId) ?? new Set();
+            subtypes.add(rel.sourceId);
+            directSubtypes.set(rel.targetId, subtypes);
             const supertypes = directSupertypes.get(rel.sourceId) ?? new Set();
             supertypes.add(rel.targetId);
             directSupertypes.set(rel.sourceId, supertypes);
         }
+        const orderedDirectSubtypes = new Map([...directSubtypes].map(([typeId, subtypes]) => [typeId, [...subtypes].sort().reverse()]));
         const memberToClass = new Map();
         for (const relationType of ['HAS_PROPERTY', 'HAS_METHOD']) {
             for (const rel of ctx.graph.iterRelationshipsByType(relationType)) {
@@ -128,18 +135,45 @@ export const diPhase = {
         const interfacesByLanguage = new Map();
         const classesByLanguage = new Map();
         ctx.graph.forEachNode((node) => {
-            if (node.label !== 'Class' && node.label !== 'Interface')
+            const concreteType = isConcreteTypeNode(node);
+            if (!concreteType && node.label !== 'Interface')
                 return;
             const language = node.properties.language;
             if (typeof language !== 'string' || !candidateLanguages.has(language))
                 return;
-            const indexes = node.label === 'Class' ? classesByLanguage : interfacesByLanguage;
+            const indexes = concreteType ? classesByLanguage : interfacesByLanguage;
             const index = indexes.get(language) ?? emptyNameIndex();
             addIndexedName(index, node);
             indexes.set(language, index);
-            if (node.label === 'Class')
+            if (concreteType)
                 providerNodes.set(node.id, node);
         });
+        const concreteSubtypesByRoot = new Map();
+        const concreteSubtypes = (rootTypeId, language) => {
+            const cacheKey = `${language}\0${rootTypeId}`;
+            const cached = concreteSubtypesByRoot.get(cacheKey);
+            if (cached !== undefined)
+                return cached;
+            const concrete = new Set();
+            const queue = [rootTypeId];
+            const visited = new Set();
+            while (queue.length > 0) {
+                const typeId = queue.pop();
+                if (typeId === undefined || visited.has(typeId))
+                    continue;
+                visited.add(typeId);
+                const typeNode = ctx.graph.getNode(typeId);
+                if (typeNode !== undefined &&
+                    isConcreteTypeNode(typeNode) &&
+                    typeNode.properties.language === language) {
+                    concrete.add(typeId);
+                }
+                const children = orderedDirectSubtypes.get(typeId) ?? [];
+                queue.push(...children);
+            }
+            concreteSubtypesByRoot.set(cacheKey, concrete);
+            return concrete;
+        };
         // A declaration returning a concrete class is assignable to every class or
         // interface that type extends/implements. Expand once per language+type and
         // register the declaration under those ancestor names. This keeps named
@@ -227,13 +261,12 @@ export const diPhase = {
                 ambiguousTypeNames.add(candidate.targetTypeName);
                 continue;
             }
-            const structural = new Set();
-            if (typeof classEntry === 'string')
-                structural.add(classEntry);
-            if (typeof interfaceEntry === 'string') {
-                for (const id of interfaceToImplementers.get(interfaceEntry) ?? [])
-                    structural.add(id);
-            }
+            const rootTypeId = typeof classEntry === 'string'
+                ? classEntry
+                : typeof interfaceEntry === 'string'
+                    ? interfaceEntry
+                    : undefined;
+            const structural = new Set(rootTypeId === undefined ? [] : concreteSubtypes(rootTypeId, candidate.language));
             for (const id of providedTypes.get(candidate.language)?.get(candidate.targetTypeName) ?? []) {
                 structural.add(id);
             }

package/dist/core/ingestion/pipeline-phases/index.d.ts

@@ -15,6 +15,7 @@ export { ormPhase, type ORMOutput } from './orm.js';
 export { crossFilePhase, type CrossFileOutput } from './cross-file.js';
 export { scopeResolutionPhase, type ScopeResolutionOutput, } from '../scope-resolution/pipeline/phase.js';
 export { springConfigPhase, type SpringConfigOutput } from './spring-config.js';
+export { springDestinationsPhase, type SpringDestinationsOutput } from './spring-destinations.js';
 export { springAutoConfigurationPhase, type SpringAutoConfigurationOutput, } from './spring-auto-configuration.js';
 export { springAopPhase, springAopInheritancePhase, type SpringAopOutput, type SpringAopInheritanceOutput, } from './spring-aop.js';
 export { pruneLocalSymbolsPhase, type PruneLocalSymbolsOutput } from './prune-local-symbols.js';