tsdown 0.17.0-beta.4 → 0.17.0-beta.5

package/dist/{config-CsOGKn_i.d.mts → config-DPU-roRC.d.mts}

@@ -1,4 +1,4 @@
-import { f as UserConfig, m as UserConfigFn, p as UserConfigExport } from "./index-gX-yrJuu.mjs";
+import { f as UserConfig, m as UserConfigFn, p as UserConfigExport } from "./index-BQZ2CZuJ.mjs";
 
 //#region src/config.d.ts
 

package/dist/config.d.mts

@@ -1,3 +1,3 @@
-import { f as UserConfig, m as UserConfigFn, p as UserConfigExport } from "./index-gX-yrJuu.mjs";
-import { t as defineConfig } from "./config-CsOGKn_i.mjs";
+import { f as UserConfig, m as UserConfigFn, p as UserConfigExport } from "./index-BQZ2CZuJ.mjs";
+import { t as defineConfig } from "./config-DPU-roRC.mjs";
 export { UserConfig, UserConfigExport, UserConfigFn, defineConfig };

package/dist/{index-gX-yrJuu.d.mts → index-BQZ2CZuJ.d.mts}

@@ -2,38 +2,12 @@ import "ansis";
 import { BuildOptions, ExternalOption, InputOption, InputOptions, InternalModuleFormat, MinifyOptions, ModuleFormat, ModuleTypes, OutputAsset, OutputChunk, OutputOptions, Plugin, TreeshakingOptions } from "rolldown";
 import { Hookable } from "hookable";
 import { Options as DtsOptions } from "rolldown-plugin-dts";
-import { CheckPackageOptions } from "@arethetypeswrong/core";
 import { StartOptions } from "@vitejs/devtools/cli-commands";
 import { PackageJson } from "pkg-types";
+import { CheckPackageOptions } from "@arethetypeswrong/core";
 import { Options as PublintOptions } from "publint";
 import { Options as UnusedOptions } from "unplugin-unused";
 
-//#region src/features/attw.d.ts
-interface AttwOptions extends CheckPackageOptions {
-  /**
-  * Profiles select a set of resolution modes to require/ignore. All are evaluated but failures outside
-  * of those required are ignored.
-  *
-  * The available profiles are:
-  * - `strict`: requires all resolutions
-  * - `node16`: ignores node10 resolution failures
-  * - `esm-only`: ignores CJS resolution failures
-  *
-  * @default 'strict'
-  */
-  profile?: "strict" | "node16" | "esm-only";
-  /**
-  * The level of the check.
-  *
-  * The available levels are:
-  * - `error`: fails the build
-  * - `warn`: warns the build
-  *
-  * @default 'warn'
-  */
-  level?: "error" | "warn";
-}
-//#endregion
 //#region src/utils/types.d.ts
 type Overwrite<T, U> = Omit<T, keyof U> & U;
 type Awaitable<T> = T | Promise<T>;
@@ -64,27 +38,6 @@ interface DebugOptions extends NonNullable<InputOptions["debug"]> {
   clean?: boolean;
 }
 //#endregion
-//#region src/features/exports.d.ts
-type TsdownChunks = Partial<Record<NormalizedFormat, Array<OutputChunk | OutputAsset>>>;
-interface ExportsOptions {
-  /**
-  * Generate exports that link to source code during development.
-  * - string: add as a custom condition.
-  * - true: all conditions point to source files, and add dist exports to `publishConfig`.
-  */
-  devExports?: boolean | string;
-  /**
-  * Exports for all files.
-  */
-  all?: boolean;
-  customExports?: (exports: Record<string, any>, context: {
-    pkg: PackageJson;
-    chunks: TsdownChunks;
-    outDir: string;
-    isPublish: boolean;
-  }) => Awaitable<Record<string, any>>;
-}
-//#endregion
 //#region src/features/hooks.d.ts
 interface BuildContext {
   options: ResolvedConfig;
@@ -112,10 +65,15 @@ interface TsdownHooks {
   * Invoked after each tsdown build completes.
   * Use this hook for cleanup or post-processing tasks.
   */
-  "build:done": (ctx: BuildContext) => void | Promise<void>;
+  "build:done": (ctx: BuildContext & {
+    chunks: RolldownChunk[];
+  }) => void | Promise<void>;
 }
 //#endregion
 //#region src/utils/package.d.ts
+interface PackageJsonWithPath extends PackageJson {
+  packageJsonPath: string;
+}
 type PackageType = "module" | "commonjs" | undefined;
 //#endregion
 //#region src/features/output.d.ts
@@ -141,6 +99,61 @@ type ChunkAddonFunction = (ctx: {
 }) => ChunkAddonObject | string | undefined;
 type ChunkAddon = ChunkAddonObject | ChunkAddonFunction | string;
 //#endregion
+//#region src/features/pkg/attw.d.ts
+interface AttwOptions extends CheckPackageOptions {
+  /**
+  * Profiles select a set of resolution modes to require/ignore. All are evaluated but failures outside
+  * of those required are ignored.
+  *
+  * The available profiles are:
+  * - `strict`: requires all resolutions
+  * - `node16`: ignores node10 resolution failures
+  * - `esm-only`: ignores CJS resolution failures
+  *
+  * @default 'strict'
+  */
+  profile?: "strict" | "node16" | "esm-only";
+  /**
+  * The level of the check.
+  *
+  * The available levels are:
+  * - `error`: fails the build
+  * - `warn`: warns the build
+  *
+  * @default 'warn'
+  */
+  level?: "error" | "warn";
+}
+//#endregion
+//#region src/utils/chunks.d.ts
+type RolldownChunk = (OutputChunk | OutputAsset) & {
+  outDir: string;
+};
+type ChunksByFormat = Partial<Record<NormalizedFormat, RolldownChunk[]>>;
+interface TsdownBundle extends AsyncDisposable {
+  chunks: RolldownChunk[];
+  config: ResolvedConfig;
+}
+//#endregion
+//#region src/features/pkg/exports.d.ts
+interface ExportsOptions {
+  /**
+  * Generate exports that link to source code during development.
+  * - string: add as a custom condition.
+  * - true: all conditions point to source files, and add dist exports to `publishConfig`.
+  */
+  devExports?: boolean | string;
+  /**
+  * Exports for all files.
+  */
+  all?: boolean;
+  customExports?: (exports: Record<string, any>, context: {
+    pkg: PackageJson;
+    chunks: ChunksByFormat;
+    isPublish: boolean;
+  }) => Awaitable<Record<string, any>>;
+}
+//#endregion
 //#region src/utils/logger.d.ts
 type LogType = "error" | "warn" | "info";
 type LogLevel = LogType | "silent";
@@ -176,7 +189,7 @@ interface ReportOptions {
   */
   maxCompressSize?: number;
 }
-declare function ReportPlugin(userOptions: ReportOptions, logger: Logger, cwd: string, cjsDts?: boolean, name?: string, isMultiFormat?: boolean): Plugin;
+declare function ReportPlugin(userOptions: ReportOptions, logger: Logger, cwd: string, cjsDts?: boolean, name?: string, isDualFormat?: boolean): Plugin;
 //#endregion
 //#region src/config/types.d.ts
 type Sourcemap = boolean | "inline" | "hidden";
@@ -336,11 +349,17 @@ interface UserConfig {
     cjsDts: boolean;
   }) => Awaitable<InputOptions | void | null>);
   /** @default 'es' */
-  format?: Format | Format[];
+  format?: Format | Format[] | Partial<Record<Format, Partial<ResolvedConfig>>>;
   globalName?: string;
   /** @default 'dist' */
   outDir?: string;
   /**
+  * Whether to write the files to disk.
+  * This option is incompatible with watch mode.
+  * @default true
+  */
+  write?: boolean;
+  /**
   * Whether to generate source map files.
   *
   * Note that this option will always be `true` if you have
@@ -447,10 +466,6 @@ interface UserConfig {
   */
   ignoreWatch?: Arrayable<string | RegExp>;
   /**
-  * You can specify command to be executed after a successful build, specially useful for Watch mode
-  */
-  onSuccess?: string | ((config: ResolvedConfig, signal: AbortSignal) => void | Promise<void>);
-  /**
   * **[experimental]** Enable debug mode.
   *
   * Both debug mode and Vite DevTools are still under development, and this is for early testers only.
@@ -461,6 +476,10 @@ interface UserConfig {
   */
   debug?: WithEnabled<DebugOptions>;
   /**
+  * You can specify command to be executed after a successful build, specially useful for Watch mode
+  */
+  onSuccess?: string | ((config: ResolvedConfig, signal: AbortSignal) => void | Promise<void>);
+  /**
   * Enables generation of TypeScript declaration files (`.d.ts`).
   *
   * By default, this option is auto-detected based on your project's `package.json`:
@@ -548,10 +567,10 @@ type UserConfigFn = (inlineConfig: InlineConfig, context: {
 }) => Awaitable<Arrayable<UserConfig>>;
 type UserConfigExport = Awaitable<Arrayable<UserConfig> | UserConfigFn>;
 type ResolvedConfig = Overwrite<MarkPartial<Omit<UserConfig, "workspace" | "fromVite" | "publicDir" | "silent" | "bundle" | "removeNodeProtocol" | "logLevel" | "failOnWarn" | "customLogger">, "globalName" | "inputOptions" | "outputOptions" | "minify" | "define" | "alias" | "external" | "onSuccess" | "outExtensions" | "hooks" | "copy" | "loader" | "name" | "banner" | "footer">, {
-  format: NormalizedFormat[];
+  format: NormalizedFormat;
   target?: string[];
   clean: string[];
-  pkg?: PackageJson;
+  pkg?: PackageJsonWithPath;
   nodeProtocol: "strip" | boolean;
   logger: Logger;
   ignoreWatch: Array<string | RegExp>;
@@ -567,4 +586,4 @@ type ResolvedConfig = Overwrite<MarkPartial<Omit<UserConfig, "workspace" | "from
   unused: false | UnusedOptions;
 }>;
 //#endregion
-export { TsdownHooks as A, ChunkAddonObject as C, PackageType as D, OutExtensionObject as E, CopyOptions as F, CopyOptionsFn as I, AttwOptions as L, TsdownChunks as M, DebugOptions as N, BuildContext as O, CopyEntry as P, ChunkAddonFunction as S, OutExtensionFactory as T, ReportOptions as _, NoExternalFn as a, globalLogger as b, ResolvedConfig as c, UnusedOptions as d, UserConfig as f, Workspace as g, WithEnabled as h, InlineConfig as i, ExportsOptions as j, RolldownContext as k, Sourcemap as l, UserConfigFn as m, DtsOptions as n, NormalizedFormat as o, UserConfigExport as p, Format as r, PublintOptions as s, CIOption as t, TreeshakingOptions as u, ReportPlugin as v, OutExtensionContext as w, ChunkAddon as x, Logger as y };
+export { OutExtensionObject as A, TsdownBundle as C, ChunkAddonObject as D, ChunkAddonFunction as E, TsdownHooks as F, DebugOptions as I, CopyEntry as L, PackageType as M, BuildContext as N, OutExtensionContext as O, RolldownContext as P, CopyOptions as R, RolldownChunk as S, ChunkAddon as T, ReportOptions as _, NoExternalFn as a, globalLogger as b, ResolvedConfig as c, UnusedOptions as d, UserConfig as f, Workspace as g, WithEnabled as h, InlineConfig as i, PackageJsonWithPath as j, OutExtensionFactory as k, Sourcemap as l, UserConfigFn as m, DtsOptions as n, NormalizedFormat as o, UserConfigExport as p, Format as r, PublintOptions as s, CIOption as t, TreeshakingOptions as u, ReportPlugin as v, AttwOptions as w, ExportsOptions as x, Logger as y, CopyOptionsFn as z };

package/dist/index.d.mts

@@ -1,10 +1,8 @@
-import { A as TsdownHooks, C as ChunkAddonObject, D as PackageType, E as OutExtensionObject, F as CopyOptions, I as CopyOptionsFn, L as AttwOptions, M as TsdownChunks, N as DebugOptions, O as BuildContext, P as CopyEntry, S as ChunkAddonFunction, T as OutExtensionFactory, _ as ReportOptions, a as NoExternalFn, b as globalLogger, c as ResolvedConfig, d as UnusedOptions, f as UserConfig, g as Workspace, h as WithEnabled, i as InlineConfig, j as ExportsOptions, k as RolldownContext, l as Sourcemap, m as UserConfigFn, n as DtsOptions, o as NormalizedFormat, p as UserConfigExport, r as Format, s as PublintOptions, t as CIOption, u as TreeshakingOptions, w as OutExtensionContext, x as ChunkAddon, y as Logger } from "./index-gX-yrJuu.mjs";
-import { t as defineConfig } from "./config-CsOGKn_i.mjs";
+import { A as OutExtensionObject, C as TsdownBundle, D as ChunkAddonObject, E as ChunkAddonFunction, F as TsdownHooks, I as DebugOptions, L as CopyEntry, M as PackageType, N as BuildContext, O as OutExtensionContext, P as RolldownContext, R as CopyOptions, S as RolldownChunk, T as ChunkAddon, _ as ReportOptions, a as NoExternalFn, b as globalLogger, c as ResolvedConfig, d as UnusedOptions, f as UserConfig, g as Workspace, h as WithEnabled, i as InlineConfig, j as PackageJsonWithPath, k as OutExtensionFactory, l as Sourcemap, m as UserConfigFn, n as DtsOptions, o as NormalizedFormat, p as UserConfigExport, r as Format, s as PublintOptions, t as CIOption, u as TreeshakingOptions, w as AttwOptions, x as ExportsOptions, y as Logger, z as CopyOptionsFn } from "./index-BQZ2CZuJ.mjs";
+import { t as defineConfig } from "./config-DPU-roRC.mjs";
 
 //#region src/index.d.ts
-interface TsdownBundle extends AsyncDisposable {
-  chunks: TsdownChunks;
-}
+
 /**
 * Build with tsdown.
 */
@@ -17,8 +15,8 @@ declare function build(userOptions?: InlineConfig): Promise<TsdownBundle[]>;
 * @private
 * @param config Resolved options
 */
-declare function buildSingle(config: ResolvedConfig, configFiles: string[], clean: () => Promise<void>, restart: () => void): Promise<TsdownBundle>;
+declare function buildSingle(config: ResolvedConfig, configFiles: string[], isDualFormat: boolean, clean: () => Promise<void>, restart: () => void, done: (bundle: TsdownBundle) => Promise<void>): Promise<TsdownBundle>;
 /** @internal */
 declare const shimFile: string;
 //#endregion
-export { AttwOptions, BuildContext, CIOption, ChunkAddon, ChunkAddonFunction, ChunkAddonObject, CopyEntry, CopyOptions, CopyOptionsFn, DebugOptions, DtsOptions, ExportsOptions, Format, InlineConfig, type Logger, NoExternalFn, NormalizedFormat, OutExtensionContext, OutExtensionFactory, OutExtensionObject, PackageType, PublintOptions, ReportOptions, ResolvedConfig, RolldownContext, Sourcemap, TreeshakingOptions, TsdownBundle, TsdownChunks, TsdownHooks, UnusedOptions, UserConfig, UserConfigExport, UserConfigFn, WithEnabled, Workspace, build, buildSingle, defineConfig, globalLogger, shimFile };
+export { AttwOptions, BuildContext, CIOption, ChunkAddon, ChunkAddonFunction, ChunkAddonObject, CopyEntry, CopyOptions, CopyOptionsFn, DebugOptions, DtsOptions, ExportsOptions, Format, InlineConfig, type Logger, NoExternalFn, NormalizedFormat, OutExtensionContext, OutExtensionFactory, OutExtensionObject, PackageJsonWithPath, PackageType, PublintOptions, ReportOptions, ResolvedConfig, RolldownChunk, RolldownContext, Sourcemap, TreeshakingOptions, TsdownBundle, TsdownHooks, UnusedOptions, UserConfig, UserConfigExport, UserConfigFn, WithEnabled, Workspace, build, buildSingle, defineConfig, globalLogger, shimFile };

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { t as defineConfig } from "./config-DLSWqKoz.mjs";
-import { n as buildSingle, r as shimFile, t as build } from "./src-Bz4Gwq5G.mjs";
-import { a as globalLogger } from "./package-xGnUa543.mjs";
+import { n as buildSingle, r as shimFile, t as build } from "./src-ipppZiPk.mjs";
+import { a as globalLogger } from "./package-CxZ5olT1.mjs";
 
 export { build, buildSingle, defineConfig, globalLogger, shimFile };

package/dist/{package-xGnUa543.mjs → package-CxZ5olT1.mjs}

@@ -42,6 +42,15 @@ async function importWithError(moduleName) {
 		throw new Error(`Failed to import module "${moduleName}". Please ensure it is installed.`, { cause: error });
 	}
 }
+function promiseWithResolvers() {
+	let resolve;
+	return {
+		promise: new Promise((res) => {
+			resolve = res;
+		}),
+		resolve
+	};
+}
 
 //#endregion
 //#region src/utils/logger.ts
@@ -150,7 +159,7 @@ function hue2rgb(p, q, t) {
 
 //#endregion
 //#region package.json
-var version = "0.17.0-beta.4";
+var version = "0.17.0-beta.5";
 
 //#endregion
-export { globalLogger as a, importWithError as c, pkgExists as d, resolveComma as f, toArray as h, generateColor as i, matchPattern as l, slash as m, LogLevels as n, prettyFormat as o, resolveRegex as p, createLogger as r, prettyName as s, version as t, noop as u };
+export { globalLogger as a, importWithError as c, pkgExists as d, promiseWithResolvers as f, toArray as g, slash as h, generateColor as i, matchPattern as l, resolveRegex as m, LogLevels as n, prettyFormat as o, resolveComma as p, createLogger as r, prettyName as s, version as t, noop as u };

package/dist/plugins.d.mts

@@ -1,5 +1,5 @@
-import { c as ResolvedConfig, v as ReportPlugin, y as Logger } from "./index-gX-yrJuu.mjs";
-import { OutputAsset, OutputChunk, Plugin } from "rolldown";
+import { C as TsdownBundle, c as ResolvedConfig, v as ReportPlugin, y as Logger } from "./index-BQZ2CZuJ.mjs";
+import { Plugin } from "rolldown";
 
 //#region src/features/external.d.ts
 declare function ExternalPlugin({
@@ -10,7 +10,7 @@ declare function ExternalPlugin({
 }: ResolvedConfig): Plugin;
 //#endregion
 //#region src/features/shebang.d.ts
-declare function ShebangPlugin(logger: Logger, cwd: string, name?: string, isMultiFormat?: boolean): Plugin;
+declare function ShebangPlugin(logger: Logger, cwd: string, name?: string, isDualFormat?: boolean): Plugin;
 //#endregion
 //#region src/features/node-protocol.d.ts
 /**
@@ -20,13 +20,9 @@ declare function ShebangPlugin(logger: Logger, cwd: string, name?: string, isMul
 declare function NodeProtocolPlugin(nodeProtocolOption: "strip" | true): Plugin;
 //#endregion
 //#region src/features/watch.d.ts
-interface WatchContext {
-  config: ResolvedConfig;
-  chunks: Array<OutputChunk | OutputAsset>;
-}
 declare function WatchPlugin(configFiles: string[], {
   config,
   chunks
-}: WatchContext): Plugin;
+}: TsdownBundle): Plugin;
 //#endregion
 export { ExternalPlugin, NodeProtocolPlugin, ReportPlugin, ShebangPlugin, WatchPlugin };

package/dist/plugins.mjs

@@ -1,5 +1,5 @@
 import "./config-DLSWqKoz.mjs";
-import { a as ShebangPlugin, c as ExternalPlugin, i as WatchPlugin, o as ReportPlugin, s as NodeProtocolPlugin } from "./src-Bz4Gwq5G.mjs";
-import "./package-xGnUa543.mjs";
+import { a as ShebangPlugin, c as ExternalPlugin, i as WatchPlugin, o as ReportPlugin, s as NodeProtocolPlugin } from "./src-ipppZiPk.mjs";
+import "./package-CxZ5olT1.mjs";
 
 export { ExternalPlugin, NodeProtocolPlugin, ReportPlugin, ShebangPlugin, WatchPlugin };

package/dist/run.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { a as globalLogger, f as resolveComma, h as toArray, t as version } from "./package-xGnUa543.mjs";
+import { a as globalLogger, g as toArray, p as resolveComma, t as version } from "./package-CxZ5olT1.mjs";
 import module from "node:module";
 import { dim } from "ansis";
 import { VERSION } from "rolldown";
@@ -29,7 +29,7 @@ cli.help().version(version);
 cli.command("[...files]", "Bundle files", {
 	ignoreOptionDefaultValue: true,
 	allowUnknownOptions: true
-}).option("-c, --config <filename>", "Use a custom config file").option("--config-loader <loader>", "Config loader to use: auto, native, unrun", { default: "auto" }).option("--no-config", "Disable config file").option("-f, --format <format>", "Bundle format: esm, cjs, iife, umd", { default: "esm" }).option("--clean", "Clean output directory, --no-clean to disable").option("--external <module>", "Mark dependencies as external").option("--minify", "Minify output").option("--debug", "Enable debug mode").option("--debug-logs [feat]", "Show debug logs").option("--target <target>", "Bundle target, e.g \"es2015\", \"esnext\"").option("-l, --logLevel <level>", "Set log level: info, warn, error, silent").option("--fail-on-warn", "Fail on warnings", { default: true }).option("-d, --out-dir <dir>", "Output directory", { default: "dist" }).option("--treeshake", "Tree-shake bundle", { default: true }).option("--sourcemap", "Generate source map", { default: false }).option("--shims", "Enable cjs and esm shims ", { default: false }).option("--platform <platform>", "Target platform", { default: "node" }).option("--dts", "Generate dts files").option("--publint", "Enable publint", { default: false }).option("--attw", "Enable Are the types wrong integration", { default: false }).option("--unused", "Enable unused dependencies check", { default: false }).option("-w, --watch [path]", "Watch mode").option("--ignore-watch <path>", "Ignore custom paths in watch mode").option("--from-vite [vitest]", "Reuse config from Vite or Vitest").option("--report", "Size report", { default: true }).option("--env.* <value>", "Define compile-time env variables").option("--on-success <command>", "Command to run on success").option("--copy <dir>", "Copy files to output dir").option("--public-dir <dir>", "Alias for --copy, deprecated").option("--tsconfig <tsconfig>", "Set tsconfig path").option("--unbundle", "Unbundle mode").option("-W, --workspace [dir]", "Enable workspace mode").option("-F, --filter <pattern>", "Filter configs (cwd or name), e.g. /pkg-name$/ or pkg-name").option("--exports", "Generate export-related metadata for package.json (experimental)").action(async (input, flags) => {
+}).option("-c, --config <filename>", "Use a custom config file").option("--config-loader <loader>", "Config loader to use: auto, native, unrun", { default: "auto" }).option("--no-config", "Disable config file").option("-f, --format <format>", "Bundle format: esm, cjs, iife, umd", { default: "esm" }).option("--clean", "Clean output directory, --no-clean to disable").option("--external <module>", "Mark dependencies as external").option("--minify", "Minify output").option("--debug", "Enable debug mode").option("--debug-logs [feat]", "Show debug logs").option("--target <target>", "Bundle target, e.g \"es2015\", \"esnext\"").option("-l, --logLevel <level>", "Set log level: info, warn, error, silent").option("--fail-on-warn", "Fail on warnings", { default: true }).option("--no-write", "Disable writing files to disk, incompatible with watch mode").option("-d, --out-dir <dir>", "Output directory", { default: "dist" }).option("--treeshake", "Tree-shake bundle", { default: true }).option("--sourcemap", "Generate source map", { default: false }).option("--shims", "Enable cjs and esm shims ", { default: false }).option("--platform <platform>", "Target platform", { default: "node" }).option("--dts", "Generate dts files").option("--publint", "Enable publint", { default: false }).option("--attw", "Enable Are the types wrong integration", { default: false }).option("--unused", "Enable unused dependencies check", { default: false }).option("-w, --watch [path]", "Watch mode").option("--ignore-watch <path>", "Ignore custom paths in watch mode").option("--from-vite [vitest]", "Reuse config from Vite or Vitest").option("--report", "Size report", { default: true }).option("--env.* <value>", "Define compile-time env variables").option("--on-success <command>", "Command to run on success").option("--copy <dir>", "Copy files to output dir").option("--public-dir <dir>", "Alias for --copy, deprecated").option("--tsconfig <tsconfig>", "Set tsconfig path").option("--unbundle", "Unbundle mode").option("-W, --workspace [dir]", "Enable workspace mode").option("-F, --filter <pattern>", "Filter configs (cwd or name), e.g. /pkg-name$/ or pkg-name").option("--exports", "Generate export-related metadata for package.json (experimental)").action(async (input, flags) => {
 	globalLogger.level = flags.logLevel || (flags.silent ? "error" : "info");
 	globalLogger.info(`tsdown ${dim`v${version}`} powered by rolldown ${dim`v${VERSION}`}`);
 	const { build: build$1 } = await import("./index.mjs");

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

@@ -1,11 +1,11 @@
 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-xGnUa543.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 { clearCJSCache, init, isSupported } from "import-without-cache";
+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";
@@ -16,13 +16,13 @@ import { RE_CSS, RE_DTS, RE_JS, RE_NODE_MODULES } from "rolldown-plugin-dts/file
 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";
@@ -167,8 +167,11 @@ async function loadConfigFile(inlineConfig, workspace) {
 		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 (configLoader === "auto") return !!(process.features.typescript || process.versions.bun || process.versions.deno) && isSupported ? "native" : "unrun";
+	if (configLoader === "auto") return autoLoader;
 	else return configLoader === "native" ? "native" : "unrun";
 }
 function createParser(loader) {
@@ -191,7 +194,7 @@ async function nativeImport(id) {
 	if (isSupported) {
 		importAttributes.cache = "no";
 		init();
-	} else url.searchParams.set("no-cache", crypto.randomUUID());
+	} 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;
@@ -294,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,
@@ -314,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)) {
@@ -331,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 = ".";
@@ -359,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
 	});
@@ -369,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
 		});
@@ -390,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;
 }
@@ -483,28 +482,26 @@ 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/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$10 = 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;
+		return [];
 	}
 	const logger = createLogger(logLevel, {
 		customLogger,
@@ -527,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) {
@@ -556,7 +558,7 @@ async function resolveUserConfig(userConfig, inlineConfig) {
 		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");
-	return {
+	const config = {
 		...userConfig,
 		alias,
 		attw: attw$1,
@@ -571,7 +573,6 @@ async function resolveUserConfig(userConfig, inlineConfig) {
 		exports,
 		external,
 		fixedExtension,
-		format: normalizeFormat(format),
 		globImport,
 		hash,
 		ignoreWatch,
@@ -594,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;
@@ -693,8 +708,9 @@ async function resolveConfig(inlineConfig) {
 	} 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)))).filter((config) => !!config);
+		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.");
@@ -705,7 +721,69 @@ async function resolveConfig(inlineConfig) {
 }
 
 //#endregion
-//#region src/features/attw.ts
+//#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]`;
 /**
@@ -794,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) {
@@ -895,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");
@@ -1093,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
@@ -1124,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}`);
@@ -1168,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) {
@@ -1177,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);
 				}
 			}
@@ -1194,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",
@@ -1209,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));
 			}
 		}
 	};
@@ -1222,17 +1308,18 @@ 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) {
+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));
@@ -1261,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,
@@ -1422,18 +1509,22 @@ async function build$1(userOptions = {}) {
 		if (restarting) return;
 		restarting = true;
 		await Promise.all(disposeCbs.map((cb) => cb()));
-		clearCJSCache();
+		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({
@@ -1452,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;
@@ -1501,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":
@@ -1529,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);
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsdown",
-  "version": "0.17.0-beta.4",
+  "version": "0.17.0-beta.5",
   "description": "The Elegant Bundler for Libraries",
   "type": "module",
   "license": "MIT",
@@ -77,7 +77,7 @@
     "cac": "^6.7.14",
     "empathic": "^2.0.0",
     "hookable": "^5.5.3",
-    "import-without-cache": "^0.1.3",
+    "import-without-cache": "^0.2.0",
     "obug": "^2.1.1",
     "rolldown": "1.0.0-beta.52",
     "rolldown-plugin-dts": "^0.18.1",
@@ -122,7 +122,7 @@
     "lint": "eslint --cache --max-warnings 0 .",
     "lint:fix": "pnpm run lint --fix",
     "build": "unrun ./src/run.ts",
-    "dev": "unrun ./src/run.ts",
+    "dev": "node ./src/run.ts",
     "test": "vitest",
     "typecheck": "tsc --noEmit",
     "format": "prettier --cache --write .",