@cloudflare/vite-plugin 1.40.1 → 1.41.0

package/dist/index.mjs

@@ -1505,7 +1505,7 @@ async function assertWranglerVersion() {
 * The default compatibility date to use when the user omits one.
 * This value is injected at build time and remains fixed for each release.
 */
-const DEFAULT_COMPAT_DATE = "2026-06-09";
+const DEFAULT_COMPAT_DATE = "2026-06-16";
 
 //#endregion
 //#region ../../node_modules/.pnpm/@remix-run+node-fetch-server@0.8.0/node_modules/@remix-run/node-fetch-server/dist/node-fetch-server.js
@@ -30929,11 +30929,18 @@ __export(mod_esm_exports, { default: () => mod_esm_default });
 var import_mod_cjs = __toESM(require_mod_cjs3(), 1);
 __reExport(mod_esm_exports, __toESM(require_mod_cjs3(), 1));
 var mod_esm_default = import_mod_cjs.default;
+function getGlobalConfigPath({ appName = "wrangler", leadingDot = true, useLegacyHomeDir = true } = {}) {
+	const dirName = `${leadingDot ? "." : ""}${appName}`;
+	const configDir = mod_esm_default(dirName).config();
+	if (useLegacyHomeDir) {
+		const legacyConfigDir = path.join(os.homedir(), dirName);
+		if (isDirectory(legacyConfigDir)) return legacyConfigDir;
+	}
+	return configDir;
+}
+__name(getGlobalConfigPath, "getGlobalConfigPath");
 function getGlobalWranglerConfigPath() {
-	const configDir = mod_esm_default(".wrangler").config();
-	const legacyConfigDir = path.join(os.homedir(), ".wrangler");
-	if (isDirectory(legacyConfigDir)) return legacyConfigDir;
-	else return configDir;
+	return getGlobalConfigPath();
 }
 __name(getGlobalWranglerConfigPath, "getGlobalWranglerConfigPath");
 function getBooleanEnvironmentVariableFactory(options) {
@@ -34396,7 +34403,7 @@ __name(maybeThrowFriendlyError, "maybeThrowFriendlyError");
 function logHeaders(headers, logger) {
 	const clone = cloneHeaders(headers);
 	clone.delete("Authorization");
-	logger.debugWithSanitization("HEADERS:", JSON.stringify(Object.fromEntries(clone), null, 2));
+	logger.debugWithSanitization?.("HEADERS:", JSON.stringify(Object.fromEntries(clone), null, 2));
 }
 __name(logHeaders, "logHeaders");
 async function performApiFetchBase(complianceConfig, resource, init = {}, userAgent, logger, queryParams, abortSignal, credentials) {
@@ -34409,10 +34416,10 @@ async function performApiFetchBase(complianceConfig, resource, init = {}, userAg
 	maybeAddTraceHeader(headers);
 	const queryString = queryParams ? `?${queryParams.toString()}` : "";
 	logger.debug(`-- START CF API REQUEST: ${method} ${getCloudflareApiBaseUrl(complianceConfig)}${resource}`);
-	logger.debugWithSanitization("QUERY STRING:", queryString);
+	logger.debugWithSanitization?.("QUERY STRING:", queryString);
 	logHeaders(headers, logger);
-	logger.debugWithSanitization("INIT:", JSON.stringify({ ...init }, null, 2));
-	if (init.body instanceof import_undici.FormData) logger.debugWithSanitization("BODY:", await new import_undici.Response(init.body).text(), null, 2);
+	logger.debugWithSanitization?.("INIT:", JSON.stringify({ ...init }, null, 2));
+	if (init.body instanceof import_undici.FormData) logger.debugWithSanitization?.("BODY:", await new import_undici.Response(init.body).text(), null, 2);
 	logger.debug("-- END CF API REQUEST");
 	return await (0, import_undici.fetch)(`${getCloudflareApiBaseUrl(complianceConfig)}${resource}${queryString}`, {
 		method,
@@ -34428,7 +34435,7 @@ async function fetchInternalBase(complianceConfig, resource, init = {}, userAgen
 	const jsonText = await response.text();
 	logger.debug("-- START CF API RESPONSE:", response.statusText, response.status);
 	logHeaders(response.headers, logger);
-	logger.debugWithSanitization("RESPONSE:", jsonText);
+	logger.debugWithSanitization?.("RESPONSE:", jsonText);
 	logger.debug("-- END CF API RESPONSE");
 	if (!jsonText && (response.status === 204 || response.status === 205)) return {
 		response: {
@@ -34592,6 +34599,22 @@ function throwWAFBlockError(headers, method, resource, status, statusText) {
 	});
 }
 __name(throwWAFBlockError, "throwWAFBlockError");
+async function fetchKVGetValueBase(complianceConfig, accountId, namespaceId, key, userAgent, logger, credentials) {
+	const headers = new import_undici.Headers();
+	addAuthorizationHeader(headers, credentials);
+	headers.set("User-Agent", userAgent);
+	maybeAddTraceHeader(headers);
+	const resource = `${getCloudflareApiBaseUrl(complianceConfig)}/accounts/${accountId}/storage/kv/namespaces/${namespaceId}/values/${key}`;
+	logger.debug(`-- START CF API REQUEST: GET ${resource}`);
+	logger.debug("-- END CF API REQUEST");
+	const response = await (0, import_undici.fetch)(resource, {
+		method: "GET",
+		headers
+	});
+	if (response.ok) return await response.arrayBuffer();
+	else throw new Error(`Failed to fetch ${resource} - ${response.status}: ${response.statusText}`);
+}
+__name(fetchKVGetValueBase, "fetchKVGetValueBase");
 function hasCursor(result_info) {
 	const cursor = result_info?.cursor;
 	return cursor !== void 0 && cursor !== null && cursor !== "";
@@ -37141,8 +37164,11 @@ var PluginContext = class {
 	getWorkerConfig(environmentName) {
 		return this.#getWorker(environmentName)?.config;
 	}
+	getWorkerNewConfig(environmentName) {
+		return this.#getWorker(environmentName)?.parsedNewConfig;
+	}
 	get allWorkerConfigs() {
-		if (this.resolvedPluginConfig.type === "preview") return this.resolvedPluginConfig.workers;
+		if (this.resolvedPluginConfig.type === "preview") return this.resolvedPluginConfig.workers.map((worker) => worker.config);
 		return Array.from(this.resolvedPluginConfig.environmentNameToWorkerMap.values()).map((worker) => worker.config);
 	}
 	get entryWorkerConfig() {
@@ -37273,6 +37299,138 @@ const defuArrayFn = createDefu((object, key, currentValue) => {
 	}
 });
 
+//#endregion
+//#region src/build-output.ts
+/**
+* Initial draft version of the Build Output API.
+*
+* Will move to `v1` when the spec stabilises.
+*/
+const BUILD_OUTPUT_VERSION = "v0";
+/**
+* Project-relative root.
+*/
+const BUILD_OUTPUT_ROOT = ".cloudflare/output";
+/**
+* Filename of the per-Worker config.
+*/
+const WORKER_CONFIG_FILENAME = "worker.config.json";
+/**
+* Absolute path to the Build Output API root for the current project.
+*/
+function getBuildOutputDir(root) {
+	return nodePath.resolve(root, BUILD_OUTPUT_ROOT);
+}
+/**
+* Clean the build output directory
+*
+* Called once at the start of each build
+*/
+function cleanBuildOutputDir(root) {
+	removeDirSync(getBuildOutputDir(root));
+}
+/**
+* Absolute path to the workers output directory
+*/
+function getWorkersDir(root) {
+	return nodePath.join(getBuildOutputDir(root), BUILD_OUTPUT_VERSION, "workers");
+}
+/**
+* Absolute path to `worker.config.json` for a given Worker.
+*/
+function getWorkerConfigPath(root, workerName) {
+	return nodePath.join(getWorkersDir(root), workerName, WORKER_CONFIG_FILENAME);
+}
+/**
+* Absolute path to the bundle directory for a given Worker.
+*/
+function getWorkerBundleDir(root, workerName) {
+	return nodePath.join(getWorkersDir(root), workerName, "bundle");
+}
+/**
+* Absolute path to the assets directory for a given Worker.
+*/
+function getWorkerAssetsDir(root, workerName) {
+	return nodePath.join(getWorkersDir(root), workerName, "assets");
+}
+/**
+* Map a bundle filename to its declared module type.
+*/
+function detectModuleType(filename) {
+	switch (nodePath.extname(filename).toLowerCase()) {
+		case ".js":
+		case ".mjs": return "esm";
+		case ".wasm": return "wasm";
+		case ".bin": return "data";
+		case ".txt":
+		case ".html":
+		case ".sql": return "text";
+		case ".json": return "json";
+		case ".map": return "sourcemap";
+		default: return "data";
+	}
+}
+/**
+* Write the output `worker.config.json` for a given Worker to the Build
+* Output API tree.
+*
+* - Workers mode: `manifest` is provided (bundle/ present on disk).
+* - Assets-only mode: `manifest` is omitted (no bundle/ directory).
+*/
+function writeOutputWorkerConfig(root, parsedConfig, manifest) {
+	const { entrypoint: _entrypoint,...rest } = parsedConfig;
+	const outputConfig = {
+		...rest,
+		manifest
+	};
+	const workerOutputDir = nodePath.join(getWorkersDir(root), outputConfig.name);
+	fs$1.mkdirSync(workerOutputDir, { recursive: true });
+	const configPath = getWorkerConfigPath(root, outputConfig.name);
+	fs$1.writeFileSync(configPath, JSON.stringify(outputConfig));
+}
+
+//#endregion
+//#region src/build-output-preview.ts
+/**
+* Read the Build Output API at `<root>/.cloudflare/output/v0/workers/`
+* and reconstruct a `BuildOutputPreviewWorker` for each Worker
+*/
+async function readBuildOutputWorkers(root) {
+	const workersDir = getWorkersDir(root);
+	if (!fs$1.existsSync(workersDir)) throw new Error(`No Build Output API tree found at ${workersDir}.`);
+	const workerNames = fs$1.readdirSync(workersDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+	if (workerNames.length === 0) throw new Error(`Build Output API tree at ${workersDir} contains no Worker directories.`);
+	const { OutputWorkerSchema, convertToWranglerConfig } = await import("./dist-Cr__Sz5N.mjs");
+	return workerNames.map((workerName) => {
+		const configPath = getWorkerConfigPath(root, workerName);
+		assert(fs$1.existsSync(configPath), `Build Output API: missing \`${WORKER_CONFIG_FILENAME}\` for Worker "${workerName}" at ${configPath}.`);
+		const { manifest,...inputShape } = OutputWorkerSchema.parse(JSON.parse(fs$1.readFileSync(configPath, "utf-8")));
+		const { config, diagnostics } = normalizeAndValidateConfig(convertToWranglerConfig(inputShape), void 0, void 0, {}, true);
+		if (diagnostics.hasWarnings()) console.warn(diagnostics.renderWarnings());
+		if (diagnostics.hasErrors()) throw new Error(diagnostics.renderErrors());
+		const bundleDir = getWorkerBundleDir(root, workerName);
+		const assetsDir = getWorkerAssetsDir(root, workerName);
+		if (fs$1.existsSync(assetsDir)) config.assets = {
+			...config.assets ?? {},
+			directory: assetsDir
+		};
+		let bundle;
+		if (manifest) {
+			config.main = manifest.mainModule;
+			bundle = {
+				rootPath: bundleDir,
+				mainModule: manifest.mainModule,
+				modules: manifest.modules
+			};
+		}
+		return {
+			source: "build-output",
+			config,
+			bundle
+		};
+	});
+}
+
 //#endregion
 //#region src/deploy-config.ts
 function getDeployConfigPath(root) {
@@ -44160,8 +44318,14 @@ const allowedWranglerConfigExtensions = [
 //#region src/plugin-config.ts
 function normalizeNewConfig(option) {
 	if (option === void 0 || option === false) return;
-	if (option === true) return { types: { generate: true } };
-	return { types: { generate: option.types?.generate ?? true } };
+	if (option === true) return {
+		types: { generate: true },
+		cfBuildOutput: false
+	};
+	return {
+		types: { generate: option.types?.generate ?? true },
+		cfBuildOutput: option.cfBuildOutput ?? false
+	};
 }
 function filterEntryWorkerConfig(config) {
 	const { topLevelName: _topLevelName, name: _name,...filteredConfig } = config;
@@ -44227,20 +44391,30 @@ async function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
 	const prefixedEnv = vite.loadEnv(viteEnv.mode, root, ["CLOUDFLARE_", "WRANGLER_HYPERDRIVE_LOCAL_CONNECTION_STRING_"]);
 	Object.assign(process.env, prefixedEnv);
 	const remoteBindings = prefixedEnv.CLOUDFLARE_VITE_FORCE_LOCAL === "true" ? false : pluginConfig.remoteBindings ?? true;
-	if (viteEnv.isPreview) return {
-		...shared,
-		remoteBindings,
-		type: "preview",
-		workers: getWorkerConfigs(root, !!process.env.CLOUDFLARE_VITE_BUILD)
-	};
+	if (viteEnv.isPreview) {
+		const workers = resolvedNewConfig?.cfBuildOutput ? await readBuildOutputWorkers(root) : getWorkerConfigs(root, !!process.env.CLOUDFLARE_VITE_BUILD).map((config) => ({
+			source: "legacy",
+			config
+		}));
+		return {
+			...shared,
+			remoteBindings,
+			type: "preview",
+			workers
+		};
+	}
 	const configPaths = /* @__PURE__ */ new Set();
 	const cloudflareEnv = prefixedEnv.CLOUDFLARE_ENV;
 	const validateAndAddEnvironmentName = createEnvironmentNameValidator();
 	let configPath;
 	let rawConfigOverride;
+	let parsedNewConfig;
 	if (resolvedNewConfig) {
 		if (pluginConfig.configPath) throw new Error("`configPath` cannot be used together with `experimental.newConfig`. Configure the entry Worker via `cloudflare.config.ts` instead.");
 		if (pluginConfig.auxiliaryWorkers?.length) throw new Error("`auxiliaryWorkers` are not yet supported when `experimental.newConfig` is enabled.");
+		if (pluginConfig.experimental?.prerenderWorker) throw new Error("`experimental.prerenderWorker` is not yet supported when `experimental.newConfig` is enabled.");
+		if (typeof pluginConfig.config !== "undefined") throw new Error("`config` cannot be used together with `experimental.newConfig`. Configure the entry Worker via `cloudflare.config.ts` instead.");
+		if (resolvedNewConfig.cfBuildOutput && pluginConfig.viteEnvironment?.childEnvironments?.length) throw new Error("`viteEnvironment.childEnvironments` cannot be used together with `experimental.newConfig.cfBuildOutput`. Child environments are not yet supported in the Build Output API.");
 		const result = await loadNewConfig({
 			root,
 			mode: viteEnv.mode,
@@ -44248,6 +44422,7 @@ async function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
 		});
 		configPath = result.configPath;
 		rawConfigOverride = result.rawConfig;
+		parsedNewConfig = result.parsedConfig;
 		configPaths.add(result.configPath);
 		for (const dep of result.dependencies) configPaths.add(dep);
 	} else configPath = getValidatedWranglerConfigPath(root, pluginConfig.configPath ?? prefixedEnv.CLOUDFLARE_VITE_WRANGLER_CONFIG_PATH);
@@ -44255,7 +44430,7 @@ async function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
 		root,
 		configPath: resolvedNewConfig ? void 0 : configPath,
 		env: cloudflareEnv,
-		configCustomizer: pluginConfig.config,
+		configCustomizer: resolvedNewConfig ? void 0 : pluginConfig.config,
 		visitedConfigPaths: configPaths,
 		rawConfigOverride
 	});
@@ -44286,6 +44461,7 @@ async function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
 		type: "assets-only",
 		cloudflareEnv,
 		config: entryWorkerResolvedConfig.config,
+		parsedNewConfig,
 		environmentNameToWorkerMap,
 		environmentNameToChildEnvironmentNamesMap,
 		prerenderWorkerEnvironmentName,
@@ -44297,7 +44473,7 @@ async function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
 	if (Array.isArray(entryWorkerResolvedConfig.config.assets?.run_worker_first)) staticRouting = parseStaticRouting(entryWorkerResolvedConfig.config.assets.run_worker_first);
 	const entryWorkerEnvironmentName = pluginConfig.viteEnvironment?.name ?? workerNameToEnvironmentName(entryWorkerResolvedConfig.config.topLevelName);
 	validateAndAddEnvironmentName(entryWorkerEnvironmentName);
-	environmentNameToWorkerMap.set(entryWorkerEnvironmentName, resolveWorker(entryWorkerResolvedConfig.config, pluginConfig.assetsOnly));
+	environmentNameToWorkerMap.set(entryWorkerEnvironmentName, resolveWorker(entryWorkerResolvedConfig.config, pluginConfig.assetsOnly, parsedNewConfig));
 	const entryWorkerChildEnvironments = pluginConfig.viteEnvironment?.childEnvironments;
 	if (entryWorkerChildEnvironments) {
 		for (const childName of entryWorkerChildEnvironments) validateAndAddEnvironmentName(childName);
@@ -44360,11 +44536,12 @@ function resolveDevOnly(devOnly) {
 	if (typeof devOnly === "function") return devOnly();
 	return devOnly ?? false;
 }
-function resolveWorker(workerConfig, devOnly) {
+function resolveWorker(workerConfig, devOnly, parsedNewConfig) {
 	return {
 		config: workerConfig,
 		nodeJsCompat: hasNodeJsCompat(workerConfig) ? new NodeJsCompat(workerConfig) : void 0,
-		devOnly
+		devOnly,
+		parsedNewConfig
 	};
 }
 const NEW_CONFIG_FILENAME = "cloudflare.config.ts";
@@ -44372,8 +44549,10 @@ const TYPES_OUTPUT_FILENAME = "worker-configuration.d.ts";
 const EXPERIMENTAL_CONFIG_PKG = "@cloudflare/vite-plugin/experimental-config";
 /**
 * Load and convert a `cloudflare.config.ts` file via `@cloudflare/config`. Returns
-* the resulting Wrangler `RawConfig`, the absolute path of the loaded file,
-* and the set of files imported while resolving the config (for watch-mode).
+* the resulting Wrangler `RawConfig`, the parsed new-config shape (for
+* downstream Build Output API emission), the absolute path of the loaded
+* file, and the set of files imported while resolving the config (for
+* watch-mode).
 *
 * If `generateTypes` is true, also writes `worker-configuration.d.ts` next to
 * the config when the generated content differs from what's already on disk.
@@ -44381,10 +44560,10 @@ const EXPERIMENTAL_CONFIG_PKG = "@cloudflare/vite-plugin/experimental-config";
 async function loadNewConfig(options) {
 	const configPath = nodePath.resolve(options.root, NEW_CONFIG_FILENAME);
 	if (!fs$1.existsSync(configPath)) throw new Error(`\`experimental.newConfig\` is enabled but no \`${NEW_CONFIG_FILENAME}\` was found at ${configPath}.`);
-	const { loadConfig, ConfigSchema, convertToWranglerConfig, generateTypes: generateTypesFn, resolveWorkerDefinition } = await import("./dist-MawCthRW.mjs");
+	const { loadConfig, InputWorkerSchema, convertToWranglerConfig, generateTypes: generateTypesFn, resolveWorkerDefinition } = await import("./dist-Cr__Sz5N.mjs");
 	const { config: rawExport, dependencies } = await loadConfig(configPath);
 	const resolved = await resolveWorkerDefinition(rawExport, { mode: options.mode });
-	const parsed = ConfigSchema.safeParse(resolved);
+	const parsed = InputWorkerSchema.safeParse(resolved);
 	if (!parsed.success) throw new Error(`Invalid \`${NEW_CONFIG_FILENAME}\`:\n${parsed.error.message}`);
 	const rawConfig = convertToWranglerConfig(parsed.data);
 	if (options.generateTypes) writeWorkerConfigurationDts({
@@ -44394,6 +44573,7 @@ async function loadNewConfig(options) {
 	});
 	return {
 		rawConfig,
+		parsedConfig: parsed.data,
 		configPath,
 		dependencies
 	};
@@ -45519,6 +45699,268 @@ function createModuleReference(type, id) {
 	return `__CLOUDFLARE_MODULE__${type}__${id}__CLOUDFLARE_MODULE__`;
 }
 
+//#endregion
+//#region src/cloudflare-environment.ts
+const MAIN_ENTRY_NAME = "index";
+const webSocketUndefinedError = "The WebSocket is undefined";
+function createHotChannel(webSocketContainer) {
+	const listenersMap = /* @__PURE__ */ new Map();
+	const client = { send(payload) {
+		const webSocket = webSocketContainer.webSocket;
+		assert(webSocket, webSocketUndefinedError);
+		webSocket.send(JSON.stringify(payload));
+	} };
+	function onMessage(event) {
+		const payload = JSON.parse(event.data.toString());
+		const listeners = listenersMap.get(payload.event) ?? /* @__PURE__ */ new Set();
+		for (const listener of listeners) listener(payload.data, client);
+	}
+	return {
+		send(payload) {
+			const webSocket = webSocketContainer.webSocket;
+			const message = JSON.stringify(payload);
+			if (!webSocket) {
+				webSocketContainer.messageBuffers ??= [];
+				webSocketContainer.messageBuffers.push(message);
+				return;
+			}
+			webSocket.send(message);
+		},
+		on(event, listener) {
+			const listeners = listenersMap.get(event) ?? /* @__PURE__ */ new Set();
+			listeners.add(listener);
+			listenersMap.set(event, listeners);
+		},
+		off(event, listener) {
+			listenersMap.get(event)?.delete(listener);
+		},
+		listen() {
+			const webSocket = webSocketContainer.webSocket;
+			assert(webSocket, webSocketUndefinedError);
+			webSocket.addEventListener("message", onMessage);
+		},
+		close() {
+			const webSocket = webSocketContainer.webSocket;
+			assert(webSocket, webSocketUndefinedError);
+			webSocket.removeEventListener("message", onMessage);
+		}
+	};
+}
+var CloudflareDevEnvironment = class extends vite.DevEnvironment {
+	#webSocketContainer;
+	constructor(name, config) {
+		const webSocketContainer = {};
+		super(name, config, {
+			hot: true,
+			transport: createHotChannel(webSocketContainer)
+		});
+		this.#webSocketContainer = webSocketContainer;
+	}
+	async initRunner(miniflare, workerConfig, options) {
+		const response = await miniflare.dispatchFetch(new URL(INIT_PATH, UNKNOWN_HOST), { headers: {
+			[CoreHeaders.ROUTE_OVERRIDE]: workerConfig.name,
+			[WORKER_ENTRY_PATH_HEADER]: encodeURIComponent(workerConfig.main),
+			[IS_ENTRY_WORKER_HEADER]: String(options.isEntryWorker),
+			[ENVIRONMENT_NAME_HEADER]: this.name,
+			[IS_PARENT_ENVIRONMENT_HEADER]: String(options.isParentEnvironment),
+			upgrade: "websocket"
+		} });
+		assert(response.ok, `Failed to initialize module runner, error: ${await response.text()}`);
+		const webSocket = response.webSocket;
+		assert(webSocket, "Failed to establish WebSocket");
+		webSocket.accept();
+		this.#webSocketContainer.webSocket = webSocket;
+		if (this.#webSocketContainer.messageBuffers) {
+			for (const bufferedMessage of this.#webSocketContainer.messageBuffers) webSocket.send(bufferedMessage);
+			delete this.#webSocketContainer.messageBuffers;
+		}
+	}
+	async fetchWorkerExportTypes(miniflare, workerConfig) {
+		await this.depsOptimizer?.init();
+		return await (await miniflare.dispatchFetch(new URL(GET_EXPORT_TYPES_PATH, UNKNOWN_HOST), { headers: { [CoreHeaders.ROUTE_OVERRIDE]: workerConfig.name } })).json();
+	}
+	async fetchModule(id, importer, options) {
+		if (additionalModuleRE.test(id)) return {
+			externalize: id,
+			type: "module"
+		};
+		return super.fetchModule(id, importer, options);
+	}
+};
+const cloudflareBuiltInModules = [
+	"cloudflare:email",
+	"cloudflare:node",
+	"cloudflare:sockets",
+	"cloudflare:workers",
+	"cloudflare:workflows"
+];
+const defaultConditions = [
+	"workerd",
+	"worker",
+	"module",
+	"browser"
+];
+const target = "es2024";
+const resolveExtensions = [
+	".mjs",
+	".js",
+	".mts",
+	".ts",
+	".jsx",
+	".tsx",
+	".json",
+	".cjs",
+	".cts",
+	".ctx"
+];
+function createCloudflareEnvironmentOptions({ workerConfig, userConfig, mode, environmentName, isEntryWorker, isParentEnvironment, hasNodeJsCompat: hasNodeJsCompat$1 }) {
+	const rollupOptions = isParentEnvironment ? {
+		input: { [MAIN_ENTRY_NAME]: VIRTUAL_WORKER_ENTRY },
+		preserveEntrySignatures: "strict"
+	} : {};
+	const define$1 = getProcessEnvReplacements(hasNodeJsCompat$1, mode);
+	return {
+		resolve: {
+			noExternal: true,
+			conditions: [...defaultConditions, "development|production"],
+			builtins: [...cloudflareBuiltInModules]
+		},
+		define: define$1,
+		dev: { createEnvironment(name, config) {
+			if (!config.plugins.some((plugin) => plugin.name === "vite-plugin-cloudflare:dev" && plugin.configureServer !== void 0)) return vite.createRunnableDevEnvironment(name, config);
+			return new CloudflareDevEnvironment(name, config);
+		} },
+		build: {
+			createEnvironment(name, config) {
+				return new vite.BuildEnvironment(name, config);
+			},
+			target,
+			emitAssets: true,
+			manifest: isEntryWorker,
+			outDir: getOutputDirectory(userConfig, environmentName),
+			copyPublicDir: false,
+			ssr: true,
+			...isRolldown ? { rolldownOptions: {
+				...rollupOptions,
+				platform: "neutral",
+				resolve: { extensions: resolveExtensions }
+			} } : { rollupOptions }
+		},
+		optimizeDeps: {
+			noDiscovery: false,
+			ignoreOutdatedRequests: true,
+			entries: vite.normalizePath(workerConfig.main),
+			exclude: [
+				...cloudflareBuiltInModules,
+				...nonPrefixedNodeModules,
+				...nonPrefixedNodeModules.map((module$1) => `node:${module$1}`),
+				...[
+					"node:sea",
+					"node:sqlite",
+					"node:test",
+					"node:test/reporters"
+				]
+			],
+			...isRolldown ? { rolldownOptions: {
+				platform: "neutral",
+				resolve: {
+					conditionNames: [...defaultConditions, "development"],
+					extensions: resolveExtensions
+				},
+				transform: {
+					target,
+					define: define$1
+				},
+				plugins: [vite.esmExternalRequirePlugin({
+					external: [nodeBuiltinsRE],
+					skipDuplicateCheck: true
+				})]
+			} } : { esbuildOptions: {
+				platform: "neutral",
+				conditions: [...defaultConditions, "development"],
+				resolveExtensions,
+				target,
+				define: define$1
+			} }
+		},
+		keepProcessEnv: true
+	};
+}
+/**
+* Gets `process.env` replacement values.
+* `process.env.NODE_ENV` is always replaced.
+* `process.env` is replaced with an empty object if `nodejs_compat` is not enabled
+* @param hasNodeJsCompat - whether `nodejs_compat` is enabled
+* @param mode - the Vite mode
+* @returns replacement values
+*/
+function getProcessEnvReplacements(hasNodeJsCompat$1, mode) {
+	const nodeEnv = process.env.NODE_ENV || mode;
+	const nodeEnvReplacements = {
+		"process.env.NODE_ENV": JSON.stringify(nodeEnv),
+		"global.process.env.NODE_ENV": JSON.stringify(nodeEnv),
+		"globalThis.process.env.NODE_ENV": JSON.stringify(nodeEnv)
+	};
+	return hasNodeJsCompat$1 ? nodeEnvReplacements : {
+		...nodeEnvReplacements,
+		"process.env": "{}",
+		"global.process.env": "{}",
+		"globalThis.process.env": "{}"
+	};
+}
+function initRunners(resolvedPluginConfig, viteDevServer, miniflare) {
+	const initPromises = [...resolvedPluginConfig.environmentNameToWorkerMap].flatMap(([environmentName, worker]) => {
+		debuglog("Initializing worker:", worker.config.name);
+		const isEntryWorker = environmentName === resolvedPluginConfig.entryWorkerEnvironmentName;
+		const childEnvironmentNames = resolvedPluginConfig.environmentNameToChildEnvironmentNamesMap.get(environmentName) ?? [];
+		return [viteDevServer.environments[environmentName].initRunner(miniflare, worker.config, {
+			isEntryWorker,
+			isParentEnvironment: true
+		}), ...childEnvironmentNames.map((childEnvironmentName) => {
+			debuglog("Initializing child environment:", childEnvironmentName);
+			return viteDevServer.environments[childEnvironmentName].initRunner(miniflare, worker.config, {
+				isEntryWorker: false,
+				isParentEnvironment: false
+			});
+		})];
+	});
+	return Promise.all(initPromises);
+}
+
+//#endregion
+//#region src/plugins/build-output.ts
+/**
+* Build Output API plugin. Replaces `outputConfigPlugin` when
+* `experimental.newConfig.cfBuildOutput` is set.
+*/
+const buildOutputPlugin = createPlugin("build-output", (ctx) => {
+	return { writeBundle(_options, bundle) {
+		if (ctx.isChildEnvironment(this.environment.name)) return;
+		if (ctx.resolvedPluginConfig.type === "assets-only" && this.environment.name === "client") {
+			const workerNewConfig$1 = ctx.resolvedPluginConfig.parsedNewConfig;
+			assert(workerNewConfig$1, "Expected parsedNewConfig on assets-only resolved config");
+			writeOutputWorkerConfig(ctx.resolvedViteConfig.root, workerNewConfig$1);
+			return;
+		}
+		const workerNewConfig = ctx.getWorkerNewConfig(this.environment.name);
+		if (!workerNewConfig) return;
+		const entryChunk = Object.values(bundle).find((chunk) => chunk.type === "chunk" && chunk.isEntry && chunk.name === MAIN_ENTRY_NAME);
+		assert(entryChunk, `Expected entry chunk with name "${MAIN_ENTRY_NAME}"`);
+		const importedAssetPaths = /* @__PURE__ */ new Set();
+		for (const entry of Object.values(bundle)) for (const asset of entry.viteMetadata?.importedAssets ?? []) importedAssetPaths.add(asset);
+		const modules = {};
+		for (const fileName of Object.keys(bundle)) {
+			if (fileName === ".vite/manifest.json") continue;
+			if (importedAssetPaths.has(fileName)) continue;
+			modules[fileName] = { type: detectModuleType(fileName) };
+		}
+		writeOutputWorkerConfig(ctx.resolvedViteConfig.root, workerNewConfig, {
+			mainModule: entryChunk.fileName,
+			modules
+		});
+	} };
+});
+
 //#endregion
 //#region ../workers-shared/utils/configuration/constructConfiguration.ts
 function constructRedirects({ redirects, redirectsFile, logger }) {
@@ -51188,7 +51630,8 @@ function createBuildApp(resolvedPluginConfig) {
 		if (hasClientEntry) await builder.build(clientEnvironment);
 		else if (importedAssetPaths.size || getHasPublicAssets(builder.config) || resolvedPluginConfig.prerenderWorkerEnvironmentName) await fallbackBuild(builder, clientEnvironment);
 		else {
-			if (!satisfiesMinimumViteVersion("7.0.0")) removeAssetsField(entryWorkerBuildDirectory);
+			const cfBuildOutput = resolvedPluginConfig.experimental.newConfig?.cfBuildOutput === true;
+			if (!satisfiesMinimumViteVersion("7.0.0") && !cfBuildOutput) removeAssetsField(entryWorkerBuildDirectory);
 			return;
 		}
 		const clientBuildDirectory = nodePath.resolve(builder.config.root, clientEnvironment.config.build.outDir);
@@ -51243,234 +51686,6 @@ function removeAssetsField(entryWorkerBuildDirectory) {
 	fs$1.writeFileSync(entryWorkerConfigPath, JSON.stringify(workerConfig));
 }
 
-//#endregion
-//#region src/cloudflare-environment.ts
-const MAIN_ENTRY_NAME = "index";
-const webSocketUndefinedError = "The WebSocket is undefined";
-function createHotChannel(webSocketContainer) {
-	const listenersMap = /* @__PURE__ */ new Map();
-	const client = { send(payload) {
-		const webSocket = webSocketContainer.webSocket;
-		assert(webSocket, webSocketUndefinedError);
-		webSocket.send(JSON.stringify(payload));
-	} };
-	function onMessage(event) {
-		const payload = JSON.parse(event.data.toString());
-		const listeners = listenersMap.get(payload.event) ?? /* @__PURE__ */ new Set();
-		for (const listener of listeners) listener(payload.data, client);
-	}
-	return {
-		send(payload) {
-			const webSocket = webSocketContainer.webSocket;
-			const message = JSON.stringify(payload);
-			if (!webSocket) {
-				webSocketContainer.messageBuffers ??= [];
-				webSocketContainer.messageBuffers.push(message);
-				return;
-			}
-			webSocket.send(message);
-		},
-		on(event, listener) {
-			const listeners = listenersMap.get(event) ?? /* @__PURE__ */ new Set();
-			listeners.add(listener);
-			listenersMap.set(event, listeners);
-		},
-		off(event, listener) {
-			listenersMap.get(event)?.delete(listener);
-		},
-		listen() {
-			const webSocket = webSocketContainer.webSocket;
-			assert(webSocket, webSocketUndefinedError);
-			webSocket.addEventListener("message", onMessage);
-		},
-		close() {
-			const webSocket = webSocketContainer.webSocket;
-			assert(webSocket, webSocketUndefinedError);
-			webSocket.removeEventListener("message", onMessage);
-		}
-	};
-}
-var CloudflareDevEnvironment = class extends vite.DevEnvironment {
-	#webSocketContainer;
-	constructor(name, config) {
-		const webSocketContainer = {};
-		super(name, config, {
-			hot: true,
-			transport: createHotChannel(webSocketContainer)
-		});
-		this.#webSocketContainer = webSocketContainer;
-	}
-	async initRunner(miniflare, workerConfig, options) {
-		const response = await miniflare.dispatchFetch(new URL(INIT_PATH, UNKNOWN_HOST), { headers: {
-			[CoreHeaders.ROUTE_OVERRIDE]: workerConfig.name,
-			[WORKER_ENTRY_PATH_HEADER]: encodeURIComponent(workerConfig.main),
-			[IS_ENTRY_WORKER_HEADER]: String(options.isEntryWorker),
-			[ENVIRONMENT_NAME_HEADER]: this.name,
-			[IS_PARENT_ENVIRONMENT_HEADER]: String(options.isParentEnvironment),
-			upgrade: "websocket"
-		} });
-		assert(response.ok, `Failed to initialize module runner, error: ${await response.text()}`);
-		const webSocket = response.webSocket;
-		assert(webSocket, "Failed to establish WebSocket");
-		webSocket.accept();
-		this.#webSocketContainer.webSocket = webSocket;
-		if (this.#webSocketContainer.messageBuffers) {
-			for (const bufferedMessage of this.#webSocketContainer.messageBuffers) webSocket.send(bufferedMessage);
-			delete this.#webSocketContainer.messageBuffers;
-		}
-	}
-	async fetchWorkerExportTypes(miniflare, workerConfig) {
-		await this.depsOptimizer?.init();
-		return await (await miniflare.dispatchFetch(new URL(GET_EXPORT_TYPES_PATH, UNKNOWN_HOST), { headers: { [CoreHeaders.ROUTE_OVERRIDE]: workerConfig.name } })).json();
-	}
-	async fetchModule(id, importer, options) {
-		if (additionalModuleRE.test(id)) return {
-			externalize: id,
-			type: "module"
-		};
-		return super.fetchModule(id, importer, options);
-	}
-};
-const cloudflareBuiltInModules = [
-	"cloudflare:email",
-	"cloudflare:node",
-	"cloudflare:sockets",
-	"cloudflare:workers",
-	"cloudflare:workflows"
-];
-const defaultConditions = [
-	"workerd",
-	"worker",
-	"module",
-	"browser"
-];
-const target = "es2024";
-const resolveExtensions = [
-	".mjs",
-	".js",
-	".mts",
-	".ts",
-	".jsx",
-	".tsx",
-	".json",
-	".cjs",
-	".cts",
-	".ctx"
-];
-function createCloudflareEnvironmentOptions({ workerConfig, userConfig, mode, environmentName, isEntryWorker, isParentEnvironment, hasNodeJsCompat: hasNodeJsCompat$1 }) {
-	const rollupOptions = isParentEnvironment ? {
-		input: { [MAIN_ENTRY_NAME]: VIRTUAL_WORKER_ENTRY },
-		preserveEntrySignatures: "strict"
-	} : {};
-	const define$1 = getProcessEnvReplacements(hasNodeJsCompat$1, mode);
-	return {
-		resolve: {
-			noExternal: true,
-			conditions: [...defaultConditions, "development|production"],
-			builtins: [...cloudflareBuiltInModules]
-		},
-		define: define$1,
-		dev: { createEnvironment(name, config) {
-			if (!config.plugins.some((plugin) => plugin.name === "vite-plugin-cloudflare:dev" && plugin.configureServer !== void 0)) return vite.createRunnableDevEnvironment(name, config);
-			return new CloudflareDevEnvironment(name, config);
-		} },
-		build: {
-			createEnvironment(name, config) {
-				return new vite.BuildEnvironment(name, config);
-			},
-			target,
-			emitAssets: true,
-			manifest: isEntryWorker,
-			outDir: getOutputDirectory(userConfig, environmentName),
-			copyPublicDir: false,
-			ssr: true,
-			...isRolldown ? { rolldownOptions: {
-				...rollupOptions,
-				platform: "neutral",
-				resolve: { extensions: resolveExtensions }
-			} } : { rollupOptions }
-		},
-		optimizeDeps: {
-			noDiscovery: false,
-			ignoreOutdatedRequests: true,
-			entries: vite.normalizePath(workerConfig.main),
-			exclude: [
-				...cloudflareBuiltInModules,
-				...nonPrefixedNodeModules,
-				...nonPrefixedNodeModules.map((module$1) => `node:${module$1}`),
-				...[
-					"node:sea",
-					"node:sqlite",
-					"node:test",
-					"node:test/reporters"
-				]
-			],
-			...isRolldown ? { rolldownOptions: {
-				platform: "neutral",
-				resolve: {
-					conditionNames: [...defaultConditions, "development"],
-					extensions: resolveExtensions
-				},
-				transform: {
-					target,
-					define: define$1
-				},
-				plugins: [vite.esmExternalRequirePlugin({
-					external: [nodeBuiltinsRE],
-					skipDuplicateCheck: true
-				})]
-			} } : { esbuildOptions: {
-				platform: "neutral",
-				conditions: [...defaultConditions, "development"],
-				resolveExtensions,
-				target,
-				define: define$1
-			} }
-		},
-		keepProcessEnv: true
-	};
-}
-/**
-* Gets `process.env` replacement values.
-* `process.env.NODE_ENV` is always replaced.
-* `process.env` is replaced with an empty object if `nodejs_compat` is not enabled
-* @param hasNodeJsCompat - whether `nodejs_compat` is enabled
-* @param mode - the Vite mode
-* @returns replacement values
-*/
-function getProcessEnvReplacements(hasNodeJsCompat$1, mode) {
-	const nodeEnv = process.env.NODE_ENV || mode;
-	const nodeEnvReplacements = {
-		"process.env.NODE_ENV": JSON.stringify(nodeEnv),
-		"global.process.env.NODE_ENV": JSON.stringify(nodeEnv),
-		"globalThis.process.env.NODE_ENV": JSON.stringify(nodeEnv)
-	};
-	return hasNodeJsCompat$1 ? nodeEnvReplacements : {
-		...nodeEnvReplacements,
-		"process.env": "{}",
-		"global.process.env": "{}",
-		"globalThis.process.env": "{}"
-	};
-}
-function initRunners(resolvedPluginConfig, viteDevServer, miniflare) {
-	const initPromises = [...resolvedPluginConfig.environmentNameToWorkerMap].flatMap(([environmentName, worker]) => {
-		debuglog("Initializing worker:", worker.config.name);
-		const isEntryWorker = environmentName === resolvedPluginConfig.entryWorkerEnvironmentName;
-		const childEnvironmentNames = resolvedPluginConfig.environmentNameToChildEnvironmentNamesMap.get(environmentName) ?? [];
-		return [viteDevServer.environments[environmentName].initRunner(miniflare, worker.config, {
-			isEntryWorker,
-			isParentEnvironment: true
-		}), ...childEnvironmentNames.map((childEnvironmentName) => {
-			debuglog("Initializing child environment:", childEnvironmentName);
-			return viteDevServer.environments[childEnvironmentName].initRunner(miniflare, worker.config, {
-				isEntryWorker: false,
-				isParentEnvironment: false
-			});
-		})];
-	});
-	return Promise.all(initPromises);
-}
-
 //#endregion
 //#region src/dev-vars.ts
 /**
@@ -51574,7 +51789,12 @@ const configPlugin = createPlugin("config", (ctx) => {
 		},
 		configResolved(resolvedViteConfig) {
 			ctx.setResolvedViteConfig(resolvedViteConfig);
-			if (ctx.resolvedPluginConfig.type !== "preview") validateWorkerEnvironmentOptions(ctx.resolvedPluginConfig, ctx.resolvedViteConfig);
+			if (ctx.resolvedPluginConfig.type === "preview") return;
+			validateWorkerEnvironmentOptions(ctx.resolvedPluginConfig, ctx.resolvedViteConfig);
+			if (ctx.resolvedPluginConfig.experimental.newConfig?.cfBuildOutput) {
+				forceBuildOutputDirs(ctx.resolvedPluginConfig, ctx.resolvedViteConfig);
+				if (ctx.resolvedViteConfig.command === "build") cleanBuildOutputDir(ctx.resolvedViteConfig.root);
+			}
 		},
 		buildStart() {
 			ctx.setHasShownWorkerConfigWarnings(false);
@@ -51604,26 +51824,33 @@ const configPlugin = createPlugin("config", (ctx) => {
 				const { entryWorkerEnvironmentName } = ctx.resolvedPluginConfig;
 				const entryWorkerEnvironment = builder.environments[entryWorkerEnvironmentName];
 				assert(entryWorkerEnvironment, `No "${entryWorkerEnvironmentName}" environment`);
+				const cfBuildOutput = ctx.resolvedPluginConfig.experimental.newConfig?.cfBuildOutput === true;
 				if (entryWorkerEnvironment.isBuilt) {
-					if (!builder.environments.client?.isBuilt) removeAssetsField(nodePath.resolve(builder.config.root, entryWorkerEnvironment.config.build.outDir));
+					if (!builder.environments.client?.isBuilt && !cfBuildOutput) removeAssetsField(nodePath.resolve(builder.config.root, entryWorkerEnvironment.config.build.outDir));
 				} else {
 					const clientEnvironment = builder.environments.client;
 					assert(clientEnvironment, "No \"client\" environment");
 					if (!clientEnvironment.isBuilt) throw new Error("If `assetsOnly` is set to `true`, the client environment must be built");
-					const entryWorkerConfig = ctx.getWorkerConfig(entryWorkerEnvironmentName);
-					assert(entryWorkerConfig, `No config found for "${entryWorkerEnvironmentName}" environment`);
-					const outputConfig = {
-						...entryWorkerConfig,
-						main: void 0,
-						assets: {
-							...entryWorkerConfig.assets,
-							directory: ".",
-							binding: void 0
-						}
-					};
-					if (outputConfig.unsafe && Object.keys(outputConfig.unsafe).length === 0) outputConfig.unsafe = void 0;
-					fs$1.writeFileSync(nodePath.resolve(builder.config.root, clientEnvironment.config.build.outDir, "wrangler.json"), JSON.stringify(outputConfig));
-					writeDeployConfig(ctx.resolvedPluginConfig, ctx.resolvedViteConfig, true);
+					if (cfBuildOutput) {
+						const entryWorkerNewConfig = ctx.getWorkerNewConfig(entryWorkerEnvironmentName);
+						assert(entryWorkerNewConfig, `No config found for "${entryWorkerEnvironmentName}" environment`);
+						writeOutputWorkerConfig(builder.config.root, entryWorkerNewConfig);
+					} else {
+						const entryWorkerConfig = ctx.getWorkerConfig(entryWorkerEnvironmentName);
+						assert(entryWorkerConfig, `No config found for "${entryWorkerEnvironmentName}" environment`);
+						const outputConfig = {
+							...entryWorkerConfig,
+							main: void 0,
+							assets: {
+								...entryWorkerConfig.assets,
+								directory: ".",
+								binding: void 0
+							}
+						};
+						if (outputConfig.unsafe && Object.keys(outputConfig.unsafe).length === 0) outputConfig.unsafe = void 0;
+						fs$1.writeFileSync(nodePath.resolve(builder.config.root, clientEnvironment.config.build.outDir, "wrangler.json"), JSON.stringify(outputConfig));
+						writeDeployConfig(ctx.resolvedPluginConfig, ctx.resolvedViteConfig, true);
+					}
 				}
 			}
 		}
@@ -51663,6 +51890,37 @@ function getEnvironmentsConfig(ctx, userConfig, mode) {
 		}
 	};
 }
+/**
+* When the Build Output API is enabled,
+* force every Worker environment's and the client environment's `build.outDir`
+* to the spec-mandated location.
+*
+* Runs after Vite's merge in `configResolved`, so it overrides any
+* user-supplied `build.outDir`
+*/
+function forceBuildOutputDirs(resolvedPluginConfig, resolvedViteConfig) {
+	if (!resolvedPluginConfig.experimental.newConfig?.cfBuildOutput) return;
+	const { root } = resolvedViteConfig;
+	let clientWorkerName;
+	if (resolvedPluginConfig.type === "workers") {
+		for (const [environmentName, worker] of resolvedPluginConfig.environmentNameToWorkerMap) {
+			const environment = resolvedViteConfig.environments[environmentName];
+			if (!environment) continue;
+			assert(worker.parsedNewConfig, "Expected parsedNewConfig to be defined");
+			environment.build.outDir = getWorkerBundleDir(root, worker.parsedNewConfig.name);
+		}
+		const entryName = resolvedPluginConfig.entryWorkerEnvironmentName;
+		const entryWorker = resolvedPluginConfig.environmentNameToWorkerMap.get(entryName);
+		assert(entryWorker, `Expected entry worker for environment "${entryName}"`);
+		assert(entryWorker.parsedNewConfig, "Expected parsedNewConfig to be defined");
+		clientWorkerName = entryWorker.parsedNewConfig.name;
+	} else {
+		assert(resolvedPluginConfig.parsedNewConfig, "Expected parsedNewConfig to be defined");
+		clientWorkerName = resolvedPluginConfig.parsedNewConfig.name;
+	}
+	const clientEnvironment = resolvedViteConfig.environments.client;
+	if (clientEnvironment) clientEnvironment.build.outDir = getWorkerAssetsDir(root, clientWorkerName);
+}
 function getAllowedHosts(tunnelHostnames, userAllowedHosts) {
 	if (tunnelHostnames.length === 0 || userAllowedHosts === true) return userAllowedHosts;
 	return Array.from(new Set([...userAllowedHosts ?? [], ...tunnelHostnames]));
@@ -51763,8 +52021,8 @@ const debugPlugin = createPlugin("debug", (ctx) => {
 			if (!!process.env.VSCODE_INSPECTOR_OPTIONS) return;
 			if (ctx.resolvedPluginConfig.workers.length >= 1 && ctx.resolvedPluginConfig.inspectorPort !== false) addDebugToVitePrintUrls(vitePreviewServer);
 			const workerNames = ctx.resolvedPluginConfig.workers.map((worker) => {
-				assert(worker.name, "Expected the Worker to have a name");
-				return worker.name;
+				assert(worker.config.name, "Expected the Worker to have a name");
+				return worker.config.name;
 			});
 			vitePreviewServer.middlewares.use(DEBUG_PATH, async (_, res, next) => {
 				const resolvedInspectorPort = await ctx.getResolvedInspectorPort();
@@ -55953,11 +56211,54 @@ function getPreviewModules(main, modulesRules) {
 		})))]
 	};
 }
+/**
+* Translate a Build Output API module type to a Miniflare module type.
+*/
+function toMiniflareModuleType(type) {
+	switch (type) {
+		case "esm": return "ESModule";
+		case "cjs": return "CommonJS";
+		case "wasm": return "CompiledWasm";
+		case "text": return "Text";
+		case "data": return "Data";
+		case "json": return "Data";
+		case "python": return "PythonModule";
+		case "pythonRequirement": return null;
+		case "sourcemap": return null;
+	}
+}
+/**
+* Get Miniflare's module list directly from the `modules` manifest.
+*
+* Miniflare uses the first module in the list as the entry, so the
+* `mainModule` is hoisted to index 0 regardless of the manifest's
+* order.
+*/
+function getModulesFromManifest(bundle) {
+	const { mainModule } = bundle;
+	const mainEntry = bundle.modules[mainModule];
+	assert(mainEntry !== void 0, `Build Output API: \`mainModule\` "${mainModule}" is missing from \`modules\`.`);
+	const ordered = [[mainModule, mainEntry]];
+	for (const [modulePath, value] of Object.entries(bundle.modules)) if (modulePath !== mainModule) ordered.push([modulePath, value]);
+	const modules = ordered.map(([modulePath, { type }]) => {
+		const miniflareType = toMiniflareModuleType(type);
+		if (miniflareType === null) return null;
+		return {
+			type: miniflareType,
+			path: modulePath
+		};
+	}).filter((m) => m !== null);
+	return {
+		rootPath: bundle.rootPath,
+		modules
+	};
+}
 async function getPreviewMiniflareOptions(ctx, vitePreviewServer) {
 	const inputInspectorPort = await getInputInspectorPort(ctx, vitePreviewServer);
 	const { resolvedPluginConfig, resolvedViteConfig } = ctx;
 	const containerTagToOptionsMap = /* @__PURE__ */ new Map();
-	const workers = (await Promise.all(resolvedPluginConfig.workers.map(async (workerConfig) => {
+	const workers = (await Promise.all(resolvedPluginConfig.workers.map(async (previewWorker) => {
+		const workerConfig = previewWorker.config;
 		const bindings = wrangler.unstable_convertConfigBindingsToStartWorkerBindings(workerConfig);
 		const preExistingRemoteProxySessionData = workerConfig.configPath ? remoteProxySessionsDataMap.get(workerConfig.configPath) : void 0;
 		const remoteProxySessionData = !resolvedPluginConfig.remoteBindings ? null : await wrangler.maybeStartOrUpdateRemoteProxySession({
@@ -55988,7 +56289,7 @@ async function getPreviewMiniflareOptions(ctx, vitePreviewServer) {
 			...workerOptions,
 			name: workerOptions.name ?? workerConfig.name,
 			unsafeInspectorProxy: inputInspectorPort !== false,
-			...miniflareWorkerOptions.main ? getPreviewModules(miniflareWorkerOptions.main, modulesRules) : {
+			...previewWorker.source === "build-output" && previewWorker.bundle ? getModulesFromManifest(previewWorker.bundle) : miniflareWorkerOptions.main ? getPreviewModules(miniflareWorkerOptions.main, modulesRules) : {
 				modules: true,
 				script: ""
 			}
@@ -57253,6 +57554,8 @@ await assertWranglerVersion();
 */
 function cloudflare(pluginConfig = {}) {
 	const ctx = new PluginContext(sharedContext);
+	const newConfig = pluginConfig.experimental?.newConfig;
+	const outputPlugin = typeof newConfig === "object" && newConfig?.cfBuildOutput === true ? buildOutputPlugin(ctx) : outputConfigPlugin(ctx);
 	return [
 		{
 			name: "vite-plugin-cloudflare",
@@ -57285,7 +57588,7 @@ function cloudflare(pluginConfig = {}) {
 		triggerHandlersPlugin(ctx),
 		virtualModulesPlugin(ctx),
 		virtualClientFallbackPlugin(ctx),
-		outputConfigPlugin(ctx),
+		outputPlugin,
 		wasmHelperPlugin(ctx),
 		additionalModulesPlugin(ctx),
 		nodeJsAlsPlugin(ctx),