bunchee 4.4.8 → 5.0.0-beta.2

package/dist/index.js

@@ -105,13 +105,19 @@ const nodeResolveExtensions = [
     '.node',
     '.jsx'
 ];
-const suffixedExportConventions = new Set([
+const runtimeExportConventions = new Set([
     'react-server',
     'react-native',
-    'edge-light',
+    'edge-light'
+]);
+const optimizeConventions = new Set([
     'development',
     'production'
 ]);
+const specialExportConventions = new Set([
+    ...runtimeExportConventions,
+    ...optimizeConventions
+]);
 const availableESExtensionsRegex = /\.(m|c)?[jt]sx?$/;
 const SRC = 'src';
 const dtsExtensionsMap = {
@@ -139,6 +145,7 @@ const DEFAULT_TS_CONFIG = {
         moduleResolution: 'bundler'
     }
 };
+const BINARY_TAG = '$binary';
 
 const defaultColorFn = (text)=>text;
 function color(prefixColor) {
@@ -219,10 +226,15 @@ async function getSourcePathFromExportPath(cwd, exportPath, exportType) {
         if (exportPath === '.') exportPath = './index';
         // Find convention-based source file for specific export types
         // $binary represents `pkg.bin`
-        if (suffixedExportConventions.has(exportType) && exportType !== '$binary') {
+        if (runtimeExportConventions.has(exportType) && exportType !== BINARY_TAG) {
             const filename = await findSourceEntryFile(cwd, exportPath, exportType, ext);
             if (filename) return filename;
         }
+        const [, optimizeType] = exportType.split('.');
+        if (optimizeConventions.has(optimizeType)) {
+            const filename = await findSourceEntryFile(cwd, exportPath, optimizeType, ext);
+            if (filename) return filename;
+        }
         const filename = await findSourceEntryFile(cwd, exportPath, null, ext);
         if (filename) return filename;
     }
@@ -239,11 +251,16 @@ function filePathWithoutExtension(filePath) {
     }
     return filePath;
 }
-const nonNullable = (n)=>Boolean(n);
 const hasAvailableExtension = (filename)=>availableExtensions.has(path__default.default.extname(filename).slice(1));
 const hasCjsExtension = (filename)=>path__default.default.extname(filename) === '.cjs';
+const getMainFieldExportType = (pkg)=>{
+    const isEsmPkg = isESModulePackage(pkg.type);
+    const mainExportType = isEsmPkg && pkg.main ? hasCjsExtension(pkg.main) ? 'require' : 'import' : 'require';
+    return mainExportType;
+};
 // TODO: add unit test
 const baseNameWithoutExtension = (filename)=>path__default.default.basename(filename, path__default.default.extname(filename));
+const isTestFile = (filename)=>/\.(test|spec)$/.test(baseNameWithoutExtension(filename));
 const memoize = (fn, resolver)=>{
     const cache = new Map();
     return (...args)=>{
@@ -259,6 +276,17 @@ const memoize = (fn, resolver)=>{
         return result;
     };
 };
+function joinRelativePath(...segments) {
+    let result = path__default.default.join(...segments);
+    // If the first segment starts with '.', ensure the result does too.
+    if (segments[0] === '.' && !result.startsWith('.')) {
+        result = './' + result;
+    }
+    return result;
+}
+function isESModulePackage(packageType) {
+    return packageType === 'module';
+}
 
 let hasLoggedTsWarning = false;
 function resolveTypescriptHandler(cwd) {
@@ -569,268 +597,127 @@ function prependDirectives() {
     };
 }
 
-function getPackageTypings(pkg) {
-    return pkg.types || pkg.typings;
-}
-// Reached the end of the export path
-function isExportLike(field) {
-    if (typeof field === 'string') return true;
-    return Object.entries(field).every(// Every value is string and key is not start with '.'
-    ([key, value])=>typeof value === 'string' && !key.startsWith('.'));
-}
-function constructFullExportCondition(exportCondition, packageType) {
-    let fullExportCond;
-    if (typeof exportCondition === 'string') {
-        const exportType = getExportTypeFromFile(exportCondition, packageType);
-        fullExportCond = {
-            [exportType]: exportCondition
-        };
-    } else {
-        const exportTypes = Object.keys(exportCondition);
-        fullExportCond = {};
-        exportTypes.forEach((exportType)=>{
-            const condition = exportCondition[exportType];
-            // Filter out nullable value
-            if (condition) {
-                fullExportCond[exportType] = condition;
-            }
-        });
-    }
-    return fullExportCond;
-}
-function joinRelativePath(...segments) {
-    let result = path.join(...segments);
-    // If the first segment starts with '.', ensure the result does too.
-    if (segments[0] === '.' && !result.startsWith('.')) {
-        result = './' + result;
-    }
-    return result;
-}
-const getFirstExportPath = (fullExportCondition)=>{
-    // Handle all export cond { <require|import|default>: ... }
-    if (typeof fullExportCondition === 'object') {
-        for (const key of Object.keys(fullExportCondition)){
-            if (key.startsWith('.') || key === 'types') {
-                continue;
-            }
-            return fullExportCondition[key];
-        }
-    }
-    return fullExportCondition;
-};
-const joinExportAndCondition = (exportPath, condition)=>{
-    return (exportPath === '.' ? '' : exportPath) + '.' + condition;
-};
-function findExport(exportPath, exportCondition, paths, packageType, currentPath) {
-    // Skip `types` field, it cannot be the entry point
-    if (exportPath === 'types') return;
-    if (isExportLike(exportCondition)) {
-        const fullExportCondition = constructFullExportCondition(exportCondition, packageType);
-        if (exportPath.startsWith('.')) {
-            paths[exportPath] = {
-                ...paths[exportPath],
-                ...fullExportCondition
-            };
+function collectExportPath(exportValue, exportKey, currentPath, exportTypes, exportToDist) {
+    // End of searching, export value is file path.
+    // <export key>: <export value> (string)
+    if (typeof exportValue === 'string') {
+        const composedTypes = new Set(exportTypes);
+        composedTypes.add(exportKey.startsWith('.') ? 'default' : exportKey);
+        const exportInfo = exportToDist.get(currentPath);
+        const exportCondition = Array.from(composedTypes).join('.');
+        if (!exportInfo) {
+            const outputConditionPair = [
+                exportValue,
+                exportCondition
+            ];
+            exportToDist.set(currentPath, [
+                outputConditionPair
+            ]);
         } else {
-            const exportJsBundlePath = getFirstExportPath(fullExportCondition);
-            if (suffixedExportConventions.has(exportPath)) {
-                const specialPath = joinExportAndCondition(currentPath, exportPath);
-                paths[specialPath] = {
-                    ...paths[specialPath],
-                    ...exportCondition
-                };
-            } else {
-                // exportPath is exportType, import, require, ...
-                // merge to currentPath
-                paths[currentPath] = {
-                    ...paths[currentPath],
-                    [exportPath]: exportJsBundlePath
-                };
-            }
+            exportInfo.push([
+                exportValue,
+                exportCondition
+            ]);
         }
         return;
     }
-    Object.keys(exportCondition).forEach((subpath)=>{
-        if (subpath.startsWith('.')) {
-            // subpath is actual export path, ./a, ./b, ...
-            const nestedExportPath = joinRelativePath(currentPath, subpath);
-            const nestedExportCondition = exportCondition[subpath];
-            findExport(nestedExportPath, nestedExportCondition, paths, packageType, nestedExportPath);
-        } else {
-            // subpath is exportType, import, require, ...
-            const exportType = subpath;
-            if (typeof exportCondition[subpath] === 'object') {
-                const defaultPath = exportCondition[subpath].default;
-                if (defaultPath) {
-                    const nestedExportCondition = {
-                        [exportType]: defaultPath
-                    };
-                    findExport(exportPath, nestedExportCondition, paths, packageType, currentPath);
-                }
-                // Find special export type, such as import: { development: './dev.js', production: './prod.js' }
-                const conditionSpecialTypes = Object.keys(exportCondition[exportType]).filter((key)=>suffixedExportConventions.has(key));
-                if (conditionSpecialTypes.length > 0) {
-                    for (const conditionSpecialType of conditionSpecialTypes){
-                        const nestedExportConditionPath = {
-                            [exportType]: exportCondition[exportType][conditionSpecialType]
-                        };
-                        findExport(conditionSpecialType, nestedExportConditionPath, paths, packageType, currentPath);
-                    }
-                }
-            }
-            const defaultPath = typeof exportCondition[subpath] === 'object' ? exportCondition[subpath].default : exportCondition[subpath];
-            const nestedExportCondition = {
-                [exportType]: defaultPath
-            };
-            findExport(exportPath, nestedExportCondition, paths, packageType, currentPath);
-        }
-    });
-}
-/**
- *
- * Convert package.exports field to paths mapping
- * Example
- *
- * Input:
- * {
- *   "./sub": {
- *     "import": {
- *       "types": "./sub.js",
- *       "default": "./sub.cjs",
- *     }
- *   }
- * }
- *
- * Output:
- * {
- *   "./sub": {
- *     "import": "./sub.js",
- *     "require": "./sub.cjs",
- *     "types": "./sub.d.ts",
- *   }
- * }
- *
- */ function parseExport(exportsCondition, packageType) {
-    const paths = {};
-    const initialPath = '.';
-    if (typeof exportsCondition === 'string') {
-        paths[initialPath] = constructFullExportCondition(exportsCondition, packageType);
-    } else if (typeof exportsCondition === 'object') {
-        if (isExportLike(exportsCondition)) {
-            paths[initialPath] = constructFullExportCondition(exportsCondition, packageType);
+    const exportKeys = Object.keys(exportValue);
+    for (const exportKey of exportKeys){
+        // Clone the set to avoid modifying the parent set
+        const childExports = new Set(exportTypes);
+        // Normalize child export value to a map
+        const childExportValue = exportValue[exportKey];
+        // Visit export path: ./subpath, ./subpath2, ...
+        if (exportKey.startsWith('.')) {
+            const childPath = joinRelativePath(currentPath, exportKey);
+            collectExportPath(childExportValue, exportKey, childPath, childExports, exportToDist);
         } else {
-            Object.keys(exportsCondition).forEach((key)=>{
-                const exportCondition = exportsCondition[key];
-                findExport(key, exportCondition, paths, packageType, initialPath);
-            });
+            // Visit export type: import, require, ...
+            childExports.add(exportKey);
+            collectExportPath(childExportValue, exportKey, currentPath, childExports, exportToDist);
         }
     }
-    return paths;
 }
 /**
- * Get package exports paths
+ * parseExports - parse package.exports field and other fields like main,module to a map
  *
- * Example:
- *
- * ```json
- * {
- *  "exports": {
- *    ".": {
- *      "require": "./dist/index.cjs",
- *      "module": "./dist/index.esm.js",
- *      "default": "./dist/index.esm.js"
- *    },
- *    "./foo": {
- *      "require": "./dist/foo.cjs",
- *      "module": "./dist/foo.esm.js",
- *      "default": "./dist/foo.esm.js"
- *   }
- * }
- *
- * ```
- *
- * will be parsed to:
- *
- * ```js
- * {
- *   '.': {
- *     main: './dist/index.cjs',
- *     module: './dist/index.esm.js',
- *     export: './dist/index.esm.js'
- *   },
- *   './foo': {
- *     main: './dist/foo.cjs',
- *     module: './dist/foo.esm.js',
- *     export: './dist/foo.esm.js'
- *   }
- *
- *
- * pkg.main and pkg.module will be added to ['.'] if exists
- */ function getExportPaths(pkg, resolvedWildcardExports) {
-    var _pathsMap_;
-    let pathsMap = {};
-    const packageType = getPackageType(pkg);
-    const isEsmPackage = isESModulePackage(packageType);
-    const exportsConditions = resolvedWildcardExports != null ? resolvedWildcardExports : pkg.exports;
-    if (exportsConditions) {
-        const paths = parseExport(exportsConditions, packageType);
-        pathsMap = {
-            ...pathsMap,
-            ...paths
-        };
-    }
-    // main export '.' from main/module/typings
-    let mainExportCondition;
-    if (pkg.main) {
-        const mainExportType = isEsmPackage ? hasCjsExtension(pkg.main) ? 'require' : 'import' : 'require';
-        mainExportCondition = {
-            [mainExportType]: pkg.main
-        };
-    }
-    const defaultMainExport = constructFullExportCondition({
-        ...mainExportCondition,
-        module: pkg.module,
-        types: getPackageTypings(pkg)
-    }, packageType);
-    if (!isEsmPackage && ((_pathsMap_ = pathsMap['.']) == null ? void 0 : _pathsMap_['require'])) {
-        // pathsMap's exports.require are prioritized.
-        defaultMainExport['require'] = pathsMap['.']['require'];
-    }
-    // Merge the main export into '.' paths
-    const mainExport = {
-        ...pathsMap['.'],
-        ...defaultMainExport
-    };
-    // main export is not empty
-    if (Object.keys(mainExport).length > 0) {
-        pathsMap['.'] = {
-            ...pathsMap['.'],
-            ...mainExport
-        };
-    }
-    return pathsMap;
-}
-function getPackageType(pkg) {
-    return pkg.type || 'commonjs';
-}
-function isESModulePackage(packageType) {
-    return packageType === 'module';
-}
-function constructDefaultExportCondition(value, packageType) {
-    const isEsmPackage = isESModulePackage(packageType);
-    let exportCondition;
-    if (typeof value === 'string') {
-        const types = getPackageTypings(value);
-        exportCondition = {
-            [isEsmPackage ? 'import' : 'require']: value,
-            ...types && {
-                types
+ * map from export path to output path and export conditions
+ */ function parseExports(pkg) {
+    var _pkg_exports;
+    const exportsField = (_pkg_exports = pkg.exports) != null ? _pkg_exports : {};
+    var _pkg_bin;
+    const bins = (_pkg_bin = pkg.bin) != null ? _pkg_bin : {};
+    const exportToDist = new Map();
+    const isEsmPkg = isESModulePackage(pkg.type);
+    const defaultCondition = isEsmPkg ? 'import' : 'require';
+    let currentPath = '.';
+    if (typeof exportsField === 'string') {
+        const outputConditionPair = [
+            exportsField,
+            defaultCondition
+        ];
+        exportToDist.set(currentPath, [
+            outputConditionPair
+        ]);
+    } else {
+        // keys means unknown if they're relative path or export type
+        const exportConditionKeys = Object.keys(exportsField);
+        for (const exportKey of exportConditionKeys){
+            const exportValue = exportsField[exportKey];
+            const exportTypes = new Set();
+            const isExportPath = exportKey.startsWith('.');
+            const childPath = isExportPath ? joinRelativePath(currentPath, exportKey) : currentPath;
+            if (!isExportPath) {
+                exportTypes.add(exportKey);
             }
-        };
+            collectExportPath(exportValue, exportKey, childPath, exportTypes, exportToDist);
+        }
+    }
+    if (typeof bins === 'string') {
+        const outputConditionPair = [
+            bins,
+            defaultCondition
+        ];
+        exportToDist.set(BINARY_TAG, [
+            outputConditionPair
+        ]);
     } else {
-        exportCondition = value;
+        for (const binName of Object.keys(bins)){
+            const binDistPath = bins[binName];
+            const exportType = getExportTypeFromFile(binDistPath, pkg.type);
+            const exportPath = path.posix.join(BINARY_TAG, binName);
+            const outputConditionPair = [
+                binDistPath,
+                exportType
+            ];
+            exportToDist.set(exportPath, [
+                outputConditionPair
+            ]);
+        }
     }
-    return constructFullExportCondition(exportCondition, packageType);
+    // Handle package.json global exports fields
+    if (pkg.main || pkg.module || pkg.types) {
+        const mainExportPath = pkg.main;
+        const moduleExportPath = pkg.module;
+        const typesEntryPath = pkg.types;
+        const existingExportInfo = exportToDist.get('.');
+        exportToDist.set('.', [
+            ...existingExportInfo || [],
+            Boolean(mainExportPath) && [
+                mainExportPath,
+                getMainFieldExportType(pkg)
+            ],
+            Boolean(moduleExportPath) && [
+                moduleExportPath,
+                'import'
+            ],
+            Boolean(typesEntryPath) && [
+                typesEntryPath,
+                'types'
+            ]
+        ].filter(Boolean));
+    }
+    return exportToDist;
 }
 function isEsmExportName(name, ext) {
     return [
@@ -847,12 +734,21 @@ function isCjsExportName(pkg, exportCondition, ext) {
     const isNotEsmExportName = !isEsmExportName(exportCondition, ext);
     return !isESModule && isNotEsmExportName && (ext !== 'mjs' || isCjsCondition) || ext === 'cjs';
 }
-function getExportsDistFilesOfCondition(pkg, parsedExportCondition, cwd) {
+function getFileExportType(composedTypes) {
+    return composedTypes.split('.').pop();
+}
+function getExportsDistFilesOfCondition(pkg, parsedExportCondition, cwd, dts) {
     const dist = [];
     const exportConditionNames = Object.keys(parsedExportCondition.export);
     const uniqueFiles = new Set();
     for (const exportCondition of exportConditionNames){
-        if (exportCondition === 'types') {
+        const exportType = getFileExportType(exportCondition);
+        // Filter out non-types field when generating types jobs
+        if (dts && exportType !== 'types') {
+            continue;
+        }
+        // Filter out types field when generating asset jobs
+        if (!dts && exportType === 'types') {
             continue;
         }
         const filePath = parsedExportCondition.export[exportCondition];
@@ -866,7 +762,8 @@ function getExportsDistFilesOfCondition(pkg, parsedExportCondition, cwd) {
         uniqueFiles.add(distFile);
         dist.push({
             format,
-            file: distFile
+            file: distFile,
+            exportCondition
         });
     }
     return dist;
@@ -886,17 +783,9 @@ function getExportTypeFromFile(filename, pkgType) {
     return exportType;
 }
 
-const swcMinifyOptions = {
-    compress: true,
-    format: {
-        comments: 'some'
-    },
-    mangle: {
-        toplevel: true
-    }
-};
-// return { 'process.env.<key>': '<value>' }
-function getDefinedInlineVariables(envs, parsedExportCondition) {
+/**
+ * @return {Record<string, string>} env { 'process.env.<key>': '<value>' }
+ */ function getDefinedInlineVariables(envs, parsedExportCondition) {
     if (!envs.includes('NODE_ENV')) {
         envs.push('NODE_ENV');
     }
@@ -907,9 +796,14 @@ function getDefinedInlineVariables(envs, parsedExportCondition) {
         }
         return acc;
     }, {});
-    // handle .development, .production
-    const condName = parsedExportCondition.name.startsWith('.') ? parsedExportCondition.name.slice(1) : parsedExportCondition.name;
-    const exportConditionNames = new Set(Object.keys(parsedExportCondition.export).concat(condName));
+    const exportConditionNames = Object.keys(parsedExportCondition.export).reduce((acc, key)=>{
+        // key could be 'require' or 'import.development' etc.
+        const exportTypes = key.split('.');
+        for (const exportType of exportTypes){
+            acc.add(exportType);
+        }
+        return acc;
+    }, new Set());
     // For development and production convention, we override the NODE_ENV value
     if (exportConditionNames.has('development')) {
         envVars['process.env.NODE_ENV'] = JSON.stringify('development');
@@ -921,17 +815,245 @@ function getDefinedInlineVariables(envs, parsedExportCondition) {
     }
     return envVars;
 }
+
+// shared.ts -> ./shared
+// shared.<export condition>.ts -> ./shared
+// index.ts -> ./index
+// index.development.ts -> ./index.development
+function sourceFilenameToExportPath(filename) {
+    const baseName = baseNameWithoutExtension(filename);
+    let exportPath = baseName;
+    return relativify(exportPath);
+}
+async function collectEntriesFromParsedExports(cwd, parsedExportsInfo, sourceFile) {
+    const entries = {};
+    if (sourceFile) {
+        const defaultExport = parsedExportsInfo.get('.')[0];
+        entries['.'] = {
+            source: sourceFile,
+            name: '.',
+            export: {
+                default: defaultExport[0]
+            }
+        };
+    }
+    // Find source files
+    const { bins, exportsEntries } = await collectSourceEntries(path.join(cwd, SRC));
+    // A mapping between each export path and its related special export conditions,
+    // excluding the 'default' export condition.
+    // { '.' => Set('development') }
+    const pathSpecialConditionsMap = {};
+    for (const [exportPath] of exportsEntries){
+        const normalizedExportPath = normalizeExportPath(exportPath);
+        if (!pathSpecialConditionsMap[normalizedExportPath]) {
+            pathSpecialConditionsMap[normalizedExportPath] = new Set();
+        }
+        const exportType = getExportTypeFromExportPath(exportPath);
+        if (exportType !== 'default') {
+            pathSpecialConditionsMap[normalizedExportPath].add(exportType);
+        }
+    }
+    // Traverse source files and try to match the entries
+    // Find exports from parsed exports info
+    // entryExportPath can be: '.', './index.development', './shared.edge-light', etc.
+    for (const [entryExportPath, sourceFilesMap] of exportsEntries){
+        const normalizedExportPath = normalizeExportPath(entryExportPath);
+        const entryExportPathType = getExportTypeFromExportPath(entryExportPath);
+        const outputExports = parsedExportsInfo.get(normalizedExportPath);
+        if (!outputExports) {
+            continue;
+        }
+        for (const [outputPath, composedExportType] of outputExports){
+            const matchedExportType = getSpecialExportTypeFromExportPath(composedExportType);
+            // export type can be: default, development, react-server, etc.
+            const sourceFile = sourceFilesMap[matchedExportType] || sourceFilesMap.default;
+            if (!sourceFile) {
+                continue;
+            }
+            if (!entries[entryExportPath]) {
+                entries[entryExportPath] = {
+                    source: sourceFile,
+                    name: normalizedExportPath,
+                    export: {}
+                };
+            }
+            const exportMap = entries[entryExportPath].export;
+            if (entryExportPathType === 'default' && matchedExportType !== 'default' && pathSpecialConditionsMap[normalizedExportPath].size > 0) {
+                continue;
+            }
+            exportMap[composedExportType] = outputPath;
+        }
+    }
+    // Handling binaries
+    for (const [exportPath, sourceFile] of bins){
+        const normalizedExportPath = normalizeExportPath(exportPath);
+        const outputExports = parsedExportsInfo.get(normalizedExportPath);
+        if (!outputExports) {
+            continue;
+        }
+        for (const [outputPath, exportType] of outputExports){
+            entries[exportPath] = {
+                source: sourceFile,
+                name: exportPath,
+                export: {
+                    [exportType]: outputPath
+                }
+            };
+        }
+    }
+    return entries;
+}
+// ./index -> import|require|default
+// ./index.development -> development
+// ./index.react-server -> react-server
+function getExportTypeFromExportPath(exportPath) {
+    // Skip the first two segments: `.` and `index`
+    const exportTypes = exportPath.split('.').slice(2);
+    return getExportTypeFromExportTypes(exportTypes);
+}
+function getSpecialExportTypeFromExportPath(composedExportType) {
+    const exportTypes = composedExportType.split('.');
+    for (const exportType of exportTypes){
+        if (specialExportConventions.has(exportType)) {
+            return exportType;
+        }
+    }
+    return 'default';
+}
+function getExportTypeFromExportTypes(types) {
+    let exportType = 'default';
+    new Set(types).forEach((value)=>{
+        if (specialExportConventions.has(value)) {
+            exportType = value;
+        } else if (value === 'import' || value === 'require' || value === 'types') {
+            exportType = value;
+        }
+    });
+    return exportType;
+}
+// ./index -> .
+// ./index.development -> .
+// ./index.react-server -> .
+// ./shared -> ./shared
+// ./shared.development -> ./shared
+// $binary -> $binary
+// $binary/index -> $binary
+// $binary/foo -> $binary/foo
+function normalizeExportPath(exportPath) {
+    if (exportPath.startsWith(BINARY_TAG)) {
+        if (exportPath === `${BINARY_TAG}/index`) {
+            exportPath = BINARY_TAG;
+        }
+        return exportPath;
+    }
+    const baseName = exportPath.split('.').slice(0, 2).join('.');
+    if (baseName === './index') {
+        return '.';
+    }
+    return baseName;
+}
+async function collectSourceEntries(sourceFolderPath) {
+    const bins = new Map();
+    const exportsEntries = new Map();
+    if (!fs__default.default.existsSync(sourceFolderPath)) {
+        return {
+            bins,
+            exportsEntries
+        };
+    }
+    const entryFileDirentList = await fsp__default.default.readdir(sourceFolderPath, {
+        withFileTypes: true
+    });
+    for (const dirent of entryFileDirentList){
+        if (dirent.isDirectory()) {
+            if (dirent.name === 'bin') {
+                const binDirentList = await fsp__default.default.readdir(path__default.default.join(sourceFolderPath, dirent.name), {
+                    withFileTypes: true
+                });
+                for (const binDirent of binDirentList){
+                    if (binDirent.isFile()) {
+                        const binFileAbsolutePath = path__default.default.join(sourceFolderPath, dirent.name, binDirent.name);
+                        const binExportPath = sourceFilenameToExportPath(binDirent.name);
+                        if (fs__default.default.existsSync(binFileAbsolutePath)) {
+                            bins.set(path.posix.join(BINARY_TAG, binExportPath), binFileAbsolutePath);
+                        }
+                    }
+                }
+            } else {
+                // Search folder/index.<ext> convention entries
+                for (const extension of availableExtensions){
+                    const indexAbsoluteFile = path__default.default.join(dirent.path, dirent.name, `index.${extension}`);
+                    // Search folder/index.<special type>.<ext> convention entries
+                    for (const specialExportType of runtimeExportConventions){
+                        const indexSpecialAbsoluteFile = path__default.default.join(dirent.path, dirent.name, `index.${specialExportType}.${extension}`);
+                        if (fs__default.default.existsSync(indexSpecialAbsoluteFile)) {
+                            // Add special export path
+                            // { ./<export path>.<special cond>: { <special cond>: 'index.<special cond>.<ext>' } }
+                            const exportPath = sourceFilenameToExportPath(dirent.name);
+                            const specialExportPath = exportPath + '.' + specialExportType;
+                            const sourceFilesMap = exportsEntries.get(specialExportPath) || {};
+                            sourceFilesMap[specialExportType] = indexSpecialAbsoluteFile;
+                            exportsEntries.set(specialExportPath, sourceFilesMap);
+                        }
+                    }
+                    if (fs__default.default.existsSync(indexAbsoluteFile) && !isTestFile(indexAbsoluteFile)) {
+                        const exportPath = sourceFilenameToExportPath(dirent.name);
+                        const sourceFilesMap = exportsEntries.get(exportPath) || {};
+                        const exportType = getExportTypeFromExportPath(exportPath);
+                        sourceFilesMap[exportType] = indexAbsoluteFile;
+                        exportsEntries.set(exportPath, sourceFilesMap);
+                        break;
+                    }
+                }
+            }
+        } else if (dirent.isFile()) {
+            const isAvailableExtension = availableExtensions.has(path__default.default.extname(dirent.name).slice(1));
+            if (isAvailableExtension) {
+                const exportPath = sourceFilenameToExportPath(dirent.name);
+                const isBinFile = exportPath === './bin';
+                const fullPath = path__default.default.join(sourceFolderPath, dirent.name);
+                if (isBinFile) {
+                    bins.set(BINARY_TAG, fullPath);
+                } else {
+                    if (hasAvailableExtension(dirent.name) && !isTestFile(dirent.name)) {
+                        const sourceFilesMap = exportsEntries.get(exportPath) || {};
+                        const exportType = getExportTypeFromExportPath(exportPath);
+                        sourceFilesMap[exportType] = fullPath;
+                        exportsEntries.set(exportPath, sourceFilesMap);
+                    }
+                }
+            }
+        }
+    }
+    return {
+        bins,
+        exportsEntries
+    };
+}
+
+const swcMinifyOptions = {
+    compress: {
+        directives: false
+    },
+    format: {
+        comments: 'some'
+    },
+    mangle: {
+        toplevel: true
+    }
+};
 /**
  * return {
  *   <absolute source path>: <pkg>/<export>
  * }
- */ function getReversedAlias(entries) {
+ */ function getReversedAlias({ entries, name }) {
     const alias = {};
-    for (const [entryImportPath, exportCondition] of Object.entries(entries)){
-        const exportType = entryImportPath.split('.')[1] // e.g. index.react-server, pick react-server
-        ;
-        if (!exportType) {
-            alias[exportCondition.source] = entryImportPath;
+    for (const [entryExportPath, exportCondition] of Object.entries(entries)){
+        const normalizedExportPath = normalizeExportPath(entryExportPath);
+        // entryExportPath format: ./index, ./shared, etc.
+        const specialExportType = getSpecialExportTypeFromExportPath(entryExportPath);
+        if (specialExportType === 'default') {
+            alias[exportCondition.source] = path.posix.join(name || '', normalizedExportPath);
         }
     }
     return alias;
@@ -949,7 +1071,7 @@ async function buildInputConfig(entry, bundleConfig, exportCondition, buildConte
     for (const [exportImportPath, exportCondition] of Object.entries(entries)){
         const entryFilePath = exportCondition.source;
         if (entryFilePath !== entry) {
-            externals.push(exportImportPath);
+            externals.push(path.posix.join(pkg.name || '', normalizeExportPath(exportImportPath)));
             externals.push(entryFilePath);
         }
     }
@@ -1083,25 +1205,13 @@ async function buildInputConfig(entry, bundleConfig, exportCondition, buildConte
             if (dts && code === 'EMPTY_BUNDLE') return;
             if (disabledWarnings.has(code)) return;
             // If the circular dependency warning is from node_modules, ignore it
-            if (code === 'CIRCULAR_DEPENDENCY' && /Circular dependency: node_modules/.test(warning.message)) {
+            if (code === 'CIRCULAR_DEPENDENCY' && /Circular dependency:(\s|\S)*node_modules/.test(warning.message)) {
                 return;
             }
             warn(warning);
         }
     };
 }
-function hasEsmExport(exportPaths, tsCompilerOptions) {
-    let hasEsm = false;
-    for(const key in exportPaths){
-        const exportInfo = exportPaths[key];
-        const exportInfoEntries = Object.entries(exportInfo);
-        if (exportInfoEntries.some(([exportType, file])=>isEsmExportName(exportType, file))) {
-            hasEsm = true;
-            break;
-        }
-    }
-    return Boolean(hasEsm || (tsCompilerOptions == null ? void 0 : tsCompilerOptions.esModuleInterop));
-}
 function getModuleLater(moduleMeta) {
     const directives = (moduleMeta.preserveDirectives || {
         directives: []
@@ -1109,6 +1219,18 @@ function getModuleLater(moduleMeta) {
     const moduleLayer = directives[0];
     return moduleLayer;
 }
+function getCustomModuleLayer(moduleId) {
+    const segments = path__default.default.basename(moduleId).split('.');
+    if (segments.length >= 2) {
+        const [layerSegment, ext] = segments.slice(-2);
+        const match = layerSegment.match(/^(\w+)-runtime$/);
+        const layer = match && match[1];
+        if (availableExtensions.has(ext) && layer && layer.length > 0) {
+            return layer;
+        }
+    }
+    return undefined;
+}
 // dependencyGraphMap: Map<subModuleId, Set<entryParentId>>
 function createSplitChunks(dependencyGraphMap, entryFiles) {
     // If there's existing chunk being splitted, and contains a layer { <id>: <chunkGroup> }
@@ -1141,6 +1263,15 @@ function createSplitChunks(dependencyGraphMap, entryFiles) {
                 }
             }
         }
+        if (!isEntry) {
+            const cachedCustomModuleLayer = splitChunksGroupMap.get(id);
+            if (cachedCustomModuleLayer) return cachedCustomModuleLayer;
+            const customModuleLayer = getCustomModuleLayer(id);
+            if (customModuleLayer) {
+                splitChunksGroupMap.set(id, customModuleLayer);
+                return customModuleLayer;
+            }
+        }
         // If current module has a layer, and it's not an entry
         if (moduleLayer && !isEntry) {
             // If the module is imported by the entry:
@@ -1176,9 +1307,11 @@ function createSplitChunks(dependencyGraphMap, entryFiles) {
 }
 async function buildOutputConfigs(entry, bundleConfig, exportCondition, buildContext, dts) {
     const { format } = bundleConfig;
-    const { entries, pkg, exportPaths, cwd, tsOptions: { tsCompilerOptions }, pluginContext } = buildContext;
+    const { entries, pkg, // exportPaths,
+    cwd, tsOptions: { tsCompilerOptions }, pluginContext } = buildContext;
     // Add esm mark and interop helper if esm export is detected
-    const useEsModuleMark = hasEsmExport(exportPaths, tsCompilerOptions);
+    const useEsModuleMark = tsCompilerOptions == null ? void 0 : tsCompilerOptions.esModuleInterop // hasEsmExport(exportPaths, tsCompilerOptions)
+    ;
     const absoluteOutputFile = path.resolve(cwd, bundleConfig.file);
     const outputFileExtension = path.extname(absoluteOutputFile);
     const name = filePathWithoutExtension(absoluteOutputFile);
@@ -1223,168 +1356,81 @@ async function buildEntryConfig(bundleConfig, pluginContext, dts) {
     }
     return configs;
 }
-async function collectEntry(// export type, e.g. react-server, edge-light those special cases required suffix
-exportType, options) {
-    const { cwd, pkg, entries, entryPath, exportCondRef, entryExport: originEntryExport } = options;
-    let entryExport = originEntryExport;
-    let exportCondForType = {
-        ...exportCondRef
-    };
-    // Special cases of export type, only pass down the exportPaths for the type
-    if (suffixedExportConventions.has(exportType)) {
-        exportCondForType = {
-            [exportType]: exportCondRef[exportType]
-        };
-    } else if (exportType[0] === '.' && suffixedExportConventions.has(exportType.slice(1))) {
-        // e.g. .development, .production that has both esm and cjs export
-        exportCondForType = exportCondRef;
-        exportType = exportType.slice(1);
-        entryExport = entryExport.replace(exportType, '');
-    } else {
-        // Basic export type, pass down the exportPaths with erasing the special ones
-        for (const exportType of suffixedExportConventions){
-            delete exportCondForType[exportType];
-        }
-    }
-    let source = entryPath;
-    if (source) {
-        source = resolveSourceFile(cwd, source);
-    } else {
-        source = await getSourcePathFromExportPath(cwd, entryExport, exportType);
-    }
-    if (!source) {
-        return;
-    }
-    const exportCondition = {
-        source,
-        name: originEntryExport,
-        export: exportCondForType
-    };
-    const nameWithExportPath = pkg.name ? path__default.default.join(pkg.name, exportCondition.name) : exportCondition.name;
-    const needsDelimiter = !nameWithExportPath.endsWith('.') && exportType;
-    const entryImportPath = nameWithExportPath + (needsDelimiter ? '.' : '') + exportType;
-    entries[entryImportPath] = exportCondition;
-}
-/*
- * build configs for each entry from package exports
- *
- * return { <pkg>/<export>: { input: InputOptions, output: OutputOptions[] }
- */ async function collectEntries(pkg, entryPath, exportPaths, cwd) {
-    const entries = {};
-    const binaryExports = pkg.bin;
-    if (binaryExports) {
-        // binDistPaths: [ [ 'bin1', './dist/bin1.js'], [ 'bin2', './dist/bin2.js'] ]
-        const binPairs = typeof binaryExports === 'string' ? [
-            [
-                'bin',
-                binaryExports
-            ]
-        ] : Object.keys(binaryExports).map((key)=>[
-                path.join('bin', key),
-                binaryExports[key]
-            ]);
-        const binExportPaths = binPairs.reduce((acc, [binName, binDistPath])=>{
-            const exportType = getExportTypeFromFile(binDistPath, pkg.type);
-            acc[binName] = {
-                [exportType]: binDistPath
-            };
-            return acc;
-        }, {});
-        for (const [binName] of binPairs){
-            const source = await getSourcePathFromExportPath(cwd, binName, '$binary');
-            if (!source) {
-                logger.warn(`Cannot find source file for ${binName}`);
-                continue;
-            }
-            const binEntryPath = await resolveSourceFile(cwd, source);
-            entries[binName] = {
-                source: binEntryPath,
-                name: binName,
-                export: binExportPaths[binName]
-            };
-        }
-    }
-    const collectEntriesPromises = Object.keys(exportPaths).map(async (entryExport)=>{
-        const exportCond = exportPaths[entryExport];
-        const collectEntryOptions = {
-            cwd,
-            pkg,
-            entries,
-            entryPath,
-            exportCondRef: exportCond,
-            entryExport
-        };
-        if (entryExport.startsWith('.')) {
-            await collectEntry('', collectEntryOptions);
-            for (const exportCondType of suffixedExportConventions){
-                if (exportCond[exportCondType]) {
-                    await collectEntry(exportCondType, collectEntryOptions);
-                } else if (entryExport === '.' + exportCondType) {
-                    await collectEntry(entryExport, collectEntryOptions);
-                }
-            }
-        }
-    });
-    await Promise.all(collectEntriesPromises);
-    return entries;
-}
 async function buildConfig(bundleConfig, exportCondition, pluginContext, dts) {
     const { file } = bundleConfig;
     const { pkg, cwd } = pluginContext;
     const entry = exportCondition.source;
-    const outputExports = getExportsDistFilesOfCondition(pkg, exportCondition, cwd);
+    const outputExports = getExportsDistFilesOfCondition(pkg, exportCondition, cwd, dts);
     // If there's nothing found, give a default output
     if (outputExports.length === 0 && !pkg.bin) {
-        const defaultFormat = isESModulePackage(pkg.type) ? 'esm' : 'cjs';
+        const isEsmPkg = isESModulePackage(pkg.type);
+        const defaultFormat = isEsmPkg ? 'esm' : 'cjs';
         outputExports.push({
             format: defaultFormat,
-            file: path.join(cwd, 'dist/index.js')
+            file: path.join(cwd, 'dist/index.js'.replace('/', path__default.default.sep)),
+            exportCondition: 'default'
         });
     }
     let bundleOptions = [];
-    // multi outputs with specified format
-    // CLI output option is always prioritized
     if (file) {
-        var _outputExports_;
-        const fallbackFormat = (_outputExports_ = outputExports[0]) == null ? void 0 : _outputExports_.format;
-        bundleOptions = [
-            {
-                resolvedFile: path.resolve(cwd, file),
-                format: bundleConfig.format || fallbackFormat
-            }
-        ];
+        const absoluteFile = path.resolve(cwd, file);
+        const absoluteTypeFile = getExportFileTypePath(absoluteFile);
+        if (dts) {
+            bundleOptions = [
+                {
+                    file: absoluteTypeFile,
+                    format: 'esm',
+                    exportCondition: 'types'
+                }
+            ];
+        } else {
+            const fallbackExport = outputExports[0];
+            bundleOptions = [
+                {
+                    file: absoluteFile,
+                    format: bundleConfig.format || fallbackExport.format,
+                    exportCondition: fallbackExport.exportCondition
+                }
+            ];
+        }
     } else {
-        bundleOptions = outputExports.map((exportDist)=>{
-            return {
-                resolvedFile: path.resolve(cwd, exportDist.file),
-                format: exportDist.format
-            };
-        });
-    }
-    if (dts) {
-        // types could have duplicates, dedupe them
-        // e.g. { types, import, .. } use the same `types` condition with all conditions
-        const uniqTypes = new Set();
-        bundleOptions.forEach((bundleOption)=>{
-            if (exportCondition.export.types) {
-                uniqTypes.add(path.resolve(cwd, exportCondition.export.types));
-            }
-            const typeForExtension = getExportFileTypePath(bundleOption.resolvedFile);
-            uniqTypes.add(typeForExtension);
-        });
-        bundleOptions = Array.from(uniqTypes).map((typeFile)=>{
-            return {
-                resolvedFile: typeFile,
-                format: 'esm'
-            };
-        });
+        // CLI output option is always prioritized
+        if (dts) {
+            // types could have duplicates, dedupe them
+            // e.g. { types, import, .. } use the same `types` condition with all conditions
+            const uniqTypes = new Set();
+            outputExports.forEach((exportDist)=>{
+                uniqTypes.add(path.resolve(cwd, exportDist.file));
+            });
+            bundleOptions = Array.from(uniqTypes).map((typeFile)=>{
+                return {
+                    file: typeFile,
+                    format: 'esm',
+                    exportCondition: 'types'
+                };
+            });
+        } else {
+            bundleOptions = outputExports.map((exportDist)=>{
+                return {
+                    file: path.resolve(cwd, exportDist.file),
+                    format: exportDist.format,
+                    exportCondition: exportDist.exportCondition
+                };
+            });
+        }
     }
     const outputConfigs = bundleOptions.map(async (bundleOption)=>{
+        const targetExportCondition = {
+            ...exportCondition,
+            export: {
+                [bundleOption.exportCondition]: bundleOption.exportCondition === 'types' ? bundleOption.file : exportCondition.export[bundleOption.exportCondition]
+            }
+        };
         return await buildOutputConfigs(entry, {
             ...bundleConfig,
-            file: bundleOption.resolvedFile,
+            file: bundleOption.file,
             format: bundleOption.format
-        }, exportCondition, pluginContext, dts);
+        }, targetExportCondition, pluginContext, dts);
     });
     return Promise.all(outputConfigs);
 }
@@ -1393,17 +1439,21 @@ async function buildConfig(bundleConfig, exportCondition, pluginContext, dts) {
 const removeScope = (exportPath)=>exportPath.replace(/^@[^/]+\//, '');
 function createOutputState({ entries }) {
     const sizeStats = new Map();
+    const uniqFiles = new Set();
     function addSize({ fileName, size, sourceFileName, exportPath }) {
         if (!sizeStats.has(exportPath)) {
             sizeStats.set(exportPath, []);
         }
         const distFilesStats = sizeStats.get(exportPath);
-        if (distFilesStats) {
-            distFilesStats.push([
-                fileName,
-                sourceFileName,
-                size
-            ]);
+        if (!uniqFiles.has(fileName)) {
+            uniqFiles.add(fileName);
+            if (distFilesStats) {
+                distFilesStats.push([
+                    fileName,
+                    sourceFileName,
+                    size
+                ]);
+            }
         }
     }
     const reversedMapping = new Map();
@@ -1440,7 +1490,7 @@ function createOutputState({ entries }) {
     };
 }
 function isBin(filename) {
-    return filename === 'bin' || filename.startsWith('bin/');
+    return filename === BINARY_TAG || filename.startsWith(BINARY_TAG + '/');
 }
 function isTypeFile(filename) {
     return filename.endsWith('.d.ts') || filename.endsWith('.d.mts') || filename.endsWith('.d.cts');
@@ -1448,26 +1498,15 @@ function isTypeFile(filename) {
 function normalizeExportName(exportName) {
     const isBinary = isBin(exportName);
     let result = exportName;
-    const isSubpathExport = exportName.includes('/');
-    const isSpecialExport = exportName.includes('.');
     if (isBinary) {
-        result = (exportName.replace(/bin(\/|$)/, '') || '.') + ' (bin)';
-    } else if (isSubpathExport || isSpecialExport) {
-        const subExportName = exportName.split('/')[1] || exportName;
-        if (subExportName.includes('.') && subExportName !== '.') {
-            const [originExportName, specialCondition] = subExportName.split('.');
-            result = (isSubpathExport ? relativify(originExportName) : '.') + ' (' + specialCondition + ')';
-        } else {
-            result = isSubpathExport ? relativify(subExportName) : '.';
-        }
+        result = (exportName.replace(new RegExp(`^\\${BINARY_TAG}\\/?`), '') || '.') + ' (bin)';
     } else {
-        result = '.';
+        const normalizedExportPath = normalizeExportPath(exportName);
+        const specialConditionName = getSpecialExportTypeFromExportPath(exportName);
+        result = normalizedExportPath + (specialConditionName !== 'default' ? ` (${specialConditionName})` : '');
     }
     return result;
 }
-function getExportNameWithoutExportCondition(exportName) {
-    return exportName.includes('.') ? exportName.split('.')[0] : exportName;
-}
 function logOutputState(sizeCollector) {
     const stats = sizeCollector.getSizeStats();
     if (stats.size === 0) {
@@ -1479,7 +1518,7 @@ function logOutputState(sizeCollector) {
     const statsArray = [
         ...stats.entries()
     ].sort(([a], [b])=>{
-        const comp = getExportNameWithoutExportCondition(a).length - getExportNameWithoutExportCondition(b).length;
+        const comp = normalizeExportPath(a).length - normalizeExportPath(b).length;
         return comp === 0 ? a.localeCompare(b) : comp;
     });
     const maxLengthOfExportName = Math.max(...statsArray.map(([exportName])=>normalizeExportName(exportName).length));
@@ -1512,61 +1551,6 @@ function logOutputState(sizeCollector) {
     });
 }
 
-// TODO: support nested wildcard exportsCondition (e.g. './foo/*')
-const getWildcardExports = (exportsCondition)=>{
-    return {
-        './*': exportsCondition['./*']
-    };
-};
-const isExportable = async (dirent, pathname)=>{
-    if (dirent.isDirectory()) {
-        const innerDirents = await fsp__default.default.readdir(path__default.default.join(pathname, dirent.name), {
-            withFileTypes: true
-        });
-        return innerDirents.some(({ name })=>name.startsWith('index') && hasAvailableExtension(name));
-    }
-    return dirent.isFile() && !dirent.name.startsWith('index') && hasAvailableExtension(dirent.name);
-};
-async function getExportables(cwd, excludeKeys) {
-    const pathname = path__default.default.resolve(cwd, SRC);
-    const dirents = await fsp__default.default.readdir(pathname, {
-        withFileTypes: true
-    });
-    const exportables = await Promise.all(dirents.map(async (dirent)=>await isExportable(dirent, pathname) && !excludeKeys.includes(dirent.name) ? dirent.name : undefined));
-    return exportables.filter(nonNullable);
-}
-function mapWildcard(wildcardExports, exportables) {
-    return exportables.map((exportable)=>{
-        const isFile = exportable.includes('.');
-        const filename = isFile ? filePathWithoutExtension(exportable) : exportable;
-        return {
-            [`./${filename}`]: Object.fromEntries(Object.entries(wildcardExports['./*']).map(([key, value])=>[
-                    key,
-                    value.replace(/\*/g, isFile ? filename : `${filename}/index`)
-                ]))
-        };
-    });
-}
-async function resolveWildcardExports(exportsCondition, cwd) {
-    if (!exportsCondition || typeof exportsCondition === 'string') return undefined;
-    const hasWildcard = !!exportsCondition['./*'];
-    if (hasWildcard) {
-        logger.warn(`The wildcard export "./*" is experimental and may change or be removed at any time.\n` + 'To open an issue, please visit https://github.com/huozhi/bunchee/issues' + '.\n');
-        // './foo' -> ['foo']; './foo/bar' -> ['bar']
-        // will contain '*' also but it's not a problem
-        const excludeKeys = Object.keys(exportsCondition).map((key)=>key.split('/').pop());
-        const exportables = await getExportables(cwd, excludeKeys);
-        if (exportables.length > 0) {
-            const wildcardExports = getWildcardExports(exportsCondition);
-            const resolvedWildcardExports = mapWildcard(wildcardExports, exportables);
-            const resolvedExports = Object.assign({}, exportsCondition, ...resolvedWildcardExports);
-            delete resolvedExports['./*'];
-            return resolvedExports;
-        }
-    }
-    return undefined;
-}
-
 function assignDefault(options, name, defaultValue) {
     if (!(name in options) || options[name] == null) {
         options[name] = defaultValue;
@@ -1582,12 +1566,11 @@ async function bundle(cliEntryPath, { cwd: _cwd, ...options } = {}) {
     assignDefault(options, 'minify', false);
     assignDefault(options, 'target', 'es2015');
     const pkg = await getPackageMeta(cwd);
-    const resolvedWildcardExports = await resolveWildcardExports(pkg.exports, cwd);
-    const packageType = getPackageType(pkg);
-    const exportPaths = getExportPaths(pkg, resolvedWildcardExports);
-    const isMultiEntries = hasMultiEntryExport(exportPaths) // exportPathsLength > 1
-    ;
+    const parsedExportsInfo = parseExports(pkg);
+    const isMultiEntries = hasMultiEntryExport(parsedExportsInfo);
     const hasBin = Boolean(pkg.bin);
+    // Original input file path, client path might change later
+    const inputFile = cliEntryPath;
     const isFromCli = Boolean(cliEntryPath);
     let tsConfig = resolveTsConfig(cwd);
     let hasTsConfig = Boolean(tsConfig == null ? void 0 : tsConfig.tsConfigPath);
@@ -1602,21 +1585,27 @@ async function bundle(cliEntryPath, { cwd: _cwd, ...options } = {}) {
         cliEntryPath = cliEntryPath || await getSourcePathFromExportPath(cwd, '.', 'default') || '';
     }
     // Handle CLI input
-    if (cliEntryPath) {
-        let mainEntryPath;
-        let typesEntryPath;
+    let mainExportPath;
+    let typesEntryPath;
+    if (isFromCli) {
         // with -o option
         if (options.file) {
-            mainEntryPath = options.file;
+            mainExportPath = options.file;
         }
-        if (mainEntryPath) {
+        if (mainExportPath) {
             if (options.dts) {
-                typesEntryPath = getExportFileTypePath(mainEntryPath);
+                typesEntryPath = getExportFileTypePath(mainExportPath);
             }
-            exportPaths['.'] = constructDefaultExportCondition({
-                main: mainEntryPath,
-                types: typesEntryPath
-            }, packageType);
+            parsedExportsInfo.set('.', [
+                [
+                    mainExportPath,
+                    'default'
+                ],
+                Boolean(typesEntryPath) && [
+                    typesEntryPath,
+                    'types'
+                ]
+            ].filter(Boolean));
         }
     }
     const bundleOrWatch = async (rollupConfig)=>{
@@ -1646,7 +1635,7 @@ async function bundle(cliEntryPath, { cwd: _cwd, ...options } = {}) {
             }
         }
     }
-    const entries = await collectEntries(pkg, cliEntryPath, exportPaths, cwd);
+    const entries = await collectEntriesFromParsedExports(cwd, parsedExportsInfo, inputFile);
     const hasTypeScriptFiles = Object.values(entries).some((entry)=>isTypescriptFile(entry.source));
     if (hasTypeScriptFiles && !hasTsConfig) {
         const tsConfigPath = path.resolve(cwd, 'tsconfig.json');
@@ -1657,11 +1646,13 @@ async function bundle(cliEntryPath, { cwd: _cwd, ...options } = {}) {
     const sizeCollector = createOutputState({
         entries
     });
-    const entriesAlias = getReversedAlias(entries);
+    const entriesAlias = getReversedAlias({
+        entries,
+        name: pkg.name
+    });
     const buildContext = {
         entries,
         pkg,
-        exportPaths,
         cwd,
         tsOptions: defaultTsOptions,
         useTypeScript: hasTsConfig,
@@ -1673,7 +1664,7 @@ async function bundle(cliEntryPath, { cwd: _cwd, ...options } = {}) {
     };
     const buildConfigs = await buildEntryConfig(options, buildContext, false);
     const assetsJobs = buildConfigs.map((rollupConfig)=>bundleOrWatch(rollupConfig));
-    const typesJobs = hasTsConfig ? (await buildEntryConfig(options, buildContext, true)).map((rollupConfig)=>bundleOrWatch(rollupConfig)) : [];
+    const typesJobs = hasTsConfig && options.dts !== false ? (await buildEntryConfig(options, buildContext, true)).map((rollupConfig)=>bundleOrWatch(rollupConfig)) : [];
     const totalJobs = assetsJobs.concat(typesJobs);
     const result = await Promise.all(totalJobs);
     if (result.length === 0) {