@knighted/duel 4.0.0-rc.0 → 4.0.0-rc.2

package/README.md

@@ -6,6 +6,9 @@
 
 Tool for building a Node.js [dual package](https://nodejs.org/api/packages.html#dual-commonjses-module-packages) with TypeScript. Supports CommonJS and ES module projects.
 
+> [!NOTE]
+> I wish this tool were unnecessary, but dual emit was declared out of scope by the TypeScript team, so `duel` exists to fill that gap.
+
 ## Features
 
 - Bidirectional ESM ↔️ CJS dual builds inferred from the package.json `type`.
@@ -60,6 +63,9 @@ It should work similarly for a CJS-first project. Except, your package.json file
 > [!IMPORTANT]
 > This works best if your CJS-first project uses file extensions in _relative_ specifiers. That is acceptable in CJS and [required in ESM](https://nodejs.org/api/esm.html#import-specifiers). `duel` does not rewrite bare specifiers or remap relative specifiers to directory indexes.
 
+> [!TIP]
+> `duel` creates a hash-named temp workspace (`.duel-cache/_duel_<hash>_`) inside your project during a build. The `_duel_<hash>_` temp directory is removed on success/failure unless `DUEL_KEEP_TEMP=1` is set. The `.duel-cache/` folder itself (which also holds incremental caches) is not automatically deleted—add it to your `.gitignore`. If a temp folder is ever left behind (e.g., abrupt kill), it is safe to delete.
+
 ### Build orientation
 
 `duel` infers the primary vs dual build orientation from your `package.json` `type`:
@@ -84,7 +90,7 @@ Assuming an `outDir` of `dist`, running the above will create `dist/esm` and `di
 `tsc` is asymmetric: `import.meta` globals fail in a CJS-targeted build, but CommonJS globals like `__filename`/`__dirname` pass when targeting ESM, causing runtime errors in the compiled output. See [TypeScript#58658](https://github.com/microsoft/TypeScript/issues/58658). Use `--mode` to mitigate:
 
 - `--mode globals` [rewrites module globals](https://github.com/knightedcodemonkey/module/blob/main/docs/globals-only.md#rewrites-at-a-glance).
-- `--mode full` adds syntax lowering _in addition to_ the globals rewrite.
+- `--mode full` adds syntax lowering _in addition to_ the globals rewrite. TS sources keep a pre-`tsc` guard (`transformSyntax: "globals-only"`) so TypeScript controls declaration emit; JS/JSX and the dual CJS rewrite path are fully lowered. See the [mode matrix](docs/mode-matrix.md) for details.
 
 ```json
 "scripts": {

package/dist/cjs/duel.cjs

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.duel = void 0;
 const node_process_1 = require("node:process");
+const node_url_1 = require("node:url");
 const node_path_1 = require("node:path");
 const node_child_process_1 = require("node:child_process");
 const promises_1 = require("node:fs/promises");
@@ -53,7 +54,7 @@ const duel = async (args) => {
                 /* continue */
             }
         }, { cwd: projectDir });
-        const runBuild = (project, outDir) => {
+        const runBuild = (project, outDir, tsBuildInfoFile, cwdForBuild) => {
             return new Promise((fulfill, rejectBuild) => {
                 const useBuildMode = hasReferences;
                 const tsArgs = useBuildMode
@@ -61,7 +62,16 @@ const duel = async (args) => {
                     : outDir
                         ? [tsc, '-p', project, '--outDir', outDir]
                         : [tsc, '-p', project];
-                const build = (0, node_child_process_1.spawn)(process.execPath, tsArgs, { stdio: 'inherit' });
+                if (!useBuildMode) {
+                    tsArgs.push('--incremental');
+                    if (tsBuildInfoFile) {
+                        tsArgs.push('--tsBuildInfoFile', tsBuildInfoFile);
+                    }
+                }
+                const build = (0, node_child_process_1.spawn)(process.execPath, tsArgs, {
+                    stdio: 'inherit',
+                    cwd: cwdForBuild ?? process.cwd(),
+                });
                 build.on('exit', code => {
                     if (code > 0) {
                         return rejectBuild(new Error(code));
@@ -77,27 +87,94 @@ const duel = async (args) => {
         const absoluteOutDir = (0, node_path_1.resolve)(projectDir, outDir);
         const originalType = pkg.packageJson.type ?? 'commonjs';
         const isCjsBuild = originalType !== 'commonjs';
+        const absoluteDualOutDir = (0, node_path_1.join)(projectDir, isCjsBuild ? (0, node_path_1.join)(outDir, 'cjs') : (0, node_path_1.join)(outDir, 'esm'));
+        const projectRoot = (0, node_path_1.dirname)(projectDir);
         const primaryOutDir = dirs
             ? isCjsBuild
                 ? (0, node_path_1.join)(absoluteOutDir, 'esm')
                 : (0, node_path_1.join)(absoluteOutDir, 'cjs')
             : absoluteOutDir;
-        const hex = (0, node_crypto_1.randomBytes)(4).toString('hex');
+        const { type, exports, imports, main, module, types, typings, typesVersions, sideEffects, } = pkg.packageJson ?? {};
+        const pkgHashInputs = {
+            type,
+            exports,
+            imports,
+            main,
+            module,
+            types,
+            typings,
+            typesVersions,
+            sideEffects,
+        };
+        const hash = (0, node_crypto_1.createHash)('sha1')
+            .update(JSON.stringify({
+            configPath,
+            tsconfig,
+            packageJson: pkgHashInputs,
+            dualTarget: isCjsBuild ? 'cjs' : 'esm',
+        }))
+            .digest('hex')
+            .slice(0, 8);
+        const cacheDir = (0, node_path_1.join)(projectDir, '.duel-cache');
+        const primaryTsBuildInfoFile = (0, node_path_1.join)(cacheDir, `primary.${hash}.tsbuildinfo`);
+        const dualTsBuildInfoFile = (0, node_path_1.join)(cacheDir, `dual.${hash}.tsbuildinfo`);
+        const subDir = (0, node_path_1.join)(cacheDir, `_duel_${hash}_`);
+        const shadowDualOutDir = (0, node_path_1.join)(subDir, (0, node_path_1.relative)(projectRoot, absoluteDualOutDir));
         const hazardMode = detectDualPackageHazard ?? 'warn';
         const hazardScope = dualPackageHazardScope ?? 'file';
-        const getOverrideTsConfig = () => {
+        function mapReferencesToShadow(references = [], options) {
+            const { resolveRefPath, toShadowPathFn, fromDir } = options;
+            return references.map(ref => {
+                if (!ref?.path)
+                    return ref;
+                const refAbs = resolveRefPath(ref.path);
+                const shadowRef = toShadowPathFn(refAbs);
+                return {
+                    ...ref,
+                    path: (0, node_path_1.relative)(fromDir, shadowRef),
+                };
+            });
+        }
+        const getOverrideTsConfig = dualConfigDir => {
+            const shadowReferences = mapReferencesToShadow(tsconfig.references ?? [], {
+                resolveRefPath: refPath => (0, node_path_1.resolve)(projectDir, refPath),
+                toShadowPathFn: abs => (0, node_path_1.join)(subDir, (0, node_path_1.relative)(projectRoot, abs)),
+                fromDir: dualConfigDir,
+            });
             return {
                 ...tsconfig,
+                references: shadowReferences,
                 compilerOptions: {
-                    ...tsconfig.compilerOptions,
+                    ...(tsconfig.compilerOptions ?? {}),
                     module: 'NodeNext',
                     moduleResolution: 'NodeNext',
+                    target: tsconfig.compilerOptions?.target ?? 'ES2022',
+                    // Emit dual build into the shadow workspace, then copy to real outDir
+                    outDir: shadowDualOutDir,
+                    incremental: true,
+                    tsBuildInfoFile: dualTsBuildInfoFile,
                 },
             };
         };
         const hasReferences = Array.isArray(tsconfig.references) && tsconfig.references.length > 0;
         const runPrimaryBuild = () => {
-            return runBuild(configPath, hasReferences ? undefined : primaryOutDir);
+            return runBuild(configPath, hasReferences ? undefined : primaryOutDir, hasReferences ? undefined : primaryTsBuildInfoFile, projectDir);
+        };
+        const refreshDualBuildInfo = async () => {
+            try {
+                await (0, promises_1.access)(shadowDualOutDir);
+            }
+            catch {
+                await (0, promises_1.rm)(dualTsBuildInfoFile, { force: true });
+            }
+        };
+        const refreshPrimaryBuildInfo = async () => {
+            try {
+                await (0, promises_1.access)(primaryOutDir);
+            }
+            catch {
+                await (0, promises_1.rm)(primaryTsBuildInfoFile, { force: true });
+            }
         };
         const resolveReferenceConfigPath = (baseDir, refPath) => {
             const abs = (0, node_path_1.resolve)(baseDir, refPath);
@@ -233,6 +310,7 @@ const duel = async (args) => {
         let success = false;
         const startTime = node_perf_hooks_1.performance.now();
         try {
+            await refreshPrimaryBuildInfo();
             await runPrimaryBuild();
             success = true;
         }
@@ -240,15 +318,19 @@ const duel = async (args) => {
             handleErrorAndExit(message);
         }
         if (success) {
-            const projectRoot = (0, node_path_1.dirname)(projectDir);
             const parentRoot = (0, node_path_1.dirname)(projectRoot);
-            const subDir = (0, node_path_1.join)(projectRoot, `_${hex}_`);
-            const absoluteDualOutDir = (0, node_path_1.join)(projectDir, isCjsBuild ? (0, node_path_1.join)(outDir, 'cjs') : (0, node_path_1.join)(outDir, 'esm'));
-            const tsconfigDual = getOverrideTsConfig();
             const tsconfigRel = (0, node_path_1.relative)(projectRoot, configPath);
-            const tsconfigDualRel = tsconfigRel.replace(/tsconfig\.json$/i, `tsconfig.${hex}.json`);
+            const tsconfigDualRel = tsconfigRel.replace(/tsconfig\.json$/i, `tsconfig.${hash}.json`);
             const dualConfigPath = (0, node_path_1.join)(subDir, tsconfigDualRel);
             const dualConfigDir = (0, node_path_1.dirname)(dualConfigPath);
+            const tsconfigDual = getOverrideTsConfig(dualConfigDir);
+            const keepTemp = process.env.DUEL_KEEP_TEMP === '1';
+            const { cleanupTemp, cleanupTempSync } = (0, util_js_1.createTempCleanup)({
+                subDir,
+                keepTemp,
+                logWarnFn: util_js_1.logWarn,
+            });
+            const unregisterCleanupHandlers = (0, util_js_1.registerCleanupHandlers)(cleanupTempSync);
             let errorMsg = '';
             let exportsConfigData = null;
             if (exportsConfig) {
@@ -285,11 +367,16 @@ const duel = async (args) => {
                     process.exit(1);
                 }
             }
-            await (0, promises_1.mkdir)(subDir, { recursive: true });
-            await (0, util_js_1.maybeLinkNodeModules)(projectRoot, subDir);
+            await Promise.all([
+                (0, promises_1.mkdir)(subDir, { recursive: true }),
+                (0, promises_1.mkdir)(cacheDir, { recursive: true }),
+            ]);
+            const linkNodeModulesPromise = (0, util_js_1.maybeLinkNodeModules)(projectDir, subDir);
             const projectRel = (0, node_path_1.relative)(projectRoot, projectDir);
             const projectCopyDest = (0, node_path_1.join)(subDir, projectRel);
             const makeCopyFilter = (rootDir, allowDist) => src => {
+                if (src.split(/[/\\]/).includes('.duel-cache'))
+                    return false;
                 if (src.split(/[/\\]/).includes('node_modules'))
                     return false;
                 if (allowDist)
@@ -300,92 +387,170 @@ const duel = async (args) => {
                 const [segment] = rel.split(node_path_1.sep);
                 return segment !== outDir;
             };
-            const copyProjectTree = async (allowDist) => {
-                await (0, promises_1.cp)(projectDir, projectCopyDest, {
-                    recursive: true,
-                    filter: makeCopyFilter(projectDir, allowDist),
-                });
-                if (hasReferences) {
-                    for (const ref of tsconfig.references ?? []) {
-                        if (!ref.path)
+            const copyFilesToTemp = async () => {
+                const copyDirContents = async (sourceDir, destDir, allowDist) => {
+                    await (0, promises_1.mkdir)(destDir, { recursive: true });
+                    const filter = makeCopyFilter(sourceDir, allowDist);
+                    const entries = await (0, promises_1.readdir)(sourceDir, { withFileTypes: true });
+                    for (const entry of entries) {
+                        const srcPath = (0, node_path_1.join)(sourceDir, entry.name);
+                        if (!filter(srcPath))
                             continue;
-                        const refAbs = (0, node_path_1.resolve)(projectDir, ref.path);
-                        const refRel = (0, node_path_1.relative)(projectRoot, refAbs);
-                        const refDest = (0, node_path_1.join)(subDir, refRel);
-                        await (0, promises_1.cp)(refAbs, refDest, {
+                        const dstPath = (0, node_path_1.join)(destDir, entry.name);
+                        await (0, promises_1.cp)(srcPath, dstPath, {
                             recursive: true,
-                            filter: makeCopyFilter(refAbs, allowDist),
+                            filter,
                         });
                     }
+                };
+                if (copyMode === 'full') {
+                    const allowDist = hasReferences;
+                    await copyDirContents(projectDir, projectCopyDest, allowDist);
+                    if (hasReferences) {
+                        for (const ref of tsconfig.references ?? []) {
+                            if (!ref.path)
+                                continue;
+                            const refAbs = (0, node_path_1.resolve)(projectDir, ref.path);
+                            const refRel = (0, node_path_1.relative)(projectRoot, refAbs);
+                            const refDest = (0, node_path_1.join)(subDir, refRel);
+                            await copyDirContents(refAbs, refDest, allowDist);
+                        }
+                    }
                 }
-            };
-            if (copyMode === 'full') {
-                const allowDist = hasReferences;
-                await copyProjectTree(allowDist);
-            }
-            else {
-                const filesToCopy = new Set([...compileFiles, ...configFiles, ...packageJsons]);
-                for (const file of filesToCopy) {
-                    let rel = (0, node_path_1.relative)(projectRoot, file);
-                    rel = (0, node_path_1.normalize)(rel);
-                    if (rel.startsWith('..')) {
-                        const altRel = hasReferences ? (0, node_path_1.normalize)((0, node_path_1.relative)(parentRoot, file)) : rel;
-                        if (!altRel.startsWith('..')) {
-                            rel = altRel;
+                else {
+                    const filesToCopy = new Set([...compileFiles, ...configFiles, ...packageJsons]);
+                    for (const file of filesToCopy) {
+                        let rel = (0, node_path_1.relative)(projectRoot, file);
+                        rel = (0, node_path_1.normalize)(rel);
+                        if (rel.startsWith('..')) {
+                            const altRel = hasReferences ? (0, node_path_1.normalize)((0, node_path_1.relative)(parentRoot, file)) : rel;
+                            if (!altRel.startsWith('..')) {
+                                rel = altRel;
+                            }
+                            else {
+                                (0, util_js_1.logWarn)(`Skipping copy for ${file} outside of project root ${projectRoot}`);
+                                continue;
+                            }
                         }
-                        else {
-                            (0, util_js_1.logWarn)(`Skipping copy for ${file} outside of project root ${projectRoot}`);
-                            continue;
+                        const dest = (0, node_path_1.join)(subDir, rel);
+                        await (0, promises_1.mkdir)((0, node_path_1.dirname)(dest), { recursive: true });
+                        await (0, promises_1.cp)(file, dest);
+                    }
+                    const missingConfigs = [];
+                    for (const configFile of configFiles) {
+                        const dest = (0, node_path_1.join)(subDir, (0, node_path_1.relative)(projectRoot, configFile));
+                        try {
+                            await (0, promises_1.access)(dest);
+                        }
+                        catch {
+                            missingConfigs.push({ src: configFile, dest });
+                        }
+                    }
+                    if (missingConfigs.length) {
+                        (0, util_js_1.logWarn)(`Copying ${missingConfigs.length} missing referenced config(s) into temp workspace: ${missingConfigs
+                            .map(entry => entry.src)
+                            .join(', ')}`);
+                        for (const { src, dest } of missingConfigs) {
+                            await (0, promises_1.mkdir)((0, node_path_1.dirname)(dest), { recursive: true });
+                            await (0, promises_1.cp)(src, dest);
                         }
                     }
-                    const dest = (0, node_path_1.join)(subDir, rel);
-                    await (0, promises_1.mkdir)((0, node_path_1.dirname)(dest), { recursive: true });
-                    await (0, promises_1.cp)(file, dest);
                 }
-                const missingConfigs = [];
+            };
+            const toShadowPath = absPath => (0, node_path_1.join)(subDir, (0, node_path_1.relative)(projectRoot, absPath));
+            // Patch referenced tsconfig files in the shadow workspace to emit dual outputs
+            const patchReferencedConfigs = async () => {
                 for (const configFile of configFiles) {
+                    if (configFile === configPath)
+                        continue;
                     const dest = (0, node_path_1.join)(subDir, (0, node_path_1.relative)(projectRoot, configFile));
+                    let parsed = null;
                     try {
-                        await (0, promises_1.access)(dest);
-                    }
-                    catch {
-                        missingConfigs.push({ src: configFile, dest });
+                        parsed = (0, get_tsconfig_1.parseTsconfig)(dest);
                     }
-                }
-                if (missingConfigs.length) {
-                    (0, util_js_1.logWarn)(`Copying ${missingConfigs.length} missing referenced config(s) into temp workspace: ${missingConfigs
-                        .map(entry => entry.src)
-                        .join(', ')}`);
-                    for (const { src, dest } of missingConfigs) {
-                        await (0, promises_1.mkdir)((0, node_path_1.dirname)(dest), { recursive: true });
-                        await (0, promises_1.cp)(src, dest);
+                    catch (err) {
+                        (0, util_js_1.logWarn)(`Skipping referenced tsconfig at ${dest} (parse failed): ${err?.message ?? err}`);
+                        continue;
                     }
+                    const cfg = parsed?.tsconfig ?? parsed;
+                    if (!cfg || typeof cfg !== 'object')
+                        continue;
+                    const cfgDir = (0, node_path_1.dirname)(configFile);
+                    const baseOut = cfg.compilerOptions?.outDir
+                        ? (0, node_path_1.resolve)(cfgDir, cfg.compilerOptions.outDir)
+                        : (0, node_path_1.resolve)(cfgDir, 'dist');
+                    const dualOutReal = (0, node_path_1.join)(baseOut, isCjsBuild ? 'cjs' : 'esm');
+                    const dualOut = toShadowPath(dualOutReal);
+                    const tsbuildReal = cfg.compilerOptions?.tsBuildInfoFile
+                        ? (0, node_path_1.resolve)(cfgDir, cfg.compilerOptions.tsBuildInfoFile)
+                        : (0, node_path_1.join)(baseOut, 'tsconfig.tsbuildinfo');
+                    const dualTsbuild = toShadowPath((0, node_path_1.join)((0, node_path_1.dirname)(tsbuildReal), 'tsconfig.dual.tsbuildinfo'));
+                    const shadowReferences = mapReferencesToShadow(cfg.references ?? [], {
+                        resolveRefPath: refPath => resolveReferenceConfigPath(cfgDir, refPath),
+                        toShadowPathFn: toShadowPath,
+                        fromDir: (0, node_path_1.dirname)(dest),
+                    });
+                    const patched = {
+                        ...cfg,
+                        references: shadowReferences,
+                        compilerOptions: {
+                            ...(cfg.compilerOptions ?? {}),
+                            module: 'NodeNext',
+                            moduleResolution: 'NodeNext',
+                            outDir: dualOut,
+                            incremental: cfg.compilerOptions?.incremental ?? true,
+                            tsBuildInfoFile: dualTsbuild,
+                        },
+                    };
+                    await (0, promises_1.writeFile)(dest, JSON.stringify(patched, null, 2));
                 }
-            }
+            };
             /**
              * Write dual package.json and tsconfig into temp dir; avoid mutating root package.json.
              */
-            await (0, promises_1.writeFile)((0, node_path_1.join)(subDir, (0, node_path_1.relative)(projectRoot, pkg.path)), JSON.stringify({
-                type: isCjsBuild ? 'commonjs' : 'module',
-            }));
-            await (0, promises_1.mkdir)(dualConfigDir, { recursive: true });
-            await (0, promises_1.writeFile)(dualConfigPath, JSON.stringify({
-                ...tsconfigDual,
-                compilerOptions: {
-                    ...tsconfigDual.compilerOptions,
-                    outDir: absoluteDualOutDir,
-                },
-            }, null, 2));
+            await copyFilesToTemp();
+            await patchReferencedConfigs();
+            const writeDualPackage = async () => {
+                const pkgDest = (0, node_path_1.join)(subDir, (0, node_path_1.relative)(projectRoot, pkg.path));
+                await (0, promises_1.mkdir)((0, node_path_1.dirname)(pkgDest), { recursive: true });
+                await (0, promises_1.writeFile)(pkgDest, JSON.stringify({
+                    name: pkg.packageJson?.name,
+                    version: pkg.packageJson?.version,
+                    type: isCjsBuild ? 'commonjs' : 'module',
+                    exports: pkg.packageJson?.exports,
+                    imports: pkg.packageJson?.imports,
+                    main: pkg.packageJson?.main,
+                    module: pkg.packageJson?.module,
+                    types: pkg.packageJson?.types ?? pkg.packageJson?.typings,
+                    typesVersions: pkg.packageJson?.typesVersions,
+                    sideEffects: pkg.packageJson?.sideEffects,
+                }, null, 2));
+            };
+            const writeDualConfig = async () => {
+                await (0, promises_1.mkdir)(dualConfigDir, { recursive: true });
+                await (0, promises_1.writeFile)(dualConfigPath, JSON.stringify({
+                    ...tsconfigDual,
+                    compilerOptions: {
+                        ...tsconfigDual.compilerOptions,
+                        outDir: shadowDualOutDir,
+                        incremental: true,
+                        tsBuildInfoFile: dualTsBuildInfoFile,
+                    },
+                }, null, 2));
+            };
+            await Promise.all([linkNodeModulesPromise, writeDualPackage(), writeDualConfig()]);
             if (modules) {
                 /**
                  * Transform ambiguous modules for the target dual build.
                  * @see https://github.com/microsoft/TypeScript/issues/58658
                  */
                 const toTransform = await (0, glob_1.glob)(`${subDir.replace(/\\/g, '/')}/**/*{.js,.jsx,.ts,.tsx}`, {
-                    ignore: 'node_modules/**',
+                    ignore: `${subDir.replace(/\\/g, '/')}/**/node_modules/**`,
                 });
                 let transformDiagnosticsError = false;
                 for (const file of toTransform) {
+                    if (file.split(/[/\\]/).includes('node_modules'))
+                        continue;
                     const isTsLike = /\.[cm]?tsx?$/.test(file);
                     const transformSyntaxMode = syntaxMode === true && isTsLike ? 'globals-only' : syntaxMode;
                     const diagnostics = [];
@@ -407,22 +572,16 @@ const duel = async (args) => {
             // Build dual
             (0, util_js_1.log)('Starting dual build...');
             try {
-                await runBuild(dualConfigPath, hasReferences ? undefined : absoluteDualOutDir);
+                await refreshDualBuildInfo();
+                await runBuild(dualConfigPath, hasReferences ? undefined : shadowDualOutDir, hasReferences ? undefined : dualTsBuildInfoFile, subDir);
             }
             catch ({ message }) {
                 success = false;
                 errorMsg = message;
             }
-            finally {
-                const keepTemp = process.env.DUEL_KEEP_TEMP === '1';
-                // Cleanup temp dir unless debugging is requested
-                if (!keepTemp) {
-                    await (0, promises_1.rm)(dualConfigPath, { force: true });
-                    await (0, promises_1.rm)(subDir, { force: true, recursive: true });
-                }
-                else {
-                    (0, util_js_1.logWarn)(`DUEL_KEEP_TEMP=1 set; temp workspace preserved at ${subDir}`);
-                }
+            if (!success) {
+                await cleanupTemp();
+                unregisterCleanupHandlers();
                 if (errorMsg) {
                     handleErrorAndExit(errorMsg);
                 }
@@ -430,24 +589,41 @@ const duel = async (args) => {
             if (success) {
                 const dualTarget = isCjsBuild ? 'commonjs' : 'module';
                 const dualTargetExt = isCjsBuild ? '.cjs' : dirs ? '.js' : '.mjs';
-                const filenames = await (0, glob_1.glob)(`${absoluteDualOutDir.replace(/\\/g, '/')}/**/*{.js,.d.ts}`, {
-                    ignore: 'node_modules/**',
+                await (0, promises_1.rm)(absoluteDualOutDir, { force: true, recursive: true });
+                await (0, promises_1.mkdir)((0, node_path_1.dirname)(absoluteDualOutDir), { recursive: true });
+                // Only copy if the shadow dual outDir was produced; absent indicates a failed emit
+                try {
+                    await (0, promises_1.cp)(shadowDualOutDir, absoluteDualOutDir, { recursive: true });
+                }
+                catch (err) {
+                    if (err?.code === 'ENOENT') {
+                        throw new Error(`Dual build output not found at ${shadowDualOutDir}`);
+                    }
+                    throw err;
+                }
+                const dualGlob = dualTarget === 'commonjs' ? '**/*{.js,.cjs,.d.ts}' : '**/*{.js,.mjs,.d.ts}';
+                const filenames = await (0, glob_1.glob)(`${absoluteDualOutDir.replace(/\\/g, '/')}/${dualGlob}`, {
+                    ignore: `${absoluteDualOutDir.replace(/\\/g, '/')}/**/node_modules/**`,
                 });
+                const rewriteSyntaxMode = dualTarget === 'commonjs' ? true : syntaxMode;
                 await (0, resolver_js_1.rewriteSpecifiersAndExtensions)(filenames, {
                     target: dualTarget,
                     ext: dualTargetExt,
-                    syntaxMode,
+                    syntaxMode: rewriteSyntaxMode,
                     rewritePolicy,
                     validateSpecifiers,
                     onWarn: message => (0, util_js_1.logWarn)(message),
                     onRewrite: (from, to) => logVerbose(`Rewrote specifiers in ${from} -> ${to}`),
                 });
                 if (dirs && originalType === 'commonjs') {
-                    const primaryFiles = await (0, glob_1.glob)(`${primaryOutDir.replace(/\\/g, '/')}/**/*{.js,.d.ts}`, { ignore: 'node_modules/**' });
+                    const primaryFiles = await (0, glob_1.glob)(`${primaryOutDir.replace(/\\/g, '/')}/**/*{.js,.cjs,.d.ts}`, {
+                        ignore: `${primaryOutDir.replace(/\\/g, '/')}/**/node_modules/**`,
+                    });
                     await (0, resolver_js_1.rewriteSpecifiersAndExtensions)(primaryFiles, {
                         target: 'commonjs',
                         ext: '.cjs',
-                        syntaxMode,
+                        // Always lower syntax for primary CJS output when dirs mode rewrites primary build.
+                        syntaxMode: true,
                         rewritePolicy,
                         validateSpecifiers,
                         onWarn: message => (0, util_js_1.logWarn)(message),
@@ -467,15 +643,33 @@ const duel = async (args) => {
                     mainDefaultKind,
                     mainPath,
                 });
+                await cleanupTemp();
+                unregisterCleanupHandlers();
                 logSuccess(startTime);
             }
         }
     }
 };
 exports.duel = duel;
-(async () => {
-    const realFileUrlArgv1 = await (0, util_js_1.getRealPathAsFileUrl)(node_process_1.argv[1] ?? '');
-    if (require("node:url").pathToFileURL(__filename).href === realFileUrlArgv1) {
-        await duel();
+const getCurrentHref = () => {
+    if (typeof module !== 'undefined' && require("node:url").pathToFileURL(__filename).href)
+        return require("node:url").pathToFileURL(__filename).href;
+    if (typeof module !== 'undefined' && module?.filename) {
+        return (0, node_url_1.pathToFileURL)(module.filename).href;
+    }
+    return null;
+};
+const runIfEntry = async () => {
+    try {
+        const realFileUrlArgv1 = await (0, util_js_1.getRealPathAsFileUrl)(node_process_1.argv[1] ?? '');
+        const currentHref = getCurrentHref();
+        if (currentHref && currentHref === realFileUrlArgv1) {
+            await duel();
+        }
     }
-})();
+    catch (err) {
+        (0, util_js_1.logError)(err?.message ?? err);
+        process.exit(1);
+    }
+};
+runIfEntry();

package/dist/cjs/init.cjs

@@ -189,7 +189,8 @@ const init = async (args) => {
             (0, util_js_1.logError)(`Provided --project '${project}' resolves to ${configPath} which is not a file or directory.`);
             return false;
         }
-        pkg = await (0, read_package_up_1.readPackageUp)({ cwd: pkgDir ?? configPath });
+        const pkgSearchCwd = pkgDir ?? (stats.isDirectory() ? configPath : (0, node_path_1.dirname)(configPath));
+        pkg = await (0, read_package_up_1.readPackageUp)({ cwd: pkgSearchCwd });
         if (!pkg) {
             (0, util_js_1.logError)('No package.json file found.');
             return false;

package/dist/cjs/init.d.cts

@@ -1,18 +1,27 @@
 export function init(args: any): Promise<false | {
-    pkg: any;
-    dirs: any;
+    pkg: import("read-package-up", { with: { "resolution-mode": "import" } }).NormalizedReadResult;
+    dirs: boolean;
     modules: boolean;
     transformSyntax: boolean;
-    exports: any;
-    exportsConfig: any;
-    exportsValidate: any;
-    rewritePolicy: any;
-    validateSpecifiers: any;
-    detectDualPackageHazard: any;
-    dualPackageHazardScope: any;
-    verbose: any;
-    copyMode: any;
-    tsconfig: any;
-    projectDir: any;
-    configPath: any;
+    exports: string | undefined;
+    exportsConfig: string | undefined;
+    exportsValidate: boolean;
+    rewritePolicy: string;
+    validateSpecifiers: boolean;
+    detectDualPackageHazard: string;
+    dualPackageHazardScope: string;
+    verbose: boolean;
+    copyMode: string;
+    tsconfig: {
+        compilerOptions?: import("get-tsconfig").TsConfigJson.CompilerOptions | undefined;
+        watchOptions?: import("get-tsconfig").TsConfigJson.WatchOptions | undefined;
+        typeAcquisition?: import("get-tsconfig").TsConfigJson.TypeAcquisition | undefined;
+        compileOnSave?: boolean | undefined;
+        files?: string[] | undefined;
+        exclude?: string[] | undefined;
+        include?: string[] | undefined;
+        references?: import("get-tsconfig").TsConfigJson.References[] | undefined;
+    };
+    projectDir: string;
+    configPath: string;
 }>;