@rolldown/browser 1.0.0-rc.1 → 1.0.0-rc.2

package/dist/shared/{load-config-BBZgIUGN.mjs → load-config-hx3WBhLe.mjs}

@@ -1,4 +1,4 @@
-import { t as rolldown } from "./rolldown-C0_W0QdY.mjs";
+import { t as rolldown } from "./rolldown-D2E0YTeB.mjs";
 import path from "node:path";
 import { readdir } from "node:fs/promises";
 import { pathToFileURL } from "node:url";

package/dist/shared/{logging-Nvu645a7.d.mts → logging-RB67zQ4N.d.mts}

@@ -9,9 +9,9 @@ interface RolldownLog {
   binding?: string;
   cause?: unknown;
   /**
-  	* The log code for this log object.
-  	* @example 'PLUGIN_ERROR'
-  	*/
+  * The log code for this log object.
+  * @example 'PLUGIN_ERROR'
+  */
   code?: string;
   exporter?: string;
   frame?: string;
@@ -24,9 +24,9 @@ interface RolldownLog {
     line: number;
   };
   /**
-  	* The message for this log object.
-  	* @example 'The "transform" hook used by the output plugin "rolldown-plugin-foo" is a build time hook and will not be run for that plugin. Either this plugin cannot be used as an output plugin, or it should have an option to configure it as an output plugin.'
-  	*/
+  * The message for this log object.
+  * @example 'The "transform" hook used by the output plugin "rolldown-plugin-foo" is a build time hook and will not be run for that plugin. Either this plugin cannot be used as an output plugin, or it should have an option to configure it as an output plugin.'
+  */
   message: string;
   meta?: any;
   names?: string[];

package/dist/shared/{parse-ast-index-2ahkCVK6.mjs → parse-ast-index-BQpfNG1v.mjs}

@@ -1,7 +1,7 @@
 import { l as locate, n as error, s as logParseError, t as augmentCodeLocation, u as getCodeFrame } from "./logs-B2CASPcx.mjs";
 import { parse, parseSync } from "../rolldown-binding.wasi.cjs";
 
-//#region ../../node_modules/.pnpm/oxc-parser@0.110.0/node_modules/oxc-parser/src-js/wrap.js
+//#region ../../node_modules/.pnpm/oxc-parser@0.111.0/node_modules/oxc-parser/src-js/wrap.js
 function wrap$1(result) {
 	let program, module, comments, errors;
 	return {

package/dist/shared/{prompt-B6NrDD1-.mjs → prompt-CYPmuhh-.mjs}

@@ -1,6 +1,6 @@
 import process$1, { stdin, stdout } from "node:process";
 import { WriteStream } from "node:tty";
-import f$1 from "node:readline";
+import f from "node:readline";
 
 //#region ../../node_modules/.pnpm/consola@3.4.2/node_modules/consola/dist/chunks/prompt.mjs
 function getDefaultExportFromCjs(x) {
@@ -481,13 +481,13 @@ var x = class {
 			const e = new WriteStream(0);
 			e._write = (s, i, D) => {
 				this._track && (this.value = this.rl?.line.replace(/\t/g, ""), this._cursor = this.rl?.cursor ?? 0, this.emit("value", this.value)), D();
-			}, this.input.pipe(e), this.rl = f$1.createInterface({
+			}, this.input.pipe(e), this.rl = f.createInterface({
 				input: this.input,
 				output: e,
 				tabSize: 2,
 				prompt: "",
 				escapeCodeTimeout: 50
-			}), f$1.emitKeypressEvents(this.input, this.rl), this.rl.prompt(), this.opts.initialValue !== void 0 && this._track && this.rl.write(this.opts.initialValue), this.input.on("keypress", this.onKeypress), d$1(this.input, true), this.output.on("resize", this.render), this.render(), this.once("submit", () => {
+			}), f.emitKeypressEvents(this.input, this.rl), this.rl.prompt(), this.opts.initialValue !== void 0 && this._track && this.rl.write(this.opts.initialValue), this.input.on("keypress", this.onKeypress), d$1(this.input, true), this.output.on("resize", this.render), this.render(), this.once("submit", () => {
 				this.output.write(srcExports.cursor.show), this.output.off("resize", this.render), d$1(this.input, false), u(this.value);
 			}), this.once("cancel", () => {
 				this.output.write(srcExports.cursor.show), this.output.off("resize", this.render), d$1(this.input, false), u(S);

package/dist/shared/{rolldown-C0_W0QdY.mjs → rolldown-D2E0YTeB.mjs}

@@ -1,4 +1,4 @@
-import { l as PluginDriver, s as validateOption, t as RolldownBuild } from "./rolldown-build-DLuUhuNw.mjs";
+import { l as PluginDriver, s as validateOption, t as RolldownBuild } from "./rolldown-build-Do6WlRGM.mjs";
 
 //#region src/api/rolldown/index.ts
 /**

package/dist/shared/{rolldown-build-DLuUhuNw.mjs → rolldown-build-Do6WlRGM.mjs}

@@ -1,6 +1,6 @@
 import { i as logInputHookInOutputPlugin, n as error } from "./logs-B2CASPcx.mjs";
 import { n as BuiltinPlugin } from "./normalize-string-or-regex-DIwprzLy.mjs";
-import { S as VERSION, _ as LOG_LEVEL_DEBUG, b as LOG_LEVEL_WARN, c as transformToRollupOutput, d as transformAssetSource, f as lazyProp, g as normalizeLog, h as normalizeHook, i as transformModuleInfo, l as transformRenderedChunk, m as MinimalPluginContextImpl, p as PlainObjectLike, s as unwrapBindingResult, t as bindingifyInputOptions, u as __decorate, v as LOG_LEVEL_ERROR, x as logLevelPriority, y as LOG_LEVEL_INFO } from "./bindingify-input-options-Bp2kpiI8.mjs";
+import { S as VERSION, _ as LOG_LEVEL_DEBUG, b as LOG_LEVEL_WARN, c as transformToRollupOutput, d as transformAssetSource, f as lazyProp, g as normalizeLog, h as normalizeHook, i as transformModuleInfo, l as transformRenderedChunk, m as MinimalPluginContextImpl, p as PlainObjectLike, s as unwrapBindingResult, t as bindingifyInputOptions, u as __decorate, v as LOG_LEVEL_ERROR, x as logLevelPriority, y as LOG_LEVEL_INFO } from "./bindingify-input-options-CObJx_Uj.mjs";
 import { v as unimplemented } from "./composable-filters-CIxSuZSM.mjs";
 import { Worker } from "node:worker_threads";
 import { BindingBundler, ParallelJsPluginRegistry, shutdownAsyncRuntime, startAsyncRuntime } from "../rolldown-binding.wasi.cjs";
@@ -537,6 +537,19 @@ function getDefault(schema, dataset, config$1) {
 	return typeof schema.default === "function" ? schema.default(dataset, config$1) : schema.default;
 }
 /**
+* Checks if the input matches the schema. By using a type predicate, this
+* function can be used as a type guard.
+*
+* @param schema The schema to be used.
+* @param input The input to be tested.
+*
+* @returns Whether the input matches the schema.
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function is(schema, input) {
+	return !schema["~run"]({ value: input }, { abortEarly: true }).issues;
+}
+/**
 * Creates an any schema.
 *
 * Hint: This schema function exists only for completeness and is not
@@ -709,74 +722,6 @@ function literal(literal_, message$1) {
 	};
 }
 /* @__NO_SIDE_EFFECTS__ */
-function looseObject(entries$1, message$1) {
-	return {
-		kind: "schema",
-		type: "loose_object",
-		reference: looseObject,
-		expects: "Object",
-		async: false,
-		entries: entries$1,
-		message: message$1,
-		get "~standard"() {
-			return /* @__PURE__ */ _getStandardProps(this);
-		},
-		"~run"(dataset, config$1) {
-			const input = dataset.value;
-			if (input && typeof input === "object") {
-				dataset.typed = true;
-				dataset.value = {};
-				for (const key in this.entries) {
-					const valueSchema = this.entries[key];
-					if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
-						const value$1 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
-						const valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
-						if (valueDataset.issues) {
-							const pathItem = {
-								type: "object",
-								origin: "value",
-								input,
-								key,
-								value: value$1
-							};
-							for (const issue of valueDataset.issues) {
-								if (issue.path) issue.path.unshift(pathItem);
-								else issue.path = [pathItem];
-								dataset.issues?.push(issue);
-							}
-							if (!dataset.issues) dataset.issues = valueDataset.issues;
-							if (config$1.abortEarly) {
-								dataset.typed = false;
-								break;
-							}
-						}
-						if (!valueDataset.typed) dataset.typed = false;
-						dataset.value[key] = valueDataset.value;
-					} else if (valueSchema.fallback !== void 0) dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
-					else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
-						_addIssue(this, "key", dataset, config$1, {
-							input: void 0,
-							expected: `"${key}"`,
-							path: [{
-								type: "object",
-								origin: "key",
-								input,
-								key,
-								value: input[key]
-							}]
-						});
-						if (config$1.abortEarly) break;
-					}
-				}
-				if (!dataset.issues || !config$1.abortEarly) {
-					for (const key in input) if (/* @__PURE__ */ _isValidObjectKey(input, key) && !(key in this.entries)) dataset.value[key] = input[key];
-				}
-			} else _addIssue(this, "type", dataset, config$1);
-			return dataset;
-		}
-	};
-}
-/* @__NO_SIDE_EFFECTS__ */
 function never(message$1) {
 	return {
 		kind: "schema",
@@ -1491,7 +1436,9 @@ function styleText$1(...args) {
 
 //#endregion
 //#region src/utils/validator.ts
+function isTypeTrue() {}
 const StringOrRegExpSchema = union([string(), instance(RegExp)]);
+isTypeTrue();
 function vFunction() {
 	return function_();
 }
@@ -1500,25 +1447,32 @@ const LogLevelSchema = union([
 	literal("info"),
 	literal("warn")
 ]);
+isTypeTrue();
 const LogLevelOptionSchema = union([LogLevelSchema, literal("silent")]);
+isTypeTrue();
 const LogLevelWithErrorSchema = union([LogLevelSchema, literal("error")]);
+isTypeTrue();
 const RollupLogSchema = any();
 const RollupLogWithStringSchema = union([RollupLogSchema, string()]);
+isTypeTrue();
 const InputOptionSchema = union([
 	string(),
 	array(string()),
 	record(string(), string())
 ]);
+isTypeTrue();
 const ExternalOptionFunctionSchema = pipe(vFunction(), args(tuple([
 	string(),
 	optional(string()),
 	boolean()
 ])), returns(nullish(boolean())));
+isTypeTrue();
 const ExternalOptionSchema = union([
 	StringOrRegExpSchema,
 	array(StringOrRegExpSchema),
 	ExternalOptionFunctionSchema
 ]);
+isTypeTrue();
 const ModuleTypesSchema = record(string(), union([
 	literal("asset"),
 	literal("base64"),
@@ -1533,21 +1487,26 @@ const ModuleTypesSchema = record(string(), union([
 	literal("ts"),
 	literal("tsx")
 ]));
+isTypeTrue();
 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(boolean()), description("Toggles whether to throw an error when a tag name uses an XML namespace")),
+	pure: pipe(optional(boolean()), description("Mark JSX elements and top-level React method calls as pure for tree shaking.")),
 	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")),
-	refresh: pipe(optional(boolean()), description("Enable react fast refresh"))
+	refresh: pipe(optional(union([boolean(), any()])), description("Enable react fast refresh"))
 });
+isTypeTrue();
 const HelperModeSchema = union([literal("Runtime"), literal("External")]);
 const DecoratorOptionSchema = object({
 	legacy: optional(boolean()),
 	emitDecoratorMetadata: optional(boolean())
 });
+isTypeTrue();
 const HelpersSchema = object({ mode: optional(HelperModeSchema) });
+isTypeTrue();
 const RewriteImportExtensionsSchema = union([
 	literal("rewrite"),
 	literal("remove"),
@@ -1559,12 +1518,14 @@ const TypescriptSchema = object({
 	onlyRemoveTypeImports: optional(boolean()),
 	allowNamespaces: optional(boolean()),
 	allowDeclareFields: optional(boolean()),
+	removeClassFieldsWithoutInitializer: optional(boolean()),
 	declaration: optional(object({
 		stripInternal: optional(boolean()),
 		sourcemap: optional(boolean())
 	})),
 	rewriteImportExtensions: optional(RewriteImportExtensionsSchema)
 });
+isTypeTrue();
 const AssumptionsSchema = object({
 	ignoreFunctionLength: optional(boolean()),
 	noDocumentAll: optional(boolean()),
@@ -1572,11 +1533,17 @@ const AssumptionsSchema = object({
 	pureGetters: optional(boolean()),
 	setPublicClassFields: optional(boolean())
 });
+isTypeTrue();
+const TransformPluginsSchema = object({
+	styledComponents: optional(any()),
+	taggedTemplateEscape: optional(boolean())
+});
+isTypeTrue();
 const TransformOptionsSchema = object({
 	assumptions: optional(AssumptionsSchema),
 	typescript: optional(TypescriptSchema),
 	helpers: optional(HelpersSchema),
-	decorators: optional(DecoratorOptionSchema),
+	decorator: optional(DecoratorOptionSchema),
 	jsx: optional(union([
 		literal(false),
 		literal("preserve"),
@@ -1587,9 +1554,11 @@ const TransformOptionsSchema = object({
 	target: pipe(optional(union([string(), array(string())])), description("The JavaScript target environment")),
 	define: pipe(optional(record(string(), string())), description("Define global variables (syntax: key=value,key2=value2)")),
 	inject: pipe(optional(record(string(), union([string(), tuple([string(), string()])]))), description("Inject import statements on demand")),
-	dropLabels: pipe(optional(array(string())), description("Remove labeled statements with these label names"))
+	dropLabels: pipe(optional(array(string())), description("Remove labeled statements with these label names")),
+	plugins: pipe(optional(TransformPluginsSchema), description("Third-party plugins to use"))
 });
-const WatchOptionsSchema = strictObject({
+isTypeTrue();
+const WatcherOptionsSchema = strictObject({
 	chokidar: optional(never(`The "watch.chokidar" option is deprecated, please use "watch.notify" instead of it`)),
 	exclude: optional(union([StringOrRegExpSchema, array(StringOrRegExpSchema)])),
 	include: optional(union([StringOrRegExpSchema, array(StringOrRegExpSchema)])),
@@ -1600,8 +1569,9 @@ const WatchOptionsSchema = strictObject({
 	skipWrite: pipe(optional(boolean()), description("Skip the bundle.write() step")),
 	buildDelay: pipe(optional(number()), description("Throttle watch rebuilds")),
 	clearScreen: pipe(optional(boolean()), description("Whether to clear the screen when a rebuild is triggered")),
-	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."))
+	onInvalidate: pipe(optional(vFunction()), description("An optional function that will be called immediately every time a module changes that is part of the build."))
 });
+isTypeTrue();
 const ChecksOptionsSchema = strictObject({
 	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")),
@@ -1619,46 +1589,55 @@ const ChecksOptionsSchema = strictObject({
 	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"))
+	pluginTimings: pipe(optional(boolean()), description("Whether to emit warnings when plugins take significant time during the build process")),
+	duplicateShebang: pipe(optional(boolean()), description("Whether to emit warnings when both the code and postBanner contain shebang"))
 });
+isTypeTrue();
 const CompressOptionsKeepNamesSchema = strictObject({
 	function: boolean(),
 	class: boolean()
 });
+isTypeTrue();
+const CompressTreeshakeOptionsSchema = strictObject({
+	annotations: optional(boolean()),
+	manualPureFunctions: optional(array(string())),
+	propertyReadSideEffects: optional(union([boolean(), literal("always")])),
+	unknownGlobalSideEffects: optional(boolean()),
+	invalidImportSideEffects: optional(boolean())
+});
+isTypeTrue();
 const CompressOptionsSchema = strictObject({
-	target: optional(union([
-		literal("esnext"),
-		literal("es2015"),
-		literal("es2016"),
-		literal("es2017"),
-		literal("es2018"),
-		literal("es2019"),
-		literal("es2020"),
-		literal("es2021"),
-		literal("es2022"),
-		literal("es2023"),
-		literal("es2024")
-	])),
+	target: optional(union([string(), array(string())])),
 	dropConsole: optional(boolean()),
 	dropDebugger: optional(boolean()),
 	keepNames: optional(CompressOptionsKeepNamesSchema),
-	unused: optional(union([boolean(), literal("keep_assign")]))
+	unused: optional(union([boolean(), literal("keep_assign")])),
+	joinVars: optional(boolean()),
+	sequences: optional(boolean()),
+	dropLabels: optional(array(string())),
+	maxIterations: optional(number()),
+	treeshake: optional(CompressTreeshakeOptionsSchema)
 });
+isTypeTrue();
 const MangleOptionsKeepNamesSchema = strictObject({
 	function: boolean(),
 	class: boolean()
 });
+isTypeTrue();
 const MangleOptionsSchema = strictObject({
 	toplevel: optional(boolean()),
 	keepNames: optional(union([boolean(), MangleOptionsKeepNamesSchema])),
 	debug: optional(boolean())
 });
+isTypeTrue();
 const CodegenOptionsSchema = strictObject({ removeWhitespace: optional(boolean()) });
+isTypeTrue();
 const MinifyOptionsSchema = strictObject({
 	compress: optional(union([boolean(), CompressOptionsSchema])),
 	mangle: optional(union([boolean(), MangleOptionsSchema])),
 	codegen: optional(union([boolean(), CodegenOptionsSchema]))
 });
+isTypeTrue();
 const ResolveOptionsSchema = strictObject({
 	alias: optional(record(string(), union([
 		literal(false),
@@ -1674,17 +1653,20 @@ const ResolveOptionsSchema = strictObject({
 	mainFiles: optional(array(string())),
 	modules: optional(array(string())),
 	symlinks: optional(boolean()),
-	yarnPnp: optional(boolean())
+	tsconfigFilename: optional(string())
 });
-const TreeshakingOptionsSchema = union([boolean(), looseObject({
+isTypeTrue();
+const TreeshakingOptionsSchema = strictObject({
+	moduleSideEffects: optional(any()),
 	annotations: optional(boolean()),
-	manualPureFunctions: optional(array(string())),
+	manualPureFunctions: optional(custom((input) => is(array(string()), input), "string array")),
 	unknownGlobalSideEffects: optional(boolean()),
 	invalidImportSideEffects: optional(boolean()),
 	commonjs: optional(boolean()),
 	propertyReadSideEffects: optional(union([literal(false), literal("always")])),
 	propertyWriteSideEffects: optional(union([literal(false), literal("always")]))
-})]);
+});
+isTypeTrue();
 const OptimizationOptionsSchema = strictObject({
 	inlineConst: pipe(optional(union([boolean(), strictObject({
 		mode: optional(union([literal("all"), literal("smart")])),
@@ -1692,19 +1674,24 @@ const OptimizationOptionsSchema = strictObject({
 	})])), description("Enable crossmodule constant inlining")),
 	pifeForModuleWrappers: pipe(optional(boolean()), description("Use PIFE pattern for module wrappers"))
 });
+isTypeTrue();
 const LogOrStringHandlerSchema = pipe(vFunction(), args(tuple([LogLevelWithErrorSchema, RollupLogWithStringSchema])));
+isTypeTrue();
 const OnLogSchema = pipe(vFunction(), args(tuple([
 	LogLevelSchema,
 	RollupLogSchema,
 	LogOrStringHandlerSchema
 ])));
+isTypeTrue();
 const OnwarnSchema = pipe(vFunction(), args(tuple([RollupLogSchema, pipe(vFunction(), args(tuple([union([RollupLogWithStringSchema, pipe(vFunction(), returns(RollupLogWithStringSchema))])])))])));
+isTypeTrue();
 const DevModeSchema = union([boolean(), strictObject({
 	port: optional(number()),
 	host: optional(string()),
 	implement: optional(string()),
 	lazy: optional(boolean())
 })]);
+isTypeTrue();
 const InputOptionsSchema = strictObject({
 	input: optional(InputOptionSchema),
 	plugins: optional(custom(() => true)),
@@ -1718,35 +1705,34 @@ const InputOptionsSchema = strictObject({
 		literal("node")
 	])), description(`Platform for which the code should be generated (node, ${styleText$1("underline", "browser")}, neutral)`)),
 	shimMissingExports: pipe(optional(boolean()), description("Create shim variables for missing exports")),
-	treeshake: optional(TreeshakingOptionsSchema),
+	treeshake: optional(union([boolean(), TreeshakingOptionsSchema])),
 	optimization: optional(OptimizationOptionsSchema),
 	logLevel: pipe(optional(LogLevelOptionSchema), description(`Log level (${styleText$1("dim", "silent")}, ${styleText$1(["underline", "gray"], "info")}, debug, ${styleText$1("yellow", "warn")})`)),
 	onLog: optional(OnLogSchema),
 	onwarn: optional(OnwarnSchema),
 	moduleTypes: pipe(optional(ModuleTypesSchema), description("Module types for customized extensions")),
 	experimental: optional(strictObject({
-		enableComposingJsPlugins: optional(boolean()),
 		viteMode: optional(boolean()),
 		resolveNewUrlToAsset: optional(boolean()),
-		strictExecutionOrder: optional(boolean()),
-		onDemandWrapping: optional(boolean()),
-		incrementalBuild: optional(boolean()),
 		devMode: optional(DevModeSchema),
+		chunkModulesOrder: optional(union([literal("module-id"), literal("exec-order")])),
 		attachDebugInfo: optional(union([
 			literal("none"),
 			literal("simple"),
 			literal("full")
 		])),
-		chunkModulesOrder: optional(union([literal("module-id"), literal("exec-order")])),
 		chunkImportMap: optional(union([boolean(), object({
 			baseUrl: optional(string()),
 			fileName: optional(string())
 		})])),
+		onDemandWrapping: optional(boolean()),
+		incrementalBuild: optional(boolean()),
 		nativeMagicString: optional(boolean()),
-		chunkOptimization: optional(boolean())
+		chunkOptimization: optional(boolean()),
+		lazyBarrel: optional(boolean())
 	})),
 	transform: optional(TransformOptionsSchema),
-	watch: optional(union([WatchOptionsSchema, literal(false)])),
+	watch: optional(union([WatcherOptionsSchema, literal(false)])),
 	checks: optional(ChecksOptionsSchema),
 	devtools: pipe(optional(object({ sessionId: pipe(optional(string()), description("Used to name the build.")) })), description("Enable debug mode. Emit debug information to disk. This might slow down the build process significantly.")),
 	preserveEntrySignatures: pipe(optional(union([
@@ -1755,8 +1741,10 @@ const InputOptionsSchema = strictObject({
 		literal("exports-only"),
 		literal(false)
 	]))),
+	context: pipe(optional(string()), description("The value of `this` at the top level of each module.")),
 	tsconfig: pipe(optional(union([boolean(), string()])), description("Path to the tsconfig.json file."))
 });
+isTypeTrue();
 const InputCliOverrideSchema = strictObject({
 	input: pipe(optional(array(string())), description("Entry file")),
 	external: pipe(optional(array(string())), description("Comma-separated list of module ids to exclude from the bundle `<module-id>,...`")),
@@ -1785,22 +1773,32 @@ const ModuleFormatSchema = union([
 	literal("iife"),
 	literal("umd")
 ]);
+isTypeTrue();
 const AddonFunctionSchema = pipe(vFunction(), args(tuple([custom(() => true)])), returnsAsync(unionAsync([string(), pipeAsync(promise(), awaitAsync(), string())])));
+isTypeTrue();
 const ChunkFileNamesFunctionSchema = pipe(vFunction(), args(tuple([custom(() => true)])), returns(string()));
+isTypeTrue();
 const ChunkFileNamesSchema = union([string(), ChunkFileNamesFunctionSchema]);
 const AssetFileNamesFunctionSchema = pipe(vFunction(), args(tuple([custom(() => true)])), returns(string()));
+isTypeTrue();
 const AssetFileNamesSchema = union([string(), AssetFileNamesFunctionSchema]);
 const SanitizeFileNameFunctionSchema = pipe(vFunction(), args(tuple([string()])), returns(string()));
+isTypeTrue();
 const SanitizeFileNameSchema = union([boolean(), SanitizeFileNameFunctionSchema]);
 const GlobalsFunctionSchema = pipe(vFunction(), args(tuple([string()])), returns(string()));
+isTypeTrue();
 const PathsFunctionSchema = pipe(vFunction(), args(tuple([string()])), returns(string()));
+isTypeTrue();
 const ManualChunksFunctionSchema = pipe(vFunction(), args(tuple([string(), object({})])), returns(nullish(string())));
+isTypeTrue();
 const AdvancedChunksNameFunctionSchema = pipe(vFunction(), args(tuple([string(), object({})])), returns(nullish(string())));
+isTypeTrue();
 const AdvancedChunksTestFunctionSchema = pipe(vFunction(), args(tuple([string()])), returns(union([
 	boolean(),
 	void_(),
 	undefined_()
 ])));
+isTypeTrue();
 const AdvancedChunksSchema = strictObject({
 	includeDependenciesRecursively: optional(boolean()),
 	minSize: optional(number()),
@@ -1819,12 +1817,15 @@ const AdvancedChunksSchema = strictObject({
 		maxModuleSize: optional(number())
 	})))
 });
+isTypeTrue();
 const GeneratedCodePresetSchema = union([literal("es5"), literal("es2015")]);
+isTypeTrue();
 const GeneratedCodeOptionsSchema = strictObject({
 	symbols: pipe(optional(boolean()), description("Whether to use Symbol.toStringTag for namespace objects")),
-	preset: GeneratedCodePresetSchema,
+	preset: optional(GeneratedCodePresetSchema),
 	profilerNames: pipe(optional(boolean()), description("Whether to add readable names to internal variables for profiling purposes"))
 });
+isTypeTrue();
 const OutputOptionsSchema = strictObject({
 	dir: pipe(optional(string()), description("Output directory, defaults to `dist` if `file` is not set")),
 	file: pipe(optional(string()), description("Single output file")),
@@ -1892,8 +1893,10 @@ const OutputOptionsSchema = strictObject({
 	minifyInternalExports: pipe(optional(boolean()), description("Minify internal exports")),
 	topLevelVar: pipe(optional(boolean()), description("Rewrite top-level declarations to use `var`.")),
 	cleanDir: pipe(optional(boolean()), description("Clean output directory before emitting output")),
-	keepNames: pipe(optional(boolean()), description("Keep function and class names after bundling"))
+	keepNames: pipe(optional(boolean()), description("Keep function and class names after bundling")),
+	strictExecutionOrder: pipe(optional(boolean()), description("Lets modules be executed in the order they are declared."))
 });
+isTypeTrue();
 const getAddonDescription = (placement, wrapper) => {
 	return `Code to insert the ${styleText$1("bold", placement)} of the bundled file (${styleText$1("bold", wrapper)} the wrapper function)`;
 };

package/dist/shared/{types-CIYK49jr.d.mts → types-CIhJMr1h.d.mts}

@@ -1,4 +1,4 @@
-//#region ../../node_modules/.pnpm/@oxc-project+types@0.110.0/node_modules/@oxc-project/types/types.d.ts
+//#region ../../node_modules/.pnpm/@oxc-project+types@0.111.0/node_modules/@oxc-project/types/types.d.ts
 // Auto-generated code, DO NOT EDIT DIRECTLY!
 // To edit this generated file you have to edit `tasks/ast_tools/src/generators/typescript.rs`.
 interface Program extends Span {
@@ -1235,7 +1235,7 @@ interface TSImportEqualsDeclaration extends Span {
   importKind: ImportOrExportKind;
   parent?: Node;
 }
-type TSModuleReference = TSExternalModuleReference | TSTypeName;
+type TSModuleReference = TSExternalModuleReference | IdentifierReference | TSQualifiedName;
 interface TSExternalModuleReference extends Span {
   type: "TSExternalModuleReference";
   expression: StringLiteral;

package/dist/shared/{watch-eIop0yN6.mjs → watch-BsneBCNP.mjs}

@@ -1,7 +1,7 @@
 import { o as logMultiplyNotifyOption } from "./logs-B2CASPcx.mjs";
-import { a as aggregateBindingErrorsIntoJsError, b as LOG_LEVEL_WARN } from "./bindingify-input-options-Bp2kpiI8.mjs";
+import { a as aggregateBindingErrorsIntoJsError, b as LOG_LEVEL_WARN } from "./bindingify-input-options-CObJx_Uj.mjs";
 import { h as arraify } from "./composable-filters-CIxSuZSM.mjs";
-import { l as PluginDriver, n as createBundlerOptions } from "./rolldown-build-DLuUhuNw.mjs";
+import { l as PluginDriver, n as createBundlerOptions } from "./rolldown-build-Do6WlRGM.mjs";
 import { BindingWatcher, shutdownAsyncRuntime } from "../rolldown-binding.wasi.cjs";
 
 //#region ../../node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/signals.js
@@ -368,11 +368,11 @@ function getValidNotifyOption(bundlerOptions) {
 * @experimental
 * @category Programmatic APIs
 */
-const watch = (input) => {
+function watch(input) {
 	const emitter = new WatcherEmitter();
 	createWatcher(emitter, input);
 	return emitter;
-};
+}
 
 //#endregion
 export { onExit as n, watch as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rolldown/browser",
-  "version": "1.0.0-rc.1",
+  "version": "1.0.0-rc.2",
   "description": "Fast JavaScript/TypeScript bundler in Rust with Rollup-compatible API.",
   "keywords": [
     "bundler",