@savvy-web/rslib-builder 0.10.0 → 0.12.0

package/index.js

@@ -5,16 +5,19 @@ import { defineConfig } from "@rslib/core";
 import { access, copyFile, mkdir, readFile, readdir, rm, stat, unlink as promises_unlink, writeFile } from "node:fs/promises";
 import { logger as core_logger } from "@rsbuild/core";
 import picocolors from "picocolors";
-import { getWorkspaceManagerRoot } from "workspace-tools";
+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";
+import { getCatalogsFromWorkspaceManifest } from "@pnpm/catalogs.config";
+import { parseCatalogProtocol } from "@pnpm/catalogs.protocol-parser";
 import { createExportableManifest } from "@pnpm/exportable-manifest";
-import { parse } from "yaml";
+import { readWantedLockfile } from "@pnpm/lockfile.fs";
+import { readWorkspaceManifest } from "@pnpm/workspace.read-manifest";
 const { cyan: cyan, dim: dim, bold: bold } = picocolors;
 function formatTime(ms) {
     if (ms < 1000) return `${ms}ms`;
@@ -83,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;
@@ -104,6 +112,7 @@ class EntryExtractor {
             if (!this.isTypeScriptFile(resolvedPath)) continue;
             const entryName = this.createEntryName(key);
             entries[entryName] = resolvedPath;
+            exportPaths[entryName] = key;
         }
     }
     extractFromBin(bin, entries) {
@@ -141,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);
@@ -176,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 {
@@ -205,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`;
@@ -229,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: {
@@ -310,21 +552,6 @@ class TSConfigFile {
     }
 }
 class LibraryTSConfigFile extends TSConfigFile {
-    bundle(target) {
-        const config = transformStringsDeep(this.config, (str)=>str.replace("${configDir}", "../../../../../.."));
-        const include = config.include?.filter((pattern)=>pattern.includes("/src/") || pattern.includes("/types/") || pattern.includes("/public/") || pattern.includes("package.json")).filter((pattern)=>!pattern.includes(".tsx") && !pattern.includes(".cts"));
-        return {
-            ...config,
-            compilerOptions: {
-                ...config.compilerOptions,
-                outDir: "dist",
-                tsBuildInfoFile: `${process.cwd()}/dist/.tsbuildinfo.${target}.bundle`
-            },
-            ...void 0 !== include && include.length > 0 ? {
-                include
-            } : {}
-        };
-    }
     writeBundleTempConfig(_target) {
         const cwd = process.cwd();
         const baseConfig = this.config;
@@ -786,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;
@@ -884,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;
@@ -928,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: {
@@ -960,7 +1191,7 @@ async function bundleDtsFiles(options) {
                         }
                     }
                 },
-                bundledPackages: bundledPackages
+                bundledPackages
             },
             packageJsonFullPath: join(cwd, "package.json"),
             configObjectFullPath: void 0
@@ -1040,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");
@@ -1052,9 +1283,7 @@ async function bundleDtsFiles(options) {
     }
     return {
         bundledFiles,
-        ...apiModelPath && {
-            apiModelPath
-        },
+        apiModelPaths,
         ...tsdocMetadataPath && {
             tsdocMetadataPath
         },
@@ -1066,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, {
@@ -1231,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) {
@@ -1242,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)){
@@ -1272,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,
@@ -1289,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;
@@ -1309,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,
@@ -1325,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);
@@ -1349,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){
@@ -1367,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;
@@ -1576,75 +1863,76 @@ const FilesArrayPlugin = (options)=>({
     });
 const CATALOG_PREFIX = "catalog:";
 const WORKSPACE_PREFIX = "workspace:";
-class PnpmCatalog {
-    catalogCache = null;
-    catalogCacheMtime = null;
-    cachedWorkspaceRoot = null;
+class WorkspaceCatalog {
+    catalogsCache = null;
+    cachedWorkspaceInfo = null;
     clearCache() {
-        this.catalogCache = null;
-        this.catalogCacheMtime = null;
-        this.cachedWorkspaceRoot = null;
+        this.catalogsCache = null;
+        this.cachedWorkspaceInfo = null;
     }
-    async getCatalog() {
-        try {
-            if (!this.cachedWorkspaceRoot) {
-                this.cachedWorkspaceRoot = getWorkspaceManagerRoot(process.cwd());
-                if (!this.cachedWorkspaceRoot) throw new Error("Could not find workspace root - ensure you're in a workspace");
-            }
-            const workspaceFile = external_node_path_resolve(this.cachedWorkspaceRoot, "pnpm-workspace.yaml");
-            const stats = await stat(workspaceFile);
-            const currentMtime = stats.mtime.getTime();
-            if (null !== this.catalogCache && this.catalogCacheMtime === currentMtime) return this.catalogCache;
-            const content = await readFile(workspaceFile, "utf-8");
-            const workspace = parse(content);
-            this.catalogCache = workspace.catalog ?? {};
-            this.catalogCacheMtime = currentMtime;
-            return this.catalogCache;
-        } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
+    async getCatalogs() {
+        if (null !== this.catalogsCache) return this.catalogsCache;
+        const workspaceInfo = this.getWorkspaceInfo();
+        if (!workspaceInfo) {
             const logger = createEnvLogger("catalog");
-            if (errorMessage.includes("ENOENT") && errorMessage.includes("pnpm-workspace.yaml")) {
-                logger.error("Failed to read pnpm catalog: workspace configuration not found");
-                logger.error("  -> Ensure you're in a pnpm workspace with proper configuration");
-            } else if (errorMessage.includes("YAML")) {
-                logger.error("Failed to read pnpm catalog: Invalid YAML syntax in workspace configuration");
-                logger.error("  -> Check workspace configuration file syntax");
-            } else logger.error(`Failed to read pnpm catalog from pnpm-workspace.yaml: ${errorMessage}`);
+            logger.error("Could not find workspace root - ensure you're in a workspace");
             return {};
         }
+        const { manager, root } = workspaceInfo;
+        if ("pnpm" === manager) this.catalogsCache = await this.readPnpmCatalogs(root);
+        else if ("yarn" === manager) this.catalogsCache = this.readYarnCatalogs(root);
+        else this.catalogsCache = {};
+        return this.catalogsCache;
     }
     async resolvePackageJson(packageJson, dir = process.cwd()) {
-        const logger = createEnvLogger("pnpm");
+        const workspaceInfo = this.getWorkspaceInfo();
+        const loggerName = workspaceInfo?.manager === "yarn" ? "yarn" : "pnpm";
+        const logger = createEnvLogger(loggerName);
         try {
-            const catalog = await this.getCatalog();
-            const catalogDeps = this.collectDependencies(packageJson, CATALOG_PREFIX);
+            const catalogs = await this.getCatalogs();
+            const catalogDeps = this.collectCatalogDependencies(packageJson);
             const workspaceDeps = this.collectDependencies(packageJson, WORKSPACE_PREFIX);
             const hasCatalogDeps = catalogDeps.length > 0;
             const hasWorkspaceDeps = workspaceDeps.length > 0;
-            if (hasCatalogDeps && 0 === Object.keys(catalog).length) {
-                const error = `Package contains ${CATALOG_PREFIX} dependencies but catalog configuration is missing`;
-                logger.error(error);
-                logger.error("  -> Catalog dependencies found:");
-                for (const { field, dependency, version } of catalogDeps)logger.error(`    - ${field}.${dependency}: ${version}`);
-                throw new Error(error);
+            if (hasCatalogDeps) {
+                const missingCatalogs = this.findMissingCatalogs(catalogDeps, catalogs);
+                if (missingCatalogs.size > 0) {
+                    const available = Object.keys(catalogs).join(", ") || "none";
+                    const error = `Catalog(s) not found: ${[
+                        ...missingCatalogs
+                    ].join(", ")}. Available: ${available}`;
+                    logger.error(error);
+                    logger.error("  -> Catalog dependencies found:");
+                    for (const { field, dependency, version, catalogName } of catalogDeps)if (missingCatalogs.has(catalogName)) logger.error(`    - ${field}.${dependency}: ${version}`);
+                    throw new Error(error);
+                }
+                logger.info(`Resolving ${catalogDeps.length} ${CATALOG_PREFIX} dependencies`);
             }
-            if (hasCatalogDeps) logger.info(`Resolving ${catalogDeps.length} ${CATALOG_PREFIX} dependencies`);
             if (hasWorkspaceDeps) logger.info(`Resolving ${workspaceDeps.length} ${WORKSPACE_PREFIX} dependencies`);
             const result = await createExportableManifest(dir, packageJson, {
-                catalogs: {
-                    default: catalog
-                }
+                catalogs
             });
-            if (hasCatalogDeps || hasWorkspaceDeps) this.logResolvedDependencies(result, [
-                ...catalogDeps,
-                ...workspaceDeps
-            ], logger);
+            if (hasCatalogDeps || hasWorkspaceDeps) {
+                const allDeps = [
+                    ...catalogDeps.map((d)=>({
+                            field: d.field,
+                            dependency: d.dependency,
+                            source: "default" === d.catalogName ? "catalog:" : `catalog:${d.catalogName}`
+                        })),
+                    ...workspaceDeps.map((d)=>({
+                            field: d.field,
+                            dependency: d.dependency,
+                            source: "workspace:"
+                        }))
+                ];
+                this.logResolvedDependencies(result, allDeps, logger);
+            }
             this.validateNoUnresolvedReferences(result, logger);
             return result;
         } catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
-            if (errorMessage.startsWith("Transformation failed:") || errorMessage.includes(`Package contains ${CATALOG_PREFIX} dependencies`)) throw error;
-            logger.error(`Failed to apply pnpm transformations for directory ${dir}: ${errorMessage}`);
+            if (errorMessage.startsWith("Transformation failed:") || errorMessage.startsWith("Catalog(s) not found:")) throw error;
+            logger.error(`Failed to apply transformations for directory ${dir}: ${errorMessage}`);
             if (errorMessage.includes("catalog")) {
                 logger.error(`  -> Catalog resolution failed - check workspace configuration and ${CATALOG_PREFIX} dependencies`);
                 throw new Error("Catalog resolution failed");
@@ -1658,8 +1946,89 @@ class PnpmCatalog {
                 throw new Error(`Manifest processing failed: ${errorMessage}`);
             }
             logger.error("  -> Cannot proceed with invalid package.json transformations");
-            throw new Error(`PNPM transformation failed: ${errorMessage}`);
+            throw new Error(`Transformation failed: ${errorMessage}`);
+        }
+    }
+    getWorkspaceInfo() {
+        if (null !== this.cachedWorkspaceInfo) return this.cachedWorkspaceInfo;
+        const info = getWorkspaceManagerAndRoot(process.cwd());
+        this.cachedWorkspaceInfo = info ?? null;
+        return this.cachedWorkspaceInfo;
+    }
+    async readPnpmCatalogs(workspaceRoot) {
+        const lockfileCatalogs = await this.readPnpmLockfileCatalogs(workspaceRoot);
+        if (Object.keys(lockfileCatalogs).length > 0) return lockfileCatalogs;
+        return this.readPnpmWorkspaceCatalogs(workspaceRoot);
+    }
+    async readPnpmLockfileCatalogs(workspaceRoot) {
+        try {
+            const lockfile = await readWantedLockfile(workspaceRoot, {
+                ignoreIncompatible: true
+            });
+            if (!lockfile?.catalogs) return {};
+            return this.convertLockfileCatalogs(lockfile.catalogs);
+        } catch  {
+            return {};
+        }
+    }
+    async readPnpmWorkspaceCatalogs(workspaceRoot) {
+        try {
+            const manifest = await readWorkspaceManifest(workspaceRoot);
+            return getCatalogsFromWorkspaceManifest(manifest);
+        } catch  {
+            return {};
+        }
+    }
+    readYarnCatalogs(workspaceRoot) {
+        const catalogs = getCatalogs(workspaceRoot, "yarn");
+        if (!catalogs) return {};
+        return this.convertWorkspaceToolsCatalogs(catalogs);
+    }
+    convertLockfileCatalogs(snapshots) {
+        const result = {};
+        for (const [name, entries] of Object.entries(snapshots)){
+            result[name] = {};
+            for (const [dep, entry] of Object.entries(entries))result[name][dep] = entry.specifier;
+        }
+        return result;
+    }
+    convertWorkspaceToolsCatalogs(catalogs) {
+        const result = {};
+        if (catalogs.default) result.default = {
+            ...catalogs.default
+        };
+        if (catalogs.named) for (const [name, catalog] of Object.entries(catalogs.named))result[name] = {
+            ...catalog
+        };
+        return result;
+    }
+    collectCatalogDependencies(packageJson) {
+        const deps = [];
+        const fields = [
+            "dependencies",
+            "devDependencies",
+            "peerDependencies",
+            "optionalDependencies"
+        ];
+        for (const field of fields){
+            const fieldDeps = packageJson[field];
+            if (fieldDeps) for (const [dependency, version] of Object.entries(fieldDeps)){
+                if ("string" != typeof version || !version.startsWith(CATALOG_PREFIX)) continue;
+                const catalogName = parseCatalogProtocol(version);
+                if (catalogName) deps.push({
+                    field,
+                    dependency,
+                    version,
+                    catalogName
+                });
+            }
         }
+        return deps;
+    }
+    findMissingCatalogs(deps, catalogs) {
+        const missing = new Set();
+        for (const { catalogName } of deps)if (!catalogs[catalogName]) missing.add(catalogName);
+        return missing;
     }
     collectDependencies(packageJson, prefix) {
         const deps = [];
@@ -1683,28 +2052,35 @@ class PnpmCatalog {
     }
     logResolvedDependencies(resultPkg, originalDeps, logger) {
         const allResolved = {};
-        for (const { field, dependency } of originalDeps){
+        for (const { field, dependency, source } of originalDeps){
             const deps = resultPkg[field];
             if (deps?.[dependency]) {
                 if (!allResolved[field]) allResolved[field] = [];
                 allResolved[field].push({
                     dependency,
-                    version: deps[dependency]
+                    version: deps[dependency],
+                    source
                 });
             }
         }
         if (Object.keys(allResolved).length > 0) {
-            logger.info("Resolved dependencies:");
+            logger.global.info("Resolved dependencies:");
             for (const [field, deps] of Object.entries(allResolved)){
-                logger.info(`- ${field}:`);
-                for (const { dependency, version } of deps)logger.info(`    ${dependency}: ${version}`);
+                logger.global.info(`- ${field}:`);
+                for (const { dependency, version, source } of deps)logger.global.info(`    ${dependency}: ${version} (${source})`);
             }
         }
     }
     validateNoUnresolvedReferences(resultPkg, logger) {
+        const unresolvedCatalog = this.collectCatalogDependencies(resultPkg);
+        const unresolvedWorkspace = this.collectDependencies(resultPkg, WORKSPACE_PREFIX);
         const unresolvedDeps = [
-            ...this.collectDependencies(resultPkg, CATALOG_PREFIX),
-            ...this.collectDependencies(resultPkg, WORKSPACE_PREFIX)
+            ...unresolvedCatalog.map((d)=>({
+                    field: d.field,
+                    dependency: d.dependency,
+                    version: d.version
+                })),
+            ...unresolvedWorkspace
         ];
         if (unresolvedDeps.length > 0) {
             const catalogRefs = unresolvedDeps.filter((dep)=>dep.version.startsWith(CATALOG_PREFIX));
@@ -1721,10 +2097,8 @@ class PnpmCatalog {
         }
     }
 }
-let defaultInstance = null;
-function getDefaultPnpmCatalog() {
-    if (!defaultInstance) defaultInstance = new PnpmCatalog();
-    return defaultInstance;
+function createWorkspaceCatalog() {
+    return new WorkspaceCatalog();
 }
 function transformExportPath(path, processTSExports = true, collapseIndex = false) {
     let transformedPath = path;
@@ -1829,8 +2203,9 @@ function applyRslibTransformations(packageJson, originalPackageJson, processTSEx
     });
     return sort_package_json(processedManifest);
 }
-async function applyPnpmTransformations(packageJson, dir = process.cwd()) {
-    return getDefaultPnpmCatalog().resolvePackageJson(packageJson, dir);
+async function applyPnpmTransformations(packageJson, dir = process.cwd(), catalog) {
+    const workspaceCatalog = catalog ?? createWorkspaceCatalog();
+    return workspaceCatalog.resolvePackageJson(packageJson, dir);
 }
 async function buildPackageJson(packageJson, isProduction = false, processTSExports = true, entrypoints, exportToOutputMap, bundle, transform) {
     let result;
@@ -1841,12 +2216,9 @@ async function buildPackageJson(packageJson, isProduction = false, processTSExpo
     if (transform) result = transform(result);
     return result;
 }
-const PackageJsonTransformPlugin = (options = {})=>{
-    const cache = new Map();
-    return {
+const PackageJsonTransformPlugin = (options = {})=>({
         name: "package-json-processor",
         setup (api) {
-            api.expose("files-cache", cache);
             let filesArray = api.useExposed("files-array");
             if (!filesArray) {
                 filesArray = new Set();
@@ -1895,225 +2267,7 @@ 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 = [];
@@ -2157,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;
@@ -2273,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 {
@@ -2293,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")}`);
@@ -2350,7 +2645,8 @@ const VirtualEntryPlugin = (options)=>{
             "npm"
         ],
         externals: [],
-        apiModel: true
+        apiModel: true,
+        bundle: true
     };
     static mergeOptions(options = {}) {
         const copyPatterns = [
@@ -2370,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
             },
@@ -2415,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 && {
@@ -2441,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
             },
@@ -2462,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
                 },
@@ -2482,7 +2810,7 @@ const VirtualEntryPlugin = (options)=>{
             experiments: {
                 advancedEsm: "esm" === libraryFormat
             },
-            bundle: true,
+            bundle: options.bundle ?? true,
             plugins,
             source: {
                 ...options.tsconfigPath && {
@@ -2507,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());
@@ -2584,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 };