@savvy-web/rslib-builder 0.11.0 → 0.12.1

package/README.md

@@ -16,6 +16,8 @@ resolution automatically.
   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

package/index.d.ts

@@ -62,10 +62,9 @@ import ts from 'typescript';
  * API model generation is enabled by default. To disable, set `apiModel: false`.
  * Providing an options object implicitly enables API model generation.
  *
- * API models are only generated for the main "index" entry point (the "." export).
- * Additional entry points like "./hooks" or "./utils" do not generate separate API models.
- * This prevents multiple conflicting API models and ensures a single source of truth
- * for package documentation.
+ * When a package has multiple entry points, API Extractor runs for each entry and the
+ * resulting per-entry models are merged into a single API model with multiple
+ * EntryPoint members. Canonical references are scoped per entry point.
  *
  * @public
  */
@@ -222,6 +221,18 @@ export declare interface AutoEntryPluginOptions {
      * @defaultValue false
      */
     exportsAsIndexes?: boolean;
+    /**
+     * When enabled, uses import graph analysis to discover all reachable files
+     * from entry points, and sets RSlib's source.entry to the traced file list
+     * instead of named entries.
+     *
+     * @remarks
+     * Named entries are still exposed via the `entrypoints` map for DtsPlugin
+     * and PackageJsonTransformPlugin to use.
+     *
+     * @defaultValue false
+     */
+    bundleless?: boolean;
 }
 
 /**
@@ -515,24 +526,14 @@ export declare interface ExtractedEntries {
      * Entry name to TypeScript source path mapping.
      */
     entries: Record<string, string>;
+    /**
+     * Entry name to original export key mapping.
+     * Maps entry names back to the original package.json export path
+     * (e.g., `"nested-one"` → `"./nested/one"`).
+     */
+    exportPaths: Record<string, string>;
 }
 
-/**
- * Extracts TypeScript entry points from package.json (functional interface).
- *
- * @remarks
- * This is a convenience function that creates an EntryExtractor instance
- * and extracts entries in one call. For repeated use, consider creating
- * an EntryExtractor instance directly.
- *
- * @param packageJson - The package.json object to extract entries from
- * @param options - Configuration options for entry extraction
- * @returns Object containing the extracted entries
- *
- * @public
- */
-export declare function extractEntriesFromPackageJson(packageJson: PackageJson, options?: EntryExtractorOptions): ExtractedEntries;
-
 /**
  * Plugin to manage the `files` array in package.json for npm publishing.
  *
@@ -1162,6 +1163,7 @@ export declare class NodeLibraryBuilder {
         targets: ("dev" | "npm")[];
         externals: never[];
         apiModel: true;
+        bundle: true;
     };
     /**
      * Merges user-provided options with default options.
@@ -1480,6 +1482,19 @@ export declare interface NodeLibraryBuilderOptions {
      * ```
      */
     apiModel?: ApiModelOptions | boolean;
+    /**
+     * Whether to bundle JavaScript output into single files per entry point.
+     *
+     * @remarks
+     * - `true` (default): RSlib bundles JS into single files per entry (current behavior)
+     * - `false`: RSlib runs in bundleless mode, preserving file structure for JS output.
+     *   DTS is still bundled per entry via API Extractor (hybrid mode).
+     *   When `apiModel` is enabled with multiple entries, per-entry API models are
+     *   merged into a single `api.model.json` with multiple EntryPoint members.
+     *
+     * @defaultValue true
+     */
+    bundle?: boolean;
 }
 
 /**
@@ -2901,6 +2916,16 @@ export declare class TsconfigResolver {
          * @defaultValue `true`
          */
         persistConfig?: boolean | PathLike;
+        /**
+         * Whether to run lint per entry point individually with per-entry logging.
+         *
+         * @remarks
+         * When enabled, each entry point is linted separately and results are
+         * logged per entry for better visibility in bundleless mode.
+         *
+         * @defaultValue false
+         */
+        perEntry?: boolean;
     }
 
     /**

package/index.js

@@ -6,10 +6,10 @@ import { access, copyFile, mkdir, readFile, readdir, rm, stat, unlink as promise
 import { logger as core_logger } from "@rsbuild/core";
 import picocolors from "picocolors";
 import { getCatalogs, getWorkspaceManagerAndRoot, getWorkspaceManagerRoot } from "workspace-tools";
+import typescript, { ImportsNotUsedAsValues, JsxEmit, ModuleDetectionKind, ModuleKind, ModuleResolutionKind, NewLineKind, ScriptTarget, createCompilerHost, findConfigFile, formatDiagnostic, parseJsonConfigFileContent, readConfigFile, sys } from "typescript";
 import { spawn } from "node:child_process";
 import { StandardTags, Standardization, TSDocTagSyntaxKind } from "@microsoft/tsdoc";
 import deep_equal from "deep-equal";
-import typescript, { ImportsNotUsedAsValues, JsxEmit, ModuleDetectionKind, ModuleKind, ModuleResolutionKind, NewLineKind, ScriptTarget, createCompilerHost, findConfigFile, formatDiagnostic, parseJsonConfigFileContent, readConfigFile, sys } from "typescript";
 import { createRequire } from "node:module";
 import { inspect } from "node:util";
 import sort_package_json from "sort-package-json";
@@ -86,16 +86,21 @@ class EntryExtractor {
     }
     extract(packageJson) {
         const entries = {};
-        this.extractFromExports(packageJson.exports, entries);
+        const exportPaths = {};
+        this.extractFromExports(packageJson.exports, entries, exportPaths);
         this.extractFromBin(packageJson.bin, entries);
         return {
-            entries
+            entries,
+            exportPaths
         };
     }
-    extractFromExports(exports, entries) {
+    extractFromExports(exports, entries, exportPaths) {
         if (!exports) return;
         if ("string" == typeof exports) {
-            if (this.isTypeScriptFile(exports)) entries.index = exports;
+            if (this.isTypeScriptFile(exports)) {
+                entries.index = exports;
+                exportPaths.index = ".";
+            }
             return;
         }
         if ("object" != typeof exports) return;
@@ -107,6 +112,7 @@ class EntryExtractor {
             if (!this.isTypeScriptFile(resolvedPath)) continue;
             const entryName = this.createEntryName(key);
             entries[entryName] = resolvedPath;
+            exportPaths[entryName] = key;
         }
     }
     extractFromBin(bin, entries) {
@@ -144,10 +150,6 @@ class EntryExtractor {
         return withoutPrefix.replace(/\//g, "-");
     }
 }
-function extractEntriesFromPackageJson(packageJson, options) {
-    const extractor = new EntryExtractor(options);
-    return extractor.extract(packageJson);
-}
 async function fileExistAsync(assetName) {
     const assetPath = join(process.cwd(), assetName);
     const assetExists = !!await stat(assetPath).catch(()=>false);
@@ -179,6 +181,223 @@ function getApiExtractorPath() {
     }
     throw new Error("API Extractor bundling requires @microsoft/api-extractor to be installed.\nInstall it with: pnpm add -D @microsoft/api-extractor");
 }
+class ImportGraph {
+    options;
+    sys;
+    program = null;
+    compilerOptions = null;
+    moduleResolutionCache = null;
+    constructor(options){
+        this.options = options;
+        this.sys = options.sys ?? typescript.sys;
+    }
+    traceFromEntries(entryPaths) {
+        const errors = [];
+        const visited = new Set();
+        const entries = [];
+        const initResult = this.initializeProgram();
+        if (!initResult.success) return {
+            files: [],
+            entries: [],
+            errors: [
+                initResult.error
+            ]
+        };
+        for (const entryPath of entryPaths){
+            const absolutePath = this.resolveEntryPath(entryPath);
+            if (!this.sys.fileExists(absolutePath)) {
+                errors.push({
+                    type: "entry_not_found",
+                    message: `Entry file not found: ${entryPath}`,
+                    path: absolutePath
+                });
+                continue;
+            }
+            entries.push(absolutePath);
+            this.traceImports(absolutePath, visited, errors);
+        }
+        const files = Array.from(visited).filter((file)=>this.isSourceFile(file));
+        return {
+            files: files.sort(),
+            entries,
+            errors
+        };
+    }
+    traceFromPackageExports(packageJsonPath) {
+        const absolutePath = this.resolveEntryPath(packageJsonPath);
+        let packageJson;
+        try {
+            const content = this.sys.readFile(absolutePath);
+            if (!content) return {
+                files: [],
+                entries: [],
+                errors: [
+                    {
+                        type: "package_json_not_found",
+                        message: `Failed to read package.json: File not found at ${absolutePath}`,
+                        path: absolutePath
+                    }
+                ]
+            };
+            packageJson = JSON.parse(content);
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                files: [],
+                entries: [],
+                errors: [
+                    {
+                        type: "package_json_parse_error",
+                        message: `Failed to parse package.json: ${message}`,
+                        path: absolutePath
+                    }
+                ]
+            };
+        }
+        const extractor = new EntryExtractor();
+        const { entries } = extractor.extract(packageJson);
+        const packageDir = dirname(absolutePath);
+        const entryPaths = Object.values(entries).map((p)=>external_node_path_resolve(packageDir, p));
+        return this.traceFromEntries(entryPaths);
+    }
+    initializeProgram() {
+        if (this.program) return {
+            success: true
+        };
+        const configPath = this.findTsConfig();
+        if (!configPath) return {
+            success: false,
+            error: {
+                type: "tsconfig_not_found",
+                message: `No tsconfig.json found in ${this.options.rootDir}`,
+                path: this.options.rootDir
+            }
+        };
+        const configFile = typescript.readConfigFile(configPath, (path)=>this.sys.readFile(path));
+        if (configFile.error) {
+            const message = typescript.flattenDiagnosticMessageText(configFile.error.messageText, "\n");
+            return {
+                success: false,
+                error: {
+                    type: "tsconfig_read_error",
+                    message: `Failed to read tsconfig.json: ${message}`,
+                    path: configPath
+                }
+            };
+        }
+        const parsed = typescript.parseJsonConfigFileContent(configFile.config, this.sys, dirname(configPath));
+        if (parsed.errors.length > 0) {
+            const messages = parsed.errors.map((e)=>typescript.flattenDiagnosticMessageText(e.messageText, "\n")).join("\n");
+            return {
+                success: false,
+                error: {
+                    type: "tsconfig_parse_error",
+                    message: `Failed to parse tsconfig.json: ${messages}`,
+                    path: configPath
+                }
+            };
+        }
+        this.compilerOptions = parsed.options;
+        this.moduleResolutionCache = typescript.createModuleResolutionCache(this.options.rootDir, (fileName)=>fileName.toLowerCase(), this.compilerOptions);
+        const host = typescript.createCompilerHost(this.compilerOptions, true);
+        host.getCurrentDirectory = ()=>this.options.rootDir;
+        this.program = typescript.createProgram([], this.compilerOptions, host);
+        return {
+            success: true
+        };
+    }
+    findTsConfig() {
+        if (this.options.tsconfigPath) {
+            const customPath = isAbsolute(this.options.tsconfigPath) ? this.options.tsconfigPath : external_node_path_resolve(this.options.rootDir, this.options.tsconfigPath);
+            if (this.sys.fileExists(customPath)) return customPath;
+            return null;
+        }
+        const configPath = typescript.findConfigFile(this.options.rootDir, (path)=>this.sys.fileExists(path));
+        return configPath ?? null;
+    }
+    resolveEntryPath(entryPath) {
+        if (isAbsolute(entryPath)) return normalize(entryPath);
+        return normalize(external_node_path_resolve(this.options.rootDir, entryPath));
+    }
+    traceImports(filePath, visited, errors) {
+        const normalizedPath = normalize(filePath);
+        if (visited.has(normalizedPath)) return;
+        if (this.isExternalModule(normalizedPath)) return;
+        visited.add(normalizedPath);
+        const content = this.sys.readFile(normalizedPath);
+        if (!content) return void errors.push({
+            type: "file_read_error",
+            message: `Failed to read file: ${normalizedPath}`,
+            path: normalizedPath
+        });
+        const sourceFile = typescript.createSourceFile(normalizedPath, content, typescript.ScriptTarget.Latest, true);
+        const imports = this.extractImports(sourceFile);
+        for (const importPath of imports){
+            const resolved = this.resolveImport(importPath, normalizedPath);
+            if (resolved) this.traceImports(resolved, visited, errors);
+        }
+    }
+    extractImports(sourceFile) {
+        const imports = [];
+        const visit = (node)=>{
+            if (typescript.isImportDeclaration(node)) {
+                const specifier = node.moduleSpecifier;
+                if (typescript.isStringLiteral(specifier)) imports.push(specifier.text);
+            } else if (typescript.isExportDeclaration(node)) {
+                const specifier = node.moduleSpecifier;
+                if (specifier && typescript.isStringLiteral(specifier)) imports.push(specifier.text);
+            } else if (typescript.isCallExpression(node)) {
+                const expression = node.expression;
+                if (expression.kind === typescript.SyntaxKind.ImportKeyword && node.arguments.length > 0) {
+                    const arg = node.arguments[0];
+                    if (arg && typescript.isStringLiteral(arg)) imports.push(arg.text);
+                }
+            }
+            typescript.forEachChild(node, visit);
+        };
+        visit(sourceFile);
+        return imports;
+    }
+    resolveImport(specifier, fromFile) {
+        if (!specifier.startsWith(".") && !specifier.startsWith("/")) {
+            if (!this.compilerOptions?.paths || !Object.keys(this.compilerOptions.paths).length) return null;
+        }
+        if (!this.compilerOptions || !this.moduleResolutionCache) return null;
+        const resolved = typescript.resolveModuleName(specifier, fromFile, this.compilerOptions, this.sys, this.moduleResolutionCache);
+        if (resolved.resolvedModule) {
+            const resolvedPath = resolved.resolvedModule.resolvedFileName;
+            if (resolved.resolvedModule.isExternalLibraryImport) return null;
+            if (resolvedPath.endsWith(".d.ts")) {
+                const sourcePath = resolvedPath.replace(/\.d\.ts$/, ".ts");
+                if (this.sys.fileExists(sourcePath)) return sourcePath;
+                return null;
+            }
+            return resolvedPath;
+        }
+        return null;
+    }
+    isExternalModule(filePath) {
+        return filePath.includes("/node_modules/") || filePath.includes("\\node_modules\\");
+    }
+    isSourceFile(filePath) {
+        if (!filePath.endsWith(".ts") && !filePath.endsWith(".tsx")) return false;
+        if (filePath.endsWith(".d.ts")) return false;
+        if (filePath.includes(".test.") || filePath.includes(".spec.")) return false;
+        if (filePath.includes("/__test__/") || filePath.includes("\\__test__\\")) return false;
+        if (filePath.includes("/__tests__/") || filePath.includes("\\__tests__\\")) return false;
+        const excludePatterns = this.options.excludePatterns ?? [];
+        for (const pattern of excludePatterns)if (filePath.includes(pattern)) return false;
+        return true;
+    }
+    static fromEntries(entryPaths, options) {
+        const graph = new ImportGraph(options);
+        return graph.traceFromEntries(entryPaths);
+    }
+    static fromPackageExports(packageJsonPath, options) {
+        const graph = new ImportGraph(options);
+        return graph.traceFromPackageExports(packageJsonPath);
+    }
+}
 const AutoEntryPlugin = (options)=>{
     const buildStateMap = new WeakMap();
     return {
@@ -208,15 +427,16 @@ const AutoEntryPlugin = (options)=>{
                 try {
                     const packageJsonContent = await readFile(assetPath, "utf-8");
                     const packageJson = JSON.parse(packageJsonContent);
-                    const { entries } = extractEntriesFromPackageJson(packageJson, options?.exportsAsIndexes != null ? {
+                    const extractorOptions = options?.exportsAsIndexes != null ? {
                         exportsAsIndexes: options.exportsAsIndexes
-                    } : void 0);
+                    } : void 0;
+                    const { entries } = new EntryExtractor(extractorOptions).extract(packageJson);
                     if (options?.exportsAsIndexes && packageJson.exports) {
                         const exports = packageJson.exports;
                         if ("object" == typeof exports && !Array.isArray(exports)) for (const pkgExportKey of Object.keys(exports)){
                             if ("./package.json" === pkgExportKey) continue;
                             const normalizedExportKey = pkgExportKey.replace(/^\.\//, "");
-                            for (const [entryName] of Object.entries(entries)){
+                            for (const entryName of Object.keys(entries)){
                                 const normalizedEntryName = entryName.replace(/\/index$/, "");
                                 if ("." === pkgExportKey && "index" === entryName || normalizedExportKey === normalizedEntryName) {
                                     const outputPath = `./${entryName}.js`;
@@ -232,7 +452,26 @@ const AutoEntryPlugin = (options)=>{
                     }
                     if (Object.keys(entries).length > 0) {
                         const environments = Object.entries(config?.environments ?? {});
-                        environments.forEach(([_env, lib])=>{
+                        if (options?.bundleless) {
+                            const cwd = process.cwd();
+                            const graph = new ImportGraph({
+                                rootDir: cwd
+                            });
+                            const entrySourcePaths = Object.values(entries);
+                            const result = graph.traceFromEntries(entrySourcePaths);
+                            const tracedEntries = {};
+                            for (const file of result.files){
+                                const relPath = relative(cwd, file);
+                                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 = {
                                 ...lib.source,
                                 entry: {
@@ -774,7 +1013,7 @@ class TsDocConfigBuilder {
         const tsdocConfig = {
             $schema: "https://developer.microsoft.com/json-schemas/tsdoc/v0/tsdoc.schema.json",
             noStandardTags: !useStandardTags,
-            reportUnsupportedHtmlElements: false
+            reportUnsupportedHtmlElements: true
         };
         if (tagDefinitions.length > 0) tsdocConfig.tagDefinitions = tagDefinitions;
         if (Object.keys(supportForTags).length > 0) tsdocConfig.supportForTags = supportForTags;
@@ -872,19 +1111,22 @@ async function collectDtsFiles(dir, baseDir = dir) {
     await walk(dir);
     return files;
 }
+function resolveTsdocMetadataFilename(apiModel) {
+    const option = "object" == typeof apiModel ? apiModel.tsdocMetadata : void 0;
+    return "object" == typeof option && option.filename ? option.filename : "tsdoc-metadata.json";
+}
 async function bundleDtsFiles(options) {
     const { cwd, tempDtsDir, tempOutputDir, tsconfigPath, bundledPackages, entryPoints, banner, footer, apiModel } = options;
     const bundledFiles = new Map();
-    let apiModelPath;
+    const apiModelPaths = new Map();
     let tsdocMetadataPath;
     const apiModelEnabled = true === apiModel || "object" == typeof apiModel;
-    const apiModelFilename = "object" == typeof apiModel && apiModel.filename ? apiModel.filename : "api.json";
     const tsdocOptions = "object" == typeof apiModel ? apiModel.tsdoc : void 0;
     const tsdocMetadataOption = "object" == typeof apiModel ? apiModel.tsdocMetadata : void 0;
     const tsdocWarnings = tsdocOptions?.warnings ?? (TsDocConfigBuilder.isCI() ? "fail" : "log");
     const forgottenExports = ("object" == typeof apiModel ? apiModel.forgottenExports : void 0) ?? (TsDocConfigBuilder.isCI() ? "error" : "include");
     const tsdocMetadataEnabled = apiModelEnabled && (void 0 === tsdocMetadataOption || true === tsdocMetadataOption || "object" == typeof tsdocMetadataOption && false !== tsdocMetadataOption.enabled);
-    const tsdocMetadataFilename = "object" == typeof tsdocMetadataOption && tsdocMetadataOption.filename ? tsdocMetadataOption.filename : "tsdoc-metadata.json";
+    const tsdocMetadataFilename = resolveTsdocMetadataFilename(apiModel);
     getApiExtractorPath();
     const lintConfig = "object" == typeof tsdocOptions?.lint ? tsdocOptions.lint : void 0;
     const persistConfig = lintConfig?.persistConfig;
@@ -916,9 +1158,10 @@ async function bundleDtsFiles(options) {
         }
         const outputFileName = `${entryName}.d.ts`;
         const tempBundledPath = join(tempOutputDir, outputFileName);
-        const generateApiModel = apiModelEnabled && "index" === entryName;
-        const tempApiModelPath = generateApiModel ? join(tempOutputDir, apiModelFilename) : void 0;
-        const generateTsdocMetadata = tsdocMetadataEnabled && "index" === entryName;
+        const isMainEntry = "index" === entryName || 1 === entryPoints.size;
+        const generateApiModel = apiModelEnabled;
+        const tempApiModelPath = generateApiModel ? join(tempOutputDir, `${entryName}.api.json`) : void 0;
+        const generateTsdocMetadata = tsdocMetadataEnabled && isMainEntry;
         const tempTsdocMetadataPath = generateTsdocMetadata ? join(tempOutputDir, tsdocMetadataFilename) : void 0;
         const prepareOptions = {
             configObject: {
@@ -948,7 +1191,7 @@ async function bundleDtsFiles(options) {
                         }
                     }
                 },
-                bundledPackages: bundledPackages
+                bundledPackages
             },
             packageJsonFullPath: join(cwd, "package.json"),
             configObjectFullPath: void 0
@@ -1028,7 +1271,7 @@ async function bundleDtsFiles(options) {
             if ("error" === forgottenExports) throw new Error(`Forgotten exports detected for entry "${entryName}":\n  ${forgottenMessages}`);
             if ("include" === forgottenExports) core_logger.warn(`Forgotten exports for entry "${entryName}":\n  ${forgottenMessages}`);
         }
-        if (generateApiModel && tempApiModelPath) apiModelPath = tempApiModelPath;
+        if (generateApiModel && tempApiModelPath) apiModelPaths.set(entryName, tempApiModelPath);
         if (generateTsdocMetadata && tempTsdocMetadataPath) tsdocMetadataPath = tempTsdocMetadataPath;
         if (banner || footer) {
             let content = await readFile(tempBundledPath, "utf-8");
@@ -1040,9 +1283,7 @@ async function bundleDtsFiles(options) {
     }
     return {
         bundledFiles,
-        ...apiModelPath && {
-            apiModelPath
-        },
+        apiModelPaths,
         ...tsdocMetadataPath && {
             tsdocMetadataPath
         },
@@ -1054,6 +1295,45 @@ async function bundleDtsFiles(options) {
 function stripSourceMapComment(content) {
     return content.replace(/\/\/# sourceMappingURL=\S+\.d\.ts\.map\s*$/gm, "").trim();
 }
+function mergeApiModels(options) {
+    const { perEntryModels, packageName, exportPaths } = options;
+    if (0 === perEntryModels.size) throw new Error("Cannot merge zero API models");
+    const firstModel = perEntryModels.values().next().value;
+    const merged = JSON.parse(JSON.stringify(firstModel));
+    const entryPointMembers = [];
+    for (const [entryName, model] of perEntryModels){
+        const entryPoints = model.members;
+        if (!entryPoints || 0 === entryPoints.length) continue;
+        const entryPoint = JSON.parse(JSON.stringify(entryPoints[0]));
+        const exportPath = exportPaths[entryName] ?? ("index" === entryName ? "." : `./${entryName}`);
+        const isMainEntry = "." === exportPath;
+        if (isMainEntry) entryPointMembers.unshift(entryPoint);
+        else {
+            const subpath = exportPath.replace(/^\.\//, "");
+            const originalPrefix = `${packageName}!`;
+            const newPrefix = `${packageName}/${subpath}!`;
+            entryPoint.canonicalReference = newPrefix;
+            entryPoint.name = subpath;
+            rewriteCanonicalReferences(entryPoint, originalPrefix, newPrefix);
+            entryPointMembers.push(entryPoint);
+        }
+    }
+    merged.members = entryPointMembers;
+    return merged;
+}
+function rewriteCanonicalReferences(node, originalPrefix, newPrefix) {
+    if (!node || "object" != typeof node) return;
+    if (Array.isArray(node)) {
+        for (const item of node)rewriteCanonicalReferences(item, originalPrefix, newPrefix);
+        return;
+    }
+    const obj = node;
+    if ("string" == typeof obj.canonicalReference && "EntryPoint" !== obj.kind) {
+        const ref = obj.canonicalReference;
+        if (ref.startsWith(originalPrefix)) obj.canonicalReference = ref.replace(originalPrefix, newPrefix);
+    }
+    if (Array.isArray(obj.members)) for (const member of obj.members)rewriteCanonicalReferences(member, originalPrefix, newPrefix);
+}
 async function ensureTempDeclarationDir(cwd, name) {
     const dir = join(cwd, ".rslib", "declarations", name);
     await rm(dir, {
@@ -1219,7 +1499,26 @@ function runTsgo(options) {
                         return !path.includes("__test__/") && !path.includes(".test.d.ts");
                     });
                     if (0 === dtsFiles.length) return void log.global.warn("No declaration files were generated");
-                    if (options.bundle) try {
+                    if (!options.bundle) {
+                        let emittedCount = 0;
+                        for (const file of dtsFiles){
+                            if (file.relativePath.endsWith(".d.ts.map")) continue;
+                            let outputPath = file.relativePath;
+                            if (outputPath.startsWith("src/")) outputPath = outputPath.slice(4);
+                            if (".d.ts" !== dtsExtension && outputPath.endsWith(".d.ts")) outputPath = outputPath.replace(/\.d\.ts$/, dtsExtension);
+                            const jsOutputPath = outputPath.replace(/\.d\.(ts|mts|cts)$/, ".js");
+                            if (!context.compilation.assets[jsOutputPath]) continue;
+                            let content = await readFile(file.path, "utf-8");
+                            content = stripSourceMapComment(content);
+                            const source = new context.sources.OriginalSource(content, outputPath);
+                            context.compilation.emitAsset(outputPath, source);
+                            emittedCount++;
+                            if (filesArray && outputPath.endsWith(".d.ts")) filesArray.add(outputPath);
+                        }
+                        core_logger.info(`${picocolors.dim(`[${envId}]`)} Emitted ${emittedCount} declaration file${1 === emittedCount ? "" : "s"} through asset pipeline`);
+                    }
+                    const apiModelEnabled = true === options.apiModel || "object" == typeof options.apiModel;
+                    if (options.bundle || apiModelEnabled) try {
                         const exposedPackageJson = api.useExposed("api-extractor-package-json");
                         let packageJson;
                         if (exposedPackageJson) {
@@ -1230,8 +1529,7 @@ function runTsgo(options) {
                             const packageJsonContent = await readFile(packageJsonPath, "utf-8");
                             packageJson = JSON.parse(packageJsonContent);
                         }
-                        const extractor = new EntryExtractor();
-                        const { entries } = extractor.extract(packageJson);
+                        const { entries, exportPaths } = new EntryExtractor().extract(packageJson);
                         const entryPoints = new Map();
                         const virtualEntryNames = api.useExposed("virtual-entry-names");
                         for (const [entryName, sourcePath] of Object.entries(entries)){
@@ -1260,7 +1558,7 @@ function runTsgo(options) {
                             await mkdir(tempBundledDir, {
                                 recursive: true
                             });
-                            const { bundledFiles, apiModelPath, tsdocMetadataPath, tsdocConfigPath } = await bundleDtsFiles({
+                            const { bundledFiles, apiModelPaths, tsdocMetadataPath, tsdocConfigPath } = await bundleDtsFiles({
                                 cwd,
                                 tempDtsDir,
                                 tempOutputDir: tempBundledDir,
@@ -1277,17 +1575,37 @@ function runTsgo(options) {
                                     apiModel: options.apiModel
                                 }
                             });
-                            let emittedCount = 0;
-                            for (const [entryName, tempBundledPath] of bundledFiles){
-                                const bundledFileName = `${entryName}.d.ts`;
-                                let content = await readFile(tempBundledPath, "utf-8");
-                                content = stripSourceMapComment(content);
-                                const source = new context.sources.OriginalSource(content, bundledFileName);
-                                context.compilation.emitAsset(bundledFileName, source);
-                                emittedCount++;
-                                if (filesArray) filesArray.add(bundledFileName);
+                            let apiModelPath;
+                            if (1 === apiModelPaths.size) apiModelPath = apiModelPaths.values().next().value;
+                            else if (apiModelPaths.size > 1 && packageJson.name) {
+                                core_logger.info(`${picocolors.dim(`[${envId}]`)} Merging API models from ${apiModelPaths.size} entries...`);
+                                const perEntryModels = new Map();
+                                for (const [entryName, modelPath] of apiModelPaths){
+                                    const content = await readFile(modelPath, "utf-8");
+                                    perEntryModels.set(entryName, JSON.parse(content));
+                                }
+                                const mergedModel = mergeApiModels({
+                                    perEntryModels,
+                                    packageName: packageJson.name,
+                                    exportPaths
+                                });
+                                const mergedPath = join(tempBundledDir, "merged.api.json");
+                                await writeFile(mergedPath, JSON.stringify(mergedModel, null, 2), "utf-8");
+                                apiModelPath = mergedPath;
+                            }
+                            if (options.bundle) {
+                                let emittedCount = 0;
+                                for (const [entryName, tempBundledPath] of bundledFiles){
+                                    const bundledFileName = `${entryName}.d.ts`;
+                                    let content = await readFile(tempBundledPath, "utf-8");
+                                    content = stripSourceMapComment(content);
+                                    const source = new context.sources.OriginalSource(content, bundledFileName);
+                                    context.compilation.emitAsset(bundledFileName, source);
+                                    emittedCount++;
+                                    if (filesArray) filesArray.add(bundledFileName);
+                                }
+                                core_logger.info(`${picocolors.dim(`[${envId}]`)} Emitted ${emittedCount} bundled declaration file${1 === emittedCount ? "" : "s"} through asset pipeline`);
                             }
-                            core_logger.info(`${picocolors.dim(`[${envId}]`)} Emitted ${emittedCount} bundled declaration file${1 === emittedCount ? "" : "s"} through asset pipeline`);
                             if (apiModelPath) {
                                 const defaultApiModelFilename = packageJson.name ? `${getUnscopedPackageName(packageJson.name)}.api.json` : "api.json";
                                 const apiModelFilename = "object" == typeof options.apiModel && options.apiModel.filename ? options.apiModel.filename : defaultApiModelFilename;
@@ -1297,10 +1615,8 @@ function runTsgo(options) {
                                 if (filesArray) filesArray.add(`!${apiModelFilename}`);
                                 core_logger.info(`${picocolors.dim(`[${envId}]`)} Emitted API model: ${apiModelFilename} (excluded from npm publish)`);
                                 const localPaths = "object" == typeof options.apiModel ? options.apiModel.localPaths : void 0;
-                                const isCI = "true" === process.env.GITHUB_ACTIONS || "true" === process.env.CI;
-                                if (localPaths && localPaths.length > 0 && !isCI) {
-                                    const tsdocMetadataOption = "object" == typeof options.apiModel ? options.apiModel.tsdocMetadata : void 0;
-                                    const localTsdocFilename = "object" == typeof tsdocMetadataOption && tsdocMetadataOption.filename ? tsdocMetadataOption.filename : "tsdoc-metadata.json";
+                                if (localPaths && localPaths.length > 0 && !TsDocConfigBuilder.isCI()) {
+                                    const localTsdocFilename = resolveTsdocMetadataFilename(options.apiModel);
                                     api.expose("dts-local-paths-data", {
                                         localPaths,
                                         apiModelFilename,
@@ -1313,8 +1629,7 @@ function runTsgo(options) {
                                 }
                             }
                             if (tsdocMetadataPath) {
-                                const tsdocMetadataOption = "object" == typeof options.apiModel ? options.apiModel.tsdocMetadata : void 0;
-                                const tsdocMetadataFilename = "object" == typeof tsdocMetadataOption && tsdocMetadataOption.filename ? tsdocMetadataOption.filename : "tsdoc-metadata.json";
+                                const tsdocMetadataFilename = resolveTsdocMetadataFilename(options.apiModel);
                                 const tsdocMetadataContent = (await readFile(tsdocMetadataPath, "utf-8")).replaceAll("\r\n", "\n");
                                 const tsdocMetadataSource = new context.sources.OriginalSource(tsdocMetadataContent, tsdocMetadataFilename);
                                 context.compilation.emitAsset(tsdocMetadataFilename, tsdocMetadataSource);
@@ -1337,7 +1652,7 @@ function runTsgo(options) {
                                 if (filesArray) filesArray.add("!tsconfig.json");
                                 core_logger.info(`${picocolors.dim(`[${envId}]`)} Emitted resolved tsconfig: tsconfig.json (excluded from npm publish)`);
                             }
-                            for (const [entryName] of bundledFiles){
+                            if (options.bundle) for (const [entryName] of bundledFiles){
                                 const bundledFileName = `${entryName}.d.ts`;
                                 const mapFileName = `${bundledFileName}.map`;
                                 for (const file of dtsFiles){
@@ -1355,22 +1670,6 @@ function runTsgo(options) {
                         log.global.error("Failed to bundle declaration files:", error);
                         if (abortOnError) throw error;
                     }
-                    else {
-                        let emittedCount = 0;
-                        for (const file of dtsFiles){
-                            if (file.relativePath.endsWith(".d.ts.map")) continue;
-                            let content = await readFile(file.path, "utf-8");
-                            let outputPath = file.relativePath;
-                            if (outputPath.startsWith("src/")) outputPath = outputPath.slice(4);
-                            if (".d.ts" !== dtsExtension && outputPath.endsWith(".d.ts")) outputPath = outputPath.replace(/\.d\.ts$/, dtsExtension);
-                            content = stripSourceMapComment(content);
-                            const source = new context.sources.OriginalSource(content, outputPath);
-                            context.compilation.emitAsset(outputPath, source);
-                            emittedCount++;
-                            if (filesArray && outputPath.endsWith(".d.ts")) filesArray.add(outputPath);
-                        }
-                        core_logger.info(`${picocolors.dim(`[${envId}]`)} Emitted ${emittedCount} declaration file${1 === emittedCount ? "" : "s"} through asset pipeline`);
-                    }
                 } catch (error) {
                     log.global.error("Failed to generate declaration files:", error);
                     if (abortOnError) throw error;
@@ -1969,223 +2268,6 @@ const PackageJsonTransformPlugin = (options = {})=>({
             });
         }
     });
-class ImportGraph {
-    options;
-    sys;
-    program = null;
-    compilerOptions = null;
-    moduleResolutionCache = null;
-    constructor(options){
-        this.options = options;
-        this.sys = options.sys ?? typescript.sys;
-    }
-    traceFromEntries(entryPaths) {
-        const errors = [];
-        const visited = new Set();
-        const entries = [];
-        const initResult = this.initializeProgram();
-        if (!initResult.success) return {
-            files: [],
-            entries: [],
-            errors: [
-                initResult.error
-            ]
-        };
-        for (const entryPath of entryPaths){
-            const absolutePath = this.resolveEntryPath(entryPath);
-            if (!this.sys.fileExists(absolutePath)) {
-                errors.push({
-                    type: "entry_not_found",
-                    message: `Entry file not found: ${entryPath}`,
-                    path: absolutePath
-                });
-                continue;
-            }
-            entries.push(absolutePath);
-            this.traceImports(absolutePath, visited, errors);
-        }
-        const files = Array.from(visited).filter((file)=>this.isSourceFile(file));
-        return {
-            files: files.sort(),
-            entries,
-            errors
-        };
-    }
-    traceFromPackageExports(packageJsonPath) {
-        const absolutePath = this.resolveEntryPath(packageJsonPath);
-        let packageJson;
-        try {
-            const content = this.sys.readFile(absolutePath);
-            if (!content) return {
-                files: [],
-                entries: [],
-                errors: [
-                    {
-                        type: "package_json_not_found",
-                        message: `Failed to read package.json: File not found at ${absolutePath}`,
-                        path: absolutePath
-                    }
-                ]
-            };
-            packageJson = JSON.parse(content);
-        } catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            return {
-                files: [],
-                entries: [],
-                errors: [
-                    {
-                        type: "package_json_parse_error",
-                        message: `Failed to parse package.json: ${message}`,
-                        path: absolutePath
-                    }
-                ]
-            };
-        }
-        const extractor = new EntryExtractor();
-        const { entries } = extractor.extract(packageJson);
-        const packageDir = dirname(absolutePath);
-        const entryPaths = Object.values(entries).map((p)=>external_node_path_resolve(packageDir, p));
-        return this.traceFromEntries(entryPaths);
-    }
-    initializeProgram() {
-        if (this.program) return {
-            success: true
-        };
-        const configPath = this.findTsConfig();
-        if (!configPath) return {
-            success: false,
-            error: {
-                type: "tsconfig_not_found",
-                message: `No tsconfig.json found in ${this.options.rootDir}`,
-                path: this.options.rootDir
-            }
-        };
-        const configFile = typescript.readConfigFile(configPath, (path)=>this.sys.readFile(path));
-        if (configFile.error) {
-            const message = typescript.flattenDiagnosticMessageText(configFile.error.messageText, "\n");
-            return {
-                success: false,
-                error: {
-                    type: "tsconfig_read_error",
-                    message: `Failed to read tsconfig.json: ${message}`,
-                    path: configPath
-                }
-            };
-        }
-        const parsed = typescript.parseJsonConfigFileContent(configFile.config, this.sys, dirname(configPath));
-        if (parsed.errors.length > 0) {
-            const messages = parsed.errors.map((e)=>typescript.flattenDiagnosticMessageText(e.messageText, "\n")).join("\n");
-            return {
-                success: false,
-                error: {
-                    type: "tsconfig_parse_error",
-                    message: `Failed to parse tsconfig.json: ${messages}`,
-                    path: configPath
-                }
-            };
-        }
-        this.compilerOptions = parsed.options;
-        this.moduleResolutionCache = typescript.createModuleResolutionCache(this.options.rootDir, (fileName)=>fileName.toLowerCase(), this.compilerOptions);
-        const host = typescript.createCompilerHost(this.compilerOptions, true);
-        host.getCurrentDirectory = ()=>this.options.rootDir;
-        this.program = typescript.createProgram([], this.compilerOptions, host);
-        return {
-            success: true
-        };
-    }
-    findTsConfig() {
-        if (this.options.tsconfigPath) {
-            const customPath = isAbsolute(this.options.tsconfigPath) ? this.options.tsconfigPath : external_node_path_resolve(this.options.rootDir, this.options.tsconfigPath);
-            if (this.sys.fileExists(customPath)) return customPath;
-            return null;
-        }
-        const configPath = typescript.findConfigFile(this.options.rootDir, (path)=>this.sys.fileExists(path));
-        return configPath ?? null;
-    }
-    resolveEntryPath(entryPath) {
-        if (isAbsolute(entryPath)) return normalize(entryPath);
-        return normalize(external_node_path_resolve(this.options.rootDir, entryPath));
-    }
-    traceImports(filePath, visited, errors) {
-        const normalizedPath = normalize(filePath);
-        if (visited.has(normalizedPath)) return;
-        if (this.isExternalModule(normalizedPath)) return;
-        visited.add(normalizedPath);
-        const content = this.sys.readFile(normalizedPath);
-        if (!content) return void errors.push({
-            type: "file_read_error",
-            message: `Failed to read file: ${normalizedPath}`,
-            path: normalizedPath
-        });
-        const sourceFile = typescript.createSourceFile(normalizedPath, content, typescript.ScriptTarget.Latest, true);
-        const imports = this.extractImports(sourceFile);
-        for (const importPath of imports){
-            const resolved = this.resolveImport(importPath, normalizedPath);
-            if (resolved) this.traceImports(resolved, visited, errors);
-        }
-    }
-    extractImports(sourceFile) {
-        const imports = [];
-        const visit = (node)=>{
-            if (typescript.isImportDeclaration(node)) {
-                const specifier = node.moduleSpecifier;
-                if (typescript.isStringLiteral(specifier)) imports.push(specifier.text);
-            } else if (typescript.isExportDeclaration(node)) {
-                const specifier = node.moduleSpecifier;
-                if (specifier && typescript.isStringLiteral(specifier)) imports.push(specifier.text);
-            } else if (typescript.isCallExpression(node)) {
-                const expression = node.expression;
-                if (expression.kind === typescript.SyntaxKind.ImportKeyword && node.arguments.length > 0) {
-                    const arg = node.arguments[0];
-                    if (arg && typescript.isStringLiteral(arg)) imports.push(arg.text);
-                }
-            }
-            typescript.forEachChild(node, visit);
-        };
-        visit(sourceFile);
-        return imports;
-    }
-    resolveImport(specifier, fromFile) {
-        if (!specifier.startsWith(".") && !specifier.startsWith("/")) {
-            if (!this.compilerOptions?.paths || !Object.keys(this.compilerOptions.paths).length) return null;
-        }
-        if (!this.compilerOptions || !this.moduleResolutionCache) return null;
-        const resolved = typescript.resolveModuleName(specifier, fromFile, this.compilerOptions, this.sys, this.moduleResolutionCache);
-        if (resolved.resolvedModule) {
-            const resolvedPath = resolved.resolvedModule.resolvedFileName;
-            if (resolved.resolvedModule.isExternalLibraryImport) return null;
-            if (resolvedPath.endsWith(".d.ts")) {
-                const sourcePath = resolvedPath.replace(/\.d\.ts$/, ".ts");
-                if (this.sys.fileExists(sourcePath)) return sourcePath;
-                return null;
-            }
-            return resolvedPath;
-        }
-        return null;
-    }
-    isExternalModule(filePath) {
-        return filePath.includes("/node_modules/") || filePath.includes("\\node_modules\\");
-    }
-    isSourceFile(filePath) {
-        if (!filePath.endsWith(".ts") && !filePath.endsWith(".tsx")) return false;
-        if (filePath.endsWith(".d.ts")) return false;
-        if (filePath.includes(".test.") || filePath.includes(".spec.")) return false;
-        if (filePath.includes("/__test__/") || filePath.includes("\\__test__\\")) return false;
-        if (filePath.includes("/__tests__/") || filePath.includes("\\__tests__\\")) return false;
-        const excludePatterns = this.options.excludePatterns ?? [];
-        for (const pattern of excludePatterns)if (filePath.includes(pattern)) return false;
-        return true;
-    }
-    static fromEntries(entryPaths, options) {
-        const graph = new ImportGraph(options);
-        return graph.traceFromEntries(entryPaths);
-    }
-    static fromPackageExports(packageJsonPath, options) {
-        const graph = new ImportGraph(options);
-        return graph.traceFromPackageExports(packageJsonPath);
-    }
-}
 function formatLintResults(results, cwd) {
     if (0 === results.messages.length) return "";
     const lines = [];
@@ -2229,6 +2311,41 @@ function discoverFilesToLint(options, cwd) {
         isGlobPattern: false
     };
 }
+function discoverFilesToLintPerEntry(cwd) {
+    const packageJsonPath = join(cwd, "package.json");
+    let packageJson;
+    try {
+        packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    } catch  {
+        return {
+            perEntry: new Map(),
+            errors: []
+        };
+    }
+    const { entries } = new EntryExtractor().extract(packageJson);
+    const graph = new ImportGraph({
+        rootDir: cwd
+    });
+    const perEntry = new Map();
+    const allErrors = [];
+    for (const [entryName, sourcePath] of Object.entries(entries)){
+        if (entryName.startsWith("bin/")) continue;
+        const resolvedPath = sourcePath.startsWith(".") ? external_node_path_resolve(cwd, sourcePath) : sourcePath;
+        const result = graph.traceFromEntries([
+            resolvedPath
+        ]);
+        perEntry.set(entryName, {
+            files: result.files,
+            errors: result.errors,
+            isGlobPattern: false
+        });
+        allErrors.push(...result.errors);
+    }
+    return {
+        perEntry,
+        errors: allErrors
+    };
+}
 async function runTsDocLint(options, cwd) {
     const tsdocOptions = options.tsdoc ?? {};
     const persistConfig = options.persistConfig;
@@ -2345,6 +2462,112 @@ async function runTsDocLint(options, cwd) {
         }
     };
 }
+async function runTsDocLintPerEntry(options, cwd) {
+    const tsdocOptions = options.tsdoc ?? {};
+    const persistConfig = options.persistConfig;
+    const shouldPersist = TsDocConfigBuilder.shouldPersist(persistConfig);
+    const tsdocConfigOutputPath = TsDocConfigBuilder.getConfigPath(persistConfig, cwd);
+    const skipCIValidation = false === persistConfig;
+    const tsdocConfigPath = await TsDocConfigBuilder.writeConfigFile(tsdocOptions, dirname(tsdocConfigOutputPath), skipCIValidation);
+    const eslintModule = await import("eslint");
+    const tsParserModule = await import("@typescript-eslint/parser");
+    const tsdocPluginModule = await import("eslint-plugin-tsdoc");
+    const { ESLint } = eslintModule;
+    const tsParser = tsParserModule.default ?? tsParserModule;
+    const tsdocPlugin = tsdocPluginModule.default ?? tsdocPluginModule;
+    const { perEntry, errors: allErrors } = discoverFilesToLintPerEntry(cwd);
+    if (0 === perEntry.size) return {
+        results: {
+            errorCount: 0,
+            warningCount: 0,
+            messages: []
+        },
+        ...shouldPersist && {
+            tsdocConfigPath
+        },
+        ...allErrors.length > 0 && {
+            discoveryErrors: allErrors
+        }
+    };
+    const eslint = new ESLint({
+        cwd,
+        overrideConfigFile: true,
+        overrideConfig: [
+            {
+                ignores: [
+                    "**/node_modules/**",
+                    "**/dist/**",
+                    "**/coverage/**"
+                ]
+            },
+            {
+                files: [
+                    "**/*.ts",
+                    "**/*.tsx"
+                ],
+                languageOptions: {
+                    parser: tsParser
+                },
+                plugins: {
+                    tsdoc: tsdocPlugin
+                },
+                rules: {
+                    "tsdoc/syntax": "error"
+                }
+            }
+        ]
+    });
+    const allMessages = [];
+    let totalErrors = 0;
+    let totalWarnings = 0;
+    for (const [entryName, discovery] of perEntry){
+        if (0 === discovery.files.length) continue;
+        const exportKey = "index" === entryName ? "." : `./${entryName}`;
+        core_logger.info(`${picocolors.dim("[tsdoc-lint]")} Validating "${exportKey}" (${discovery.files.length} file${1 === discovery.files.length ? "" : "s"})...`);
+        const eslintResults = await eslint.lintFiles(discovery.files);
+        let entryErrors = 0;
+        let entryWarnings = 0;
+        for (const result of eslintResults)for (const msg of result.messages){
+            allMessages.push({
+                filePath: result.filePath,
+                line: msg.line,
+                column: msg.column,
+                message: msg.message,
+                ruleId: msg.ruleId,
+                severity: msg.severity
+            });
+            if (2 === msg.severity) {
+                entryErrors++;
+                totalErrors++;
+            } else {
+                entryWarnings++;
+                totalWarnings++;
+            }
+        }
+        if (0 === entryErrors && 0 === entryWarnings) core_logger.info(`${picocolors.dim("[tsdoc-lint]")} ${picocolors.green(`\u2713 "${exportKey}" - All TSDoc comments valid`)}`);
+        else {
+            const errorText = 1 === entryErrors ? "error" : "errors";
+            const warningText = 1 === entryWarnings ? "warning" : "warnings";
+            const parts = [];
+            if (entryErrors > 0) parts.push(`${entryErrors} ${errorText}`);
+            if (entryWarnings > 0) parts.push(`${entryWarnings} ${warningText}`);
+            core_logger.warn(`${picocolors.dim("[tsdoc-lint]")} ${picocolors.red(`\u2717 "${exportKey}" - ${parts.join(", ")} found`)}`);
+        }
+    }
+    return {
+        results: {
+            errorCount: totalErrors,
+            warningCount: totalWarnings,
+            messages: allMessages
+        },
+        ...shouldPersist && {
+            tsdocConfigPath
+        },
+        ...allErrors.length > 0 && {
+            discoveryErrors: allErrors
+        }
+    };
+}
 async function cleanupTsDocConfig(configPath) {
     if (!configPath) return;
     try {
@@ -2365,7 +2588,7 @@ const TsDocLintPlugin = (options = {})=>{
                 const onError = options.onError ?? (isCI ? "throw" : "error");
                 core_logger.info(`${picocolors.dim("[tsdoc-lint]")} Validating TSDoc comments...`);
                 try {
-                    const { results, tsdocConfigPath, discoveryErrors } = await runTsDocLint(options, cwd);
+                    const { results, tsdocConfigPath, discoveryErrors } = options.perEntry ? await runTsDocLintPerEntry(options, cwd) : await runTsDocLint(options, cwd);
                     if (discoveryErrors && discoveryErrors.length > 0) for (const error of discoveryErrors)core_logger.warn(`${picocolors.dim("[tsdoc-lint]")} ${error.message}`);
                     if (!TsDocConfigBuilder.shouldPersist(options.persistConfig)) tempTsDocConfigPath = tsdocConfigPath;
                     if (0 === results.errorCount && 0 === results.warningCount) return void core_logger.info(`${picocolors.dim("[tsdoc-lint]")} ${picocolors.green("All TSDoc comments are valid")}`);
@@ -2422,7 +2645,8 @@ const VirtualEntryPlugin = (options)=>{
             "npm"
         ],
         externals: [],
-        apiModel: true
+        apiModel: true,
+        bundle: true
     };
     static mergeOptions(options = {}) {
         const copyPatterns = [
@@ -2442,6 +2666,7 @@ const VirtualEntryPlugin = (options)=>{
             targets: options.targets ?? NodeLibraryBuilder.DEFAULT_OPTIONS.targets,
             externals: options.externals ?? NodeLibraryBuilder.DEFAULT_OPTIONS.externals,
             apiModel: options.apiModel ?? NodeLibraryBuilder.DEFAULT_OPTIONS.apiModel,
+            bundle: options.bundle ?? NodeLibraryBuilder.DEFAULT_OPTIONS.bundle,
             ...void 0 !== options.entry && {
                 entry: options.entry
             },
@@ -2487,20 +2712,31 @@ const VirtualEntryPlugin = (options)=>{
                 },
                 ..."object" == typeof lintConfig ? lintConfig : {}
             };
-            plugins.push(TsDocLintPlugin(lintOptions));
+            plugins.push(TsDocLintPlugin({
+                ...lintOptions,
+                ...false === options.bundle && {
+                    perEntry: true
+                }
+            }));
         }
-        if (!options.entry) plugins.push(AutoEntryPlugin(null != options.exportsAsIndexes ? {
-            exportsAsIndexes: options.exportsAsIndexes
-        } : void 0));
+        if (!options.entry) plugins.push(AutoEntryPlugin({
+            ...null != options.exportsAsIndexes && {
+                exportsAsIndexes: options.exportsAsIndexes
+            },
+            ...false === options.bundle && {
+                bundleless: true
+            }
+        }));
         const userTransform = options.transform;
         const transformFn = userTransform ? (pkg)=>userTransform({
                 target,
                 pkg
             }) : void 0;
         const libraryFormat = options.format ?? "esm";
+        const collapseIndex = (options.bundle ?? true) || !(options.exportsAsIndexes ?? false);
         plugins.push(PackageJsonTransformPlugin({
             forcePrivate: "dev" === target,
-            bundle: true,
+            bundle: collapseIndex,
             target,
             format: libraryFormat,
             ...transformFn && {
@@ -2513,16 +2749,32 @@ const VirtualEntryPlugin = (options)=>{
                 transformFiles: options.transformFiles
             }
         }));
-        if (options.plugins) plugins.push(...options.plugins);
+        plugins.push(...options.plugins);
         const outputDir = `dist/${target}`;
-        const entry = options.entry;
+        let entry = options.entry;
+        if (false === options.bundle && !entry) {
+            const cwd = process.cwd();
+            const packageJsonPath = join(cwd, "package.json");
+            const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+            const { entries } = new EntryExtractor().extract(packageJson);
+            const graph = new ImportGraph({
+                rootDir: cwd
+            });
+            const result = graph.traceFromEntries(Object.values(entries));
+            const tracedEntries = {};
+            for (const file of result.files){
+                const relPath = relative(cwd, file);
+                tracedEntries[relPath] = `./${relPath}`;
+            }
+            entry = tracedEntries;
+        }
         const apiModelForTarget = "npm" === target ? options.apiModel : void 0;
         plugins.push(DtsPlugin({
             ...options.tsconfigPath && {
                 tsconfigPath: options.tsconfigPath
             },
             abortOnError: true,
-            bundle: true,
+            bundle: options.bundle ?? true,
             ...options.dtsBundledPackages && {
                 bundledPackages: options.dtsBundledPackages
             },
@@ -2534,12 +2786,16 @@ const VirtualEntryPlugin = (options)=>{
         }));
         const lib = {
             id: target,
-            outBase: outputDir,
+            outBase: false === options.bundle ? "src" : outputDir,
             output: {
                 target: "node",
                 module: true,
                 cleanDistPath: true,
                 sourceMap: "dev" === target,
+                // Prevent @preserve comments from generating .LICENSE.txt files
+                ...false === options.bundle && {
+                    legalComments: "inline"
+                },
                 distPath: {
                     root: outputDir
                 },
@@ -2554,7 +2810,7 @@ const VirtualEntryPlugin = (options)=>{
             experiments: {
                 advancedEsm: "esm" === libraryFormat
             },
-            bundle: true,
+            bundle: options.bundle ?? true,
             plugins,
             source: {
                 ...options.tsconfigPath && {
@@ -2579,10 +2835,13 @@ const VirtualEntryPlugin = (options)=>{
             const virtualByFormat = new Map();
             for (const [outputName, config] of Object.entries(virtualEntries)){
                 const entryFormat = config.format ?? libraryFormat;
-                if (!virtualByFormat.has(entryFormat)) virtualByFormat.set(entryFormat, new Map());
+                let formatMap = virtualByFormat.get(entryFormat);
+                if (!formatMap) {
+                    formatMap = new Map();
+                    virtualByFormat.set(entryFormat, formatMap);
+                }
                 const entryName = outputName.replace(/\.(c|m)?js$/, "");
-                const formatMap = virtualByFormat.get(entryFormat);
-                if (formatMap) formatMap.set(entryName, config.source);
+                formatMap.set(entryName, config.source);
             }
             for (const [format, entries] of virtualByFormat){
                 const virtualEntryNames = new Set(entries.keys());
@@ -2656,4 +2915,4 @@ const VirtualEntryPlugin = (options)=>{
         }
     }
 }
-export { AutoEntryPlugin, DtsPlugin, EntryExtractor, FilesArrayPlugin, ImportGraph, NodeLibraryBuilder, PackageJsonTransformPlugin, TsDocConfigBuilder, TsDocLintPlugin, TsconfigResolver, TsconfigResolverError, VirtualEntryPlugin, extractEntriesFromPackageJson };
+export { AutoEntryPlugin, DtsPlugin, EntryExtractor, FilesArrayPlugin, ImportGraph, NodeLibraryBuilder, PackageJsonTransformPlugin, TsDocConfigBuilder, TsDocLintPlugin, TsconfigResolver, TsconfigResolverError, VirtualEntryPlugin };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@savvy-web/rslib-builder",
-	"version": "0.11.0",
+	"version": "0.12.1",
 	"private": false,
 	"description": "RSlib-based build system for Node.js libraries with automatic package.json transformation, TypeScript declaration bundling, and multi-target support",
 	"keywords": [
@@ -47,7 +47,7 @@
 		"@microsoft/tsdoc-config": "^0.18.0",
 		"@pnpm/catalogs.config": "^1000.0.5",
 		"@pnpm/catalogs.protocol-parser": "^1001.0.0",
-		"@pnpm/exportable-manifest": "^1000.3.1",
+		"@pnpm/exportable-manifest": "^1000.4.0",
 		"@pnpm/lockfile.fs": "^1001.1.29",
 		"@pnpm/workspace.read-manifest": "^1000.2.10",
 		"@typescript-eslint/parser": "^8.53.1",
@@ -57,14 +57,14 @@
 		"glob": "^13.0.1",
 		"picocolors": "^1.1.1",
 		"sort-package-json": "^3.6.1",
-		"tmp": "^0.2.5",
+		"tmp": ">=0.2.4",
 		"workspace-tools": "^0.41.0"
 	},
 	"peerDependencies": {
-		"@microsoft/api-extractor": "^7.55.2",
-		"@rslib/core": "^0.19.3",
-		"@types/node": "^25.0.10",
-		"@typescript/native-preview": "^7.0.0-dev.20260124.1",
+		"@microsoft/api-extractor": "^7.56.3",
+		"@rslib/core": "^0.19.5",
+		"@types/node": "^25.2.1",
+		"@typescript/native-preview": "7.0.0-dev.20260207.1",
 		"typescript": "^5.9.3"
 	},
 	"peerDependenciesMeta": {

package/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.56.0"
+      "packageVersion": "7.56.3"
     }
   ]
 }