gitnexus 1.6.6-rc.99 → 1.6.6

package/dist/core/ingestion/field-extractors/typescript.js

@@ -70,17 +70,6 @@ export class TypeScriptFieldExtractor extends BaseFieldExtractor {
                 }
             }
         }
-        // Check for modifier node (tree-sitter typescript may group these)
-        const modifiers = node.childForFieldName('modifiers');
-        if (modifiers) {
-            for (let i = 0; i < modifiers.childCount; i++) {
-                const modifier = modifiers.child(i);
-                const modText = modifier?.text.trim();
-                if (modText && TypeScriptFieldExtractor.VISIBILITY_MODIFIERS.has(modText)) {
-                    return modText;
-                }
-            }
-        }
         // TypeScript class members are public by default
         return 'public';
     }
@@ -94,15 +83,6 @@ export class TypeScriptFieldExtractor extends BaseFieldExtractor {
                 return true;
             }
         }
-        const modifiers = node.childForFieldName('modifiers');
-        if (modifiers) {
-            for (let i = 0; i < modifiers.childCount; i++) {
-                const modifier = modifiers.child(i);
-                if (modifier && modifier.text === 'static') {
-                    return true;
-                }
-            }
-        }
         return false;
     }
     /**
@@ -115,15 +95,6 @@ export class TypeScriptFieldExtractor extends BaseFieldExtractor {
                 return true;
             }
         }
-        const modifiers = node.childForFieldName('modifiers');
-        if (modifiers) {
-            for (let i = 0; i < modifiers.childCount; i++) {
-                const modifier = modifiers.child(i);
-                if (modifier && modifier.text === 'readonly') {
-                    return true;
-                }
-            }
-        }
         return false;
     }
     /**

package/dist/core/ingestion/filesystem-walker.d.ts

@@ -1,7 +1,3 @@
-export interface FileEntry {
-    path: string;
-    content: string;
-}
 /** Lightweight entry — path + size from stat, no content in memory */
 export interface ScannedFile {
     path: string;
@@ -21,8 +17,3 @@ export declare const walkRepositoryPaths: (repoPath: string, onProgress?: (curre
  * Returns a Map for O(1) lookup. Silently skips files that fail to read.
  */
 export declare const readFileContents: (repoPath: string, relativePaths: string[]) => Promise<Map<string, string>>;
-/**
- * Legacy API — scans and reads everything into memory.
- * Used by sequential fallback path only.
- */
-export declare const walkRepository: (repoPath: string, onProgress?: (current: number, total: number, filePath: string) => void) => Promise<FileEntry[]>;

package/dist/core/ingestion/filesystem-walker.js

@@ -111,14 +111,3 @@ export const readFileContents = async (repoPath, relativePaths) => {
     }
     return contents;
 };
-/**
- * Legacy API — scans and reads everything into memory.
- * Used by sequential fallback path only.
- */
-export const walkRepository = async (repoPath, onProgress) => {
-    const scanned = await walkRepositoryPaths(repoPath, onProgress);
-    const contents = await readFileContents(repoPath, scanned.map((f) => f.path));
-    return scanned
-        .filter((f) => contents.has(f.path))
-        .map((f) => ({ path: f.path, content: contents.get(f.path) }));
-};

package/dist/core/ingestion/finalize-orchestrator.js

@@ -32,6 +32,8 @@
  * safely consult `model.scopes` without branching on presence.
  */
 import { buildDefIndex, buildMethodDispatchIndex, buildModuleScopeIndex, buildQualifiedNameIndex, buildScopeTree, finalize, } from '../../_shared/index.js';
+import { parseTruthyEnv } from './utils/env.js';
+import { TransitionalScopeTree } from '../../storage/scope-index-store.js';
 /**
  * Produce a fully materialized `ScopeResolutionIndexes` from the
  * workspace's per-file artifacts.
@@ -66,13 +68,19 @@ export function finalizeScopeModel(parsedFiles, options = {}) {
             allDefs.push(d);
         moduleEntries.push({ filePath: file.filePath, moduleScopeId: file.moduleScope });
     }
-    const scopeTree = buildScopeTree(allScopes);
+    // Out-of-core scope index: when enabled, build a TransitionalScopeTree
+    // (validated + fully resident now; sealed to disk by run.ts just before emit so
+    // the heavy Scope.bindings payload is reclaimed). Default off → the in-heap
+    // buildScopeTree result exactly, byte-identical.
+    const scopeTree = parseTruthyEnv(process.env.GITNEXUS_DISK_SCOPE_INDEX)
+        ? new TransitionalScopeTree(allScopes)
+        : buildScopeTree(allScopes);
     const defs = buildDefIndex(allDefs);
     const qualifiedNames = buildQualifiedNameIndex(allDefs);
     const moduleScopes = buildModuleScopeIndex(moduleEntries);
     // ── Step 3: MethodDispatchIndex. Today we lack per-language MRO
     // strategies wired into this orchestrator (that belongs with the
-    // HeritageMap bridge, a separate piece of work). Ship an EMPTY index
+    // MRO bridge, a separate piece of work). Ship an EMPTY index
     // so the bundle shape is consistent; the callbacks return `[]` for
     // every owner and `implementsOf` returns `[]`. Populating this
     // properly is tracked alongside the per-language provider hooks.
@@ -95,6 +103,10 @@ export function finalizeScopeModel(parsedFiles, options = {}) {
         // consumes the bundle. Most languages leave it empty.
         bindingAugmentations: new Map(),
         workspaceFqnBindings: new Map(),
+        workspaceTypeBindings: new Map(),
+        namespaceFqnBindings: new Map(),
+        namespaceTypeBindings: new Map(),
+        accessibleNamespacesByScope: new Map(),
         referenceSites: Object.freeze([...allReferenceSites]),
         sccs: finalizeOut.sccs,
         stats: finalizeOut.stats,

package/dist/core/ingestion/import-resolvers/configs/swift.d.ts

@@ -1,6 +1,27 @@
 /**
  * Swift import resolution config.
  * Package.swift target map strategy — no standard fallback (unresolved = external framework).
+ *
+ * ## Performance (anti-O(imports × files))
+ *
+ * The previous implementation rescanned the whole `normalizedFileList`
+ * on every import to collect the `.swift` files under the requested
+ * target's directory — O(imports × files) per run, the exact hot path
+ * fixed for Python in PR #1918. We now build a `target → files` index
+ * ONCE per run, memoized on the stable `allFileList` array reference
+ * (the same `ResolveCtx` — and therefore the same array — is passed to
+ * every strategy invocation, per `import-processor`'s build-once
+ * context). Lookup per import is then O(1).
+ *
+ * Behavior is preserved bit-for-bit: a file is attributed to a target
+ * iff its **forward-slash (backslash-normalized), case-sensitive** path
+ * starts with `<targetDir>/`, matching the old
+ * `normalizedFileList[i].startsWith(targetDir + '/')` comparison
+ * (`normalizedFileList` is only backslash→forward-slash normalized — NOT
+ * lowercased — so the match is case-sensitive); the returned paths are
+ * the original-case `allFileList` entries; and the per-target file ORDER
+ * follows `allFileList`, so the emitted `{ kind: 'files', files }` set and
+ * ordering are identical to the old scan.
  */
 import type { ImportResolutionConfig, ImportResolverStrategy } from '../types.js';
 /** Swift Package.swift target map resolution strategy. */

package/dist/core/ingestion/import-resolvers/configs/swift.js

@@ -1,24 +1,85 @@
 /**
  * Swift import resolution config.
  * Package.swift target map strategy — no standard fallback (unresolved = external framework).
+ *
+ * ## Performance (anti-O(imports × files))
+ *
+ * The previous implementation rescanned the whole `normalizedFileList`
+ * on every import to collect the `.swift` files under the requested
+ * target's directory — O(imports × files) per run, the exact hot path
+ * fixed for Python in PR #1918. We now build a `target → files` index
+ * ONCE per run, memoized on the stable `allFileList` array reference
+ * (the same `ResolveCtx` — and therefore the same array — is passed to
+ * every strategy invocation, per `import-processor`'s build-once
+ * context). Lookup per import is then O(1).
+ *
+ * Behavior is preserved bit-for-bit: a file is attributed to a target
+ * iff its **forward-slash (backslash-normalized), case-sensitive** path
+ * starts with `<targetDir>/`, matching the old
+ * `normalizedFileList[i].startsWith(targetDir + '/')` comparison
+ * (`normalizedFileList` is only backslash→forward-slash normalized — NOT
+ * lowercased — so the match is case-sensitive); the returned paths are
+ * the original-case `allFileList` entries; and the per-target file ORDER
+ * follows `allFileList`, so the emitted `{ kind: 'files', files }` set and
+ * ordering are identical to the old scan.
  */
 import { SupportedLanguages } from '../../../../_shared/index.js';
+/**
+ * Memoized on the `allFileList` array identity. `import-processor` builds
+ * the `ResolveCtx` once per run and threads the same object (and the same
+ * `allFileList`) through every strategy call, so the WeakMap is keyed on a
+ * stable reference and the index is built once — not once per import. A
+ * fresh run produces a fresh array → a fresh index, so cross-run staleness
+ * is impossible.
+ */
+const SWIFT_TARGET_INDEX_CACHE = new WeakMap();
+function getSwiftTargetIndex(ctx, targets) {
+    const key = ctx.allFileList;
+    const cached = SWIFT_TARGET_INDEX_CACHE.get(key);
+    if (cached !== undefined)
+        return cached;
+    // Pre-compute each target's directory prefix once (original case, to
+    // match the legacy comparison against the forward-slash-normalized,
+    // case-sensitive file list — see module docstring).
+    const targetPrefixes = [];
+    const byTarget = new Map();
+    for (const [name, dir] of targets) {
+        targetPrefixes.push({ name, prefix: dir + '/' });
+        byTarget.set(name, []);
+    }
+    // Single pass over the file list. `normalizedFileList` is forward-slash
+    // (backslash-normalized), case-sensitive, and index-aligned with
+    // `allFileList`; attribute the original-case path to every target whose
+    // prefix the normalized path starts with (a file under a nested target
+    // dir can legitimately belong to multiple configured targets — the
+    // legacy per-import scan would have returned it for each).
+    for (let i = 0; i < ctx.allFileList.length; i++) {
+        const norm = ctx.normalizedFileList[i];
+        if (!norm.endsWith('.swift'))
+            continue;
+        for (const { name, prefix } of targetPrefixes) {
+            if (norm.startsWith(prefix)) {
+                byTarget.get(name).push(ctx.allFileList[i]);
+            }
+        }
+    }
+    const index = { byTarget };
+    SWIFT_TARGET_INDEX_CACHE.set(key, index);
+    return index;
+}
 /** Swift Package.swift target map resolution strategy. */
 export const swiftPackageStrategy = (rawImportPath, _filePath, ctx) => {
     const swiftPackageConfig = ctx.configs.swiftPackageConfig;
     if (swiftPackageConfig) {
-        const targetDir = swiftPackageConfig.targets.get(rawImportPath);
-        if (targetDir) {
-            const dirPrefix = targetDir + '/';
-            const files = [];
-            for (let i = 0; i < ctx.normalizedFileList.length; i++) {
-                if (ctx.normalizedFileList[i].startsWith(dirPrefix) &&
-                    ctx.normalizedFileList[i].endsWith('.swift')) {
-                    files.push(ctx.allFileList[i]);
-                }
+        // Only the targets map is needed; build the index lazily so repos
+        // without a Package.swift config pay nothing.
+        if (swiftPackageConfig.targets.has(rawImportPath)) {
+            const index = getSwiftTargetIndex(ctx, swiftPackageConfig.targets);
+            const files = index.byTarget.get(rawImportPath);
+            if (files !== undefined && files.length > 0) {
+                // Copy so callers can't mutate the cached index bucket.
+                return { kind: 'files', files: [...files] };
             }
-            if (files.length > 0)
-                return { kind: 'files', files };
         }
     }
     return null; // External framework (Foundation, UIKit, etc.)

package/dist/core/ingestion/import-resolvers/python.d.ts

@@ -19,4 +19,4 @@
  *
  * Returns null to let the caller fall through to suffixResolve.
  */
-export declare function resolvePythonImportInternal(currentFile: string, importPath: string, allFiles: Set<string>): string | null;
+export declare function resolvePythonImportInternal(currentFile: string, importPath: string, allFiles: ReadonlySet<string>): string | null;

package/dist/core/ingestion/import-resolvers/standard.d.ts

@@ -17,8 +17,8 @@ export declare const RESOLVE_CACHE_CAP = 100000;
  * - TypeScript/JavaScript: rewrites tsconfig path aliases
  * - Rust: converts crate::/super::/self:: to relative paths
  *
- * Java wildcards and Go package imports are handled separately in processImports
- * because they resolve to multiple files.
+ * Java wildcards and Go package imports are handled by the scope-resolution
+ * phase because they resolve to multiple files.
  */
 export declare const resolveImportPath: (currentFile: string, importPath: string, allFiles: Set<string>, allFileList: string[], normalizedFileList: string[], resolveCache: Map<string, string | null>, language: SupportedLanguages, tsconfigPaths: TsconfigPaths | null, index?: SuffixIndex) => string | null;
 /**

package/dist/core/ingestion/import-resolvers/standard.js

@@ -16,8 +16,8 @@ export const RESOLVE_CACHE_CAP = 100_000;
  * - TypeScript/JavaScript: rewrites tsconfig path aliases
  * - Rust: converts crate::/super::/self:: to relative paths
  *
- * Java wildcards and Go package imports are handled separately in processImports
- * because they resolve to multiple files.
+ * Java wildcards and Go package imports are handled by the scope-resolution
+ * phase because they resolve to multiple files.
  */
 export const resolveImportPath = (currentFile, importPath, allFiles, allFileList, normalizedFileList, resolveCache, language, tsconfigPaths, index) => {
     const cacheKey = `${currentFile}::${importPath}`;
@@ -79,8 +79,8 @@ export const resolveImportPath = (currentFile, importPath, allFiles, allFileList
         else if (importPath.startsWith('{') && importPath.endsWith('}')) {
             // Top-level grouped imports: use {crate::a, crate::b}
             // Iterate each part and return the first that resolves. This function returns a single
-            // string, so callers that need ALL edges must intercept before reaching here (see the
-            // Rust grouped-import blocks in processImports / processImportsBatch). This fallback
+            // string, so callers that need ALL edges must intercept before reaching here (the
+            // scope-resolution phase handles Rust grouped-import blocks). This fallback
             // handles any path that reaches resolveImportPath directly.
             const inner = importPath.slice(1, -1);
             const parts = inner
@@ -128,7 +128,8 @@ export const resolveImportPath = (currentFile, importPath, allFiles, allFileList
         return cache(null);
     }
     // ---- Generic package/absolute import resolution (suffix matching) ----
-    // Java wildcards are handled in processImports, not here
+    // Java wildcards are handled by the scope-resolution phase, not here; this
+    // resolver returns null for `.*` so it never produces a single-file match.
     if (importPath.endsWith('.*')) {
         return cache(null);
     }

package/dist/core/ingestion/import-resolvers/utils.d.ts

@@ -1,6 +1,5 @@
 /**
- * Shared utilities for import resolution.
- * Extracted from import-processor.ts to reduce file size.
+ * Suffix-index helpers for import path resolution.
  */
 /** All file extensions to try during resolution */
 export declare const EXTENSIONS: string[];
@@ -8,7 +7,7 @@ export declare const EXTENSIONS: string[];
  * Try to match a path (with extensions) against the known file set.
  * Returns the matched file path or null.
  */
-export declare function tryResolveWithExtensions(basePath: string, allFiles: Set<string>): string | null;
+export declare function tryResolveWithExtensions(basePath: string, allFiles: ReadonlySet<string>): string | null;
 /**
  * Build a suffix index for O(1) endsWith lookups.
  * Maps every possible path suffix to its original file path.
@@ -26,8 +25,6 @@ export interface SuffixIndex {
     /** Get all files in a directory suffix */
     getFilesInDir(dirSuffix: string, extension: string): string[];
 }
-/** Sentinel index that returns no results. Used to release memory after import resolution. */
-export declare const EMPTY_INDEX: SuffixIndex;
 export declare function buildSuffixIndex(normalizedFileList: string[], allFileList: string[]): SuffixIndex;
 /**
  * Suffix-based resolution using index. O(1) per lookup instead of O(files).

package/dist/core/ingestion/import-resolvers/utils.js

@@ -1,6 +1,5 @@
 /**
- * Shared utilities for import resolution.
- * Extracted from import-processor.ts to reduce file size.
+ * Suffix-index helpers for import path resolution.
  */
 /** All file extensions to try during resolution */
 export const EXTENSIONS = [
@@ -63,13 +62,6 @@ export function tryResolveWithExtensions(basePath, allFiles) {
     }
     return null;
 }
-const FROZEN_EMPTY_ARRAY = Object.freeze([]);
-/** Sentinel index that returns no results. Used to release memory after import resolution. */
-export const EMPTY_INDEX = Object.freeze({
-    get: () => undefined,
-    getInsensitive: () => undefined,
-    getFilesInDir: () => FROZEN_EMPTY_ARRAY,
-});
 export function buildSuffixIndex(normalizedFileList, allFileList) {
     // Map: normalized suffix -> original file path
     const exactMap = new Map();

package/dist/core/ingestion/language-provider.d.ts

@@ -11,38 +11,17 @@
 import type { SupportedLanguages, MroStrategy, CaptureMatch, BindingRef, TypeRef, Scope, ScopeId, ScopeKind, ScopeTree, ParsedImport, ParsedTypeBinding, SymbolDefinition, Callsite, WorkspaceIndex } from '../../_shared/index.js';
 import type { LanguageTypeConfig } from './type-extractors/types.js';
 import type { CallRouter } from './call-routing.js';
-import type { CallExtractor, DispatchDecision, ImplicitReceiverOverride, ReceiverEnriched } from './call-types.js';
+import type { CallExtractor } from './call-types.js';
 import type { ClassExtractor } from './class-types.js';
 import type { ExportChecker } from './export-detection.js';
 import type { FieldExtractor } from './field-extractor.js';
-import type { HeritageExtractor } from './heritage-types.js';
 import type { MethodExtractor } from './method-types.js';
 import type { VariableExtractor } from './variable-types.js';
 import type { ImportResolverFn } from './import-resolvers/types.js';
-import type { NamedBindingExtractorFn } from './named-bindings/types.js';
 import type { SyntaxNode } from './utils/ast-helpers.js';
 import type { NodeLabel } from '../../_shared/index.js';
 /** Tree-sitter query captures: capture name → AST node (or undefined if not captured). */
 export type CaptureMap = Record<string, SyntaxNode | undefined>;
-/**
- * How a language handles imports — determines wildcard synthesis behavior.
- *
- * Import resolution is a graph-traversal policy with multiple distinct strategies,
- * analogous to MRO for method resolution. Each tag picks a strategy:
- *
- * | Tag                   | Mechanism                                      | Traversal           | Languages                                  |
- * |-----------------------|------------------------------------------------|---------------------|--------------------------------------------|
- * | `named`               | Per-symbol imports                             | None (use-site)     | JS/TS, Java, C#, Rust, PHP, Kotlin, Vue    |
- * | `wildcard-transitive` | Textual paste, symbols chain through files     | BFS closure         | C, C++ (future: Obj-C, Fortran, Nim)       |
- * | `wildcard-leaf`       | Whole public API, single hop                   | None (direct only)  | Go, Ruby, Swift, Dart                      |
- * | `namespace`           | Qualified handle; symbols resolved at call site| None at import      | Python                                     |
- * | `explicit-reexport`   | Opt-in per-symbol re-export (SCAFFOLD)         | Topological DAG     | (future: TS `export *`, Rust `pub use`)    |
- *
- * The `explicit-reexport` tag is a compile-time scaffold; no provider claims it yet.
- * It falls through to `wildcard-leaf` behavior in synthesis so today's TS/Rust
- * handling is unchanged. A future PR will implement the DAG walk for `export *`.
- */
-export type ImportSemantics = 'named' | 'wildcard-transitive' | 'wildcard-leaf' | 'namespace' | 'explicit-reexport';
 /** Configuration for AST-based framework detection patterns. */
 export interface AstFrameworkPatternConfig {
     framework: string;
@@ -115,26 +94,10 @@ interface LanguageProviderConfig {
     /** Call routing for languages that express imports/heritage as calls (e.g., Ruby).
      *  Default: no routing (all calls are normal call expressions). */
     readonly callRouter?: CallRouter;
-    /** Named binding extraction from import statements.
-     *  Default: undefined (language uses wildcard/whole-module imports). */
-    readonly namedBindingExtractor?: NamedBindingExtractorFn;
-    /** How this language handles imports. See `ImportSemantics` for the full taxonomy.
-     *  - 'named': per-symbol imports (JS/TS, Java, C#, Rust, PHP, Kotlin)
-     *  - 'wildcard-transitive': textual-include closure; imports chain through files (C, C++)
-     *  - 'wildcard-leaf': whole-module single-hop imports; no transitive chaining (Go, Ruby, Swift, Dart)
-     *  - 'namespace': qualified namespace imports, needs moduleAliasMap (Python)
-     *  - 'explicit-reexport': opt-in per-symbol re-export (scaffold; no provider uses yet)
-     *  Default: 'named'. */
-    readonly importSemantics?: ImportSemantics;
     /** Language-specific transformation of raw import path text before resolution.
      *  Called after sanitization. E.g., Kotlin appends wildcard suffixes.
      *  Default: undefined (no preprocessing). */
     readonly importPathPreprocessor?: (cleaned: string, importNode: SyntaxNode) => string;
-    /** Wire implicit inter-file imports for languages where all files in a module
-     *  see each other (e.g., Swift targets, C header inclusion units).
-     *  Called with only THIS language's files (pre-grouped by the processor).
-     *  Default: undefined (no implicit imports). */
-    readonly implicitImportWirer?: (languageFiles: string[], importMap: ReadonlyMap<string, ReadonlySet<string>>, addImportEdge: (src: string, target: string) => void, projectConfig: unknown) => void;
     /** Resolve a container node during enclosing-owner tree walks.
      *  Called when a CLASS_CONTAINER_TYPES node is found while walking up.
      *  - Return a different SyntaxNode to remap the container (e.g., Ruby
@@ -189,12 +152,6 @@ interface LanguageProviderConfig {
      *  (e.g., 'Method' for Kotlin), or defaultLabel to keep as-is.
      *  Default: undefined (standard label assignment). */
     readonly labelOverride?: (functionNode: SyntaxNode, defaultLabel: NodeLabel) => NodeLabel | null;
-    /** Default edge type when parent symbol is ambiguous (interface vs class).
-     *  Default: 'EXTENDS'. */
-    readonly heritageDefaultEdge?: 'EXTENDS' | 'IMPLEMENTS';
-    /** Regex to detect interface names by convention (e.g., /^I[A-Z]/ for C#/Java).
-     *  When matched, IMPLEMENTS edge is used instead of heritageDefaultEdge. */
-    readonly interfaceNamePattern?: RegExp;
     /** MRO strategy for multiple inheritance resolution.
      *  Default: 'first-wins'. */
     readonly mroStrategy?: MroStrategy;
@@ -220,13 +177,6 @@ interface LanguageProviderConfig {
      *  Uses the same provider-driven strategy pattern as method/field extraction so
      *  namespace/package/module rules stay language-specific. */
     readonly classExtractor?: ClassExtractor;
-    /** Heritage extractor for extracting extends/implements/trait-impl relationships
-     *  from tree-sitter @heritage.* captures and call-based heritage (e.g., Ruby
-     *  include/extend/prepend). Produced by createHeritageExtractor() — pass a
-     *  SupportedLanguages value for default behaviour or a full
-     *  HeritageExtractionConfig for languages with custom hooks (Go, Ruby).
-     *  All tree-sitter providers MUST supply this. */
-    readonly heritageExtractor?: HeritageExtractor;
     /** Extract a semantic description for a definition node (e.g., PHP Eloquent
      *  property arrays, relation method descriptions).
      *  Default: undefined (no description extraction). */
@@ -235,66 +185,6 @@ interface LanguageProviderConfig {
      *  When true, the worker extracts routes via the language's route extraction logic.
      *  Default: undefined (no route files). */
     readonly isRouteFile?: (filePath: string) => boolean;
-    /**
-     * DAG stage 3 hook: synthesize an implicit receiver when the call site omits one.
-     *
-     * Runs after shared inference (TypeEnv → constructor-map → class-as-receiver →
-     * mixed-chain). Return an `ImplicitReceiverOverride` to overlay all fields onto
-     * `ReceiverEnriched`; return null to keep current state and proceed to stage 4.
-     *
-     * Constraints: MUST return null when an explicit receiver is already set, at
-     * top-level scope, or for built-in methods. Do not mutate input params.
-     * `hint` is opaque to shared stages; consumed by this language's `selectDispatch`.
-     *
-     * Ruby example: bare `serialize` in `Account#call_serialize` →
-     * `{ callForm: 'member', receiverName: 'self', receiverTypeName: 'Account',
-     *    receiverSource: 'implicit-self', hint: 'instance' }`
-     *
-     * @see call-types.ts § ImplicitReceiverOverride
-     * @see selectDispatch (stage 4, reads the hint)
-     *
-     * Default: undefined (no implicit-receiver inference).
-     */
-    readonly inferImplicitReceiver?: (params: {
-        readonly calledName: string;
-        readonly callForm: 'free' | 'member' | 'constructor' | undefined;
-        readonly receiverName: string | undefined;
-        readonly receiverTypeName: string | undefined;
-        readonly callNode: SyntaxNode;
-        readonly filePath: string;
-    }) => ImplicitReceiverOverride | null;
-    /**
-     * DAG stage 4 hook: decide dispatch strategy (primary path, fallback, MRO view).
-     *
-     * Runs after stage 3. Return a `DispatchDecision` to override shared defaults;
-     * return null to use `defaultDispatchDecision` (constructor→`'constructor'`,
-     * member→`'owner-scoped'`, free→`'free'`). Most languages return null.
-     *
-     * The hook is responsible for its own gating. `ancestryView` only affects
-     * `'ruby-mixin'` strategy. Singleton-ancestry miss NEVER falls through to
-     * file-scoped fallback in stage 5 (enforced in resolveCallTarget).
-     *
-     * Ruby examples:
-     * - `receiverSource='implicit-self', hint='instance'` →
-     *   `{primary: 'owner-scoped', fallback: 'free-arity-narrowed', ancestryView: 'instance'}`
-     * - `receiverSource='class-as-receiver'` →
-     *   `{primary: 'owner-scoped', ancestryView: 'singleton'}` (miss null-routes)
-     * - `receiverSource='implicit-self', hint='singleton'` →
-     *   `{primary: 'owner-scoped', fallback: 'free-arity-narrowed', ancestryView: 'singleton'}`
-     *
-     * @see call-types.ts § DispatchDecision
-     * @see call-processor.ts § defaultDispatchDecision, resolveCallTarget
-     *
-     * Default: undefined (use `defaultDispatchDecision`).
-     */
-    readonly selectDispatch?: (params: {
-        readonly calledName: string;
-        readonly callForm: 'free' | 'member' | 'constructor' | undefined;
-        readonly receiverName: string | undefined;
-        readonly receiverTypeName: string | undefined;
-        readonly receiverSource: ReceiverEnriched['receiverSource'];
-        readonly hint: string | undefined;
-    }) => DispatchDecision | null;
     /** Built-in/stdlib names that should be filtered from the call graph for this language.
      *  Default: undefined (no language-specific filtering). */
     readonly builtInNames?: ReadonlySet<string>;
@@ -315,9 +205,8 @@ interface LanguageProviderConfig {
      * routing (scope / declaration / import / type-binding / reference)
      * lands on coherent records.
      *
-     * Required for any provider participating in scope-based resolution.
-     * Providers that have not yet migrated continue to run through the
-     * legacy DAG path (feature-flagged per `REGISTRY_PRIMARY_<LANG>`).
+     * Required for any provider participating in scope-based resolution
+     * (the sole resolution path).
      *
      * **Sync return.** Tree-sitter query execution and COBOL's regex
      * tagger are both synchronous; no current or foreseeable provider
@@ -325,7 +214,7 @@ interface LanguageProviderConfig {
      * `parse-worker.ts` (#920) invoke it inline in its already-sync
      * per-file loop without cascading `async` through the batch pipeline.
      *
-     * Default: undefined (language continues to use legacy DAG).
+     * Default: undefined (no scope-based captures emitted for this language).
      */
     readonly emitScopeCaptures?: (sourceText: string, filePath: string, 
     /**
@@ -338,7 +227,40 @@ interface LanguageProviderConfig {
      * Cache miss (parameter omitted or undefined) is always safe and
      * MUST trigger a fresh parse.
      */
-    cachedTree?: unknown) => readonly CaptureMatch[];
+    cachedTree?: unknown, 
+    /**
+     * Optional metadata about how `sourceText` was produced.
+     *
+     * Most providers ignore this and treat `sourceText` as full file content.
+     * Vue uses it to distinguish:
+     *   - `full-file`: full `.vue` SFC source
+     *   - `pre-extracted-script`: worker-preprocessed bare `<script>` content
+     *
+     * Default: `{ sourceKind: 'full-file' }`.
+     */
+    sourceMeta?: {
+        readonly sourceKind?: 'full-file' | 'pre-extracted-script';
+    }) => readonly CaptureMatch[];
+    /**
+     * Snapshot the capture-time side-channel state that this provider's
+     * `emitScopeCaptures` just populated for `filePath` into module-level maps,
+     * returning a plain JSON-serializable value (or `undefined` when there is
+     * nothing to carry).
+     *
+     * Called in the parse worker IMMEDIATELY after `emitScopeCaptures` runs for
+     * a file (see `parse-worker.ts`), and the result is stored on the produced
+     * `ParsedFile.captureSideChannel`. Scope-resolution on the main thread reuses
+     * that serialized `ParsedFile` and skips re-extraction (#1983), so this hook
+     * is how the worker-computed marks survive the worker→main boundary and the
+     * disk store WITHOUT a main-thread re-parse. The main thread restores them
+     * via the matching `ScopeResolver.applyCaptureSideChannel` hook.
+     *
+     * MUST return plain data (objects / arrays / primitives) so it round-trips
+     * through `JSON.stringify` + the parsedfile-store interning reviver.
+     *
+     * Default: undefined (provider has no capture-time module-level side effects).
+     */
+    readonly collectCaptureSideChannel?: (filePath: string) => unknown;
     /**
      * Interpret a raw `@import.statement` capture group into a `ParsedImport`.
      * The central finalize algorithm resolves `ParsedImport.targetRaw` to a
@@ -482,9 +404,7 @@ interface LanguageProviderConfig {
     readonly arityCompatibility?: (def: SymbolDefinition, callsite: Callsite) => 'compatible' | 'unknown' | 'incompatible';
 }
 /** Runtime type — same as LanguageProviderConfig but with defaults guaranteed present. */
-export interface LanguageProvider extends Omit<LanguageProviderConfig, 'importSemantics' | 'heritageDefaultEdge' | 'mroStrategy'> {
-    readonly importSemantics: ImportSemantics;
-    readonly heritageDefaultEdge: 'EXTENDS' | 'IMPLEMENTS';
+export interface LanguageProvider extends Omit<LanguageProviderConfig, 'mroStrategy'> {
     readonly mroStrategy: MroStrategy;
     /** Check if a name is a built-in/stdlib function that should be filtered from the call graph. */
     readonly isBuiltInName: (name: string) => boolean;

package/dist/core/ingestion/language-provider.js

@@ -9,8 +9,6 @@
  * so adding a language to the enum without creating a provider is a compiler error.
  */
 const DEFAULTS = {
-    importSemantics: 'named',
-    heritageDefaultEdge: 'EXTENDS',
     mroStrategy: 'first-wins',
 };
 /** Define a language provider — required fields must be supplied, optional fields get sensible defaults. */