gitnexus 1.6.2-rc.20 → 1.6.2-rc.22

package/dist/_shared/mro-strategy.d.ts

@@ -1,19 +1,41 @@
 /**
- * MRO (Method Resolution Order) strategy — shared between CLI and any
- * future consumer that reasons about multiple-inheritance semantics.
- *
- * Lives in `gitnexus-shared` so the low-level resolution module
- * (`core/ingestion/model/resolve.ts`) does not need to import from
- * `languages/` — keeping the `model/` layer free of language-registry
- * coupling.
- *
- * Strategy semantics:
- * - `first-wins`:       BFS ancestor walk, first match wins (default).
- * - `leftmost-base`:    BFS ancestor walk, leftmost base wins (C++).
- * - `c3`:               C3-linearized ancestor order, first match wins (Python).
- * - `implements-split`: BFS walk, first match wins (Java/C#/Kotlin) — full
- *                       interface-default ambiguity is handled at graph level.
- * - `qualified-syntax`: No auto-resolution (Rust — requires `<T as Trait>::m`).
+ * MRO (Method Resolution Order) strategy — shared canonical definition.
+ *
+ * Lives in `gitnexus-shared` so `model/resolve.ts` and `mro-processor.ts` share
+ * the type without importing the language registry (avoids circular coupling).
+ *
+ * `first-wins` (default, Java/C#/Kotlin/Go/Swift/Dart):
+ *   BFS ancestor walk in declaration order; first match wins.
+ *
+ * `leftmost-base` (C++):
+ *   BFS walk; HeritageMap preserves source insertion order, so BFS naturally
+ *   picks the leftmost base in diamond inheritance.
+ *
+ * `c3` (Python):
+ *   C3-linearization; falls back to BFS on cyclic/inconsistent hierarchy.
+ *   See model/resolve.ts § c3Linearize.
+ *
+ * `implements-split` (Java/C#/Kotlin):
+ *   Low-level lookup is BFS; graph-level mro-processor detects and warns on
+ *   interface-default method ambiguity.
+ *
+ * `qualified-syntax` (Rust):
+ *   No auto-resolution — `lookupMethodByOwnerWithMRO` returns undefined immediately.
+ *   Rust requires explicit `<Type as Trait>::method` syntax.
+ *
+ * `ruby-mixin` (Ruby):
+ *   Kind-aware walk that does NOT short-circuit on direct owner first (`prepend`
+ *   must beat the class's own method). Walk order:
+ *     1. Prepend providers (reverse declaration — last-prepended wins)
+ *     2. Direct owner's own methods
+ *     3. Include providers (reverse declaration)
+ *     4. Transitive ancestors (BFS fallback)
+ *   Singleton dispatch: caller passes `ancestryOverride` (extend providers only);
+ *   becomes a simple left-to-right scan. Miss NEVER falls through to file-scoped
+ *   lookup — null-routes or honors `fallback`.
+ *
+ * @see model/resolve.ts § lookupMethodByOwnerWithMRO
+ * @see languages/ruby.ts § selectDispatch
  */
-export type MroStrategy = 'first-wins' | 'c3' | 'leftmost-base' | 'implements-split' | 'qualified-syntax';
+export type MroStrategy = 'first-wins' | 'c3' | 'leftmost-base' | 'implements-split' | 'qualified-syntax' | 'ruby-mixin';
 //# sourceMappingURL=mro-strategy.d.ts.map

package/dist/_shared/mro-strategy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mro-strategy.d.ts","sourceRoot":"","sources":["../src/mro-strategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,WAAW,GACnB,YAAY,GACZ,IAAI,GACJ,eAAe,GACf,kBAAkB,GAClB,kBAAkB,CAAC"}
+{"version":3,"file":"mro-strategy.d.ts","sourceRoot":"","sources":["../src/mro-strategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,MAAM,WAAW,GACnB,YAAY,GACZ,IAAI,GACJ,eAAe,GACf,kBAAkB,GAClB,kBAAkB,GAClB,YAAY,CAAC"}

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

@@ -123,7 +123,7 @@ export declare const _resolveCallTargetForTesting: (call: Pick<ExtractedCall, "c
  * @param ctx         - Resolution context
  * @param heritageMap - Optional heritage map for MRO-aware ancestor walking
  */
-export declare const resolveMemberCall: (ownerType: string, methodName: string, currentFile: string, ctx: ResolutionContext, heritageMap?: HeritageMap, argCount?: number) => ResolveResult | null;
+export declare const resolveMemberCall: (ownerType: string, methodName: string, currentFile: string, ctx: ResolutionContext, heritageMap?: HeritageMap, argCount?: number, ancestryView?: "instance" | "singleton") => ResolveResult | null;
 /**
  * Resolve a free-function call using `lookupExact` (same-file) + import-scoped
  * resolution via `ctx.resolve()`.

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

@@ -1,4 +1,25 @@
 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';
@@ -609,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;
@@ -786,22 +811,29 @@ importedRawReturnTypesMap, heritageMap, bindingAccumulator) => {
             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);
@@ -852,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
@@ -890,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';
                     }
                 }
             }
@@ -898,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.
@@ -941,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;
@@ -957,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}`);
@@ -1359,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
@@ -1411,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);
@@ -1567,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;
@@ -1595,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;
@@ -1643,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' ||

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

@@ -58,3 +58,78 @@ export interface CallExtractionConfig {
      */
     typeAsReceiverHeuristic?: boolean;
 }
+/**
+ * DAG stage 3 output: call record with receiver type and source discriminant.
+ *
+ * `receiverTypeName` is resolved via TypeEnv → constructor-map → class-as-receiver →
+ * mixed-chain, or synthesized by `inferImplicitReceiver`. `receiverSource` tags
+ * which path won and drives MRO strategy selection in stage 4.
+ *
+ * Invariants:
+ * - `receiverSource` MUST match how `receiverTypeName` was resolved; every
+ *   discriminant must have a live reader and writer.
+ * - `hint` is opaque to shared stages; only the same provider's `selectDispatch` reads it.
+ *
+ * @see language-provider.ts § inferImplicitReceiver, selectDispatch
+ */
+export interface ReceiverEnriched {
+    readonly calledName: string;
+    readonly callForm: 'free' | 'member' | 'constructor' | undefined;
+    readonly receiverName: string | undefined;
+    readonly receiverTypeName: string | undefined;
+    readonly receiverSource: 'none' | 'typed-binding' | 'constructor-map' | 'class-as-receiver' | 'mixed-chain' | 'implicit-self';
+    /** Free-form hint from the provider hook; opaque to shared stages. */
+    readonly hint?: string;
+}
+/**
+ * Provider hook output for `LanguageProvider.inferImplicitReceiver` (DAG stage 3).
+ *
+ * Overlay applied to `ReceiverEnriched` when an implicit receiver is synthesized.
+ * Ruby example: bare `serialize` inside `Account#call_serialize` →
+ * `{ callForm: 'member', receiverName: 'self', receiverTypeName: 'Account',
+ *   receiverSource: 'implicit-self', hint: 'instance' }`
+ *
+ * Invariants:
+ * - `receiverSource` is always `'implicit-self'` — the only variant this type produces.
+ * - `callForm` is always `'member'` — the rewrite converts bare-call to method invocation.
+ * - `hint` is opaque to shared stages; consumed by the same language's `selectDispatch`.
+ */
+export interface ImplicitReceiverOverride {
+    readonly callForm: 'free' | 'member' | 'constructor';
+    readonly receiverName: string;
+    readonly receiverTypeName: string;
+    readonly receiverSource: Extract<ReceiverEnriched['receiverSource'], 'implicit-self'>;
+    /** Free-form language tag (e.g. Ruby sets 'singleton' for `def self.foo`
+     *  method bodies). Consumed by the same language's `selectDispatch` hook. */
+    readonly hint?: string;
+}
+/**
+ * DAG stage 4 output: dispatch strategy for resolving the target method.
+ *
+ * Encodes which resolver branch to try first and an optional fallback.
+ * Stage 5 delegates to `resolveMemberCall`, `resolveFreeCall`, or
+ * `resolveStaticCall` based on `primary`.
+ *
+ * - `primary`: `'owner-scoped'` = MRO walk, `'free'` = arity-tiered global lookup,
+ *   `'constructor'` = type instantiation.
+ * - `fallback`: Only `'free-arity-narrowed'` exists; used by Ruby implicit-self
+ *   to degrade to arity-tiered free lookup when the MRO walk misses.
+ * - `ancestryView`: Ruby `'ruby-mixin'` only. `'singleton'` walks extend providers
+ *   only; a miss NEVER falls through to file-scoped lookup (enforced in
+ *   resolveCallTarget). `'instance'` is the default.
+ *
+ * Common patterns:
+ *   - `{primary: 'constructor'}` — constructor call
+ *   - `{primary: 'owner-scoped'}` — member call with known type
+ *   - `{primary: 'owner-scoped', fallback: 'free-arity-narrowed', ancestryView: 'instance'}` — Ruby implicit-self
+ *   - `{primary: 'owner-scoped', ancestryView: 'singleton'}` — Ruby class-method call
+ *
+ * @see language-provider.ts § selectDispatch
+ * @see call-processor.ts § defaultDispatchDecision, resolveCallTarget
+ */
+export interface DispatchDecision {
+    readonly primary: 'owner-scoped' | 'free' | 'constructor';
+    readonly fallback?: 'free-arity-narrowed';
+    readonly ancestryView?: 'instance' | 'singleton';
+    readonly hint?: string;
+}

package/dist/core/ingestion/heritage-extractors/configs/go.d.ts

@@ -0,0 +1,13 @@
+import type { HeritageExtractionConfig } from '../../heritage-types.js';
+/**
+ * Go heritage extraction config.
+ *
+ * Go struct embedding: the tree-sitter query matches ALL field_declarations
+ * with type_identifier, but only anonymous fields (no name) are embedded.
+ * Named fields like `Breed string` also match — skip them.
+ *
+ * The shouldSkipExtends hook checks if the extends node's parent is a
+ * field_declaration with a named field child, indicating a regular
+ * (non-embedded) field that should not produce a heritage record.
+ */
+export declare const goHeritageConfig: HeritageExtractionConfig;

package/dist/core/ingestion/heritage-extractors/configs/go.js

@@ -0,0 +1,20 @@
+// gitnexus/src/core/ingestion/heritage-extractors/configs/go.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+/**
+ * Go heritage extraction config.
+ *
+ * Go struct embedding: the tree-sitter query matches ALL field_declarations
+ * with type_identifier, but only anonymous fields (no name) are embedded.
+ * Named fields like `Breed string` also match — skip them.
+ *
+ * The shouldSkipExtends hook checks if the extends node's parent is a
+ * field_declaration with a named field child, indicating a regular
+ * (non-embedded) field that should not produce a heritage record.
+ */
+export const goHeritageConfig = {
+    language: SupportedLanguages.Go,
+    shouldSkipExtends(extendsNode) {
+        const fieldDecl = extendsNode.parent;
+        return fieldDecl?.type === 'field_declaration' && fieldDecl.childForFieldName?.('name') != null;
+    },
+};