gitnexus 1.6.2-rc.21 → 1.6.2-rc.22

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

@@ -27,6 +27,7 @@ import { createVariableExtractor } from '../variable-extractors/generic.js';
 import { dartVariableConfig } from '../variable-extractors/configs/dart.js';
 import { createCallExtractor } from '../call-extractors/generic.js';
 import { dartCallConfig } from '../call-extractors/configs/dart.js';
+import { createHeritageExtractor } from '../heritage-extractors/generic.js';
 /**
  * Resolve the enclosing function from a `function_body` node by looking at its
  * previous sibling.  In Dart's tree-sitter grammar, function_signature and
@@ -95,6 +96,7 @@ export const dartProvider = defineLanguage({
     methodExtractor: createMethodExtractor(dartMethodConfig),
     variableExtractor: createVariableExtractor(dartVariableConfig),
     classExtractor: createClassExtractor(dartClassConfig),
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.Dart),
     enclosingFunctionFinder: dartEnclosingFunctionFinder,
     builtInNames: BUILT_INS,
 });

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

@@ -25,6 +25,8 @@ import { createVariableExtractor } from '../variable-extractors/generic.js';
 import { goVariableConfig } from '../variable-extractors/configs/go.js';
 import { createCallExtractor } from '../call-extractors/generic.js';
 import { goCallConfig } from '../call-extractors/configs/go.js';
+import { createHeritageExtractor } from '../heritage-extractors/generic.js';
+import { goHeritageConfig } from '../heritage-extractors/configs/go.js';
 export const goProvider = defineLanguage({
     id: SupportedLanguages.Go,
     extensions: ['.go'],
@@ -38,4 +40,5 @@ export const goProvider = defineLanguage({
     methodExtractor: createMethodExtractor(goMethodConfig),
     variableExtractor: createVariableExtractor(goVariableConfig),
     classExtractor: createClassExtractor(goClassConfig),
+    heritageExtractor: createHeritageExtractor(goHeritageConfig),
 });

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

@@ -24,6 +24,7 @@ import { createMethodExtractor } from '../method-extractors/generic.js';
 import { javaMethodConfig } from '../method-extractors/configs/jvm.js';
 import { createVariableExtractor } from '../variable-extractors/generic.js';
 import { javaVariableConfig } from '../variable-extractors/configs/jvm.js';
+import { createHeritageExtractor } from '../heritage-extractors/generic.js';
 export const javaProvider = defineLanguage({
     id: SupportedLanguages.Java,
     extensions: ['.java'],
@@ -39,4 +40,5 @@ export const javaProvider = defineLanguage({
     methodExtractor: createMethodExtractor(javaMethodConfig),
     variableExtractor: createVariableExtractor(javaVariableConfig),
     classExtractor: createClassExtractor(javaClassConfig),
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.Java),
 });

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

@@ -25,6 +25,7 @@ import { createMethodExtractor } from '../method-extractors/generic.js';
 import { kotlinMethodConfig } from '../method-extractors/configs/jvm.js';
 import { createVariableExtractor } from '../variable-extractors/generic.js';
 import { kotlinVariableConfig } from '../variable-extractors/configs/jvm.js';
+import { createHeritageExtractor } from '../heritage-extractors/generic.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. */
@@ -110,6 +111,7 @@ export const kotlinProvider = defineLanguage({
     methodExtractor: createMethodExtractor(kotlinMethodConfig),
     variableExtractor: createVariableExtractor(kotlinVariableConfig),
     classExtractor: createClassExtractor(kotlinClassConfig),
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.Kotlin),
     builtInNames: BUILT_INS,
     labelOverride: (functionNode, defaultLabel) => {
         if (defaultLabel !== 'Function')

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

@@ -24,6 +24,7 @@ import { createVariableExtractor } from '../variable-extractors/generic.js';
 import { phpVariableConfig } from '../variable-extractors/configs/php.js';
 import { createCallExtractor } from '../call-extractors/generic.js';
 import { phpCallConfig } from '../call-extractors/configs/php.js';
+import { createHeritageExtractor } from '../heritage-extractors/generic.js';
 const BUILT_INS = new Set([
     'echo',
     'isset',
@@ -232,6 +233,7 @@ export const phpProvider = defineLanguage({
     methodExtractor: createMethodExtractor(phpMethodConfig),
     variableExtractor: createVariableExtractor(phpVariableConfig),
     classExtractor: createClassExtractor(phpClassConfig),
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.PHP),
     descriptionExtractor: phpDescriptionExtractor,
     isRouteFile: isPhpRouteFile,
     builtInNames: BUILT_INS,

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

@@ -27,6 +27,7 @@ import { createVariableExtractor } from '../variable-extractors/generic.js';
 import { pythonVariableConfig } from '../variable-extractors/configs/python.js';
 import { createCallExtractor } from '../call-extractors/generic.js';
 import { pythonCallConfig } from '../call-extractors/configs/python.js';
+import { createHeritageExtractor } from '../heritage-extractors/generic.js';
 const BUILT_INS = new Set([
     'print',
     'len',
@@ -71,5 +72,6 @@ export const pythonProvider = defineLanguage({
     methodExtractor: createMethodExtractor(pythonMethodConfig),
     variableExtractor: createVariableExtractor(pythonVariableConfig),
     classExtractor: createClassExtractor(pythonClassConfig),
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.Python),
     builtInNames: BUILT_INS,
 });

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

@@ -24,6 +24,27 @@ import { createVariableExtractor } from '../variable-extractors/generic.js';
 import { rubyVariableConfig } from '../variable-extractors/configs/ruby.js';
 import { createCallExtractor } from '../call-extractors/generic.js';
 import { rubyCallConfig } from '../call-extractors/configs/ruby.js';
+import { createHeritageExtractor } from '../heritage-extractors/generic.js';
+import { rubyHeritageConfig } from '../heritage-extractors/configs/ruby.js';
+import { maybeRewriteRubyBareCallToSelf } from '../utils/ruby-self-call.js';
+import { findEnclosingClassInfo } from '../utils/ast-helpers.js';
+/**
+ * Ruby label override. Applied to:
+ *   - `definition.module` captures in the structure phase — remaps to `Trait`
+ *     so Ruby modules are registered in the class-like type registry and are
+ *     therefore resolvable by `lookupClassByName` during mixin heritage
+ *     resolution (`include`/`extend`/`prepend`).
+ *   - `definition.function` captures — Ruby has no bare "function" construct
+ *     (top-level `def` is a method on `main`); return the default so generic
+ *     logic continues to apply.
+ *
+ * Returning `null` means "skip this definition"; we never do that here.
+ */
+const rubyLabelOverride = (_node, defaultLabel) => {
+    if (defaultLabel === 'Module')
+        return 'Trait';
+    return defaultLabel;
+};
 /** Ruby method/singleton_method: extract name from 'name' field, label as Method. */
 const rubyExtractFunctionName = (node) => {
     if (node.type !== 'method' && node.type !== 'singleton_method')
@@ -97,6 +118,26 @@ const BUILT_INS = new Set([
     'flatten',
     'uniq',
 ]);
+/**
+ * Remaps `class << self` (singleton_class) to its enclosing class/module for
+ * receiver inference. A `singleton_class` node is not itself a type — walking
+ * up to the real owner lets `inferImplicitReceiver` set `hint='singleton'`.
+ * Returns null for orphaned singleton_class (no enclosing class/module found).
+ * All other container types are returned as-is.
+ */
+const rubyResolveEnclosingOwner = (node) => {
+    if (node.type === 'singleton_class') {
+        let ancestor = node.parent;
+        while (ancestor) {
+            if (ancestor.type === 'class' || ancestor.type === 'module') {
+                return ancestor;
+            }
+            ancestor = ancestor.parent;
+        }
+        return null; // no enclosing class/module — skip
+    }
+    return node; // use as-is for all other container types
+};
 export const rubyProvider = defineLanguage({
     id: SupportedLanguages.Ruby,
     extensions: ['.rb', '.rake', '.gemspec'],
@@ -107,21 +148,7 @@ export const rubyProvider = defineLanguage({
     callRouter: routeRubyCall,
     importSemantics: 'wildcard-leaf',
     callExtractor: createCallExtractor(rubyCallConfig),
-    resolveEnclosingOwner(node) {
-        // Ruby singleton_class (class << self) should resolve to the enclosing
-        // class or module for owner/container resolution (HAS_METHOD edges, class IDs).
-        if (node.type === 'singleton_class') {
-            let ancestor = node.parent;
-            while (ancestor) {
-                if (ancestor.type === 'class' || ancestor.type === 'module') {
-                    return ancestor;
-                }
-                ancestor = ancestor.parent;
-            }
-            return null; // no enclosing class/module — skip
-        }
-        return node; // use as-is for all other container types
-    },
+    resolveEnclosingOwner: rubyResolveEnclosingOwner,
     fieldExtractor: createFieldExtractor(rubyFieldConfig),
     methodExtractor: createMethodExtractor({
         ...rubyMethodConfig,
@@ -129,5 +156,55 @@ export const rubyProvider = defineLanguage({
     }),
     variableExtractor: createVariableExtractor(rubyVariableConfig),
     classExtractor: createClassExtractor(rubyClassConfig),
+    heritageExtractor: createHeritageExtractor(rubyHeritageConfig),
+    labelOverride: rubyLabelOverride,
+    // Ruby MRO is kind-aware: prepend providers beat the class's own method,
+    // which in turn beats include providers. See `lookupMethodByOwnerWithMRO`
+    // in `model/resolve.ts` for the walk order.
+    mroStrategy: 'ruby-mixin',
+    // ── DAG hooks ────────────────────────────────────────────────────
+    //
+    // DAG stage 3: rewrite bare calls (e.g. `serialize` in Account#call_serialize)
+    // as `self.serialize` so they route through owner-scoped MRO instead of
+    // global free-call lookup. `dispatchKind` goes into `hint` for stage 4.
+    inferImplicitReceiver: ({ calledName, callForm, receiverName, receiverTypeName, callNode, filePath, }) => {
+        // Only fire when no receiver has been resolved already.
+        if (receiverName || receiverTypeName)
+            return null;
+        const enclosing = findEnclosingClassInfo(callNode, filePath, rubyResolveEnclosingOwner);
+        const rewrite = maybeRewriteRubyBareCallToSelf(calledName, callForm, callNode, enclosing?.className ?? null, { isBuiltInName: (n) => BUILT_INS.has(n), mroStrategy: 'ruby-mixin' });
+        if (!rewrite)
+            return null;
+        return {
+            callForm: rewrite.callForm,
+            receiverName: rewrite.receiverName,
+            receiverTypeName: rewrite.receiverTypeName,
+            receiverSource: 'implicit-self',
+            hint: rewrite.dispatchKind, // 'instance' | 'singleton'
+        };
+    },
+    // DAG stage 4: two Ruby dispatch overrides —
+    //   implicit-self: MRO walk first, fallback to free-arity-narrowed on miss.
+    //   class-as-receiver: singleton ancestry (extend providers only); miss null-routes.
+    selectDispatch: ({ receiverSource, hint }) => {
+        if (receiverSource === 'implicit-self') {
+            // hint='instance' → instance ancestry (prepend→direct→include, see mro-strategy.ts § 'ruby-mixin')
+            // hint='singleton' → singleton ancestry (extend providers only; miss null-routes)
+            const ancestryView = hint === 'singleton' ? 'singleton' : 'instance';
+            return {
+                primary: 'owner-scoped',
+                fallback: 'free-arity-narrowed',
+                ancestryView,
+            };
+        }
+        if (receiverSource === 'class-as-receiver') {
+            // Class constant receiver (e.g. Account.log): singleton ancestry only; miss null-routes.
+            return {
+                primary: 'owner-scoped',
+                ancestryView: 'singleton',
+            };
+        }
+        return null;
+    },
     builtInNames: BUILT_INS,
 });

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

@@ -27,6 +27,7 @@ import { createVariableExtractor } from '../variable-extractors/generic.js';
 import { rustVariableConfig } from '../variable-extractors/configs/rust.js';
 import { createCallExtractor } from '../call-extractors/generic.js';
 import { rustCallConfig } from '../call-extractors/configs/rust.js';
+import { createHeritageExtractor } from '../heritage-extractors/generic.js';
 /** Rust impl_item: find the function_item child and extract its name as a Method. */
 const rustExtractFunctionName = (node) => {
     if (node.type !== 'impl_item')
@@ -126,5 +127,6 @@ export const rustProvider = defineLanguage({
     }),
     variableExtractor: createVariableExtractor(rustVariableConfig),
     classExtractor: createClassExtractor(rustClassConfig),
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.Rust),
     builtInNames: BUILT_INS,
 });

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

@@ -26,6 +26,7 @@ import { createVariableExtractor } from '../variable-extractors/generic.js';
 import { swiftVariableConfig } from '../variable-extractors/configs/swift.js';
 import { createCallExtractor } from '../call-extractors/generic.js';
 import { swiftCallConfig } from '../call-extractors/configs/swift.js';
+import { createHeritageExtractor } from '../heritage-extractors/generic.js';
 /**
  * Group Swift files by SPM target for implicit module visibility.
  * If SwiftPackageConfig is available, use target -> directory mappings.
@@ -237,6 +238,7 @@ export const swiftProvider = defineLanguage({
     }),
     variableExtractor: createVariableExtractor(swiftVariableConfig),
     classExtractor: createClassExtractor(swiftClassConfig),
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.Swift),
     implicitImportWirer: wireSwiftImplicitImports,
     builtInNames: BUILT_INS,
 });

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

@@ -25,6 +25,7 @@ import { createVariableExtractor } from '../variable-extractors/generic.js';
 import { typescriptVariableConfig, javascriptVariableConfig, } from '../variable-extractors/configs/typescript-javascript.js';
 import { createCallExtractor } from '../call-extractors/generic.js';
 import { typescriptCallConfig, javascriptCallConfig, } from '../call-extractors/configs/typescript-javascript.js';
+import { createHeritageExtractor } from '../heritage-extractors/generic.js';
 /**
  * TypeScript/JavaScript: arrow_function and function_expression get their name
  * from the parent variable_declarator (e.g. `const foo = () => {}`).
@@ -159,6 +160,7 @@ export const typescriptProvider = defineLanguage({
     }),
     variableExtractor: createVariableExtractor(typescriptVariableConfig),
     classExtractor: createClassExtractor(typescriptClassConfig),
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.TypeScript),
     builtInNames: BUILT_INS,
 });
 export const javascriptProvider = defineLanguage({
@@ -177,5 +179,6 @@ export const javascriptProvider = defineLanguage({
     }),
     variableExtractor: createVariableExtractor(javascriptVariableConfig),
     classExtractor: createClassExtractor(javascriptClassConfig),
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.JavaScript),
     builtInNames: BUILT_INS,
 });

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

@@ -26,6 +26,7 @@ import { createVariableExtractor } from '../variable-extractors/generic.js';
 import { typescriptVariableConfig } from '../variable-extractors/configs/typescript-javascript.js';
 import { createCallExtractor } from '../call-extractors/generic.js';
 import { typescriptCallConfig } from '../call-extractors/configs/typescript-javascript.js';
+import { createHeritageExtractor } from '../heritage-extractors/generic.js';
 const VUE_SPECIFIC_BUILT_INS = [
     'ref',
     'reactive',
@@ -71,5 +72,6 @@ export const vueProvider = defineLanguage({
     fieldExtractor: typescriptFieldExtractor,
     variableExtractor: createVariableExtractor(typescriptVariableConfig),
     classExtractor: vueClassExtractor,
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.TypeScript),
     builtInNames: VUE_BUILT_INS,
 });

package/dist/core/ingestion/model/heritage-map.d.ts

@@ -43,11 +43,46 @@ export declare const resolveExtendsType: (parentName: string, currentFilePath: s
     type: "EXTENDS" | "IMPLEMENTS";
     idPrefix: string;
 };
+/**
+ * Direct parent entry with the heritage kind that produced it. Preserved
+ * so kind-aware consumers (Ruby MRO, see `lookupMethodByOwnerWithMRO`) can
+ * walk prepend/include providers in the correct order. Flat-string consumers
+ * use `getParents` / `getAncestors` and see only the parent nodeIds.
+ */
+export interface ParentEntry {
+    readonly parentId: string;
+    /** 'extends' | 'implements' | 'trait-impl' | 'include' | 'extend' | 'prepend' */
+    readonly kind: string;
+}
 export interface HeritageMap {
     /** Direct parents of `childNodeId` (extends + implements + trait-impl). */
     getParents(childNodeId: string): string[];
     /** Full ancestor chain (BFS, bounded depth, cycle-safe). */
     getAncestors(childNodeId: string): string[];
+    /**
+     * Direct parents with heritage kind preserved, insertion-ordered. Used by
+     * kind-aware consumers (Ruby MRO) that need to distinguish prepend /
+     * include / extend / extends for walk-order decisions.
+     *
+     * Insertion order mirrors the order `ExtractedHeritage` records were fed
+     * into `buildHeritageMap`, which in turn mirrors tree-sitter match order.
+     * For Ruby, this matches source declaration order for `prepend` / `include`
+     * statements — the MRO walk reverses this (last-declared-first) at the
+     * consumer side.
+     */
+    getParentEntries(childNodeId: string): readonly ParentEntry[];
+    /**
+     * Ordered ancestry for instance method dispatch (Ruby-aware): includes
+     * `extends`, `implements`, `trait-impl`, `include`, `prepend` kinds.
+     * Excludes `extend` (singleton-only). Order is caller-determined in Unit 3.
+     * For non-Ruby callers (first-wins, c3, etc.), this matches `getAncestors`.
+     */
+    getInstanceAncestry(childNodeId: string): readonly ParentEntry[];
+    /**
+     * Ordered ancestry for singleton / class-method dispatch (Ruby-aware):
+     * only `extend` kind parents. For non-Ruby languages this is always empty.
+     */
+    getSingletonAncestry(childNodeId: string): readonly ParentEntry[];
     /**
      * File paths of classes that directly implement or extend-as-interface the
      * given interface/abstract-class **name**. Replaces the standalone

package/dist/core/ingestion/model/heritage-map.js

@@ -64,8 +64,12 @@ const DEFAULT_HERITAGE_STRATEGY = { defaultEdge: 'EXTENDS' };
  * paths) used by interface-dispatch in call resolution.
  */
 export const buildHeritageMap = (heritage, ctx, getHeritageStrategy) => {
-    // childNodeId → Set<parentNodeId>  (Set to deduplicate cross-chunk duplicates)
+    // childNodeId → insertion-ordered array of { parentId, kind }.
+    // Ordered array (not Set) because Ruby MRO walk depends on declaration
+    // order. A parallel `seen` map dedupes `(parentId, kind)` pairs without
+    // losing order.
     const directParents = new Map();
+    const seenParents = new Map();
     // interfaceName → Set<filePath>  (implementor lookup for interface dispatch)
     const implementorFiles = new Map();
     for (const h of heritage) {
@@ -80,10 +84,23 @@ export const buildHeritageMap = (heritage, ctx, getHeritageStrategy) => {
                         continue;
                     let parents = directParents.get(child.nodeId);
                     if (!parents) {
-                        parents = new Set();
+                        parents = [];
                         directParents.set(child.nodeId, parents);
                     }
-                    parents.add(parent.nodeId);
+                    let seen = seenParents.get(child.nodeId);
+                    if (!seen) {
+                        seen = new Set();
+                        seenParents.set(child.nodeId, seen);
+                    }
+                    // Dedup by `parentId + kind` so the same parent under two different
+                    // kinds (e.g. a module that is both included and prepended — legal
+                    // Ruby though unusual) is recorded twice; the consumer needs both
+                    // kinds in the walk. A single (parent, kind) pair is deduped.
+                    const key = `${parent.nodeId}|${h.kind}`;
+                    if (!seen.has(key)) {
+                        seen.add(key);
+                        parents.push({ parentId: parent.nodeId, kind: h.kind });
+                    }
                 }
             }
         }
@@ -120,9 +137,28 @@ export const buildHeritageMap = (heritage, ctx, getHeritageStrategy) => {
         }
     }
     // --- Public API ---------------------------------------------------
+    /** Internal helper: return the entries array (may be undefined). */
+    const entriesFor = (nodeId) => directParents.get(nodeId);
+    const getParentEntries = (childNodeId) => {
+        const entries = entriesFor(childNodeId);
+        return entries ?? [];
+    };
     const getParents = (childNodeId) => {
-        const parents = directParents.get(childNodeId);
-        return parents ? [...parents] : [];
+        const entries = entriesFor(childNodeId);
+        if (!entries)
+            return [];
+        // Deduplicate parent ids across kinds so the flat-string contract
+        // (used by non-Ruby MRO strategies and by the C3 linearizer) stays
+        // identical to its pre-kind-awareness behavior.
+        const out = [];
+        const seen = new Set();
+        for (const e of entries) {
+            if (!seen.has(e.parentId)) {
+                seen.add(e.parentId);
+                out.push(e.parentId);
+            }
+        }
+        return out;
     };
     const getAncestors = (childNodeId) => {
         const result = [];
@@ -139,11 +175,15 @@ export const buildHeritageMap = (heritage, ctx, getHeritageStrategy) => {
                 visited.add(parentId);
                 result.push(parentId);
                 // Expand parent's own parents for next level
-                const grandparents = directParents.get(parentId);
+                const grandparents = entriesFor(parentId);
                 if (grandparents) {
+                    const gpSeen = new Set();
                     for (const gp of grandparents) {
-                        if (!visited.has(gp))
-                            nextFrontier.push(gp);
+                        if (gpSeen.has(gp.parentId))
+                            continue;
+                        gpSeen.add(gp.parentId);
+                        if (!visited.has(gp.parentId))
+                            nextFrontier.push(gp.parentId);
                     }
                 }
             }
@@ -152,8 +192,69 @@ export const buildHeritageMap = (heritage, ctx, getHeritageStrategy) => {
         }
         return result;
     };
+    /**
+     * Lazy-computed per-owner split of direct parents into instance-dispatch
+     * (non-`extend`) and singleton-dispatch (`extend`-only) views. Memoized on
+     * first request so the `.filter()` pass happens at most once per owner per
+     * HeritageMap lifetime, not per call-site dispatch.
+     *
+     * Shared empty-array sentinels for owners with no entries in a given view
+     * avoid per-call allocation when the split is asymmetric (common Ruby case:
+     * a class has `include` but no `extend`, so its singleton view is empty).
+     */
+    const EMPTY_PARENT_ENTRIES = [];
+    const splitCache = new Map();
+    const splitForOwner = (childNodeId) => {
+        let cached = splitCache.get(childNodeId);
+        if (cached)
+            return cached;
+        const entries = entriesFor(childNodeId);
+        if (!entries || entries.length === 0) {
+            cached = { instance: EMPTY_PARENT_ENTRIES, singleton: EMPTY_PARENT_ENTRIES };
+        }
+        else {
+            const instance = [];
+            const singleton = [];
+            for (const e of entries) {
+                if (e.kind === 'extend')
+                    singleton.push(e);
+                else
+                    instance.push(e);
+            }
+            cached = {
+                instance: instance.length === 0 ? EMPTY_PARENT_ENTRIES : instance,
+                singleton: singleton.length === 0 ? EMPTY_PARENT_ENTRIES : singleton,
+            };
+        }
+        splitCache.set(childNodeId, cached);
+        return cached;
+    };
+    /**
+     * Instance-dispatch ancestry walk. Excludes `extend` (singleton-only).
+     * For kind-aware consumers (Ruby MRO): walks parents in source-insertion
+     * order. The consumer is responsible for interleaving self / reversing
+     * prepend order / etc. This method preserves raw declaration order.
+     *
+     * Result is cached per owner; repeat calls return the same array.
+     */
+    const getInstanceAncestry = (childNodeId) => splitForOwner(childNodeId).instance;
+    /**
+     * Singleton-dispatch ancestry walk. Only `extend` parents. For non-Ruby
+     * languages this is always empty (no language currently produces `extend`
+     * heritage records outside Ruby).
+     *
+     * Result is cached per owner; repeat calls return the same array.
+     */
+    const getSingletonAncestry = (childNodeId) => splitForOwner(childNodeId).singleton;
     const getImplementorFiles = (interfaceName) => {
         return implementorFiles.get(interfaceName) ?? EMPTY_SET;
     };
-    return { getParents, getAncestors, getImplementorFiles };
+    return {
+        getParents,
+        getAncestors,
+        getParentEntries,
+        getInstanceAncestry,
+        getSingletonAncestry,
+        getImplementorFiles,
+    };
 };

package/dist/core/ingestion/model/resolve.d.ts

@@ -28,32 +28,34 @@ declare function gatherAncestors(classId: string, parentMap: Map<string, string[
 export declare function c3Linearize(classId: string, parentMap: Map<string, string[]>, cache: Map<string, string[] | null>, inProgress?: Set<string>): string[] | null;
 export { gatherAncestors };
 /**
- * Look up a method on an owner class, walking the parent chain via HeritageMap
- * when the method isn't found on the direct owner.
- *
- * Respects the 5 per-language MRO strategies:
- * - `first-wins`:       BFS ancestor walk, first match wins (default)
- * - `leftmost-base`:    BFS ancestor walk, leftmost base in declaration order wins (C++);
- *                        HeritageMap preserves insertion order matching source declaration,
- *                        so BFS order is equivalent to leftmost-base semantics
- * - `c3`:               C3-linearized ancestor order, first match wins (Python)
- * - `implements-split`: BFS ancestor walk, first match wins (Java/C#) —
- *                        full ambiguity detection for multiple interface defaults
- *                        is handled by computeMRO at graph level
- * - `qualified-syntax`: No auto-resolution (Rust) — returns undefined
- *
- * Uses the `c3Linearize` defined in this file (also consumed by
- * mro-processor.ts for graph-level MRO emission) for the `c3` strategy.
- *
- * Depends only on {@link SemanticModel} + {@link HeritageMap} + an
- * {@link MroStrategy} literal — NO dependency on SymbolTable, the language
- * registry, or resolution-context, which keeps the `model/` module free of
- * cross-layer imports. Callers derive the strategy from their language
- * provider before invoking this function.
- *
- * @internal This is the low-level MRO walker. Exported so call-processor's
- * higher-level resolvers (and unit tests) can invoke it directly. Callers
- * outside `core/ingestion/` should use the higher-level resolvers in
- * call-processor.ts instead of depending on this function.
+ * DAG stage 5 helper: look up a method on an owner class via MRO walk.
+ *
+ * Low-level resolver; no dependency on SymbolTable, language registry, or
+ * resolution-context (keeps model/ layer free of cross-layer imports).
+ * All strategies respect `argCount` for overload narrowing.
+ * `ancestryOverride` replaces the default walk; caller must compute it correctly.
+ *
+ * Strategy summary (full docs in gitnexus-shared/mro-strategy.ts):
+ * - `first-wins` / `leftmost-base` / `implements-split`: BFS, first match wins.
+ * - `c3`: C3-linearized order; falls back to BFS on cycle/inconsistency.
+ * - `qualified-syntax`: returns undefined immediately (Rust requires explicit syntax).
+ * - `ruby-mixin`: kind-aware walk — see inline comments below.
+ *
+ * Internal API: exported for call-processor resolvers and tests.
+ * External callers should use resolveMemberCall instead.
+ *
+ * @see gitnexus-shared/mro-strategy.ts § 'ruby-mixin'
+ * @see call-processor.ts § resolveMemberCall
+ */
+export declare const lookupMethodByOwnerWithMRO: (ownerNodeId: string, methodName: string, heritageMap: HeritageMap, model: SemanticModel, strategy: MroStrategy, argCount?: number, 
+/**
+ * Optional pre-computed ancestry list. When provided, overrides the default
+ * per-strategy ancestry source. Primarily used by Ruby singleton dispatch:
+ * the caller supplies `heritageMap.getSingletonAncestry(ownerNodeId)` as
+ * node-id array so this walker resolves against `extend` providers only.
+ *
+ * For `ruby-mixin` strategy, passing an override switches the walker into
+ * a no-prepend-no-direct linear scan (the caller has already decided the
+ * order), which is the correct semantics for singleton dispatch.
  */
-export declare const lookupMethodByOwnerWithMRO: (ownerNodeId: string, methodName: string, heritageMap: HeritageMap, model: SemanticModel, strategy: MroStrategy, argCount?: number) => SymbolDefinition | undefined;
+ancestryOverride?: readonly string[]) => SymbolDefinition | undefined;