@savvy-web/rslib-builder 0.1.0

package/index.js

@@ -0,0 +1,1521 @@
+/*! For license information please see index.js.LICENSE.txt */
+import * as __rspack_external_node_path_c5b9b54f from "node:path";
+import { __webpack_require__ } from "./rslib-runtime.js";
+import { constants, existsSync, writeFileSync } from "node:fs";
+import { defineConfig } from "@rslib/core";
+import { access, copyFile, mkdir, readFile as promises_readFile, readdir, rm, stat as promises_stat, unlink, writeFile } from "node:fs/promises";
+import { getWorkspaceRoot } from "workspace-tools";
+import { logger as core_logger } from "@rsbuild/core";
+import picocolors from "picocolors";
+import { spawn } from "node:child_process";
+import { 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 { createExportableManifest } from "@pnpm/exportable-manifest";
+import { parse } from "yaml";
+__webpack_require__.add({
+    "node:path" (module) {
+        module.exports = __rspack_external_node_path_c5b9b54f;
+    }
+});
+const external_node_path_ = __webpack_require__("node:path");
+async function fileExistAsync(assetName) {
+    const assetPath = (0, external_node_path_.join)(process.cwd(), assetName);
+    const assetExists = !!await promises_stat(assetPath).catch(()=>false);
+    return {
+        assetName,
+        assetPath,
+        assetExists
+    };
+}
+async function packageJsonVersion() {
+    const { assetExists, assetPath } = await fileExistAsync("package.json");
+    if (!assetExists) throw new Error("package.json not found in project root");
+    try {
+        const json = await promises_readFile(assetPath, "utf-8");
+        const { version } = JSON.parse(json);
+        return version;
+    } catch  {
+        throw new Error("Failed to read version from package.json");
+    }
+}
+function getApiExtractorPath() {
+    const cwd = process.cwd();
+    const localApiExtractor = (0, external_node_path_.join)(cwd, "node_modules", "@microsoft", "api-extractor");
+    if (existsSync(localApiExtractor)) return localApiExtractor;
+    const workspaceRoot = getWorkspaceRoot(cwd);
+    if (workspaceRoot) {
+        const workspaceApiExtractor = (0, external_node_path_.join)(workspaceRoot, "node_modules", "@microsoft", "api-extractor");
+        if (existsSync(workspaceApiExtractor)) return workspaceApiExtractor;
+    }
+    throw new Error("API Extractor bundling requires @microsoft/api-extractor to be installed.\nInstall it with: pnpm add -D @microsoft/api-extractor");
+}
+const { cyan: cyan, dim: dim, bold: bold } = picocolors;
+function formatTime(ms) {
+    if (ms < 1000) return `${ms}ms`;
+    return `${(ms / 1000).toFixed(2)}s`;
+}
+function isTestEnvironment() {
+    return "test" === process.env.NODE_ENV || "true" === process.env.VITEST || void 0 !== process.env.JEST_WORKER_ID || process.argv.some((arg)=>arg.includes("vitest") || arg.includes("jest"));
+}
+function createEnvLogger(envId) {
+    const isTest = isTestEnvironment();
+    return {
+        info: (message, ...args)=>{
+            if (!isTest) core_logger.info(`${message} (${cyan(envId)})`, ...args);
+        },
+        warn: (message, ...args)=>{
+            if (!isTest) core_logger.warn(`${message} (${cyan(envId)})`, ...args);
+        },
+        error: (message, ...args)=>{
+            if (!isTest) core_logger.error(`${message} (${cyan(envId)})`, ...args);
+        },
+        withTime: (message, time, ...args)=>{
+            if (!isTest) {
+                const env = dim(`(${envId})`);
+                core_logger.info(`${message} in ${bold(formatTime(time))} ${env}`, ...args);
+            }
+        },
+        success: (message, filename, ...args)=>{
+            if (!isTest) {
+                const coloredFilename = filename ? cyan(filename) : "";
+                const fullMessage = filename ? `${message} ${coloredFilename}` : message;
+                const env = dim(`(${envId})`);
+                core_logger.info(`${fullMessage} ${env}`, ...args);
+            }
+        },
+        fileOp: (message, files, ...args)=>{
+            if (!isTest) {
+                const coloredFiles = files.map((f)=>cyan(f)).join(", ");
+                const env = dim(`(${envId})`);
+                core_logger.info(`${message}: ${coloredFiles} ${env}`, ...args);
+            }
+        },
+        entries: (message, entries, ...args)=>{
+            if (!isTest) {
+                const coloredEntries = Object.entries(entries).map(([name, path])=>cyan(`${name} => ${path}`)).join(", ");
+                const env = dim(`(${envId})`);
+                core_logger.info(`${message}: ${coloredEntries} ${env}`, ...args);
+            }
+        },
+        global: {
+            info: (message, ...args)=>{
+                if (!isTest) core_logger.info(message, ...args);
+            },
+            warn: (message, ...args)=>{
+                if (!isTest) core_logger.warn(message, ...args);
+            },
+            error: (message, ...args)=>{
+                if (!isTest) core_logger.error(message, ...args);
+            }
+        }
+    };
+}
+class EntryExtractor {
+    options;
+    constructor(options = {}){
+        this.options = options;
+    }
+    extract(packageJson) {
+        const entries = {};
+        this.extractFromExports(packageJson.exports, entries);
+        this.extractFromBin(packageJson.bin, entries);
+        return {
+            entries
+        };
+    }
+    extractFromExports(exports, entries) {
+        if (!exports) return;
+        if ("string" == typeof exports) {
+            if (this.isTypeScriptFile(exports)) entries.index = exports;
+            return;
+        }
+        if ("object" != typeof exports) return;
+        for (const [key, value] of Object.entries(exports)){
+            if ("./package.json" === key || key.endsWith(".json")) continue;
+            const sourcePath = this.resolveSourcePath(value);
+            if (!sourcePath) continue;
+            const resolvedPath = this.resolveToTypeScript(sourcePath);
+            if (!this.isTypeScriptFile(resolvedPath)) continue;
+            const entryName = this.createEntryName(key);
+            entries[entryName] = resolvedPath;
+        }
+    }
+    extractFromBin(bin, entries) {
+        if (!bin) return;
+        if ("string" == typeof bin) {
+            const resolvedPath = this.resolveToTypeScript(bin);
+            if (this.isTypeScriptFile(resolvedPath)) entries["bin/cli"] = resolvedPath;
+            return;
+        }
+        if ("object" != typeof bin) return;
+        for (const [command, path] of Object.entries(bin)){
+            if ("string" != typeof path) continue;
+            const resolvedPath = this.resolveToTypeScript(path);
+            if (this.isTypeScriptFile(resolvedPath)) entries[`bin/${command}`] = resolvedPath;
+        }
+    }
+    resolveSourcePath(value) {
+        if ("string" == typeof value) return value;
+        if (value && "object" == typeof value) {
+            const exportObj = value;
+            return exportObj.import || exportObj.default || exportObj.types;
+        }
+    }
+    resolveToTypeScript(path) {
+        if (path.endsWith(".js") && path.includes("/dist/")) return path.replace("/dist/", "/src/").replace(/\.js$/, ".ts");
+        return path;
+    }
+    isTypeScriptFile(path) {
+        return path.endsWith(".ts") || path.endsWith(".tsx");
+    }
+    createEntryName(exportKey) {
+        if ("." === exportKey) return "index";
+        const withoutPrefix = exportKey.replace(/^\.\//, "");
+        if (this.options.exportsAsIndexes) return `${withoutPrefix}/index`;
+        return withoutPrefix.replace(/\//g, "-");
+    }
+}
+function extractEntriesFromPackageJson(packageJson, options) {
+    const extractor = new EntryExtractor(options);
+    return extractor.extract(packageJson);
+}
+const AutoEntryPlugin = (options)=>{
+    const buildStateMap = new WeakMap();
+    return {
+        name: "auto-entry-plugin",
+        setup (api) {
+            buildStateMap.set(api, {
+                hasLoggedEntries: false,
+                hasLoggedSchemas: false
+            });
+            let entrypoints = api.useExposed("entrypoints");
+            if (!entrypoints) {
+                entrypoints = new Map();
+                api.expose("entrypoints", entrypoints);
+            }
+            let exportToOutputMap = api.useExposed("exportToOutputMap");
+            if (!exportToOutputMap) {
+                exportToOutputMap = new Map();
+                api.expose("exportToOutputMap", exportToOutputMap);
+            }
+            api.onBeforeBuild(async (context)=>{
+                api.logger.debug(context);
+            });
+            api.modifyRsbuildConfig(async (config)=>{
+                const log = createEnvLogger("auto-entry");
+                const { assetPath, assetExists } = await fileExistAsync("package.json");
+                if (!assetExists) {
+                    log.global.error("package.json not found in project root");
+                    throw new Error("package.json not found in project root");
+                }
+                try {
+                    const packageJsonContent = await promises_readFile(assetPath, "utf-8");
+                    const packageJson = JSON.parse(packageJsonContent);
+                    const { entries } = extractEntriesFromPackageJson(packageJson, {
+                        exportsAsIndexes: options?.exportsAsIndexes
+                    });
+                    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)){
+                                const normalizedEntryName = entryName.replace(/\/index$/, "");
+                                if ("." === pkgExportKey && "index" === entryName || normalizedExportKey === normalizedEntryName) {
+                                    const outputPath = `./${entryName}.js`;
+                                    exportToOutputMap.set(pkgExportKey, outputPath);
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    for (const [entryName, sourcePath] of Object.entries(entries)){
+                        const outputName = `${entryName}.ts`;
+                        entrypoints.set(outputName, sourcePath);
+                    }
+                    if (Object.keys(entries).length > 0) {
+                        const environments = Object.entries(config?.environments ?? {});
+                        environments.forEach(([_env, lib])=>{
+                            lib.source = {
+                                ...lib.source,
+                                entry: {
+                                    ...lib.source?.entry,
+                                    ...entries
+                                }
+                            };
+                        });
+                        const state = buildStateMap.get(api);
+                        if (state && !state.hasLoggedEntries) {
+                            state.hasLoggedEntries = true;
+                            environments.forEach(([env])=>{
+                                const log = createEnvLogger(env);
+                                log.entries("auto-detected entries", entries);
+                            });
+                        }
+                    }
+                } catch (error) {
+                    log.global.error("failed to process package.json:", error);
+                }
+                return config;
+            });
+        }
+    };
+};
+var lib_namespaceObject = JSON.parse('{"$schema":"https://json.schemastore.org/tsconfig.json","compilerOptions":{"allowSyntheticDefaultImports":true,"composite":true,"declaration":true,"declarationDir":"${configDir}/dist","declarationMap":false,"emitDeclarationOnly":false,"esModuleInterop":true,"explainFiles":false,"forceConsistentCasingInFileNames":true,"incremental":true,"isolatedDeclarations":true,"isolatedModules":true,"jsx":"preserve","lib":["esnext"],"module":"nodenext","moduleResolution":"nodenext","outDir":"${configDir}/dist","resolveJsonModule":true,"rootDir":"${configDir}","skipLibCheck":true,"sourceMap":false,"strict":true,"strictNullChecks":true,"target":"es2023","tsBuildInfoFile":"${configDir}/dist/.tsbuildinfo.lib","typeRoots":["${configDir}/node_modules/@types","${configDir}/types"],"verbatimModuleSyntax":true},"exclude":["${configDir}/node_modules","${configDir}/dist/**/*"],"include":["${configDir}/types/*.ts","${configDir}/package.json","${configDir}/*.ts","${configDir}/*.cts","${configDir}/*.mts","${configDir}/src/**/*.ts","${configDir}/src/**/*.tsx","${configDir}/src/**/*.cts","${configDir}/src/**/*.mts","${configDir}/lib/**/*.ts","${configDir}/lib/**/*.tsx","${configDir}/lib/**/*.cts","${configDir}/lib/**/*.mts","${configDir}/public/**/*.json"]}');
+var root_namespaceObject = JSON.parse('{"$schema":"https://json.schemastore.org/tsconfig","compilerOptions":{"composite":true,"declaration":true,"module":"node20","outDir":"dist","resolveJsonModule":true,"strict":true,"strictNullChecks":true,"target":"es2023"}}');
+const requireCJS = createRequire(import.meta.url);
+const jsonImports = new Map([
+    [
+        (0, external_node_path_.join)(import.meta.dirname, "../public/tsconfig/node/ecma/lib.json"),
+        lib_namespaceObject
+    ],
+    [
+        (0, external_node_path_.join)(import.meta.dirname, "../public/tsconfig/root.json"),
+        root_namespaceObject
+    ]
+]);
+function transformStringsDeep(value, transform) {
+    if (null == value) return value;
+    if ("string" == typeof value) return transform(value);
+    if (Array.isArray(value)) return value.map((item)=>transformStringsDeep(item, transform));
+    if ("object" == typeof value) {
+        const result = {};
+        for (const [key, val] of Object.entries(value))result[key] = transformStringsDeep(val, transform);
+        return result;
+    }
+    return value;
+}
+class TSConfigFile {
+    pathname;
+    description;
+    /* v8 ignore next -- @preserve */ get path() {
+        return `./${(0, external_node_path_.relative)(process.cwd(), this.pathname)}`;
+    }
+    /* v8 ignore next -- @preserve */ get bundled() {
+        const config = this.config;
+        return transformStringsDeep(config, (str)=>str.replace("${configDir}", "../../../../../.."));
+    }
+    /* v8 ignore next -- @preserve */ get config() {
+        const imported = jsonImports.get(this.pathname);
+        if (!imported) throw new Error(`Config file not found in imports: ${this.pathname}`);
+        return imported;
+    }
+    constructor(description, pathname){
+        this.pathname = pathname;
+        this.description = description;
+        Object.defineProperty(this, "path", {
+            enumerable: true,
+            get: ()=>`./${(0, external_node_path_.relative)(process.cwd(), this.pathname)}`
+        });
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            get: ()=>{
+                const imported = jsonImports.get(this.pathname);
+                if (!imported) throw new Error(`Config file not found in imports: ${this.pathname}`);
+                return imported;
+            }
+        });
+        Object.defineProperty(this, "bundled", {
+            enumerable: true,
+            get: ()=>{
+                const imported = jsonImports.get(this.pathname);
+                if (!imported) throw new Error(`Config file not found in imports: ${this.pathname}`);
+                return transformStringsDeep(imported, (str)=>str.replace("${configDir}", "../../../../../.."));
+            }
+        });
+        Object.defineProperty(this, inspect.custom, {
+            value: (_depth, options)=>inspect({
+                    description: this.description,
+                    pathname: this.pathname,
+                    path: this.path,
+                    config: this.config,
+                    bundled: this.bundled
+                }, {
+                    ...options,
+                    depth: null,
+                    colors: options.colors ?? true,
+                    maxArrayLength: null,
+                    breakLength: 80
+                })
+        });
+    }
+}
+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`
+            },
+            include
+        };
+    }
+    writeBundleTempConfig(target) {
+        const cwd = process.cwd();
+        const config = this.bundle(target);
+        const toAbsolute = (path)=>{
+            if (path.startsWith("../") || ".." === path) return path.replace(/^((\.\.\/)+\.\.?|\.\.\/*)$/, cwd).replace(/^(\.\.\/)+/, `${cwd}/`);
+            return path;
+        };
+        const absoluteConfig = {
+            ...config,
+            compilerOptions: {
+                ...config.compilerOptions,
+                rootDir: cwd,
+                declarationMap: true,
+                emitDeclarationOnly: false,
+                declarationDir: config.compilerOptions?.declarationDir ? toAbsolute(config.compilerOptions.declarationDir) : void 0,
+                typeRoots: config.compilerOptions?.typeRoots?.map(toAbsolute)
+            },
+            include: config.include?.map(toAbsolute),
+            exclude: config.exclude?.map(toAbsolute)
+        };
+        const tmpFile = requireCJS("tmp").fileSync({
+            prefix: "tsconfig-bundle-",
+            postfix: ".json"
+        });
+        writeFileSync(tmpFile.name, JSON.stringify(absoluteConfig, null, "\t"));
+        return tmpFile.name;
+    }
+}
+const Root = new TSConfigFile("Root configuration for workspace setup", (0, external_node_path_.join)(import.meta.dirname, "../public/tsconfig/root.json"));
+const NodeEcmaLib = new LibraryTSConfigFile("ECMAScript library build configuration", (0, external_node_path_.join)(import.meta.dirname, "../public/tsconfig/node/ecma/lib.json"));
+const TSConfigs = {
+    root: Root,
+    node: {
+        ecma: {
+            lib: NodeEcmaLib
+        }
+    }
+};
+function getTsgoBinPath() {
+    const cwd = process.cwd();
+    const localTsgoBin = (0, external_node_path_.join)(cwd, "node_modules", ".bin", "tsgo");
+    if (existsSync(localTsgoBin)) return localTsgoBin;
+    const workspaceRoot = getWorkspaceRoot(cwd);
+    if (workspaceRoot) {
+        const workspaceTsgoBin = (0, external_node_path_.join)(workspaceRoot, "node_modules", ".bin", "tsgo");
+        if (existsSync(workspaceTsgoBin)) return workspaceTsgoBin;
+    }
+    return localTsgoBin;
+}
+function generateTsgoArgs(options) {
+    const { configPath, declarationDir, rootDir, tsBuildInfoFile } = options;
+    const args = [
+        "--project",
+        configPath,
+        "--declaration",
+        "--emitDeclarationOnly",
+        "--declarationMap",
+        "--declarationDir",
+        declarationDir
+    ];
+    if (rootDir) args.push("--rootDir", rootDir);
+    if (tsBuildInfoFile) args.push("--tsBuildInfoFile", tsBuildInfoFile);
+    return args;
+}
+async function collectDtsFiles(dir, baseDir = dir) {
+    const files = [];
+    async function walk(currentDir) {
+        const entries = await readdir(currentDir, {
+            withFileTypes: true
+        });
+        for (const entry of entries){
+            const fullPath = (0, external_node_path_.join)(currentDir, entry.name);
+            if (entry.isDirectory()) await walk(fullPath);
+            else if (entry.name.endsWith(".d.ts") || entry.name.endsWith(".d.ts.map")) {
+                const relativePath = (0, external_node_path_.relative)(baseDir, fullPath);
+                files.push({
+                    path: fullPath,
+                    relativePath
+                });
+            }
+        }
+    }
+    await walk(dir);
+    return files;
+}
+async function bundleDtsFiles(options) {
+    const { cwd, tempDtsDir, tempOutputDir, tsconfigPath, bundledPackages, entryPoints, banner, footer, apiModel } = options;
+    const bundledFiles = new Map();
+    let apiModelPath;
+    const apiModelEnabled = true === apiModel || "object" == typeof apiModel && (void 0 === apiModel.enabled || true === apiModel.enabled);
+    const apiModelFilename = "object" == typeof apiModel && apiModel.filename ? apiModel.filename : "api.model.json";
+    getApiExtractorPath();
+    const { Extractor, ExtractorConfig } = await import("@microsoft/api-extractor");
+    for (const [entryName, sourcePath] of entryPoints){
+        const normalizedSourcePath = sourcePath.replace(/^\.\//, "");
+        const dtsFileName = normalizedSourcePath.replace(/\.(tsx?|jsx?)$/, ".d.ts");
+        let tempDtsPath = (0, external_node_path_.join)(tempDtsDir, dtsFileName);
+        try {
+            await access(tempDtsPath, constants.F_OK);
+        } catch  {
+            const withoutSrc = dtsFileName.replace(/^src\//, "");
+            if (withoutSrc !== dtsFileName) {
+                const alternativePath = (0, external_node_path_.join)(tempDtsDir, withoutSrc);
+                try {
+                    await access(alternativePath, constants.F_OK);
+                    tempDtsPath = alternativePath;
+                } catch  {}
+            }
+        }
+        const outputFileName = `${entryName}.d.ts`;
+        const tempBundledPath = (0, external_node_path_.join)(tempOutputDir, outputFileName);
+        const generateApiModel = apiModelEnabled && "index" === entryName;
+        const tempApiModelPath = generateApiModel ? (0, external_node_path_.join)(tempOutputDir, apiModelFilename) : void 0;
+        const extractorConfig = ExtractorConfig.prepare({
+            configObject: {
+                projectFolder: cwd,
+                mainEntryPointFilePath: tempDtsPath,
+                compiler: {
+                    tsconfigFilePath: tsconfigPath
+                },
+                dtsRollup: {
+                    enabled: true,
+                    untrimmedFilePath: tempBundledPath
+                },
+                docModel: generateApiModel ? {
+                    enabled: true,
+                    apiJsonFilePath: tempApiModelPath
+                } : void 0,
+                bundledPackages: bundledPackages
+            },
+            packageJsonFullPath: (0, external_node_path_.join)(cwd, "package.json"),
+            configObjectFullPath: void 0
+        });
+        const extractorResult = Extractor.invoke(extractorConfig, {
+            localBuild: true,
+            showVerboseMessages: false,
+            messageCallback: (message)=>{
+                if (message.text?.includes("Analysis will use the bundled TypeScript version") || message.text?.includes("The target project appears to use TypeScript")) {
+                    message.logLevel = "none";
+                    return;
+                }
+                if (message.text?.includes("You have changed the public API signature")) message.logLevel = "none";
+            }
+        });
+        if (!extractorResult.succeeded) throw new Error(`API Extractor failed for entry "${entryName}"`);
+        if (generateApiModel && tempApiModelPath) apiModelPath = tempApiModelPath;
+        if (banner || footer) {
+            let content = await promises_readFile(tempBundledPath, "utf-8");
+            if (banner) content = `${banner}\n${content}`;
+            if (footer) content = `${content}\n${footer}`;
+            await writeFile(tempBundledPath, content, "utf-8");
+        }
+        bundledFiles.set(entryName, tempBundledPath);
+    }
+    return {
+        bundledFiles,
+        apiModelPath
+    };
+}
+function stripSourceMapComment(content) {
+    return content.replace(/\/\/# sourceMappingURL=.+\.d\.ts\.map\s*$/gm, "").trim();
+}
+async function ensureTempDeclarationDir(cwd, name) {
+    const dir = (0, external_node_path_.join)(cwd, ".rslib", "declarations", name);
+    await rm(dir, {
+        recursive: true,
+        force: true
+    });
+    await mkdir(dir, {
+        recursive: true
+    });
+    return dir;
+}
+function findTsConfig(cwd, tsconfigPath) {
+    if (tsconfigPath) {
+        const { isAbsolute } = __webpack_require__("node:path");
+        if (isAbsolute(tsconfigPath) && sys.fileExists(tsconfigPath)) return tsconfigPath;
+    }
+    return findConfigFile(cwd, sys.fileExists.bind(sys), tsconfigPath) ?? null;
+}
+function loadTsConfig(configPath) {
+    const configContent = readConfigFile(configPath, sys.readFile.bind(sys));
+    if (configContent.error) throw new Error(`Failed to read tsconfig: ${formatDiagnostic(configContent.error, createCompilerHost({}, true))}`);
+    const parsedConfig = parseJsonConfigFileContent(configContent.config, sys, (0, external_node_path_.dirname)(configPath), {}, configPath);
+    if (parsedConfig.errors.length > 0) throw new Error(`Failed to parse tsconfig: ${parsedConfig.errors.map((err)=>formatDiagnostic(err, createCompilerHost({}, true))).join("\n")}`);
+    return parsedConfig;
+}
+function runTsgo(options) {
+    const { configPath, declarationDir, rootDir, tsBuildInfoFile, name } = options;
+    const tsgoBinPath = getTsgoBinPath();
+    const args = generateTsgoArgs({
+        configPath,
+        declarationDir,
+        rootDir,
+        tsBuildInfoFile
+    });
+    return new Promise((resolve)=>{
+        const child = spawn(tsgoBinPath, args, {
+            stdio: [
+                "inherit",
+                "pipe",
+                "pipe"
+            ],
+            shell: false
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout?.on("data", (data)=>{
+            const text = data.toString();
+            stdout += text;
+            core_logger.info(`${picocolors.dim(`[${name}]`)} ${text.trim()}`);
+        });
+        child.stderr?.on("data", (data)=>{
+            const text = data.toString();
+            stderr += text;
+            core_logger.error(`${picocolors.dim(`[${name}]`)} ${picocolors.red(text.trim())}`);
+        });
+        child.on("close", (code)=>{
+            const output = stdout + stderr;
+            resolve({
+                success: 0 === code,
+                output
+            });
+        });
+        child.on("error", (err)=>{
+            core_logger.error(`Failed to spawn tsgo: ${err.message}`);
+            resolve({
+                success: false,
+                output: err.message
+            });
+        });
+    });
+}
+/* v8 ignore next -- @preserve */ const DtsPlugin = (options = {})=>{
+    const { abortOnError = true, dtsExtension = ".d.ts" } = options;
+    const state = {
+        tsconfigPath: null,
+        parsedConfig: null
+    };
+    return {
+        name: "dts-plugin",
+        setup (api) {
+            api.modifyRsbuildConfig(async (config)=>{
+                const log = createEnvLogger("dts");
+                const cwd = api.context.rootPath;
+                try {
+                    let configTsconfigPath = options.tsconfigPath || config.source?.tsconfigPath;
+                    if (!configTsconfigPath && options.buildTarget) {
+                        const originalCwd = process.cwd();
+                        try {
+                            process.chdir(cwd);
+                            configTsconfigPath = TSConfigs.node.ecma.lib.writeBundleTempConfig(options.buildTarget);
+                            log.global.info(`Using tsconfig: ${configTsconfigPath}`);
+                        } finally{
+                            process.chdir(originalCwd);
+                        }
+                    }
+                    state.tsconfigPath = findTsConfig(cwd, configTsconfigPath);
+                    if (!state.tsconfigPath) {
+                        const error = new Error(`Failed to resolve tsconfig file ${picocolors.cyan(`"${config.source?.tsconfigPath ?? "tsconfig.json"}"`)} from ${picocolors.cyan(cwd)}. Please ensure that the file exists.`);
+                        error.stack = "";
+                        throw error;
+                    }
+                    state.parsedConfig = loadTsConfig(state.tsconfigPath);
+                    log.global.info(`Using tsconfig: ${picocolors.cyan((0, external_node_path_.relative)(cwd, state.tsconfigPath))}`);
+                } catch (error) {
+                    log.global.error("Failed to initialize DTS plugin:", error);
+                    throw error;
+                }
+                return config;
+            });
+            api.processAssets({
+                stage: "pre-process"
+            }, async (context)=>{
+                if (!state.tsconfigPath || !state.parsedConfig) return void core_logger.warn("DTS plugin not properly initialized, skipping declaration generation");
+                const envId = context.compilation?.name || "unknown";
+                const log = createEnvLogger(envId);
+                const cwd = api.context.rootPath;
+                const tempDtsDir = await ensureTempDeclarationDir(cwd, envId);
+                const filesArray = api.useExposed("files-array");
+                try {
+                    core_logger.info(`${picocolors.dim(`[${envId}]`)} Generating declaration files...`);
+                    const { success, output } = await runTsgo({
+                        configPath: state.tsconfigPath,
+                        declarationDir: tempDtsDir,
+                        rootDir: state.parsedConfig.options.rootDir,
+                        tsBuildInfoFile: state.parsedConfig.options.tsBuildInfoFile,
+                        name: envId
+                    });
+                    if (!success) {
+                        const errorMsg = `TypeScript declaration generation failed:\n${output}`;
+                        if (abortOnError) throw new Error(errorMsg);
+                        log.global.error(errorMsg);
+                        log.global.warn("With `abortOnError` disabled, type errors will not fail the build, but proper type declaration output cannot be guaranteed.");
+                        return;
+                    }
+                    const allDtsFiles = await collectDtsFiles(tempDtsDir);
+                    const apiExtractorMapping = api.useExposed("api-extractor-temp-mapping");
+                    if (apiExtractorMapping) {
+                        const tempFileRelative = (0, external_node_path_.relative)(cwd, apiExtractorMapping.tempPath);
+                        for (const file of allDtsFiles){
+                            const expectedPath = tempFileRelative.replace(/\.ts$/, ".d.ts");
+                            const expectedMapPath = `${expectedPath}.map`;
+                            if (file.relativePath === expectedPath || file.relativePath === expectedMapPath) {
+                                const ext = file.relativePath.endsWith(".map") ? ".d.ts.map" : ".d.ts";
+                                const originalDtsPath = apiExtractorMapping.originalPath.replace(/\.ts$/, ext);
+                                const newPath = (0, external_node_path_.join)(tempDtsDir, originalDtsPath);
+                                await mkdir((0, external_node_path_.dirname)(newPath), {
+                                    recursive: true
+                                });
+                                await copyFile(file.path, newPath);
+                                log.global.info(`Renamed ${file.relativePath} -> ${originalDtsPath} (from temp api-extractor)`);
+                                await unlink(file.path);
+                            }
+                        }
+                        allDtsFiles.length = 0;
+                        allDtsFiles.push(...await collectDtsFiles(tempDtsDir));
+                    }
+                    const dtsFiles = allDtsFiles.filter((file)=>{
+                        const path = file.relativePath;
+                        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 {
+                        const exposedPackageJson = api.useExposed("api-extractor-package-json");
+                        let packageJson;
+                        if (exposedPackageJson) {
+                            log.global.info("Using in-memory package.json from api-report-plugin");
+                            packageJson = exposedPackageJson;
+                        } else {
+                            const packageJsonPath = (0, external_node_path_.join)(cwd, "package.json");
+                            const packageJsonContent = await promises_readFile(packageJsonPath, "utf-8");
+                            packageJson = JSON.parse(packageJsonContent);
+                        }
+                        const entryPoints = new Map();
+                        if (packageJson.exports) {
+                            const exports = packageJson.exports;
+                            const mainExport = exports["."];
+                            if (mainExport) {
+                                const sourcePath = "string" == typeof mainExport ? mainExport : mainExport?.default;
+                                if (sourcePath && "string" == typeof sourcePath) {
+                                    if (sourcePath.match(/\.(ts|mts|cts|tsx)$/)) {
+                                        if (!sourcePath.includes(".test.") && !sourcePath.includes("__test__")) {
+                                            const resolvedSourcePath = sourcePath.startsWith(".") ? (0, external_node_path_.join)(cwd, sourcePath) : sourcePath;
+                                            if (resolvedSourcePath.startsWith(cwd)) {
+                                                let finalSourcePath = sourcePath;
+                                                if (apiExtractorMapping && resolvedSourcePath === apiExtractorMapping.tempPath) {
+                                                    finalSourcePath = apiExtractorMapping.originalPath;
+                                                    log.global.info(`Using original path for api-extractor: ${finalSourcePath}`);
+                                                }
+                                                entryPoints.set("index", finalSourcePath);
+                                            } else log.global.info(`Skipping main export (source outside package: ${sourcePath})`);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        if (0 === entryPoints.size) log.global.warn("No main export found in package.json exports, skipping bundling");
+                        else {
+                            const tempBundledDir = (0, external_node_path_.join)(tempDtsDir, "bundled");
+                            await mkdir(tempBundledDir, {
+                                recursive: true
+                            });
+                            const { bundledFiles, apiModelPath } = await bundleDtsFiles({
+                                cwd,
+                                tempDtsDir,
+                                tempOutputDir: tempBundledDir,
+                                tsconfigPath: state.tsconfigPath,
+                                bundledPackages: options.bundledPackages || [],
+                                entryPoints,
+                                banner: options.banner,
+                                footer: options.footer,
+                                apiModel: options.apiModel
+                            });
+                            let emittedCount = 0;
+                            for (const [entryName, tempBundledPath] of bundledFiles){
+                                const bundledFileName = `${entryName}.d.ts`;
+                                let content = await promises_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`);
+                            if (apiModelPath) {
+                                const apiModelFilename = "object" == typeof options.apiModel && options.apiModel.filename ? options.apiModel.filename : "api.model.json";
+                                const apiModelContent = await promises_readFile(apiModelPath, "utf-8");
+                                const apiModelSource = new context.sources.OriginalSource(apiModelContent, apiModelFilename);
+                                context.compilation.emitAsset(apiModelFilename, apiModelSource);
+                                if (filesArray) filesArray.add(apiModelFilename);
+                                core_logger.info(`${picocolors.dim(`[${envId}]`)} Emitted API model: ${apiModelFilename}`);
+                                const shouldAddNpmIgnore = true === options.apiModel || "object" == typeof options.apiModel && false !== options.apiModel.npmIgnore;
+                                if (shouldAddNpmIgnore) {
+                                    const npmIgnoreContent = `# Exclude API model from npm publish (used by internal tooling)\n${apiModelFilename}\n`;
+                                    const npmIgnoreSource = new context.sources.OriginalSource(npmIgnoreContent, ".npmignore");
+                                    context.compilation.emitAsset(".npmignore", npmIgnoreSource);
+                                    if (filesArray) filesArray.add(".npmignore");
+                                    core_logger.info(`${picocolors.dim(`[${envId}]`)} Emitted .npmignore to exclude ${apiModelFilename}`);
+                                }
+                                const isCI = "true" === process.env.GITHUB_ACTIONS || "true" === process.env.CI;
+                                const localPaths = "object" == typeof options.apiModel ? options.apiModel.localPaths : void 0;
+                                if (localPaths && localPaths.length > 0 && !isCI) for (const localPath of localPaths){
+                                    const resolvedPath = (0, external_node_path_.join)(cwd, localPath);
+                                    const parentDir = (0, external_node_path_.dirname)(resolvedPath);
+                                    if (!existsSync(parentDir)) {
+                                        core_logger.warn(`${picocolors.dim(`[${envId}]`)} Skipping local path: parent directory does not exist: ${parentDir}`);
+                                        continue;
+                                    }
+                                    await mkdir(resolvedPath, {
+                                        recursive: true
+                                    });
+                                    const apiModelDestPath = (0, external_node_path_.join)(resolvedPath, apiModelFilename);
+                                    await writeFile(apiModelDestPath, apiModelContent, "utf-8");
+                                    const packageJsonAsset = context.compilation.assets["package.json"];
+                                    if (packageJsonAsset) {
+                                        const rawContent = "function" == typeof packageJsonAsset.source ? packageJsonAsset.source() : packageJsonAsset.source;
+                                        const packageJsonContent = "string" == typeof rawContent ? rawContent : rawContent instanceof Buffer ? rawContent.toString("utf-8") : String(rawContent);
+                                        const packageJsonDestPath = (0, external_node_path_.join)(resolvedPath, "package.json");
+                                        await writeFile(packageJsonDestPath, packageJsonContent, "utf-8");
+                                    }
+                                    core_logger.info(`${picocolors.dim(`[${envId}]`)} Copied API model and package.json to: ${localPath}`);
+                                }
+                            }
+                            for (const [entryName] of bundledFiles){
+                                const bundledFileName = `${entryName}.d.ts`;
+                                const mapFileName = `${bundledFileName}.map`;
+                                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 mapFileName = `${outputPath}.map`;
+                                    if (context.compilation.assets[mapFileName]) delete context.compilation.assets[mapFileName];
+                                }
+                                if (context.compilation.assets[mapFileName]) delete context.compilation.assets[mapFileName];
+                            }
+                        }
+                    } catch (error) {
+                        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 promises_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;
+                }
+            });
+            api.processAssets({
+                stage: "summarize"
+            }, async (compiler)=>{
+                const assetsToDelete = [];
+                for(const assetName in compiler.compilation.assets)if (assetName.endsWith(".d.ts")) {
+                    const asset = compiler.compilation.assets[assetName];
+                    const content = asset.source().toString();
+                    const strippedContent = stripSourceMapComment(content);
+                    if (strippedContent !== content) {
+                        const source = new compiler.sources.OriginalSource(strippedContent, assetName);
+                        compiler.compilation.assets[assetName] = source;
+                    }
+                } else if (assetName.endsWith(".d.ts.map")) assetsToDelete.push(assetName);
+                for (const assetName of assetsToDelete)delete compiler.compilation.assets[assetName];
+            });
+        }
+    };
+};
+class TextAsset {
+    compiler;
+    _fileName;
+    asset;
+    source;
+    constructor(compiler, _fileName){
+        this.compiler = compiler;
+        this._fileName = _fileName;
+        this.asset = compiler.assets[_fileName];
+        this.source = this.asset.source().toString();
+    }
+    get fileName() {
+        return this._fileName;
+    }
+    update() {
+        const updatedSource = new this.compiler.sources.RawSource(this.source);
+        this.compiler.compilation.updateAsset(this.fileName, updatedSource);
+    }
+    static async create(context, fileName, required = true) {
+        let asset = context.assets[fileName];
+        if (asset) return new TextAsset(context, fileName);
+        try {
+            const filePath = (0, external_node_path_.join)(process.cwd(), fileName);
+            const content = await promises_readFile(filePath, "utf-8");
+            const source = new context.sources.RawSource(content);
+            context.compilation.emitAsset(fileName, source);
+            asset = source;
+            return new TextAsset(context, fileName);
+        } catch (error) {
+            if (required) throw new Error(`Failed to load text asset: ${fileName}: ${error instanceof Error ? error.message : String(error)}`);
+            return null;
+        }
+    }
+}
+class JsonAsset extends TextAsset {
+    data;
+    constructor(compiler, fileName){
+        super(compiler, fileName);
+        try {
+            this.data = JSON.parse(this.source);
+        } catch (error) {
+            throw new Error(`Failed to parse JSON in ${fileName}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    update() {
+        this.source = JSON.stringify(this.data, null, "\t");
+        super.update();
+    }
+    static async create(context, fileName, required = false) {
+        let asset = context.assets[fileName];
+        if (asset) return new JsonAsset(context, fileName);
+        try {
+            const filePath = (0, external_node_path_.join)(process.cwd(), fileName);
+            const content = await promises_readFile(filePath, "utf-8");
+            const source = new context.sources.RawSource(content);
+            context.compilation.emitAsset(fileName, source);
+            asset = source;
+            return new JsonAsset(context, fileName);
+        } catch (err) {
+            if (required) throw new Error(`Failed to load JSON asset: ${fileName}: ${err instanceof Error ? err.message : String(err)}`);
+            return null;
+        }
+    }
+}
+const FilesArrayPlugin = (options)=>({
+        name: "files-array-plugin",
+        post: [
+            "rsbuild:dts"
+        ],
+        setup (api) {
+            let filesArray = api.useExposed("files-array");
+            if (!filesArray) {
+                filesArray = new Set();
+                api.expose("files-array", filesArray);
+            }
+            api.processAssets({
+                stage: "additional"
+            }, async (context)=>{
+                const packageJson = await JsonAsset.create(context, "package.json", false);
+                if (packageJson) filesArray.add(packageJson.fileName);
+                const readme = await TextAsset.create(context, "README.md", false);
+                if (readme) filesArray.add(readme.fileName);
+                const license = await TextAsset.create(context, "LICENSE", false);
+                if (license) filesArray.add(license.fileName);
+                for (const assetName of Object.keys(context.compilation.assets))if (!assetName.endsWith(".map") && !filesArray.has(assetName)) filesArray.add(assetName);
+                if (options?.transformFiles) await options.transformFiles({
+                    compilation: context.compilation,
+                    filesArray,
+                    target: options.target
+                });
+            });
+            api.processAssets({
+                stage: "optimize-inline"
+            }, async (context)=>{
+                const envId = context.compilation?.name || context.compilation?.options?.name || "unknown";
+                const log = createEnvLogger(envId);
+                const packageJson = await JsonAsset.create(context, "package.json", false);
+                if (packageJson) {
+                    const previousFiles = new Set(packageJson.data.files || []);
+                    const allFiles = new Set([
+                        ...previousFiles,
+                        ...Array.from(filesArray)
+                    ].sort());
+                    if (0 === allFiles.size) delete packageJson.data.files;
+                    else {
+                        const newFiles = new Set([
+                            ...allFiles
+                        ].filter((file)=>!previousFiles.has(file)));
+                        if (newFiles.size > 0) log.fileOp("added to files array", Array.from(newFiles));
+                    }
+                    packageJson.data.files = Array.from(allFiles);
+                    packageJson.update();
+                }
+            });
+        }
+    });
+const CATALOG_PREFIX = "catalog:";
+const WORKSPACE_PREFIX = "workspace:";
+class PnpmCatalog {
+    catalogCache = null;
+    catalogCacheMtime = null;
+    cachedWorkspaceRoot = null;
+    clearCache() {
+        this.catalogCache = null;
+        this.catalogCacheMtime = null;
+        this.cachedWorkspaceRoot = null;
+    }
+    async getCatalog() {
+        try {
+            if (!this.cachedWorkspaceRoot) {
+                this.cachedWorkspaceRoot = getWorkspaceRoot(process.cwd());
+                if (!this.cachedWorkspaceRoot) throw new Error("Could not find workspace root - ensure you're in a workspace");
+            }
+            const workspaceFile = (0, external_node_path_.resolve)(this.cachedWorkspaceRoot, "pnpm-workspace.yaml");
+            const stats = await promises_stat(workspaceFile);
+            const currentMtime = stats.mtime.getTime();
+            if (null !== this.catalogCache && this.catalogCacheMtime === currentMtime) return this.catalogCache;
+            const content = await promises_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);
+            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}`);
+            return {};
+        }
+    }
+    async resolvePackageJson(packageJson, dir = process.cwd()) {
+        const logger = createEnvLogger("pnpm");
+        try {
+            const catalog = await this.getCatalog();
+            const catalogDeps = this.collectDependencies(packageJson, CATALOG_PREFIX);
+            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) 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
+                }
+            });
+            if (hasCatalogDeps || hasWorkspaceDeps) this.logResolvedDependencies(result, [
+                ...catalogDeps,
+                ...workspaceDeps
+            ], 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.includes("catalog")) {
+                logger.error(`  -> Catalog resolution failed - check workspace configuration and ${CATALOG_PREFIX} dependencies`);
+                throw new Error("Catalog resolution failed");
+            }
+            if (errorMessage.includes("workspace")) {
+                logger.error(`  -> Workspace resolution failed - check ${WORKSPACE_PREFIX} dependencies and configuration`);
+                throw new Error("Workspace resolution failed");
+            }
+            if (errorMessage.includes("manifest")) {
+                logger.error("  -> Manifest processing failed - check package.json syntax");
+                throw new Error(`Manifest processing failed: ${errorMessage}`);
+            }
+            logger.error("  -> Cannot proceed with invalid package.json transformations");
+            throw new Error(`PNPM transformation failed: ${errorMessage}`);
+        }
+    }
+    collectDependencies(packageJson, prefix) {
+        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(prefix)) deps.push({
+                    field,
+                    dependency,
+                    version
+                });
+            }
+        }
+        return deps;
+    }
+    logResolvedDependencies(resultPkg, originalDeps, logger) {
+        const allResolved = {};
+        for (const { field, dependency } of originalDeps){
+            const deps = resultPkg[field];
+            if (deps?.[dependency]) {
+                if (!allResolved[field]) allResolved[field] = [];
+                allResolved[field].push({
+                    dependency,
+                    version: deps[dependency]
+                });
+            }
+        }
+        if (Object.keys(allResolved).length > 0) {
+            logger.info("Resolved dependencies:");
+            for (const [field, deps] of Object.entries(allResolved)){
+                logger.info(`- ${field}:`);
+                for (const { dependency, version } of deps)logger.info(`    ${dependency}: ${version}`);
+            }
+        }
+    }
+    validateNoUnresolvedReferences(resultPkg, logger) {
+        const unresolvedDeps = [
+            ...this.collectDependencies(resultPkg, CATALOG_PREFIX),
+            ...this.collectDependencies(resultPkg, WORKSPACE_PREFIX)
+        ];
+        if (unresolvedDeps.length > 0) {
+            const catalogRefs = unresolvedDeps.filter((dep)=>dep.version.startsWith(CATALOG_PREFIX));
+            const workspaceRefs = unresolvedDeps.filter((dep)=>dep.version.startsWith(WORKSPACE_PREFIX));
+            const refTypes = [];
+            if (catalogRefs.length > 0) refTypes.push(CATALOG_PREFIX);
+            if (workspaceRefs.length > 0) refTypes.push(WORKSPACE_PREFIX);
+            const error = `Transformation failed: unresolved ${refTypes.join(" and ")} references remain in package.json`;
+            logger.error(error);
+            logger.error("  -> This would result in invalid package.json being published to npm");
+            logger.error("  -> Unresolved dependencies:");
+            for (const { field, dependency, version } of unresolvedDeps)logger.error(`    - ${field}.${dependency}: ${version}`);
+            throw new Error(error);
+        }
+    }
+}
+let defaultInstance = null;
+function getDefaultPnpmCatalog() {
+    if (!defaultInstance) defaultInstance = new PnpmCatalog();
+    return defaultInstance;
+}
+class PackageJsonTransformer {
+    options;
+    pnpmCatalog;
+    constructor(options = {}){
+        this.options = {
+            processTSExports: options.processTSExports ?? true,
+            collapseIndex: options.collapseIndex ?? false,
+            entrypoints: options.entrypoints ?? new Map(),
+            exportToOutputMap: options.exportToOutputMap ?? new Map()
+        };
+        this.pnpmCatalog = new PnpmCatalog();
+    }
+    transformExportPath(path) {
+        let transformedPath = path;
+        if (transformedPath.startsWith("./exports/")) transformedPath = `./${transformedPath.slice(10)}`;
+        else if (transformedPath.startsWith("./public/")) transformedPath = `./${transformedPath.slice(9)}`;
+        else if (transformedPath.startsWith("./src/")) transformedPath = `./${transformedPath.slice(6)}`;
+        if (this.options.processTSExports) {
+            const { collapseIndex } = this.options;
+            if (collapseIndex && transformedPath.endsWith("/index.ts") && "./index.ts" !== transformedPath) transformedPath = `${transformedPath.slice(0, -9)}.js`;
+            else if (collapseIndex && transformedPath.endsWith("/index.tsx") && "./index.tsx" !== transformedPath) transformedPath = `${transformedPath.slice(0, -10)}.js`;
+            else if (transformedPath.endsWith(".tsx")) transformedPath = `${transformedPath.slice(0, -4)}.js`;
+            else if (transformedPath.endsWith(".ts") && !transformedPath.endsWith(".d.ts")) transformedPath = `${transformedPath.slice(0, -3)}.js`;
+        }
+        return transformedPath;
+    }
+    createTypePath(jsPath) {
+        const { collapseIndex } = this.options;
+        if (collapseIndex && jsPath.endsWith("/index.js") && "./index.js" !== jsPath) return `${jsPath.slice(0, -9)}.d.ts`;
+        if (jsPath.endsWith(".js")) return `${jsPath.slice(0, -3)}.d.ts`;
+        return `${jsPath}.d.ts`;
+    }
+    transformExports(exports, exportKey) {
+        if ("string" == typeof exports) return this.transformStringExport(exports, exportKey);
+        if (Array.isArray(exports)) return exports.map((item)=>{
+            const transformed = this.transformExports(item, exportKey);
+            return transformed ?? item;
+        });
+        if (exports && "object" == typeof exports) return this.transformObjectExports(exports, exportKey);
+        return exports;
+    }
+    transformBin(bin) {
+        if ("string" == typeof bin) return this.transformExportPath(bin);
+        if (bin && "object" == typeof bin) {
+            const transformed = {};
+            for (const [command, path] of Object.entries(bin))if (void 0 !== path) transformed[command] = this.transformExportPath(path);
+            return transformed;
+        }
+        return bin;
+    }
+    async transform(packageJson, context = {}) {
+        const { isProduction = false, customTransform } = context;
+        let result;
+        if (isProduction) {
+            const pnpmTransformed = await this.applyPnpmTransformations(packageJson);
+            result = this.applyRslibTransformations(pnpmTransformed, packageJson);
+        } else result = this.applyRslibTransformations(packageJson, packageJson);
+        if (customTransform) result = customTransform(result);
+        return result;
+    }
+    async applyPnpmTransformations(packageJson) {
+        return this.pnpmCatalog.resolvePackageJson(packageJson);
+    }
+    applyRslibTransformations(packageJson, originalPackageJson) {
+        const { publishConfig, scripts, ...rest } = packageJson;
+        let isPrivate = true;
+        if (originalPackageJson.publishConfig?.access === "public") isPrivate = false;
+        const processedManifest = {
+            ...rest,
+            private: isPrivate
+        };
+        if (processedManifest.exports) processedManifest.exports = this.transformExports(processedManifest.exports);
+        if (processedManifest.bin) processedManifest.bin = this.transformBin(processedManifest.bin);
+        if (originalPackageJson.typesVersions) {
+            const transformedTypesVersions = {};
+            for (const [version, paths] of Object.entries(originalPackageJson.typesVersions)){
+                const transformedPaths = {};
+                for (const [key, value] of Object.entries(paths))transformedPaths[key] = value.map((path)=>this.transformExportPath(path));
+                transformedTypesVersions[version] = transformedPaths;
+            }
+            processedManifest.typesVersions = transformedTypesVersions;
+        }
+        if (originalPackageJson.files) processedManifest.files = originalPackageJson.files.map((file)=>{
+            let transformedFile = file.startsWith("./") ? file.slice(2) : file;
+            if (transformedFile.startsWith("public/")) transformedFile = transformedFile.slice(7);
+            return transformedFile;
+        });
+        return sort_package_json(processedManifest);
+    }
+    transformStringExport(exportString, exportKey) {
+        const { entrypoints, exportToOutputMap, processTSExports } = this.options;
+        let transformedPath;
+        if (exportToOutputMap.size > 0 && exportKey && exportToOutputMap.has(exportKey)) {
+            const mappedPath = exportToOutputMap.get(exportKey);
+            if (!mappedPath) throw new Error(`Export key "${exportKey}" has no mapped path`);
+            transformedPath = mappedPath;
+        } else if (entrypoints.size > 0 && exportKey) {
+            const keyWithoutPrefix = exportKey.startsWith("./") ? exportKey.slice(2) : exportKey;
+            transformedPath = entrypoints.has(exportKey) ? entrypoints.get(exportKey) ?? exportString : entrypoints.has(keyWithoutPrefix) ? entrypoints.get(keyWithoutPrefix) ?? exportString : this.transformExportPath(exportString);
+        } else transformedPath = this.transformExportPath(exportString);
+        if (processTSExports && (exportString.endsWith(".ts") || exportString.endsWith(".tsx")) && !exportString.endsWith(".d.ts")) return {
+            types: this.createTypePath(transformedPath),
+            import: transformedPath
+        };
+        return transformedPath;
+    }
+    transformObjectExports(exportsObject, exportKey) {
+        const transformed = {};
+        const isConditions = this.isConditionsObject(exportsObject);
+        for (const [key, value] of Object.entries(exportsObject))transformed[key] = this.transformExportEntry(key, value, isConditions, exportKey);
+        return transformed;
+    }
+    isConditionsObject(exports) {
+        return Object.keys(exports).some((key)=>"import" === key || "require" === key || "types" === key || "default" === key);
+    }
+    transformExportEntry(key, value, isConditions, exportKey) {
+        if (isConditions && ("import" === key || "require" === key || "types" === key || "default" === key)) {
+            if ("string" == typeof value) return this.transformExportPath(value);
+            if (null != value) return this.transformExports(value, exportKey);
+            return value;
+        }
+        if (null != value) return this.transformExports(value, key);
+        return value;
+    }
+}
+function transformExportPath(path, processTSExports = true, collapseIndex = false) {
+    let transformedPath = path;
+    if (transformedPath.startsWith("./exports/")) transformedPath = `./${transformedPath.slice(10)}`;
+    else if (transformedPath.startsWith("./public/")) transformedPath = `./${transformedPath.slice(9)}`;
+    else if (transformedPath.startsWith("./src/")) transformedPath = `./${transformedPath.slice(6)}`;
+    if (processTSExports) {
+        if (collapseIndex && transformedPath.endsWith("/index.ts") && "./index.ts" !== transformedPath) transformedPath = `${transformedPath.slice(0, -9)}.js`;
+        else if (collapseIndex && transformedPath.endsWith("/index.tsx") && "./index.tsx" !== transformedPath) transformedPath = `${transformedPath.slice(0, -10)}.js`;
+        else if (transformedPath.endsWith(".tsx")) transformedPath = `${transformedPath.slice(0, -4)}.js`;
+        else if (transformedPath.endsWith(".ts") && !transformedPath.endsWith(".d.ts")) transformedPath = `${transformedPath.slice(0, -3)}.js`;
+    }
+    return transformedPath;
+}
+function createTypePath(jsPath, collapseIndex = true) {
+    if (collapseIndex && jsPath.endsWith("/index.js") && "./index.js" !== jsPath) return `${jsPath.slice(0, -9)}.d.ts`;
+    if (jsPath.endsWith(".js")) return `${jsPath.slice(0, -3)}.d.ts`;
+    return `${jsPath}.d.ts`;
+}
+function transformPackageBin(bin, processTSExports = true) {
+    if ("string" == typeof bin) return transformExportPath(bin, processTSExports);
+    if (bin && "object" == typeof bin) {
+        const transformed = {};
+        for (const [command, path] of Object.entries(bin))if (void 0 !== path) transformed[command] = transformExportPath(path, processTSExports);
+        return transformed;
+    }
+    return bin;
+}
+function isConditionsObject(exports) {
+    return Object.keys(exports).some((key)=>"import" === key || "require" === key || "types" === key || "default" === key);
+}
+function transformPackageExports(exports, processTSExports = true, exportKey, entrypoints, exportToOutputMap, collapseIndex = false) {
+    if ("string" == typeof exports) return transformStringExport(exports, processTSExports, exportKey, entrypoints, exportToOutputMap, collapseIndex);
+    if (Array.isArray(exports)) return exports.map((item)=>{
+        const transformed = transformPackageExports(item, processTSExports, exportKey, entrypoints, exportToOutputMap, collapseIndex);
+        return transformed ?? item;
+    });
+    if (exports && "object" == typeof exports) return transformObjectExports(exports, processTSExports, exportKey, entrypoints, exportToOutputMap, collapseIndex);
+    /* v8 ignore next -- @preserve */ return exports;
+}
+function transformStringExport(exportString, processTSExports, exportKey, entrypoints, exportToOutputMap, collapseIndex = false) {
+    let transformedPath;
+    if (exportToOutputMap && exportKey && exportToOutputMap.has(exportKey)) {
+        const mappedPath = exportToOutputMap.get(exportKey);
+        if (!mappedPath) throw new Error(`Export key "${exportKey}" has no mapped path`);
+        transformedPath = mappedPath;
+    } else if (entrypoints && exportKey) {
+        const keyWithoutPrefix = exportKey.startsWith("./") ? exportKey.slice(2) : exportKey;
+        transformedPath = entrypoints.has(exportKey) ? entrypoints.get(exportKey) ?? exportString : entrypoints.has(keyWithoutPrefix) ? entrypoints.get(keyWithoutPrefix) ?? exportString : transformExportPath(exportString, processTSExports, collapseIndex);
+    } else transformedPath = transformExportPath(exportString, processTSExports, collapseIndex);
+    if (processTSExports && (exportString.endsWith(".ts") || exportString.endsWith(".tsx")) && !exportString.endsWith(".d.ts")) return {
+        types: createTypePath(transformedPath, collapseIndex),
+        import: transformedPath
+    };
+    return transformedPath;
+}
+function transformObjectExports(exportsObject, processTSExports, exportKey, entrypoints, exportToOutputMap, collapseIndex = false) {
+    const transformed = {};
+    const isConditions = isConditionsObject(exportsObject);
+    for (const [key, value] of Object.entries(exportsObject))transformed[key] = transformExportEntry(key, value, isConditions, processTSExports, exportKey, entrypoints, exportToOutputMap, collapseIndex);
+    return transformed;
+}
+function transformExportEntry(key, value, isConditions, processTSExports, exportKey, entrypoints, exportToOutputMap, collapseIndex = false) {
+    if (isConditions && ("import" === key || "require" === key || "types" === key || "default" === key)) {
+        if ("string" == typeof value) return transformExportPath(value, processTSExports, collapseIndex);
+        if (null != value) return transformPackageExports(value, processTSExports, exportKey, entrypoints, exportToOutputMap, collapseIndex);
+        return value;
+    }
+    if (null != value) return transformPackageExports(value, processTSExports, key, entrypoints, exportToOutputMap, collapseIndex);
+    return value;
+}
+function applyRslibTransformations(packageJson, originalPackageJson, processTSExports = true, entrypoints, exportToOutputMap, bundle) {
+    const { publishConfig, scripts, ...rest } = packageJson;
+    let isPrivate = true;
+    if (originalPackageJson.publishConfig?.access === "public") isPrivate = false;
+    const processedManifest = {
+        ...rest,
+        private: isPrivate
+    };
+    if (processedManifest.exports) processedManifest.exports = transformPackageExports(processedManifest.exports, processTSExports, void 0, entrypoints, exportToOutputMap, bundle ?? false);
+    if (processedManifest.bin) processedManifest.bin = transformPackageBin(processedManifest.bin, processTSExports);
+    if (originalPackageJson.typesVersions) {
+        const transformedTypesVersions = {};
+        for (const [version, paths] of Object.entries(originalPackageJson.typesVersions)){
+            const transformedPaths = {};
+            for (const [key, value] of Object.entries(paths))transformedPaths[key] = value.map((path)=>transformExportPath(path, processTSExports, bundle ?? false));
+            transformedTypesVersions[version] = transformedPaths;
+        }
+        processedManifest.typesVersions = transformedTypesVersions;
+    }
+    if (originalPackageJson.files) processedManifest.files = originalPackageJson.files.map((file)=>{
+        let transformedFile = file.startsWith("./") ? file.slice(2) : file;
+        if (transformedFile.startsWith("public/")) transformedFile = transformedFile.slice(7);
+        return transformedFile;
+    });
+    return sort_package_json(processedManifest);
+}
+async function applyPnpmTransformations(packageJson, dir = process.cwd()) {
+    return getDefaultPnpmCatalog().resolvePackageJson(packageJson, dir);
+}
+async function buildPackageJson(packageJson, isProduction = false, processTSExports = true, entrypoints, exportToOutputMap, bundle, transform) {
+    let result;
+    if (isProduction) {
+        const pnpmTransformed = await applyPnpmTransformations(packageJson);
+        result = applyRslibTransformations(pnpmTransformed, packageJson, processTSExports, entrypoints, exportToOutputMap, bundle);
+    } else result = applyRslibTransformations(packageJson, packageJson, processTSExports, entrypoints, exportToOutputMap, bundle);
+    if (transform) result = transform(result);
+    return result;
+}
+const PackageJsonTransformPlugin = (options = {})=>{
+    const cache = new Map();
+    return {
+        name: "package-json-processor",
+        setup (api) {
+            api.expose("files-cache", cache);
+            let filesArray = api.useExposed("files-array");
+            if (!filesArray) {
+                filesArray = new Set();
+                api.expose("files-array", filesArray);
+            }
+            api.processAssets({
+                stage: "pre-process"
+            }, async (context)=>{
+                const packageJson = await JsonAsset.create(context, "package.json", true);
+                if (packageJson) filesArray.add(packageJson.fileName);
+                const readme = await TextAsset.create(context, "README.md", false);
+                if (readme) filesArray.add(readme.fileName);
+                const license = await TextAsset.create(context, "LICENSE", false);
+                if (license) filesArray.add(license.fileName);
+            });
+            api.processAssets({
+                stage: "optimize"
+            }, async (context)=>{
+                const packageJson = await JsonAsset.create(context, "package.json", true);
+                if (!packageJson) return;
+                const envId = context.compilation?.name || "unknown";
+                const isProduction = "dev" !== envId;
+                const entrypoints = api.useExposed("entrypoints");
+                const exportToOutputMap = api.useExposed("exportToOutputMap");
+                const processedPackageJson = await buildPackageJson(packageJson.data, isProduction, options.processTSExports, entrypoints, exportToOutputMap, options.bundle, options.transform);
+                packageJson.data = processedPackageJson;
+                if (options.forcePrivate) packageJson.data.private = true;
+                const useRollupTypes = api.useExposed("use-rollup-types");
+                if (useRollupTypes && packageJson.data.exports && "object" == typeof packageJson.data.exports) {
+                    const exports = packageJson.data.exports;
+                    delete exports["./api-extractor"];
+                    for (const [, value] of Object.entries(exports))if (value && "object" == typeof value && "types" in value) value.types = "./index.d.ts";
+                }
+                packageJson.update();
+            });
+            api.processAssets({
+                stage: "optimize-inline"
+            }, async (compiler)=>{
+                if (options.name && true !== options.name) {
+                    const packageJson = await JsonAsset.create(compiler, "package.json", true);
+                    if (packageJson) {
+                        packageJson.data.name = options.name;
+                        packageJson.update();
+                    }
+                }
+            });
+        }
+    };
+};
+/* v8 ignore next -- @preserve */ class NodeLibraryBuilder {
+    static DEFAULT_OPTIONS = {
+        entry: void 0,
+        plugins: [],
+        define: {},
+        copyPatterns: [],
+        targets: [
+            "dev",
+            "npm"
+        ],
+        tsconfigPath: void 0,
+        externals: [],
+        dtsBundledPackages: void 0,
+        transformFiles: void 0
+    };
+    static mergeOptions(options = {}) {
+        const merged = {
+            ...NodeLibraryBuilder.DEFAULT_OPTIONS,
+            ...options,
+            copyPatterns: [
+                ...options.copyPatterns ?? NodeLibraryBuilder.DEFAULT_OPTIONS.copyPatterns
+            ]
+        };
+        if (existsSync((0, external_node_path_.join)(process.cwd(), "public"))) merged.copyPatterns.unshift({
+            from: "./public",
+            to: "./",
+            context: process.cwd()
+        });
+        return merged;
+    }
+    static create(options = {}) {
+        const mergedOptions = NodeLibraryBuilder.mergeOptions(options);
+        return async ({ envMode })=>{
+            const target = envMode || "dev";
+            const validTargets = [
+                "dev",
+                "npm"
+            ];
+            if (!validTargets.includes(target)) throw new Error(`Invalid env-mode: "${target}". Must be one of: ${validTargets.join(", ")}\nExample: rslib build --env-mode npm`);
+            const targetConfig = await NodeLibraryBuilder.createSingleTarget(target, mergedOptions);
+            return targetConfig;
+        };
+    }
+    static async createSingleTarget(target, opts) {
+        const options = NodeLibraryBuilder.mergeOptions(opts);
+        const VERSION = await packageJsonVersion();
+        const plugins = [];
+        if ("dev" === target || "npm" === target) {
+            if (!options.entry) plugins.push(AutoEntryPlugin({
+                exportsAsIndexes: options.exportsAsIndexes
+            }));
+            const userTransform = options.transform;
+            const transformFn = userTransform ? (pkg)=>userTransform({
+                    target,
+                    pkg
+                }) : void 0;
+            plugins.push(PackageJsonTransformPlugin({
+                forcePrivate: "dev" === target,
+                bundle: true,
+                target,
+                transform: transformFn
+            }));
+            plugins.push(FilesArrayPlugin({
+                target,
+                transformFiles: options.transformFiles
+            }));
+        }
+        if (options.plugins) plugins.push(...options.plugins);
+        const outputDir = `dist/${target}`;
+        const entry = options.entry;
+        const apiModelForTarget = "npm" === target ? options.apiModel : void 0;
+        plugins.push(DtsPlugin({
+            tsconfigPath: options.tsconfigPath,
+            abortOnError: true,
+            bundle: true,
+            bundledPackages: options.dtsBundledPackages,
+            buildTarget: target,
+            apiModel: apiModelForTarget
+        }));
+        const lib = {
+            id: target,
+            outBase: outputDir,
+            output: {
+                target: "node",
+                module: true,
+                cleanDistPath: true,
+                sourceMap: "dev" === target,
+                distPath: {
+                    root: outputDir
+                },
+                copy: {
+                    patterns: options.copyPatterns
+                },
+                externals: options.externals && options.externals.length > 0 ? options.externals : void 0
+            },
+            format: "esm",
+            experiments: {
+                advancedEsm: true
+            },
+            bundle: true,
+            plugins,
+            source: {
+                tsconfigPath: options.tsconfigPath,
+                entry,
+                define: {
+                    "process.env.__PACKAGE_VERSION__": JSON.stringify(VERSION),
+                    ...options.define
+                }
+            }
+        };
+        return defineConfig({
+            lib: [
+                lib
+            ],
+            source: {
+                tsconfigPath: options.tsconfigPath
+            },
+            performance: {
+                buildCache: {
+                    cacheDirectory: `.rslib/cache/${target}`
+                }
+            }
+        });
+    }
+}
+export { AutoEntryPlugin, DtsPlugin, EntryExtractor, FilesArrayPlugin, NodeLibraryBuilder, PackageJsonTransformPlugin, PackageJsonTransformer, PnpmCatalog, collectDtsFiles, ensureTempDeclarationDir, findTsConfig, generateTsgoArgs, getTsgoBinPath, stripSourceMapComment };