@bobfrankston/npmglobalize 1.0.230 → 1.0.231

package/README.md

@@ -586,13 +586,25 @@ Workspace mode is auto-detected when run from a root with `"private": true` and
                 migration automatically when a build hits a TS7 deprecation
                 error, so day-to-day you never need this flag.
                     npmglobalize <path> -tsfix
-                If the automatic migration breaks a build (usually relative
-                imports missing their .js extension, TS2835), the tsconfig is
-                put back so the build keeps working and EVERY error from the
-                nodenext attempt is listed, file(line,col) and the suggested
-                fix, for fixing by hand. Nothing in the source is rewritten.
-                The migration reruns on the next build once the imports are
-                fixed. (2026-09-14)
+                Relative imports that NodeNext rejects for lacking a file
+                extension (TS2835) are fixed too, in the release flow and
+                under -tsfix alike: the extension tsc itself suggests is
+                written into the import ("./a" -> "./a.js", "./utils" ->
+                "./utils/index.js"), driven only by tsc's diagnostics, never
+                by a regex over source, so comments, template strings and
+                bare package specifiers are never touched. A noEmit project
+                that Node runs directly gets ".ts" instead and
+                allowImportingTsExtensions is switched on, since Node's type
+                stripping does not map "./a.js" to a.ts. A suggestion that is
+                not just an added extension is left alone and reported. Each
+                rewritten import is printed and counted in the issues summary
+                so the diff can be reviewed. -tsfix type-checks each package
+                with tsc --noEmit to get those diagnostics (it still emits
+                nothing, commits nothing, publishes nothing). If a build
+                still fails after the import fixes, the tsconfig is put back
+                so the build keeps working, the import edits stay (a named
+                file is right under the old resolver too), and every
+                remaining error is listed for fixing by hand. (2026-09-14)
 -show           Show package.json dependency changes
 -package, -pkg  Update package.json scripts to use npmglobalize (see below)
 -h, -help       Show help

package/cli.js

@@ -592,7 +592,7 @@ export async function main() {
     if (cliOptions.ts7Fix) {
         console.log('');
         console.log(colors.accent('━━━ TypeScript 7 tsconfig fix ━━━'));
-        const { changedDirs, remaining } = fixTs7Deprecations(cwd);
+        const { changedDirs, remaining, importFixes, typeErrors } = await fixTs7Deprecations(cwd);
         if (changedDirs.length === 0) {
             console.log(colors.success('  ✓ Nothing to fix — no removed-in-TS7 compilerOptions in writable tsconfigs.'));
         }
@@ -600,7 +600,24 @@ export async function main() {
             console.log(colors.success(`  ✓ Patched tsconfig(s) in ${changedDirs.length} package(s):`));
             for (const dir of changedDirs)
                 console.log(`      ${dir}`);
-            console.log(colors.muted('  Rebuild to validate — NodeNext resolution may surface real import errors the old resolver hid.'));
+        }
+        // 2026-09-14 — Claude Code (Fable 5.1): -tsfix now also type-checks each package
+        // and adds the extension NodeNext requires on relative imports (see
+        // fixImportExtensions in lib.ts). What still fails is listed, per package.
+        const totalImports = [...importFixes.values()].reduce((a, b) => a + b, 0);
+        if (totalImports > 0) {
+            console.log(colors.success(`  ✓ Added file extensions to ${totalImports} relative import(s) in ${importFixes.size} package(s) — review the diff.`));
+        }
+        if (typeErrors.size > 0) {
+            console.log(colors.warn(`  ${typeErrors.size} package(s) still fail to type-check under the migrated settings:`));
+            for (const [dir, errs] of typeErrors) {
+                console.log(colors.warn(`    ${dir}`));
+                for (const e of errs)
+                    console.log(colors.warn(`      ${e}`));
+            }
+        }
+        else if (changedDirs.length > 0 || totalImports > 0) {
+            console.log(colors.success('  ✓ Every package type-checks under the migrated settings.'));
         }
         if (remaining.length > 0) {
             console.log(colors.warn(`  ${remaining.length} item(s) could not be auto-fixed:`));
@@ -611,7 +628,7 @@ export async function main() {
         }
         console.log('');
         printBuildSummary();
-        process.exit(remaining.length > 0 ? 1 : 0);
+        process.exit(remaining.length > 0 || typeErrors.size > 0 ? 1 : 0);
     }
     // Build file: deps topologically, then the target itself.
     // Ensures consumers' tsc sees up-to-date `.d.ts` from sibling checkouts

package/lib.d.ts

@@ -30,6 +30,52 @@ export declare function extractFirstTscError(output: string): string | null;
  *  line (the imports a nodenext migration surfaces), as opposed to the one-line summary
  *  extractFirstTscError gives. (2026-09-14) */
 export declare function extractTscErrors(output: string): string[];
+/** One relative import rewritten by fixImportExtensions. */
+export interface ImportExtensionFix {
+    file: string; /** Path as tsc printed it (relative to the build's cwd) */
+    line: number;
+    col: number;
+    from: string; /** Specifier as it was, e.g. "./a" */
+    to: string; /** Specifier as written, e.g. "./a.js" */
+}
+/** A TS2835 diagnostic fixImportExtensions left alone, and why. */
+export interface ImportExtensionSkip {
+    file: string;
+    line: number;
+    col: number;
+    reason: string;
+}
+/** Add the file extension NodeNext requires on relative imports, driven ONLY by tsc's own
+ *  TS2835 diagnostics in `output` ("Relative import paths need explicit file extensions …
+ *  Did you mean './a.js'?"). Each diagnostic carries the file, the exact position of the
+ *  specifier's opening quote, and tsc's suggested specifier, which already accounts for
+ *  directory imports ('./utils' → './utils/index.js') and other source kinds ('.mts' →
+ *  '.mjs'). No regex over source, so comments, template strings, dynamic imports and bare
+ *  package specifiers are never touched.
+ *
+ *  TS2834 is the same complaint without a suggestion — TypeScript 6 gives it for a
+ *  directory import ('./utils' → utils/index.ts). For those the suggestion is derived from
+ *  disk, relative to the importing file, and only when exactly one answer exists:
+ *  utils.ts/.tsx/.d.ts/.js → './utils.js', .mts → '.mjs', .cts → '.cjs', a directory
+ *  with an index file → './utils/index.js' (or .mjs/.cjs). Nothing found, or both a
+ *  file and a directory, is skipped and reported.
+ *
+ *  A fix is applied only when the suggestion is the current specifier plus an extension,
+ *  or plus '/index' and an extension; anything else is skipped and reported. A noEmit
+ *  project run directly by Node gets the '.ts' family instead of '.js': Node's type
+ *  stripping does not map './a.js' to a.ts, so tsc's suggestion would break the run.
+ *
+ *  Edits are applied per file from the bottom up so earlier positions stay valid.
+ *  2026-09-14 19:00 EDT — Claude Code (Fable 5.1), at Bob's direction: "Might as well
+ *  fix the imports too since I just use modules and legacy problems should be rare or
+ *  nonexistent." Only relative specifiers are ever in scope (Bob: "I presume this is
+ *  only for relative imports rather than libraries"). */
+export declare function fixImportExtensions(cwd: string, output: string, opts?: {
+    useTsExtensions?: boolean;
+}): {
+    fixed: ImportExtensionFix[];
+    skipped: ImportExtensionSkip[];
+};
 /** A TS7016 — "Could not find a declaration file for module 'X'" — that tsc blames
  *  on the file being compiled is frequently not that file's fault: the copy of X in
  *  node_modules carries no `.d.ts` whatsoever. That happens when X was published at
@@ -536,10 +582,12 @@ export declare function reportTs7Deprecations(cwd: string): Ts7Finding[];
  *  the next real TS7-removal error). Returns the dirs whose tsconfigs changed
  *  plus the findings that remain (e.g. options inherited from read-only
  *  node_modules bases). */
-export declare function fixTs7Deprecations(cwd: string): {
+export declare function fixTs7Deprecations(cwd: string): Promise<{
     changedDirs: string[];
     remaining: Ts7Finding[];
-};
+    importFixes: Map<string, number>;
+    typeErrors: Map<string, string[]>;
+}>;
 /** Ensure the workspace-root `node_modules/` is in sync with every member's
  *  declared deps. Workspaces hoist deps to the root, so a dep added to any
  *  member `package.json` without a follow-up `npm install` at the root leaves

package/lib.js

@@ -96,6 +96,179 @@ export function extractTscErrors(output) {
     }
     return lines;
 }
+/** Add the file extension NodeNext requires on relative imports, driven ONLY by tsc's own
+ *  TS2835 diagnostics in `output` ("Relative import paths need explicit file extensions …
+ *  Did you mean './a.js'?"). Each diagnostic carries the file, the exact position of the
+ *  specifier's opening quote, and tsc's suggested specifier, which already accounts for
+ *  directory imports ('./utils' → './utils/index.js') and other source kinds ('.mts' →
+ *  '.mjs'). No regex over source, so comments, template strings, dynamic imports and bare
+ *  package specifiers are never touched.
+ *
+ *  TS2834 is the same complaint without a suggestion — TypeScript 6 gives it for a
+ *  directory import ('./utils' → utils/index.ts). For those the suggestion is derived from
+ *  disk, relative to the importing file, and only when exactly one answer exists:
+ *  utils.ts/.tsx/.d.ts/.js → './utils.js', .mts → '.mjs', .cts → '.cjs', a directory
+ *  with an index file → './utils/index.js' (or .mjs/.cjs). Nothing found, or both a
+ *  file and a directory, is skipped and reported.
+ *
+ *  A fix is applied only when the suggestion is the current specifier plus an extension,
+ *  or plus '/index' and an extension; anything else is skipped and reported. A noEmit
+ *  project run directly by Node gets the '.ts' family instead of '.js': Node's type
+ *  stripping does not map './a.js' to a.ts, so tsc's suggestion would break the run.
+ *
+ *  Edits are applied per file from the bottom up so earlier positions stay valid.
+ *  2026-09-14 19:00 EDT — Claude Code (Fable 5.1), at Bob's direction: "Might as well
+ *  fix the imports too since I just use modules and legacy problems should be rare or
+ *  nonexistent." Only relative specifiers are ever in scope (Bob: "I presume this is
+ *  only for relative imports rather than libraries"). */
+export function fixImportExtensions(cwd, output, opts = {}) {
+    const fixed = [];
+    const skipped = [];
+    if (!output)
+        return { fixed, skipped };
+    // file(line,col): error TS2835: Relative import paths need explicit file extensions … Did you mean './a.js'?
+    // file(line,col): error TS2834: Relative import paths need explicit file extensions … Consider adding an extension to the import path.
+    const re = /^(.+?)\((\d+),(\d+)\): error TS283[45]: [^\n]*?(?:Did you mean '([^']+)'\?)?\s*$/gm;
+    const byFile = new Map();
+    for (const m of output.matchAll(re)) {
+        const list = byFile.get(m[1]) ?? [];
+        list.push({ line: Number(m[2]), col: Number(m[3]), suggested: m[4] || '' });
+        byFile.set(m[1], list);
+    }
+    const toTs = (spec) => spec.replace(/\.js$/, '.ts').replace(/\.mjs$/, '.mts').replace(/\.cjs$/, '.cts');
+    /** What `from` (as written in `importer`) should become, decided from what is on disk.
+     *  Returns the single answer, or an explanation of why there is none. */
+    const suggestFromDisk = (importer, from) => {
+        const target = path.resolve(path.dirname(importer), from);
+        const base = from.replace(/\/$/, '');
+        // [file on disk, specifier to write]
+        const candidates = [
+            [`${target}.ts`, `${base}.js`], [`${target}.tsx`, `${base}.js`], [`${target}.d.ts`, `${base}.js`], [`${target}.js`, `${base}.js`],
+            [`${target}.mts`, `${base}.mjs`], [`${target}.mjs`, `${base}.mjs`],
+            [`${target}.cts`, `${base}.cjs`], [`${target}.cjs`, `${base}.cjs`],
+            [path.join(target, 'index.ts'), `${base}/index.js`], [path.join(target, 'index.tsx'), `${base}/index.js`],
+            [path.join(target, 'index.d.ts'), `${base}/index.js`], [path.join(target, 'index.js'), `${base}/index.js`],
+            [path.join(target, 'index.mts'), `${base}/index.mjs`], [path.join(target, 'index.mjs'), `${base}/index.mjs`],
+            [path.join(target, 'index.cts'), `${base}/index.cjs`], [path.join(target, 'index.cjs'), `${base}/index.cjs`],
+        ];
+        const found = new Set(candidates.filter(([file]) => fs.existsSync(file)).map(([, spec]) => spec));
+        if (found.size === 1)
+            return { suggested: [...found][0] };
+        if (found.size === 0)
+            return { reason: `tsc gave no suggestion and nothing on disk matches "${from}" (looked for ${path.basename(target)}.ts/.tsx/.mts/.cts/.js and ${path.basename(target)}/index.*)` };
+        return { reason: `tsc gave no suggestion and "${from}" is ambiguous on disk: ${[...found].join(' or ')}` };
+    };
+    for (const [file, diags] of byFile) {
+        const filePath = path.resolve(cwd, file);
+        let text;
+        try {
+            text = fs.readFileSync(filePath, 'utf-8');
+        }
+        catch (error) {
+            for (const d of diags)
+                skipped.push({ file, line: d.line, col: d.col, reason: `cannot read ${filePath}: ${error.message}` });
+            continue;
+        }
+        const lines = text.split(/(?<=\n)/); // keep each line's own EOL
+        // Bottom-up, and right-to-left within a line, so untouched positions stay valid.
+        diags.sort((a, b) => b.line - a.line || b.col - a.col);
+        const seen = new Set();
+        let changed = false;
+        for (const d of diags) {
+            const key = `${d.line}:${d.col}`;
+            if (seen.has(key))
+                continue; // tsc can report the same position twice (e.g. import + re-export builds)
+            seen.add(key);
+            const lineText = lines[d.line - 1];
+            const quote = lineText?.[d.col - 1];
+            if (quote !== '"' && quote !== "'") {
+                skipped.push({ file, line: d.line, col: d.col, reason: 'no string literal at the reported position (file changed since the build?)' });
+                continue;
+            }
+            const close = lineText.indexOf(quote, d.col);
+            if (close < 0) {
+                skipped.push({ file, line: d.line, col: d.col, reason: 'unterminated string at the reported position' });
+                continue;
+            }
+            const from = lineText.slice(d.col, close);
+            if (!from.startsWith('./') && !from.startsWith('../')) {
+                skipped.push({ file, line: d.line, col: d.col, reason: `"${from}" is not a relative specifier` });
+                continue;
+            }
+            if (!d.suggested) {
+                const derived = suggestFromDisk(filePath, from);
+                if ('reason' in derived) {
+                    skipped.push({ file, line: d.line, col: d.col, reason: derived.reason });
+                    continue;
+                }
+                d.suggested = derived.suggested;
+            }
+            const base = from.replace(/\/$/, '');
+            const isPlainAppend = /^\.(js|mjs|cjs)$/.test(d.suggested.slice(from.length)) && d.suggested.startsWith(from);
+            const isIndexAppend = d.suggested.startsWith(base + '/index.') && /^\.(js|mjs|cjs)$/.test(d.suggested.slice(base.length + '/index'.length));
+            if (!isPlainAppend && !isIndexAppend) {
+                skipped.push({ file, line: d.line, col: d.col, reason: `tsc suggests "${d.suggested}" for "${from}", which is not just an added extension — left for a human` });
+                continue;
+            }
+            const to = opts.useTsExtensions ? toTs(d.suggested) : d.suggested;
+            lines[d.line - 1] = lineText.slice(0, d.col) + to + lineText.slice(close);
+            fixed.push({ file, line: d.line, col: d.col, from, to });
+            changed = true;
+        }
+        if (changed) {
+            try {
+                fs.writeFileSync(filePath, lines.join(''));
+            }
+            catch (error) {
+                // Nothing on disk changed for this file, so its fixes did not happen: move them to skipped.
+                for (let i = fixed.length - 1; i >= 0; i--) {
+                    if (fixed[i].file !== file)
+                        continue;
+                    skipped.push({ file, line: fixed[i].line, col: fixed[i].col, reason: `cannot write ${filePath}: ${error.message}` });
+                    fixed.splice(i, 1);
+                }
+            }
+        }
+    }
+    fixed.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line || a.col - b.col);
+    return { fixed, skipped };
+}
+/** Run fixImportExtensions for `dir` against a build's output and print what it did.
+ *  For a noEmit project the '.ts' extension is written and `allowImportingTsExtensions`
+ *  is switched on in the most-leaf writable tsconfig, since tsc rejects '.ts' specifiers
+ *  without it (TS5097). Returns the number of imports rewritten. */
+function applyImportExtensionFixes(dir, output, label) {
+    const useTs = isNoEmitProject(dir);
+    const { fixed, skipped } = fixImportExtensions(dir, output, { useTsExtensions: useTs });
+    for (const f of fixed)
+        console.log(colors.cyan(`  Fixed import in ${f.file}(${f.line},${f.col}): "${f.from}" → "${f.to}"`));
+    for (const s of skipped)
+        console.log(colors.yellow(`  Left import in ${s.file}(${s.line},${s.col}): ${s.reason}`));
+    if (fixed.length && useTs) {
+        const tsconfigPath = path.join(dir, 'tsconfig.json');
+        const { chain } = resolveTsconfigChain(tsconfigPath);
+        const already = effectiveCompilerOption(chain, 'allowImportingTsExtensions')?.value === true;
+        const target = chain.find(c => c.writable);
+        if (!already && target) {
+            try {
+                const text = fs.readFileSync(target.path, 'utf-8');
+                const patched = upsertCompilerOption(text, 'allowImportingTsExtensions', 'true');
+                if (patched && patched !== text) {
+                    fs.writeFileSync(target.path, patched);
+                    console.log(colors.cyan(`  Set allowImportingTsExtensions: true in ${path.relative(dir, target.path) || 'tsconfig.json'} (noEmit project — imports name the .ts files)`));
+                }
+            }
+            catch (error) {
+                console.log(colors.yellow(`  Could not set allowImportingTsExtensions in ${target.path}: ${error.message}`));
+            }
+        }
+    }
+    if (fixed.length) {
+        const files = new Set(fixed.map(f => f.file)).size;
+        recordBuildIssue(label, 'warning', `Added the ${useTs ? '.ts' : '.js'} extension to ${fixed.length} relative import(s) in ${files} file(s) for NodeNext — review the diff.`);
+    }
+    return fixed.length;
+}
 /** Does `dir` contain any `.d.ts` at all? Bounded, and never descends into a
  *  nested `node_modules` — we are asking about this package's own output. */
 function hasDeclarationFiles(dir, depth = 3) {
@@ -3747,6 +3920,21 @@ export async function buildProject(cwd, opts = {}) {
             buildResult = await runCommandAsync('npm', ['run', 'build'], { cwd, silent: true });
         }
     }
+    // NodeNext surfaced relative imports without extensions (TS2835). Add the
+    // extension tsc suggests and rebuild — two passes at most, since one pass
+    // handles every diagnostic tsc reported and a second only catches what the
+    // first pass's edits uncovered. Kept ahead of the revert below on purpose:
+    // an import that names its file is right under the old resolver too, so
+    // even a build that still fails afterwards keeps these edits.
+    // 2026-09-14 19:00 EDT — Claude Code (Fable 5.1), at Bob's direction.
+    for (let pass = 0; pass < 2 && !buildResult.success; pass++) {
+        const out = (buildResult.stderr || '') + (buildResult.output || '');
+        if (!/error TS283[45]\b/.test(out))
+            break;
+        if (!applyImportExtensionFixes(cwd, out, pkg.name || path.basename(cwd)))
+            break;
+        buildResult = await runCommandAsync('npm', ['run', 'build'], { cwd, silent: true });
+    }
     // "Try changing the 'lib' compiler option to 'es2023' or later" — a tsconfig
     // pinned below the standard-library APIs the code actually uses. Raise it and
     // rebuild. Looped because one level can uncover the need for a higher one,
@@ -4031,12 +4219,45 @@ export function reportTs7Deprecations(cwd) {
  *  the next real TS7-removal error). Returns the dirs whose tsconfigs changed
  *  plus the findings that remain (e.g. options inherited from read-only
  *  node_modules bases). */
-export function fixTs7Deprecations(cwd) {
+export async function fixTs7Deprecations(cwd) {
     const changedDirs = [];
-    for (const dir of collectFileDepDirs(cwd)) {
+    const dirs = collectFileDepDirs(cwd);
+    for (const dir of dirs) {
         if (migrateTsconfigDeprecations(dir))
             changedDirs.push(dir);
     }
+    // Then the imports NodeNext rejects. A type-check pass (`tsc --noEmit`, nothing
+    // written by tsc itself) yields the TS2835 diagnostics that drive
+    // fixImportExtensions; a second pass catches what the first one's edits
+    // uncovered, and whatever still fails is handed back for a human.
+    // 2026-09-14 19:00 EDT — Claude Code (Fable 5.1), at Bob's direction.
+    const importFixes = new Map();
+    const typeErrors = new Map();
+    for (const dir of dirs) {
+        if (!fs.existsSync(path.join(dir, 'tsconfig.json')))
+            continue;
+        const label = (() => { try {
+            return readPackageJson(dir).name;
+        }
+        catch {
+            return null;
+        } })() || path.basename(dir);
+        let result = await runCommandAsync('tsc', ['-p', '.', '--noEmit'], { cwd: dir, silent: true });
+        for (let pass = 0; pass < 2 && !result.success; pass++) {
+            const out = (result.stderr || '') + (result.output || '');
+            if (!/error TS283[45]\b/.test(out))
+                break;
+            const fixedCount = applyImportExtensionFixes(dir, out, label);
+            if (!fixedCount)
+                break;
+            importFixes.set(dir, (importFixes.get(dir) ?? 0) + fixedCount);
+            result = await runCommandAsync('tsc', ['-p', '.', '--noEmit'], { cwd: dir, silent: true });
+        }
+        if (!result.success) {
+            const errs = extractTscErrors((result.stderr || '') + (result.output || ''));
+            typeErrors.set(dir, errs.length ? errs : [(result.stderr || result.output || '').trim().split('\n')[0] || 'tsc failed with no output']);
+        }
+    }
     // Drop ignoreDeprecations wherever nothing deprecated remains in that package.
     let remaining = reportTs7Deprecations(cwd);
     const igdDirs = new Set(remaining.filter(f => f.option === 'ignoreDeprecations').map(f => f.dir));
@@ -4068,7 +4289,7 @@ export function fixTs7Deprecations(cwd) {
     }
     if (removedIgd)
         remaining = reportTs7Deprecations(cwd);
-    return { changedDirs, remaining };
+    return { changedDirs, remaining, importFixes, typeErrors };
 }
 /** Ensure the workspace-root `node_modules/` is in sync with every member's
  *  declared deps. Workspaces hoist deps to the root, so a dep added to any
@@ -4870,7 +5091,9 @@ export function runCommand(cmd, args, options = {}) {
  *  child, restore deps, and exit — instead of being queued behind spawnSync. */
 export function runCommandAsync(cmd, args, options = {}) {
     const { silent = false, verbose = false, showCommand = false, cwd } = options;
-    const needsShell = cmd === 'npm' || cmd === 'npm.cmd' || cmd === 'gh';
+    // npm, gh and tsc are .cmd shims on Windows, which spawn() cannot find without a shell.
+    // (tsc added 2026-09-14 for the -tsfix import-extension pass.)
+    const needsShell = cmd === 'npm' || cmd === 'npm.cmd' || cmd === 'gh' || cmd === 'tsc';
     if (!silent && (showCommand || verbose)) {
         console.log(colors.cyan(`> ${cmd} ${args.join(' ')}`));
     }
@@ -5783,19 +6006,17 @@ const ALL_GITIGNORE = [...IGNORE_PATTERNS.gitignore.security, ...IGNORE_PATTERNS
 const ALL_NPMIGNORE = [...IGNORE_PATTERNS.npmignore.security, ...IGNORE_PATTERNS.npmignore.recommended];
 /** Patterns that should NOT be in .npmignore for noEmit projects (TS files are the runtime files) */
 const TS_NPMIGNORE_PATTERNS = new Set(['*.ts', '!*.d.ts', '*.map', 'tsconfig.json']);
-/** Check if target project uses noEmit (TS files run directly, no compilation) */
+/** Check if target project uses noEmit (TS files run directly, no compilation).
+ *  Reads the effective value through the `extends` chain, not just the local file.
+ *  2026-09-14 — Claude Code (Fable 5.1): was a bare JSON5 read of tsconfig.json;
+ *  now shared with fixImportExtensions, where a wrong answer writes ".js" into a
+ *  project Node runs from its .ts and breaks it at runtime. */
 function isNoEmitProject(cwd) {
     const tsconfigPath = path.join(cwd, 'tsconfig.json');
     if (!fs.existsSync(tsconfigPath))
         return false;
-    try {
-        const content = fs.readFileSync(tsconfigPath, 'utf-8');
-        const tsconfig = JSON5.parse(content);
-        return tsconfig.compilerOptions?.noEmit === true;
-    }
-    catch {
-        return false;
-    }
+    const { chain } = resolveTsconfigChain(tsconfigPath);
+    return effectiveCompilerOption(chain, 'noEmit')?.value === true;
 }
 /** Resolve whether .ts source files should be kept in the published tarball.
  *  Explicit allowTs wins; otherwise noEmit projects default to including .ts. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/npmglobalize",
-  "version": "1.0.230",
+  "version": "1.0.231",
   "description": "Transform file: dependencies to npm versions for publishing",
   "main": "index.js",
   "type": "module",