@rolldown/browser 1.0.0-beta.59 → 1.0.0-beta.60

package/dist/{rolldown-build-Bfw5c2c3.js → rolldown-build-Zb6e1FlF.js}

@@ -1,4 +1,4 @@
-import { A as augmentCodeLocation, C as LOG_LEVEL_INFO, D as unimplemented, E as arraify, F as logNoFileSystemInBrowser, I as logParseError, L as logPluginError, M as logCycleLoading, N as logInputHookInOutputPlugin, O as unreachable, R as locate, S as LOG_LEVEL_ERROR, T as logLevelPriority, _ as PlainObjectLike, a as bindingifyManifestPlugin, b as normalizeLog, c as collectChangedBundle, d as bindingifySourcemap$1, f as transformRenderedChunk, g as lazyProp, h as transformAssetSource, i as bindingifyCSSPostPlugin, j as error, k as unsupported, l as transformToOutputBundle, m as bindingAssetSource, n as BuiltinPlugin, o as bindingifyViteHtmlPlugin, p as __decorate, r as bindingifyBuiltInPlugin, t as normalizedStringOrRegex, u as transformToRollupOutput, v as MinimalPluginContextImpl, w as LOG_LEVEL_WARN, x as LOG_LEVEL_DEBUG, y as VERSION, z as getCodeFrame } from "./normalize-string-or-regex-BB1FWNyl.js";
+import { c as logCycleLoading, f as logNoFileSystemInBrowser, g as getCodeFrame, h as locate, i as bindingifyManifestPlugin, l as logInputHookInOutputPlugin, m as logPluginError, n as BuiltinPlugin, o as augmentCodeLocation, p as logParseError, r as bindingifyBuiltInPlugin, s as error, t as normalizedStringOrRegex, u as logInvalidLogPosition } from "./normalize-string-or-regex-DcX5TPjK.js";
 import { BindingAttachDebugInfo, BindingBundler, BindingChunkModuleOrderBy, BindingLogLevel, BindingMagicString, BindingPluginOrder, BindingPropertyReadSideEffects, BindingPropertyWriteSideEffects, parse, parseSync, shutdownAsyncRuntime, startAsyncRuntime } from "./rolldown-binding.wasi-browser.js";
 
 //#region ../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs
@@ -449,6 +449,62 @@ const mix = (del = delimiter) => {
 const posix = /* @__PURE__ */ mix(":");
 const win32 = /* @__PURE__ */ mix(";");
 
+//#endregion
+//#region package.json
+var version = "1.0.0-beta.60";
+
+//#endregion
+//#region src/version.ts
+/** @category Plugin APIs */
+const VERSION = version;
+
+//#endregion
+//#region src/utils/misc.ts
+function arraify(value) {
+	return Array.isArray(value) ? value : [value];
+}
+function unimplemented(info) {
+	if (info) throw new Error(`unimplemented: ${info}`);
+	throw new Error("unimplemented");
+}
+function unreachable(info) {
+	if (info) throw new Error(`unreachable: ${info}`);
+	throw new Error("unreachable");
+}
+function unsupported(info) {
+	throw new Error(`UNSUPPORTED: ${info}`);
+}
+function noop(..._args) {}
+
+//#endregion
+//#region src/log/logging.ts
+const LOG_LEVEL_SILENT = "silent";
+const LOG_LEVEL_ERROR = "error";
+const LOG_LEVEL_WARN = "warn";
+const LOG_LEVEL_INFO = "info";
+const LOG_LEVEL_DEBUG = "debug";
+const logLevelPriority = {
+	[LOG_LEVEL_DEBUG]: 0,
+	[LOG_LEVEL_INFO]: 1,
+	[LOG_LEVEL_WARN]: 2,
+	[LOG_LEVEL_SILENT]: 3
+};
+
+//#endregion
+//#region src/log/log-handler.ts
+const normalizeLog = (log) => typeof log === "string" ? { message: log } : typeof log === "function" ? normalizeLog(log()) : log;
+function getLogHandler(level, code$1, logger, pluginName, logLevel) {
+	if (logLevelPriority[level] < logLevelPriority[logLevel]) return noop;
+	return (log, pos) => {
+		if (pos != null) logger(LOG_LEVEL_WARN, logInvalidLogPosition(pluginName));
+		log = normalizeLog(log);
+		if (log.code && !log.pluginCode) log.pluginCode = log.code;
+		log.code = code$1;
+		log.plugin = pluginName;
+		logger(level, log);
+	};
+}
+
 //#endregion
 //#region src/log/logger.ts
 function getLogger(plugins, onLog, logLevel, watchMode) {
@@ -459,20 +515,20 @@ function getLogger(plugins, onLog, logLevel, watchMode) {
 			if (skipped.has(plugin)) continue;
 			const { onLog: pluginOnLog } = plugin;
 			if (pluginOnLog) {
-				const getLogHandler = (level$1) => {
+				const getLogHandler$1 = (level$1) => {
 					if (logLevelPriority[level$1] < minimalPriority) return () => {};
 					return (log$1) => logger(level$1, normalizeLog(log$1), new Set(skipped).add(plugin));
 				};
 				if (("handler" in pluginOnLog ? pluginOnLog.handler : pluginOnLog).call({
-					debug: getLogHandler(LOG_LEVEL_DEBUG),
+					debug: getLogHandler$1(LOG_LEVEL_DEBUG),
 					error: (log$1) => error(normalizeLog(log$1)),
-					info: getLogHandler(LOG_LEVEL_INFO),
+					info: getLogHandler$1(LOG_LEVEL_INFO),
 					meta: {
 						rollupVersion: "4.23.0",
 						rolldownVersion: VERSION,
 						watchMode
 					},
-					warn: getLogHandler(LOG_LEVEL_WARN),
+					warn: getLogHandler$1(LOG_LEVEL_WARN),
 					pluginName: plugin.name || "unknown"
 				}, level, log) === false) return;
 			}
@@ -641,6 +697,30 @@ function normalizePlugins(plugins, anonymousPrefix) {
 const ANONYMOUS_PLUGIN_PREFIX = "at position ";
 const ANONYMOUS_OUTPUT_PLUGIN_PREFIX = "at output position ";
 
+//#endregion
+//#region src/plugin/minimal-plugin-context.ts
+var MinimalPluginContextImpl = class {
+	info;
+	warn;
+	debug;
+	meta;
+	constructor(onLog, logLevel, pluginName, watchMode, hookName) {
+		this.pluginName = pluginName;
+		this.hookName = hookName;
+		this.debug = getLogHandler(LOG_LEVEL_DEBUG, "PLUGIN_LOG", onLog, pluginName, logLevel);
+		this.info = getLogHandler(LOG_LEVEL_INFO, "PLUGIN_LOG", onLog, pluginName, logLevel);
+		this.warn = getLogHandler(LOG_LEVEL_WARN, "PLUGIN_WARNING", onLog, pluginName, logLevel);
+		this.meta = {
+			rollupVersion: "4.23.0",
+			rolldownVersion: VERSION,
+			watchMode
+		};
+	}
+	error(e$1) {
+		return error(logPluginError(normalizeLog(e$1), this.pluginName, { hook: this.hookName }));
+	}
+};
+
 //#endregion
 //#region src/plugin/plugin-driver.ts
 var PluginDriver = class {
@@ -1970,22 +2050,23 @@ const WatchOptionsSchema = strictObject({
 	onInvalidate: pipe(optional(pipe(function_(), args(tuple([string()])))), description("An optional function that will be called immediately every time a module changes that is part of the build."))
 });
 const ChecksOptionsSchema = strictObject({
-	circularDependency: pipe(optional(boolean()), description("Whether to emit warning when detecting circular dependency")),
-	eval: pipe(optional(boolean()), description("Whether to emit warning when detecting eval")),
-	missingGlobalName: pipe(optional(boolean()), description("Whether to emit warning when detecting missing global name")),
-	missingNameOptionForIifeExport: pipe(optional(boolean()), description("Whether to emit warning when detecting missing name option for iife export")),
-	mixedExports: pipe(optional(boolean()), description("Whether to emit warning when detecting mixed exports")),
-	unresolvedEntry: pipe(optional(boolean()), description("Whether to emit warning when detecting unresolved entry")),
-	unresolvedImport: pipe(optional(boolean()), description("Whether to emit warning when detecting unresolved import")),
-	filenameConflict: pipe(optional(boolean()), description("Whether to emit warning when detecting filename conflict")),
-	commonJsVariableInEsm: pipe(optional(boolean()), description("Whether to emit warning when detecting common js variable in esm")),
-	importIsUndefined: pipe(optional(boolean()), description("Whether to emit warning when detecting import is undefined")),
-	emptyImportMeta: pipe(optional(boolean()), description("Whether to emit warning when detecting empty import meta")),
-	cannotCallNamespace: pipe(optional(boolean()), description("Whether to emit warning when detecting cannot call namespace")),
-	configurationFieldConflict: pipe(optional(boolean()), description("Whether to emit warning when detecting configuration field conflict")),
-	preferBuiltinFeature: pipe(optional(boolean()), description("Whether to emit warning when detecting prefer builtin feature")),
-	couldNotCleanDirectory: pipe(optional(boolean()), description("Whether to emit warning when detecting could not clean directory")),
-	pluginTimings: pipe(optional(boolean()), description("Whether to emit warning when detecting plugin timings"))
+	circularDependency: pipe(optional(boolean()), description("Whether to emit warnings when detecting circular dependency")),
+	eval: pipe(optional(boolean()), description("Whether to emit warnings when detecting uses of direct `eval`s")),
+	missingGlobalName: pipe(optional(boolean()), description("Whether to emit warnings when the `output.globals` option is missing when needed")),
+	missingNameOptionForIifeExport: pipe(optional(boolean()), description("Whether to emit warnings when the `output.name` option is missing when needed")),
+	mixedExports: pipe(optional(boolean()), description("Whether to emit warnings when the way to export values is ambiguous")),
+	unresolvedEntry: pipe(optional(boolean()), description("Whether to emit warnings when an entrypoint cannot be resolved")),
+	unresolvedImport: pipe(optional(boolean()), description("Whether to emit warnings when an import cannot be resolved")),
+	filenameConflict: pipe(optional(boolean()), description("Whether to emit warnings when files generated have the same name with different contents")),
+	commonJsVariableInEsm: pipe(optional(boolean()), description("Whether to emit warnings when a CommonJS variable is used in an ES module")),
+	importIsUndefined: pipe(optional(boolean()), description("Whether to emit warnings when an imported variable is not exported")),
+	emptyImportMeta: pipe(optional(boolean()), description("Whether to emit warnings when `import.meta` is not supported with the output format and is replaced with an empty object (`{}`)")),
+	toleratedTransform: pipe(optional(boolean()), description("Whether to emit warnings when detecting tolerated transform")),
+	cannotCallNamespace: pipe(optional(boolean()), description("Whether to emit warnings when a namespace is called as a function")),
+	configurationFieldConflict: pipe(optional(boolean()), description("Whether to emit warnings when a config value is overridden by another config value with a higher priority")),
+	preferBuiltinFeature: pipe(optional(boolean()), description("Whether to emit warnings when a plugin that is covered by a built-in feature is used")),
+	couldNotCleanDirectory: pipe(optional(boolean()), description("Whether to emit warnings when Rolldown could not clean the output directory")),
+	pluginTimings: pipe(optional(boolean()), description("Whether to emit warnings when plugins take significant time during the build process"))
 });
 const CompressOptionsKeepNamesSchema = strictObject({
 	function: boolean(),
@@ -2090,7 +2171,6 @@ const InputOptionsSchema = strictObject({
 	onwarn: optional(OnwarnSchema),
 	moduleTypes: pipe(optional(ModuleTypesSchema), description("Module types for customized extensions")),
 	experimental: optional(strictObject({
-		disableLiveBindings: optional(boolean()),
 		enableComposingJsPlugins: optional(boolean()),
 		viteMode: optional(boolean()),
 		resolveNewUrlToAsset: optional(boolean()),
@@ -2121,7 +2201,7 @@ const InputOptionsSchema = strictObject({
 		literal("exports-only"),
 		literal(false)
 	]))),
-	tsconfig: pipe(optional(union([literal(true), string()])), description("Path to the tsconfig.json file."))
+	tsconfig: pipe(optional(union([boolean(), string()])), description("Path to the tsconfig.json file."))
 });
 const InputCliOverrideSchema = strictObject({
 	input: pipe(optional(array(string())), description("Entry file")),
@@ -2246,6 +2326,7 @@ const OutputOptionsSchema = strictObject({
 	inlineDynamicImports: pipe(optional(boolean()), description("Inline dynamic imports")),
 	dynamicImportInCjs: pipe(optional(boolean()), description("Dynamic import in CJS output")),
 	manualChunks: optional(ManualChunksFunctionSchema),
+	codeSplitting: optional(AdvancedChunksSchema),
 	advancedChunks: optional(AdvancedChunksSchema),
 	legalComments: pipe(optional(union([literal("none"), literal("inline")])), description("Control comments in the output")),
 	plugins: optional(custom(() => true)),
@@ -2277,10 +2358,14 @@ const OutputCliOverrideSchema = strictObject({
 	outro: pipe(optional(string()), description(getAddonDescription("bottom", "inside"))),
 	esModule: pipe(optional(boolean()), description("Always generate `__esModule` marks in non-ESM formats, defaults to `if-default-prop` (use `--no-esModule` to always disable)")),
 	globals: pipe(optional(record(string(), string())), description("Global variable of UMD / IIFE dependencies (syntax: `key=value`)")),
+	codeSplitting: pipe(optional(strictObject({
+		minSize: pipe(optional(number()), description("Minimum size of the chunk")),
+		minShareCount: pipe(optional(number()), description("Minimum share count of the chunk"))
+	})), description("Code splitting options")),
 	advancedChunks: pipe(optional(strictObject({
 		minSize: pipe(optional(number()), description("Minimum size of the chunk")),
 		minShareCount: pipe(optional(number()), description("Minimum share count of the chunk"))
-	})), description("Global variable of UMD / IIFE dependencies (syntax: `key=value`)")),
+	})), description("Deprecated: use codeSplitting instead")),
 	minify: pipe(optional(boolean()), description("Minify the bundled file"))
 });
 const OutputCliOptionsSchema = omit(strictObject({
@@ -2330,6 +2415,497 @@ function validateOption(key, options) {
 	}
 }
 
+//#endregion
+//#region src/types/plain-object-like.ts
+const LAZY_FIELDS_KEY = Symbol("__lazy_fields__");
+/**
+* Base class for classes that use `@lazyProp` decorated properties.
+*
+* **Design Pattern in Rolldown:**
+* This is a common pattern in Rolldown due to its three-layer architecture:
+* TypeScript API → NAPI Bindings → Rust Core
+*
+* **Why we use getters:**
+* For performance - to lazily fetch data from Rust bindings only when needed,
+* rather than eagerly fetching all data during object construction.
+*
+* **The problem:**
+* Getters defined on class prototypes are non-enumerable by default, which breaks:
+* - Object spread operators ({...obj})
+* - Object.keys() and similar methods
+* - Standard JavaScript object semantics
+*
+* **The solution:**
+* This base class automatically converts `@lazyProp` decorated getters into
+* own enumerable getters on each instance during construction.
+*
+* **Result:**
+* Objects get both lazy-loading performance benefits AND plain JavaScript object behavior.
+*
+* @example
+* ```typescript
+* class MyClass extends PlainObjectLike {
+*   @lazyProp
+*   get myProp() {
+*     return fetchFromRustBinding();
+*   }
+* }
+* ```
+*/
+var PlainObjectLike = class {
+	constructor() {
+		setupLazyProperties(this);
+	}
+};
+/**
+* Set up lazy properties as own getters on an instance.
+* This is called automatically by the `PlainObjectLike` base class constructor.
+*
+* @param instance - The instance to set up lazy properties on
+* @internal
+*/
+function setupLazyProperties(instance$1) {
+	const lazyFields = instance$1.constructor[LAZY_FIELDS_KEY];
+	if (!lazyFields) return;
+	for (const [propertyKey, originalGetter] of lazyFields.entries()) {
+		let cachedValue;
+		let hasValue = false;
+		Object.defineProperty(instance$1, propertyKey, {
+			get() {
+				if (!hasValue) {
+					cachedValue = originalGetter.call(this);
+					hasValue = true;
+				}
+				return cachedValue;
+			},
+			enumerable: true,
+			configurable: true
+		});
+	}
+}
+/**
+* Get all lazy field names from a class instance.
+*
+* @param instance - Instance to inspect
+* @returns Set of lazy property names
+*/
+function getLazyFields(instance$1) {
+	const lazyFields = instance$1.constructor[LAZY_FIELDS_KEY];
+	return lazyFields ? new Set(lazyFields.keys()) : /* @__PURE__ */ new Set();
+}
+
+//#endregion
+//#region src/decorators/lazy.ts
+/**
+* Decorator that marks a getter as lazy-evaluated and cached.
+*
+* **What "lazy" means here:**
+* 1. Data is lazily fetched from Rust bindings only when the property is accessed (not eagerly on construction)
+* 2. Once fetched, the data is cached for subsequent accesses (performance optimization)
+* 3. Despite being a getter, it behaves like a plain object property (enumerable, appears in Object.keys())
+*
+* **Important**: Properties decorated with `@lazyProp` are defined as own enumerable
+* properties on each instance (not on the prototype). This ensures they:
+* - Appear in Object.keys() and Object.getOwnPropertyNames()
+* - Are included in object spreads ({...obj})
+* - Are enumerable in for...in loops
+*
+* Classes using this decorator must extend `PlainObjectLike` base class.
+*
+* @example
+* ```typescript
+* class MyClass extends PlainObjectLike {
+*   @lazyProp
+*   get expensiveValue() {
+*     return someExpensiveComputation();
+*   }
+* }
+* ```
+*/
+function lazyProp(target, propertyKey, descriptor) {
+	if (!target.constructor[LAZY_FIELDS_KEY]) target.constructor[LAZY_FIELDS_KEY] = /* @__PURE__ */ new Map();
+	const originalGetter = descriptor.get;
+	target.constructor[LAZY_FIELDS_KEY].set(propertyKey, originalGetter);
+	return {
+		enumerable: false,
+		configurable: true
+	};
+}
+
+//#endregion
+//#region src/utils/asset-source.ts
+function transformAssetSource(bindingAssetSource) {
+	return bindingAssetSource.inner;
+}
+function bindingAssetSource(source) {
+	return { inner: source };
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.108.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 extends PlainObjectLike {
+	type = "asset";
+	constructor(bindingAsset) {
+		super();
+		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([lazyProp], OutputAssetImpl.prototype, "fileName", null);
+__decorate([lazyProp], OutputAssetImpl.prototype, "originalFileName", null);
+__decorate([lazyProp], OutputAssetImpl.prototype, "originalFileNames", null);
+__decorate([lazyProp], OutputAssetImpl.prototype, "name", null);
+__decorate([lazyProp], OutputAssetImpl.prototype, "names", null);
+__decorate([lazyProp], OutputAssetImpl.prototype, "source", 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 extends PlainObjectLike {
+	type = "chunk";
+	constructor(bindingChunk) {
+		super();
+		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([lazyProp], OutputChunkImpl.prototype, "fileName", null);
+__decorate([lazyProp], OutputChunkImpl.prototype, "name", null);
+__decorate([lazyProp], OutputChunkImpl.prototype, "exports", null);
+__decorate([lazyProp], OutputChunkImpl.prototype, "isEntry", null);
+__decorate([lazyProp], OutputChunkImpl.prototype, "facadeModuleId", null);
+__decorate([lazyProp], OutputChunkImpl.prototype, "isDynamicEntry", null);
+__decorate([lazyProp], OutputChunkImpl.prototype, "sourcemapFileName", null);
+__decorate([lazyProp], OutputChunkImpl.prototype, "preliminaryFileName", null);
+__decorate([lazyProp], OutputChunkImpl.prototype, "code", null);
+__decorate([lazyProp], OutputChunkImpl.prototype, "modules", null);
+__decorate([lazyProp], OutputChunkImpl.prototype, "imports", null);
+__decorate([lazyProp], OutputChunkImpl.prototype, "dynamicImports", null);
+__decorate([lazyProp], OutputChunkImpl.prototype, "moduleIds", null);
+__decorate([lazyProp], OutputChunkImpl.prototype, "map", null);
+
+//#endregion
+//#region src/types/sourcemap.ts
+function bindingifySourcemap$1(map) {
+	if (map == null) return;
+	return { inner: typeof map === "string" ? map : {
+		file: map.file ?? void 0,
+		mappings: map.mappings,
+		sourceRoot: "sourceRoot" in map ? map.sourceRoot ?? void 0 : void 0,
+		sources: map.sources?.map((s) => s ?? void 0),
+		sourcesContent: map.sourcesContent?.map((s) => s ?? void 0),
+		names: map.names,
+		x_google_ignoreList: map.x_google_ignoreList,
+		debugId: "debugId" in map ? map.debugId : void 0
+	} };
+}
+
+//#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 extends PlainObjectLike {
@@ -2355,7 +2931,7 @@ var RolldownOutputImpl = class extends PlainObjectLike {
 __decorate([lazyProp], RolldownOutputImpl.prototype, "output", null);
 
 //#endregion
-//#region ../../node_modules/.pnpm/oxc-parser@0.107.0/node_modules/oxc-parser/src-js/wrap.js
+//#region ../../node_modules/.pnpm/oxc-parser@0.108.0/node_modules/oxc-parser/src-js/wrap.js
 function wrap$1(result) {
 	let program, module, comments, errors;
 	return {
@@ -2633,9 +3209,9 @@ function exclude(expr) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/remeda@2.33.0/node_modules/remeda/dist/lazyDataLastImpl-DtF3cihj.js
-function e(e$1, t$2, n$1) {
-	let r = (n$2) => e$1(n$2, ...t$2);
+//#region ../../node_modules/.pnpm/remeda@2.33.1/node_modules/remeda/dist/lazyDataLastImpl-DtF3cihj.js
+function e(e, t$2, n$1) {
+	let r = (n$2) => e(n$2, ...t$2);
 	return n$1 === void 0 ? r : Object.assign(r, {
 		lazy: n$1,
 		lazyArgs: t$2
@@ -2643,7 +3219,7 @@ function e(e$1, t$2, n$1) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/remeda@2.33.0/node_modules/remeda/dist/purry-GjwKKIlp.js
+//#region ../../node_modules/.pnpm/remeda@2.33.1/node_modules/remeda/dist/purry-GjwKKIlp.js
 function t$1(t$2, n$1, r) {
 	let i = t$2.length - n$1.length;
 	if (i === 0) return t$2(...n$1);
@@ -2652,14 +3228,14 @@ function t$1(t$2, n$1, r) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/remeda@2.33.0/node_modules/remeda/dist/partition.js
-function t(...t$2) {
-	return t$1(n, t$2);
-}
-const n = (e$1, t$2) => {
-	let n$1 = [[], []];
-	for (let [r, i] of e$1.entries()) t$2(i, r, e$1) ? n$1[0].push(i) : n$1[1].push(i);
-	return n$1;
+//#region ../../node_modules/.pnpm/remeda@2.33.1/node_modules/remeda/dist/partition.js
+function t(...t) {
+	return t$1(n, t);
+}
+const n = (e$1, t) => {
+	let n = [[], []];
+	for (let [r, i] of e$1.entries()) t(i, r, e$1) ? n[0].push(i) : n[1].push(i);
+	return n;
 };
 
 //#endregion
@@ -2973,16 +3549,16 @@ var TransformPluginContextImpl = class extends PluginContextImpl {
 		this.inner = inner;
 		this.moduleId = moduleId;
 		this.moduleSource = moduleSource;
-		const getLogHandler = (handler) => (log, pos) => {
+		const getLogHandler$1 = (handler) => (log, pos) => {
 			log = normalizeLog(log);
 			if (pos) augmentCodeLocation(log, pos, moduleSource, moduleId);
 			log.id = moduleId;
 			log.hook = "transform";
 			handler(log);
 		};
-		this.debug = getLogHandler(this.debug);
-		this.warn = getLogHandler(this.warn);
-		this.info = getLogHandler(this.info);
+		this.debug = getLogHandler$1(this.debug);
+		this.warn = getLogHandler$1(this.warn);
+		this.info = getLogHandler$1(this.info);
 	}
 	error(e$1, pos) {
 		if (typeof e$1 === "string") e$1 = { message: e$1 };
@@ -3298,8 +3874,8 @@ function bindingifyCloseBundle(args$1) {
 	if (!hook) return {};
 	const { handler, meta } = normalizeHook(hook);
 	return {
-		plugin: async (ctx) => {
-			await handler.call(new PluginContextImpl(args$1.outputOptions, ctx, args$1.plugin, args$1.pluginContextData, args$1.onLog, args$1.logLevel, args$1.watchMode));
+		plugin: async (ctx, err) => {
+			await handler.call(new PluginContextImpl(args$1.outputOptions, ctx, args$1.plugin, args$1.pluginContextData, args$1.onLog, args$1.logLevel, args$1.watchMode), err ? aggregateBindingErrorsIntoJsError(err) : void 0);
 		},
 		meta: bindingifyPluginHookMeta(meta)
 	};
@@ -3380,29 +3956,29 @@ function bindingifyCloseWatcher(args$1) {
 
 //#endregion
 //#region src/plugin/generated/hook-usage.ts
-let HookUsageKind = /* @__PURE__ */ function(HookUsageKind$1) {
-	HookUsageKind$1[HookUsageKind$1["buildStart"] = 1] = "buildStart";
-	HookUsageKind$1[HookUsageKind$1["resolveId"] = 2] = "resolveId";
-	HookUsageKind$1[HookUsageKind$1["resolveDynamicImport"] = 4] = "resolveDynamicImport";
-	HookUsageKind$1[HookUsageKind$1["load"] = 8] = "load";
-	HookUsageKind$1[HookUsageKind$1["transform"] = 16] = "transform";
-	HookUsageKind$1[HookUsageKind$1["moduleParsed"] = 32] = "moduleParsed";
-	HookUsageKind$1[HookUsageKind$1["buildEnd"] = 64] = "buildEnd";
-	HookUsageKind$1[HookUsageKind$1["renderStart"] = 128] = "renderStart";
-	HookUsageKind$1[HookUsageKind$1["renderError"] = 256] = "renderError";
-	HookUsageKind$1[HookUsageKind$1["renderChunk"] = 512] = "renderChunk";
-	HookUsageKind$1[HookUsageKind$1["augmentChunkHash"] = 1024] = "augmentChunkHash";
-	HookUsageKind$1[HookUsageKind$1["generateBundle"] = 2048] = "generateBundle";
-	HookUsageKind$1[HookUsageKind$1["writeBundle"] = 4096] = "writeBundle";
-	HookUsageKind$1[HookUsageKind$1["closeBundle"] = 8192] = "closeBundle";
-	HookUsageKind$1[HookUsageKind$1["watchChange"] = 16384] = "watchChange";
-	HookUsageKind$1[HookUsageKind$1["closeWatcher"] = 32768] = "closeWatcher";
-	HookUsageKind$1[HookUsageKind$1["transformAst"] = 65536] = "transformAst";
-	HookUsageKind$1[HookUsageKind$1["banner"] = 131072] = "banner";
-	HookUsageKind$1[HookUsageKind$1["footer"] = 262144] = "footer";
-	HookUsageKind$1[HookUsageKind$1["intro"] = 524288] = "intro";
-	HookUsageKind$1[HookUsageKind$1["outro"] = 1048576] = "outro";
-	return HookUsageKind$1;
+let HookUsageKind = /* @__PURE__ */ function(HookUsageKind) {
+	HookUsageKind[HookUsageKind["buildStart"] = 1] = "buildStart";
+	HookUsageKind[HookUsageKind["resolveId"] = 2] = "resolveId";
+	HookUsageKind[HookUsageKind["resolveDynamicImport"] = 4] = "resolveDynamicImport";
+	HookUsageKind[HookUsageKind["load"] = 8] = "load";
+	HookUsageKind[HookUsageKind["transform"] = 16] = "transform";
+	HookUsageKind[HookUsageKind["moduleParsed"] = 32] = "moduleParsed";
+	HookUsageKind[HookUsageKind["buildEnd"] = 64] = "buildEnd";
+	HookUsageKind[HookUsageKind["renderStart"] = 128] = "renderStart";
+	HookUsageKind[HookUsageKind["renderError"] = 256] = "renderError";
+	HookUsageKind[HookUsageKind["renderChunk"] = 512] = "renderChunk";
+	HookUsageKind[HookUsageKind["augmentChunkHash"] = 1024] = "augmentChunkHash";
+	HookUsageKind[HookUsageKind["generateBundle"] = 2048] = "generateBundle";
+	HookUsageKind[HookUsageKind["writeBundle"] = 4096] = "writeBundle";
+	HookUsageKind[HookUsageKind["closeBundle"] = 8192] = "closeBundle";
+	HookUsageKind[HookUsageKind["watchChange"] = 16384] = "watchChange";
+	HookUsageKind[HookUsageKind["closeWatcher"] = 32768] = "closeWatcher";
+	HookUsageKind[HookUsageKind["transformAst"] = 65536] = "transformAst";
+	HookUsageKind[HookUsageKind["banner"] = 131072] = "banner";
+	HookUsageKind[HookUsageKind["footer"] = 262144] = "footer";
+	HookUsageKind[HookUsageKind["intro"] = 524288] = "intro";
+	HookUsageKind[HookUsageKind["outro"] = 1048576] = "outro";
+	return HookUsageKind;
 }({});
 var HookUsage = class {
 	bitflag = BigInt(0);
@@ -3900,8 +4476,6 @@ function bindingifyInputOptions(rawPlugins, inputOptions, outputOptions, normali
 	const plugins = rawPlugins.map((plugin) => {
 		if ("_parallel" in plugin) return;
 		if (plugin instanceof BuiltinPlugin) switch (plugin.name) {
-			case "builtin:vite-css-post": return bindingifyCSSPostPlugin(plugin, pluginContextData);
-			case "builtin:vite-html": return bindingifyViteHtmlPlugin(plugin, onLog, logLevel, watchMode, pluginContextData);
 			case "builtin:vite-manifest": return bindingifyManifestPlugin(plugin, pluginContextData);
 			default: return bindingifyBuiltInPlugin(plugin);
 		}
@@ -3984,7 +4558,6 @@ function bindingifyExperimental(experimental) {
 	}
 	return {
 		strictExecutionOrder: experimental?.strictExecutionOrder,
-		disableLiveBindings: experimental?.disableLiveBindings,
 		viteMode: experimental?.viteMode,
 		resolveNewUrlToAsset: experimental?.resolveNewUrlToAsset,
 		devMode: bindingifyDevMode(experimental?.devMode),
@@ -4147,7 +4720,7 @@ function bindingifyOutputOptions(outputOptions) {
 	if (outputOptions.inlineDynamicImports === true) {
 		if (manualChunks != null) throw new Error("Invalid value \"true\" for option \"output.inlineDynamicImports\" - this option is not supported for \"output.manualChunks\".");
 	}
-	const advancedChunks = bindingifyAdvancedChunks(outputOptions.advancedChunks, manualChunks);
+	const advancedChunks = bindingifyAdvancedChunks(outputOptions.codeSplitting, outputOptions.advancedChunks, manualChunks);
 	return {
 		dir,
 		file: file == null ? void 0 : file,
@@ -4181,7 +4754,7 @@ function bindingifyOutputOptions(outputOptions) {
 		externalLiveBindings: outputOptions.externalLiveBindings,
 		inlineDynamicImports: outputOptions.inlineDynamicImports,
 		dynamicImportInCjs: outputOptions.dynamicImportInCjs,
-		advancedChunks,
+		manualCodeSplitting: advancedChunks,
 		polyfillRequire: outputOptions.polyfillRequire,
 		sanitizeFileName,
 		preserveModules,
@@ -4234,15 +4807,21 @@ function bindingifyAssetFilenames(assetFileNames) {
 	};
 	return assetFileNames;
 }
-function bindingifyAdvancedChunks(advancedChunks, manualChunks) {
-	if (manualChunks != null && advancedChunks != null) console.warn("`manualChunks` option is ignored due to `advancedChunks` option is specified.");
-	else if (manualChunks != null) advancedChunks = { groups: [{ name(moduleId, ctx) {
+function bindingifyAdvancedChunks(codeSplitting, advancedChunks, manualChunks) {
+	let effectiveOption = codeSplitting;
+	if (codeSplitting != null && advancedChunks != null) console.warn("`advancedChunks` option is ignored due to `codeSplitting` option is specified.");
+	else if (codeSplitting == null && advancedChunks != null) {
+		console.warn("`advancedChunks` option is deprecated, please use `codeSplitting` instead.");
+		effectiveOption = advancedChunks;
+	}
+	if (manualChunks != null && effectiveOption != null) console.warn("`manualChunks` option is ignored due to `codeSplitting` option is specified.");
+	else if (manualChunks != null) effectiveOption = { groups: [{ name(moduleId, ctx) {
 		return manualChunks(moduleId, { getModuleInfo: (id$1) => ctx.getModuleInfo(id$1) });
 	} }] };
-	if (advancedChunks == null) return;
-	const { groups, ...restAdvancedChunks } = advancedChunks;
+	if (effectiveOption == null) return;
+	const { groups, ...restOptions } = effectiveOption;
 	return {
-		...restAdvancedChunks,
+		...restOptions,
 		groups: groups?.map((group) => {
 			const { name, ...restGroup } = group;
 			return {
@@ -4338,4 +4917,4 @@ var RolldownBuild = class RolldownBuild {
 };
 
 //#endregion
-export { unwrapBindingResult as a, validateOption as c, normalizeBindingResult as i, PluginDriver as l, createBundlerOptions as n, parse$1 as o, aggregateBindingErrorsIntoJsError as r, parseSync$1 as s, RolldownBuild as t };
+export { unwrapBindingResult as a, transformToRollupOutput as c, LOG_LEVEL_WARN as d, arraify as f, normalizeBindingResult as i, validateOption as l, createBundlerOptions as n, parse$1 as o, VERSION as p, aggregateBindingErrorsIntoJsError as r, parseSync$1 as s, RolldownBuild as t, PluginDriver as u };