cgraphx 2.0.1 → 2.0.3

package/dist/core/code/engine/core/ingestion/scope-resolution/pipeline/run.js

@@ -0,0 +1,632 @@
+"use strict";
+/**
+ * `runScopeResolution` — generic registry-primary resolution
+ * orchestrator.
+ *
+ *     ParsedFile[]  (one per file via `extractParsedFile`)
+ *        │  finalizeScopeModel(  + provider hooks adapted to FinalizeHooks)
+ *        ▼
+ *     ScopeResolutionIndexes
+ *        │  resolveReferenceSites
+ *        ▼
+ *     ReferenceIndex
+ *        │  emitReceiverBoundCalls (FIRST — see Contract Invariant I1)
+ *        │  emitFreeCallFallback   (THEN)
+ *        │  emitReferencesViaLookup (LAST — uses handledSites)
+ *        │  emitImportEdges
+ *        ▼
+ *     KnowledgeGraph
+ *
+ * Per-language entry points (e.g. `runPythonScopeResolution` in
+ * `languages/python/scope-resolver.ts`) construct an `ScopeResolver` and
+ * delegate here.
+ *
+ * Plan: `docs/plans/2026-04-20-001-refactor-emit-pipeline-generalization-plan.md`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runScopeResolution = runScopeResolution;
+const utils_js_1 = require("../../../../lib/utils.js");
+const owned_members_lookup_js_1 = require("../../model/owned-members-lookup.js");
+const reconcile_ownership_js_1 = require("./reconcile-ownership.js");
+const validate_bindings_immutability_js_1 = require("./validate-bindings-immutability.js");
+const scope_extractor_bridge_js_1 = require("../../scope-extractor-bridge.js");
+const finalize_orchestrator_js_1 = require("../../finalize-orchestrator.js");
+const resolve_references_js_1 = require("../../resolve-references.js");
+const node_lookup_js_1 = require("../graph-bridge/node-lookup.js");
+const ids_js_1 = require("../graph-bridge/ids.js");
+const method_dispatch_js_1 = require("../graph-bridge/method-dispatch.js");
+const imported_return_types_js_1 = require("../passes/imported-return-types.js");
+const receiver_bound_calls_js_1 = require("../passes/receiver-bound-calls.js");
+const free_call_fallback_js_1 = require("../passes/free-call-fallback.js");
+const property_dispatch_js_1 = require("../passes/property-dispatch.js");
+const references_to_edges_js_1 = require("../graph-bridge/references-to-edges.js");
+const callee_id_sink_js_1 = require("../graph-bridge/callee-id-sink.js");
+const imports_to_edges_js_1 = require("../graph-bridge/imports-to-edges.js");
+const callable_value_flow_js_1 = require("../passes/callable-value-flow.js");
+const walkers_js_1 = require("../scope/walkers.js");
+const workspace_index_js_1 = require("../workspace-index.js");
+const heap_probe_js_1 = require("../../utils/heap-probe.js");
+const env_js_1 = require("../../utils/env.js");
+const scope_index_store_js_1 = require("../../../../storage/scope-index-store.js");
+const parsedfile_store_js_1 = require("../../../../storage/parsedfile-store.js");
+const logger_js_1 = require("../../../logger.js");
+/**
+ * Emit one class-owned inheritance edge directly (the inheritance pre-pass is
+ * the authoritative emitter — see `preEmitInheritanceEdges`). Encapsulates the
+ * dual dedup contract so the two sets' joint semantics live in one place:
+ *   - `existing` — coarse per-`(caller, target, type)` gate, seeded from the
+ *     graph (so this pass is a no-op when the legacy path already emitted it).
+ *   - `seen` — per-site key shared with the generic edge bridge so the two
+ *     passes never double-emit the same resolution.
+ * The `dedupKey` and `rel:` id shape match `tryEmitEdge` exactly, so graph
+ * output stays byte-identical. The caller is the enclosing class (NOT the
+ * method/constructor `resolveCallerGraphId` would prefer — that broke MRO for
+ * C# 12 primary constructors, #1951); the edge type is pre-discriminated.
+ */
+function emitInheritanceEdgeDirect(graph, seen, existing, callerGraphId, targetGraphId, edgeType, site) {
+    const edgeKey = `${edgeType}:${callerGraphId}->${targetGraphId}`;
+    const dedupKey = `${edgeKey}:${site.atRange.startLine}:${site.atRange.startCol}`;
+    if (existing.has(edgeKey) || seen.has(dedupKey))
+        return;
+    seen.add(dedupKey);
+    existing.add(edgeKey);
+    graph.addRelationship({
+        id: `rel:${dedupKey}`,
+        sourceId: callerGraphId,
+        targetId: targetGraphId,
+        type: edgeType,
+        confidence: 0.85,
+        reason: 'scope-resolution: inherits',
+    });
+}
+/**
+ * Resolve inheritance reference sites early and pre-emit their EXTENDS edges
+ * before MRO construction. This lets template-base captures contribute to the
+ * graph in time for `buildMro`, while `handledSites` prevents the generic
+ * reference-edge bridge from re-emitting the same sites later.
+ *
+ * @returns Site keys to seed the downstream handled-site skip set.
+ */
+function preEmitInheritanceEdges(graph, scopes, nodeLookup) {
+    const handledSites = new Set();
+    const seen = new Set();
+    // Tracks inheritance edges emitted during this pass so the structural
+    // interface-implementation pass (emitDetectedInterfaceImplementations) and
+    // repeated `inherits` sites don't double-emit. Starts empty: this pre-pass is
+    // the authoritative inheritance emitter — no EXTENDS/IMPLEMENTS edges exist in
+    // the graph before it runs (the legacy heritage path was removed in #942).
+    const existing = new Set();
+    for (const site of scopes.referenceSites) {
+        if (site.kind !== 'inherits')
+            continue;
+        const scope = scopes.scopeTree.getScope(site.inScope);
+        const siteKey = scope?.filePath !== undefined
+            ? `${scope.filePath}:${site.atRange.startLine}:${site.atRange.startCol}`
+            : undefined;
+        if (siteKey !== undefined) {
+            // Intentionally suppress every `inherits` site from the generic
+            // reference bridge, even when this pre-pass can't emit an EXTENDS
+            // edge. The shared bridge resolves the source via
+            // `resolveCallerGraphId`, which can degrade class-heritage sites into
+            // method-owned EXTENDS edges once methods exist on the class. This
+            // pre-pass is the authoritative inheritance emitter and pins the source
+            // to the enclosing class (via the `callerGraphId` override below), so
+            // suppression keeps `buildMro` and the final graph class-owned.
+            handledSites.add(siteKey);
+        }
+        // Resolve the deriving (caller) class first and reuse it as the enclosing
+        // context for qualified-base resolution — avoids a second findEnclosingClassDef
+        // walk per qualified site (#1982 perf). Both need the same enclosing class.
+        const callerClass = (0, walkers_js_1.findEnclosingClassDef)(site.inScope, scopes);
+        if (callerClass === undefined)
+            continue;
+        const targetDef = (0, walkers_js_1.resolveInheritanceBaseInScope)(site.inScope, site.name, scopes, site.rawQualifiedName, callerClass);
+        if (targetDef === undefined)
+            continue;
+        const callerGraphId = (0, ids_js_1.resolveDefGraphId)(callerClass.filePath, callerClass, nodeLookup);
+        const targetGraphId = (0, ids_js_1.resolveDefGraphId)(targetDef.filePath, targetDef, nodeLookup);
+        if (callerGraphId === undefined || targetGraphId === undefined)
+            continue;
+        // Discriminate EXTENDS vs IMPLEMENTS by the resolved target's symbol kind:
+        // conforming to an interface OR mixing in a trait/protocol is IMPLEMENTS,
+        // deriving from a class-like is EXTENDS. The discriminator is purely
+        // symbol-kind-driven (no language is named here, per AGENTS.md): a base that
+        // resolves to neither an Interface nor a Trait symbol always takes the
+        // EXTENDS branch, so such languages are unchanged.
+        const edgeType = targetDef.type === 'Interface' || targetDef.type === 'Trait' ? 'IMPLEMENTS' : 'EXTENDS';
+        emitInheritanceEdgeDirect(graph, seen, existing, callerGraphId, targetGraphId, edgeType, site);
+    }
+    return handledSites;
+}
+/**
+ * Emit language-inferred structural interface implementations before MRO and
+ * interface dispatch are built. Languages such as Go do not declare
+ * `implements` explicitly, so their resolver can infer defId-level interface
+ * satisfaction from parsed files and this bridge converts those defIds to
+ * graph node ids.
+ *
+ * Existing explicit IMPLEMENTS edges win: the local `existing` set prevents
+ * duplicate structural edges and keeps this hook language-neutral. The reason
+ * string carries the provider language (`go-structural-implements`) so callers
+ * can distinguish inferred edges from source-declared heritage.
+ */
+function emitDetectedInterfaceImplementations(graph, parsedFiles, nodeLookup, provider, indexes, model) {
+    if (provider.detectInterfaceImplementations === undefined)
+        return 0;
+    const graphIdByDefId = new Map();
+    for (const parsed of parsedFiles) {
+        for (const def of parsed.localDefs) {
+            if (def.type !== 'Class' && def.type !== 'Struct' && def.type !== 'Interface')
+                continue;
+            const graphId = (0, ids_js_1.resolveDefGraphId)(parsed.filePath, def, nodeLookup);
+            if (graphId !== undefined)
+                graphIdByDefId.set(def.nodeId, graphId);
+        }
+    }
+    const existing = new Set();
+    for (const rel of graph.iterRelationshipsByType('IMPLEMENTS')) {
+        existing.add(`${rel.sourceId}->${rel.targetId}`);
+    }
+    let emitted = 0;
+    const detected = provider.detectInterfaceImplementations(parsedFiles, indexes, model);
+    for (const [interfaceDefId, implementorDefIds] of detected) {
+        const targetId = graphIdByDefId.get(interfaceDefId);
+        if (targetId === undefined)
+            continue;
+        for (const implementor of implementorDefIds) {
+            const sourceId = graphIdByDefId.get(implementor.structDefId);
+            if (sourceId === undefined)
+                continue;
+            const edgeKey = `${sourceId}->${targetId}`;
+            if (existing.has(edgeKey))
+                continue;
+            existing.add(edgeKey);
+            graph.addRelationship({
+                id: (0, utils_js_1.generateId)('IMPLEMENTS', edgeKey),
+                sourceId,
+                targetId,
+                type: 'IMPLEMENTS',
+                confidence: 0.85,
+                // The receiver form rides in `reason` because relationships carry no
+                // arbitrary properties — adding one would change the relation DDL and
+                // move SCHEMA_FINGERPRINT, forcing a full re-analyze for a fact that a
+                // string already expresses. `-pointer` means ONLY the pointer type
+                // implements: `var x I = T{}` is invalid, `var x I = &T{}` is fine.
+                // The unsuffixed form is unchanged from before, so a consumer matching
+                // the old string keeps seeing exactly the value-form implementors.
+                reason: implementor.receiverForm === 'pointer'
+                    ? `${provider.language}-structural-implements-pointer`
+                    : `${provider.language}-structural-implements`,
+            });
+            emitted++;
+        }
+    }
+    return emitted;
+}
+function runScopeResolution(input, provider) {
+    const { graph, files } = input;
+    const callableFlowOnly = provider.scopeResolutionEdgeMode === 'callable-flow-only';
+    const onWarn = input.onWarn ?? (() => { });
+    const resolutionOutcomes = [];
+    const recordResolutionOutcome = (outcome) => {
+        resolutionOutcomes.push(outcome);
+        input.recordResolutionOutcome?.(outcome);
+    };
+    const PROF = process.env.PROF_SCOPE_RESOLUTION === '1';
+    const tStart = PROF ? process.hrtime.bigint() : 0n;
+    let fileContents;
+    const getFileContents = () => {
+        if (fileContents === undefined) {
+            fileContents = new Map();
+            for (const f of files)
+                fileContents.set(f.path, f.content);
+        }
+        return fileContents;
+    };
+    // ── Phase 1: extract each file → ParsedFile ────────────────────────────
+    const parsedFiles = [];
+    let filesSkipped = 0;
+    const treeCache = input.treeCache;
+    const preExtracted = input.preExtractedParsedFiles;
+    let preExtractedHits = 0;
+    const progressInterval = files.length > 0 ? Math.max(1, Math.floor(files.length / 50)) : 1;
+    input.onProgress?.('extracting', 0, files.length);
+    (0, heap_probe_js_1.logHeapProbe)('sr-extract-start', `lang=${provider.language} files=${files.length}`);
+    for (let fileIdx = 0; fileIdx < files.length; fileIdx++) {
+        const file = files[fileIdx];
+        let parsed;
+        // Fast path: a worker (during the parse phase) already produced a
+        // ParsedFile for this file via `extractParsedFile`. Reuse it
+        // directly — skips a tree-sitter re-parse on the main thread.
+        let reusedPreExtracted = false;
+        if (preExtracted !== undefined) {
+            parsed = preExtracted.get(file.path);
+            if (parsed !== undefined) {
+                preExtractedHits++;
+                reusedPreExtracted = true;
+            }
+        }
+        if (parsed === undefined) {
+            const cachedTree = treeCache?.get(file.path);
+            parsed = (0, scope_extractor_bridge_js_1.extractParsedFile)(provider.languageProvider, file.content, file.path, onWarn, cachedTree);
+            if (parsed === undefined) {
+                filesSkipped++;
+                continue;
+            }
+        }
+        // Worker-boundary restore: a pre-extracted ParsedFile was produced by
+        // `extractParsedFile` running INSIDE a worker, so any capture-time
+        // module-level side-channel state (`emitScopeCaptures` side effects that
+        // are NOT serialized onto the ParsedFile's scopes/defs — C++ ADL/namespace
+        // marks) was populated in the worker process and is missing here. The
+        // worker stashed a plain-data snapshot on `parsed.captureSideChannel` (via
+        // `collectCaptureSideChannel`); write it back into the module maps now,
+        // BEFORE populateOwners consumes the resolved ranges. NO re-parse — that is
+        // the #1983 fix. The fresh-extract leg above already populated those marks
+        // in this process, so it skips the restore. See
+        // `ScopeResolver.applyCaptureSideChannel`.
+        if (reusedPreExtracted && provider.applyCaptureSideChannel !== undefined) {
+            provider.applyCaptureSideChannel(parsed);
+        }
+        provider.populateOwners(parsed);
+        parsedFiles.push(parsed);
+        if ((fileIdx + 1) % progressInterval === 0 || fileIdx === files.length - 1) {
+            input.onProgress?.('extracting', fileIdx + 1, files.length);
+            (0, heap_probe_js_1.logHeapProbe)('sr-extract-progress', `lang=${provider.language} idx=${fileIdx + 1}/${files.length} parsedFiles=${parsedFiles.length} preExtractedHits=${preExtractedHits}`);
+        }
+    }
+    if (PROF && preExtracted !== undefined) {
+        logger_js_1.logger.warn(`[scope-resolution prof] pre-extracted hits: ${preExtractedHits}/${files.length}`);
+    }
+    (0, heap_probe_js_1.logHeapProbe)('sr-extract-end', `lang=${provider.language} parsedFiles=${parsedFiles.length} preExtractedHits=${preExtractedHits} skipped=${filesSkipped}`);
+    provider.populateWorkspaceOwners?.(parsedFiles, { fileContents: getFileContents() });
+    // A callable-flow-only provider has no reason to build the whole-graph
+    // lookup or finalize ordinary references when none of its files emitted a
+    // callable fact. This keeps the opt-in path proportional to source scanning
+    // for repositories that use the provider but no first-class callables.
+    if (callableFlowOnly &&
+        !parsedFiles.some((parsed) => (parsed.callableFlowSites?.length ?? 0) > 0)) {
+        return {
+            filesProcessed: parsedFiles.length,
+            filesSkipped,
+            importsEmitted: 0,
+            resolve: { sitesProcessed: 0, referencesEmitted: 0, unresolved: 0 },
+            referenceEdgesEmitted: 0,
+            referenceSkipped: 0,
+            propertyDispatchSkippedKeys: 0,
+            resolutionOutcomes,
+        };
+    }
+    // Reconcile scope-resolution's ownership view into the SemanticModel.
+    // See `reconcile-ownership.ts` for the full rationale (Contract
+    // Invariant I9). Debug-mode validator runs immediately after to
+    // catch drift between `parsed.localDefs` and the registries.
+    //
+    // PHASE BOUNDARY: `input.model` is `MutableSemanticModel` up to this
+    // point (write phase: reconciliation). After this line no further
+    // writes are expected — downstream passes consume `readonlyModel`
+    // (narrowed to `SemanticModel`) so accidental writes would surface
+    // as type errors.
+    (0, reconcile_ownership_js_1.reconcileOwnership)(parsedFiles, input.model);
+    (0, reconcile_ownership_js_1.validateOwnershipParity)(parsedFiles, input.model, onWarn);
+    const readonlyModel = input.model;
+    if (parsedFiles.length === 0) {
+        return {
+            filesProcessed: 0,
+            filesSkipped,
+            importsEmitted: 0,
+            resolve: { sitesProcessed: 0, referencesEmitted: 0, unresolved: 0 },
+            referenceEdgesEmitted: 0,
+            referenceSkipped: 0,
+            propertyDispatchSkippedKeys: 0,
+            resolutionOutcomes,
+        };
+    }
+    const tExtract = PROF ? process.hrtime.bigint() : 0n;
+    // ── Phase 2: finalize → ScopeResolutionIndexes ─────────────────────────
+    input.onProgress?.('analyzing types', files.length, files.length);
+    const allFilePaths = new Set(parsedFiles.map((f) => f.filePath));
+    (0, heap_probe_js_1.logHeapProbe)('sr-pre-nodeLookup', `lang=${provider.language}`);
+    const nodeLookup = input.prebuiltNodeLookup ?? (0, node_lookup_js_1.buildGraphNodeLookup)(graph);
+    (0, heap_probe_js_1.logHeapProbe)('sr-post-nodeLookup', `lang=${provider.language}`);
+    const resolutionConfig = input.resolutionConfig;
+    const finalized = (0, finalize_orchestrator_js_1.finalizeScopeModel)(parsedFiles, {
+        hooks: {
+            resolveImportTarget: (targetRaw, fromFile, _workspaceIndex, parsedImport) => provider.resolveImportTarget(targetRaw, fromFile, allFilePaths, resolutionConfig, {
+                parsedFiles,
+                parsedImport,
+            }),
+            isNamespaceImport: (parsedImport, targetFile, fromFile) => provider.isNamespaceImport?.(parsedImport, targetFile, fromFile) ?? false,
+            expandsWildcardTo: (targetModuleScope) => provider.expandsWildcardTo?.(targetModuleScope, parsedFiles) ?? [],
+            mergeBindings: (existing, incoming, scopeId) => provider.mergeBindings(existing, incoming, scopeId),
+        },
+    });
+    (0, heap_probe_js_1.logHeapProbe)('sr-post-finalize', `lang=${provider.language}`);
+    const preEmittedInheritanceSites = callableFlowOnly
+        ? new Set()
+        : preEmitInheritanceEdges(graph, finalized, nodeLookup);
+    // Call-based heritage hook (e.g., Ruby include/extend/prepend) — emits
+    // IMPLEMENTS edges that `preEmitInheritanceEdges` cannot produce because
+    // the heritage declarations are syntactic method calls, not grammar-level
+    // heritage clauses. Must run BEFORE `buildMro` so MRO construction sees
+    // the freshly-emitted IMPLEMENTS edges.
+    if (!callableFlowOnly) {
+        provider.emitHeritageEdges?.(graph, parsedFiles, nodeLookup, finalized);
+    }
+    // Implicit IMPORTS-edge hook — for languages whose files have compiler-
+    // implicit cross-file visibility (no syntactic import statement). The
+    // finalized-ImportEdge pipeline (`emitImportEdges`) cannot produce these
+    // because there is no `ImportEdge` to materialize. Idempotent.
+    if (!callableFlowOnly) {
+        provider.emitImplicitImportEdges?.(graph, parsedFiles, nodeLookup, resolutionConfig);
+    }
+    // Rebuild the node lookup after heritage-edge emission. Languages like
+    // Ruby create Property graph nodes inside `emitHeritageEdges`; those
+    // nodes must be visible to downstream passes (`emitReceiverBoundCalls`
+    // resolves write-access targets via `resolveDefGraphId` which consults
+    // `nodeLookup`). Without this rebuild, Property nodes added by the
+    // heritage hook are invisible and ACCESSES edges silently fail to emit.
+    const postHeritageNodeLookup = !callableFlowOnly && provider.emitHeritageEdges !== undefined
+        ? (0, node_lookup_js_1.buildGraphNodeLookup)(graph)
+        : nodeLookup;
+    if (!callableFlowOnly) {
+        emitDetectedInterfaceImplementations(graph, parsedFiles, postHeritageNodeLookup, provider, finalized, readonlyModel);
+    }
+    const mroByClassDefId = provider.buildMro(graph, parsedFiles, postHeritageNodeLookup);
+    const extendsOnlyMroByClassDefId = provider.buildExtendsOnlyMro?.(graph, parsedFiles, postHeritageNodeLookup);
+    // Replace the empty MethodDispatchIndex that finalizeScopeModel
+    // builds by design with the populated one derived from the
+    // language's MRO. Spread produces a fresh `ScopeResolutionIndexes`
+    // instead of mutating the finalized result through an `as` cast —
+    // downstream passes get an object whose readonly guarantees match
+    // the type system.
+    const indexes = {
+        ...finalized,
+        methodDispatch: (0, method_dispatch_js_1.buildPopulatedMethodDispatch)(mroByClassDefId, extendsOnlyMroByClassDefId),
+    };
+    // Build the workspace resolution index ONCE — scope-valued lookups
+    // (`classScopeByDefId`, `moduleScopeByFile`) that `SemanticModel`
+    // cannot carry. Must run AFTER `populateOwners` (so owned defs are
+    // attributed correctly) and AFTER finalize (so module-scope
+    // bindings are available).
+    // Pass the scopeTree so the index's class/module Scope lookups are id-backed
+    // views that delegate to it (out-of-core scope index) — the index pins no Scope objects, so the
+    // disk seal can reclaim them. Byte-identical: the view returns the same Scope
+    // the resident tree holds (or a value-identical revived one in disk mode).
+    const workspaceIndex = (0, workspace_index_js_1.buildWorkspaceResolutionIndex)(parsedFiles, indexes.scopeTree);
+    (0, heap_probe_js_1.logHeapProbe)('sr-post-workspaceIndex', `lang=${provider.language}`);
+    // Cross-file implicit-namespace visibility (C#). Must run before
+    // propagateImportedReturnTypes so the latter pass sees siblings'
+    // class bindings when chasing return-type chains across files.
+    // The hook writes to `bindingAugmentations` only; finalized
+    // `indexes.bindings` remains immutable post-finalize (I8).
+    if (provider.populateNamespaceSiblings !== undefined) {
+        provider.populateNamespaceSiblings(parsedFiles, indexes, {
+            fileContents: getFileContents(),
+            treeCache,
+            resolutionConfig,
+        });
+    }
+    const tFinalize = PROF ? process.hrtime.bigint() : 0n;
+    // Cross-package namespace typeBinding mirroring. Runs before
+    // propagateImportedReturnTypes so the SCC-ordered pass sees the
+    // mirrored bindings.
+    if (provider.mirrorNamespaceTypeBindings !== undefined) {
+        provider.mirrorNamespaceTypeBindings(parsedFiles, indexes, workspaceIndex, resolutionConfig);
+    }
+    // Cross-file return-type propagation (Contract Invariant I3 timing:
+    // after finalize, before resolve). Split-timed separately so the
+    // SCC-ordered pass's cost is observable (PR #1050 made this O(files)
+    // with chain-follow per importer; quadratic regressions show up
+    // here, not in finalize).
+    if (provider.propagatesReturnTypesAcrossImports !== false) {
+        (0, imported_return_types_js_1.propagateImportedReturnTypes)(parsedFiles, indexes, workspaceIndex);
+    }
+    const tRangeBindStart = PROF ? process.hrtime.bigint() : 0n;
+    if (provider.populateRangeBindings !== undefined) {
+        provider.populateRangeBindings(parsedFiles, indexes, {
+            fileContents: getFileContents(),
+            treeCache,
+        });
+    }
+    const tPropagate = PROF ? process.hrtime.bigint() : 0n;
+    // Opt-in I8 invariant guard. Runs once after all post-finalize hooks
+    // (`populateNamespaceSiblings`, `propagateImportedReturnTypes`) have
+    // had a chance to drift, so a single sweep covers the full
+    // post-finalize surface visible to `resolveReferenceSites`. No-op in
+    // default CLI runs; enabled by NODE_ENV=development or
+    // VALIDATE_SEMANTIC_MODEL=1.
+    (0, validate_bindings_immutability_js_1.validateBindingsImmutability)(indexes, onWarn);
+    // ── Phase 3: resolve references via Registry.lookup ────────────────────
+    input.onProgress?.('resolving references', files.length, files.length);
+    const registryProviders = {
+        arityCompatibility: provider.arityCompatibility,
+    };
+    const { referenceIndex, stats: resolveStats } = (0, resolve_references_js_1.resolveReferenceSites)({
+        scopes: indexes,
+        providers: registryProviders,
+        ownedMembersByOwner: (ownerDefId, memberName) => (0, owned_members_lookup_js_1.lookupOwnedMembersByOwner)(readonlyModel, ownerDefId, memberName),
+    });
+    const tResolve = PROF ? process.hrtime.bigint() : 0n;
+    (0, heap_probe_js_1.logHeapProbe)('sr-post-resolve', `lang=${provider.language}`);
+    // ── Out-of-core scope seal boundary ─────────────────────────────────────
+    // Pass-A (finalize + propagate + resolve) is done; all whole-language reads
+    // of `Scope.bindings` are behind us. Emit reaches scopes ONLY via
+    // `scopeTree.getScope` (a point lookup), so seal the TransitionalScopeTree to
+    // disk now and drop the resident scopes. The scopes are pinned from THREE
+    // sides: (1) the model's frozen `scopeTree` — released by `seal()` nulling its
+    // resident backing from the inside; (2) `input.preExtractedParsedFiles` (held
+    // by the caller for its own post-run release) — released here since run.ts is
+    // its last reader after extract; (3) this function's `parsedFiles` — replaced
+    // by a scope-stripped copy that keeps only what emit reads (referenceSites /
+    // filePath / localDefs). All three released → the heavy payload is collectible.
+    let emitParsedFiles = parsedFiles;
+    if (input.scopeIndexStorePath !== undefined &&
+        (0, env_js_1.parseTruthyEnv)(process.env.CGRAPH_DISK_SCOPE_INDEX) &&
+        indexes.scopeTree instanceof scope_index_store_js_1.TransitionalScopeTree) {
+        (0, heap_probe_js_1.logHeapProbe)('sr-seal-pre', `lang=${provider.language}`);
+        indexes.scopeTree.seal(input.scopeIndexStorePath);
+        emitParsedFiles = parsedFiles.map((p) => ({ ...p, scopes: [] }));
+        parsedFiles.length = 0;
+        if (preExtracted !== undefined)
+            preExtracted.clear();
+        (0, parsedfile_store_js_1.forceGc)();
+        (0, heap_probe_js_1.logHeapProbe)('sr-seal-post', `lang=${provider.language}`);
+    }
+    // ── Phase 4: emit graph edges (LOAD-BEARING ORDER — see I1) ────────────
+    input.onProgress?.('linking symbols', files.length, files.length);
+    const handledSites = new Set(preEmittedInheritanceSites);
+    const deferredIndirectSites = (0, callable_value_flow_js_1.collectDeferredIndirectSites)(emitParsedFiles, indexes);
+    const callableArgumentSites = new Set();
+    if (deferredIndirectSites.size > 0) {
+        for (const parsed of emitParsedFiles) {
+            for (const site of parsed.callableFlowSites ?? []) {
+                if (site.kind === 'argument') {
+                    callableArgumentSites.add((0, callable_value_flow_js_1.callableFlowSiteKey)(parsed.filePath, site.callSite));
+                }
+            }
+        }
+    }
+    // Resolved-callee-id accumulator (#2227 U2 + callable-value-flow). Created
+    // when indirect-call facts need direct targets for actual→formal propagation.
+    // Populated below at every CALLS emit path before dedup.
+    const calleeIdAccumulator = deferredIndirectSites.size > 0
+        ? (0, callee_id_sink_js_1.createCalleeIdAccumulator)((filePath, line, col) => callableArgumentSites.has(`${filePath}:${line}:${col}`))
+        : undefined;
+    const receiverBound = callableFlowOnly
+        ? {
+            emitted: 0,
+            dispatchFanoutSkipped: 0,
+            dispatchFanoutSkippedNames: [],
+        }
+        : (0, receiver_bound_calls_js_1.emitReceiverBoundCalls)(graph, indexes, emitParsedFiles, postHeritageNodeLookup, handledSites, provider, workspaceIndex, readonlyModel, {
+            recordResolutionOutcome,
+            calleeIdSink: calleeIdAccumulator,
+            // The pass's only source of positive EXTERNAL evidence for a dropped
+            // receiver (`console.log`, `fetch(...)`). Same hook, same spelling as
+            // the `emitFreeCallFallback` wiring below.
+            isBuiltInName: provider.languageProvider.isBuiltInName,
+        });
+    const receiverExtras = receiverBound.emitted;
+    if (receiverBound.dispatchFanoutSkipped > 0) {
+        // Never drop dispatch coverage silently (#2829) — same contract as the
+        // property-dispatch cap below. An interface member over the cap loses real
+        // implementors, so `impact()` on those implementations under-reports; an
+        // operator has to be able to see WHICH member lost them.
+        logger_js_1.logger.warn({
+            lang: provider.language,
+            dispatchFanoutSkipped: receiverBound.dispatchFanoutSkipped,
+            dispatchFanoutSkippedNames: receiverBound.dispatchFanoutSkippedNames,
+            fanoutCap: receiver_bound_calls_js_1.MAX_INTERFACE_DISPATCH_FANOUT,
+        }, 'interface-dispatch: members over the fan-out cap dropped implementors (their CALLS edges were not emitted)');
+    }
+    const unresolvedReceiverExtras = !callableFlowOnly && provider.emitUnresolvedReceiverEdges !== undefined
+        ? provider.emitUnresolvedReceiverEdges(graph, indexes, emitParsedFiles, postHeritageNodeLookup, handledSites, readonlyModel)
+        : 0;
+    const freeCallExtras = callableFlowOnly
+        ? 0
+        : (0, free_call_fallback_js_1.emitFreeCallFallback)(graph, indexes, emitParsedFiles, postHeritageNodeLookup, referenceIndex, handledSites, readonlyModel, workspaceIndex, {
+            allowGlobalFallback: provider.allowGlobalFreeCallFallback === true,
+            constructorCallTargetsClass: provider.constructorCallTargetsClass === true,
+            isFileLocalDef: provider.isFileLocalDef,
+            isBuiltInName: provider.languageProvider.isBuiltInName,
+            freeCallsRequireInstanceOwnership: provider.freeCallsRequireInstanceOwnership === true,
+            isCallableVisibleFromCaller: provider.isCallableVisibleFromCaller,
+            resolveAdlCandidates: provider.resolveAdlCandidates,
+            resolveQualifiedFreeCall: provider.resolveQualifiedFreeCall,
+            conversionRankFn: provider.conversionRankFn,
+            conversionOnlyArgTypePrefixes: provider.conversionOnlyArgTypePrefixes,
+            constraintCompatibility: provider.constraintCompatibility,
+            recordResolutionOutcome,
+            calleeIdSink: calleeIdAccumulator,
+            skipSites: deferredIndirectSites,
+        });
+    const referenceSkipSites = new Set(handledSites);
+    for (const key of deferredIndirectSites)
+        referenceSkipSites.add(key);
+    const { emitted, skipped } = callableFlowOnly
+        ? { emitted: 0, skipped: 0 }
+        : (0, references_to_edges_js_1.emitReferencesViaLookup)(graph, indexes, referenceIndex, postHeritageNodeLookup, referenceSkipSites, calleeIdAccumulator);
+    // value-ref registrations (#2437): USES edges at the registration sites
+    // plus field-based dispatch — synthesized CALLS from member-call sites to
+    // functions registered under the same property key. This runs after the
+    // ordinary precise passes but before callable-value-flow: property-dispatched
+    // wrapper calls must populate the callee accumulator before actual→formal
+    // propagation. `graph.addRelationship` remains first-write-wins, so precise
+    // edges already emitted for a site retain ownership.
+    const propertyDispatch = callableFlowOnly
+        ? { usesEmitted: 0, callsEmitted: 0, skippedKeys: 0, skippedKeyNames: [] }
+        : (0, property_dispatch_js_1.emitPropertyDispatchCalls)(graph, indexes, emitParsedFiles, postHeritageNodeLookup, calleeIdAccumulator);
+    if (propertyDispatch.skippedKeys > 0) {
+        // Never drop dispatch coverage silently: a hook table larger than the
+        // fan-out cap means member calls through those keys get no synthesized
+        // CALLS — the #2437 false-safe gap reappears for exactly those keys.
+        logger_js_1.logger.warn({
+            lang: provider.language,
+            skippedKeys: propertyDispatch.skippedKeys,
+            skippedKeyNames: propertyDispatch.skippedKeyNames,
+            fanoutCap: property_dispatch_js_1.MAX_PROPERTY_DISPATCH_FANOUT,
+        }, 'property-dispatch: keys over the fan-out cap were dropped (no CALLS synthesized for them)');
+    }
+    const callableValueFlow = calleeIdAccumulator === undefined
+        ? {
+            emitted: 0,
+            resolvedInvokes: 0,
+            ambiguousInvokes: 0,
+            unmatchedInvokes: 0,
+            iterations: 0,
+        }
+        : (0, callable_value_flow_js_1.emitCallableValueFlow)({
+            graph,
+            scopes: indexes,
+            parsedFiles: emitParsedFiles,
+            nodeLookup: postHeritageNodeLookup,
+            calleeIds: calleeIdAccumulator,
+            language: provider.language,
+            collapseByCallerTarget: provider.collapseMemberCallsByCallerTarget === true,
+            isCallableValueTarget: provider.isCallableValueTarget,
+            hasFileLocalCallableLinkage: provider.hasFileLocalCallableLinkage,
+            onWarn: (warning) => logger_js_1.logger.warn(warning, 'callable-value-flow: candidate set exceeded the cap; no partial CALLS emitted'),
+        });
+    const importsEmitted = callableFlowOnly
+        ? 0
+        : (0, imports_to_edges_js_1.emitImportEdges)(graph, indexes.imports, indexes.scopeTree, provider.importEdgeReason);
+    // Language-specific supplementary edges (e.g. Vue template-derived
+    // BINDS_EVENT_HANDLER / EMITS_EVENT / CALLS / ACCESSES edges).
+    // Runs last so the full graph — including import edges — is visible.
+    if (!callableFlowOnly && provider.emitPostResolutionEdges !== undefined) {
+        provider.emitPostResolutionEdges(graph, emitParsedFiles, postHeritageNodeLookup, indexes, {
+            fileContents: getFileContents(),
+            resolutionConfig,
+        });
+    }
+    if (PROF) {
+        const tEnd = process.hrtime.bigint();
+        const ns = (a, b) => Number(b - a) / 1_000_000;
+        logger_js_1.logger.warn(`[scope-resolution prof] extract=${ns(tStart, tExtract).toFixed(0)}ms` +
+            ` finalize=${ns(tExtract, tFinalize).toFixed(0)}ms` +
+            ` propagate=${ns(tFinalize, tPropagate).toFixed(0)}ms` +
+            ` rangeBind=${ns(tRangeBindStart, tPropagate).toFixed(1)}ms` +
+            ` resolve=${ns(tPropagate, tResolve).toFixed(0)}ms` +
+            ` emit=${ns(tResolve, tEnd).toFixed(0)}ms` +
+            ` total=${ns(tStart, tEnd).toFixed(0)}ms` +
+            ` (${parsedFiles.length} files)`);
+    }
+    (0, heap_probe_js_1.logHeapProbe)('sr-end', `lang=${provider.language} parsedFiles=${parsedFiles.length}`);
+    return {
+        filesProcessed: parsedFiles.length,
+        filesSkipped,
+        importsEmitted,
+        resolve: resolveStats,
+        referenceEdgesEmitted: emitted +
+            receiverExtras +
+            unresolvedReceiverExtras +
+            freeCallExtras +
+            callableValueFlow.emitted +
+            propertyDispatch.usesEmitted +
+            propertyDispatch.callsEmitted,
+        referenceSkipped: skipped,
+        propertyDispatchSkippedKeys: propertyDispatch.skippedKeys,
+        resolutionOutcomes,
+    };
+}