ucn 3.8.25 → 4.0.0

package/languages/javascript.js

@@ -12,7 +12,8 @@ const {
     extractParams,
     parseStructuredParams,
     extractJSDocstring,
-    buildTypeAnnotations
+    buildTypeAnnotations,
+    visitNameNodes,
 } = require('./utils');
 const { PARSE_OPTIONS, safeParse } = require('./index');
 
@@ -38,6 +39,27 @@ function extractReturnType(node) {
     return null;
 }
 
+/**
+ * Base type name from a type-alias target (fix #208, TS): ZodType<any, any>
+ * → ZodType, ns.Type → Type, (T) → T. Unions, intersections, object/function
+ * types, mapped/conditional types, and predefined types return null — they
+ * are not single-type identities a method receiver can be resolved through.
+ */
+function aliasBaseTypeName(typeNode) {
+    if (!typeNode) return null;
+    if (typeNode.type === 'type_identifier') return typeNode.text;
+    if (typeNode.type === 'nested_type_identifier') {
+        return typeNode.childForFieldName('name')?.text || null;
+    }
+    if (typeNode.type === 'generic_type') {
+        return aliasBaseTypeName(typeNode.childForFieldName('name') || typeNode.namedChild(0));
+    }
+    if (typeNode.type === 'parenthesized_type') {
+        return aliasBaseTypeName(typeNode.namedChild(0));
+    }
+    return null;
+}
+
 /**
  * Check if function is a generator
  * @param {object} node - Function node
@@ -622,6 +644,11 @@ function _processClass(node, classes, processedRanges, lines) {
         if (nameNode) {
             const { startLine, endLine } = nodeToLocation(node, lines);
             const docstring = extractJSDocstring(lines, startLine);
+            // `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'));
 
             classes.push({
                 name: nameNode.text,
@@ -629,6 +656,7 @@ function _processClass(node, classes, processedRanges, lines) {
                 endLine,
                 type: 'type',
                 members: [],
+                ...(aliasOf && { aliasOf }),
                 ...(docstring && { docstring })
             });
         }
@@ -818,11 +846,18 @@ function extractInterfaceMembers(interfaceNode, code) {
             const nameNode = child.childForFieldName('name');
             if (nameNode) {
                 const { startLine, endLine } = nodeToLocation(child, code);
+                // Declared property type (fix #219): raw annotation text —
+                // findCallers hops field receivers to it (this._map.has()),
+                // and function-typed properties ((arg) => T) count as
+                // callable owners in the dispatch tiering.
+                const typeNode = child.childForFieldName('type');
+                const fieldType = typeNode ? typeNode.text.replace(/^:\s*/, '').trim() : undefined;
                 members.push({
                     name: nameNode.text,
                     startLine,
                     endLine,
-                    memberType: 'field'
+                    memberType: 'field',
+                    ...(fieldType && { fieldType })
                 });
             }
         }
@@ -1030,11 +1065,18 @@ function extractClassMembers(classNode, codeOrLines) {
                         ...(fieldDecorators.length > 0 && { decorators: fieldDecorators })
                     });
                 } else {
+                    // Declared field type (fix #219): `_map: WeakMap<K,V> =
+                    // new WeakMap()` — the annotation is the compiler-true
+                    // contract for every receiver hop through this field.
+                    const fieldTypeNode = child.childForFieldName('type');
+                    const fieldType = fieldTypeNode
+                        ? fieldTypeNode.text.replace(/^:\s*/, '').trim() : undefined;
                     members.push({
                         name,
                         startLine,
                         endLine,
                         memberType: name.startsWith('#') ? 'private field' : 'field',
+                        ...(fieldType && { fieldType }),
                         ...(fieldDecorators.length > 0 && { decorators: fieldDecorators })
                         // Not a method - regular field
                     });
@@ -1149,6 +1191,97 @@ function parse(code, parser) {
  * @param {object} parser - Tree-sitter parser instance
  * @returns {Array<{name: string, line: number, isMethod: boolean, receiver?: string, isConstructor?: boolean}>}
  */
+// Builtin types for literal method receivers: [].map() is Array.map, never a
+// project class method. Keys are tree-sitter node types.
+const JS_LITERAL_RECEIVER_TYPES = {
+    array: 'Array',
+    string: 'String',
+    template_string: 'String',
+    object: 'Object',
+    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']);
+
+/**
+ * Extract a single concrete type name from a TS type node. Conservative by
+ * design: a wrong type would exclude true callers downstream
+ * (receiver-type-mismatch), so anything ambiguous returns undefined.
+ * Handles: Foo · ns.Foo · Foo | null · Store<string> · (Foo) · string
+ */
+function tsTypeName(node) {
+    if (!node) return undefined;
+    switch (node.type) {
+        case 'type_identifier':
+        case 'identifier':
+            return node.text;
+        case 'nested_type_identifier': {
+            // ns.Foo → classes match by name in the symbol table → last segment
+            const last = node.namedChild(node.namedChildCount - 1);
+            return last?.text;
+        }
+        case 'generic_type':
+            // Store<string> → Store
+            return tsTypeName(node.namedChild(0));
+        case 'union_type': {
+            // Foo | null / Foo | undefined → Foo; unions of two real types are ambiguous
+            const real = [];
+            for (let i = 0; i < node.namedChildCount; i++) {
+                const c = node.namedChild(i);
+                if (c.type === 'literal_type' ||
+                    (c.type === 'predefined_type' && !TS_PREDEFINED_RECEIVER_TYPES.has(c.text))) {
+                    continue;
+                }
+                real.push(c);
+            }
+            return real.length === 1 ? tsTypeName(real[0]) : undefined;
+        }
+        case 'parenthesized_type':
+            return tsTypeName(node.namedChild(0));
+        case 'predefined_type':
+            return TS_PREDEFINED_RECEIVER_TYPES.has(node.text) ? node.text : undefined;
+        default:
+            return undefined;
+    }
+}
+
+/**
+ * Variable receiving this call's result: `const x = foo()` / `x = await foo()`
+ * → 'x'. Identifier targets only. Compared by node id — tree-sitter wrapper
+ * objects are not identity-stable.
+ */
+function jsAssignmentTargetOf(callNode) {
+    let n = callNode;
+    let p = n.parent;
+    if (p && p.type === 'await_expression') { n = p; p = n.parent; }
+    if (p && p.type === 'variable_declarator') {
+        const value = p.childForFieldName('value');
+        const nameNode = p.childForFieldName('name');
+        if (value && value.id === n.id && nameNode?.type === 'identifier') return nameNode.text;
+    }
+    if (p && p.type === 'assignment_expression') {
+        const right = p.childForFieldName('right');
+        const left = p.childForFieldName('left');
+        if (right && right.id === n.id && left?.type === 'identifier') return left.text;
+    }
+    return undefined;
+}
+
+/**
+ * Type name from a new-expression constructor node: new Foo() or new pkg.Foo().
+ */
+function jsConstructorTypeName(ctorNode) {
+    if (!ctorNode) return undefined;
+    if (ctorNode.type === 'identifier') return ctorNode.text;
+    if (ctorNode.type === 'member_expression') {
+        const prop = ctorNode.childForFieldName('property');
+        return prop?.text;
+    }
+    return undefined;
+}
+
 function findCallsInCode(code, parser) {
     const tree = parseTree(parser, code);
     const calls = [];
@@ -1156,6 +1289,7 @@ 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)
+    const moduleAliases = new Set();  // Names bound to MODULES (import * as ns / const pkg = require(...))
     const localVarTypesStack = [];  // Stack for function-scoped save/restore of localVarTypes
 
     // Helper: extract first string-arg literal from a call_expression node.
@@ -1337,7 +1471,90 @@ function findCallsInCode(code, parser) {
             : null;
     };
 
+    // fix #203: does a declaration node declare `name` (incl. shallow 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;
+                }
+            }
+        }
+        return false;
+    };
+
+    // fix #203: is a bare-identifier function REFERENCE shadowed by a
+    // let/const/var local, for/catch binding, or inner-arrow param in an
+    // enclosing lexical scope? Block-accurate, declaration-before-use.
+    // The enclosing SYMBOL's params are checked at query time in
+    // findCallers — let locals and non-symbol arrow params are only
+    // visible here. Module-level (program) declarations are NOT shadows:
+    // that's the module binding itself, owned by binding resolution.
+    const isShadowedByLocal = (refNode, name) => {
+        for (let p = refNode.parent; p; p = p.parent) {
+            if (p.type === 'statement_block') {
+                for (let i = 0; i < p.namedChildCount; i++) {
+                    const stmt = p.namedChild(i);
+                    // Nested function/class declarations are hoisted within
+                    // their block — they shadow regardless of position
+                    // (fix #218: `function getStyle() {}` after the ref).
+                    if ((stmt.type === 'function_declaration' ||
+                        stmt.type === 'generator_function_declaration' ||
+                        stmt.type === 'class_declaration') &&
+                        stmt.childForFieldName('name')?.text === name) return true;
+                    if (stmt.startIndex >= refNode.startIndex) continue; // declaration-before-use
+                    if ((stmt.type === 'lexical_declaration' || stmt.type === 'variable_declaration') &&
+                        _declaresName(stmt, name)) return true;
+                }
+            } else if (p.type === 'for_statement') {
+                const init = p.childForFieldName('initializer');
+                if (init && (init.type === 'lexical_declaration' || init.type === 'variable_declaration') &&
+                    _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 (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;
+            } 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 => ...
+                    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;
+                        }
+                    }
+                }
+            }
+        }
+        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
+        // class methods.
+        if (node.type === 'namespace_import') {
+            const id = node.namedChild(0);
+            if (id?.type === 'identifier') moduleAliases.add(id.text);
+        }
+
         // Track function entry
         if (isFunctionNode(node)) {
             functionStack.push({
@@ -1353,6 +1570,13 @@ function findCallsInCode(code, parser) {
         if (node.type === 'variable_declarator') {
             const nameNode = node.childForFieldName('name');
             const initNode = node.childForFieldName('value');
+            // const pkg = require("./lib") — pkg is a module namespace
+            if (nameNode?.type === 'identifier' && initNode?.type === 'call_expression') {
+                const fn = initNode.childForFieldName('function');
+                if (fn?.type === 'identifier' && fn.text === 'require') {
+                    moduleAliases.add(nameNode.text);
+                }
+            }
             if (nameNode?.type === 'identifier' && initNode?.type === 'identifier') {
                 // Simple alias: const p = parse
                 aliases.set(nameNode.text, initNode.text);
@@ -1388,10 +1612,10 @@ function findCallsInCode(code, parser) {
             // Constructor results are object instances, not callable functions
             if (nameNode?.type === 'identifier' && initNode?.type === 'new_expression') {
                 nonCallableNames.add(nameNode.text);
-                // Infer type: const x = new Foo() → x is Foo
-                const ctorNode = initNode.childForFieldName('constructor');
-                if (ctorNode?.type === 'identifier') {
-                    localVarTypes.set(nameNode.text, ctorNode.text);
+                // Infer type: const x = new Foo() / new pkg.Foo() → x is Foo
+                const ctorName = jsConstructorTypeName(initNode.childForFieldName('constructor'));
+                if (ctorName) {
+                    localVarTypes.set(nameNode.text, ctorName);
                 }
             }
             // Track TypeScript type annotations: const x: Foo = ...
@@ -1401,28 +1625,36 @@ function findCallsInCode(code, parser) {
                     // type_annotation → first named child is the type identifier
                     const typeId = typeNode.type === 'type_annotation'
                         ? typeNode.namedChild(0) : typeNode;
-                    if (typeId?.type === 'type_identifier' || typeId?.type === 'identifier') {
-                        localVarTypes.set(nameNode.text, typeId.text);
-                    } else if (typeId?.type === 'generic_type') {
-                        // Store<string> → generic_type has type_identifier as first child
-                        const baseType = typeId.namedChild(0);
-                        if (baseType?.type === 'type_identifier' || baseType?.type === 'identifier') {
-                            localVarTypes.set(nameNode.text, baseType.text);
-                        }
+                    const typeName = tsTypeName(typeId);
+                    if (typeName) {
+                        localVarTypes.set(nameNode.text, typeName);
                     }
                 }
             }
         }
 
+        // Track TS parameter type annotations: function f(client: Client) → client is Client
+        if (node.type === 'required_parameter' || node.type === 'optional_parameter') {
+            const pat = node.childForFieldName('pattern') || node.namedChild(0);
+            const typeNode = node.childForFieldName('type');
+            if (pat?.type === 'identifier' && typeNode) {
+                const inner = typeNode.type === 'type_annotation' ? typeNode.namedChild(0) : typeNode;
+                const typeName = tsTypeName(inner);
+                if (typeName) {
+                    localVarTypes.set(pat.text, typeName);
+                }
+            }
+        }
+
         // Track reassignment with new expression: x = new Bar() → update localVarTypes
         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 ctorNode = right.childForFieldName('constructor');
-                if (ctorNode?.type === 'identifier') {
-                    localVarTypes.set(left.text, ctorNode.text);
+                const ctorName = jsConstructorTypeName(right.childForFieldName('constructor'));
+                if (ctorName) {
+                    localVarTypes.set(left.text, ctorName);
                 }
             }
         }
@@ -1445,6 +1677,7 @@ function findCallsInCode(code, parser) {
                 const resolvedName = typeof alias === 'string' ? alias : undefined;
                 const resolvedNames = Array.isArray(alias) ? alias : undefined;
                 const firstArg = getFirstStringArg(node);
+                const assignedTo = jsAssignmentTargetOf(node);
                 // MEDIUM-5: capture explicit method for fetch(url, { method }).
                 const optionsMethod = funcNode.text === 'fetch'
                     ? getOptionsMethod(node, 1)
@@ -1455,6 +1688,7 @@ function findCallsInCode(code, parser) {
                     ...(resolvedNames && { resolvedNames }),
                     line: node.startPosition.row + 1,
                     isMethod: false,
+                    ...(assignedTo && { assignedTo }),
                     enclosingFunction,
                     uncertain,
                     ...(firstArg && { firstStringArg: firstArg.value, firstStringArgInterp: firstArg.interp }),
@@ -1468,7 +1702,12 @@ function findCallsInCode(code, parser) {
                 if (propNode) {
                     const propName = propNode.text;
 
-                    // Handle .call(), .apply(), .bind() - these are calls TO the object
+                    // Handle .call(), .apply(), .bind() - these are calls TO the object.
+                    // boundCall marks the indirection (fix #221, family B): the line
+                    // establishes the call relationship through Function.prototype
+                    // rather than direct call syntax — the edge surfaces as
+                    // calledAs:'bound' so consumers know reference oracles see a
+                    // non-call reference here.
                     if (['call', 'apply', 'bind'].includes(propName) && objNode) {
                         if (objNode.type === 'identifier') {
                             // foo.call() -> call to foo
@@ -1476,6 +1715,7 @@ function findCallsInCode(code, parser) {
                                 name: objNode.text,
                                 line: node.startPosition.row + 1,
                                 isMethod: false,
+                                boundCall: true,
                                 enclosingFunction
                             });
                         } else if (objNode.type === 'member_expression') {
@@ -1487,6 +1727,7 @@ function findCallsInCode(code, parser) {
                                     name: innerProp.text,
                                     line: node.startPosition.row + 1,
                                     isMethod: true,
+                                    boundCall: true,
                                     receiver: innerObj?.text,
                                     enclosingFunction,
                                     uncertain
@@ -1502,15 +1743,82 @@ function findCallsInCode(code, parser) {
                                 receiver = objNode.text;
                             }
                         }
-                        const receiverType = receiver ? localVarTypes.get(receiver) : undefined;
+                        // One-hop field receiver (fix #219 — #202's shape for
+                        // structural): this._map.has(x) / def.cache.get(k) —
+                        // receiverRoot/Field let findCallers hop to the
+                        // 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;
+                        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;
+                                receiverFieldName = fldNode.text;
+                                if (rootNode.type === 'identifier') {
+                                    receiverRootType = localVarTypes.get(rootNode.text);
+                                }
+                            }
+                        }
+                        // Chained receiver (fix #219): the receiver IS a call —
+                        // parseAsync(args).catch(...) — record the producer so
+                        // findCallers can type the receiver from its declared
+                        // return annotation (Promise<...> → Promise).
+                        let receiverCall, receiverCallIsMethod, receiverCallAwaited;
+                        {
+                            let recvNode = objNode;
+                            if (recvNode && recvNode.type === 'parenthesized_expression') {
+                                recvNode = recvNode.namedChild(0);
+                            }
+                            if (recvNode && recvNode.type === 'await_expression') {
+                                receiverCallAwaited = true;
+                                recvNode = recvNode.namedChild(0);
+                            }
+                            if (recvNode && recvNode.type === 'call_expression') {
+                                const prodFunc = recvNode.childForFieldName('function');
+                                if (prodFunc?.type === 'identifier') {
+                                    receiverCall = prodFunc.text;
+                                } else if (prodFunc?.type === 'member_expression') {
+                                    const prodProp = prodFunc.childForFieldName('property');
+                                    if (prodProp) {
+                                        receiverCall = prodProp.text;
+                                        receiverCallIsMethod = true;
+                                    }
+                                }
+                            }
+                            if (!receiverCall) receiverCallAwaited = undefined;
+                        }
+                        // Literal receivers carry their builtin type: [].map() can
+                        // never be a project class method
+                        const receiverType = receiver
+                            ? localVarTypes.get(receiver)
+                            : (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 firstArg = getFirstStringArg(node);
                         const argCount = getArgCount(node);
+                        const assignedTo = jsAssignmentTargetOf(node);
                         calls.push({
                             name: propName,
-                            line: node.startPosition.row + 1,
+                            // Multi-line chains (builder.x()\n.y()) must report
+                            // each method's OWN name line, not the chain-start
+                            // line — the account's ground set is keyed by the
+                            // name's line
+                            line: propNode.startPosition.row + 1,
                             isMethod: true,
                             receiver,
                             ...(receiverType && { receiverType }),
+                            ...(receiverIsModule && { receiverIsModule: true }),
+                            ...(receiverFieldName && { receiverRoot, receiverField: receiverFieldName }),
+                            ...(receiverFieldName && receiverRootType && { receiverRootType }),
+                            ...(receiverCall && { receiverCall }),
+                            ...(receiverCallIsMethod && { receiverCallIsMethod: true }),
+                            ...(receiverCallAwaited && { receiverCallAwaited: true }),
+                            ...(assignedTo && { assignedTo }),
                             enclosingFunction,
                             uncertain,
                             ...(firstArg && { firstStringArg: firstArg.value, firstStringArgInterp: firstArg.interp }),
@@ -1551,6 +1859,7 @@ function findCallsInCode(code, parser) {
                                     line: arg.startPosition.row + 1,
                                     isMethod: false,
                                     isFunctionReference: true,
+                                    ...(isShadowedByLocal(arg, arg.text) && { localShadow: true }),
                                     enclosingFunction
                                 });
                             } else if (arg.type === 'member_expression') {
@@ -1589,6 +1898,7 @@ function findCallsInCode(code, parser) {
                                 isMethod: false,
                                 isFunctionReference: true,
                                 isPotentialCallback: true,
+                                ...(isShadowedByLocal(arg, arg.text) && { localShadow: true }),
                                 enclosingFunction
                             });
                         }
@@ -1606,6 +1916,7 @@ function findCallsInCode(code, parser) {
                                             isMethod: false,
                                             isFunctionReference: true,
                                             isPotentialCallback: true,
+                                            ...(isShadowedByLocal(val, val.text) && { localShadow: true }),
                                             enclosingFunction
                                         });
                                     }
@@ -1708,6 +2019,7 @@ function findCallsInCode(code, parser) {
                         isMethod: false,
                         isFunctionReference: true,
                         isPotentialCallback: true,
+                        ...(isShadowedByLocal(child, child.text) && { localShadow: true }),
                         enclosingFunction
                     });
                 } else if (child.type === 'member_expression') {
@@ -2107,7 +2419,20 @@ function findExportsInCode(code, parser) {
 
             // Check for export * from 'x'
             if (node.text.includes('export *') && source) {
-                exports.push({ name: '*', type: 're-export-all', line, source });
+                // `export * as ns from 'x'` exposes ONLY the single name `ns`
+                // (a module namespace object), not x's flattened surface —
+                // record the alias so name-level chases don't walk through it
+                // (fix #218: zod's `export * as core` made z._default look
+                // reachable from core). Name stays '*' for shape stability.
+                let nsAlias = null;
+                for (let i = 0; i < node.namedChildCount; i++) {
+                    const child = node.namedChild(i);
+                    if (child.type === 'namespace_export') {
+                        const id = child.namedChild(0);
+                        if (id) nsAlias = id.text;
+                    }
+                }
+                exports.push({ name: '*', type: 're-export-all', line, source, ...(nsAlias && { alias: nsAlias }) });
                 return true;
             }
 
@@ -2118,10 +2443,18 @@ function findExportsInCode(code, parser) {
                     for (let j = 0; j < child.namedChildCount; j++) {
                         const specifier = child.namedChild(j);
                         if (specifier.type === 'export_specifier') {
-                            const nameNode = specifier.namedChild(0);
+                            const nameNode = specifier.childForFieldName('name') || specifier.namedChild(0);
+                            // Export rename: `export { _gt as gt }` — name keeps the
+                            // local/source symbol (deadcode and re-export resolution
+                            // key on it); alias carries the external name callers use.
+                            const aliasNode = specifier.childForFieldName('alias');
                             if (nameNode) {
                                 const exportType = source ? 're-export' : 'named';
-                                exports.push({ name: nameNode.text, type: exportType, line, ...(source && { source }) });
+                                exports.push({
+                                    name: nameNode.text, type: exportType, line,
+                                    ...(source && { source }),
+                                    ...(aliasNode && aliasNode.text !== nameNode.text && { alias: aliasNode.text }),
+                                });
                             }
                         }
                     }
@@ -2267,7 +2600,7 @@ function findUsagesInCode(code, name, parser) {
     const tree = parseTree(parser, code);
     const usages = [];
 
-    traverseTreeCached(tree.rootNode, (node) => {
+    visitNameNodes(tree, code, name, (node) => {
         // Look for identifier, property_identifier (method names in obj.method() calls),
         // type_identifier (TypeScript type annotations), and shorthand_property_identifier_pattern
         // (destructured names in `const { name } = require(...)`)