ucn 4.2.2 → 5.0.1

package/languages/javascript.js

@@ -379,6 +379,62 @@ function extractDecoratorsWithArgs(node) {
 
 // --- Single-pass helpers: extracted from find* callbacks ---
 
+const FUNCTION_SCOPE_NODES = new Set([
+    'function_declaration', 'generator_function_declaration',
+    'function_expression', 'generator_function', 'arrow_function',
+    'method_definition',
+]);
+
+function lexicalOwnerRange(node) {
+    for (let parent = node?.parent; parent; parent = parent.parent) {
+        if (!FUNCTION_SCOPE_NODES.has(parent.type)) continue;
+        const body = parent.childForFieldName('body') || parent;
+        return {
+            lexicalScopeStartLine: body.startPosition.row + 1,
+            lexicalScopeEndLine: body.endPosition.row + 1,
+        };
+    }
+    return {};
+}
+
+/**
+ * Concrete runtime value returned by a function when every reachable return
+ * constructs the same class. Nested functions/classes are separate scopes.
+ * This complements (never guesses beyond) a declared interface return type.
+ */
+function extractReturnedConcreteType(node) {
+    const body = node.childForFieldName('body');
+    if (!body) return null;
+    const types = [];
+    let incomplete = false;
+    const stack = [body];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (current !== body && FUNCTION_SCOPE_NODES.has(current.type)) continue;
+        if (current.type === 'class_declaration' || current.type === 'class') continue;
+        if (current.type === 'return_statement') {
+            const value = current.namedChild(0);
+            if (value?.type !== 'new_expression') {
+                incomplete = true;
+                continue;
+            }
+            const constructor = value.childForFieldName('constructor');
+            if (!constructor ||
+                !['identifier', 'member_expression'].includes(constructor.type)) {
+                incomplete = true;
+                continue;
+            }
+            types.push(constructor.text.split('.').pop());
+            continue;
+        }
+        for (let i = current.namedChildCount - 1; i >= 0; i--) {
+            stack.push(current.namedChild(i));
+        }
+    }
+    return !incomplete && types.length > 0 && new Set(types).size === 1
+        ? types[0] : null;
+}
+
 /**
  * Process a node for function extraction (single-pass helper)
  * Returns true if node was matched, false otherwise
@@ -397,6 +453,7 @@ function _processFunction(node, functions, processedRanges, lines) {
         if (nameNode) {
             const { startLine, endLine, indent } = nodeToLocation(node, lines);
             const returnType = extractReturnType(node);
+            const returnedConcreteType = extractReturnedConcreteType(node);
             const generics = extractGenerics(node);
             const docstring = extractJSDocstring(lines, startLine);
             const isGen = isGenerator(node);
@@ -421,6 +478,55 @@ function _processFunction(node, functions, processedRanges, lines) {
                 isGenerator: isGen,
                 isAsync,
                 modifiers,
+                ...lexicalOwnerRange(node),
+                ...typeAnno,
+                ...(returnedConcreteType && { returnedConcreteType }),
+                ...(generics && { generics }),
+                ...(docstring && { docstring })
+            });
+        }
+        return true;
+    }
+
+    // Named function expressions used as callbacks have a real lexical
+    // definition even when no variable owns them: `test('x', function run()
+    // {})`.  Property/variable assignments are handled by their binding
+    // branches below; indexing the expression name there as a second symbol
+    // would manufacture a duplicate public definition.
+    if (node.type === 'function_expression' || node.type === 'generator_function') {
+        const parent = node.parent;
+        const isBoundValue = (parent?.type === 'variable_declarator' &&
+                sameNode(parent.childForFieldName('value'), node)) ||
+            (parent?.type === 'assignment_expression' &&
+                sameNode(parent.childForFieldName('right'), node)) ||
+            (parent?.type === 'pair' && sameNode(parent.childForFieldName('value'), node));
+        const nameNode = node.childForFieldName('name');
+        if (!isBoundValue && nameNode && !processedRanges.has(rangeKey)) {
+            processedRanges.add(rangeKey);
+            const paramsNode = node.childForFieldName('parameters');
+            const { startLine, endLine, indent } = nodeToLocation(node, lines);
+            const returnType = extractReturnType(node);
+            const generics = extractGenerics(node);
+            const paramsStructured = parseStructuredParams(paramsNode, 'javascript');
+            const typeAnno = buildTypeAnnotations(paramsStructured, returnType, lines, startLine, true);
+            const docstring = extractJSDocstring(lines, startLine);
+            functions.push({
+                name: nameNode.text,
+                params: extractParams(paramsNode),
+                paramsStructured,
+                startLine,
+                endLine,
+                indent,
+                isArrow: false,
+                isGenerator: isGenerator(node),
+                isAsync: node.text.trimStart().startsWith('async '),
+                modifiers: [],
+                // ECMA-262: a FunctionExpression's BindingIdentifier is in
+                // scope only within its own body — the name creates no
+                // file-level binding (never enters the bindings table) and
+                // the expression is consumed where it appears (argument /
+                // value position), so deadcode never audits it.
+                bodyScopedName: true,
                 ...typeAnno,
                 ...(generics && { generics }),
                 ...(docstring && { docstring })
@@ -481,7 +587,8 @@ function _processFunction(node, functions, processedRanges, lines) {
 
                     if (isArrow || isFnExpr) {
                         processedRanges.add(rangeKey);
-                        const paramsNode = valueNode.childForFieldName('parameters');
+                        const paramsNode = valueNode.childForFieldName('parameters') ||
+                            valueNode.childForFieldName('parameter');
                         const { startLine, endLine, indent } = nodeToLocation(node, lines);
                         const returnType = extractReturnType(valueNode);
                         const generics = extractGenerics(valueNode);
@@ -613,7 +720,10 @@ function _processFunction(node, functions, processedRanges, lines) {
                 }
                 parent = parent.parent;
             }
-            if (!isTopLevel) return true;
+            // A nested property assignment still defines that object's
+            // callable member (`reply.send = () => {}`).  Only a nested bare
+            // assignment lacks a new symbol binding and stays excluded.
+            if (!isTopLevel && leftNode?.type !== 'member_expression') return true;
         }
 
         const rightNode = node.childForFieldName('right');
@@ -624,7 +734,16 @@ function _processFunction(node, functions, processedRanges, lines) {
                              rightNode.type === 'generator_function';
 
             if (isArrow || isFnExpr) {
-                const name = getAssignmentName(leftNode);
+                const isCommonJsDefault = leftNode.text === 'module.exports';
+                const expressionName = isFnExpr
+                    ? rightNode.childForFieldName('name')?.text : null;
+                // `module.exports = function transformer(){}` exports the
+                // function expression, not a symbol called "exports". Keep
+                // its authored name when present; anonymous defaults use the
+                // same `default` identity exposed by the API surface.
+                const name = isCommonJsDefault
+                    ? (expressionName || 'default')
+                    : getAssignmentName(leftNode);
                 if (name) {
                     processedRanges.add(rangeKey);
                     const paramsNode = rightNode.childForFieldName('parameters');
@@ -645,7 +764,7 @@ function _processFunction(node, functions, processedRanges, lines) {
                         indent,
                         isArrow,
                         isGenerator: isGen,
-                        modifiers: [],
+                        modifiers: isCommonJsDefault ? ['export'] : [],
                         // A property-assignment def (Reply.prototype.serialize
                         // = function, exports.h = () => ...) creates NO
                         // lexical name — a bare call in the file can never
@@ -812,18 +931,26 @@ function _processClass(node, classes, processedRanges, lines) {
         if (nameNode) {
             const { startLine, endLine } = nodeToLocation(node, lines);
             const docstring = extractJSDocstring(lines, startLine);
+            const valueNode = node.childForFieldName('value');
             // `type ZodTypeAny = ZodType<any, any, any>;` — the alias IS the
             // aliased type. Record the base name so receivers annotated with
             // the alias validate against the base type's methods (fix #208,
             // TS parity with Rust/Go).
-            const aliasOf = aliasBaseTypeName(node.childForFieldName('value'));
+            const aliasOf = aliasBaseTypeName(valueNode);
+            // Object type aliases are structural record declarations, not
+            // opaque labels. Index their declared fields just like interface
+            // fields so a compiler-typed hop such as
+            // `node: Node; node._source.unsubscribe()` can resolve Node's
+            // `_source: Signal` contract without name guessing.
+            const members = valueNode?.type === 'object_type'
+                ? extractTypeMembers(valueNode, lines) : [];
 
             classes.push({
                 name: nameNode.text,
                 startLine,
                 endLine,
                 type: 'type',
-                members: [],
+                members,
                 ...(aliasOf && { aliasOf }),
                 ...(docstring && { docstring })
             });
@@ -991,10 +1118,13 @@ function extractInterfaceExtends(interfaceNode) {
  * Extract interface members (method signatures, property signatures)
  */
 function extractInterfaceMembers(interfaceNode, code) {
-    const members = [];
     const bodyNode = interfaceNode.childForFieldName('body');
-    if (!bodyNode) return members;
+    if (!bodyNode) return [];
+    return extractTypeMembers(bodyNode, code);
+}
 
+function extractTypeMembers(bodyNode, code) {
+    const members = [];
     for (let i = 0; i < bodyNode.namedChildCount; i++) {
         const child = bodyNode.namedChild(i);
 
@@ -1388,6 +1518,87 @@ function parse(code, parser) {
         return true; // always continue, never skip subtrees
     });
 
+    // Some valid overload-heavy TypeScript files exceed the grammar's error
+    // recovery budget. tree-sitter then returns a whole-file ERROR root and
+    // flattens later declarations into unrelated type nodes without throwing.
+    // Recover from AST tokens, not source patterns: top-level declaration
+    // tokens define bounded fragments which are reparsed by the same grammar.
+    // This keeps the AST-only contract while preventing a valid declaration
+    // near the end of one difficult type file from disappearing silently.
+    if (tree.rootNode.hasError) {
+        const declarationTokens = [];
+        const startsDeclaration = new Set([
+            'export', 'declare', 'async', 'function', 'class', 'abstract',
+            'interface', 'type', 'enum', 'namespace', 'module',
+            'const', 'let', 'var'
+        ]);
+        const stack = [tree.rootNode];
+        while (stack.length > 0) {
+            const node = stack.pop();
+            if (node.childCount === 0) {
+                // In severe recovery, a keyword itself can be downgraded to
+                // an identifier token. Its AST position/text still supplies
+                // a safe declaration boundary; semantic extraction remains
+                // entirely delegated to the reparsed fragment.
+                const recoveredKeyword = node.type === 'identifier' &&
+                    startsDeclaration.has(node.text);
+                if (node.startPosition.column === 0 &&
+                    (startsDeclaration.has(node.type) || recoveredKeyword)) {
+                    declarationTokens.push(node);
+                }
+                continue;
+            }
+            const children = node.children;
+            for (let i = children.length - 1; i >= 0; i--) stack.push(children[i]);
+        }
+        declarationTokens.sort((a, b) => a.startIndex - b.startIndex);
+
+        const recoveredFunctions = [], recoveredClasses = [], recoveredState = [];
+        for (let i = 0; i < declarationTokens.length; i++) {
+            const token = declarationTokens[i];
+            const next = declarationTokens[i + 1];
+            if (next && next.startIndex === token.startIndex) continue;
+            const fragment = code.slice(token.startIndex, next?.startIndex ?? code.length);
+            if (!fragment.trim()) continue;
+            const fragmentTree = parseTree(parser, fragment);
+            const fragmentLines = fragment.split('\n');
+            const ff = [], fc = [], fs = [];
+            const pf = new Set(), pc = new Set();
+            traverseTreeCached(fragmentTree.rootNode, (node) => {
+                _processFunction(node, ff, pf, fragmentLines);
+                _processClass(node, fc, pc, fragmentLines);
+                _processState(node, fs, fragmentLines);
+                return true;
+            });
+            const lineOffset = token.startPosition.row;
+            const shiftLines = (value) => {
+                if (!value || typeof value !== 'object') return;
+                if (Array.isArray(value)) {
+                    for (const item of value) shiftLines(item);
+                    return;
+                }
+                for (const [key, child] of Object.entries(value)) {
+                    if (Number.isInteger(child) && /Line$/.test(key)) value[key] = child + lineOffset;
+                    else if (child && typeof child === 'object') shiftLines(child);
+                }
+            };
+            for (const item of ff) { shiftLines(item); recoveredFunctions.push(item); }
+            for (const item of fc) { shiftLines(item); recoveredClasses.push(item); }
+            for (const item of fs) { shiftLines(item); recoveredState.push(item); }
+        }
+
+        const mergeUnique = (target, additions, kind) => {
+            const seen = new Set(target.map(item => `${kind}\0${item.name}\0${item.startLine}`));
+            for (const item of additions) {
+                const key = `${kind}\0${item.name}\0${item.startLine}`;
+                if (!seen.has(key)) { seen.add(key); target.push(item); }
+            }
+        };
+        mergeUnique(functions, recoveredFunctions, 'function');
+        mergeUnique(classes, recoveredClasses, 'class');
+        mergeUnique(stateObjects, recoveredState, 'state');
+    }
+
     functions.sort((a, b) => a.startLine - b.startLine);
     classes.sort((a, b) => a.startLine - b.startLine);
     stateObjects.sort((a, b) => a.startLine - b.startLine);
@@ -1519,9 +1730,38 @@ function jsConstructorTypeName(ctorNode) {
     return undefined;
 }
 
+function jsConstructorTypeQualifier(ctorNode) {
+    if (ctorNode?.type !== 'member_expression') return undefined;
+    let root = ctorNode.childForFieldName('object');
+    while (root?.type === 'member_expression') root = root.childForFieldName('object');
+    return root?.type === 'identifier' ? root.text : undefined;
+}
+
+// CommonJS permits direct namespace calls without a local alias:
+// `require('./output').formatContextJson(...)`. Preserve the literal module
+// specifier on the outer call so the index can apply the same export-ownership
+// rules as `const output = require('./output'); output.formatContextJson()`.
+function jsLiteralRequireModule(node) {
+    if (node?.type !== 'call_expression') return undefined;
+    const fn = node.childForFieldName('function');
+    if (fn?.type !== 'identifier' || fn.text !== 'require') return undefined;
+    const args = node.childForFieldName('arguments');
+    if (!args || args.namedChildCount !== 1) return undefined;
+    const first = args.namedChild(0);
+    return first?.type === 'string' ? first.text.slice(1, -1) : undefined;
+}
+
 function findCallsInCode(code, parser) {
     const tree = parseTree(parser, code);
     const calls = [];
+    const assignedMembers = new Set();
+    traverseTreeCached(tree.rootNode, node => {
+        if (node.type !== 'assignment_expression' &&
+            node.type !== 'augmented_assignment_expression') return true;
+        const left = node.childForFieldName('left');
+        if (left?.type === 'member_expression') assignedMembers.add(left.text);
+        return true;
+    });
     const functionStack = [];  // Stack of { name, startLine, endLine }
     // Local aliases with lexical ownership. A flat aliasName→target map leaks
     // block locals into the rest of a module (`let effect = batchedEffect`
@@ -1530,6 +1770,7 @@ function findCallsInCode(code, parser) {
     const aliases = new Map();  // aliasName -> [{ target, declarationIndex, scopeStart, scopeEnd }]
     const nonCallableNames = new Set();  // Track names assigned non-callable values
     const localVarTypes = new Map();  // Track local variable types: varName -> typeName (for receiverType inference)
+    const localVarTypeQualifiers = new Map(); // qualifier provenance for new ns.Type()
     // 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
@@ -1538,6 +1779,7 @@ function findCallsInCode(code, parser) {
     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
+    const localVarTypeQualifiersStack = [];
 
     // Helper: extract first string-arg literal from a call_expression node.
     // Used by route extraction to capture path arg of fetch('/path'), app.get('/path', handler) etc.
@@ -1714,7 +1956,10 @@ function findCallsInCode(code, parser) {
     // Helper to get current enclosing function
     const getCurrentEnclosingFunction = () => {
         return functionStack.length > 0
-            ? { ...functionStack[functionStack.length - 1] }
+            ? {
+                ...functionStack[functionStack.length - 1],
+                scopeChain: functionStack.map(scope => scope.startLine),
+            }
             : null;
     };
 
@@ -1750,20 +1995,31 @@ function findCallsInCode(code, parser) {
         return best && best.target;
     };
 
-    // fix #203: does a declaration node declare `name` (incl. shallow destructuring)?
+    const _patternDeclaresName = (pattern, name) => {
+        if (!pattern) return false;
+        if ((pattern.type === 'identifier' ||
+            pattern.type === 'shorthand_property_identifier_pattern') &&
+            pattern.text === name) return true;
+        if (pattern.type === 'pair_pattern' || pattern.type === 'pair') {
+            return _patternDeclaresName(pattern.childForFieldName('value'), name);
+        }
+        if (pattern.type === 'assignment_pattern') {
+            return _patternDeclaresName(
+                pattern.childForFieldName('left') || pattern.childForFieldName('pattern'), name);
+        }
+        for (let i = 0; i < pattern.namedChildCount; i++) {
+            if (_patternDeclaresName(pattern.namedChild(i), name)) return true;
+        }
+        return false;
+    };
+
+    // fix #203: does a declaration node declare `name` (including nested destructuring)?
     const _declaresName = (declNode, name) => {
         for (let i = 0; i < declNode.namedChildCount; i++) {
             const d = declNode.namedChild(i);
             if (d.type !== 'variable_declarator') continue;
             const nameNode = d.childForFieldName('name');
-            if (nameNode?.type === 'identifier' && nameNode.text === name) return true;
-            if (nameNode && (nameNode.type === 'object_pattern' || nameNode.type === 'array_pattern')) {
-                for (let j = 0; j < nameNode.namedChildCount; j++) {
-                    const el = nameNode.namedChild(j);
-                    if ((el.type === 'identifier' || el.type === 'shorthand_property_identifier_pattern') &&
-                        el.text === name) return true;
-                }
-            }
+            if (_patternDeclaresName(nameNode, name)) return true;
         }
         return false;
     };
@@ -1797,27 +2053,22 @@ function findCallsInCode(code, parser) {
                     _declaresName(init, name)) return true;
             } else if (p.type === 'for_in_statement') {
                 const left = p.childForFieldName('left');
-                if (left?.type === 'identifier' && left.text === name) return true;
+                if (_patternDeclaresName(left, name)) return true;
                 if (left && (left.type === 'lexical_declaration' || left.type === 'variable_declaration') &&
                     _declaresName(left, name)) return true;
             } else if (p.type === 'catch_clause') {
                 const param = p.childForFieldName('parameter');
-                if (param?.type === 'identifier' && param.text === name) return true;
+                if (_patternDeclaresName(param, name)) return true;
             } else if (p.type === 'arrow_function' || p.type === 'function_expression' ||
                 p.type === 'function_declaration' || p.type === 'function' ||
                 p.type === 'method_definition' || p.type === 'generator_function' ||
                 p.type === 'generator_function_declaration') {
                 const params = p.childForFieldName('parameters') || p.childForFieldName('parameter');
                 if (params) {
-                    if (params.type === 'identifier' && params.text === name) return true; // x => ...
+                    if (_patternDeclaresName(params, name)) return true;
                     for (let i = 0; i < params.namedChildCount; i++) {
                         const prm = params.namedChild(i);
-                        if (prm.type === 'identifier' && prm.text === name) return true;
-                        if (prm.type === 'assignment_pattern' || prm.type === 'required_parameter' ||
-                            prm.type === 'optional_parameter') {
-                            const l = prm.childForFieldName('left') || prm.childForFieldName('pattern');
-                            if (l?.type === 'identifier' && l.text === name) return true;
-                        }
+                        if (_patternDeclaresName(prm, name)) return true;
                     }
                 }
             }
@@ -1825,6 +2076,21 @@ function findCallsInCode(code, parser) {
         return false;
     };
 
+    const isConditionalReassignment = node => {
+        for (let p = node.parent; p && !isFunctionNode(p); p = p.parent) {
+            if (p.type === 'if_statement') {
+                const condition = p.childForFieldName('condition');
+                if (!condition || node.startIndex < condition.startIndex ||
+                    node.endIndex > condition.endIndex) return true;
+            }
+            if (p.type === 'switch_case' || p.type === 'ternary_expression' ||
+                p.type === 'for_statement' || p.type === 'for_in_statement' ||
+                p.type === 'while_statement' || p.type === 'do_statement' ||
+                p.type === 'catch_clause') return true;
+        }
+        return false;
+    };
+
     traverseTree(tree.rootNode, (node) => {
         // Track module-alias bindings: `import * as ns from "./m"` binds ns to a
         // MODULE — method calls through it dispatch to module exports, never to
@@ -1843,6 +2109,7 @@ function findCallsInCode(code, parser) {
             });
             // Save localVarTypes so inner declarations don't leak to sibling functions
             localVarTypesStack.push(new Map(localVarTypes));
+            localVarTypeQualifiersStack.push(new Map(localVarTypeQualifiers));
             declaredTypeVarsStack.push(new Set(declaredTypeVars));
         }
 
@@ -1896,6 +2163,10 @@ function findCallsInCode(code, parser) {
                 const ctorName = jsConstructorTypeName(initNode.childForFieldName('constructor'));
                 if (ctorName) {
                     localVarTypes.set(nameNode.text, ctorName);
+                    const qualifier = jsConstructorTypeQualifier(
+                        initNode.childForFieldName('constructor'));
+                    if (qualifier) localVarTypeQualifiers.set(nameNode.text, qualifier);
+                    else localVarTypeQualifiers.delete(nameNode.text);
                 }
             }
             // Track TypeScript type annotations: const x: Foo = ...
@@ -1941,15 +2212,21 @@ function findCallsInCode(code, parser) {
                 if (right?.type === 'new_expression') {
                     nonCallableNames.add(left.text);
                     const ctorName = jsConstructorTypeName(right.childForFieldName('constructor'));
-                    if (ctorName) {
+                    if (ctorName && !isConditionalReassignment(node)) {
                         localVarTypes.set(left.text, ctorName);
+                        const qualifier = jsConstructorTypeQualifier(
+                            right.childForFieldName('constructor'));
+                        if (qualifier) localVarTypeQualifiers.set(left.text, qualifier);
+                        else localVarTypeQualifiers.delete(left.text);
                     } else if (!declaredTypeVars.has(left.text)) {
                         localVarTypes.delete(left.text);
+                        localVarTypeQualifiers.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]);
+                        localVarTypeQualifiers.delete(left.text);
                     }
                 } else if (localVarTypes.has(left.text) && !declaredTypeVars.has(left.text)) {
                     // Rebinding without a known type makes any previously
@@ -1957,6 +2234,7 @@ function findCallsInCode(code, parser) {
                     // semantics (#218d). Annotation-declared types survive:
                     // the TS compiler enforces assignability for those.
                     localVarTypes.delete(left.text);
+                    localVarTypeQualifiers.delete(left.text);
                 }
             }
             // Handler-registration references (fix #252, the #221 family's
@@ -2012,9 +2290,17 @@ function findCallsInCode(code, parser) {
 
         // Handle regular function calls: foo(), obj.foo(), foo.call()
         if (node.type === 'call_expression') {
-            const funcNode = node.childForFieldName('function');
+            let funcNode = node.childForFieldName('function');
             if (!funcNode) return true;
 
+            // tree-sitter-typescript represents `await obj.method<T>()` with
+            // the await_expression inside the call's function field. Unwrap
+            // it so generic awaited calls use the same AST call path as every
+            // other method invocation.
+            if (funcNode.type === 'await_expression' && funcNode.namedChildCount === 1) {
+                funcNode = funcNode.namedChild(0);
+            }
+
             const enclosingFunction = getCurrentEnclosingFunction();
             let uncertain = false;
             // optional chaining implies possible non-call
@@ -2038,6 +2324,8 @@ function findCallsInCode(code, parser) {
                     ...(resolvedName && { resolvedName }),
                     ...(resolvedNames && { resolvedNames }),
                     line: node.startPosition.row + 1,
+                    callStart: node.startIndex,
+                    callEnd: node.endIndex,
                     isMethod: false,
                     ...(assignedTo && { assignedTo }),
                     enclosingFunction,
@@ -2054,6 +2342,8 @@ function findCallsInCode(code, parser) {
                 calls.push({
                     name: 'constructor',
                     line: node.startPosition.row + 1,
+                    callStart: node.startIndex,
+                    callEnd: node.endIndex,
                     isMethod: true,
                     receiver: 'super',
                     argCount: node.childForFieldName('arguments')?.namedChildCount ?? 0,
@@ -2089,12 +2379,32 @@ function findCallsInCode(code, parser) {
                             const innerProp = objNode.childForFieldName('property');
                             const innerObj = objNode.childForFieldName('object');
                             if (innerProp) {
+                                const prototypeOwner = innerObj?.type === 'member_expression' &&
+                                    innerObj.childForFieldName('property')?.text === 'prototype' &&
+                                    innerObj.childForFieldName('object')?.type === 'identifier'
+                                    ? innerObj.childForFieldName('object').text
+                                    : undefined;
+                                const boundReceiver = prototypeOwner ||
+                                    (innerObj?.type === 'identifier'
+                                        ? innerObj.text : innerObj?.text);
+                                const boundReceiverType = prototypeOwner ||
+                                    (innerObj?.type === 'identifier'
+                                        ? localVarTypes.get(innerObj.text) : undefined);
                                 calls.push({
                                     name: innerProp.text,
                                     line: node.startPosition.row + 1,
                                     isMethod: true,
                                     boundCall: true,
-                                    receiver: innerObj?.text,
+                                    receiver: boundReceiver,
+                                    ...(boundReceiverType && { receiverType: boundReceiverType }),
+                                    ...(innerObj?.type === 'identifier' &&
+                                        localVarTypeQualifiers.has(innerObj.text) && {
+                                            receiverTypeQualifier: localVarTypeQualifiers.get(innerObj.text),
+                                        }),
+                                    ...(innerObj?.type === 'identifier' &&
+                                        isShadowedByLocal(innerObj, innerObj.text) && {
+                                            receiverLocalBinding: true,
+                                        }),
                                     enclosingFunction,
                                     uncertain
                                 });
@@ -2115,17 +2425,26 @@ function findCallsInCode(code, parser) {
                         // field's DECLARED type annotation. `this`-rooted hops
                         // resolve their root type query-side (the enclosing
                         // class); identifier roots type from local annotations.
-                        let receiverRoot, receiverFieldName, receiverRootType;
+                        let receiverRoot, receiverFieldName, receiverRootType, receiverBindingNode;
+                        let receiverDeepPath = false;
+                        if (receiver && objNode?.type === 'identifier') receiverBindingNode = objNode;
                         if (!receiver && objNode && objNode.type === 'member_expression') {
                             const rootNode = objNode.childForFieldName('object');
                             const fldNode = objNode.childForFieldName('property');
                             if (fldNode && rootNode &&
                                 (rootNode.type === 'identifier' || rootNode.type === 'this')) {
                                 receiverRoot = rootNode.text;
+                                receiverBindingNode = rootNode.type === 'identifier' ? rootNode : undefined;
                                 receiverFieldName = fldNode.text;
                                 if (rootNode.type === 'identifier') {
                                     receiverRootType = localVarTypes.get(rootNode.text);
                                 }
+                            } else {
+                                // Preserve unresolved deeper member chains
+                                // (`client.req.query()`). Their terminal name
+                                // must not borrow a same-file method binding
+                                // while the root object's type is unknown.
+                                receiverDeepPath = true;
                             }
                         }
                         // Chained receiver (fix #219): the receiver IS a call —
@@ -2133,6 +2452,7 @@ function findCallsInCode(code, parser) {
                         // findCallers can type the receiver from its declared
                         // return annotation (Promise<...> → Promise).
                         let receiverCall, receiverCallIsMethod, receiverCallAwaited, receiverCallLine;
+                        let receiverCallStart, receiverCallEnd;
                         {
                             let recvNode = objNode;
                             if (recvNode && recvNode.type === 'parenthesized_expression') {
@@ -2149,6 +2469,8 @@ function findCallsInCode(code, parser) {
                                     // Producer link (fix #258): plain-call
                                     // records carry the call node's start line
                                     receiverCallLine = recvNode.startPosition.row + 1;
+                                    receiverCallStart = recvNode.startIndex;
+                                    receiverCallEnd = recvNode.endIndex;
                                 } else if (prodFunc?.type === 'member_expression') {
                                     const prodProp = prodFunc.childForFieldName('property');
                                     if (prodProp) {
@@ -2157,6 +2479,8 @@ function findCallsInCode(code, parser) {
                                         // Method records report the property
                                         // node's own line
                                         receiverCallLine = prodProp.startPosition.row + 1;
+                                        receiverCallStart = recvNode.startIndex;
+                                        receiverCallEnd = recvNode.endIndex;
                                     }
                                 }
                             }
@@ -2164,13 +2488,25 @@ function findCallsInCode(code, parser) {
                         }
                         // Literal receivers carry their builtin type: [].map() can
                         // never be a project class method
+                        // A freshly constructed receiver has an exact runtime
+                        // type as well: new Service().start(). Recording it here
+                        // avoids treating the call as an untyped method dispatch.
+                        const constructedReceiverType = objNode?.type === 'new_expression'
+                            ? jsConstructorTypeName(objNode.childForFieldName('constructor'))
+                            : undefined;
+                        const constructedReceiverQualifier = objNode?.type === 'new_expression'
+                            ? jsConstructorTypeQualifier(objNode.childForFieldName('constructor'))
+                            : undefined;
                         const receiverType = receiver
                             ? localVarTypes.get(receiver)
-                            : (objNode ? JS_LITERAL_RECEIVER_TYPES[objNode.type] : undefined);
+                            : (constructedReceiverType ||
+                                (objNode ? JS_LITERAL_RECEIVER_TYPES[objNode.type] : undefined));
                         // Module receiver (ns.helper()) — unless locally shadowed
                         // by a typed instance binding
-                        const receiverIsModule = !!receiver && moduleAliases.has(receiver) &&
-                            !localVarTypes.has(receiver);
+                        const receiverModuleSpecifier = jsLiteralRequireModule(objNode);
+                        const receiverIsModule = !!receiverModuleSpecifier ||
+                            (!!receiver && moduleAliases.has(receiver) &&
+                                !localVarTypes.has(receiver));
                         const firstArg = getFirstStringArg(node);
                         const argCount = getArgCount(node);
                         const assignedTo = jsAssignmentTargetOf(node);
@@ -2181,16 +2517,33 @@ function findCallsInCode(code, parser) {
                             // line — the account's ground set is keyed by the
                             // name's line
                             line: propNode.startPosition.row + 1,
+                            callStart: node.startIndex,
+                            callEnd: node.endIndex,
                             isMethod: true,
                             receiver,
                             ...(receiverType && { receiverType }),
+                            ...((constructedReceiverQualifier ||
+                                (receiver && localVarTypeQualifiers.get(receiver))) && {
+                                receiverTypeQualifier: constructedReceiverQualifier ||
+                                    localVarTypeQualifiers.get(receiver),
+                            }),
                             ...(receiverIsModule && { receiverIsModule: true }),
+                            ...(receiverModuleSpecifier && { receiverModuleSpecifier }),
+                            ...(receiver && assignedMembers.has(`${receiver}.${propName}`) && {
+                                receiverMemberAssigned: true,
+                            }),
+                            ...(receiverBindingNode &&
+                                isShadowedByLocal(receiverBindingNode, receiverBindingNode.text) &&
+                                { receiverLocalBinding: true }),
                             ...(receiverFieldName && { receiverRoot, receiverField: receiverFieldName }),
                             ...(receiverFieldName && receiverRootType && { receiverRootType }),
+                            ...(receiverDeepPath && { receiverDeepPath: true }),
                             ...(receiverCall && { receiverCall }),
                             ...(receiverCallIsMethod && { receiverCallIsMethod: true }),
                             ...(receiverCallAwaited && { receiverCallAwaited: true }),
                             ...(receiverCallLine && { receiverCallLine }),
+                            ...(receiverCallStart != null && { receiverCallStart }),
+                            ...(receiverCallEnd != null && { receiverCallEnd }),
                             ...(assignedTo && { assignedTo }),
                             enclosingFunction,
                             uncertain,
@@ -2315,6 +2668,7 @@ function findCallsInCode(code, parser) {
                         line: node.startPosition.row + 1,
                         isMethod: false,
                         isConstructor: true,
+                        ...(isShadowedByLocal(ctorNode, ctorNode.text) && { localShadow: true }),
                         enclosingFunction
                     });
                 } else if (ctorNode.type === 'member_expression') {
@@ -2426,6 +2780,11 @@ function findCallsInCode(code, parser) {
                     localVarTypes.clear();
                     for (const [k, v] of saved) localVarTypes.set(k, v);
                 }
+                const savedQualifiers = localVarTypeQualifiersStack.pop();
+                if (savedQualifiers) {
+                    localVarTypeQualifiers.clear();
+                    for (const [k, v] of savedQualifiers) localVarTypeQualifiers.set(k, v);
+                }
                 const savedDeclared = declaredTypeVarsStack.pop();
                 if (savedDeclared) {
                     declaredTypeVars.clear();
@@ -2733,11 +3092,17 @@ function findImportsInCode(code, parser) {
 
                     // Check parent for variable name
                     let parent = node.parent;
+                    let defaultLike = false;
                     if (parent && parent.type === 'variable_declarator') {
                         const nameNode = parent.childForFieldName('name');
                         if (nameNode) {
                             if (nameNode.type === 'identifier') {
                                 names.push(nameNode.text);
+                                // `const app = require('./app')` binds the
+                                // value assigned to `module.exports`, not a
+                                // named property called `app`. Preserve that
+                                // distinction for exact import ownership.
+                                defaultLike = true;
                             } else if (nameNode.type === 'object_pattern') {
                                 // Destructuring: const { a, b } = require('x')
                                 for (let i = 0; i < nameNode.namedChildCount; i++) {
@@ -2762,6 +3127,7 @@ function findImportsInCode(code, parser) {
 
                     if (modulePath) {
                         imports.push({ module: modulePath, names, type: 'require', line, dynamic,
+                            ...(defaultLike && { defaultLike: true }),
                             // Per-import rename pairing (fix #269): the flat
                             // importAliases list loses WHICH module a renamed
                             // name came from — `{ validate: validateSchema }`
@@ -2985,10 +3351,16 @@ function findExportsInCode(code, parser) {
                             for (let i = 0; i < rightNode.namedChildCount; i++) {
                                 const prop = rightNode.namedChild(i);
                                 if (prop.type === 'shorthand_property_identifier') {
-                                    exports.push({ name: prop.text, type: 'module.exports', line });
+                                    exports.push({ name: prop.text, localName: prop.text, type: 'module.exports', line });
                                 } else if (prop.type === 'pair') {
                                     const key = prop.childForFieldName('key');
-                                    if (key) exports.push({ name: key.text, type: 'module.exports', line });
+                                    const value = prop.childForFieldName('value');
+                                    if (key) exports.push({
+                                        name: key.text,
+                                        ...(value?.type === 'identifier' && { localName: value.text }),
+                                        type: 'module.exports',
+                                        line,
+                                    });
                                 } else if (prop.type === 'method_definition') {
                                     // Shorthand methods are exports too
                                     // (fix #252 — `module.exports =
@@ -2996,12 +3368,41 @@ function findExportsInCode(code, parser) {
                                     // export list, so deadcode audited a
                                     // require()-reachable function).
                                     const mName = prop.childForFieldName('name');
-                                    if (mName) exports.push({ name: mName.text, type: 'module.exports', line });
+                                    if (mName) exports.push({ name: mName.text, localName: mName.text, type: 'module.exports', line });
+                                } else if (prop.type === 'spread_element') {
+                                    // CommonJS barrel: `module.exports = {
+                                    // ...require('./public') }`. This is the
+                                    // CJS equivalent of `export * from` and
+                                    // must retain its SOURCE so namespace
+                                    // calls through the barrel can establish
+                                    // name ownership. A dynamic spread stays
+                                    // an explicitly unmodelable CJS surface.
+                                    const value = prop.namedChild(0);
+                                    const fn = value?.type === 'call_expression'
+                                        ? value.childForFieldName('function') : null;
+                                    const args = value?.type === 'call_expression'
+                                        ? value.childForFieldName('arguments') : null;
+                                    const first = args?.namedChild(0);
+                                    if (fn?.type === 'identifier' && fn.text === 'require' &&
+                                        first?.type === 'string') {
+                                        exports.push({
+                                            name: '*',
+                                            type: 're-export-all',
+                                            line,
+                                            source: first.text.slice(1, -1),
+                                        });
+                                    } else {
+                                        exports.push({
+                                            name: '*',
+                                            type: 'module.exports',
+                                            line,
+                                        });
+                                    }
                                 }
                             }
                         } else if (rightNode && rightNode.type === 'identifier') {
                             // module.exports = something
-                            exports.push({ name: rightNode.text, type: 'module.exports', line });
+                            exports.push({ name: rightNode.text, localName: rightNode.text, type: 'module.exports', line });
                         } else {
                             exports.push({ name: 'default', type: 'module.exports', line });
                         }
@@ -3011,7 +3412,13 @@ function findExportsInCode(code, parser) {
                     // exports.name = ...
                     if (objNode.text === 'exports') {
                         const line = node.startPosition.row + 1;
-                        exports.push({ name: propNode.text, type: 'exports', line });
+                        const rightNode = node.childForFieldName('right');
+                        exports.push({
+                            name: propNode.text,
+                            ...(rightNode?.type === 'identifier' && { localName: rightNode.text }),
+                            type: 'exports',
+                            line,
+                        });
                         return true;
                     }
 
@@ -3046,12 +3453,14 @@ function findUsagesInCode(code, name, parser, tree) {
 
     visitNameNodes(tree, code, name, (node) => {
         // Look for identifier, property_identifier (method names in obj.method() calls),
+        // private_property_identifier (#method definitions and calls),
         // type_identifier (TypeScript type annotations), shorthand_property_identifier_pattern
         // (destructured names in `const { name } = require(...)`), and
         // shorthand_property_identifier (value-position shorthand — CJS export
         // objects `module.exports = { helper }` and option objects `f({ helper })`
         // reference the symbol but produced no usage record at all, fix #241)
         const isIdentifier = node.type === 'identifier' || node.type === 'property_identifier' ||
+            node.type === 'private_property_identifier' ||
             node.type === 'type_identifier' || node.type === 'shorthand_property_identifier_pattern' ||
             node.type === 'shorthand_property_identifier';
         if (!isIdentifier || node.text !== name) {
@@ -3155,17 +3564,11 @@ function findUsagesInCode(code, name, parser, tree) {
             // Property access (method call): a.name() - the name after dot
             else if (parent.type === 'member_expression' &&
                      sameNode(parent.childForFieldName('property'), node)) {
-                // Skip built-in objects and common module names (JSON.parse, path.parse, etc.)
+                // Preserve the receiver and let the project-aware usage layer
+                // decide ownership. A spelling such as `util` or `path` can be
+                // either a standard module or a local project namespace, which
+                // cannot be decided correctly from this file's AST alone.
                 const object = parent.childForFieldName('object');
-                const builtins = [
-                    // JS built-in objects
-                    'JSON', 'Math', 'console', 'Object', 'Array', 'String', 'Number', 'Date', 'RegExp', 'Promise', 'Reflect', 'Proxy', 'Map', 'Set', 'WeakMap', 'WeakSet', 'Symbol', 'Intl', 'WebAssembly', 'Atomics', 'SharedArrayBuffer', 'ArrayBuffer', 'DataView', 'Int8Array', 'Uint8Array', 'Uint8ClampedArray', 'Int16Array', 'Uint16Array', 'Int32Array', 'Uint32Array', 'Float32Array', 'Float64Array', 'BigInt64Array', 'BigUint64Array', 'Error', 'EvalError', 'RangeError', 'ReferenceError', 'SyntaxError', 'TypeError', 'URIError', 'URL', 'URLSearchParams',
-                    // Node.js core modules
-                    'path', 'fs', 'os', 'http', 'https', 'net', 'dgram', 'dns', 'tls', 'crypto', 'zlib', 'stream', 'util', 'events', 'buffer', 'child_process', 'cluster', 'readline', 'repl', 'vm', 'assert', 'querystring', 'url', 'punycode', 'string_decoder', 'timers', 'tty', 'v8', 'perf_hooks', 'worker_threads', 'inspector', 'trace_events', 'async_hooks', 'process'
-                ];
-                if (object && object.type === 'identifier' && builtins.includes(object.text)) {
-                    return true; // Skip built-in method calls
-                }
                 // Check if this is a method call
                 const grandparent = parent.parent;
                 if (grandparent && grandparent.type === 'call_expression') {