gitnexus 1.6.11-rc.2 → 1.6.11-rc.21

package/dist/core/ingestion/languages/kotlin/lombok-synthesizer.js

@@ -0,0 +1,417 @@
+import { booleanIsPrefixBase, jvmGetterName, jvmSetterName } from '../jvm/beanspec.js';
+import { createExistingMethodIndex, createJvmAccessorSynthesis, hasExistingMethod, jvmTypeSimpleName, rememberExistingMethod, } from '../jvm/accessor-synthesis.js';
+const KOTLIN_TYPE_DECLS = new Set(['class_declaration', 'object_declaration', 'companion_object']);
+function capitalizeAscii(name) {
+    const first = name.charAt(0);
+    return first >= 'a' && first <= 'z'
+        ? String.fromCharCode(first.charCodeAt(0) - 32) + name.slice(1)
+        : name;
+}
+export function kotlinGetterName(propertyName) {
+    return jvmGetterName(propertyName, booleanIsPrefixBase(propertyName, true) !== null, capitalizeAscii);
+}
+export function kotlinSetterName(propertyName) {
+    return jvmSetterName(propertyName, true, capitalizeAscii);
+}
+function collectKotlinImports(root) {
+    const byLocalName = new Map();
+    const shadowedSimpleNames = new Set();
+    for (const child of root.children) {
+        if (child.type !== 'class_declaration')
+            continue;
+        const name = jvmTypeSimpleName(child);
+        if (name)
+            shadowedSimpleNames.add(name);
+    }
+    const importList = root.children.find((child) => child.type === 'import_list');
+    for (const child of importList?.children ?? []) {
+        if (child.type !== 'import_header')
+            continue;
+        const text = child.text
+            .replace(/^import\s+/, '')
+            .replace(/\/\*[\s\S]*?\*\//g, '')
+            .trim();
+        const [pathText, aliasText] = text.split(/\s+as\s+/, 2);
+        const importPath = pathText?.replace(/\s+/g, '');
+        if (!importPath || importPath.endsWith('.*'))
+            continue;
+        const localName = aliasText?.trim() || importPath.split('.').pop();
+        if (localName)
+            byLocalName.set(localName, importPath);
+    }
+    return { byLocalName, shadowedSimpleNames };
+}
+function annotationUserTypeText(annotation) {
+    const constructor = annotation.namedChildren.find((c) => c.type === 'constructor_invocation');
+    const userType = constructor?.namedChildren.find((c) => c.type === 'user_type') ??
+        annotation.namedChildren.find((c) => c.type === 'user_type');
+    return userType?.text ?? '';
+}
+function isKotlinJvmAnnotation(annotation, name, imports) {
+    const typeText = annotationUserTypeText(annotation);
+    const canonical = `kotlin.jvm.${name}`;
+    if (typeText.includes('.'))
+        return typeText === canonical;
+    const imported = imports.byLocalName.get(typeText);
+    if (imported !== undefined)
+        return imported === canonical;
+    if (imports.shadowedSimpleNames.has(typeText))
+        return false;
+    return typeText === name;
+}
+function kotlinVisibility(modifiers) {
+    if (!modifiers)
+        return 'public';
+    for (const child of modifiers.namedChildren) {
+        if (child.type !== 'visibility_modifier')
+            continue;
+        if (child.text === 'private')
+            return 'private';
+        if (child.text === 'protected')
+            return 'protected';
+        if (child.text === 'internal')
+            return 'package';
+    }
+    return 'public';
+}
+function hasJvmField(node, imports) {
+    const mods = node.children.find((c) => c.type === 'modifiers');
+    return (mods?.namedChildren.some((child) => child.type === 'annotation' && isKotlinJvmAnnotation(child, 'JvmField', imports)) === true);
+}
+function hasConst(node) {
+    const mods = node.children.find((c) => c.type === 'modifiers');
+    if (mods?.namedChildren.some((child) => child.type === 'property_modifier' && child.text === 'const')) {
+        return true;
+    }
+    return node.namedChildren.some((child) => child.type === 'const');
+}
+function isVarBinding(node) {
+    const kind = node.children.find((c) => c.type === 'binding_pattern_kind');
+    const text = kind?.text;
+    if (text === 'var')
+        return true;
+    if (text === 'val')
+        return false;
+    return null;
+}
+function inferredInitializerType(node) {
+    switch (node.type) {
+        case 'string_literal':
+        case 'line_string_literal':
+        case 'multi_line_string_literal':
+            return 'String';
+        case 'character_literal':
+            return 'Char';
+        case 'boolean_literal':
+        case 'true':
+        case 'false':
+            return 'Boolean';
+        case 'long_literal':
+            return 'Long';
+        case 'unsigned_literal':
+            return /l$/i.test(node.text) ? 'ULong' : 'UInt';
+        case 'integer_literal':
+        case 'decimal_integer_literal':
+        case 'hex_integer_literal':
+        case 'octal_integer_literal':
+        case 'binary_integer_literal':
+            return 'Int';
+        case 'real_literal':
+        case 'decimal_floating_point_literal':
+            return /f$/i.test(node.text) ? 'Float' : 'Double';
+        case 'prefix_expression': {
+            const operand = node.namedChildren.at(-1);
+            return operand ? inferredInitializerType(operand) : undefined;
+        }
+        case 'call_expression': {
+            const callee = node.namedChildren.find((child) => child.type === 'simple_identifier');
+            if (!callee)
+                return undefined;
+            const first = callee.text.charAt(0);
+            return first !== '' && first === first.toUpperCase() ? callee.text : undefined;
+        }
+        default:
+            return undefined;
+    }
+}
+function propertyTypeText(node) {
+    const declarator = node.type === 'class_parameter'
+        ? node
+        : (node.children.find((c) => c.type === 'variable_declaration') ?? node);
+    const colon = declarator.children.find((c) => c.type === ':');
+    let typeNode = colon?.nextNamedSibling ?? null;
+    while (typeNode?.type === 'type_modifiers')
+        typeNode = typeNode.nextNamedSibling;
+    if (typeNode)
+        return typeNode.text;
+    const initializer = node.namedChildren.find((child) => child.id !== declarator.id &&
+        child.type !== 'binding_pattern_kind' &&
+        child.type !== 'modifiers');
+    return initializer ? (inferredInitializerType(initializer) ?? 'unknown') : 'unknown';
+}
+function propertyNameNode(node) {
+    if (node.type === 'class_parameter') {
+        return node.children.find((c) => c.type === 'simple_identifier') ?? null;
+    }
+    const decl = node.children.find((c) => c.type === 'variable_declaration');
+    if (decl) {
+        return decl.children.find((c) => c.type === 'simple_identifier') ?? null;
+    }
+    return node.children.find((c) => c.type === 'simple_identifier') ?? null;
+}
+function accessorMetadata(prop, propertyVisibility, imports) {
+    let getter = propertyVisibility;
+    let setter = propertyVisibility;
+    let skipGetter = false;
+    let skipSetter = false;
+    const propertyModifiers = prop.children.find((c) => c.type === 'modifiers');
+    for (const annotation of propertyModifiers?.namedChildren ?? []) {
+        if (annotation.type !== 'annotation' ||
+            !isKotlinJvmAnnotation(annotation, 'JvmName', imports)) {
+            continue;
+        }
+        const target = annotation.children.find((c) => c.type === 'use_site_target')?.text;
+        if (target === 'get:')
+            skipGetter = true;
+        if (target === 'set:')
+            skipSetter = true;
+    }
+    const apply = (node) => {
+        const modifiers = node.children.find((c) => c.type === 'modifiers');
+        if (!modifiers)
+            return;
+        if (node.type === 'getter')
+            getter = kotlinVisibility(modifiers);
+        if (node.type === 'setter')
+            setter = kotlinVisibility(modifiers);
+        if (modifiers.namedChildren.some((annotation) => isKotlinJvmAnnotation(annotation, 'JvmName', imports))) {
+            if (node.type === 'getter')
+                skipGetter = true;
+            if (node.type === 'setter')
+                skipSetter = true;
+        }
+    };
+    for (const child of prop.children) {
+        if (child.type === 'getter' || child.type === 'setter')
+            apply(child);
+    }
+    let sib = prop.nextNamedSibling;
+    while (sib && (sib.type === 'getter' || sib.type === 'setter')) {
+        apply(sib);
+        sib = sib.nextNamedSibling;
+    }
+    return {
+        getterVisibility: getter,
+        setterVisibility: setter,
+        skipGetter,
+        skipSetter,
+    };
+}
+function hasKotlinAccessorBody(prop, kind) {
+    const hasBody = (node) => node.type === kind && node.children.some((child) => child.type === 'function_body');
+    if (prop.children.some(hasBody))
+        return true;
+    let sib = prop.nextNamedSibling;
+    while (sib && (sib.type === 'getter' || sib.type === 'setter')) {
+        if (hasBody(sib))
+            return true;
+        sib = sib.nextNamedSibling;
+    }
+    return false;
+}
+function functionName(node) {
+    return node.children.find((c) => c.type === 'simple_identifier')?.text;
+}
+function functionArity(node) {
+    const params = node.children.find((c) => c.type === 'function_value_parameters');
+    let arity = node.childForFieldName('receiver') !== null ||
+        node.namedChildren.some((child) => child.type === 'receiver_type')
+        ? 1
+        : 0;
+    const modifiers = node.children.find((child) => child.type === 'modifiers');
+    if (modifiers?.namedChildren.some((child) => child.type === 'function_modifier' && child.text === 'suspend')) {
+        arity += 1;
+    }
+    for (const child of params?.namedChildren ?? []) {
+        if (child.type === 'parameter' || child.type === 'parameter_with_optional_type')
+            arity += 1;
+    }
+    return arity;
+}
+function collectExistingMethods(...bodies) {
+    const index = createExistingMethodIndex('exact');
+    for (const body of bodies) {
+        if (!body)
+            continue;
+        for (const child of body.children) {
+            if (child.type !== 'function_declaration')
+                continue;
+            const name = functionName(child);
+            if (!name)
+                continue;
+            rememberExistingMethod(index, name, functionArity(child));
+        }
+    }
+    return index;
+}
+function toKtProperty(child, imports) {
+    const isVar = isVarBinding(child);
+    if (isVar === null)
+        return null;
+    if (hasJvmField(child, imports) || hasConst(child))
+        return null;
+    const nameNode = propertyNameNode(child);
+    if (!nameNode)
+        return null;
+    const mods = child.children.find((c) => c.type === 'modifiers');
+    const visibility = kotlinVisibility(mods);
+    const accessor = accessorMetadata(child, visibility, imports);
+    return {
+        name: nameNode.text,
+        type: propertyTypeText(child),
+        isVar,
+        skipGetter: accessor.skipGetter,
+        skipSetter: accessor.skipSetter,
+        getterVisibility: accessor.getterVisibility,
+        setterVisibility: accessor.setterVisibility,
+        startLine: child.startPosition.row + 1,
+        endLine: child.endPosition.row + 1,
+        propertyNode: child,
+        declaratorNode: nameNode,
+    };
+}
+function collectTypedProperties(parent, type, imports) {
+    if (!parent)
+        return [];
+    const out = [];
+    for (const child of parent.namedChildren) {
+        if (child.type !== type)
+            continue;
+        const prop = toKtProperty(child, imports);
+        if (prop)
+            out.push(prop);
+    }
+    return out;
+}
+function findKtClasses(root, imports) {
+    const classes = [];
+    const graphOwnerNode = (node) => {
+        if (node.type !== 'companion_object')
+            return node;
+        if (jvmTypeSimpleName(node))
+            return node;
+        let current = node.parent;
+        while (current && !KOTLIN_TYPE_DECLS.has(current.type))
+            current = current.parent;
+        return current ?? node;
+    };
+    const walk = (node) => {
+        if (KOTLIN_TYPE_DECLS.has(node.type)) {
+            const ownerNode = graphOwnerNode(node);
+            const name = jvmTypeSimpleName(ownerNode) ?? '';
+            const ctor = node.children.find((c) => c.type === 'primary_constructor') ?? null;
+            const body = node.children.find((c) => c.type === 'class_body') ?? null;
+            if (name) {
+                const properties = [
+                    ...collectTypedProperties(ctor, 'class_parameter', imports),
+                    ...collectTypedProperties(body, 'property_declaration', imports),
+                ];
+                if (properties.length > 0) {
+                    const ownerBody = ownerNode.id === node.id
+                        ? null
+                        : (ownerNode.children.find((child) => child.type === 'class_body') ?? null);
+                    classes.push({
+                        node: ownerNode,
+                        name,
+                        isStatic: node.type === 'companion_object',
+                        isInterface: node.children.some((child) => child.type === 'interface'),
+                        wasHoisted: ownerNode.id !== node.id,
+                        properties,
+                        existingMethods: collectExistingMethods(body, ownerBody),
+                    });
+                }
+            }
+            if (body) {
+                for (const child of body.namedChildren) {
+                    if (KOTLIN_TYPE_DECLS.has(child.type))
+                        walk(child);
+                }
+            }
+            return;
+        }
+        for (const child of node.namedChildren)
+            walk(child);
+    };
+    walk(root);
+    return classes;
+}
+function planAccessors(cls) {
+    const planned = [];
+    for (const prop of cls.properties) {
+        const gName = kotlinGetterName(prop.name);
+        if (!prop.skipGetter && !hasExistingMethod(cls.existingMethods, gName, 0)) {
+            planned.push({
+                kind: 'getter',
+                name: gName,
+                returnType: prop.type,
+                parameterTypes: [],
+                visibility: prop.getterVisibility,
+                isStatic: cls.isStatic,
+                isAbstract: cls.isInterface && !hasKotlinAccessorBody(prop.propertyNode, 'getter'),
+                startLine: prop.startLine,
+                endLine: prop.endLine,
+                declaratorNode: prop.declaratorNode,
+            });
+        }
+        if (prop.isVar && !prop.skipSetter) {
+            const sName = kotlinSetterName(prop.name);
+            if (!hasExistingMethod(cls.existingMethods, sName, 1)) {
+                planned.push({
+                    kind: 'setter',
+                    name: sName,
+                    returnType: 'void',
+                    parameterTypes: [prop.type],
+                    visibility: prop.setterVisibility,
+                    isStatic: cls.isStatic,
+                    isAbstract: cls.isInterface && !hasKotlinAccessorBody(prop.propertyNode, 'setter'),
+                    startLine: prop.startLine,
+                    endLine: prop.endLine,
+                    declaratorNode: prop.declaratorNode,
+                });
+            }
+        }
+    }
+    return planned;
+}
+function planKotlinAccessorOwners(rootNode) {
+    const owners = [];
+    const imports = collectKotlinImports(rootNode);
+    for (const cls of findKtClasses(rootNode, imports)) {
+        const accessors = planAccessors(cls);
+        const existingIndex = cls.wasHoisted
+            ? owners.findIndex((owner) => owner.node.id === cls.node.id)
+            : -1;
+        const existing = existingIndex >= 0 ? owners[existingIndex] : undefined;
+        if (existing) {
+            owners[existingIndex] = {
+                ...existing,
+                accessors: [...existing.accessors, ...accessors],
+            };
+        }
+        else {
+            owners.push({ node: cls.node, name: cls.name, accessors });
+        }
+    }
+    return owners;
+}
+const lombokAccessorSynthesis = createJvmAccessorSynthesis({
+    language: 'kotlin',
+    synthetic: 'kotlin-jvm',
+    planOwners: planKotlinAccessorOwners,
+});
+export function synthesizeLombokAccessors(tree, filePath, classOwnersById) {
+    return lombokAccessorSynthesis.synthesize(tree, filePath, classOwnersById);
+}
+export function synthesizeLombokAccessorCaptures(rootNode) {
+    return lombokAccessorSynthesis.captures(rootNode);
+}

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

@@ -15,6 +15,7 @@ import { clearKotlinPackageFacts } from './package-facts.js';
 import { attachKotlinSpringDiMetadata } from './spring-di.js';
 import { attachKotlinSpringConditionalMetadata } from './spring-conditionals.js';
 import { attachKotlinSpringNonHttpHandlerMetadata } from './spring-non-http-handlers.js';
+import { attachKotlinSpringDynamicLookup } from './spring-dynamic-lookup.js';
 /**
  * Kotlin scope resolver for RFC #909 Ring 3.
  *
@@ -121,6 +122,7 @@ export const kotlinScopeResolver = {
         attachKotlinSpringConditionalMetadata(graph, parsedFiles, nodeLookup, indexes);
         attachKotlinSpringDiMetadata(graph, parsedFiles, nodeLookup, indexes);
         attachKotlinSpringNonHttpHandlerMetadata(graph, parsedFiles, nodeLookup, indexes);
+        attachKotlinSpringDynamicLookup(graph, parsedFiles, nodeLookup, indexes);
     },
 };
 /**

package/dist/core/ingestion/languages/kotlin/spring-dynamic-lookup.d.ts

@@ -0,0 +1,8 @@
+import { type SpringDynamicLookupFact } from '../../frameworks/spring/dynamic-lookups.js';
+import { type SyntaxNode } from '../../utils/ast-helpers.js';
+/** Capture real Kotlin calls using `Type::class` or `Type::class.java`. */
+export declare function captureKotlinSpringDynamicLookupFact(node: SyntaxNode, filePath: string): SpringDynamicLookupFact | null;
+/** Standalone extractor for focused tests; production reuses scope-query call nodes. */
+export declare function captureKotlinSpringDynamicLookupFacts(rootNode: SyntaxNode, filePath: string): SpringDynamicLookupFact[];
+/** Attach Kotlin lookup facts for later resolution by the shared DI phase. */
+export declare const attachKotlinSpringDynamicLookup: (graph: import("../../../graph/types.js").KnowledgeGraph, parsedFiles: readonly import('../../../../_shared/index.js').ParsedFile[], nodeLookup: import("../../scope-resolution/graph-bridge/node-lookup.js").GraphNodeLookup, indexes: import("../../model/scope-resolution-indexes.js").ScopeResolutionIndexes) => void;

package/dist/core/ingestion/languages/kotlin/spring-dynamic-lookup.js

@@ -0,0 +1,77 @@
+import { makeScopeId } from '../../../../_shared/index.js';
+import { createSpringDynamicLookupMetadataAttacher, springDynamicLookupCardinality, } from '../../frameworks/spring/dynamic-lookups.js';
+import { findAncestorBeforeBoundary, nodeToCapture, } from '../../utils/ast-helpers.js';
+import { getKotlinSpringDynamicLookupFacts } from './capture-side-channel.js';
+// Kotlin emits graph callables for functions and secondary constructors.
+// `init {}` / primary-constructor bodies have no independent callable node, so
+// attributing their lookups to the enclosing Class would violate graph semantics.
+const CALLABLE_NODE_TYPES = new Set(['function_declaration', 'secondary_constructor']);
+const NO_CALLABLE_BOUNDARIES = new Set();
+const KOTLIN_CLASS_LITERAL = /^([A-Za-z_$][A-Za-z0-9_$]*(?:\.[A-Za-z_$][A-Za-z0-9_$]*)*)::class(?:\.java)?$/;
+function navigationParts(node) {
+    if (node.type !== 'navigation_expression')
+        return null;
+    const text = node.text.trim();
+    const separator = text.lastIndexOf('.');
+    if (separator <= 0 || separator === text.length - 1)
+        return null;
+    return {
+        receiverName: text.slice(0, separator),
+        methodName: text.slice(separator + 1),
+    };
+}
+function singleClassLiteralArgument(node) {
+    const suffix = node.namedChildren.find((child) => child.type === 'call_suffix');
+    const argumentsNode = suffix?.namedChildren.find((child) => child.type === 'value_arguments');
+    if (argumentsNode === undefined)
+        return null;
+    const argumentsWithoutComments = argumentsNode.namedChildren.filter((child) => child.type !== 'line_comment' && child.type !== 'multiline_comment');
+    if (argumentsWithoutComments.length !== 1)
+        return null;
+    const value = argumentsWithoutComments[0];
+    if (value?.type !== 'value_argument' || value.namedChildCount !== 1)
+        return null;
+    return value.namedChild(0)?.text.trim().match(KOTLIN_CLASS_LITERAL)?.[1] ?? null;
+}
+/** Capture real Kotlin calls using `Type::class` or `Type::class.java`. */
+export function captureKotlinSpringDynamicLookupFact(node, filePath) {
+    if (node.type !== 'call_expression')
+        return null;
+    const callee = node.namedChildren.find((child) => child.type === 'navigation_expression');
+    if (callee === undefined)
+        return null;
+    const parts = navigationParts(callee);
+    if (parts === null)
+        return null;
+    if (springDynamicLookupCardinality(parts.receiverName, parts.methodName) === null)
+        return null;
+    const targetTypeName = singleClassLiteralArgument(node);
+    if (targetTypeName === null)
+        return null;
+    const owner = findAncestorBeforeBoundary(node, CALLABLE_NODE_TYPES, NO_CALLABLE_BOUNDARIES);
+    if (owner === null)
+        return null;
+    const ownerCapture = nodeToCapture('@spring-dynamic-lookup.owner', owner);
+    return {
+        ownerScopeId: makeScopeId({
+            filePath,
+            range: ownerCapture.range,
+            kind: 'Function',
+        }),
+        ownerRange: ownerCapture.range,
+        receiverName: parts.receiverName,
+        methodName: parts.methodName,
+        targetTypeName,
+    };
+}
+/** Standalone extractor for focused tests; production reuses scope-query call nodes. */
+export function captureKotlinSpringDynamicLookupFacts(rootNode, filePath) {
+    return rootNode
+        .descendantsOfType('call_expression')
+        .map((node) => captureKotlinSpringDynamicLookupFact(node, filePath))
+        .filter((fact) => fact !== null);
+}
+/** Attach Kotlin lookup facts for later resolution by the shared DI phase. */
+export const attachKotlinSpringDynamicLookup = createSpringDynamicLookupMetadataAttacher({
+    getFacts: getKotlinSpringDynamicLookupFacts,
+});

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

@@ -28,6 +28,7 @@ import { kotlinMethodConfig } from '../method-extractors/configs/jvm.js';
 import { createVariableExtractor } from '../variable-extractors/generic.js';
 import { kotlinVariableConfig } from '../variable-extractors/configs/jvm.js';
 import { collectKotlinCaptureSideChannel, emitKotlinScopeCaptures, interpretKotlinImport, interpretKotlinTypeBinding, kotlinArityCompatibility, kotlinBindingScopeFor, kotlinImportOwningScope, kotlinMergeBindings, kotlinReceiverBinding, } from './kotlin/index.js';
+import { synthesizeLombokAccessors } from './kotlin/lombok-synthesizer.js';
 /** Check if a Kotlin function_declaration capture is inside a class_body (i.e., a method).
  *  Kotlin grammar uses function_declaration for both top-level functions and class methods.
  *  Returns true when the captured definition node has a class_body ancestor. */
@@ -183,4 +184,5 @@ export const kotlinProvider = defineLanguage({
     mergeBindings: (_scope, bindings) => kotlinMergeBindings(bindings),
     receiverBinding: kotlinReceiverBinding,
     arityCompatibility: kotlinArityCompatibility,
+    synthesizeStructureMembers: synthesizeLombokAccessors,
 });

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/parse-impl.d.ts

@@ -2,7 +2,7 @@
  * Parse implementation — chunked parse + resolve loop.
  *
  * This is the core parsing engine of the ingestion pipeline. It reads
- * source files in byte-budget chunks (~20MB each), parses via the worker
+ * source files in stable hash-bucket packs (~2MB each by default), parses via the worker
  * pool (the sole parse path — there is no sequential fallback), and emits
  * route CALLS edges. Import,
  * call, and inheritance resolution are owned by the scope-resolution
@@ -94,6 +94,8 @@ export declare function runChunkedParseAndResolve(graph: KnowledgeGraph, scanned
      *  files. There is no sequential parser — the pool is the sole parse path
      *  whenever a chunk misses the cache. */
     usedWorkerPool: boolean;
+    /** Files dispatched to parser workers after parse-cache lookup. */
+    reparsedFileCount: number;
     /** Worker-produced ParsedFile artifacts aggregated across chunks.
      *  Threaded into scope-resolution as a re-extract cache so the warm-
      *  cache analyze run can skip the dominant `extractParsedFile` cost