tsdown 0.17.0-beta.3 → 0.17.0-beta.5

package/dist/{src-B28M8gGv.mjs → src-ipppZiPk.mjs}

@@ -1,27 +1,28 @@
 import { createRequire as __cjs_createRequire } from "node:module";
 const __cjs_require = __cjs_createRequire(import.meta.url);
-import { a as globalLogger, c as importWithError, d as pkgExists, f as resolveComma, h as toArray, i as generateColor, l as matchPattern, m as slash, n as LogLevels, o as prettyFormat, p as resolveRegex, r as createLogger, s as prettyName, t as version, u as noop } from "./package-C_EvEUSK.mjs";
+import { a as globalLogger, c as importWithError, d as pkgExists, f as promiseWithResolvers, g as toArray, h as slash, i as generateColor, l as matchPattern, m as resolveRegex, n as LogLevels, o as prettyFormat, p as resolveComma, r as createLogger, s as prettyName, t as version, u as noop } from "./package-CxZ5olT1.mjs";
 import { builtinModules, isBuiltin } from "node:module";
 import path, { dirname, join, normalize, sep } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { blue, bold, dim, green, underline } from "ansis";
+import { clearRequireCache, init, isSupported } from "import-without-cache";
 import { VERSION, build, watch } from "rolldown";
+import { createDebug } from "obug";
 import { access, chmod, cp, mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
 import process, { env } from "node:process";
-import { createDebug } from "obug";
 import { createConfigCoreLoader } from "unconfig-core";
 import { glob, isDynamicPattern } from "tinyglobby";
 import { RE_CSS, RE_DTS, RE_JS, RE_NODE_MODULES } from "rolldown-plugin-dts/filename";
 const minVersion = __cjs_require("semver/ranges/min-version.js");
 import { up } from "empathic/find";
 import { up as up$1 } from "empathic/package";
-import { tmpdir } from "node:os";
-import { exec } from "tinyexec";
 const coerce = __cjs_require("semver/functions/coerce.js");
 const satisfies = __cjs_require("semver/functions/satisfies.js");
 import { createHooks } from "hookable";
+import { exec } from "tinyexec";
 const treeKill = __cjs_require("tree-kill");
-import util, { promisify } from "node:util";
+import util, { formatWithOptions, promisify } from "node:util";
+import { tmpdir } from "node:os";
 import { importGlobPlugin } from "rolldown/experimental";
 import { Buffer } from "node:buffer";
 import { brotliCompress, gzip } from "node:zlib";
@@ -72,29 +73,27 @@ function lowestCommonAncestor(...filepaths) {
 }
 
 //#endregion
-//#region src/config/config.ts
-const debug$8 = createDebug("tsdown:config");
+//#region src/config/file.ts
+const debug$9 = createDebug("tsdown:config:file");
 async function loadViteConfig(prefix, cwd, configLoader) {
 	const loader = resolveConfigLoader(configLoader);
-	debug$8("Loading Vite config via loader: ", loader);
+	debug$9("Loading Vite config via loader: ", loader);
 	const parser = createParser(loader);
 	const [result] = await createConfigCoreLoader({
 		sources: [{
 			files: [`${prefix}.config`],
 			extensions: [
-				"ts",
-				"mts",
-				"cts",
 				"js",
 				"mjs",
+				"ts",
 				"cjs",
-				"json",
-				""
+				"mts",
+				"mts"
 			],
 			parser
 		}],
 		cwd
-	}).load();
+	}).load(true);
 	if (!result) return;
 	const { config, source } = result;
 	globalLogger.info(`Using Vite config: ${underline(source)}`);
@@ -106,10 +105,6 @@ async function loadViteConfig(prefix, cwd, configLoader) {
 	return resolved;
 }
 const configPrefix = "tsdown.config";
-let noCacheLoad = false;
-function setNoCacheLoad() {
-	noCacheLoad = true;
-}
 async function loadConfigFile(inlineConfig, workspace) {
 	let cwd = inlineConfig.cwd || process.cwd();
 	let overrideConfig = false;
@@ -127,7 +122,7 @@ async function loadConfigFile(inlineConfig, workspace) {
 		}
 	}
 	const loader = resolveConfigLoader(inlineConfig.configLoader);
-	debug$8("Using config loader:", loader);
+	debug$9("Using config loader:", loader);
 	const parser = createParser(loader);
 	const [result] = await createConfigCoreLoader({
 		sources: overrideConfig ? [{
@@ -143,8 +138,7 @@ async function loadConfigFile(inlineConfig, workspace) {
 				"js",
 				"mjs",
 				"cjs",
-				"json",
-				""
+				"json"
 			],
 			parser
 		}, {
@@ -153,12 +147,12 @@ async function loadConfigFile(inlineConfig, workspace) {
 		}],
 		cwd,
 		stopAt: workspace && path.dirname(workspace)
-	}).load(noCacheLoad);
+	}).load(true);
 	let exported = [];
 	let file;
 	if (result) {
 		({config: exported, source: file} = result);
-		globalLogger.info(`Using tsdown config: ${underline(file)}`);
+		globalLogger.info(`config file: ${underline(file)}`, loader === "native" ? "" : `(${loader})`);
 		exported = await exported;
 		if (typeof exported === "function") exported = await exported(inlineConfig, { ci: is_in_ci_default });
 	}
@@ -166,13 +160,18 @@ async function loadConfigFile(inlineConfig, workspace) {
 	if (exported.length === 0) exported.push({});
 	if (exported.some((config) => typeof config === "function")) throw new Error("Function should not be nested within multiple tsdown configurations. It must be at the top level.\nExample: export default defineConfig(() => [...])");
 	return {
-		configs: exported,
+		configs: exported.map((config) => ({
+			cwd,
+			...config
+		})),
 		file
 	};
 }
+const isBun = !!process.versions.bun;
+const nativeTS = process.features.typescript || process.versions.deno;
+const autoLoader = isBun || nativeTS && isSupported ? "native" : "unrun";
 function resolveConfigLoader(configLoader = "auto") {
-	if (noCacheLoad) return "unrun";
-	else if (configLoader === "auto") return !!(process.features.typescript || process.versions.bun || process.versions.deno) ? "native" : "unrun";
+	if (configLoader === "auto") return autoLoader;
 	else return configLoader === "native" ? "native" : "unrun";
 }
 function createParser(loader) {
@@ -190,7 +189,13 @@ function createParser(loader) {
 	};
 }
 async function nativeImport(id) {
-	const mod = await import(pathToFileURL(id).href).catch((error) => {
+	const url = pathToFileURL(id);
+	const importAttributes = Object.create(null);
+	if (isSupported) {
+		importAttributes.cache = "no";
+		init();
+	} else if (!isBun) url.searchParams.set("no-cache", crypto.randomUUID());
+	const mod = await import(url.href, { with: importAttributes }).catch((error) => {
 		if (error?.message?.includes?.("Cannot find module")) throw new Error(`Failed to load the config file. Try setting the --config-loader CLI flag to \`unrun\`.\n\n${error.message}`, { cause: error });
 		else throw error;
 	});
@@ -204,7 +209,7 @@ async function unrunImport(id) {
 
 //#endregion
 //#region src/features/clean.ts
-const debug$7 = createDebug("tsdown:clean");
+const debug$8 = createDebug("tsdown:clean");
 const RE_LAST_SLASH = /[/\\]$/;
 async function cleanOutDir(configs) {
 	const removes = /* @__PURE__ */ new Set();
@@ -222,10 +227,10 @@ async function cleanOutDir(configs) {
 	if (!removes.size) return;
 	globalLogger.info(`Cleaning ${removes.size} files`);
 	await Promise.all([...removes].map(async (file) => {
-		debug$7("Removing", file);
+		debug$8("Removing", file);
 		await fsRemove(file);
 	}));
-	debug$7("Removed %d files", removes.size);
+	debug$8("Removed %d files", removes.size);
 }
 function resolveClean(clean, outDir, cwd) {
 	if (clean === true) clean = [slash(outDir)];
@@ -236,7 +241,7 @@ function resolveClean(clean, outDir, cwd) {
 async function cleanupChunks(outDir, chunks) {
 	await Promise.all(chunks.map(async (chunk) => {
 		const filePath = path.resolve(outDir, chunk.fileName);
-		debug$7("Removing chunk file", filePath);
+		debug$8("Removing chunk file", filePath);
 		await fsRemove(filePath);
 	}));
 }
@@ -292,12 +297,11 @@ function detectIndentation(jsonText) {
 }
 
 //#endregion
-//#region src/features/exports.ts
+//#region src/features/pkg/exports.ts
 async function writeExports(options, chunks) {
-	if (!options.exports) return;
-	const { outDir, pkg } = options;
-	if (!pkg) throw new Error("`package.json` not found, cannot write exports");
-	const { publishExports, ...generated } = await generateExports(pkg, outDir, chunks, options.exports);
+	const pkg = options.pkg;
+	const exports = options.exports;
+	const { publishExports, ...generated } = await generateExports(pkg, chunks, exports);
 	const updatedPkg = {
 		...pkg,
 		...generated,
@@ -312,10 +316,8 @@ async function writeExports(options, chunks) {
 	if (original.endsWith("\n")) contents += "\n";
 	if (contents !== original) await writeFile(pkg.packageJsonPath, contents, "utf8");
 }
-async function generateExports(pkg, outDir, chunks, { devExports, all, customExports }) {
-	const pkgJsonPath = pkg.packageJsonPath;
-	const pkgRoot$1 = path.dirname(pkgJsonPath);
-	const outDirRelative = slash(path.relative(pkgRoot$1, outDir));
+async function generateExports(pkg, chunks, { devExports, all, customExports }) {
+	const pkgRoot$1 = path.dirname(pkg.packageJsonPath);
 	let main, module$1, cjsTypes, esmTypes;
 	const exportsMap = /* @__PURE__ */ new Map();
 	for (const [format, chunksByFormat] of Object.entries(chunks)) {
@@ -329,6 +331,7 @@ async function generateExports(pkg, outDir, chunks, { devExports, all, customExp
 			const isDts = name.endsWith(".d");
 			if (isDts) name = name.slice(0, -2);
 			const isIndex = onlyOneEntry || name === "index";
+			const outDirRelative = slash(path.relative(pkgRoot$1, chunk.outDir));
 			const distFile = `${outDirRelative ? `./${outDirRelative}` : "."}/${normalizedName}`;
 			if (isIndex) {
 				name = ".";
@@ -357,7 +360,6 @@ async function generateExports(pkg, outDir, chunks, { devExports, all, customExp
 	exportMeta(exports, all);
 	if (customExports) exports = await customExports(exports, {
 		pkg,
-		outDir,
 		chunks,
 		isPublish: false
 	});
@@ -367,7 +369,6 @@ async function generateExports(pkg, outDir, chunks, { devExports, all, customExp
 		exportMeta(publishExports, all);
 		if (customExports) publishExports = await customExports(publishExports, {
 			pkg,
-			outDir,
 			chunks,
 			isPublish: true
 		});
@@ -388,8 +389,8 @@ function genSubExport(devExports, { src, es, cjs }) {
 	else {
 		value = {};
 		if (typeof devExports === "string") value[devExports] = src;
-		if (es) value[dualFormat ? "import" : "default"] = es;
 		if (cjs) value[dualFormat ? "require" : "default"] = cjs;
+		if (es) value[dualFormat ? "import" : "default"] = es;
 	}
 	return value;
 }
@@ -463,11 +464,11 @@ async function resolveTsconfig(logger, tsconfig, cwd, name) {
 
 //#endregion
 //#region src/utils/package.ts
-const debug$6 = createDebug("tsdown:package");
+const debug$7 = createDebug("tsdown:package");
 async function readPackageJson(dir) {
 	const packageJsonPath = up$1({ cwd: dir });
 	if (!packageJsonPath) return;
-	debug$6("Reading package.json:", packageJsonPath);
+	debug$7("Reading package.json:", packageJsonPath);
 	const contents = await readFile(packageJsonPath, "utf8");
 	return {
 		...JSON.parse(contents),
@@ -481,105 +482,27 @@ function getPackageType(pkg) {
 	}
 }
 function normalizeFormat(format) {
-	return resolveComma(toArray(format, "es")).map((format$1) => {
-		switch (format$1) {
-			case "es":
-			case "esm":
-			case "module": return "es";
-			case "cjs":
-			case "commonjs": return "cjs";
-			default: return format$1;
-		}
-	});
+	switch (format) {
+		case "es":
+		case "esm":
+		case "module": return "es";
+		case "cjs":
+		case "commonjs": return "cjs";
+		default: return format;
+	}
 }
 
 //#endregion
-//#region src/config/index.ts
-const debug$5 = createDebug("tsdown:options");
-const DEFAULT_EXCLUDE_WORKSPACE = [
-	"**/node_modules/**",
-	"**/dist/**",
-	"**/test?(s)/**",
-	"**/t?(e)mp/**"
-];
-async function resolveConfig(inlineConfig) {
-	debug$5("inline config %O", inlineConfig);
-	const { configs: rootConfigs, file } = await loadConfigFile(inlineConfig);
-	const files = [];
-	if (file) {
-		files.push(file);
-		debug$5("loaded root user config file %s", file);
-		debug$5("root user configs %O", rootConfigs);
-	} else debug$5("no root user config file found");
-	const configs = (await Promise.all(rootConfigs.map(async (rootConfig) => {
-		const { configs: workspaceConfigs, files: workspaceFiles } = await resolveWorkspace(rootConfig, inlineConfig);
-		if (workspaceFiles) files.push(...workspaceFiles);
-		return Promise.all(workspaceConfigs.filter((config) => !config.workspace || config.entry).map((config) => resolveUserConfig(config, inlineConfig)));
-	}))).flat();
-	debug$5("resolved configs %O", configs);
-	return {
-		configs,
-		files
-	};
-}
-async function resolveWorkspace(config, inlineConfig) {
-	const normalized = {
-		...config,
-		...inlineConfig
-	};
-	const rootCwd = normalized.cwd || process.cwd();
-	let { workspace } = normalized;
-	if (!workspace) return {
-		configs: [normalized],
-		files: []
-	};
-	if (workspace === true) workspace = {};
-	else if (typeof workspace === "string" || Array.isArray(workspace)) workspace = { include: workspace };
-	let { include: packages = "auto", exclude = DEFAULT_EXCLUDE_WORKSPACE, config: workspaceConfig } = workspace;
-	if (packages === "auto") packages = (await glob("**/package.json", {
-		ignore: exclude,
-		cwd: rootCwd,
-		expandDirectories: false
-	})).filter((file) => file !== "package.json").map((file) => slash(path.resolve(rootCwd, file, "..")));
-	else packages = (await glob(packages, {
-		ignore: exclude,
-		cwd: rootCwd,
-		onlyDirectories: true,
-		absolute: true,
-		expandDirectories: false
-	})).map((file) => slash(path.resolve(file)));
-	if (packages.length === 0) throw new Error("No workspace packages found, please check your config");
-	if (inlineConfig.filter) {
-		inlineConfig.filter = resolveRegex(inlineConfig.filter);
-		packages = packages.filter((path$1) => {
-			return typeof inlineConfig.filter === "string" ? path$1.includes(inlineConfig.filter) : Array.isArray(inlineConfig.filter) ? inlineConfig.filter.some((filter) => path$1.includes(filter)) : inlineConfig.filter.test(path$1);
-		});
-		if (packages.length === 0) throw new Error("No packages matched the filters");
-	}
-	const files = [];
-	return {
-		configs: (await Promise.all(packages.map(async (cwd) => {
-			debug$5("loading workspace config %s", cwd);
-			const { configs, file } = await loadConfigFile({
-				...inlineConfig,
-				config: workspaceConfig,
-				cwd
-			}, cwd);
-			if (file) {
-				debug$5("loaded workspace config file %s", file);
-				files.push(file);
-			} else debug$5("no workspace config file found in %s", cwd);
-			return configs.map((config$1) => ({
-				...normalized,
-				cwd,
-				...config$1
-			}));
-		}))).flat(),
-		files
-	};
-}
+//#region src/config/options.ts
+const debugLog = createDebug("tsdown:config:options");
 async function resolveUserConfig(userConfig, inlineConfig) {
-	let { entry, format = ["es"], plugins = [], clean = true, silent = false, logLevel = silent ? "silent" : "info", failOnWarn = "ci-only", customLogger, treeshake = true, platform = "node", outDir = "dist", sourcemap = false, dts, unused = false, watch: watch$1 = false, ignoreWatch, shims = false, skipNodeModulesBundle = false, publint: publint$1 = false, attw: attw$1 = false, fromVite, alias, tsconfig, report = true, target, env: env$1 = {}, copy: copy$1, publicDir, hash = true, cwd = process.cwd(), name, workspace, external, noExternal, exports = false, bundle, unbundle = typeof bundle === "boolean" ? !bundle : false, removeNodeProtocol, nodeProtocol, cjsDefault = true, globImport = true, inlineOnly, fixedExtension = platform === "node", debug: debug$9 = false } = userConfig;
+	let { entry, format = ["es"], plugins = [], clean = true, silent = false, logLevel = silent ? "silent" : "info", failOnWarn = "ci-only", customLogger, treeshake = true, platform = "node", outDir = "dist", sourcemap = false, dts, unused = false, watch: watch$1 = false, ignoreWatch, shims = false, skipNodeModulesBundle = false, publint: publint$1 = false, attw: attw$1 = false, fromVite, alias, tsconfig, report = true, target, env: env$1 = {}, copy: copy$1, publicDir, hash = true, cwd = process.cwd(), name, workspace, external, noExternal, exports = false, bundle, unbundle = typeof bundle === "boolean" ? !bundle : false, removeNodeProtocol, nodeProtocol, cjsDefault = true, globImport = true, inlineOnly, fixedExtension = platform === "node", debug: debug$10 = false, write = true } = userConfig;
+	const pkg = await readPackageJson(cwd);
+	if (workspace) name ||= pkg?.name;
+	if (!filterConfig(inlineConfig.filter, cwd, name)) {
+		debugLog("[filter] skipping config %s", cwd);
+		return [];
+	}
 	const logger = createLogger(logLevel, {
 		customLogger,
 		failOnWarn: resolveFeatureOption(failOnWarn, true)
@@ -589,8 +512,6 @@ async function resolveUserConfig(userConfig, inlineConfig) {
 	nodeProtocol = nodeProtocol ?? (removeNodeProtocol ? "strip" : false);
 	outDir = path.resolve(cwd, outDir);
 	clean = resolveClean(clean, outDir, cwd);
-	const pkg = await readPackageJson(cwd);
-	if (workspace) name ||= pkg?.name;
 	entry = await resolveEntry(logger, entry, cwd, name);
 	if (dts == null) dts = !!(pkg?.types || pkg?.typings || hasExportsTypes(pkg));
 	target = resolveTarget(logger, target, pkg, name);
@@ -603,6 +524,11 @@ async function resolveUserConfig(userConfig, inlineConfig) {
 	unused = resolveFeatureOption(unused, {});
 	report = resolveFeatureOption(report, {});
 	dts = resolveFeatureOption(dts, {});
+	if (!pkg) {
+		if (exports) throw new Error("`package.json` not found, cannot write exports");
+		if (publint$1) logger.warn(prettyName(name), "publint is enabled but package.json is not found");
+		if (attw$1) logger.warn(prettyName(name), "attw is enabled but package.json is not found");
+	}
 	if (publicDir) if (copy$1) throw new TypeError("`publicDir` is deprecated. Cannot be used with `copy`");
 	else logger.warn(`${blue`publicDir`} is deprecated. Use ${blue`copy`} instead.`);
 	if (fromVite) {
@@ -627,12 +553,12 @@ async function resolveUserConfig(userConfig, inlineConfig) {
 		noExternal = (id) => matchPattern(id, noExternalPatterns);
 	}
 	if (inlineOnly != null) inlineOnly = toArray(inlineOnly);
-	debug$9 = resolveFeatureOption(debug$9, {});
-	if (debug$9) if (watch$1) {
-		if (debug$9.devtools) logger.warn("Devtools is not supported in watch mode, disabling it.");
-		debug$9.devtools = false;
-	} else debug$9.devtools ??= !!pkgExists("@vitejs/devtools/cli");
-	return {
+	debug$10 = resolveFeatureOption(debug$10, {});
+	if (debug$10) if (watch$1) {
+		if (debug$10.devtools) logger.warn("Devtools is not supported in watch mode, disabling it.");
+		debug$10.devtools = false;
+	} else debug$10.devtools ??= !!pkgExists("@vitejs/devtools/cli");
+	const config = {
 		...userConfig,
 		alias,
 		attw: attw$1,
@@ -640,14 +566,13 @@ async function resolveUserConfig(userConfig, inlineConfig) {
 		clean,
 		copy: publicDir || copy$1,
 		cwd,
-		debug: debug$9,
+		debug: debug$10,
 		dts,
 		entry,
 		env: env$1,
 		exports,
 		external,
 		fixedExtension,
-		format: normalizeFormat(format),
 		globImport,
 		hash,
 		ignoreWatch,
@@ -670,8 +595,22 @@ async function resolveUserConfig(userConfig, inlineConfig) {
 		tsconfig,
 		unbundle,
 		unused,
-		watch: watch$1
+		watch: watch$1,
+		write
 	};
+	const objectFormat = typeof format === "object" && !Array.isArray(format);
+	return (objectFormat ? Object.keys(format) : resolveComma(toArray(format, "es"))).map((fmt, idx) => {
+		const once = idx === 0;
+		const overrides = objectFormat ? format[fmt] : void 0;
+		return {
+			...config,
+			copy: once ? config.copy : void 0,
+			hooks: once ? config.hooks : void 0,
+			onSuccess: once ? config.onSuccess : void 0,
+			format: normalizeFormat(fmt),
+			...overrides
+		};
+	});
 }
 async function mergeUserOptions(defaults, user, args) {
 	const userOutputOptions = typeof user === "function" ? await user(defaults, ...args) : user;
@@ -689,9 +628,162 @@ function resolveCIOption(value) {
 	if (value === "local-only") return is_in_ci_default ? false : true;
 	return value;
 }
+function filterConfig(filter, configCwd, name) {
+	if (!filter) return true;
+	let cwd = path.relative(process.cwd(), configCwd);
+	if (cwd === "") cwd = ".";
+	if (filter instanceof RegExp) return name && filter.test(name) || filter.test(cwd);
+	return toArray(filter).some((value) => name && name === value || cwd === value);
+}
+
+//#endregion
+//#region src/config/workspace.ts
+const debug$6 = createDebug("tsdown:config:workspace");
+const DEFAULT_EXCLUDE_WORKSPACE = [
+	"**/node_modules/**",
+	"**/dist/**",
+	"**/test?(s)/**",
+	"**/t?(e)mp/**"
+];
+async function resolveWorkspace(config, inlineConfig) {
+	const normalized = {
+		...config,
+		...inlineConfig
+	};
+	const rootCwd = normalized.cwd || process.cwd();
+	let { workspace } = normalized;
+	if (!workspace) return {
+		configs: [normalized],
+		files: []
+	};
+	if (workspace === true) workspace = {};
+	else if (typeof workspace === "string" || Array.isArray(workspace)) workspace = { include: workspace };
+	let { include: packages = "auto", exclude = DEFAULT_EXCLUDE_WORKSPACE, config: workspaceConfig } = workspace;
+	if (packages === "auto") packages = (await glob("**/package.json", {
+		ignore: exclude,
+		cwd: rootCwd,
+		expandDirectories: false
+	})).filter((file) => file !== "package.json").map((file) => slash(path.resolve(rootCwd, file, "..")));
+	else packages = (await glob(packages, {
+		ignore: exclude,
+		cwd: rootCwd,
+		onlyDirectories: true,
+		absolute: true,
+		expandDirectories: false
+	})).map((file) => slash(path.resolve(file)));
+	if (packages.length === 0) throw new Error("No workspace packages found, please check your config");
+	const files = [];
+	return {
+		configs: (await Promise.all(packages.map(async (cwd) => {
+			debug$6("loading workspace config %s", cwd);
+			const { configs, file } = await loadConfigFile({
+				...inlineConfig,
+				config: workspaceConfig,
+				cwd
+			}, cwd);
+			if (file) {
+				debug$6("loaded workspace config file %s", file);
+				files.push(file);
+			} else debug$6("no workspace config file found in %s", cwd);
+			return configs.map((config$1) => ({
+				...normalized,
+				...config$1
+			}));
+		}))).flat(),
+		files
+	};
+}
 
 //#endregion
-//#region src/features/attw.ts
+//#region src/config/index.ts
+const debug$5 = createDebug("tsdown:config");
+async function resolveConfig(inlineConfig) {
+	debug$5("inline config %O", inlineConfig);
+	const { configs: rootConfigs, file } = await loadConfigFile(inlineConfig);
+	const files = [];
+	if (file) {
+		files.push(file);
+		debug$5("loaded root user config file %s", file);
+		debug$5("root user configs %O", rootConfigs);
+	} else debug$5("no root user config file found");
+	const configs = (await Promise.all(rootConfigs.map(async (rootConfig) => {
+		const { configs: workspaceConfigs, files: workspaceFiles } = await resolveWorkspace(rootConfig, inlineConfig);
+		debug$5("workspace configs %O", workspaceConfigs);
+		if (workspaceFiles) files.push(...workspaceFiles);
+		return (await Promise.all(workspaceConfigs.filter((config) => !config.workspace || config.entry).map((config) => resolveUserConfig(config, inlineConfig)))).flat().filter((config) => !!config);
+	}))).flat();
+	debug$5("resolved configs %O", configs);
+	if (configs.length === 0) throw new Error("No valid configuration found.");
+	return {
+		configs,
+		files
+	};
+}
+
+//#endregion
+//#region src/features/cjs.ts
+/**
+* If the config includes the `cjs` format and
+* one of its target >= node 23.0.0 / 22.12.0,
+* warn the user about the deprecation of CommonJS.
+*/
+function warnLegacyCJS(config) {
+	if (!config.format.includes("cjs") || !config.target) return;
+	if (config.target.some((t) => {
+		const version$1 = coerce(t.split("node")[1]);
+		return version$1 && satisfies(version$1, ">=23.0.0 || >=22.12.0");
+	})) config.logger.warnOnce("We recommend using the ESM format instead of CommonJS.\nThe ESM format is compatible with modern platforms and runtimes, and most new libraries are now distributed only in ESM format.\nLearn more at https://nodejs.org/en/learn/modules/publishing-a-package#how-did-we-get-here");
+}
+
+//#endregion
+//#region src/features/copy.ts
+async function copy(options) {
+	if (!options.copy) return;
+	const copy$1 = typeof options.copy === "function" ? await options.copy(options) : options.copy;
+	await Promise.all(toArray(copy$1).map((dir) => {
+		const from = typeof dir === "string" ? dir : dir.from;
+		const to = typeof dir === "string" ? path.resolve(options.outDir, path.basename(from)) : dir.to;
+		return cp$1(options.cwd, from, to);
+	}));
+}
+function cp$1(cwd, from, to) {
+	return fsCopy(path.resolve(cwd, from), path.resolve(cwd, to));
+}
+
+//#endregion
+//#region src/features/hooks.ts
+async function createHooks$1(options) {
+	const hooks = createHooks();
+	if (typeof options.hooks === "object") hooks.addHooks(options.hooks);
+	else if (typeof options.hooks === "function") await options.hooks(hooks);
+	return {
+		hooks,
+		context: {
+			options,
+			hooks
+		}
+	};
+}
+function executeOnSuccess(config) {
+	if (!config.onSuccess) return;
+	const ab = new AbortController();
+	if (typeof config.onSuccess === "string") {
+		const p = exec(config.onSuccess, [], { nodeOptions: {
+			shell: true,
+			stdio: "inherit"
+		} });
+		p.then(({ exitCode }) => {
+			if (exitCode) process.exitCode = exitCode;
+		});
+		ab.signal.addEventListener("abort", () => {
+			if (typeof p.pid === "number") treeKill(p.pid);
+		});
+	} else config.onSuccess(config, ab.signal);
+	return ab;
+}
+
+//#endregion
+//#region src/features/pkg/attw.ts
 const debug$4 = createDebug("tsdown:attw");
 const label$1 = dim`[attw]`;
 /**
@@ -780,69 +872,7 @@ function formatProblem(problem) {
 }
 
 //#endregion
-//#region src/features/cjs.ts
-/**
-* If the config includes the `cjs` format and
-* one of its target >= node 23.0.0 / 22.12.0,
-* warn the user about the deprecation of CommonJS.
-*/
-function warnLegacyCJS(config) {
-	if (!config.format.includes("cjs") || !config.target) return;
-	if (config.target.some((t) => {
-		const version$1 = coerce(t.split("node")[1]);
-		return version$1 && satisfies(version$1, ">=23.0.0 || >=22.12.0");
-	})) config.logger.warnOnce("We recommend using the ESM format instead of CommonJS.\nThe ESM format is compatible with modern platforms and runtimes, and most new libraries are now distributed only in ESM format.\nLearn more at https://nodejs.org/en/learn/modules/publishing-a-package#how-did-we-get-here");
-}
-
-//#endregion
-//#region src/features/copy.ts
-async function copy(options) {
-	if (!options.copy) return;
-	const copy$1 = typeof options.copy === "function" ? await options.copy(options) : options.copy;
-	await Promise.all(toArray(copy$1).map((dir) => {
-		const from = typeof dir === "string" ? dir : dir.from;
-		const to = typeof dir === "string" ? path.resolve(options.outDir, path.basename(from)) : dir.to;
-		return cp$1(options.cwd, from, to);
-	}));
-}
-function cp$1(cwd, from, to) {
-	return fsCopy(path.resolve(cwd, from), path.resolve(cwd, to));
-}
-
-//#endregion
-//#region src/features/hooks.ts
-async function createHooks$1(options) {
-	const hooks = createHooks();
-	if (typeof options.hooks === "object") hooks.addHooks(options.hooks);
-	else if (typeof options.hooks === "function") await options.hooks(hooks);
-	return {
-		hooks,
-		context: {
-			options,
-			hooks
-		}
-	};
-}
-function executeOnSuccess(config) {
-	if (!config.onSuccess) return;
-	const ab = new AbortController();
-	if (typeof config.onSuccess === "string") {
-		const p = exec(config.onSuccess, [], { nodeOptions: {
-			shell: true,
-			stdio: "inherit"
-		} });
-		p.then(({ exitCode }) => {
-			if (exitCode) process.exitCode = exitCode;
-		});
-		ab.signal.addEventListener("abort", () => {
-			if (typeof p.pid === "number") treeKill(p.pid);
-		});
-	} else config.onSuccess(config, ab.signal);
-	return ab;
-}
-
-//#endregion
-//#region src/features/publint.ts
+//#region src/features/pkg/publint.ts
 const debug$3 = createDebug("tsdown:publint");
 const label = dim`[publint]`;
 async function publint(options) {
@@ -881,6 +911,66 @@ async function publint(options) {
 	}
 }
 
+//#endregion
+//#region src/features/pkg/index.ts
+function initBundleByPkg(configs) {
+	const map = {};
+	for (const config of configs) {
+		const pkgJson = config.pkg?.packageJsonPath;
+		if (!pkgJson) continue;
+		if (!map[pkgJson]) {
+			const { promise, resolve } = promiseWithResolvers();
+			map[pkgJson] = {
+				promise,
+				resolve,
+				count: 0,
+				formats: /* @__PURE__ */ new Set(),
+				bundles: []
+			};
+		}
+		map[pkgJson].count++;
+		map[pkgJson].formats.add(config.format);
+	}
+	return map;
+}
+async function bundleDone(bundleByPkg, bundle) {
+	const pkg = bundle.config.pkg;
+	if (!pkg) return;
+	const ctx = bundleByPkg[pkg.packageJsonPath];
+	ctx.bundles.push(bundle);
+	if (ctx.bundles.length < ctx.count) return ctx.promise;
+	const configs = ctx.bundles.map(({ config }) => config);
+	const exportsConfigs = dedupeConfigs(configs, "exports");
+	if (exportsConfigs.length) {
+		if (exportsConfigs.length > 1) throw new Error(`Conflicting exports options for package at ${pkg.packageJsonPath}. Please merge them:\n${exportsConfigs.map((config) => `- ${formatWithOptions({ colors: true }, config.exports)}`).join("\n")}`);
+		const chunks = {};
+		for (const bundle$1 of ctx.bundles) {
+			if (!bundle$1.config.exports) continue;
+			chunks[bundle$1.config.format] ||= [];
+			chunks[bundle$1.config.format].push(...bundle$1.chunks);
+		}
+		await writeExports(exportsConfigs[0], chunks);
+	}
+	const publintConfigs = dedupeConfigs(configs, "publint");
+	const attwConfigs = dedupeConfigs(configs, "attw");
+	if (publintConfigs.length > 1 || attwConfigs.length > 1) publintConfigs[1].logger.warn(`Multiple publint or attw configurations found for package at ${pkg.packageJsonPath}. Consider merging them for better consistency and performance.`);
+	await Promise.all([...publintConfigs.map((config) => publint(config)), ...attwConfigs.map((config) => attw(config))]);
+	ctx.resolve();
+}
+function dedupeConfigs(configs, key) {
+	const filtered = configs.filter((config) => config[key]);
+	if (!filtered.length) return [];
+	const seen = /* @__PURE__ */ new Set();
+	const results = filtered.filter((config) => {
+		if (!Object.keys(config[key]).length) return false;
+		if (seen.has(config[key])) return false;
+		seen.add(config[key]);
+		return true;
+	});
+	if (results.length === 0) return [filtered[0]];
+	return results;
+}
+
 //#endregion
 //#region src/features/external.ts
 const debug$2 = createDebug("tsdown:external");
@@ -1079,7 +1169,7 @@ const defaultOptions = {
 	brotli: false,
 	maxCompressSize: 1e6
 };
-function ReportPlugin(userOptions, logger, cwd, cjsDts, name, isMultiFormat) {
+function ReportPlugin(userOptions, logger, cwd, cjsDts, name, isDualFormat) {
 	const options = {
 		...defaultOptions,
 		...userOptions
@@ -1110,7 +1200,7 @@ function ReportPlugin(userOptions, logger, cwd, cjsDts, name, isMultiFormat) {
 				return b.raw - a.raw;
 			});
 			const nameLabel = prettyName(name);
-			const formatLabel = isMultiFormat && prettyFormat(cjsDts ? "cjs" : outputOptions.format);
+			const formatLabel = isDualFormat && prettyFormat(cjsDts ? "cjs" : outputOptions.format);
 			for (const size of sizes) {
 				const filenameColor = size.dts ? green : noop;
 				logger.info(nameLabel, formatLabel, dim(outDir + path.sep) + filenameColor((size.isEntry ? bold : noop)(size.filename)), ` `.repeat(filenameLength - size.filename.length), dim(size.rawText), options.gzip && size.gzipText && dim`│ gzip: ${size.gzipText}`, options.brotli && size.brotliText && dim`│ brotli: ${size.brotliText}`);
@@ -1154,7 +1244,7 @@ async function calcSize(options, chunk) {
 //#endregion
 //#region src/features/shebang.ts
 const RE_SHEBANG = /^#!.*/;
-function ShebangPlugin(logger, cwd, name, isMultiFormat) {
+function ShebangPlugin(logger, cwd, name, isDualFormat) {
 	return {
 		name: "tsdown:shebang",
 		async writeBundle(options, bundle) {
@@ -1163,7 +1253,7 @@ function ShebangPlugin(logger, cwd, name, isMultiFormat) {
 				if (!RE_SHEBANG.test(chunk.code)) continue;
 				const filepath = path.resolve(cwd, options.file || path.join(options.dir, chunk.fileName));
 				if (await fsExists(filepath)) {
-					logger.info(prettyName(name), isMultiFormat && prettyFormat(options.format), `Granting execute permission to ${underline(path.relative(cwd, filepath))}`);
+					logger.info(prettyName(name), isDualFormat && prettyFormat(options.format), `Granting execute permission to ${underline(path.relative(cwd, filepath))}`);
 					await chmod(filepath, 493);
 				}
 			}
@@ -1180,9 +1270,18 @@ function getShimsInject(format, platform) {
 	};
 }
 
+//#endregion
+//#region src/utils/chunks.ts
+function addOutDirToChunks(chunks, outDir) {
+	return chunks.map((chunk) => {
+		chunk.outDir = outDir;
+		return chunk;
+	});
+}
+
 //#endregion
 //#region src/features/watch.ts
-const endsWithConfig = /[\\/](?:tsdown\.config.*|tsconfig\.json)$/;
+const endsWithConfig = /[\\/](?:tsdown\.config.*|package\.json|tsconfig\.json)$/;
 function WatchPlugin(configFiles, { config, chunks }) {
 	return {
 		name: "tsdown:watch",
@@ -1195,11 +1294,12 @@ function WatchPlugin(configFiles, { config, chunks }) {
 			config.tsconfig && this.addWatchFile(config.tsconfig);
 			for (const file of configFiles) this.addWatchFile(file);
 			if (typeof config.watch !== "boolean") for (const file of resolveComma(toArray(config.watch))) this.addWatchFile(file);
+			if (config.pkg) this.addWatchFile(config.pkg.packageJsonPath);
 		},
 		generateBundle: {
 			order: "post",
 			handler(outputOptions, bundle) {
-				chunks.push(...Object.values(bundle));
+				chunks.push(...addOutDirToChunks(Object.values(bundle), config.outDir));
 			}
 		}
 	};
@@ -1208,18 +1308,19 @@ function WatchPlugin(configFiles, { config, chunks }) {
 //#endregion
 //#region src/features/rolldown.ts
 const debug = createDebug("tsdown:rolldown");
-async function getBuildOptions(config, format, configFiles, watchContext, cjsDts = false, isMultiFormat) {
-	const inputOptions = await resolveInputOptions(config, format, configFiles, watchContext, cjsDts, isMultiFormat);
+async function getBuildOptions(config, format, configFiles, bundle, cjsDts = false, isDualFormat) {
+	const inputOptions = await resolveInputOptions(config, format, configFiles, bundle, cjsDts, isDualFormat);
 	const outputOptions = await resolveOutputOptions(inputOptions, config, format, cjsDts);
 	const rolldownConfig = {
 		...inputOptions,
-		output: outputOptions
+		output: outputOptions,
+		write: config.write
 	};
 	debug("rolldown config with format \"%s\" %O", cjsDts ? "cjs dts" : format, rolldownConfig);
 	return rolldownConfig;
 }
-async function resolveInputOptions(config, format, configFiles, watchContext, cjsDts, isMultiFormat) {
-	const { alias, banner, cjsDefault, cwd, debug: debug$9, dts, entry, env: env$1, external, footer, globImport, loader, logger, name, nodeProtocol, platform, plugins: userPlugins, report, shims, target, treeshake, tsconfig, unused, watch: watch$1 } = config;
+async function resolveInputOptions(config, format, configFiles, bundle, cjsDts, isDualFormat) {
+	const { alias, banner, cjsDefault, cwd, debug: debug$10, dts, entry, env: env$1, external, footer, globImport, loader, logger, name, nodeProtocol, platform, plugins: userPlugins, report, shims, target, treeshake, tsconfig, unused, watch: watch$1 } = config;
 	const plugins = [];
 	if (nodeProtocol) plugins.push(NodeProtocolPlugin(nodeProtocol));
 	if (config.pkg || config.skipNodeModulesBundle) plugins.push(ExternalPlugin(config));
@@ -1247,11 +1348,11 @@ async function resolveInputOptions(config, format, configFiles, watchContext, cj
 			}));
 		}
 		if (target) plugins.push(await LightningCSSPlugin({ target }));
-		plugins.push(ShebangPlugin(logger, cwd, name, isMultiFormat));
+		plugins.push(ShebangPlugin(logger, cwd, name, isDualFormat));
 		if (globImport) plugins.push(importGlobPlugin());
 	}
-	if (report && LogLevels[logger.level] >= 3) plugins.push(ReportPlugin(report, logger, cwd, cjsDts, name, isMultiFormat));
-	if (watch$1) plugins.push(WatchPlugin(configFiles, watchContext));
+	if (report && LogLevels[logger.level] >= 3) plugins.push(ReportPlugin(report, logger, cwd, cjsDts, name, isDualFormat));
+	if (watch$1) plugins.push(WatchPlugin(configFiles, bundle));
 	if (!cjsDts) plugins.push(userPlugins);
 	const define = {
 		...config.define,
@@ -1283,7 +1384,7 @@ async function resolveInputOptions(config, format, configFiles, watchContext, cj
 			if (log.code === "MIXED_EXPORT") return;
 			defaultHandler(level, log);
 		} : void 0,
-		debug: debug$9 || void 0
+		debug: debug$10 || void 0
 	}, config.inputOptions, [format, { cjsDts }]);
 }
 async function resolveOutputOptions(inputOptions, config, format, cjsDts) {
@@ -1309,7 +1410,7 @@ async function getDebugRolldownDir() {
 	return await mkdtemp(join(tmpdir(), "tsdown-config-"));
 }
 async function debugBuildOptions(dir, name, format, buildOptions) {
-	const outFile = join(dir, `tsdown.config.${format}.js`);
+	const outFile = join(dir, `rolldown.config.${format}.js`);
 	handlePluginInspect(buildOptions.plugins);
 	const serialized = util.formatWithOptions({
 		depth: null,
@@ -1408,18 +1509,22 @@ async function build$1(userOptions = {}) {
 		if (restarting) return;
 		restarting = true;
 		await Promise.all(disposeCbs.map((cb) => cb()));
-		setNoCacheLoad();
+		clearRequireCache();
 		build$1(userOptions);
 	}
+	const configChunksByPkg = initBundleByPkg(configs);
+	function done(bundle) {
+		return bundleDone(configChunksByPkg, bundle);
+	}
 	globalLogger.info("Build start");
-	const bundles = await Promise.all(configs.map((options) => buildSingle(options, configFiles, clean, restart)));
+	const bundles = await Promise.all(configs.map((options) => {
+		return buildSingle(options, configFiles, options.pkg ? configChunksByPkg[options.pkg.packageJsonPath].formats.size > 1 : true, clean, restart, done);
+	}));
 	const firstDevtoolsConfig = configs.find((config) => config.debug && config.debug.devtools);
 	if (configs.some((config) => config.watch)) {
 		disposeCbs.push(shortcuts(restart));
 		for (const bundle of bundles) disposeCbs.push(bundle[asyncDispose]);
-		return;
-	}
-	if (firstDevtoolsConfig) {
+	} else if (firstDevtoolsConfig) {
 		const { start } = await importWithError("@vitejs/devtools/cli-commands");
 		const devtoolsOptions = firstDevtoolsConfig.debug.devtools;
 		await start({
@@ -1438,42 +1543,39 @@ async function build$1(userOptions = {}) {
 * @private
 * @param config Resolved options
 */
-async function buildSingle(config, configFiles, clean, restart) {
-	const { format: formats, dts, watch: watch$1, logger } = config;
+async function buildSingle(config, configFiles, isDualFormat, clean, restart, done) {
+	const { format, dts, watch: watch$1, logger, outDir } = config;
 	const { hooks, context } = await createHooks$1(config);
 	warnLegacyCJS(config);
 	const startTime = performance.now();
 	await hooks.callHook("build:prepare", context);
 	await clean();
 	const debugRolldownConfigDir = await getDebugRolldownDir();
-	const chunks = {};
+	const chunks = [];
 	let watcher;
-	const watchCtx = { config };
 	let ab;
-	const isMultiFormat = formats.length > 1;
-	const configsByFormat = (await Promise.all(formats.map((format) => buildOptionsByFormat(format)))).flat();
+	let updated = false;
+	const bundle = {
+		chunks,
+		config,
+		async [asyncDispose]() {
+			ab?.abort();
+			await watcher?.close();
+		}
+	};
+	const configs = await initBuildOptions();
 	if (watch$1) {
-		watcher = watch(configsByFormat.map((item) => item[1]));
+		watcher = watch(configs);
 		handleWatcher(watcher);
 	} else {
-		const outputs = await build(configsByFormat.map((item) => item[1]));
-		for (const [i, output] of outputs.entries()) {
-			const format = configsByFormat[i][0];
-			chunks[format] ||= [];
-			chunks[format].push(...output.output);
-		}
+		const outputs = await build(configs);
+		for (const { output } of outputs) chunks.push(...addOutDirToChunks(output, outDir));
 	}
 	if (!watch$1) {
 		logger.success(prettyName(config.name), `Build complete in ${green(`${Math.round(performance.now() - startTime)}ms`)}`);
 		await postBuild();
 	}
-	return {
-		chunks,
-		async [asyncDispose]() {
-			ab?.abort();
-			await watcher?.close();
-		}
-	};
+	return bundle;
 	function handleWatcher(watcher$1) {
 		const changedFile = [];
 		let hasError = false;
@@ -1487,10 +1589,8 @@ async function buildSingle(config, configFiles, clean, restart) {
 		watcher$1.on("event", async (event) => {
 			switch (event.code) {
 				case "START":
-					for (const format of formats) {
-						await cleanupChunks(config.outDir, chunks[format]);
-						chunks[format].length = 0;
-					}
+					await cleanupChunks(config.outDir, chunks);
+					chunks.length = 0;
 					hasError = false;
 					break;
 				case "END":
@@ -1515,25 +1615,25 @@ async function buildSingle(config, configFiles, clean, restart) {
 			}
 		});
 	}
-	async function buildOptionsByFormat(format) {
-		const watchContext = {
-			...watchCtx,
-			chunks: chunks[format] = []
-		};
-		const buildOptions = await getBuildOptions(config, format, configFiles, watchContext, false, isMultiFormat);
+	async function initBuildOptions() {
+		const buildOptions = await getBuildOptions(config, format, configFiles, bundle, false, isDualFormat);
 		await hooks.callHook("build:before", {
 			...context,
 			buildOptions
 		});
 		if (debugRolldownConfigDir) await debugBuildOptions(debugRolldownConfigDir, config.name, format, buildOptions);
-		const configs = [[format, buildOptions]];
-		if (format === "cjs" && dts) configs.push([format, await getBuildOptions(config, format, configFiles, watchContext, true, isMultiFormat)]);
-		return configs;
+		const configs$1 = [buildOptions];
+		if (format === "cjs" && dts) configs$1.push(await getBuildOptions(config, format, configFiles, bundle, true, isDualFormat));
+		return configs$1;
 	}
 	async function postBuild() {
-		await Promise.all([writeExports(config, chunks), copy(config)]);
-		await Promise.all([publint(config), attw(config)]);
-		await hooks.callHook("build:done", context);
+		if (updated) await copy(config);
+		else await done(bundle);
+		await hooks.callHook("build:done", {
+			...context,
+			chunks
+		});
+		updated = true;
 		ab?.abort();
 		ab = executeOnSuccess(config);
 	}
@@ -1544,4 +1644,4 @@ const pkgRoot = path.resolve(dirname$1, "..");
 const shimFile = path.resolve(pkgRoot, "esm-shims.js");
 
 //#endregion
-export { ReportPlugin as a, ShebangPlugin as i, buildSingle as n, NodeProtocolPlugin as o, shimFile as r, ExternalPlugin as s, build$1 as t };
+export { ShebangPlugin as a, ExternalPlugin as c, WatchPlugin as i, buildSingle as n, ReportPlugin as o, shimFile as r, NodeProtocolPlugin as s, build$1 as t };