@savvy-web/rslib-builder 0.12.2 → 0.13.0

package/README.md

@@ -10,23 +10,33 @@ resolution automatically.
 
 ## Features
 
-- **Zero-Config Entry Detection** - Auto-discovers entry points from package.json
-  exports, no manual configuration needed
-- **10-100x Faster Types** - Uses tsgo (native TypeScript compiler) with API
-  Extractor for bundled, clean public API declarations
-- **Production-Ready Transforms** - Converts `.ts` exports to `.js`, resolves
-  PNPM `catalog:` and `workspace:` references, generates files array
-- **Bundled or Bundleless** - Choose single-file bundles per entry or
-  bundleless mode that preserves your source file structure
-- **Multi-Target Builds** - Separate dev (with source maps) and npm (optimized)
-  outputs from a single configuration
-- **TSDoc Validation** - Pre-build documentation validation with automatic
-  public API discovery
+- **Zero-Config Entry Detection** - Auto-discovers
+  entry points from package.json exports
+- **10-100x Faster Types** - Uses tsgo (native
+  TypeScript compiler) with API Extractor for
+  bundled, clean public API declarations
+- **Production-Ready Transforms** - Converts `.ts`
+  exports to `.js`, resolves PNPM `catalog:` and
+  `workspace:` references, generates files array
+- **Bundled or Bundleless** - Choose single-file
+  bundles per entry or bundleless mode that
+  preserves your source file structure
+- **Multi-Target Builds** - Separate dev (with
+  source maps) and npm (optimized) outputs from a
+  single configuration
+- **Flexible Formats** - ESM, CJS, or dual format
+  output with per-entry format overrides
+- **TSDoc Validation** - Pre-build documentation
+  validation with automatic public API discovery
 
 ## Installation
 
 ```bash
-npm install --save-dev @savvy-web/rslib-builder @rslib/core @microsoft/api-extractor @typescript/native-preview
+npm install --save-dev \
+  @savvy-web/rslib-builder \
+  @rslib/core \
+  @microsoft/api-extractor \
+  @typescript/native-preview
 ```
 
 ## Quick Start

package/index.d.ts

@@ -1238,9 +1238,42 @@ export declare interface NodeLibraryBuilderOptions {
      * - `"esm"` → `"type": "module"`
      * - `"cjs"` → `"type": "commonjs"`
      *
+     * When an array is provided, the package is built in both formats.
+     * The first format in the array is the primary format (determines `type` field).
+     * Each format outputs to its own subdirectory (`dist/{target}/esm/`, `dist/{target}/cjs/`).
+     *
      * @defaultValue `"esm"`
+     *
+     * @example
+     * Dual format output:
+     * ```typescript
+     * NodeLibraryBuilder.create({
+     *   format: ['esm', 'cjs'],
+     * })
+     * ```
      */
-    format?: LibraryFormat;
+    format?: LibraryFormat | LibraryFormat[];
+    /**
+     * Per-entry format overrides.
+     * Maps export paths (matching package.json exports keys like `"./markdownlint"`)
+     * to a specific format. Entries not listed inherit the top-level `format`.
+     *
+     * @remarks
+     * When both `entryFormats` and array `format` are used, `entryFormats` takes precedence.
+     * An entry with a specific format override will only be built in that format,
+     * even if the global format is dual.
+     *
+     * @example
+     * ```typescript
+     * NodeLibraryBuilder.create({
+     *   format: 'esm',
+     *   entryFormats: {
+     *     './markdownlint': 'cjs',
+     *   },
+     * })
+     * ```
+     */
+    entryFormats?: Record<string, LibraryFormat>;
     /**
      * Additional entry points bundled with custom output names.
      * These entries bypass type generation and package.json exports
@@ -2081,6 +2114,18 @@ export declare interface PackageJsonTransformPluginOptions {
      * ```
      */
     transform?: (pkg: PackageJson) => PackageJson;
+    /**
+     * Per-entry format overrides for export conditions.
+     * Maps export paths to their format (e.g., `{ "./markdownlint": "cjs" }`).
+     * Entries not listed inherit the top-level `format`.
+     */
+    entryFormats?: Record<string, LibraryFormat>;
+    /**
+     * Whether the build uses dual format (both ESM and CJS).
+     * When true, exports get both `import` and `require` conditions
+     * with format directory prefixes.
+     */
+    dualFormat?: boolean;
 }
 
 /**
@@ -3124,7 +3169,8 @@ export declare class TsconfigResolver {
         source: string;
         /**
          * Output format for this entry.
-         * If not specified, inherits from top-level `format` option.
+         * If not specified, inherits from the primary format
+         * (first element when `format` is an array, or the single format value).
          */
         format?: LibraryFormat;
     }

package/index.js

@@ -465,28 +465,24 @@ const AutoEntryPlugin = (options)=>{
                                 tracedEntries[relPath] = `./${relPath}`;
                             }
                             log.global.info(`bundleless: traced ${Object.keys(tracedEntries).length} files from ${entrySourcePaths.length} entries`);
-                            environments.forEach(([_env, lib])=>{
-                                lib.source = {
-                                    ...lib.source,
-                                    entry: tracedEntries
-                                };
-                            });
-                        } else environments.forEach(([_env, lib])=>{
-                            lib.source = {
+                            for (const [, lib] of environments)lib.source = {
                                 ...lib.source,
-                                entry: {
-                                    ...lib.source?.entry,
-                                    ...entries
-                                }
+                                entry: tracedEntries
                             };
-                        });
+                        } else for (const [, lib] of environments)lib.source = {
+                            ...lib.source,
+                            entry: {
+                                ...lib.source?.entry,
+                                ...entries
+                            }
+                        };
                         const state = buildStateMap.get(api);
                         if (state && !state.hasLoggedEntries) {
                             state.hasLoggedEntries = true;
-                            environments.forEach(([env])=>{
+                            for (const [env] of environments){
                                 const log = createEnvLogger(env);
                                 log.entries("auto-detected entries", entries);
-                            });
+                            }
                         }
                     }
                 } catch (error) {
@@ -977,8 +973,7 @@ class TsDocConfigBuilder {
             }));
     }
     static shouldPersist(persistConfig) {
-        if (false === persistConfig) return false;
-        return true;
+        return false !== persistConfig;
     }
     static getConfigPath(persistConfig, cwd) {
         if ("string" == typeof persistConfig) return isAbsolute(persistConfig) ? persistConfig : join(cwd, persistConfig);
@@ -1156,7 +1151,8 @@ async function bundleDtsFiles(options) {
                 } catch  {}
             }
         }
-        const outputFileName = `${entryName}.d.ts`;
+        const dtsExtension = "cjs" === options.format ? ".d.cts" : ".d.ts";
+        const outputFileName = `${entryName}${dtsExtension}`;
         const tempBundledPath = join(tempOutputDir, outputFileName);
         const isMainEntry = "index" === entryName || 1 === entryPoints.size;
         const generateApiModel = apiModelEnabled;
@@ -1293,7 +1289,7 @@ async function bundleDtsFiles(options) {
     };
 }
 function stripSourceMapComment(content) {
-    return content.replace(/\/\/# sourceMappingURL=\S+\.d\.ts\.map\s*$/gm, "").trim();
+    return content.replace(/\/\/# sourceMappingURL=\S+\.d\.c?ts\.map\s*$/gm, "").trim();
 }
 function mergeApiModels(options) {
     const { perEntryModels, packageName, exportPaths } = options;
@@ -1573,6 +1569,9 @@ function runTsgo(options) {
                                 },
                                 ...void 0 !== options.apiModel && {
                                     apiModel: options.apiModel
+                                },
+                                ...options.format && {
+                                    format: options.format
                                 }
                             });
                             let apiModelPath;
@@ -1593,10 +1592,11 @@ function runTsgo(options) {
                                 await writeFile(mergedPath, JSON.stringify(mergedModel, null, 2), "utf-8");
                                 apiModelPath = mergedPath;
                             }
+                            const bundledDtsExtension = "cjs" === options.format ? ".d.cts" : ".d.ts";
                             if (options.bundle) {
                                 let emittedCount = 0;
                                 for (const [entryName, tempBundledPath] of bundledFiles){
-                                    const bundledFileName = `${entryName}.d.ts`;
+                                    const bundledFileName = `${entryName}${bundledDtsExtension}`;
                                     let content = await readFile(tempBundledPath, "utf-8");
                                     content = stripSourceMapComment(content);
                                     const source = new context.sources.OriginalSource(content, bundledFileName);
@@ -1653,7 +1653,7 @@ function runTsgo(options) {
                                 core_logger.info(`${picocolors.dim(`[${envId}]`)} Emitted resolved tsconfig: tsconfig.json (excluded from npm publish)`);
                             }
                             if (options.bundle) for (const [entryName] of bundledFiles){
-                                const bundledFileName = `${entryName}.d.ts`;
+                                const bundledFileName = `${entryName}${bundledDtsExtension}`;
                                 const mapFileName = `${bundledFileName}.map`;
                                 for (const file of dtsFiles){
                                     if (file.relativePath.endsWith(".d.ts.map")) continue;
@@ -1679,7 +1679,7 @@ function runTsgo(options) {
                 stage: "summarize"
             }, async (compiler)=>{
                 const assetsToDelete = [];
-                for(const assetName in compiler.compilation.assets)if (assetName.endsWith(".d.ts")) {
+                for(const assetName in compiler.compilation.assets)if (assetName.endsWith(".d.ts") || assetName.endsWith(".d.cts")) {
                     const asset = compiler.compilation.assets[assetName];
                     const content = asset.source().toString();
                     const strippedContent = stripSourceMapComment(content);
@@ -1687,7 +1687,7 @@ function runTsgo(options) {
                         const source = new compiler.sources.OriginalSource(strippedContent, assetName);
                         compiler.compilation.assets[assetName] = source;
                     }
-                } else if (assetName.endsWith(".d.ts.map")) assetsToDelete.push(assetName);
+                } else if (assetName.endsWith(".d.ts.map") || assetName.endsWith(".d.cts.map")) assetsToDelete.push(assetName);
                 for (const assetName of assetsToDelete)delete compiler.compilation.assets[assetName];
             });
             api.onCloseBuild(async ()=>{
@@ -2118,7 +2118,7 @@ function createTypePath(jsPath, collapseIndex = true) {
     if (jsPath.endsWith(".js")) return `${jsPath.slice(0, -3)}.d.ts`;
     return `${jsPath}.d.ts`;
 }
-function transformPackageBin(bin, _processTSExports = true) {
+function transformPackageBin(bin) {
     if ("string" == typeof bin) {
         if (bin.endsWith(".ts") || bin.endsWith(".tsx")) return "./bin/cli.js";
         return bin;
@@ -2184,7 +2184,7 @@ function applyRslibTransformations(packageJson, originalPackageJson, processTSEx
     };
     if (processedManifest.exports) processedManifest.exports = transformPackageExports(processedManifest.exports, processTSExports, void 0, entrypoints, exportToOutputMap, bundle ?? false);
     if (processedManifest.bin) {
-        const transformedBin = transformPackageBin(processedManifest.bin, processTSExports);
+        const transformedBin = transformPackageBin(processedManifest.bin);
         if (transformedBin) processedManifest.bin = transformedBin;
     }
     if (originalPackageJson.typesVersions) {
@@ -2207,15 +2207,51 @@ async function applyPnpmTransformations(packageJson, dir = process.cwd(), catalo
     const workspaceCatalog = catalog ?? createWorkspaceCatalog();
     return workspaceCatalog.resolvePackageJson(packageJson, dir);
 }
-async function buildPackageJson(packageJson, isProduction = false, processTSExports = true, entrypoints, exportToOutputMap, bundle, transform) {
+async function buildPackageJson(packageJson, isProduction = false, processTSExports = true, entrypoints, exportToOutputMap, bundle, transform, formatConditions) {
     let result;
     if (isProduction) {
         const pnpmTransformed = await applyPnpmTransformations(packageJson);
         result = applyRslibTransformations(pnpmTransformed, packageJson, processTSExports, entrypoints, exportToOutputMap, bundle);
     } else result = applyRslibTransformations(packageJson, packageJson, processTSExports, entrypoints, exportToOutputMap, bundle);
+    if (formatConditions && result.exports) result.exports = applyFormatConditions(result.exports, formatConditions);
     if (transform) result = transform(result);
     return result;
 }
+function toCjsPath(jsPath) {
+    if (jsPath.endsWith(".js")) return `${jsPath.slice(0, -3)}.cjs`;
+    return jsPath;
+}
+function toCtsTypePath(dtsPath) {
+    if (dtsPath.endsWith(".d.ts")) return `${dtsPath.slice(0, -5)}.d.cts`;
+    return dtsPath;
+}
+function addFormatDirPrefix(path, format) {
+    if (path.startsWith("./")) return `./${format}/${path.slice(2)}`;
+    return `./${format}/${path}`;
+}
+function applyFormatConditions(exports, options) {
+    if (!exports || "object" != typeof exports || Array.isArray(exports)) return exports;
+    const { format = "esm", entryFormats, dualFormat } = options;
+    const result = {};
+    for (const [key, value] of Object.entries(exports))if (value && "object" == typeof value && !Array.isArray(value)) {
+        const condObj = value;
+        if ("string" == typeof condObj.types && "string" == typeof condObj.import) {
+            const entryFormat = entryFormats?.[key] ?? format;
+            const hasExplicitOverride = void 0 !== entryFormats && key in entryFormats;
+            if (dualFormat && !hasExplicitOverride) result[key] = {
+                types: addFormatDirPrefix(condObj.types, "esm"),
+                import: addFormatDirPrefix(condObj.import, "esm"),
+                require: addFormatDirPrefix(toCjsPath(condObj.import), "cjs")
+            };
+            else if ("cjs" === entryFormat) result[key] = {
+                types: toCtsTypePath(condObj.types),
+                require: toCjsPath(condObj.import)
+            };
+            else result[key] = value;
+        } else result[key] = value;
+    } else result[key] = value;
+    return result;
+}
 const PackageJsonTransformPlugin = (options = {})=>({
         name: "package-json-processor",
         setup (api) {
@@ -2243,7 +2279,19 @@ const PackageJsonTransformPlugin = (options = {})=>({
                 const isProduction = "dev" !== envId;
                 const entrypoints = api.useExposed("entrypoints");
                 const exportToOutputMap = api.useExposed("exportToOutputMap");
-                const processedPackageJson = await buildPackageJson(packageJson.data, isProduction, options.processTSExports, entrypoints, exportToOutputMap, options.bundle, options.transform);
+                let formatConditions;
+                if (options.entryFormats || options.dualFormat) formatConditions = {
+                    ...options.format && {
+                        format: options.format
+                    },
+                    ...options.entryFormats && {
+                        entryFormats: options.entryFormats
+                    },
+                    ...options.dualFormat && {
+                        dualFormat: options.dualFormat
+                    }
+                };
+                const processedPackageJson = await buildPackageJson(packageJson.data, isProduction, options.processTSExports, entrypoints, exportToOutputMap, options.bundle, options.transform, formatConditions);
                 packageJson.data = processedPackageJson;
                 if (options.forcePrivate) packageJson.data.private = true;
                 if (options.format) packageJson.data.type = "esm" === options.format ? "module" : "commonjs";
@@ -2251,7 +2299,7 @@ const PackageJsonTransformPlugin = (options = {})=>({
                 if (useRollupTypes && packageJson.data.exports && "object" == typeof packageJson.data.exports) {
                     const exports = packageJson.data.exports;
                     delete exports["./api-extractor"];
-                    for (const [, value] of Object.entries(exports))if (value && "object" == typeof value && "types" in value) value.types = "./index.d.ts";
+                    for (const value of Object.values(exports))if (value && "object" == typeof value && "types" in value) value.types = "./index.d.ts";
                 }
                 packageJson.update();
             });
@@ -2684,6 +2732,9 @@ const VirtualEntryPlugin = (options)=>{
             },
             ...void 0 !== options.virtualEntries && {
                 virtualEntries: options.virtualEntries
+            },
+            ...void 0 !== options.entryFormats && {
+                entryFormats: options.entryFormats
             }
         };
         return merged;
@@ -2698,6 +2749,7 @@ const VirtualEntryPlugin = (options)=>{
     }
     static async createSingleTarget(target, opts) {
         const options = NodeLibraryBuilder.mergeOptions(opts);
+        const bundle = options.bundle ?? true;
         const VERSION = await packageJsonVersion();
         const plugins = [];
         const apiModelConfig = "object" == typeof options.apiModel ? options.apiModel : {};
@@ -2714,7 +2766,7 @@ const VirtualEntryPlugin = (options)=>{
             };
             plugins.push(TsDocLintPlugin({
                 ...lintOptions,
-                ...false === options.bundle && {
+                ...!bundle && {
                     perEntry: true
                 }
             }));
@@ -2723,7 +2775,7 @@ const VirtualEntryPlugin = (options)=>{
             ...null != options.exportsAsIndexes && {
                 exportsAsIndexes: options.exportsAsIndexes
             },
-            ...false === options.bundle && {
+            ...!bundle && {
                 bundleless: true
             }
         }));
@@ -2732,27 +2784,31 @@ const VirtualEntryPlugin = (options)=>{
                 target,
                 pkg
             }) : void 0;
-        const libraryFormat = options.format ?? "esm";
-        const collapseIndex = (options.bundle ?? true) || !(options.exportsAsIndexes ?? false);
-        plugins.push(PackageJsonTransformPlugin({
-            forcePrivate: "dev" === target,
-            bundle: collapseIndex,
-            target,
-            format: libraryFormat,
-            ...transformFn && {
-                transform: transformFn
-            }
-        }));
-        plugins.push(FilesArrayPlugin({
-            target,
-            ...options.transformFiles && {
-                transformFiles: options.transformFiles
-            }
-        }));
-        plugins.push(...options.plugins);
-        const outputDir = `dist/${target}`;
+        const formatOption = options.format ?? "esm";
+        const formats = Array.isArray(formatOption) ? formatOption : [
+            formatOption
+        ];
+        const primaryFormat = formats[0] ?? "esm";
+        const isDualFormat = formats.length > 1;
+        const entryFormats = options.entryFormats;
+        const hasFormatOverrides = void 0 !== entryFormats && Object.keys(entryFormats).length > 0;
+        const collapseIndex = bundle || !(options.exportsAsIndexes ?? false);
+        const baseOutputDir = `dist/${target}`;
+        const outputDir = isDualFormat ? `${baseOutputDir}/${primaryFormat}` : baseOutputDir;
+        const apiModelForTarget = "npm" === target ? options.apiModel : void 0;
+        const sourceMap = "dev" === target;
+        const externalsConfig = options.externals && options.externals.length > 0 ? {
+            externals: options.externals
+        } : {};
+        const bundlelessOutput = bundle ? {} : {
+            legalComments: "inline"
+        };
+        const sourceDefine = {
+            "process.env.__PACKAGE_VERSION__": JSON.stringify(VERSION),
+            ...options.define
+        };
         let entry = options.entry;
-        if (false === options.bundle && !entry) {
+        if (!bundle && !entry) {
             const cwd = process.cwd();
             const packageJsonPath = join(cwd, "package.json");
             const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
@@ -2768,49 +2824,65 @@ const VirtualEntryPlugin = (options)=>{
             }
             entry = tracedEntries;
         }
-        const apiModelForTarget = "npm" === target ? options.apiModel : void 0;
+        plugins.push(PackageJsonTransformPlugin({
+            forcePrivate: "dev" === target,
+            bundle: collapseIndex,
+            target,
+            format: primaryFormat,
+            ...transformFn && {
+                transform: transformFn
+            },
+            ...hasFormatOverrides && {
+                entryFormats
+            },
+            ...isDualFormat && {
+                dualFormat: true
+            }
+        }));
+        plugins.push(FilesArrayPlugin({
+            target,
+            ...options.transformFiles && {
+                transformFiles: options.transformFiles
+            }
+        }));
+        plugins.push(...options.plugins);
         plugins.push(DtsPlugin({
             ...options.tsconfigPath && {
                 tsconfigPath: options.tsconfigPath
             },
             abortOnError: true,
-            bundle: options.bundle ?? true,
+            bundle,
             ...options.dtsBundledPackages && {
                 bundledPackages: options.dtsBundledPackages
             },
             buildTarget: target,
-            format: libraryFormat,
+            format: primaryFormat,
             ...void 0 !== apiModelForTarget && {
                 apiModel: apiModelForTarget
             }
         }));
         const lib = {
-            id: target,
-            outBase: false === options.bundle ? "src" : outputDir,
+            id: isDualFormat ? `${target}-${primaryFormat}` : target,
+            outBase: bundle ? outputDir : "src",
             output: {
                 target: "node",
                 module: true,
                 cleanDistPath: true,
-                sourceMap: "dev" === target,
-                // Prevent @preserve comments from generating .LICENSE.txt files
-                ...false === options.bundle && {
-                    legalComments: "inline"
-                },
+                sourceMap,
+                ...bundlelessOutput,
                 distPath: {
                     root: outputDir
                 },
                 copy: {
                     patterns: options.copyPatterns
                 },
-                ...options.externals && options.externals.length > 0 && {
-                    externals: options.externals
-                }
+                ...externalsConfig
             },
-            format: libraryFormat,
+            format: primaryFormat,
             experiments: {
-                advancedEsm: "esm" === libraryFormat
+                advancedEsm: "esm" === primaryFormat
             },
-            bundle: options.bundle ?? true,
+            bundle,
             plugins,
             source: {
                 ...options.tsconfigPath && {
@@ -2819,10 +2891,7 @@ const VirtualEntryPlugin = (options)=>{
                 ...entry && {
                     entry
                 },
-                define: {
-                    "process.env.__PACKAGE_VERSION__": JSON.stringify(VERSION),
-                    ...options.define
-                }
+                define: sourceDefine
             }
         };
         const hasRegularEntries = void 0 !== options.entry || NodeLibraryBuilder.packageHasExports();
@@ -2830,11 +2899,129 @@ const VirtualEntryPlugin = (options)=>{
         const hasVirtualEntries = Object.keys(virtualEntries).length > 0;
         if (!hasRegularEntries && !hasVirtualEntries) throw new Error("No entry points configured. Provide package.json exports, explicit entry option, or virtualEntries.");
         const libConfigs = [];
-        if (hasRegularEntries) libConfigs.push(lib);
+        if (hasRegularEntries) {
+            libConfigs.push(lib);
+            if (isDualFormat) for (const secondaryFormat of formats.slice(1)){
+                const secondaryOutputDir = `${baseOutputDir}/${secondaryFormat}`;
+                const secondaryPlugins = [
+                    FilesArrayPlugin({
+                        target
+                    }),
+                    DtsPlugin({
+                        ...options.tsconfigPath && {
+                            tsconfigPath: options.tsconfigPath
+                        },
+                        abortOnError: true,
+                        bundle,
+                        ...options.dtsBundledPackages && {
+                            bundledPackages: options.dtsBundledPackages
+                        },
+                        buildTarget: target,
+                        format: secondaryFormat
+                    })
+                ];
+                const secondaryLib = {
+                    id: `${target}-${secondaryFormat}`,
+                    outBase: bundle ? secondaryOutputDir : "src",
+                    output: {
+                        target: "node",
+                        cleanDistPath: false,
+                        sourceMap,
+                        ...bundlelessOutput,
+                        distPath: {
+                            root: secondaryOutputDir
+                        },
+                        ...externalsConfig
+                    },
+                    format: secondaryFormat,
+                    experiments: {
+                        advancedEsm: "esm" === secondaryFormat
+                    },
+                    bundle,
+                    plugins: secondaryPlugins,
+                    source: {
+                        ...options.tsconfigPath && {
+                            tsconfigPath: options.tsconfigPath
+                        },
+                        ...entry && {
+                            entry
+                        },
+                        define: sourceDefine
+                    }
+                };
+                libConfigs.push(secondaryLib);
+            }
+            if (hasFormatOverrides && !isDualFormat) {
+                const cwd = process.cwd();
+                const packageJsonPath = join(cwd, "package.json");
+                const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+                const { entries: extractedEntries, exportPaths } = new EntryExtractor().extract(packageJson);
+                const overridesByFormat = new Map();
+                for (const [entryName, sourcePath] of Object.entries(extractedEntries)){
+                    const exportPath = exportPaths[entryName];
+                    if (exportPath && entryFormats?.[exportPath] && entryFormats[exportPath] !== primaryFormat) {
+                        const overrideFormat = entryFormats[exportPath];
+                        let formatEntries = overridesByFormat.get(overrideFormat);
+                        if (!formatEntries) {
+                            formatEntries = {};
+                            overridesByFormat.set(overrideFormat, formatEntries);
+                        }
+                        formatEntries[entryName] = sourcePath;
+                    }
+                }
+                for (const [overrideFormat, overrideEntries] of overridesByFormat){
+                    const overridePlugins = [
+                        FilesArrayPlugin({
+                            target
+                        }),
+                        DtsPlugin({
+                            ...options.tsconfigPath && {
+                                tsconfigPath: options.tsconfigPath
+                            },
+                            abortOnError: true,
+                            bundle,
+                            ...options.dtsBundledPackages && {
+                                bundledPackages: options.dtsBundledPackages
+                            },
+                            buildTarget: target,
+                            format: overrideFormat
+                        })
+                    ];
+                    const overrideLib = {
+                        id: `${target}-${overrideFormat}`,
+                        outBase: bundle ? baseOutputDir : "src",
+                        output: {
+                            target: "node",
+                            cleanDistPath: false,
+                            sourceMap,
+                            ...bundlelessOutput,
+                            distPath: {
+                                root: baseOutputDir
+                            },
+                            ...externalsConfig
+                        },
+                        format: overrideFormat,
+                        experiments: {
+                            advancedEsm: "esm" === overrideFormat
+                        },
+                        bundle,
+                        plugins: overridePlugins,
+                        source: {
+                            entry: overrideEntries,
+                            ...options.tsconfigPath && {
+                                tsconfigPath: options.tsconfigPath
+                            },
+                            define: sourceDefine
+                        }
+                    };
+                    libConfigs.push(overrideLib);
+                }
+            }
+        }
         if (hasVirtualEntries) {
             const virtualByFormat = new Map();
             for (const [outputName, config] of Object.entries(virtualEntries)){
-                const entryFormat = config.format ?? libraryFormat;
+                const entryFormat = config.format ?? primaryFormat;
                 let formatMap = virtualByFormat.get(entryFormat);
                 if (!formatMap) {
                     formatMap = new Map();
@@ -2855,11 +3042,9 @@ const VirtualEntryPlugin = (options)=>{
                         cleanDistPath: false,
                         sourceMap: false,
                         distPath: {
-                            root: outputDir
+                            root: baseOutputDir
                         },
-                        ...options.externals && options.externals.length > 0 && {
-                            externals: options.externals
-                        }
+                        ...externalsConfig
                     },
                     source: {
                         entry: entryMap

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@savvy-web/rslib-builder",
-	"version": "0.12.2",
+	"version": "0.13.0",
 	"private": false,
 	"description": "RSlib-based build system for Node.js libraries with automatic package.json transformation, TypeScript declaration bundling, and multi-target support",
 	"keywords": [
@@ -63,8 +63,8 @@
 	"peerDependencies": {
 		"@microsoft/api-extractor": "^7.56.3",
 		"@rslib/core": "^0.19.5",
-		"@types/node": "^25.2.2",
-		"@typescript/native-preview": "^7.0.0-dev.20260209.1",
+		"@types/node": "^25.2.3",
+		"@typescript/native-preview": "7.0.0-dev.20260210.1",
 		"typescript": "^5.9.3"
 	},
 	"peerDependenciesMeta": {