ucn 4.1.1 → 4.1.3

package/languages/go.js

@@ -678,6 +678,8 @@ function findCallsInCode(code, parser, options = {}) {
     const closureScopes = new Map();
     // Track variable -> type mappings per function scope (scopeStartLine -> Map<varName, typeName>)
     const scopeTypes = new Map();
+    // Names whose scope type is a New*-prefix GUESS (fix #266) — per scope
+    const scopeGuesses = new Map();
     // Track function-typed parameter names per scope (scopeStartLine -> Set<name>)
     const funcParamScopes = new Map();
 
@@ -822,6 +824,21 @@ function findCallsInCode(code, parser, options = {}) {
         }
         return undefined;
     };
+    // Is the FIRST scope-chain hit for this variable a New*-prefix GUESS
+    // (fix #266, viper-measured)? `registry := NewCodecRegistry()` types
+    // registry as 'CodecRegistry' by NAME CONVENTION — the actual return
+    // annotation says *DefaultCodecRegistry. Guess-grade types help
+    // resolution but must never be exclusion evidence; findCallers lets
+    // the compiler-checked return-type flow map override them.
+    const isGuessedType = (varName) => {
+        for (let i = functionStack.length - 1; i >= 0; i--) {
+            const typeMap = scopeTypes.get(functionStack[i].startLine);
+            if (typeMap?.has(varName)) {
+                return !!scopeGuesses.get(functionStack[i].startLine)?.has(varName);
+            }
+        }
+        return false;
+    };
 
     // fix #203 (Go): is a bare-identifier function REFERENCE shadowed by an
     // enclosing func-literal/function parameter, method receiver, range/init
@@ -957,6 +974,7 @@ function findCallsInCode(code, parser, options = {}) {
                     for (let vi = 0; vi < Math.min(names.length, values.length); vi++) {
                         const val = values[vi];
                         let typeName = null;
+                        let typeGuessed = false;
                         // &Type{...} or Type{...}
                         if (val.type === 'composite_literal') {
                             typeName = extractTypeName(val.childForFieldName('type'));
@@ -978,8 +996,14 @@ function findCallsInCode(code, parser, options = {}) {
                                         ? callFuncNode.childForFieldName('field')?.text
                                         : null;
                                 if (callName && /^New[A-Z]/.test(callName)) {
+                                    // NAME CONVENTION, not compiler truth (fix
+                                    // #266): NewCodecRegistry() returns
+                                    // *DefaultCodecRegistry. Marked a guess so
+                                    // the return-type flow map can override it
+                                    // and exclusions never trust it.
                                     typeName = callName.slice(3);
                                     if (!typeName || !/^[A-Z]/.test(typeName)) typeName = null;
+                                    if (typeName) typeGuessed = true;
                                 } else if (callFuncNode.type === 'identifier' &&
                                     callFuncNode.text === 'new') {
                                     // buf := new(bytes.Buffer) — the builtin
@@ -1000,7 +1024,16 @@ function findCallsInCode(code, parser, options = {}) {
                                 }
                             }
                         }
-                        if (typeName) typeMap.set(names[vi], typeName);
+                        if (typeName) {
+                            typeMap.set(names[vi], typeName);
+                            let gset = scopeGuesses.get(scopeKey);
+                            if (typeGuessed) {
+                                if (!gset) { gset = new Set(); scopeGuesses.set(scopeKey, gset); }
+                                gset.add(names[vi]);
+                            } else if (gset) {
+                                gset.delete(names[vi]); // compiler-true retype clears the guess
+                            }
+                        }
                     }
                 }
             }
@@ -1021,7 +1054,10 @@ function findCallsInCode(code, parser, options = {}) {
                     if (!typeName) return;
                     for (let j = 0; j < spec.namedChildCount; j++) {
                         const id = spec.namedChild(j);
-                        if (id.type === 'identifier') varTypeMap.set(id.text, typeName);
+                        if (id.type === 'identifier') {
+                            varTypeMap.set(id.text, typeName);
+                            scopeGuesses.get(scopeKey)?.delete(id.text); // declared type clears any guess
+                        }
                     }
                 };
                 for (let i = 0; i < node.namedChildCount; i++) {
@@ -1150,7 +1186,7 @@ function findCallsInCode(code, parser, options = {}) {
                     // fix #202: one-hop declared-field receivers — h.inner.Run().
                     // receiverRoot/Field/RootType let findCallers hop to the
                     // field's declared struct-field type cross-file.
-                    let receiverRoot, receiverFieldName, receiverRootType;
+                    let receiverRoot, receiverFieldName, receiverRootType, receiverRootTypeGuessed;
                     if (!receiver && operandNode?.type === 'selector_expression') {
                         const rootNode = operandNode.childForFieldName('operand');
                         const fldNode = operandNode.childForFieldName('field');
@@ -1159,6 +1195,9 @@ function findCallsInCode(code, parser, options = {}) {
                             receiverRoot = rootNode.text;
                             receiverFieldName = fldNode.text;
                             receiverRootType = getReceiverType(rootNode.text);
+                            if (receiverRootType && isGuessedType(rootNode.text)) {
+                                receiverRootTypeGuessed = true;
+                            }
                         }
                     }
                     // Chained receiver (fix #220, cobra-measured): the receiver
@@ -1167,16 +1206,22 @@ function findCallsInCode(code, parser, options = {}) {
                     // declared return (*pflag.FlagSet → external → routed).
                     // Package-qualified producers (os.CreateTemp().Name())
                     // carry the qualifier for strict import-package resolution.
-                    let receiverCall, receiverCallIsMethod, receiverCallReceiver;
+                    let receiverCall, receiverCallIsMethod, receiverCallReceiver, receiverCallLine;
                     if (!receiver && !receiverFieldName && operandNode?.type === 'call_expression') {
                         const prodFunc = operandNode.childForFieldName('function');
                         if (prodFunc?.type === 'identifier') {
                             receiverCall = prodFunc.text;
+                            // Producer link (fix #258): plain-call records carry
+                            // the call node's start line
+                            receiverCallLine = operandNode.startPosition.row + 1;
                         } else if (prodFunc?.type === 'selector_expression') {
                             const pf = prodFunc.childForFieldName('field');
                             const po = prodFunc.childForFieldName('operand');
                             if (pf) {
                                 receiverCall = pf.text;
+                                // Selector records report the FIELD's own line
+                                // (fix #223 name-node convention)
+                                receiverCallLine = pf.startPosition.row + 1;
                                 if (po?.type === 'identifier' && importAliases.has(po.text)) {
                                     receiverCallReceiver = po.text;
                                 } else {
@@ -1198,11 +1243,14 @@ function findCallsInCode(code, parser, options = {}) {
                         isMethod: !isPkgCall,
                         receiver,
                         ...(receiverType && { receiverType }),
+                        ...(receiverType && isGuessedType(receiver) && { receiverTypeGuessed: true }),
                         ...(receiverFieldName && { receiverRoot, receiverField: receiverFieldName }),
                         ...(receiverFieldName && receiverRootType && { receiverRootType }),
+                        ...(receiverFieldName && receiverRootType && receiverRootTypeGuessed && { receiverRootTypeGuessed: true }),
                         ...(receiverCall && { receiverCall }),
                         ...(receiverCallIsMethod && { receiverCallIsMethod: true }),
                         ...(receiverCallReceiver && { receiverCallReceiver }),
+                        ...(receiverCallLine && { receiverCallLine }),
                         argCount,
                         ...(argSpread && { argSpread: true }),
                         ...(assigned && { assignedTo: assigned.assignedTo }),
@@ -1282,6 +1330,7 @@ function findCallsInCode(code, parser, options = {}) {
                         isMethod: true,
                         receiver,
                         ...(receiverType && { receiverType }),
+                        ...(receiverType && isGuessedType(receiver) && { receiverTypeGuessed: true }),
                         enclosingFunction,
                         isPotentialCallback: true,
                         uncertain: false
@@ -1337,6 +1386,7 @@ function findCallsInCode(code, parser, options = {}) {
                                 isMethod: true,
                                 receiver,
                                 ...(receiverType && { receiverType }),
+                                ...(receiverType && isGuessedType(receiver) && { receiverTypeGuessed: true }),
                                 enclosingFunction,
                                 isPotentialCallback: true,
                                 uncertain: false
@@ -1431,6 +1481,7 @@ function findCallsInCode(code, parser, options = {}) {
                             isMethod: true,
                             receiver,
                             ...(receiverType && { receiverType }),
+                            ...(receiverType && isGuessedType(receiver) && { receiverTypeGuessed: true }),
                             enclosingFunction,
                             isPotentialCallback: true,
                             uncertain: false,
@@ -1469,6 +1520,7 @@ function findCallsInCode(code, parser, options = {}) {
                 if (leaving) {
                     closureScopes.delete(leaving.startLine);
                     scopeTypes.delete(leaving.startLine);
+                    scopeGuesses.delete(leaving.startLine);
                 }
             }
         }

package/languages/java.js

@@ -556,16 +556,26 @@ function extractImplements(classNode) {
  * Extract extends from interface
  */
 function extractInterfaceExtends(interfaceNode) {
-    const extendsNode = interfaceNode.childForFieldName('extends');
-    if (extendsNode) {
-        const interfaces = [];
-        for (let i = 0; i < extendsNode.namedChildCount; i++) {
-            const iface = extendsNode.namedChild(i);
-            interfaces.push(iface.text);
+    // The grammar exposes interface extends as an `extends_interfaces` child
+    // wrapping a type_list, not as an `extends` field — the field lookup
+    // returned null and interfaces silently never recorded their supertypes
+    // (fix #270: the deadcode heritage walk needs them).
+    const interfaces = [];
+    for (let i = 0; i < interfaceNode.namedChildCount; i++) {
+        const child = interfaceNode.namedChild(i);
+        if (child.type !== 'extends_interfaces') continue;
+        for (let j = 0; j < child.namedChildCount; j++) {
+            const entry = child.namedChild(j);
+            if (entry.type === 'type_list') {
+                for (let k = 0; k < entry.namedChildCount; k++) {
+                    interfaces.push(entry.namedChild(k).text);
+                }
+            } else {
+                interfaces.push(entry.text);
+            }
         }
-        return interfaces;
     }
-    return [];
+    return interfaces;
 }
 
 /**
@@ -1131,11 +1141,14 @@ function findCallsInCode(code, parser) {
                 // Chained receiver (fix #220): the receiver IS a call —
                 // getConfig().validate() — record the producer so findCallers
                 // can type it from the declared return annotation.
-                let receiverCall, receiverCallIsMethod;
+                let receiverCall, receiverCallIsMethod, receiverCallLine;
                 if (!receiver && !receiverFieldName && objNode?.type === 'method_invocation') {
                     const prodName = objNode.childForFieldName('name');
                     if (prodName) {
                         receiverCall = prodName.text;
+                        // Producer link (fix #258): records report the name
+                        // node's own line
+                        receiverCallLine = prodName.startPosition.row + 1;
                         if (objNode.childForFieldName('object')) receiverCallIsMethod = true;
                     }
                 }
@@ -1155,6 +1168,7 @@ function findCallsInCode(code, parser) {
                     ...(receiverFieldName && receiverRootType && { receiverRootType }),
                     ...(receiverCall && { receiverCall }),
                     ...(receiverCallIsMethod && { receiverCallIsMethod: true }),
+                    ...(receiverCallLine && { receiverCallLine }),
                     argCount: callArgs.argCount,
                     ...(callArgs.argKinds && { argKinds: callArgs.argKinds }),
                     ...(assignedTo && { assignedTo }),

package/languages/javascript.js

@@ -528,6 +528,18 @@ function _processFunction(node, functions, processedRanges, lines) {
                         isArrow,
                         isGenerator: isGen,
                         modifiers: [],
+                        // A property-assignment def (Reply.prototype.serialize
+                        // = function, exports.h = () => ...) creates NO
+                        // lexical name — a bare call in the file can never
+                        // bind it (fix #269, fastify-measured: the prototype
+                        // def stole the module-scope binding from the free
+                        // `function serialize(...)` below it). Prototype
+                        // assignments carry their class so typed-receiver
+                        // method resolution reaches them.
+                        ...(leftNode.type === 'member_expression' && { memberAssigned: true }),
+                        ...(leftNode.type === 'member_expression' &&
+                            /^([A-Za-z_$][\w$]*)\.prototype\.[A-Za-z_$][\w$]*$/.test(leftNode.text) &&
+                            { className: leftNode.text.split('.')[0], isMethod: true }),
                         ...typeAnno,
                         ...(generics && { generics }),
                         ...(docstring && { docstring })
@@ -752,7 +764,14 @@ function _processClass(node, classes, processedRanges, lines) {
     // TypeScript namespace/module declarations
     if (node.type === 'internal_module' || node.type === 'module') {
         const nameNode = node.childForFieldName('name');
-        if (nameNode) {
+        // A STRING-named module declaration (`declare module '../vanilla'`)
+        // is a module AUGMENTATION/shape declaration, not a nameable symbol
+        // (fix #267, zustand-measured): it declares no identifier project
+        // code can reference, so indexing it as a namespace made deadcode
+        // claim every augmentation block dead (5 FALSE-DEADs on zustand's
+        // StoreMutators augmentations). The compiler merges it into the
+        // TARGET module — never claimable, never importable by this "name".
+        if (nameNode && nameNode.type !== 'string') {
             const { startLine, endLine } = nodeToLocation(node, lines);
             const docstring = extractJSDocstring(lines, startLine);
 
@@ -1280,6 +1299,21 @@ const JS_LITERAL_RECEIVER_TYPES = {
     number: 'Number',
 };
 
+// Literal ASSIGNMENTS type the variable (fix #262, the #218d Python rule):
+// `const lines = []` → lines is Array, so lines.push() is Array.push. Object
+// literals are deliberately absent — `const obj = {}` is the mutable
+// property-bag / namespace idiom (obj.render = fn happens later), so typing
+// it 'Object' would falsely externalize its assigned methods. A DIRECT
+// literal receiver (`{}.hasOwnProperty()`) has no such future, hence the
+// separate map above.
+const JS_LITERAL_ASSIGN_TYPES = {
+    array: 'Array',
+    string: 'String',
+    template_string: 'String',
+    regex: 'RegExp',
+    number: 'Number',
+};
+
 // Predefined TS types that pin a receiver; any/unknown/object say nothing.
 const TS_PREDEFINED_RECEIVER_TYPES = new Set(['string', 'number', 'boolean', 'bigint', 'symbol']);
 
@@ -1367,6 +1401,12 @@ function findCallsInCode(code, parser) {
     const aliases = new Map();  // Track local aliases: aliasName -> originalName (string or string[])
     const nonCallableNames = new Set();  // Track names assigned non-callable values
     const localVarTypes = new Map();  // Track local variable types: varName -> typeName (for receiverType inference)
+    // Names whose type came from a DECLARED annotation (TS `x: Foo` / typed
+    // params). The compiler enforces assignability for these, so reassignment
+    // never stales them; inferred types (literal/new) DO stale and are
+    // deleted on untyped reassignment (fix #262, #218d semantics).
+    const declaredTypeVars = new Set();
+    const declaredTypeVarsStack = [];
     const moduleAliases = new Set();  // Names bound to MODULES (import * as ns / const pkg = require(...))
     const localVarTypesStack = [];  // Stack for function-scoped save/restore of localVarTypes
 
@@ -1642,6 +1682,7 @@ function findCallsInCode(code, parser) {
             });
             // Save localVarTypes so inner declarations don't leak to sibling functions
             localVarTypesStack.push(new Map(localVarTypes));
+            declaredTypeVarsStack.push(new Set(declaredTypeVars));
         }
 
         // Track local aliases: const myParse = parse, const { parse: csvParse } = ...
@@ -1706,7 +1747,13 @@ function findCallsInCode(code, parser) {
                     const typeName = tsTypeName(typeId);
                     if (typeName) {
                         localVarTypes.set(nameNode.text, typeName);
+                        declaredTypeVars.add(nameNode.text);
                     }
+                } else if (initNode && JS_LITERAL_ASSIGN_TYPES[initNode.type]) {
+                    // Literal declaration types the variable (fix #262):
+                    // `const lines = []` → Array. Annotation, when present,
+                    // wins (the branch above).
+                    localVarTypes.set(nameNode.text, JS_LITERAL_ASSIGN_TYPES[initNode.type]);
                 }
             }
         }
@@ -1720,6 +1767,7 @@ function findCallsInCode(code, parser) {
                 const typeName = tsTypeName(inner);
                 if (typeName) {
                     localVarTypes.set(pat.text, typeName);
+                    declaredTypeVars.add(pat.text);
                 }
             }
         }
@@ -1728,11 +1776,26 @@ function findCallsInCode(code, parser) {
         if (node.type === 'assignment_expression') {
             const left = node.childForFieldName('left');
             const right = node.childForFieldName('right');
-            if (left?.type === 'identifier' && right?.type === 'new_expression') {
-                nonCallableNames.add(left.text);
-                const ctorName = jsConstructorTypeName(right.childForFieldName('constructor'));
-                if (ctorName) {
-                    localVarTypes.set(left.text, ctorName);
+            if (left?.type === 'identifier') {
+                if (right?.type === 'new_expression') {
+                    nonCallableNames.add(left.text);
+                    const ctorName = jsConstructorTypeName(right.childForFieldName('constructor'));
+                    if (ctorName) {
+                        localVarTypes.set(left.text, ctorName);
+                    } else if (!declaredTypeVars.has(left.text)) {
+                        localVarTypes.delete(left.text);
+                    }
+                } else if (right && JS_LITERAL_ASSIGN_TYPES[right.type]) {
+                    // Literal reassignment re-types the variable (fix #262)
+                    if (!declaredTypeVars.has(left.text)) {
+                        localVarTypes.set(left.text, JS_LITERAL_ASSIGN_TYPES[right.type]);
+                    }
+                } else if (localVarTypes.has(left.text) && !declaredTypeVars.has(left.text)) {
+                    // Rebinding without a known type makes any previously
+                    // INFERRED type stale — nearest-preceding-assignment
+                    // semantics (#218d). Annotation-declared types survive:
+                    // the TS compiler enforces assignability for those.
+                    localVarTypes.delete(left.text);
                 }
             }
             // Handler-registration references (fix #252, the #221 family's
@@ -1878,7 +1941,7 @@ function findCallsInCode(code, parser) {
                         // parseAsync(args).catch(...) — record the producer so
                         // findCallers can type the receiver from its declared
                         // return annotation (Promise<...> → Promise).
-                        let receiverCall, receiverCallIsMethod, receiverCallAwaited;
+                        let receiverCall, receiverCallIsMethod, receiverCallAwaited, receiverCallLine;
                         {
                             let recvNode = objNode;
                             if (recvNode && recvNode.type === 'parenthesized_expression') {
@@ -1892,11 +1955,17 @@ function findCallsInCode(code, parser) {
                                 const prodFunc = recvNode.childForFieldName('function');
                                 if (prodFunc?.type === 'identifier') {
                                     receiverCall = prodFunc.text;
+                                    // Producer link (fix #258): plain-call
+                                    // records carry the call node's start line
+                                    receiverCallLine = recvNode.startPosition.row + 1;
                                 } else if (prodFunc?.type === 'member_expression') {
                                     const prodProp = prodFunc.childForFieldName('property');
                                     if (prodProp) {
                                         receiverCall = prodProp.text;
                                         receiverCallIsMethod = true;
+                                        // Method records report the property
+                                        // node's own line
+                                        receiverCallLine = prodProp.startPosition.row + 1;
                                     }
                                 }
                             }
@@ -1930,6 +1999,7 @@ function findCallsInCode(code, parser) {
                             ...(receiverCall && { receiverCall }),
                             ...(receiverCallIsMethod && { receiverCallIsMethod: true }),
                             ...(receiverCallAwaited && { receiverCallAwaited: true }),
+                            ...(receiverCallLine && { receiverCallLine }),
                             ...(assignedTo && { assignedTo }),
                             enclosingFunction,
                             uncertain,
@@ -2165,6 +2235,11 @@ function findCallsInCode(code, parser) {
                     localVarTypes.clear();
                     for (const [k, v] of saved) localVarTypes.set(k, v);
                 }
+                const savedDeclared = declaredTypeVarsStack.pop();
+                if (savedDeclared) {
+                    declaredTypeVars.clear();
+                    for (const k of savedDeclared) declaredTypeVars.add(k);
+                }
             }
         }
     });
@@ -2340,6 +2415,7 @@ function findImportsInCode(code, parser) {
             const line = node.startPosition.row + 1;
             let modulePath = null;
             const names = [];
+            const esmRenames = [];
             let importType = 'named';
 
             // Find the module path (string node)
@@ -2385,6 +2461,7 @@ function findImportsInCode(code, parser) {
                                     if (nameNode && aliasNode && aliasNode.text !== nameNode.text) {
                                         if (!importAliases) importAliases = [];
                                         importAliases.push({ original: nameNode.text, local: aliasNode.text });
+                                        esmRenames.push({ original: nameNode.text, local: aliasNode.text });
                                     }
                                 }
                             }
@@ -2405,7 +2482,8 @@ function findImportsInCode(code, parser) {
                     // Side-effect import: import 'x'
                     importType = 'side-effect';
                 }
-                imports.push({ module: modulePath, names, type: importType, line });
+                imports.push({ module: modulePath, names, type: importType, line,
+                    ...(esmRenames.length > 0 && { renames: esmRenames }) });
             }
             return true;
         }
@@ -2451,6 +2529,7 @@ function findImportsInCode(code, parser) {
                     const firstArg = argsNode.namedChild(0);
                     const line = node.startPosition.row + 1;
                     const names = [];
+                    const renames = [];
                     let modulePath;
                     let dynamic = false;
 
@@ -2482,6 +2561,7 @@ function findImportsInCode(code, parser) {
                                         if (key && val && val.text !== key.text) {
                                             if (!importAliases) importAliases = [];
                                             importAliases.push({ original: key.text, local: val.text });
+                                            renames.push({ original: key.text, local: val.text });
                                         }
                                     }
                                 }
@@ -2490,7 +2570,13 @@ function findImportsInCode(code, parser) {
                     }
 
                     if (modulePath) {
-                        imports.push({ module: modulePath, names, type: 'require', line, dynamic });
+                        imports.push({ module: modulePath, names, type: 'require', line, dynamic,
+                            // Per-import rename pairing (fix #269): the flat
+                            // importAliases list loses WHICH module a renamed
+                            // name came from — `{ validate: validateSchema }`
+                            // must pin to its own require, not any module
+                            // exporting the source name.
+                            ...(renames.length > 0 && { renames }) });
                     }
                 }
             }

package/languages/python.js

@@ -138,6 +138,7 @@ function _processFunction(node, functions, processedRanges, lines, code) {
                 ...(paramTypes && { paramTypes }),
                 ...(docstring && { docstring }),
                 ...(decorators.length > 0 && { decorators }),
+                ...(isOverloadDecorated(decorators) && { isSignature: true }),
                 ...(nameLine !== decoratorStartLine && { nameLine })
             });
         }
@@ -285,6 +286,19 @@ function findFunctions(code, parser) {
     return functions;
 }
 
+/**
+ * A typing @overload-decorated def is a SIGNATURE of the implementation that
+ * follows, not a callable of its own (fix #265 — TS overload parity): the
+ * runtime discards the stub bodies, so pin identity must close over the
+ * group and resolution must prefer the implementation.
+ */
+function isOverloadDecorated(decorators) {
+    return decorators.some(d => {
+        const head = d.split('(')[0].trim();
+        return head === 'overload' || head.endsWith('.overload');
+    });
+}
+
 /**
  * Extract decorators from a function/class node
  */
@@ -472,6 +486,7 @@ function extractClassMembers(classNode, code) {
                     ...(paramTypes && { paramTypes }),
                     ...(docstring && { docstring }),
                     ...(memberDecorators.length > 0 && { decorators: memberDecorators }),
+                    ...(isOverloadDecorated(memberDecorators) && { isSignature: true }),
                     ...(nameLine !== startLine && { nameLine })
                 });
             }
@@ -1073,7 +1088,7 @@ function findCallsInCode(code, parser) {
                     // annotation. `(await f()).m()` unwraps to the call and
                     // marks awaited (an un-awaited async producer's value is a
                     // coroutine, not the annotation's type).
-                    let receiverCall, receiverCallIsMethod, receiverCallAwaited;
+                    let receiverCall, receiverCallIsMethod, receiverCallAwaited, receiverCallLine;
 
                     // Detect super().method() pattern
                     if (objNode?.type === 'call') {
@@ -1093,11 +1108,17 @@ function findCallsInCode(code, parser) {
                             const prodFunc = recvNode.childForFieldName('function');
                             if (prodFunc?.type === 'identifier') {
                                 receiverCall = prodFunc.text;
+                                // Producer link (fix #258): plain-call records
+                                // carry the call node's start line
+                                receiverCallLine = recvNode.startPosition.row + 1;
                             } else if (prodFunc?.type === 'attribute') {
                                 const prodAttr = prodFunc.childForFieldName('attribute');
                                 if (prodAttr) {
                                     receiverCall = prodAttr.text;
                                     receiverCallIsMethod = true;
+                                    // Method records report the attribute
+                                    // node's own line
+                                    receiverCallLine = prodAttr.startPosition.row + 1;
                                 }
                             }
                         }
@@ -1140,6 +1161,7 @@ function findCallsInCode(code, parser) {
                         ...(receiverCall && { receiverCall }),
                         ...(receiverCallIsMethod && { receiverCallIsMethod: true }),
                         ...(receiverCallAwaited && { receiverCallAwaited: true }),
+                        ...(receiverCallLine && { receiverCallLine }),
                         ...(assignedTo && { assignedTo }),
                         argCount,
                         ...(argSpread && { argSpread: true }),

package/languages/rust.js

@@ -1311,13 +1311,18 @@ function findCallsInCode(code, parser) {
                     // chain to its root: if the chain originates at Router::new() or
                     // any Router-typed call, set a synthetic receiver string so the
                     // bridge layer can recognize this as a Router method invocation.
+                    let receiverIsChainRoot;
                     if (!receiver && valueNode?.type === 'call_expression') {
                         const rootType = _findRustChainRootType(valueNode);
                         if (rootType) {
                             // Synthetic marker — ROUTER_CHAIN:<RootTypeName>. The
                             // <RootTypeName> portion lets the bridge match
-                            // /^router/i case-insensitively.
+                            // /^router/i case-insensitively. receiverIsChainRoot
+                            // tells caller physics this is NOT an identifier in
+                            // the code (fix #258) — the chain fold types it from
+                            // the producer link instead.
                             receiver = rootType;
+                            receiverIsChainRoot = true;
                         }
                     }
                     // fix #202: one-hop declared-field receivers — self.dent.path(),
@@ -1354,16 +1359,43 @@ function findCallsInCode(code, parser) {
                     // Chained receiver (fix #220): the receiver IS a call —
                     // self.as_u8().as_color() — record the producer so
                     // findCallers can type it from the declared return.
-                    // Path producers (Config::load().x()) stay uncaptured
-                    // until a measured family justifies the path branch.
-                    let receiverCall, receiverCallIsMethod;
-                    if (!receiver && !receiverField && valueNode?.type === 'call_expression') {
-                        const prodFunc = valueNode.childForFieldName('function');
+                    // Fix #258 (clap-measured): receiverCallLine links to the
+                    // producer's OWN record (per-record line convention:
+                    // field identifier for method producers, call-node start
+                    // for plain/path producers) so the chain fold can walk
+                    // Command::new("x").a(...).b(...) hop by hop; path
+                    // producers (Config::load().x()) are captured now, and
+                    // rooted chains keep their synthetic receiver marker for
+                    // the bridge but get the link too.
+                    let receiverCall, receiverCallIsMethod, receiverCallLine;
+                    if ((!receiver || receiverIsChainRoot) && !receiverField &&
+                        valueNode?.type === 'call_expression') {
+                        let prodFunc = valueNode.childForFieldName('function');
+                        if (prodFunc?.type === 'generic_function') {
+                            prodFunc = prodFunc.childForFieldName('function') || prodFunc;
+                        }
                         if (prodFunc?.type === 'identifier') {
                             receiverCall = prodFunc.text;
+                            receiverCallLine = valueNode.startPosition.row + 1;
                         } else if (prodFunc?.type === 'field_expression') {
                             const pf = prodFunc.childForFieldName('field');
-                            if (pf) { receiverCall = pf.text; receiverCallIsMethod = true; }
+                            if (pf) {
+                                receiverCall = pf.text;
+                                receiverCallIsMethod = true;
+                                receiverCallLine = pf.startPosition.row + 1;
+                            }
+                        } else if (prodFunc?.type === 'scoped_identifier') {
+                            // Path producer: Command::new(...).arg(...) — the
+                            // producer record's name is the last path segment
+                            // (turbofish segments dropped, matching the path
+                            // record's own derivation) at the call node's line.
+                            const segs = prodFunc.text.split('::');
+                            const prodName = segs[segs.length - 1];
+                            if (prodName && !prodName.startsWith('<')) {
+                                receiverCall = prodName;
+                                receiverCallIsMethod = true;
+                                receiverCallLine = valueNode.startPosition.row + 1;
+                            }
                         }
                     }
                     // Literal receivers carry their builtin type (fix #220,
@@ -1374,7 +1406,7 @@ function findCallsInCode(code, parser) {
                         ? ({ string_literal: 'str', raw_string_literal: 'str',
                             char_literal: 'char', boolean_literal: 'bool' })[valueNode.type]
                         : undefined;
-                    const receiverType = (receiver && receiver !== 'self')
+                    const receiverType = (receiver && receiver !== 'self' && !receiverIsChainRoot)
                         ? getReceiverType(receiver)
                         : literalReceiverType;
                     const firstArg = getFirstStringArg(node);
@@ -1389,10 +1421,12 @@ function findCallsInCode(code, parser) {
                         isMethod: true,
                         receiver,
                         ...(receiverType && { receiverType }),
+                        ...(receiverIsChainRoot && { receiverIsChainRoot: true }),
                         ...(receiverField && { receiverRoot, receiverField }),
                         ...(receiverField && receiverRootType && { receiverRootType }),
                         ...(receiverCall && { receiverCall }),
                         ...(receiverCallIsMethod && { receiverCallIsMethod: true }),
+                        ...(receiverCallLine && { receiverCallLine }),
                         argCount,
                         ...(assigned && { assignedTo: assigned.assignedTo }),
                         ...(assigned?.unwrapped && { assignedUnwrap: true }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucn",
-  "version": "4.1.1",
+  "version": "4.1.3",
   "mcpName": "io.github.mleoca/ucn",
   "description": "Code intelligence toolkit for AI agents — extract functions, trace call chains, find callers, detect dead code without reading entire files. Works as MCP server, CLI, or agent skill. Supports JS/TS, Python, Go, Rust, Java.",
   "main": "index.js",