gitnexus 1.6.10-rc.98 → 1.6.10

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

@@ -49,6 +49,9 @@ export declare function emitFreeCallFallback(graph: KnowledgeGraph, scopes: Scop
             readonly startCol: number;
         };
     }, callerParsed: ParsedFile, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[]) => readonly SymbolDefinition[] | undefined;
+    /** Module-qualified free-call resolver (#2730) — see
+     *  `ScopeResolver.resolveQualifiedFreeCall`. */
+    readonly resolveQualifiedFreeCall?: ScopeResolver['resolveQualifiedFreeCall'];
     readonly conversionRankFn?: ConversionRankFn;
     readonly conversionOnlyArgTypePrefixes?: readonly string[];
     /** Optional per-language constraint hook threaded into

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, findEnclosingClassDef, resolveInheritanceBaseInScope, } from '../scope/walkers.js';
+import { findAllCallableBindingCandidatesInScope, 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;
@@ -32,6 +32,11 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
     // defs.byId.values() at every constructor call. Same simple-name keying
     // and class-like kind filter the previous per-site scan applied.
     const globalClassesBySimpleName = buildGlobalClassIndex(scopes);
+    // Workspace file-path set for `resolveQualifiedFreeCall` (a module path maps
+    // to a file by language convention). Built lazily and once: languages without
+    // the hook never pay for it.
+    let allFilePathsMemo;
+    const allFilePaths = () => (allFilePathsMemo ??= new Set(parsedFiles.map((p) => p.filePath)));
     // Per-pass memo of pickUniqueGlobalCallable's post-filter candidate list,
     // keyed (simpleName, callerFilePath). Only created when no per-caller
     // visibility filter applies (the list is then a pure function of name+file —
@@ -40,7 +45,43 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
     const scopeDefsCache = options.isCallableVisibleFromCaller === undefined
         ? new Map()
         : undefined;
+    const enclosingInstanceOwnerByScope = options.freeCallsRequireInstanceOwnership === true
+        ? new Map()
+        : undefined;
+    const reachableInstanceOwnersByOwner = options.freeCallsRequireInstanceOwnership === true
+        ? new Map()
+        : undefined;
+    const instanceOwnerKey = (ownerId) => {
+        const owner = scopes.defs.get(ownerId);
+        const qualifiedName = owner?.qualifiedName;
+        if (qualifiedName === undefined || qualifiedName === '')
+            return ownerId;
+        const namespacePrefix = owner.namespacePrefix ?? '';
+        return `${namespacePrefix.length}:${namespacePrefix}:${qualifiedName}`;
+    };
+    const isReachableInstanceOwner = (scopeId, ownerId) => {
+        let enclosing = enclosingInstanceOwnerByScope?.get(scopeId);
+        if (enclosing === undefined) {
+            enclosing = findEnclosingClassDef(scopeId, scopes) ?? null;
+            enclosingInstanceOwnerByScope?.set(scopeId, enclosing);
+        }
+        if (enclosing === null)
+            return false;
+        let owners = reachableInstanceOwnersByOwner?.get(enclosing.nodeId);
+        if (owners === undefined) {
+            const mutableOwners = new Set([instanceOwnerKey(enclosing.nodeId)]);
+            for (const inheritedOwnerId of scopes.methodDispatch.mroFor(enclosing.nodeId)) {
+                mutableOwners.add(instanceOwnerKey(inheritedOwnerId));
+            }
+            owners = mutableOwners;
+            reachableInstanceOwnersByOwner?.set(enclosing.nodeId, owners);
+        }
+        return owners.has(instanceOwnerKey(ownerId));
+    };
     for (const parsed of parsedFiles) {
+        const bindingCandidatesByScope = options.freeCallsRequireInstanceOwnership === true
+            ? new Map()
+            : undefined;
         for (const site of parsed.referenceSites) {
             if (site.kind !== 'call')
                 continue;
@@ -82,6 +123,18 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                     }
                 }
             }
+            // Module-qualified free call (`mod::fn()`): the source named the module
+            // explicitly, so that path outranks every lexical tier below — otherwise
+            // the scope-chain walk binds the bare tail to a same-named definition in
+            // the caller's own file and emits a self-loop instead of the real
+            // cross-module edge (#2730). Only fires when the language populated
+            // `rawQualifiedName` AND provides the hook; `undefined` falls through to
+            // the unchanged chain, so this tier is strictly additive.
+            if (fnDef === undefined &&
+                options.resolveQualifiedFreeCall !== undefined &&
+                site.rawQualifiedName !== undefined) {
+                fnDef = options.resolveQualifiedFreeCall(site, parsed, scopes, workspaceIndex, allFilePaths());
+            }
             // Implicit-this overload narrowing: an unqualified call inside
             // a method body might be calling a sibling overload on the
             // enclosing class. When the workspace has multiple methods of
@@ -108,10 +161,51 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                     // (local shadows import). When a conversion-rank function is
                     // available AND the binding scope contains multiple overloads,
                     // refine with narrowOverloadCandidates (#1578).
-                    fnDef = findCallableBindingInScope(site.inScope, site.name, scopes);
+                    let bindingCandidates;
+                    if (bindingCandidatesByScope !== undefined) {
+                        let byName = bindingCandidatesByScope.get(site.inScope);
+                        if (byName === undefined) {
+                            byName = new Map();
+                            bindingCandidatesByScope.set(site.inScope, byName);
+                        }
+                        bindingCandidates = byName.get(site.name);
+                        if (bindingCandidates === undefined) {
+                            bindingCandidates = findAllCallableBindingCandidatesInScope(site.inScope, site.name, scopes);
+                            byName.set(site.name, bindingCandidates);
+                        }
+                    }
+                    let eligibleBindingCandidates;
+                    if (bindingCandidates === undefined) {
+                        fnDef = findCallableBindingInScope(site.inScope, site.name, scopes);
+                    }
+                    else {
+                        eligibleBindingCandidates = bindingCandidates.filter((candidate) => {
+                            const def = candidate.def;
+                            if (def.type !== 'Method' ||
+                                def.ownerId === undefined ||
+                                def.filePath !== parsed.filePath) {
+                                return true;
+                            }
+                            const ownerReachable = isReachableInstanceOwner(site.inScope, def.ownerId);
+                            const staticallyImported = candidate.bindings.some((binding) => binding.visibility === 'static-member-import');
+                            return ownerReachable || staticallyImported;
+                        });
+                        fnDef = eligibleBindingCandidates[0]?.def;
+                        if (fnDef === undefined && bindingCandidates.length > 0) {
+                            recordSuppressedOutcome(options.recordResolutionOutcome, {
+                                phase: 'free-call-fallback',
+                                filePath: parsed.filePath,
+                                name: site.name,
+                                range: site.atRange,
+                                reason: 'free-call-instance-ownership',
+                                candidates: bindingCandidates.map((candidate) => candidate.def),
+                            });
+                        }
+                    }
                     if (fnDef !== undefined &&
                         options.isBuiltInName?.(site.name) === true &&
                         fnDef.filePath === parsed.filePath &&
+                        eligibleBindingCandidates?.some((candidate) => candidate.bindings.some((binding) => binding.visibility === 'static-member-import')) !== true &&
                         !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
@@ -138,45 +232,11 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                         // 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);
+                        (options.conversionRankFn !== undefined || bindingCandidates !== undefined)) {
+                        const allCallables = eligibleBindingCandidates === undefined
+                            ? findAllCallableBindingsInScope(site.inScope, site.name, scopes)
+                            : eligibleBindingCandidates.map((candidate) => candidate.def);
                         if (allCallables.length > 1) {
                             const narrowed = narrowOverloadCandidates(allCallables, site.arity, site.argumentTypes, {
                                 argumentTypeClasses: site.argumentTypeClasses,
@@ -535,7 +595,7 @@ export function pickUniqueGlobalCallable(name, model, globalCallablesBySimpleNam
     // when a visibility filter is present (`isCallerVisible !== undefined`),
     // because the list would then depend on the caller's scope, not just its file.
     const cacheKey = scopeDefsCache !== undefined && isCallerVisible === undefined
-        ? `${name}${callerFilePath}`
+        ? `${name}\0${callerFilePath}`
         : undefined;
     let scopeDefs = cacheKey !== undefined ? scopeDefsCache.get(cacheKey) : undefined;
     if (scopeDefs === undefined) {

package/dist/core/ingestion/scope-resolution/passes/imported-value-refs.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Cross-file value references, resolved post-finalize (A2).
+ *
+ * `resolveReferenceSites` runs against the registries, and — as its own
+ * comment says — "imports live in finalized bindings the registries can't
+ * see". That is why free CALLS need `emitFreeCallFallback`. Reads had no
+ * equivalent, so a module-scope `const` read from another file resolved to
+ * nothing: `import { DEFAULT_FETCH_LIMIT } from './config.js'` followed by a
+ * bare use produced no edge, while a CALL through the very same import
+ * statement resolved fine. "Who imports this constant?" — the question behind
+ * every constants refactor and dead-code trim — was unanswerable across files.
+ *
+ * This is the read/write counterpart to that call fallback, and it reuses the
+ * walker built for finalized bindings rather than inventing a lookup.
+ *
+ * DELIBERATELY CROSS-FILE ONLY. Same-file reads already resolve through the
+ * registries, so re-resolving them here would add nothing — and would add
+ * something unwanted: `findValueBindingInScope` accepts `Const`/`Variable`,
+ * which includes BLOCK-LOCAL values. Emitting an edge to one of those keeps
+ * alive exactly the inert local symbols `pruneLocalSymbols` exists to drop,
+ * inflating every indexed repo. A def in another file cannot be a block-local
+ * of this one, so the file guard is what keeps this pass proportional.
+ */
+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';
+export interface ImportedValueRefStats {
+    /** Cross-file value references resolved through finalized bindings. */
+    readonly emitted: number;
+}
+export declare function emitImportedValueReferences(graph: KnowledgeGraph, indexes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[], nodeLookup: GraphNodeLookup, 
+/** Sites an earlier pass already owns — never re-resolved here. */
+skipSites: ReadonlySet<string>): ImportedValueRefStats;

package/dist/core/ingestion/scope-resolution/passes/imported-value-refs.js

@@ -0,0 +1,62 @@
+/**
+ * Cross-file value references, resolved post-finalize (A2).
+ *
+ * `resolveReferenceSites` runs against the registries, and — as its own
+ * comment says — "imports live in finalized bindings the registries can't
+ * see". That is why free CALLS need `emitFreeCallFallback`. Reads had no
+ * equivalent, so a module-scope `const` read from another file resolved to
+ * nothing: `import { DEFAULT_FETCH_LIMIT } from './config.js'` followed by a
+ * bare use produced no edge, while a CALL through the very same import
+ * statement resolved fine. "Who imports this constant?" — the question behind
+ * every constants refactor and dead-code trim — was unanswerable across files.
+ *
+ * This is the read/write counterpart to that call fallback, and it reuses the
+ * walker built for finalized bindings rather than inventing a lookup.
+ *
+ * DELIBERATELY CROSS-FILE ONLY. Same-file reads already resolve through the
+ * registries, so re-resolving them here would add nothing — and would add
+ * something unwanted: `findValueBindingInScope` accepts `Const`/`Variable`,
+ * which includes BLOCK-LOCAL values. Emitting an edge to one of those keeps
+ * alive exactly the inert local symbols `pruneLocalSymbols` exists to drop,
+ * inflating every indexed repo. A def in another file cannot be a block-local
+ * of this one, so the file guard is what keeps this pass proportional.
+ */
+import { tryEmitEdge } from '../graph-bridge/edges.js';
+import { findValueBindingInScope } from '../scope/walkers.js';
+import { callableFlowSiteKey } from './callable-value-flow.js';
+/**
+ * Confidence for a reference resolved through a finalized import binding.
+ * This is a PRECISE resolution — the import names the def — so it carries the
+ * ordinary emission confidence, not the reduced tier used for name inference.
+ */
+const IMPORTED_VALUE_CONFIDENCE = 0.9;
+export function emitImportedValueReferences(graph, indexes, parsedFiles, nodeLookup, 
+/** Sites an earlier pass already owns — never re-resolved here. */
+skipSites) {
+    let emitted = 0;
+    const seen = new Set();
+    for (const parsed of parsedFiles) {
+        for (const site of parsed.referenceSites) {
+            if (site.kind !== 'read' && site.kind !== 'write')
+                continue;
+            // A member read (`obj.field`) is the receiver-bound passes' business;
+            // this pass exists for the BARE identifier an import binds.
+            if (site.explicitReceiver !== undefined)
+                continue;
+            const siteKey = callableFlowSiteKey(parsed.filePath, site.atRange);
+            if (skipSites.has(siteKey))
+                continue;
+            const def = findValueBindingInScope(site.inScope, site.name, indexes);
+            if (def === undefined)
+                continue;
+            // See the header: same-file hits are already resolved, and accepting
+            // them here would start emitting edges to block-local values.
+            if (def.filePath === parsed.filePath)
+                continue;
+            if (tryEmitEdge(graph, indexes, nodeLookup, site, def, 'import-resolved', seen, IMPORTED_VALUE_CONFIDENCE)) {
+                emitted++;
+            }
+        }
+    }
+    return { emitted };
+}

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

@@ -48,8 +48,12 @@ import type { CalleeIdSink } from '../graph-bridge/callee-id-sink.js';
  * 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).
+ *
+ * Override via `GITNEXUS_MAX_PROPERTY_DISPATCH_FANOUT` env var for repos with
+ * legitimate high-fanout property keys (e.g. large Vue codebases where
+ * `validator` exceeds the default).
  */
-export declare const MAX_PROPERTY_DISPATCH_FANOUT = 32;
+export declare const MAX_PROPERTY_DISPATCH_FANOUT: number;
 /** 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): {

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

@@ -45,8 +45,15 @@ import { findCallableBindingInScope } from '../scope/walkers.js';
  * 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).
+ *
+ * Override via `GITNEXUS_MAX_PROPERTY_DISPATCH_FANOUT` env var for repos with
+ * legitimate high-fanout property keys (e.g. large Vue codebases where
+ * `validator` exceeds the default).
  */
-export const MAX_PROPERTY_DISPATCH_FANOUT = 32;
+export const MAX_PROPERTY_DISPATCH_FANOUT = (() => {
+    const env = Number(process.env.GITNEXUS_MAX_PROPERTY_DISPATCH_FANOUT);
+    return Number.isInteger(env) && env >= 1 ? env : 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) {

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

@@ -8,14 +8,18 @@
  *
  *   1. **super branch** — `provider.isSuperReceiver(receiverName)` →
  *      MRO walk skipping self
- *   2. **Case 0 (compound)** — receiver has `.` or `(` → compound resolver
+ *   2. **Case 0 (compound)** — receiver has `.` or `(` → compound resolver.
+ *      Also emits the interface-dispatch fan-out when the folded receiver type
+ *      is an Interface (#2829) — see Case 4, which does the same.
  *   3. **Case 0.5 (implicit `this` receiver)** — GATED: fires only when
  *      the language sets `resolveThisViaEnclosingClass === true` AND the
  *      receiver is literally `this` → enclosing-class + MRO chain walk
  *      with C++ member-name-hiding semantics. Languages that leave the
  *      toggle unset skip this case entirely; their `this` sites fall
  *      through to Case 4 via the synthesized `this` typeBinding (which
- *      also emits interface-dispatch fan-out that this case does not).
+ *      emits the interface-dispatch fan-out that this case does not —
+ *      as do Cases 0 since #2829 and 3b since #2832; Case 0.5 remains
+ *      the only fold-or-walk case without it).
  *   4. **Case 1 (namespace)** — receiver in `namespaceTargets` → exported def
  *   5. **Case 2 (class-name / static receiver)** — receiver resolves to a
  *      class-like binding (Class/Interface/Struct/Record/Enum/Trait) → MRO
@@ -25,7 +29,9 @@
  *   6. **Case 3 (dotted typeBinding for namespace prefix)** —
  *      `typeRef.rawName` like `models.User`
  *   7. **Case 3b (chain-typebinding)** — `typeRef.rawName` has a dot
- *      but not a namespace prefix → compound resolver
+ *      but not a namespace prefix → compound resolver. Also emits the
+ *      interface-dispatch fan-out when the folded receiver type is an
+ *      Interface (#2832) — same call Cases 0 and 4 make.
  *   8. **Case 4 (simple typeBinding)** — `typeRef.rawName` has no dot →
  *      MRO walk + `findOwnedMember`
  *   9. **Case 5 (value-receiver bridge)** — receiver is a `Const`/`Variable`
@@ -33,6 +39,15 @@
  *      (object-literal services). Last-resort fallback for lowercase
  *      receivers with no class-like or type-binding match. Mirrors
  *      the legacy DAG bridge in `call-processor.ts`.
+ *  10. **Case 6 (class-level member receiver)** — `Holder.repo.save(u)`,
+ *      where the receiver's head is a CLASS and the one hop past it is a
+ *      class-level (`isStatic`) field. Types the receiver from that field
+ *      DEF's declared type rather than from a `typeBindings` entry, which
+ *      is the thing a per-scope binding map cannot hold for a class that
+ *      declares both a static and an instance member of one name. Gated on
+ *      Case 0 having declined the same receiver, so it only ever adds an
+ *      edge where there was none. Emits the interface-dispatch fan-out
+ *      alongside Cases 0, 3b and 4.
  *
  * Reordering or merging cases changes resolution semantics.
  *
@@ -50,12 +65,81 @@ import type { SemanticModel } from '../../model/semantic-model.js';
 import type { ScopeResolver } from '../contract/scope-resolver.js';
 import type { GraphNodeLookup } from '../graph-bridge/node-lookup.js';
 import type { WorkspaceResolutionIndex } from '../workspace-index.js';
+import { type DecorationStripper } from '../scope/walkers.js';
 import type { CalleeIdSink } from '../graph-bridge/callee-id-sink.js';
+import { type HeritageTypeArguments } from '../utils/generic-instantiation.js';
 import type { ResolutionOutcomeRecorder } from '../resolution-outcome.js';
+import type { ReceiverOrigin } from '../resolution-outcome.js';
+import type { DecodedReceiverChain } from '../../utils/receiver-chain-codec.js';
 /** Subset of `ScopeResolver` consumed by this pass. Accepting the
  *  subset rather than the full provider keeps tests and partial
  *  refactors lighter — callers only need to populate what we read. */
-type ReceiverBoundProviderSubset = Pick<ScopeResolver, 'isSuperReceiver' | 'isSuperReceiverInContext' | 'fieldFallbackOnMethodLookup' | 'collapseMemberCallsByCallerTarget' | 'unwrapCollectionAccessor' | 'hoistTypeBindingsToModule' | 'stripReceiverCastExpressions' | 'resolveQualifiedReceiverMember' | 'resolveReceiverMember' | 'resolveThisViaEnclosingClass' | 'conversionRankFn' | 'conversionOnlyArgTypePrefixes' | 'constraintCompatibility' | 'isStaticOnly'>;
+type ReceiverBoundProviderSubset = Pick<ScopeResolver, 'isSuperReceiver' | 'isSuperReceiverInContext' | 'fieldFallbackOnMethodLookup' | 'collapseMemberCallsByCallerTarget' | 'elementTypeOf' | 'hoistTypeBindingsToModule' | 'stripReceiverCastExpressions' | 'constructionSyntax' | 'stripTypePreservingDecoration' | 'resolveQualifiedReceiverMember' | 'namespaceReceiverPaths' | 'resolveReceiverMember' | 'resolveThisViaEnclosingClass' | 'conversionRankFn' | 'conversionOnlyArgTypePrefixes' | 'constraintCompatibility' | 'isStaticOnly' | 'normalizeTypeArgument'>;
+/**
+ * Is this dropped receiver rooted inside the analyzed program?
+ *
+ * Asks of the receiver's BASE — the leftmost name the chain hangs off — what
+ * this index can DEMONSTRATE. Three answers, and the asymmetry between them is
+ * the whole point:
+ *
+ * - `in-program` — the base's declared type resolves here, or the base itself is
+ *   a class, a qualified name, or a value this program declares. A real edge was
+ *   lost; the hedge must fire.
+ * - `external` — POSITIVE evidence that the target is outside: the language
+ *   itself names the base (or its bare declared type) a built-in. `console.log`,
+ *   `fetch(...)`, `JSON.stringify` reach code no index contains, so there is no
+ *   node an edge could have pointed at and nothing was lost.
+ * - `unknown` — everything else. An absence of evidence is NOT evidence of
+ *   externality: an unannotated parameter (`function f(svc) { svc.a().b(); }`)
+ *   is recorded nowhere in the scope model at all, and calling that "external"
+ *   published `epistemic: 'exact'` over a genuinely missing in-program caller —
+ *   strictly worse than hedging, because it is a confident wrong answer rather
+ *   than an admitted gap. `unknown` counts WITH `in-program` in
+ *   `summarizeUnresolvedReceivers`, which is the safe direction.
+ *
+ * Uses the AST-derived chain base when one was minted, and falls back to the
+ * head of the receiver text otherwise — never a regex over the source line.
+ *
+ * Exported for the unit tests that pin the three-way split; the pass is its only
+ * production caller.
+ */
+export declare function classifyReceiverOrigin(decoded: DecodedReceiverChain | undefined, inScope: string, receiverName: string, scopes: ScopeResolutionIndexes, options?: {
+    /** The language's type-preserving decoration stripper. Without it a Go
+     *  pointer receiver — `func (h *Host)` binds `h` to the literal `*Host` —
+     *  resolves to no class and the whole method body's drops were reported as
+     *  external. Same hook the three receiver-chain lookups in
+     *  `compound-receiver.ts` already receive. */
+    readonly stripTypePreservingDecoration?: DecorationStripper;
+    /** `LanguageProvider.isBuiltInName`, threaded through the pass options the
+     *  same way `emitFreeCallFallback` receives it. THE only source of positive
+     *  external evidence available here; languages that declare no built-in set
+     *  simply never produce an `external` verdict, which is the safe default. */
+    readonly isBuiltInName?: (name: string) => boolean;
+}): ReceiverOrigin;
+/**
+ * Upper bound on how many implementors ONE interface member may fan out to at a
+ * single call site (#2829).
+ *
+ * Mirrors `MAX_PROPERTY_DISPATCH_FANOUT` in `property-dispatch.ts`, deliberately
+ * including its reporting half: a bare cap would silently discard valid dispatch
+ * targets, which is the same false-safe silence #2813 was filed about. The
+ * default matches that sibling's 32 — the fan-out is a per-call-site product, so
+ * an interface with hundreds of implementors (mock proliferation is the usual
+ * cause) multiplies the graph without adding information a reader can act on.
+ *
+ * Override with `GITNEXUS_MAX_INTERFACE_DISPATCH_FANOUT` for a repo with
+ * legitimately high implementor counts.
+ */
+export declare const MAX_INTERFACE_DISPATCH_FANOUT: number;
+/** What `emitReceiverBoundCalls` reports back to the orchestrator. */
+export interface ReceiverBoundResult {
+    /** CALLS/ACCESSES edges emitted by this pass. */
+    readonly emitted: number;
+    /** Dispatch targets DROPPED because a member exceeded the fan-out cap. */
+    readonly dispatchFanoutSkipped: number;
+    /** Bounded sample naming which interface members lost targets. */
+    readonly dispatchFanoutSkippedNames: readonly string[];
+}
 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 under `--pdg`
@@ -63,7 +147,23 @@ export declare function emitReceiverBoundCalls(graph: KnowledgeGraph, scopes: Sc
      *  `undefined` ⇒ zero overhead, byte-identity (R4). Per-file capture
      *  contexts are built from this + `parsed.filePath` in the loop. */
     readonly calleeIdSink?: CalleeIdSink;
-}): number;
+    /** `LanguageProvider.isBuiltInName`. Passed through the options bag rather
+     *  than widened into `ReceiverBoundProviderSubset`, mirroring how
+     *  `emitFreeCallFallback` receives the same hook — the subset exists to keep
+     *  test providers small, and this pass reads nothing else off the language
+     *  provider. Consumed ONLY by `classifyReceiverOrigin`, so leaving it unset
+     *  degrades a drop's label to `unknown` (the safe direction) and changes no
+     *  edge. */
+    readonly isBuiltInName?: (name: string) => boolean;
+    /** The generic arguments each heritage clause instantiated its base with,
+     *  from the passes that emitted those heritage edges — the inheritance
+     *  pre-pass, and the language resolvers that emit their own (Rust `impl T
+     *  for S`, Dart `implements` / `with`) (#2912). Read
+     *  ONLY by the interface-dispatch fan-out, to refuse an implementor of an
+     *  incompatible instantiation. Absent ⇒ every heritage instantiation reads
+     *  as unknown ⇒ the pre-#2912 fan-out, unchanged. */
+    readonly heritageTypeArguments?: HeritageTypeArguments;
+}): ReceiverBoundResult;
 /**
  * Sentinel returned by `pickOverload` when narrowing leaves >1 candidate
  * sharing identical normalized parameter-types. Callers should suppress