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

package/dist/shared/{bindingify-input-options--qcSYuhh.mjs → bindingify-input-options-C4xVxTKf.mjs}

@@ -1,12 +1,50 @@
-import { c as logPluginError, n as error, r as logCycleLoading, t as augmentCodeLocation } from "./logs-DEfpOy5A.mjs";
-import { a as unreachable, o as unsupported, t as arraify } from "./misc-BubmxcE3.mjs";
-import { E as LOG_LEVEL_WARN, S as normalizeLog, _ as PlainObjectLike, a as bindingifyManifestPlugin, c as collectChangedBundle, d as bindingifySourcemap, f as transformRenderedChunk, g as lazyProp, i as bindingifyCSSPostPlugin, l as transformToOutputBundle, m as bindingAssetSource, n as BuiltinPlugin, o as bindingifyViteHtmlPlugin, p as __decorate, r as bindingifyBuiltInPlugin, t as normalizedStringOrRegex, v as MinimalPluginContextImpl } from "./normalize-string-or-regex-CIiT1lMg.mjs";
-import { t as parseAst } from "./parse-ast-index-CgzK6cxG.mjs";
-import { a as id, f as or, n as code, r as exclude, s as include, t as and, u as moduleType } from "./composable-filters-C5qA4jo-.mjs";
+import { a as logInvalidLogPosition, c as logPluginError, n as error, r as logCycleLoading, t as augmentCodeLocation } from "./logs-cXucB9vK.mjs";
+import { i as bindingifyManifestPlugin, n as BuiltinPlugin, r as bindingifyBuiltInPlugin, t as normalizedStringOrRegex } from "./normalize-string-or-regex-Bn5eoSii.mjs";
+import { _ as noop, a as id, b as unsupported, f as or, h as arraify, n as code, r as exclude, s as include, t as and, u as moduleType, y as unreachable } from "./composable-filters-DmVadxLf.mjs";
+import { t as parseAst } from "./parse-ast-index-B54CTqgh.mjs";
 import { BindingAttachDebugInfo, BindingChunkModuleOrderBy, BindingLogLevel, BindingMagicString, BindingPluginOrder, BindingPropertyReadSideEffects, BindingPropertyWriteSideEffects } from "../rolldown-binding.wasi.cjs";
 import path from "node:path";
 import fsp from "node:fs/promises";
 
+//#region package.json
+var version = "1.0.0-beta.60";
+var description = "Fast JavaScript/TypeScript bundler in Rust with Rollup-compatible API.";
+
+//#endregion
+//#region src/version.ts
+/** @category Plugin APIs */
+const VERSION = version;
+
+//#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/utils/normalize-hook.ts
 function normalizeHook(hook) {
 	if (typeof hook === "function" || typeof hook === "string") return {
@@ -25,6 +63,521 @@ function normalizeHook(hook) {
 	unreachable("Invalid hook type");
 }
 
+//#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/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) {
+	const lazyFields = instance.constructor[LAZY_FIELDS_KEY];
+	if (!lazyFields) return;
+	for (const [propertyKey, originalGetter] of lazyFields.entries()) {
+		let cachedValue;
+		let hasValue = false;
+		Object.defineProperty(instance, 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) {
+	const lazyFields = instance.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(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(item.map),
+			sourcemapFilename: item.sourcemapFileName || void 0,
+			preliminaryFilename: item.preliminaryFileName
+		};
+	}
+	return {
+		changes,
+		deleted: changed.deleted
+	};
+}
+
 //#endregion
 //#region src/utils/error.ts
 function unwrapBindingResult(container) {
@@ -132,9 +685,9 @@ function normalizeTransformHookSourcemap(id$1, originalCode, rawMap) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/remeda@2.32.0/node_modules/remeda/dist/lazyDataLastImpl-BDhrIOwR.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
@@ -142,7 +695,7 @@ function e(e$1, t$2, n$1) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/remeda@2.32.0/node_modules/remeda/dist/purry-DH9cw9sy.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);
@@ -151,14 +704,14 @@ function t$1(t$2, n$1, r) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/remeda@2.32.0/node_modules/remeda/dist/partition-DAu403JQ.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
@@ -467,16 +1020,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 };
@@ -792,8 +1345,8 @@ function bindingifyCloseBundle(args) {
 	if (!hook) return {};
 	const { handler, meta } = normalizeHook(hook);
 	return {
-		plugin: async (ctx) => {
-			await handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode));
+		plugin: async (ctx, err) => {
+			await handler.call(new PluginContextImpl(args.outputOptions, ctx, args.plugin, args.pluginContextData, args.onLog, args.logLevel, args.watchMode), err ? aggregateBindingErrorsIntoJsError(err) : void 0);
 		},
 		meta: bindingifyPluginHookMeta(meta)
 	};
@@ -874,29 +1427,29 @@ function bindingifyCloseWatcher(args) {
 
 //#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);
@@ -1394,8 +1947,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);
 		}
@@ -1478,7 +2029,6 @@ function bindingifyExperimental(experimental) {
 	}
 	return {
 		strictExecutionOrder: experimental?.strictExecutionOrder,
-		disableLiveBindings: experimental?.disableLiveBindings,
 		viteMode: experimental?.viteMode,
 		resolveNewUrlToAsset: experimental?.resolveNewUrlToAsset,
 		devMode: bindingifyDevMode(experimental?.devMode),
@@ -1487,7 +2037,8 @@ function bindingifyExperimental(experimental) {
 		chunkImportMap: experimental?.chunkImportMap,
 		onDemandWrapping: experimental?.onDemandWrapping,
 		incrementalBuild: experimental?.incrementalBuild,
-		nativeMagicString: experimental?.nativeMagicString
+		nativeMagicString: experimental?.nativeMagicString,
+		chunkOptimization: experimental?.chunkOptimization
 	};
 }
 function bindingifyResolve(resolve) {
@@ -1618,4 +2169,4 @@ function bindingifyPreserveEntrySignatures(preserveEntrySignatures) {
 }
 
 //#endregion
-export { aggregateBindingErrorsIntoJsError as a, normalizeHook as c, transformModuleInfo as i, PluginContextData as n, normalizeBindingResult as o, bindingifyPlugin as r, unwrapBindingResult as s, bindingifyInputOptions as t };
+export { description as C, VERSION as S, LOG_LEVEL_DEBUG as _, aggregateBindingErrorsIntoJsError as a, LOG_LEVEL_WARN as b, transformToRollupOutput as c, transformAssetSource as d, lazyProp as f, normalizeLog as g, normalizeHook as h, transformModuleInfo as i, transformRenderedChunk as l, MinimalPluginContextImpl as m, PluginContextData as n, normalizeBindingResult as o, PlainObjectLike as p, bindingifyPlugin as r, unwrapBindingResult as s, bindingifyInputOptions as t, __decorate as u, LOG_LEVEL_ERROR as v, version as w, logLevelPriority as x, LOG_LEVEL_INFO as y };