ucn 5.2.2 → 5.3.0

package/core/reporting.js

@@ -133,41 +133,155 @@ function getStats(index, options = {}) {
         // decide which definitions are capable of entering the requested top
         // N. Exact pinned caller resolution is then run only until no unseen
         // candidate can beat the current Nth result.
-        const rawUpperByName = new Map();
+        // A record whose receiver is provably EXTERNAL (fix #340) cannot
+        // confirm a project definition — the engine routes such calls
+        // external-package / possible-dispatch, never confirmed — so it leaves
+        // the bound. `t.Fatalf(...)` (receiverType T, qualifier `testing`)
+        // used to hand every project `Fatalf`/`Fatal`/`Errorf`/`String` a
+        // four-digit upper bound, so the early stop never fired and grpc-go's
+        // `repo` refined 1375 candidates. Resolution is the engine's own
+        // module physics: an import naming the qualifier that resolves to a
+        // project file keeps the record; a resolver gap keeps it; only an
+        // import that is non-relative, non-project, and unresolved drops it.
+        const { _unresolvedModuleIsGap } = require('./callers');
+        const externalQualifierMemo = new Map(); // filePath + qualifier -> boolean
+        const receiverProvablyExternal = (filePath, fileEntry, c) => {
+            if (!c.isMethod || !fileEntry) return false;
+            const qualifier = c.receiverTypeQualifier ||
+                (c.receiverIsModule && c.receiver) || null;
+            if (!qualifier || typeof qualifier !== 'string') return false;
+            const key = filePath + '\u0000' + qualifier;
+            const memo = externalQualifierMemo.get(key);
+            if (memo !== undefined) return memo;
+            const head = qualifier.split('.')[0];
+            const modules = new Set();
+            for (const binding of fileEntry.importBindings || []) {
+                if (binding.name === head || binding.alias === head) modules.add(binding.module);
+            }
+            for (const mod of fileEntry.imports || []) {
+                const text = String(mod || '');
+                if (text === head || text.split('/').pop() === head ||
+                    text.split('.').pop() === head) modules.add(text);
+            }
+            let verdict = false;
+            if (modules.size > 0) {
+                verdict = true;
+                for (const mod of modules) {
+                    if (fileEntry.moduleResolved?.[mod] || _unresolvedModuleIsGap(index, mod)) {
+                        verdict = false;
+                        break;
+                    }
+                }
+            }
+            externalQualifierMemo.set(key, verdict);
+            return verdict;
+        };
+        // Per-DEFINITION bound (fix #340). A record with a trusted parser
+        // receiver type can confirm only that type's own same-name method,
+        // or an inherited/promoted one when that type defines none itself —
+        // so it is charged to that class alone (or to every definition when
+        // the class is not a definer). Untyped and convention-guessed
+        // receivers (#266: never exclusion evidence) stay charged to every
+        // definition. grpc-go: `String` has 278 same-name methods and `Close`
+        // 146; under the per-NAME bound every one of them inherited the whole
+        // name's ceiling and had to be refined.
+        const normalizeTypeName = (text) => String(text || '')
+            .replace(/^[*&\s]+/, '').replace(/[<[(].*$/, '').split('.').pop() || null;
+        const untypedByName = new Map(); // name -> records with no trusted receiver type
+        const typedByName = new Map();   // name -> Map<className, records typed to it>
+        const chargeRecord = (name, c) => {
+            const typed = c.isMethod && c.receiverType && !c.receiverTypeGuessed
+                ? normalizeTypeName(c.receiverType) : null;
+            if (typed) {
+                let byClass = typedByName.get(name);
+                if (!byClass) { byClass = new Map(); typedByName.set(name, byClass); }
+                byClass.set(typed, (byClass.get(typed) || 0) + 1);
+            } else {
+                untypedByName.set(name, (untypedByName.get(name) || 0) + 1);
+            }
+        };
+        // Fix #343: symbols and call sites inside inline test modules
+        // (`#[cfg(test)] mod tests` / `#[test]` fns, fix #244's ranges) are
+        // test code even though their FILE is production — ripgrep's
+        // `TempDir.path` (197 calls, all from tests) ranked second among
+        // "production functions". Under productionCallsOnly they leave the
+        // candidate set, the exact count, AND the upper bound (a bound that
+        // still counted them stopped the early exit from firing, so the
+        // orientation fell back to its approximate refinement budget).
+        const { inlineTestRanges, lineInRanges } = require('./shared');
+        const inlineTestRangesByFile = new Map();
+        const inInlineTest = (file, line) => {
+            if (!file || !line) return false;
+            let ranges = inlineTestRangesByFile.get(file);
+            if (!ranges) {
+                ranges = inlineTestRanges(index.files.get(file) || {});
+                inlineTestRangesByFile.set(file, ranges);
+            }
+            return ranges.length > 0 && lineInRanges(line, ranges);
+        };
         for (const [filePath, entry] of index.callsCache) {
             if (!scopedPaths.has(filePath)) continue;
-            if (index.files.get(filePath)?.isBundled) continue;
+            const fileEntry = index.files.get(filePath);
+            if (fileEntry?.isBundled) continue;
             if (!entry || !Array.isArray(entry.calls)) continue;
             const seenInFile = new Set();
             for (const c of entry.calls) {
                 if (!c || !c.name) continue;
-                const key = `${c.name}::${c.line || 0}`;
+                if (receiverProvablyExternal(filePath, fileEntry, c)) continue;
+                if (options.productionCallsOnly && inInlineTest(filePath, c.line)) continue;
+                // Distinct receiver types on one line can confirm DIFFERENT
+                // definitions. Dedup within a type bucket, never across them.
+                // Mixed typed/untyped buckets may overcount, which is safe for
+                // an upper bound; dropping a bucket can erase a true HOT item.
+                const bucket = c.isMethod && c.receiverType && !c.receiverTypeGuessed
+                    ? normalizeTypeName(c.receiverType) : '';
+                const key = `${c.name}::${c.line || 0}::${bucket}`;
                 if (!seenInFile.has(key)) {
                     seenInFile.add(key);
-                    rawUpperByName.set(c.name, (rawUpperByName.get(c.name) || 0) + 1);
+                    chargeRecord(c.name, c);
                 }
                 if (c.resolvedName && c.resolvedName !== c.name) {
-                    const rkey = `${c.resolvedName}::${c.line || 0}`;
+                    const rkey = `${c.resolvedName}::${c.line || 0}::${bucket}`;
                     if (!seenInFile.has(rkey)) {
                         seenInFile.add(rkey);
-                        rawUpperByName.set(c.resolvedName,
-                            (rawUpperByName.get(c.resolvedName) || 0) + 1);
+                        chargeRecord(c.resolvedName, c);
                     }
                 }
             }
         }
+        const ownerOf = (symbol) => normalizeTypeName(symbol.className || symbol.receiver || '');
 
         const candidates = [];
         const seenDefinitions = new Set();
         for (const [name, symbols] of index.symbols) {
-            const upper = rawUpperByName.get(name) || 0;
-            if (upper === 0) continue;
+            const untyped = untypedByName.get(name) || 0;
+            const typedByClass = typedByName.get(name);
+            if (untyped === 0 && !typedByClass) continue;
             const callable = symbols.filter(symbol =>
                 FUNCTION_TYPES.has(symbol.type) &&
                 matchesReportingScope(index, symbol.relativePath, options));
+            const definers = new Set(callable.map(ownerOf).filter(Boolean));
             for (const symbol of callable) {
+                let upper = untyped;
+                if (typedByClass) {
+                    const owner = ownerOf(symbol);
+                    for (const [cls, count] of typedByClass) {
+                        if (cls === owner || !definers.has(cls)) upper += count;
+                    }
+                }
+                if (upper === 0) continue;
+                // Fair share of the name's ceiling: a name shared by 278
+                // methods cannot make all 278 hot, so a definition's likely
+                // count is nearer upper/definers than upper. Ordering by the
+                // share puts the genuinely hot definitions first; the early
+                // stop below still uses the exact remaining ceiling, so the
+                // exact answer is unchanged and only a bounded refinement
+                // (`maxRefine`) benefits from the order.
+                const share = upper / Math.max(1, callable.length);
                 if (index.files.get(symbol.file)?.isBundled) continue;
-                if (options.productionCallsOnly && require('./shared').isTestPath(symbol.relativePath)) continue;
+                if (options.productionCallsOnly &&
+                    (require('./shared').isTestPath(symbol.relativePath) ||
+                        inInlineTest(symbol.file, symbol.startLine))) continue;
                 const identity = `${symbol.file}:${symbol.startLine}:${name}:` +
                     `${symbol.className || symbol.receiver || ''}:${symbol.params || ''}`;
                 if (seenDefinitions.has(identity)) continue;
@@ -183,21 +297,39 @@ function getStats(index, options = {}) {
                         index.importGraph.get(symbol.file)?.has(candidate.file)))) {
                     continue;
                 }
-                candidates.push({ name, symbol, upper });
+                candidates.push({ name, symbol, upper, share });
             }
         }
+        const maxRefine = Number.isInteger(options.maxRefine) && options.maxRefine > 0
+            ? options.maxRefine : Infinity;
+        // Exact mode walks the ceilings in descending order so the early stop
+        // fires as soon as possible; a bounded refinement walks fair shares so
+        // the budget lands on the definitions most likely to be hot.
         candidates.sort((a, b) =>
+            (maxRefine !== Infinity ? (b.share - a.share) : 0) ||
             (b.upper - a.upper) ||
             codeUnitCompare(a.symbol.relativePath, b.symbol.relativePath) ||
             (a.symbol.startLine || 0) - (b.symbol.startLine || 0));
+        // Suffix maximum of the exact ceilings: once no unseen candidate can
+        // beat the current Nth result, the answer is exact regardless of order.
+        const remainingUpper = new Array(candidates.length + 1).fill(-1);
+        for (let i = candidates.length - 1; i >= 0; i--) {
+            remainingUpper[i] = Math.max(candidates[i].upper, remainingUpper[i + 1]);
+        }
 
         const hotList = [];
         const { findCallers } = require('./callers');
         const scopedCallerQuery = !!(options.file || options.in ||
             (options.exclude && options.exclude.length > 0));
         let refined = 0;
+        let budgetExhausted = false;
+        // One operation scope for the whole refinement loop (fix #340): the
+        // per-file derivations findCallers builds are shared across candidates.
+        if (top > 0) index._beginOp();
+        try {
         if (top > 0) {
             for (let candidateIndex = 0; candidateIndex < candidates.length; candidateIndex++) {
+                if (refined >= maxRefine) { budgetExhausted = true; break; }
                 const { name, symbol } = candidates[candidateIndex];
                 const exact = findCallers(index, name, {
                     targetDefinitions: [symbol],
@@ -210,7 +342,8 @@ function getStats(index, options = {}) {
                     (!scopedCallerQuery || scopedPaths.has(caller.file)) &&
                     !index.files.get(caller.file)?.isBundled &&
                     (!options.productionCallsOnly ||
-                        !require('./shared').isTestPath(caller.relativePath || caller.file))).length;
+                        (!require('./shared').isTestPath(caller.relativePath || caller.file) &&
+                            !inInlineTest(caller.file, caller.line)))).length;
                 if (count > 0) {
                     const owner = symbol.className ||
                         (symbol.receiver || '').replace(/^\*/, '');
@@ -229,11 +362,11 @@ function getStats(index, options = {}) {
                     (a.startLine || 0) - (b.startLine || 0));
                 if (hotList.length >= top) {
                     const threshold = hotList[top - 1].callCount;
-                    const nextUpper = candidates[candidateIndex + 1]?.upper ?? -1;
-                    if (nextUpper < threshold) break;
+                    if (remainingUpper[candidateIndex + 1] < threshold) break;
                 }
             }
         }
+        } finally { if (top > 0) index._endOp(); }
 
         // Stable order: callCount desc, then (relativePath, startLine) asc.
         hotList.sort((a, b) =>
@@ -248,6 +381,7 @@ function getStats(index, options = {}) {
             totalKind: refined === candidates.length ? 'confirmed' : 'raw-call-candidates',
             refined,
             items: hotList.slice(0, top),
+            ...(budgetExhausted && { budgetExhausted: true, maxRefine }),
             note: refined === candidates.length
                 ? 'Counts are confirmed caller-engine edges pinned to each displayed definition; unverified dispatch is excluded.'
                 : `Displayed counts are exact confirmed caller-engine edges; ${candidates.length} raw candidates were bounded and ${refined} required exact refinement.`,
@@ -805,6 +939,12 @@ function computeEvidenceProfile(index, { sampleSize, matchInFilter }) {
  * trust verdict. Composes existing engine reads; counts and pointers only
  * (no caller claims, so no account — the toc/stats category).
  */
+// Orientation refines at most this many HOT candidates exactly (fix #340).
+// grpc-go (1037 files): exact refinement walks 1089 candidates in ~20s; 400
+// in fair-share order reproduces the exact top 8 in under 5s. When the budget
+// binds, the header says so and points at the exact command.
+const ORIENT_HOT_REFINE_BUDGET = 400;
+
 function orient(index, options = {}) {
     const top = options.top || 8;
     const scope = {
@@ -827,6 +967,8 @@ function orient(index, options = {}) {
         // actually contains production files. In an all-test repository it
         // would erase the raw ranking that orient promises as its fallback.
         productionCallsOnly: options.includeTests !== true && hasProductionFiles,
+        maxRefine: Number.isInteger(options.hotRefineBudget) && options.hotRefineBudget > 0
+            ? options.hotRefineBudget : ORIENT_HOT_REFINE_BUDGET,
     });
     const health = doctor(index, scope);
 
@@ -908,6 +1050,9 @@ function orient(index, options = {}) {
             total: stats.hot?.total ?? 0,
             totalKind: stats.hot?.totalKind || 'confirmed',
             refined: stats.hot?.refined ?? 0,
+            ...(stats.hot?.budgetExhausted && {
+                budgetExhausted: true, maxRefine: stats.hot.maxRefine,
+            }),
             top,
             production,
             items: hotItems,

package/languages/javascript.js

@@ -2371,6 +2371,40 @@ function findCallsInCode(code, parser) {
         }
         return false;
     };
+    // fix #337: a declarator initialized from require()/import() is an
+    // IMPORT binding — the module's own name reaching this scope — not a
+    // local shadow. `function build() { const { Foo } = require('./lib');
+    // new Foo() }` resolves through import ownership exactly like the
+    // top-level require the walk already exempts as the module binding
+    // itself. Unwraps `await import()`, parens, and `require('./x').Foo`.
+    const _isImportBindingInitializer = (value) => {
+        let v = value;
+        for (;;) {
+            if (!v) return false;
+            if (v.type === 'await_expression' || v.type === 'parenthesized_expression') {
+                v = v.namedChild(0);
+                continue;
+            }
+            if (v.type === 'member_expression' || v.type === 'subscript_expression') {
+                v = v.childForFieldName('object');
+                continue;
+            }
+            break;
+        }
+        if (v.type !== 'call_expression') return false;
+        const fn = v.childForFieldName('function');
+        return !!fn && (fn.type === 'import' || (fn.type === 'identifier' && fn.text === 'require'));
+    };
+    const _declaresLocalShadow = (declNode, name) => {
+        for (let i = 0; i < declNode.namedChildCount; i++) {
+            const d = declNode.namedChild(i);
+            if (d.type !== 'variable_declarator') continue;
+            if (!_patternDeclaresName(d.childForFieldName('name'), name)) continue;
+            if (_isImportBindingInitializer(d.childForFieldName('value'))) continue;
+            return true;
+        }
+        return false;
+    };
 
     // Bare callback references need to distinguish a module-owned VALUE from
     // an unbound name. File-level import reachability cannot prove the value's
@@ -2447,7 +2481,7 @@ function findCallsInCode(code, parser) {
                         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;
+                        _declaresLocalShadow(stmt, name)) return true;
                 }
             } else if (p.type === 'for_statement') {
                 const init = p.childForFieldName('initializer');
@@ -3438,6 +3472,144 @@ function findImportsInCode(code, parser) {
     const imports = [];
     let importAliases = null;  // {original, local}[] — tracks renamed imports
 
+    // fix #338: classify edges that do not execute during module
+    // initialization so dependency-cycle reporting can separate an eager
+    // import-time loop from a deliberate lazy one. `require()`/`import()`
+    // nested in any function body (incl. `() => require('./x')` thunks) runs
+    // only when that function is called; TS `import type` / `export type`
+    // re-exports and all-`type` specifier lists are erased at compile time.
+    const FUNCTION_LIKE = new Set(['function_declaration', 'function_expression', 'arrow_function',
+        'method_definition', 'generator_function_declaration', 'generator_function', 'function']);
+    const importDeferral = (node) => {
+        for (let p = node.parent; p; p = p.parent) {
+            if (FUNCTION_LIKE.has(p.type)) return 'function-local';
+        }
+        return null;
+    };
+    // Static path folding is positive identity evidence. A method merely
+    // named join/resolve need not be Node's path utility. Keep an ambiguous
+    // or shadowed binding dynamic rather than inventing a module edge.
+    let pathBindings = null;
+    const isPathModuleCall = node => {
+        if (node?.type !== 'call_expression') return false;
+        const fn = node.childForFieldName('function');
+        const args = node.childForFieldName('arguments');
+        const arg = args?.namedChild(0);
+        return fn?.type === 'identifier' && fn.text === 'require' &&
+            args.namedChildCount === 1 && arg?.type === 'string' &&
+            ['path', 'node:path'].includes(arg.text.slice(1, -1));
+    };
+    const collectPathBindings = () => {
+        if (pathBindings) return;
+        pathBindings = new Map();
+        const add = (pattern, value) => {
+            if (!pattern) return;
+            traverseTree(pattern, id => {
+                if (id.type === 'identifier' || id.type === 'shorthand_property_identifier_pattern') {
+                    const entries = pathBindings.get(id.text) || [];
+                    entries.push({ pattern, value });
+                    pathBindings.set(id.text, entries);
+                }
+                return true;
+            });
+        };
+        // File-wide ambiguity is deliberately conservative, including writes
+        // and parameters in unrelated scopes. This rare syntax needs proof,
+        // while ordinary literal require specifiers keep their existing path.
+        traverseTree(tree.rootNode, n => {
+            if (n.type === 'variable_declarator') add(n.childForFieldName('name'), n.childForFieldName('value'));
+            else if (n.type === 'formal_parameters' || n.type === 'import_clause') add(n, null);
+            else if (n.type === 'assignment_expression' || n.type === 'augmented_assignment_expression') add(n.childForFieldName('left'), null);
+            else if (n.type === 'update_expression') add(n.childForFieldName('argument'), null);
+            else if (n.type === 'class_declaration' || n.type === 'class') add(n.childForFieldName('name'), null);
+            else if (n.type === 'catch_clause') add(n.childForFieldName('parameter'), null);
+            else if (FUNCTION_LIKE.has(n.type)) {
+                add(n.childForFieldName('name'), null);
+                add(n.childForFieldName('parameter'), null); // unparenthesized arrow
+            }
+            return true;
+        });
+    };
+    const isPathUtility = fn => {
+        if (pathBindings.has('require')) return false;
+        if (fn?.type !== 'member_expression' ||
+            !['join', 'resolve'].includes(fn.childForFieldName('property')?.text)) return false;
+        const object = fn.childForFieldName('object');
+        if (isPathModuleCall(object)) return true;
+        if (object?.type !== 'identifier') return false;
+        const bindings = pathBindings.get(object.text) || [];
+        return bindings.length === 1 && bindings[0].pattern.type === 'identifier' &&
+            isPathModuleCall(bindings[0].value);
+    };
+    // Static composition of `__dirname`-rooted require paths (fix #337b).
+    // Returns a relative specifier ('./x' / '../x') or null when any piece is
+    // not a string literal.
+    const unquote = (n) => (n.type === 'string' &&
+        !n.namedChildren.some(child => child.type === 'escape_sequence') ? n.text.slice(1, -1) : null);
+    const staticDirnamePath = (arg) => {
+        collectPathBindings();
+        if (pathBindings.has('__dirname') || pathBindings.has('require')) return null;
+        let parts = null;
+        if (arg.type === 'call_expression') {
+            const fn = arg.childForFieldName('function');
+            if (!isPathUtility(fn)) return null;
+            const args = arg.childForFieldName('arguments');
+            if (!args || args.namedChildCount < 2) return null;
+            if (args.namedChild(0).type !== 'identifier' || args.namedChild(0).text !== '__dirname') return null;
+            parts = [];
+            for (let i = 1; i < args.namedChildCount; i++) {
+                const piece = unquote(args.namedChild(i));
+                if (piece == null || piece.startsWith('/')) return null;
+                parts.push(piece);
+            }
+        } else if (arg.type === 'binary_expression') {
+            const operands = [];
+            const flatten = (n) => {
+                if (n.type === 'binary_expression' && n.childForFieldName('operator')?.text === '+') {
+                    flatten(n.childForFieldName('left'));
+                    flatten(n.childForFieldName('right'));
+                } else operands.push(n);
+            };
+            flatten(arg);
+            if (operands.length < 2 || operands[0].type !== 'identifier' || operands[0].text !== '__dirname') return null;
+            let tail = '';
+            for (let i = 1; i < operands.length; i++) {
+                const piece = unquote(operands[i]);
+                if (piece == null) return null;
+                tail += piece;
+            }
+            if (!tail.startsWith('/')) return null;
+            parts = [tail.slice(1)];
+        } else if (arg.type === 'template_string') {
+            let tail = '';
+            let sawDirname = false;
+            for (let i = 0; i < arg.childCount; i++) {
+                const c = arg.child(i);
+                if (c.type === 'template_substitution') {
+                    if (sawDirname || c.namedChildCount !== 1 || c.namedChild(0).text !== '__dirname') return null;
+                    sawDirname = true;
+                } else if (c.type === 'string_fragment') {
+                    if (!sawDirname) return null;
+                    tail += c.text;
+                } else if (c.type !== '`') return null;
+            }
+            if (!sawDirname || !tail.startsWith('/')) return null;
+            parts = [tail.slice(1)];
+        }
+        if (!parts || parts.length === 0) return null;
+        const joined = parts.join('/').replace(/\\/g, '/');
+        if (!joined || joined.includes('${')) return null;
+        const normalized = require('path').posix.normalize(joined);
+        if (normalized.startsWith('/') || normalized === '.') return null;
+        return normalized.startsWith('.') ? normalized : `./${normalized}`;
+    };
+    const hasTypeKeyword = (node) => {
+        for (let i = 0; i < node.childCount; i++) {
+            if (node.child(i).type === 'type') return true;
+        }
+        return false;
+    };
+
     traverseTreeCached(tree.rootNode, (node) => {
         // ES6 import statements
         if (node.type === 'import_statement') {
@@ -3446,6 +3618,10 @@ function findImportsInCode(code, parser) {
             const names = [];
             const esmRenames = [];
             let importType = 'named';
+            let typeOnly = hasTypeKeyword(node);
+            let specifierCount = 0;
+            let typeSpecifierCount = 0;
+            let hasValueBinding = false;
 
             // Find the module path (string node)
             for (let i = 0; i < node.namedChildCount; i++) {
@@ -3466,7 +3642,8 @@ function findImportsInCode(code, parser) {
                         if (c.type === 'string') src = c.text.slice(1, -1);
                     }
                     if (src) {
-                        imports.push({ module: src, names: alias ? [alias] : [], type: 'require', line });
+                        imports.push({ module: src, names: alias ? [alias] : [], type: 'require', line,
+                            ...(typeOnly && { deferred: true, deferredReason: 'type-only' }) });
                     }
                     return true;
                 }
@@ -3478,6 +3655,7 @@ function findImportsInCode(code, parser) {
                             // Default import: import foo from 'x'
                             names.push(clauseChild.text);
                             importType = 'default';
+                            hasValueBinding = true;
                         } else if (clauseChild.type === 'named_imports') {
                             // Named imports: import { a, b } from 'x'
                             for (let k = 0; k < clauseChild.namedChildCount; k++) {
@@ -3485,6 +3663,8 @@ function findImportsInCode(code, parser) {
                                 if (specifier.type === 'import_specifier') {
                                     const nameNode = specifier.namedChild(0);
                                     const aliasNode = specifier.namedChild(1);
+                                    specifierCount++;
+                                    if (hasTypeKeyword(specifier)) typeSpecifierCount++;
                                     if (nameNode) names.push(nameNode.text);
                                     // Track renamed imports: import { X as Y }
                                     if (nameNode && aliasNode && aliasNode.text !== nameNode.text) {
@@ -3501,6 +3681,7 @@ function findImportsInCode(code, parser) {
                                           clauseChild.namedChild(0);
                             if (nsName) names.push(nsName.text);
                             importType = 'namespace';
+                            hasValueBinding = true;
                         }
                     }
                 }
@@ -3511,8 +3692,13 @@ function findImportsInCode(code, parser) {
                     // Side-effect import: import 'x'
                     importType = 'side-effect';
                 }
+                if (!typeOnly && specifierCount > 0 && typeSpecifierCount === specifierCount &&
+                    importType === 'named' && !hasValueBinding) {
+                    typeOnly = true;
+                }
                 imports.push({ module: modulePath, names, type: importType, line,
-                    ...(esmRenames.length > 0 && { renames: esmRenames }) });
+                    ...(esmRenames.length > 0 && { renames: esmRenames }),
+                    ...(typeOnly && { deferred: true, deferredReason: 'type-only' }) });
             }
             return true;
         }
@@ -3522,6 +3708,8 @@ function findImportsInCode(code, parser) {
         if (node.type === 'export_statement') {
             let source = null;
             const names = [];
+            let specifierCount = 0;
+            let typeSpecifierCount = 0;
 
             // Find the source module (string node with 'from')
             for (let i = 0; i < node.namedChildCount; i++) {
@@ -3533,6 +3721,8 @@ function findImportsInCode(code, parser) {
                     for (let j = 0; j < child.namedChildCount; j++) {
                         const specifier = child.namedChild(j);
                         if (specifier.type === 'export_specifier') {
+                            specifierCount++;
+                            if (hasTypeKeyword(specifier)) typeSpecifierCount++;
                             const nameNode = specifier.namedChild(0);
                             if (nameNode) names.push(nameNode.text);
                         }
@@ -3544,7 +3734,9 @@ function findImportsInCode(code, parser) {
                 const line = node.startPosition.row + 1;
                 const isStarReExport = node.text.includes('export *');
                 const importType = isStarReExport ? 'namespace' : 'named';
-                imports.push({ module: source, names, type: importType, line, isReExport: true });
+                imports.push({ module: source, names, type: importType, line, isReExport: true,
+                    ...((hasTypeKeyword(node) || (specifierCount > 0 && specifierCount === typeSpecifierCount)) &&
+                        { deferred: true, deferredReason: 'type-only' }) });
             }
             return true;
         }
@@ -3562,8 +3754,17 @@ function findImportsInCode(code, parser) {
                     let modulePath;
                     let dynamic = false;
 
+                    const composedPath = firstArg && firstArg.type !== 'string' ? staticDirnamePath(firstArg) : null;
                     if (firstArg && firstArg.type === 'string') {
                         modulePath = firstArg.text.slice(1, -1);
+                    } else if (composedPath) {
+                        // fix #337b: `require(path.join(__dirname, '..', 'x'))`,
+                        // `require(__dirname + '/x')`, `require(\`${__dirname}/x\`)`
+                        // compose to an exact relative specifier — the CJS
+                        // test-suite idiom that used to be an unresolvable
+                        // dynamic module (excluding every constructor call it
+                        // bound as other-definition-import).
+                        modulePath = composedPath;
                     } else {
                         dynamic = true;
                         modulePath = firstArg ? firstArg.text : null;
@@ -3605,7 +3806,9 @@ function findImportsInCode(code, parser) {
                     }
 
                     if (modulePath) {
+                        const deferral = importDeferral(node);
                         imports.push({ module: modulePath, names, type: 'require', line, dynamic,
+                            ...(deferral && { deferred: true, deferredReason: deferral }),
                             ...(defaultLike && { defaultLike: true }),
                             // Per-import rename pairing (fix #269): the flat
                             // importAliases list loses WHICH module a renamed
@@ -3623,11 +3826,15 @@ function findImportsInCode(code, parser) {
                 if (argsNode && argsNode.namedChildCount > 0) {
                     const firstArg = argsNode.namedChild(0);
                     const line = node.startPosition.row + 1;
+                    const deferral = importDeferral(node);
+                    const deferredFields = deferral ? { deferred: true, deferredReason: deferral } : {};
                     if (firstArg && firstArg.type === 'string') {
                         const modulePath = firstArg.text.slice(1, -1);
-                        imports.push({ module: modulePath, names: [], type: 'dynamic', line, dynamic: false });
+                        imports.push({ module: modulePath, names: [], type: 'dynamic', line, dynamic: false,
+                            ...deferredFields });
                     } else if (firstArg) {
-                        imports.push({ module: firstArg.text, names: [], type: 'dynamic', line, dynamic: true });
+                        imports.push({ module: firstArg.text, names: [], type: 'dynamic', line, dynamic: true,
+                            ...deferredFields });
                     }
                 }
             }