ucn 5.3.4 → 5.3.6

package/core/callers.js

@@ -12,8 +12,13 @@ const { detectLanguage, getParser, getLanguageAdapter, langTraits } = require('.
 const { isTestFile } = require('./discovery');
 const { NON_CALLABLE_TYPES, isOverrideMarked, codeUnitCompare, isTestPath, CALLABLE_SYMBOL_KINDS } = require('./shared');
 const { _resolveJavaPackageImport } = require('./graph-build');
-const { scoreEdge, tierForResolution, TIER } = require('./confidence');
+const { scoreEdge, tierForResolution, TIER, validateConfirmation } = require('./confidence');
+const { summarizeProvenance, declarationIdentity, sameDeclaration } = require('./provenance');
+const { confirmationFacts, occurrenceIdentity } = require('./provenance-facts');
+const { BUILTIN_RECEIVER_TYPES, isProvenanceBuiltinReceiver } = require('./receiver-types');
 const { findGoModule, resolveRustImport } = require('./imports');
+const { rustWrapperContract, validateRustWrapperContract } = require('./rust-result-flow');
+const { pythonFixtureReceiver, pythonFixtureType } = require('./python-fixture-flow');
 
 const CONSTRUCTABLE_BINDING_KINDS = new Set([
     'class', 'struct', 'record', 'enum', 'function',
@@ -23,6 +28,45 @@ const RESERVED_RECEIVER_NAMES = new Set([
 ]);
 const CROSS_OPERATION_FLOW_CACHE_LIMIT = 4096;
 
+function _confirmationFacts(index, file, call, targets, options = {}) {
+    return confirmationFacts(index, file, call, targets, {
+        ...options,
+        selectOverload: selectProvenanceOverload,
+        typeHead: name => _structuralTypeHead(name, { index, language: index.files.get(file)?.language }),
+        resolveType(name, context, line, qualified) {
+            const language = index.files.get(context)?.language;
+            const parts = name.split(name.includes('::') ? '::' : '.');
+            if (parts.length > 1) {
+                const simple = parts.pop();
+                const qualifier = parts.join(language === 'cpp' ? '::' : '.');
+                const named = (index.symbols.get(simple) || []).filter(d =>
+                    IDENTITY_TYPE_KINDS.has(d.type) && d.namespace === qualifier &&
+                    (d.file === context || index.importGraph.get(context)?.has(d.file)));
+                if (named.length === 1) return named[0];
+            }
+            if (language === 'java' || language === 'csharp') {
+                const definitions = (index.symbols.get(name) || []).filter(d => IDENTITY_TYPE_KINDS.has(d.type));
+                const selected = definitions.filter(d => _resolveReceiverTypeIdentity(
+                    index, context, name, [{ ...d, className: name }], line, qualified) === 'target');
+                if (selected.length === 1) return selected[0];
+            }
+            if (language === 'java' && qualified) {
+                const nested = (index.symbols.get(name) || []).filter(d =>
+                    IDENTITY_TYPE_KINDS.has(d.type) && d.enclosingType === qualified);
+                if (nested.length === 1) return nested[0];
+            }
+            const origin = _resolveFlowTypeOrigin(index, context, name, qualified);
+            if (!origin?.fromFile) return null;
+            const definitions = (index.symbols.get(name) || []).filter(d =>
+                (IDENTITY_TYPE_KINDS.has(d.type) || (d.type === 'type' && d.aliasOf)) &&
+                d.file === origin.fromFile &&
+                (!d.lexicalScopeStartLine || (line != null &&
+                    line >= d.lexicalScopeStartLine && line <= d.lexicalScopeEndLine)));
+            return definitions.length === 1 ? definitions[0] : null;
+        },
+    });
+}
+
 // `base` is a contextual receiver keyword only in C#. TypeScript and the
 // other supported languages may bind an ordinary local named base; treating
 // it as reserved globally suppresses otherwise exact assignment flow.
@@ -290,8 +334,9 @@ function findCallers(index, name, options = {}) {
     // lookup); the rest stay as shadow-style records. Display caps are handled
     // by formatters — this only bounds file reads.
     const unverifiedEnrichLimit = options.unverifiedEnrichLimit ?? 10;
-    const recordExcluded = (filePath, line, reason) => {
-        if (accountRaw) accountRaw.excludedEntries.push({ file: filePath, line, reason });
+    const recordExcluded = (filePath, line, reason, provenance) => {
+        if (accountRaw) accountRaw.excludedEntries.push({ file: filePath, line, reason,
+            ...(provenance && { provenance }) });
     };
 
     const definitions = index.symbols.get(name) || [];
@@ -556,7 +601,7 @@ function findCallers(index, name, options = {}) {
     // unverified-tier entry (tiered caller contract: shown in its own
     // section, never silently hidden). Does NOT count toward pendingCount —
     // totals describe the confirmed answer.
-    const routeUnverified = (filePath, fileEntry, call, reason, calledAs, meta) => {
+    const routeUnverified = (filePath, fileEntry, call, reason, calledAs, meta, facts) => {
         if (!collectAccount) return; // non-account paths (trace/blast/verify) keep the plain drop
         const compilerSelectsOverload = cppOverloadDispatchTarget &&
             (reason === 'overload-ambiguous' || reason === 'ambiguous-binding' ||
@@ -582,11 +627,28 @@ function findCallers(index, name, options = {}) {
             _tier: TIER.UNVERIFIED, _reason: reason, _meta: meta,
             // Dispatch-tiered routes carry their own resolution so JSON output
             // distinguishes "possible virtual dispatch" from a bare uncertain.
-            _evidence: reason === 'possible-dispatch' ? { possibleDispatch: true }
+            _evidence: { ...(reason === 'single-owner' ? { hasSingleOwnerEvidence: true }
+                : reason === 'possible-dispatch' ? { possibleDispatch: true }
                 : reason === 'method-ambiguous' ? { methodAmbiguous: true }
-                : { isUncertain: true },
+                : { isUncertain: true }), ...(facts && { facts }) },
         });
     };
+    const excludeReceiver = (filePath, fileEntry, call, calledAs, receiverOptions = {}) => {
+        const targets = options.targetDefinitions || definitions;
+        const facts = _confirmationFacts(index, filePath, call, targets, receiverOptions);
+        if ((BUILTIN_RECEIVER_TYPES.has(facts.receiverType) ||
+            (fileEntry.language === 'rust' && ['Option', 'Result', 'Vec'].includes(facts.receiverType))) &&
+            (facts.receiverTypeSource === 'literal' || !facts.receiverTypeDeclaration)) {
+            facts.builtinReceiver = { type: facts.receiverType, language: fileEntry.language };
+        }
+        const provenance = scoreEdge({ hasReceiverType: true, facts }).provenance;
+        const checked = validateConfirmation(provenance, facts.targets);
+        if (checked.verdict === 'establishes-other' || checked.verdict === 'unsupported') {
+            recordExcluded(filePath, call.line, 'receiver-type-mismatch', provenance);
+        } else {
+            routeUnverified(filePath, fileEntry, call, 'provenance-incomplete', calledAs, undefined, facts);
+        }
+    };
     const maxResults = options.maxResults;
     // BUG-H1: when consumers (like `about`) need an accurate truncation header
     // ("showing N of <total>"), they pass needsTotal:true so Phase 1 runs to
@@ -670,6 +732,21 @@ function findCallers(index, name, options = {}) {
                     calledAs = call.name;
                 }
 
+                const standardWrapper = fileEntry.language === 'rust'
+                    ? _rustStandardWrapperMethod(index, filePath, call, calls) : null;
+                if (standardWrapper) {
+                    const facts = { language: 'rust', site: occurrenceIdentity(fileEntry.relativePath, call),
+                        targets: (options.targetDefinitions || definitions).map(declarationIdentity), standardWrapper };
+                    const checked = validateConfirmation({ facts }, facts.targets);
+                    if (checked.verdict === 'establishes-other') {
+                        recordExcluded(filePath, call.line, 'standard-wrapper-method', {
+                            rule: 'rust-standard-wrapper', rules: ['rust-standard-wrapper'], facts,
+                            validation: checked.verdict, diagnostic: 'standard-wrapper-method',
+                        });
+                        continue;
+                    }
+                }
+
                 // A direct static call cannot cross an unrelated runtime
                 // language boundary. A Python `service.get` is not a possible
                 // target of JavaScript `map.get()`, nor can a Java method be
@@ -692,6 +769,8 @@ function findCallers(index, name, options = {}) {
                         call = {
                             ...call,
                             receiverType: indexedType.type,
+                            receiverTypeSource: 'flow',
+                            receiverTypeEvidence: { source: 'flow', ...indexedType },
                             ...(indexedType.fromFile && {
                                 receiverTypeFlowFile: indexedType.fromFile,
                             }),
@@ -925,7 +1004,7 @@ function findCallers(index, name, options = {}) {
                 // persisted with this file's calls.
                 if (call.isMethod && call.receiver &&
                     !_isReservedReceiver(fileEntry.language, call.receiver) &&
-                    (!call.receiverType || call.receiverTypeGuessed) &&
+                    (!call.receiverType || call.receiverTypeGuessed || call.receiverTypeSource === 'guess') &&
                     !call.receiverPatternShadow && !call.receiverFlowInvalidated &&
                     !call.receiverIsChainRoot &&
                     (langTraits(fileEntry.language)?.typeSystem === 'structural' ||
@@ -954,7 +1033,7 @@ function findCallers(index, name, options = {}) {
                                 receiverExternalConcreteFlow: true,
                             }),
                         };
-                        if (call.receiverTypeGuessed) {
+                        if (call.receiverTypeGuessed || call.receiverTypeSource === 'guess') {
                             call = { ...call, receiverType: undefined, receiverTypeGuessed: undefined };
                         }
                     } else if (flowEntry) {
@@ -965,12 +1044,30 @@ function findCallers(index, name, options = {}) {
                         // annotation says *DefaultCodecRegistry; the guess
                         // excluded all three true RegisterCodec callers).
                         call = { ...call, receiverType: flowEntry.type,
+                            receiverTypeSource: 'flow',
+                            receiverTypeEvidence: { source: 'flow', ...flowEntry },
                             receiverTypeGuessed: undefined,
                             receiverFlowInvalidated: false,
                             ...(flowEntry.fromFile && { receiverTypeFlowFile: flowEntry.fromFile }) };
                     }
                 }
 
+                if (fileEntry.language === 'python' && call.isMethod && !call.receiverType) {
+                    const fixture = _pythonFixtureReceiverType(index, filePath, call);
+                    if (fixture) call = { ...call, receiverType: fixture.type,
+                        receiverTypeSource: 'fixture', receiverTypeEvidence: { source: 'fixture', ...fixture },
+                        ...(fixture.fromFile && { receiverTypeFlowFile: fixture.fromFile }) };
+                    const external = !fixture && _pythonExternalFieldFlow(index, filePath, call);
+                    if (external) {
+                        call = { ...call, receiverTypeSource: 'flow',
+                            receiverTypeEvidence: { source: 'flow', externalFactory: external.proof } };
+                        routeUnverified(filePath, fileEntry, call, 'possible-dispatch', calledAs,
+                            { dispatchVia: external.via, externalContract: true },
+                            _confirmationFacts(index, filePath, call, options.targetDefinitions || definitions));
+                        continue;
+                    }
+                }
+
                 // Python indexed receivers (fix #324): `layout["body"].update()`
                 // dispatch through the container's compiler-visible
                 // `__getitem__` return contract. The parser retains only a
@@ -992,6 +1089,8 @@ function findCallers(index, name, options = {}) {
                         call = {
                             ...call,
                             receiverType: indexedType.type,
+                            receiverTypeSource: 'flow',
+                            receiverTypeEvidence: { source: 'flow', ...indexedType },
                             ...(indexedType.fromFile && {
                                 receiverTypeFlowFile: indexedType.fromFile,
                             }),
@@ -1028,7 +1127,9 @@ function findCallers(index, name, options = {}) {
                         const items = _pythonDeclaredIterablePathItems(
                             index, rootType, call.receiverIterationFields);
                         const item = items?.[call.receiverIterationIndex || 0];
-                        if (item) call = { ...call, receiverType: item };
+                        if (item) call = { ...call, receiverType: item,
+                            receiverTypeSource: 'flow',
+                            receiverTypeEvidence: { source: 'flow', type: item, iteration: call.receiver } };
                     }
                 }
 
@@ -1038,6 +1139,8 @@ function findCallers(index, name, options = {}) {
                         index, fileEntry, call.receiver);
                     if (importedType) {
                         call = { ...call, receiverType: importedType.type,
+                            receiverTypeSource: 'flow',
+                            receiverTypeEvidence: { source: 'flow', ...importedType },
                             receiverTypeFlowFile: importedType.fromFile };
                     }
                 }
@@ -1082,6 +1185,9 @@ function findCallers(index, name, options = {}) {
                         call = {
                             ...call,
                             receiverType: returnInfo.type.replace(/\[\]$/, '').split('.').pop(),
+                            receiverTypeSource: 'flow',
+                            receiverTypeEvidence: { source: 'flow', ...returnInfo,
+                                producerPath: call.receiverCallTypePath },
                             ...(returnInfo.fromFile && {
                                 receiverTypeFlowFile: returnInfo.fromFile,
                             }),
@@ -1113,7 +1219,7 @@ function findCallers(index, name, options = {}) {
                 // exact indexed variant and positional payload before method
                 // dispatch; external qualified payloads remain external
                 // provenance, never borrowed project identity.
-                if (collectAccount && fileEntry.language === 'rust' &&
+                if ((collectAccount || call.receiverPatternSourceCallStart != null) && fileEntry.language === 'rust' &&
                     call.isMethod && !call.receiverType &&
                     call.receiverPatternVariant) {
                     const patternType = _rustPatternReceiverType(
@@ -1122,6 +1228,8 @@ function findCallers(index, name, options = {}) {
                         call = {
                             ...call,
                             receiverType: patternType.type,
+                            receiverTypeSource: 'flow',
+                            receiverTypeEvidence: { source: 'flow', ...patternType },
                             ...(patternType.fromFile && {
                                 receiverTypeFlowFile: patternType.fromFile,
                             }),
@@ -1246,10 +1354,14 @@ function findCallers(index, name, options = {}) {
                     const builtinChained = _pythonBuiltinChainedReceiverType(
                         index, fileEntry, call, foldCtx);
                     if (builtinChained) {
-                        call = { ...call, receiverType: builtinChained,
+                        call = { ...call, receiverType: builtinChained.type,
+                            receiverTypeSource: 'flow',
+                            receiverTypeEvidence: { source: 'flow', ...builtinChained },
                             receiverTypePlatform: true };
                     } else if (folded && folded.type) {
                         call = { ...call, receiverType: folded.type,
+                            receiverTypeSource: 'flow',
+                            receiverTypeEvidence: { source: 'flow', ...folded },
                             ...(folded.fromFile && { receiverTypeFlowFile: folded.fromFile }) };
                     } else if (folded && folded.externalVia) {
                         call = {
@@ -1262,6 +1374,8 @@ function findCallers(index, name, options = {}) {
                     } else if (!folded?.suppressFallback) {
                         const chainedType = _chainedReceiverType(index, call, fileEntry.language);
                         if (chainedType) call = { ...call, receiverType: chainedType.type,
+                            receiverTypeSource: 'flow',
+                            receiverTypeEvidence: { source: 'flow', ...chainedType },
                             ...(chainedType.fromFile && { receiverTypeFlowFile: chainedType.fromFile }) };
                     }
                 } else if (call.isMethod && (!call.receiver || call.receiverIsChainRoot) &&
@@ -1303,6 +1417,8 @@ function findCallers(index, name, options = {}) {
                         };
                     } else if (flowEntry) {
                         call = { ...call, receiverType: flowEntry.type,
+                            receiverTypeSource: 'flow',
+                            receiverTypeEvidence: { source: 'flow', ...flowEntry },
                             ...(flowEntry.fromFile && { receiverTypeFlowFile: flowEntry.fromFile }) };
                     }
                 }
@@ -1313,7 +1429,7 @@ function findCallers(index, name, options = {}) {
                 // analysis resolves the source owner and its declared
                 // `Iterator<Item = T>` contract. Item-preserving std adapters
                 // such as rev/filter/take recurse to that same declaration.
-                if (collectAccount && fileEntry.language === 'rust' &&
+                if (fileEntry.language === 'rust' &&
                     call.isMethod && call.receiver && !call.receiverType &&
                     (call.receiverIterationCall || call.receiverIterationVariable)) {
                     let foldCtx = foldCtxCache.get(filePath);
@@ -1329,37 +1445,14 @@ function findCallers(index, name, options = {}) {
                             } };
                         foldCtxCache.set(filePath, foldCtx);
                     }
-                    let items = [];
-                    if (call.receiverIterationVariable) {
-                        const flow = _lookupReturnTypeFlow(foldCtx.getFlowMap(), {
-                            ...call,
-                            receiver: call.receiverIterationVariable,
-                        });
-                        if (flow?.iteratorItemType) {
-                            items = [{
-                                type: flow.iteratorItemType,
-                                fromFile: flow.iteratorItemFromFile,
-                            }];
-                        }
-                    } else {
-                        const sources = _chainedProducerRecords(foldCtx, {
-                            receiverCall: call.receiverIterationCall,
-                            receiverCallIsMethod: call.receiverIterationCallIsMethod,
-                            receiverCallLine: call.receiverIterationCallLine,
-                            receiverCallStart: call.receiverIterationCallStart,
-                            receiverCallEnd: call.receiverIterationCallEnd,
-                        });
-                        items = sources.map(source => _rustIteratorOutputItemType(
-                            index, fileEntry, filePath, source, foldCtx));
-                    }
-                    if (items.length > 0 && items.every(Boolean) &&
-                        new Set(items.map(item => item.type)).size === 1 &&
-                        new Set(items.map(item => item.fromFile)).size === 1 &&
-                        items[0].fromFile) {
+                    const item = _rustIterationReceiverType(index, fileEntry, filePath, call, foldCtx);
+                    if (item) {
                         call = {
                             ...call,
-                            receiverType: items[0].type,
-                            receiverTypeFlowFile: items[0].fromFile,
+                            receiverType: item.type,
+                            receiverTypeSource: 'flow',
+                            receiverTypeEvidence: { source: 'flow', ...item },
+                            receiverTypeFlowFile: item.fromFile,
                         };
                     }
                 }
@@ -1393,6 +1486,8 @@ function findCallers(index, name, options = {}) {
                         call = {
                             ...call,
                             receiverType: closureType.type,
+                            receiverTypeSource: 'flow',
+                            receiverTypeEvidence: { source: 'flow', ...closureType },
                             receiverTypeFlowFile: closureType.fromFile,
                         };
                     }
@@ -1590,7 +1685,7 @@ function findCallers(index, name, options = {}) {
                                             dispatchCandidates: countDispatchCandidates(call.receiverType),
                                         });
                                     } else {
-                                        recordExcluded(filePath, call.line, 'receiver-type-mismatch');
+                                        excludeReceiver(filePath, fileEntry, call, calledAs);
                                     }
                                 }
                                 continue;
@@ -1619,9 +1714,9 @@ function findCallers(index, name, options = {}) {
                             const cbTypedMatch = call.receiverType && cbTypes.has(call.receiverType);
                             const cbAllTypeTargets = cbTargetDefs.length > 0 &&
                                 cbTargetDefs.every(d => IDENTITY_TYPE_KINDS.has(d.type));
-                            if (!cbTypeQualified && !cbTypedMatch &&
-                                (methodOwnerKeys().size > 1 || cbAllTypeTargets)) {
-                                routeUnverified(filePath, fileEntry, call, 'method-ambiguous', calledAs,
+                            if (!cbTypeQualified && !cbTypedMatch) {
+                                routeUnverified(filePath, fileEntry, call,
+                                    methodOwnerKeys().size === 1 && !cbAllTypeTargets ? 'single-owner' : 'method-ambiguous', calledAs,
                                     { dispatchCandidates: methodOwnerKeys().size });
                                 continue;
                             }
@@ -2005,6 +2100,7 @@ function findCallers(index, name, options = {}) {
                 // resolution, but its evidence grade is receiver-hint, not
                 // same-class (the receiver is the field's class).
                 let resolvedByTypedAttribute = false;
+                let resolvedReceiverFacts = {};
                 // Receiver/path type known to mismatch the target: such an edge can
                 // never tier as confirmed even when legacy includeUncertain keeps it
                 // visible (scoreEdge checks hasReceiverType before isUncertain, so
@@ -2053,6 +2149,9 @@ function findCallers(index, name, options = {}) {
                         index, fileEntry, call.receiver);
                     if (staticFieldType) {
                         call = { ...call, receiverType: staticFieldType,
+                            receiverTypeSource: 'field',
+                            receiverTypeEvidence: { source: 'field', field: call.receiver,
+                                type: staticFieldType, imports: fileEntry.importBindings },
                             receiverIsTypeQualified: false };
                     }
                 }
@@ -2160,6 +2259,12 @@ function findCallers(index, name, options = {}) {
                                 if (compatibleTypes.has(targetClass)) {
                                     resolvedBySameClass = true;
                                     resolvedByTypedAttribute = true;
+                                    resolvedReceiverFacts = {
+                                        receiverType: targetClass, receiverTypeSource: 'field',
+                                        receiverOrigin: { source: 'field', rootType: callerSymbol.className,
+                                            field: call.selfAttribute, scope: declarationIdentity(callerSymbol),
+                                            ...attrTypes?.origins?.get(call.selfAttribute) },
+                                    };
                                 } else if (_isAncestorOfTargetClass(index, targetClass, tDefs)) {
                                     // A field declared as a strict ancestor can
                                     // dynamically hold the pinned override.
@@ -2172,7 +2277,11 @@ function findCallers(index, name, options = {}) {
                                     // type is exact negative evidence. Earlier
                                     // code discarded this field contract and
                                     // emitted method-no-evidence.
-                                    recordExcluded(filePath, call.line, 'receiver-type-mismatch');
+                                    excludeReceiver(filePath, fileEntry, call, calledAs, {
+                                        receiverType: targetClass, receiverTypeSource: 'field',
+                                        receiverOrigin: { source: 'field', rootType: callerSymbol?.className,
+                                            field: call.selfAttribute, ...attrTypes?.origins?.get(call.selfAttribute) },
+                                    });
                                     continue;
                                 } else if (options.collectAccount || !options.includeMethods) {
                                     routeUnverified(filePath, fileEntry, call, 'possible-dispatch', calledAs, {
@@ -2351,7 +2460,9 @@ function findCallers(index, name, options = {}) {
                     const builtinFieldType = _pythonBuiltinFieldPathType(
                         index, fileEntry, call.receiverRoot, call.receiverFields);
                     if (builtinFieldType) {
-                        call = { ...call, receiverType: builtinFieldType,
+                        call = { ...call, receiverType: builtinFieldType.type,
+                            receiverTypeSource: 'field',
+                            receiverTypeEvidence: { source: 'field', ...builtinFieldType },
                             receiverTypePlatform: true };
                     }
                 }
@@ -2774,6 +2885,42 @@ function findCallers(index, name, options = {}) {
                 // modules must not exclude: a binding to an unresolved module
                 // whose first segment matches a project directory routes
                 // visible instead.
+                // Rust item renames are name-level ownership (fix #357): a
+                // bare call spelled by a `use path::name as local` alias
+                // denotes exactly the item that binding resolves to. Two
+                // renames of one source name from different modules
+                // (`use alpha::widget as a; use beta::widget as b`) used to
+                // fall through to file-level import evidence, which BOTH
+                // modules satisfy, so each pin confirmed both sites. The
+                // paired binding decides: resolves into a target file →
+                // confirmable; resolves to another project file → excluded
+                // other-definition-import; unresolvable → visible (a resolver
+                // gap is never exclusion evidence).
+                if (calledAs && !call.isMethod && !call.receiver &&
+                    fileEntry.language === 'rust' && call.name === calledAs) {
+                    const paired = (fileEntry.importBindings || []).filter(b =>
+                        b.alias === call.name);
+                    if (paired.length > 0) {
+                        const tFiles = new Set(targetDefs.map(d => d.file).filter(Boolean));
+                        let verdict = 'unknown';
+                        for (const b of paired) {
+                            const resolved = _rustBindingResolvedFiles(index, fileEntry, filePath, b);
+                            if (resolved.size === 0) { verdict = 'unknown'; break; }
+                            const hit = [...resolved].some(f => tFiles.has(f));
+                            if (hit) { verdict = 'target'; break; }
+                            verdict = 'other';
+                        }
+                        if (verdict === 'other') {
+                            recordExcluded(filePath, call.line, 'other-definition-import');
+                            continue;
+                        }
+                        if (verdict === 'unknown' && collectAccount) {
+                            routeUnverified(filePath, fileEntry, call, 'no-import-link', calledAs);
+                            continue;
+                        }
+                    }
+                }
+
                 if (!bindingId && !call.isMethod &&
                     langTraits(fileEntry.language)?.typeSystem === 'structural' &&
                     (fileEntry.importBindings || []).length > 0) {
@@ -3036,6 +3183,13 @@ function findCallers(index, name, options = {}) {
                         continue;
                     }
                     const targetHasClass = targetDefs.some(d => d.className);
+                    if (call.isMethod && !targetHasClass && fileEntry.language === 'c') {
+                        // C member calls invoke function-pointer fields. The
+                        // pointer can hold the pinned free function; member
+                        // syntax alone is neither binding nor exclusion proof.
+                        routeUnverified(filePath, fileEntry, call, 'callable-field', calledAs);
+                        continue;
+                    }
                     if (call.isMethod && !targetHasClass) {
                         // Method call but target is a standalone function — skip
                         recordExcluded(filePath, call.line, 'method-kind-mismatch');
@@ -3227,7 +3381,7 @@ function findCallers(index, name, options = {}) {
                     isUncertain = true;
                     typeMismatch = true;
                     if (collectAccount) {
-                        recordExcluded(filePath, call.line, 'receiver-type-mismatch');
+                        excludeReceiver(filePath, fileEntry, call, calledAs);
                         continue;
                     }
                     if (!options.includeUncertain) {
@@ -3303,7 +3457,7 @@ function findCallers(index, name, options = {}) {
                     isUncertain = true;
                     typeMismatch = true;
                     if (collectAccount) {
-                        recordExcluded(filePath, call.line, 'receiver-type-mismatch');
+                        excludeReceiver(filePath, fileEntry, call, calledAs);
                         continue;
                     }
                     if (!options.includeUncertain) {
@@ -3312,6 +3466,14 @@ function findCallers(index, name, options = {}) {
                     }
                 }
 
+                // C# dynamic is an unresolved runtime receiver, never a
+                // concrete foreign type that can disprove a project edge.
+                if (fileEntry.language === 'csharp' && call.receiverType === 'dynamic') {
+                    routeUnverified(filePath, fileEntry, call, 'possible-dispatch', calledAs,
+                        { dispatchVia: 'dynamic' });
+                    continue;
+                }
+
                 // Receiver-class disambiguation:
                 // When the target definition has a class/receiver type, filter callers
                 // whose receiverType is known to be a different type.
@@ -3571,7 +3733,8 @@ function findCallers(index, name, options = {}) {
                                     // Not evidence against — visible possible-dispatch.
                                     // Go struct embedding binds statically and stays
                                     // excluded.
-                                    if (_dispatchCapableSupertype(index, fileEntry.language, knownType, targetDefs, definitions)) {
+                                    if (_dispatchCapableSupertype(index, fileEntry.language, knownType, targetDefs, definitions) ||
+                                        (!knownTypeHasProjectIdentity && externalContractTarget()?.via === knownType)) {
                                         const externalContract = externalContractTarget();
                                         routeUnverified(filePath, fileEntry, call, 'possible-dispatch', calledAs, {
                                             dispatchVia: knownType,
@@ -3582,7 +3745,11 @@ function findCallers(index, name, options = {}) {
                                         });
                                         continue;
                                     }
-                                    recordExcluded(filePath, call.line, 'receiver-type-mismatch');
+                                    excludeReceiver(filePath, fileEntry, call, calledAs, fieldHopType && !call.receiverType ? {
+                                        receiverType: fieldHopType, receiverTypeSource: 'field',
+                                        receiverOrigin: { source: 'field', root: call.receiverRoot,
+                                            rootType: call.receiverRootType, field: call.receiverField },
+                                    } : {});
                                     continue;
                                 }
                                 if (!options.includeUncertain) {
@@ -3695,7 +3862,7 @@ function findCallers(index, name, options = {}) {
                                 isUncertain = true;
                                 typeMismatch = true;
                                 if (collectAccount) {
-                                    recordExcluded(filePath, call.line, 'receiver-type-mismatch');
+                                    excludeReceiver(filePath, fileEntry, call, calledAs);
                                     continue;
                                 }
                                 if (!options.includeUncertain) {
@@ -3736,6 +3903,10 @@ function findCallers(index, name, options = {}) {
                                 }
                                 inferredMatch = true;
                                 nominalInferredMatch = true;
+                                resolvedReceiverFacts = {
+                                    receiverType: typeReceiver, receiverTypeSource: 'type-qualified',
+                                    receiverOrigin: { source: 'type-qualified', site: occurrenceIdentity(fileEntry.relativePath, call) },
+                                };
                             }
                             // Still no type — fall back to receiver name matching when
                             // multiple defs exist. A field-declared interface/trait type
@@ -4100,7 +4271,9 @@ function findCallers(index, name, options = {}) {
                     let aliasResolvedFile = null;
                     if (receiverName && !tTypes.has(receiverName)) {
                         for (const im of (fileEntry.importBindings || [])) {
-                            if (im.name !== receiverName) continue;
+                            // fix #357: Rust rename bindings carry the local
+                            // name as `alias` (the original is `name`).
+                            if ((im.alias || im.name) !== receiverName) continue;
                             // fix #353: C# `using BH = Beta.Helper` (and Java
                             // dotted paths) split on `.`; Rust paths on `::`.
                             const orig = String(im.module || '').split(/::|\./).pop();
@@ -4154,6 +4327,13 @@ function findCallers(index, name, options = {}) {
                             continue;
                         }
                     }
+                    if (typeQualifiedReceiver) {
+                        resolvedReceiverFacts = {
+                            receiverType: receiverName, receiverTypeSource: 'type-qualified',
+                            receiverOrigin: { source: 'type-qualified', site: occurrenceIdentity(fileEntry.relativePath, call) },
+                            ...(aliasResolvedFile && { originFile: aliasResolvedFile }),
+                        };
+                    }
                     if (!typeQualifiedReceiver) {
                         // External-producer receiver (fix #220): the variable
                         // was assigned from a call into an external package
@@ -4344,6 +4524,15 @@ function findCallers(index, name, options = {}) {
                                 }
                             }
                         }
+                        // Module ownership is evidence for an exported item,
+                        // not for a method nested inside that module's type.
+                        // A same-named free function and method can share the
+                        // target file (itertools::peek_nth vs PeekNth::peek_nth).
+                        if (call.moduleOwnedPath && fileEntry.language === 'rust' &&
+                            targetDefs2.every(d => d.className || d.receiver)) {
+                            routeUnverified(filePath, fileEntry, call, 'provenance-incomplete', calledAs);
+                            continue;
+                        }
                         const knownDispatchType = call.receiverType || fieldHopType || fieldDispatchType;
                         // Module-owned qualified calls (fix #260b) are resolved
                         // by OWNERSHIP — the dispatch-ambiguity routing below is
@@ -4373,8 +4562,11 @@ function findCallers(index, name, options = {}) {
                             });
                             continue;
                         }
-                        if (!call.moduleOwnedPath && !knownDispatchType && methodOwnerKeys().size > 1) {
-                            routeUnverified(filePath, fileEntry, call, 'method-ambiguous', calledAs, {
+                        if (!call.moduleOwnedPath && !knownDispatchType) {
+                            const contract = externalContractTarget();
+                            routeUnverified(filePath, fileEntry, call,
+                                contract ? 'possible-dispatch' : methodOwnerKeys().size === 1 ? 'single-owner' : 'method-ambiguous', calledAs, {
+                                ...(contract && { dispatchVia: contract.via, externalContract: true }),
                                 dispatchCandidates: methodOwnerKeys().size,
                             });
                             continue;
@@ -4566,8 +4758,8 @@ function findCallers(index, name, options = {}) {
                 // in a file that imports _decoders.py is bytes.decode, not
                 // ContentDecoder.decode. An untyped-receiver method call
                 // confirms only via binding, same-class, a validated receiver
-                // type, a type-qualified receiver (Class.method static style),
-                // or a single project-wide owner. Multi-owner name matches
+                // type or a type-qualified receiver (Class.method static style).
+                // Single-owner and multi-owner name matches
                 // route VISIBLE method-ambiguous — never dropped. Same for a
                 // bare call against pure method targets (a bare name cannot
                 // denote a method in JS/TS/Python — only a rebound alias can,
@@ -4583,7 +4775,11 @@ function findCallers(index, name, options = {}) {
                     if (call.isMethod && !call.receiverIsModule &&
                         !recvSubmoduleRel && !call.moduleOwnedPath) {
                         const tTypes = dispatchTargetTypes(targetDefs2);
-                        const typeQualifiedReceiver = !!(call.receiver && tTypes.has(call.receiver));
+                        let typeQualifiedReceiver = !!(call.receiver && tTypes.has(call.receiver));
+                        if (typeQualifiedReceiver) resolvedReceiverFacts = {
+                            receiverType: call.receiver, receiverTypeSource: 'type-qualified',
+                            receiverOrigin: { source: 'type-qualified', site: occurrenceIdentity(fileEntry.relativePath, call) },
+                        };
                         const knownDispatchType = call.receiverType ||
                             fieldHopType || fieldDispatchType;
                         // A compiler/parser-known receiver type that is not a
@@ -4758,6 +4954,8 @@ function findCallers(index, name, options = {}) {
                                 });
                                 continue;
                             }
+                            typeQualifiedReceiver = true;
+                            call = { ...call, moduleOwnedPath: true };
                         }
                         // External-contract single owner (fix #210): same
                         // physics as the nominal gate above — an override
@@ -4787,7 +4985,7 @@ function findCallers(index, name, options = {}) {
                             });
                             continue;
                         }
-                        if (!typeQualifiedReceiver && methodOwnerKeys().size > 1) {
+                        if (!typeQualifiedReceiver) {
                             const knownDispatchType = call.receiverType || fieldHopType || fieldDispatchType;
                             if (knownDispatchType) {
                                 // Known-but-unvalidated type (supertype of the
@@ -4801,7 +4999,7 @@ function findCallers(index, name, options = {}) {
                                     dispatchCandidates: countDispatchCandidates(knownDispatchType),
                                 });
                             } else {
-                                routeUnverified(filePath, fileEntry, call, 'method-ambiguous', calledAs, {
+                                routeUnverified(filePath, fileEntry, call, methodOwnerKeys().size === 1 ? 'single-owner' : 'method-ambiguous', calledAs, {
                                     dispatchCandidates: methodOwnerKeys().size,
                                 });
                             }
@@ -4876,6 +5074,17 @@ function findCallers(index, name, options = {}) {
                     }
                 }
 
+                if (!collectAccount && call.isMethod && !call.isConstructor &&
+                    !resolvedBySameClass && !receiverTypeValidated && !nominalInferredMatch &&
+                    !resolvedByExtensionMethod && !call.moduleOwnedPath &&
+                    !call.receiverIsModule && !recvSubmoduleRel) {
+                    const qualified = _calleeTypeQualifiedReceiver(index,
+                        { ...callerSymbol, file: filePath }, fileEntry, call, fileEntry.language);
+                    const exact = qualified?.match && targetDefs.some(target =>
+                        target.file === qualified.match.file && target.startLine === qualified.match.startLine);
+                    if (!exact) continue;
+                }
+
                 if (!pendingByFile.has(filePath)) pendingByFile.set(filePath, []);
                 pendingByFile.get(filePath).push({
                     call, fileEntry, callerSymbol,
@@ -4891,6 +5100,19 @@ function findCallers(index, name, options = {}) {
                     receiverType: call.receiverType,
                     calledAs,
                     _evidence: {
+                        facts: _confirmationFacts(index, filePath, call, targetDefs, {
+                            bindingId,
+                            ...resolvedReceiverFacts,
+                            sameClass: !!resolvedBySameClass && !resolvedByTypedAttribute,
+                            ...(fieldHopType && !call.receiverType && {
+                                receiverType: fieldHopType, receiverTypeSource: 'field',
+                                receiverOrigin: { source: 'field', root: call.receiverRoot,
+                                    rootType: call.receiverRootType, field: call.receiverField },
+                            }),
+                        }),
+                        typeQualifiedReceiver: resolvedReceiverFacts.receiverTypeSource === 'type-qualified',
+                        moduleOwnedPath: !!call.moduleOwnedPath,
+                        extensionMethod: !!resolvedByExtensionMethod,
                         hasBindingId: !!bindingId,
                         resolvedBySameClass: !!resolvedBySameClass && !resolvedByTypedAttribute,
                         hasSamePackageEvidence,
@@ -4912,8 +5134,8 @@ function findCallers(index, name, options = {}) {
                         // The dispatch gates above have already rejected
                         // external contracts, universal methods, wrong arity,
                         // unresolved producer flow, and multi-owner names.
-                        // What remains with exactly one project owner is
-                        // positive project-scope identity evidence.
+                        // Owner count describes unresolved candidates. It
+                        // never establishes the identity of a value receiver (#355).
                         hasSingleOwnerEvidence: !!(collectAccount && call.isMethod &&
                             !call.inMacroDefinition && !call.isMacro &&
                             !call.receiverType && !fieldHopType &&
@@ -4967,14 +5189,43 @@ function findCallers(index, name, options = {}) {
         for (const { call, fileEntry, callerSymbol, isMethod, isFunctionReference,
             isTypeReference, receiver, receiverType, calledAs, _evidence, _tier,
             _reason, _meta } of pending) {
-            const scored = scoreEdge(_evidence || {});
+            const evidence = {
+                ...(_evidence || {}),
+                ...(_reason && { reason: _reason }),
+                facts: _evidence?.facts || _confirmationFacts(index, filePath,
+                    call, options.targetDefinitions || definitions, {
+                        sameClass: _evidence?.resolvedBySameClass,
+                    }),
+            };
+            let scored = scoreEdge(evidence);
+            let routedTier = _tier;
+            let routedReason = _reason;
+            const migrated = isMethod && !call.isConstructor && !evidence.resolvedBySameClass &&
+                !evidence.typeQualifiedReceiver && !evidence.moduleOwnedPath && !evidence.extensionMethod &&
+                (evidence.hasReceiverType || evidence.resolvedByReceiverHint || evidence.hasSingleOwnerEvidence);
+            if (!_tier && migrated && collectAccount) {
+                const checked = validateConfirmation(scored.provenance, evidence.facts.targets);
+                if (checked.verdict === 'establishes-other') {
+                    recordExcluded(filePath, call.line, 'receiver-target-different', scored.provenance);
+                    continue;
+                }
+                if (checked.verdict !== 'establishes-target' && checked.verdict !== 'unsupported') {
+                    if (!collectAccount) continue;
+                    routedTier = TIER.UNVERIFIED;
+                    routedReason = evidence.hasSingleOwnerEvidence && !evidence.hasReceiverType
+                        ? 'single-owner' : 'provenance-incomplete';
+                    const ranking = scoreEdge({ isUncertain: true,
+                        hasSingleOwnerEvidence: routedReason === 'single-owner' });
+                    scored = { ...ranking, provenance: scored.provenance };
+                }
+            }
             // Family B contract field (fix #221): a bind/call/apply site reaches
             // the target through Function.prototype indirection, not direct call
             // syntax — label the edge calledAs:'bound'. Rename aliases keep their
             // surface name (they describe the same slot and are rarer). Label
             // only, computed at edge construction: routing logic never sees it.
             const edgeCalledAs = calledAs || (call.boundCall ? 'bound' : undefined);
-            if (_tier) {
+            if (routedTier) {
                 // Routed unverified entry — never competes with the main
                 // answer for maxResults/enrichLimit slots.
                 const base = {
@@ -4986,8 +5237,9 @@ function findCallers(index, name, options = {}) {
                     evidenceScore: scored.evidenceScore,
                     scoreKind: scored.scoreKind,
                     resolution: scored.resolution,
-                    tier: _tier,
-                    reason: _reason,
+                    ...(collectAccount && { provenance: scored.provenance }),
+                    tier: routedTier,
+                    reason: routedReason,
                     ...(_meta || {}),
                     isMethod: call.isMethod || false,
                     ...(isFunctionReference && { isFunctionReference: true }),
@@ -5036,6 +5288,7 @@ function findCallers(index, name, options = {}) {
                     evidenceScore: scored.evidenceScore,
                     scoreKind: scored.scoreKind,
                     resolution: scored.resolution,
+                    ...(collectAccount && { provenance: scored.provenance }),
                     ...(tier && { tier }),
                     isMethod: call.isMethod || false,
                     ...(isFunctionReference && { isFunctionReference: true }),
@@ -5074,6 +5327,7 @@ function findCallers(index, name, options = {}) {
                 evidenceScore: scored.evidenceScore,
                 scoreKind: scored.scoreKind,
                 resolution: scored.resolution,
+                    ...(collectAccount && { provenance: scored.provenance }),
                 ...(tier && { tier }),
             });
             enrichedCount++;
@@ -5211,6 +5465,30 @@ function findCallees(index, definition, options = {}) {
             : [];
 
         const callees = new Map();  // key -> { name, bindingId, count }
+        const siteEvidence = new Map();
+        const provenanceForSite = (siteId, target, reason) => {
+            const record = siteEvidence.get(siteId) || { call: calls[siteId], evidence: {} };
+            const call = record.call;
+            const evidence = { ...record.evidence, ...(reason && { reason }) };
+            evidence.facts = _confirmationFacts(index, def.file, call,
+                target ? [target] : (index.symbols.get(call.name) || []), record.options);
+            // A bindingId synthesized by receiver resolution is not a
+            // lexical binding of the method token. Rank the actual site facts.
+            if (call.isMethod && !call.receiverIsModule && !call.moduleOwnedPath &&
+                !evidence.typeQualifiedReceiver && !evidence.extensionMethod) evidence.hasBindingId = false;
+            if (!call.isMethod && target && !evidence.hasBindingId) {
+                evidence.hasImportEvidence = (index.symbols.get(call.name) || []).length === 1 ||
+                    target.file === def.file || index.importGraph.get(def.file)?.has(target.file);
+            }
+            const scored = scoreEdge(evidence);
+            return {
+                ...occurrenceIdentity(fileEntry?.relativePath || def.file, call, siteId),
+                ...(target && { targetDef: declarationIdentity(target) }),
+                confidence: scored.confidence, evidenceScore: scored.evidenceScore,
+                resolution: scored.resolution, scoreKind: scored.scoreKind,
+                provenance: scored.provenance,
+            };
+        };
         let selfAttrCalls = null;   // collected for Python self.attr.method() resolution
         let selfMethodCalls = null; // collected for Python self.method() resolution
 
@@ -5259,7 +5537,7 @@ function findCallees(index, definition, options = {}) {
         };
         // Retain an uncertain/unresolved call as a visible unverified callee
         // entry (aggregated by name+reason) and claim its site.
-        const noteUnverified = (siteId, call, reason, meta = {}) => {
+        const noteUnverified = (siteId, call, reason, meta = {}, siteProof) => {
             if (!collectAccount || claimedSiteIds.has(siteId)) return;
             noteSite(siteId, 'unverified', reason, call);
             const key = `${call.name}|${reason}|${meta.dispatchVia || ''}`;
@@ -5272,6 +5550,13 @@ function findCallees(index, definition, options = {}) {
             }
             entry.callCount++;
             entry.sites.push(call.line);
+            if (!entry.siteProvenance) entry.siteProvenance = [];
+            const unverifiedScore = scoreEdge({ isUncertain: true, reason });
+            entry.siteProvenance.push({ ...(siteProof || provenanceForSite(siteId, null, reason)),
+                tier: TIER.UNVERIFIED, reason,
+                confidence: unverifiedScore.confidence, evidenceScore: unverifiedScore.evidenceScore,
+                resolution: reason, scoreKind: unverifiedScore.scoreKind });
+            entry.provenance = summarizeProvenance(entry.siteProvenance);
         };
         // A statically selected base implementation is not the only runtime
         // target in languages with virtual/structural dispatch. If a project
@@ -5353,7 +5638,8 @@ function findCallees(index, definition, options = {}) {
         // already carry stronger identity and must not trigger a whole-file
         // flow build merely because their parser record lacks receiverType.
         const mayNeedDirectReceiverFlow = call =>
-            call.isMethod && call.receiver && !call.receiverType &&
+            call.isMethod && call.receiver && (!call.receiverType ||
+                call.receiverTypeGuessed || call.receiverTypeSource === 'guess') &&
             !call.receiverPatternShadow &&
             !_isReservedReceiver(language, call.receiver) &&
             !call.isPathCall && !call.receiverIsModule &&
@@ -5378,6 +5664,14 @@ function findCallees(index, definition, options = {}) {
         for (let call of calls) {
             siteOrdinal++;
             const siteId = siteOrdinal;
+            siteEvidence.set(siteId, {
+                call,
+                evidence: {
+                    hasReceiverType: !!call.receiverType,
+                    resolvedBySameClass: !!call.receiver && _isReservedReceiver(language, call.receiver),
+                },
+                options: { sameClass: !!call.receiver && _isReservedReceiver(language, call.receiver) },
+            });
             if (language === 'csharp') {
                 // fix #353: `Beta.Helper.Widget()` — namespace-qualified type
                 // receiver (see the findCallers twin).
@@ -5391,6 +5685,8 @@ function findCallees(index, definition, options = {}) {
                     call = {
                         ...call,
                         receiverType: indexedType.type,
+                            receiverTypeSource: 'flow',
+                            receiverTypeEvidence: { source: 'flow', ...indexedType },
                         ...(indexedType.fromFile && {
                             receiverTypeFlowFile: indexedType.fromFile,
                         }),
@@ -5417,6 +5713,55 @@ function findCallees(index, definition, options = {}) {
             if (!isDirectMatch && !isNestedCallback) continue;
             if (calleeAccount) calleeAccount.totalSites++;
 
+            if (language === 'python' && call.isMethod && !call.receiverType) {
+                const fixture = _pythonFixtureReceiverType(index, def.file, call);
+                if (fixture) call = { ...call, receiverType: fixture.type,
+                    receiverTypeSource: 'fixture', receiverTypeEvidence: { source: 'fixture', ...fixture },
+                    ...(fixture.fromFile && { receiverTypeFlowFile: fixture.fromFile }) };
+                const external = !fixture && _pythonExternalFieldFlow(index, def.file, call);
+                if (external) {
+                    call = { ...call, receiverTypeSource: 'flow',
+                        receiverTypeEvidence: { source: 'flow', externalFactory: external.proof } };
+                    const targets = (index.symbols.get(call.name) || []).filter(d => !NON_CALLABLE_TYPES.has(d.type));
+                    const facts = _confirmationFacts(index, def.file, call, targets);
+                    const provenance = scoreEdge({ possibleDispatch: true, facts }).provenance;
+                    noteUnverified(siteId, call, 'possible-dispatch', { dispatchVia: external.via, externalContract: true },
+                        { ...occurrenceIdentity(fileEntry.relativePath, call, siteId), provenance });
+                    continue;
+                }
+            }
+
+            if (language === 'rust' && _rustStandardWrapperMethod(index, def.file, call, allCalls)) {
+                noteSite(siteId, 'external', 'standard-wrapper-method', call);
+                continue;
+            }
+            if (language === 'rust' && call.isMethod && !call.receiverType &&
+                call.receiverPatternVariant && (collectAccount || call.receiverPatternSourceCallStart != null)) {
+                const item = _rustPatternReceiverType(index, fileEntry, def.file, call, foldCtx());
+                if (item?.type) call = { ...call, receiverType: item.type,
+                    receiverTypeSource: 'flow', receiverTypeEvidence: { source: 'flow', ...item },
+                    receiverTypeFlowFile: item.fromFile };
+            }
+            if (language === 'rust' && call.isMethod &&
+                call.receiver && !call.receiverType &&
+                (call.receiverIterationCall || call.receiverIterationVariable)) {
+                const item = _rustIterationReceiverType(index, fileEntry, def.file, call, foldCtx());
+                if (item) call = { ...call, receiverType: item.type,
+                    receiverTypeSource: 'flow', receiverTypeEvidence: { source: 'flow', ...item },
+                    receiverTypeFlowFile: item.fromFile };
+            }
+
+            if (language === 'c' && call.isMethod) {
+                noteUnverified(siteId, call, 'callable-field');
+                continue;
+            }
+
+            if (language === 'csharp' && call.receiverType === 'dynamic') {
+                if (_calleeZeroCandidateName(index, call)) noteSite(siteId, 'external', null, call);
+                else noteUnverified(siteId, call, 'possible-dispatch', { dispatchVia: 'dynamic' });
+                continue;
+            }
+
             if (call.macroParameter) {
                 noteSite(siteId, 'excluded', 'macro-parameter', call);
                 continue;
@@ -5460,6 +5805,7 @@ function findCallees(index, definition, options = {}) {
                     const selected = _calleeOverloadSelect(
                         index, call, extensions, language);
                     if (selected.match) {
+                        if (collectAccount) siteEvidence.get(siteId).evidence.extensionMethod = true;
                         const match = selected.match;
                         const key = match.bindingId ||
                             `${match.file}:${match.startLine}:${call.name}`;
@@ -5530,6 +5876,8 @@ function findCallees(index, definition, options = {}) {
                     call = {
                         ...call,
                         receiverType: indexedType.type,
+                            receiverTypeSource: 'flow',
+                            receiverTypeEvidence: { source: 'flow', ...indexedType },
                         ...(indexedType.fromFile && {
                             receiverTypeFlowFile: indexedType.fromFile,
                         }),
@@ -5648,6 +5996,22 @@ function findCallees(index, definition, options = {}) {
                 }
             }
 
+            if (collectAccount) {
+                const record = siteEvidence.get(siteId);
+                record.call = call;
+                if (directReceiverFlow?.type || fieldHopType) {
+                    const source = directReceiverFlow?.type ? 'flow' : 'field';
+                    record.evidence.hasReceiverType = true;
+                    Object.assign(record.options, {
+                        receiverType: directReceiverFlow?.type || fieldHopType,
+                        receiverTypeSource: source,
+                        originFile: directReceiverFlow?.fromFile || fieldHopInfo?.fromFile,
+                        receiverOrigin: { source, ...(directReceiverFlow || fieldHopInfo || {}),
+                            field: call.receiverField, rootType: call.receiverRootType },
+                    });
+                }
+            }
+
             if (fieldDispatchType) {
                 noteUnverified(siteId, call, 'possible-dispatch', {
                     dispatchVia: fieldDispatchType,
@@ -5667,6 +6031,7 @@ function findCallees(index, definition, options = {}) {
                     const selected = _calleeOverloadSelect(
                         index, extensionCall, extensions, language);
                     if (selected.match) {
+                        if (collectAccount) siteEvidence.get(siteId).evidence.extensionMethod = true;
                         const match = selected.match;
                         const key = match.bindingId ||
                             `${match.file}:${match.startLine}:${call.name}`;
@@ -5810,6 +6175,7 @@ function findCallees(index, definition, options = {}) {
                 !_isReservedReceiver(language, call.receiver) &&
                 !(localTypes && localTypes.has(call.receiver))) {
                 typeQual = _calleeTypeQualifiedReceiver(index, def, fileEntry, call, language);
+                if (typeQual) siteEvidence.get(siteId).evidence.typeQualifiedReceiver = true;
             }
 
             // Package-qualified NON-method records (fix #268, chi-measured):
@@ -5954,7 +6320,7 @@ function findCallees(index, definition, options = {}) {
                         }
                         continue;
                     }
-                    const typeName = call.receiverType || directReceiverFlow?.type || fieldHopType;
+                    const typeName = directReceiverFlow?.type || call.receiverType || fieldHopType;
                     const symbols = index.symbols.get(call.name);
                     const qualifiedType = language === 'go' && call.receiverType
                         ? _goQualifiedReceiverType(index, fileEntry,
@@ -5980,8 +6346,8 @@ function findCallees(index, definition, options = {}) {
                     const isCallableRT = (s) => !NON_CALLABLE_TYPES.has(s.type) ||
                         (s.type === 'field' && s.fieldType && /^func\b/.test(s.fieldType));
                     // Same-class overload selection by static call shape (fix #268)
-                    const receiverOriginFile = call.receiverTypeFlowFile ||
-                        directReceiverFlow?.fromFile ||
+                    const receiverOriginFile = directReceiverFlow?.fromFile ||
+                        call.receiverTypeFlowFile ||
                         fieldHopInfo?.fromFile ||
                         (call.receiverType
                             ? _resolveFlowTypeOrigin(
@@ -6103,6 +6469,12 @@ function findCallees(index, definition, options = {}) {
                         chained = _nominalChainedReceiverType(index, call, fileEntry, def.file);
                     }
                     if (chained?.type) {
+                        const record = siteEvidence.get(siteId);
+                        record.evidence.hasReceiverType = true;
+                        Object.assign(record.options, {
+                            receiverType: chained.type, receiverTypeSource: 'flow',
+                            receiverOrigin: { source: 'flow', ...chained }, originFile: chained.fromFile,
+                        });
                         const symbols = index.symbols.get(call.name);
                         const isCallableCh = (s) => !NON_CALLABLE_TYPES.has(s.type) ||
                             (s.type === 'field' && s.fieldType && /^func\b/.test(s.fieldType));
@@ -6849,21 +7221,28 @@ function findCallees(index, definition, options = {}) {
                 if (bound && routeVirtualOverride(siteId, call, def.className, bound)) continue;
             }
 
-            // Single project-wide owner (fix #236 — the caller side's
-            // #204/#209 rule on the callee side): an untyped-receiver method
-            // call whose name has exactly ONE owner type resolves to that
-            // owner's method — `k.run()` where only Kit defines run. Without
-            // it, trace trees stopped expanding at statically-resolvable
-            // calls the caller direction confirms.
+            // Receiver evidence for the former single-owner fallback (#355).
+            // A name with one owner still needs an independent typed lookup;
+            // unresolved values remain visible in the contract.
             if (isUncertain && call.isMethod && call.receiver && !bindingResolved) {
                 const fm = mayNeedDirectReceiverFlow(call) ? flowMap() : null;
                 const flowEntry = fm ? _lookupReturnTypeFlow(fm, call) : undefined;
                 const owner = _calleeSingleOwnerMatch(index, def, fileEntry, call, effectiveName, language, flowEntry);
                 if (owner) {
+                    siteEvidence.get(siteId).evidence.hasSingleOwnerEvidence = true;
                     isUncertain = false;
                     bindingResolved = owner.bindingId;
                     calleeKey = owner.bindingId ||
                         `${owner.className || (owner.receiver || '').replace(/^\*/, '')}.${effectiveName}`;
+                } else if (!call.receiverType && !flowEntry?.type && !fieldHopType &&
+                    !call.receiverExternalFlow && !call.receiverQualifiedFlow) {
+                    const owners = new Set((index.symbols.get(effectiveName) || [])
+                        .filter(d => !NON_CALLABLE_TYPES.has(d.type) && (d.className || d.receiver))
+                        .map(d => `${d.file}:${d.className || d.receiver}`));
+                    if (owners.size === 1) {
+                        uncertainReason = 'single-owner';
+                        siteEvidence.get(siteId).evidence.hasSingleOwnerEvidence = true;
+                    }
                 }
             }
 
@@ -6891,6 +7270,59 @@ function findCallees(index, definition, options = {}) {
                 }
             }
 
+            // Legacy callers receive no uncertainty band. Drop an untyped
+            // value receiver even if a same-file or unique-name lookup picked
+            // a method; only actual receiver/module/type evidence survives.
+            if (!collectAccount && call.isMethod && !call.receiverType &&
+                !directReceiverFlow?.type && !fieldHopType &&
+                !localTypes?.has(call.receiver) &&
+                !siteEvidence.get(siteId).evidence.resolvedBySameClass &&
+                !siteEvidence.get(siteId).evidence.typeQualifiedReceiver &&
+                !call.receiverIsModule && !call.receiverModuleSpecifier &&
+                !call.receiverModuleComposition && !call.moduleOwnedPath &&
+                !call.isConstructor) continue;
+
+            if (collectAccount) {
+                const record = siteEvidence.get(siteId);
+                record.call = call;
+                if (bindingResolved && !record.evidence.hasSingleOwnerEvidence) {
+                    record.evidence.hasBindingId = true;
+                    record.options.bindingId = bindingResolved;
+                }
+            }
+            if (collectAccount) {
+                const record = siteEvidence.get(siteId);
+                const valueReceiver = call.isMethod && !call.isConstructor &&
+                    !call.receiverIsModule && !call.receiverModuleSpecifier &&
+                    !call.receiverModuleComposition && !call.moduleOwnedPath &&
+                    !record.evidence.typeQualifiedReceiver && !record.evidence.extensionMethod &&
+                    !record.evidence.resolvedBySameClass;
+                if (valueReceiver) {
+                    // Resolve and classify THIS occurrence before its grouping
+                    // key is chosen. A sibling site cannot lend its receiver
+                    // evidence or overload identity to this one.
+                    const proof = provenanceForSite(siteId, null);
+                    const facts = proof.provenance.facts;
+                    const checked = validateConfirmation(proof.provenance, facts.targets);
+                    const selected = checked.verdict === 'establishes-target' &&
+                        (index.symbols.get(effectiveName) || []).find(candidate =>
+                            sameDeclaration(declarationIdentity(candidate), facts.lookup?.selected));
+                    const reportOnly = checked.verdict === 'unsupported' && record.evidence.hasReceiverType;
+                    if (!selected && !reportOnly) {
+                        const reason = !record.evidence.hasReceiverType && facts.ownerCount === 1
+                            ? 'single-owner' : 'provenance-incomplete';
+                        if (reason === 'single-owner') proof.provenance = scoreEdge({
+                            hasSingleOwnerEvidence: true, facts,
+                        }).provenance;
+                        noteUnverified(siteId, call, reason, {}, proof);
+                        continue;
+                    }
+                    if (selected) {
+                        bindingResolved = selected.bindingId;
+                        calleeKey = selected.bindingId || `${selected.file}:${selected.startLine}:${selected.name}`;
+                    }
+                }
+            }
             const existing = callees.get(calleeKey);
             if (existing) {
                 existing.count += 1;
@@ -7254,24 +7686,61 @@ function findCallees(index, definition, options = {}) {
                     }
                 }
 
-                const calleeScored = scoreEdge({
+                let calleeScored = scoreEdge({
                     hasBindingId: !!bindingId,
                     hasImportEvidence: !!bindingId || resolutionSymbols.length === 1 ||
                         (callee.file === def.file) || callerImportSet.has(callee.file),
                     isUncertain: false, // uncertain callees already filtered above
                 });
+                const siteProvenance = collectAccount ? siteIds.map(siteId => ({
+                    ...provenanceForSite(siteId, callee), tier: TIER.CONFIRMED,
+                })).sort((a, b) => a.siteId - b.siteId).filter(site => {
+                    const record = siteEvidence.get(site.siteId);
+                    const valueReceiver = record.call.isMethod &&
+                        !record.call.receiverIsModule && !record.call.receiverModuleSpecifier &&
+                        !record.call.receiverModuleComposition && !record.evidence.typeQualifiedReceiver;
+                    const untypedValue = valueReceiver && !record.evidence.hasReceiverType &&
+                        !record.evidence.resolvedBySameClass;
+                    if (untypedValue && site.provenance.facts.ownerCount === 1) {
+                        record.evidence.hasSingleOwnerEvidence = true;
+                    }
+                    const migrated = valueReceiver && !record.call.isConstructor &&
+                        !record.evidence.resolvedBySameClass && !record.evidence.extensionMethod &&
+                        (record.evidence.hasReceiverType || record.evidence.hasSingleOwnerEvidence || untypedValue);
+                    if (!migrated) return true;
+                    const checked = validateConfirmation(site.provenance, [declarationIdentity(callee)]);
+                    if (checked.verdict === 'establishes-target' ||
+                        (checked.verdict === 'unsupported' && record.evidence.hasReceiverType)) return true;
+                    if (checked.verdict === 'establishes-other') {
+                        noteSite(site.siteId, 'excluded', 'receiver-target-different', record.call);
+                        (calleeAccount.excluded.evidence ||= []).push(site);
+                    } else {
+                        const reason = record.evidence.hasSingleOwnerEvidence && !record.evidence.hasReceiverType
+                            ? 'single-owner' : 'provenance-incomplete';
+                        if (reason === 'single-owner') site.provenance = scoreEdge({
+                            hasSingleOwnerEvidence: true, facts: site.provenance.facts,
+                        }).provenance;
+                        noteUnverified(site.siteId, record.call, reason, {}, site);
+                    }
+                    return false;
+                }) : null;
+                if (collectAccount && siteProvenance.length === 0) continue;
+                if (collectAccount) calleeScored = siteProvenance.reduce((weakest, site) =>
+                    site.evidenceScore < weakest.evidenceScore ? site : weakest);
                 claimSites('confirmed', null);
                 result.push({
                     ...callee,
-                    callCount: count,
-                    weight: index.calculateWeight(count),
+                    callCount: collectAccount ? siteProvenance.length : count,
+                    weight: index.calculateWeight(collectAccount ? siteProvenance.length : count),
                     confidence: calleeScored.confidence,
                     evidenceScore: calleeScored.evidenceScore,
                     scoreKind: calleeScored.scoreKind,
                     resolution: calleeScored.resolution,
                     ...(collectAccount && {
                         tier: TIER.CONFIRMED,
-                        sites: [...sites].sort((a, b) => a - b),
+                        provenance: summarizeProvenance(siteProvenance),
+                        siteProvenance,
+                        sites: siteProvenance.map(site => site.line).sort((a, b) => a - b),
                         ...(isFunctionReference && { functionReference: true }),
                     }),
                 });
@@ -7369,6 +7838,28 @@ function getInstanceAttributeTypes(index, filePath, className) {
                         'python', { filePath, consumerAwaited: false });
                     return result?.fromFile ? result.type : null;
                 },
+                resolveImportedCallType(name) {
+                    const bindings = (fileEntry.importBindings || []).filter(binding =>
+                        (binding.alias || binding.name) === name);
+                    if (bindings.length !== 1 || (fileEntry.moduleAssignedNames || []).includes(name) ||
+                        (index.symbols.get(name) || []).some(d => d.file === filePath)) return null;
+                    const binding = bindings[0];
+                    if (!_pythonBuiltinContractAllowed(index, fileEntry, binding.module)) return null;
+                    const type = langModule.getBuiltinCallReturnType?.(binding.module, binding.name);
+                    return type ? { type, binding: { ...binding }, externalModule: binding.module } : null;
+                },
+                resolveExternalFactory(parts) {
+                    const name = parts[0];
+                    const bindings = (fileEntry.importBindings || []).filter(binding => (binding.alias || binding.name) === name);
+                    if (bindings.length !== 1 || (fileEntry.moduleAssignedNames || []).includes(name) ||
+                        (index.symbols.get(name) || []).some(d => d.file === filePath)) return null;
+                    const binding = bindings[0];
+                    if (!_pythonBuiltinContractAllowed(index, fileEntry, binding.module)) return null;
+                    const importedFunction = ['from', 'relative'].includes(binding.kind);
+                    if (parts.length !== (importedFunction ? 1 : 2)) return null;
+                    return { module: binding.module, producer: importedFunction ? binding.name : parts[1],
+                        binding: { ...binding }, projectDeclarations: [], projectBindings: [], resolvedModule: null };
+                },
             });
             index._attrTypeCache.set(filePath, fileCache);
         } catch {
@@ -7616,6 +8107,30 @@ function _buildReturnTypeFlowMap(index, filePath, calls) {
                 candidate.callStart === call.receiverCallStart &&
                 candidate.callEnd === call.receiverCallEnd);
 
+        // A separate unwrap/expect assignment consumes the payload of the
+        // receiver's declared standard wrapper. Its spelling alone is not a
+        // contract: project-defined Result/Option classes remain ordinary
+        // method producers. Reassignments are checked by the same nearest-
+        // assignment lookup used for every other flow receiver.
+        if (language === 'rust' && call.isMethod && call.receiver &&
+            !call.receiverPatternShadow && !call.receiverFlowInvalidated &&
+            ((call.name === 'unwrap' && call.argCount === 0) ||
+                (call.name === 'expect' && call.argCount === 1))) {
+            const receiverFlow = _lookupReturnTypeFlow(map, call);
+            const contract = receiverFlow?.rustWrapper;
+            if (contract?.type && validateRustWrapperContract(contract)) {
+                const scope = call.enclosingFunction ? `${call.enclosingFunction.startLine}` : '';
+                const key = `${scope}:${call.assignedTo}`;
+                if (!map.has(key)) map.set(key, []);
+                map.get(key).push({ line: call.line, start: call.callStart,
+                    type: contract.type, fromFile: contract.fromFile,
+                    wrapperUnwrap: { method: call.name,
+                        producer: { line: receiverFlow.line, start: receiverFlow.start,
+                            type: receiverFlow.type, fromFile: receiverFlow.fromFile }, contract } });
+                continue;
+            }
+        }
+
         // Rust's `collect::<Vec<Item>>()` turbofish fixes the concrete result
         // and its item type at the call site. Preserve the item identity even
         // though the outer collection is a standard-library type with no
@@ -7692,7 +8207,7 @@ function _buildReturnTypeFlowMap(index, filePath, calls) {
                     ? resolved[0]
                     : null;
             }
-            if (folded?.type || folded?.externalVia) {
+            if (folded?.type || folded?.externalVia || folded?.rustWrapper) {
                 const scope = call.enclosingFunction
                     ? `${call.enclosingFunction.startLine}` : '';
                 const key = `${scope}:${call.assignedTo}`;
@@ -7701,12 +8216,15 @@ function _buildReturnTypeFlowMap(index, filePath, calls) {
                 map.get(key).push({ line: call.line, start: call.callStart,
                     ...(folded.type && { type: folded.type }),
                     ...(folded.fromFile && { fromFile: folded.fromFile }),
+                    ...(folded.rustWrapper && { rustWrapper: folded.rustWrapper }),
+                    ...(folded.rustReturnDeclaration && { rustReturnDeclaration: folded.rustReturnDeclaration }),
+                    ...(folded.moduleProducer && { moduleProducer: folded.moduleProducer }),
                     ...(folded.externalVia && { externalVia: folded.externalVia }),
                     ...(folded.externalConcrete && { externalConcrete: true }) });
                 continue;
             }
         }
-        let returnType, fromFile, selfClass, returnedFunctionResult, returnDefinition;
+        let returnType, fromFile, selfClass, returnedFunctionResult, returnDefinition, moduleProducer;
         const builtinCallReturn = !nominal && language === 'python'
             ? _pythonBuiltinCallReturnType(index, fileEntry, call) : null;
         if (call.localValueCall && call.returnTypeHint) {
@@ -7732,10 +8250,14 @@ function _buildReturnTypeFlowMap(index, filePath, calls) {
             returnType = callableFlow.returnedFunctionResult;
             fromFile = callableFlow.fromFile;
         } else if (call.isMethod && call.receiverType &&
-            !call.receiverTypeGuessed) {
+            !call.receiverTypeGuessed && call.receiverTypeSource !== 'guess') {
             const defs = index.symbols.get(call.name) || [];
             if (nominal) {
-                const matches = defs.filter(d => d.className === call.receiverType && d.returnType);
+                const rustOwner = language === 'rust'
+                    ? _rustFlowReceiverOrigin(index, filePath, call.receiverType, call.receiverTypeQualifier)
+                    : null;
+                const matches = defs.filter(d => d.className === call.receiverType && d.returnType &&
+                    (language !== 'rust' || rustOwner?.fromFile));
                 if (matches.length > 0 && new Set(matches.map(d => d.returnType)).size === 1) {
                     returnType = matches[0].returnType;
                     fromFile = matches[0].file;
@@ -7846,6 +8368,15 @@ function _buildReturnTypeFlowMap(index, filePath, calls) {
                 cls = next;
             }
         } else if (nominal && call.isMethod && call.isPathCall && call.receiver) {
+            if (language === 'rust') {
+                const producer = _rustModuleProducer(index, fileEntry, filePath, call);
+                if (producer) {
+                    returnDefinition = producer.definition;
+                    returnType = returnDefinition.returnType;
+                    fromFile = returnDefinition.file;
+                    moduleProducer = producer.facts;
+                }
+            }
             if (language === 'cpp') {
                 // C++ value-initialization through a qualified type name:
                 // `auto p = fmt::pipe()`. The portable tree-sitter AST uses
@@ -8327,6 +8858,18 @@ function _buildReturnTypeFlowMap(index, filePath, calls) {
             }
             const origin = _resolveFlowTypeOrigin(index, fromFile || filePath, parsed.name, parsed.qualifier);
             if (!origin) {
+                const wrapper = language === 'rust' && !call.assignedUnwrap &&
+                    _rustReturnWrapper(index, returnType, fromFile || filePath, selfClass,
+                        returnDefinition, [], true);
+                if (wrapper && validateRustWrapperContract(wrapper, true)) {
+                    const scope = call.enclosingFunction ? `${call.enclosingFunction.startLine}` : '';
+                    const key = `${scope}:${call.assignedTo}`;
+                    if (!map) map = new Map();
+                    if (!map.has(key)) map.set(key, []);
+                    map.get(key).push({ line: call.line, start: call.callStart,
+                        rustWrapper: wrapper, rustReturnDeclaration: _rustReturnDeclaration(returnDefinition) });
+                    continue;
+                }
                 // A project producer can return a package-qualified external
                 // Go type (`DefaultLogger(...) http.Handler`). That still
                 // gives compiler-grade provenance: the assigned receiver is
@@ -8373,6 +8916,12 @@ function _buildReturnTypeFlowMap(index, filePath, calls) {
         if (!map.has(key)) map.set(key, []);
         map.get(key).push({ line: call.line, start: call.callStart, type: typeName,
             ...(entryFromFile && { fromFile: entryFromFile }),
+            ...(moduleProducer && { moduleProducer }),
+            ...(language === 'rust' && returnDefinition && { rustReturnDeclaration: _rustReturnDeclaration(returnDefinition) }),
+            ...(language === 'rust' && !call.assignedUnwrap && {
+                rustWrapper: _rustReturnWrapper(index, returnType, fromFile || filePath,
+                    selfClass, returnDefinition),
+            }),
             ...(iteratorItemType && {
                 iteratorItemType,
                 iteratorItemFromFile,
@@ -8480,7 +9029,15 @@ function _lookupReturnTypeFlow(map, call) {
         for (const e of entries) {
             if (precedesCall(e) && laterThan(e, best)) best = e;
         }
-        if (best) return best.invalidated ? undefined : best;
+        if (best) {
+            const binding = call.receiverTypeEvidence?.aliasBinding;
+            // A non-call copy/rebinding is absent from the producer map.
+            // Its newer AST declaration must still invalidate an older
+            // factory payload with the same local variable name.
+            if (binding?.target === call.receiver && Number.isInteger(binding.assignment?.start) &&
+                (best.start == null || binding.assignment.start > best.start)) return undefined;
+            return best.invalidated ? undefined : best;
+        }
     }
     return undefined;
 }
@@ -8555,6 +9112,59 @@ function _splitTopLevelGenericArgs(s) {
     return out;
 }
 
+function _rustReturnWrapper(index, text, file, selfClass, producer, projection = [], allowUnknownPayload = false) {
+    if (!text || !file || !producer) return null;
+    const contract = rustWrapperContract(index, text, file, {
+        projection,
+        allowUnknownPayload,
+        parseType: value => _returnTypeNameNominal(value, 'rust', { selfClass }),
+        resolveType: (context, name, qualifier) => _resolveFlowTypeOrigin(index, context, name, qualifier),
+    });
+    return contract && { ...contract, producer: { ...declarationIdentity(producer), returnType: producer.returnType } };
+}
+
+function _rustReturnDeclaration(definition) {
+    return { ...declarationIdentity(definition), file: definition.file,
+        relativePath: definition.relativePath, returnType: definition.returnType };
+}
+
+function _rustStandardWrapperMethod(index, file, call, calls) {
+    if (!call.isMethod || !call.receiver || call.isPathCall ||
+        call.receiverPatternShadow || call.receiverFlowInvalidated ||
+        !['unwrap', 'expect'].includes(call.name)) return null;
+    const flow = _lookupReturnTypeFlow(_buildReturnTypeFlowMap(index, file, calls), call);
+    const contract = flow?.rustWrapper;
+    if (contract && validateRustWrapperContract(contract, true)) {
+        return { method: call.name, receiver: call.receiver, callKind: 'method',
+            producer: { line: flow.line, start: flow.start }, contract };
+    }
+    // Ownership of a standard wrapper does not require knowing its payload:
+    // `value: Result<T, E>` still uses Result's inherent unwrap. This negative
+    // proof never types T or attributes its later methods to a project class.
+    const type = call.receiverType;
+    if (!['Result', 'Option'].includes(type) || call.receiverTypeSource !== 'annotation' ||
+        call.receiverTypeEvidence?.source !== 'annotation' ||
+        _isGenericParamReceiverType(index, file, call.line, type)) return null;
+    const entry = index.files.get(file);
+    const module = type === 'Result' ? 'result' : 'option';
+    const standardPaths = [`std::${module}::${type}`, `core::${module}::${type}`];
+    const qualifier = call.receiverTypeQualifier;
+    const local = (index.symbols.get(type) || []).filter(d => d.file === file &&
+        (IDENTITY_TYPE_KINDS.has(d.type) || d.type === 'type'));
+    const bindings = (entry.importBindings || []).filter(b => (b.alias || b.name) === type);
+    if (qualifier ? !standardPaths.includes(`${qualifier}::${type}`)
+        : local.length || bindings.some(b => !standardPaths.includes(b.module))) return null;
+    if ((entry.importBindings || []).some(b => b.name === '*' || b.module?.endsWith('::*'))) return null;
+    const root = qualifier?.split('::')[0] || bindings[0]?.module.split('::')[0];
+    if (root && ((index.symbols.get(root) || []).some(d => d.file === file) ||
+        (entry.importBindings || []).some(b => (b.alias || b.name) === root))) return null;
+    return { method: call.name, receiver: call.receiver, callKind: 'method',
+        annotationReceiver: { type, origin: call.receiverTypeEvidence,
+            qualifier: qualifier || null, localDeclarations: local.map(declarationIdentity),
+            bindings, wildcardImports: [], rootDeclarations: [], rootBindings: [],
+            genericParameter: false } };
+}
+
 function _splitTopLevelDelimiter(s, delimiter) {
     const out = [];
     let angle = 0, paren = 0, bracket = 0, brace = 0, cur = '';
@@ -8659,10 +9269,11 @@ function _returnTypeNameNominal(text, language, opts = {}) {
     if (language === 'go') {
         const qm = t.replace(/^\*+/, '').match(/^([A-Za-z_]\w*)\.([A-Za-z_]\w*)$/);
         if (qm) qualifier = qm[1];
-    } else if (language === 'cpp') {
-        const stripped = t
-            .replace(/\b(const|volatile|class|struct|typename)\b/g, '')
-            .replace(/[*&]+/g, '').trim();
+    } else if (language === 'cpp' || language === 'rust') {
+        const stripped = language === 'rust'
+            ? t.replace(/^&(?:\s*'\w+)?\s*/, '').replace(/^mut\s+/, '').trim()
+            : t.replace(/\b(const|volatile|class|struct|typename)\b/g, '')
+                .replace(/[*&]+/g, '').trim();
         const genericStart = stripped.indexOf('<');
         const head = genericStart >= 0
             ? stripped.slice(0, genericStart).trim() : stripped;
@@ -8807,6 +9418,35 @@ function _rustImportedTypeIdentity(index, filePath, localName) {
  *    trusted (a use/import of an external type can shadow it invisibly)
  *  - no project type def at all: external name — safe, can't conflate
  */
+function _rustFlowReceiverOrigin(index, file, name, qualifier) {
+    const entry = index.files.get(file);
+    // An annotation names a type in this module's scope. A same-directory
+    // project Result/Option declaration does not shadow the standard prelude
+    // of another module, nor does an unrelated imported file bind its names.
+    const local = (index.symbols.get(name) || []).some(d => d.file === file &&
+        (IDENTITY_TYPE_KINDS.has(d.type) || (d.type === 'type' && d.aliasOf)));
+    const bound = (entry?.importBindings || []).some(b => (b.alias || b.name) === name);
+    if (!qualifier && !local && !bound) return null;
+    return _resolveFlowTypeOrigin(index, file, name, qualifier);
+}
+
+function _rustSameNameAliasOrigin(index, definition, seen = new Set()) {
+    if (!definition || seen.has(definition) || seen.size >= 8) return null;
+    seen.add(definition);
+    if (definition.type !== 'type') return { fromFile: definition.file };
+    if (!definition.aliasTypeText) return null;
+    const parsed = _returnTypeNameNominal(definition.aliasTypeText, 'rust');
+    if (parsed?.name !== definition.name || !parsed.qualifier) return null;
+    const relative = index.files.get(definition.file)?.moduleResolved?.[parsed.qualifier];
+    const resolved = relative ? path.resolve(index.root, relative)
+        : resolveRustImport(`${parsed.qualifier}::${parsed.name}`, definition.file, index.root) ||
+            resolveRustImport(parsed.qualifier, definition.file, index.root);
+    if (!resolved) return null;
+    const targets = (index.symbols.get(parsed.name) || []).filter(d =>
+        IDENTITY_TYPE_KINDS.has(d.type) && d.file === resolved);
+    return targets.length === 1 ? _rustSameNameAliasOrigin(index, targets[0], seen) : null;
+}
+
 function _resolveFlowTypeOrigin(index, producerFile, typeName, qualifier = undefined) {
     const opCache = index._opFlowTypeOriginCache;
     const cacheKey = `${producerFile}\x00${typeName}\x00${qualifier || ''}`;
@@ -8863,6 +9503,13 @@ function _resolveFlowTypeOrigin(index, producerFile, typeName, qualifier = undef
             const resolved = resolveRustImport(
                 `${qualifier}::${typeName}`, producerFile, index.root);
             if (resolved) {
+                const local = typeDefs.filter(d => d.file === resolved);
+                if (local.length === 1) {
+                    const direct = local[0].type === 'type' && local[0].aliasOf === typeName
+                        ? _rustSameNameAliasOrigin(index, local[0])
+                        : { fromFile: local[0].file };
+                    if (direct) return finish(direct);
+                }
                 const reachable = typeDefs.filter(d =>
                     d.file === resolved ||
                     _importReaches(index, resolved, new Set([d.file])));
@@ -9052,22 +9699,7 @@ const JS_GLOBAL_RECEIVERS = new Set([
     'crypto', 'performance', 'history', 'location', 'screen',
 ]);
 
-const BUILTIN_RECEIVER_TYPES = new Set([
-    'dict', 'list', 'set', 'tuple', 'str', 'int', 'float', 'bool', 'bytes', 'frozenset',
-    'Mapping', 'MutableMapping', 'Sequence', 'MutableSequence',
-    'Collection', 'Iterable', 'Iterator', 'KeysView', 'ValuesView', 'ItemsView',
-    'IO', 'TextIO', 'BinaryIO', 'StringIO', 'BytesIO',
-    'ZlibCompress', 'ZlibDecompress',
-    'AsyncEvent',
-    'Generator', 'AsyncGenerator', 'ContextManager', 'AsyncContextManager',
-    'Array', 'String', 'Object', 'RegExp', 'Number', 'Boolean', 'Map', 'Set', 'Promise',
-    'WeakMap', 'WeakSet',
-    'string', 'number', 'boolean', 'bigint', 'symbol',
-    'object', 'dynamic', 'decimal', 'byte', 'sbyte', 'char',
-    'short', 'ushort', 'uint', 'long', 'ulong', 'double',
-    'List', 'Dictionary', 'HashSet', 'Queue', 'Stack',
-    'Task', 'ValueTask', 'IEnumerable', 'ICollection', 'IList',
-]);
+
 
 // Universal-contract method names (fix #265, hono-measured: 183 untyped
 // `x.toString()` calls confirmed against JSXNode.toString via the single-
@@ -10959,6 +11591,60 @@ function _pythonBuiltinContractAllowed(index, fileEntry, moduleName) {
     return !_unresolvedModuleIsGap(index, module);
 }
 
+function _pythonExternalFieldFlow(index, file, call) {
+    const field = call.receiverRoot === 'self' && (!call.receiverFields || call.receiverFields.length === 1)
+        ? call.receiverField : call.receiver?.startsWith('self.') && call.receiver.split('.').length === 2
+        ? call.receiver.slice(5) : null;
+    if (!field || call.receiverFlowInvalidated) return null;
+    const enclosing = index.findEnclosingFunction(file, call.line, true);
+    if (!enclosing?.className) return null;
+    const owner = (index.symbols.get(enclosing.className) || []).filter(d => d.file === file && d.type === 'class');
+    if (owner.length !== 1) return null;
+    const flow = getInstanceAttributeTypes(index, file, enclosing.className)?.externalFlows?.get(field);
+    if (!flow) return null;
+    const producer = flow.assignments[0];
+    return { via: `${producer.module}.${producer.producer}${'()'.repeat(producer.depth)}`,
+        proof: { ...flow, owner: declarationIdentity(owner[0]), enclosing: declarationIdentity(enclosing) } };
+}
+
+function _pythonFixtureReceiverType(index, file, call) {
+    const resolveType = (context, name, qualifier) => {
+        const root = qualifier || name, entry = index.files.get(context);
+        if ((entry.moduleAssignedNames || []).includes(root) ||
+            (entry.importBindings || []).filter(b => (b.alias || b.name) === root).length > 1 ||
+            (qualifier && (index.symbols.get(root) || []).some(d => d.file === context))) return null;
+        return pythonFixtureType(index, context, qualifier ? `${qualifier}.${name}` : name,
+            d => IDENTITY_TYPE_KINDS.has(d.type));
+    };
+    return pythonFixtureReceiver(index, file, call, {
+        resolveType,
+        externalModule: (context, module) => _pythonBuiltinContractAllowed(index, index.files.get(context), module),
+        field(type, context, field) {
+            const owner = resolveType(context, type)?.declaration;
+            if (!owner) return null;
+            const members = (index.symbols.get(field) || []).filter(d => d.className === type && d.file === owner.file &&
+                ['property', 'getter', 'field'].includes(d.type));
+            if (members.length !== 1) return null;
+            const member = members[0], text = member.returnType || member.fieldType;
+            const result = _structuralTypeExpression(text);
+            if (!result || result.args.length) return null;
+            const qualifier = result.qualifiedHead.includes('.')
+                ? result.qualifiedHead.slice(0, result.qualifiedHead.lastIndexOf('.')) : undefined;
+            const next = resolveType(member.file, result.head, qualifier);
+            const builtin = !qualifier && !next && isProvenanceBuiltinReceiver(result.head, 'python') &&
+                !(index.files.get(member.file).importBindings || []).some(b => (b.alias || b.name) === result.head) &&
+                !(index.files.get(member.file).moduleAssignedNames || []).includes(result.head) &&
+                !(index.symbols.get(result.head) || []).some(d => d.file === member.file);
+            if (!next && !builtin) return null;
+            return { type: result.head, fromFile: next?.declaration.file,
+                fact: { owner: declarationIdentity(owner), member: declarationIdentity(member), annotation: text,
+                    result: next ? declarationIdentity(next.declaration) : { builtin: result.head, language: 'python' },
+                    ...(builtin && { builtinShadowDeclarations: [], builtinShadowBindings: [] }),
+                    importChain: next?.chain || [] } };
+        },
+    });
+}
+
 function _structuralImportedReceiverType(index, fileEntry, receiver) {
     const bindings = (fileEntry.importBindings || []).filter(binding =>
         binding.name === receiver || binding.alias === receiver);
@@ -10981,7 +11667,7 @@ function _structuralImportedReceiverType(index, fileEntry, receiver) {
     return { type: receiver, fromFile: definition.file };
 }
 
-function _pythonBuiltinCallReturnType(index, fileEntry, call) {
+function _pythonBuiltinCallReturnType(index, fileEntry, call, evidence = null) {
     if (fileEntry?.language !== 'python') return null;
     const adapter = getLanguageAdapter('python');
     if (typeof adapter?.getBuiltinCallReturnType !== 'function') return null;
@@ -10998,7 +11684,10 @@ function _pythonBuiltinCallReturnType(index, fileEntry, call) {
     for (const binding of bindings) {
         if (!_pythonBuiltinContractAllowed(index, fileEntry, binding.module)) continue;
         const type = adapter.getBuiltinCallReturnType(binding.module, call.name);
-        if (type) types.add(type);
+        if (type) {
+            types.add(type);
+            if (evidence) (evidence.bindings ||= []).push({ ...binding, returnType: type });
+        }
     }
     return types.size === 1 ? [...types][0] : null;
 }
@@ -11010,21 +11699,30 @@ function _pythonBuiltinFieldPathType(index, fileEntry, root, fields) {
     const bindings = (fileEntry.importBindings || []).filter(binding =>
         binding.name === root || binding.alias === root);
     const types = new Set();
+    const contracts = [];
     for (const binding of bindings) {
         if (!_pythonBuiltinContractAllowed(index, fileEntry, binding.module)) continue;
         const type = adapter.getBuiltinFieldType(binding.module, fields[0]);
-        if (type) types.add(type);
+        if (type) {
+            types.add(type);
+            contracts.push({ ...binding, field: fields[0], type });
+        }
     }
-    return types.size === 1 ? [...types][0] : null;
+    return types.size === 1 ? { type: [...types][0], root, fields, bindings: contracts } : null;
 }
 
 function _pythonBuiltinChainedReceiverType(index, fileEntry, call, foldCtx) {
     if (fileEntry?.language !== 'python') return null;
     const producers = _chainedProducerRecords(foldCtx, call);
     if (producers.length === 0) return null;
-    const types = producers.map(producer =>
-        _pythonBuiltinCallReturnType(index, fileEntry, producer));
-    return types.every(Boolean) && new Set(types).size === 1 ? types[0] : null;
+    const witnesses = producers.map(producer => {
+        const evidence = { name: producer.name, line: producer.line, site: producer.callSite };
+        const type = _pythonBuiltinCallReturnType(index, fileEntry, producer, evidence);
+        return { type, ...evidence };
+    });
+    const types = witnesses.map(witness => witness.type);
+    return types.every(Boolean) && new Set(types).size === 1
+        ? { type: types[0], producers: witnesses } : null;
 }
 
 /**
@@ -11062,12 +11760,22 @@ function _calleeStructuralModuleRoute(index, fileEntry, call, language) {
 }
 
 function _calleeStructuralImportedNameRoute(index, fileEntry, call, language) {
-    const lookupName = call.resolvedName || call.name;
+    let lookupName = call.resolvedName || call.name;
     let bindings = (fileEntry?.importBindings || []).filter(b => b.name === lookupName);
     if (call.resolvedName && bindings.some(b => b.alias)) {
         const paired = bindings.filter(b => b.alias === call.name);
         if (paired.length > 0) bindings = paired;
     }
+    // fix #357: a call spelled by a rename's LOCAL alias (Rust `use m::a as
+    // b; b()`) pairs with exactly the binding carrying that alias, and the
+    // exported item is the binding's ORIGINAL name.
+    if (bindings.length === 0) {
+        const aliased = (fileEntry?.importBindings || []).filter(b => b.alias === call.name);
+        if (aliased.length > 0 && new Set(aliased.map(b => b.name)).size === 1) {
+            bindings = aliased;
+            lookupName = aliased[0].name;
+        }
+    }
     if (bindings.length === 0) return null;
     return _calleeStructuralBindingRoute(index, fileEntry, call, language, bindings, lookupName, true);
 }
@@ -11127,6 +11835,7 @@ function _calleeExportDefinitions(index, startAbs, exposedName, language, call,
     let unknown = false;
     let frontier = [[startAbs, exposedName]];
     const shapeMatches = d =>
+        (language !== 'rust' || !(d.className || d.receiver)) &&
         (!NON_CALLABLE_TYPES.has(d.type) ||
             (call.isConstructor && d.type === 'class') ||
             (langTraits(language)?.classesCallableWithoutNew && d.type === 'class')) &&
@@ -11264,6 +11973,19 @@ function _calleeGoPackageMatch(index, call, importModule) {
     return bestMatch;
 }
 
+function selectProvenanceOverload(index, call, candidates, language) {
+    const remaining = new Set(candidates);
+    const slots = [];
+    for (const definition of candidates) {
+        if (!remaining.has(definition)) continue;
+        const group = _closeCallableIdentityGroup(index, [definition], candidates);
+        const representative = group.find(d => !d.isSignature && !d.isDeclaration) || definition;
+        slots.push(representative);
+        for (const member of group) remaining.delete(member);
+    }
+    return _calleeOverloadSelect(index, call, slots, language);
+}
+
 function _calleeOverloadSelect(index, call, matches, language) {
     if (matches.length === 0) return { match: null };
     if (call.argCount == null || call.argSpread) {
@@ -11580,6 +12302,7 @@ function _declaredFieldType(
                     className: rootType,
                     fieldType,
                     file: owner.file,
+                    ...(attrs.origins?.get(fieldName) && { fieldOrigin: attrs.origins.get(fieldName) }),
                 });
             }
             if (complete && inferred.length > 0) {
@@ -11642,6 +12365,7 @@ function _declaredFieldType(
     const aliasBase = _pureAliasBase(index, typeName);
     if (aliasBase) typeName = aliasBase;
     if (info) {
+        if (onType.length === 1 && onType[0].fieldOrigin) Object.assign(info, onType[0].fieldOrigin);
         const origins = new Set();
         const namespaces = new Set();
         let complete = true;
@@ -12309,7 +13033,14 @@ function _calleeSingleOwnerMatch(index, def, fileEntry, call, name, language, fl
     if (matchFe && callerFe &&
         (isTestFile(matchFe.relativePath, matchFe.language) || isTestPath(matchFe.relativePath)) &&
         !(isTestFile(callerFe.relativePath, callerFe.language) || isTestPath(callerFe.relativePath))) return null;
-    return match;
+    const facts = _confirmationFacts(index, def.file, call, [match], {
+        ...(flowEntry?.type && !call.receiverType && {
+            receiverType: flowEntry.type, receiverTypeSource: 'flow',
+            receiverOrigin: { source: 'flow', ...flowEntry }, originFile: flowEntry.fromFile,
+        }),
+    });
+    return validateConfirmation({ facts }, facts.targets).verdict === 'establishes-target'
+        ? match : null;
 }
 
 const _CSHARP_TYPE_ALIASES = new Map([
@@ -15111,8 +15842,18 @@ function _methodReturnOnType(index, typeName, fromFile, methodName, language, op
         const parsed = _returnTypeNameNominal(def.returnType, language, { selfClass: selfType });
         if (!parsed) return null;
         const origin = _resolveFlowTypeOrigin(index, def.file || opts.filePath, parsed.name, parsed.qualifier);
-        if (!origin) return null;
-        return { type: parsed.name, ...(origin.fromFile && { fromFile: origin.fromFile }) };
+        const wrappers = language === 'rust' ? owned.map(candidate =>
+            _rustReturnWrapper(index, candidate.returnType, candidate.file || opts.filePath,
+                selfType, candidate, [], true)) : [];
+        // Identical annotation text in different impl files can bind different
+        // aliases. Every possible producer must agree on the payload identity.
+        const rustWrapper = wrappers.length && wrappers.every(wrapper => wrapper &&
+            wrapper.kind === wrappers[0].kind && wrapper.type === wrappers[0].type &&
+            wrapper.fromFile === wrappers[0].fromFile) ? wrappers[0] : null;
+        if (!origin && !rustWrapper) return null;
+        return { ...(origin && { type: parsed.name }), ...(origin?.fromFile && { fromFile: origin.fromFile }),
+            ...(language === 'rust' && owned.length === 1 && { rustReturnDeclaration: _rustReturnDeclaration(def) }),
+            ...(rustWrapper && { rustWrapper }) };
     }
     // Structural: heads must agree; `this`/`Self` are the receiver's type
     // (checked BEFORE the reject set — with a known owner they ARE identity);
@@ -15266,7 +16007,72 @@ function _rustPathIsKnownExternal(index, fileEntry, filePath, receiver, name) {
         `${segments.join('::')}::${name}`, filePath, index.root);
 }
 
-function _rustPatternReceiverType(index, fileEntry, filePath, record) {
+/** A qualified free function belongs to its exact module, never an impl
+ * whose type or method happens to share either path component. Re-exports
+ * and inline modules abstain until their complete item path is available.
+ */
+function _rustModuleProducer(index, fileEntry, filePath, call) {
+    if (!call.isPathCall || !call.receiver || call.receiverType || call.localShadow) return null;
+    const parts = call.receiver.split('::');
+    const root = parts[0];
+    const bindings = (fileEntry.importBindings || []).filter(b => (b.alias || b.name) === root);
+    const locals = (index.symbols.get(root) || []).filter(d => d.file === filePath);
+    if (locals.some(d => d.type !== 'module') || bindings.length > 1) return null;
+    const binding = bindings[0];
+    const specifier = binding ? [binding.module, ...parts.slice(1)].join('::') : call.receiver;
+    const terminal = specifier.split('::').at(-1);
+    if (!terminal || ['Self', 'self', 'super', 'crate'].includes(terminal)) return null;
+    const relative = fileEntry.moduleResolved?.[specifier];
+    const destination = relative ? path.resolve(index.root, relative)
+        : resolveRustImport(specifier, filePath, index.root);
+    if (!destination || !index.files.has(destination) || destination === filePath) return null;
+    const base = path.basename(destination, '.rs');
+    if ((base === 'mod' ? path.basename(path.dirname(destination)) : base) !== terminal) return null;
+    const candidates = (index.symbols.get(call.name) || []).filter(d => d.file === destination &&
+        !NON_CALLABLE_TYPES.has(d.type) && !d.className && !d.receiver && !d.namespace);
+    if (candidates.length !== 1 || !candidates[0].returnType) return null;
+    const definition = candidates[0];
+    if ((index.files.get(destination).symbols || []).some(d => d.type === 'module' &&
+        d.startLine < definition.startLine && d.endLine >= definition.endLine)) return null;
+    return { definition, facts: {
+        call: { file: fileEntry.relativePath, line: call.line, start: call.callStart,
+            end: call.callEnd, receiver: call.receiver, name: call.name },
+        binding: binding || null, module: { specifier, file: path.relative(index.root, destination) },
+        declaration: { ...declarationIdentity(definition), returnType: definition.returnType },
+    } };
+}
+
+function _rustPatternReceiverType(index, fileEntry, filePath, record, ctx) {
+    if (['Some', 'Ok'].includes(record.receiverPatternVariant) && !record.receiverPatternOwner &&
+        (record.receiverPatternIndex || 0) === 0 &&
+        (record.receiverPatternSourceCallStart != null || record.receiverPatternSourceVariable)) {
+        if (!ctx) {
+            const records = index.getCachedCalls(filePath);
+            ctx = { records, memo: new Map(), visiting: new Set(),
+                getFlowMap: () => _buildReturnTypeFlowMap(index, filePath, records) };
+        }
+        const shadow = (index.symbols.get(record.receiverPatternVariant) || []).some(d => d.file === filePath) ||
+            (fileEntry.importBindings || []).some(b => (b.alias || b.name) === record.receiverPatternVariant || b.name === '*');
+        const sources = record.receiverPatternSourceVariable
+            ? [_lookupReturnTypeFlow(ctx.getFlowMap(), { ...record, receiver: record.receiverPatternSourceVariable,
+                receiverPatternShadow: false })]
+            : ctx.records.filter(source => source.callStart === record.receiverPatternSourceCallStart &&
+                source.callEnd === record.receiverPatternSourceCallEnd).map(source =>
+                _typeOfCallResultFold(index, fileEntry, filePath, source, ctx));
+        const producer = sources.length === 1 && sources[0]?.rustReturnDeclaration;
+        const contract = !shadow && producer && _rustReturnWrapper(index, producer.returnType, producer.file,
+            producer.className, producer, record.receiverPatternProjection || []);
+        if (contract && validateRustWrapperContract(contract) &&
+            contract.kind === (record.receiverPatternVariant === 'Some' ? 'Option' : 'Result')) {
+            return { type: contract.type, fromFile: contract.fromFile,
+                wrapperPattern: { variant: record.receiverPatternVariant, contract,
+                    source: { start: record.receiverPatternSourceCallStart, end: record.receiverPatternSourceCallEnd,
+                        variable: record.receiverPatternSourceVariable }, shadowDeclarations: [], shadowBindings: [] } };
+        }
+        // A tuple payload cannot be treated as its outer type by the older
+        // whole-payload path below.
+        if (record.receiverPatternProjection?.length) return null;
+    }
     let variants = (index.symbols.get(record.receiverPatternVariant) || [])
         .filter(definition => definition.type === 'variant');
     if (record.receiverPatternOwner) {
@@ -15356,7 +16162,15 @@ const _RUST_ITERATOR_ITEM_CALLBACKS = new Set([
 ]);
 
 function _rustRecordReceiverType(index, fileEntry, filePath, record, ctx) {
-    if (record.receiverType && !record.receiverIsChainRoot) {
+    if (record.receiver === 'self') {
+        const enclosing = index.findEnclosingFunction(filePath, record.line, true);
+        if (enclosing?.className) {
+            const origin = _resolveFlowTypeOrigin(index, filePath, enclosing.className);
+            if (origin?.fromFile) return { type: enclosing.className, fromFile: origin.fromFile };
+        }
+    }
+    if (record.receiverType && !record.receiverIsChainRoot &&
+        !record.receiverTypeGuessed && record.receiverTypeSource !== 'guess') {
         const origin = _resolveFlowTypeOrigin(
             index, filePath, record.receiverType, record.receiverTypeQualifier);
         if (origin?.fromFile) {
@@ -15383,9 +16197,13 @@ function _rustRecordReceiverType(index, fileEntry, filePath, record, ctx) {
     }
     if (record.receiverPatternVariant) {
         const pattern = _rustPatternReceiverType(
-            index, fileEntry, filePath, record);
+            index, fileEntry, filePath, record, ctx);
         if (pattern) return pattern;
     }
+    if (record.enclosingFunction?.closureParameterNames?.includes(record.receiver)) {
+        const parameter = _rustClosureReceiverType(index, fileEntry, filePath, record, ctx);
+        if (parameter) return parameter;
+    }
     if (record.receiver && !record.receiverIsChainRoot &&
         !record.receiverPatternShadow) {
         const flow = _lookupReturnTypeFlow(ctx.getFlowMap(), record);
@@ -15485,6 +16303,35 @@ const _RUST_ITERATOR_ITEM_PRESERVING = new Set([
     'skip', 'skip_while', 'step_by', 'take', 'take_while',
 ]);
 
+function _rustIterationReceiverType(index, fileEntry, filePath, call, ctx) {
+    let items = [];
+    let producers = [];
+    if (call.receiverIterationVariable) {
+        const flow = _lookupReturnTypeFlow(ctx.getFlowMap(), {
+            ...call, receiver: call.receiverIterationVariable,
+        });
+        if (flow?.iteratorItemType) {
+            items = [{ type: flow.iteratorItemType, fromFile: flow.iteratorItemFromFile }];
+            producers = [{ ...flow }];
+        }
+    } else {
+        const sources = _chainedProducerRecords(ctx, {
+            receiverCall: call.receiverIterationCall,
+            receiverCallIsMethod: call.receiverIterationCallIsMethod,
+            receiverCallLine: call.receiverIterationCallLine,
+            receiverCallStart: call.receiverIterationCallStart,
+            receiverCallEnd: call.receiverIterationCallEnd,
+        });
+        items = sources.map(source => _rustIteratorOutputItemType(index, fileEntry, filePath, source, ctx));
+        producers = sources.map(source => ({ name: source.name,
+            site: occurrenceIdentity(fileEntry.relativePath, source) }));
+    }
+    if (!items.length || items.some(item => !item?.fromFile) ||
+        new Set(items.map(item => item.type)).size !== 1 ||
+        new Set(items.map(item => item.fromFile)).size !== 1) return null;
+    return { ...items[0], alternatives: items, producers };
+}
+
 function _rustIteratorOutputItemType(index, fileEntry, filePath, source, ctx, visiting = new Set()) {
     if (!source || visiting.has(source)) return null;
     visiting.add(source);
@@ -15731,6 +16578,16 @@ function _typeOfCallResultFoldInner(index, fileEntry, filePath, record, ctx, con
                 externalConcrete: true,
             };
         }
+        const module = language === 'rust' ? _rustModuleProducer(index, fileEntry, filePath, record) : null;
+        if (module) {
+            const producer = module.definition;
+            const parsed = _returnTypeNameNominal(producer.returnType, language);
+            const origin = parsed && _resolveFlowTypeOrigin(index, producer.file, parsed.name, parsed.qualifier);
+            if (!origin) return null;
+            return { type: parsed.name, fromFile: origin.fromFile, moduleProducer: module.facts,
+                rustReturnDeclaration: _rustReturnDeclaration(producer),
+                rustWrapper: _rustReturnWrapper(index, producer.returnType, producer.file, null, producer) };
+        }
         const segs = String(record.receiver).split('::');
         let seg = segs.pop();
         if (seg === 'Self') {
@@ -15872,11 +16729,15 @@ function _typeOfCallResultFoldInner(index, fileEntry, filePath, record, ctx, con
     if (record.isMethod) {
         let rt = _goBuiltinChainedReceiverType(
             index, fileEntry, filePath, record);
-        if (record.receiverType && !record.receiverIsChainRoot) {
-            const origin = nominal
+        if (record.receiverType && !record.receiverIsChainRoot &&
+            !record.receiverTypeGuessed && record.receiverTypeSource !== 'guess') {
+            const origin = language === 'rust'
+                ? _rustFlowReceiverOrigin(index, filePath, record.receiverType, record.receiverTypeQualifier)
+                : nominal
                 ? _resolveFlowTypeOrigin(index, filePath, record.receiverType,
                     record.receiverTypeQualifier)
                 : null;
+            if (language === 'rust' && !origin?.fromFile) return null;
             rt = {
                 type: record.receiverType,
                 ...(origin?.fromFile && { fromFile: origin.fromFile }),
@@ -16073,7 +16934,8 @@ function _typeOfCallResultFoldInner(index, fileEntry, filePath, record, ctx, con
         if (!parsed) return null;
         const origin = _resolveFlowTypeOrigin(index, chosen.file || filePath, parsed.name, parsed.qualifier);
         if (!origin) return null;
-        return { type: parsed.name, ...(origin.fromFile && { fromFile: origin.fromFile }) };
+        return { type: parsed.name, ...(origin.fromFile && { fromFile: origin.fromFile }),
+            ...(language === 'rust' && chosen.file === filePath && { rustReturnDeclaration: _rustReturnDeclaration(chosen) }) };
     }
     if (language === 'python' && !consumerAwaited && chosen.isAsync) return null;
     let head = _structuralTypeHead(chosen.returnType, {
@@ -16167,6 +17029,9 @@ function _foldChainedReceiverType(index, fileEntry, filePath, call, ctx) {
     const typeTexts = new Set(results.map(r => r.typeText));
     let result = {
         type: results[0].type,
+        ...(results.length === 1 && results[0].moduleProducer && {
+            moduleProducer: results[0].moduleProducer,
+        }),
         ...(typeTexts.size === 1 && results[0].typeText && {
             typeText: results[0].typeText,
         }),
@@ -16317,4 +17182,4 @@ function findCallbackUsages(index, name) {
     return usages;
 }
 
-module.exports = { _unresolvedModuleIsGap, _importReaches, _sameNominalPackageDir, getCachedCalls, findCallers, findCallees, getInstanceAttributeTypes, findCallbackUsages, _nameBindingReaches, _moduleAttributeBindingReaches, _declaredFieldType, _projectTopLevelNames, _callArityCompatible, _closeCallableIdentityGroup, _overloadDiscipline, _overloadApplicable };
+module.exports = { isProvenanceBuiltinReceiver, provenanceParameterIdentity: _overloadTypeIdentity, selectProvenanceOverload, _unresolvedModuleIsGap, _importReaches, _sameNominalPackageDir, getCachedCalls, findCallers, findCallees, getInstanceAttributeTypes, findCallbackUsages, _nameBindingReaches, _moduleAttributeBindingReaches, _declaredFieldType, _projectTopLevelNames, _callArityCompatible, _closeCallableIdentityGroup, _overloadDiscipline, _overloadApplicable };