gitnexus 1.6.10-rc.99 → 1.6.10

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

@@ -9,7 +9,51 @@ import { SupportedLanguages } from '../../../_shared/index.js';
 import { defineLanguage } from '../language-provider.js';
 import { createClassExtractor } from '../class-extractors/generic.js';
 import { typescriptClassConfig, javascriptClassConfig, } from '../class-extractors/configs/typescript-javascript.js';
-import { createLeadingDocDescriptionExtractor } from '../utils/ast-helpers.js';
+import { createLeadingDocDescriptionExtractor, isCjsDefaultExportAssignment, isPrototypeMemberAssignmentNode, } from '../utils/ast-helpers.js';
+import { cjsExportedNameFor, isModuleLevelThisAssignment, isModuleLevelThisExport, isShadowedCjsExportAssignmentNode, } from './typescript/cjs-export-assignment.js';
+const rootOf = (node) => node.tree?.rootNode;
+/** `exports.X = fn` where the module already declares `X` — see #2723. */
+const isShadowedCjsExportNode = (node) => {
+    const root = rootOf(node);
+    return root !== undefined && isShadowedCjsExportAssignmentNode(node, root);
+};
+/**
+ * Label for a `<receiver>.<member> = <function>` capture (#2723 follow-up).
+ *
+ * The member-assignment queries match ANY identifier receiver, because an
+ * `exports` alias (`const e = exports; e.foo = fn`) cannot be pinned in the
+ * query. Everything that is not a recognised shape is dropped HERE — without
+ * that, every `obj.handler = function () {}` in every JS/TS file would emit a
+ * spurious top-level `Function` named `handler`.
+ *
+ * Recognised: a CJS export (direct, `module.exports`, or via a module-scope
+ * alias) stays a Function; a prototype or `this` member becomes a Method; a
+ * CJS export shadowing a name the module already declares emits nothing.
+ */
+const memberAssignmentLabel = (node) => {
+    const root = rootOf(node);
+    // Module-level `this.X = fn` in CommonJS IS `module.exports.X = fn`, so it
+    // is an exported Function, not an instance member. Checked before the
+    // Method branch, which would otherwise claim every `this` receiver.
+    if (root !== undefined && isModuleLevelThisExport(node, root))
+        return 'Function';
+    // `module.exports = fn` — the module itself is the callable.
+    if (isCjsDefaultExportAssignment(node))
+        return 'Function';
+    // A module-level `this` member in ESM or a no-signal file is neither an
+    // export (top-level `this` is undefined) nor an instance member. Emitting a
+    // Method there minted an ownerless node (#2729 review F13).
+    if (isModuleLevelThisAssignment(node))
+        return null;
+    if (isPrototypeMemberAssignmentNode(node))
+        return 'Method';
+    if (isShadowedCjsExportNode(node))
+        return null;
+    const value = node.childForFieldName('right');
+    if (root === undefined || value === null)
+        return null;
+    return cjsExportedNameFor(value, root) !== null ? 'Function' : null;
+};
 import { createTypeScriptCfgVisitor } from '../cfg/visitors/typescript.js';
 import { typeConfig as typescriptConfig } from '../type-extractors/typescript.js';
 import { tsExportChecker } from '../export-detection.js';
@@ -28,6 +72,15 @@ import { typescriptCallConfig, javascriptCallConfig, } from '../call-extractors/
 import { ARRAY_METHOD_HOC_BLOCKLIST_SET, DEFAULT_EXPORT_IDENTIFIER_BLOCKLIST_SET, deriveDefaultExportHocName, } from '../ts-js-hoc-utils.js';
 import { emitTsScopeCaptures, interpretTsImport, interpretTsTypeBinding, tsBindingScopeFor, tsImportOwningScope, tsReceiverBinding, typescriptMergeBindings, typescriptArityCompatibility, resolveTsImportTarget, } from './typescript/index.js';
 import { emitJsScopeCaptures, interpretJsImport, interpretJsTypeBinding, jsBindingScopeFor, jsImportOwningScope, jsReceiverBinding, jsMergeBindings, jsArityCompatibility, } from './javascript/index.js';
+import { extractDispatchGuardRoutes } from '../route-extractors/dispatch-guard.js';
+import { extractDataRouteTableRoutes } from '../route-extractors/data-route-table.js';
+import { extractNestRoutes } from '../route-extractors/nest.js';
+import { extractConvexEndpointProperties } from './typescript/convex-endpoint-metadata.js';
+const extractJsTsRoutes = (...args) => [
+    ...extractDispatchGuardRoutes(...args),
+    ...extractDataRouteTableRoutes(...args),
+    ...extractNestRoutes(...args),
+];
 /**
  * TypeScript/JavaScript: arrow_function and function_expression are
  * anonymous AST nodes — they take their name from the surrounding
@@ -250,6 +303,15 @@ export const BUILT_INS = new Set([
     'toString',
     'valueOf',
 ]);
+/**
+ * `this` is the only receiver keyword JavaScript and TypeScript bind, and it
+ * is bound by every function form except an arrow (#2701). The query files
+ * tag those forms with `@receiver-owner.this`; this hook just reads the tag,
+ * so the node-type list stays in the one place that already names grammar
+ * nodes. See `Scope.ownsReceivers` for what the marker does to the walk.
+ */
+const TS_OWNED_RECEIVERS = new Set(['this']);
+const tsScopeOwnsReceivers = (match) => match['@receiver-owner.this'] === undefined ? undefined : TS_OWNED_RECEIVERS;
 export const typescriptProvider = defineLanguage({
     id: SupportedLanguages.TypeScript,
     extensions: ['.ts', '.tsx'],
@@ -278,6 +340,7 @@ export const typescriptProvider = defineLanguage({
     ],
     treeSitterQueries: TYPESCRIPT_QUERIES,
     typeConfig: typescriptConfig,
+    scopeOwnsReceivers: tsScopeOwnsReceivers,
     exportChecker: tsExportChecker,
     importResolver: createImportResolver(typescriptImportConfig),
     callExtractor: createCallExtractor(typescriptCallConfig),
@@ -287,6 +350,7 @@ export const typescriptProvider = defineLanguage({
         extractFunctionName: tsExtractFunctionName,
     }),
     variableExtractor: createVariableExtractor(typescriptVariableConfig),
+    definitionPropertiesExtractor: extractConvexEndpointProperties,
     classExtractor: createClassExtractor(typescriptClassConfig),
     // ── JSDoc → description (issue #2270). An exported decl is captured as the
     //    inner declaration; its JSDoc precedes the wrapping `export_statement`. ──
@@ -294,6 +358,19 @@ export const typescriptProvider = defineLanguage({
         wrapperNodeTypes: ['export_statement'],
     }),
     builtInNames: BUILT_INS,
+    // Member-assignment shapes are not free functions (#2723 follow-up). The
+    // capture arrives anchored on the assignment, so the shape is decided from
+    // the left-hand side:
+    //   - `Foo.prototype.bar = fn` / `this.bar = fn` -> a Method
+    //   - a CJS export shadowing a name the module already declares -> no node
+    //     at all, since the scope declaration that would reach it is suppressed
+    //     too (an orphan `Function` twin beside `class Dup {}` otherwise).
+    // Every other `definition.function` capture keeps its default label.
+    labelOverride: (functionNode, defaultLabel) => defaultLabel !== 'Function'
+        ? defaultLabel
+        : functionNode.type === 'assignment_expression'
+            ? memberAssignmentLabel(functionNode)
+            : defaultLabel,
     // ── RFC #909 Ring 3: scope-based resolution hooks (RFC §5) ──────────
     // TypeScript is the third migration after Python and C#. See
     // ./typescript/index.ts for the full per-hook rationale and the
@@ -314,10 +391,14 @@ export const typescriptProvider = defineLanguage({
     receiverBinding: tsReceiverBinding,
     arityCompatibility: typescriptArityCompatibility,
     resolveImportTarget: resolveTsImportTarget,
+    // A raw `node:http` server declares its routes by comparing the request path
+    // to a literal; nothing else in this pipeline can see that shape. TS and JS
+    // share the grammar, so they share the extractor.
+    extractDecoratorRoutes: extractJsTsRoutes,
 });
 export const javascriptProvider = defineLanguage({
     id: SupportedLanguages.JavaScript,
-    extensions: ['.js', '.jsx'],
+    extensions: ['.js', '.jsx', '.mjs', '.cjs'],
     entryPointPatterns: [/^use[A-Z]/],
     astFrameworkPatterns: [
         {
@@ -343,6 +424,7 @@ export const javascriptProvider = defineLanguage({
     ],
     treeSitterQueries: JAVASCRIPT_QUERIES,
     typeConfig: typescriptConfig,
+    scopeOwnsReceivers: tsScopeOwnsReceivers,
     exportChecker: tsExportChecker,
     importResolver: createImportResolver(javascriptImportConfig),
     callExtractor: createCallExtractor(javascriptCallConfig),
@@ -352,6 +434,7 @@ export const javascriptProvider = defineLanguage({
         extractFunctionName: tsExtractFunctionName,
     }),
     variableExtractor: createVariableExtractor(javascriptVariableConfig),
+    definitionPropertiesExtractor: extractConvexEndpointProperties,
     classExtractor: createClassExtractor(javascriptClassConfig),
     // ── JSDoc → description (issue #2270). An exported decl is captured as the
     //    inner declaration; its JSDoc precedes the wrapping `export_statement`. ──
@@ -359,6 +442,12 @@ export const javascriptProvider = defineLanguage({
         wrapperNodeTypes: ['export_statement'],
     }),
     builtInNames: BUILT_INS,
+    // Member-assignment shapes — see the TypeScript provider above.
+    labelOverride: (functionNode, defaultLabel) => defaultLabel !== 'Function'
+        ? defaultLabel
+        : functionNode.type === 'assignment_expression'
+            ? memberAssignmentLabel(functionNode)
+            : defaultLabel,
     // ── RFC #909 Ring 3: scope-based resolution hooks (RFC §5) ──────────
     // JavaScript is the fourth migration after Python, C#, and TypeScript.
     // Hooks are thin wrappers over the TypeScript implementations where
@@ -375,4 +464,6 @@ export const javascriptProvider = defineLanguage({
     mergeBindings: (_scope, bindings) => jsMergeBindings(bindings),
     receiverBinding: jsReceiverBinding,
     arityCompatibility: jsArityCompatibility,
+    // See the TypeScript provider above.
+    extractDecoratorRoutes: extractJsTsRoutes,
 });

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

@@ -1,27 +1,11 @@
 /**
  * Import-target resolver for Vue SFCs (RFC #909 Ring 3, issue #940).
  *
- * Vue `<script>` / `<script setup>` blocks are TypeScript (or plain
- * JavaScript), so the resolver delegates to `resolveTsTarget` with
- * `language: SupportedLanguages.TypeScript` to get:
- *
- *   - tsconfig path-alias rewriting (Vue projects universally use TS)
- *   - `.ts` / `.tsx` / `.js` / `.jsx` extension-suffix fallback
- *
- * `.vue` imports are written with explicit extensions (`'./Button.vue'`),
- * so no Vue-specific suffix guessing is required: the standard
- * resolver finds them via the exact-path branch before any extension
- * logic fires.
- *
- * Memoization mirrors the TypeScript adapter: workspace file-list
- * arrays, the suffix index, and the per-pass resolve cache are rebuilt
- * lazily when `allFilePaths` reference changes (once per workspace pass).
- */
-/**
- * Build a memoized `resolveImportTarget` adapter for Vue SFCs.
- *
- * Uses `SupportedLanguages.TypeScript` so tsconfig path-alias resolution
- * and `.ts`/`.tsx` extension guessing fire for relative and bare-specifier
- * imports inside `<script>` blocks.
+ * `<script>` / `<script setup>` blocks are TypeScript or plain JavaScript, so
+ * resolution is TypeScript's: the same tsconfig `paths`/`baseUrl` rules and the
+ * same `package.json` manifests. `.vue` imports are written with an explicit
+ * extension (`'./Button.vue'`) and `.vue` is in the candidate list, so no
+ * Vue-specific guessing is required — the exact-path branch finds them first.
  */
+/** Build the Vue `resolveImportTarget` adapter. */
 export declare function makeVueResolveImportTarget(): (targetRaw: string, fromFile: string, allFilePaths: ReadonlySet<string>, resolutionConfig?: unknown) => string | readonly string[] | null;

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

@@ -1,58 +1,22 @@
 /**
  * Import-target resolver for Vue SFCs (RFC #909 Ring 3, issue #940).
  *
- * Vue `<script>` / `<script setup>` blocks are TypeScript (or plain
- * JavaScript), so the resolver delegates to `resolveTsTarget` with
- * `language: SupportedLanguages.TypeScript` to get:
- *
- *   - tsconfig path-alias rewriting (Vue projects universally use TS)
- *   - `.ts` / `.tsx` / `.js` / `.jsx` extension-suffix fallback
- *
- * `.vue` imports are written with explicit extensions (`'./Button.vue'`),
- * so no Vue-specific suffix guessing is required: the standard
- * resolver finds them via the exact-path branch before any extension
- * logic fires.
- *
- * Memoization mirrors the TypeScript adapter: workspace file-list
- * arrays, the suffix index, and the per-pass resolve cache are rebuilt
- * lazily when `allFilePaths` reference changes (once per workspace pass).
+ * `<script>` / `<script setup>` blocks are TypeScript or plain JavaScript, so
+ * resolution is TypeScript's: the same tsconfig `paths`/`baseUrl` rules and the
+ * same `package.json` manifests. `.vue` imports are written with an explicit
+ * extension (`'./Button.vue'`) and `.vue` is in the candidate list, so no
+ * Vue-specific guessing is required — the exact-path branch finds them first.
  */
-import { SupportedLanguages } from '../../../../_shared/index.js';
 import { resolveTsTarget } from '../typescript/import-target.js';
-import { buildSuffixIndex } from '../../import-resolvers/utils.js';
-/**
- * Build a memoized `resolveImportTarget` adapter for Vue SFCs.
- *
- * Uses `SupportedLanguages.TypeScript` so tsconfig path-alias resolution
- * and `.ts`/`.tsx` extension guessing fire for relative and bare-specifier
- * imports inside `<script>` blocks.
- */
+/** Build the Vue `resolveImportTarget` adapter. */
 export function makeVueResolveImportTarget() {
-    let cached = null;
     return (targetRaw, fromFile, allFilePaths, resolutionConfig) => {
-        if (cached === null || cached.key !== allFilePaths) {
-            const allFileList = Array.from(allFilePaths);
-            const normalizedFileList = allFileList.map((f) => f.toLowerCase());
-            cached = {
-                key: allFilePaths,
-                allFilePaths: new Set(allFilePaths),
-                allFileList,
-                normalizedFileList,
-                index: buildSuffixIndex(normalizedFileList, allFileList),
-                resolveCache: new Map(),
-            };
-        }
         const cfg = resolutionConfig;
-        const ws = {
+        return resolveTsTarget(targetRaw, {
             fromFile,
-            language: SupportedLanguages.TypeScript,
-            allFilePaths: cached.allFilePaths,
-            allFileList: cached.allFileList,
-            normalizedFileList: cached.normalizedFileList,
-            index: cached.index,
-            resolveCache: cached.resolveCache,
-            tsconfigPaths: cfg?.tsconfigPaths ?? null,
-        };
-        return resolveTsTarget(targetRaw, ws);
+            allFilePaths,
+            tsconfigs: cfg?.tsconfigs ?? null,
+            nodeWorkspacePackages: cfg?.nodeWorkspacePackages ?? null,
+        });
     };
 }

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

@@ -56,7 +56,8 @@ import { buildMro, defaultLinearize } from '../../scope-resolution/passes/mro.js
 import { populateClassOwnedMembers } from '../../scope-resolution/scope/walkers.js';
 import { simpleKey } from '../../scope-resolution/graph-bridge/node-lookup.js';
 import { vueProvider } from '../vue.js';
-import { loadTsconfigPaths } from '../../language-config.js';
+import { loadTsconfigIndex } from '../typescript/tsconfig.js';
+import { loadNodeWorkspacePackages } from '../../import-resolvers/node-workspace-packages.js';
 import { typescriptArityCompatibility, typescriptMergeBindings } from '../typescript/index.js';
 import { makeVueResolveImportTarget } from './import-target.js';
 import { extractVueTemplateEdgeData } from '../../vue-sfc-extractor.js';
@@ -79,7 +80,8 @@ const vueScopeResolver = {
     // Vue projects universally use TypeScript — load tsconfig so path
     // aliases (`@/`, `~/`, `#/`) resolve through the standard branch.
     loadResolutionConfig: async (repoPath) => ({
-        tsconfigPaths: await loadTsconfigPaths(repoPath),
+        tsconfigs: await loadTsconfigIndex(repoPath),
+        nodeWorkspacePackages: await loadNodeWorkspacePackages(repoPath),
     }),
     // TypeScript LEGB semantics apply inside `<script>` / `<script setup>`.
     mergeBindings: (existing, incoming) => [...typescriptMergeBindings([...existing, ...incoming])],

package/dist/core/ingestion/local-symbol-pruner.js

@@ -16,10 +16,10 @@ const isLocalValueCandidate = (node) => {
 // True when `rel` is the structural `File -> DEFINES -> candidate` edge. Callers
 // guard on the candidate already being the edge target, so only the source label
 // needs checking here.
-const isFileDefinesEdge = (graph, rel) => {
-    if (rel.type !== 'DEFINES')
+const isFileDefinesEdge = (graph, type, sourceId) => {
+    if (type !== 'DEFINES')
         return false;
-    return graph.getNode(rel.sourceId)?.label === 'File';
+    return graph.getNode(sourceId)?.label === 'File';
 };
 export const pruneLocalValueSymbols = (graph, options = {}) => {
     if (options.keepLocalValueSymbols ?? shouldKeepLocalValueSymbols()) {
@@ -33,20 +33,20 @@ export const pruneLocalValueSymbols = (graph, options = {}) => {
     if (candidateIds.size === 0)
         return emptyStats(false);
     const candidatesWithSemanticEdges = new Set();
-    for (const rel of graph.iterRelationships()) {
+    // Field-wise scan (#2680): a whole-graph walk that reads only these three, so
+    // materializing a relationship object per edge would be pure overhead.
+    graph.forEachRelationshipFields((sourceId, targetId, type) => {
         // Any outgoing edge from a candidate is a semantic edge: the only structural
         // edge a block-local value symbol carries is the incoming File -> DEFINES, on
         // which the candidate is the target, never the source.
-        if (candidateIds.has(rel.sourceId)) {
-            candidatesWithSemanticEdges.add(rel.sourceId);
+        if (candidateIds.has(sourceId)) {
+            candidatesWithSemanticEdges.add(sourceId);
         }
         // An incoming edge is semantic unless it is the structural File -> DEFINES.
-        if (candidateIds.has(rel.targetId)) {
-            if (!isFileDefinesEdge(graph, rel)) {
-                candidatesWithSemanticEdges.add(rel.targetId);
-            }
+        if (candidateIds.has(targetId) && !isFileDefinesEdge(graph, type, sourceId)) {
+            candidatesWithSemanticEdges.add(targetId);
         }
-    }
+    });
     let prunedNodes = 0;
     for (const candidateId of candidateIds) {
         if (candidatesWithSemanticEdges.has(candidateId))

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

@@ -282,6 +282,7 @@ export const csharpMethodConfig = {
             annotations: [], // C# has no syntax for attributes on primary constructors
             sourceFile: context.filePath,
             line: paramList.startPosition.row + 1,
+            column: paramList.startPosition.column,
         };
     },
 };

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

@@ -202,5 +202,6 @@ function buildMethod(node, ownerNode, context, config) {
         annotations: config.extractAnnotations?.(node) ?? [],
         sourceFile: context.filePath,
         line: node.startPosition.row + 1,
+        column: node.startPosition.column,
     };
 }

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

@@ -31,6 +31,22 @@ export interface MethodInfo {
     annotations: string[];
     sourceFile: string;
     line: number;
+    /**
+     * 0-based `startPosition.column` of the node `line` was derived from.
+     *
+     * `line` alone does NOT identify a callable. A callable that is SYNTHESIZED
+     * at a position that is not its own declaration shares its owner's line: a
+     * Java record's implicit component accessor is minted at the COMPONENT, and a
+     * C# 12 primary constructor at the owner's `parameter_list`. So both
+     * `record P(int x, int y) { int x(int s) {…} }` and
+     * `class Point(int x, int y) { public Point(int x) : this(x, 0) {} }` give two
+     * different callables the same (name, line) (#2936).
+     *
+     * Required, not optional: the per-class map in parse-worker keys on it, and
+     * an absent column would key an entry no lookup could ever reach — a silent,
+     * whole-language loss of method enrichment rather than a compile error.
+     */
+    column: number;
 }
 export interface MethodExtractorContext {
     filePath: string;

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

@@ -3,7 +3,7 @@
  *
  * Framework-neutral dependency-injection resolution. Per-language resolvers
  * identify injection sites and provider metadata; this phase performs only
- * graph-level type/heritage resolution and emits Class -> Class INJECTS edges.
+ * graph-level type/heritage resolution and emits owner/site -> provider INJECTS edges.
  *
  * @deps    mro
  * @reads   graph (Class/Interface/member nodes and heritage/ownership edges)

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

@@ -3,7 +3,7 @@
  *
  * Framework-neutral dependency-injection resolution. Per-language resolvers
  * identify injection sites and provider metadata; this phase performs only
- * graph-level type/heritage resolution and emits Class -> Class INJECTS edges.
+ * graph-level type/heritage resolution and emits owner/site -> provider INJECTS edges.
  *
  * @deps    mro
  * @reads   graph (Class/Interface/member nodes and heritage/ownership edges)
@@ -13,6 +13,16 @@ import { DI_RESOLVERS, isSupportedLanguage, } from '../di-extractors/index.js';
 import { isDev } from '../utils/env.js';
 import { logger } from '../../logger.js';
 const AMBIGUOUS = Symbol('ambiguous');
+function addProvidedType(index, language, typeName, providerId) {
+    const byName = index.get(language) ?? new Map();
+    const names = new Set([typeName, typeName.slice(typeName.lastIndexOf('.') + 1)]);
+    for (const name of names) {
+        const providers = byName.get(name) ?? new Set();
+        providers.add(providerId);
+        byName.set(name, providers);
+    }
+    index.set(language, byName);
+}
 function emptyNameIndex() {
     return { byQualifiedName: new Map(), bySimpleName: new Map() };
 }
@@ -50,6 +60,10 @@ export const diPhase = {
         });
         const candidates = [];
         const providers = new Map();
+        const providedTypes = new Map();
+        const providerNames = new Map();
+        const providerNodes = new Map();
+        const providersByDeclarer = new Map();
         ctx.graph.forEachNode((node) => {
             const language = node.properties.language;
             if (language === undefined || !isSupportedLanguage(language))
@@ -58,8 +72,25 @@ export const diPhase = {
             if (resolver === undefined)
                 return;
             const provider = resolver.matchProvider(node);
-            if (provider !== null)
+            if (provider !== null) {
                 providers.set(node.id, provider);
+                providerNodes.set(node.id, node);
+                const namesByLanguage = providerNames.get(language) ?? new Map();
+                for (const name of provider.names) {
+                    const namedProviders = namesByLanguage.get(name) ?? new Set();
+                    namedProviders.add(node.id);
+                    namesByLanguage.set(name, namedProviders);
+                }
+                providerNames.set(language, namesByLanguage);
+                if (provider.providedTypeName !== undefined) {
+                    addProvidedType(providedTypes, language, provider.providedTypeName, node.id);
+                }
+                if (provider.declaredByNodeId !== undefined) {
+                    const declared = providersByDeclarer.get(provider.declaredByNodeId) ?? new Set();
+                    declared.add(node.id);
+                    providersByDeclarer.set(provider.declaredByNodeId, declared);
+                }
+            }
             for (const match of resolver.matchInjectionSites(node)) {
                 candidates.push({ ...match, siteNodeId: node.id, language });
             }
@@ -73,10 +104,19 @@ export const diPhase = {
             };
         }
         const interfaceToImplementers = 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 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 supertypes = directSupertypes.get(rel.sourceId) ?? new Set();
+            supertypes.add(rel.targetId);
+            directSupertypes.set(rel.sourceId, supertypes);
         }
         const memberToClass = new Map();
         for (const relationType of ['HAS_PROPERTY', 'HAS_METHOD']) {
@@ -87,7 +127,6 @@ export const diPhase = {
         const candidateLanguages = new Set(candidates.map((candidate) => candidate.language));
         const interfacesByLanguage = new Map();
         const classesByLanguage = new Map();
-        const classNodes = new Map();
         ctx.graph.forEachNode((node) => {
             if (node.label !== 'Class' && node.label !== 'Interface')
                 return;
@@ -99,8 +138,62 @@ export const diPhase = {
             addIndexedName(index, node);
             indexes.set(language, index);
             if (node.label === 'Class')
-                classNodes.set(node.id, node);
+                providerNodes.set(node.id, node);
         });
+        // 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
+        // selection fast (set intersection below) while allowing, for example, a
+        // `DefaultGateway` Bean to satisfy a named `Gateway` Resource site.
+        const assignableNamesByProvidedType = new Map();
+        for (const [providerId, provider] of providers) {
+            if (provider.providedTypeName === undefined)
+                continue;
+            const providerNode = providerNodes.get(providerId);
+            const language = providerNode?.properties.language;
+            if (typeof language !== 'string')
+                continue;
+            const cacheKey = `${language}\0${provider.providedTypeName}`;
+            let assignableTypeNames = assignableNamesByProvidedType.get(cacheKey);
+            if (assignableTypeNames === undefined) {
+                const classEntry = resolveIndexedName(classesByLanguage.get(language), provider.providedTypeName);
+                const interfaceEntry = resolveIndexedName(interfacesByLanguage.get(language), provider.providedTypeName);
+                const rootTypeId = typeof classEntry === 'string' && interfaceEntry === undefined
+                    ? classEntry
+                    : typeof interfaceEntry === 'string' && classEntry === undefined
+                        ? interfaceEntry
+                        : undefined;
+                const names = new Set();
+                if (rootTypeId !== undefined) {
+                    const queue = [rootTypeId];
+                    const visited = new Set();
+                    while (queue.length > 0) {
+                        const typeId = queue.pop();
+                        if (typeId === undefined)
+                            continue;
+                        if (visited.has(typeId))
+                            continue;
+                        visited.add(typeId);
+                        const typeNode = ctx.graph.getNode(typeId);
+                        if ((typeNode?.label === 'Class' || typeNode?.label === 'Interface') &&
+                            typeNode.properties.language === language) {
+                            names.add(typeNode.properties.name);
+                            const qualifiedName = typeNode.properties.qualifiedName;
+                            if (typeof qualifiedName === 'string')
+                                names.add(qualifiedName);
+                        }
+                        for (const supertypeId of directSupertypes.get(typeId) ?? []) {
+                            queue.push(supertypeId);
+                        }
+                    }
+                }
+                assignableTypeNames = [...names];
+                assignableNamesByProvidedType.set(cacheKey, assignableTypeNames);
+            }
+            for (const typeName of assignableTypeNames) {
+                addProvidedType(providedTypes, language, typeName, providerId);
+            }
+        }
         let ambiguousSkipped = 0;
         let ambiguousInjections = 0;
         const ambiguousTypeNames = new Set();
@@ -118,6 +211,7 @@ export const diPhase = {
             const consumerClassId = siteNode?.label === 'Class' ? siteNode.id : memberToClass.get(candidate.siteNodeId);
             if (consumerClassId === undefined)
                 continue;
+            const edgeSourceId = candidate.edgeSource === 'site' && siteNode !== undefined ? siteNode.id : consumerClassId;
             const classEntry = resolveIndexedName(classesByLanguage.get(candidate.language), candidate.targetTypeName);
             const interfaceEntry = resolveIndexedName(interfacesByLanguage.get(candidate.language), candidate.targetTypeName);
             if (classEntry === AMBIGUOUS ||
@@ -140,36 +234,57 @@ export const diPhase = {
                 for (const id of interfaceToImplementers.get(interfaceEntry) ?? [])
                     structural.add(id);
             }
+            for (const id of providedTypes.get(candidate.language)?.get(candidate.targetTypeName) ?? []) {
+                structural.add(id);
+            }
+            for (const id of providersByDeclarer.get(edgeSourceId) ?? [])
+                structural.delete(id);
             structural.delete(consumerClassId);
+            structural.delete(edgeSourceId);
             if (structural.size === 0)
                 continue;
-            let viable = providerCandidates(structural, providers);
             const namedSelection = candidate.namedSelection;
+            let usedNamedSelection = false;
+            let selectionSuffix = '';
+            let viable;
             if (namedSelection !== undefined) {
-                viable = viable.filter((id) => providers.get(id)?.names.includes(namedSelection.name) === true);
-                if (viable.length === 0)
+                const named = [
+                    ...(providerNames.get(candidate.language)?.get(namedSelection.name) ?? []),
+                ].filter((id) => structural.has(id));
+                if (named.length > 0) {
+                    viable = named;
+                    usedNamedSelection = true;
+                    selectionSuffix = `; ${namedSelection.reason}`;
+                }
+                else if (namedSelection.fallbackToType === true) {
+                    viable = providerCandidates(structural, providers);
+                    selectionSuffix = `; ${namedSelection.reason} unmatched; type fallback`;
+                }
+                else {
                     continue;
+                }
+            }
+            else {
+                viable = providerCandidates(structural, providers);
             }
             if (candidate.cardinality === 'collection') {
-                const confidence = namedSelection === undefined ? 0.8 : 0.9;
-                const suffix = namedSelection === undefined ? '' : `; ${namedSelection.reason}`;
+                const confidence = usedNamedSelection ? 0.9 : 0.8;
                 for (const targetId of viable) {
                     queueEdge({
-                        sourceId: consumerClassId,
+                        sourceId: edgeSourceId,
                         targetId,
                         confidence,
-                        reason: candidate.reason + suffix,
+                        reason: candidate.reason + selectionSuffix,
                     });
                 }
                 continue;
             }
             if (viable.length === 1) {
-                const suffix = namedSelection === undefined ? '' : `; ${namedSelection.reason}`;
                 queueEdge({
-                    sourceId: consumerClassId,
+                    sourceId: edgeSourceId,
                     targetId: viable[0],
-                    confidence: namedSelection === undefined ? 0.9 : 0.95,
-                    reason: candidate.reason + suffix,
+                    confidence: usedNamedSelection ? 0.95 : namedSelection === undefined ? 0.9 : 0.85,
+                    reason: candidate.reason + selectionSuffix,
                 });
                 continue;
             }
@@ -177,27 +292,27 @@ export const diPhase = {
                 const reason = providers.get(id)?.preferenceReason;
                 return reason === undefined ? [] : [{ id, reason }];
             });
-            if (namedSelection === undefined && preferred.length === 1) {
+            if (!usedNamedSelection && preferred.length === 1) {
                 const selected = preferred[0];
                 queueEdge({
-                    sourceId: consumerClassId,
+                    sourceId: edgeSourceId,
                     targetId: selected.id,
                     confidence: 0.95,
-                    reason: `${candidate.reason}; ${selected.reason}`,
+                    reason: `${candidate.reason}${selectionSuffix}; ${selected.reason}`,
                 });
                 continue;
             }
             ambiguousInjections++;
             const candidateNames = viable
-                .map((id) => classNodes.get(id)?.properties.name ?? id)
+                .map((id) => providerNodes.get(id)?.properties.name ?? id)
                 .sort()
                 .join(', ');
             for (const targetId of viable) {
                 queueEdge({
-                    sourceId: consumerClassId,
+                    sourceId: edgeSourceId,
                     targetId,
                     confidence: 0.5,
-                    reason: `${candidate.reason}; ambiguous candidates: ${candidateNames}`,
+                    reason: `${candidate.reason}${selectionSuffix}; ambiguous candidates: ${candidateNames}`,
                 });
             }
         }