gitnexus 1.6.6-rc.99 → 1.6.6

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

@@ -1,20 +1,17 @@
 /**
- * Deterministic Resolution Functions
+ * MRO primitives.
  *
- * Pure functions that resolve methods across the inheritance hierarchy
- * using only the SemanticModel registries and HeritageMap — NO dependency
- * on resolution-context.ts (circular dependency risk).
+ * `c3Linearize` and its BFS helper `gatherAncestors` are pure functions over a
+ * `parentMap` (classId → parent ids). They carry no dependency on the semantic
+ * model or graph, so the model layer stays a pure leaf — `mro-processor.ts`
+ * (graph-level MRO emission) imports `c3Linearize` / `gatherAncestors` from here.
  */
-import type { SymbolDefinition } from '../../../_shared/index.js';
-import type { SemanticModel } from './semantic-model.js';
-import type { HeritageMap } from './heritage-map.js';
-import type { MroStrategy } from '../../../_shared/index.js';
 /**
  * Gather all ancestor IDs in BFS / topological order.
  * Returns the linearized list of ancestor IDs (excluding the class itself).
  *
  * Uses a head-pointer BFS (`queue[head++]`) instead of `Array.shift()` to
- * avoid O(n) per-dequeue re-indexing — matching `buildParentMapFromHeritage`.
+ * avoid O(n) per-dequeue re-indexing.
  */
 declare function gatherAncestors(classId: string, parentMap: Map<string, string[]>): string[];
 /**
@@ -22,40 +19,7 @@ declare function gatherAncestors(classId: string, parentMap: Map<string, string[
  * Returns an array of ancestor IDs in C3 order (excluding the class itself),
  * or null if linearization fails (inconsistent or cyclic hierarchy).
  *
- * Used internally by `lookupMethodByOwnerWithMRO` for the Python MRO
- * strategy and re-exported for mro-processor.ts (graph-level MRO emission).
+ * Re-exported for mro-processor.ts (graph-level MRO emission).
  */
 export declare function c3Linearize(classId: string, parentMap: Map<string, string[]>, cache: Map<string, string[] | null>, inProgress?: Set<string>): string[] | null;
 export { gatherAncestors };
-/**
- * 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.
- */
-ancestryOverride?: readonly string[]) => SymbolDefinition | undefined;

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

@@ -1,23 +1,17 @@
 /**
- * Deterministic Resolution Functions
+ * MRO primitives.
  *
- * Pure functions that resolve methods across the inheritance hierarchy
- * using only the SemanticModel registries and HeritageMap — NO dependency
- * on resolution-context.ts (circular dependency risk).
+ * `c3Linearize` and its BFS helper `gatherAncestors` are pure functions over a
+ * `parentMap` (classId → parent ids). They carry no dependency on the semantic
+ * model or graph, so the model layer stays a pure leaf — `mro-processor.ts`
+ * (graph-level MRO emission) imports `c3Linearize` / `gatherAncestors` from here.
  */
-// ---------------------------------------------------------------------------
-// MRO primitives.
-//
-// `c3Linearize` and its BFS helper `gatherAncestors` live here so the model
-// layer stays a pure leaf — mro-processor.ts (graph-level MRO emission)
-// imports `c3Linearize` from this file.
-// ---------------------------------------------------------------------------
 /**
  * Gather all ancestor IDs in BFS / topological order.
  * Returns the linearized list of ancestor IDs (excluding the class itself).
  *
  * Uses a head-pointer BFS (`queue[head++]`) instead of `Array.shift()` to
- * avoid O(n) per-dequeue re-indexing — matching `buildParentMapFromHeritage`.
+ * avoid O(n) per-dequeue re-indexing.
  */
 function gatherAncestors(classId, parentMap) {
     const visited = new Set();
@@ -45,8 +39,7 @@ function gatherAncestors(classId, parentMap) {
  * Returns an array of ancestor IDs in C3 order (excluding the class itself),
  * or null if linearization fails (inconsistent or cyclic hierarchy).
  *
- * Used internally by `lookupMethodByOwnerWithMRO` for the Python MRO
- * strategy and re-exported for mro-processor.ts (graph-level MRO emission).
+ * Re-exported for mro-processor.ts (graph-level MRO emission).
  */
 export function c3Linearize(classId, parentMap, cache, inProgress) {
     if (cache.has(classId))
@@ -187,215 +180,3 @@ export function c3Linearize(classId, parentMap, cache, inProgress) {
 // `gatherAncestors` is exported so mro-processor.ts can reuse the same
 // BFS traversal for graph-level MRO emission.
 export { gatherAncestors };
-// ---------------------------------------------------------------------------
-// C3 linearization cache (per HeritageMap, auto-drained via WeakMap)
-// ---------------------------------------------------------------------------
-/**
- * Per-HeritageMap cache of C3 linearization results keyed by owner nodeId.
- *
- * HeritageMap instances are immutable after construction, so C3 output is
- * stable for the lifetime of a HeritageMap. WeakMap lets the cache auto-drain
- * when the HeritageMap is garbage collected (end of ingestion run), so we
- * never need to manually invalidate it.
- *
- * `null` is a sentinel for "C3 failed for this owner" (cyclic or inconsistent
- * hierarchy) so we don't re-run the expensive linearization repeatedly.
- */
-const c3LinearizationCache = new WeakMap();
-const getCachedC3Linearization = (ownerNodeId, heritageMap) => {
-    let perHmCache = c3LinearizationCache.get(heritageMap);
-    if (!perHmCache) {
-        perHmCache = new Map();
-        c3LinearizationCache.set(heritageMap, perHmCache);
-    }
-    const cached = perHmCache.get(ownerNodeId);
-    if (cached !== undefined)
-        return cached;
-    const parentMap = buildParentMapFromHeritage(ownerNodeId, heritageMap);
-    const result = c3Linearize(ownerNodeId, parentMap, new Map()) ?? null;
-    perHmCache.set(ownerNodeId, result);
-    return result;
-};
-// ---------------------------------------------------------------------------
-// Heritage → parentMap conversion
-// ---------------------------------------------------------------------------
-/**
- * Build a parentMap from HeritageMap for use with c3Linearize.
- * Traverses the parent chain starting from startNodeId, collecting all
- * parent→children relationships into a Map<string, string[]>.
- *
- * Uses a head-pointer BFS (queue[head++]) instead of Array.shift() to avoid
- * O(n) per-dequeue re-indexing. For wide/shallow hierarchies common in
- * large Java/C# codebases this keeps the walk linear in ancestor count.
- */
-const buildParentMapFromHeritage = (startNodeId, heritageMap) => {
-    const parentMap = new Map();
-    const visited = new Set();
-    const queue = [startNodeId];
-    let head = 0;
-    while (head < queue.length) {
-        const nodeId = queue[head++];
-        if (visited.has(nodeId))
-            continue;
-        visited.add(nodeId);
-        const parents = heritageMap.getParents(nodeId);
-        if (parents.length > 0) {
-            parentMap.set(nodeId, parents);
-            for (const p of parents) {
-                if (!visited.has(p))
-                    queue.push(p);
-            }
-        }
-    }
-    return parentMap;
-};
-// ---------------------------------------------------------------------------
-// MRO-aware method lookup
-// ---------------------------------------------------------------------------
-/**
- * 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 const lookupMethodByOwnerWithMRO = (ownerNodeId, methodName, heritageMap, model, strategy, argCount, 
-/**
- * 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.
- */
-ancestryOverride) => {
-    // ── Ruby mixin strategy ───────────────────────────────────────────
-    // Kind-aware walk — does NOT short-circuit on direct owner first (prepend beats direct).
-    // Instance dispatch: prepend (reverse) → direct → include (reverse) → transitive BFS.
-    // Singleton dispatch: caller supplies ancestryOverride (extend providers only);
-    //   simple left-to-right scan. Miss NEVER falls through to file-scoped fallback.
-    // See gitnexus-shared/mro-strategy.ts § 'ruby-mixin' for full strategy docs.
-    if (strategy === 'ruby-mixin') {
-        if (ancestryOverride) {
-            // Singleton dispatch: scan pre-computed ancestry only. Miss null-routes.
-            for (const ancestorId of ancestryOverride) {
-                const method = model.methods.lookupMethodByOwner(ancestorId, methodName, argCount);
-                if (method)
-                    return method;
-            }
-            return undefined;
-        }
-        // Instance dispatch — kind-aware walk per the pseudocode above.
-        const instanceEntries = heritageMap.getInstanceAncestry(ownerNodeId);
-        // Partition into prepend parents vs other parents (extends / include /
-        // implements / trait-impl), preserving declaration order within each.
-        const prependParents = [];
-        const otherParents = [];
-        for (const e of instanceEntries) {
-            if (e.kind === 'prepend')
-                prependParents.push(e.parentId);
-            else
-                otherParents.push(e.parentId);
-        }
-        // Step 1: Walk prepend parents in REVERSE declaration order (last-prepended wins).
-        for (let i = prependParents.length - 1; i >= 0; i--) {
-            const method = model.methods.lookupMethodByOwner(prependParents[i], methodName, argCount);
-            if (method)
-                return method;
-        }
-        // Step 2: Direct owner lookup (the class's own method).
-        // This is the only difference from other strategies — prepend beats direct.
-        const direct = model.methods.lookupMethodByOwner(ownerNodeId, methodName, argCount);
-        if (direct)
-            return direct;
-        // Step 3: Walk extends + include parents in REVERSE declaration order.
-        // (Ruby `include A; include B` puts B ahead of A in MRO.)
-        for (let i = otherParents.length - 1; i >= 0; i--) {
-            const method = model.methods.lookupMethodByOwner(otherParents[i], methodName, argCount);
-            if (method)
-                return method;
-        }
-        // Step 4: Transitive ancestors (a mixin that itself mixes in another module).
-        // Fall back to the BFS ancestor walk for depth > 1. Order is best-effort;
-        // Ruby's actual MRO for transitive mixins is rare and under-specified
-        // (documented in architecture docs as deferred work).
-        //
-        // O(1) skip-check via Sets:
-        //   - `walkedDirect` covers parents already visited in steps 1-3.
-        //   - `singletonOnly` covers direct `extend` providers: they belong to
-        //     the singleton MRO and must NEVER appear in instance dispatch.
-        // Building Sets once before the BFS loop avoids O(n²) `Array.includes`
-        // on large mixin hierarchies.
-        const walkedDirect = new Set(prependParents);
-        for (const id of otherParents)
-            walkedDirect.add(id);
-        const singletonOnly = new Set(heritageMap.getSingletonAncestry(ownerNodeId).map((e) => e.parentId));
-        for (const ancestorId of heritageMap.getAncestors(ownerNodeId)) {
-            if (ancestorId === ownerNodeId)
-                continue;
-            if (walkedDirect.has(ancestorId))
-                continue;
-            if (singletonOnly.has(ancestorId))
-                continue;
-            const method = model.methods.lookupMethodByOwner(ancestorId, methodName, argCount);
-            if (method)
-                return method;
-        }
-        return undefined;
-    }
-    // ── Non-Ruby strategies: direct-owner-first short-circuit ─────────
-    // Direct lookup first (child override — no walk needed).
-    // argCount is threaded through so arity-differing overloads on the direct
-    // owner can be disambiguated before the MRO walk starts.
-    const direct = model.methods.lookupMethodByOwner(ownerNodeId, methodName, argCount);
-    if (direct)
-        return direct;
-    // Rust: requires qualified syntax (<Type as Trait>::method), no auto-resolution
-    if (strategy === 'qualified-syntax')
-        return undefined;
-    // Determine ancestor walk order based on MRO strategy.
-    // readonly to accept the cached (frozen) c3 linearization without copying.
-    let ancestors;
-    if (ancestryOverride) {
-        ancestors = ancestryOverride;
-    }
-    else if (strategy === 'c3') {
-        // C3 linearization (memoized per HeritageMap
-        // so repeated calls for the same owner within an ingestion run reuse the
-        // linearization instead of rebuilding the parent map and re-running C3).
-        // c3Linearize returns ancestors only (excludes the owner itself),
-        // matching heritageMap.getAncestors() semantics.
-        const c3Result = getCachedC3Linearization(ownerNodeId, heritageMap);
-        // Fall back to BFS order if C3 fails (cyclic or inconsistent hierarchy).
-        // Note: BFS order may not preserve Python MRO semantics in these edge
-        // cases, but cyclic/inconsistent hierarchies are invalid in Python anyway.
-        ancestors = c3Result ?? heritageMap.getAncestors(ownerNodeId);
-    }
-    else {
-        // first-wins, leftmost-base, implements-split: BFS order via HeritageMap
-        ancestors = heritageMap.getAncestors(ownerNodeId);
-    }
-    // Walk ancestors in MRO order — first match wins.
-    // argCount narrows overloaded ancestors the same way as the direct lookup.
-    for (const ancestorId of ancestors) {
-        const method = model.methods.lookupMethodByOwner(ancestorId, methodName, argCount);
-        if (method)
-            return method;
-    }
-    return undefined;
-};

package/dist/core/ingestion/model/scope-resolution-indexes.d.ts

@@ -39,7 +39,7 @@
  * `ReferenceIndex` is deliberately NOT here — it is populated in a later
  * phase (RFC §3.2 Phase 4 / Ring 2 PKG #925) and owned separately.
  */
-import type { BindingRef, DefIndex, FinalizedScc, FinalizeStats, ImportEdge, MethodDispatchIndex, ModuleScopeIndex, QualifiedNameIndex, ReferenceSite, ScopeId, ScopeTree } from '../../../_shared/index.js';
+import type { BindingRef, DefIndex, FinalizedScc, FinalizeStats, ImportEdge, MethodDispatchIndex, ModuleScopeIndex, QualifiedNameIndex, ReferenceSite, ScopeId, ScopeTree, TypeRef } from '../../../_shared/index.js';
 export interface ScopeResolutionIndexes {
     readonly scopeTree: ScopeTree;
     readonly defs: DefIndex;
@@ -73,6 +73,51 @@ export interface ScopeResolutionIndexes {
      *  shared map gives those workspace-wide names one entry each instead of
      *  O(scopes × defs) per-scope augmentation. */
     readonly workspaceFqnBindings: ReadonlyMap<string, readonly BindingRef[]>;
+    /** Workspace-level *type* binding lookup — the typeBindings analogue of
+     *  `workspaceFqnBindings`. Holds names that are type-visible from every file
+     *  (e.g. C# global/default-namespace method return-type bindings, keyed by
+     *  the bound name). The C# language spec makes the unnamed global namespace a
+     *  single declaration space whose members are available from inside named
+     *  namespaces too — so this channel is consulted scope-independently by the
+     *  typeBindings chain-walkers (`findReceiverTypeBinding`,
+     *  `followChainPostFinalize`) as a final fallback after the per-scope chain.
+     *  Routing global types here gives them one shared entry instead of the
+     *  O(scopes × defs) per-file `Scope.typeBindings` copy that OOM'd large
+     *  no-namespace solutions (#1871) — mirroring how Roslyn resolves against a
+     *  single `Compilation.GlobalNamespace` symbol rather than per-file copies.
+     *  Populated post-finalize by `populateCsharpNamespaceSiblings`; most
+     *  languages leave it empty. */
+    readonly workspaceTypeBindings: ReadonlyMap<string, TypeRef>;
+    /** Per-namespace class/def binding lookup — the namespace-scoped analogue of
+     *  `workspaceFqnBindings`. Outer key is the namespace name (e.g. `App.Models`),
+     *  inner key is the simple name. Unlike the flat workspace channels (which are
+     *  visible from *every* file — correct only for the global/default namespace),
+     *  named-namespace types are visible only within that namespace and to files
+     *  that import it, so this channel is consulted through an accessibility gate
+     *  (`accessibleNamespacesByScope`) rather than unconditionally. Routing named
+     *  siblings here gives them one entry per def instead of the O(files × defs)
+     *  per-scope augmentation that OOM'd large single-namespace solutions (#1871).
+     *  Populated post-finalize by language namespace-sibling hooks; most languages
+     *  leave it empty. */
+    readonly namespaceFqnBindings: ReadonlyMap<string, ReadonlyMap<string, readonly BindingRef[]>>;
+    /** Per-namespace *type* binding lookup — the namespace-scoped analogue of
+     *  `workspaceTypeBindings`. Outer key is the namespace name, inner key is the
+     *  bound name (e.g. a method name mapping to its return TypeRef). Consulted by
+     *  the typeBindings chain-walkers (`findReceiverTypeBinding`,
+     *  `followChainPostFinalize`) through the `accessibleNamespacesByScope` gate
+     *  after the per-scope chain and the flat `workspaceTypeBindings` miss.
+     *  Populated post-finalize; most languages leave it empty. */
+    readonly namespaceTypeBindings: ReadonlyMap<string, ReadonlyMap<string, TypeRef>>;
+    /** Accessibility gate for the per-namespace channels: maps a module ScopeId to
+     *  the namespace names type-visible from that file — its own declared
+     *  namespace(s) plus every imported/`using`d namespace (and dotted prefixes).
+     *  This is the same per-file accessible-namespace set the C# hook already
+     *  derives (`expandedNamespaces`), materialized so the language-neutral walkers
+     *  can consult `namespaceFqnBindings` / `namespaceTypeBindings` for exactly the
+     *  namespaces a file can see — preserving namespace visibility semantics
+     *  without the per-file binding copy. Empty when no language populates the
+     *  namespace channels. */
+    readonly accessibleNamespacesByScope: ReadonlyMap<ScopeId, readonly string[]>;
     /** Pre-resolution usage facts; consumed by the resolution phase. */
     readonly referenceSites: readonly ReferenceSite[];
     /** SCC condensation of the file-level import graph — callers that want

package/dist/core/ingestion/model/semantic-model.d.ts

@@ -19,7 +19,7 @@
  *          ↑
  *     model/semantic-model.ts                 — THIS FILE (orchestrator)
  *          ↑
- *     resolve.ts, call-processor.ts, resolution-context.ts, ...
+ *     resolve.ts, call-processor.ts, ...
  *
  * `symbol-table.ts` is a leaf — it never imports from `./model/`. This
  * file (semantic-model.ts) is the ONLY place where SymbolTable and the
@@ -113,10 +113,8 @@ export interface SemanticModel {
     /**
      * Materialized scope-resolution indexes from RFC #909 Ring 2 PKG #921.
      *
-     * `undefined` until the finalize-orchestrator attaches them. While
-     * `undefined`, the legacy DAG is the sole resolution surface; once set,
-     * resolvers whose language has `REGISTRY_PRIMARY_<LANG>=true` consult
-     * these indexes instead.
+     * `undefined` until the finalize-orchestrator attaches them. Once set,
+     * the scope-resolution resolvers consult these indexes.
      *
      * The attach is a one-shot write (see `MutableSemanticModel`). Callers
      * holding a read-only `SemanticModel` handle see either `undefined` or
@@ -126,7 +124,7 @@ export interface SemanticModel {
 }
 /** Mutable variant — exposes the MutableX registries, a Writer-typed
  *  `symbols` facade, and a full-cascade reset. This is the interface
- *  held by the lifecycle owner (pipeline, resolution-context); resolvers
+ *  held by the lifecycle owner (the parse pipeline); resolvers
  *  that only query should hold the narrower {@link SemanticModel}. */
 export interface MutableSemanticModel extends SemanticModel {
     readonly types: MutableTypeRegistry;

package/dist/core/ingestion/model/semantic-model.js

@@ -19,7 +19,7 @@
  *          ↑
  *     model/semantic-model.ts                 — THIS FILE (orchestrator)
  *          ↑
- *     resolve.ts, call-processor.ts, resolution-context.ts, ...
+ *     resolve.ts, call-processor.ts, ...
  *
  * `symbol-table.ts` is a leaf — it never imports from `./model/`. This
  * file (semantic-model.ts) is the ONLY place where SymbolTable and the

package/dist/core/ingestion/model/symbol-table.d.ts

@@ -27,7 +27,7 @@
  *          ↑
  *     model/semantic-model.ts           — orchestrator, wraps add()
  *          ↑
- *     model/resolve.ts, call-processor.ts, resolution-context.ts, ...
+ *     model/resolve.ts, call-processor.ts, ...
  *
  * No arrow ever points downward from this file. If you are tempted to
  * import from `./model/` here, you are going the wrong way — move the
@@ -57,9 +57,8 @@ export type ClassLikeLabel = (typeof CLASS_TYPES_TUPLE)[number];
 export declare const CLASS_TYPES: ReadonlySet<NodeLabel>;
 /** Free-callable labels — single source of truth for "callables that have
  *  NO owner scope". Methods and constructors are owner-scoped and live in
- *  `MethodRegistry` — Tier 3 reaches them via
- *  `model.methods.lookupMethodByName`. See `resolution-context.ts` Tier 3
- *  for how both indexes are consulted together.
+ *  `MethodRegistry`, reached via `model.methods.lookupMethodByName`. Global
+ *  by-name resolution consults both indexes (see `model/index.ts`).
  *
  *  Exported as a `readonly` tuple so that `typeof FREE_CALLABLE_TUPLE[number]`
  *  yields a precise literal union (`FreeCallableLabel`). `registration-table.ts`

package/dist/core/ingestion/model/symbol-table.js

@@ -27,7 +27,7 @@
  *          ↑
  *     model/semantic-model.ts           — orchestrator, wraps add()
  *          ↑
- *     model/resolve.ts, call-processor.ts, resolution-context.ts, ...
+ *     model/resolve.ts, call-processor.ts, ...
  *
  * No arrow ever points downward from this file. If you are tempted to
  * import from `./model/` here, you are going the wrong way — move the
@@ -62,9 +62,8 @@ export const CLASS_TYPES_TUPLE = [
 export const CLASS_TYPES = new Set(CLASS_TYPES_TUPLE);
 /** Free-callable labels — single source of truth for "callables that have
  *  NO owner scope". Methods and constructors are owner-scoped and live in
- *  `MethodRegistry` — Tier 3 reaches them via
- *  `model.methods.lookupMethodByName`. See `resolution-context.ts` Tier 3
- *  for how both indexes are consulted together.
+ *  `MethodRegistry`, reached via `model.methods.lookupMethodByName`. Global
+ *  by-name resolution consults both indexes (see `model/index.ts`).
  *
  *  Exported as a `readonly` tuple so that `typeof FREE_CALLABLE_TUPLE[number]`
  *  yields a precise literal union (`FreeCallableLabel`). `registration-table.ts`

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

@@ -1,16 +1,12 @@
 import { KnowledgeGraph } from '../graph/types.js';
-import type { SymbolTableWriter, ExtractedHeritage } from './model/index.js';
-import { ASTCache } from './ast-cache.js';
+import type { SymbolTableWriter } from './model/index.js';
+import { type ExportedTypeMap } from './call-processor.js';
 import type { ParsedFile } from '../../_shared/index.js';
 import { WorkerPool } from './workers/worker-pool.js';
-import type { ParseWorkerResult, ExtractedImport, ExtractedCall, ExtractedAssignment, ExtractedRoute, ExtractedFetchCall, ExtractedDecoratorRoute, ExtractedToolDef, FileConstructorBindings, FileScopeBindings, ExtractedORMQuery, FetchWrapperDef } from './workers/parse-worker.js';
+import type { ParseWorkerResult, ExtractedRoute, ExtractedFetchCall, ExtractedDecoratorRoute, ExtractedToolDef, FileScopeBindings, ExtractedORMQuery, FetchWrapperDef } from './workers/parse-worker.js';
 import type { ExtractedRouterImport, ExtractedRouterInclude, ExtractedRouterModuleAlias } from './route-extractors/fastapi-router-bindings.js';
 export type FileProgressCallback = (current: number, total: number, filePath: string) => void;
 export interface WorkerExtractedData {
-    imports: ExtractedImport[];
-    calls: ExtractedCall[];
-    assignments: ExtractedAssignment[];
-    heritage: ExtractedHeritage[];
     routes: ExtractedRoute[];
     fetchCalls: ExtractedFetchCall[];
     fetchWrapperDefs: FetchWrapperDef[];
@@ -20,7 +16,6 @@ export interface WorkerExtractedData {
     routerModuleAliases: ExtractedRouterModuleAlias[];
     toolDefs: ExtractedToolDef[];
     ormQueries: ExtractedORMQuery[];
-    constructorBindings: FileConstructorBindings[];
     fileScopeBindings: FileScopeBindings[];
     /**
      * Per-file `ParsedFile` artifacts from the new scope-based resolution
@@ -35,31 +30,42 @@ export interface WorkerExtractedData {
  * Merge a list of `ParseWorkerResult`s into the running graph + symbol
  * table state and produce the chunk-aggregated `WorkerExtractedData`.
  *
- * Extracted from `processParsingWithWorkers` so the same merge logic can
+ * Split out from the worker-parse path so the same merge logic can
  * be applied to both freshly-parsed worker output AND cached worker
  * output replayed during incremental analyze. Idempotent on the
  * accumulator fields (push-only); idempotent on graph if the caller
  * starts from a clean graph (otherwise duplicate `addNode` calls are
  * silently no-op'd by `KnowledgeGraph`).
  */
-export declare const mergeChunkResults: (graph: KnowledgeGraph, symbolTable: SymbolTableWriter, chunkResults: readonly ParseWorkerResult[]) => WorkerExtractedData;
-export declare const processParsing: (graph: KnowledgeGraph, files: {
+export declare const mergeChunkResults: (graph: KnowledgeGraph, symbolTable: SymbolTableWriter, chunkResults: readonly ParseWorkerResult[], exportedTypeMap?: ExportedTypeMap) => WorkerExtractedData;
+/**
+ * Dispatch a chunk's files to the worker pool and return the RAW per-worker
+ * results, WITHOUT merging them into the graph. Split out from
+ * {@link processParsing} so the parse loop can overlap one chunk's
+ * merge (main-thread, via {@link mergeChunkResults}) with the NEXT chunk's
+ * worker parse — the merge is the only remaining serial main-thread step once
+ * ParsedFile serialization moved into the workers (#worker-idle pipelining).
+ * Returns `[]` for an all-unparseable chunk (the caller merges `[]` → empty).
+ */
+export declare const dispatchChunkParse: (files: {
     path: string;
     content: string;
-}[], symbolTable: SymbolTableWriter, astCache: ASTCache, 
+}[], workerPool: WorkerPool, onFileProgress?: FileProgressCallback, 
+/** Populated in-place with the raw results (parse-cache capture). */
+outRawResults?: ParseWorkerResult[], 
 /**
- * Persistent tree cache (separate from `astCache`, which the caller
- * clears between chunks). Sequential parses additionally write the
- * Tree here so cross-phase consumers (scope-resolution) can read it.
- * Worker-mode parses skip — Trees can't cross MessageChannels.
- * Pass `undefined` if no consumer needs cross-phase access.
+ * Content hash of this parse chunk. When set, the workers tag their durable
+ * ParsedFile shards with it so a future warm cache hit can restore them
+ * (#2038). `undefined` ⇒ no durable write (tests / no-cache path).
  */
-scopeTreeCache: ASTCache | undefined, onFileProgress?: FileProgressCallback, workerPool?: WorkerPool, 
+chunkHash?: string) => Promise<ParseWorkerResult[]>;
+export declare const processParsing: (graph: KnowledgeGraph, files: {
+    path: string;
+    content: string;
+}[], symbolTable: SymbolTableWriter, workerPool: WorkerPool, onFileProgress?: FileProgressCallback, 
 /**
- * Optional out-parameter for the incremental parse cache. When
- * provided AND the worker-pool path runs successfully, populated
- * with the raw `ParseWorkerResult[]` from the workers (pre-merge).
- * Stays empty for the sequential fallback path (no per-chunk
- * artifact to cache there). See `gitnexus/src/storage/parse-cache.ts`.
+ * Optional out-parameter for the incremental parse cache. When provided,
+ * populated with the raw `ParseWorkerResult[]` from the workers (pre-merge).
+ * See `gitnexus/src/storage/parse-cache.ts`.
  */
-outRawResults?: ParseWorkerResult[]) => Promise<WorkerExtractedData | null>;
+outRawResults?: ParseWorkerResult[], exportedTypeMap?: ExportedTypeMap) => Promise<WorkerExtractedData>;