gitnexus 1.6.2-rc.9 → 1.6.2

package/dist/core/ingestion/call-processor.js

@@ -1,4 +1,25 @@
-import { CLASS_TYPES, CALL_TARGET_TYPES } from './model/symbol-table.js';
+import { CLASS_TYPES, CALL_TARGET_TYPES, lookupMethodByOwnerWithMRO } from './model/index.js';
+/**
+ * DAG stage 4 fallback: used when `selectDispatch` is absent or returns null.
+ * Preserves pre-DAG dispatch semantics:
+ *   - 'constructor'         → constructor branch
+ *   - 'free'                → free branch (admits Swift/Kotlin class-target fast path)
+ *   - 'member' or undefined → owner-scoped branch
+ *
+ * `undefined` callForm MUST route through owner-scoped (not free) so bare
+ * identifiers without a classified shape do NOT trigger `resolveFreeCall`'s
+ * class-target fast path. Without a `receiverTypeName`, the owner-scoped
+ * branch falls through to `resolveModuleAliasedCall` + `singleCandidate`,
+ * matching legacy behavior where non-callable symbols (Class, Interface)
+ * null-route instead of producing spurious Constructor edges.
+ */
+const defaultDispatchDecision = (callForm) => {
+    if (callForm === 'constructor')
+        return { primary: 'constructor' };
+    if (callForm === 'free')
+        return { primary: 'free' };
+    return { primary: 'owner-scoped' };
+};
 import Parser from 'tree-sitter';
 import { TIER_CONFIDENCE } from './model/resolution-context.js';
 import { isLanguageAvailable, loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
@@ -15,8 +36,6 @@ import { getTreeSitterBufferSize } from './constants.js';
 import { normalizeFetchURL, routeMatches } from './route-extractors/nextjs.js';
 import { extractTemplateComponents } from './vue-sfc-extractor.js';
 import { extractReturnTypeName, stripNullable } from './type-extractors/shared.js';
-import { extractParsedCallSite } from './call-sites/extract-language-call-site.js';
-import { lookupMethodByOwnerWithMRO } from './model/resolve.js';
 /**
  * Type labels treated as class-like **method-dispatch receivers** by the call
  * resolver — the set walked by the MRO / heritage path for member and static
@@ -611,23 +630,27 @@ importedRawReturnTypesMap, heritageMap, bindingAccumulator) => {
         // Extract heritage from query matches to build parentMap for buildTypeEnv.
         // Heritage-processor runs in PARALLEL, so graph edges don't exist when buildTypeEnv runs.
         const fileParentMap = new Map();
-        for (const match of matches) {
-            const captureMap = {};
-            match.captures.forEach((c) => (captureMap[c.name] = c.node));
-            if (captureMap['heritage.class'] && captureMap['heritage.extends']) {
-                const className = captureMap['heritage.class'].text;
-                const parentName = captureMap['heritage.extends'].text;
-                const extendsNode = captureMap['heritage.extends'];
-                const fieldDecl = extendsNode.parent;
-                if (fieldDecl?.type === 'field_declaration' && fieldDecl.childForFieldName('name'))
-                    continue;
-                let parents = fileParentMap.get(className);
-                if (!parents) {
-                    parents = [];
-                    fileParentMap.set(className, parents);
+        if (provider.heritageExtractor) {
+            for (const match of matches) {
+                const captureMap = {};
+                match.captures.forEach((c) => (captureMap[c.name] = c.node));
+                if (captureMap['heritage.class']) {
+                    const heritageItems = provider.heritageExtractor.extract(captureMap, {
+                        filePath: file.path,
+                        language,
+                    });
+                    for (const item of heritageItems) {
+                        if (item.kind === 'extends') {
+                            let parents = fileParentMap.get(item.className);
+                            if (!parents) {
+                                parents = [];
+                                fileParentMap.set(item.className, parents);
+                            }
+                            if (!parents.includes(item.parentName))
+                                parents.push(item.parentName);
+                        }
+                    }
                 }
-                if (!parents.includes(parentName))
-                    parents.push(parentName);
             }
         }
         const parentMap = fileParentMap;
@@ -733,73 +756,84 @@ importedRawReturnTypesMap, heritageMap, bindingAccumulator) => {
             if (!captureMap['call'])
                 return;
             const callNode = captureMap['call'];
-            const languageSeed = extractParsedCallSite(language, callNode);
-            if (languageSeed) {
-                if (provider.isBuiltInName(languageSeed.calledName))
-                    return;
-                const sourceId = findEnclosingFunction(callNode, file.path, ctx, provider) ||
-                    generateId('File', file.path);
-                const receiverName = languageSeed.callForm === 'member' ? languageSeed.receiverName : undefined;
-                let receiverTypeName = receiverName && typeEnv ? typeEnv.lookup(receiverName, callNode) : undefined;
-                if (receiverName !== undefined &&
-                    receiverTypeName === undefined &&
-                    languageSeed.callForm === 'member' &&
-                    (language === 'java' || language === 'csharp' || language === 'kotlin')) {
-                    const c0 = receiverName.charCodeAt(0);
-                    if (c0 >= 65 && c0 <= 90)
-                        receiverTypeName = receiverName;
-                }
-                const resolved = resolveCallTarget({
-                    calledName: languageSeed.calledName,
-                    callForm: languageSeed.callForm,
-                    ...(receiverTypeName !== undefined ? { receiverTypeName } : {}),
-                    ...(receiverName !== undefined ? { receiverName } : {}),
-                }, file.path, ctx, undefined, widenCache, undefined, heritageMap);
-                if (!resolved)
-                    return;
-                graph.addRelationship({
-                    id: generateId('CALLS', `${sourceId}:${languageSeed.calledName}->${resolved.nodeId}`),
-                    sourceId,
-                    targetId: resolved.nodeId,
-                    type: 'CALLS',
-                    confidence: resolved.confidence,
-                    reason: resolved.reason,
-                });
-                if (heritageMap && languageSeed.callForm === 'member' && receiverTypeName) {
-                    const implTargets = findInterfaceDispatchTargets(languageSeed.calledName, receiverTypeName, file.path, ctx, heritageMap, resolved.nodeId);
-                    for (const impl of implTargets) {
-                        graph.addRelationship({
-                            id: generateId('CALLS', `${sourceId}:${languageSeed.calledName}->${impl.nodeId}`),
-                            sourceId,
-                            targetId: impl.nodeId,
-                            type: 'CALLS',
-                            confidence: impl.confidence,
-                            reason: impl.reason,
-                        });
+            const callExtractor = provider.callExtractor;
+            // ── Language-specific call site (e.g. Java :: method references) ──
+            if (callExtractor) {
+                const langCallSite = callExtractor.extract(callNode, undefined);
+                if (langCallSite) {
+                    if (provider.isBuiltInName(langCallSite.calledName))
+                        return;
+                    const sourceId = findEnclosingFunction(callNode, file.path, ctx, provider) ||
+                        generateId('File', file.path);
+                    const receiverName = langCallSite.callForm === 'member' ? langCallSite.receiverName : undefined;
+                    let receiverTypeName = receiverName && typeEnv ? typeEnv.lookup(receiverName, callNode) : undefined;
+                    if (langCallSite.typeAsReceiverHeuristic &&
+                        receiverName !== undefined &&
+                        receiverTypeName === undefined &&
+                        langCallSite.callForm === 'member') {
+                        const c0 = receiverName.charCodeAt(0);
+                        if (c0 >= 65 && c0 <= 90)
+                            receiverTypeName = receiverName;
+                    }
+                    const resolved = resolveCallTarget({
+                        calledName: langCallSite.calledName,
+                        callForm: langCallSite.callForm,
+                        ...(receiverTypeName !== undefined ? { receiverTypeName } : {}),
+                        ...(receiverName !== undefined ? { receiverName } : {}),
+                    }, file.path, ctx, undefined, widenCache, undefined, heritageMap);
+                    if (!resolved)
+                        return;
+                    graph.addRelationship({
+                        id: generateId('CALLS', `${sourceId}:${langCallSite.calledName}->${resolved.nodeId}`),
+                        sourceId,
+                        targetId: resolved.nodeId,
+                        type: 'CALLS',
+                        confidence: resolved.confidence,
+                        reason: resolved.reason,
+                    });
+                    if (heritageMap && langCallSite.callForm === 'member' && receiverTypeName) {
+                        const implTargets = findInterfaceDispatchTargets(langCallSite.calledName, receiverTypeName, file.path, ctx, heritageMap, resolved.nodeId);
+                        for (const impl of implTargets) {
+                            graph.addRelationship({
+                                id: generateId('CALLS', `${sourceId}:${langCallSite.calledName}->${impl.nodeId}`),
+                                sourceId,
+                                targetId: impl.nodeId,
+                                type: 'CALLS',
+                                confidence: impl.confidence,
+                                reason: impl.reason,
+                            });
+                        }
                     }
+                    return;
                 }
-                return;
             }
             const nameNode = captureMap['call.name'];
             if (!nameNode)
                 return;
             const calledName = nameNode.text;
+            // Check heritage extractor for call-based heritage (e.g., Ruby include/extend/prepend)
+            if (provider.heritageExtractor?.extractFromCall) {
+                const heritageItems = provider.heritageExtractor.extractFromCall(calledName, captureMap['call'], { filePath: file.path, language });
+                if (heritageItems !== null) {
+                    for (const item of heritageItems) {
+                        collectedHeritage.push({
+                            filePath: file.path,
+                            className: item.className,
+                            parentName: item.parentName,
+                            kind: item.kind,
+                        });
+                    }
+                    return;
+                }
+            }
+            // Dispatch: route language-specific calls (properties, imports)
+            // Heritage routing is handled by heritageExtractor.extractFromCall above.
             const routed = callRouter?.(calledName, captureMap['call']);
             if (routed) {
                 switch (routed.kind) {
                     case 'skip':
                     case 'import':
                         return;
-                    case 'heritage':
-                        for (const item of routed.items) {
-                            collectedHeritage.push({
-                                filePath: file.path,
-                                className: item.enclosingClass,
-                                parentName: item.mixinName,
-                                kind: item.heritageKind,
-                            });
-                        }
-                        return;
                     case 'properties': {
                         const fileId = generateId('File', file.path);
                         const propEnclosingClassId = findEnclosingClassId(captureMap['call'], file.path);
@@ -850,9 +884,16 @@ importedRawReturnTypesMap, heritageMap, bindingAccumulator) => {
             }
             if (provider.isBuiltInName(calledName))
                 return;
-            const callForm = inferCallForm(callNode, nameNode);
-            const receiverName = callForm === 'member' ? extractReceiverName(nameNode) : undefined;
+            // --- DAG stage 2-3: classify-form + infer-receiver (shared defaults) ---
+            // These stages run the shared inference chain. Language providers can
+            // customize infer-receiver (stage 3) via the inferImplicitReceiver hook
+            // which runs AFTER this default chain (typed-binding → constructor-map →
+            // module-alias → class-as-receiver → mixed-chain), and selectDispatch
+            // (stage 4) which picks the resolver branch.
+            let callForm = inferCallForm(callNode, nameNode);
+            let receiverName = callForm === 'member' ? extractReceiverName(nameNode) : undefined;
             let receiverTypeName = receiverName && typeEnv ? typeEnv.lookup(receiverName, callNode) : undefined;
+            let receiverSource = receiverTypeName ? 'typed-binding' : 'none';
             // Phase P: virtual dispatch override — when the declared type is a base class but
             // the constructor created a known subclass, prefer the more specific type.
             // Checks per-file parentMap first, then falls back to globalParentMap for
@@ -888,6 +929,7 @@ importedRawReturnTypesMap, heritageMap, bindingAccumulator) => {
                         (ctx.model.types.lookupClassByName(ctorType).length > 0 &&
                             ctx.model.types.lookupClassByName(receiverTypeName).length > 0)) {
                         receiverTypeName = ctorType;
+                        receiverSource = 'constructor-map';
                     }
                 }
             }
@@ -896,18 +938,25 @@ importedRawReturnTypesMap, heritageMap, bindingAccumulator) => {
                 const enclosingFunc = findEnclosingFunction(callNode, file.path, ctx, provider);
                 const funcName = enclosingFunc ? extractFuncNameFromSourceId(enclosingFunc) : '';
                 receiverTypeName = lookupReceiverType(receiverIndex, funcName, receiverName);
+                if (receiverTypeName)
+                    receiverSource = 'constructor-map';
             }
-            // Fall back to class-as-receiver for static method calls (e.g. UserService.find_user()).
-            // When the receiver name is not a variable in TypeEnv but resolves to a Class/Struct/Interface
-            // through the standard tiered resolution, use it directly as the receiver type.
+            // Fall back to class-as-receiver for static method calls (e.g. UserService.find_user(),
+            // Greetable.format()). When the receiver name is not a variable in TypeEnv but
+            // resolves to a class-like symbol (Class / Interface / Struct / Enum / Trait) via
+            // tiered resolution, use it directly as the receiver type. `Trait` is included so
+            // Ruby module class-method calls flow through the class-as-receiver path and reach
+            // the `selectDispatch` hook's singleton branch.
             if (!receiverTypeName && receiverName && callForm === 'member') {
                 const typeResolved = ctx.resolve(receiverName, file.path);
                 if (typeResolved &&
                     typeResolved.candidates.some((d) => d.type === 'Class' ||
                         d.type === 'Interface' ||
                         d.type === 'Struct' ||
-                        d.type === 'Enum')) {
+                        d.type === 'Enum' ||
+                        d.type === 'Trait')) {
                     receiverTypeName = receiverName;
+                    receiverSource = 'class-as-receiver';
                 }
             }
             // Hoist sourceId so it's available for ACCESSES edge emission during chain walk.
@@ -939,10 +988,48 @@ importedRawReturnTypesMap, heritageMap, bindingAccumulator) => {
                         }
                         if (currentType) {
                             receiverTypeName = walkMixedChain(extracted.chain, currentType, file.path, ctx, makeAccessEmitter(graph, sourceId), heritageMap);
+                            if (receiverTypeName)
+                                receiverSource = 'mixed-chain';
                         }
                     }
                 }
             }
+            // --- DAG stage 3: infer-receiver (provider hook) ---
+            // Synthesize implicit receivers for languages that omit them (e.g., Ruby bare-call).
+            // This hook runs AFTER the shared inference chain so explicit receivers /
+            // typed bindings always take precedence. Output (if non-null) overlays onto
+            // the ReceiverEnriched for the next stage.
+            let dispatchHint;
+            if (provider.inferImplicitReceiver) {
+                const override = provider.inferImplicitReceiver({
+                    calledName,
+                    callForm,
+                    receiverName,
+                    receiverTypeName,
+                    callNode,
+                    filePath: file.path,
+                });
+                if (override) {
+                    callForm = override.callForm;
+                    receiverName = override.receiverName;
+                    receiverTypeName = override.receiverTypeName;
+                    receiverSource = override.receiverSource;
+                    dispatchHint = override.hint;
+                }
+            }
+            // --- DAG stage 4: select-dispatch (provider hook + default fallback) ---
+            // Decide which resolver path to try first (primary) and fallback strategy.
+            // Language providers can customize dispatch via selectDispatch hook; all
+            // others use the shared defaultDispatchDecision. Always non-null after this
+            // block so downstream resolvers are table-driven.
+            const dispatchDecision = provider.selectDispatch?.({
+                calledName,
+                callForm,
+                receiverName,
+                receiverTypeName,
+                receiverSource,
+                hint: dispatchHint,
+            }) ?? defaultDispatchDecision(callForm);
             // Build overload hints for languages with inferLiteralType (Java/Kotlin/C#/C++).
             // Only used when multiple candidates survive arity filtering — ~1-3% of calls.
             const langConfig = provider.typeConfig;
@@ -955,7 +1042,7 @@ importedRawReturnTypesMap, heritageMap, bindingAccumulator) => {
                 callForm,
                 receiverTypeName,
                 receiverName,
-            }, file.path, ctx, hints, widenCache, undefined, heritageMap);
+            }, file.path, ctx, hints, widenCache, undefined, heritageMap, dispatchDecision);
             if (!resolved)
                 return;
             const relId = generateId('CALLS', `${sourceId}:${calledName}->${resolved.nodeId}`);
@@ -1357,26 +1444,45 @@ const singleCandidate = (tiered, argCount, callForm) => {
 };
 /** @internal Exported for unit tests. Do not use outside tests. */
 export const _resolveCallTargetForTesting = (call, currentFile, ctx, opts) => resolveCallTarget(call, currentFile, ctx, opts?.overloadHints, opts?.widenCache, opts?.preComputedArgTypes, opts?.heritageMap);
-const resolveCallTarget = (call, currentFile, ctx, overloadHints, widenCache, preComputedArgTypes, heritageMap) => {
+const resolveCallTarget = (call, currentFile, ctx, overloadHints, widenCache, preComputedArgTypes, heritageMap, dispatchDecision) => {
     const tiered = ctx.resolve(call.calledName, currentFile);
     if (!tiered)
         return null;
-    if (call.callForm === 'free') {
+    // DAG dispatch: use decision.primary to pick the resolver branch.
+    // Callers that own the DAG (processCalls + crossFile deferred paths)
+    // pass a decision; other callers use the shared default ladder.
+    // Language-specific primary / fallback / ancestryView overrides come from
+    // the provider's `selectDispatch` hook.
+    const decision = dispatchDecision ?? defaultDispatchDecision(call.callForm);
+    const primary = decision.primary;
+    if (primary === 'free') {
         return resolveFreeCall(call.calledName, currentFile, ctx, call.argCount, tiered, overloadHints, preComputedArgTypes);
     }
-    if (call.callForm === 'constructor') {
+    if (primary === 'constructor') {
         return (resolveStaticCall(call.calledName, currentFile, ctx, call.argCount, tiered, overloadHints, preComputedArgTypes) ?? singleCandidate(tiered, call.argCount, 'constructor'));
     }
+    // primary === 'owner-scoped'
     if (call.receiverTypeName) {
         // Skip the owner-scoped MRO path when the tiered pool has genuine
         // overload ambiguity that needs D1-D4+E handling, not D0.
         const skipMember = (!!overloadHints || !!preComputedArgTypes) &&
             countCallableCandidates(tiered.candidates, call.argCount, call.callForm) > 1;
         // Try owner-scoped (resolveMemberCall) then file-scoped (resolveMemberCallByFile).
+        // DAG: dispatchDecision.ancestryView selects instance vs singleton ancestry
+        // for kind-aware MRO strategies. Ruby `Account.log` flows via 'singleton'.
+        //
+        // Singleton-ancestry miss MUST NOT degrade to the file-scoped fallback:
+        // resolveMemberCallByFile matches by ownerId and would happily pick an
+        // instance method defined on the same class, leaking instance dispatch
+        // onto what was declared a class-method call. For singleton dispatch,
+        // a miss either null-routes or falls through to `decision.fallback`.
+        const singletonDispatch = decision.ancestryView === 'singleton';
         const memberResult = (!skipMember
-            ? resolveMemberCall(call.receiverTypeName, call.calledName, currentFile, ctx, heritageMap, call.argCount)
+            ? resolveMemberCall(call.receiverTypeName, call.calledName, currentFile, ctx, heritageMap, call.argCount, decision.ancestryView)
             : null) ??
-            resolveMemberCallByFile(call.calledName, call.receiverTypeName, currentFile, ctx, call.argCount, call.callForm, overloadHints, preComputedArgTypes);
+            (singletonDispatch
+                ? null
+                : resolveMemberCallByFile(call.calledName, call.receiverTypeName, currentFile, ctx, call.argCount, call.callForm, overloadHints, preComputedArgTypes));
         if (memberResult)
             return memberResult;
         // Module-alias narrowing runs as a FALLBACK, after owner/file-scoped
@@ -1409,7 +1515,19 @@ const resolveCallTarget = (call, currentFile, ctx, overloadHints, widenCache, pr
         // hierarchy. When the type is NOT in the index (PHP `mixed`, dynamic
         // types, unresolvable aliases), the scoped resolvers had nothing to
         // work with and singleCandidate is the correct last resort.
+        //
+        // DAG fallback override: when `select-dispatch` returned
+        // `fallback: 'free-arity-narrowed'` (today: Ruby implicit-self bare
+        // calls whose enclosing class doesn't define the method), fall through
+        // to free-call resolution instead of null-routing. This preserves
+        // existing free-call arity-narrowing heuristics for bare calls that
+        // happen to target methods on unrelated classes.
         if (typeResolves && typeResolves.candidates.length > 0) {
+            if (decision.fallback === 'free-arity-narrowed') {
+                const free = resolveFreeCall(call.calledName, currentFile, ctx, call.argCount, tiered, overloadHints, preComputedArgTypes);
+                if (free)
+                    return free;
+            }
             return null; // null-route: type resolved, no candidate matched
         }
         return singleCandidate(tiered, call.argCount, call.callForm);
@@ -1565,7 +1683,14 @@ const resolveFieldOwnership = (receiverName, fieldName, filePath, ctx) => {
  * Threaded out here so callers don't need a second `ctx.resolve(ownerType, ...)` call —
  * this decouples callers from `ctx.resolve`'s per-file caching contract.
  */
-const resolveMethodByOwner = (receiverTypeName, methodName, filePath, ctx, heritageMap, argCount) => {
+const resolveMethodByOwner = (receiverTypeName, methodName, filePath, ctx, heritageMap, argCount, 
+/**
+ * DAG-sourced ancestry selector. `'singleton'` routes through
+ * `heritageMap.getSingletonAncestry(owner)` for class-method dispatch
+ * (Ruby `Account.log` via `extend LoggerMixin`). Default / undefined
+ * uses the walker's instance-dispatch behavior.
+ */
+ancestryView) => {
     const typeResolved = ctx.resolve(receiverTypeName, filePath);
     if (!typeResolved)
         return undefined;
@@ -1593,8 +1718,15 @@ const resolveMethodByOwner = (receiverTypeName, methodName, filePath, ctx, herit
     for (const candidate of typeResolved.candidates) {
         if (!CLASS_LIKE_TYPES.has(candidate.type))
             continue;
+        // Singleton dispatch: when the DAG decision requested the singleton
+        // ancestry view, pass `heritageMap.getSingletonAncestry` as the walker's
+        // ancestry override. Kind-aware strategies (e.g. MroStrategy 'ruby-mixin')
+        // honor the override by scanning it linearly in place of their default walk.
+        const singletonOverride = ancestryView === 'singleton' && canWalkMRO && heritageMap
+            ? heritageMap.getSingletonAncestry(candidate.nodeId).map((e) => e.parentId)
+            : undefined;
         const def = canWalkMRO
-            ? lookupMethodByOwnerWithMRO(candidate.nodeId, methodName, heritageMap, ctx.model, mroStrategy, argCount)
+            ? lookupMethodByOwnerWithMRO(candidate.nodeId, methodName, heritageMap, ctx.model, mroStrategy, argCount, singletonOverride)
             : ctx.model.methods.lookupMethodByOwner(candidate.nodeId, methodName, argCount);
         if (!def)
             continue;
@@ -1641,8 +1773,8 @@ const resolveMethodByOwner = (receiverTypeName, methodName, filePath, ctx, herit
  * @param ctx         - Resolution context
  * @param heritageMap - Optional heritage map for MRO-aware ancestor walking
  */
-export const resolveMemberCall = (ownerType, methodName, currentFile, ctx, heritageMap, argCount) => {
-    const resolved = resolveMethodByOwner(ownerType, methodName, currentFile, ctx, heritageMap, argCount);
+export const resolveMemberCall = (ownerType, methodName, currentFile, ctx, heritageMap, argCount, ancestryView) => {
+    const resolved = resolveMethodByOwner(ownerType, methodName, currentFile, ctx, heritageMap, argCount, ancestryView);
     if (!resolved)
         return null;
     return toResolveResult(resolved.def, resolved.tier);

package/dist/core/ingestion/call-routing.d.ts

@@ -1,10 +1,14 @@
 /**
  * Shared Ruby call routing logic.
  *
- * Ruby expresses imports, heritage (mixins), and property definitions as
- * method calls rather than syntax-level constructs. This module provides a
- * routing function used by the CLI call-processor, CLI parse-worker, and
- * the web call-processor so that the classification logic lives in one place.
+ * Ruby expresses imports and property definitions as method calls rather
+ * than syntax-level constructs. This module provides a routing function
+ * used by the CLI call-processor, CLI parse-worker, and the web
+ * call-processor so that the classification logic lives in one place.
+ *
+ * Heritage (mixins: include/extend/prepend) was previously routed here
+ * but is now handled by heritageExtractor.extractFromCall before the
+ * call router runs.  The router still returns 'skip' for these calls.
  *
  * NOTE: This file is intentionally duplicated in gitnexus-web/ because the
  * two packages have separate build targets (Node native vs WASM/browser).
@@ -24,9 +28,6 @@ export type RubyCallRouting = {
     kind: 'import';
     importPath: string;
     isRelative: boolean;
-} | {
-    kind: 'heritage';
-    items: RubyHeritageItem[];
 } | {
     kind: 'properties';
     items: RubyPropertyItem[];
@@ -35,11 +36,6 @@ export type RubyCallRouting = {
 } | {
     kind: 'skip';
 };
-export interface RubyHeritageItem {
-    enclosingClass: string;
-    mixinName: string;
-    heritageKind: 'include' | 'extend' | 'prepend';
-}
 export type RubyAccessorType = 'attr_accessor' | 'attr_reader' | 'attr_writer';
 export interface RubyPropertyItem {
     propName: string;

package/dist/core/ingestion/call-routing.js

@@ -1,10 +1,14 @@
 /**
  * Shared Ruby call routing logic.
  *
- * Ruby expresses imports, heritage (mixins), and property definitions as
- * method calls rather than syntax-level constructs. This module provides a
- * routing function used by the CLI call-processor, CLI parse-worker, and
- * the web call-processor so that the classification logic lives in one place.
+ * Ruby expresses imports and property definitions as method calls rather
+ * than syntax-level constructs. This module provides a routing function
+ * used by the CLI call-processor, CLI parse-worker, and the web
+ * call-processor so that the classification logic lives in one place.
+ *
+ * Heritage (mixins: include/extend/prepend) was previously routed here
+ * but is now handled by heritageExtractor.extractFromCall before the
+ * call router runs.  The router still returns 'skip' for these calls.
  *
  * NOTE: This file is intentionally duplicated in gitnexus-web/ because the
  * two packages have separate build targets (Node native vs WASM/browser).
@@ -13,8 +17,6 @@
 // ── Pre-allocated singletons for common return values ────────────────────────
 const CALL_RESULT = { kind: 'call' };
 const SKIP_RESULT = { kind: 'skip' };
-/** Max depth for parent-walking loops to prevent pathological AST traversals */
-const MAX_PARENT_DEPTH = 50;
 // ── Routing function ────────────────────────────────────────────────────────
 /**
  * Classify a Ruby call node and extract its semantic payload.
@@ -42,35 +44,12 @@ export function routeRubyCall(calledName, callNode) {
         }
         return { kind: 'import', importPath, isRelative };
     }
-    // ── include / extend / prepend → heritage (mixin) ──────────────────────
+    // ── include / extend / prepend — heritage (now handled by heritageExtractor) ─
+    // Call-based heritage is intercepted by heritageExtractor.extractFromCall
+    // before the call router runs.  Return SKIP_RESULT so these calls don't
+    // fall through to normal call processing.
     if (calledName === 'include' || calledName === 'extend' || calledName === 'prepend') {
-        let enclosingClass = null;
-        let current = callNode.parent;
-        let depth = 0;
-        while (current && ++depth <= MAX_PARENT_DEPTH) {
-            if (current.type === 'class' || current.type === 'module') {
-                const nameNode = current.childForFieldName?.('name');
-                if (nameNode) {
-                    enclosingClass = nameNode.text;
-                    break;
-                }
-            }
-            current = current.parent;
-        }
-        if (!enclosingClass)
-            return SKIP_RESULT;
-        const items = [];
-        const argList = callNode.childForFieldName?.('arguments');
-        for (const arg of argList?.children ?? []) {
-            if (arg.type === 'constant' || arg.type === 'scope_resolution') {
-                items.push({
-                    enclosingClass,
-                    mixinName: arg.text,
-                    heritageKind: calledName,
-                });
-            }
-        }
-        return items.length > 0 ? { kind: 'heritage', items } : SKIP_RESULT;
+        return SKIP_RESULT;
     }
     // ── attr_accessor / attr_reader / attr_writer → property definitions ───
     if (calledName === 'attr_accessor' ||