ucn 5.2.0 → 5.2.2

package/core/callers.js

@@ -20,6 +20,15 @@ const CONSTRUCTABLE_BINDING_KINDS = new Set([
 const RESERVED_RECEIVER_NAMES = new Set([
     'self', 'cls', 'this', 'super', 'base', 'Self',
 ]);
+const CROSS_OPERATION_FLOW_CACHE_LIMIT = 4096;
+
+// `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.
+function _isReservedReceiver(language, receiver) {
+    if (receiver === 'base') return language === 'csharp';
+    return RESERVED_RECEIVER_NAMES.has(receiver);
+}
 
 /** Set.some() helper — like Array.some() but for Sets */
 function setSome(set, predicate) {
@@ -586,6 +595,7 @@ function findCallers(index, name, options = {}) {
     const localTypeCache = new Map(); // `${filePath}:${startLine}` -> localTypes Map or null
     const returnFlowCache = new Map(); // filePath -> return-type-flow map (see _buildReturnTypeFlowMap)
     const foldCtxCache = new Map(); // filePath -> chained-receiver fold context (fix #258)
+    const pythonIndexedReceiverCache = new Map();
 
     // Use inverted callee index to skip files that don't contain calls to this name
     let calleeFiles = index.getCalleeFiles(name);
@@ -651,6 +661,26 @@ function findCallers(index, name, options = {}) {
                     continue;
                 }
 
+                if (fileEntry.language === 'go' && call.isMethod &&
+                    !call.receiverType && call.receiverIndexField) {
+                    const indexedType = _goIndexedReceiverType(index, filePath, call);
+                    if (indexedType?.type) {
+                        call = {
+                            ...call,
+                            receiverType: indexedType.type,
+                            ...(indexedType.fromFile && {
+                                receiverTypeFlowFile: indexedType.fromFile,
+                            }),
+                        };
+                    } else if (indexedType?.externalVia) {
+                        call = {
+                            ...call,
+                            receiverExternalFlow: indexedType.externalVia,
+                            receiverExternalConcreteFlow: true,
+                        };
+                    }
+                }
+
                 // A call-shaped identifier in a C/C++ replacement list can
                 // be a macro parameter (`#define APPLY(fn, x) fn(x)`). It is
                 // dynamically supplied by each expansion and therefore is
@@ -870,7 +900,7 @@ function findCallers(index, name, options = {}) {
                 // type derives from OTHER files' annotations, so it must never be
                 // persisted with this file's calls.
                 if (call.isMethod && call.receiver &&
-                    !RESERVED_RECEIVER_NAMES.has(call.receiver) &&
+                    !_isReservedReceiver(fileEntry.language, call.receiver) &&
                     (!call.receiverType || call.receiverTypeGuessed) &&
                     !call.receiverPatternShadow && !call.receiverFlowInvalidated &&
                     !call.receiverIsChainRoot &&
@@ -916,6 +946,34 @@ function findCallers(index, name, options = {}) {
                             ...(flowEntry.fromFile && { receiverTypeFlowFile: flowEntry.fromFile }) };
                     }
                 }
+
+                // Python indexed receivers (fix #324): `layout["body"].update()`
+                // dispatch through the container's compiler-visible
+                // `__getitem__` return contract. The parser retains only a
+                // simple identifier root; query time pins that root's type to
+                // an exact project definition before trusting the contract.
+                // External, unresolved, and ambiguous containers abstain.
+                if (fileEntry.language === 'python' && call.isMethod &&
+                    !call.receiverType && call.receiverSubscriptRoot) {
+                    const indexedType = _pythonIndexedReceiverType(
+                        index, filePath, call, () => {
+                            let flowMap = returnFlowCache.get(filePath);
+                            if (flowMap === undefined) {
+                                flowMap = _buildReturnTypeFlowMap(index, filePath, calls);
+                                returnFlowCache.set(filePath, flowMap);
+                            }
+                            return flowMap;
+                        }, pythonIndexedReceiverCache);
+                    if (indexedType?.type) {
+                        call = {
+                            ...call,
+                            receiverType: indexedType.type,
+                            ...(indexedType.fromFile && {
+                                receiverTypeFlowFile: indexedType.fromFile,
+                            }),
+                        };
+                    }
+                }
                 // Python loop/comprehension bindings can inherit item types
                 // from a declared attribute path. The parser records the
                 // source path (`request.headers.raw`) and tuple position;
@@ -1581,9 +1639,56 @@ function findCallers(index, name, options = {}) {
                         cbTargetDefs.some(d => d.file &&
                             _sameNominalPackageDir(path.dirname(d.file), path.dirname(filePath), fileEntry.language));
                     let cbImportLink = false;
+                    // A module-scoped variable passed as a callback has a
+                    // concrete lexical owner, but its VALUE may be dynamic
+                    // (`const app = express(); use(app)`). It must not borrow
+                    // target identity from an unrelated file-level import
+                    // edge. Exact named/default imports still confirm when
+                    // their export chain reaches the pin; definitive chains
+                    // elsewhere exclude; dynamic/CJS factory values remain
+                    // visible. Account-gated to preserve legacy trace/blast
+                    // behavior while strengthening grep-reliable surfaces.
+                    if (collectAccount && !cbSameFile && call.moduleLocalBinding &&
+                        langTraits(fileEntry.language)?.typeSystem === 'structural') {
+                        const cbNameBindings = (fileEntry.importBindings || []).filter(binding =>
+                            binding.name === call.name || binding.alias === call.name);
+                        let cbBindingReaches = false;
+                        let cbBindingUnknown = cbNameBindings.length === 0;
+                        for (const binding of cbNameBindings) {
+                            const rel = fileEntry.moduleResolved?.[binding.module];
+                            if (!rel) {
+                                const mod = String(binding.module || '');
+                                const firstSeg = mod.split(/[./]/).filter(Boolean)[0];
+                                if (mod.startsWith('.') ||
+                                    (firstSeg && _projectTopLevelNames(index).has(firstSeg))) {
+                                    cbBindingUnknown = true;
+                                }
+                                continue;
+                            }
+                            const resolvedAbs = path.join(index.root, rel);
+                            const verdict = binding.defaultLike
+                                ? _defaultBindingReaches(index, resolvedAbs, cbTargetFiles)
+                                : _nameBindingReaches(index, resolvedAbs, binding.name, cbTargetFiles);
+                            if (verdict === 'yes') {
+                                cbBindingReaches = true;
+                                break;
+                            }
+                            if (verdict === 'unknown') cbBindingUnknown = true;
+                        }
+                        if (!cbBindingReaches && !cbBindingUnknown) {
+                            recordExcluded(filePath, call.line, 'other-definition-import');
+                            continue;
+                        }
+                        if (!cbBindingReaches) {
+                            routeUnverified(filePath, fileEntry, call, 'ambiguous-binding', calledAs);
+                            continue;
+                        }
+                        cbImportLink = true;
+                    }
                     if (!cbSameFile && !cbSamePackage) {
                         const cbImports = index.importGraph.get(filePath);
-                        cbImportLink = !!(cbImports && setSome(cbImports, imp => cbTargetFiles.has(imp)));
+                        cbImportLink = cbImportLink ||
+                            !!(cbImports && setSome(cbImports, imp => cbTargetFiles.has(imp)));
                         if (!cbImportLink && cbImports) {
                             for (const imp of cbImports) {
                                 const trans = index.importGraph.get(imp);
@@ -2072,7 +2177,8 @@ function findCallers(index, name, options = {}) {
                                 continue;
                             }
                         }
-                    } else if (['self', 'cls', 'this', 'super', 'base'].includes(call.receiver) ||
+                    } else if (['self', 'cls', 'this', 'super'].includes(call.receiver) ||
+                               (call.receiver === 'base' && fileEntry.language === 'csharp') ||
                                (call.receiver === 'Self' && fileEntry.language === 'rust')) {
                         // self/this/super.method() — resolve to same-class or parent method.
                         // Rust `Self::method()` (fix #232) is the path-call same-class form:
@@ -2089,8 +2195,8 @@ function findCallers(index, name, options = {}) {
                             }
                         } else {
                             // For super(), skip same-class — only check parent chain
-                            const parentOnlyReceiver =
-                                call.receiver === 'super' || call.receiver === 'base';
+                            const parentOnlyReceiver = call.receiver === 'super' ||
+                                (call.receiver === 'base' && fileEntry.language === 'csharp');
                             let matchedClass = !parentOnlyReceiver &&
                                 definitions.some(d => d.className === callerSymbol.className)
                                 ? callerSymbol.className : null;
@@ -2244,7 +2350,23 @@ function findCallers(index, name, options = {}) {
                         ...call,
                         receiver: call.receiverRoot,
                     });
-                    if (inferredRoot?.type) fieldHopRootType = inferredRoot.type;
+                    if (inferredRoot?.type) {
+                        fieldHopRootType = inferredRoot.type;
+                    } else if (inferredRoot?.externalVia &&
+                        !call.receiverExternalFlow) {
+                        // External root-flow through a field path (fix #306,
+                        // chi-measured): `resp := http.Get(...); resp.Body.Close()`.
+                        // The compiler fixed `resp` outside the project, so
+                        // `.Body` cannot turn a globally unique project Close
+                        // into an exact edge. Preserve the provenance on the
+                        // demote-only external-contract rail; a generic
+                        // external root may still carry a project value.
+                        call = {
+                            ...call,
+                            receiverExternalFlow:
+                                `${inferredRoot.externalVia}.${call.receiverField}`,
+                        };
+                    }
                 }
                 // Go's parser preserves the package qualifier on a declared
                 // root type (`r *http.Response; r.Body.Close()`). If that
@@ -2305,6 +2427,27 @@ function findCallers(index, name, options = {}) {
                         };
                     }
                 }
+                // Structural namespace value hop (fix #315, Zod-measured):
+                // `core.globalRegistry.add()` has a module namespace root and
+                // an exported VALUE whose explicit annotation fixes the
+                // receiver type. Follow exact ESM re-export chains (including
+                // barrels) to that annotation; untyped/conflicting/dynamic
+                // surfaces abstain. This is the value-level counterpart of
+                // the declared class-field hop above.
+                if (!fieldHopType && call.isMethod && !call.receiverType &&
+                    call.receiverField && !resolvedBySameClass &&
+                    langTraits(fileEntry.language)?.typeSystem === 'structural') {
+                    const moduleValueInfo = {};
+                    fieldHopType = _structuralModuleValueFieldType(
+                        index, fileEntry, call, moduleValueInfo);
+                    if (fieldHopType && moduleValueInfo.fromFile &&
+                        !call.receiverTypeFlowFile) {
+                        call = {
+                            ...call,
+                            receiverTypeFlowFile: moduleValueInfo.fromFile,
+                        };
+                    }
+                }
                 if (!resolvedByExtensionMethod && fileEntry.language === 'csharp' &&
                     fieldHopType) {
                     resolvedByExtensionMethod = _csharpExtensionCallMatches(
@@ -2908,7 +3051,7 @@ function findCallers(index, name, options = {}) {
                 // only when every target is a class method; standalone-function
                 // and class (constructor) targets keep flowing on import evidence.
                 if ((!bindingId || recvExportedNamespace) && !resolvedBySameClass && call.isMethod &&
-                    (call.receiverIsModule || recvExportedNamespace) &&
+                    (call.receiverIsModule || call.receiverModuleSpecifier || recvExportedNamespace) &&
                     langTraits(fileEntry.language)?.typeSystem === 'structural' &&
                     targetDefs.length > 0 && targetDefs.every(d => d.className)) {
                     isUncertain = true;
@@ -2935,11 +3078,30 @@ function findCallers(index, name, options = {}) {
                 // dynamic CJS surfaces can exceed the modeled ownership);
                 // unresolved-but-project-looking → visible (resolver gap).
                 if ((!bindingId || recvExportedNamespace) && !resolvedBySameClass && call.isMethod &&
-                    (call.receiverIsModule || recvSubmoduleRel || recvExportedNamespace) &&
+                    (call.receiverIsModule || call.receiverModuleSpecifier ||
+                        recvSubmoduleRel || recvExportedNamespace ||
+                        call.receiverModuleComposition) &&
                     langTraits(fileEntry.language)?.typeSystem === 'structural') {
-                    const recvBindings = recvExportedNamespace
-                        ? [] : _structuralModuleBindings(fileEntry, call);
                     const tFiles = targetDefinitionFiles;
+                    const compositeOwnership = call.receiverModuleComposition
+                        ? _structuralCompositeModuleOwnership(
+                            index, fileEntry, call, tFiles)
+                        : null;
+                    if (compositeOwnership?.verdict === 'no') {
+                        recordExcluded(filePath, call.line, 'other-definition-import');
+                        continue;
+                    }
+                    if (compositeOwnership?.verdict === 'unknown') {
+                        if (collectAccount) {
+                            routeUnverified(filePath, fileEntry, call,
+                                'no-import-link', calledAs);
+                            continue;
+                        }
+                    }
+                    const recvBindings = recvExportedNamespace
+                        ? [] : (compositeOwnership?.verdict === 'yes'
+                            ? [compositeOwnership.binding]
+                            : _structuralModuleBindings(fileEntry, call));
                     // Same-file targets get NO bypass (fix #294, flask-measured:
                     // `import json as _json; _json.dump(...)` in the file
                     // defining flask's own `dump` confirmed a self-recursive
@@ -4099,18 +4261,37 @@ function findCallers(index, name, options = {}) {
                                             if (r && index.files.has(r)) _modFiles.push(r);
                                         } catch { /* resolver gap — never exclusion evidence */ }
                                     }
+                                    const _targetFiles = new Set(
+                                        targetDefs2.map(d => d.file).filter(Boolean));
                                     const _pinnedIn = _modFiles.length > 0 &&
                                         targetDefs2.some(d => _modFiles.includes(d.file));
-                                    if (!_pinnedIn) {
+                                    // A module/crate surface may re-export the
+                                    // callable from a child module (`pub use
+                                    // self::join::join`). Path ownership is
+                                    // name-aware: reaching a file that declares
+                                    // a same-named module is not a competing
+                                    // value-namespace definition. Follow the
+                                    // exact name through import/re-export
+                                    // bindings before deciding this path owns a
+                                    // different callable (fix #302, Rayon).
+                                    const _reexportVerdicts = _pinnedIn ? [] :
+                                        _modFiles.map(f => _nameBindingReaches(
+                                            index, f, name, _targetFiles));
+                                    const _reexportPinned =
+                                        _reexportVerdicts.includes('yes');
+                                    if (!_pinnedIn && !_reexportPinned) {
                                         const _ownsName = _modFiles.some(f => {
                                             const fe2 = index.files.get(f);
                                             return fe2 && fe2.symbols && fe2.symbols.some(s =>
-                                                s.name === name && !NON_CALLABLE_TYPES.has(s.type));
+                                                s.name === name && s.type !== 'module' &&
+                                                !NON_CALLABLE_TYPES.has(s.type));
                                         });
                                         if (_ownsName) {
                                             recordExcluded(filePath, call.line, 'other-definition');
                                             continue;
                                         }
+                                        // A live but unresolved re-export path
+                                        // is uncertainty, never negative proof.
                                         routeUnverified(filePath, fileEntry, call, 'method-ambiguous', calledAs, {
                                             dispatchCandidates: methodOwnerKeys().size,
                                         });
@@ -4398,6 +4579,13 @@ function findCallers(index, name, options = {}) {
                         if (!typeQualifiedReceiver && call.receiverLocalBinding &&
                             !call.receiverType && !fieldHopType && !fieldDispatchType &&
                             !call.receiverExternalFlow && !call.receiverQualifiedFlow) {
+                            if (call.receiverUntypedIteration) {
+                                routeUnverified(filePath, fileEntry, call,
+                                    'possible-dispatch', calledAs, {
+                                        dispatchVia: 'untyped loop element',
+                                    });
+                                continue;
+                            }
                             let demoteFlowMap = returnFlowCache.get(filePath);
                             if (demoteFlowMap === undefined) {
                                 demoteFlowMap = _buildReturnTypeFlowMap(index, filePath, calls);
@@ -4446,7 +4634,7 @@ function findCallers(index, name, options = {}) {
                         // root counts only when the resolver PROVED it a
                         // submodule (#224 — a from-import name may be a
                         // plain symbol, never assume).
-                        if (!typeQualifiedReceiver && !knownDispatchType &&
+                        if (!call.moduleOwnedPath && !typeQualifiedReceiver && !knownDispatchType &&
                             call.receiverRoot && !call.receiverRootType &&
                             langTraits(fileEntry.language)?.typeSystem === 'structural') {
                             const rootBinding = (fileEntry.importBindings || []).find(b =>
@@ -5114,6 +5302,7 @@ function findCallees(index, definition, options = {}) {
         // Return-type flow map (lazy — only built if a single-owner
         // resolution needs the external-producer/typed-receiver defeater).
         let _flowMap;
+        const pythonIndexedReceiverCache = new Map();
         const flowMap = () => {
             if (_flowMap === undefined) {
                 if (queryProfile) {
@@ -5131,7 +5320,7 @@ function findCallees(index, definition, options = {}) {
         const mayNeedDirectReceiverFlow = call =>
             call.isMethod && call.receiver && !call.receiverType &&
             !call.receiverPatternShadow &&
-            !RESERVED_RECEIVER_NAMES.has(call.receiver) &&
+            !_isReservedReceiver(language, call.receiver) &&
             !call.isPathCall && !call.receiverIsModule &&
             !call.receiverIsChainRoot;
         // Chained-receiver fold context (fix #268 — the #258 rails, callee
@@ -5140,6 +5329,11 @@ function findCallees(index, definition, options = {}) {
         const foldCtx = () => {
             if (!calleeFoldCtx) {
                 calleeFoldCtx = { memo: new Map(), visiting: new Set(), records: calls,
+                    // A called local arrow factory may be declared outside
+                    // the current callee definition. Keep the narrow records
+                    // set for ordinary producer indexing, but expose the
+                    // already-loaded file records for exact returned spans.
+                    allRecords: allCalls,
                     getFlowMap: () => flowMap() };
             }
             return calleeFoldCtx;
@@ -5149,6 +5343,25 @@ function findCallees(index, definition, options = {}) {
         for (let call of calls) {
             siteOrdinal++;
             const siteId = siteOrdinal;
+            if (language === 'go' && call.isMethod &&
+                !call.receiverType && call.receiverIndexField) {
+                const indexedType = _goIndexedReceiverType(index, def.file, call);
+                if (indexedType?.type) {
+                    call = {
+                        ...call,
+                        receiverType: indexedType.type,
+                        ...(indexedType.fromFile && {
+                            receiverTypeFlowFile: indexedType.fromFile,
+                        }),
+                    };
+                } else if (indexedType?.externalVia) {
+                    call = {
+                        ...call,
+                        receiverExternalFlow: indexedType.externalVia,
+                        receiverExternalConcreteFlow: true,
+                    };
+                }
+            }
             // Filter to calls within this function's scope
             // Method 1: Direct match via enclosingFunction (fast path for direct calls)
             const isDirectMatch = call.enclosingFunction &&
@@ -5264,6 +5477,25 @@ function findCallees(index, definition, options = {}) {
                 }
             }
 
+            // Python indexed receivers share the caller-side #324 contract:
+            // only an exact project container type plus its declared
+            // `__getitem__` return type may identify the selected value.
+            if (language === 'python' && call.isMethod &&
+                !call.receiverType && call.receiverSubscriptRoot) {
+                const indexedType = _pythonIndexedReceiverType(
+                    index, def.file, call, flowMap,
+                    pythonIndexedReceiverCache);
+                if (indexedType?.type) {
+                    call = {
+                        ...call,
+                        receiverType: indexedType.type,
+                        ...(indexedType.fromFile && {
+                            receiverTypeFlowFile: indexedType.fromFile,
+                        }),
+                    };
+                }
+            }
+
             // Query-time return flow for an ordinary receiver assignment:
             // `v := New(); v.ReadConfig()`. The compiler-declared return type
             // is stronger than constructor-name guesses and must participate
@@ -5271,6 +5503,17 @@ function findCallees(index, definition, options = {}) {
             const directReceiverFlow = mayNeedDirectReceiverFlow(call)
                 ? _lookupReturnTypeFlow(flowMap(), call)
                 : undefined;
+            // Caller-side fix #305 twin: a loop element drawn from an
+            // untyped identifier/attribute iterable has no class identity.
+            // Unique project ownership of the method spelling is not enough
+            // to invent an exact callee.
+            if (collectAccount && call.isMethod && !call.receiverType &&
+                call.receiverUntypedIteration) {
+                noteUnverified(siteId, call, 'possible-dispatch', {
+                    dispatchVia: 'untyped loop element',
+                });
+                continue;
+            }
             // Callee-side twin of the structural caller gate (#222(4)).  A
             // local receiver whose nearest producer was examined but could
             // not be typed (`C2 = decorator(Base); value = C2()`) has unknown
@@ -5303,19 +5546,26 @@ function findCallees(index, definition, options = {}) {
                     hopRoot = localTypes.get(call.receiverRoot);
                 }
                 if (!hopRoot && call.receiverRoot &&
-                    !RESERVED_RECEIVER_NAMES.has(call.receiverRoot)) {
+                    !_isReservedReceiver(language, call.receiverRoot)) {
                     const inferredRoot = _lookupReturnTypeFlow(flowMap(), {
                         ...call,
                         receiver: call.receiverRoot,
                     });
-                    if (inferredRoot?.type) hopRoot = inferredRoot.type;
+                    if (inferredRoot?.type) {
+                        hopRoot = inferredRoot.type;
+                    } else if (inferredRoot?.externalVia) {
+                        fieldHopInfo = {
+                            externalVia:
+                                `${inferredRoot.externalVia}.${call.receiverField}`,
+                        };
+                    }
                 }
                 if (!hopRoot && call.receiverRoot === 'this' &&
                     langTraits(language)?.typeSystem === 'structural') {
                     hopRoot = index.findEnclosingFunction(def.file, call.line, true)?.className;
                 }
                 if (hopRoot) {
-                    fieldHopInfo = {};
+                    fieldHopInfo = fieldHopInfo || {};
                     const fields = call.receiverFields || [call.receiverField];
                     fieldHopType = _declaredFieldPathType(index, hopRoot, fields,
                         language, fieldHopInfo, call.receiverRootNamespace);
@@ -5349,6 +5599,12 @@ function findCallees(index, definition, options = {}) {
                         }
                     }
                 }
+                if (!fieldHopType &&
+                    langTraits(language)?.typeSystem === 'structural') {
+                    fieldHopInfo = fieldHopInfo || {};
+                    fieldHopType = _structuralModuleValueFieldType(
+                        index, fileEntry, call, fieldHopInfo);
+                }
             }
 
             if (fieldDispatchType) {
@@ -5510,7 +5766,7 @@ function findCallees(index, definition, options = {}) {
             if (call.isMethod && !call.isConstructor && call.receiver &&
                 !call.receiverType && !fieldHopType && !goImportModule &&
                 !call.receiverIsModule && !call.selfAttribute &&
-                !RESERVED_RECEIVER_NAMES.has(call.receiver) &&
+                !_isReservedReceiver(language, call.receiver) &&
                 !(localTypes && localTypes.has(call.receiver))) {
                 typeQual = _calleeTypeQualifiedReceiver(index, def, fileEntry, call, language);
             }
@@ -5551,7 +5807,8 @@ function findCallees(index, definition, options = {}) {
                            (call.receiver === 'Self' && language === 'rust')) {
                     // self.method() / cls.method() / this.method() — resolve to same-class method below
                     // Rust Self::method() resolves same-impl the same way (fix #236, the #232 callee analog)
-                } else if (call.receiver === 'super' || call.receiver === 'base') {
+                } else if (call.receiver === 'super' ||
+                    (call.receiver === 'base' && language === 'csharp')) {
                     // super().method() — resolve to parent class method below
                 } else if (directReceiverFlow?.externalVia) {
                     if (directReceiverFlow.externalConcrete) {
@@ -5682,7 +5939,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 = directReceiverFlow?.fromFile ||
+                    const receiverOriginFile = call.receiverTypeFlowFile ||
+                        directReceiverFlow?.fromFile ||
                         fieldHopInfo?.fromFile ||
                         (call.receiverType
                             ? _resolveFlowTypeOrigin(
@@ -5696,7 +5954,8 @@ function findCallees(index, definition, options = {}) {
                          (symbol.file &&
                           path.dirname(symbol.file) === qualifiedType.dir)) &&
                         (!receiverOriginFile || !symbol.file ||
-                         ((language === 'java' || language === 'csharp')
+                         ((langTraits(language)?.typeSystem === 'structural' ||
+                           language === 'java' || language === 'csharp')
                              ? symbol.file === receiverOriginFile
                              : path.dirname(symbol.file) ===
                                 path.dirname(receiverOriginFile)));
@@ -5786,18 +6045,20 @@ function findCallees(index, definition, options = {}) {
                         continue;
                     }
                     // Structural legacy mode retains its historical fallback.
-                } else if (call.receiverCall && (!call.receiver || call.receiverIsChainRoot) && !call.isConstructor &&
-                    langTraits(language)?.typeSystem === 'nominal') {
-                    // Chained receiver, nominal callee direction (fix #268,
-                    // chi-measured): `m.NotFound().ServeHTTP(w, r)` /
-                    // `r.Context().Value(k)` — the producer's compiler-checked
-                    // return annotation types the receiver (#207 rails), and
-                    // an untypable chain routes visible — never bare-name or
-                    // binding resolution (the same-file Mux.ServeHTTP binding
-                    // confirmed a self-edge; a single-def project `Value`
-                    // confirmed for context.Context's).
+                } else if (call.receiverCall && (!call.receiver || call.receiverIsChainRoot) &&
+                    !call.receiverIsModule && !call.isConstructor) {
+                    // Chained receiver, callee direction (fix #302):
+                    // `Environment().getattr(...)` is the structural twin of
+                    // the nominal #268 shapes (`m.NotFound().ServeHTTP(...)`).
+                    // The shared fold already resolves constructor roots and
+                    // method-return chains for both type-system families; the
+                    // old nominal-only gate threw that evidence away and
+                    // classified exact Python/JS calls as external. Module
+                    // producers (`require("./lib").target()`) stay on the
+                    // stronger name-aware module route below.
                     let chained = _foldChainedReceiverType(index, fileEntry, def.file, call, foldCtx());
-                    if (!chained || (!chained.type && !chained.externalVia)) {
+                    if ((!chained || (!chained.type && !chained.externalVia)) &&
+                        langTraits(language)?.typeSystem === 'nominal') {
                         chained = _nominalChainedReceiverType(index, call, fileEntry, def.file);
                     }
                     if (chained?.type) {
@@ -5816,7 +6077,12 @@ function findCallees(index, definition, options = {}) {
                             def.file, acceptsChainedDefinition);
                         if (sel.match) {
                             const match = sel.match;
-                            if (routeVirtualOverride(siteId, call, chained.type, match)) continue;
+                            // A direct constructor expression fixes the
+                            // runtime class exactly (`Environment()` cannot be
+                            // a subclass instance). Declared/returned base
+                            // types keep normal virtual-dispatch demotion.
+                            if (!chained.exactConstructor &&
+                                routeVirtualOverride(siteId, call, chained.type, match)) continue;
                             const key = match.bindingId || `${chained.type}.${call.name}`;
                             const existing = callees.get(key);
                             if (existing) {
@@ -5906,7 +6172,7 @@ function findCallees(index, definition, options = {}) {
                 }
                 if (collectAccount && call.receiver && !call.receiverIsModule && !call.receiverType &&
                     !call.receiverCall && !call.isPotentialCallback &&
-                    !RESERVED_RECEIVER_NAMES.has(call.receiver)) {
+                    !_isReservedReceiver(language, call.receiver)) {
                     const owners = new Set((index.symbols.get(call.name) || [])
                         .filter(s => !NON_CALLABLE_TYPES.has(s.type))
                         .map(s => s.className || (s.receiver && s.receiver.replace(/^\*/, '')))
@@ -5926,7 +6192,8 @@ function findCallees(index, definition, options = {}) {
             // `super(...)` 'constructor' record were routed external here
             // because __init__/constructor sit in the builtin name sets).
             const selfShaped = call.isMethod &&
-                (['self', 'cls', 'this', 'super', 'base'].includes(call.receiver) ||
+                (['self', 'cls', 'this', 'super'].includes(call.receiver) ||
+                 (call.receiver === 'base' && language === 'csharp') ||
                  (call.receiver === 'Self' && language === 'rust'));
             // Builtin/global names are shadowable. `Request` is a web global,
             // but `const Request = require('./request')` owns `new Request()`
@@ -6011,7 +6278,8 @@ function findCallees(index, definition, options = {}) {
 
             // Collect super().method() calls for parent-class resolution
             if (call.isMethod &&
-                (call.receiver === 'super' || call.receiver === 'base')) {
+                (call.receiver === 'super' ||
+                 (call.receiver === 'base' && language === 'csharp'))) {
                 if (!selfMethodCalls) selfMethodCalls = [];
                 selfMethodCalls.push({ call, siteId });
                 continue;
@@ -6024,7 +6292,8 @@ function findCallees(index, definition, options = {}) {
             // the callee. Follow the module's name-level re-export chain and
             // add only definitions it actually exposes. Unknown CJS/dynamic
             // surfaces stay visible; external modules are external.
-            if (call.isMethod && call.receiverIsModule &&
+            if (call.isMethod && (call.receiverIsModule ||
+                call.receiverModuleSpecifier || call.receiverModuleComposition) &&
                 langTraits(language)?.typeSystem === 'structural') {
                 const moduleRoute = _calleeStructuralModuleRoute(index, fileEntry, call, language);
                 if (moduleRoute.matches?.length) {
@@ -6147,7 +6416,7 @@ function findCallees(index, definition, options = {}) {
                 // also named ReadConfig. Otherwise the bare wrapper steals the
                 // exact callee before receiver evidence is considered.
                 const receiverBlindMethodBinding = call.isMethod &&
-                    !RESERVED_RECEIVER_NAMES.has(call.receiver);
+                    !_isReservedReceiver(language, call.receiver);
                 let bindings = receiverBlindMethodBinding ? [] :
                     fileEntry.bindings.filter(b => b.name === call.name);
                 // For Go, also check sibling files in same directory (same
@@ -6682,8 +6951,8 @@ function findCallees(index, definition, options = {}) {
                 }
 
                 // For super().method(), skip same-class — start from parent
-                const parentOnlyReceiver =
-                    call.receiver === 'super' || call.receiver === 'base';
+                const parentOnlyReceiver = call.receiver === 'super' ||
+                    (call.receiver === 'base' && language === 'csharp');
                 const selectOwner = owner => _calleeOverloadSelect(
                     index,
                     call,
@@ -7031,12 +7300,33 @@ function getInstanceAttributeTypes(index, filePath, className) {
             const parser = getParser('python');
             const fileEntry = index.files.get(filePath);
             fileCache = langModule.findInstanceAttributeTypes(content, parser, {
-                resolveBuiltinCallType(moduleName, functionName) {
-                    if (!_pythonBuiltinContractAllowed(index, fileEntry, moduleName)) {
-                        return null;
-                    }
-                    return langModule.getBuiltinCallReturnType?.(
-                        moduleName, functionName) || null;
+                resolveTypeAliasMembers(typeName) {
+                    const owner = _resolveFlowTypeOrigin(
+                        index, filePath, typeName);
+                    if (!owner?.fromFile) return null;
+                    const definitions = (index.symbols.get(typeName) || [])
+                        .filter(definition => definition.file === owner.fromFile &&
+                            definition.type === 'type' &&
+                            Array.isArray(definition.aliasMembers));
+                    if (definitions.length === 0) return null;
+                    const identities = new Set(definitions.map(definition =>
+                        definition.aliasMembers.join('\0')));
+                    return identities.size === 1
+                        ? [...definitions[0].aliasMembers] : null;
+                },
+                resolveCallType(moduleName, functionName) {
+                    if (_pythonBuiltinContractAllowed(index, fileEntry, moduleName)) {
+                        const builtin = langModule.getBuiltinCallReturnType?.(
+                            moduleName, functionName);
+                        if (builtin) return builtin;
+                    }
+                    const owner = _resolveFlowTypeOrigin(
+                        index, filePath, moduleName);
+                    if (!owner?.fromFile) return null;
+                    const result = _methodReturnOnType(
+                        index, moduleName, owner.fromFile, functionName,
+                        'python', { filePath, consumerAwaited: false });
+                    return result?.fromFile ? result.type : null;
                 },
             });
             index._attrTypeCache.set(filePath, fileCache);
@@ -7141,11 +7431,11 @@ function _typeNameFromReturnAnnotation(text) {
         t = m[2].trim();
     }
     // generic base: Foo[...] / Foo<...> → Foo (the value is a Foo)
-    m = t.match(/^([\w.]+)\s*[[<]/);
+    m = t.match(/^([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)\s*[[<]/);
     if (m) t = m[1];
     // dotted → last segment; validate a bare identifier remains
     const last = t.split('.').pop();
-    return /^[A-Za-z_]\w*$/.test(last) ? last : undefined;
+    return /^[A-Za-z_$][\w$]*$/.test(last) ? last : undefined;
 }
 
 /**
@@ -7186,6 +7476,19 @@ function _buildReturnTypeFlowMap(index, filePath, calls) {
     // Map.has() so files without resolvable flow are cheap too.
     const opCache = index._opReturnTypeFlowCache;
     if (opCache?.has(filePath)) return opCache.get(filePath);
+    // Return-flow derives from symbols in OTHER files, so it must never enter
+    // the persisted calls cache. It is nevertheless immutable until the next
+    // ProjectIndex build. Retain a bounded, calls-array-identity-guarded copy
+    // across composed agent queries; build() clears it when any annotation or
+    // import graph could have changed.
+    const persistentCache = index._returnTypeFlowCache;
+    const persistent = persistentCache?.get(filePath);
+    if (persistent?.calls === calls) {
+        persistentCache.delete(filePath);
+        persistentCache.set(filePath, persistent);
+        if (opCache) opCache.set(filePath, persistent.map);
+        return persistent.map;
+    }
     const fileEntry = index.files.get(filePath);
     const language = fileEntry?.language;
     const nominal = langTraits(language)?.typeSystem === 'nominal';
@@ -7247,6 +7550,23 @@ function _buildReturnTypeFlowMap(index, filePath, calls) {
             if (via) routeUnknownAssignment(call, via);
             continue;
         }
+        // Package-owned value method producer (fix #306, chi-measured):
+        // `resp, err := http.DefaultClient.Do(req)`. The parser correctly
+        // retains `http` as a module root and `DefaultClient` as its exported
+        // value, but this shape is neither an ordinary package call nor a
+        // locally typed method receiver. When that package is external, its
+        // result is externally decided and must defeat later single-owner
+        // confirmation (`resp.Body.Close()`). Project-owned package values
+        // abstain here until their field declarations can be resolved.
+        if (language === 'go' && call.isMethod && call.receiverRootIsModule &&
+            call.receiverRoot && call.receiverField) {
+            const qualified = _goQualifiedReceiverType(
+                index, fileEntry, call.receiverRoot, call.receiverField);
+            if (qualified && qualified.kind !== 'project') {
+                routeUnknownAssignment(call, `${qualified.via}.${call.name}`);
+                continue;
+            }
+        }
         const delegatedUnwrapAssignment = language === 'rust' &&
             call.receiverCall && calls.some(candidate =>
                 candidate !== call &&
@@ -7280,11 +7600,16 @@ function _buildReturnTypeFlowMap(index, filePath, calls) {
             continue;
         }
 
-        // Assigned builder chain (chi-measured):
-        // `hr := RouteHeaders().Route(...)` stores the OUTERMOST method call
-        // as the assignment producer. Fold the chain to its declared result
-        // before composing later `hr.Handler(...)` flow.
-        if (nominal && (call.receiverCall || call.isMacro)) {
+        // Assigned builder chain (chi/zod-measured):
+        // `hr := RouteHeaders().Route(...)` / `const s = z.array().refine(...)`
+        // stores the OUTERMOST method call as the assignment producer. Fold
+        // the chain to its declared result before composing a later receiver.
+        // Macro-result folding remains nominal-only; structural call chains
+        // use the same compiler-annotation and module-ownership rails as the
+        // already-supported immediate chained-receiver path.
+        if (call.receiverCall ||
+            (!nominal && call.isMethod && call.receiverRoot && call.receiverField) ||
+            (nominal && call.isMacro)) {
             let folded = _typeOfCallResultFold(
                 index, fileEntry, filePath, call, assignedFoldCtx);
             // Rust result aliases are commonly imported under a local name
@@ -7365,7 +7690,8 @@ function _buildReturnTypeFlowMap(index, filePath, calls) {
         } else if (callableFlow?.returnedFunctionResult) {
             returnType = callableFlow.returnedFunctionResult;
             fromFile = callableFlow.fromFile;
-        } else if (call.isMethod && call.receiverType) {
+        } else if (call.isMethod && call.receiverType &&
+            !call.receiverTypeGuessed) {
             const defs = index.symbols.get(call.name) || [];
             if (nominal) {
                 const matches = defs.filter(d => d.className === call.receiverType && d.returnType);
@@ -7402,6 +7728,25 @@ function _buildReturnTypeFlowMap(index, filePath, calls) {
                         index._getInheritanceParents?.(owner, filePath) || []))];
                 }
             }
+        } else if (!nominal && language === 'python' && call.isMethod &&
+            call.receiver && !call.receiverLocalBinding &&
+            !call.receiverIsModule && !call.receiverModuleComposition) {
+            // Exact imported class factory: `text = Text.from_markup(...)`.
+            // The parser intentionally does not label every capitalized
+            // receiver as an instance type. Pin the value to an indexed type
+            // in the caller's import scope first, then reuse the method
+            // contract agreement discipline to type the assigned result.
+            const owner = _resolveFlowTypeOrigin(index, filePath, call.receiver);
+            const resolved = owner?.fromFile
+                ? _methodReturnOnType(
+                    index, call.receiver, owner.fromFile, call.name,
+                    language, { filePath, consumerAwaited: false })
+                : null;
+            if (resolved?.type) {
+                returnType = resolved.type;
+                fromFile = resolved.fromFile;
+                selfClass = call.receiver;
+            }
         } else if (call.isMethod && call.receiver &&
             !['self', 'this', 'cls'].includes(call.receiver) &&
             _lookupReturnTypeFlow(map, call)) {
@@ -7583,7 +7928,9 @@ function _buildReturnTypeFlowMap(index, filePath, calls) {
                 }
                 continue;
             }
-        } else if (!nominal && call.isMethod && call.receiverIsModule &&
+        } else if (!nominal && call.isMethod &&
+            (call.receiverIsModule || call.receiverModuleSpecifier ||
+                call.receiverModuleComposition) &&
             (call.receiver || call.receiverModuleSpecifier)) {
             // Structural module-qualified producer (fix #209): schema =
             // z.string() — the module alias resolves through the file's
@@ -7591,8 +7938,15 @@ function _buildReturnTypeFlowMap(index, filePath, calls) {
             // and the producer's return annotation types the variable.
             // Standalone exports only (className-less): a module attr is
             // never a class method.
-            const binding = _structuralModuleBindings(fileEntry, call)[0];
-            const rel = binding && fileEntry.moduleResolved && fileEntry.moduleResolved[binding.module];
+            const composite = call.receiverModuleComposition
+                ? _structuralCompositeModuleOwnership(index, fileEntry, call)
+                : null;
+            if (composite && composite.verdict !== 'yes') continue;
+            const binding = composite?.binding ||
+                _structuralModuleBindings(fileEntry, call)[0];
+            const rel = composite?.rel ||
+                (binding && fileEntry.moduleResolved &&
+                    fileEntry.moduleResolved[binding.module]);
             if (binding && !rel) {
                 // External module producer (fix #222, httpx-measured — the
                 // #220 Go external-producer rule for structural languages):
@@ -7620,6 +7974,19 @@ function _buildReturnTypeFlowMap(index, filePath, calls) {
                 const cands = (index.symbols.get(call.name) || [])
                     .filter(d => !NON_CALLABLE_TYPES.has(d.type) && d.returnType && !d.className);
                 let matches = cands.filter(d => d.file === modFile);
+                // A namespace binding owns a NAME through the complete
+                // re-export surface, not merely through one import edge.
+                // Zod's self exports run index -> external -> types; the
+                // one-hop fallback below lost the producer's defining-file
+                // provenance and conflated the v3/v4 types with identical
+                // short names. Reuse the same name-aware ownership proof as
+                // chained producers before retaining the legacy fallback.
+                if (matches.length === 0) {
+                    matches = cands.filter(definition =>
+                        _importedNamespaceMemberOwnership(
+                            index, fileEntry, call,
+                            new Set([definition.file]))?.verdict === 'yes');
+                }
                 if (matches.length === 0) {
                     const hop = index.importGraph.get(modFile);
                     if (hop) matches = cands.filter(d => hop.has(d.file));
@@ -7974,6 +8341,13 @@ function _buildReturnTypeFlowMap(index, filePath, calls) {
             }) });
     }
     if (opCache) opCache.set(filePath, map);
+    if (persistentCache) {
+        persistentCache.delete(filePath);
+        persistentCache.set(filePath, { calls, map });
+        if (persistentCache.size > CROSS_OPERATION_FLOW_CACHE_LIMIT) {
+            persistentCache.delete(persistentCache.keys().next().value);
+        }
+    }
     return map;
 }
 
@@ -8187,7 +8561,6 @@ function _returnTypeNameNominal(text, language, opts = {}) {
         if (t.startsWith('(')) {
             if (!opts.tuple) return undefined;
             const inner = t.slice(1, -1);
-            if (inner.includes('func(') || inner.includes('func (')) return undefined;
             const position = Number.isInteger(opts.tupleIndex)
                 ? opts.tupleIndex : 0;
             const item = _splitTopLevelGenericArgs(inner)[position]?.trim();
@@ -8850,13 +9223,41 @@ function _receiverPackageResolution(index, fileEntry, receiver, targetDefs) {
  * back to the original route through records this chase follows or flags).
  */
 function _nameBindingReaches(index, startAbs, name, targetFiles, maxDepth = 4) {
+    // The same export path is asked once per competing definition and again
+    // by caller/callee projections in a composed command. The graph and file
+    // surfaces are immutable during an operation, so retain the tri-state
+    // verdict beside the existing import-reachability memo. Target identity
+    // is part of the key; no answer can leak between pinned definitions.
+    const opCache = index._opImportReachCache;
+    const targetKey = [...targetFiles].sort(codeUnitCompare).join('\x00');
+    const cacheKey = `name\x00${maxDepth}\x00${startAbs}\x00${name}\x00${targetKey}`;
+    if (opCache?.has(cacheKey)) return opCache.get(cacheKey);
+    const persistentCache = index._nameBindingReachCache;
+    if (persistentCache?.has(cacheKey)) {
+        const value = persistentCache.get(cacheKey);
+        // Map insertion order is the LRU order.
+        persistentCache.delete(cacheKey);
+        persistentCache.set(cacheKey, value);
+        if (opCache) opCache.set(cacheKey, value);
+        return value;
+    }
+    const finish = value => {
+        if (opCache) opCache.set(cacheKey, value);
+        if (persistentCache) {
+            persistentCache.set(cacheKey, value);
+            if (persistentCache.size > 16384) {
+                persistentCache.delete(persistentCache.keys().next().value);
+            }
+        }
+        return value;
+    };
     let unknown = false;
     const visited = new Set();
     let frontier = [[startAbs, name]];
     for (let d = 0; d <= maxDepth && frontier.length > 0; d++) {
         const next = [];
         for (const [abs, attr] of frontier) {
-            if (targetFiles.has(abs)) return 'yes';
+            if (targetFiles.has(abs)) return finish('yes');
             const stateKey = `${abs}\x00${attr}`;
             if (visited.has(stateKey)) continue;
             visited.add(stateKey);
@@ -8886,7 +9287,7 @@ function _nameBindingReaches(index, startAbs, name, targetFiles, maxDepth = 4) {
                     e.defaultLike && e.type === 'module.exports' &&
                     (e.alias || e.name) !== attr);
             if (staticOwner && !competingDynamic) {
-                return 'no';
+                return finish('no');
             }
 
             const enqueue = (module, nextAttr) => {
@@ -8944,7 +9345,7 @@ function _nameBindingReaches(index, startAbs, name, targetFiles, maxDepth = 4) {
         frontier = next;
     }
     if (frontier.length > 0) unknown = true; // depth exhausted with live paths
-    return unknown ? 'unknown' : 'no';
+    return finish(unknown ? 'unknown' : 'no');
 }
 
 /**
@@ -9143,6 +9544,122 @@ function _importedNamespaceMemberOwnership(index, fileEntry, call, targetFiles)
     return { verdict: unknown ? 'unknown' : 'no' };
 }
 
+/**
+ * Resolve the compiler-declared type of an exported JS/TS value through an
+ * exact ESM export chain. This is deliberately narrower than ordinary name
+ * ownership: a local value without an explicit annotation, a dynamic/CJS
+ * surface, an unresolved module, or competing exports returns unknown.
+ */
+function _structuralExportedValueType(
+    index, startAbs, exposedName, language, maxDepth = 6, visited = new Set()
+) {
+    if (maxDepth < 0) return { verdict: 'unknown' };
+    const stateKey = `${startAbs}\x00${exposedName}`;
+    if (visited.has(stateKey)) return { verdict: 'unknown' };
+    visited.add(stateKey);
+    const fileEntry = index.files.get(startAbs);
+    if (!fileEntry) return { verdict: 'unknown' };
+    const details = fileEntry.exportDetails || [];
+    if (details.some(item => item.type === 'exports' ||
+        item.type === 'module.exports')) return { verdict: 'unknown' };
+
+    const local = details.filter(item =>
+        !item.source && (item.alias || item.name) === exposedName);
+    if (local.length > 0) {
+        if (local.length !== 1 || !local[0].isVariable ||
+            !local[0].typeAnnotation) return { verdict: 'unknown' };
+        const type = _structuralTypeHead(local[0].typeAnnotation, {
+            index,
+            language,
+            originFile: startAbs,
+        });
+        if (!type || _STRUCTURAL_FLOW_REJECT.has(type) ||
+            (/^[A-Z][A-Z0-9]?$/.test(type) &&
+                !(index.symbols.get(type) || [])
+                    .some(definition => IDENTITY_TYPE_KINDS.has(definition.type)))) {
+            return { verdict: 'unknown' };
+        }
+        const typeDefs = (index.symbols.get(type) || [])
+            .filter(definition => IDENTITY_TYPE_KINDS.has(definition.type));
+        if (typeDefs.length === 0) return { verdict: 'yes', type };
+        const origin = _resolveFlowTypeOrigin(index, startAbs, type);
+        if (!origin?.fromFile) return { verdict: 'unknown' };
+        return { verdict: 'yes', type, fromFile: origin.fromFile };
+    }
+
+    const resolveSource = (item, name) => {
+        const rel = fileEntry.moduleResolved?.[item.source];
+        if (!rel) return { verdict: 'unknown' };
+        return _structuralExportedValueType(
+            index, path.join(index.root, rel), name, language,
+            maxDepth - 1, new Set(visited));
+    };
+    const merge = results => {
+        if (results.some(result => result.verdict === 'unknown')) {
+            return { verdict: 'unknown' };
+        }
+        const matches = results.filter(result => result.verdict === 'yes');
+        if (matches.length === 0) return { verdict: 'no' };
+        const identities = new Set(matches.map(result =>
+            `${result.type}\x00${result.fromFile || ''}`));
+        return identities.size === 1 ? matches[0] : { verdict: 'unknown' };
+    };
+
+    const exact = details.filter(item => item.source &&
+        item.type === 're-export' && (item.alias || item.name) === exposedName);
+    if (exact.length > 0) {
+        return merge(exact.map(item => resolveSource(item, item.name)));
+    }
+    const stars = details.filter(item => item.source &&
+        item.type === 're-export-all' && !item.alias);
+    if (stars.length === 0) return { verdict: 'no' };
+    return merge(stars.map(item => resolveSource(item, exposedName)));
+}
+
+/**
+ * Type a one-hop field receiver rooted at an unshadowed namespace import:
+ * `api.service.run()` where `service` is an explicitly typed exported value.
+ */
+function _structuralModuleValueFieldType(index, fileEntry, call, info = null) {
+    if (!call?.receiverRoot || !call.receiverField || call.receiverLocalBinding) {
+        return null;
+    }
+    const fields = call.receiverFields || [call.receiverField];
+    if (fields.length !== 1) return null;
+    const cache = index._opImportReachCache;
+    const cacheKey = `module-value-type\x00${fileEntry?.path || ''}\x00` +
+        `${call.receiverRoot}\x00${call.receiverField}`;
+    if (cache?.has(cacheKey)) {
+        const cached = cache.get(cacheKey);
+        if (info && cached?.fromFile) info.fromFile = cached.fromFile;
+        return cached?.type || null;
+    }
+    const finish = result => {
+        if (cache) cache.set(cacheKey, result);
+        if (info && result?.fromFile) info.fromFile = result.fromFile;
+        return result?.type || null;
+    };
+    const bindings = (fileEntry?.importBindings || []).filter(binding =>
+        binding.kind === 'namespace' &&
+        (binding.alias || binding.name) === call.receiverRoot);
+    if (bindings.length === 0) return finish(null);
+
+    const results = [];
+    for (const binding of bindings) {
+        const rel = fileEntry.moduleResolved?.[binding.module];
+        if (!rel) return finish(null);
+        const result = _structuralExportedValueType(
+            index, path.join(index.root, rel), call.receiverField,
+            fileEntry.language);
+        if (result.verdict !== 'yes') return finish(null);
+        results.push(result);
+    }
+    const identities = new Set(results.map(result =>
+        `${result.type}\x00${result.fromFile || ''}`));
+    if (identities.size !== 1) return finish(null);
+    return finish(results[0]);
+}
+
 /**
  * Ownership chase for a CommonJS default-like require binding:
  * `const local = require('./module')`. The local binding name says nothing
@@ -9373,6 +9890,21 @@ function _genericParamNames(genericsText) {
     return names.size > 0 ? names : null;
 }
 
+/**
+ * A method declared on a generic owner parameter (`impl<I> Trait for I`) has
+ * no concrete receiver identity. The owner may be instantiated by every type
+ * satisfying the impl bounds, so it can neither confirm nor exclude a typed
+ * receiver. Parser-provided ownerGenerics distinguishes this from an actual
+ * project type whose short name happens to look generic.
+ */
+function _definitionHasGenericOwner(definition) {
+    const owner = definition?.className ||
+        (definition?.receiver || '').replace(/^[*&]\s*/, '');
+    if (!owner) return false;
+    const params = _genericParamNames(definition.ownerGenerics);
+    return !!params?.has(owner);
+}
+
 /**
  * Is typeName a declared GENERIC TYPE PARAMETER in scope at this call site —
  * on the enclosing function itself (`fn f<TStore: Wipe>(t: &TStore)`) or on
@@ -10241,6 +10773,62 @@ function _structuralModuleBindings(fileEntry, call) {
     return (fileEntry?.importBindings || []).filter(b => b.name === call?.receiver);
 }
 
+/**
+ * Resolve an ordinary module-local object composed from namespace spreads:
+ * `const z = { ...schemas, ...checks, iso }`.
+ *
+ * The JS parser records this only for a private, unescaped, unmodified const
+ * object. Walk layers from last to first because later object spreads and
+ * explicit properties override earlier names. A layer may be skipped only
+ * when its complete modeled export surface definitively lacks the requested
+ * name; resolver gaps and dynamic surfaces remain unknown.
+ *
+ * When targetFiles is supplied, verdict answers whether the winning layer
+ * owns that pinned definition. Without targetFiles it returns the winning
+ * module binding for return-flow/callee lookup.
+ */
+function _structuralCompositeModuleOwnership(
+    index, fileEntry, call, targetFiles = null
+) {
+    const layers = call?.receiverModuleComposition;
+    if (!Array.isArray(layers) || layers.length === 0 || !call.name) return null;
+    const nameFiles = new Set((index.symbols.get(call.name) || [])
+        .filter(definition => definition.file &&
+            (!NON_CALLABLE_TYPES.has(definition.type) || definition.type === 'class'))
+        .map(definition => definition.file));
+    if (nameFiles.size === 0) return { verdict: 'unknown' };
+
+    for (let i = layers.length - 1; i >= 0; i--) {
+        const layer = layers[i];
+        if (layer.kind === 'property') {
+            if (layer.name === call.name) return { verdict: 'unknown' };
+            continue;
+        }
+        if (layer.kind !== 'spread' || !layer.receiver) {
+            return { verdict: 'unknown' };
+        }
+        const bindings = (fileEntry?.importBindings || []).filter(binding =>
+            (binding.alias || binding.name) === layer.receiver &&
+            binding.kind === 'namespace');
+        if (bindings.length !== 1) return { verdict: 'unknown' };
+        const binding = bindings[0];
+        const rel = fileEntry.moduleResolved?.[binding.module];
+        if (!rel) return { verdict: 'unknown' };
+        const moduleFile = path.join(index.root, rel);
+        const presence = _nameBindingReaches(
+            index, moduleFile, call.name, nameFiles);
+        if (presence === 'unknown') return { verdict: 'unknown' };
+        if (presence === 'no') continue;
+        if (!targetFiles) {
+            return { verdict: 'yes', binding, rel, moduleFile };
+        }
+        const verdict = _nameBindingReaches(
+            index, moduleFile, call.name, targetFiles);
+        return { verdict, binding, rel, moduleFile };
+    }
+    return { verdict: 'no' };
+}
+
 function _pythonBuiltinContractAllowed(index, fileEntry, moduleName) {
     const module = String(moduleName || '');
     if (!module || module.startsWith('.')) return false;
@@ -10341,7 +10929,12 @@ function _structuralReturnedConstructorFlow(index, definition) {
 }
 
 function _calleeStructuralModuleRoute(index, fileEntry, call, language) {
-    const bindings = _structuralModuleBindings(fileEntry, call);
+    const composite = call.receiverModuleComposition
+        ? _structuralCompositeModuleOwnership(index, fileEntry, call)
+        : null;
+    if (composite && composite.verdict !== 'yes') return { unknown: true };
+    const bindings = composite
+        ? [composite.binding] : _structuralModuleBindings(fileEntry, call);
     if (bindings.length === 0) return { unknown: true };
     return _calleeStructuralBindingRoute(index, fileEntry, call, language, bindings, call.name, false);
 }
@@ -10641,8 +11234,15 @@ function _calleeSelectReceiverMethod(index, call, symbols, typeName, language,
          (symbol.receiver && symbol.receiver.replace(/^\*/, '') === owner)));
     let selected = _calleeOverloadSelect(
         index, call, onOwner(typeName), language);
-    if (!selected.match && !selected.ambiguous &&
-        langTraits(language)?.typeSystem === 'nominal') {
+    // Nominal lookup and compiler-typed TS/TSX class values inherit methods
+    // from the nearest recorded base. Structural lookup stays restricted to
+    // TypeScript here: plain JavaScript/Python receivers can be dynamically
+    // reshaped, while a TS return annotation plus a concrete class heritage
+    // edge is compiler-grade method ownership.
+    const followsRecordedClassInheritance =
+        langTraits(language)?.typeSystem === 'nominal' ||
+        language === 'typescript' || language === 'tsx';
+    if (!selected.match && !selected.ambiguous && followsRecordedClassInheritance) {
         const visited = new Set([typeName]);
         const queue = [...(index._getInheritanceParents?.(
             typeName, contextFile) || [])];
@@ -10695,7 +11295,97 @@ function _csharpParamsNormalFormApplicable(index, call, definition) {
     return !!actual && !!expected && actual === expected;
 }
 
-function _declaredFieldType(index, rootType, fieldName, language, info, rootNamespace) {
+function _goContainerElementType(raw) {
+    const text = String(raw || '').trim();
+    let element = null;
+    const bracketStart = text.startsWith('map[') ? 3 : text.startsWith('[') ? 0 : -1;
+    if (bracketStart >= 0) {
+        let depth = 0;
+        for (let i = bracketStart; i < text.length; i++) {
+            if (text[i] === '[') depth++;
+            else if (text[i] === ']') {
+                depth--;
+                if (depth === 0) {
+                    element = text.slice(i + 1).trim();
+                    break;
+                }
+            }
+        }
+    }
+    if (!element) return null;
+    element = element.replace(/^\*+/, '').trim();
+    const qualified = element.match(/^([A-Za-z_]\w*)\.([A-Za-z_]\w*)$/);
+    if (qualified) {
+        return { qualifier: qualified[1], type: qualified[2] };
+    }
+    return /^[A-Za-z_]\w*$/.test(element)
+        ? { qualifier: null, type: element } : null;
+}
+
+function _goIndexedReceiverType(index, filePath, call) {
+    const rootType = call.receiverIndexRootType;
+    const fieldName = call.receiverIndexField;
+    if (!rootType || !fieldName) return null;
+
+    const rootOrigin = _resolveFlowTypeOrigin(
+        index, filePath, rootType, call.receiverIndexRootTypeQualifier);
+    if (call.receiverIndexRootTypeQualifier && !rootOrigin?.fromFile) {
+        return { externalVia: `${call.receiverIndexRootTypeQualifier}.${rootType}` };
+    }
+
+    let fields = (index.symbols.get(fieldName) || []).filter(definition =>
+        definition.className === rootType && definition.fieldType &&
+        (definition.type === 'field' || definition.memberType === 'field'));
+    if (rootOrigin?.fromFile) {
+        const owned = fields.filter(field => field.file === rootOrigin.fromFile);
+        if (owned.length > 0) fields = owned;
+    }
+    if (fields.length === 0) return null;
+
+    const candidates = new Map();
+    for (const field of fields) {
+        const element = _goContainerElementType(field.fieldType);
+        if (!element) return null;
+        if (element.qualifier) {
+            const origin = field.file && _resolveFlowTypeOrigin(
+                index, field.file, element.type, element.qualifier);
+            if (origin?.fromFile) {
+                candidates.set(`${element.type}\0${origin.fromFile}`, {
+                    type: element.type,
+                    fromFile: origin.fromFile,
+                });
+            } else if (field.file &&
+                _goQualifierNamesImport(index, field.file, element.qualifier)) {
+                candidates.set(`external\0${element.qualifier}.${element.type}`, {
+                    externalVia: `${element.qualifier}.${element.type}`,
+                });
+            } else {
+                return null;
+            }
+            continue;
+        }
+
+        const typeDefs = (index.symbols.get(element.type) || [])
+            .filter(definition => IDENTITY_TYPE_KINDS.has(definition.type));
+        if (typeDefs.length === 0) {
+            if (!BUILTIN_RECEIVER_TYPES.has(element.type)) return null;
+            candidates.set(`builtin\0${element.type}`, { type: element.type });
+            continue;
+        }
+        const origin = field.file && _resolveFlowTypeOrigin(
+            index, field.file, element.type);
+        if (!origin?.fromFile) return null;
+        candidates.set(`${element.type}\0${origin.fromFile}`, {
+            type: element.type,
+            fromFile: origin.fromFile,
+        });
+    }
+    return candidates.size === 1 ? [...candidates.values()][0] : null;
+}
+
+function _declaredFieldType(
+    index, rootType, fieldName, language, info = null, rootNamespace = undefined
+) {
     const defs = index.symbols.get(fieldName) || [];
     if (defs.length === 0 && language !== 'python') return null;
     // 'private field' (JS #-fields, fix #219): equally compiler-true, and
@@ -10708,7 +11398,7 @@ function _declaredFieldType(index, rootType, fieldName, language, info, rootName
         d.type === 'property' || d.memberType === 'property';
     const fields = defs.filter(d =>
         ((d.type === 'field' || d.memberType === 'field' || d.memberType === 'private field') && d.fieldType) ||
-        (isAccessor(d) && d.returnType));
+        (isAccessor(d) && (d.returnType || d.fieldType)));
     let onType = fields.filter(d => d.className === rootType &&
         (language !== 'csharp' || !rootNamespace ||
             (d.namespace || null) === rootNamespace));
@@ -10767,7 +11457,7 @@ function _declaredFieldType(index, rootType, fieldName, language, info, rootName
     if (onType.length === 0) return null;
     const normalized = new Set();
     for (const f of onType) {
-        const rawText = isAccessor(f) ? f.returnType : f.fieldType;
+        const rawText = isAccessor(f) ? (f.returnType || f.fieldType) : f.fieldType;
         // Qualified declared types resolve through the FIELD-DECLARING file's
         // imports or not at all (fix #268, chi-measured — the #206 identity
         // discipline): `inner http.Handler` is net/http's Handler, never a
@@ -10799,7 +11489,10 @@ function _declaredFieldType(index, rootType, fieldName, language, info, rootName
                 return null;
             }
         }
-        const localType = _normalizeFieldTypeName(rawText, language);
+        const localType = _normalizeFieldTypeName(rawText, language, {
+            index,
+            originFile: f.file,
+        });
         const importedIdentity = language === 'rust' && f.file && localType
             ? _rustImportedTypeIdentity(index, f.file, localType) : null;
         const t = importedIdentity?.type || localType;
@@ -10824,11 +11517,15 @@ function _declaredFieldType(index, rootType, fieldName, language, info, rootName
                 complete = false;
                 break;
             }
-            const rawText = isAccessor(field) ? field.returnType : field.fieldType;
+            const rawText = isAccessor(field)
+                ? (field.returnType || field.fieldType) : field.fieldType;
             const qualifier = language === 'java'
                 ? _javaNestedTypeQualifier(rawText) : undefined;
             if (qualifier) namespaces.add(qualifier);
-            const localType = _normalizeFieldTypeName(rawText, language);
+            const localType = _normalizeFieldTypeName(rawText, language, {
+                index,
+                originFile: field.file,
+            });
             const importedIdentity = language === 'rust' && localType
                 ? _rustImportedTypeIdentity(index, field.file, localType) : null;
             const origin = importedIdentity?.type === typeName
@@ -10983,10 +11680,14 @@ function _nonCallableFieldMember(index, typeName, name, language) {
         (d.receiver && d.receiver.replace(/^\*/, '') === typeName));
     if (onType.length === 0) return false;
     for (const d of onType) {
-        if (d.type !== 'field' && d.memberType !== 'field' && d.memberType !== 'private field') return false;
-        if (!d.fieldType) return false;
+        const valueMember = d.type === 'field' || d.memberType === 'field' ||
+            d.memberType === 'private field' || d.type === 'property' ||
+            d.memberType === 'property';
+        if (!valueMember) return false;
+        const declaredType = d.fieldType || d.returnType;
+        if (!declaredType) return false;
         if (_callableFieldDef(index, d)) return false;
-        const raw = String(d.fieldType).trim();
+        const raw = String(declaredType).trim();
         if (/^func\b/.test(raw)) return false;
         if (/\bfn\s*\(|\b(?:Fn|FnMut|FnOnce)\s*[(<]/.test(raw)) return false;
         if (langTraits(language)?.typeSystem === 'structural') {
@@ -12185,8 +12886,17 @@ function _javaArgKindMatches(index, kind, paramType, language) {
     return allowed.includes(bare);
 }
 
-function _cppTypeCategory(type) {
+function _cppTypeCategory(index, type) {
     if (!type) return { kind: 'unknown', head: null };
+    const cacheKey = String(type);
+    const cached = index._opCppTypeCategoryCache?.get(cacheKey);
+    if (cached) return cached;
+    const result = _computeCppTypeCategory(type);
+    index._opCppTypeCategoryCache?.set(cacheKey, result);
+    return result;
+}
+
+function _computeCppTypeCategory(type) {
     const original = String(type).trim();
     const compact = original.replace(/\s+/g, '');
     const unqualified = original
@@ -12266,9 +12976,9 @@ function _cppTypeCategory(type) {
  * converting constructors and unknown template constraints keep the
  * candidate alive.
  */
-function _cppArgKindMatches(kind, paramType) {
+function _cppArgKindMatches(index, kind, paramType) {
     if (!kind || kind === 'expr' || !paramType) return true;
-    const expected = _cppTypeCategory(paramType);
+    const expected = _cppTypeCategory(index, paramType);
     if (expected.kind === 'unknown' || expected.kind === 'generic') return true;
 
     if (kind.startsWith('string:')) {
@@ -12315,7 +13025,7 @@ function _cppArgKindMatches(kind, paramType) {
     if (kind.startsWith('type:') || kind.startsWith('call:') ||
         kind.startsWith('bcall:')) {
         const actualType = kind.slice(kind.indexOf(':') + 1);
-        const actual = _cppTypeCategory(actualType);
+        const actual = _cppTypeCategory(index, actualType);
         if (actual.head && expected.head && actual.head === expected.head) return true;
         const closed = new Set([
             'format-string', 'string', 'locale', 'style',
@@ -12357,7 +13067,7 @@ function _overloadApplicable(index, call, def) {
         const p = ps[i];
         if (!p || p.rest) break;
         const matches = language === 'cpp'
-            ? _cppArgKindMatches(kinds[i], p.type)
+            ? _cppArgKindMatches(index, kinds[i], p.type)
             : _javaArgKindMatches(index, kinds[i], p.type, language);
         if (!matches) return false;
     }
@@ -12651,6 +13361,10 @@ function _cppTargetVisibility(index, callerFile, targetDefs) {
 
 function _cppPathReceiverNamesType(index, receiver) {
     if (!receiver) return false;
+    const cacheKey = String(receiver);
+    if (index._opCppPathReceiverTypeCache?.has(cacheKey)) {
+        return index._opCppPathReceiverTypeCache.get(cacheKey);
+    }
     // Remove template arguments before selecting the terminal path segment;
     // nested qualifiers inside `<...>` must not be mistaken for the owner.
     let plain = '';
@@ -12667,9 +13381,11 @@ function _cppPathReceiverNamesType(index, receiver) {
         if (depth === 0) plain += character;
     }
     const name = plain.split('::').filter(Boolean).pop();
-    return !!(name && (index.symbols.get(name) || []).some(definition =>
+    const result = !!(name && (index.symbols.get(name) || []).some(definition =>
         IDENTITY_TYPE_KINDS.has(definition.type) ||
         (definition.type === 'type' && definition.aliasOf)));
+    index._opCppPathReceiverTypeCache?.set(cacheKey, result);
+    return result;
 }
 
 function _cppQualifiedPathOwnsTarget(index, callerFile, call, targetDefs) {
@@ -13125,13 +13841,38 @@ function _cppExactOverloadWinner(call, applicable) {
  */
 function _buildTargetTypeSet(index, targetDefs, definitions) {
     const targetTypes = new Set();
+    const targetTypeOrigins = [];
+    // Callable-identity closure joins a trait declaration with its impl slot.
+    // If any member is a blanket impl over a generic owner, the whole slot is
+    // universally quantified: a concrete receiver can satisfy it without
+    // having the trait name as its nominal class. No member of that closed
+    // target group has exclusion-grade concrete receiver identity.
+    if (targetDefs.some(_definitionHasGenericOwner)) return targetTypes;
     for (const td of targetDefs) {
+        // Blanket/generic impl owner (`impl<I> Trait for I`) is a quantified
+        // parameter, not a concrete type called I. Keeping it in targetTypes
+        // made every real receiver look provably unrelated and excluded true
+        // Rayon par_iter/par_iter_mut calls. Empty target identity deliberately
+        // falls through to the visible dispatch tier.
         if (td.explicitInterface) {
             const interfaceType = _csharpTypeIdentity(td.explicitInterface);
-            if (interfaceType) targetTypes.add(interfaceType);
+            if (interfaceType) {
+                targetTypes.add(interfaceType);
+                targetTypeOrigins.push({ name: interfaceType, file: td.file });
+            }
         } else {
-            if (td.className) targetTypes.add(td.className);
-            if (td.receiver) targetTypes.add(td.receiver.replace(/^\*/, ''));
+            const owners = [
+                td.className,
+                td.receiver && td.receiver.replace(/^\*/, ''),
+            ].filter(Boolean);
+            for (const owner of owners) {
+                targetTypes.add(owner);
+                const origin = _resolveFlowTypeOrigin(index, td.file, owner);
+                targetTypeOrigins.push({
+                    name: owner,
+                    file: origin?.fromFile || td.file,
+                });
+            }
         }
     }
     if (targetTypes.size > 0) {
@@ -13148,26 +13889,42 @@ function _buildTargetTypeSet(index, targetDefs, definitions) {
         const overloadedSlots = !!langTraits(language)?.hasArityOverloads;
         const targetSignatures = new Set(targetDefs.map(signature)
             .filter(value => value !== null));
-        const queue = [...targetTypes];
+        const queue = targetTypeOrigins.length > 0
+            ? targetTypeOrigins : [...targetTypes].map(name => ({ name }));
         while (queue.length > 0) {
-            const children = index.extendedByGraph?.get(queue.pop());
+            const parent = queue.pop();
+            const children = index.extendedByGraph?.get(parent.name);
             if (!children) continue;
             for (const child of children) {
                 const cName = typeof child === 'string' ? child : child.name;
                 if (!cName || targetTypes.has(cName)) continue;
+                const childFile = typeof child === 'string' ? null : child.file;
+                if (parent.file && childFile) {
+                    // extendedByGraph is keyed by the parent's SHORT name.
+                    // Parallel package versions can therefore share a bucket
+                    // (zod v3/v4 both define ZodType). Admit a child only when
+                    // its written parent resolves back to this exact target
+                    // type origin. An unresolved parent stays conservative;
+                    // a positively foreign origin is never confirmation-grade.
+                    const parentOrigin = _resolveFlowTypeOrigin(
+                        index, childFile, parent.name);
+                    if (parentOrigin?.fromFile &&
+                        parentOrigin.fromFile !== parent.file) continue;
+                }
                 // In overload-capable languages, another same-named overload
                 // on the child does not override the pinned virtual slot.
                 // JsonTextWriter.WriteValue(Guid) must not hide inherited
                 // JsonWriter.WriteValue(Guid?). Only an agreeing parameter
                 // signature blocks the subtype closure.
                 const childDefinitions = definitions.filter(definition =>
-                    definition.className === cName);
+                    definition.className === cName &&
+                    (!childFile || definition.file === childFile));
                 const overrides = childDefinitions.some(definition =>
                         !overloadedSlots ||
                         targetSignatures.has(signature(definition)));
                 if (overrides) continue;
                 targetTypes.add(cName);
-                queue.push(cName);
+                queue.push({ name: cName, file: childFile || parent.file });
             }
         }
     }
@@ -13175,12 +13932,16 @@ function _buildTargetTypeSet(index, targetDefs, definitions) {
     // callable through the wrapper value. Close only over wrappers whose
     // indexed type definitions all agree on one Deref target.
     if (targetTypes.size > 0) {
-        const derefPairs = [];
-        for (const [wrapper, defs] of index.symbols) {
-            const typeDefs = defs.filter(d => IDENTITY_TYPE_KINDS.has(d.type));
-            if (typeDefs.length === 0 || !typeDefs.every(d => d.derefTarget)) continue;
-            const targets = new Set(typeDefs.map(d => d.derefTarget));
-            if (targets.size === 1) derefPairs.push([wrapper, [...targets][0]]);
+        let derefPairs = index._opDerefPairs;
+        if (!Array.isArray(derefPairs)) {
+            derefPairs = [];
+            for (const [wrapper, defs] of index.symbols) {
+                const typeDefs = defs.filter(d => IDENTITY_TYPE_KINDS.has(d.type));
+                if (typeDefs.length === 0 || !typeDefs.every(d => d.derefTarget)) continue;
+                const targets = new Set(typeDefs.map(d => d.derefTarget));
+                if (targets.size === 1) derefPairs.push([wrapper, [...targets][0]]);
+            }
+            if (index._opDerefPairs !== null) index._opDerefPairs = derefPairs;
         }
         let changed = derefPairs.length > 0;
         while (changed) {
@@ -13204,19 +13965,23 @@ function _buildTargetTypeSet(index, targetDefs, definitions) {
     // package must not confirm foreign receivers (#206 discipline). The
     // parser records aliasOf for Rust/Go; names without it never close.
     if (targetTypes.size > 0) {
-        const aliasPairs = [];
-        for (const [aliasName, defs] of index.symbols) {
-            let base = null;
-            let pure = true;
-            for (const d of defs) {
-                if (d.type !== 'type' && !IDENTITY_TYPE_KINDS.has(d.type)) continue;
-                if (d.type === 'type' && d.aliasOf) {
-                    const normalized = _normalizedAliasBase(index, d);
-                    if (base === null) base = normalized;
-                    else if (base !== normalized) { pure = false; break; }
-                } else { pure = false; break; }
-            }
-            if (pure && base) aliasPairs.push([aliasName, base]);
+        let aliasPairs = index._opAliasPairs;
+        if (!Array.isArray(aliasPairs)) {
+            aliasPairs = [];
+            for (const [aliasName, defs] of index.symbols) {
+                let base = null;
+                let pure = true;
+                for (const d of defs) {
+                    if (d.type !== 'type' && !IDENTITY_TYPE_KINDS.has(d.type)) continue;
+                    if (d.type === 'type' && d.aliasOf) {
+                        const normalized = _normalizedAliasBase(index, d);
+                        if (base === null) base = normalized;
+                        else if (base !== normalized) { pure = false; break; }
+                    } else { pure = false; break; }
+                }
+                if (pure && base) aliasPairs.push([aliasName, base]);
+            }
+            if (index._opAliasPairs !== null) index._opAliasPairs = aliasPairs;
         }
         let changed = aliasPairs.length > 0;
         while (changed) {
@@ -13455,7 +14220,8 @@ function _declaredFieldInterfaceType(index, rootType, fieldName, language, rootN
     const defs = index.symbols.get(fieldName);
     if (!defs) return null;
     const fields = defs.filter(d =>
-        (d.type === 'field' || d.memberType === 'field') &&
+        (d.type === 'field' || d.memberType === 'field' ||
+         d.type === 'property' || d.memberType === 'property') &&
         d.className === rootType && d.fieldType &&
         (language !== 'csharp' || !rootNamespace ||
             (d.namespace || null) === rootNamespace));
@@ -13586,7 +14352,7 @@ function _javaNestedTypeQualifier(raw) {
  *   go:   `*ignore.Ig` → Ig; slices/maps/chans/funcs → null
  *   java: `java.util.List<Foo>` → List; arrays → null
  */
-function _normalizeFieldTypeName(raw, language) {
+function _normalizeFieldTypeName(raw, language, options = {}) {
     let t = String(raw).trim();
     if (language === 'rust') {
         let prev;
@@ -13625,7 +14391,7 @@ function _normalizeFieldTypeName(raw, language) {
     if (langTraits(language)?.typeSystem === 'structural') {
         // JS/TS/Python (fix #219): compiler-true annotation heads, value-
         // position semantics — a field declared Promise<X> HOLDS a Promise.
-        return _structuralTypeHead(t, { language });
+        return _structuralTypeHead(t, { language, ...options });
     }
     return null;
 }
@@ -13868,6 +14634,50 @@ function _nominalChainedReceiverType(index, call, fileEntry, filePath) {
     return { type: parsed.name, ...(origin.fromFile && { fromFile: origin.fromFile }) };
 }
 
+/**
+ * Type a Python subscript expression used as a method receiver from the
+ * indexed container's declared `__getitem__` return contract.
+ *
+ * The root must resolve to an exact project type definition. This prevents a
+ * globally unique project `__getitem__` (or a same-named local class) from
+ * lending identity to an external or ambiguous container. The returned value
+ * then follows the same origin-pinned structural return rails as an ordinary
+ * method call.
+ */
+function _pythonIndexedReceiverType(
+    index, filePath, call, getFlowMap, cache = null
+) {
+    if (!call?.receiverSubscriptRoot) return null;
+    let rootType = call.receiverSubscriptRootType;
+    let rootFromFile;
+    if (!rootType && typeof getFlowMap === 'function') {
+        const flow = _lookupReturnTypeFlow(getFlowMap(), {
+            ...call,
+            receiver: call.receiverSubscriptRoot,
+        });
+        if (flow?.type) {
+            rootType = flow.type;
+            rootFromFile = flow.fromFile;
+        }
+    }
+    if (!rootType) return null;
+
+    const origin = _resolveFlowTypeOrigin(
+        index, rootFromFile || filePath, rootType,
+        call.receiverSubscriptRootTypeQualifier);
+    if (!origin?.fromFile) return null;
+
+    const key = `${origin.fromFile}\0${rootType}`;
+    if (cache?.has(key)) return cache.get(key);
+    const result = _methodReturnOnType(
+        index, rootType, origin.fromFile, '__getitem__', 'python', {
+            filePath,
+            selfType: rootType,
+        });
+    if (cache) cache.set(key, result || null);
+    return result;
+}
+
 function _chainedReceiverType(index, call, language) {
     const defs = (index.symbols.get(call.receiverCall) || [])
         .filter(d => !NON_CALLABLE_TYPES.has(d.type));
@@ -13926,6 +14736,131 @@ function _chainedReceiverType(index, call, language) {
 
 const _FOLD_TYPE_KINDS = new Set(['class', 'struct', 'enum', 'trait', 'interface', 'record', 'type', 'namespace']);
 
+function _structuralTypeExpression(text) {
+    if (!text || typeof text !== 'string') return null;
+    const source = text.trim();
+    const match = source.match(/^([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)/);
+    if (!match) return null;
+    const qualifiedHead = match[1];
+    const rest = source.slice(qualifiedHead.length).trim();
+    if (!rest) {
+        return { head: qualifiedHead.split('.').pop(), qualifiedHead, args: [], text: source };
+    }
+    if (!rest.startsWith('<') || !rest.endsWith('>')) return null;
+    let depth = 0;
+    for (let i = 0; i < rest.length; i++) {
+        if (rest[i] === '<') depth++;
+        else if (rest[i] === '>') depth--;
+        if (depth === 0 && i !== rest.length - 1) return null;
+        if (depth < 0) return null;
+    }
+    if (depth !== 0) return null;
+    return {
+        head: qualifiedHead.split('.').pop(),
+        qualifiedHead,
+        args: _splitTopLevelGenericArgs(rest.slice(1, -1)).map(arg => arg.trim()),
+        text: source,
+    };
+}
+
+function _structuralGenericParameters(generics) {
+    if (!generics || typeof generics !== 'string') return [];
+    const source = generics.trim();
+    if (!source.startsWith('<') || !source.endsWith('>')) return [];
+    return _splitTopLevelGenericArgs(source.slice(1, -1)).map(part => {
+        const match = part.trim().match(/^([A-Za-z_$][\w$]*)/);
+        return match ? match[1] : null;
+    }).filter(Boolean);
+}
+
+function _substituteStructuralGenerics(text, bindings) {
+    let result = String(text || '').trim();
+    for (const [name, value] of [...bindings].sort((a, b) => b[0].length - a[0].length)) {
+        if (!value || !_structuralTypeExpression(value)) continue;
+        result = result.replace(new RegExp(`\\b${name}\\b`, 'g'), value);
+    }
+    return result;
+}
+
+function _pinnedStructuralTypeDefinition(index, typeName, fromFile) {
+    let defs = (index.symbols.get(typeName) || []).filter(definition =>
+        IDENTITY_TYPE_KINDS.has(definition.type) && definition.file);
+    if (fromFile) {
+        const origin = _resolveFlowTypeOrigin(index, fromFile, typeName);
+        if (!origin?.fromFile) return null;
+        defs = defs.filter(definition => definition.file === origin.fromFile);
+    }
+    return defs.length === 1 ? defs[0] : null;
+}
+
+function _singleStructuralParent(text) {
+    if (!text) return null;
+    let angle = 0, square = 0, paren = 0;
+    for (const ch of String(text)) {
+        if (ch === '<') angle++;
+        else if (ch === '>') angle--;
+        else if (ch === '[') square++;
+        else if (ch === ']') square--;
+        else if (ch === '(') paren++;
+        else if (ch === ')') paren--;
+        else if (ch === ',' && angle === 0 && square === 0 && paren === 0) return null;
+        if (angle < 0 || square < 0 || paren < 0) return null;
+    }
+    return angle === 0 && square === 0 && paren === 0 ? String(text).trim() : null;
+}
+
+function _structuralFieldTypeExpression(
+    index, typeText, fromFile, fieldName, depth = 0
+) {
+    if (depth > 12) return null;
+    const expression = _structuralTypeExpression(typeText);
+    if (!expression) return null;
+    const definition = _pinnedStructuralTypeDefinition(
+        index, expression.head, fromFile);
+    if (!definition) return null;
+    const params = _structuralGenericParameters(definition.generics);
+    const bindings = new Map();
+    for (let i = 0; i < params.length && i < expression.args.length; i++) {
+        if (_structuralTypeExpression(expression.args[i])) {
+            bindings.set(params[i], expression.args[i]);
+        }
+    }
+    const fields = (index.symbols.get(fieldName) || []).filter(field =>
+        field.className === expression.head && field.file === definition.file &&
+        (field.type === 'field' || field.memberType === 'field' ||
+            field.memberType === 'private field') && field.fieldType);
+    if (fields.length > 0) {
+        const resolved = new Set(fields.map(field =>
+            _substituteStructuralGenerics(field.fieldType, bindings)));
+        if (resolved.size !== 1) return null;
+        const text = [...resolved][0];
+        const parsed = _structuralTypeExpression(text);
+        if (!parsed) return null;
+        const origin = _resolveFlowTypeOrigin(index, definition.file, parsed.head);
+        return { text, fromFile: origin?.fromFile || definition.file };
+    }
+    const parent = _singleStructuralParent(definition.extends);
+    if (!parent) return null;
+    const parentText = _substituteStructuralGenerics(parent, bindings);
+    const parsedParent = _structuralTypeExpression(parentText);
+    if (!parsedParent) return null;
+    const parentOrigin = _resolveFlowTypeOrigin(
+        index, definition.file, parsedParent.head);
+    if (!parentOrigin?.fromFile) return null;
+    return _structuralFieldTypeExpression(
+        index, parentText, parentOrigin.fromFile, fieldName, depth + 1);
+}
+
+function _structuralReturnedReceiverType(index, receiverText, fromFile, fieldNames) {
+    let current = { text: receiverText, fromFile };
+    for (const fieldName of fieldNames) {
+        current = _structuralFieldTypeExpression(
+            index, current.text, current.fromFile, fieldName);
+        if (!current) return null;
+    }
+    return current;
+}
+
 /**
  * Resolve method `methodName` on type `typeName` (identity-pinned to
  * `fromFile` when known) and return its resolved return-type head as
@@ -13950,8 +14885,16 @@ function _methodReturnOnType(index, typeName, fromFile, methodName, language, op
     const typeDefs = (index.symbols.get(typeName) || []).filter(d => _FOLD_TYPE_KINDS.has(d.type));
     if (typeDefs.length > 1 && owned.length > 0) {
         if (!fromFile) return null;
-        const dir = path.dirname(fromFile);
-        owned = owned.filter(d => d.file === fromFile || (d.file && path.dirname(d.file) === dir));
+        if (nominal) {
+            const dir = path.dirname(fromFile);
+            owned = owned.filter(d => d.file === fromFile ||
+                (d.file && path.dirname(d.file) === dir));
+        } else {
+            // Structural sibling modules are distinct identities. Directory
+            // co-location is package evidence for Go/Rust/Java impl layouts,
+            // but never merges two Python/JS/TS classes with the same name.
+            owned = owned.filter(d => d.file === fromFile);
+        }
     }
     if (owned.length === 0) {
         // Inheritance walk: resolve on a declared ancestor; Self/this still
@@ -13983,16 +14926,46 @@ function _methodReturnOnType(index, typeName, fromFile, methodName, language, op
     // Structural: heads must agree; `this`/`Self` are the receiver's type
     // (checked BEFORE the reject set — with a known owner they ARE identity);
     // un-awaited async producers stay untyped (the value is a coroutine).
-    if (language === 'python' && !opts.consumerAwaited && owned.some(d => d.isAsync)) return null;
+    // TypeScript/Python overload signatures are the public call contract;
+    // their runtime implementation may intentionally omit a return annotation.
+    // Once a compiler-recognized signature group exists, use only those
+    // declarations for result-flow agreement. Conflicting signature heads
+    // still abstain below (fix #316, zod-measured fluent default chains).
+    const contracts = owned.some(d => d.isSignature)
+        ? owned.filter(d => d.isSignature) : owned;
+    if (language === 'python' && !opts.consumerAwaited && contracts.some(d => d.isAsync)) return null;
+    const returnedPaths = contracts.map(definition => definition.returnedReceiverPath);
+    if (contracts.length > 0 && returnedPaths.every(path =>
+        Array.isArray(path) && path.length > 0) &&
+        new Set(returnedPaths.map(path => path.join('\0'))).size === 1) {
+        const receiverText = opts.selfTypeText || selfType;
+        const resolved = _structuralReturnedReceiverType(
+            index, receiverText, fromFile || contracts[0].file, returnedPaths[0]);
+        const parsed = resolved && _structuralTypeExpression(resolved.text);
+        if (!parsed || /^[A-Z][A-Z0-9]?$/.test(parsed.head) ||
+            _STRUCTURAL_FLOW_REJECT.has(parsed.head)) return null;
+        const origin = _resolveFlowTypeOrigin(
+            index, resolved.fromFile || contracts[0].file, parsed.head);
+        if (!origin?.fromFile) return null;
+        return {
+            type: parsed.head,
+            typeText: resolved.text,
+            fromFile: origin.fromFile,
+        };
+    }
     const heads = new Set();
-    for (const d of owned) {
+    const typeTexts = new Set();
+    for (const d of contracts) {
         if (!d.returnType) return null;
-        let h = _structuralTypeHead(d.returnType, {
+        const returnText = String(d.returnType).replace(
+            /\b(?:this|Self)\b/g, opts.selfTypeText || selfType);
+        let h = _structuralTypeHead(returnText, {
             unwrapAsync: opts.consumerAwaited, index, language, originFile: d.file,
         });
         if (h === 'this' || h === 'Self') h = selfType;
         if (!h) return null;
         heads.add(h);
+        typeTexts.add(returnText);
         if (heads.size > 1) return null;
     }
     const head = [...heads][0];
@@ -14001,16 +14974,23 @@ function _methodReturnOnType(index, typeName, fromFile, methodName, language, op
     const returnTypeDefs = (index.symbols.get(head) || []).filter(d => IDENTITY_TYPE_KINDS.has(d.type));
     if (returnTypeDefs.length > 0) {
         const origins = new Set();
-        for (const d of owned) {
+        for (const d of contracts) {
             const origin = _resolveFlowTypeOrigin(index, d.file || opts.filePath, head);
             if (!origin) return null;
             origins.add(origin.fromFile);
             if (origins.size > 1) return null;
         }
         const fromFile = [...origins][0];
-        return { type: head, ...(fromFile && { fromFile }) };
+        return {
+            type: head,
+            ...(typeTexts.size === 1 && { typeText: [...typeTexts][0] }),
+            ...(fromFile && { fromFile }),
+        };
     }
-    return { type: head };
+    return {
+        type: head,
+        ...(typeTexts.size === 1 && { typeText: [...typeTexts][0] }),
+    };
 }
 
 function _rustMacroDefinitions(index, fileEntry, filePath, record) {
@@ -14495,6 +15475,26 @@ function _typeOfCallResultFold(index, fileEntry, filePath, record, ctx, consumer
     return out;
 }
 
+function _returnedCallRecord(ctx, start, end, current) {
+    if (!ctx.returnedCallIndex) {
+        ctx.returnedCallIndex = new Map();
+        const records = ctx.allRecords || ctx.records || [];
+        for (const candidate of records) {
+            if (candidate.callStart == null || candidate.callEnd == null) continue;
+            const key = `${candidate.callStart}:${candidate.callEnd}`;
+            let group = ctx.returnedCallIndex.get(key);
+            if (!group) {
+                group = [];
+                ctx.returnedCallIndex.set(key, group);
+            }
+            group.push(candidate);
+        }
+    }
+    const matches = (ctx.returnedCallIndex.get(`${start}:${end}`) || [])
+        .filter(candidate => candidate !== current);
+    return matches.length === 1 ? matches[0] : null;
+}
+
 function _typeOfCallResultFoldInner(index, fileEntry, filePath, record, ctx, consumerAwaited) {
     const language = fileEntry.language;
     const traits = langTraits(language);
@@ -14505,6 +15505,27 @@ function _typeOfCallResultFoldInner(index, fileEntry, filePath, record, ctx, con
         return _rustMacroCallResultType(index, fileEntry, filePath, record);
     }
 
+    // Structural constructor expression: `Environment().getattr(...)`.
+    // Python/JS class calls are plain call records rather than nominal
+    // constructor records. A unique in-scope class declaration is exact
+    // result-type evidence; a same-named callable or unresolved origin keeps
+    // the chain untyped. This is deliberately identity-pinned through the
+    // calling file's imports, not a project-wide capitalization guess.
+    if (!nominal && !record.isMethod && !record.receiver) {
+        const named = index.symbols.get(name) || [];
+        const typeDefs = named.filter(definition =>
+            IDENTITY_TYPE_KINDS.has(definition.type) && definition.file);
+        const callableDefs = named.filter(definition =>
+            !NON_CALLABLE_TYPES.has(definition.type));
+        if (typeDefs.length === 1 && callableDefs.length === 0) {
+            const origin = _resolveFlowTypeOrigin(index, filePath, name);
+            if (origin?.fromFile === typeDefs[0].file) {
+                return { type: name, fromFile: origin.fromFile,
+                    exactConstructor: true };
+            }
+        }
+    }
+
     // Path producer (Rust): Command::new(...) — the last path segment names
     // the impl type (flow-map rails: module-path producers stay untyped);
     // Self::new() resolves through the enclosing impl. The type's identity
@@ -14569,8 +15590,15 @@ function _typeOfCallResultFoldInner(index, fileEntry, filePath, record, ctx, con
     if (!nominal && record.isMethod &&
         (record.receiver || record.receiverModuleSpecifier) &&
         (record.receiverIsModule || _isStructuralImportReceiver(fileEntry, record))) {
-        const binding = _structuralModuleBindings(fileEntry, record)[0];
-        const rel = binding && fileEntry.moduleResolved && fileEntry.moduleResolved[binding.module];
+        const composite = record.receiverModuleComposition
+            ? _structuralCompositeModuleOwnership(index, fileEntry, record)
+            : null;
+        if (composite && composite.verdict !== 'yes') return null;
+        const binding = composite?.binding ||
+            _structuralModuleBindings(fileEntry, record)[0];
+        const rel = composite?.rel ||
+            (binding && fileEntry.moduleResolved &&
+                fileEntry.moduleResolved[binding.module]);
         if (binding && !rel) {
             const mod = String(binding.module);
             const firstSeg = mod.split(/[./]/).filter(Boolean)[0];
@@ -14629,7 +15657,8 @@ function _typeOfCallResultFoldInner(index, fileEntry, filePath, record, ctx, con
         return { type: head, ...(fromFile && { fromFile }) };
     }
     // self/this/cls receiver: resolve through the enclosing class (+ walk).
-    if (record.isMethod && ['self', 'this', 'cls'].includes(record.receiver)) {
+    if (record.isMethod && !record.receiverField &&
+        ['self', 'this', 'cls'].includes(record.receiver)) {
         const enclosing = index.findEnclosingFunction(filePath, record.line, true);
         let cls = enclosing && enclosing.className;
         let ctxFile = filePath;
@@ -14668,6 +15697,12 @@ function _typeOfCallResultFoldInner(index, fileEntry, filePath, record, ctx, con
         if (!rt && record.receiverField && record.receiverRoot) {
             let rootType = record.receiverRootType;
             let rootFromFile;
+            if (!rootType && language === 'python' &&
+                ['self', 'cls'].includes(record.receiverRoot)) {
+                rootType = index.findEnclosingFunction(
+                    filePath, record.line, true)?.className;
+                if (rootType) rootFromFile = filePath;
+            }
             if (!rootType) {
                 const flowMap = ctx.getFlowMap();
                 const rootFlow = flowMap && _lookupReturnTypeFlow(flowMap, {
@@ -14705,6 +15740,19 @@ function _typeOfCallResultFoldInner(index, fileEntry, filePath, record, ctx, con
                     };
                 }
             }
+            if (!rt && langTraits(language)?.typeSystem === 'structural') {
+                const moduleValueInfo = {};
+                const moduleValueType = _structuralModuleValueFieldType(
+                    index, fileEntry, record, moduleValueInfo);
+                if (moduleValueType) {
+                    rt = {
+                        type: moduleValueType,
+                        ...(moduleValueInfo.fromFile && {
+                            fromFile: moduleValueInfo.fromFile,
+                        }),
+                    };
+                }
+            }
         }
         if (!rt && record.receiverCall && (!record.receiver || record.receiverIsChainRoot)) {
             rt = _foldChainedReceiverType(index, fileEntry, filePath, record, ctx);
@@ -14733,7 +15781,7 @@ function _typeOfCallResultFoldInner(index, fileEntry, filePath, record, ctx, con
                 if (builtinReturn) return { type: builtinReturn };
             }
             return _methodReturnOnType(index, rt.type, rt.fromFile, name, language,
-                { filePath, consumerAwaited });
+                { filePath, consumerAwaited, selfTypeText: rt.typeText });
         }
         if (nominal) return null;
         // One-hop agreement (the #207/#219 discipline, one level deeper):
@@ -14801,7 +15849,24 @@ function _typeOfCallResultFoldInner(index, fileEntry, filePath, record, ctx, con
         const sameFile = defs.filter(d => d.file === filePath);
         if (sameFile.length === 1) chosen = sameFile[0];
     }
-    if (!chosen || !chosen.returnType) return null;
+    if (!chosen) return null;
+    // An expression-bodied arrow returns its expression by construction.
+    // The parser persists the exact span only when that expression IS a call;
+    // resolve that existing call record through the normal compiler-evidence
+    // rails. Async functions expose the inner value only when the consumer
+    // awaits them; generators are never ordinary value factories (fix #317,
+    // zod-measured local `base = () => z.object(...)` flow).
+    if (!nominal && !chosen.returnType && !chosen.isGenerator &&
+        (!chosen.isAsync || consumerAwaited) &&
+        chosen.returnedCallStart != null && chosen.returnedCallEnd != null) {
+        const returned = _returnedCallRecord(
+            ctx, chosen.returnedCallStart, chosen.returnedCallEnd, record);
+        if (returned) {
+            return _typeOfCallResultFold(
+                index, fileEntry, filePath, returned, ctx, consumerAwaited);
+        }
+    }
+    if (!chosen.returnType) return null;
     if (nominal) {
         if (language === 'cpp') {
             const concrete = _cppAutoReturnConcreteType(index, chosen);
@@ -14896,7 +15961,8 @@ function _foldChainedReceiverType(index, fileEntry, filePath, call, ctx) {
         // fallback is not allowed to borrow Mocker.number (or another
         // module/version) as its return type. Keep the consumer untyped and
         // visible instead of manufacturing exclusion-grade evidence.
-        if (prods.some(r => r.receiverIsModule || _isStructuralImportReceiver(fileEntry, r))) {
+        if (prods.some(r => r.receiverIsModule || r.receiverModuleComposition ||
+            _isStructuralImportReceiver(fileEntry, r))) {
             return { suppressFallback: true };
         }
         return null;
@@ -14910,11 +15976,18 @@ function _foldChainedReceiverType(index, fileEntry, filePath, call, ctx) {
     if (results.some(r => r.externalVia)) return null;
     if (new Set(results.map(r => r.type)).size !== 1) return null;
     const fromFiles = new Set(results.map(r => r.fromFile));
+    const typeTexts = new Set(results.map(r => r.typeText));
     let result = {
         type: results[0].type,
+        ...(typeTexts.size === 1 && results[0].typeText && {
+            typeText: results[0].typeText,
+        }),
         ...(fromFiles.size === 1 && results[0].fromFile && {
             fromFile: results[0].fromFile,
         }),
+        ...(results.every(r => r.exactConstructor) && {
+            exactConstructor: true,
+        }),
     };
     if (call.receiverFields?.length) {
         const fieldInfo = {};
@@ -14944,6 +16017,7 @@ function _foldChainedReceiverType(index, fileEntry, filePath, call, ctx) {
 // return annotation from an unrelated class. Capitalized named imports remain
 // eligible for class/static-method resolution.
 function _isStructuralImportReceiver(fileEntry, record) {
+    if (record?.receiverModuleSpecifier || record?.receiverModuleComposition) return true;
     if (!record?.receiver || !/^[a-z_$]/.test(record.receiver)) return false;
     return (fileEntry?.importBindings || []).some(b => b.name === record.receiver);
 }