gitnexus 1.6.8-rc.9 → 1.6.8

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

@@ -89,6 +89,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
             if (fnDef === undefined) {
                 fnDef = pickImplicitThisOverload(site, scopes, workspaceIndex, model, {
                     conversionRankFn: options.conversionRankFn,
+                    conversionOnlyArgTypePrefixes: options.conversionOnlyArgTypePrefixes,
                     constraintCompatibility: options.constraintCompatibility,
                 });
                 fnDefFromImplicitThis = fnDef !== undefined;
@@ -112,6 +113,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                             const narrowed = narrowOverloadCandidates(allCallables, site.arity, site.argumentTypes, {
                                 argumentTypeClasses: site.argumentTypeClasses,
                                 conversionRankFn: options.conversionRankFn,
+                                conversionOnlyArgTypePrefixes: options.conversionOnlyArgTypePrefixes,
                                 constraintCompatibility: options.constraintCompatibility,
                             });
                             if (narrowed.length === 1) {
@@ -190,6 +192,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                             const narrowed = narrowOverloadCandidates(ordinary, site.arity, site.argumentTypes, {
                                 argumentTypeClasses: site.argumentTypeClasses,
                                 conversionRankFn: options.conversionRankFn,
+                                conversionOnlyArgTypePrefixes: options.conversionOnlyArgTypePrefixes,
                                 constraintCompatibility: options.constraintCompatibility,
                             });
                             if (narrowed.length === 1) {
@@ -240,6 +243,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                         const narrowed = narrowOverloadCandidates(merged, site.arity, site.argumentTypes, {
                             argumentTypeClasses: site.argumentTypeClasses,
                             conversionRankFn: options.conversionRankFn,
+                            conversionOnlyArgTypePrefixes: options.conversionOnlyArgTypePrefixes,
                             constraintCompatibility: options.constraintCompatibility,
                         });
                         if (narrowed.length === 1) {
@@ -285,10 +289,22 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                         callerScope: site.inScope,
                         scopes,
                     })
-                    : undefined, site.argumentTypes, site.argumentTypeClasses, options.conversionRankFn, scopeDefsCache);
+                    : undefined, site.argumentTypes, site.argumentTypeClasses, options.conversionRankFn, scopeDefsCache, options.conversionOnlyArgTypePrefixes);
             }
             if (fnDef === undefined)
                 continue;
+            if (fnDef.isDeleted === true) {
+                recordSuppressedOutcome(options.recordResolutionOutcome, {
+                    phase: 'free-call-fallback',
+                    filePath: parsed.filePath,
+                    name: site.name,
+                    range: site.atRange,
+                    reason: 'selected-callable-deleted',
+                    candidates: [fnDef],
+                });
+                handledSites.add(siteKey(parsed.filePath, site));
+                continue;
+            }
             if ((fnDefFromImplicitThis || fnDef.type === 'Method' || fnDef.type === 'Constructor') &&
                 options.isCallableVisibleFromCaller !== undefined &&
                 !options.isCallableVisibleFromCaller({
@@ -310,6 +326,13 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
             // means we don't add a new edge — so `emit-references` skips its
             // potentially-wrong fallback for the same site.
             handledSites.add(siteKey(parsed.filePath, site));
+            // Resolved-callee-id capture (#2227 U2/KTD6/R8): record this CALLS site's
+            // resolved target BEFORE the collapsed `seen` dedup. The free-call dedup
+            // key drops the line (one edge per caller→target), so capturing after
+            // `seen.has` would lose every same-target call past the first — capture
+            // here, per site, keyed on `site.atRange` (byte-equal to U1's
+            // SiteRecord.at: 1-based line / 0-based col).
+            options.calleeIdSink?.add(parsed.filePath, site.atRange.startLine, site.atRange.startCol, tgtGraphId);
             const relId = `rel:CALLS:${callerGraphId}->${tgtGraphId}`;
             if (seen.has(relId))
                 continue;
@@ -430,7 +453,7 @@ export function buildGlobalClassIndex(scopes) {
  * order. Exported for unit testing — the `scopeDefsCache` equivalence is
  * exercised via synthetic stubs in `pick-unique-global-callable.test.ts`.
  */
-export function pickUniqueGlobalCallable(name, model, globalCallablesBySimpleName, callerFilePath, isFileLocalDef, callArity, isCallerVisible, callArgTypes, callArgTypeClasses, conversionRankFn, scopeDefsCache) {
+export function pickUniqueGlobalCallable(name, model, globalCallablesBySimpleName, callerFilePath, isFileLocalDef, callArity, isCallerVisible, callArgTypes, callArgTypeClasses, conversionRankFn, scopeDefsCache, conversionOnlyArgTypePrefixes) {
     // The scope-index candidate list is a pure function of (name, callerFilePath):
     // the same-name bucket is fixed for the pass, the file-local filter depends
     // only on the candidate + callerFilePath, and the logical-key dedup is
@@ -492,6 +515,7 @@ export function pickUniqueGlobalCallable(name, model, globalCallablesBySimpleNam
         const narrowed = narrowOverloadCandidates(scopeDefs, callArity, callArgTypes, {
             argumentTypeClasses: callArgTypeClasses,
             conversionRankFn,
+            conversionOnlyArgTypePrefixes,
         });
         if (narrowed.length === 1)
             return narrowed[0];
@@ -533,6 +557,7 @@ export function pickUniqueGlobalCallable(name, model, globalCallablesBySimpleNam
         const narrowed = narrowOverloadCandidates(defs, callArity, callArgTypes, {
             argumentTypeClasses: callArgTypeClasses,
             conversionRankFn,
+            conversionOnlyArgTypePrefixes,
         });
         if (narrowed.length === 1)
             return narrowed[0];
@@ -675,6 +700,7 @@ export function pickImplicitThisOverload(site, scopes, workspaceIndex, model, ho
     const candidates = narrowOverloadCandidates(overloads, site.arity, site.argumentTypes, {
         argumentTypeClasses: site.argumentTypeClasses,
         conversionRankFn: hookCtx?.conversionRankFn,
+        conversionOnlyArgTypePrefixes: hookCtx?.conversionOnlyArgTypePrefixes,
         constraintCompatibility: hookCtx?.constraintCompatibility,
     });
     if (candidates.length !== 1)

package/dist/core/ingestion/scope-resolution/passes/overload-narrowing.d.ts

@@ -69,6 +69,10 @@ export interface OverloadNarrowingHookCtx {
     /** Conversion-rank scoring fallback (step 4b). Engages when the
      *  exact-type filter rejects every candidate. */
     readonly conversionRankFn?: ConversionRankFn;
+    /** Per-language argument-type prefixes whose conversion-rank failures
+     *  should suppress genuinely ambiguous multi-overload sets instead of
+     *  falling back to arity-only candidates. */
+    readonly conversionOnlyArgTypePrefixes?: readonly string[];
     /** Constraint filter (step 4c). Drops candidates whose template
      *  guards (SFINAE `enable_if_t`, C++20 `requires`, future Rust
      *  trait bounds, etc.) provably fail at the call site. Three-valued

package/dist/core/ingestion/scope-resolution/passes/overload-narrowing.js

@@ -106,6 +106,10 @@ export function narrowOverloadCandidates(overloads, argCount, argTypes, hookCtx)
             const ranked = rankByConversion(candidates, argTypes, hookCtx.conversionRankFn, hookCtx.argumentTypeClasses);
             if (ranked.length > 0)
                 result = ranked;
+            else if (candidates.length > 1 &&
+                hasConversionOnlyArgType(argTypes, hookCtx.conversionOnlyArgTypePrefixes)) {
+                result = [];
+            }
         }
     }
     // Constraint filter (step 4c; Tier-A — SFINAE / `requires` clauses).
@@ -145,6 +149,11 @@ export function narrowOverloadCandidates(overloads, argCount, argTypes, hookCtx)
     }
     return result;
 }
+function hasConversionOnlyArgType(argTypes, prefixes) {
+    if (prefixes === undefined || prefixes.length === 0)
+        return false;
+    return argTypes.some((type) => prefixes.some((prefix) => type.startsWith(prefix)));
+}
 function exactTypeSlotMatches(argType, paramType, argTypeClass, paramTypeClass) {
     if (argType !== paramType)
         return false;

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

@@ -43,13 +43,18 @@ 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 { CalleeIdSink } from '../graph-bridge/callee-id-sink.js';
 import type { ResolutionOutcomeRecorder } from '../resolution-outcome.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' | 'resolveQualifiedReceiverMember' | 'resolveReceiverMember' | 'resolveThisViaEnclosingClass' | 'conversionRankFn' | 'constraintCompatibility' | 'isStaticOnly'>;
+type ReceiverBoundProviderSubset = Pick<ScopeResolver, 'isSuperReceiver' | 'isSuperReceiverInContext' | 'fieldFallbackOnMethodLookup' | 'collapseMemberCallsByCallerTarget' | 'unwrapCollectionAccessor' | 'hoistTypeBindingsToModule' | '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. */
+    readonly calleeIdSink?: CalleeIdSink;
 }): number;
 /**
  * Sentinel returned by `pickOverload` when narrowing leaves >1 candidate

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

@@ -38,7 +38,7 @@
  */
 import { collectNamespaceTargets } from '../scope/namespace-targets.js';
 import { findClassBindingInScope, findEnclosingClassDef, findExportedDef, findOwnedMember, findReceiverTypeBinding, findValueBindingInScope, isClassLike, } from '../scope/walkers.js';
-import { tryEmitEdge, tryEmitEdgeWithExplicitTargetId } from '../graph-bridge/edges.js';
+import { tryEmitEdge, tryEmitEdgeWithExplicitTargetId, } from '../graph-bridge/edges.js';
 import { resolveCompoundReceiverClass } from '../passes/compound-receiver.js';
 import { resolveDefGraphId } from '../graph-bridge/ids.js';
 import { narrowOverloadCandidates, isOverloadAmbiguousAfterNormalization, } from './overload-narrowing.js';
@@ -130,7 +130,7 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
      *  when the primary receiver-typed edge targeted an Interface's
      *  method. Each implementing class's same-named method gets a
      *  secondary edge (excluding the primary target itself). */
-    const emitInterfaceDispatchFor = (ownerDef, memberName, primaryMemberDef, site, confidence) => {
+    const emitInterfaceDispatchFor = (ownerDef, memberName, primaryMemberDef, site, confidence, calleeCapture) => {
         if (ownerDef.type !== 'Interface')
             return 0;
         const impls = implementorsByInterfaceDefId.get(ownerDef.nodeId);
@@ -138,12 +138,15 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
             return 0;
         let n = 0;
         for (const implDef of impls) {
-            const implMember = findOwnedMember(implDef.nodeId, memberName, model);
-            if (implMember === undefined)
+            const implMember = pickOverload(implDef.nodeId, memberName, site, model, provider);
+            if (implMember === undefined ||
+                implMember === OVERLOAD_AMBIGUOUS ||
+                implMember.isDeleted === true) {
                 continue;
+            }
             if (implMember.nodeId === primaryMemberDef.nodeId)
                 continue;
-            const ok = tryEmitEdge(graph, scopes, nodeLookup, site, implMember, 'interface-dispatch', seen, confidence, collapse);
+            const ok = tryEmitEdge(graph, scopes, nodeLookup, site, implMember, 'interface-dispatch', seen, confidence, collapse, calleeCapture);
             if (ok)
                 n++;
         }
@@ -151,6 +154,12 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
     };
     for (const parsed of parsedFiles) {
         const namespaceTargets = collectNamespaceTargets(parsed, scopes);
+        // Per-file resolved-callee-id capture context (#2227 U2). Built once per
+        // file; `undefined` when the sink is absent (pdg off) so the `tryEmitEdge`
+        // capture is a no-op and emission stays byte-identical (R4).
+        const calleeCapture = options.calleeIdSink !== undefined
+            ? { sink: options.calleeIdSink, filePath: parsed.filePath }
+            : undefined;
         for (const site of parsed.referenceSites) {
             if (site.kind !== 'call' && site.kind !== 'read' && site.kind !== 'write')
                 continue;
@@ -179,12 +188,30 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                         ? extendsOnly(enclosingClass.nodeId)
                         : scopes.methodDispatch.mroFor(enclosingClass.nodeId);
                     let memberDef;
+                    let ambiguousOwnerId;
                     for (const ownerId of ancestors) {
-                        memberDef = findOwnedMember(ownerId, memberName, model);
-                        if (memberDef !== undefined)
+                        const picked = site.kind === 'call'
+                            ? pickOverload(ownerId, memberName, site, model, provider)
+                            : findOwnedMember(ownerId, memberName, model);
+                        if (picked === OVERLOAD_AMBIGUOUS) {
+                            ambiguousOwnerId = ownerId;
+                            break;
+                        }
+                        if (picked !== undefined) {
+                            memberDef = picked;
                             break;
+                        }
+                    }
+                    if (ambiguousOwnerId !== undefined) {
+                        recordReceiverOverloadSuppression(options.recordResolutionOutcome, parsed.filePath, site, ambiguousOwnerId, memberName, model, provider);
+                        handledSites.add(siteKey);
+                        continue;
                     }
                     if (memberDef !== undefined) {
+                        if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, memberDef)) {
+                            handledSites.add(siteKey);
+                            continue;
+                        }
                         // Super/base calls resolve through the MRO chain, not
                         // through imports — the ancestor method is found by
                         // walking `methodDispatch.mroFor(enclosingClass)`, which
@@ -201,7 +228,7 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                         // superclass via its `import`/`from … import …` binding.
                         // Closing that gap requires realigning the legacy tier
                         // classifier and is tracked separately.
-                        const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, 'global', seen, 0.85, collapse);
+                        const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, 'global', seen, 0.85, collapse, calleeCapture);
                         if (ok)
                             emitted++;
                         // Always mark handled when the site was resolved, even
@@ -219,9 +246,9 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                 if (currentClass !== undefined) {
                     const chain = [currentClass.nodeId, ...scopes.methodDispatch.mroFor(currentClass.nodeId)];
                     let memberDef;
+                    let ambiguousOwnerId;
                     // Static-only filter (#1756 / U3): same shape as Case 4's
-                    // chain walk (skip-and-walk-on) but without overload
-                    // narrowing — Case 0 uses `findOwnedMember` directly. When
+                    // overload-aware chain walk (skip-and-walk-on). When
                     // an owner's resolved candidate is static-only (Kotlin
                     // companion-promoted), continue to the next ancestor in
                     // the MRO chain so a legitimate instance member can bind.
@@ -233,18 +260,30 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                     // shapes like `Logger.create("a")`), so there's no wrong
                     // target to suppress.
                     for (const ownerId of chain) {
-                        const candidate = findOwnedMember(ownerId, memberName, model);
-                        if (candidate === undefined)
-                            continue;
-                        if (provider.isStaticOnly?.(candidate) === true) {
-                            // Skip static-only candidate; walk to next ancestor.
+                        const picked = site.kind === 'call'
+                            ? pickFirstNonStaticOnly(ownerId, memberName, site, model, provider)
+                            : findOwnedMember(ownerId, memberName, model);
+                        if (picked === OVERLOAD_AMBIGUOUS) {
+                            ambiguousOwnerId = ownerId;
+                            break;
+                        }
+                        if (picked === STATIC_ONLY_FILTERED || picked === undefined) {
                             continue;
                         }
-                        memberDef = candidate;
+                        memberDef = picked;
                         break;
                     }
+                    if (ambiguousOwnerId !== undefined) {
+                        recordReceiverOverloadSuppression(options.recordResolutionOutcome, parsed.filePath, site, ambiguousOwnerId, memberName, model, provider);
+                        handledSites.add(siteKey);
+                        continue;
+                    }
                     if (memberDef !== undefined) {
-                        const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, memberDef.filePath !== parsed.filePath ? 'import-resolved' : 'global', seen, 0.85, collapse);
+                        if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, memberDef)) {
+                            handledSites.add(siteKey);
+                            continue;
+                        }
+                        const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, memberDef.filePath !== parsed.filePath ? 'import-resolved' : 'global', seen, 0.85, collapse, calleeCapture);
                         if (ok)
                             emitted++;
                         // Always mark handled when the site was resolved, even
@@ -290,13 +329,17 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                     }
                     if (languageResolution?.kind === 'resolved') {
                         const memberDef = languageResolution.definition;
+                        if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, memberDef)) {
+                            handledSites.add(siteKey);
+                            continue;
+                        }
                         const reason = site.kind === 'write' || site.kind === 'read'
                             ? site.kind
                             : memberDef.filePath !== parsed.filePath
                                 ? 'import-resolved'
                                 : 'global';
                         const confidence = site.kind === 'write' || site.kind === 'read' ? 1.0 : 0.85;
-                        const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, reason, seen, confidence, collapse);
+                        const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, reason, seen, confidence, collapse, calleeCapture);
                         if (ok)
                             emitted++;
                         handledSites.add(siteKey);
@@ -315,6 +358,7 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                             const narrowed = narrowOverloadCandidates(methodOverloads, site.arity, site.argumentTypes, {
                                 argumentTypeClasses: site.argumentTypeClasses,
                                 conversionRankFn: provider.conversionRankFn,
+                                conversionOnlyArgTypePrefixes: provider.conversionOnlyArgTypePrefixes,
                                 constraintCompatibility: provider.constraintCompatibility,
                             });
                             if (isOverloadAmbiguousAfterNormalization(narrowed, site.arity)) {
@@ -357,13 +401,17 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                         continue;
                     }
                     if (memberDef !== undefined) {
+                        if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, memberDef)) {
+                            handledSites.add(siteKey);
+                            continue;
+                        }
                         const reason = site.kind === 'write' || site.kind === 'read'
                             ? site.kind
                             : memberDef.filePath !== parsed.filePath
                                 ? 'import-resolved'
                                 : 'global';
                         const confidence = site.kind === 'write' || site.kind === 'read' ? 1.0 : 0.85;
-                        const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, reason, seen, confidence, collapse);
+                        const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, reason, seen, confidence, collapse, calleeCapture);
                         if (ok)
                             emitted++;
                         handledSites.add(siteKey);
@@ -373,12 +421,17 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
             }
             // ── Case 1: namespace receiver ───────────────────────────────
             const targetFiles = namespaceTargets.get(receiverName);
-            if (targetFiles !== undefined) {
+            if (targetFiles !== undefined && provider.resolveQualifiedReceiverMember === undefined) {
                 let found = false;
                 for (const targetFile of targetFiles) {
                     const memberDef = findExportedDef(targetFile, memberName, index);
                     if (memberDef !== undefined) {
-                        const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, memberDef.filePath !== parsed.filePath ? 'import-resolved' : 'global', seen, 0.85, collapse);
+                        if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, memberDef)) {
+                            handledSites.add(siteKey);
+                            found = true;
+                            break;
+                        }
+                        const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, memberDef.filePath !== parsed.filePath ? 'import-resolved' : 'global', seen, 0.85, collapse, calleeCapture);
                         if (ok)
                             emitted++;
                         handledSites.add(siteKey);
@@ -413,7 +466,11 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                     continue;
                 }
                 if (memberDef !== undefined) {
-                    const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, memberDef.filePath !== parsed.filePath ? 'import-resolved' : 'global', seen, 0.85, collapse);
+                    if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, memberDef)) {
+                        handledSites.add(siteKey);
+                        continue;
+                    }
+                    const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, memberDef.filePath !== parsed.filePath ? 'import-resolved' : 'global', seen, 0.85, collapse, calleeCapture);
                     if (ok)
                         emitted++;
                     handledSites.add(siteKey);
@@ -425,9 +482,17 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
             if (classDef !== undefined) {
                 const chain = [classDef.nodeId, ...scopes.methodDispatch.mroFor(classDef.nodeId)];
                 let memberDef;
+                let ambiguousOwnerId;
                 for (const ownerId of chain) {
-                    memberDef = findOwnedMember(ownerId, memberName, model);
-                    if (memberDef !== undefined) {
+                    const picked = site.kind === 'call'
+                        ? pickOverload(ownerId, memberName, site, model, provider)
+                        : findOwnedMember(ownerId, memberName, model);
+                    if (picked === OVERLOAD_AMBIGUOUS) {
+                        ambiguousOwnerId = ownerId;
+                        break;
+                    }
+                    if (picked !== undefined) {
+                        memberDef = picked;
                         // The MRO chain is most-derived-first ([classDef, ...ancestors]).
                         // If the most-derived definition is arity-incompatible with the
                         // call site, PHP throws ArgumentCountError at runtime — it does
@@ -441,14 +506,23 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                         break;
                     }
                 }
+                if (ambiguousOwnerId !== undefined) {
+                    recordReceiverOverloadSuppression(options.recordResolutionOutcome, parsed.filePath, site, ambiguousOwnerId, memberName, model, provider);
+                    handledSites.add(siteKey);
+                    continue;
+                }
                 if (memberDef !== undefined) {
+                    if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, memberDef)) {
+                        handledSites.add(siteKey);
+                        continue;
+                    }
                     const reason = site.kind === 'write' || site.kind === 'read'
                         ? site.kind
                         : memberDef.filePath !== parsed.filePath
                             ? 'import-resolved'
                             : 'global';
                     const confidence = site.kind === 'write' || site.kind === 'read' ? 1.0 : 0.85;
-                    const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, reason, seen, confidence, collapse);
+                    const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, reason, seen, confidence, collapse, calleeCapture);
                     if (ok)
                         emitted++;
                     handledSites.add(siteKey);
@@ -466,9 +540,26 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                     for (const targetFile3 of targetFiles3) {
                         const classDef3 = findExportedDef(targetFile3, className, index);
                         if (classDef3 !== undefined) {
-                            const memberDef = findOwnedMember(classDef3.nodeId, memberName, model);
-                            if (memberDef !== undefined) {
-                                const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, memberDef.filePath !== parsed.filePath ? 'import-resolved' : 'global', seen);
+                            const picked = site.kind === 'call'
+                                ? pickOverload(classDef3.nodeId, memberName, site, model, provider)
+                                : findOwnedMember(classDef3.nodeId, memberName, model);
+                            if (picked === OVERLOAD_AMBIGUOUS) {
+                                recordReceiverOverloadSuppression(options.recordResolutionOutcome, parsed.filePath, site, classDef3.nodeId, memberName, model, provider);
+                                handledSites.add(siteKey);
+                                found3 = true;
+                                break;
+                            }
+                            if (picked !== undefined) {
+                                const memberDef = picked;
+                                if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, memberDef)) {
+                                    handledSites.add(siteKey);
+                                    found3 = true;
+                                    break;
+                                }
+                                const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, memberDef.filePath !== parsed.filePath ? 'import-resolved' : 'global', seen, 
+                                // Explicit defaults so the trailing capture ctx (#2227 U2) can
+                                // be threaded without changing dedup/confidence behavior.
+                                0.85, false, calleeCapture);
                                 if (ok) {
                                     emitted++;
                                     handledSites.add(siteKey);
@@ -504,8 +595,9 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                 if (ownerDef !== undefined) {
                     const chain = [ownerDef.nodeId, ...scopes.methodDispatch.mroFor(ownerDef.nodeId)];
                     let memberDef;
-                    // Static-only filter (#1756 / U3): mirrors Case 0's chain
-                    // walk — `findOwnedMember` without overload narrowing. When
+                    let ambiguousOwnerId;
+                    // Static-only filter (#1756 / U3): mirrors Case 0's
+                    // overload-aware chain walk. When
                     // a static-only candidate is found at an ancestor, walk on
                     // so a legitimate instance member can bind. If the entire
                     // chain is static-only, no edge is emitted (Case 3b is fed
@@ -513,17 +605,30 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                     // `emitReferencesViaLookup` for compound shapes, so no
                     // handled-site marker is needed for chain-only-static).
                     for (const ownerId of chain) {
-                        const candidate = findOwnedMember(ownerId, memberName, model);
-                        if (candidate === undefined)
-                            continue;
-                        if (provider.isStaticOnly?.(candidate) === true) {
+                        const picked = site.kind === 'call'
+                            ? pickFirstNonStaticOnly(ownerId, memberName, site, model, provider)
+                            : findOwnedMember(ownerId, memberName, model);
+                        if (picked === OVERLOAD_AMBIGUOUS) {
+                            ambiguousOwnerId = ownerId;
+                            break;
+                        }
+                        if (picked === STATIC_ONLY_FILTERED || picked === undefined) {
                             continue;
                         }
-                        memberDef = candidate;
+                        memberDef = picked;
                         break;
                     }
+                    if (ambiguousOwnerId !== undefined) {
+                        recordReceiverOverloadSuppression(options.recordResolutionOutcome, parsed.filePath, site, ambiguousOwnerId, memberName, model, provider);
+                        handledSites.add(siteKey);
+                        continue;
+                    }
                     if (memberDef !== undefined) {
-                        const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, memberDef.filePath !== parsed.filePath ? 'import-resolved' : 'global', seen, 0.85, collapse);
+                        if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, memberDef)) {
+                            handledSites.add(siteKey);
+                            continue;
+                        }
+                        const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, memberDef.filePath !== parsed.filePath ? 'import-resolved' : 'global', seen, 0.85, collapse, calleeCapture);
                         if (ok)
                             emitted++;
                         // Always mark handled when the site was resolved, even
@@ -574,13 +679,17 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                     }
                     if (languageResolution?.kind === 'resolved') {
                         const memberDef = languageResolution.definition;
+                        if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, memberDef)) {
+                            handledSites.add(siteKey);
+                            continue;
+                        }
                         const reason = site.kind === 'write' || site.kind === 'read'
                             ? site.kind
                             : memberDef.filePath !== parsed.filePath
                                 ? 'import-resolved'
                                 : 'global';
                         const confidence = site.kind === 'write' || site.kind === 'read' ? 1.0 : 0.85;
-                        const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, reason, seen, confidence, collapse);
+                        const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, reason, seen, confidence, collapse, calleeCapture);
                         if (ok)
                             emitted++;
                         handledSites.add(siteKey);
@@ -657,6 +766,10 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                         continue;
                     }
                     if (memberDef !== undefined) {
+                        if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, memberDef)) {
+                            handledSites.add(siteKey);
+                            continue;
+                        }
                         // For read/write ACCESSES, mirror the legacy DAG's reason
                         // convention so consumers asserting `reason === 'write'`
                         // keep working.
@@ -666,13 +779,13 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                                 ? 'import-resolved'
                                 : 'global';
                         const confidence = site.kind === 'write' || site.kind === 'read' ? 1.0 : 0.85;
-                        const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, reason, seen, confidence, collapse);
+                        const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, reason, seen, confidence, collapse, calleeCapture);
                         if (ok)
                             emitted++;
                         // Interface dispatch: when the primary owner is an
                         // Interface, emit secondary CALLS edges to every
                         // implementing class's same-named method.
-                        emitted += emitInterfaceDispatchFor(ownerDef, memberName, memberDef, site, confidence);
+                        emitted += emitInterfaceDispatchFor(ownerDef, memberName, memberDef, site, confidence, calleeCapture);
                         // Always mark handled when the site was resolved, even
                         // if the edge was deduplicated (collapse mode), so
                         // `emitReferencesViaLookup` doesn't re-emit from the
@@ -713,6 +826,10 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                     continue;
                 }
                 if (picked !== undefined) {
+                    if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, picked)) {
+                        handledSites.add(siteKey);
+                        continue;
+                    }
                     // Static-only filter (#1756 / U3): unlike Case 4 there's no
                     // MRO chain to walk here — Case 5 dispatches on a single
                     // owner via `pickOverload`. When the picked candidate is
@@ -732,7 +849,7 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                             ? 'import-resolved'
                             : 'global';
                     const confidence = site.kind === 'write' || site.kind === 'read' ? 1.0 : 0.85;
-                    const ok = tryEmitEdgeWithExplicitTargetId(graph, scopes, nodeLookup, site, picked.nodeId, reason, seen, confidence, collapse);
+                    const ok = tryEmitEdgeWithExplicitTargetId(graph, scopes, nodeLookup, site, picked.nodeId, reason, seen, confidence, collapse, calleeCapture);
                     if (ok)
                         emitted++;
                     handledSites.add(siteKey);
@@ -760,6 +877,7 @@ function pickOverload(ownerId, memberName, site, model, provider) {
     const candidates = narrowOverloadCandidates(overloads, site.arity, site.argumentTypes, {
         argumentTypeClasses: site.argumentTypeClasses,
         conversionRankFn: provider.conversionRankFn,
+        conversionOnlyArgTypePrefixes: provider.conversionOnlyArgTypePrefixes,
         constraintCompatibility: provider.constraintCompatibility,
     });
     // When narrowing leaves >1 candidate that share identical normalized
@@ -860,6 +978,7 @@ function pickFirstNonStaticOnly(ownerId, memberName, site, model, provider) {
     const candidates = narrowOverloadCandidates(overloads, site.arity, site.argumentTypes, {
         argumentTypeClasses: site.argumentTypeClasses,
         conversionRankFn: provider.conversionRankFn,
+        conversionOnlyArgTypePrefixes: provider.conversionOnlyArgTypePrefixes,
         constraintCompatibility: provider.constraintCompatibility,
     });
     // Same ambiguity handling as `pickOverload`: when normalization
@@ -873,6 +992,20 @@ function pickFirstNonStaticOnly(ownerId, memberName, site, model, provider) {
         return OVERLOAD_AMBIGUOUS;
     return candidates[0] ?? overloads[0];
 }
+function suppressDeletedCallTarget(record, filePath, site, target) {
+    if (site.kind !== 'call' || target.isDeleted !== true)
+        return false;
+    record?.({
+        kind: 'suppressed',
+        phase: 'receiver-bound-calls',
+        filePath,
+        name: site.name,
+        range: site.atRange,
+        reason: 'selected-callable-deleted',
+        candidateIds: [target.nodeId],
+    });
+    return true;
+}
 function recordReceiverOverloadSuppression(record, filePath, site, ownerId, memberName, model, provider) {
     if (record === undefined)
         return;
@@ -880,6 +1013,7 @@ function recordReceiverOverloadSuppression(record, filePath, site, ownerId, memb
     const candidates = narrowOverloadCandidates(overloads, site.arity, site.argumentTypes, {
         argumentTypeClasses: site.argumentTypeClasses,
         conversionRankFn: provider.conversionRankFn,
+        conversionOnlyArgTypePrefixes: provider.conversionOnlyArgTypePrefixes,
         constraintCompatibility: provider.constraintCompatibility,
     });
     const reason = isOverloadAmbiguousAfterNormalization(candidates, site.arity)