@rolldown/browser 1.0.0-beta.44 → 1.0.0-beta.46

package/dist/shared/{src-BnIhK3nA.mjs → src-B8saaB3b.mjs}

@@ -1,7 +1,7 @@
-import { a as logCycleLoading, c as logDeprecatedInject, d as logInputHookInOutputPlugin, f as logInvalidLogPosition, h as styleText, i as error, l as logDeprecatedKeepNames, m as logPluginError, o as logDeprecatedDefine, p as logMultiplyNotifyOption, r as augmentCodeLocation, s as logDeprecatedDropLabels, t as parseAst, u as logDeprecatedProfilerNames } from "./parse-ast-index-Ck5SwMSC.mjs";
-import { a as include, c as or, d as arraify, g as unsupported, h as unreachable, i as id, m as unimplemented, n as code, o as moduleType, p as noop, r as exclude, t as and } from "./dist-DNFKY37q.mjs";
+import { n as __toESM, t as require_binding } from "./binding-BeWSOIj5.mjs";
+import { a as logCycleLoading, c as logDeprecatedInject, d as logInputHookInOutputPlugin, f as logInvalidLogPosition, h as styleText, i as error, l as logDeprecatedKeepNames, m as logPluginError, o as logDeprecatedDefine, p as logMultiplyNotifyOption, r as augmentCodeLocation, s as logDeprecatedDropLabels, t as parseAst, u as logDeprecatedProfilerNames } from "./parse-ast-index-DMI5m8Lk.mjs";
+import { a as include, c as or, d as arraify, g as unsupported, h as unreachable, i as id, m as unimplemented, n as code, o as moduleType, p as noop, r as exclude, t as and } from "./composable-filters-CgRsnfr3.mjs";
 import { Worker, isMainThread } from "node:worker_threads";
-import { BindingAttachDebugInfo, BindingBundler, BindingCallableBuiltinPlugin, BindingChunkModuleOrderBy, BindingLogLevel, BindingMagicString, BindingMagicString as BindingMagicString$1, BindingPluginOrder, BindingPropertyReadSideEffects, BindingPropertyWriteSideEffects, BindingWatcher, ParallelJsPluginRegistry, initTraceSubscriber, shutdownAsyncRuntime, startAsyncRuntime } from "../rolldown-binding.wasi.cjs";
 import path from "node:path";
 import fsp from "node:fs/promises";
 import os from "node:os";
@@ -208,8 +208,9 @@ const { onExit, load, unload } = signalExitWrap(processOk(process$1) ? new Signa
 
 //#endregion
 //#region src/setup.ts
+var import_binding$8 = /* @__PURE__ */ __toESM(require_binding(), 1);
 if (isMainThread) {
-	const subscriberGuard = initTraceSubscriber();
+	const subscriberGuard = (0, import_binding$8.initTraceSubscriber)();
 	onExit(() => {
 		subscriberGuard?.close();
 	});
@@ -217,11 +218,12 @@ if (isMainThread) {
 
 //#endregion
 //#region package.json
-var version = "1.0.0-beta.44";
+var version = "1.0.0-beta.46";
 var description$1 = "Fast JavaScript/TypeScript bundler in Rust with Rollup-compatible API.";
 
 //#endregion
 //#region src/builtin-plugin/utils.ts
+var import_binding$7 = /* @__PURE__ */ __toESM(require_binding(), 1);
 var BuiltinPlugin = class {
 	constructor(name, _options) {
 		this.name = name;
@@ -229,7 +231,7 @@ var BuiltinPlugin = class {
 	}
 };
 function makeBuiltinPluginCallable(plugin) {
-	let callablePlugin = new BindingCallableBuiltinPlugin(bindingifyBuiltInPlugin(plugin));
+	let callablePlugin = new import_binding$7.BindingCallableBuiltinPlugin(bindingifyBuiltInPlugin(plugin));
 	const wrappedPlugin = plugin;
 	for (const key in callablePlugin) wrappedPlugin[key] = async function(...args$1) {
 		try {
@@ -1381,6 +1383,25 @@ function tuple(items, message2) {
 	};
 }
 /* @__NO_SIDE_EFFECTS__ */
+function undefined_(message2) {
+	return {
+		kind: "schema",
+		type: "undefined",
+		reference: undefined_,
+		expects: "undefined",
+		async: false,
+		message: message2,
+		get "~standard"() {
+			return /* @__PURE__ */ _getStandardProps(this);
+		},
+		"~run"(dataset, config2) {
+			if (dataset.value === void 0) dataset.typed = true;
+			else _addIssue(this, "type", dataset, config2);
+			return dataset;
+		}
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
 function _subIssues(datasets) {
 	let issues;
 	if (datasets) for (const dataset of datasets) if (issues) issues.push(...dataset.issues);
@@ -1632,6 +1653,9 @@ function flattenValibotSchema(schema, result = {}, prefix = "") {
 //#endregion
 //#region src/utils/validator.ts
 const StringOrRegExpSchema = union([string(), instance(RegExp)]);
+function vFunction() {
+	return function_();
+}
 const LogLevelSchema = union([
 	literal("debug"),
 	literal("info"),
@@ -1646,14 +1670,15 @@ const InputOptionSchema = union([
 	array(string()),
 	record(string(), string())
 ]);
-const ExternalSchema = union([
+const ExternalOptionFunctionSchema = pipe(vFunction(), args(tuple([
+	string(),
+	optional(string()),
+	boolean()
+])), returns(nullish(boolean())));
+const ExternalOptionSchema = union([
 	StringOrRegExpSchema,
 	array(StringOrRegExpSchema),
-	pipe(function_(), args(tuple([
-		string(),
-		optional(string()),
-		boolean()
-	])), returns(nullish(boolean())))
+	ExternalOptionFunctionSchema
 ]);
 const ModuleTypesSchema = record(string(), union([
 	literal("asset"),
@@ -1672,7 +1697,7 @@ const ModuleTypesSchema = record(string(), union([
 const JsxOptionsSchema = strictObject({
 	runtime: pipe(optional(union([literal("classic"), literal("automatic")])), description("Which runtime to use")),
 	development: pipe(optional(boolean()), description("Development specific information")),
-	throwIfNamespace: pipe(optional(string()), description("Toggles whether to throw an error when a tag name uses an XML namespace")),
+	throwIfNamespace: pipe(optional(boolean()), description("Toggles whether to throw an error when a tag name uses an XML namespace")),
 	importSource: pipe(optional(string()), description("Import the factory of element and fragment if mode is classic")),
 	pragma: pipe(optional(string()), description("Jsx element transformation")),
 	pragmaFrag: pipe(optional(string()), description("Jsx fragment transformation")),
@@ -1713,7 +1738,13 @@ const TransformOptionsSchema = object({
 	typescript: optional(TypescriptSchema),
 	helpers: optional(HelpersSchema),
 	decorators: optional(DecoratorOptionSchema),
-	jsx: optional(union([literal("preserve"), JsxOptionsSchema])),
+	jsx: optional(union([
+		literal(false),
+		literal("preserve"),
+		literal("react"),
+		literal("react-jsx"),
+		JsxOptionsSchema
+	])),
 	target: pipe(optional(union([string(), array(string())])), description("The JavaScript target environment")),
 	define: optional(record(string(), string())),
 	inject: optional(record(string(), union([string(), tuple([string(), string()])]))),
@@ -1748,8 +1779,8 @@ const ChecksOptionsSchema = strictObject({
 	preferBuiltinFeature: pipe(optional(boolean()), description("Whether to emit warning when detecting prefer builtin feature"))
 });
 const CompressOptionsKeepNamesSchema = strictObject({
-	function: optional(boolean()),
-	class: optional(boolean())
+	function: boolean(),
+	class: boolean()
 });
 const CompressOptionsSchema = strictObject({
 	target: optional(union([
@@ -1771,8 +1802,8 @@ const CompressOptionsSchema = strictObject({
 	unused: optional(union([boolean(), literal("keep_assign")]))
 });
 const MangleOptionsKeepNamesSchema = strictObject({
-	function: optional(boolean()),
-	class: optional(boolean())
+	function: boolean(),
+	class: boolean()
 });
 const MangleOptionsSchema = strictObject({
 	toplevel: optional(boolean()),
@@ -1811,22 +1842,19 @@ const TreeshakingOptionsSchema = union([boolean(), looseObject({
 	propertyWriteSideEffects: optional(union([literal(false), literal("always")]))
 })]);
 const OptimizationOptionsSchema = strictObject({
-	inlineConst: pipe(optional(union([
-		boolean(),
-		literal("smart"),
-		strictObject({
-			mode: optional(union([literal("all"), literal("smart")])),
-			pass: optional(number())
-		})
-	])), description("Enable crossmodule constant inlining")),
+	inlineConst: pipe(optional(union([boolean(), strictObject({
+		mode: optional(union([literal("all"), literal("smart")])),
+		pass: optional(number())
+	})])), description("Enable crossmodule constant inlining")),
 	pifeForModuleWrappers: pipe(optional(boolean()), description("Use PIFE pattern for module wrappers"))
 });
-const OnLogSchema = pipe(function_(), args(tuple([
+const LogOrStringHandlerSchema = pipe(vFunction(), args(tuple([LogLevelWithErrorSchema, RollupLogWithStringSchema])));
+const OnLogSchema = pipe(vFunction(), args(tuple([
 	LogLevelSchema,
 	RollupLogSchema,
-	pipe(function_(), args(tuple([LogLevelWithErrorSchema, RollupLogWithStringSchema])))
+	LogOrStringHandlerSchema
 ])));
-const OnwarnSchema = pipe(function_(), args(tuple([RollupLogSchema, pipe(function_(), args(tuple([union([RollupLogWithStringSchema, pipe(function_(), returns(RollupLogWithStringSchema))])])))])));
+const OnwarnSchema = pipe(vFunction(), args(tuple([RollupLogSchema, pipe(vFunction(), args(tuple([union([RollupLogWithStringSchema, pipe(vFunction(), returns(RollupLogWithStringSchema))])])))])));
 const HmrSchema = union([boolean(), strictObject({
 	new: optional(boolean()),
 	port: optional(number()),
@@ -1836,7 +1864,7 @@ const HmrSchema = union([boolean(), strictObject({
 const InputOptionsSchema = strictObject({
 	input: optional(InputOptionSchema),
 	plugins: optional(custom(() => true)),
-	external: optional(ExternalSchema),
+	external: optional(ExternalOptionSchema),
 	makeAbsoluteExternalsRelative: optional(union([boolean(), literal("ifRelativeSource")])),
 	resolve: optional(ResolveOptionsSchema),
 	cwd: pipe(optional(string()), description("Current working directory")),
@@ -1920,12 +1948,22 @@ const ModuleFormatSchema = union([
 	literal("iife"),
 	literal("umd")
 ]);
-const AddonFunctionSchema = pipe(function_(), args(tuple([custom(() => true)])), returnsAsync(unionAsync([string(), pipeAsync(promise(), awaitAsync(), string())])));
-const ChunkFileNamesSchema = union([string(), pipe(function_(), args(tuple([custom(() => true)])), returns(string()))]);
-const AssetFileNamesSchema = union([string(), pipe(function_(), args(tuple([custom(() => true)])), returns(string()))]);
-const SanitizeFileNameSchema = union([boolean(), pipe(function_(), args(tuple([string()])), returns(string()))]);
-const GlobalsFunctionSchema = pipe(function_(), args(tuple([string()])), returns(string()));
-const PathsFunctionSchema = pipe(function_(), args(tuple([string()])), returns(string()));
+const AddonFunctionSchema = pipe(vFunction(), args(tuple([custom(() => true)])), returnsAsync(unionAsync([string(), pipeAsync(promise(), awaitAsync(), string())])));
+const ChunkFileNamesFunctionSchema = pipe(vFunction(), args(tuple([custom(() => true)])), returns(string()));
+const ChunkFileNamesSchema = union([string(), ChunkFileNamesFunctionSchema]);
+const AssetFileNamesFunctionSchema = pipe(vFunction(), args(tuple([custom(() => true)])), returns(string()));
+const AssetFileNamesSchema = union([string(), AssetFileNamesFunctionSchema]);
+const SanitizeFileNameFunctionSchema = pipe(vFunction(), args(tuple([string()])), returns(string()));
+const SanitizeFileNameSchema = union([boolean(), SanitizeFileNameFunctionSchema]);
+const GlobalsFunctionSchema = pipe(vFunction(), args(tuple([string()])), returns(string()));
+const PathsFunctionSchema = pipe(vFunction(), args(tuple([string()])), returns(string()));
+const ManualChunksFunctionSchema = pipe(vFunction(), args(tuple([string(), object({})])), returns(nullish(string())));
+const AdvancedChunksNameFunctionSchema = pipe(vFunction(), args(tuple([string(), object({})])), returns(nullish(string())));
+const AdvancedChunksTestFunctionSchema = pipe(vFunction(), args(tuple([string()])), returns(union([
+	boolean(),
+	void_(),
+	undefined_()
+])));
 const AdvancedChunksSchema = strictObject({
 	includeDependenciesRecursively: optional(boolean()),
 	minSize: optional(number()),
@@ -1934,12 +1972,8 @@ const AdvancedChunksSchema = strictObject({
 	maxModuleSize: optional(number()),
 	minShareCount: optional(number()),
 	groups: optional(array(strictObject({
-		name: union([string(), pipe(function_(), args(tuple([string()])), returns(nullish(string())))]),
-		test: optional(union([
-			string(),
-			instance(RegExp),
-			pipe(function_(), args(tuple([string()])), returns(union([nullish(boolean()), void_()])))
-		])),
+		name: union([string(), AdvancedChunksNameFunctionSchema]),
+		test: optional(union([StringOrRegExpSchema, AdvancedChunksTestFunctionSchema])),
 		priority: optional(number()),
 		minSize: optional(number()),
 		minShareCount: optional(number()),
@@ -1996,7 +2030,7 @@ const OutputOptionsSchema = strictObject({
 	sanitizeFileName: optional(SanitizeFileNameSchema),
 	minify: pipe(optional(union([
 		boolean(),
-		string("dce-only"),
+		literal("dce-only"),
 		MinifyOptionsSchema
 	])), description("Minify the bundled file")),
 	name: pipe(optional(string()), description("Name for UMD / IIFE format outputs")),
@@ -2005,15 +2039,12 @@ const OutputOptionsSchema = strictObject({
 	generatedCode: pipe(optional(partial(GeneratedCodeOptionsSchema)), description("Generated code options")),
 	externalLiveBindings: pipe(optional(boolean()), description("external live bindings")),
 	inlineDynamicImports: pipe(optional(boolean()), description("Inline dynamic imports")),
-	manualChunks: optional(pipe(function_(), args(tuple([string(), object({})])), returns(union([string(), nullish(string())])))),
+	manualChunks: optional(ManualChunksFunctionSchema),
 	advancedChunks: optional(AdvancedChunksSchema),
 	legalComments: pipe(optional(union([literal("none"), literal("inline")])), description("Control comments in the output")),
 	plugins: optional(custom(() => true)),
 	polyfillRequire: pipe(optional(boolean()), description("Disable require polyfill injection")),
-	hoistTransitiveImports: optional(custom((input) => {
-		if (input) return false;
-		return true;
-	}, () => `The 'true' value is not supported`)),
+	hoistTransitiveImports: optional(literal(false)),
 	preserveModules: pipe(optional(boolean()), description("Preserve module structure")),
 	preserveModulesRoot: pipe(optional(string()), description("Put preserved modules under this path at root level")),
 	virtualDirname: optional(string()),
@@ -2106,6 +2137,264 @@ function getCliSchemaInfo() {
 	return flattenValibotSchema(CliOptionsSchema);
 }
 
+//#endregion
+//#region src/decorators/lazy.ts
+const LAZY_FIELDS_KEY = Symbol("__lazy_fields__");
+const LAZY_CACHE_PREFIX = "__cached_";
+/**
+* Legacy decorator that makes a getter lazy-evaluated and cached.
+* Also auto-registers the field for batch prefetching.
+*
+* @example
+* ```typescript
+* class MyClass {
+*   @lazy
+*   get expensiveValue() {
+*     return someExpensiveComputation();
+*   }
+* }
+* ```
+*/
+function lazy(target, propertyKey, descriptor) {
+	if (!target.constructor[LAZY_FIELDS_KEY]) target.constructor[LAZY_FIELDS_KEY] = /* @__PURE__ */ new Set();
+	target.constructor[LAZY_FIELDS_KEY].add(propertyKey);
+	const originalGetter = descriptor.get;
+	const cacheKey = LAZY_CACHE_PREFIX + propertyKey;
+	descriptor.get = function() {
+		if (!(cacheKey in this)) this[cacheKey] = originalGetter.call(this);
+		return this[cacheKey];
+	};
+	return descriptor;
+}
+/**
+* Get all lazy field names from a class instance.
+*
+* @param instance - Instance to inspect
+* @returns Set of lazy property names
+*/
+function getLazyFields(instance$1) {
+	return instance$1.constructor[LAZY_FIELDS_KEY] || /* @__PURE__ */ new Set();
+}
+
+//#endregion
+//#region src/decorators/non-enumerable.ts
+/**
+* Decorator that makes a property or method non-enumerable.
+* This hides the property from enumeration (e.g., Object.keys(), for...in loops).
+*
+* @example
+* ```typescript
+* class MyClass {
+*   @nonEnumerable
+*   hiddenMethod() {
+*     return 'This method will not show up in Object.keys()';
+*   }
+* }
+* ```
+*/
+function nonEnumerable(target, propertyKey, descriptor) {
+	descriptor.enumerable = false;
+	return descriptor;
+}
+
+//#endregion
+//#region src/utils/asset-source.ts
+function transformAssetSource(bindingAssetSource$1) {
+	return bindingAssetSource$1.inner;
+}
+function bindingAssetSource(source) {
+	return { inner: source };
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.96.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+//#endregion
+//#region src/types/output-asset-impl.ts
+var OutputAssetImpl = class {
+	type = "asset";
+	constructor(bindingAsset) {
+		this.bindingAsset = bindingAsset;
+	}
+	get fileName() {
+		return this.bindingAsset.getFileName();
+	}
+	get originalFileName() {
+		return this.bindingAsset.getOriginalFileName() || null;
+	}
+	get originalFileNames() {
+		return this.bindingAsset.getOriginalFileNames();
+	}
+	get name() {
+		return this.bindingAsset.getName() ?? void 0;
+	}
+	get names() {
+		return this.bindingAsset.getNames();
+	}
+	get source() {
+		return transformAssetSource(this.bindingAsset.getSource());
+	}
+	__rolldown_external_memory_handle__(keepDataAlive) {
+		if (keepDataAlive) this.#evaluateAllLazyFields();
+		return this.bindingAsset.dropInner();
+	}
+	#evaluateAllLazyFields() {
+		for (const field of getLazyFields(this)) this[field];
+	}
+};
+__decorate([lazy], OutputAssetImpl.prototype, "fileName", null);
+__decorate([lazy], OutputAssetImpl.prototype, "originalFileName", null);
+__decorate([lazy], OutputAssetImpl.prototype, "originalFileNames", null);
+__decorate([lazy], OutputAssetImpl.prototype, "name", null);
+__decorate([lazy], OutputAssetImpl.prototype, "names", null);
+__decorate([lazy], OutputAssetImpl.prototype, "source", null);
+__decorate([nonEnumerable], OutputAssetImpl.prototype, "__rolldown_external_memory_handle__", null);
+
+//#endregion
+//#region src/utils/transform-rendered-module.ts
+function transformToRenderedModule(bindingRenderedModule) {
+	return {
+		get code() {
+			return bindingRenderedModule.code;
+		},
+		get renderedLength() {
+			return bindingRenderedModule.code?.length || 0;
+		},
+		get renderedExports() {
+			return bindingRenderedModule.renderedExports;
+		}
+	};
+}
+
+//#endregion
+//#region src/utils/transform-rendered-chunk.ts
+function transformRenderedChunk(chunk) {
+	let modules = null;
+	return {
+		type: "chunk",
+		get name() {
+			return chunk.name;
+		},
+		get isEntry() {
+			return chunk.isEntry;
+		},
+		get isDynamicEntry() {
+			return chunk.isDynamicEntry;
+		},
+		get facadeModuleId() {
+			return chunk.facadeModuleId;
+		},
+		get moduleIds() {
+			return chunk.moduleIds;
+		},
+		get exports() {
+			return chunk.exports;
+		},
+		get fileName() {
+			return chunk.fileName;
+		},
+		get imports() {
+			return chunk.imports;
+		},
+		get dynamicImports() {
+			return chunk.dynamicImports;
+		},
+		get modules() {
+			if (!modules) modules = transformChunkModules(chunk.modules);
+			return modules;
+		}
+	};
+}
+function transformChunkModules(modules) {
+	const result = {};
+	for (let i = 0; i < modules.values.length; i++) {
+		let key = modules.keys[i];
+		const mod = modules.values[i];
+		result[key] = transformToRenderedModule(mod);
+	}
+	return result;
+}
+
+//#endregion
+//#region src/types/output-chunk-impl.ts
+var OutputChunkImpl = class {
+	type = "chunk";
+	constructor(bindingChunk) {
+		this.bindingChunk = bindingChunk;
+	}
+	get fileName() {
+		return this.bindingChunk.getFileName();
+	}
+	get name() {
+		return this.bindingChunk.getName();
+	}
+	get exports() {
+		return this.bindingChunk.getExports();
+	}
+	get isEntry() {
+		return this.bindingChunk.getIsEntry();
+	}
+	get facadeModuleId() {
+		return this.bindingChunk.getFacadeModuleId() || null;
+	}
+	get isDynamicEntry() {
+		return this.bindingChunk.getIsDynamicEntry();
+	}
+	get sourcemapFileName() {
+		return this.bindingChunk.getSourcemapFileName() || null;
+	}
+	get preliminaryFileName() {
+		return this.bindingChunk.getPreliminaryFileName();
+	}
+	get code() {
+		return this.bindingChunk.getCode();
+	}
+	get modules() {
+		return transformChunkModules(this.bindingChunk.getModules());
+	}
+	get imports() {
+		return this.bindingChunk.getImports();
+	}
+	get dynamicImports() {
+		return this.bindingChunk.getDynamicImports();
+	}
+	get moduleIds() {
+		return this.bindingChunk.getModuleIds();
+	}
+	get map() {
+		const mapString = this.bindingChunk.getMap();
+		return mapString ? transformToRollupSourceMap(mapString) : null;
+	}
+	__rolldown_external_memory_handle__(keepDataAlive) {
+		if (keepDataAlive) this.#evaluateAllLazyFields();
+		return this.bindingChunk.dropInner();
+	}
+	#evaluateAllLazyFields() {
+		for (const field of getLazyFields(this)) this[field];
+	}
+};
+__decorate([lazy], OutputChunkImpl.prototype, "fileName", null);
+__decorate([lazy], OutputChunkImpl.prototype, "name", null);
+__decorate([lazy], OutputChunkImpl.prototype, "exports", null);
+__decorate([lazy], OutputChunkImpl.prototype, "isEntry", null);
+__decorate([lazy], OutputChunkImpl.prototype, "facadeModuleId", null);
+__decorate([lazy], OutputChunkImpl.prototype, "isDynamicEntry", null);
+__decorate([lazy], OutputChunkImpl.prototype, "sourcemapFileName", null);
+__decorate([lazy], OutputChunkImpl.prototype, "preliminaryFileName", null);
+__decorate([lazy], OutputChunkImpl.prototype, "code", null);
+__decorate([lazy], OutputChunkImpl.prototype, "modules", null);
+__decorate([lazy], OutputChunkImpl.prototype, "imports", null);
+__decorate([lazy], OutputChunkImpl.prototype, "dynamicImports", null);
+__decorate([lazy], OutputChunkImpl.prototype, "moduleIds", null);
+__decorate([lazy], OutputChunkImpl.prototype, "map", null);
+__decorate([nonEnumerable], OutputChunkImpl.prototype, "__rolldown_external_memory_handle__", null);
+
 //#endregion
 //#region src/types/sourcemap.ts
 function bindingifySourcemap$1(map) {
@@ -2122,6 +2411,190 @@ function bindingifySourcemap$1(map) {
 	} };
 }
 
+//#endregion
+//#region src/utils/transform-to-rollup-output.ts
+function transformToRollupSourceMap(map) {
+	const obj = {
+		...JSON.parse(map),
+		toString() {
+			return JSON.stringify(obj);
+		},
+		toUrl() {
+			return `data:application/json;charset=utf-8;base64,${Buffer.from(obj.toString(), "utf-8").toString("base64")}`;
+		}
+	};
+	return obj;
+}
+function transformToRollupOutputChunk(bindingChunk) {
+	return new OutputChunkImpl(bindingChunk);
+}
+function transformToMutableRollupOutputChunk(bindingChunk, changed) {
+	const chunk = {
+		type: "chunk",
+		get code() {
+			return bindingChunk.getCode();
+		},
+		fileName: bindingChunk.getFileName(),
+		name: bindingChunk.getName(),
+		get modules() {
+			return transformChunkModules(bindingChunk.getModules());
+		},
+		get imports() {
+			return bindingChunk.getImports();
+		},
+		get dynamicImports() {
+			return bindingChunk.getDynamicImports();
+		},
+		exports: bindingChunk.getExports(),
+		isEntry: bindingChunk.getIsEntry(),
+		facadeModuleId: bindingChunk.getFacadeModuleId() || null,
+		isDynamicEntry: bindingChunk.getIsDynamicEntry(),
+		get moduleIds() {
+			return bindingChunk.getModuleIds();
+		},
+		get map() {
+			const map = bindingChunk.getMap();
+			return map ? transformToRollupSourceMap(map) : null;
+		},
+		sourcemapFileName: bindingChunk.getSourcemapFileName() || null,
+		preliminaryFileName: bindingChunk.getPreliminaryFileName()
+	};
+	const cache = {};
+	return new Proxy(chunk, {
+		get(target, p) {
+			if (p in cache) return cache[p];
+			const value = target[p];
+			cache[p] = value;
+			return value;
+		},
+		set(_target, p, newValue) {
+			cache[p] = newValue;
+			changed.updated.add(bindingChunk.getFileName());
+			return true;
+		},
+		has(target, p) {
+			if (p in cache) return true;
+			return p in target;
+		}
+	});
+}
+function transformToRollupOutputAsset(bindingAsset) {
+	return new OutputAssetImpl(bindingAsset);
+}
+function transformToMutableRollupOutputAsset(bindingAsset, changed) {
+	const asset = {
+		type: "asset",
+		fileName: bindingAsset.getFileName(),
+		originalFileName: bindingAsset.getOriginalFileName() || null,
+		originalFileNames: bindingAsset.getOriginalFileNames(),
+		get source() {
+			return transformAssetSource(bindingAsset.getSource());
+		},
+		name: bindingAsset.getName() ?? void 0,
+		names: bindingAsset.getNames()
+	};
+	const cache = {};
+	return new Proxy(asset, {
+		get(target, p) {
+			if (p in cache) return cache[p];
+			const value = target[p];
+			cache[p] = value;
+			return value;
+		},
+		set(_target, p, newValue) {
+			cache[p] = newValue;
+			changed.updated.add(bindingAsset.getFileName());
+			return true;
+		}
+	});
+}
+function transformToRollupOutput(output) {
+	const { chunks, assets } = output;
+	return { output: [...chunks.map((chunk) => transformToRollupOutputChunk(chunk)), ...assets.map((asset) => transformToRollupOutputAsset(asset))] };
+}
+function transformToMutableRollupOutput(output, changed) {
+	const { chunks, assets } = output;
+	return { output: [...chunks.map((chunk) => transformToMutableRollupOutputChunk(chunk, changed)), ...assets.map((asset) => transformToMutableRollupOutputAsset(asset, changed))] };
+}
+function transformToOutputBundle(context, output, changed) {
+	const bundle = Object.fromEntries(transformToMutableRollupOutput(output, changed).output.map((item) => [item.fileName, item]));
+	return new Proxy(bundle, {
+		set(_target, _p, _newValue, _receiver) {
+			const originalStackTraceLimit = Error.stackTraceLimit;
+			Error.stackTraceLimit = 2;
+			const message = "This plugin assigns to bundle variable. This is discouraged by Rollup and is not supported by Rolldown. This will be ignored. https://rollupjs.org/plugin-development/#generatebundle:~:text=DANGER,this.emitFile.";
+			const stack = new Error(message).stack ?? message;
+			Error.stackTraceLimit = originalStackTraceLimit;
+			context.warn({
+				message: stack,
+				code: "UNSUPPORTED_BUNDLE_ASSIGNMENT"
+			});
+			return true;
+		},
+		deleteProperty(target, property) {
+			if (typeof property === "string") changed.deleted.add(property);
+			return true;
+		}
+	});
+}
+function collectChangedBundle(changed, bundle) {
+	const changes = {};
+	for (const key in bundle) {
+		if (changed.deleted.has(key) || !changed.updated.has(key)) continue;
+		const item = bundle[key];
+		if (item.type === "asset") changes[key] = {
+			filename: item.fileName,
+			originalFileNames: item.originalFileNames,
+			source: bindingAssetSource(item.source),
+			names: item.names
+		};
+		else changes[key] = {
+			code: item.code,
+			filename: item.fileName,
+			name: item.name,
+			isEntry: item.isEntry,
+			exports: item.exports,
+			modules: {},
+			imports: item.imports,
+			dynamicImports: item.dynamicImports,
+			facadeModuleId: item.facadeModuleId || void 0,
+			isDynamicEntry: item.isDynamicEntry,
+			moduleIds: item.moduleIds,
+			map: bindingifySourcemap$1(item.map),
+			sourcemapFilename: item.sourcemapFileName || void 0,
+			preliminaryFilename: item.preliminaryFileName
+		};
+	}
+	return {
+		changes,
+		deleted: changed.deleted
+	};
+}
+
+//#endregion
+//#region src/types/rolldown-output-impl.ts
+var RolldownOutputImpl = class {
+	constructor(bindingOutputs) {
+		this.bindingOutputs = bindingOutputs;
+	}
+	get output() {
+		return transformToRollupOutput(this.bindingOutputs).output;
+	}
+	__rolldown_external_memory_handle__(keepDataAlive) {
+		const results = this.output.map((item) => item.__rolldown_external_memory_handle__(keepDataAlive));
+		if (!results.every((r) => r.freed)) {
+			const reasons = results.filter((r) => !r.freed).map((r) => r.reason).filter(Boolean);
+			return {
+				freed: false,
+				reason: `Failed to free ${reasons.length} item(s): ${reasons.join("; ")}`
+			};
+		}
+		return { freed: true };
+	}
+};
+__decorate([lazy], RolldownOutputImpl.prototype, "output", null);
+__decorate([nonEnumerable], RolldownOutputImpl.prototype, "__rolldown_external_memory_handle__", null);
+
 //#endregion
 //#region src/utils/error.ts
 function unwrapBindingResult(container) {
@@ -2389,28 +2862,20 @@ function bindingifyRenderChunkFilter(filterOption) {
 
 //#endregion
 //#region src/plugin/bindingify-plugin-hook-meta.ts
+var import_binding$6 = /* @__PURE__ */ __toESM(require_binding(), 1);
 function bindingifyPluginHookMeta(options) {
 	return { order: bindingPluginOrder(options.order) };
 }
 function bindingPluginOrder(order) {
 	switch (order) {
-		case "post": return BindingPluginOrder.Post;
-		case "pre": return BindingPluginOrder.Pre;
+		case "post": return import_binding$6.BindingPluginOrder.Post;
+		case "pre": return import_binding$6.BindingPluginOrder.Pre;
 		case null:
 		case void 0: return;
 		default: throw new Error(`Unknown plugin order: ${order}`);
 	}
 }
 
-//#endregion
-//#region src/utils/asset-source.ts
-function transformAssetSource(bindingAssetSource$1) {
-	return bindingAssetSource$1.inner;
-}
-function bindingAssetSource(source) {
-	return { inner: source };
-}
-
 //#endregion
 //#region src/plugin/fs.ts
 const fsModule = {
@@ -2565,6 +3030,7 @@ var TransformPluginContextImpl = class extends PluginContextImpl {
 
 //#endregion
 //#region src/plugin/bindingify-build-hooks.ts
+var import_binding$5 = /* @__PURE__ */ __toESM(require_binding(), 1);
 function bindingifyBuildStart(args$1) {
 	const hook = args$1.plugin.buildStart;
 	if (!hook) return {};
@@ -2662,7 +3128,7 @@ function bindingifyTransform(args$1) {
 		plugin: async (ctx, code$1, id$1, meta$1) => {
 			Object.defineProperties(meta$1, {
 				magicString: { get() {
-					return new BindingMagicString(code$1);
+					return new import_binding$5.BindingMagicString(code$1);
 				} },
 				ast: { get() {
 					let lang = "js";
@@ -2693,7 +3159,7 @@ function bindingifyTransform(args$1) {
 			let normalizedCode = void 0;
 			let map = ret.map;
 			if (typeof ret.code === "string") normalizedCode = ret.code;
-			else if (ret.code instanceof BindingMagicString) {
+			else if (ret.code instanceof import_binding$5.BindingMagicString) {
 				let magicString = ret.code;
 				normalizedCode = magicString.toString();
 				let fallbackSourcemap = ctx.sendMagicString(magicString);
@@ -2758,220 +3224,6 @@ function bindingifyModuleParsed(args$1) {
 	};
 }
 
-//#endregion
-//#region src/utils/transform-rendered-module.ts
-function transformToRenderedModule(bindingRenderedModule) {
-	return {
-		get code() {
-			return bindingRenderedModule.code;
-		},
-		get renderedLength() {
-			return bindingRenderedModule.code?.length || 0;
-		},
-		get renderedExports() {
-			return bindingRenderedModule.renderedExports;
-		}
-	};
-}
-
-//#endregion
-//#region src/utils/transform-rendered-chunk.ts
-function transformRenderedChunk(chunk) {
-	let modules = null;
-	return {
-		type: "chunk",
-		get name() {
-			return chunk.name;
-		},
-		get isEntry() {
-			return chunk.isEntry;
-		},
-		get isDynamicEntry() {
-			return chunk.isDynamicEntry;
-		},
-		get facadeModuleId() {
-			return chunk.facadeModuleId;
-		},
-		get moduleIds() {
-			return chunk.moduleIds;
-		},
-		get exports() {
-			return chunk.exports;
-		},
-		get fileName() {
-			return chunk.fileName;
-		},
-		get imports() {
-			return chunk.imports;
-		},
-		get dynamicImports() {
-			return chunk.dynamicImports;
-		},
-		get modules() {
-			if (!modules) modules = transformChunkModules(chunk.modules);
-			return modules;
-		}
-	};
-}
-function transformChunkModules(modules) {
-	const result = {};
-	for (let i = 0; i < modules.values.length; i++) {
-		let key = modules.keys[i];
-		const mod = modules.values[i];
-		result[key] = transformToRenderedModule(mod);
-	}
-	return result;
-}
-
-//#endregion
-//#region src/utils/transform-to-rollup-output.ts
-function transformToRollupSourceMap(map) {
-	const obj = {
-		...JSON.parse(map),
-		toString() {
-			return JSON.stringify(obj);
-		},
-		toUrl() {
-			return `data:application/json;charset=utf-8;base64,${Buffer.from(obj.toString(), "utf-8").toString("base64")}`;
-		}
-	};
-	return obj;
-}
-function transformToRollupOutputChunk(bindingChunk, changed) {
-	const chunk = {
-		type: "chunk",
-		get code() {
-			return bindingChunk.code;
-		},
-		fileName: bindingChunk.fileName,
-		name: bindingChunk.name,
-		get modules() {
-			return transformChunkModules(bindingChunk.modules);
-		},
-		get imports() {
-			return bindingChunk.imports;
-		},
-		get dynamicImports() {
-			return bindingChunk.dynamicImports;
-		},
-		exports: bindingChunk.exports,
-		isEntry: bindingChunk.isEntry,
-		facadeModuleId: bindingChunk.facadeModuleId || null,
-		isDynamicEntry: bindingChunk.isDynamicEntry,
-		get moduleIds() {
-			return bindingChunk.moduleIds;
-		},
-		get map() {
-			return bindingChunk.map ? transformToRollupSourceMap(bindingChunk.map) : null;
-		},
-		sourcemapFileName: bindingChunk.sourcemapFileName || null,
-		preliminaryFileName: bindingChunk.preliminaryFileName
-	};
-	const cache = {};
-	return new Proxy(chunk, {
-		get(target, p) {
-			if (p in cache) return cache[p];
-			const value = target[p];
-			cache[p] = value;
-			return value;
-		},
-		set(_target, p, newValue) {
-			cache[p] = newValue;
-			changed?.updated.add(bindingChunk.fileName);
-			return true;
-		},
-		has(target, p) {
-			if (p in cache) return true;
-			return p in target;
-		}
-	});
-}
-function transformToRollupOutputAsset(bindingAsset, changed) {
-	const asset = {
-		type: "asset",
-		fileName: bindingAsset.fileName,
-		originalFileName: bindingAsset.originalFileName || null,
-		originalFileNames: bindingAsset.originalFileNames,
-		get source() {
-			return transformAssetSource(bindingAsset.source);
-		},
-		name: bindingAsset.name ?? void 0,
-		names: bindingAsset.names
-	};
-	const cache = {};
-	return new Proxy(asset, {
-		get(target, p) {
-			if (p in cache) return cache[p];
-			const value = target[p];
-			cache[p] = value;
-			return value;
-		},
-		set(_target, p, newValue) {
-			cache[p] = newValue;
-			changed?.updated.add(bindingAsset.fileName);
-			return true;
-		}
-	});
-}
-function transformToRollupOutput(output, changed) {
-	const { chunks, assets } = output;
-	return { output: [...chunks.map((chunk) => transformToRollupOutputChunk(chunk, changed)), ...assets.map((asset) => transformToRollupOutputAsset(asset, changed))] };
-}
-function transformToOutputBundle(context, output, changed) {
-	const bundle = Object.fromEntries(transformToRollupOutput(output, changed).output.map((item) => [item.fileName, item]));
-	return new Proxy(bundle, {
-		set(_target, _p, _newValue, _receiver) {
-			const originalStackTraceLimit = Error.stackTraceLimit;
-			Error.stackTraceLimit = 2;
-			const message = "This plugin assigns to bundle variable. This is discouraged by Rollup and is not supported by Rolldown. This will be ignored. https://rollupjs.org/plugin-development/#generatebundle:~:text=DANGER,this.emitFile.";
-			const stack = new Error(message).stack ?? message;
-			Error.stackTraceLimit = originalStackTraceLimit;
-			context.warn({
-				message: stack,
-				code: "UNSUPPORTED_BUNDLE_ASSIGNMENT"
-			});
-			return true;
-		},
-		deleteProperty(target, property) {
-			if (typeof property === "string") changed.deleted.add(property);
-			return true;
-		}
-	});
-}
-function collectChangedBundle(changed, bundle) {
-	const changes = {};
-	for (const key in bundle) {
-		if (changed.deleted.has(key) || !changed.updated.has(key)) continue;
-		const item = bundle[key];
-		if (item.type === "asset") changes[key] = {
-			filename: item.fileName,
-			originalFileNames: item.originalFileNames,
-			source: bindingAssetSource(item.source),
-			names: item.names
-		};
-		else changes[key] = {
-			code: item.code,
-			filename: item.fileName,
-			name: item.name,
-			isEntry: item.isEntry,
-			exports: item.exports,
-			modules: {},
-			imports: item.imports,
-			dynamicImports: item.dynamicImports,
-			facadeModuleId: item.facadeModuleId || void 0,
-			isDynamicEntry: item.isDynamicEntry,
-			moduleIds: item.moduleIds,
-			map: bindingifySourcemap$1(item.map),
-			sourcemapFilename: item.sourcemapFileName || void 0,
-			preliminaryFilename: item.preliminaryFileName
-		};
-	}
-	return {
-		changes,
-		deleted: changed.deleted
-	};
-}
-
 //#endregion
 //#region src/plugin/bindingify-output-hooks.ts
 function bindingifyRenderStart(args$1) {
@@ -3011,7 +3263,7 @@ function bindingifyAugmentChunkHash(args$1) {
 	const { handler, meta } = normalizeHook(hook);
 	return {
 		plugin: async (ctx, chunk) => {
-			return await handler.call(new PluginContextImpl(args$1.outputOptions, ctx, args$1.plugin, args$1.pluginContextData, args$1.onLog, args$1.logLevel, args$1.watchMode), transformRenderedChunk(chunk));
+			return handler.call(new PluginContextImpl(args$1.outputOptions, ctx, args$1.plugin, args$1.pluginContextData, args$1.onLog, args$1.logLevel, args$1.watchMode), transformRenderedChunk(chunk));
 		},
 		meta: bindingifyPluginHookMeta(meta)
 	};
@@ -3636,6 +3888,7 @@ function normalizeTransformOptions(inputOptions, onLog) {
 
 //#endregion
 //#region src/utils/bindingify-input-options.ts
+var import_binding$4 = /* @__PURE__ */ __toESM(require_binding(), 1);
 function bindingifyInputOptions(rawPlugins, inputOptions, outputOptions, normalizedOutputPlugins, onLog, logLevel, watchMode) {
 	const pluginContextData = new PluginContextData(onLog, outputOptions, normalizedOutputPlugins);
 	const plugins = rawPlugins.map((plugin) => {
@@ -3705,9 +3958,9 @@ function bindingifyHmr(hmr) {
 function bindingifyAttachDebugInfo(attachDebugInfo) {
 	switch (attachDebugInfo) {
 		case void 0: return;
-		case "full": return BindingAttachDebugInfo.Full;
-		case "simple": return BindingAttachDebugInfo.Simple;
-		case "none": return BindingAttachDebugInfo.None;
+		case "full": return import_binding$4.BindingAttachDebugInfo.Full;
+		case "simple": return import_binding$4.BindingAttachDebugInfo.Simple;
+		case "none": return import_binding$4.BindingAttachDebugInfo.None;
 	}
 }
 function bindingifyExternal(external) {
@@ -3720,13 +3973,13 @@ function bindingifyExternal(external) {
 	}
 }
 function bindingifyExperimental(experimental) {
-	let chunkModulesOrder = BindingChunkModuleOrderBy.ExecOrder;
+	let chunkModulesOrder = import_binding$4.BindingChunkModuleOrderBy.ExecOrder;
 	if (experimental?.chunkModulesOrder) switch (experimental.chunkModulesOrder) {
 		case "exec-order":
-			chunkModulesOrder = BindingChunkModuleOrderBy.ExecOrder;
+			chunkModulesOrder = import_binding$4.BindingChunkModuleOrderBy.ExecOrder;
 			break;
 		case "module-id":
-			chunkModulesOrder = BindingChunkModuleOrderBy.ModuleId;
+			chunkModulesOrder = import_binding$4.BindingChunkModuleOrderBy.ModuleId;
 			break;
 		default: throw new Error(`Unexpected chunkModulesOrder: ${experimental.chunkModulesOrder}`);
 	}
@@ -3786,10 +4039,10 @@ function bindingifyInject(inject) {
 }
 function bindingifyLogLevel(logLevel) {
 	switch (logLevel) {
-		case "silent": return BindingLogLevel.Silent;
-		case "debug": return BindingLogLevel.Debug;
-		case "warn": return BindingLogLevel.Warn;
-		case "info": return BindingLogLevel.Info;
+		case "silent": return import_binding$4.BindingLogLevel.Silent;
+		case "debug": return import_binding$4.BindingLogLevel.Debug;
+		case "warn": return import_binding$4.BindingLogLevel.Warn;
+		case "info": return import_binding$4.BindingLogLevel.Info;
 		default: throw new Error(`Unexpected log level: ${logLevel}`);
 	}
 }
@@ -3825,19 +4078,19 @@ function bindingifyTreeshakeOptions(config) {
 	};
 	switch (config.propertyReadSideEffects) {
 		case "always":
-			normalizedConfig.propertyReadSideEffects = BindingPropertyReadSideEffects.Always;
+			normalizedConfig.propertyReadSideEffects = import_binding$4.BindingPropertyReadSideEffects.Always;
 			break;
 		case false:
-			normalizedConfig.propertyReadSideEffects = BindingPropertyReadSideEffects.False;
+			normalizedConfig.propertyReadSideEffects = import_binding$4.BindingPropertyReadSideEffects.False;
 			break;
 		default:
 	}
 	switch (config.propertyWriteSideEffects) {
 		case "always":
-			normalizedConfig.propertyWriteSideEffects = BindingPropertyWriteSideEffects.Always;
+			normalizedConfig.propertyWriteSideEffects = import_binding$4.BindingPropertyWriteSideEffects.Always;
 			break;
 		case false:
-			normalizedConfig.propertyWriteSideEffects = BindingPropertyWriteSideEffects.False;
+			normalizedConfig.propertyWriteSideEffects = import_binding$4.BindingPropertyWriteSideEffects.False;
 			break;
 		default:
 	}
@@ -3997,6 +4250,7 @@ function bindingifyAdvancedChunks(advancedChunks, manualChunks) {
 
 //#endregion
 //#region src/utils/initialize-parallel-plugins.ts
+var import_binding$3 = /* @__PURE__ */ __toESM(require_binding(), 1);
 async function initializeParallelPlugins(plugins) {
 	const pluginInfos = [];
 	for (const [index, plugin] of plugins.entries()) if ("_parallel" in plugin) {
@@ -4009,7 +4263,7 @@ async function initializeParallelPlugins(plugins) {
 	}
 	if (pluginInfos.length <= 0) return;
 	const count = availableParallelism();
-	const parallelJsPluginRegistry = new ParallelJsPluginRegistry(count);
+	const parallelJsPluginRegistry = new import_binding$3.ParallelJsPluginRegistry(count);
 	const registryId = parallelJsPluginRegistry.id;
 	const workers = await initializeWorkers(registryId, count, pluginInfos);
 	const stopWorkers = async () => {
@@ -4087,6 +4341,7 @@ async function createBundlerOptions(inputOptions, outputOptions, watchMode) {
 
 //#endregion
 //#region src/api/rolldown/rolldown-build.ts
+var import_binding$2 = /* @__PURE__ */ __toESM(require_binding());
 Symbol.asyncDispose ??= Symbol("Symbol.asyncDispose");
 var RolldownBuild = class RolldownBuild {
 	#inputOptions;
@@ -4095,7 +4350,7 @@ var RolldownBuild = class RolldownBuild {
 	static asyncRuntimeShutdown = false;
 	constructor(inputOptions) {
 		this.#inputOptions = inputOptions;
-		this.#bundler = new BindingBundler();
+		this.#bundler = new import_binding$2.BindingBundler();
 	}
 	get closed() {
 		return this.#bundlerImpl?.impl.closed ?? true;
@@ -4103,13 +4358,13 @@ var RolldownBuild = class RolldownBuild {
 	async #getBundlerWithStopWorker(outputOptions) {
 		if (this.#bundlerImpl) await this.#bundlerImpl.stopWorkers?.();
 		const option = await createBundlerOptions(this.#inputOptions, outputOptions, false);
-		if (RolldownBuild.asyncRuntimeShutdown) startAsyncRuntime();
+		if (RolldownBuild.asyncRuntimeShutdown) (0, import_binding$2.startAsyncRuntime)();
 		try {
 			return this.#bundlerImpl = {
 				impl: this.#bundler.createImpl(option.bundlerOptions),
 				stopWorkers: option.stopWorkers,
 				shutdown: () => {
-					shutdownAsyncRuntime();
+					(0, import_binding$2.shutdownAsyncRuntime)();
 					RolldownBuild.asyncRuntimeShutdown = true;
 				}
 			};
@@ -4125,13 +4380,16 @@ var RolldownBuild = class RolldownBuild {
 	async generate(outputOptions = {}) {
 		validateOption("output", outputOptions);
 		const { impl } = await this.#getBundlerWithStopWorker(outputOptions);
-		return transformToRollupOutput(unwrapBindingResult(await impl.generate()));
+		return new RolldownOutputImpl(unwrapBindingResult(await impl.generate()));
 	}
 	async write(outputOptions = {}) {
 		validateOption("output", outputOptions);
 		const { impl } = await this.#getBundlerWithStopWorker(outputOptions);
-		return transformToRollupOutput(unwrapBindingResult(await impl.write()));
+		return new RolldownOutputImpl(unwrapBindingResult(await impl.write()));
 	}
+	/**
+	* Close the build and free resources.
+	*/
 	async close() {
 		if (this.#bundlerImpl) {
 			await this.#bundlerImpl.stopWorkers?.();
@@ -4246,6 +4504,7 @@ var WatcherEmitter = class {
 
 //#endregion
 //#region src/api/watch/watcher.ts
+var import_binding$1 = /* @__PURE__ */ __toESM(require_binding(), 1);
 var Watcher = class {
 	closed;
 	inner;
@@ -4267,7 +4526,7 @@ var Watcher = class {
 		this.closed = true;
 		for (const stop of this.stopWorkers) await stop?.();
 		await this.inner.close();
-		shutdownAsyncRuntime();
+		(0, import_binding$1.shutdownAsyncRuntime)();
 	}
 	start() {
 		process.nextTick(() => this.inner.start(this.emitter.onEvent.bind(this.emitter)));
@@ -4279,7 +4538,7 @@ async function createWatcher(emitter, input) {
 		return createBundlerOptions(await PluginDriver.callOptionsHook(option, true), output, true);
 	})).flat());
 	const notifyOptions = getValidNotifyOption(bundlerOptions);
-	new Watcher(emitter, new BindingWatcher(bundlerOptions.map((option) => option.bundlerOptions), notifyOptions), bundlerOptions.map((option) => option.stopWorkers)).start();
+	new Watcher(emitter, new import_binding$1.BindingWatcher(bundlerOptions.map((option) => option.bundlerOptions), notifyOptions), bundlerOptions.map((option) => option.stopWorkers)).start();
 }
 function getValidNotifyOption(bundlerOptions) {
 	let result;
@@ -4308,7 +4567,8 @@ function defineConfig(config) {
 
 //#endregion
 //#region src/index.ts
+var import_binding = /* @__PURE__ */ __toESM(require_binding(), 1);
 const VERSION = version;
 
 //#endregion
-export { version as C, description$1 as S, getOutputCliKeys as _, build as a, BuiltinPlugin as b, createBundlerOptions as c, bindingifyPlugin as d, transformToRollupOutput as f, getInputCliKeys as g, getCliSchemaInfo as h, watch as i, normalizedStringOrRegex as l, bindingifySourcemap$1 as m, VERSION as n, rolldown as o, normalizeBindingResult as p, defineConfig as r, RolldownBuild as s, BindingMagicString$1 as t, PluginContextData as u, validateCliOptions as v, onExit as w, makeBuiltinPluginCallable as x, PluginDriver as y };
+export { version as C, description$1 as S, getOutputCliKeys as _, build as a, BuiltinPlugin as b, createBundlerOptions as c, bindingifyPlugin as d, normalizeBindingResult as f, getInputCliKeys as g, getCliSchemaInfo as h, watch as i, normalizedStringOrRegex as l, bindingifySourcemap$1 as m, import_binding as n, rolldown as o, transformToRollupOutput as p, defineConfig as r, RolldownBuild as s, VERSION as t, PluginContextData as u, validateCliOptions as v, onExit as w, makeBuiltinPluginCallable as x, PluginDriver as y };