ucn 5.0.6 → 5.1.1

package/core/index-ir.js

@@ -16,6 +16,7 @@ function createImportBindings(imports) {
             return {
                 name,
                 module: item.module,
+                ...(item.type && { kind: item.type }),
                 ...(item.line != null && { line: item.line }),
                 ...(rename && { alias: rename.local }),
                 ...(item.defaultLike && { defaultLike: true }),
@@ -69,13 +70,14 @@ const OPTIONAL_SYMBOL_FIELDS = Object.freeze([
     'enclosingType', 'isMethod', 'receiver', 'memberType', 'fieldType',
     'aliasOf', 'derefTarget', 'decorators', 'decoratorsWithArgs',
     'annotationsWithArgs', 'attributesWithArgs', 'nameLine', 'traitImpl',
-    'traitName', 'isSignature', 'memberAssigned', 'bodyScopedName',
+    'traitName', 'isSignature', 'memberAssigned', 'assignedReceiver', 'bodyScopedName',
     'registryMember', 'registryContainer', 'namespace',
     'isExtensionMethod', 'extensionReceiver', 'explicitInterface',
     'lexicalScopeStartLine', 'lexicalScopeEndLine',
     'returnTypeQualifier', 'macroNeverReturns', 'callbackParamTypes', 'iteratorItemType',
     'returnedConcreteType', 'returnedConstructors', 'templateDependent',
-    'linkage', 'functionLike',
+    'linkage', 'functionLike', 'callableAlias', 'exportedAlias',
+    'aliasOwner', 'aliasMember',
 ]);
 
 function materializeSymbol(fileEntry, item) {
@@ -91,7 +93,9 @@ function materializeSymbol(fileEntry, item) {
         returnType: item.returnType,
         modifiers: item.modifiers,
         docstring: item.docstring,
-        bindingId: `${fileEntry.relativePath}:${item.kind}:${item.startLine}`,
+        bindingId: item.id
+            ? `${fileEntry.relativePath}:${item.id}`
+            : `${fileEntry.relativePath}:${item.kind}:${item.startLine}`,
         ...(item.owner && { className: item.owner }),
     };
     for (const field of OPTIONAL_SYMBOL_FIELDS) {
@@ -109,7 +113,13 @@ function materializeSymbol(fileEntry, item) {
 function addIRSymbol(fileEntry, item, symbolTable = null) {
     const symbol = materializeSymbol(fileEntry, item);
     fileEntry.symbols.push(symbol);
-    if (!item.memberAssigned && !item.bodyScopedName) {
+    // A Rust `impl X`/`impl Trait for X` block introduces NO name into any
+    // scope (fix #286b, cursive-measured: the impl symbol stole the bare-name
+    // binding of ColorPair from the cross-file struct, excluding a compiler-
+    // true composite-literal caller as other-definition). The struct/enum
+    // claim covers the impl — same discipline as deadcode's CLASS_AUDIT_KINDS.
+    if (!item.memberAssigned && !item.bodyScopedName && !item.exportedAlias &&
+        item.kind !== 'impl') {
         fileEntry.bindings.push({
             id: symbol.bindingId,
             name: symbol.name,

package/core/ir.js

@@ -47,13 +47,14 @@ function normalizeSymbol(symbol, family, language, kind, owner = null) {
         'isNested', 'enclosingType', 'isMethod', 'memberType', 'fieldType',
         'aliasOf', 'derefTarget', 'decorators', 'decoratorsWithArgs',
         'annotationsWithArgs', 'attributesWithArgs', 'nameLine', 'traitImpl',
-        'traitName', 'isSignature', 'memberAssigned', 'bodyScopedName',
+        'traitName', 'isSignature', 'memberAssigned', 'assignedReceiver', 'bodyScopedName',
         'registryMember', 'registryContainer', 'isConstructor',
         'isExtensionMethod', 'extensionReceiver', 'explicitInterface',
         'namespace', 'lexicalScopeStartLine', 'lexicalScopeEndLine',
         'returnTypeQualifier', 'macroNeverReturns', 'callbackParamTypes', 'iteratorItemType',
         'returnedConcreteType', 'returnedConstructors', 'templateDependent',
-        'linkage', 'functionLike',
+        'linkage', 'functionLike', 'callableAlias', 'exportedAlias',
+        'aliasOwner', 'aliasMember',
     ];
     for (const field of passthrough) {
         if (symbol[field] !== undefined && symbol[field] !== null) {
@@ -114,6 +115,51 @@ function createFileIR({
     for (const symbol of stateObjects) append(symbol, 'state', 'state');
     for (const symbol of macros) append(symbol,
         symbol.functionLike ? 'callable' : 'state', 'macro');
+    // An immutable module-scope member alias has the callable signature of
+    // the class member it captures: `const make = Widget.create`. Materialize
+    // the local value and each explicit export alias as real function symbols
+    // only when its member is static and every declared return type agrees.
+    // This is compiler-visible identity; mutable aliases and ambiguous
+    // overload returns were rejected by the parser/agreement gate above.
+    for (const alias of (parsed.callableAliases || [])) {
+        const sources = normalizedSymbols.filter(symbol =>
+            symbol.name === alias.member && symbol.owner === alias.owner &&
+            (symbol.params !== undefined || symbol.paramsStructured) &&
+            (symbol.modifiers?.includes('static') ||
+                String(symbol.memberType || symbol.kind).startsWith('static')) &&
+            symbol.returnType);
+        if (sources.length === 0) continue;
+        const sourceReturns = new Set(sources.map(source => source.returnType));
+        if (sourceReturns.size !== 1) continue;
+        const source = sources[0];
+        const exported = (parsed.exports || []).filter(item =>
+            !item.source && item.name === alias.name);
+        const exposed = exported.map(item => ({
+            name: item.type === 'default' ? 'default' : (item.alias || item.name),
+            line: item.line || alias.startLine,
+        }));
+        const localIsExported = exposed.some(item => item.name === alias.name);
+        const makeAlias = (name, startLine, isExported, exportedAlias = false) => ({
+            bindingId: `callable-alias:${alias.owner}.${alias.member}:${name}:${startLine}`,
+            name,
+            startLine,
+            endLine: startLine,
+            params: source.params,
+            ...(source.paramsStructured && { paramsStructured: source.paramsStructured }),
+            returnType: source.returnType,
+            modifiers: isExported ? ['export'] : [],
+            callableAlias: true,
+            ...(exportedAlias && { exportedAlias: true }),
+            aliasOwner: alias.owner,
+            aliasMember: alias.member,
+        });
+        append(makeAlias(alias.name, alias.startLine, localIsExported),
+            'callable', 'function');
+        for (const item of exposed) {
+            if (item.name === alias.name) continue;
+            append(makeAlias(item.name, item.line, true, true), 'callable', 'function');
+        }
+    }
     const imports = [...(parsed.imports || [])];
     return {
         schemaVersion: IR_SCHEMA_VERSION,

package/core/output/analysis.js

@@ -74,6 +74,23 @@ function isTestEntry(entry) {
     return isTestPath(entry.relativePath || entry.file || '');
 }
 
+function formatAmbiguityCandidates(lines, ambiguity) {
+    if (!ambiguity?.items?.length) return;
+    const owners = ambiguity.dispatchOwners
+        ? `; ${ambiguity.dispatchOwners} dispatch owners` : '';
+    lines.push(`  competing definitions (${ambiguity.totalDefinitions}${owners}):`);
+    for (const candidate of ambiguity.items) {
+        const owner = candidate.owner
+            ? ` on ${candidate.owner}${candidate.memberAssignment ? ' (member assignment)' : ''}` : '';
+        const selected = candidate.selected ? ' [selected target]' : '';
+        lines.push(`    - ${candidate.handle} — ${candidate.type}${owner}${selected}`);
+    }
+    if (ambiguity.truncated) {
+        lines.push(`    (+${ambiguity.totalDefinitions - ambiguity.items.length} more — ` +
+            `use find ${ambiguity.name})`);
+    }
+}
+
 /**
  * Render the conservation contract lines: ACCOUNT and CONTRACT (always),
  * WARNING (unparsed files containing the symbol), FILTERED (display-filter
@@ -273,6 +290,9 @@ function formatContextJson(context) {
                             ? 'runtime-dispatch' : 'actionable-ambiguity'),
                     ...(c.dispatchFamily && { dispatchFamily: c.dispatchFamily }),
                 })),
+                ...(context.ambiguityCandidates && {
+                    ambiguityCandidates: context.ambiguityCandidates,
+                }),
                 ...(context.warnings && { warnings: context.warnings })
             }
         });
@@ -327,6 +347,9 @@ function formatContextJson(context) {
                         ? 'runtime-dispatch' : 'actionable-ambiguity'),
                 ...(c.dispatchFamily && { dispatchFamily: c.dispatchFamily }),
             })),
+            ...(context.ambiguityCandidates && {
+                ambiguityCandidates: context.ambiguityCandidates,
+            }),
             callees: callees.map(c => ({
                 name: c.name,
                 type: c.type,
@@ -427,6 +450,7 @@ function formatContext(ctx, options = {}) {
         const typeUnverified = ctx.unverifiedCallers || [];
         if (typeUnverified.length > 0) {
             lines.push(`\nCALLERS — UNVERIFIED (${typeUnverified.length}) — call syntax, no binding/receiver evidence:`);
+            formatAmbiguityCandidates(lines, ctx.ambiguityCandidates);
             const cap = 10;
             let shown = 0;
             for (const u of typeUnverified) {
@@ -653,6 +677,7 @@ function formatContext(ctx, options = {}) {
     // Always visible and capped at 10 one-liners unless --all.
     if (actionableUnverified.length > 0) {
         lines.push(`${compact ? '' : '\n'}CALLERS — UNVERIFIED (${actionableUnverified.length}) — call syntax, no binding/receiver evidence:`);
+        formatAmbiguityCandidates(lines, ctx.ambiguityCandidates);
         const cap = (ctx.meta && ctx.meta.all) ? Infinity : 10;
         let shown = 0;
         for (const u of actionableUnverified) {

package/core/output/shared.js

@@ -338,7 +338,7 @@ function formatGitLine(git) {
  * Display label for an unverified-tier entry's reason. Dispatch-tiered
  * entries (nominal languages) carry attribution metadata: the declared
  * supertype the call dispatches through (dispatchVia) and how many
- * same-name definitions the dispatch could land on (dispatchCandidates).
+ * distinct same-name owners the dispatch could land on (dispatchCandidates).
  */
 function unverifiedReasonLabel(entry) {
     if (!entry || !entry.reason) return '';
@@ -356,7 +356,7 @@ function unverifiedReasonLabel(entry) {
             : `possible-dispatch via ${entry.dispatchVia}`;
     }
     if (entry.reason === 'method-ambiguous' && entry.dispatchCandidates > 1) {
-        return `method-ambiguous — ${entry.dispatchCandidates} same-name definitions`;
+        return `method-ambiguous — ${entry.dispatchCandidates} dispatch owners`;
     }
     if (entry.reason === 'overload-ambiguous' && entry.dispatchCandidates > 1) {
         return `overload-ambiguous — 1 of ${entry.dispatchCandidates} applicable overloads`;

package/languages/javascript.js

@@ -435,6 +435,34 @@ function extractReturnedConcreteType(node) {
         ? types[0] : null;
 }
 
+/**
+ * Whether every explicit value-producing return yields the current receiver.
+ * A fallthrough/empty return cannot feed a subsequent chained call, so it does
+ * not compete with `this`; any other returned value makes the result unknown.
+ */
+function returnsReceiverSelf(node) {
+    const body = node.childForFieldName('body');
+    if (!body) return false;
+    let sawSelf = 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) continue;
+            if (value.type !== 'this') return false;
+            sawSelf = true;
+            continue;
+        }
+        for (let i = current.namedChildCount - 1; i >= 0; i--) {
+            stack.push(current.namedChild(i));
+        }
+    }
+    return sawSelf;
+}
+
 /**
  * Process a node for function extraction (single-pass helper)
  * Returns true if node was matched, false otherwise
@@ -618,6 +646,7 @@ function _processFunction(node, functions, processedRanges, lines) {
                             isGenerator: isGen,
                             isAsync,
                             modifiers,
+                            ...lexicalOwnerRange(node),
                             ...typeAnno,
                             ...(generics && { generics }),
                             ...(docstring && { docstring })
@@ -699,8 +728,14 @@ function _processFunction(node, functions, processedRanges, lines) {
         if (processedRanges.has(rangeKey)) return false;
 
         const leftNode = node.childForFieldName('left');
-        const isPrototypeAssignment = leftNode && leftNode.type === 'member_expression' &&
-            leftNode.text.includes('.prototype.');
+        const assignedObject = leftNode?.type === 'member_expression'
+            ? leftNode.childForFieldName('object') : null;
+        const prototypeBase = assignedObject?.type === 'member_expression' &&
+            assignedObject.childForFieldName('property')?.text === 'prototype'
+            ? assignedObject.childForFieldName('object') : null;
+        const prototypeOwner = prototypeBase?.type === 'identifier'
+            ? prototypeBase.text : null;
+        const isPrototypeAssignment = !!prototypeOwner;
 
         // For non-prototype assignments, check if nested
         if (!isPrototypeAssignment) {
@@ -748,7 +783,8 @@ function _processFunction(node, functions, processedRanges, lines) {
                     processedRanges.add(rangeKey);
                     const paramsNode = rightNode.childForFieldName('parameters');
                     const { startLine, endLine, indent } = nodeToLocation(node, lines);
-                    const returnType = extractReturnType(rightNode);
+                    const returnType = extractReturnType(rightNode) ||
+                        (prototypeOwner && returnsReceiverSelf(rightNode) ? 'this' : null);
                     const generics = extractGenerics(rightNode);
                     const docstring = extractJSDocstring(lines, startLine);
                     const isGen = isGenerator(rightNode);
@@ -774,9 +810,14 @@ function _processFunction(node, functions, processedRanges, lines) {
                         // assignments carry their class so typed-receiver
                         // method resolution reaches them.
                         ...(leftNode.type === 'member_expression' && { memberAssigned: true }),
+                        // One-hop member assignments record the object they
+                        // patch (fix #286a: `console.log = () => {}` — the
+                        // builtin-global exclusion must see cross-file that
+                        // the project rebinds this global's member).
                         ...(leftNode.type === 'member_expression' &&
-                            /^([A-Za-z_$][\w$]*)\.prototype\.[A-Za-z_$][\w$]*$/.test(leftNode.text) &&
-                            { className: leftNode.text.split('.')[0], isMethod: true }),
+                            leftNode.childForFieldName('object')?.type === 'identifier' &&
+                            { assignedReceiver: leftNode.childForFieldName('object').text }),
+                        ...(prototypeOwner && { className: prototypeOwner, isMethod: true }),
                         ...typeAnno,
                         ...(generics && { generics }),
                         ...(docstring && { docstring })
@@ -1258,7 +1299,8 @@ function extractClassMembers(classNode, codeOrLines) {
                 }
 
                 const isAsync = text.match(/^\s*(?:(?:public|private|protected)\s+)?(?:static\s+)?(?:override\s+)?async\s/) !== null;
-                const returnType = extractReturnType(child);
+                const returnType = extractReturnType(child) ||
+                    (returnsReceiverSelf(child) ? 'this' : null);
                 const docstring = extractJSDocstring(code, startLine);
                 const paramsStructured = parseStructuredParams(paramsNode, 'javascript');
                 const typeAnno = buildTypeAnnotations(paramsStructured, returnType, code, startLine, true);
@@ -1372,6 +1414,8 @@ function extractClassMembers(classNode, codeOrLines) {
                 const name = nameNode.text;
                 const valueNode = child.childForFieldName('value');
                 const isArrow = valueNode && valueNode.type === 'arrow_function';
+                const isStatic = Array.from({ length: child.childCount }, (_, ci) => child.child(ci))
+                    .some(part => part.type === 'static');
 
                 // Collect decorators — children of the field node (TS) or preceding siblings (JS)
                 const fieldDecorators = [];
@@ -1410,6 +1454,7 @@ function extractClassMembers(classNode, codeOrLines) {
                         startLine,
                         endLine,
                         memberType: name.startsWith('#') ? 'private' : 'field',
+                        ...(isStatic && { modifiers: ['static'] }),
                         isArrow: true,
                         isMethod: true,  // Arrow fields are callable like methods
                         ...typeAnno,
@@ -1427,6 +1472,7 @@ function extractClassMembers(classNode, codeOrLines) {
                         startLine,
                         endLine,
                         memberType: name.startsWith('#') ? 'private field' : 'field',
+                        ...(isStatic && { modifiers: ['static'] }),
                         ...(fieldType && { fieldType }),
                         ...(fieldDecorators.length > 0 && { decorators: fieldDecorators })
                         // Not a method - regular field
@@ -1484,6 +1530,48 @@ function _processState(node, objects, lines) {
     return false;
 }
 
+/**
+ * Record immutable module-scope aliases of a statically named class member.
+ *
+ * `const make = Widget.create` preserves the member's compiler-visible
+ * callable signature.  The normalized IR can therefore expose both the local
+ * callable value and any `export { make as widget }` surface without guessing
+ * from a later call spelling.  Mutable/local/object aliases deliberately stay
+ * out: they need data-flow evidence, not a declaration-shape shortcut.
+ */
+function _processCallableAlias(node, aliases) {
+    if (node.type !== 'lexical_declaration' || !isModuleScope(node)) return false;
+    const declarationKind = node.child(0)?.text;
+    if (declarationKind !== 'const') return false;
+
+    let matched = false;
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const declarator = node.namedChild(i);
+        if (declarator.type !== 'variable_declarator') continue;
+        const nameNode = declarator.childForFieldName('name');
+        let valueNode = declarator.childForFieldName('value');
+        if (nameNode?.type !== 'identifier' || !valueNode) continue;
+        while (valueNode && ['parenthesized_expression', 'as_expression',
+            'satisfies_expression', 'type_assertion'].includes(valueNode.type)) {
+            valueNode = valueNode.namedChild(0);
+        }
+        if (valueNode?.type !== 'member_expression') continue;
+        const owner = valueNode.childForFieldName('object');
+        const member = valueNode.childForFieldName('property');
+        if (owner?.type !== 'identifier' ||
+            !['identifier', 'property_identifier'].includes(member?.type)) continue;
+        aliases.push({
+            name: nameNode.text,
+            owner: owner.text,
+            member: member.text,
+            startLine: declarator.startPosition.row + 1,
+            endLine: declarator.endPosition.row + 1,
+        });
+        matched = true;
+    }
+    return matched;
+}
+
 /**
  * Find state objects (CONFIG, constants, etc.)
  */
@@ -1508,13 +1596,14 @@ function findStateObjects(code, parser) {
 function parse(code, parser) {
     const tree = parseTree(parser, code);
     const lines = code.split('\n');
-    const functions = [], classes = [], stateObjects = [];
+    const functions = [], classes = [], stateObjects = [], callableAliases = [];
     const processedFn = new Set(), processedCls = new Set();
 
     traverseTreeCached(tree.rootNode, (node) => {
         _processFunction(node, functions, processedFn, lines);
         _processClass(node, classes, processedCls, lines);
         _processState(node, stateObjects, lines);
+        _processCallableAlias(node, callableAliases);
         return true; // always continue, never skip subtrees
     });
 
@@ -1554,6 +1643,7 @@ function parse(code, parser) {
         declarationTokens.sort((a, b) => a.startIndex - b.startIndex);
 
         const recoveredFunctions = [], recoveredClasses = [], recoveredState = [];
+        const recoveredCallableAliases = [];
         for (let i = 0; i < declarationTokens.length; i++) {
             const token = declarationTokens[i];
             const next = declarationTokens[i + 1];
@@ -1562,12 +1652,13 @@ function parse(code, parser) {
             if (!fragment.trim()) continue;
             const fragmentTree = parseTree(parser, fragment);
             const fragmentLines = fragment.split('\n');
-            const ff = [], fc = [], fs = [];
+            const ff = [], fc = [], fs = [], fa = [];
             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);
+                _processCallableAlias(node, fa);
                 return true;
             });
             const lineOffset = token.startPosition.row;
@@ -1585,6 +1676,7 @@ function parse(code, parser) {
             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); }
+            for (const item of fa) { shiftLines(item); recoveredCallableAliases.push(item); }
         }
 
         const mergeUnique = (target, additions, kind) => {
@@ -1597,11 +1689,21 @@ function parse(code, parser) {
         mergeUnique(functions, recoveredFunctions, 'function');
         mergeUnique(classes, recoveredClasses, 'class');
         mergeUnique(stateObjects, recoveredState, 'state');
+        const aliasKeys = new Set(callableAliases.map(alias =>
+            `${alias.name}\0${alias.owner}\0${alias.member}\0${alias.startLine}`));
+        for (const alias of recoveredCallableAliases) {
+            const key = `${alias.name}\0${alias.owner}\0${alias.member}\0${alias.startLine}`;
+            if (!aliasKeys.has(key)) {
+                aliasKeys.add(key);
+                callableAliases.push(alias);
+            }
+        }
     }
 
     functions.sort((a, b) => a.startLine - b.startLine);
     classes.sort((a, b) => a.startLine - b.startLine);
     stateObjects.sort((a, b) => a.startLine - b.startLine);
+    callableAliases.sort((a, b) => a.startLine - b.startLine);
 
     return {
         language: 'javascript',
@@ -1609,6 +1711,7 @@ function parse(code, parser) {
         functions,
         classes,
         stateObjects,
+        callableAliases,
         ...(tree.rootNode.hasError && { parseRecovery: true }),
         imports: [],  // Handled by core/imports.js
         exports: []   // Handled by core/imports.js
@@ -1653,6 +1756,40 @@ const JS_LITERAL_ASSIGN_TYPES = {
 // Predefined TS types that pin a receiver; any/unknown/object say nothing.
 const TS_PREDEFINED_RECEIVER_TYPES = new Set(['string', 'number', 'boolean', 'bigint', 'symbol']);
 
+/**
+ * Companion to tsTypeName: the namespace qualifier that owns the annotated
+ * name (fix #286e — `app: ns.Flask` must carry 'ns' so two same-name classes
+ * resolve by declaration origin, not directory proximity).
+ */
+function tsTypeQualifier(node) {
+    if (!node) return undefined;
+    switch (node.type) {
+        case 'nested_type_identifier': {
+            const last = node.namedChild(node.namedChildCount - 1);
+            const start = node.startIndex;
+            return last && last.startIndex > start
+                ? node.text.slice(0, last.startIndex - start).replace(/\.$/, '') || undefined
+                : undefined;
+        }
+        case 'generic_type':
+            return tsTypeQualifier(node.namedChild(0));
+        case 'union_type': {
+            for (let i = 0; i < node.namedChildCount; i++) {
+                const c = node.namedChild(i);
+                if (c.type === 'nested_type_identifier' || c.type === 'generic_type') {
+                    const q = tsTypeQualifier(c);
+                    if (q) return q;
+                }
+            }
+            return undefined;
+        }
+        case 'parenthesized_type':
+            return tsTypeQualifier(node.namedChild(0));
+        default:
+            return undefined;
+    }
+}
+
 /**
  * Extract a single concrete type name from a TS type node. Conservative by
  * design: a wrong type would exclude true callers downstream
@@ -2180,6 +2317,12 @@ function findCallsInCode(code, parser) {
                     if (typeName) {
                         localVarTypes.set(nameNode.text, typeName);
                         declaredTypeVars.add(nameNode.text);
+                        const annotationQualifier = tsTypeQualifier(typeId);
+                        if (annotationQualifier) {
+                            localVarTypeQualifiers.set(nameNode.text, annotationQualifier);
+                        } else {
+                            localVarTypeQualifiers.delete(nameNode.text);
+                        }
                     }
                 } else if (initNode && JS_LITERAL_ASSIGN_TYPES[initNode.type]) {
                     // Literal declaration types the variable (fix #262):
@@ -2200,6 +2343,12 @@ function findCallsInCode(code, parser) {
                 if (typeName) {
                     localVarTypes.set(pat.text, typeName);
                     declaredTypeVars.add(pat.text);
+                    const annotationQualifier = tsTypeQualifier(inner);
+                    if (annotationQualifier) {
+                        localVarTypeQualifiers.set(pat.text, annotationQualifier);
+                    } else {
+                        localVarTypeQualifiers.delete(pat.text);
+                    }
                 }
             }
         }
@@ -3163,6 +3312,22 @@ function findImportsInCode(code, parser) {
     return imports;
 }
 
+/**
+ * Return the local symbol created or referenced by a statically-owned
+ * CommonJS property assignment. Dynamic expressions deliberately return
+ * undefined: `exports.x = factory()` and `exports.x = other.y` may be
+ * re-exports or arbitrary values, so they are not exclusion-grade identity.
+ */
+function cjsAssignedLocalName(valueNode, exposedName) {
+    if (!valueNode) return undefined;
+    if (valueNode.type === 'identifier') return valueNode.text;
+    if (['function_expression', 'generator_function', 'arrow_function', 'class']
+        .includes(valueNode.type)) {
+        return valueNode.childForFieldName('name')?.text || exposedName;
+    }
+    return undefined;
+}
+
 /**
  * Find all exports in JavaScript/TypeScript code using tree-sitter AST
  * @param {string} code - Source code to analyze
@@ -3355,12 +3520,15 @@ function findExportsInCode(code, parser) {
                                 } else if (prop.type === 'pair') {
                                     const key = prop.childForFieldName('key');
                                     const value = prop.childForFieldName('value');
-                                    if (key) exports.push({
-                                        name: key.text,
-                                        ...(value?.type === 'identifier' && { localName: value.text }),
-                                        type: 'module.exports',
-                                        line,
-                                    });
+                                    if (key) {
+                                        const localName = cjsAssignedLocalName(value, key.text);
+                                        exports.push({
+                                            name: key.text,
+                                            ...(localName && { localName }),
+                                            type: 'module.exports',
+                                            line,
+                                        });
+                                    }
                                 } else if (prop.type === 'method_definition') {
                                     // Shorthand methods are exports too
                                     // (fix #252 — `module.exports =
@@ -3402,9 +3570,21 @@ function findExportsInCode(code, parser) {
                             }
                         } else if (rightNode && rightNode.type === 'identifier') {
                             // module.exports = something
-                            exports.push({ name: rightNode.text, localName: rightNode.text, type: 'module.exports', line });
+                            exports.push({ name: rightNode.text, localName: rightNode.text,
+                                type: 'module.exports', defaultLike: true, line });
                         } else {
-                            exports.push({ name: 'default', type: 'module.exports', line });
+                            // A named function/class expression still exports
+                            // one callable default. Preserve its LOCAL symbol
+                            // identity so `require('./mod')()` resolves back
+                            // to the declaration; anonymous expressions use
+                            // the parser's synthetic `default` symbol.
+                            const localName = rightNode &&
+                                ['function_expression', 'generator_function', 'class'].includes(rightNode.type)
+                                ? rightNode.childForFieldName('name')?.text
+                                : undefined;
+                            exports.push({ name: 'default',
+                                ...(localName && { localName }),
+                                type: 'module.exports', defaultLike: true, line });
                         }
                         return true;
                     }
@@ -3413,9 +3593,10 @@ function findExportsInCode(code, parser) {
                     if (objNode.text === 'exports') {
                         const line = node.startPosition.row + 1;
                         const rightNode = node.childForFieldName('right');
+                        const localName = cjsAssignedLocalName(rightNode, propNode.text);
                         exports.push({
                             name: propNode.text,
-                            ...(rightNode?.type === 'identifier' && { localName: rightNode.text }),
+                            ...(localName && { localName }),
                             type: 'exports',
                             line,
                         });
@@ -3425,7 +3606,11 @@ function findExportsInCode(code, parser) {
                     // module.exports.name = ...
                     if (objNode.type === 'member_expression' && objNode.text === 'module.exports') {
                         const line = node.startPosition.row + 1;
-                        exports.push({ name: propNode.text, type: 'module.exports', line });
+                        const rightNode = node.childForFieldName('right');
+                        const localName = cjsAssignedLocalName(rightNode, propNode.text);
+                        exports.push({ name: propNode.text,
+                            ...(localName && { localName }),
+                            type: 'module.exports', line });
                         return true;
                     }
                 }