gitnexus 1.5.2 → 1.6.0

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

@@ -1,6 +1,6 @@
 // gitnexus/src/core/ingestion/method-extractors/generic.ts
-/** Owner node types where member functions are effectively static (JVM semantics). */
-const STATIC_OWNER_TYPES = new Set(['companion_object', 'object_declaration']);
+/** Owner node types where member functions are effectively static (JVM/Ruby semantics). */
+const STATIC_OWNER_TYPES = new Set(['companion_object', 'object_declaration', 'singleton_class']);
 /**
  * Create a MethodExtractor from a declarative config.
  */
@@ -16,18 +16,26 @@ export function createMethodExtractor(config) {
         extract(node, context) {
             if (!typeDeclarationSet.has(node.type))
                 return null;
-            // Resolve owner name: field-based → type_identifier → simple_identifier → "Companion"
+            // Resolve owner name: config hook → field-based → type_identifier → simple_identifier → "Companion"
             let ownerName;
-            const nameField = node.childForFieldName('name');
-            if (nameField) {
-                ownerName = nameField.text;
+            if (config.extractOwnerName) {
+                ownerName = config.extractOwnerName(node);
             }
-            else {
-                for (let i = 0; i < node.namedChildCount; i++) {
-                    const child = node.namedChild(i);
-                    if (child && (child.type === 'type_identifier' || child.type === 'simple_identifier')) {
-                        ownerName = child.text;
-                        break;
+            if (!ownerName) {
+                const nameField = node.childForFieldName('name');
+                if (nameField) {
+                    ownerName = nameField.text;
+                }
+                else {
+                    for (let i = 0; i < node.namedChildCount; i++) {
+                        const child = node.namedChild(i);
+                        if (child &&
+                            (child.type === 'type_identifier' ||
+                                child.type === 'simple_identifier' ||
+                                child.type === 'identifier')) {
+                            ownerName = child.text;
+                            break;
+                        }
                     }
                 }
             }
@@ -50,6 +58,12 @@ export function createMethodExtractor(config) {
             }
             return { ownerName, methods };
         },
+        extractFromNode(node, context) {
+            if (!methodNodeSet.has(node.type))
+                return null;
+            return buildMethod(node, node, context, config);
+        },
+        ...(config.extractFunctionName ? { extractFunctionName: config.extractFunctionName } : {}),
     };
 }
 function findBodies(node, bodyNodeSet) {
@@ -77,19 +91,27 @@ function findBodies(node, bodyNodeSet) {
     }
     return result;
 }
-function addNestedBodies(parent, bodyNodeSet, out) {
+function addNestedBodies(parent, bodyNodeSet, out, seen) {
+    const visited = seen ?? new Set(out);
     for (let i = 0; i < parent.namedChildCount; i++) {
         const child = parent.namedChild(i);
-        if (child && bodyNodeSet.has(child.type) && !out.includes(child)) {
+        if (child && bodyNodeSet.has(child.type) && !visited.has(child)) {
+            visited.add(child);
             out.push(child);
         }
     }
 }
 function extractMethodsFromBody(body, ownerNode, context, config, methodNodeSet, out) {
     for (let i = 0; i < body.namedChildCount; i++) {
-        const child = body.namedChild(i);
+        let child = body.namedChild(i);
         if (!child)
             continue;
+        // C++ template methods are wrapped in template_declaration — unwrap to the inner node
+        if (child.type === 'template_declaration') {
+            const inner = child.namedChildren.find((c) => methodNodeSet.has(c.type));
+            if (inner)
+                child = inner;
+        }
         if (methodNodeSet.has(child.type)) {
             const method = buildMethod(child, ownerNode, context, config);
             if (method)
@@ -130,6 +152,7 @@ function buildMethod(node, ownerNode, context, config) {
         ...(config.isOverride?.(node) ? { isOverride: true } : {}),
         ...(config.isAsync?.(node) ? { isAsync: true } : {}),
         ...(config.isPartial?.(node) ? { isPartial: true } : {}),
+        ...(config.isConst?.(node) ? { isConst: true } : {}),
         annotations: config.extractAnnotations?.(node) ?? [],
         sourceFile: context.filePath,
         line: node.startPosition.row + 1,

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

@@ -5,6 +5,10 @@ export type MethodVisibility = FieldVisibility;
 export interface ParameterInfo {
     name: string;
     type: string | null;
+    /** Full type text including generic/template args (e.g. 'vector<int>', 'List<String>').
+     *  Used by typeTagForId for overload disambiguation where generic args matter.
+     *  Falls back to `type` when not set. */
+    rawType?: string | null;
     isOptional: boolean;
     isVariadic: boolean;
 }
@@ -21,6 +25,7 @@ export interface MethodInfo {
     isOverride?: boolean;
     isAsync?: boolean;
     isPartial?: boolean;
+    isConst?: boolean;
     annotations: string[];
     sourceFile: string;
     line: number;
@@ -37,6 +42,17 @@ export interface MethodExtractor {
     language: SupportedLanguages;
     extract(node: SyntaxNode, context: MethodExtractorContext): ExtractedMethods | null;
     isTypeDeclaration(node: SyntaxNode): boolean;
+    /** Extract method info from a standalone method node (e.g. Go top-level method_declaration). */
+    extractFromNode?(node: SyntaxNode, context: MethodExtractorContext): MethodInfo | null;
+    /** Extract function name + label from an AST node during parent-walk.
+     *  Languages with non-standard AST structures (e.g. C/C++ declarator
+     *  unwrapping, Swift init/deinit, Rust impl_item) provide this hook
+     *  to replace the generic name-field lookup.
+     *  Return null to fall through to the generic extractor. */
+    extractFunctionName?(node: SyntaxNode): {
+        funcName: string | null;
+        label: import('../../_shared/index.js').NodeLabel;
+    } | null;
 }
 export interface MethodExtractionConfig {
     language: SupportedLanguages;
@@ -56,6 +72,15 @@ export interface MethodExtractionConfig {
     isOverride?: (node: SyntaxNode) => boolean;
     isAsync?: (node: SyntaxNode) => boolean;
     isPartial?: (node: SyntaxNode) => boolean;
+    isConst?: (node: SyntaxNode) => boolean;
+    /** Resolve the owner name from a standalone method node (e.g. Go receiver type). */
+    extractOwnerName?: (node: SyntaxNode) => string | undefined;
     /** Extract a primary constructor from the owner node itself (e.g. C# 12 class Point(int x, int y)). */
     extractPrimaryConstructor?: (ownerNode: SyntaxNode, context: MethodExtractorContext) => MethodInfo | null;
+    /** Extract function name + label from an AST node during parent-walk.
+     *  Passed through to the MethodExtractor by createMethodExtractor. */
+    extractFunctionName?: (node: SyntaxNode) => {
+        funcName: string | null;
+        label: import('../../_shared/index.js').NodeLabel;
+    } | null;
 }

package/dist/core/ingestion/model/field-registry.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Field Registry
+ *
+ * Owner-scoped field/property index extracted from SymbolTable.
+ * Stores Property symbols keyed by `ownerNodeId\0fieldName` for O(1) lookup.
+ */
+import type { SymbolDefinition } from './symbol-table.js';
+export interface FieldRegistry {
+    /** Look up a field/property by its owning class nodeId and field name. */
+    lookupFieldByOwner(ownerNodeId: string, fieldName: string): SymbolDefinition | undefined;
+}
+export interface MutableFieldRegistry extends FieldRegistry {
+    /** Register a field/property under its owner. */
+    register(ownerNodeId: string, fieldName: string, def: SymbolDefinition): void;
+    /** Clear all entries. */
+    clear(): void;
+}
+export declare const createFieldRegistry: () => MutableFieldRegistry;

package/dist/core/ingestion/model/field-registry.js

@@ -0,0 +1,22 @@
+/**
+ * Field Registry
+ *
+ * Owner-scoped field/property index extracted from SymbolTable.
+ * Stores Property symbols keyed by `ownerNodeId\0fieldName` for O(1) lookup.
+ */
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+export const createFieldRegistry = () => {
+    const fieldByOwner = new Map();
+    const lookupFieldByOwner = (ownerNodeId, fieldName) => {
+        return fieldByOwner.get(`${ownerNodeId}\0${fieldName}`);
+    };
+    const register = (ownerNodeId, fieldName, def) => {
+        fieldByOwner.set(`${ownerNodeId}\0${fieldName}`, def);
+    };
+    const clear = () => {
+        fieldByOwner.clear();
+    };
+    return { lookupFieldByOwner, register, clear };
+};

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

@@ -0,0 +1,70 @@
+/**
+ * Heritage Map
+ *
+ * Unified inheritance data structure built from accumulated
+ * {@link ExtractedHeritage} records **after all chunks complete** (between
+ * chunk processing and call resolution). Consumes `ExtractedHeritage[]` and
+ * resolves type names to nodeIds via `lookupClassByName`, NOT graph-edge
+ * queries.
+ *
+ * Combines two concerns:
+ * 1. **Parent/ancestor lookup** (MRO-aware method resolution)
+ * 2. **Implementor lookup** (interface dispatch — which files contain
+ *    classes implementing a given interface)
+ */
+import type { ResolutionContext } from './resolution-context.js';
+import { type SupportedLanguages } from '../../../_shared/index.js';
+export interface ExtractedHeritage {
+    filePath: string;
+    className: string;
+    parentName: string;
+    /** 'extends' | 'implements' | 'trait-impl' | 'include' | 'extend' | 'prepend' */
+    kind: string;
+}
+export interface HeritageResolutionStrategy {
+    /** If set and the parent name matches, force IMPLEMENTS even when the
+     *  symbol is unresolved (e.g. `/^I[A-Z]/` for C# / Java). */
+    readonly interfaceNamePattern?: RegExp;
+    /** Fallback edge for unresolved parents when the name pattern doesn't
+     *  match (Swift uses 'IMPLEMENTS' for protocol conformance). */
+    readonly defaultEdge: 'EXTENDS' | 'IMPLEMENTS';
+}
+/** Callback used by `buildHeritageMap` to look up the resolution strategy
+ *  for a given language. Injected by callers so the model module doesn't
+ *  depend on `../languages/index.js`. */
+export type HeritageStrategyLookup = (lang: SupportedLanguages) => HeritageResolutionStrategy;
+/**
+ * Determine whether a heritage.extends capture is actually an IMPLEMENTS
+ * relationship. Consults the symbol table first (authoritative — Tier 1 /
+ * Tier 2 resolution); falls back to the injected {@link HeritageResolutionStrategy}
+ * heuristics for external symbols not present in the graph.
+ */
+export declare const resolveExtendsType: (parentName: string, currentFilePath: string, ctx: ResolutionContext, strategy: HeritageResolutionStrategy) => {
+    type: "EXTENDS" | "IMPLEMENTS";
+    idPrefix: 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[];
+    /**
+     * File paths of classes that directly implement or extend-as-interface the
+     * given interface/abstract-class **name**. Replaces the standalone
+     * `ImplementorMap` — used by interface-dispatch in call resolution.
+     */
+    getImplementorFiles(interfaceName: string): ReadonlySet<string>;
+}
+/**
+ * Build a HeritageMap from accumulated ExtractedHeritage records.
+ *
+ * Resolves class/interface/struct/trait names to nodeIds via
+ * `ctx.model.types.lookupClassByName`. When a name resolves to multiple
+ * candidates, all are recorded (partial-class / cross-file scenario).
+ * Unresolvable names are silently skipped — a missing parent is better
+ * than a wrong edge.
+ *
+ * Also builds the implementor index (interface name → implementing file
+ * paths) used by interface-dispatch in call resolution.
+ */
+export declare const buildHeritageMap: (heritage: readonly ExtractedHeritage[], ctx: ResolutionContext, getHeritageStrategy?: HeritageStrategyLookup) => HeritageMap;

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

@@ -0,0 +1,159 @@
+/**
+ * Heritage Map
+ *
+ * Unified inheritance data structure built from accumulated
+ * {@link ExtractedHeritage} records **after all chunks complete** (between
+ * chunk processing and call resolution). Consumes `ExtractedHeritage[]` and
+ * resolves type names to nodeIds via `lookupClassByName`, NOT graph-edge
+ * queries.
+ *
+ * Combines two concerns:
+ * 1. **Parent/ancestor lookup** (MRO-aware method resolution)
+ * 2. **Implementor lookup** (interface dispatch — which files contain
+ *    classes implementing a given interface)
+ */
+import { getLanguageFromFilename } from '../../../_shared/index.js';
+/**
+ * Determine whether a heritage.extends capture is actually an IMPLEMENTS
+ * relationship. Consults the symbol table first (authoritative — Tier 1 /
+ * Tier 2 resolution); falls back to the injected {@link HeritageResolutionStrategy}
+ * heuristics for external symbols not present in the graph.
+ */
+export const resolveExtendsType = (parentName, currentFilePath, ctx, strategy) => {
+    const resolved = ctx.resolve(parentName, currentFilePath);
+    if (resolved && resolved.candidates.length > 0) {
+        const isInterface = resolved.candidates[0].type === 'Interface';
+        return isInterface
+            ? { type: 'IMPLEMENTS', idPrefix: 'Interface' }
+            : { type: 'EXTENDS', idPrefix: 'Class' };
+    }
+    // Unresolved symbol — fall back to strategy heuristics.
+    if (strategy.interfaceNamePattern?.test(parentName)) {
+        return { type: 'IMPLEMENTS', idPrefix: 'Interface' };
+    }
+    if (strategy.defaultEdge === 'IMPLEMENTS') {
+        return { type: 'IMPLEMENTS', idPrefix: 'Interface' };
+    }
+    return { type: 'EXTENDS', idPrefix: 'Class' };
+};
+// ---------------------------------------------------------------------------
+// Public types
+// ---------------------------------------------------------------------------
+/** Maximum ancestor chain depth to prevent runaway traversal. */
+const MAX_ANCESTOR_DEPTH = 32;
+/** Shared empty set returned when no implementors are found. */
+const EMPTY_SET = new Set();
+/** Default strategy used when `buildHeritageMap` is called without an
+ *  explicit `getHeritageStrategy` callback — the fallback for a language
+ *  whose provider sets no interface-name pattern and no non-default
+ *  `heritageDefaultEdge`. */
+const DEFAULT_HERITAGE_STRATEGY = { defaultEdge: 'EXTENDS' };
+// ---------------------------------------------------------------------------
+// Builder
+// ---------------------------------------------------------------------------
+/**
+ * Build a HeritageMap from accumulated ExtractedHeritage records.
+ *
+ * Resolves class/interface/struct/trait names to nodeIds via
+ * `ctx.model.types.lookupClassByName`. When a name resolves to multiple
+ * candidates, all are recorded (partial-class / cross-file scenario).
+ * Unresolvable names are silently skipped — a missing parent is better
+ * than a wrong edge.
+ *
+ * Also builds the implementor index (interface name → implementing file
+ * paths) used by interface-dispatch in call resolution.
+ */
+export const buildHeritageMap = (heritage, ctx, getHeritageStrategy) => {
+    // childNodeId → Set<parentNodeId>  (Set to deduplicate cross-chunk duplicates)
+    const directParents = new Map();
+    // interfaceName → Set<filePath>  (implementor lookup for interface dispatch)
+    const implementorFiles = new Map();
+    for (const h of heritage) {
+        // ── Parent lookup (nodeId-based) ────────────────────────────────
+        const childDefs = ctx.model.types.lookupClassByName(h.className);
+        const parentDefs = ctx.model.types.lookupClassByName(h.parentName);
+        if (childDefs.length > 0 && parentDefs.length > 0) {
+            for (const child of childDefs) {
+                for (const parent of parentDefs) {
+                    // Skip self-references
+                    if (child.nodeId === parent.nodeId)
+                        continue;
+                    let parents = directParents.get(child.nodeId);
+                    if (!parents) {
+                        parents = new Set();
+                        directParents.set(child.nodeId, parents);
+                    }
+                    parents.add(parent.nodeId);
+                }
+            }
+        }
+        // ── Implementor index (name-based) ──────────────────────────────
+        //
+        // Known limitation: Rust `kind: 'trait-impl'` entries are intentionally NOT
+        // added to the implementor index. Interface dispatch resolution currently
+        // does not traverse Rust trait objects, so recording them here would
+        // inflate the index without a consumer. Revisit if/when trait-object
+        // dispatch is added.
+        //
+        // Known limitation: `getImplementorFiles` is keyed by interface **name**
+        // (string), so two interfaces with the same unqualified name in different
+        // packages (e.g. `pkgA.IRepository` vs `pkgB.IRepository`) collide.
+        let isImpl = false;
+        if (h.kind === 'implements') {
+            isImpl = true;
+        }
+        else if (h.kind === 'extends') {
+            const lang = getLanguageFromFilename(h.filePath);
+            if (lang) {
+                const strategy = getHeritageStrategy?.(lang) ?? DEFAULT_HERITAGE_STRATEGY;
+                const { type } = resolveExtendsType(h.parentName, h.filePath, ctx, strategy);
+                isImpl = type === 'IMPLEMENTS';
+            }
+        }
+        if (isImpl) {
+            let files = implementorFiles.get(h.parentName);
+            if (!files) {
+                files = new Set();
+                implementorFiles.set(h.parentName, files);
+            }
+            files.add(h.filePath);
+        }
+    }
+    // --- Public API ---------------------------------------------------
+    const getParents = (childNodeId) => {
+        const parents = directParents.get(childNodeId);
+        return parents ? [...parents] : [];
+    };
+    const getAncestors = (childNodeId) => {
+        const result = [];
+        const visited = new Set();
+        visited.add(childNodeId); // prevent cycles through the start node
+        // BFS with bounded depth
+        let frontier = getParents(childNodeId);
+        let depth = 0;
+        while (frontier.length > 0 && depth < MAX_ANCESTOR_DEPTH) {
+            const nextFrontier = [];
+            for (const parentId of frontier) {
+                if (visited.has(parentId))
+                    continue;
+                visited.add(parentId);
+                result.push(parentId);
+                // Expand parent's own parents for next level
+                const grandparents = directParents.get(parentId);
+                if (grandparents) {
+                    for (const gp of grandparents) {
+                        if (!visited.has(gp))
+                            nextFrontier.push(gp);
+                    }
+                }
+            }
+            frontier = nextFrontier;
+            depth++;
+        }
+        return result;
+    };
+    const getImplementorFiles = (interfaceName) => {
+        return implementorFiles.get(interfaceName) ?? EMPTY_SET;
+    };
+    return { getParents, getAncestors, getImplementorFiles };
+};

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

@@ -0,0 +1,20 @@
+/**
+ * Semantic Model — public module surface.
+ *
+ * Barrel re-export for the `model/` module. Consumers outside `model/`
+ * should import from this file rather than reaching into individual
+ * registry files.
+ *
+ * The model is owner-scoped type/method/field knowledge layered above
+ * `SymbolTable`. File-indexed and name-keyed callable lookups stay in
+ * `SymbolTable` by design.
+ */
+export { type SemanticModel, type MutableSemanticModel, createSemanticModel, } from './semantic-model.js';
+export { type SymbolTableReader, type SymbolTableWriter, createSymbolTable, } from './symbol-table.js';
+export { type TypeRegistry, type MutableTypeRegistry, createTypeRegistry, } from './type-registry.js';
+export { type MethodRegistry, type MutableMethodRegistry, createMethodRegistry, } from './method-registry.js';
+export { type FieldRegistry, type MutableFieldRegistry, createFieldRegistry, } from './field-registry.js';
+export { lookupMethodByOwnerWithMRO } from './resolve.js';
+export { type NamedImportBinding, type NamedImportMap, isFileInPackageDir, } from './resolution-context.js';
+export { type ExtractedHeritage, type HeritageResolutionStrategy, type HeritageStrategyLookup, } from './heritage-map.js';
+export { CALLABLE_ONLY_LABELS, INERT_LABELS, DISPATCH_LABELS, ALL_NODE_LABELS, type LabelBehavior, } from './registration-table.js';

package/dist/core/ingestion/model/index.js

@@ -0,0 +1,41 @@
+/**
+ * Semantic Model — public module surface.
+ *
+ * Barrel re-export for the `model/` module. Consumers outside `model/`
+ * should import from this file rather than reaching into individual
+ * registry files.
+ *
+ * The model is owner-scoped type/method/field knowledge layered above
+ * `SymbolTable`. File-indexed and name-keyed callable lookups stay in
+ * `SymbolTable` by design.
+ */
+// Unified semantic model (factory + interfaces). SemanticModel is the
+// top-level container and owns the file/callable SymbolTable as a
+// nested `symbols` field.
+export { createSemanticModel, } from './semantic-model.js';
+// SymbolTable is exclusively owned by SemanticModel. Re-exported here
+// for the rare caller that needs the file/callable interface in
+// isolation (e.g. tests).
+export { createSymbolTable, } from './symbol-table.js';
+// Type registry (classes, structs, interfaces, enums, records, impls)
+export { createTypeRegistry, } from './type-registry.js';
+// Method registry (owner-scoped methods with arity-aware overload lookup)
+export { createMethodRegistry, } from './method-registry.js';
+// Field registry (owner-scoped fields/properties)
+export { createFieldRegistry, } from './field-registry.js';
+// MRO-aware method resolution (C3, first-wins, leftmost-base, implements-split,
+// qualified-syntax). Pure function that depends only on the model + HeritageMap.
+// `MroStrategy` itself lives in `gitnexus-shared`; re-exported here for
+// consumers that reach model behavior through the barrel.
+export { lookupMethodByOwnerWithMRO } from './resolve.js';
+// Named-import types and package-dir helper. Re-exported so barrel
+// consumers don't need to reach into a specific model file.
+export { isFileInPackageDir, } from './resolution-context.js';
+// Behavior-grouped dispatch table for SymbolTable.add() routing.
+// See registration-table.ts module JSDoc for the behavior group taxonomy
+// and "how to add a new NodeLabel" checklist.
+// NOTE: createRegistrationTable, RegistrationHook, and RegistrationTableDeps
+// are deliberately NOT re-exported here — they are factory internals of
+// SemanticModel and should only be imported directly from registration-table.js
+// by semantic-model.ts and the registration-table.test.ts file.
+export { CALLABLE_ONLY_LABELS, INERT_LABELS, DISPATCH_LABELS, ALL_NODE_LABELS, } from './registration-table.js';

package/dist/core/ingestion/model/method-registry.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Method Registry
+ *
+ * Owner-scoped method index extracted from SymbolTable.
+ * Stores Method/Constructor/Function-with-ownerId symbols keyed by
+ * `ownerNodeId\0methodName` for O(1) lookup. Supports overloads
+ * (array values) and arity-based filtering.
+ */
+import type { SymbolDefinition } from './symbol-table.js';
+export interface MethodRegistry {
+    /**
+     * Look up a method by owner class + name, optionally filtered by arity.
+     *
+     * When `argCount` is provided, overloads whose parameter count doesn't
+     * accommodate the call's argument count are filtered out before the
+     * returnType dedup runs. This lets D0 (`resolveMemberCall`) disambiguate
+     * arity-differing overloads (e.g. C++ `greet()` vs `greet(string)`) that
+     * would otherwise collide on the shared `ownerId + methodName` key.
+     *
+     * Same-arity, same-returnType overloads (e.g. `save(int)` vs `save(String)`,
+     * both returning `void`) still collapse to the first match — callers must
+     * gate D0 on overload concern before invoking this function for that case.
+     */
+    lookupMethodByOwner(ownerNodeId: string, methodName: string, argCount?: number): SymbolDefinition | undefined;
+    /**
+     * Flat-by-name lookup across all owners. Returns every method registered
+     * with the given unqualified name, in registration order, accumulated
+     * across owners and overloads.
+     *
+     * Required by Tier 3 global resolution: Method and Constructor do not
+     * land in `SymbolTable.callableByName`, so Tier 3 reaches them through
+     * this flat index instead. Returns `[]` on miss — never `undefined` —
+     * so callers can concatenate without null checks.
+     *
+     * Reference identity: each returned def is the same object reference
+     * stored under `lookupMethodByOwner`, so a method symbol occupies one
+     * allocation reachable from two indexes.
+     */
+    lookupMethodByName(name: string): readonly SymbolDefinition[];
+    /**
+     * True iff at least one registered def has `type === 'Function'` — i.e.,
+     * a Python/Rust/Kotlin class method emitted by the worker as
+     * `Function + ownerId` rather than as a strict `Method` label. Such defs
+     * are double-indexed: they land in `SymbolTable.callableByName` (via the
+     * Function callable-index gate) AND in this registry (via the
+     * dispatch-key normalization in `wrappedAdd`). Tier 3 resolution must
+     * then dedup the two indexes by nodeId.
+     *
+     * When this flag is false, the callable and method indexes are
+     * guaranteed disjoint and Tier 3 can skip the dedup pass entirely.
+     * The flag is monotonic (false→true once, never back) for the lifetime
+     * of the MethodRegistry.
+     */
+    readonly hasFunctionMethods: boolean;
+}
+export interface MutableMethodRegistry extends MethodRegistry {
+    /** Register a method under its owner. Supports multiple overloads. */
+    register(ownerNodeId: string, methodName: string, def: SymbolDefinition): void;
+    /** Clear all entries. */
+    clear(): void;
+}
+export declare const createMethodRegistry: () => MutableMethodRegistry;