gitnexus 1.6.9 → 1.6.10-aptos.0

package/dist/core/ingestion/scope-resolution/passes/free-call-fallback.d.ts

@@ -57,11 +57,23 @@ export declare function emitFreeCallFallback(graph: KnowledgeGraph, scopes: Scop
      *  fail at the call site. Three-valued; `'unknown'` keeps the
      *  candidate (monotonicity). */
     readonly constraintCompatibility?: ScopeResolver['constraintCompatibility'];
+    /** Platform/language built-in names (e.g. `fetch`, `setTimeout`) that
+     *  are never real repository declarations. Gates the finalize-bucket
+     *  guard below (#2545) -- see `hasGenuineLexicalBinding`. */
+    readonly isBuiltInName?: (name: string) => boolean;
+    /** Instance-ownership gate (#2550): a free call may resolve to a
+     *  `Method` only when the caller's enclosing class chain (self + MRO)
+     *  contains the method's owner. See
+     *  `ScopeResolver.freeCallsRequireInstanceOwnership`. */
+    readonly freeCallsRequireInstanceOwnership?: boolean;
     readonly recordResolutionOutcome?: ResolutionOutcomeRecorder;
-    /** Resolved-callee-id capture sink (#2227 U2). Threaded in only under
-     *  `--pdg`; `undefined` ⇒ zero overhead, byte-identity (R4). Captured at
-     *  the CALLS emit below BEFORE the collapsed `seen` dedup (KTD6) so
-     *  same-target multi-line calls are still recorded per site. */
+    /** Call sites owned by a later precise pass (for example callable-value-flow). */
+    readonly skipSites?: ReadonlySet<string>;
+    /** Resolved-callee-id capture sink (#2227 U2). Threaded in under `--pdg`
+     *  OR for callable-flow's direct-target index (#2437, position-filtered);
+     *  `undefined` ⇒ zero overhead, byte-identity (R4). Captured at the CALLS
+     *  emit below BEFORE the collapsed `seen` dedup (KTD6) so same-target
+     *  multi-line calls are still recorded per site. */
     readonly calleeIdSink?: CalleeIdSink;
 }): number;
 /**

package/dist/core/ingestion/scope-resolution/passes/free-call-fallback.js

@@ -17,7 +17,7 @@
  * generalization plan.
  */
 import { resolveCallerGraphId, resolveDefGraphId } from '../graph-bridge/ids.js';
-import { findAllCallableBindingsInScope, findCallableBindingInScope, findCallableBindingsAndAdlBlocker, resolveInheritanceBaseInScope, } from '../scope/walkers.js';
+import { findAllCallableBindingsInScope, findCallableBindingInScope, findCallableBindingsAndAdlBlocker, findEnclosingClassDef, resolveInheritanceBaseInScope, } from '../scope/walkers.js';
 import { isOverloadAmbiguousAfterNormalization, narrowOverloadCandidates, } from './overload-narrowing.js';
 export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _referenceIndex, handledSites, model, workspaceIndex, options = {}) {
     let emitted = 0;
@@ -46,6 +46,8 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                 continue;
             if (site.explicitReceiver !== undefined)
                 continue;
+            if (options.skipSites?.has(siteKey(parsed.filePath, site)) === true)
+                continue;
             // Constructor form (`new User(...)`): resolve the class, then
             // emit CALLS to its explicit Constructor def (when present) or
             // to the Class node itself (implicit constructor). Legacy emits
@@ -107,6 +109,72 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                     // available AND the binding scope contains multiple overloads,
                     // refine with narrowOverloadCandidates (#1578).
                     fnDef = findCallableBindingInScope(site.inScope, site.name, scopes);
+                    if (fnDef !== undefined &&
+                        options.isBuiltInName?.(site.name) === true &&
+                        fnDef.filePath === parsed.filePath &&
+                        !hasGenuineLexicalBinding(site.inScope, site.name, scopes)) {
+                        // A platform/language built-in (e.g. `fetch`, `setTimeout`)
+                        // with no binding reachable via the TRUE lexical scope chain
+                        // (Scope.bindings only) -- the match came solely from
+                        // finalize's per-file "local + imports + wildcards" bucket,
+                        // which flattens every declaration in the file onto the
+                        // module scope regardless of true nesting depth
+                        // (gitnexus-shared's `materializeBindings`). That flattening
+                        // is correct for its purpose (cross-file import targets) but
+                        // over-matches same-file built-in-shadowing declarations that
+                        // were never really module-scope-visible -- e.g. a Cloudflare
+                        // Worker's `export default { fetch(req) {} }` handler (#2545).
+                        // Leave the call unresolved rather than emit a false edge.
+                        //
+                        // `fnDef.filePath === parsed.filePath` is the load-bearing
+                        // guard against a real regression: `materializeBindings`'s
+                        // flat bucket is per-file, so the leak this guard targets is
+                        // ALWAYS same-file. A cross-file match at this point can only
+                        // come from a genuine import/namespace/workspace-FQN channel
+                        // (the separate, gated `pickUniqueGlobalCallable` global
+                        // fallback runs later and isn't what populated `fnDef` here)
+                        // -- e.g. `import { fetch } from './fetch-polyfill'` must
+                        // keep resolving. Without this check, that import silently
+                        // stopped resolving (verified via a scratch probe fixture).
+                        fnDef = undefined;
+                    }
+                    // Instance-ownership gate (#2550). Placement matters: after the
+                    // scope-chain lookup, BEFORE overload narrowing -- a suppressed
+                    // candidate must not participate in overload selection. The
+                    // legitimate same-class bare call already resolved earlier via
+                    // `pickImplicitThisOverload`; an inherited bare call passes the
+                    // MRO arm here; what remains is the finalize-bucket leak (an
+                    // unrelated same-file method matched by bare name).
+                    //
+                    // Same-file only (mirrors the #2545 guard's load-bearing
+                    // condition): the `materializeBindings` bucket is per-file, so
+                    // the leak is ALWAYS same-file. A cross-file Method match here
+                    // came through a genuine import channel -- e.g. the arity-
+                    // narrowing parity fixtures resolve a bare `writeAudit(u)` to
+                    // an imported class's method, which must keep working
+                    // (suppressing it broke `java.test.ts`'s arity-filtering suite,
+                    // verified empirically).
+                    if (fnDef !== undefined &&
+                        options.freeCallsRequireInstanceOwnership === true &&
+                        fnDef.type === 'Method' &&
+                        fnDef.ownerId !== undefined &&
+                        fnDef.filePath === parsed.filePath) {
+                        const enclosing = findEnclosingClassDef(site.inScope, scopes);
+                        const ownerReachable = enclosing !== undefined &&
+                            (enclosing.nodeId === fnDef.ownerId ||
+                                scopes.methodDispatch.mroFor(enclosing.nodeId).includes(fnDef.ownerId));
+                        if (!ownerReachable) {
+                            recordSuppressedOutcome(options.recordResolutionOutcome, {
+                                phase: 'free-call-fallback',
+                                filePath: parsed.filePath,
+                                name: site.name,
+                                range: site.atRange,
+                                reason: 'free-call-instance-ownership',
+                                candidates: [fnDef],
+                            });
+                            fnDef = undefined;
+                        }
+                    }
                     if (fnDef !== undefined && options.conversionRankFn !== undefined) {
                         const allCallables = findAllCallableBindingsInScope(site.inScope, site.name, scopes);
                         if (allCallables.length > 1) {
@@ -707,3 +775,31 @@ export function pickImplicitThisOverload(site, scopes, workspaceIndex, model, ho
         return undefined;
     return candidates[0];
 }
+/**
+ * True when `name` is bound somewhere along the TRUE lexical scope
+ * chain from `startScope` -- i.e. via `Scope.bindings` (the raw,
+ * nesting-aware per-scope map built during extraction), NOT via
+ * finalize's `indexes.bindings` module-scope bucket (which flattens
+ * every declaration in the file onto the module scope regardless of
+ * true nesting -- see `hasGenuineLexicalBinding`'s caller for why that
+ * distinction matters, #2545).
+ */
+function hasGenuineLexicalBinding(startScope, name, scopes) {
+    let currentId = startScope;
+    const visited = new Set();
+    while (currentId !== null) {
+        if (visited.has(currentId))
+            return false;
+        visited.add(currentId);
+        const scope = scopes.scopeTree.getScope(currentId);
+        if (scope === undefined)
+            return false;
+        // `Object` scopes (object/record literal bodies) are a hoist
+        // boundary only -- never a genuine lexical binding, not even to
+        // their own nested children (#2551, mirrors scope/walkers.ts).
+        if (scope.kind !== 'Object' && scope.bindings.get(name) !== undefined)
+            return true;
+        currentId = scope.parent;
+    }
+    return false;
+}

package/dist/core/ingestion/scope-resolution/passes/property-dispatch.d.ts

@@ -0,0 +1,60 @@
+/**
+ * `emitPropertyDispatchCalls` — value-ref registration edges + field-based
+ * dispatch for functions registered as object-literal property values
+ * (#2437).
+ *
+ * A provider-hook registration (`{ emitScopeCaptures: emitCppScopeCaptures }`)
+ * emits a USES reference edge — a registration is not an invocation (Kythe
+ * `ref` vs `ref/call`; Joern `METHOD_REF`). The invocation happens later
+ * through the property (`provider.emitScopeCaptures(...)`) — a dispatch the
+ * receiver-bound pass cannot resolve because object literals are not
+ * IMPLEMENTS-linked implementors. This pass closes that soundness gap the
+ * field-based way (Feldthaus et al., ICSE'13; CodeQL `impliedReceiverStep`):
+ * key registrations by property name and connect every member-call site
+ * `x.<key>(...)` to every function registered under `<key>`.
+ *
+ * This pass is the SINGLE owner of `value-ref` resolution. The shared
+ * registries only consult pre-finalize local bindings — imported names live
+ * in finalized bindings (the same reason free calls need
+ * `emitFreeCallFallback`) — so `resolveReferenceSites` skips `value-ref`
+ * sites and this pass resolves them post-finalize via
+ * `findCallableBindingInScope` (Function/Method/Constructor only — the
+ * callable gate that keeps `{ port: DEFAULT_PORT }` from emitting anything).
+ *
+ * Precision posture (mirrors `emitInterfaceDispatchFor`):
+ *   - reason `'property-dispatch'` keeps synthesized CALLS auditable;
+ *   - dispatch confidence 0.7 sits below the 0.85 resolved baseline;
+ *   - a per-key fan-out cap drops promiscuous names (`handler`, `callback`)
+ *     entirely rather than truncating silently — property-name collisions
+ *     across unrelated objects are the documented field-based failure mode.
+ *
+ * Ordering: runs AFTER the precise emit passes. `graph.addRelationship` is
+ * first-write-wins on the position-keyed edge id, so a site that already
+ * resolved precisely to the same target keeps its precise edge.
+ *
+ * Language-neutral: consumes only `value-ref` sites (any language that
+ * emits the capture participates) and generic member-call sites.
+ */
+import type { ParsedFile } from '../../../../_shared/index.js';
+import type { KnowledgeGraph } from '../../../graph/types.js';
+import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
+import type { GraphNodeLookup } from '../graph-bridge/node-lookup.js';
+import type { CalleeIdSink } from '../graph-bridge/callee-id-sink.js';
+/**
+ * Keys registered by more than this many distinct functions are skipped —
+ * dispatch through such a name says nothing about which function runs.
+ * Calibrated on this repo's own provider tables: `emitScopeCaptures` has 16
+ * legitimate registrations (one per language provider), so the cap sits at
+ * 2× that — dropping the motivating key was the failure the first value (8)
+ * had. ponytail: flat cap; revisit with per-receiver narrowing if real
+ * repos show useful keys being dropped (§12 of the #2437 plan).
+ */
+export declare const MAX_PROPERTY_DISPATCH_FANOUT = 32;
+/** Below the 0.85 resolved baseline; same discount idea as interface-dispatch. */
+export declare const PROPERTY_DISPATCH_CONFIDENCE = 0.7;
+export declare function emitPropertyDispatchCalls(graph: KnowledgeGraph, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[], nodeLookup: GraphNodeLookup, calleeIdSink?: CalleeIdSink): {
+    usesEmitted: number;
+    callsEmitted: number;
+    skippedKeys: number;
+    skippedKeyNames: readonly string[];
+};

package/dist/core/ingestion/scope-resolution/passes/property-dispatch.js

@@ -0,0 +1,111 @@
+/**
+ * `emitPropertyDispatchCalls` — value-ref registration edges + field-based
+ * dispatch for functions registered as object-literal property values
+ * (#2437).
+ *
+ * A provider-hook registration (`{ emitScopeCaptures: emitCppScopeCaptures }`)
+ * emits a USES reference edge — a registration is not an invocation (Kythe
+ * `ref` vs `ref/call`; Joern `METHOD_REF`). The invocation happens later
+ * through the property (`provider.emitScopeCaptures(...)`) — a dispatch the
+ * receiver-bound pass cannot resolve because object literals are not
+ * IMPLEMENTS-linked implementors. This pass closes that soundness gap the
+ * field-based way (Feldthaus et al., ICSE'13; CodeQL `impliedReceiverStep`):
+ * key registrations by property name and connect every member-call site
+ * `x.<key>(...)` to every function registered under `<key>`.
+ *
+ * This pass is the SINGLE owner of `value-ref` resolution. The shared
+ * registries only consult pre-finalize local bindings — imported names live
+ * in finalized bindings (the same reason free calls need
+ * `emitFreeCallFallback`) — so `resolveReferenceSites` skips `value-ref`
+ * sites and this pass resolves them post-finalize via
+ * `findCallableBindingInScope` (Function/Method/Constructor only — the
+ * callable gate that keeps `{ port: DEFAULT_PORT }` from emitting anything).
+ *
+ * Precision posture (mirrors `emitInterfaceDispatchFor`):
+ *   - reason `'property-dispatch'` keeps synthesized CALLS auditable;
+ *   - dispatch confidence 0.7 sits below the 0.85 resolved baseline;
+ *   - a per-key fan-out cap drops promiscuous names (`handler`, `callback`)
+ *     entirely rather than truncating silently — property-name collisions
+ *     across unrelated objects are the documented field-based failure mode.
+ *
+ * Ordering: runs AFTER the precise emit passes. `graph.addRelationship` is
+ * first-write-wins on the position-keyed edge id, so a site that already
+ * resolved precisely to the same target keeps its precise edge.
+ *
+ * Language-neutral: consumes only `value-ref` sites (any language that
+ * emits the capture participates) and generic member-call sites.
+ */
+import { tryEmitEdge } from '../graph-bridge/edges.js';
+import { findCallableBindingInScope } from '../scope/walkers.js';
+/**
+ * Keys registered by more than this many distinct functions are skipped —
+ * dispatch through such a name says nothing about which function runs.
+ * Calibrated on this repo's own provider tables: `emitScopeCaptures` has 16
+ * legitimate registrations (one per language provider), so the cap sits at
+ * 2× that — dropping the motivating key was the failure the first value (8)
+ * had. ponytail: flat cap; revisit with per-receiver narrowing if real
+ * repos show useful keys being dropped (§12 of the #2437 plan).
+ */
+export const MAX_PROPERTY_DISPATCH_FANOUT = 32;
+/** Below the 0.85 resolved baseline; same discount idea as interface-dispatch. */
+export const PROPERTY_DISPATCH_CONFIDENCE = 0.7;
+export function emitPropertyDispatchCalls(graph, scopes, parsedFiles, nodeLookup, calleeIdSink) {
+    const seen = new Set();
+    let usesEmitted = 0;
+    // Sweep 1 — resolve every value-ref site: emit the USES registration edge
+    // and index dispatchable registrations by property key.
+    const registrations = new Map();
+    for (const parsed of parsedFiles) {
+        for (const site of parsed.referenceSites) {
+            if (site.kind !== 'value-ref')
+                continue;
+            const def = findCallableBindingInScope(site.inScope, site.name, scopes);
+            if (def === undefined)
+                continue;
+            const ok = tryEmitEdge(graph, scopes, nodeLookup, site, def, 'scope-resolution: value-ref', seen);
+            if (ok)
+                usesEmitted++;
+            if (site.propertyKey === undefined)
+                continue;
+            let byDef = registrations.get(site.propertyKey);
+            if (byDef === undefined) {
+                byDef = new Map();
+                registrations.set(site.propertyKey, byDef);
+            }
+            byDef.set(def.nodeId, def);
+        }
+    }
+    // Keep the dropped key NAMES (bounded) — an over-cap key means no CALLS
+    // are synthesized through it, and a count alone leaves the operator unable
+    // to tell WHICH hook table lost coverage (#2522 review).
+    let skippedKeys = 0;
+    const skippedKeyNames = [];
+    for (const [key, defs] of registrations) {
+        if (defs.size > MAX_PROPERTY_DISPATCH_FANOUT) {
+            registrations.delete(key);
+            skippedKeys++;
+            if (skippedKeyNames.length < 20)
+                skippedKeyNames.push(key);
+        }
+    }
+    // Sweep 2 — synthesize CALLS from member-call sites through registered keys.
+    let callsEmitted = 0;
+    if (registrations.size > 0) {
+        for (const parsed of parsedFiles) {
+            const calleeCapture = calleeIdSink !== undefined ? { sink: calleeIdSink, filePath: parsed.filePath } : undefined;
+            for (const site of parsed.referenceSites) {
+                if (site.kind !== 'call' || site.callForm !== 'member')
+                    continue;
+                const defs = registrations.get(site.name);
+                if (defs === undefined)
+                    continue;
+                for (const def of defs.values()) {
+                    const ok = tryEmitEdge(graph, scopes, nodeLookup, site, def, 'property-dispatch', seen, PROPERTY_DISPATCH_CONFIDENCE, false, calleeCapture);
+                    if (ok)
+                        callsEmitted++;
+                }
+            }
+        }
+    }
+    return { usesEmitted, callsEmitted, skippedKeys, skippedKeyNames };
+}

package/dist/core/ingestion/scope-resolution/passes/receiver-bound-calls.d.ts

@@ -58,9 +58,10 @@ import type { ResolutionOutcomeRecorder } from '../resolution-outcome.js';
 type ReceiverBoundProviderSubset = Pick<ScopeResolver, 'isSuperReceiver' | 'isSuperReceiverInContext' | 'fieldFallbackOnMethodLookup' | 'collapseMemberCallsByCallerTarget' | 'unwrapCollectionAccessor' | 'hoistTypeBindingsToModule' | 'stripReceiverCastExpressions' | 'resolveQualifiedReceiverMember' | 'resolveReceiverMember' | 'resolveThisViaEnclosingClass' | 'conversionRankFn' | 'conversionOnlyArgTypePrefixes' | 'constraintCompatibility' | 'isStaticOnly'>;
 export declare function emitReceiverBoundCalls(graph: KnowledgeGraph, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[], nodeLookup: GraphNodeLookup, handledSites: Set<string>, provider: ReceiverBoundProviderSubset, index: WorkspaceResolutionIndex, model: SemanticModel, options?: {
     readonly recordResolutionOutcome?: ResolutionOutcomeRecorder;
-    /** Resolved-callee-id capture sink (#2227 U2). Threaded in only under
-     *  `--pdg`; `undefined` ⇒ zero overhead, byte-identity (R4). Per-file
-     *  capture contexts are built from this + `parsed.filePath` in the loop. */
+    /** Resolved-callee-id capture sink (#2227 U2). Threaded in under `--pdg`
+     *  OR for callable-flow's direct-target index (#2437, position-filtered);
+     *  `undefined` ⇒ zero overhead, byte-identity (R4). Per-file capture
+     *  contexts are built from this + `parsed.filePath` in the loop. */
     readonly calleeIdSink?: CalleeIdSink;
 }): number;
 /**

package/dist/core/ingestion/scope-resolution/pipeline/phase.d.ts

@@ -29,6 +29,7 @@ import type { ResolutionOutcome } from '../resolution-outcome.js';
 import type { FunctionSummary } from '../../taint/summary-model.js';
 import type { CallSummary } from '../../taint/call-summary-model.js';
 import { type PdgEmitManifest } from '../../../lbug/pdg-emit-sink.js';
+import type { ScopeResolver } from '../contract/scope-resolver.js';
 export interface ScopeResolutionOutput {
     /** True when at least one language ran. */
     readonly ran: boolean;
@@ -68,4 +69,8 @@ export interface ScopeResolutionOutput {
      */
     readonly pdgEmitManifest?: PdgEmitManifest;
 }
+/** Select source files that must be materialized for one resolver pass. */
+export declare function selectScopeSourcePathsToRead(provider: ScopeResolver, primaryFilePaths: readonly string[], preExtractedByPath: {
+    readonly has: (filePath: string) => boolean;
+}): string[];
 export declare const scopeResolutionPhase: PipelinePhase<ScopeResolutionOutput>;

package/dist/core/ingestion/scope-resolution/pipeline/phase.js

@@ -47,6 +47,17 @@ const NOOP_OUTPUT = Object.freeze({
     functionSummaries: [],
     callSummaries: [],
 });
+/** Select source files that must be materialized for one resolver pass. */
+export function selectScopeSourcePathsToRead(provider, primaryFilePaths, preExtractedByPath) {
+    const hasPostExtractHooks = provider.populateWorkspaceOwners !== undefined ||
+        provider.populateNamespaceSiblings !== undefined ||
+        provider.populateRangeBindings !== undefined ||
+        provider.emitPostResolutionEdges !== undefined;
+    const needsAllSourceText = hasPostExtractHooks && provider.postExtractSourceTextPolicy !== 'uncached-files';
+    return needsAllSourceText
+        ? [...primaryFilePaths]
+        : primaryFilePaths.filter((filePath) => !preExtractedByPath.has(filePath));
+}
 export const scopeResolutionPhase = {
     name: 'scopeResolution',
     // Depends on `parse` because emit-references attaches edges to
@@ -89,11 +100,10 @@ export const scopeResolutionPhase = {
         // runs use the in-heap `workerParsedFiles` above or fall back to a fresh
         // extract per file inside runScopeResolution.
         const parsedFileStorePath = ctx.options?.parseCache?.storagePath;
-        // Drop pre-extracted entries for standalone providers — these
-        // languages are skipped by the canonical guard below (line 164)
-        // and never consume preExtractedByPath, so holding onto their
-        // entries leaks memory until the cleanup loop at 262-264 which
-        // also never runs for skipped providers.
+        // Standalone providers are re-extracted from source on the main thread;
+        // workers intentionally do not serialize ParsedFile artifacts for them.
+        // Drop any stale/cache-sourced entry defensively so provider-owned regex
+        // capture logic is always the source of truth for the current content.
         for (const [path] of preExtractedByPath) {
             const lang = getLanguageFromFilename(path);
             if (lang === null)
@@ -132,16 +142,13 @@ export const scopeResolutionPhase = {
             const fileLang = getLanguageFromFilename(f.path);
             if (fileLang === null)
                 continue;
-            // Skip files whose grammar isn't available (optional grammars like
-            // swift/dart/kotlin on an install where the binding is absent or the
-            // user set GITNEXUS_SKIP_OPTIONAL_GRAMMARS). The parse phase already
-            // excluded and warned about these (parse-impl.ts); without this guard the
-            // file would fall through to the main-thread re-extract in run.ts and
-            // throw "Unsupported language" (caught, but noisy, and it needlessly
-            // loads the grammar on the main thread). `isLanguageAvailable` is
-            // memoized, so this stays O(1) per language. (#2091, #2093)
-            if (!isLanguageAvailable(fileLang))
+            // Tree-sitter providers require an available grammar. Standalone regex
+            // providers deliberately have none and re-extract on the main thread.
+            const resolver = SCOPE_RESOLVERS.get(fileLang);
+            if (resolver?.languageProvider.parseStrategy !== 'standalone' &&
+                !isLanguageAvailable(fileLang)) {
                 continue;
+            }
             let bucket = filesByLang.get(fileLang);
             if (bucket === undefined) {
                 bucket = [];
@@ -220,14 +227,6 @@ export const scopeResolutionPhase = {
         let pdgSinkSettled = false;
         try {
             for (const [lang, provider] of SCOPE_RESOLVERS) {
-                // Standalone providers (COBOL, JCL) don't emit graph edges yet
-                // through the scope-resolution path. This is the canonical guard:
-                // runScopeResolution is never called for standalone providers, which
-                // keeps cobolPhase as the sole IMPORTS edge producer. Keep this guard
-                // in sync with any additional standalone providers added to
-                // SCOPE_RESOLVERS.
-                if (provider.languageProvider.parseStrategy === 'standalone')
-                    continue;
                 const primaryLangFiles = filesByLang.get(lang) ?? [];
                 if (primaryLangFiles.length === 0)
                     continue;
@@ -262,16 +261,6 @@ export const scopeResolutionPhase = {
                     for (const [fp, pf] of fromDisk)
                         preExtractedByPath.set(fp, pf);
                 };
-                // A provider that feeds source text into a post-extract hook
-                // (populateWorkspaceOwners / populateNamespaceSiblings /
-                // populateRangeBindings / emitPostResolutionEdges) needs content for ALL
-                // its files; one without those hooks only needs content for files the
-                // store does NOT cover (fresh-extract fallback). Keep this in sync with
-                // the getFileContents() call-sites in run.ts.
-                const providerNeedsAllContent = provider.populateWorkspaceOwners !== undefined ||
-                    provider.populateNamespaceSiblings !== undefined ||
-                    provider.populateRangeBindings !== undefined ||
-                    provider.emitPostResolutionEdges !== undefined;
                 let scopeFilePaths;
                 let contents;
                 if (provider.collectScopeContextPaths !== undefined) {
@@ -294,9 +283,7 @@ export const scopeResolutionPhase = {
                 else {
                     scopeFilePaths = new Set(primaryFilePaths);
                     await loadStoreFor(scopeFilePaths);
-                    const pathsToRead = providerNeedsAllContent
-                        ? primaryFilePaths
-                        : primaryFilePaths.filter((p) => !preExtractedByPath.has(p));
+                    const pathsToRead = selectScopeSourcePathsToRead(provider, primaryFilePaths, preExtractedByPath);
                     contents = await readFileContents(ctx.repoPath, pathsToRead);
                 }
                 const filePaths = [...scopeFilePaths];
@@ -308,9 +295,9 @@ export const scopeResolutionPhase = {
                     }
                     else if (preExtractedByPath.has(fp)) {
                         // Store covers extraction for this file and we deliberately skipped
-                        // reading its source; the empty string is never consumed (the
-                        // extract loop uses the pre-extracted ParsedFile and this provider
-                        // has no content hook).
+                        // reading its source; extraction uses the pre-extracted ParsedFile,
+                        // and the provider's source-text policy guarantees its hooks can
+                        // tolerate empty content for cached files.
                         files.push({ path: fp, content: '' });
                     }
                     // else: uncovered AND unreadable → skip (unchanged from prior behavior).

package/dist/core/ingestion/scope-resolution/pipeline/run.d.ts

@@ -185,6 +185,12 @@ interface RunScopeResolutionStats {
     readonly resolve: ResolveStats;
     readonly referenceEdgesEmitted: number;
     readonly referenceSkipped: number;
+    /**
+     * Property-dispatch keys dropped for exceeding the fan-out cap. Non-zero
+     * means member calls through those keys got NO synthesized CALLS — the
+     * #2437 false-safe gap for exactly those keys (names are in the warn log).
+     */
+    readonly propertyDispatchSkippedKeys: number;
     readonly resolutionOutcomes: readonly ResolutionOutcome[];
     /**
      * Per-function taint summaries harvested in the pdg window (#2084 M4 U1).