gitnexus 1.6.10-rc.98 → 1.6.10

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

@@ -34,6 +34,7 @@ import { isDev, isSemanticModelValidatorEnabled } from '../../utils/env.js';
 import { logHeapProbe } from '../../utils/heap-probe.js';
 import { clearParsedFileStore, loadParsedFilesForPaths, forceGc, } from '../../../../storage/parsedfile-store.js';
 import { buildFunctionNodeIndex } from '../../taint/summary-harvest-driver.js';
+import { buildPropertyNameIndex } from '../passes/unique-name-properties.js';
 import { PdgEmitSink } from '../../../lbug/pdg-emit-sink.js';
 import { resolveNativeSafeStorageDir } from '../../../lbug/lbug-config.js';
 import { logger } from '../../../logger.js';
@@ -43,9 +44,11 @@ const NOOP_OUTPUT = Object.freeze({
     importsEmitted: 0,
     referenceEdgesEmitted: 0,
     resolutionOutcomes: [],
+    // Deliberately absent, not `[]`: nothing ran, so nothing was decided either.
     perLanguage: new Map(),
     functionSummaries: [],
     callSummaries: [],
+    propertyInference: { ambiguous: 0, ambiguousNames: [], crossLanguage: 0, crossLanguageNames: [] },
 });
 /** Select source files that must be materialized for one resolver pass. */
 export function selectScopeSourcePathsToRead(provider, primaryFilePaths, preExtractedByPath) {
@@ -118,6 +121,7 @@ export const scopeResolutionPhase = {
         let totalRefs = 0;
         let anyRan = false;
         const resolutionOutcomes = [];
+        const undecidedSatisfaction = [];
         // M4 (#2084 U1): per-function taint summaries accumulated across every
         // language pass; the cross-function fixpoint phase reads this output.
         const functionSummaries = [];
@@ -192,6 +196,13 @@ export const scopeResolutionPhase = {
         const sharedFnNodeIndex = ctx.options?.pdg === true && totalScopeFiles > 0
             ? buildFunctionNodeIndex(ctx.graph)
             : undefined;
+        // Same treatment for the `Property`-by-name index the unique-name pass
+        // consults: a whole-graph node scan, language-agnostic, and previously
+        // rebuilt inside every qualifying language pass. Language filtering happens
+        // at LOOKUP time against that language's own file set, so one shared index
+        // serves all of them without widening what any single language can resolve
+        // to.
+        const sharedPropertyNameIndex = totalScopeFiles > 0 ? buildPropertyNameIndex(ctx.graph) : undefined;
         // Streaming/chunked PDG emit (#2202): when enabled (the caller has already
         // gated this to full-rebuild + `--pdg`), route the BasicBlock + intra-file
         // PDG-edge layer to CSV-on-disk through one sink shared across every
@@ -223,6 +234,11 @@ export const scopeResolutionPhase = {
         // finalize/propagate/a provider hook) must still release the sink's file
         // descriptors. finalize() runs on the success path; the finally closes the
         // sink only when finalize did not (idempotent via the sink's `finalized`).
+        // R3-1 accumulators — see the warning after the language loop.
+        let crossLanguagePropertyReads = 0;
+        const crossLanguageAnchorsByName = new Map();
+        let ambiguousPropertyReads = 0;
+        const ambiguousPropertyNames = new Set();
         let pdgEmitManifest;
         let pdgSinkSettled = false;
         try {
@@ -322,6 +338,7 @@ export const scopeResolutionPhase = {
                     files,
                     resolutionConfig,
                     prebuiltNodeLookup: sharedNodeLookup,
+                    prebuiltPropertyNameIndex: sharedPropertyNameIndex,
                     prebuiltFunctionNodeIndex: sharedFnNodeIndex,
                     preExtractedParsedFiles: preExtractedByPath,
                     scopeIndexStorePath: parsedFileStorePath,
@@ -406,6 +423,7 @@ export const scopeResolutionPhase = {
                 processedScopeFiles += langFileCount;
                 anyRan = true;
                 functionSummaries.push(...stats.functionSummaries);
+                undecidedSatisfaction.push(...stats.undecidedSatisfaction);
                 callSummaries.push(...stats.callSummaries);
                 totalFiles += stats.filesProcessed;
                 totalImports += stats.importsEmitted;
@@ -418,6 +436,35 @@ export const scopeResolutionPhase = {
                 if (isDev) {
                     logger.info(`[scope-resolution:${lang}] ${stats.filesProcessed} files → ${stats.importsEmitted} IMPORTS + ${stats.referenceEdgesEmitted} reference edges (${stats.resolve.unresolved} unresolved sites, ${stats.referenceSkipped} skipped)`);
                 }
+                // R3-1. Accumulated across languages and reported once below, NOT gated
+                // on isDev: a field whose only definition lives in another language
+                // answers an empty ACCESSES query that is byte-identical to "unused",
+                // and that is the confident-empty failure this whole series removes.
+                ambiguousPropertyReads += stats.uniqueNamePropertyAmbiguous;
+                for (const n of stats.uniqueNamePropertyAmbiguousNames)
+                    ambiguousPropertyNames.add(n);
+                crossLanguagePropertyReads += stats.uniqueNamePropertyCrossLanguage;
+                for (const entry of stats.uniqueNamePropertyCrossLanguageNames) {
+                    const existing = crossLanguageAnchorsByName.get(entry.name);
+                    if (existing === undefined) {
+                        crossLanguageAnchorsByName.set(entry.name, new Set(entry.languages));
+                    }
+                    else {
+                        for (const l of entry.languages)
+                            existing.add(l);
+                    }
+                }
+            }
+            if (crossLanguagePropertyReads > 0) {
+                const sample = Array.from(crossLanguageAnchorsByName)
+                    .slice(0, 10)
+                    .map(([name, langs]) => `${name} (${Array.from(langs).sort().join('/')})`)
+                    .join(', ');
+                logger.warn(`[scope-resolution] ${crossLanguagePropertyReads} property read/write site(s) name a field ` +
+                    `that IS defined in this workspace, but only in another language, so per-language inference ` +
+                    `declined to link them. Queries for these fields return an empty result that does NOT mean ` +
+                    `"unused" — it means the definition anchor is in a different language. ` +
+                    `Affected: ${sample}${crossLanguageAnchorsByName.size > 10 ? ', …' : ''}`);
             }
             // Finalize the streaming PDG sink (#2202) once after the last language:
             // flush + close its CSV writers and capture the COPY manifest. forceGc at
@@ -464,10 +511,20 @@ export const scopeResolutionPhase = {
             importsEmitted: totalImports,
             referenceEdgesEmitted: totalRefs,
             resolutionOutcomes,
+            undecidedSatisfaction,
             perLanguage,
             functionSummaries,
             callSummaries,
             pdgEmitManifest,
+            propertyInference: {
+                ambiguous: ambiguousPropertyReads,
+                ambiguousNames: Array.from(ambiguousPropertyNames).sort().slice(0, 25),
+                crossLanguage: crossLanguagePropertyReads,
+                crossLanguageNames: Array.from(crossLanguageAnchorsByName)
+                    .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+                    .slice(0, 25)
+                    .map(([name, languages]) => ({ name, languages: Array.from(languages).sort() })),
+            },
         };
     },
 };

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

@@ -30,7 +30,8 @@ import { buildGraphNodeLookup } from '../graph-bridge/node-lookup.js';
 import { type FunctionNodeIndex } from '../../taint/summary-harvest-driver.js';
 import type { FunctionSummary } from '../../taint/summary-model.js';
 import type { CallSummary } from '../../taint/call-summary-model.js';
-import type { ScopeResolver } from '../contract/scope-resolver.js';
+import { type PropertyNameIndex } from '../passes/unique-name-properties.js';
+import type { ScopeResolver, UndecidedSatisfaction } from '../contract/scope-resolver.js';
 import type { ResolutionOutcome, ResolutionOutcomeRecorder } from '../resolution-outcome.js';
 export type ScopeResolutionSubPhase = 'extracting' | 'analyzing types' | 'resolving references' | 'linking symbols';
 interface RunScopeResolutionInput {
@@ -129,6 +130,14 @@ interface RunScopeResolutionInput {
      * (tests / isolated calls) it is built locally for the pdg-enabled language.
      */
     readonly prebuiltFunctionNodeIndex?: FunctionNodeIndex;
+    /**
+     * `Property`-by-name index built ONCE by the caller and shared across every
+     * language pass. Like the two above it is a whole-graph scan and is
+     * language-agnostic; the per-language restriction is applied at lookup time
+     * against that language's own file set, so sharing the index does not widen
+     * what any single language can resolve to. Built locally when omitted.
+     */
+    readonly prebuiltPropertyNameIndex?: PropertyNameIndex;
     /**
      * Opaque per-language import-resolution config (e.g. tsconfig path
      * aliases for TypeScript). Loaded once by the caller via
@@ -191,7 +200,52 @@ interface RunScopeResolutionStats {
      * #2437 false-safe gap for exactly those keys (names are in the warn log).
      */
     readonly propertyDispatchSkippedKeys: number;
+    /** Cross-file value references resolved through finalized import bindings. */
+    readonly importedValueRefEdges: number;
+    /**
+     * ACCESSES edges recovered by property NAME (A1/A5) — the last-resort pass
+     * for receivers no precise pass could type.
+     */
+    readonly uniqueNamePropertyEdges: number;
+    /**
+     * Read/write sites left unresolved because two or more `Property` defs share
+     * the name, so a unique-name match would have been a coin flip. This is the
+     * population a receiver-typing improvement would convert into precise edges.
+     */
+    readonly uniqueNamePropertyAmbiguous: number;
+    /**
+     * Of `uniqueNamePropertyEdges`, how many the name carried several definitions
+     * for and same-file or direct-import evidence narrowed to one. Strict
+     * workspace uniqueness refused every one of these (R2).
+     */
+    readonly uniqueNamePropertyNarrowed: number;
+    /**
+     * The distinct field names behind `uniqueNamePropertyAmbiguous`, capped. A
+     * count says a coverage gap exists; the names say WHICH fields are
+     * unanswerable, so the gap is actionable rather than merely measured.
+     */
+    readonly uniqueNamePropertyAmbiguousNames: readonly string[];
+    /**
+     * Read/write sites whose name IS defined in the workspace but only in another
+     * LANGUAGE, so per-language inference declined. Separate from
+     * `uniqueNamePropertyAmbiguous` because the remedy differs: ambiguity wants
+     * better receiver typing, this wants an anchor in the reading language (R3-1).
+     */
+    readonly uniqueNamePropertyCrossLanguage: number;
+    /** Those names with the languages their definitions actually live in. */
+    readonly uniqueNamePropertyCrossLanguageNames: readonly {
+        readonly name: string;
+        readonly languages: string[];
+    }[];
     readonly resolutionOutcomes: readonly ResolutionOutcome[];
+    /**
+     * Interfaces whose structural-satisfaction check could not be completed for
+     * at least one candidate type (#2873). NOT the same as "no implementors" —
+     * these are questions the analyzer could not answer, and they are reported so
+     * `impact` can hedge a zero instead of asserting one. Empty for every
+     * language whose resolver has no `detectInterfaceImplementations` hook.
+     */
+    readonly undecidedSatisfaction: readonly UndecidedSatisfaction[];
     /**
      * Per-function taint summaries harvested in the pdg window (#2084 M4 U1).
      * Empty unless `input.pdg === true` and the language has a registered taint

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

@@ -40,17 +40,22 @@ import { harvestFileCallSummaries } from '../../taint/summary-harvest-driver.js'
 import { resolveDefGraphId } from '../graph-bridge/ids.js';
 import { buildPopulatedMethodDispatch } from '../graph-bridge/method-dispatch.js';
 import { propagateImportedReturnTypes } from '../passes/imported-return-types.js';
-import { emitReceiverBoundCalls } from '../passes/receiver-bound-calls.js';
+import { emitReceiverBoundCalls, MAX_INTERFACE_DISPATCH_FANOUT, } from '../passes/receiver-bound-calls.js';
 import { emitFreeCallFallback } from '../passes/free-call-fallback.js';
 import { emitPropertyDispatchCalls, MAX_PROPERTY_DISPATCH_FANOUT, } from '../passes/property-dispatch.js';
 import { emitReferencesViaLookup } from '../graph-bridge/references-to-edges.js';
+import { buildPropertyNameIndex, emitUniqueNamePropertyAccesses, } from '../passes/unique-name-properties.js';
+import { emitReturnShapeMemberAccesses } from '../passes/return-shape-members.js';
+import { emitImportedValueReferences } from '../passes/imported-value-refs.js';
 import { createCalleeIdAccumulator, } from '../graph-bridge/callee-id-sink.js';
 import { emitImportEdges } from '../graph-bridge/imports-to-edges.js';
 import { callableFlowSiteKey, collectDeferredIndirectSites, emitCallableValueFlow, } from '../passes/callable-value-flow.js';
 import { findEnclosingClassDef, resolveInheritanceBaseInScope } from '../scope/walkers.js';
+import { heritageTypeArgumentsKey, } from '../utils/generic-instantiation.js';
 import { buildWorkspaceResolutionIndex } from '../workspace-index.js';
 import { logHeapProbe } from '../../utils/heap-probe.js';
 import { parseTruthyEnv } from '../../utils/env.js';
+import { isValueDefinitionLabel } from '../../utils/ast-helpers.js';
 import { TransitionalScopeTree } from '../../../../storage/scope-index-store.js';
 import { forceGc } from '../../../../storage/parsedfile-store.js';
 import { logger } from '../../../logger.js';
@@ -90,8 +95,18 @@ function emitInheritanceEdgeDirect(graph, seen, existing, callerGraphId, targetG
  * reference-edge bridge from re-emitting the same sites later.
  *
  * @returns Site keys to seed the downstream handled-site skip set.
+ *
+ * The generic INSTANTIATION each heritage edge was written with (#2912) goes to
+ * `recordTypeArguments` rather than out through the return, because the caller
+ * shares that sink with the language heritage hook — see
+ * `HeritageTypeArguments` in `utils/generic-instantiation.ts`. This pass is
+ * where the pairing exists at all: the site carries the arguments and this is
+ * the only code that resolves the site to a (subtype, supertype) pair, so
+ * recording it here costs one map write per generic heritage edge, while
+ * recovering it downstream would mean redoing the resolution against a graph
+ * edge that no longer carries the spelling.
  */
-function preEmitInheritanceEdges(graph, scopes, nodeLookup) {
+function preEmitInheritanceEdges(graph, scopes, nodeLookup, recordTypeArguments) {
     const handledSites = new Set();
     const seen = new Set();
     // Tracks inheritance edges emitted during this pass so the structural
@@ -104,9 +119,7 @@ function preEmitInheritanceEdges(graph, scopes, nodeLookup) {
         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;
+        const siteKey = scope?.filePath !== undefined ? callableFlowSiteKey(scope.filePath, site.atRange) : undefined;
         if (siteKey !== undefined) {
             // Intentionally suppress every `inherits` site from the generic
             // reference bridge, even when this pre-pass can't emit an EXTENDS
@@ -139,6 +152,12 @@ function preEmitInheritanceEdges(graph, scopes, nodeLookup) {
         // 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);
+        // The instantiation this heritage clause wrote (`: IValidator<string>`),
+        // keyed by the same graph-id pair the edge itself carries. Only generic
+        // bases produce an entry; the sink owns the first-writer-wins rule.
+        if (site.typeArguments !== undefined) {
+            recordTypeArguments(callerGraphId, targetGraphId, site.typeArguments);
+        }
     }
     return handledSites;
 }
@@ -156,7 +175,7 @@ function preEmitInheritanceEdges(graph, scopes, nodeLookup) {
  */
 function emitDetectedInterfaceImplementations(graph, parsedFiles, nodeLookup, provider, indexes, model) {
     if (provider.detectInterfaceImplementations === undefined)
-        return 0;
+        return [];
     const graphIdByDefId = new Map();
     for (const parsed of parsedFiles) {
         for (const def of parsed.localDefs) {
@@ -171,14 +190,13 @@ function emitDetectedInterfaceImplementations(graph, parsedFiles, nodeLookup, pr
     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) {
+    for (const [interfaceDefId, implementorDefIds] of detected.implementations) {
         const targetId = graphIdByDefId.get(interfaceDefId);
         if (targetId === undefined)
             continue;
-        for (const implementorDefId of implementorDefIds) {
-            const sourceId = graphIdByDefId.get(implementorDefId);
+        for (const implementor of implementorDefIds) {
+            const sourceId = graphIdByDefId.get(implementor.structDefId);
             if (sourceId === undefined)
                 continue;
             const edgeKey = `${sourceId}->${targetId}`;
@@ -191,18 +209,30 @@ function emitDetectedInterfaceImplementations(graph, parsedFiles, nodeLookup, pr
                 targetId,
                 type: 'IMPLEMENTS',
                 confidence: 0.85,
-                reason: `${provider.language}-structural-implements`,
+                // 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;
+    // The interfaces this provider could not decide. They mint no edges — they
+    // exist so a query can report a lower bound instead of a confident zero
+    // (#2873); see `undecided-satisfaction.ts`.
+    return detected.undecided;
 }
 export function runScopeResolution(input, provider) {
     const { graph, files } = input;
     const callableFlowOnly = provider.scopeResolutionEdgeMode === 'callable-flow-only';
     const onWarn = input.onWarn ?? (() => { });
     const resolutionOutcomes = [];
+    const undecidedSatisfaction = [];
     const recordResolutionOutcome = (outcome) => {
         resolutionOutcomes.push(outcome);
         input.recordResolutionOutcome?.(outcome);
@@ -289,7 +319,15 @@ export function runScopeResolution(input, provider) {
             referenceEdgesEmitted: 0,
             referenceSkipped: 0,
             propertyDispatchSkippedKeys: 0,
+            importedValueRefEdges: 0,
+            uniqueNamePropertyEdges: 0,
+            uniqueNamePropertyAmbiguous: 0,
+            uniqueNamePropertyNarrowed: 0,
+            uniqueNamePropertyAmbiguousNames: [],
+            uniqueNamePropertyCrossLanguage: 0,
+            uniqueNamePropertyCrossLanguageNames: [],
             resolutionOutcomes,
+            undecidedSatisfaction,
             functionSummaries: [],
             callSummaries: [],
         };
@@ -316,7 +354,15 @@ export function runScopeResolution(input, provider) {
             referenceEdgesEmitted: 0,
             referenceSkipped: 0,
             propertyDispatchSkippedKeys: 0,
+            importedValueRefEdges: 0,
+            uniqueNamePropertyEdges: 0,
+            uniqueNamePropertyAmbiguous: 0,
+            uniqueNamePropertyNarrowed: 0,
+            uniqueNamePropertyAmbiguousNames: [],
+            uniqueNamePropertyCrossLanguage: 0,
+            uniqueNamePropertyCrossLanguageNames: [],
             resolutionOutcomes,
+            undecidedSatisfaction,
             functionSummaries: [],
             callSummaries: [],
         };
@@ -335,21 +381,36 @@ export function runScopeResolution(input, provider) {
                 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),
         },
     });
     logHeapProbe('sr-post-finalize', `lang=${provider.language}`);
+    // One store and ONE writer rule for heritage instantiations (#2912), shared by
+    // the pre-pass below and by the language hook further down — a heritage shape
+    // the pre-pass cannot express (Rust `impl T for S`, Dart `implements`) records
+    // through the same sink. FIRST writer wins: a repeated (sub, super) pair is a
+    // partial declaration or a re-listed base, and letting a later entry overwrite
+    // the first would make dispatch depend on file order.
+    const heritageTypeArguments = new Map();
+    const recordHeritageTypeArguments = (subtypeGraphId, supertypeGraphId, typeArguments) => {
+        if (typeArguments.length === 0)
+            return;
+        const key = heritageTypeArgumentsKey(subtypeGraphId, supertypeGraphId);
+        if (!heritageTypeArguments.has(key))
+            heritageTypeArguments.set(key, typeArguments);
+    };
     const preEmittedInheritanceSites = callableFlowOnly
         ? new Set()
-        : preEmitInheritanceEdges(graph, finalized, nodeLookup);
+        : preEmitInheritanceEdges(graph, finalized, nodeLookup, recordHeritageTypeArguments);
     // 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);
+        provider.emitHeritageEdges?.(graph, parsedFiles, nodeLookup, finalized, recordHeritageTypeArguments);
     }
     // Implicit IMPORTS-edge hook — for languages whose files have compiler-
     // implicit cross-file visibility (no syntactic import statement). The
@@ -368,7 +429,7 @@ export function runScopeResolution(input, provider) {
         ? buildGraphNodeLookup(graph)
         : nodeLookup;
     if (!callableFlowOnly) {
-        emitDetectedInterfaceImplementations(graph, parsedFiles, postHeritageNodeLookup, provider, finalized, readonlyModel);
+        undecidedSatisfaction.push(...emitDetectedInterfaceImplementations(graph, parsedFiles, postHeritageNodeLookup, provider, finalized, readonlyModel));
     }
     const mroByClassDefId = provider.buildMro(graph, parsedFiles, postHeritageNodeLookup);
     const extendsOnlyMroByClassDefId = provider.buildExtendsOnlyMro?.(graph, parsedFiles, postHeritageNodeLookup);
@@ -447,6 +508,76 @@ export function runScopeResolution(input, provider) {
     });
     const tResolve = PROF ? process.hrtime.bigint() : 0n;
     logHeapProbe('sr-post-resolve', `lang=${provider.language}`);
+    // Value defs bound at MODULE LEVEL. A read of a block-local `const` must not
+    // mint an edge — that would retain the inert locals `pruneLocalSymbols` drops.
+    //
+    // Built HERE, above the out-of-core seal, and deliberately from `parsedFiles`
+    // rather than `emitParsedFiles`. The seal below replaces the latter with a
+    // scope-STRIPPED copy, so building this after it walked `scopes: []` for every
+    // file and produced an empty set — which the filter then reads as "no def is
+    // module-level" and drops EVERY `Const`/`Variable`/`Static` ACCESSES edge in
+    // the repo, in all languages, on the one path (`GITNEXUS_DISK_SCOPE_INDEX=1`)
+    // taken by the largest repos. Nothing failed and nothing logged; the edges
+    // were simply absent, which is the confident-empty answer this PR exists to
+    // remove.
+    //
+    // ── The question is "is this def FUNCTION-LOCAL?", so ask exactly that ──
+    //
+    // This was first written as an ALLOWLIST of module-scope value defs, and that
+    // shape carried a defect that only shows outside JavaScript. A value def is
+    // not partitioned into {module-level, block-local}; there is a third home —
+    // a CLASS body. Java/C# fields and Python class attributes live there, and an
+    // allowlist keyed on "module level" excludes all of them by construction.
+    // Worse, the guard written to make that safe could not fire: the set is armed
+    // whenever a Module scope is FOUND, and Java has module scopes while having no
+    // module-level values at all, so for Java it armed permanently empty.
+    //
+    // Inverting it removes the whole class. A BLOCKLIST of defs positively
+    // identified as function-local fails safe: anything the walk does not
+    // recognise — a Java field, a Python class attribute, a language whose scopes
+    // could not be inspected at all — is emitted rather than dropped. That also
+    // retires `moduleScopesInspected`; there is nothing left to arm, because an
+    // empty blocklist and an uninspected one mean the same thing and both mean
+    // "emit". The failure mode moves from "silently deletes a whole edge class"
+    // to "retains an inert local", which is the direction this work wants.
+    //
+    // Built HERE, above the out-of-core seal, and deliberately from `parsedFiles`
+    // rather than `emitParsedFiles`. The seal below replaces the latter with a
+    // scope-STRIPPED copy, so building this after it walked `scopes: []` for every
+    // file and produced an empty set. Under the old allowlist that read as "no def
+    // is module-level" and dropped EVERY `Const`/`Variable`/`Static` ACCESSES edge
+    // in the repo on the one path (`GITNEXUS_DISK_SCOPE_INDEX=1`) taken by the
+    // largest repos. Under the blocklist the same mistake would merely stop
+    // filtering — still wrong, still worth the ordering, no longer catastrophic.
+    //
+    // A scope is function-local when its chain to the root passes through a
+    // `Function`. `Block`/`Expression`/`Object` alone are not enough: a bare block
+    // at module level still holds module-level values, and a `Namespace` nested in
+    // a function IS local, which the chain walk gets right for free.
+    const functionLocalValueDefIds = new Set();
+    for (const parsed of parsedFiles) {
+        const scopeById = new Map(parsed.scopes.map((sc) => [sc.id, sc]));
+        for (const scope of parsed.scopes) {
+            let cursor = scope;
+            let insideFunction = false;
+            while (cursor !== undefined) {
+                if (cursor.kind === 'Function') {
+                    insideFunction = true;
+                    break;
+                }
+                cursor = cursor.parent === null ? undefined : scopeById.get(cursor.parent);
+            }
+            if (!insideFunction)
+                continue;
+            for (const [, refs] of scope.bindings) {
+                for (const ref of refs) {
+                    if (isValueDefinitionLabel(ref.def.type)) {
+                        functionLocalValueDefIds.add(ref.def.nodeId);
+                    }
+                }
+            }
+        }
+    }
     // ── 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
@@ -494,12 +625,37 @@ export function runScopeResolution(input, provider) {
             ? undefined
             : (filePath, line, col) => callableArgumentSites.has(`${filePath}:${line}:${col}`))
         : undefined;
-    const receiverExtras = callableFlowOnly
-        ? 0
+    const receiverBound = callableFlowOnly
+        ? {
+            emitted: 0,
+            dispatchFanoutSkipped: 0,
+            dispatchFanoutSkippedNames: [],
+        }
         : 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,
+            // What each heritage clause instantiated its base with, so the
+            // interface-dispatch fan-out can refuse an incompatible instantiation
+            // (#2912). Empty under `callableFlowOnly`, which emits no dispatch.
+            heritageTypeArguments,
         });
+    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.warn({
+            lang: provider.language,
+            dispatchFanoutSkipped: receiverBound.dispatchFanoutSkipped,
+            dispatchFanoutSkippedNames: receiverBound.dispatchFanoutSkippedNames,
+            fanoutCap: 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;
@@ -513,6 +669,7 @@ export function runScopeResolution(input, provider) {
             freeCallsRequireInstanceOwnership: provider.freeCallsRequireInstanceOwnership === true,
             isCallableVisibleFromCaller: provider.isCallableVisibleFromCaller,
             resolveAdlCandidates: provider.resolveAdlCandidates,
+            resolveQualifiedFreeCall: provider.resolveQualifiedFreeCall,
             conversionRankFn: provider.conversionRankFn,
             conversionOnlyArgTypePrefixes: provider.conversionOnlyArgTypePrefixes,
             constraintCompatibility: provider.constraintCompatibility,
@@ -525,7 +682,64 @@ export function runScopeResolution(input, provider) {
         referenceSkipSites.add(key);
     const { emitted, skipped } = callableFlowOnly
         ? { emitted: 0, skipped: 0 }
-        : emitReferencesViaLookup(graph, indexes, referenceIndex, postHeritageNodeLookup, referenceSkipSites, calleeIdAccumulator);
+        : emitReferencesViaLookup(graph, indexes, referenceIndex, postHeritageNodeLookup, referenceSkipSites, calleeIdAccumulator, 
+        // A blocklist, so it needs no arming: empty means "nothing identified as
+        // function-local", which is also what an uninspected repo means, and
+        // both correctly emit. See the build site above for why the earlier
+        // allowlist could not be made safe this way.
+        functionLocalValueDefIds);
+    // Last-resort property resolution by workspace-unique name (A1/A5). Runs
+    // after every precise pass and only sees what they left behind, so a
+    // scope-resolved target always wins. Sites the generic bridge already
+    // resolved are excluded explicitly: `graph.addRelationship` is
+    // first-write-wins per edge id, which stops a DUPLICATE but not a second
+    // edge to a DIFFERENT target, and second-guessing a resolved receiver is
+    // exactly the wrong-edge-in-the-safety-gate case this must not create.
+    const uniqueNameSkipSites = new Set(referenceSkipSites);
+    for (const [fromScope, refs] of referenceIndex.bySourceScope) {
+        const fromFilePath = indexes.scopeTree.getScope(fromScope)?.filePath;
+        if (fromFilePath === undefined)
+            continue;
+        for (const ref of refs) {
+            uniqueNameSkipSites.add(callableFlowSiteKey(fromFilePath, ref.atRange));
+        }
+    }
+    // Gated on the language's own field-name-fallback policy. A statically-typed
+    // language sets `fieldFallbackOnMethodLookup: false` precisely because
+    // matching a member by name over-connects when a real type system could have
+    // answered exactly; inferring an ACCESSES edge by name is the same claim, so
+    // it must obey the same opt-out rather than route around it.
+    // Cross-file value references (A2): the read/write counterpart to
+    // `emitFreeCallFallback`. Runs BEFORE unique-name inference so a precise
+    // import-resolved target always wins over a name guess.
+    const importedValueRefs = callableFlowOnly
+        ? { emitted: 0 }
+        : emitImportedValueReferences(graph, indexes, emitParsedFiles, postHeritageNodeLookup, uniqueNameSkipSites);
+    // A language that opts out of name fallback still gets DETECTION. Skipping
+    // the pass outright also skipped its reporting, so a TypeScript read whose
+    // only anchor is JavaScript answered the same silent empty as the JS-read /
+    // TS-anchor case R3-1 was filed about — the identical defect, mirrored.
+    // `reportOnly` counts without emitting: no edge, no inference, no change to
+    // what the opt-out protects.
+    // PRECISE first (R3-5). A call result's return shape names WHICH producer a
+    // receiver holds, so it answers exactly the case name inference must refuse:
+    // several functions returning the same field name. Sites it resolves are
+    // added to the skip set, so the fallback below never second-guesses them.
+    const sharedPropertyIndex = input.prebuiltPropertyNameIndex ?? buildPropertyNameIndex(graph);
+    const returnShapeMembers = callableFlowOnly
+        ? { emitted: 0, memberNotOnShape: 0 }
+        : emitReturnShapeMemberAccesses(graph, indexes, emitParsedFiles, postHeritageNodeLookup, uniqueNameSkipSites, sharedPropertyIndex, uniqueNameSkipSites);
+    const nameFallbackDisabled = provider.fieldFallbackOnMethodLookup === false;
+    const uniqueNameProperties = callableFlowOnly
+        ? {
+            emitted: 0,
+            ambiguous: 0,
+            narrowed: 0,
+            ambiguousNames: [],
+            crossLanguageOnly: 0,
+            crossLanguageOnlyNames: [],
+        }
+        : emitUniqueNamePropertyAccesses(graph, indexes, emitParsedFiles, postHeritageNodeLookup, uniqueNameSkipSites, finalized, sharedPropertyIndex, nameFallbackDisabled);
     // 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
@@ -933,7 +1147,15 @@ export function runScopeResolution(input, provider) {
             propertyDispatch.callsEmitted,
         referenceSkipped: skipped,
         propertyDispatchSkippedKeys: propertyDispatch.skippedKeys,
+        importedValueRefEdges: importedValueRefs.emitted,
+        uniqueNamePropertyEdges: uniqueNameProperties.emitted,
+        uniqueNamePropertyAmbiguous: uniqueNameProperties.ambiguous,
+        uniqueNamePropertyNarrowed: uniqueNameProperties.narrowed,
+        uniqueNamePropertyAmbiguousNames: uniqueNameProperties.ambiguousNames,
+        uniqueNamePropertyCrossLanguage: uniqueNameProperties.crossLanguageOnly,
+        uniqueNamePropertyCrossLanguageNames: uniqueNameProperties.crossLanguageOnlyNames,
         resolutionOutcomes,
+        undecidedSatisfaction,
         functionSummaries: harvestedSummaries,
         callSummaries: harvestedCallSummaries,
     };