bunchee 6.6.2 → 6.8.0

package/README.md

@@ -317,6 +317,23 @@ bunchee --no-external
 
 This will include all dependencies within your output bundle.
 
+#### TypeScript-Go Compiler
+
+TypeScript-Go (`@typescript/native-preview`) is a high-performance, Go-based implementation of the TypeScript compiler that can significantly speed up type declaration file generation.
+
+To use TypeScript-Go for type generation, use the `--tsgo` flag:
+
+```sh
+bunchee --tsgo
+```
+
+**Note**: This requires `@typescript/native-preview` to be installed as a dev dependency. If it's not installed, bunchee will exit with an error.
+
+```sh
+pnpm add -D bunchee @typescript/native-preview
+bunchee --tsgo
+```
+
 #### Build Successful Command
 
 A command to be executed after a build is successful can be specified using the `--success` option, which is useful for development watching mode:
@@ -365,6 +382,14 @@ Then use use the [exports field in package.json](https://nodejs.org/api/packages
 
 If you're building a TypeScript library, separate the types from the main entry file and specify the types path in package.json. Types exports need to stay on the top of each export with `types` condition, and you can use `default` condition for the JS bundle file.
 
+**bunchee** supports using the TypeScript-Go compiler (`@typescript/native-preview`) for faster type generation. To enable it, use the `--tsgo` flag:
+
+```sh
+bunchee --tsgo
+```
+
+Note: This requires `@typescript/native-preview` to be installed as a dev dependency. If it's not installed, bunchee will fall back to the regular TypeScript compiler with a warning.
+
 ```json5
 {
   "files": ["dist"],
@@ -545,6 +570,7 @@ await bundle(path.resolve('./src/index.ts'), {
   cwd: process.cwd(), // string
   clean: true, // boolean
   tsconfig: 'tsconfig.json', // string
+  tsgo: false, // Boolean - use TypeScript-Go compiler for type generation
 })
 ```
 

package/dist/bin/cli.js

@@ -198,7 +198,7 @@ function validateEntryFiles(entryFiles) {
 
 function exit(err) {
     logger.error(err);
-    process.exit(1);
+    throw typeof err === 'string' ? new Error(err) : err;
 }
 function hasPackageJson(cwd) {
     return fileExists(path__default.default.resolve(cwd, 'package.json'));
@@ -437,13 +437,13 @@ function validateFilesField(packageJson) {
         '*'
     ];
     const exportsField = packageJson.exports || {};
-    const resolveExportsPaths = (exports)=>{
+    const resolveExportsPaths = (exports$1)=>{
         const paths = [];
-        if (typeof exports === 'string') {
-            paths.push(exports);
-        } else if (typeof exports === 'object') {
-            for(const key in exports){
-                paths.push(...resolveExportsPaths(exports[key]));
+        if (typeof exports$1 === 'string') {
+            paths.push(exports$1);
+        } else if (typeof exports$1 === 'object') {
+            for(const key in exports$1){
+                paths.push(...resolveExportsPaths(exports$1[key]));
             }
         }
         return paths;
@@ -470,7 +470,7 @@ function validateFilesField(packageJson) {
     return state;
 }
 function lint$1(pkg) {
-    const { name, main, exports } = pkg;
+    const { name, main, exports: exports$1 } = pkg;
     const isESM = isESModulePackage(pkg.type);
     const parsedExports = parseExports(pkg);
     if (!name) {
@@ -500,12 +500,12 @@ function lint$1(pkg) {
     };
     // Validate ESM package
     if (isESM) {
-        if (exports) {
-            if (typeof exports === 'string') {
-                if (hasCjsExtension(exports)) {
+        if (exports$1) {
+            if (typeof exports$1 === 'string') {
+                if (hasCjsExtension(exports$1)) {
                     exportsState.badMainExport = true;
                 }
-            } else if (typeof exports !== 'object') {
+            } else if (typeof exports$1 !== 'object') {
                 exportsState.invalidExportsFieldType = true;
             } else {
                 parsedExports.forEach((outputPairs)=>{
@@ -548,12 +548,12 @@ function lint$1(pkg) {
         if (main && path__default.default.extname(main) === '.mjs') {
             exportsState.badMainExtension = true;
         }
-        if (exports) {
-            if (typeof exports === 'string') {
-                if (path__default.default.extname(exports) === '.mjs') {
+        if (exports$1) {
+            if (typeof exports$1 === 'string') {
+                if (path__default.default.extname(exports$1) === '.mjs') {
                     exportsState.badMainExport = true;
                 }
-            } else if (typeof exports !== 'object') {
+            } else if (typeof exports$1 !== 'object') {
                 exportsState.invalidExportsFieldType = true;
             } else {
                 parsedExports.forEach((outputPairs)=>{
@@ -647,11 +647,12 @@ function lint$1(pkg) {
     }
 }
 
-var version = "6.6.2";
+var version = "6.8.0";
 
-async function writeDefaultTsconfig(tsConfigPath) {
+async function writeDefaultTsconfig(tsConfigPath, useTsGo) {
     await fs.promises.writeFile(tsConfigPath, JSON.stringify(DEFAULT_TS_CONFIG, null, 2), 'utf-8');
-    logger.log(`Detected using TypeScript but tsconfig.json is missing, created a ${pc.blue('tsconfig.json')} for you.`);
+    const compilerName = 'TypeScript';
+    logger.log(`Detected using ${compilerName} but tsconfig.json is missing, created a ${pc.blue('tsconfig.json')} for you.`);
 }
 
 // ./index -> default
@@ -826,7 +827,7 @@ const normalizeBaseNameToExportName = (name)=>{
     const baseName = stripeBinaryTag(name);
     return /^\.\/index(\.|$)/.test(baseName) ? '.' : posixRelativify(baseName);
 };
-function createExportCondition(exportName, sourceFile, moduleType) {
+function createExportCondition(exportName, sourceFile, moduleType, esmOnly = false) {
     const isTsSourceFile = isTypescriptFile(sourceFile);
     let cjsExtension = 'js';
     let esmExtension = 'mjs';
@@ -838,23 +839,31 @@ function createExportCondition(exportName, sourceFile, moduleType) {
         exportName = 'index';
     }
     if (isTsSourceFile) {
+        const importCondition = {
+            types: getDistPath('es', `${exportName}.${dtsExtensionsMap[esmExtension]}`),
+            default: getDistPath('es', `${exportName}.${esmExtension}`)
+        };
+        if (esmOnly) {
+            return importCondition;
+        }
         return {
-            import: {
-                types: getDistPath('es', `${exportName}.${dtsExtensionsMap[esmExtension]}`),
-                default: getDistPath('es', `${exportName}.${esmExtension}`)
-            },
+            import: importCondition,
             require: {
                 types: getDistPath('cjs', `${exportName}.${dtsExtensionsMap[cjsExtension]}`),
                 default: getDistPath('cjs', `${exportName}.${cjsExtension}`)
             }
         };
     }
+    const importPath = getDistPath(`${exportName}.${esmExtension}`);
+    if (esmOnly) {
+        return importPath;
+    }
     return {
-        import: getDistPath(`${exportName}.mjs`),
+        import: importPath,
         require: getDistPath(`${exportName}.${cjsExtension}`)
     };
 }
-function createExportConditionPair(exportName, sourceFile, moduleType) {
+function createExportConditionPair(exportName, sourceFile, moduleType, esmOnly = false) {
     // <exportName>.<specialCondition>
     let specialCondition;
     const specialConditionName = getSpecialExportTypeFromComposedExportPath(exportName);
@@ -872,13 +881,39 @@ function createExportConditionPair(exportName, sourceFile, moduleType) {
             specialCondition
         ];
     }
-    const exportCond = createExportCondition(exportName, sourceFile, moduleType);
+    const exportCond = createExportCondition(exportName, sourceFile, moduleType, esmOnly);
     return [
         normalizedExportPath,
         exportCond
     ];
 }
-async function prepare(cwd) {
+function detectPackageManager(cwd) {
+    if (fs__default.default.existsSync(path__default.default.join(cwd, 'pnpm-lock.yaml'))) {
+        return 'pnpm';
+    }
+    if (fs__default.default.existsSync(path__default.default.join(cwd, 'yarn.lock'))) {
+        return 'yarn';
+    }
+    if (fs__default.default.existsSync(path__default.default.join(cwd, 'package-lock.json'))) {
+        return 'npm';
+    }
+    // Default to npm if no lock file found
+    return 'npm';
+}
+function addBuildScripts(pkgJson, cwd) {
+    if (!pkgJson.scripts) {
+        pkgJson.scripts = {};
+    }
+    const packageManager = detectPackageManager(cwd);
+    const buildCmd = packageManager === 'pnpm' ? 'pnpm build' : `${packageManager} run build`;
+    if (!pkgJson.scripts.build) {
+        pkgJson.scripts.build = 'bunchee';
+    }
+    if (!pkgJson.scripts.prepublishOnly) {
+        pkgJson.scripts.prepublishOnly = buildCmd;
+    }
+}
+async function prepare(cwd, options) {
     const sourceFolder = path__default.default.resolve(cwd, SRC);
     if (!fs__default.default.existsSync(sourceFolder)) {
         logger.error(`Source folder ${sourceFolder} does not exist. Cannot proceed to configure \`exports\` field.`);
@@ -920,7 +955,8 @@ async function prepare(cwd) {
         }
     }
     // Configure as ESM package by default if there's no package.json
-    if (!hasPackageJson) {
+    // OR if --esm flag is explicitly set
+    if (!hasPackageJson || (options == null ? void 0 : options.esm)) {
         pkgJson.type = 'module';
     }
     if (bins.size > 0) {
@@ -950,24 +986,40 @@ async function prepare(cwd) {
             }
         }
         const pkgExports = {};
+        const esmOnly = (options == null ? void 0 : options.esm) === true;
         for (const [exportName, sourceFilesMap] of exportsEntries.entries()){
             for (const sourceFile of Object.values(sourceFilesMap)){
-                const [normalizedExportPath, conditions] = createExportConditionPair(exportName, sourceFile, pkgJson.type);
-                pkgExports[normalizedExportPath] = {
-                    ...conditions,
-                    ...pkgExports[normalizedExportPath]
-                };
+                const [normalizedExportPath, conditions] = createExportConditionPair(exportName, sourceFile, pkgJson.type, esmOnly);
+                // When esmOnly is true, conditions is either a string or an object with types/default (no import/require)
+                // When esmOnly is false, conditions is an object with import/require
+                if (esmOnly || typeof conditions === 'string' || typeof conditions === 'object' && conditions !== null && !('import' in conditions || 'require' in conditions)) {
+                    pkgExports[normalizedExportPath] = conditions;
+                } else {
+                    pkgExports[normalizedExportPath] = {
+                        ...conditions,
+                        ...pkgExports[normalizedExportPath]
+                    };
+                }
             }
         }
         // Configure node10 module resolution
         if (exportsEntries.has('./index')) {
             const isESM = pkgJson.type === 'module';
             const mainExport = pkgExports['.'];
-            const mainCondition = isESM ? 'import' : 'require';
-            pkgJson.main = isUsingTs ? mainExport[mainCondition].default : mainExport[mainCondition];
-            pkgJson.module = isUsingTs ? mainExport.import.default : mainExport.import;
-            if (isUsingTs) {
-                pkgJson.types = mainExport[mainCondition].types;
+            if (esmOnly) {
+                // When esmOnly is true, mainExport is either a string or an object with types/default
+                pkgJson.main = isUsingTs ? typeof mainExport === 'object' ? mainExport.default : mainExport : typeof mainExport === 'string' ? mainExport : mainExport.default;
+                pkgJson.module = isUsingTs ? typeof mainExport === 'object' ? mainExport.default : mainExport : typeof mainExport === 'string' ? mainExport : mainExport.default;
+                if (isUsingTs && typeof mainExport === 'object') {
+                    pkgJson.types = mainExport.types;
+                }
+            } else {
+                const mainCondition = isESM ? 'import' : 'require';
+                pkgJson.main = isUsingTs ? mainExport[mainCondition].default : mainExport[mainCondition];
+                pkgJson.module = isUsingTs ? mainExport.import.default : mainExport.import;
+                if (isUsingTs) {
+                    pkgJson.types = mainExport[mainCondition].types;
+                }
             }
         }
         // Assign the properties by order: files, main, module, types, exports
@@ -987,6 +1039,10 @@ async function prepare(cwd) {
             }
         }
     }
+    // Additional setup when --esm flag is set
+    if (options == null ? void 0 : options.esm) {
+        addBuildScripts(pkgJson, cwd);
+    }
     await fsp__default.default.writeFile(pkgJsonPath, JSON.stringify(pkgJson, null, 2) + '\n');
     logger.info('Configured `exports` in package.json');
 }
@@ -1082,7 +1138,7 @@ Options:
   -o, --output <file>    specify output filename
   -f, --format <format>  type of output (esm, amd, cjs, iife, umd, system), default: esm
   -h, --help             output usage information
-  
+
   --external <mod>       specify an external dependency, separate by comma
   --no-external          do not bundle external dependencies
   --no-clean             do not clean dist folder before building, default: false
@@ -1095,6 +1151,7 @@ Options:
   --tsconfig             path to tsconfig file, default: tsconfig.json
   --dts-bundle           bundle type declaration files, default: false
   --success <cmd>     run command after build success
+  --tsgo                use TypeScript-Go compiler for type generation
 `;
 function help() {
     logger.log(helpMessage);
@@ -1172,8 +1229,18 @@ async function parseCliArgs(argv) {
     }).option('success', {
         type: 'string',
         description: 'run command after build success'
-    }).command('prepare', 'auto configure package.json exports for building', ()=>{}, (argv)=>{
-        return prepare(argv.cwd || process.cwd());
+    }).option('tsgo', {
+        type: 'boolean',
+        description: 'use TypeScript-Go compiler for type generation'
+    }).command('prepare', 'auto configure package.json exports for building', (yargs)=>{
+        return yargs.option('esm', {
+            type: 'boolean',
+            description: 'configure package as ESM (sets type: "module")'
+        });
+    }, (argv)=>{
+        return prepare(argv.cwd || process.cwd(), {
+            esm: argv.esm
+        });
     }).command('lint', 'lint package.json', ()=>{}, (argv)=>{
         return lint(argv.cwd || process.cwd());
     }).version(version).help('help', 'output usage information').showHelpOnFail(true).parse();
@@ -1207,7 +1274,8 @@ async function parseCliArgs(argv) {
         clean: args['clean'] !== false,
         env: args['env'],
         tsconfig: args['tsconfig'],
-        onSuccess: args['success']
+        onSuccess: args['success'],
+        tsgo: args['tsgo']
     };
     // When minify is enabled, sourcemap should be enabled by default, unless explicitly opted out
     if (parsedArgs.minify && typeof args['sourcemap'] === 'undefined') {
@@ -1236,9 +1304,22 @@ async function run(args) {
         env: (env == null ? void 0 : env.split(',')) || [],
         clean,
         tsconfig,
-        onSuccess
+        onSuccess,
+        tsgo: args.tsgo
     };
     const cliEntry = source ? path__default.default.resolve(cwd, source) : '';
+    // Check if ts-go is available when requested (before any build operations)
+    if (args.tsgo) {
+        try {
+            require.resolve('@typescript/native-preview', {
+                paths: [
+                    cwd
+                ]
+            });
+        } catch  {
+            exit('--tsgo flag was specified but @typescript/native-preview is not installed. Please install it as a dev dependency: pnpm add -D @typescript/native-preview');
+        }
+    }
     // lint package by default
     await lint(cwd);
     const spinnerInstance = process.stdout.isTTY ? nanospinner.createSpinner('Building...\n\n', {
@@ -1389,4 +1470,7 @@ function logError(err) {
     const error = normalizeError(err);
     logger.error(error);
 }
-main().catch(exit);
+main().catch((error)=>{
+    logError(error);
+    process.exit(1);
+});

package/dist/index.d.ts

@@ -22,6 +22,7 @@ type BundleConfig = {
     clean?: boolean;
     tsconfig?: string;
     onSuccess?: string | (() => void | Promise<void>);
+    tsgo?: boolean;
     _callbacks?: {
         onBuildStart?: (state: any) => void;
         onBuildEnd?: (assetJobs: any) => void;
@@ -36,6 +37,7 @@ type PackageMetadata = {
     files?: string[];
     type?: 'commonjs' | 'module';
     dependencies?: Record<string, string>;
+    optionalDependencies?: Record<string, string>;
     peerDependencies?: Record<string, string>;
     peerDependenciesMeta?: Record<string, Record<string, string>>;
     exports?: string | Record<string, ExportCondition>;

package/dist/index.js

@@ -299,7 +299,7 @@ function validateEntryFiles(entryFiles) {
 
 function exit(err) {
     logger.error(err);
-    process.exit(1);
+    throw typeof err === 'string' ? new Error(err) : err;
 }
 async function getPackageMeta(cwd) {
     const pkgFilePath = path__default.default.resolve(cwd, 'package.json');
@@ -1034,7 +1034,42 @@ const memoizeByKey = (fn)=>{
 const memoize = (fn)=>createMemoize(fn);
 
 let hasLoggedTsWarning = false;
-function resolveTypescript(cwd) {
+let hasLoggedTsGoWarning = false;
+function resolveTsGo(cwd) {
+    let tsgo;
+    const m = new module$1.Module('', undefined);
+    m.paths = module$1.Module._nodeModulePaths(cwd);
+    try {
+        // Bun does not yet support the `Module` class properly.
+        if (typeof (m == null ? void 0 : m.require) === 'undefined') {
+            const tsgoPath = require.resolve('@typescript/native-preview', {
+                paths: [
+                    cwd
+                ]
+            });
+            tsgo = require(tsgoPath);
+        } else {
+            tsgo = m.require('@typescript/native-preview');
+        }
+        // ts-go exports the TypeScript API as default or named export
+        return tsgo.default || tsgo;
+    } catch (e) {
+        if (!hasLoggedTsGoWarning) {
+            hasLoggedTsGoWarning = true;
+            logger.warn('Could not load TypeScript-Go compiler. Make sure `@typescript/native-preview` is installed as a dev dependency.');
+        }
+        return null;
+    }
+}
+function resolveTypescript(cwd, useTsGo) {
+    if (useTsGo) {
+        const tsgo = resolveTsGo(cwd);
+        if (tsgo) {
+            return tsgo;
+        }
+        // Error if ts-go is requested but not available
+        exit('TypeScript-Go compiler not found. Please install @typescript/native-preview as a dev dependency: pnpm add -D @typescript/native-preview');
+    }
     let ts;
     const m = new module$1.Module('', undefined);
     m.paths = module$1.Module._nodeModulePaths(cwd);
@@ -1064,11 +1099,11 @@ const resolveTsConfigPath = memoize((cwd, tsconfigFileName = 'tsconfig.json')=>{
     tsConfigPath = path.resolve(cwd, tsconfigFileName);
     return fileExists(tsConfigPath) ? tsConfigPath : undefined;
 });
-function resolveTsConfigHandler(cwd, tsConfigPath) {
+function resolveTsConfigHandler(cwd, tsConfigPath, useTsGo) {
     let tsCompilerOptions = {};
     if (tsConfigPath) {
         // Use the original ts handler to avoid memory leak
-        const ts = resolveTypescript(cwd);
+        const ts = resolveTypescript(cwd, useTsGo);
         const basePath = tsConfigPath ? path.dirname(tsConfigPath) : cwd;
         const tsconfigJSON = ts.readConfigFile(tsConfigPath, ts.sys.readFile).config;
         tsCompilerOptions = ts.parseJsonConfigFileContent(tsconfigJSON, ts.sys, basePath).options;
@@ -1080,15 +1115,28 @@ function resolveTsConfigHandler(cwd, tsConfigPath) {
         tsConfigPath
     };
 }
-const resolveTsConfig = memoize(resolveTsConfigHandler);
-async function convertCompilerOptions(cwd, json) {
+// Note: We can't memoize resolveTsConfigHandler directly with useTsGo parameter
+// because memoize doesn't handle optional parameters well. Instead, we'll create
+// a wrapper that handles the memoization per useTsGo value.
+const resolveTsConfigCache = new Map();
+function resolveTsConfig(cwd, tsConfigPath, useTsGo) {
+    const cacheKey = `${cwd}:${tsConfigPath || ''}:${useTsGo ? 'tsgo' : 'ts'}`;
+    if (resolveTsConfigCache.has(cacheKey)) {
+        return resolveTsConfigCache.get(cacheKey);
+    }
+    const result = resolveTsConfigHandler(cwd, tsConfigPath, useTsGo);
+    resolveTsConfigCache.set(cacheKey, result);
+    return result;
+}
+async function convertCompilerOptions(cwd, json, useTsGo) {
     // Use the original ts handler to avoid memory leak
-    const ts = resolveTypescript(cwd);
+    const ts = resolveTypescript(cwd, useTsGo);
     return ts.convertCompilerOptionsFromJson(json, './');
 }
-async function writeDefaultTsconfig(tsConfigPath) {
+async function writeDefaultTsconfig(tsConfigPath, useTsGo) {
     await fs.promises.writeFile(tsConfigPath, JSON.stringify(DEFAULT_TS_CONFIG, null, 2), 'utf-8');
-    logger.log(`Detected using TypeScript but tsconfig.json is missing, created a ${pc.blue('tsconfig.json')} for you.`);
+    const compilerName = useTsGo ? 'TypeScript-Go' : 'TypeScript';
+    logger.log(`Detected using ${compilerName} but tsconfig.json is missing, created a ${pc.blue('tsconfig.json')} for you.`);
 }
 
 /**
@@ -1327,6 +1375,89 @@ function rawContent({ exclude }) {
     };
 }
 
+const NATIVE_ADDON_SUFFIX = '\0native-addon:';
+/**
+ * Plugin to handle native Node.js addon (.node) files.
+ * Copies the binary to the output directory and rewrites import paths.
+ */ function nativeAddon() {
+    // Map from virtual module id to original absolute path
+    const nativeAddonMap = new Map();
+    return {
+        name: 'native-addon',
+        resolveId (source, importer) {
+            // Check if this is a .node file import
+            if (!source.endsWith('.node')) {
+                return null;
+            }
+            // Resolve the absolute path of the .node file
+            let absolutePath;
+            if (path__default.default.isAbsolute(source)) {
+                absolutePath = source;
+            } else if (importer) {
+                absolutePath = path__default.default.resolve(path__default.default.dirname(importer), source);
+            } else {
+                return null;
+            }
+            // Create a virtual module id for this native addon
+            const virtualId = NATIVE_ADDON_SUFFIX + absolutePath;
+            // Track the mapping
+            nativeAddonMap.set(virtualId, absolutePath);
+            return virtualId;
+        },
+        async load (id) {
+            if (!id.startsWith(NATIVE_ADDON_SUFFIX)) {
+                return null;
+            }
+            const absolutePath = nativeAddonMap.get(id);
+            if (!absolutePath) {
+                return null;
+            }
+            // Get the filename for the output
+            const fileName = path__default.default.basename(absolutePath);
+            // Return code that will require the binary from the same directory
+            // Using __dirname to get the directory of the output file at runtime
+            return {
+                code: `
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const require = createRequire(import.meta.url);
+
+const nativeAddon = require(join(__dirname, ${JSON.stringify(fileName)}));
+export default nativeAddon;
+`,
+                map: null,
+                meta: {
+                    nativeAddon: {
+                        absolutePath,
+                        fileName
+                    }
+                }
+            };
+        },
+        async generateBundle () {
+            // Copy all tracked native addon files to the output directory
+            for (const [_, absolutePath] of nativeAddonMap){
+                const fileName = path__default.default.basename(absolutePath);
+                try {
+                    const fileContent = await fsp.readFile(absolutePath);
+                    // Emit the binary file as an asset
+                    this.emitFile({
+                        type: 'asset',
+                        fileName,
+                        source: fileContent
+                    });
+                } catch (error) {
+                    this.error(`[bunchee] Failed to read native addon file: ${absolutePath}`);
+                }
+            }
+        }
+    };
+}
+
 function hasNoSpecialCondition(conditionNames) {
     return [
         ...conditionNames
@@ -1457,6 +1588,51 @@ const prependShebang = (entry)=>({
         }
     });
 
+function hasSwcHelpersDeclared(pkg) {
+    var _pkg_dependencies, _pkg_peerDependencies, _pkg_optionalDependencies;
+    return Boolean(((_pkg_dependencies = pkg.dependencies) == null ? void 0 : _pkg_dependencies['@swc/helpers']) || ((_pkg_peerDependencies = pkg.peerDependencies) == null ? void 0 : _pkg_peerDependencies['@swc/helpers']) || ((_pkg_optionalDependencies = pkg.optionalDependencies) == null ? void 0 : _pkg_optionalDependencies['@swc/helpers']));
+}
+function isSwcHelpersInstalled(cwd) {
+    try {
+        // Use Node's resolver (supports pnpm/yarn PnP) and resolve from the user's project.
+        const req = module$1.createRequire(path__default.default.join(cwd, 'package.json'));
+        req.resolve('@swc/helpers/package.json');
+        return true;
+    } catch  {
+        return false;
+    }
+}
+function chunkUsesSwcHelpers(chunk) {
+    const allImports = chunk.imports.concat(chunk.dynamicImports);
+    return allImports.some((id)=>id === '@swc/helpers' || id.startsWith('@swc/helpers/'));
+}
+function swcHelpersWarningPlugin({ cwd, pkg }) {
+    let hasWarned = false;
+    const swcHelpersImportFiles = new Set();
+    return {
+        name: 'bunchee:swc-helpers-warning',
+        writeBundle (options, bundle) {
+            if (hasWarned) return;
+            const outputDir = options.dir || path__default.default.dirname(options.file);
+            for (const [fileName, item] of Object.entries(bundle)){
+                if (item.type !== 'chunk') continue;
+                if (!chunkUsesSwcHelpers(item)) continue;
+                swcHelpersImportFiles.add(path__default.default.relative(cwd, path__default.default.join(outputDir, fileName)));
+            }
+            if (swcHelpersImportFiles.size === 0) return;
+            if (isSwcHelpersInstalled(cwd)) return;
+            hasWarned = true;
+            const exampleFiles = Array.from(swcHelpersImportFiles).slice(0, 3).join(', ');
+            const declaredHint = hasSwcHelpersDeclared(pkg) ? '' : ' (and add it to your dependencies)';
+            logger.warn([
+                `Your build output imports "@swc/helpers" due to transform, but it isn't installed in this project.`,
+                `Install it as a runtime dependency${declaredHint} (e.g. "pnpm add @swc/helpers").`,
+                exampleFiles ? `Detected in: ${exampleFiles}` : ''
+            ].filter(Boolean).join('\n'));
+        }
+    };
+}
+
 const swcMinifyOptions = {
     compress: {
         directives: false
@@ -1468,7 +1644,7 @@ const swcMinifyOptions = {
         toplevel: true
     }
 };
-async function createDtsPlugin(tsCompilerOptions, tsConfigPath, respectExternal, cwd) {
+async function createDtsPlugin(tsCompilerOptions, tsConfigPath, respectExternal, cwd, useTsGo) {
     const enableIncrementalWithoutBuildInfo = (tsCompilerOptions == null ? void 0 : tsCompilerOptions.incremental) && !(tsCompilerOptions == null ? void 0 : tsCompilerOptions.tsBuildInfoFile);
     const incrementalOptions = enableIncrementalWithoutBuildInfo ? {
         incremental: false
@@ -1495,7 +1671,33 @@ async function createDtsPlugin(tsCompilerOptions, tsConfigPath, respectExternal,
         ...incrementalOptions,
         // error TS6379: Composite projects may not disable incremental compilation.
         ...compositeOptions
-    });
+    }, useTsGo);
+    // If useTsGo is enabled, we need to make ts-go available to rollup-plugin-dts
+    // rollup-plugin-dts uses require('typescript') internally, so we need to
+    // temporarily override the module cache to use ts-go
+    if (useTsGo) {
+        const tsgo = resolveTsGo(cwd);
+        if (tsgo) {
+            try {
+                // First, try to resolve typescript to get its path
+                const tsPath = require.resolve('typescript', {
+                    paths: [
+                        cwd
+                    ]
+                });
+                // Make ts-go available as 'typescript' for rollup-plugin-dts
+                // This overrides the module cache so rollup-plugin-dts will use ts-go
+                require.cache[tsPath] = {
+                    id: tsPath,
+                    exports: tsgo,
+                    loaded: true
+                };
+            } catch (e) {
+            // If typescript cannot be resolved, we can't override it
+            // rollup-plugin-dts will try to require it and may fail
+            }
+        }
+    }
     const dtsPlugin = require('rollup-plugin-dts').default({
         tsconfig: tsConfigPath,
         compilerOptions: overrideResolvedTsOptions,
@@ -1589,8 +1791,8 @@ async function buildInputConfig(entry, bundleConfig, exportCondition, buildConte
         // Each process should be unique
         // Each package build should be unique
         // Composing above factors into a unique cache key to retrieve the memoized dts plugin with tsconfigs
-        const uniqueProcessId = 'dts-plugin:' + process.pid + tsConfigPath;
-        const dtsPlugin = await memoizeDtsPluginByKey(uniqueProcessId)(tsCompilerOptions, tsConfigPath, bundleConfig.dts && bundleConfig.dts.respectExternal, cwd);
+        const uniqueProcessId = 'dts-plugin:' + process.pid + tsConfigPath + (buildContext.useTsGo ? ':tsgo' : '');
+        const dtsPlugin = await memoizeDtsPluginByKey(uniqueProcessId)(tsCompilerOptions, tsConfigPath, bundleConfig.dts && bundleConfig.dts.respectExternal, cwd, buildContext.useTsGo);
         typesPlugins.push(dtsPlugin);
     }
     const plugins = (dts ? typesPlugins : [
@@ -1603,6 +1805,7 @@ async function buildInputConfig(entry, bundleConfig, exportCondition, buildConte
         rawContent({
             exclude: /node_modules/
         }),
+        nativeAddon(),
         isBinEntry && prependShebang(entry),
         replace__default.default({
             values: inlineDefinedValues,
@@ -1627,6 +1830,11 @@ async function buildInputConfig(entry, bundleConfig, exportCondition, buildConte
             // For relative paths, the module will be bundled;
             // For external libraries, the module will not be bundled.
             transformMixedEsModules: true
+        }),
+        // If SWC emits @swc/helpers imports, warn when it's not installed.
+        swcHelpersWarningPlugin({
+            cwd,
+            pkg
         })
     ]).filter(isNotNull);
     return {
@@ -1668,6 +1876,62 @@ function getModuleLayer(moduleMeta) {
     const moduleLayer = directives[0];
     return moduleLayer ? hashTo3Char(moduleLayer) : undefined;
 }
+/**
+ * Get the effective layer of a module by walking up the importer chain.
+ * A module inherits the layer of its importer if it doesn't have its own layer.
+ */ function getEffectiveModuleLayer(id, getModuleInfo, visited = new Set()) {
+    if (visited.has(id)) {
+        return undefined;
+    }
+    visited.add(id);
+    const moduleInfo = getModuleInfo(id);
+    if (!moduleInfo) {
+        return undefined;
+    }
+    // If this module has its own layer, return it
+    const ownLayer = getModuleLayer(moduleInfo.meta);
+    if (ownLayer) {
+        return ownLayer;
+    }
+    // Otherwise, inherit layer from importers
+    for (const importerId of moduleInfo.importers){
+        const importerLayer = getEffectiveModuleLayer(importerId, getModuleInfo, visited);
+        if (importerLayer) {
+            return importerLayer;
+        }
+    }
+    return undefined;
+}
+/**
+ * Check if a module is imported by modules with different boundary layers.
+ * Returns the set of unique layers if there are multiple, otherwise undefined.
+ */ function getImporterLayers(id, getModuleInfo) {
+    const moduleInfo = getModuleInfo(id);
+    if (!moduleInfo) {
+        return new Set();
+    }
+    const layers = new Set();
+    for (const importerId of moduleInfo.importers){
+        const importerInfo = getModuleInfo(importerId);
+        if (!importerInfo) {
+            continue;
+        }
+        // Get the importer's own layer first
+        const importerOwnLayer = getModuleLayer(importerInfo.meta);
+        if (importerOwnLayer) {
+            layers.add(importerOwnLayer);
+        } else {
+            // If the importer doesn't have a layer, get its effective layer
+            const effectiveLayer = getEffectiveModuleLayer(importerId, getModuleInfo, new Set([
+                id
+            ]));
+            if (effectiveLayer) {
+                layers.add(effectiveLayer);
+            }
+        }
+    }
+    return layers;
+}
 // dependencyGraphMap: Map<subModuleId, Set<entryParentId>>
 function createSplitChunks(dependencyGraphMap, entryFiles) {
     // If there's existing chunk being splitted, and contains a layer { <id>: <chunkGroup> }
@@ -1704,6 +1968,24 @@ function createSplitChunks(dependencyGraphMap, entryFiles) {
                 }
             }
         }
+        // Check if this module (without its own directive) is imported by multiple boundaries.
+        // If so, split it into a separate shared chunk to prevent boundary crossing issues.
+        if (!moduleLayer && !isEntry) {
+            const importerLayers = getImporterLayers(id, ctx.getModuleInfo);
+            // If this module is imported by modules with different layers (e.g., both client and server),
+            // split it into a separate chunk that can be safely imported by both boundaries.
+            if (importerLayers.size > 1) {
+                if (splitChunksGroupMap.has(id)) {
+                    return splitChunksGroupMap.get(id);
+                }
+                const chunkName = path__default.default.basename(id, path__default.default.extname(id));
+                // Create a unique suffix based on all the layers that import this module
+                const layersSuffix = Array.from(importerLayers).sort().join('-');
+                const chunkGroup = `${chunkName}-${hashTo3Char(layersSuffix)}`;
+                splitChunksGroupMap.set(id, chunkGroup);
+                return chunkGroup;
+            }
+        }
         // If current module has a layer, and it's not an entry
         if (moduleLayer && !isEntry) {
             // If the module is imported by the entry:
@@ -1987,8 +2269,17 @@ async function bundle(cliEntryPath, { cwd: _cwd, onSuccess, ...options } = {}) {
     // Original input file path, client path might change later
     const inputFile = cliEntryPath;
     const isFromCli = Boolean(cliEntryPath);
+    const useTsGo = options.tsgo === true;
+    // Check if ts-go is available when requested (before resolving tsconfig)
+    let tsgoInstance = null;
+    if (useTsGo) {
+        tsgoInstance = resolveTsGo(cwd);
+        if (!tsgoInstance) {
+            exit('--tsgo flag was specified but @typescript/native-preview is not installed. Please install it as a dev dependency: pnpm add -D @typescript/native-preview');
+        }
+    }
     const tsConfigPath = resolveTsConfigPath(cwd, options.tsconfig);
-    let tsConfig = resolveTsConfig(cwd, tsConfigPath);
+    let tsConfig = resolveTsConfig(cwd, tsConfigPath, useTsGo);
     let hasTsConfig = Boolean(tsConfig == null ? void 0 : tsConfig.tsConfigPath);
     const defaultTsOptions = {
         tsConfigPath: tsConfig == null ? void 0 : tsConfig.tsConfigPath,
@@ -2058,7 +2349,7 @@ async function bundle(cliEntryPath, { cwd: _cwd, onSuccess, ...options } = {}) {
         // Otherwise, use the existing one.
         const defaultTsConfigPath = path.resolve(cwd, 'tsconfig.json');
         if (!fileExists(defaultTsConfigPath)) {
-            await writeDefaultTsconfig(defaultTsConfigPath);
+            await writeDefaultTsconfig(defaultTsConfigPath, useTsGo);
         }
         defaultTsOptions.tsConfigPath = defaultTsConfigPath;
         hasTsConfig = true;
@@ -2070,12 +2361,15 @@ async function bundle(cliEntryPath, { cwd: _cwd, onSuccess, ...options } = {}) {
     const outputState = createOutputState({
         entries
     });
+    // Use ts-go if it was successfully resolved earlier
+    const useTsGoInContext = Boolean(useTsGo && hasTsConfig && tsgoInstance);
     const buildContext = {
         entries,
         pkg,
         cwd,
         tsOptions: defaultTsOptions,
         useTypeScript: hasTsConfig,
+        useTsGo: useTsGoInContext,
         browserslistConfig,
         pluginContext: {
             outputState,

package/package.json

@@ -1,10 +1,29 @@
 {
   "name": "bunchee",
-  "version": "6.6.2",
+  "version": "6.8.0",
   "description": "zero config bundler for js/ts/jsx libraries",
   "bin": "./dist/bin/cli.js",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "scripts": {
+    "test": "vitest run",
+    "test:update": "TEST_UPDATE_SNAPSHOT=1 pnpm test",
+    "test:post": "cross-env POST_BUILD=1 pnpm test test/compile.test.ts test/integration.test.ts",
+    "site": "next dev docs",
+    "docs:build": "next build docs",
+    "clean": "rm -rf ./dist",
+    "new-test": "node ./scripts/new-test.js",
+    "typecheck": "tsc --noEmit && tsc -p test/tsconfig.json --noEmit",
+    "prepare-release": "pnpm clean && pnpm build",
+    "publish-local": "pnpm prepare-release && pnpm test && pnpm publish",
+    "prepublishOnly": "pnpm prepare-release && chmod +x ./dist/bin/cli.js",
+    "run-ts": "cross-env SWC_NODE_IGNORE_DYNAMIC=1 node -r @swc-node/register",
+    "ts-bunchee": "pnpm run-ts ./src/bin/index.ts",
+    "build-dir": "pnpm ts-bunchee --cwd",
+    "build": "pnpm run-ts ./src/bin/index.ts --runtime node",
+    "format": "prettier --write .",
+    "prepare": "husky"
+  },
   "type": "commonjs",
   "keywords": [
     "bundler",
@@ -37,7 +56,7 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@rollup/plugin-commonjs": "^28.0.6",
+    "@rollup/plugin-commonjs": "^29.0.0",
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^16.0.1",
     "@rollup/plugin-replace": "^6.0.2",
@@ -51,7 +70,7 @@
     "picomatch": "^4.0.2",
     "pretty-bytes": "^5.6.0",
     "rollup": "^4.52.4",
-    "rollup-plugin-dts": "^6.2.3",
+    "rollup-plugin-dts": "^6.3.0",
     "rollup-plugin-swc3": "^0.11.1",
     "rollup-preserve-directives": "^1.1.3",
     "tinyglobby": "^0.2.14",
@@ -59,7 +78,8 @@
     "yargs": "^17.7.2"
   },
   "peerDependencies": {
-    "typescript": "^4.1 || ^5.0"
+    "typescript": "^4.1 || ^5.0",
+    "@typescript/native-preview": "*"
   },
   "peerDependenciesMeta": {
     "typescript": {
@@ -67,6 +87,9 @@
     },
     "@swc/helpers": {
       "optional": true
+    },
+    "@typescript/native-preview": {
+      "optional": true
     }
   },
   "devDependencies": {
@@ -79,16 +102,17 @@
     "@types/picomatch": "^3.0.1",
     "@types/react": "^19.0.9",
     "@types/yargs": "^17.0.33",
+    "@typescript/native-preview": "*",
     "bunchee": "link:./",
     "cross-env": "^7.0.3",
     "husky": "^9.0.11",
     "lint-staged": "^15.2.2",
-    "next": "16.0.0-canary.1",
+    "next": "16.0.10",
     "picocolors": "^1.0.0",
     "postcss": "^8.5.4",
     "prettier": "3.4.2",
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0",
+    "react": "^19.2.1",
+    "react-dom": "^19.2.1",
     "tailwindcss": "^4.1.8",
     "typescript": "^5.9.2",
     "vitest": "^3.0.4"
@@ -96,21 +120,5 @@
   "lint-staged": {
     "*.{js,jsx,ts,tsx,md,json,yml,yaml}": "prettier --write"
   },
-  "scripts": {
-    "test": "vitest run",
-    "test:update": "TEST_UPDATE_SNAPSHOT=1 pnpm test",
-    "test:post": "cross-env POST_BUILD=1 pnpm test test/compile.test.ts test/integration.test.ts",
-    "docs:dev": "next dev docs",
-    "docs:build": "next build docs",
-    "clean": "rm -rf ./dist",
-    "new-test": "node ./scripts/new-test.js",
-    "typecheck": "tsc --noEmit && tsc -p test/tsconfig.json --noEmit",
-    "prepare-release": "pnpm clean && pnpm build",
-    "publish-local": "pnpm prepare-release && pnpm test && pnpm publish",
-    "run-ts": "cross-env SWC_NODE_IGNORE_DYNAMIC=1 node -r @swc-node/register",
-    "ts-bunchee": "pnpm run-ts ./src/bin/index.ts",
-    "build-dir": "pnpm ts-bunchee --cwd",
-    "build": "pnpm run-ts ./src/bin/index.ts --runtime node",
-    "format": "prettier --write ."
-  }
-}
+  "packageManager": "pnpm@9.4.0"
+}