@depup/cloudflare__vite-plugin 1.57.3-depup.1 → 1.58.0-depup.0

package/README.md

@@ -13,7 +13,7 @@ npm install @depup/cloudflare__vite-plugin
 
 | Field | Value |
 |-------|-------|
-| Original | [@cloudflare/vite-plugin](https://www.npmjs.com/package/@cloudflare/vite-plugin) @ 1.57.3 |
+| Original | [@cloudflare/vite-plugin](https://www.npmjs.com/package/@cloudflare/vite-plugin) @ 1.58.0 |
 | Processed | 2026-09-23 |
 | Smoke test | failed |
 | Deps updated | 2 |

package/changes.json

@@ -9,6 +9,6 @@
       "to": "^8.21.3"
     }
   },
-  "timestamp": "2026-09-23T08:11:57.633Z",
+  "timestamp": "2026-09-23T16:10:20.092Z",
   "totalUpdated": 2
 }

package/dist/index.d.mts

@@ -103,14 +103,14 @@ interface ExperimentalNewConfig {
   /** Options for type generation. */
   types?: {
     /**
-     * Whether to auto-generate `worker-configuration.d.ts` at the project
-     * root. Defaults to `true`.
+     * Whether to auto-generate `.cloudflare/types/index.d.ts`. Defaults to
+     * `true`.
      */
     generate?: boolean;
     /**
      * Whether to include the Worker's runtime types (generated from the
      * project's compatibility date and flags) in the generated
-     * `worker-configuration.d.ts`. Defaults to `true`.
+     * `.cloudflare/types/index.d.ts`. Defaults to `true`.
      */
     includeRuntime?: boolean;
   };

package/dist/index.mjs

@@ -56718,7 +56718,7 @@ var import_dist = (/* @__PURE__ */ __commonJS$1({ "../../node_modules/.pnpm/ts-d
 	exports$1.dedent = dedent$1$1;
 }) }))();
 /**
-* Generate the content for worker-configuration.d.ts
+* Generate the content for a Worker types declaration file.
 *
 * @example
 * ```typescript
@@ -56726,10 +56726,10 @@ var import_dist = (/* @__PURE__ */ __commonJS$1({ "../../node_modules/.pnpm/ts-d
 * import { writeFileSync } from "node:fs";
 *
 * const content = generateTypes({
-*   configPath: "./cloudflare.config.ts",
+*   configPath: "../../cloudflare.config.ts",
 * });
 *
-* writeFileSync("worker-configuration.d.ts", content);
+* writeFileSync(".cloudflare/types/index.d.ts", content);
 * ```
 */
 function generateTypes({ configPath, packageName = "@cloudflare/config" }) {
@@ -65406,7 +65406,6 @@ async function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
 		const result = await loadNewConfig({
 			root,
 			mode: viteEnv.mode,
-			command: viteEnv.command,
 			types: resolvedNewConfig.types
 		});
 		configPath = result.configPath;
@@ -65537,7 +65536,7 @@ function resolveWorker(workerConfig, devOnly, parsedNewWorkerConfig) {
 	};
 }
 const NEW_CONFIG_FILENAME = "cloudflare.config.ts";
-const TYPES_OUTPUT_FILENAME = "worker-configuration.d.ts";
+const TYPES_OUTPUT_PATH = ".cloudflare/types/index.d.ts";
 const EXPERIMENTAL_CONFIG_PKG = "@cloudflare/vite-plugin/experimental-config";
 /**
 * Load and convert a `cloudflare.config.ts` file via `@cloudflare/config`. Returns
@@ -65546,9 +65545,8 @@ const EXPERIMENTAL_CONFIG_PKG = "@cloudflare/vite-plugin/experimental-config";
 * file, and the set of files imported while resolving the config (for
 * watch-mode).
 *
-* When `types.generate` is true, also writes `worker-configuration.d.ts` next
-* to the config when the generated content differs from what's already on disk.
-* Type generation only runs in dev.
+* When `types.generate` is true, also writes `.cloudflare/types/index.d.ts`
+* when the generated content differs from what's already on disk.
 */
 async function loadNewConfig(options) {
 	const configPath = path.resolve(options.root, NEW_CONFIG_FILENAME);
@@ -65561,7 +65559,7 @@ async function loadNewConfig(options) {
 	const worker = result.data.worker;
 	if (worker === void 0) throw new Error(`\`${NEW_CONFIG_FILENAME}\` must define a Worker using the \`worker\` property.`);
 	const rawConfig = convertToWranglerConfig(result.data);
-	if (options.command === "serve" && options.types.generate) await writeWorkerConfigurationDts({
+	if (options.types.generate) await writeCloudflareTypes({
 		root: options.root,
 		configPath,
 		includeRuntime: options.types.includeRuntime,
@@ -65576,7 +65574,7 @@ async function loadNewConfig(options) {
 	};
 }
 /**
-* Write `worker-configuration.d.ts` to the project root using
+* Write `.cloudflare/types/index.d.ts` using
 * `@cloudflare/config`'s `generateTypes`, targeting the vite-plugin's
 * `experimental-config` subpath (so users don't need a direct dependency on
 * `@cloudflare/config`).
@@ -65590,15 +65588,17 @@ async function loadNewConfig(options) {
 * check and the diff-before-write (only writes if content differs, to avoid
 * touching mtimes unnecessarily).
 */
-async function writeWorkerConfigurationDts(options) {
-	const outputPath = path.resolve(options.root, TYPES_OUTPUT_FILENAME);
-	const relativeConfigPath = "./" + path.relative(options.root, options.configPath);
+async function writeCloudflareTypes(options) {
+	const outputPath = path.resolve(options.root, TYPES_OUTPUT_PATH);
+	const outputDir = path.dirname(outputPath);
+	const relativeConfigPath = vite.normalizePath(path.relative(outputDir, options.configPath));
+	const configImportPath = relativeConfigPath.startsWith(".") ? relativeConfigPath : `./${relativeConfigPath}`;
 	let existingContent;
 	try {
 		existingContent = await fsp.readFile(outputPath, "utf8");
 	} catch {}
 	let content = generateTypes({
-		configPath: relativeConfigPath,
+		configPath: configImportPath,
 		packageName: EXPERIMENTAL_CONFIG_PKG
 	});
 	if (options.includeRuntime) {
@@ -65609,7 +65609,10 @@ async function writeWorkerConfigurationDts(options) {
 		});
 		content += `\n${runtimeHeader}\n${RUNTIME_TYPES_MARKER}\n${runtimeTypes}`;
 	}
-	if (existingContent !== content) await fsp.writeFile(outputPath, content);
+	if (existingContent !== content) {
+		await fsp.mkdir(outputDir, { recursive: true });
+		await fsp.writeFile(outputPath, content);
+	}
 }
 
 //#endregion
@@ -79985,6 +79988,79 @@ const generateStaticRoutingRuleMatcher = (rules) => ({ request: request$2 }) =>
 	return false;
 };
 
+//#endregion
+//#region src/container-cleanup.ts
+/** Owns Container cleanup for one server session, including failed attempts. */
+function createContainerCleanup() {
+	const pendingImages = /* @__PURE__ */ new Map();
+	let restarting = false;
+	function cleanupContainerImages() {
+		for (const [dockerPath, imageTags] of pendingImages) if (cleanupContainers(dockerPath, imageTags)) pendingImages.delete(dockerPath);
+		if (pendingImages.size === 0) process.off("exit", cleanupContainerImages);
+	}
+	return {
+		cleanup: cleanupContainerImages,
+		get isRestarting() {
+			return restarting;
+		},
+		async restart(action) {
+			if (restarting) return action();
+			cleanupContainerImages();
+			restarting = true;
+			try {
+				await action();
+			} finally {
+				restarting = false;
+			}
+		},
+		track(dockerPath, imageTags) {
+			const tags = new Set([...pendingImages.get(dockerPath) ?? [], ...imageTags]);
+			if (tags.size === 0) return;
+			pendingImages.set(dockerPath, tags);
+			process.off("exit", cleanupContainerImages);
+			process.on("exit", cleanupContainerImages);
+		}
+	};
+}
+/**
+* Retains Container cleanup across config reloads using Vite's inline plugins.
+* The state belongs to this server, not the re-evaluated cloudflare() factory.
+*/
+function getDevContainerCleanup(server) {
+	const pluginName = "vite-plugin-cloudflare:container-cleanup";
+	const retainedPlugin = server.config.plugins.find((plugin$1) => plugin$1.name === pluginName);
+	if (retainedPlugin?.api) return retainedPlugin.api;
+	const cleanup = createContainerCleanup();
+	const plugin = {
+		name: pluginName,
+		api: cleanup,
+		configureServer(nextServer) {
+			attachContainerCleanup(nextServer, cleanup);
+		}
+	};
+	server.config = {
+		...server.config,
+		inlineConfig: {
+			...server.config.inlineConfig,
+			plugins: [...server.config.inlineConfig.plugins ?? [], plugin]
+		}
+	};
+	attachContainerCleanup(server, cleanup);
+	return cleanup;
+}
+function attachContainerCleanup(server, cleanup) {
+	const restartServer = server.restart.bind(server);
+	server.restart = (...args) => cleanup.restart(() => restartServer(...args));
+	const closeServer = server.close.bind(server);
+	server.close = async () => {
+		try {
+			await closeServer();
+		} finally {
+			if (!cleanup.isRestarting) cleanup.cleanup();
+		}
+	};
+}
+
 //#endregion
 //#region src/containers.ts
 /**
@@ -80014,20 +80090,15 @@ function normalizeContainerImageUris(containerOptions, accountId, complianceConf
 	} : option);
 }
 /**
-* Prepares each Worker's Container images with that Worker's registry account
-* and compliance settings.
+* Prepares the sidecar and each Worker's Container images with that Worker's
+* registry account and compliance settings, including Workers whose images
+* are selected at start time.
 *
 * @param args - Planned images, Docker executable, and Vite logger.
 * @returns No value.
 */
 async function prepareContainerImagesForVite(args) {
-	const optionsByWorkerConfig = /* @__PURE__ */ new Map();
-	for (const { containerOptions, workerConfig } of args.containerTagToOptionsMap.values()) {
-		const options = optionsByWorkerConfig.get(workerConfig) ?? [];
-		options.push(containerOptions);
-		optionsByWorkerConfig.set(workerConfig, options);
-	}
-	for (const [workerConfig, plannedOptions] of optionsByWorkerConfig) {
+	for (const [workerConfig, plannedOptions] of args.containerOptionsByWorker) {
 		let containerOptions = plannedOptions;
 		if (containerOptions.some((options) => "image_uri" in options && isCloudflareRegistryImage(options.image_uri, workerConfig))) {
 			const apiToken = process.env.CLOUDFLARE_API_TOKEN;
@@ -85517,7 +85588,7 @@ __name(createWorkerUploadForm, "createWorkerUploadForm");
 //#endregion
 //#region ../remote-bindings/dist/index.mjs
 var import_undici = require_undici();
-var version$2 = "0.0.31";
+var version$2 = "0.0.32";
 var NoDefaultValueProvided = class extends UserError {
 	constructor() {
 		super("This command cannot be run in a non-interactive context", { telemetryMessage: "remote bindings prompt default missing" });
@@ -89279,7 +89350,7 @@ async function getDevMiniflareOptions(ctx, viteDevServer) {
 			}
 		}
 	];
-	const containerTagToOptionsMap = /* @__PURE__ */ new Map();
+	const containerOptionsByWorker = /* @__PURE__ */ new Map();
 	let containerEngine;
 	const workersFromConfig = resolvedPluginConfig.type === "workers" ? await Promise.all([...resolvedPluginConfig.environmentNameToWorkerMap].map(async ([environmentName, worker]) => {
 		const bindings = wrangler.unstable_convertConfigBindingsToStartWorkerBindings(worker.config);
@@ -89296,13 +89367,13 @@ async function getDevMiniflareOptions(ctx, viteDevServer) {
 		if (worker.config.containers?.length && worker.config.dev.enable_containers) {
 			containerEngine = resolveDockerHost(getDockerPath());
 			containerBuildId = generateContainerBuildId();
+			containerOptionsByWorker.set(worker.config, createContainerDevPlan({
+				containers: worker.config.containers,
+				exports: worker.config.exports,
+				containerBuildId,
+				configPath: worker.config.configPath
+			})?.containerOptions ?? []);
 		}
-		const containerPlan = worker.config.dev.enable_containers ? createContainerDevPlan({
-			containers: worker.config.containers,
-			exports: worker.config.exports,
-			containerBuildId,
-			configPath: worker.config.configPath
-		}) : void 0;
 		const miniflareWorkerOptions = wrangler.unstable_getMiniflareWorkerOptions({
 			...worker.config,
 			assets: void 0
@@ -89310,10 +89381,6 @@ async function getDevMiniflareOptions(ctx, viteDevServer) {
 			remoteProxyConnectionString: remoteProxySessionData?.session?.remoteProxyConnectionString,
 			containerBuildId
 		});
-		for (const option of containerPlan?.containerOptions ?? []) containerTagToOptionsMap.set(option.image_tag, {
-			containerOptions: option,
-			workerConfig: worker.config
-		});
 		const { externalWorkers: externalWorkers$1 } = miniflareWorkerOptions;
 		const workerOptions = miniflareWorkerOptions.workerOptions;
 		if (workerOptions.browserRendering && getBrowserRenderingHeadfulFromEnv()) workerOptions.browserRendering.headful = true;
@@ -89434,7 +89501,7 @@ async function getDevMiniflareOptions(ctx, viteDevServer) {
 				}
 			}
 		}),
-		containerTagToOptionsMap
+		containerOptionsByWorker
 	};
 }
 function getPreviewModules(main, modulesRules) {
@@ -89500,7 +89567,7 @@ function getModulesFromManifest(bundle) {
 async function getPreviewMiniflareOptions(ctx, vitePreviewServer) {
 	const inputInspectorPort = await getInputInspectorPort(ctx, vitePreviewServer);
 	const { resolvedPluginConfig, resolvedViteConfig } = ctx;
-	const containerTagToOptionsMap = /* @__PURE__ */ new Map();
+	const containerOptionsByWorker = /* @__PURE__ */ new Map();
 	let containerEngine;
 	const workers = (await Promise.all(resolvedPluginConfig.workers.map(async (previewWorker) => {
 		const workerConfig = previewWorker.config;
@@ -89518,21 +89585,17 @@ async function getPreviewMiniflareOptions(ctx, vitePreviewServer) {
 		if (workerConfig.containers?.length && workerConfig.dev.enable_containers) {
 			containerEngine = resolveDockerHost(getDockerPath());
 			containerBuildId = generateContainerBuildId();
+			containerOptionsByWorker.set(workerConfig, createContainerDevPlan({
+				containers: workerConfig.containers,
+				exports: workerConfig.exports,
+				containerBuildId,
+				configPath: workerConfig.configPath
+			})?.containerOptions ?? []);
 		}
-		const containerPlan = workerConfig.dev.enable_containers ? createContainerDevPlan({
-			containers: workerConfig.containers,
-			exports: workerConfig.exports,
-			containerBuildId,
-			configPath: workerConfig.configPath
-		}) : void 0;
 		const miniflareWorkerOptions = wrangler.unstable_getMiniflareWorkerOptions(workerConfig, void 0, {
 			remoteProxyConnectionString: remoteProxySessionData?.session?.remoteProxyConnectionString,
 			containerBuildId
 		});
-		for (const option of containerPlan?.containerOptions ?? []) containerTagToOptionsMap.set(option.image_tag, {
-			containerOptions: option,
-			workerConfig
-		});
 		const { externalWorkers } = miniflareWorkerOptions;
 		const { modulesRules,...sourcelessWorkerOptions } = miniflareWorkerOptions.workerOptions;
 		const workerOptions = sourcelessWorkerOptions;
@@ -89569,7 +89632,7 @@ async function getPreviewMiniflareOptions(ctx, vitePreviewServer) {
 			containerEngine,
 			workers
 		}),
-		containerTagToOptionsMap
+		containerOptionsByWorker
 	};
 }
 /**
@@ -89711,136 +89774,121 @@ function hasSandboxOrigin(origin) {
 //#endregion
 //#region src/plugins/dev.ts
 var import_picocolors$2 = /* @__PURE__ */ __toESM$2(require_picocolors(), 1);
-let exitCallback$2 = () => {};
-process.on("exit", () => {
-	exitCallback$2();
-});
 /**
 * Plugin to provide core development functionality
 */
 const devPlugin = createPlugin("dev", (ctx) => {
-	let containerImageTags = /* @__PURE__ */ new Set();
-	return {
-		buildEnd() {
-			if (ctx.resolvedViteConfig.command === "serve" && ctx.isRestartingDevServer && containerImageTags.size) cleanupContainers(getDockerPath(), containerImageTags);
-		},
-		async configureServer(viteDevServer) {
-			assertIsNotPreview(ctx);
-			const initialOptions = await getDevMiniflareOptions(ctx, viteDevServer);
-			let containerTagToOptionsMap = initialOptions.containerTagToOptionsMap;
-			await ctx.startOrUpdateMiniflare(initialOptions.miniflareOptions);
-			const closeServer = viteDevServer.close.bind(viteDevServer);
-			viteDevServer.close = async () => {
-				try {
-					await closeServer();
-				} finally {
-					if (!ctx.isRestartingDevServer) {
-						if (containerImageTags.size) cleanupContainers(getDockerPath(), containerImageTags);
-						try {
-							await ctx.disposeMiniflare();
-						} catch (error$2) {
-							debuglog("Failed to dispose Miniflare instance:", error$2);
-						}
-					}
-				}
-			};
-			if (viteDevServer.httpServer) viteDevServer.httpServer.on("listening", () => {
-				const addr = viteDevServer.httpServer?.address();
-				if (typeof addr === "object" && addr !== null) {
-					const serverConfig = viteDevServer.config.server;
-					ctx.miniflare.publicUrl = buildPublicUrl({
-						hostname: typeof serverConfig.host === "string" ? serverConfig.host : void 0,
-						port: addr.port,
-						secure: !!serverConfig.https
-					});
+	return { async configureServer(viteDevServer) {
+		assertIsNotPreview(ctx);
+		const containerCleanup = getDevContainerCleanup(viteDevServer);
+		const initialOptions = await getDevMiniflareOptions(ctx, viteDevServer);
+		let containerOptionsByWorker = initialOptions.containerOptionsByWorker;
+		await ctx.startOrUpdateMiniflare(initialOptions.miniflareOptions);
+		const closeServer = viteDevServer.close.bind(viteDevServer);
+		viteDevServer.close = async () => {
+			try {
+				await closeServer();
+			} finally {
+				if (!ctx.isRestartingDevServer) try {
+					await ctx.disposeMiniflare();
+				} catch (error$2) {
+					debuglog("Failed to dispose Miniflare instance:", error$2);
 				}
-			});
-			if (ctx.resolvedPluginConfig.type === "workers") {
-				debuglog("Initializing the Vite module runners");
+			}
+		};
+		if (viteDevServer.httpServer) viteDevServer.httpServer.on("listening", () => {
+			const addr = viteDevServer.httpServer?.address();
+			if (typeof addr === "object" && addr !== null) {
+				const serverConfig = viteDevServer.config.server;
+				ctx.miniflare.publicUrl = buildPublicUrl({
+					hostname: typeof serverConfig.host === "string" ? serverConfig.host : void 0,
+					port: addr.port,
+					secure: !!serverConfig.https
+				});
+			}
+		});
+		if (ctx.resolvedPluginConfig.type === "workers") {
+			debuglog("Initializing the Vite module runners");
+			await initRunners(ctx.resolvedPluginConfig, viteDevServer, ctx.miniflare);
+			const currentWorkerNameToExportTypesMap = await getCurrentWorkerNameToExportTypesMap(ctx.resolvedPluginConfig, viteDevServer, ctx.miniflare);
+			if (compareWorkerNameToExportTypesMaps(ctx.workerNameToExportTypesMap, currentWorkerNameToExportTypesMap)) {
+				ctx.setWorkerNameToExportTypesMap(currentWorkerNameToExportTypesMap);
+				const updatedOptions = await getDevMiniflareOptions(ctx, viteDevServer);
+				containerOptionsByWorker = updatedOptions.containerOptionsByWorker;
+				await ctx.startOrUpdateMiniflare(updatedOptions.miniflareOptions);
 				await initRunners(ctx.resolvedPluginConfig, viteDevServer, ctx.miniflare);
-				const currentWorkerNameToExportTypesMap = await getCurrentWorkerNameToExportTypesMap(ctx.resolvedPluginConfig, viteDevServer, ctx.miniflare);
-				if (compareWorkerNameToExportTypesMaps(ctx.workerNameToExportTypesMap, currentWorkerNameToExportTypesMap)) {
-					ctx.setWorkerNameToExportTypesMap(currentWorkerNameToExportTypesMap);
-					const updatedOptions = await getDevMiniflareOptions(ctx, viteDevServer);
-					containerTagToOptionsMap = updatedOptions.containerTagToOptionsMap;
-					await ctx.startOrUpdateMiniflare(updatedOptions.miniflareOptions);
-					await initRunners(ctx.resolvedPluginConfig, viteDevServer, ctx.miniflare);
-				}
-				for (const environmentName of ctx.resolvedPluginConfig.environmentNameToWorkerMap.keys()) {
-					const environment = viteDevServer.environments[environmentName];
-					assert2(environment, `Expected environment "${environmentName}" to be defined`);
-					environment.hot.on("vite-plugin-cloudflare:worker-export-types", async (newExportTypes) => {
-						const workerConfig = ctx.getWorkerConfig(environmentName);
-						assert2(workerConfig, `Expected workerConfig for environment "${environmentName}" to be defined`);
-						const oldExportTypes = ctx.workerNameToExportTypesMap.get(workerConfig.name);
-						assert2(oldExportTypes, `Expected export types for Worker "${workerConfig.name}" to be defined`);
-						if (compareExportTypes(oldExportTypes, newExportTypes)) {
-							viteDevServer.config.logger.info(import_picocolors$2.default.dim(import_picocolors$2.default.yellow("Worker exports have changed. Restarting dev server.")));
-							await viteDevServer.restart();
-						}
-					});
-				}
-				const entryWorkerConfig = ctx.entryWorkerConfig;
-				assert2(entryWorkerConfig, `No entry Worker config`);
-				const entryWorkerName = entryWorkerConfig.name;
-				if (viteDevServer.httpServer) handleWebSocket(viteDevServer.httpServer, ctx.miniflare, entryWorkerName);
-				const staticRouting = entryWorkerConfig.assets?.run_worker_first === true ? { user_worker: ["/*"] } : ctx.resolvedPluginConfig.staticRouting;
-				if (staticRouting) {
-					const excludeRulesMatcher = generateStaticRoutingRuleMatcher(staticRouting.asset_worker ?? []);
-					const includeRulesMatcher = generateStaticRoutingRuleMatcher(staticRouting.user_worker);
-					const userWorkerHandler = createRequestHandler(async (request$2) => {
-						request$2.headers.set(CoreHeaders.ROUTE_OVERRIDE, entryWorkerName);
-						return ctx.miniflare.dispatchFetch(request$2, { redirect: "manual" });
-					});
-					viteDevServer.middlewares.use(async function cloudflarePreMiddleware(req, res, next) {
-						assert2(req.url, `req.url not defined`);
-						const request$2 = new Request(new URL(req.url, UNKNOWN_HOST));
-						if (req[kRequestType] === "asset") next();
-						else if (excludeRulesMatcher({ request: request$2 })) {
-							req[kRequestType] = "asset";
-							next();
-						} else if (includeRulesMatcher({ request: request$2 })) userWorkerHandler(req, res, next);
-						else next();
-					});
-				}
-				if (containerTagToOptionsMap.size) {
-					viteDevServer.config.logger.info(import_picocolors$2.default.dim(import_picocolors$2.default.yellow("∷ Building container images for local development...\n")));
-					await prepareContainerImagesForVite({
-						dockerPath: getDockerPath(),
-						containerTagToOptionsMap,
-						logger: viteDevServer.config.logger
-					});
-					containerImageTags = new Set(containerTagToOptionsMap.keys());
-					viteDevServer.config.logger.info(import_picocolors$2.default.dim(import_picocolors$2.default.yellow("\n⚡️ Containers successfully built. To rebuild your containers during development, restart the Vite dev server (r + enter).")));
-					exitCallback$2 = () => {
-						if (containerImageTags.size) cleanupContainers(getDockerPath(), containerImageTags);
-					};
-				}
 			}
-			return () => {
-				if (!satisfiesMinimumViteVersion("7.0.0")) {
-					const middlewareStack = viteDevServer.middlewares.stack;
-					const preMiddlewareIndex = middlewareStack.findIndex((middleware) => "name" in middleware.handle && middleware.handle.name === "cloudflarePreMiddleware");
-					if (preMiddlewareIndex !== -1) {
-						const [preMiddleware] = middlewareStack.splice(preMiddlewareIndex, 1);
-						assert2(preMiddleware, "Failed to remove cloudflarePreMiddleware from stack");
-						const cachedTransformMiddlewareIndex = middlewareStack.findIndex((middleware) => "name" in middleware.handle && middleware.handle.name === "viteCachedTransformMiddleware");
-						assert2(cachedTransformMiddlewareIndex !== -1, "Failed to find viteCachedTransformMiddleware");
-						middlewareStack.splice(cachedTransformMiddlewareIndex, 0, preMiddleware);
-					}
-				}
-				viteDevServer.middlewares.use(createRequestHandler(async (request$2, req) => {
-					if (req[kRequestType] === "asset") {
-						request$2.headers.set(CoreHeaders.ROUTE_OVERRIDE, ASSET_WORKER_NAME);
-						return ctx.miniflare.dispatchFetch(request$2, { redirect: "manual" });
-					} else {
-						request$2.headers.set(CoreHeaders.ROUTE_OVERRIDE, ROUTER_WORKER_NAME);
-						return ctx.miniflare.dispatchFetch(request$2, { redirect: "manual" });
+			for (const environmentName of ctx.resolvedPluginConfig.environmentNameToWorkerMap.keys()) {
+				const environment = viteDevServer.environments[environmentName];
+				assert2(environment, `Expected environment "${environmentName}" to be defined`);
+				environment.hot.on("vite-plugin-cloudflare:worker-export-types", async (newExportTypes) => {
+					const workerConfig = ctx.getWorkerConfig(environmentName);
+					assert2(workerConfig, `Expected workerConfig for environment "${environmentName}" to be defined`);
+					const oldExportTypes = ctx.workerNameToExportTypesMap.get(workerConfig.name);
+					assert2(oldExportTypes, `Expected export types for Worker "${workerConfig.name}" to be defined`);
+					if (compareExportTypes(oldExportTypes, newExportTypes)) {
+						viteDevServer.config.logger.info(import_picocolors$2.default.dim(import_picocolors$2.default.yellow("Worker exports have changed. Restarting dev server.")));
+						await viteDevServer.restart();
 					}
-				}));
-			};
+				});
+			}
+			const entryWorkerConfig = ctx.entryWorkerConfig;
+			assert2(entryWorkerConfig, `No entry Worker config`);
+			const entryWorkerName = entryWorkerConfig.name;
+			if (viteDevServer.httpServer) handleWebSocket(viteDevServer.httpServer, ctx.miniflare, entryWorkerName);
+			const staticRouting = entryWorkerConfig.assets?.run_worker_first === true ? { user_worker: ["/*"] } : ctx.resolvedPluginConfig.staticRouting;
+			if (staticRouting) {
+				const excludeRulesMatcher = generateStaticRoutingRuleMatcher(staticRouting.asset_worker ?? []);
+				const includeRulesMatcher = generateStaticRoutingRuleMatcher(staticRouting.user_worker);
+				const userWorkerHandler = createRequestHandler(async (request$2) => {
+					request$2.headers.set(CoreHeaders.ROUTE_OVERRIDE, entryWorkerName);
+					return ctx.miniflare.dispatchFetch(request$2, { redirect: "manual" });
+				});
+				viteDevServer.middlewares.use(async function cloudflarePreMiddleware(req, res, next) {
+					assert2(req.url, `req.url not defined`);
+					const request$2 = new Request(new URL(req.url, UNKNOWN_HOST));
+					if (req[kRequestType] === "asset") next();
+					else if (excludeRulesMatcher({ request: request$2 })) {
+						req[kRequestType] = "asset";
+						next();
+					} else if (includeRulesMatcher({ request: request$2 })) userWorkerHandler(req, res, next);
+					else next();
+				});
+			}
+			if (containerOptionsByWorker.size) {
+				viteDevServer.config.logger.info(import_picocolors$2.default.dim(import_picocolors$2.default.yellow("∷ Building container images for local development...\n")));
+				await prepareContainerImagesForVite({
+					dockerPath: getDockerPath(),
+					containerOptionsByWorker,
+					logger: viteDevServer.config.logger
+				});
+				containerCleanup.track(getDockerPath(), [...containerOptionsByWorker.values()].flatMap((options) => options.map(({ image_tag }) => image_tag)));
+				viteDevServer.config.logger.info(import_picocolors$2.default.dim(import_picocolors$2.default.yellow("\n⚡️ Containers successfully built. To rebuild your containers during development, restart the Vite dev server (r + enter).")));
+			}
 		}
-	};
+		return () => {
+			if (!satisfiesMinimumViteVersion("7.0.0")) {
+				const middlewareStack = viteDevServer.middlewares.stack;
+				const preMiddlewareIndex = middlewareStack.findIndex((middleware) => "name" in middleware.handle && middleware.handle.name === "cloudflarePreMiddleware");
+				if (preMiddlewareIndex !== -1) {
+					const [preMiddleware] = middlewareStack.splice(preMiddlewareIndex, 1);
+					assert2(preMiddleware, "Failed to remove cloudflarePreMiddleware from stack");
+					const cachedTransformMiddlewareIndex = middlewareStack.findIndex((middleware) => "name" in middleware.handle && middleware.handle.name === "viteCachedTransformMiddleware");
+					assert2(cachedTransformMiddlewareIndex !== -1, "Failed to find viteCachedTransformMiddleware");
+					middlewareStack.splice(cachedTransformMiddlewareIndex, 0, preMiddleware);
+				}
+			}
+			viteDevServer.middlewares.use(createRequestHandler(async (request$2, req) => {
+				if (req[kRequestType] === "asset") {
+					request$2.headers.set(CoreHeaders.ROUTE_OVERRIDE, ASSET_WORKER_NAME);
+					return ctx.miniflare.dispatchFetch(request$2, { redirect: "manual" });
+				} else {
+					request$2.headers.set(CoreHeaders.ROUTE_OVERRIDE, ROUTER_WORKER_NAME);
+					return ctx.miniflare.dispatchFetch(request$2, { redirect: "manual" });
+				}
+			}));
+		};
+	} };
 });
 
 //#endregion
@@ -89908,16 +89956,16 @@ const nodeJsCompatPlugin = createPlugin("nodejs-compat", (ctx) => {
 		}
 	};
 });
-let exitCallback$1 = () => {};
+let exitCallback = () => {};
 process.on("exit", () => {
-	exitCallback$1();
+	exitCallback();
 });
 /**
 * Plugin to warn if Node.js APIs are used without enabling the `nodejs_compat` compatibility flag
 */
 const nodeJsCompatWarningsPlugin = createPlugin("nodejs-compat-warnings", (ctx) => {
 	const nodeJsCompatWarningsMap = /* @__PURE__ */ new Map();
-	exitCallback$1 = () => {
+	exitCallback = () => {
 		for (const nodeJsCompatWarnings of nodeJsCompatWarningsMap.values()) nodeJsCompatWarnings.renderWarnings();
 	};
 	return {
@@ -90116,21 +90164,23 @@ const triggerHandlersPlugin = createPlugin("trigger-handlers", (ctx) => {
 //#endregion
 //#region src/plugins/preview.ts
 var import_picocolors$1 = /* @__PURE__ */ __toESM$2(require_picocolors(), 1);
-let exitCallback = () => {};
-process.on("exit", () => {
-	exitCallback();
-});
 /**
 * Plugin to provide core preview functionality
 */
 const previewPlugin = createPlugin("preview", (ctx) => {
 	return { async configurePreviewServer(vitePreviewServer) {
 		assertIsPreview(ctx);
+		const dockerPath = getDockerPath();
+		const containerCleanup = createContainerCleanup();
 		const closePreviewServer = vitePreviewServer.close.bind(vitePreviewServer);
 		vitePreviewServer.close = async () => {
-			await Promise.all([ctx.disposeMiniflare(), closePreviewServer()]);
+			try {
+				await Promise.all([ctx.disposeMiniflare(), closePreviewServer()]);
+			} finally {
+				containerCleanup.cleanup();
+			}
 		};
-		const { miniflareOptions, containerTagToOptionsMap } = await getPreviewMiniflareOptions(ctx, vitePreviewServer);
+		const { miniflareOptions, containerOptionsByWorker } = await getPreviewMiniflareOptions(ctx, vitePreviewServer);
 		await ctx.startOrUpdateMiniflare(miniflareOptions);
 		if (vitePreviewServer.httpServer) vitePreviewServer.httpServer.on("listening", () => {
 			const addr = vitePreviewServer.httpServer?.address();
@@ -90143,19 +90193,15 @@ const previewPlugin = createPlugin("preview", (ctx) => {
 				});
 			}
 		});
-		if (containerTagToOptionsMap.size) {
-			const dockerPath = getDockerPath();
+		if (containerOptionsByWorker.size) {
 			vitePreviewServer.config.logger.info(import_picocolors$1.default.dim(import_picocolors$1.default.yellow("∷ Building container images for local preview...\n")));
 			await prepareContainerImagesForVite({
 				dockerPath,
-				containerTagToOptionsMap,
+				containerOptionsByWorker,
 				logger: vitePreviewServer.config.logger
 			});
-			const containerImageTags = new Set(containerTagToOptionsMap.keys());
+			containerCleanup.track(dockerPath, [...containerOptionsByWorker.values()].flatMap((options) => options.map(({ image_tag }) => image_tag)));
 			vitePreviewServer.config.logger.info(import_picocolors$1.default.dim(import_picocolors$1.default.yellow("\n⚡️ Containers successfully built.\n")));
-			exitCallback = () => {
-				if (containerImageTags.size) cleanupContainers(dockerPath, containerImageTags);
-			};
 		}
 		handleWebSocket(vitePreviewServer.httpServer, ctx.miniflare);
 		vitePreviewServer.middlewares.use(createRequestHandler((request$2) => {