rolldown 0.14.0-snapshot-d42ea8a-20241202003632 → 0.15.0-commit.ac58858

package/dist/shared/{src-DhHfkqAC.mjs → src-C-NQjnqV.mjs}

@@ -1,5 +1,6 @@
-import { createRequire as createRequire$1 } from "module";
-import { z, z as z$1 } from "zod";
+import { createRequire } from "module";
+import { Buffer as Buffer$1 } from "node:buffer";
+import { z } from "zod";
 import path, { default as path$1 } from "node:path";
 import { Worker } from "node:worker_threads";
 import { availableParallelism } from "node:os";
@@ -14,12 +15,6 @@ var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __commonJS = (cb, mod) => function() {
 	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
-var __export = (target, all) => {
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-};
 var __copyProps = (to, from, except, desc) => {
 	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
 		key = keys[i];
@@ -34,7 +29,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	value: mod,
 	enumerable: true
 }) : target, mod));
-var __require = /* @__PURE__ */ createRequire$1(import.meta.url);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 //#endregion
 //#region src/utils/define-config.ts
@@ -68,7 +63,11 @@ function bindingifySourcemap$1(map) {
 //#endregion
 //#region src/utils/error.ts
 function normalizeErrors(rawErrors) {
-	const errors = rawErrors.map((e) => e instanceof Error ? e : Object.assign(new Error(), e, { stack: undefined }));
+	const errors = rawErrors.map((e) => e instanceof Error ? e : Object.assign(new Error(), {
+		kind: e.kind,
+		message: e.message,
+		stack: undefined
+	}));
 	let summary = `Build failed with ${errors.length} error${errors.length < 2 ? "" : "s"}:\n`;
 	for (let i = 0; i < errors.length; i++) {
 		if (i >= 5) {
@@ -140,6 +139,19 @@ function transformChunkModules(modules) {
 
 //#endregion
 //#region src/utils/transform-to-rollup-output.ts
+function transformToRollupSourceMap(map) {
+	const parsed = JSON.parse(map);
+	const obj = {
+		...parsed,
+		toString() {
+			return JSON.stringify(obj);
+		},
+		toUrl() {
+			return `data:application/json;charset=utf-8;base64,${Buffer$1.from(obj.toString(), "utf-8").toString("base64")}`;
+		}
+	};
+	return obj;
+}
 function transformToRollupOutputChunk(bindingChunk, changed) {
 	const chunk = {
 		type: "chunk",
@@ -165,7 +177,7 @@ function transformToRollupOutputChunk(bindingChunk, changed) {
 			return bindingChunk.moduleIds;
 		},
 		get map() {
-			return bindingChunk.map ? JSON.parse(bindingChunk.map) : null;
+			return bindingChunk.map ? transformToRollupSourceMap(bindingChunk.map) : null;
 		},
 		sourcemapFileName: bindingChunk.sourcemapFileName || null,
 		preliminaryFileName: bindingChunk.preliminaryFileName
@@ -188,10 +200,12 @@ function transformToRollupOutputAsset(bindingAsset, changed) {
 		type: "asset",
 		fileName: bindingAsset.fileName,
 		originalFileName: bindingAsset.originalFileName || null,
+		originalFileNames: bindingAsset.originalFileNames,
 		get source() {
 			return transformAssetSource(bindingAsset.source);
 		},
-		name: bindingAsset.name ?? undefined
+		name: bindingAsset.name ?? undefined,
+		names: bindingAsset.names
 	};
 	const cache = {};
 	return new Proxy(asset, {
@@ -230,9 +244,9 @@ function collectChangedBundle(changed, bundle) {
 		const item = bundle[key];
 		if (item.type === "asset") assets.push({
 			filename: item.fileName,
-			originalFileName: item.originalFileName || undefined,
+			originalFileNames: item.originalFileNames,
 			source: bindingAssetSource(item.source),
-			name: item.name
+			names: item.names
 		});
 else chunks.push({
 			code: item.code,
@@ -240,7 +254,7 @@ else chunks.push({
 			name: item.name,
 			isEntry: item.isEntry,
 			exports: item.exports,
-			modules: Object.fromEntries(Object.entries(item.modules).map(([key$1, _]) => [key$1, {}])),
+			modules: {},
 			imports: item.imports,
 			dynamicImports: item.dynamicImports,
 			facadeModuleId: item.facadeModuleId || undefined,
@@ -261,7 +275,7 @@ else chunks.push({
 //#endregion
 //#region src/binding.js
 var require_binding = __commonJS({ "src/binding.js"(exports, module) {
-	const { createRequire } = __require("node:module");
+	const { createRequire: createRequire$1 } = __require("node:module");
 	const { readFileSync } = __require("node:fs");
 	let nativeBinding = null;
 	const loadErrors = [];
@@ -549,6 +563,7 @@ else loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architectur
 	}
 	module.exports.BindingBundleEndEventData = nativeBinding.BindingBundleEndEventData;
 	module.exports.BindingCallableBuiltinPlugin = nativeBinding.BindingCallableBuiltinPlugin;
+	module.exports.BindingError = nativeBinding.BindingError;
 	module.exports.BindingLog = nativeBinding.BindingLog;
 	module.exports.BindingModuleInfo = nativeBinding.BindingModuleInfo;
 	module.exports.BindingNormalizedOptions = nativeBinding.BindingNormalizedOptions;
@@ -567,8 +582,10 @@ else loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architectur
 	module.exports.BindingHookSideEffects = nativeBinding.BindingHookSideEffects;
 	module.exports.BindingLogLevel = nativeBinding.BindingLogLevel;
 	module.exports.BindingPluginOrder = nativeBinding.BindingPluginOrder;
+	module.exports.HelperMode = nativeBinding.HelperMode;
 	module.exports.isolatedDeclaration = nativeBinding.isolatedDeclaration;
 	module.exports.registerPlugins = nativeBinding.registerPlugins;
+	module.exports.Severity = nativeBinding.Severity;
 	module.exports.transform = nativeBinding.transform;
 } });
 
@@ -597,9 +614,9 @@ function noop(..._args) {}
 
 //#endregion
 //#region src/log/logging.ts
-const LogLevelSchema = z$1.literal("info").or(z$1.literal("debug")).or(z$1.literal("warn"));
-const LogLevelOptionSchema = LogLevelSchema.or(z$1.literal("silent"));
-const LogLevelWithErrorSchema = LogLevelSchema.or(z$1.literal("error"));
+const LogLevelSchema = z.literal("info").or(z.literal("debug")).or(z.literal("warn"));
+const LogLevelOptionSchema = LogLevelSchema.or(z.literal("silent"));
+const LogLevelWithErrorSchema = LogLevelSchema.or(z.literal("error"));
 const LOG_LEVEL_SILENT = "silent";
 const LOG_LEVEL_ERROR = "error";
 const LOG_LEVEL_WARN = "warn";
@@ -611,8 +628,8 @@ const logLevelPriority = {
 	[LOG_LEVEL_WARN]: 2,
 	[LOG_LEVEL_SILENT]: 3
 };
-const RollupLogSchema = z$1.any();
-const RollupLogWithStringSchema = RollupLogSchema.or(z$1.string());
+const RollupLogSchema = z.any();
+const RollupLogWithStringSchema = RollupLogSchema.or(z.string());
 
 //#endregion
 //#region src/utils/code-frame.ts
@@ -706,7 +723,7 @@ function locate(source, search, options) {
 
 //#endregion
 //#region src/log/logs.ts
-const INVALID_LOG_POSITION = "INVALID_LOG_POSITION", PLUGIN_ERROR = "PLUGIN_ERROR", INPUT_HOOK_IN_OUTPUT_PLUGIN = "INPUT_HOOK_IN_OUTPUT_PLUGIN", CYCLE_LOADING = "CYCLE_LOADING";
+const INVALID_LOG_POSITION = "INVALID_LOG_POSITION", PLUGIN_ERROR = "PLUGIN_ERROR", INPUT_HOOK_IN_OUTPUT_PLUGIN = "INPUT_HOOK_IN_OUTPUT_PLUGIN", CYCLE_LOADING = "CYCLE_LOADING", MULTIPLY_NOTIFY_OPTION = "MULTIPLY_NOTIFY_OPTION";
 function logInvalidLogPosition(pluginName) {
 	return {
 		code: INVALID_LOG_POSITION,
@@ -725,6 +742,12 @@ function logCycleLoading(pluginName, moduleId) {
 		message: `Found the module "${moduleId}" cycle loading at ${pluginName} plugin, it maybe blocking fetching modules.`
 	};
 }
+function logMultiplyNotifyOption() {
+	return {
+		code: MULTIPLY_NOTIFY_OPTION,
+		message: `Found multiply notify option at watch options, using first one to start notify watcher.`
+	};
+}
 function logPluginError(error$1, plugin, { hook, id } = {}) {
 	const code = error$1.code;
 	if (!error$1.pluginCode && code != null && (typeof code !== "string" || !code.startsWith("PLUGIN_"))) error$1.pluginCode = code;
@@ -880,9 +903,9 @@ function relativeId(id) {
 
 //#endregion
 //#region src/builtin-plugin/utils.ts
-var import_binding$5 = __toESM(require_binding());
+var import_binding$6 = __toESM(require_binding());
 function makeBuiltinPluginCallable(plugin) {
-	let callablePlugin = new import_binding$5.BindingCallableBuiltinPlugin(bindingifyBuiltInPlugin(plugin));
+	let callablePlugin = new import_binding$6.BindingCallableBuiltinPlugin(bindingifyBuiltInPlugin(plugin));
 	const wrappedPlugin = plugin;
 	for (const key in callablePlugin) wrappedPlugin[key] = function(...args) {
 		return callablePlugin[key](...args);
@@ -1115,7 +1138,7 @@ const ModuleSideEffectsRuleSchema = z.object({
 }).refine((data) => {
 	return data.test !== undefined || data.external !== undefined;
 }, "Either `test` or `external` should be set.");
-const ModuleSideEffectsOptionSchema = z.boolean().or(z.array(ModuleSideEffectsRuleSchema)).or(z.literal("no-external"));
+const ModuleSideEffectsOptionSchema = z.boolean().or(z.array(ModuleSideEffectsRuleSchema)).or(z.function().args(z.string(), z.boolean()).returns(z.boolean().optional())).or(z.literal("no-external"));
 const TreeshakingOptionsSchema = z.object({
 	moduleSideEffects: ModuleSideEffectsOptionSchema.optional(),
 	annotations: z.boolean().optional()
@@ -1182,12 +1205,12 @@ var MinimalPluginContext = class {
 
 //#endregion
 //#region src/utils/transform-side-effects.ts
-var import_binding$4 = __toESM(require_binding());
+var import_binding$5 = __toESM(require_binding());
 function bindingifySideEffects(sideEffects) {
 	switch (sideEffects) {
-		case true: return import_binding$4.BindingHookSideEffects.True;
-		case false: return import_binding$4.BindingHookSideEffects.False;
-		case "no-treeshake": return import_binding$4.BindingHookSideEffects.NoTreeshake;
+		case true: return import_binding$5.BindingHookSideEffects.True;
+		case false: return import_binding$5.BindingHookSideEffects.False;
+		case "no-treeshake": return import_binding$5.BindingHookSideEffects.NoTreeshake;
 		case null:
 		case undefined: return undefined;
 		default: throw new Error(`Unexpected side effects: ${sideEffects}`);
@@ -1298,14 +1321,14 @@ var TransformPluginContext = class extends PluginContext {
 
 //#endregion
 //#region src/plugin/bindingify-plugin-hook-meta.ts
-var import_binding$3 = __toESM(require_binding());
+var import_binding$4 = __toESM(require_binding());
 function bindingifyPluginHookMeta(options) {
 	return { order: bindingPluginOrder(options.order) };
 }
 function bindingPluginOrder(order) {
 	switch (order) {
-		case "post": return import_binding$3.BindingPluginOrder.Post;
-		case "pre": return import_binding$3.BindingPluginOrder.Pre;
+		case "post": return import_binding$4.BindingPluginOrder.Post;
+		case "pre": return import_binding$4.BindingPluginOrder.Pre;
 		case null:
 		case undefined: return undefined;
 		default: throw new Error(`Unknown plugin order: ${order}`);
@@ -1386,7 +1409,7 @@ function bindingifyBuildEnd(args) {
 	const { handler, meta } = normalizeHook(hook);
 	return {
 		plugin: async (ctx, err) => {
-			await handler.call(new PluginContext(ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel), err ? new Error(err) : undefined);
+			await handler.call(new PluginContext(ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel), err ? normalizeErrors(err) : undefined);
 		},
 		meta: bindingifyPluginHookMeta(meta)
 	};
@@ -1613,6 +1636,9 @@ var NormalizedOutputOptionsImpl = class {
 	get comments() {
 		return this.inner.comments;
 	}
+	get polyfillRequire() {
+		return this.inner.polyfillRequire;
+	}
 };
 
 //#endregion
@@ -1663,7 +1689,7 @@ function bindingifyRenderError(args) {
 	const { handler, meta } = normalizeHook(hook);
 	return {
 		plugin: async (ctx, err) => {
-			handler.call(new PluginContext(ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel), new Error(err));
+			handler.call(new PluginContext(ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel), normalizeErrors(err));
 		},
 		meta: bindingifyPluginHookMeta(meta)
 	};
@@ -1964,7 +1990,7 @@ function normalizedStringOrRegex(pattern) {
 
 //#endregion
 //#region src/utils/bindingify-input-options.ts
-var import_binding$2 = __toESM(require_binding());
+var import_binding$3 = __toESM(require_binding());
 function bindingifyInputOptions(rawPlugins, inputOptions, outputOptions, onLog, logLevel) {
 	const pluginContextData = new PluginContextData();
 	const plugins = rawPlugins.map((plugin) => {
@@ -1995,7 +2021,9 @@ function bindingifyInputOptions(rawPlugins, inputOptions, outputOptions, onLog,
 		profilerNames: inputOptions?.profilerNames,
 		jsx: bindingifyJsx(inputOptions.jsx),
 		watch: bindingifyWatch(inputOptions.watch),
-		dropLabels: inputOptions.dropLabels
+		dropLabels: inputOptions.dropLabels,
+		keepNames: inputOptions.keepNames,
+		checks: inputOptions.checks
 	};
 }
 function bindingifyExternal(external) {
@@ -2019,7 +2047,7 @@ function bindingifyResolve(resolve) {
 		return {
 			alias: alias ? Object.entries(alias).map(([name, replacement]) => ({
 				find: name,
-				replacements: [replacement]
+				replacements: arraify(replacement)
 			})) : undefined,
 			extensionAlias: extensionAlias ? Object.entries(extensionAlias).map(([name, value]) => ({
 				target: name,
@@ -2053,10 +2081,10 @@ function bindingifyInject(inject) {
 }
 function bindingifyLogLevel(logLevel) {
 	switch (logLevel) {
-		case "silent": return import_binding$2.BindingLogLevel.Silent;
-		case "debug": return import_binding$2.BindingLogLevel.Debug;
-		case "warn": return import_binding$2.BindingLogLevel.Warn;
-		case "info": return import_binding$2.BindingLogLevel.Info;
+		case "silent": return import_binding$3.BindingLogLevel.Silent;
+		case "debug": return import_binding$3.BindingLogLevel.Debug;
+		case "warn": return import_binding$3.BindingLogLevel.Warn;
+		case "info": return import_binding$3.BindingLogLevel.Info;
 		default: throw new Error(`Unexpected log level: ${logLevel}`);
 	}
 }
@@ -2091,10 +2119,6 @@ function bindingifyWatch(watch$1) {
 			include: normalizedStringOrRegex(watch$1.include),
 			exclude: normalizedStringOrRegex(watch$1.exclude)
 		};
-		if (watch$1.notify) value.notify = {
-			pollInterval: watch$1.notify.pollInterval,
-			compareContents: watch$1.notify.compareContents
-		};
 		if (watch$1.chokidar) unsupported("The watch chokidar option is deprecated, please use notify options instead of it.");
 		return value;
 	}
@@ -2149,7 +2173,8 @@ function bindingifyOutputOptions(outputOptions) {
 		minify: outputOptions.minify,
 		externalLiveBindings: outputOptions.externalLiveBindings,
 		inlineDynamicImports: outputOptions.inlineDynamicImports,
-		advancedChunks: outputOptions.advancedChunks
+		advancedChunks: outputOptions.advancedChunks,
+		polyfillRequire: outputOptions.polyfillRequire
 	};
 }
 function bindingifyAddon(configAddon) {
@@ -2535,7 +2560,7 @@ else newPlugins.push(toBeComposed[0]);
 
 //#endregion
 //#region src/utils/initialize-parallel-plugins.ts
-var import_binding$1 = __toESM(require_binding());
+var import_binding$2 = __toESM(require_binding());
 async function initializeParallelPlugins(plugins) {
 	const pluginInfos = [];
 	for (const [index, plugin] of plugins.entries()) if ("_parallel" in plugin) {
@@ -2548,7 +2573,7 @@ async function initializeParallelPlugins(plugins) {
 	}
 	if (pluginInfos.length <= 0) return undefined;
 	const count = Math.min(availableParallelism(), 8);
-	const parallelJsPluginRegistry = new import_binding$1.ParallelJsPluginRegistry(count);
+	const parallelJsPluginRegistry = new import_binding$2.ParallelJsPluginRegistry(count);
 	const registryId = parallelJsPluginRegistry.id;
 	const workers = await initializeWorkers(registryId, count, pluginInfos);
 	const stopWorkers = async () => {
@@ -2564,14 +2589,14 @@ function initializeWorkers(registryId, count, pluginInfos) {
 }
 async function initializeWorker(registryId, pluginInfos, threadNumber) {
 	const urlString = import.meta.resolve("#parallel-plugin-worker");
-	const workerData = {
+	const workerData$1 = {
 		registryId,
 		pluginInfos,
 		threadNumber
 	};
 	let worker;
 	try {
-		worker = new Worker(new URL(urlString), { workerData });
+		worker = new Worker(new URL(urlString), { workerData: workerData$1 });
 		worker.unref();
 		await new Promise((resolve, reject) => {
 			worker.once("message", async (message) => {
@@ -2587,9 +2612,8 @@ else resolve();
 }
 
 //#endregion
-//#region src/utils/create-bundler.ts
-var import_binding = __toESM(require_binding());
-async function createBundler(inputOptions, outputOptions) {
+//#region src/utils/create-bundler-option.ts
+async function createBundlerOptions(inputOptions, outputOptions) {
 	const pluginDriver = new PluginDriver();
 	inputOptions = await pluginDriver.callOptionsHook(inputOptions);
 	if (inputOptions.treeshake !== undefined) TreeshakingOptionsSchema.parse(inputOptions.treeshake);
@@ -2605,7 +2629,13 @@ async function createBundler(inputOptions, outputOptions) {
 		const bindingInputOptions = bindingifyInputOptions(plugins, inputOptions, outputOptions, onLog, logLevel);
 		const bindingOutputOptions = bindingifyOutputOptions(outputOptions);
 		return {
-			bundler: new import_binding.Bundler(bindingInputOptions, bindingOutputOptions, parallelPluginInitResult?.registry),
+			bundlerOptions: {
+				inputOptions: bindingInputOptions,
+				outputOptions: bindingOutputOptions,
+				parallelPluginsRegistry: parallelPluginInitResult?.registry
+			},
+			inputOptions,
+			onLog,
 			stopWorkers: parallelPluginInitResult?.stopWorkers
 		};
 	} catch (e) {
@@ -2615,7 +2645,23 @@ async function createBundler(inputOptions, outputOptions) {
 }
 
 //#endregion
-//#region src/rolldown-build.ts
+//#region src/utils/create-bundler.ts
+var import_binding$1 = __toESM(require_binding());
+async function createBundler(inputOptions, outputOptions) {
+	const option = await createBundlerOptions(inputOptions, outputOptions);
+	try {
+		return {
+			bundler: new import_binding$1.Bundler(option.bundlerOptions),
+			stopWorkers: option.stopWorkers
+		};
+	} catch (e) {
+		await option.stopWorkers?.();
+		throw e;
+	}
+}
+
+//#endregion
+//#region src/api/rolldown/rolldown-build.ts
 Symbol.asyncDispose ??= Symbol("Symbol.asyncDispose");
 var RolldownBuild = class {
 	#inputOptions;
@@ -2651,111 +2697,155 @@ var RolldownBuild = class {
 };
 
 //#endregion
-//#region src/watcher.ts
+//#region src/api/rolldown/index.ts
+const rolldown = async (input) => {
+	return new RolldownBuild(input);
+};
+
+//#endregion
+//#region src/api/watch/watch-emitter.ts
+var WatcherEmitter = class {
+	listeners = new Map();
+	timer;
+	constructor() {
+		this.timer = setInterval(
+			() => {},
+			1e9
+			/* Low power usage */
+);
+	}
+	on(event, listener) {
+		const listeners = this.listeners.get(event);
+		if (listeners) listeners.push(listener);
+else this.listeners.set(event, [listener]);
+		return this;
+	}
+	async onEvent(event) {
+		const listeners = this.listeners.get(event.eventKind());
+		if (listeners) switch (event.eventKind()) {
+			case "close":
+			case "restart":
+				for (const listener of listeners) await listener();
+				break;
+			case "event":
+				for (const listener of listeners) {
+					const code = event.bundleEventKind();
+					switch (code) {
+						case "BUNDLE_END":
+							const { duration, output } = event.bundleEndData();
+							await listener({
+								code: "BUNDLE_END",
+								duration,
+								output: [output]
+							});
+							break;
+						case "ERROR":
+							const errors = event.errors();
+							await listener({
+								code: "ERROR",
+								error: normalizeErrors(errors)
+							});
+							break;
+						default:
+							await listener({ code });
+							break;
+					}
+				}
+				break;
+			case "change":
+				for (const listener of listeners) {
+					const { path: path$2, kind } = event.watchChangeData();
+					await listener(path$2, { event: kind });
+				}
+				break;
+			default: throw new Error(`Unknown event: ${event}`);
+		}
+	}
+	async close() {
+		clearInterval(this.timer);
+	}
+};
+
+//#endregion
+//#region src/api/watch/watcher.ts
+var import_binding = __toESM(require_binding());
 var Watcher = class {
 	closed;
-	controller;
 	inner;
+	emitter;
 	stopWorkers;
-	listeners = new Map();
-	constructor(inner, stopWorkers) {
+	constructor(emitter, inner, stopWorkers) {
 		this.closed = false;
-		this.controller = new AbortController();
 		this.inner = inner;
+		this.emitter = emitter;
+		const originClose = emitter.close.bind(emitter);
+		emitter.close = async () => {
+			await this.close();
+			originClose();
+		};
 		this.stopWorkers = stopWorkers;
 	}
 	async close() {
+		if (this.closed) return;
 		this.closed = true;
-		await this.stopWorkers?.();
+		for (const stop of this.stopWorkers) await stop?.();
 		await this.inner.close();
-		this.controller.abort();
-	}
-	on(event, listener) {
-		const listeners = this.listeners.get(event);
-		if (listeners) listeners.push(listener);
-else this.listeners.set(event, [listener]);
-		return this;
 	}
-	watch() {
-		const timer = setInterval(
-			() => {},
-			1e9
-			/* Low power usage */
-);
-		this.controller.signal.addEventListener("abort", () => {
-			clearInterval(timer);
-		});
-		process.nextTick(() => this.inner.start(async (event) => {
-			const listeners = this.listeners.get(event.eventKind());
-			if (listeners) switch (event.eventKind()) {
-				case "close":
-				case "restart":
-					for (const listener of listeners) await listener();
-					break;
-				case "event":
-					for (const listener of listeners) {
-						const code = event.bundleEventKind();
-						switch (code) {
-							case "BUNDLE_END":
-								const { duration, output } = event.bundleEndData();
-								await listener({
-									code: "BUNDLE_END",
-									duration,
-									output: [output]
-								});
-								break;
-							case "ERROR":
-								const errors = event.errors();
-								await listener({
-									code: "ERROR",
-									error: normalizeErrors(errors)
-								});
-								break;
-							default:
-								await listener({ code });
-								break;
-						}
-					}
-					break;
-				case "change":
-					for (const listener of listeners) {
-						const { path: path$2, kind } = event.watchChangeData();
-						await listener(path$2, { event: kind });
-					}
-					break;
-				default: throw new Error(`Unknown event: ${event}`);
-			}
-		}));
+	start() {
+		process.nextTick(() => this.inner.start(this.emitter.onEvent.bind(this.emitter)));
 	}
 };
+async function createWatcher(emitter, input) {
+	const options = Array.isArray(input) ? input : [input];
+	const bundlerOptions = await Promise.all(options.map((option) => createBundlerOptions(option, option.output || {})));
+	const notifyOptions = getValidNotifyOption(bundlerOptions);
+	const bindingWatcher = new import_binding.BindingWatcher(bundlerOptions.map((option) => option.bundlerOptions), notifyOptions);
+	const watcher = new Watcher(emitter, bindingWatcher, bundlerOptions.map((option) => option.stopWorkers));
+	watcher.start();
+}
+function getValidNotifyOption(bundlerOptions) {
+	let result;
+	for (const option of bundlerOptions) if (option.inputOptions.watch) {
+		const notifyOption = option.inputOptions.watch.notify;
+		if (notifyOption) if (result) {
+			option.onLog(LOG_LEVEL_WARN, logMultiplyNotifyOption());
+			return result;
+		} else result = notifyOption;
+	}
+}
 
 //#endregion
-//#region src/rolldown.ts
-const rolldown = async (input) => {
-	return new RolldownBuild(input);
-};
-const watch = async (input) => {
-	const { bundler, stopWorkers } = await createBundler(input, input.output || {});
-	const bindingWatcher = await bundler.watch();
-	const watcher = new Watcher(bindingWatcher, stopWorkers);
-	watcher.watch();
-	return watcher;
-};
-const experimental_scan = async (input) => {
-	const { bundler, stopWorkers } = await createBundler(input, {});
-	const output = await bundler.scan();
-	handleOutputErrors(output);
-	await stopWorkers?.();
+//#region src/api/watch/index.ts
+const watch = (input) => {
+	const emitter = new WatcherEmitter();
+	createWatcher(emitter, input);
+	return emitter;
 };
 
 //#endregion
 //#region package.json
-var version = "0.14.0";
+var version = "0.15.0-commit.ac58858";
 var description = "Fast JavaScript/TypeScript bundler in Rust with Rollup-compatible API.";
 
+//#endregion
+//#region src/api/build.ts
+async function build(options) {
+	if (Array.isArray(options)) return Promise.all(options.map((opts) => build(opts)));
+else {
+		const { output, write = true,...inputOptions } = options;
+		const build$1 = await rolldown(inputOptions);
+		try {
+			if (write) return await build$1.write(output);
+else return await build$1.generate(output);
+		} finally {
+			await build$1.close();
+		}
+	}
+}
+
 //#endregion
 //#region src/index.ts
 const VERSION = version;
 
 //#endregion
-export { BuiltinPlugin, LogLevelOptionSchema, LogLevelSchema, LogLevelWithErrorSchema, PluginContextData, RollupLogSchema, RollupLogWithStringSchema, TreeshakingOptionsSchema, VERSION, __export, __toESM, arraify, bindingifyPlugin, buildImportAnalysisPlugin, composeJsPlugins, defineConfig, description, dynamicImportVarsPlugin, experimental_scan, importGlobPlugin, jsonPlugin, loadFallbackPlugin, manifestPlugin, modulePreloadPolyfillPlugin, normalizedStringOrRegex, require_binding, rolldown, version, viteResolvePlugin, wasmFallbackPlugin, wasmHelperPlugin, watch };
+export { BuiltinPlugin, LogLevelOptionSchema, LogLevelSchema, LogLevelWithErrorSchema, PluginContextData, RollupLogSchema, RollupLogWithStringSchema, TreeshakingOptionsSchema, VERSION, __toESM, arraify, bindingifyPlugin, build, buildImportAnalysisPlugin, composeJsPlugins, createBundler, defineConfig, description, dynamicImportVarsPlugin, handleOutputErrors, importGlobPlugin, jsonPlugin, loadFallbackPlugin, manifestPlugin, modulePreloadPolyfillPlugin, normalizedStringOrRegex, require_binding, rolldown, version, viteResolvePlugin, wasmFallbackPlugin, wasmHelperPlugin, watch };