ucn 4.1.1 → 4.1.2

package/core/callers.js

@@ -12,7 +12,7 @@ const { detectLanguage, getParser, getLanguageModule, langTraits } = require('..
 const { isTestFile } = require('./discovery');
 const { NON_CALLABLE_TYPES, isOverrideMarked, codeUnitCompare, isTestPath } = require('./shared');
 const { scoreEdge, tierForResolution, TIER } = require('./confidence');
-const { findGoModule } = require('./imports');
+const { findGoModule, resolveRustImport } = require('./imports');
 
 /** Set.some() helper — like Array.some() but for Sets */
 function setSome(set, predicate) {
@@ -172,6 +172,20 @@ function findCallers(index, name, options = {}) {
         definitionLines.add(`${def.file}:${def.startLine}`);
     }
 
+    // Overload-signature identity (fix #265, zustand-measured): a pin on any
+    // member of an overload group targets the WHOLE group — the signatures
+    // and the implementation declare one function, so a call binding the
+    // first signature's bindingId IS a call to the pinned implementation
+    // (useStore's only caller was excluded other-definition under the
+    // implementation pin, a false zero-caller answer).
+    if (options.targetDefinitions && options.targetDefinitions.length > 0 &&
+        definitions.length > options.targetDefinitions.length) {
+        const closed = _closeOverloadGroup(options.targetDefinitions, definitions);
+        if (closed !== options.targetDefinitions) {
+            options = { ...options, targetDefinitions: closed };
+        }
+    }
+
     // Possible-dispatch tiering inputs (nominal contract surface) — all fixed
     // per query, computed lazily once. targetTypes mirrors the receiver-class
     // disambiguation set (target classes + non-overriding subtypes); owner
@@ -338,7 +352,7 @@ function findCallers(index, name, options = {}) {
         pendingByFile.get(filePath).push({
             call, fileEntry, callerSymbol: null,
             isMethod: call.isMethod || false,
-            isFunctionReference: !!call.isFunctionReference,
+            isFunctionReference: !!(call.isFunctionReference || call.isJsxComponent),
             receiver: call.receiver, receiverType: call.receiverType,
             calledAs,
             _tier: TIER.UNVERIFIED, _reason: reason, _meta: meta,
@@ -357,6 +371,7 @@ function findCallers(index, name, options = {}) {
     const needsTotal = !!options.needsTotal;
     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)
 
     // Use inverted callee index to skip files that don't contain calls to this name
     let calleeFiles = index.getCalleeFiles(name);
@@ -409,7 +424,9 @@ function findCallers(index, name, options = {}) {
                 // Copy-on-enrich: cached call objects stay parser-pure — the flow
                 // type derives from OTHER files' annotations, so it must never be
                 // persisted with this file's calls.
-                if (call.isMethod && call.receiver && !call.receiverType &&
+                if (call.isMethod && call.receiver &&
+                    (!call.receiverType || call.receiverTypeGuessed) &&
+                    !call.receiverIsChainRoot &&
                     (langTraits(fileEntry.language)?.typeSystem === 'structural' ||
                         (collectAccount && !call.isPotentialCallback && !call.isPathCall &&
                             langTraits(fileEntry.language)?.typeSystem === 'nominal'))) {
@@ -423,9 +440,21 @@ function findCallers(index, name, options = {}) {
                         // External producer (fix #220) — typed outside the
                         // project; blocks single-owner confirmation, routes
                         // possible-dispatch in the gate. Nominal-only entries.
+                        // A parser GUESS for the same variable (fix #266) is
+                        // noise next to the flow verdict — dropped with it.
                         call = { ...call, receiverExternalFlow: flowEntry.externalVia };
+                        if (call.receiverTypeGuessed) {
+                            call = { ...call, receiverType: undefined, receiverTypeGuessed: undefined };
+                        }
                     } else if (flowEntry) {
+                        // Compiler-checked return annotation outranks the
+                        // parser's New*-prefix name guess (fix #266,
+                        // viper-measured: registry := NewCodecRegistry()
+                        // guessed 'CodecRegistry' — the interface — while the
+                        // annotation says *DefaultCodecRegistry; the guess
+                        // excluded all three true RegisterCodec callers).
                         call = { ...call, receiverType: flowEntry.type,
+                            receiverTypeGuessed: undefined,
                             ...(flowEntry.fromFile && { receiverTypeFlowFile: flowEntry.fromFile }) };
                     }
                 }
@@ -441,17 +470,58 @@ function findCallers(index, name, options = {}) {
                 // their chained calls stay under the #204 dispatch tiering
                 // (visible, honest) until a measured family justifies the
                 // #207 origin-pinning rails there.
-                if (call.isMethod && !call.receiver && !call.receiverType && call.receiverCall &&
+                if (call.isMethod && (!call.receiver || call.receiverIsChainRoot) &&
+                    !call.receiverType && call.receiverCall &&
                     langTraits(fileEntry.language)?.typeSystem === 'structural') {
-                    const chainedType = _chainedReceiverType(index, call, fileEntry.language);
-                    if (chainedType) call = { ...call, receiverType: chainedType };
-                } else if (call.isMethod && !call.receiver && !call.receiverType && call.receiverCall &&
+                    // Fold first (fix #258 — multi-hop builder chains typed
+                    // from the producer link), one-hop agreement as fallback.
+                    let foldCtx = foldCtxCache.get(filePath);
+                    if (!foldCtx) {
+                        foldCtx = { memo: new Map(), visiting: new Set(), records: calls,
+                            getFlowMap: () => {
+                                let fm = returnFlowCache.get(filePath);
+                                if (fm === undefined) {
+                                    fm = _buildReturnTypeFlowMap(index, filePath, calls);
+                                    returnFlowCache.set(filePath, fm);
+                                }
+                                return fm;
+                            } };
+                        foldCtxCache.set(filePath, foldCtx);
+                    }
+                    const folded = _foldChainedReceiverType(index, fileEntry, filePath, call, foldCtx);
+                    if (folded && folded.type) {
+                        call = { ...call, receiverType: folded.type };
+                    } else if (folded && folded.externalVia) {
+                        call = { ...call, receiverExternalFlow: folded.externalVia };
+                    } else {
+                        const chainedType = _chainedReceiverType(index, call, fileEntry.language);
+                        if (chainedType) call = { ...call, receiverType: chainedType };
+                    }
+                } else if (call.isMethod && (!call.receiver || call.receiverIsChainRoot) &&
+                    !call.receiverType && call.receiverCall &&
                     collectAccount && !call.isPotentialCallback &&
                     langTraits(fileEntry.language)?.typeSystem === 'nominal') {
                     // Nominal chained receivers (fix #220, cobra-measured):
                     // account-gated like the #207 nominal flow — mismatch
                     // reroutes are account-only; legacy would silently drop.
-                    const flowEntry = _nominalChainedReceiverType(index, call, fileEntry, filePath);
+                    // The fold (fix #258) runs first — Command::new("x")
+                    // .author(a).arg(b) types hop-by-hop where the one-hop
+                    // agreement rule dies on multi-owner `Self` returns.
+                    let foldCtx = foldCtxCache.get(filePath);
+                    if (!foldCtx) {
+                        foldCtx = { memo: new Map(), visiting: new Set(), records: calls,
+                            getFlowMap: () => {
+                                let fm = returnFlowCache.get(filePath);
+                                if (fm === undefined) {
+                                    fm = _buildReturnTypeFlowMap(index, filePath, calls);
+                                    returnFlowCache.set(filePath, fm);
+                                }
+                                return fm;
+                            } };
+                        foldCtxCache.set(filePath, foldCtx);
+                    }
+                    const flowEntry = _foldChainedReceiverType(index, fileEntry, filePath, call, foldCtx)
+                        || _nominalChainedReceiverType(index, call, fileEntry, filePath);
                     if (flowEntry && flowEntry.externalVia) {
                         call = { ...call, receiverExternalFlow: flowEntry.externalVia };
                     } else if (flowEntry) {
@@ -523,6 +593,22 @@ function findCallers(index, name, options = {}) {
                         }
                     }
 
+                    // A member access on a typed receiver whose member of this
+                    // name is a provably non-callable FIELD denotes the field,
+                    // never a same-name symbol elsewhere (fix #266,
+                    // viper-measured: `delete(v.override, alias)` on Viper's
+                    // map field scope-confirmed against the test-file function
+                    // `override` — the #231(2) callee physics, caller side).
+                    // Only certainty excludes: _nonCallableFieldMember demands
+                    // every same-type member be a field with a present
+                    // non-function type. Guess-grade receiver types (#266)
+                    // never carry it.
+                    if (call.isMethod && call.receiverType && !call.receiverTypeGuessed &&
+                        _nonCallableFieldMember(index, call.receiverType, call.name, fileEntry.language)) {
+                        recordExcluded(filePath, call.line, 'member-reference');
+                        continue;
+                    }
+
                     // A bare identifier can never denote a METHOD where bare
                     // names don't reach methods (fix #220, grpc-go-measured:
                     // `balancer.Get(Name)` references each package's const
@@ -580,7 +666,10 @@ function findCallers(index, name, options = {}) {
                                 // the ground line surfaced as call-not-resolved
                                 // (grpc-go/cursive-measured).
                                 if (collectAccount) {
-                                    if (_dispatchCapableSupertype(index, fileEntry.language, call.receiverType, cbTargetDefs, definitions)) {
+                                    // Guess-grade types (fix #266) route, never
+                                    // exclude — convention is not compiler truth.
+                                    if (call.receiverTypeGuessed ||
+                                        _dispatchCapableSupertype(index, fileEntry.language, call.receiverType, cbTargetDefs, definitions)) {
                                         routeUnverified(filePath, fileEntry, call, 'possible-dispatch', calledAs, {
                                             dispatchVia: call.receiverType,
                                             dispatchCandidates: countDispatchCandidates(call.receiverType),
@@ -1066,7 +1155,16 @@ function findCallers(index, name, options = {}) {
                 }
                 if (call.isMethod && !call.receiverType && call.receiverField && fieldHopRootType &&
                     !resolvedBySameClass) {
-                    fieldHopType = _declaredFieldType(index, fieldHopRootType, call.receiverField, fileEntry.language);
+                    const hopInfo = {};
+                    fieldHopType = _declaredFieldType(index, fieldHopRootType, call.receiverField, fileEntry.language, hopInfo);
+                    // Provably-external declared field type (fix #268,
+                    // chi-measured: `inner http.Handler` on a pin named
+                    // Handler elsewhere in the project) — rides the #220(6)
+                    // external-flow rail: defeats single-owner confirmation,
+                    // routes possible-dispatch, never excludes.
+                    if (!fieldHopType && hopInfo.externalVia && !call.receiverExternalFlow) {
+                        call = { ...call, receiverExternalFlow: hopInfo.externalVia };
+                    }
                 }
                 // Dispatch attribution (contract surface only): a field DECLARED
                 // as a project interface/trait carries no exclusion evidence
@@ -1120,7 +1218,26 @@ function findCallers(index, name, options = {}) {
                     // receiver-class disambiguation below).
                     const fieldHopMatchesTarget = fieldHopType && targetDefs.some(d =>
                         (d.className || (d.receiver || '').replace(/^\*/, '')) === fieldHopType);
-                    if (!fieldHopMatchesTarget) {
+                    // Java arity-overload groups are ONE bindable name (fix
+                    // #268, javapoet-measured): the bare delegation
+                    // `defaultValue(Code.of(...))` inside Builder name-bound
+                    // the same-class FIELD (or the sibling overload) and was
+                    // excluded other-definition — a false zero-caller answer.
+                    // When the resolved binding's def sits in the pin's
+                    // same-class callable overload family, binding identity
+                    // proves nothing; the #205 overload discipline below
+                    // adjudicates (fits/sibling/ambiguous). Fields never
+                    // receive Java calls (separate namespaces), so a
+                    // field-binding hit is treated the same way.
+                    let overloadGroupBinding = false;
+                    if (!fieldHopMatchesTarget &&
+                        langTraits(fileEntry.language)?.hasArityOverloads && !call.receiver) {
+                        const boundDef = definitions.find(d => d.bindingId === bindingId);
+                        overloadGroupBinding = !!(boundDef && boundDef.className &&
+                            targetDefs.some(d => d.className === boundDef.className &&
+                                d.file === boundDef.file));
+                    }
+                    if (!fieldHopMatchesTarget && !overloadGroupBinding) {
                         recordExcluded(filePath, call.line, 'other-definition');
                         continue;
                     }
@@ -1142,7 +1259,23 @@ function findCallers(index, name, options = {}) {
                 if (!bindingId && !call.isMethod && !calledAs &&
                     langTraits(fileEntry.language)?.typeSystem === 'structural' &&
                     (fileEntry.importBindings || []).length > 0) {
-                    const nameBindings = fileEntry.importBindings.filter(b => b.name === call.name);
+                    // Renamed destructures look up by the RESOLVED name (fix
+                    // #269, fastify-measured): `const { validate:
+                    // validateSchema } = require('./validation')` stores the
+                    // binding under 'validate' while the record's name is the
+                    // local alias — the empty lookup skipped the whole
+                    // ownership chase and the call scope-confirmed against
+                    // hooks.js's unrelated validate.
+                    const lookupName = call.resolvedName || call.name;
+                    let nameBindings = fileEntry.importBindings.filter(b => b.name === lookupName);
+                    // Exact alias pairing (fix #269): two renames of one
+                    // source name from DIFFERENT modules — the record's local
+                    // alias (call.name) picks its own binding; source-name
+                    // matching alone over-follows into the other module.
+                    if (call.resolvedName && nameBindings.some(b => b.alias)) {
+                        const paired = nameBindings.filter(b => b.alias === call.name);
+                        if (paired.length > 0) nameBindings = paired;
+                    }
                     const tFiles = new Set(targetDefs.map(d => d.file).filter(Boolean));
                     // fix #215 (rich-measured: 225 builtin `print(...)` calls
                     // confirmed against rich's def via file-level import edges):
@@ -1215,6 +1348,20 @@ function findCallers(index, name, options = {}) {
                             recordExcluded(filePath, call.line, 'other-definition-import');
                             continue;
                         }
+                        // Paired-rename records (fix #269, fastify-measured):
+                        // `{ validate: validateSchema } = require('./validation')`
+                        // pins the alias to ONE module. An un-modelable chain
+                        // (CJS export surface) blocks exclusion but is not
+                        // confirmation evidence either — the call routes
+                        // visible instead of scope-confirming a pin its own
+                        // module never provably reaches (hooks.js's unrelated
+                        // validate confirmed at scope-match 0.65).
+                        if (!reaches && undetermined && collectAccount &&
+                            call.resolvedName && nameBindings.length > 0 &&
+                            nameBindings.every(b => b.alias === call.name)) {
+                            routeUnverified(filePath, fileEntry, call, 'ambiguous-binding', calledAs);
+                            continue;
+                        }
                     }
                 }
 
@@ -1607,9 +1754,17 @@ function findCallers(index, name, options = {}) {
                                     !(index.symbols.get(knownType) || []).some(d =>
                                         d.type === 'class' || d.type === 'struct' || d.type === 'interface' || d.type === 'trait') &&
                                     _targetAncestryFullyResolved(index, targetDefs));
+                            // A New*-prefix name GUESS (fix #266) is convention,
+                            // not compiler truth — never exclusion evidence.
+                            // Account mode routes the mismatch visible through
+                            // the dispatch gate below; legacy keeps its drop
+                            // (drop-vs-route asymmetry, the #213 pattern).
+                            const receiverGuessGrade = !!(call.receiverTypeGuessed ||
+                                (viaFieldHop && call.receiverRootTypeGuessed));
                             const exclusionTrusted = (!structural ||
                                 _receiverTypeTrustedForExclusion(index, knownType)) && fieldHopDefinesMethod &&
-                                !receiverTypeUnresolved; // unresolvable identity is not positive evidence either way
+                                !receiverTypeUnresolved && // unresolvable identity is not positive evidence either way
+                                !(collectAccount && receiverGuessGrade);
                             if (!matchesTarget && exclusionTrusted) {
                                 // Known type doesn't match target — positive evidence the
                                 // call targets a DIFFERENT symbol. Under the account contract
@@ -1639,6 +1794,48 @@ function findCallers(index, name, options = {}) {
                                     continue;
                                 }
                             }
+                            // A guessed type that mismatches ROUTES visible
+                            // (fix #266): the pre-guard flow reached the
+                            // dispatch-capable reroute INSIDE the exclusion
+                            // branch, so denying exclusionTrusted alone let
+                            // the call fall through to the arity/scope
+                            // machinery below (grpc-go: stream.SendMsg on a
+                            // guessed 'Stream' fell to arity-mismatch — a
+                            // harsher wrong exclusion). Convention-grade
+                            // evidence attributes dispatch; it never excludes
+                            // and never confirms a mismatch.
+                            if (!matchesTarget && !exclusionTrusted && collectAccount && receiverGuessGrade) {
+                                routeUnverified(filePath, fileEntry, call, 'possible-dispatch', calledAs, {
+                                    dispatchVia: knownType,
+                                    dispatchCandidates: countDispatchCandidates(knownType),
+                                });
+                                continue;
+                            }
+                            // Unmatched-but-untrusted field-hop type (fix #265,
+                            // hono-measured): the hop PROVED the receiver is the
+                            // field's declared type — not the enclosing class —
+                            // yet the head earns no exclusion trust (external/
+                            // unresolvable name). Falling through let the class-
+                            // member name binding confirm `this.store.keys()`
+                            // as MockCache.keys ('exact-binding'): bindings
+                            // don't model receivers (#202). Route visible,
+                            // attributed via the field's type; never confirm,
+                            // never exclude. Structural only — nominal hops
+                            // keep their #202 promotion/embedding fall-through
+                            // (no measured family).
+                            if (!matchesTarget && !exclusionTrusted && viaFieldHop && structural) {
+                                if (collectAccount) {
+                                    routeUnverified(filePath, fileEntry, call, 'possible-dispatch', calledAs, {
+                                        dispatchVia: knownType,
+                                        dispatchCandidates: countDispatchCandidates(knownType),
+                                    });
+                                    continue;
+                                }
+                                if (!options.includeUncertain) {
+                                    if (stats) stats.uncertain = (stats.uncertain || 0) + 1;
+                                    continue;
+                                }
+                            }
                         } else {
                             // No parser-inferred type — try local type inference
                             // for Go/Java/Rust (nominal type systems)
@@ -1665,6 +1862,12 @@ function findCallers(index, name, options = {}) {
                                         let inferredType = localTypes.get(call.receiver);
                                         if (inferredType && _isGenericParamReceiverType(
                                             index, filePath, call.line, inferredType)) inferredType = null;
+                                        // New*-guess entries (fix #266) may confirm
+                                        // but never exclude: a mismatch routes as
+                                        // unresolved under the account contract
+                                        // (legacy keeps the drop — #213 asymmetry).
+                                        const inferredGuessed = !!(inferredType &&
+                                            localTypes.guessedVars?.has(call.receiver));
                                         if (inferredType) {
                                             if (targetTypes.has(inferredType)) {
                                                 // Identity discipline (fix #206) — same as the
@@ -1679,12 +1882,14 @@ function findCallers(index, name, options = {}) {
                                                     inferredMatch = true;
                                                     nominalInferredMatch = true;
                                                 } else if (identity === 'other') {
-                                                    inferredMismatch = true;
+                                                    if (collectAccount && inferredGuessed) receiverTypeUnresolved = true;
+                                                    else inferredMismatch = true;
                                                 } else {
                                                     receiverTypeUnresolved = true;
                                                 }
                                             } else {
-                                                inferredMismatch = true;
+                                                if (collectAccount && inferredGuessed) receiverTypeUnresolved = true;
+                                                else inferredMismatch = true;
                                             }
                                         }
                                     }
@@ -2063,15 +2268,106 @@ function findCallers(index, name, options = {}) {
                             recordExcluded(filePath, call.line, 'path-type-mismatch');
                             continue;
                         }
+                        // Module-qualified path calls (fix #260, clap-measured):
+                        // a LOWERCASE path qualifier names a MODULE, and the
+                        // module owns the name (#206 ownership) — clap_mangen's
+                        // `render::version(&self.cmd)` is render.rs's function,
+                        // never Command::version, yet bare-name scope evidence
+                        // confirmed it against the method pin. The qualifier's
+                        // last segment resolves through this file's import/mod
+                        // edges (basename match, mod.rs-aware): pin inside the
+                        // module → normal confirmation; module defines the name
+                        // elsewhere → excluded other-definition; resolver gap or
+                        // unresolvable qualifier → visible, never scope-confirmed
+                        // (#206(4): a qualified call never earns the target's
+                        // bare-identifier scope evidence). crate/self/super are
+                        // scope keywords, not module names — exempt.
+                        if (call.isPathCall && call.receiver) {
+                            const _modSeg = String(call.receiver).split('::').pop();
+                            if (_modSeg && !/^[A-Z]/.test(_modSeg) &&
+                                !['crate', 'self', 'super'].includes(_modSeg)) {
+                                // Inline module container first (fix #260b —
+                                // the #254 machinery): `convert::string(...)`
+                                // where `mod convert { pub fn string }` lives
+                                // in the SAME file (ripgrep defs.rs).
+                                // Containment is identity evidence: the pin
+                                // inside the module confirms; a same-name def
+                                // inside it that ISN'T the pin excludes.
+                                const _nsPin = _namespaceContainedDef(index, fileEntry, filePath,
+                                    _modSeg, name, targetDefs2);
+                                if (_nsPin) {
+                                    call = { ...call, moduleOwnedPath: true };
+                                } else if (_namespaceContainedDef(index, fileEntry, filePath,
+                                    _modSeg, name, null)) {
+                                    recordExcluded(filePath, call.line, 'other-definition');
+                                    continue;
+                                } else {
+                                    const _edges = index.importGraph.get(filePath);
+                                    const _modFiles = [];
+                                    if (_edges) {
+                                        for (const e of _edges) {
+                                            const base = path.basename(e).replace(/\.rs$/, '');
+                                            if (base === _modSeg ||
+                                                (base === 'mod' && path.basename(path.dirname(e)) === _modSeg)) {
+                                                _modFiles.push(e);
+                                            }
+                                        }
+                                    }
+                                    // Scope-rooted qualifiers (fix #260b,
+                                    // ripgrep-measured): crate::messages::
+                                    // set_errored() needs no use statement, so
+                                    // there is no import edge — resolve the full
+                                    // module path with the machinery imports use
+                                    // (crate::/super::/self::, own-package names,
+                                    // mod siblings, manifest target roots).
+                                    if (_modFiles.length === 0) {
+                                        try {
+                                            const r = resolveRustImport(String(call.receiver), filePath, index.root);
+                                            if (r && index.files.has(r)) _modFiles.push(r);
+                                        } catch { /* resolver gap — never exclusion evidence */ }
+                                    }
+                                    const _pinnedIn = _modFiles.length > 0 &&
+                                        targetDefs2.some(d => _modFiles.includes(d.file));
+                                    if (!_pinnedIn) {
+                                        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));
+                                        });
+                                        if (_ownsName) {
+                                            recordExcluded(filePath, call.line, 'other-definition');
+                                            continue;
+                                        }
+                                        routeUnverified(filePath, fileEntry, call, 'method-ambiguous', calledAs, {
+                                            dispatchCandidates: methodOwnerKeys().size,
+                                        });
+                                        continue;
+                                    }
+                                    // Pinned target lives in the qualifier's
+                                    // module — ownership is compiler-grade
+                                    // name-level evidence (Rust resolves
+                                    // crate::util::helper to util.rs's helper,
+                                    // period): carry it as import-grade
+                                    // evidence so a pure path-only usage
+                                    // confirms even with no use-statement edge.
+                                    call = { ...call, moduleOwnedPath: true };
+                                }
+                            }
+                        }
                         const knownDispatchType = call.receiverType || fieldHopType || fieldDispatchType;
-                        if (knownDispatchType && !tTypes.has(knownDispatchType)) {
+                        // Module-owned qualified calls (fix #260b) are resolved
+                        // by OWNERSHIP — the dispatch-ambiguity routing below is
+                        // receiver physics for method calls and must not demote
+                        // them (ripgrep: `convert::string(...)` tripped the
+                        // multi-owner check via unrelated `string` methods).
+                        if (!call.moduleOwnedPath && knownDispatchType && !tTypes.has(knownDispatchType)) {
                             routeUnverified(filePath, fileEntry, call, 'possible-dispatch', calledAs, {
                                 dispatchVia: knownDispatchType,
                                 dispatchCandidates: countDispatchCandidates(knownDispatchType),
                             });
                             continue;
                         }
-                        if (!knownDispatchType && methodOwnerKeys().size > 1) {
+                        if (!call.moduleOwnedPath && !knownDispatchType && methodOwnerKeys().size > 1) {
                             routeUnverified(filePath, fileEntry, call, 'method-ambiguous', calledAs, {
                                 dispatchCandidates: methodOwnerKeys().size,
                             });
@@ -2091,6 +2387,19 @@ function findCallers(index, name, options = {}) {
                             });
                             continue;
                         }
+                        // java.lang.Object universal names (fix #265 — the
+                        // structural gate's twin): toString/equals/hashCode
+                        // are satisfied by EVERY value via Object, marker or
+                        // not — unique project ownership is not identity
+                        // evidence for a receiver-evidence-free call.
+                        if (!knownDispatchType &&
+                            _universalMethodName(fileEntry.language, call.name)) {
+                            routeUnverified(filePath, fileEntry, call, 'possible-dispatch', calledAs, {
+                                dispatchVia: `${_universalRootName(fileEntry.language)} — builtin contract`,
+                                externalContract: true,
+                            });
+                            continue;
+                        }
                         // Wrong-arity call that fits no project def (fix #229
                         // carve-out marker): the single-owner rule presumes no
                         // other candidate exists, but the arity disproves the
@@ -2317,6 +2626,19 @@ function findCallers(index, name, options = {}) {
                             });
                             continue;
                         }
+                        // Universal-contract names (fix #265): Object.prototype
+                        // (JS) / object dunders (Python) — every external value
+                        // satisfies the call, so unique project ownership below
+                        // is not receiver evidence. Demote-only.
+                        if (!typeQualifiedReceiver && _universalMethodName(fileEntry.language, call.name)) {
+                            const univVia = call.receiverType || fieldHopType || fieldDispatchType;
+                            routeUnverified(filePath, fileEntry, call, 'possible-dispatch', calledAs, {
+                                dispatchVia: univVia ||
+                                    `${_universalRootName(fileEntry.language)} — builtin contract`,
+                                externalContract: true,
+                            });
+                            continue;
+                        }
                         if (!typeQualifiedReceiver && methodOwnerKeys().size > 1) {
                             const knownDispatchType = call.receiverType || fieldHopType || fieldDispatchType;
                             if (knownDispatchType) {
@@ -2377,8 +2699,11 @@ function findCallers(index, name, options = {}) {
                     isMethod: call.isMethod || false,
                     // Function references can resolve through the plain binding
                     // path too (e.g. JS `arr.map(helper)` with a local binding) —
-                    // surface the parser's marker on the edge (fix #221).
-                    isFunctionReference: !!call.isFunctionReference,
+                    // surface the parser's marker on the edge (fix #221). JSX
+                    // component usage is the same shape (fix #265): `<App />`
+                    // compiles to jsx(App, ...) — a reference the runtime
+                    // invokes, not direct call syntax.
+                    isFunctionReference: !!(call.isFunctionReference || call.isJsxComponent),
                     receiver: call.receiver,
                     receiverType: call.receiverType,
                     calledAs,
@@ -2394,7 +2719,7 @@ function findCallers(index, name, options = {}) {
                             : !!call.receiverType,
                         hasReceiverEvidence: !!(call.receiver &&
                             (fileEntry.bindings || []).some(b => b.name === call.receiver)),
-                        hasImportEvidence: !!bindingId || hasImportLink,
+                        hasImportEvidence: !!bindingId || hasImportLink || !!call.moduleOwnedPath,
                         ...(typeMismatch && { typeMismatch: true }),
                     }
                 });
@@ -2690,6 +3015,16 @@ function findCallees(index, def, options = {}) {
             if (_flowMap === undefined) _flowMap = _buildReturnTypeFlowMap(index, def.file, calls);
             return _flowMap;
         };
+        // Chained-receiver fold context (fix #268 — the #258 rails, callee
+        // direction): built lazily, shared across this def's records.
+        let calleeFoldCtx = null;
+        const foldCtx = () => {
+            if (!calleeFoldCtx) {
+                calleeFoldCtx = { memo: new Map(), visiting: new Set(), records: calls,
+                    getFlowMap: () => flowMap() };
+            }
+            return calleeFoldCtx;
+        };
 
         let siteOrdinal = -1;
         for (const call of calls) {
@@ -2720,13 +3055,17 @@ function findCallees(index, def, options = {}) {
             // to nothing). _declaredFieldType's guards apply: interface/
             // trait-typed and generic-param fields return null.
             let fieldHopType = null;
+            let fieldHopInfo = null;
             if (call.isMethod && !call.receiverType && call.receiverField) {
                 let hopRoot = call.receiverRootType;
                 if (!hopRoot && call.receiverRoot === 'this' &&
                     langTraits(language)?.typeSystem === 'structural') {
                     hopRoot = index.findEnclosingFunction(def.file, call.line, true)?.className;
                 }
-                if (hopRoot) fieldHopType = _declaredFieldType(index, hopRoot, call.receiverField, language);
+                if (hopRoot) {
+                    fieldHopInfo = {};
+                    fieldHopType = _declaredFieldType(index, hopRoot, call.receiverField, language, fieldHopInfo);
+                }
             }
 
             // Go package-qualified receiver: resolve the import module up
@@ -2734,9 +3073,14 @@ function findCallees(index, def, options = {}) {
             // type-qualified method expressions (fix #236 — a receiver that
             // is neither stays eligible for type-qualified resolution below).
             let goImportModule = null;
-            if (call.isMethod && call.receiver && langTraits(language)?.hasReceiverPackageCalls) {
+            if (call.receiver && langTraits(language)?.hasReceiverPackageCalls) {
                 const goImports = fileEntry?.imports || [];
                 // Handle Go version suffixes: k8s.io/klog/v2 → klog, not v2
+                // fix #268 (chi-measured): computed for NON-method records
+                // too — the parser marks `context.WithValue(...)` isMethod:
+                // false, which used to skip the whole package-ownership
+                // dispatch and confirm the bare name against the project's
+                // only WithValue def (middleware/value.go).
                 goImportModule = goImports.find(mod => {
                     const parts = mod.split('/');
                     const last = parts[parts.length - 1];
@@ -2758,6 +3102,30 @@ function findCallees(index, def, options = {}) {
                 typeQual = _calleeTypeQualifiedReceiver(index, def, fileEntry, call, language);
             }
 
+            // Package-qualified NON-method records (fix #268, chi-measured):
+            // the parser marks `context.WithValue(...)` isMethod:false, so it
+            // used to skip the package-ownership dispatch entirely and
+            // confirm as a bare name (the project's only WithValue def).
+            // The qualifier owns the name (#206/#209): resolve into the
+            // imported package or route external — never bare-name scope.
+            if (!call.isMethod && goImportModule && !call.isFunctionReference) {
+                const match = _calleeGoPackageMatch(index, call, goImportModule);
+                if (match) {
+                    const key = match.bindingId || `${call.receiver}.${call.name}`;
+                    const existing = callees.get(key);
+                    if (existing) {
+                        existing.count += 1;
+                        if (collectAccount) { existing.sites.push(call.line); existing.siteIds.push(siteId); }
+                    } else {
+                        callees.set(key, { name: call.name, bindingId: match.bindingId, count: 1,
+                            ...(collectAccount && { sites: [call.line], siteIds: [siteId] }) });
+                    }
+                } else {
+                    noteSite(siteId, 'external', null, call);
+                }
+                continue;
+            }
+
             // Smart method call handling:
             // - Go: include all method calls (Go doesn't use this/self/cls)
             // - self/this.method(): resolve to same-class method (handled below)
@@ -2780,23 +3148,29 @@ function findCallees(index, def, options = {}) {
                     const symbols = index.symbols.get(call.name);
                     const isCallable = (s) => !NON_CALLABLE_TYPES.has(s.type) ||
                         (s.type === 'field' && s.fieldType && /^func\b/.test(s.fieldType));
-                    let match = symbols?.find(s =>
+                    const onClass = (cls) => (symbols || []).filter(s =>
                         isCallable(s) && (
-                        s.className === typeName ||
-                        (s.receiver && s.receiver.replace(/^\*/, '') === typeName)));
+                        s.className === cls ||
+                        (s.receiver && s.receiver.replace(/^\*/, '') === cls)));
+                    // Same-class overloads select by static call shape —
+                    // arity, then Java argKinds (fix #268); an undecidable
+                    // family routes visible instead of binding defs[0].
+                    let sel = _calleeOverloadSelect(index, call, onClass(typeName), language);
                     // Walk embedding/inheritance chain if no direct match (nominal type systems)
-                    if (!match && langTraits(language)?.typeSystem === 'nominal') {
+                    if (!sel.match && !sel.ambiguous && langTraits(language)?.typeSystem === 'nominal') {
                         const parentNames = index._getInheritanceParents?.(typeName, def.file);
                         if (parentNames) {
                             for (const pName of parentNames) {
-                                match = symbols?.find(s =>
-                                    isCallable(s) && (
-                                    s.className === pName ||
-                                    (s.receiver && s.receiver.replace(/^\*/, '') === pName)));
-                                if (match) break;
+                                sel = _calleeOverloadSelect(index, call, onClass(pName), language);
+                                if (sel.match || sel.ambiguous) break;
                             }
                         }
                     }
+                    if (sel.ambiguous) {
+                        noteUnverified(siteId, call, 'overload-ambiguous');
+                        continue;
+                    }
+                    const match = sel.match;
                     if (match) {
                         const key = match.bindingId || `${typeName}.${call.name}`;
                         const existing = callees.get(key);
@@ -2815,13 +3189,17 @@ function findCallees(index, def, options = {}) {
                         // CacheService's map-typed field, which shadows any
                         // same-named project function through this receiver).
                         noteSite(siteId, 'excluded', 'member-reference', call);
+                    } else if (_calleeZeroCandidateName(index, call)) {
+                        // fix #261: the type defines no such method AND the
+                        // name has zero project defs anywhere — external.
+                        noteSite(siteId, 'external', null, call);
                     } else if (collectAccount) {
                         // Locally-typed receiver, but the type defines no such
                         // method in the index — visible, never silently dropped.
                         noteUnverified(siteId, call, 'uncertain-receiver');
                     }
                     continue;
-                } else if (call.receiverType || fieldHopType) {
+                } else if (call.receiverType || fieldHopType || fieldHopInfo?.externalVia) {
                     // Use parser-inferred receiverType for method resolution
                     // Go/Java/Rust: from param/receiver type declarations
                     // JS/TS: from `new Foo()` assignments or TypeScript type annotations
@@ -2829,27 +3207,45 @@ function findCallees(index, def, options = {}) {
                     // fieldHopType: the declared type of a one-hop field
                     // receiver (fix #231 — tm.service.Save() resolves Save
                     // through the `service *DataService` declaration)
+                    if (!call.receiverType && !fieldHopType && fieldHopInfo?.externalVia) {
+                        // Provably-external declared field type (fix #268,
+                        // chi-measured: `pool *sync.Pool`, `inner
+                        // http.Handler`) — never bare-name identity. Visible
+                        // when project owners of the name exist (an external
+                        // interface may dispatch into a project impl),
+                        // external otherwise.
+                        if ((index.symbols.get(call.name) || []).some(s => !NON_CALLABLE_TYPES.has(s.type))) {
+                            noteUnverified(siteId, call, 'possible-dispatch');
+                        } else {
+                            noteSite(siteId, 'external', null, call);
+                        }
+                        continue;
+                    }
                     const typeName = call.receiverType || fieldHopType;
                     const symbols = index.symbols.get(call.name);
                     const isCallableRT = (s) => !NON_CALLABLE_TYPES.has(s.type) ||
                         (s.type === 'field' && s.fieldType && /^func\b/.test(s.fieldType));
-                    let match = symbols?.find(s =>
+                    const onClassRT = (cls) => (symbols || []).filter(s =>
                         isCallableRT(s) && (
-                        (s.receiver && s.receiver.replace(/^\*/, '') === typeName) ||
-                        s.className === typeName));
+                        (s.receiver && s.receiver.replace(/^\*/, '') === cls) ||
+                        s.className === cls));
+                    // Same-class overload selection by static call shape (fix #268)
+                    let sel = _calleeOverloadSelect(index, call, onClassRT(typeName), language);
                     // Walk embedding/inheritance chain if no direct match (nominal type systems)
-                    if (!match && langTraits(language)?.typeSystem === 'nominal') {
+                    if (!sel.match && !sel.ambiguous && langTraits(language)?.typeSystem === 'nominal') {
                         const parentNames = index._getInheritanceParents?.(typeName, def.file);
                         if (parentNames) {
                             for (const pName of parentNames) {
-                                match = symbols?.find(s =>
-                                    isCallableRT(s) && (
-                                    (s.receiver && s.receiver.replace(/^\*/, '') === pName) ||
-                                    s.className === pName));
-                                if (match) break;
+                                sel = _calleeOverloadSelect(index, call, onClassRT(pName), language);
+                                if (sel.match || sel.ambiguous) break;
                             }
                         }
                     }
+                    if (sel.ambiguous) {
+                        noteUnverified(siteId, call, 'overload-ambiguous');
+                        continue;
+                    }
+                    const match = sel.match;
                     if (match) {
                         const key = match.bindingId || `${typeName}.${call.name}`;
                         const existing = callees.get(key);
@@ -2875,55 +3271,99 @@ function findCallees(index, def, options = {}) {
                         noteSite(siteId, 'external', null, call);
                         continue;
                     }
+                    // An ATTEMPTED field hop that resolves to a type defining
+                    // no such member never falls through to name/binding
+                    // resolution (fix #268 — the #265(C) rule, callee
+                    // direction: `mx.pool.Get()` hop-missed and the same-file
+                    // Mux.Get binding confirmed it). Zero-candidate names are
+                    // external (#261); anything else stays visible.
+                    if (fieldHopType) {
+                        if (_calleeZeroCandidateName(index, call)) {
+                            noteSite(siteId, 'external', null, call);
+                        } else {
+                            noteUnverified(siteId, call, 'uncertain-receiver');
+                        }
+                        continue;
+                    }
                     // No match found with inferred type — fall through to include as unresolved
-                } else if (goImportModule) {
-                    // Go package-qualified calls: klog.Infof(), wait.UntilWithContext()
-                    // The receiver is an import alias (resolved above) — find
-                    // definitions from that package.
-                    const importModule = goImportModule;
-                    {
-                        // Receiver is an import alias — resolve to definitions from that package
+                } else if (call.receiverCall && !call.receiver && !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).
+                    let chained = _foldChainedReceiverType(index, fileEntry, def.file, call, foldCtx());
+                    if (!chained || (!chained.type && !chained.externalVia)) {
+                        chained = _nominalChainedReceiverType(index, call, fileEntry, def.file);
+                    }
+                    if (chained?.type) {
                         const symbols = index.symbols.get(call.name);
-                        if (symbols) {
-                            // Match by checking if the definition's directory path matches the import path suffix.
-                            // Pick the symbol with the LONGEST suffix match to avoid false positives
-                            // (e.g., import "k8s.io/client-go/kubernetes/scheme" should prefer a definition
-                            // in .../client-go/kubernetes/scheme/ over one in .../kubeadm/scheme/).
-                            const importParts = importModule.split('/');
-                            let bestMatch = null;
-                            let bestMatchLen = 0;
-                            for (const s of symbols) {
-                                const sDir = path.dirname(s.relativePath || path.relative(index.root, s.file));
-                                for (let i = 0; i < importParts.length; i++) {
-                                    const suffix = importParts.slice(i).join('/');
-                                    if (sDir === suffix || sDir.endsWith('/' + suffix)) {
-                                        const matchLen = importParts.length - i;
-                                        if (matchLen > bestMatchLen) {
-                                            bestMatchLen = matchLen;
-                                            bestMatch = s;
-                                        }
-                                        break; // this symbol's best suffix found, try next
-                                    }
+                        const isCallableCh = (s) => !NON_CALLABLE_TYPES.has(s.type) ||
+                            (s.type === 'field' && s.fieldType && /^func\b/.test(s.fieldType));
+                        const onClassCh = (cls) => (symbols || []).filter(s =>
+                            isCallableCh(s) && (
+                            (s.receiver && s.receiver.replace(/^\*/, '') === cls) ||
+                            s.className === cls));
+                        let sel = _calleeOverloadSelect(index, call, onClassCh(chained.type), language);
+                        if (!sel.match && !sel.ambiguous) {
+                            const parentNames = index._getInheritanceParents?.(chained.type, def.file);
+                            if (parentNames) {
+                                for (const pName of parentNames) {
+                                    sel = _calleeOverloadSelect(index, call, onClassCh(pName), language);
+                                    if (sel.match || sel.ambiguous) break;
                                 }
                             }
-                            const match = bestMatch;
-                            if (match) {
-                                const key = match.bindingId || `${call.receiver}.${call.name}`;
-                                const existing = callees.get(key);
-                                if (existing) {
-                                    existing.count += 1;
-                                    if (collectAccount) { existing.sites.push(call.line); existing.siteIds.push(siteId); }
-                                } else {
-                                    callees.set(key, { name: call.name, bindingId: match.bindingId, count: 1,
-                                        ...(collectAccount && { sites: [call.line], siteIds: [siteId] }) });
-                                }
-                                continue;
+                        }
+                        if (sel.match) {
+                            const match = sel.match;
+                            const key = match.bindingId || `${chained.type}.${call.name}`;
+                            const existing = callees.get(key);
+                            if (existing) {
+                                existing.count += 1;
+                                if (collectAccount) { existing.sites.push(call.line); existing.siteIds.push(siteId); }
+                            } else {
+                                callees.set(key, { name: call.name, bindingId: match.bindingId, count: 1,
+                                    ...(collectAccount && { sites: [call.line], siteIds: [siteId] }) });
                             }
+                            continue;
+                        }
+                        if (sel.ambiguous) {
+                            noteUnverified(siteId, call, 'overload-ambiguous');
+                            continue;
                         }
-                        // Import resolved but no project definition matches — external call, skip
+                    }
+                    if (_calleeZeroCandidateName(index, call)) {
                         noteSite(siteId, 'external', null, call);
+                    } else if (chained?.externalVia) {
+                        noteUnverified(siteId, call, 'possible-dispatch');
+                    } else {
+                        noteUnverified(siteId, call, 'uncertain-receiver');
+                    }
+                    continue;
+                } else if (goImportModule) {
+                    // Go package-qualified calls: klog.Infof(), wait.UntilWithContext()
+                    // The receiver is an import alias (resolved above) — find
+                    // definitions from that package.
+                    const match = _calleeGoPackageMatch(index, call, goImportModule);
+                    if (match) {
+                        const key = match.bindingId || `${call.receiver}.${call.name}`;
+                        const existing = callees.get(key);
+                        if (existing) {
+                            existing.count += 1;
+                            if (collectAccount) { existing.sites.push(call.line); existing.siteIds.push(siteId); }
+                        } else {
+                            callees.set(key, { name: call.name, bindingId: match.bindingId, count: 1,
+                                ...(collectAccount && { sites: [call.line], siteIds: [siteId] }) });
+                        }
                         continue;
                     }
+                    // Import resolved but no project definition matches — external call, skip
+                    noteSite(siteId, 'external', null, call);
+                    continue;
                 } else if (typeQual) {
                     // Type-qualified receiver (fix #236): the receiver NAMES a
                     // type, so the type owns the call — Foo::new() is Foo's
@@ -3030,14 +3470,19 @@ function findCallees(index, def, options = {}) {
             let uncertainReason = null; // account-mode reason for the unverified bucket
             if (!call.bindingId && fileEntry?.bindings) {
                 let bindings = fileEntry.bindings.filter(b => b.name === call.name);
-                // For Go, also check sibling files in same directory (same package scope)
+                // For Go, also check sibling files in same directory (same
+                // package scope). dirToFiles is rebuilt on every build and
+                // cache load in canonical path order — the same iteration
+                // order as the full index.files scan it replaces (this loop
+                // runs per zero-binding call record, so the full scan was
+                // quadratic on large repos — 1037-file grpc-go measured).
                 if (bindings.length === 0 && langTraits(language)?.packageScope === 'directory') {
                     const dir = path.dirname(def.file);
-                    for (const [fp, fe] of index.files) {
-                        if (fp !== def.file && path.dirname(fp) === dir) {
-                            const sibling = (fe.bindings || []).filter(b => b.name === call.name);
-                            bindings = bindings.concat(sibling);
-                        }
+                    for (const fp of index.dirToFiles?.get(dir) || []) {
+                        if (fp === def.file) continue;
+                        const fe = index.files.get(fp);
+                        const sibling = (fe?.bindings || []).filter(b => b.name === call.name);
+                        if (sibling.length > 0) bindings = bindings.concat(sibling);
                     }
                 }
                 // Method call with no binding for the method name:
@@ -3252,6 +3697,14 @@ function findCallees(index, def, options = {}) {
             }
 
             if (isUncertain) {
+                if (_calleeZeroCandidateName(index, call)) {
+                    // fix #261: zero project definitions of the name — the
+                    // unverified band exists to keep POSSIBLE project edges
+                    // visible, and with no def anywhere no edge is possible.
+                    // Same verdict the symbol-table check gives bare names.
+                    noteSite(siteId, 'external', null, call);
+                    continue;
+                }
                 if (collectAccount) {
                     // Contract mode: uncertain callee edges are never silently
                     // dropped NOR silently confirmed — visible unverified
@@ -3295,6 +3748,13 @@ function findCallees(index, def, options = {}) {
         if (selfAttrCalls && def.className && options.includeMethods !== false) {
             const attrTypes = getInstanceAttributeTypes(index, def.file, def.className);
             for (const { call, siteId } of selfAttrCalls) {
+                    // fix #261: `self.items.append(x)` — a method name with
+                    // zero project defs cannot resolve to project code no
+                    // matter what the attribute's type turns out to be.
+                    if (_calleeZeroCandidateName(index, call)) {
+                        noteSite(siteId, 'external', null, call);
+                        continue;
+                    }
                     let targetClass = attrTypes ? attrTypes.get(call.selfAttribute) : null;
                     // Unique method heuristic: if attr type unknown but method exists on exactly one class
                     if (!targetClass) {
@@ -3337,6 +3797,7 @@ function findCallees(index, def, options = {}) {
             // claim the sites so the account stays conserved.
             for (const { call, siteId } of selfAttrCalls) {
                 if (options.includeMethods === false) noteSite(siteId, 'filtered', 'method-calls-excluded', call);
+                else if (_calleeZeroCandidateName(index, call)) noteSite(siteId, 'external', null, call);
                 else noteUnverified(siteId, call, 'self-attr-unresolved');
             }
         }
@@ -3347,7 +3808,13 @@ function findCallees(index, def, options = {}) {
         if (selfMethodCalls && def.className && options.includeMethods !== false) {
             for (const { call, siteId } of selfMethodCalls) {
                 const symbols = index.symbols.get(call.name);
-                if (!symbols) { noteUnverified(siteId, call, 'inherited-unresolved'); continue; }
+                if (!symbols || symbols.length === 0) {
+                    // fix #261: `this.push(x)` in a class extending a builtin
+                    // (or an external base) — zero project defs of the name
+                    // means the inherited method is external, not unresolved.
+                    noteSite(siteId, 'external', null, call);
+                    continue;
+                }
 
                 // For super().method(), skip same-class — start from parent
                 let match = call.receiver === 'super'
@@ -3394,6 +3861,7 @@ function findCallees(index, def, options = {}) {
         } else if (selfMethodCalls && collectAccount) {
             for (const { call, siteId } of selfMethodCalls) {
                 if (options.includeMethods === false) noteSite(siteId, 'filtered', 'method-calls-excluded', call);
+                else if (_calleeZeroCandidateName(index, call)) noteSite(siteId, 'external', null, call);
                 else noteUnverified(siteId, call, 'inherited-unresolved');
             }
         }
@@ -4073,6 +4541,13 @@ function _resolveFlowTypeOrigin(index, producerFile, typeName, qualifier) {
         const imported = typeDefs.filter(d => imports.has(d.file));
         if (imported.length === 1) return { fromFile: imported[0].file };
     }
+    // Re-export chains (fix #258, the #209 lesson brought to identity
+    // resolution): `use clap::Command` lands the import edge on the crate's
+    // lib.rs, not the type's defining file — chase bounded re-export hops
+    // (depth 4) and pin only when exactly ONE same-name type is reachable.
+    const reachable = typeDefs.filter(d =>
+        _importReaches(index, producerFile, new Set([d.file])));
+    if (reachable.length === 1) return { fromFile: reachable[0].file };
     return null;
 }
 
@@ -4135,6 +4610,39 @@ const BUILTIN_RECEIVER_TYPES = new Set([
     'string', 'number', 'boolean', 'bigint', 'symbol',
 ]);
 
+// Universal-contract method names (fix #265, hono-measured: 183 untyped
+// `x.toString()` calls confirmed against JSXNode.toString via the single-
+// owner rule): names EVERY value satisfies through the language's root
+// object — Object.prototype (JS/TS), java.lang.Object (Java), object's
+// dunders (Python, protocol names by construction). Unique project
+// ownership of such a name is not identity evidence for a receiver-
+// evidence-free call — the #210 external-contract physics without needing
+// an override marker, because overriding these IS overriding the external
+// root. Demote-only (possible-dispatch); typed/validated/same-class
+// receivers keep normal physics. Go has no universal root; Rust's
+// trait-provided universals (to_string via Display) carry #210 markers.
+const _UNIVERSAL_METHOD_NAMES_JS = new Set([
+    'toString', 'toLocaleString', 'valueOf', 'hasOwnProperty',
+    'isPrototypeOf', 'propertyIsEnumerable',
+]);
+const _UNIVERSAL_METHOD_NAMES_JAVA = new Set([
+    'toString', 'equals', 'hashCode', 'getClass', 'clone',
+    'notify', 'notifyAll', 'wait', 'finalize',
+]);
+function _universalMethodName(language, name) {
+    if (language === 'python') return /^__[A-Za-z0-9_]+__$/.test(name);
+    if (language === 'java') return _UNIVERSAL_METHOD_NAMES_JAVA.has(name);
+    if (['javascript', 'typescript', 'tsx', 'html'].includes(language)) {
+        return _UNIVERSAL_METHOD_NAMES_JS.has(name);
+    }
+    return false;
+}
+function _universalRootName(language) {
+    if (language === 'python') return 'object';
+    if (language === 'java') return 'Object';
+    return 'Object.prototype';
+}
+
 /**
  * Can this receiverType justify EXCLUDING a caller (structural languages)?
  * True for builtins and names that resolve to a project class/struct — types
@@ -4388,11 +4896,22 @@ function _projectTopLevelNames(index) {
     if (index._projectTopLevelNames) return index._projectTopLevelNames;
     const names = new Set();
     for (const [, fe] of index.files) {
-        const seg = (fe.relativePath || '').split(/[\\/]/)[0];
+        const segs = (fe.relativePath || '').split(/[\\/]/);
+        const seg = segs[0];
         if (!seg) continue;
         names.add(seg);
         const dot = seg.lastIndexOf('.');
         if (dot > 0) names.add(seg.slice(0, dot)); // utils.py → utils
+        // PEP-517 src layout (fix #269): packages under a top-level src/
+        // are importable by their SECOND segment — `import click` names
+        // src/click. Without this, the externality test proved the
+        // project's own package external (a resolver gap is not exclusion
+        // evidence, #209).
+        if (seg === 'src' && segs[1]) {
+            names.add(segs[1]);
+            const d2 = segs[1].lastIndexOf('.');
+            if (d2 > 0) names.add(segs[1].slice(0, d2));
+        }
     }
     index._projectTopLevelNames = names;
     return names;
@@ -4586,23 +5105,206 @@ function _shareProjectDescendant(index, className, targetClasses) {
  * classes disagree, or the type is a trait/interface (dynamic dispatch —
  * a trait-typed field is not evidence against any implementor).
  */
-function _declaredFieldType(index, rootType, fieldName, language) {
+/**
+ * Overload-signature identity (fix #265, zustand-measured): TS overload
+ * signatures and their implementation — and Python @overload stubs and their
+ * body — declare ONE function: `export function useStore(a): T;` ×2 plus the
+ * implementation are the same symbol, so a call binding any member IS a call
+ * to the pinned one (the #208 alias-identity principle for callables).
+ * Closes the pin over same-file, same-class, same-nesting callable defs when
+ * the group contains a signature — the overload idiom's proof. Plain
+ * same-name redefinition (JS rebinding, Python last-wins shadowing) has no
+ * signature member and never closes. `definitions` is the same-name def list,
+ * so the group key needs no name component.
+ */
+function _closeOverloadGroup(targetDefs, definitions) {
+    const keyOf = (d) => `${d.file}\0${d.className || ''}\0${d.isNested ? 1 : 0}`;
+    const groups = new Map();
+    for (const d of definitions) {
+        if (NON_CALLABLE_TYPES.has(d.type)) continue;
+        const k = keyOf(d);
+        if (!groups.has(k)) groups.set(k, []);
+        groups.get(k).push(d);
+    }
+    let expanded = null;
+    for (const t of targetDefs) {
+        const group = groups.get(keyOf(t));
+        if (!group || group.length <= 1 || !group.some(d => d.isSignature)) continue;
+        for (const d of group) {
+            if (targetDefs.includes(d) || (expanded && expanded.includes(d))) continue;
+            if (!expanded) expanded = [...targetDefs];
+            expanded.push(d);
+        }
+    }
+    return expanded || targetDefs;
+}
+
+/**
+ * Pure-alias base resolution (fix #265 — the #208 identity for declared
+ * types): when EVERY type-kind definition of a name is an alias agreeing on
+ * one base, the name IS the base type (`type StoreMap = Map<...>` types a
+ * `store: StoreMap` field as Map). Chases alias-of-alias chains bounded and
+ * cycle-guarded; mixed or disagreeing names never resolve.
+ */
+function _pureAliasBase(index, typeName) {
+    let current = typeName;
+    const seen = new Set([current]);
+    for (let hop = 0; hop < 4; hop++) {
+        const defs = index.symbols.get(current);
+        if (!defs || defs.length === 0) return current === typeName ? null : current;
+        let base = null;
+        for (const d of defs) {
+            if (d.type !== 'type' && !IDENTITY_TYPE_KINDS.has(d.type)) continue;
+            if (d.type === 'type' && d.aliasOf) {
+                if (base === null) base = d.aliasOf;
+                else if (base !== d.aliasOf) return null; // disagreeing aliases
+            } else {
+                // a real type of this name exists — the name is not purely an alias
+                return current === typeName ? null : current;
+            }
+        }
+        if (!base) return current === typeName ? null : current;
+        if (seen.has(base)) return null; // cycle
+        seen.add(base);
+        current = base;
+    }
+    return current;
+}
+
+// Does the qualifier of a Go pkg.Type field annotation name one of the
+// declaring file's imports? (last-segment match, version-suffix aware —
+// the goImportModule convention.) Presence + no project resolution above
+// makes the field's type provably external (fix #268).
+function _goQualifierNamesImport(index, fieldFile, qualifier) {
+    const fe = index.files.get(fieldFile);
+    if (!fe || !Array.isArray(fe.imports)) return false;
+    return fe.imports.some(mod => {
+        const parts = String(mod).split('/');
+        const last = parts[parts.length - 1];
+        const pkgName = (/^v\d+$/.test(last) && parts.length > 1) ? parts[parts.length - 2] : last;
+        return pkgName === qualifier;
+    });
+}
+
+// Same-class overload selection, callee direction (fix #268, jsoup-measured:
+// all 71 tb.process sites confirmed to the 1-arg overload — the .find()
+// pick was defs[0] in canonical order). Arity narrows first; Java argKinds
+// refine same-arity families; exactly one survivor binds, anything else is
+// statically undecidable and routes visible.
+// Resolve a Go package-qualified call to a definition in the imported
+// package (dir-path suffix match against the import path; LONGEST suffix
+// wins so import "k8s.io/client-go/kubernetes/scheme" prefers a def in
+// .../kubernetes/scheme/ over .../kubeadm/scheme/). Extracted for reuse:
+// the parser marks some package calls isMethod:false (fix #268).
+function _calleeGoPackageMatch(index, call, importModule) {
+    const symbols = index.symbols.get(call.name);
+    if (!symbols) return null;
+    // Self-module imports (fix #268, cobra-measured — the #220(8) go.mod
+    // identity): `import "github.com/spf13/cobra"` from doc/ names the
+    // module's ROOT package, whose relative dir is '.' and can never
+    // path-suffix-match the import string. Compose the effective package
+    // dir from the module line (nested subpackage paths compose too).
+    const goMod = findGoModule(index.root);
+    if (goMod && goMod.modulePath &&
+        (importModule === goMod.modulePath || importModule.startsWith(goMod.modulePath + '/'))) {
+        const sub = importModule === goMod.modulePath ? '.' :
+            importModule.slice(goMod.modulePath.length + 1);
+        const selfMatch = symbols.find(s => {
+            const sDir = path.dirname(s.relativePath || path.relative(index.root, s.file));
+            return sDir === sub;
+        });
+        if (selfMatch) return selfMatch;
+    }
+    const importParts = importModule.split('/');
+    let bestMatch = null;
+    let bestMatchLen = 0;
+    for (const s of symbols) {
+        const sDir = path.dirname(s.relativePath || path.relative(index.root, s.file));
+        for (let i = 0; i < importParts.length; i++) {
+            const suffix = importParts.slice(i).join('/');
+            if (sDir === suffix || sDir.endsWith('/' + suffix)) {
+                const matchLen = importParts.length - i;
+                if (matchLen > bestMatchLen) {
+                    bestMatchLen = matchLen;
+                    bestMatch = s;
+                }
+                break; // this symbol's best suffix found, try next
+            }
+        }
+    }
+    return bestMatch;
+}
+
+function _calleeOverloadSelect(index, call, matches, language) {
+    if (matches.length <= 1) return { match: matches[0] || null };
+    if (call.argCount == null || call.argSpread) return { ambiguous: true };
+    const fits = matches.filter(d => _callArityCompatible(call, [d], language));
+    if (fits.length === 1) return { match: fits[0] };
+    if (fits.length === 0) return { match: null }; // fits nothing we model — no claim
+    const applicable = fits.filter(d => _overloadApplicable(index, call, d));
+    if (applicable.length === 1) return { match: applicable[0] };
+    return { ambiguous: true };
+}
+
+function _declaredFieldType(index, rootType, fieldName, language, info) {
     const defs = index.symbols.get(fieldName);
     if (!defs) return null;
     // 'private field' (JS #-fields, fix #219): equally compiler-true, and
-    // safer — nothing outside the class can rebind them.
+    // safer — nothing outside the class can rebind them. Getters and Python
+    // @property members (fix #265, hono-measured: Context.req is `get req():
+    // HonoRequest`) type the hop through their declared RETURN annotation —
+    // the same compiler-checked evidence in accessor clothing; the annotation
+    // is what the member-access expression evaluates to (value position).
+    const isAccessor = (d) => d.type === 'get' || d.memberType === 'get' ||
+        d.type === 'property' || d.memberType === 'property';
     const fields = defs.filter(d =>
-        (d.type === 'field' || d.memberType === 'field' || d.memberType === 'private field') &&
-        d.className === rootType && d.fieldType);
-    if (fields.length === 0) return null;
+        ((d.type === 'field' || d.memberType === 'field' || d.memberType === 'private field') && d.fieldType) ||
+        (isAccessor(d) && d.returnType));
+    const onType = fields.filter(d => d.className === rootType);
+    if (onType.length === 0) return null;
     const normalized = new Set();
-    for (const f of fields) {
-        const t = _normalizeFieldTypeName(f.fieldType, language);
+    for (const f of onType) {
+        const rawText = isAccessor(f) ? f.returnType : 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
+        // project class that happens to share the bare name (an _examples
+        // type named Handler confirmed mx.handler.ServeHTTP). Go only —
+        // its pkg.Type field shape carries a checkable qualifier; Rust/Java
+        // qualified heads keep their current physics (no measured family).
+        if (language === 'go' && f.file) {
+            const qm = String(rawText).trim().replace(/^\*+/, '')
+                .match(/^([A-Za-z_]\w*)\.([A-Za-z_]\w*)$/);
+            if (qm) {
+                const [, qualifier, bare] = qm;
+                const hasProjectType = (index.symbols.get(bare) || [])
+                    .some(d => IDENTITY_TYPE_KINDS.has(d.type));
+                const origin = hasProjectType &&
+                    _resolveFlowTypeOrigin(index, f.file, bare, qualifier);
+                if (origin && origin.fromFile) { normalized.add(bare); continue; }
+                // The qualifier names an import that resolves to no project
+                // type — the field's type is provably external. Surfaced via
+                // `info` so the callee side can route external/visible; the
+                // head stays null (never bare-name identity, demote-only).
+                if (info && _goQualifierNamesImport(index, f.file, qualifier)) {
+                    info.externalVia = `${qualifier}.${bare}`;
+                }
+                return null;
+            }
+        }
+        const t = _normalizeFieldTypeName(rawText, language);
         if (t) normalized.add(t);
         else return null; // any un-normalizable declaration → no evidence
     }
     if (normalized.size !== 1) return null; // same-named classes disagree
-    const typeName = [...normalized][0];
+    let typeName = [...normalized][0];
+    // Pure-alias heads resolve to their base (fix #265 — the #208 identity
+    // for declared types): `store: StoreMap` where `type StoreMap = Map<...>`
+    // types the field as Map, which the trust gate can judge (builtin →
+    // exclusion-grade; a project-class base validates normally). Mixed or
+    // disagreeing alias names stay as-is and fail the trust gate downstream.
+    const aliasBase = _pureAliasBase(index, typeName);
+    if (aliasBase) typeName = aliasBase;
     // Generic type parameters by convention (T, K, V1 — fix #220,
     // cursive-measured): `view: T` declares the field as WHATEVER the
     // instantiation chose — not a type identity. Without this, the hop
@@ -4916,6 +5618,34 @@ function _calleeReceiverTypeRoute(index, call, localTypes, language) {
     return { uncertain: true }; // known non-builtin type with no project method
 }
 
+/**
+ * Zero-candidate call names (fix #261): a call whose name has ZERO
+ * definitions anywhere in the index cannot be a project call — there is no
+ * def an edge could land on. The confirmed path already gives bare names
+ * this exact verdict (the symbol-table check routes them external); method
+ * calls were diverted to the unverified band by receiver uncertainty FIRST,
+ * so `parts.push(...)` / `names.join(...)` sat as [unverified]
+ * uncertain-receiver noise in every trace. Dynamic property assignment does
+ * not defeat this: `obj.push = function() {...}` indexes a def named `push`
+ * (property-assignment naming, all shapes — probed), so any project that
+ * dynamically defines the method keeps its calls visible; a monkey-patched
+ * alias of an EXISTING function (`Foo.push = helper`) surfaces its edge at
+ * the assignment site as a function reference of `helper` (fix #221/#252),
+ * never at the invocation. Checks every name the call could resolve to
+ * (parser alias resolution).
+ */
+function _calleeZeroCandidateName(index, call) {
+    const names = [call.name];
+    if (call.resolvedName) names.push(call.resolvedName);
+    if (call.resolvedNames) names.push(...call.resolvedNames);
+    for (const n of names) {
+        if (!n) continue;
+        const defs = index.symbols.get(n);
+        if (defs && defs.length > 0) return false;
+    }
+    return true;
+}
+
 function _calleeSingleOwnerMatch(index, def, fileEntry, call, name, language, flowEntry) {
     if (JS_GLOBAL_RECEIVERS.has(call.receiver)) return null;
     if (call.receiverIsModule) return null;
@@ -5089,6 +5819,38 @@ function _overloadDiscipline(index, call, targetDefs, definitions) {
     if (targetOwners.size === 0) return null;
     const family = definitions.filter(d => !NON_CALLABLE_TYPES.has(d.type) &&
         d.className && targetOwners.has(d.className));
+    // Inherited sibling overloads (fix #268, javapoet-measured): the pin's
+    // dispatch surface includes ancestor same-name methods — ClassName's
+    // annotated(List) coexists with TypeName's FINAL annotated(Spec...), and
+    // a 1-arg call may bind either; receiver-hint evidence said "some
+    // annotated overload", not the pinned one (the #205 jdtls lesson).
+    // Identical type signatures in an ancestor are the OVERRIDE SLOT the pin
+    // occupies — the same virtual method, never a sibling.
+    const typeSig = (d) => Array.isArray(d.paramsStructured)
+        ? d.paramsStructured.map(p => String(p?.type ?? '').replace(/\s+/g, '')).join(',')
+        : null;
+    const pinSigs = new Set(targetDefs.map(typeSig).filter(s => s !== null));
+    const pinFile = targetDefs.find(d => d.file)?.file;
+    const seenCls = new Set(targetOwners);
+    const queue = [...targetOwners];
+    let hops = 0;
+    while (queue.length > 0 && hops++ < 32) {
+        const cls = queue.pop();
+        const parents = index._getInheritanceParents?.(cls, pinFile);
+        if (!parents) continue;
+        for (const p of parents) {
+            const pName = typeof p === 'string' ? p : p?.name;
+            if (!pName || seenCls.has(pName)) continue;
+            seenCls.add(pName);
+            queue.push(pName);
+            for (const d of definitions) {
+                if (NON_CALLABLE_TYPES.has(d.type) || d.className !== pName) continue;
+                const sig = typeSig(d);
+                if (sig !== null && pinSigs.has(sig)) continue; // override slot
+                family.push(d);
+            }
+        }
+    }
     if (family.length <= 1) return null;
     const pinnedKeys = new Set(targetDefs.map(d => `${d.file}:${d.startLine}`));
     if (family.every(d => pinnedKeys.has(`${d.file}:${d.startLine}`))) return null;
@@ -5626,6 +6388,348 @@ function _chainedReceiverType(index, call, language) {
     return head;
 }
 
+// ── Chained-receiver fold (fix #258, clap-measured) ─────────────────────────
+// Builder chains (`Command::new("x").author(a).arg(b).arg(c)`) defeat the
+// one-hop agreement rules: `arg` has two owners (Command and ArgGroup), both
+// returning `Self` — which resolves to DIFFERENT types, so project-wide
+// agreement fails and 1600+ oracle-true clap edges sat method-ambiguous.
+// The fold types the chain hop by hop from a typed root instead: the parser
+// links each chained call to its producer's OWN record (receiverCallLine),
+// the root types via the existing #207 producer rails (path/static/package-
+// qualified producers, annotated variables, module-qualified roots), and each
+// hop resolves the producer method ON THE CURRENT TYPE — `Self`/`this` map to
+// that type, a hop returning a different type re-roots the chain there, and
+// any unresolvable hop (missing annotation, foreign same-name type, sibling
+// disagreement) stops the fold: untyped, visible, honest. Per-hop identity
+// keeps the #206/#207 discipline (owner defs co-located with the pinned type
+// when the type name is ambiguous project-wide; origins re-pinned from the
+// defining file). Results feed the existing receiverType machinery — the
+// fold adds evidence, never new routing.
+
+const _FOLD_TYPE_KINDS = new Set(['class', 'struct', 'enum', 'trait', 'interface', 'record', 'type', 'namespace']);
+
+/**
+ * Resolve method `methodName` on type `typeName` (identity-pinned to
+ * `fromFile` when known) and return its resolved return-type head as
+ * { type, fromFile } — or null when the resolution is not compiler-grade.
+ * Walks declared ancestors (bounded) when the type itself doesn't define the
+ * method; `Self`/`this` return annotations resolve to the RECEIVER's type
+ * (dynamic-Self semantics — sound because the chain's static type is T).
+ */
+function _methodReturnOnType(index, typeName, fromFile, methodName, language, opts = {}) {
+    const nominal = langTraits(language)?.typeSystem === 'nominal';
+    const norm = s => (s || '').replace(/^\*/, '').replace(/\[.*$/, '').replace(/<.*$/, '');
+    const depth = opts.depth || 0;
+    if (depth > 8) return null;
+    const all = (index.symbols.get(methodName) || [])
+        .filter(d => !NON_CALLABLE_TYPES.has(d.type));
+    let owned = all.filter(d =>
+        (d.className && norm(d.className) === typeName) ||
+        (!d.className && d.receiver && norm(d.receiver) === typeName));
+    // Identity discipline (#206c): with several same-name TYPES in the
+    // project, an owner-name match is only THE type when co-located with the
+    // pinned defining file; with no pin, refuse.
+    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 (owned.length === 0) {
+        // Inheritance walk: resolve on a declared ancestor; Self/this still
+        // resolve to the RECEIVER's type (passed through selfType).
+        const ctxFile = fromFile || opts.filePath;
+        const parents = index._getInheritanceParents
+            ? (index._getInheritanceParents(typeName, ctxFile) || []) : [];
+        for (const parent of parents) {
+            const pFile = index._resolveClassFile
+                ? (index._resolveClassFile(parent, ctxFile) || undefined) : undefined;
+            const up = _methodReturnOnType(index, norm(parent), pFile, methodName, language, {
+                ...opts, depth: depth + 1, selfType: opts.selfType || typeName,
+            });
+            if (up) return up;
+        }
+        return null;
+    }
+    const selfType = opts.selfType || typeName;
+    if (nominal) {
+        if (!owned.every(d => d.returnType)) return null;
+        if (new Set(owned.map(d => d.returnType)).size !== 1) return null;
+        const def = owned[0];
+        const parsed = _returnTypeNameNominal(def.returnType, language, { selfClass: selfType });
+        if (!parsed) return null;
+        const origin = _resolveFlowTypeOrigin(index, def.file || opts.filePath, parsed.name, parsed.qualifier);
+        if (!origin) return null;
+        return { type: parsed.name, ...(origin.fromFile && { fromFile: origin.fromFile }) };
+    }
+    // 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;
+    const heads = new Set();
+    for (const d of owned) {
+        if (!d.returnType) return null;
+        let h = _structuralTypeHead(d.returnType, { unwrapAsync: opts.consumerAwaited });
+        if (h === 'this' || h === 'Self') h = selfType;
+        if (!h) return null;
+        heads.add(h);
+        if (heads.size > 1) return null;
+    }
+    const head = [...heads][0];
+    if (/^[A-Z][A-Z0-9]?$/.test(head)) return null; // generic type param
+    if (_STRUCTURAL_FLOW_REJECT.has(head)) return null;
+    return { type: head };
+}
+
+/**
+ * Type of the VALUE a call record produces — { type, fromFile },
+ * { externalVia } (compiler-grade evidence the value was typed outside the
+ * project), or null. Mirrors the #207 flow-map producer rails per shape, and
+ * recurses through the producer link for chained producers (memoized,
+ * cycle-guarded).
+ */
+function _typeOfCallResultFold(index, fileEntry, filePath, record, ctx, consumerAwaited) {
+    if (ctx.memo.has(record)) return ctx.memo.get(record);
+    if (ctx.visiting.has(record) || ctx.visiting.size > 64) return null;
+    ctx.visiting.add(record);
+    let out = null;
+    try {
+        out = _typeOfCallResultFoldInner(index, fileEntry, filePath, record, ctx, consumerAwaited);
+    } finally {
+        ctx.visiting.delete(record);
+    }
+    ctx.memo.set(record, out);
+    return out;
+}
+
+function _typeOfCallResultFoldInner(index, fileEntry, filePath, record, ctx, consumerAwaited) {
+    if (record.isMacro || record.inMacro) return null; // token-tree records carry no chain physics
+    const language = fileEntry.language;
+    const traits = langTraits(language);
+    const nominal = traits?.typeSystem === 'nominal';
+    const name = record.name;
+
+    // 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
+    // is pinned from THIS file's scope (#206 discipline — clap's derive
+    // tests define dozens of local `struct Command` fixtures; the pin keeps
+    // the fold on the imported one).
+    if (nominal && record.isPathCall && record.receiver) {
+        const segs = String(record.receiver).split('::');
+        let seg = segs.pop();
+        if (seg === 'Self') {
+            const enclosing = index.findEnclosingFunction(filePath, record.line, true);
+            seg = enclosing && enclosing.className;
+            if (!seg) return null;
+        }
+        if (!seg || !/^[A-Z]/.test(seg)) return null;
+        if (/^[A-Z][A-Z0-9]?$/.test(seg)) return null; // generic-param convention (#220)
+        const qual = segs.length > 0 ? segs[segs.length - 1] : undefined;
+        const origin = _resolveFlowTypeOrigin(index, filePath, seg,
+            qual && !['crate', 'self', 'super'].includes(qual) ? qual : undefined);
+        if (!origin) return null;
+        return _methodReturnOnType(index, seg, origin.fromFile, name, language,
+            { filePath, consumerAwaited });
+    }
+    // Java static factory: Config.parse(...) — static call style only (#206:
+    // a Go receiver named like a type is a VARIABLE).
+    if (nominal && record.isMethod && record.receiver && !record.receiverIsChainRoot &&
+        traits?.typeQualifiedCallStyle === 'static' && /^[A-Z]/.test(record.receiver) &&
+        !/^[A-Z][A-Z0-9]?$/.test(record.receiver)) {
+        const r = _methodReturnOnType(index, record.receiver, undefined, name, language,
+            { filePath, consumerAwaited });
+        if (r) return r;
+        // fall through: a capitalized Java receiver may still be a variable
+    }
+    // Go package-qualified plain producer: pkg.Get(...) — strict import
+    // resolution; unresolved packages typed the value OUTSIDE the project.
+    if (nominal && !record.isMethod && record.receiver && traits?.hasReceiverPackageCalls) {
+        const cands = (index.symbols.get(name) || [])
+            .filter(d => !NON_CALLABLE_TYPES.has(d.type) && d.returnType);
+        const inPkg = _qualifiedProducerDefs(index, fileEntry, record.receiver, cands);
+        if (!inPkg || inPkg.length === 0 || new Set(inPkg.map(d => d.returnType)).size !== 1) {
+            return { externalVia: `${record.receiver}.${name}` };
+        }
+        const def = inPkg[0];
+        const parsed = _returnTypeNameNominal(def.returnType, language, {});
+        if (!parsed) return null;
+        const origin = _resolveFlowTypeOrigin(index, def.file || filePath, parsed.name, parsed.qualifier);
+        if (!origin) return null;
+        return { type: parsed.name, ...(origin.fromFile && { fromFile: origin.fromFile }) };
+    }
+    // Structural module-qualified producer: z.string() — resolve through the
+    // file's import bindings (flow-map rails, incl. the #222 externality test).
+    if (!nominal && record.isMethod && record.receiver && record.receiverIsModule) {
+        const binding = (fileEntry?.importBindings || []).find(b => b.name === record.receiver);
+        const rel = binding && fileEntry.moduleResolved && fileEntry.moduleResolved[binding.module];
+        if (binding && !rel) {
+            const mod = String(binding.module);
+            const firstSeg = mod.split(/[./]/).filter(Boolean)[0];
+            if (!mod.startsWith('.') &&
+                !(firstSeg && _projectTopLevelNames(index).has(firstSeg))) {
+                return { externalVia: `${record.receiver}.${name}` };
+            }
+            return null;
+        }
+        if (!rel) return null;
+        const modFile = path.join(index.root, rel);
+        const cands = (index.symbols.get(name) || [])
+            .filter(d => !NON_CALLABLE_TYPES.has(d.type) && d.returnType && !d.className);
+        let matches = cands.filter(d => d.file === modFile);
+        if (matches.length === 0) {
+            const hop = index.importGraph.get(modFile);
+            if (hop) matches = cands.filter(d => hop.has(d.file));
+        }
+        if (matches.length === 0) return null;
+        if (language === 'python' && !consumerAwaited && matches.some(d => d.isAsync)) return null;
+        const heads = new Set();
+        for (const d of matches) {
+            const h = _structuralTypeHead(d.returnType, { unwrapAsync: consumerAwaited });
+            if (!h) return null;
+            heads.add(h);
+        }
+        if (heads.size !== 1) return null;
+        const head = [...heads][0];
+        if (/^[A-Z][A-Z0-9]?$/.test(head) || _STRUCTURAL_FLOW_REJECT.has(head)) return null;
+        return { type: head };
+    }
+    // self/this/cls receiver: resolve through the enclosing class (+ walk).
+    if (record.isMethod && ['self', 'this', 'cls'].includes(record.receiver)) {
+        const enclosing = index.findEnclosingFunction(filePath, record.line, true);
+        let cls = enclosing && enclosing.className;
+        let ctxFile = filePath;
+        const visited = new Set();
+        while (cls && !visited.has(cls)) {
+            visited.add(cls);
+            const r = _methodReturnOnType(index, cls, ctxFile, name, language,
+                { filePath, consumerAwaited, selfType: enclosing.className });
+            if (r) return r;
+            const parents = index._getInheritanceParents(cls, ctxFile) || [];
+            const next = parents[0];
+            if (next && index._resolveClassFile) {
+                ctxFile = index._resolveClassFile(next, ctxFile) || ctxFile;
+            }
+            cls = next;
+        }
+        return null;
+    }
+    // Method producer: type its OWN receiver (parser annotation → chain
+    // recursion → flow map), then resolve the method on that type. Falls back
+    // to the one-hop project-wide agreement rule when the receiver stays
+    // untyped.
+    if (record.isMethod) {
+        let rt = null;
+        if (record.receiverType && !record.receiverIsChainRoot) {
+            rt = { type: record.receiverType };
+        }
+        if (!rt && record.receiverCall && (!record.receiver || record.receiverIsChainRoot)) {
+            rt = _foldChainedReceiverType(index, fileEntry, filePath, record, ctx);
+        }
+        if (!rt && record.receiver && !record.receiverIsChainRoot) {
+            const flowMap = ctx.getFlowMap();
+            const fe = flowMap && _lookupReturnTypeFlow(flowMap, record);
+            if (fe && fe.externalVia) return { externalVia: fe.externalVia };
+            if (fe && fe.type) rt = { type: fe.type, ...(fe.fromFile && { fromFile: fe.fromFile }) };
+        }
+        if (rt && rt.externalVia) return rt;
+        if (rt && rt.type) {
+            return _methodReturnOnType(index, rt.type, rt.fromFile, name, language,
+                { filePath, consumerAwaited });
+        }
+        // One-hop agreement (the #207/#219 discipline, one level deeper):
+        // every method owner project-wide annotated and agreeing.
+        const methodDefs = (index.symbols.get(name) || [])
+            .filter(d => !NON_CALLABLE_TYPES.has(d.type) && (d.className || d.receiver));
+        if (methodDefs.length === 0) return null;
+        if (!methodDefs.every(d => d.returnType)) return null;
+        if (nominal) {
+            if (new Set(methodDefs.map(d => d.returnType)).size !== 1) return null;
+            const classes = new Set(methodDefs.map(d =>
+                d.className || (d.receiver || '').replace(/^\*/, '')));
+            const selfClass = classes.size === 1 ? [...classes][0] : undefined;
+            const parsed = _returnTypeNameNominal(methodDefs[0].returnType, language, { selfClass });
+            if (!parsed) return null;
+            const origin = _resolveFlowTypeOrigin(index, methodDefs[0].file || filePath, parsed.name, parsed.qualifier);
+            if (!origin) return null;
+            return { type: parsed.name, ...(origin.fromFile && { fromFile: origin.fromFile }) };
+        }
+        if (language === 'python' && !consumerAwaited && methodDefs.some(d => d.isAsync)) return null;
+        const heads = new Set();
+        for (const d of methodDefs) {
+            const h = _structuralTypeHead(d.returnType, { unwrapAsync: consumerAwaited });
+            if (!h) return null;
+            heads.add(h);
+            if (heads.size > 1) return null;
+        }
+        const head = [...heads][0];
+        if (/^[A-Z][A-Z0-9]?$/.test(head) || _STRUCTURAL_FLOW_REJECT.has(head)) return null;
+        return { type: head };
+    }
+    // Plain producer: Go same-package only; others unique-project-def with
+    // same-file narrowing; Java bare calls reach the enclosing class first.
+    if (traits?.bareCallReachesMethods) {
+        const enclosing = index.findEnclosingFunction(filePath, record.line, true);
+        if (enclosing?.className) {
+            const r = _methodReturnOnType(index, enclosing.className, filePath, name, language,
+                { filePath, consumerAwaited });
+            if (r) return r;
+        }
+    }
+    const defs = (index.symbols.get(name) || [])
+        .filter(d => !NON_CALLABLE_TYPES.has(d.type) && !(d.className || d.receiver));
+    let chosen = null;
+    if (traits?.packageScope === 'directory') {
+        const dir = path.dirname(filePath);
+        const samePkg = defs.filter(d => d.file && path.dirname(d.file) === dir);
+        if (samePkg.length === 1) chosen = samePkg[0];
+    } else if (defs.length === 1) {
+        chosen = defs[0];
+    } else {
+        const sameFile = defs.filter(d => d.file === filePath);
+        if (sameFile.length === 1) chosen = sameFile[0];
+    }
+    if (!chosen || !chosen.returnType) return null;
+    if (nominal) {
+        const parsed = _returnTypeNameNominal(chosen.returnType, language, {});
+        if (!parsed) return null;
+        const origin = _resolveFlowTypeOrigin(index, chosen.file || filePath, parsed.name, parsed.qualifier);
+        if (!origin) return null;
+        return { type: parsed.name, ...(origin.fromFile && { fromFile: origin.fromFile }) };
+    }
+    if (language === 'python' && !consumerAwaited && chosen.isAsync) return null;
+    let head = _structuralTypeHead(chosen.returnType, { unwrapAsync: consumerAwaited });
+    if (!head || /^[A-Z][A-Z0-9]?$/.test(head) || _STRUCTURAL_FLOW_REJECT.has(head)) return null;
+    return { type: head };
+}
+
+/**
+ * Type the RECEIVER of a chained call from its producer's own record
+ * (fix #258). Producer records are matched by (receiverCallLine, name) —
+ * when several match (one-line chains like `a.arg(1).arg(2)`), ALL must fold
+ * to the same type or the receiver stays untyped. Returns { type, fromFile },
+ * { externalVia }, or null (fall back to the legacy one-hop helpers).
+ */
+function _foldChainedReceiverType(index, fileEntry, filePath, call, ctx) {
+    if (!call.receiverCall || !call.receiverCallLine || !ctx.records) return null;
+    const prods = ctx.records.filter(r =>
+        r !== call && r.line === call.receiverCallLine && r.name === call.receiverCall &&
+        !r.isMacro && !r.inMacro &&
+        // Kind match: the consumer knows whether its producer was a method-
+        // shaped call — `.arg(arg("x"))` has both a chained method `arg` and
+        // a plain closure call `arg` on one line; only the right kind folds.
+        !!r.isMethod === !!call.receiverCallIsMethod);
+    if (prods.length === 0) return null;
+    const results = prods.map(r =>
+        _typeOfCallResultFold(index, fileEntry, filePath, r, ctx, call.receiverCallAwaited));
+    if (!results.every(Boolean)) return null;
+    if (results.every(r => r.externalVia)) return { externalVia: results[0].externalVia };
+    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));
+    return { type: results[0].type, ...(fromFiles.size === 1 && results[0].fromFile && { fromFile: results[0].fromFile }) };
+}
+
 /**
  * Is this field symbol callable by its own name (obj.f(...) reaches the
  * field's function value)? Arrow-function class fields are callable by
@@ -5647,6 +6751,9 @@ function _callableFieldDef(index, d) {
 
 function _buildTypedLocalTypeMap(index, def, calls) {
     const localTypes = new Map();
+    // Vars whose entry is a New*-prefix name GUESS (fix #266) — consumers may
+    // confirm through them but never exclude (convention, not compiler truth).
+    const guessedVars = new Set();
     let _cachedLines = null;
 
     for (const call of calls) {
@@ -5655,6 +6762,8 @@ function _buildTypedLocalTypeMap(index, def, calls) {
         // Collect receiverType from method calls (inferred by parser from params/receivers)
         if (call.isMethod && call.receiver && call.receiverType) {
             localTypes.set(call.receiver, call.receiverType);
+            if (call.receiverTypeGuessed) guessedVars.add(call.receiver);
+            else guessedVars.delete(call.receiver);
         }
 
         // Collect types from constructor calls: x := NewFoo() → x maps to Foo
@@ -5678,12 +6787,15 @@ function _buildTypedLocalTypeMap(index, def, calls) {
                 const typeName = assignMatch[2].slice(3);
                 if (typeName && /^[A-Z]/.test(typeName)) {
                     localTypes.set(assignMatch[1], typeName);
+                    guessedVars.add(assignMatch[1]); // name convention, not compiler truth (fix #266)
                 }
             }
         }
     }
 
-    return localTypes.size > 0 ? localTypes : null;
+    if (localTypes.size === 0) return null;
+    localTypes.guessedVars = guessedVars;
+    return localTypes;
 }
 
 /**