@cloudflare/vite-plugin 1.14.1 → 1.15.0

package/dist/{index.d.ts → index.d.mts}

@@ -1,4 +1,5 @@
 import * as vite from "vite";
+import { Miniflare, Request, Response } from "miniflare";
 import "wrangler";
 
 //#region src/plugin-config.d.ts
@@ -40,4 +41,4 @@ interface PluginConfig extends EntryWorkerConfig {
 declare function cloudflare(pluginConfig?: PluginConfig): vite.Plugin[];
 //#endregion
 export { type PluginConfig, cloudflare };
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/plugin-config.ts","../src/index.ts"],"sourcesContent":[],"mappings":";;;;;;AAsBU,KAFE,YAAA,GAEc,OAAA,GAAA;EAIhB,IAAA,EAAA,MAAA;AAA0C,CAAA;AAII,UAR9C,gBAAA,CAYY;EAKL,eAAa,CAAA,EAAA;IACV,IAAA,CAAA,EAAA,MAAA;EACJ,CAAA;;UAfN,iBAAA,SAA0B,gBAaE,CAAA;EAAiB,UAAA,CAAA,EAAA,MAAA;;UAT7C,qBAAA,SAA8B;;ACQxC;UDJU,YAAA;;;;UAKO,YAAA,SAAqB;qBAClB;iBACJ;;;iBAGA;;;;;;AAxBhB;AAAsD;AAE5B;AAI0B;AAII;AASvC,iBCDD,UAAA,CDCc,YAAA,CAAA,ECDW,YDCX,CAAA,ECD+B,IAAA,CAAK,MDCpC,EAAA"}

package/dist/{index.js → index.mjs}

@@ -1,7 +1,8 @@
 import { builtinModules } from "node:module";
 import * as vite from "vite";
 import assert from "node:assert";
-import { CoreHeaders, Log, LogLevel, Miniflare, Request as Request$1, Response as Response$1, coupleWebSocket, getDefaultDevRegistryPath, getNodeCompat, kCurrentWorker, kUnsafeEphemeralUniqueKey } from "miniflare";
+import { CoreHeaders, Log, LogLevel, Miniflare, Request as Request$1, Response as Response$1, coupleWebSocket, getDefaultDevRegistryPath, getNodeCompat, kUnsafeEphemeralUniqueKey } from "miniflare";
+import { maybeStartOrUpdateRemoteProxySession, unstable_convertConfigBindingsToStartWorkerBindings, unstable_getDurableObjectClassNameToUseSQLiteMap, unstable_getMiniflareWorkerOptions, unstable_getVarsForDev, unstable_readConfig } from "wrangler";
 import * as path$2 from "node:path";
 import path, { relative } from "node:path";
 import * as util$1 from "node:util";
@@ -9,7 +10,6 @@ import { format, inspect } from "node:util";
 import { createHeaders, createRequest, sendResponse } from "@remix-run/node-fetch-server";
 import * as fs$1 from "node:fs";
 import fs, { readFileSync, realpathSync, statSync } from "node:fs";
-import { maybeStartOrUpdateRemoteProxySession, unstable_convertConfigBindingsToStartWorkerBindings, unstable_getMiniflareWorkerOptions, unstable_getVarsForDev, unstable_readConfig } from "wrangler";
 import { getCloudflarePreset } from "@cloudflare/unenv-preset";
 import { URL as URL$1, fileURLToPath, pathToFileURL } from "node:url";
 import process$1 from "node:process";
@@ -111,6 +111,83 @@ function toMiniflareRequest(request$1) {
 	});
 }
 
+//#endregion
+//#region src/export-types.ts
+function getWorkerNameToWorkerEntrypointExportsMap(workers) {
+	const workerNameToWorkerEntrypointExportsMap = new Map(workers.map((worker) => [worker.config.name, /* @__PURE__ */ new Set()]));
+	for (const worker of workers) for (const value of worker.config.services ?? []) if (value.entrypoint !== void 0 && value.entrypoint !== "default") workerNameToWorkerEntrypointExportsMap.get(value.service)?.add(value.entrypoint);
+	return workerNameToWorkerEntrypointExportsMap;
+}
+function getWorkerNameToDurableObjectExportsMap(workers) {
+	const workerNameToDurableObjectExportsMap = new Map(workers.map((worker) => [worker.config.name, new Set(unstable_getDurableObjectClassNameToUseSQLiteMap(worker.config.migrations).keys())]));
+	for (const worker of workers) for (const value of worker.config.durable_objects.bindings) if (value.script_name) workerNameToDurableObjectExportsMap.get(value.script_name)?.add(value.class_name);
+	else workerNameToDurableObjectExportsMap.get(worker.config.name)?.add(value.class_name);
+	return workerNameToDurableObjectExportsMap;
+}
+function getWorkerNameToWorkflowEntrypointExportsMap(workers) {
+	const workerNameToWorkflowEntrypointExportsMap = new Map(workers.map((worker) => [worker.config.name, /* @__PURE__ */ new Set()]));
+	for (const worker of workers) for (const value of worker.config.workflows) if (value.script_name) workerNameToWorkflowEntrypointExportsMap.get(value.script_name)?.add(value.class_name);
+	else workerNameToWorkflowEntrypointExportsMap.get(worker.config.name)?.add(value.class_name);
+	return workerNameToWorkflowEntrypointExportsMap;
+}
+/**
+* Derives initial export types for all Workers from the Worker config files and returns them in a Map
+*/
+function getInitialWorkerNameToExportTypesMap(resolvedPluginConfig) {
+	const workers = [...resolvedPluginConfig.environmentNameToWorkerMap.values()];
+	const workerNameToWorkerEntrypointExportsMap = getWorkerNameToWorkerEntrypointExportsMap(workers);
+	const workerNameToDurableObjectExportsMap = getWorkerNameToDurableObjectExportsMap(workers);
+	const workerNameToWorkflowEntrypointExportsMap = getWorkerNameToWorkflowEntrypointExportsMap(workers);
+	return new Map(workers.map((worker) => {
+		const workerEntrypointExports = workerNameToWorkerEntrypointExportsMap.get(worker.config.name);
+		assert(workerEntrypointExports, `WorkerEntrypoint exports not found for Worker "${worker.config.name}"`);
+		const durableObjectExports = workerNameToDurableObjectExportsMap.get(worker.config.name);
+		assert(durableObjectExports, `DurableObject exports not found for Worker "${worker.config.name}"`);
+		const workflowEntrypointExports = workerNameToWorkflowEntrypointExportsMap.get(worker.config.name);
+		assert(workflowEntrypointExports, `WorkflowEntrypoint exports not found for Worker "${worker.config.name}"`);
+		const exportTypes = {};
+		for (const exportName of workerEntrypointExports) exportTypes[exportName] = "WorkerEntrypoint";
+		for (const exportName of durableObjectExports) exportTypes[exportName] = "DurableObject";
+		for (const exportName of workflowEntrypointExports) exportTypes[exportName] = "WorkflowEntrypoint";
+		return [worker.config.name, exportTypes];
+	}));
+}
+/**
+* Fetches the export types for all Workers and returns them in a Map
+*/
+async function getCurrentWorkerNameToExportTypesMap(resolvedPluginConfig, viteDevServer, miniflare) {
+	const results = await Promise.all([...resolvedPluginConfig.environmentNameToWorkerMap].map(async ([environmentName, worker]) => {
+		debuglog(`Fetching export types for worker "${worker.config.name}"`);
+		const exportTypes = await viteDevServer.environments[environmentName].fetchWorkerExportTypes(miniflare, worker.config);
+		return [worker.config.name, exportTypes];
+	}));
+	return new Map(results);
+}
+/**
+* Compares the export types for all Workers and returns `true` if any have changed
+*/
+function compareWorkerNameToExportTypesMaps(oldWorkerNameToExportTypesMap, newWorkerNameToExportTypesMap) {
+	for (const workerName of newWorkerNameToExportTypesMap.keys()) {
+		const oldExportTypes = oldWorkerNameToExportTypesMap.get(workerName);
+		assert(oldExportTypes, "Expected old export types to be defined");
+		const newExportTypes = newWorkerNameToExportTypesMap.get(workerName);
+		assert(newExportTypes, "Expected new export types to be defined");
+		if (compareExportTypes(oldExportTypes, newExportTypes)) return true;
+	}
+	return false;
+}
+/**
+* Compares two `ExportTypes` objects and returns true if they do not match.
+* Checks for added/removed exports and changed export types.
+*/
+function compareExportTypes(oldExportTypes, newExportTypes) {
+	const oldKeys = Object.keys(oldExportTypes);
+	const newKeys = Object.keys(newExportTypes);
+	if (oldKeys.length !== newKeys.length) return true;
+	for (const key of newKeys) if (!(key in oldExportTypes) || oldExportTypes[key] !== newExportTypes[key]) return true;
+	return false;
+}
+
 //#endregion
 //#region src/context.ts
 /**
@@ -151,6 +228,16 @@ var PluginContext = class {
 		const miniflareInspectorUrl = await this.#sharedContext.miniflare.getInspectorURL();
 		return Number.parseInt(miniflareInspectorUrl.port);
 	}
+	setWorkerNameToExportTypesMap(workerNameToExportTypesMap) {
+		this.#sharedContext.workerNameToExportTypesMap = workerNameToExportTypesMap;
+	}
+	get workerNameToExportTypesMap() {
+		if (!this.#sharedContext.workerNameToExportTypesMap) {
+			if (this.resolvedPluginConfig.type !== "workers") return /* @__PURE__ */ new Map();
+			return getInitialWorkerNameToExportTypesMap(this.resolvedPluginConfig);
+		}
+		return this.#sharedContext.workerNameToExportTypesMap;
+	}
 	setHasShownWorkerConfigWarnings(hasShownWorkerConfigWarnings) {
 		this.#sharedContext.hasShownWorkerConfigWarnings = hasShownWorkerConfigWarnings;
 	}
@@ -178,14 +265,14 @@ var PluginContext = class {
 		return this.#resolvedViteConfig;
 	}
 	getWorkerConfig(environmentName) {
-		return this.resolvedPluginConfig.type === "workers" ? this.resolvedPluginConfig.workers[environmentName] : void 0;
+		return this.resolvedPluginConfig.type === "workers" ? this.resolvedPluginConfig.environmentNameToWorkerMap.get(environmentName)?.config : void 0;
 	}
 	get entryWorkerConfig() {
 		if (this.resolvedPluginConfig.type !== "workers") return;
-		return this.resolvedPluginConfig.workers[this.resolvedPluginConfig.entryWorkerEnvironmentName];
+		return this.resolvedPluginConfig.environmentNameToWorkerMap.get(this.resolvedPluginConfig.entryWorkerEnvironmentName)?.config;
 	}
 	getNodeJsCompat(environmentName) {
-		return this.resolvedPluginConfig.type === "workers" ? this.resolvedPluginConfig.nodeJsCompatMap.get(environmentName) : void 0;
+		return this.resolvedPluginConfig.type === "workers" ? this.resolvedPluginConfig.environmentNameToWorkerMap.get(environmentName)?.nodeJsCompat : void 0;
 	}
 };
 function assertIsNotPreview(ctx) {
@@ -297,7 +384,7 @@ function writeDeployConfig(resolvedPluginConfig, resolvedViteConfig) {
 	} else {
 		let entryWorkerConfigPath;
 		const auxiliaryWorkers = [];
-		for (const environmentName of Object.keys(resolvedPluginConfig.workers)) {
+		for (const environmentName of resolvedPluginConfig.environmentNameToWorkerMap.keys()) {
 			const outputDirectory = resolvedViteConfig.environments[environmentName]?.build.outDir;
 			assert(outputDirectory, `Unexpected error: ${environmentName} environment output directory is undefined`);
 			const configPath = getRelativePathToWorkerConfig(deployConfigDirectory, resolvedViteConfig.root, outputDirectory);
@@ -6877,9 +6964,6 @@ const allowedWranglerConfigExtensions = [
 
 //#endregion
 //#region src/plugin-config.ts
-function workerNameToEnvironmentName(workerName) {
-	return workerName.replaceAll("-", "_");
-}
 function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
 	const shared = {
 		persistState: pluginConfig.persistState ?? true,
@@ -6914,7 +6998,7 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
 	const entryWorkerEnvironmentName = pluginConfig.viteEnvironment?.name ?? workerNameToEnvironmentName(entryWorkerConfig.topLevelName);
 	let staticRouting;
 	if (Array.isArray(entryWorkerConfig.assets?.run_worker_first)) staticRouting = parseStaticRouting(entryWorkerConfig.assets.run_worker_first);
-	const workers = { [entryWorkerEnvironmentName]: entryWorkerConfig };
+	const environmentNameToWorkerMap = new Map([[entryWorkerEnvironmentName, resolveWorker(entryWorkerConfig)]]);
 	const auxiliaryWorkersResolvedConfigs = [];
 	for (const auxiliaryWorker of pluginConfig.auxiliaryWorkers ?? []) {
 		const workerResolvedConfig = getWorkerConfig(getValidatedWranglerConfigPath(root, auxiliaryWorker.configPath, true), cloudflareEnv, { visitedConfigPaths: configPaths });
@@ -6922,18 +7006,16 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
 		assert(workerResolvedConfig.type === "worker", "Unexpected error: received AssetsOnlyResult with auxiliary workers.");
 		const workerConfig = workerResolvedConfig.config;
 		const workerEnvironmentName = auxiliaryWorker.viteEnvironment?.name ?? workerNameToEnvironmentName(workerConfig.topLevelName);
-		if (workers[workerEnvironmentName]) throw new Error(`Duplicate Vite environment name found: ${workerEnvironmentName}`);
-		workers[workerEnvironmentName] = workerConfig;
+		if (environmentNameToWorkerMap.has(workerEnvironmentName)) throw new Error(`Duplicate Vite environment name found: ${workerEnvironmentName}`);
+		environmentNameToWorkerMap.set(workerEnvironmentName, resolveWorker(workerConfig));
 	}
-	const nodeJsCompatMap = new Map(Object.entries(workers).filter(([_, workerConfig]) => hasNodeJsCompat(workerConfig)).map(([environmentName, workerConfig]) => [environmentName, new NodeJsCompat(workerConfig)]));
 	return {
 		...shared,
 		type: "workers",
 		cloudflareEnv,
 		configPaths,
-		workers,
+		environmentNameToWorkerMap,
 		entryWorkerEnvironmentName,
-		nodeJsCompatMap,
 		staticRouting,
 		remoteBindings: pluginConfig.remoteBindings ?? true,
 		rawConfigs: {
@@ -6942,6 +7024,15 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
 		}
 	};
 }
+function workerNameToEnvironmentName(workerName) {
+	return workerName.replaceAll("-", "_");
+}
+function resolveWorker(workerConfig) {
+	return {
+		config: workerConfig,
+		nodeJsCompat: hasNodeJsCompat(workerConfig) ? new NodeJsCompat(workerConfig) : void 0
+	};
+}
 
 //#endregion
 //#region ../../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.0/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
@@ -13510,10 +13601,12 @@ function getHeadersConfigPath(config) {
 //#region src/shared.ts
 const UNKNOWN_HOST = "http://localhost";
 const INIT_PATH = "/__vite_plugin_cloudflare_init__";
+const GET_EXPORT_TYPES_PATH = "/__vite_plugin_cloudflare_get_export_types__";
 const WORKER_ENTRY_PATH_HEADER = "__VITE_WORKER_ENTRY_PATH__";
 const IS_ENTRY_WORKER_HEADER = "__VITE_IS_ENTRY_WORKER__";
 const virtualPrefix = "virtual:cloudflare/";
 const VIRTUAL_WORKER_ENTRY = `${virtualPrefix}worker-entry`;
+const VIRTUAL_EXPORT_TYPES = `${virtualPrefix}export-types`;
 
 //#endregion
 //#region src/plugins/virtual-modules.ts
@@ -13528,7 +13621,7 @@ const virtualModulesPlugin = createPlugin("virtual-modules", (ctx) => {
 			return ctx.getWorkerConfig(environment.name) !== void 0;
 		},
 		resolveId(source) {
-			if (source === VIRTUAL_WORKER_ENTRY) return `\0${VIRTUAL_WORKER_ENTRY}`;
+			if (source === VIRTUAL_WORKER_ENTRY || source === VIRTUAL_EXPORT_TYPES) return `\0${source}`;
 			if (source === VIRTUAL_USER_ENTRY) {
 				const workerConfig = ctx.getWorkerConfig(this.environment.name);
 				assert(workerConfig, "Expected `workerConfig` to be defined");
@@ -13540,14 +13633,56 @@ const virtualModulesPlugin = createPlugin("virtual-modules", (ctx) => {
 				const nodeJsCompat = ctx.getNodeJsCompat(this.environment.name);
 				return `
 ${nodeJsCompat ? nodeJsCompat.injectGlobalCode() : ""}
+import { getExportTypes } from "${VIRTUAL_EXPORT_TYPES}";
 import * as mod from "${VIRTUAL_USER_ENTRY}";
 export * from "${VIRTUAL_USER_ENTRY}";
 export default mod.default ?? {};
 if (import.meta.hot) {
-	import.meta.hot.accept();
+	import.meta.hot.accept((module) => {
+		const exportTypes = getExportTypes(module);
+		import.meta.hot.send("vite-plugin-cloudflare:worker-export-types", exportTypes);
+	});
 }
 				`;
 			}
+			if (id === `\0${VIRTUAL_EXPORT_TYPES}`) return `
+import {
+	WorkerEntrypoint,
+	DurableObject,
+	WorkflowEntrypoint,
+} from "cloudflare:workers";
+
+const baseClasses = new Map([
+	["WorkerEntrypoint", WorkerEntrypoint],
+	["DurableObject", DurableObject],
+	["WorkflowEntrypoint", WorkflowEntrypoint],
+]);
+
+export function getExportTypes(module) {
+	const exportTypes = {};
+
+	for (const [key, value] of Object.entries(module)) {
+		if (key === "default") {
+			continue;
+		}
+
+		let exportType
+
+		if (typeof value === "function") {
+			for (const [type, baseClass] of baseClasses) {
+				if (baseClass.prototype.isPrototypeOf(value.prototype)) {
+					exportType = type;
+					break;
+				}
+			}
+		}
+
+		exportTypes[key] = exportType;
+	}
+
+	return exportTypes;
+}
+				`;
 		}
 	};
 });
@@ -13583,7 +13718,7 @@ function createBuildApp(resolvedPluginConfig) {
 			else if (getHasPublicAssets(builder.config)) await fallbackBuild(builder, clientEnvironment);
 			return;
 		}
-		const workerEnvironments = Object.keys(resolvedPluginConfig.workers).map((environmentName) => {
+		const workerEnvironments = [...resolvedPluginConfig.environmentNameToWorkerMap.keys()].map((environmentName) => {
 			const environment = builder.environments[environmentName];
 			assert(environment, `"${environmentName}" environment not found`);
 			return environment;
@@ -13711,6 +13846,10 @@ var CloudflareDevEnvironment = class extends vite.DevEnvironment {
 		webSocket.accept();
 		this.#webSocketContainer.webSocket = webSocket;
 	}
+	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,
@@ -13809,10 +13948,10 @@ function getProcessEnvReplacements(hasNodeJsCompat$1, mode) {
 	};
 }
 function initRunners(resolvedPluginConfig, viteDevServer, miniflare) {
-	return Promise.all(Object.entries(resolvedPluginConfig.workers).map(async ([environmentName, workerConfig]) => {
-		debuglog("Initializing worker:", workerConfig.name);
+	return Promise.all([...resolvedPluginConfig.environmentNameToWorkerMap].map(([environmentName, worker]) => {
+		debuglog("Initializing worker:", worker.config.name);
 		const isEntryWorker = environmentName === resolvedPluginConfig.entryWorkerEnvironmentName;
-		return viteDevServer.environments[environmentName].initRunner(miniflare, workerConfig, isEntryWorker);
+		return viteDevServer.environments[environmentName].initRunner(miniflare, worker.config, isEntryWorker);
 	}));
 }
 
@@ -13850,9 +13989,8 @@ function hasLocalDevVarsFileChanged({ configPaths, cloudflareEnv }, changedFileP
 * Throws an error if Worker environments include configuration options that are incompatible with the plugin.
 */
 function validateWorkerEnvironmentOptions(resolvedPluginConfig, resolvedViteConfig) {
-	const workerEnvironmentNames = Object.keys(resolvedPluginConfig.workers);
 	const disallowedEnvironmentOptionsMap = /* @__PURE__ */ new Map();
-	for (const environmentName of workerEnvironmentNames) {
+	for (const environmentName of resolvedPluginConfig.environmentNameToWorkerMap.keys()) {
 		const environmentOptions = resolvedViteConfig.environments[environmentName];
 		assert(environmentOptions, `Missing environment config for "${environmentName}"`);
 		const { resolve: resolve$1 } = environmentOptions;
@@ -13893,9 +14031,9 @@ const configPlugin = createPlugin("config", (ctx) => {
 					".dev.vars.*"
 				] } },
 				environments: ctx.resolvedPluginConfig.type === "workers" ? {
-					...Object.fromEntries(Object.entries(ctx.resolvedPluginConfig.workers).map(([environmentName, workerConfig]) => {
+					...Object.fromEntries([...ctx.resolvedPluginConfig.environmentNameToWorkerMap].map(([environmentName, worker]) => {
 						return [environmentName, createCloudflareEnvironmentOptions({
-							workerConfig,
+							workerConfig: worker.config,
 							userConfig,
 							mode: env.mode,
 							environmentName,
@@ -14012,7 +14150,7 @@ const debugPlugin = createPlugin("debug", (ctx) => {
 			assertIsNotPreview(ctx);
 			if (!!process.env.VSCODE_INSPECTOR_OPTIONS) return;
 			if (ctx.resolvedPluginConfig.type === "workers" && ctx.resolvedPluginConfig.inspectorPort !== false) addDebugToVitePrintUrls(viteDevServer);
-			const workerNames = ctx.resolvedPluginConfig.type === "workers" ? Object.values(ctx.resolvedPluginConfig.workers).map((worker) => worker.name) : [];
+			const workerNames = ctx.resolvedPluginConfig.type === "workers" ? [...ctx.resolvedPluginConfig.environmentNameToWorkerMap.values()].map((worker) => worker.config.name) : [];
 			viteDevServer.middlewares.use(DEBUG_PATH, async (_, res, next) => {
 				const resolvedInspectorPort = await ctx.getResolvedInspectorPort();
 				if (resolvedInspectorPort) {
@@ -15232,48 +15370,6 @@ function getPersistenceRoot(root, persistState) {
 	if (persistState === false) return;
 	return path$2.resolve(root, typeof persistState === "object" ? persistState.path : ".wrangler/state", "v3");
 }
-function missingWorkerErrorMessage(workerName) {
-	return `${workerName} does not match a worker name.`;
-}
-function getWorkerToWorkerEntrypointNamesMap(workers) {
-	const workerToWorkerEntrypointNamesMap = new Map(workers.map((workerOptions) => [workerOptions.name, /* @__PURE__ */ new Set()]));
-	for (const worker of workers) for (const value of Object.values(worker.serviceBindings ?? {})) if (typeof value === "object" && "name" in value && value.entrypoint !== void 0 && value.entrypoint !== "default") {
-		const targetWorkerName = value.name === kCurrentWorker ? worker.name : value.name;
-		const entrypointNames = workerToWorkerEntrypointNamesMap.get(targetWorkerName);
-		if (entrypointNames) entrypointNames.add(value.entrypoint);
-	}
-	return workerToWorkerEntrypointNamesMap;
-}
-function getWorkerToDurableObjectClassNamesMap(workers) {
-	const workerToDurableObjectClassNamesMap = new Map(workers.map((workerOptions) => [workerOptions.name, /* @__PURE__ */ new Set()]));
-	for (const worker of workers) for (const value of Object.values(worker.durableObjects ?? {})) if (typeof value === "string") {
-		const classNames = workerToDurableObjectClassNamesMap.get(worker.name);
-		assert(classNames, missingWorkerErrorMessage(worker.name));
-		classNames.add(value);
-	} else if (typeof value === "object") if (value.scriptName) {
-		const classNames = workerToDurableObjectClassNamesMap.get(value.scriptName);
-		assert(classNames, missingWorkerErrorMessage(value.scriptName));
-		classNames.add(value.className);
-	} else {
-		const classNames = workerToDurableObjectClassNamesMap.get(worker.name);
-		assert(classNames, missingWorkerErrorMessage(worker.name));
-		classNames.add(value.className);
-	}
-	return workerToDurableObjectClassNamesMap;
-}
-function getWorkerToWorkflowEntrypointClassNamesMap(workers) {
-	const workerToWorkflowEntrypointClassNamesMap = new Map(workers.map((workerOptions) => [workerOptions.name, /* @__PURE__ */ new Set()]));
-	for (const worker of workers) for (const value of Object.values(worker.workflows ?? {})) if (value.scriptName) {
-		const classNames = workerToWorkflowEntrypointClassNamesMap.get(value.scriptName);
-		assert(classNames, missingWorkerErrorMessage(value.scriptName));
-		classNames.add(value.className);
-	} else {
-		const classNames = workerToWorkflowEntrypointClassNamesMap.get(worker.name);
-		assert(classNames, missingWorkerErrorMessage(worker.name));
-		classNames.add(value.className);
-	}
-	return workerToWorkflowEntrypointClassNamesMap;
-}
 const miniflareModulesRoot = process.platform === "win32" ? "Z:\\" : "/";
 const ROUTER_WORKER_PATH = "./workers/router-worker.js";
 const ASSET_WORKER_PATH = "./workers/asset-worker.js";
@@ -15371,28 +15467,28 @@ async function getDevMiniflareOptions(ctx, viteDevServer) {
 		}
 	];
 	const containerTagToOptionsMap = /* @__PURE__ */ new Map();
-	const workersFromConfig = resolvedPluginConfig.type === "workers" ? await Promise.all(Object.entries(resolvedPluginConfig.workers).map(async ([environmentName, workerConfig]) => {
-		const bindings = unstable_convertConfigBindingsToStartWorkerBindings(workerConfig);
-		const preExistingRemoteProxySession = workerConfig.configPath ? remoteProxySessionsDataMap.get(workerConfig.configPath) : void 0;
+	const workersFromConfig = resolvedPluginConfig.type === "workers" ? await Promise.all([...resolvedPluginConfig.environmentNameToWorkerMap].map(async ([environmentName, worker]) => {
+		const bindings = unstable_convertConfigBindingsToStartWorkerBindings(worker.config);
+		const preExistingRemoteProxySession = worker.config.configPath ? remoteProxySessionsDataMap.get(worker.config.configPath) : void 0;
 		const remoteProxySessionData = !resolvedPluginConfig.remoteBindings ? null : await maybeStartOrUpdateRemoteProxySession({
-			name: workerConfig.name,
+			name: worker.config.name,
 			bindings: bindings ?? {}
 		}, preExistingRemoteProxySession ?? null);
-		if (workerConfig.configPath && remoteProxySessionData) remoteProxySessionsDataMap.set(workerConfig.configPath, remoteProxySessionData);
+		if (worker.config.configPath && remoteProxySessionData) remoteProxySessionsDataMap.set(worker.config.configPath, remoteProxySessionData);
 		let containerBuildId;
-		if (workerConfig.containers?.length && workerConfig.dev.enable_containers) {
+		if (worker.config.containers?.length && worker.config.dev.enable_containers) {
 			const dockerPath = getDockerPath();
-			workerConfig.dev.container_engine = resolveDockerHost(dockerPath);
+			worker.config.dev.container_engine = resolveDockerHost(dockerPath);
 			containerBuildId = generateContainerBuildId();
 			const options = getContainerOptions({
-				containersConfig: workerConfig.containers,
+				containersConfig: worker.config.containers,
 				containerBuildId,
-				configPath: workerConfig.configPath
+				configPath: worker.config.configPath
 			});
 			for (const option of options ?? []) containerTagToOptionsMap.set(option.image_tag, option);
 		}
 		const miniflareWorkerOptions = unstable_getMiniflareWorkerOptions({
-			...workerConfig,
+			...worker.config,
 			assets: void 0
 		}, resolvedPluginConfig.cloudflareEnv, {
 			remoteProxyConnectionString: remoteProxySessionData?.session?.remoteProxyConnectionString,
@@ -15404,7 +15500,7 @@ async function getDevMiniflareOptions(ctx, viteDevServer) {
 			externalWorkers: externalWorkers$1,
 			worker: {
 				...workerOptions,
-				name: workerOptions.name ?? workerConfig.name,
+				name: workerOptions.name ?? worker.config.name,
 				unsafeInspectorProxy: inputInspectorPort !== false,
 				unsafeDirectSockets: environmentName === resolvedPluginConfig.entryWorkerEnvironmentName ? [{
 					serviceName: VITE_PROXY_WORKER_NAME,
@@ -15415,7 +15511,7 @@ async function getDevMiniflareOptions(ctx, viteDevServer) {
 				unsafeEvalBinding: "__VITE_UNSAFE_EVAL__",
 				serviceBindings: {
 					...workerOptions.serviceBindings,
-					...environmentName === resolvedPluginConfig.entryWorkerEnvironmentName && workerConfig.assets?.binding ? { [workerConfig.assets.binding]: { node: (req, res) => {
+					...environmentName === resolvedPluginConfig.entryWorkerEnvironmentName && worker.config.assets?.binding ? { [worker.config.assets.binding]: { node: (req, res) => {
 						req[kRequestType] = "asset";
 						viteDevServer.middlewares(req, res);
 					} } } : {},
@@ -15430,9 +15526,6 @@ async function getDevMiniflareOptions(ctx, viteDevServer) {
 	})) : [];
 	const userWorkers = workersFromConfig.map((options) => options.worker);
 	const externalWorkers = workersFromConfig.flatMap((options) => options.externalWorkers);
-	const workerToWorkerEntrypointNamesMap = getWorkerToWorkerEntrypointNamesMap(userWorkers);
-	const workerToDurableObjectClassNamesMap = getWorkerToDurableObjectClassNamesMap(userWorkers);
-	const workerToWorkflowEntrypointClassNamesMap = getWorkerToWorkflowEntrypointClassNamesMap(userWorkers);
 	const logger = new ViteMiniflareLogger(resolvedViteConfig);
 	return {
 		miniflareOptions: {
@@ -15448,19 +15541,13 @@ async function getDevMiniflareOptions(ctx, viteDevServer) {
 				...externalWorkers,
 				...userWorkers.map((workerOptions) => {
 					const wrappers = [
-						`import { createWorkerEntrypointWrapper, createDurableObjectWrapper, createWorkflowEntrypointWrapper } from '${RUNNER_PATH}';`,
-						`export { __VITE_RUNNER_OBJECT__ } from '${RUNNER_PATH}';`,
-						`export default createWorkerEntrypointWrapper('default');`
+						`import { createWorkerEntrypointWrapper, createDurableObjectWrapper, createWorkflowEntrypointWrapper } from "${RUNNER_PATH}";`,
+						`export { __VITE_RUNNER_OBJECT__ } from "${RUNNER_PATH}";`,
+						`export default createWorkerEntrypointWrapper("default");`
 					];
-					const workerEntrypointNames = workerToWorkerEntrypointNamesMap.get(workerOptions.name);
-					assert(workerEntrypointNames, `WorkerEntrypoint names not found for worker ${workerOptions.name}`);
-					for (const entrypointName of [...workerEntrypointNames].sort()) wrappers.push(`export const ${entrypointName} = createWorkerEntrypointWrapper('${entrypointName}');`);
-					const durableObjectClassNames = workerToDurableObjectClassNamesMap.get(workerOptions.name);
-					assert(durableObjectClassNames, `DurableObject class names not found for worker ${workerOptions.name}`);
-					for (const className of [...durableObjectClassNames].sort()) wrappers.push(`export const ${className} = createDurableObjectWrapper('${className}');`);
-					const workflowEntrypointClassNames = workerToWorkflowEntrypointClassNamesMap.get(workerOptions.name);
-					assert(workflowEntrypointClassNames, `WorkflowEntrypoint class names not found for worker: ${workerOptions.name}`);
-					for (const className of [...workflowEntrypointClassNames].sort()) wrappers.push(`export const ${className} = createWorkflowEntrypointWrapper('${className}');`);
+					const exportTypes = ctx.workerNameToExportTypesMap.get(workerOptions.name);
+					assert(exportTypes, `Expected exportTypes to be defined`);
+					for (const [name, type] of Object.entries(exportTypes)) wrappers.push(`export const ${name} = create${type}Wrapper("${name}");`);
 					logUnknownTails(workerOptions.tails, userWorkers, viteDevServer.config.logger.warn);
 					return {
 						...workerOptions,
@@ -15656,6 +15743,10 @@ function handleWebSocket(httpServer, miniflare, entryWorkerName) {
 
 //#endregion
 //#region src/plugins/dev.ts
+let exitCallback$2 = () => {};
+process.on("exit", () => {
+	exitCallback$2();
+});
 /**
 * Plugin to provide core development functionality
 */
@@ -15673,14 +15764,37 @@ const devPlugin = createPlugin("dev", (ctx) => {
 		},
 		async configureServer(viteDevServer) {
 			assertIsNotPreview(ctx);
-			const { miniflareOptions, containerTagToOptionsMap } = await getDevMiniflareOptions(ctx, viteDevServer);
-			await ctx.startOrUpdateMiniflare(miniflareOptions);
+			const initialOptions = await getDevMiniflareOptions(ctx, viteDevServer);
+			let containerTagToOptionsMap = initialOptions.containerTagToOptionsMap;
+			await ctx.startOrUpdateMiniflare(initialOptions.miniflareOptions);
 			let preMiddleware;
 			if (ctx.resolvedPluginConfig.type === "workers") {
-				const entryWorkerConfig = ctx.entryWorkerConfig;
-				assert(entryWorkerConfig, `No entry Worker config`);
 				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);
+					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];
+					assert(environment, `Expected environment "${environmentName}" to be defined`);
+					environment.hot.on("vite-plugin-cloudflare:worker-export-types", async (newExportTypes) => {
+						const workerConfig = ctx.getWorkerConfig(environmentName);
+						assert(workerConfig, `Expected workerConfig for environment "${environmentName}" to be defined`);
+						const oldExportTypes = ctx.workerNameToExportTypesMap.get(workerConfig.name);
+						assert(oldExportTypes, `Expected export types for Worker "${workerConfig.name}" to be defined`);
+						if (compareExportTypes(oldExportTypes, newExportTypes)) {
+							viteDevServer.config.logger.info(colors.dim(colors.yellow("Worker exports have changed. Restarting dev server.")));
+							await viteDevServer.restart();
+						}
+					});
+				}
+				const entryWorkerConfig = ctx.entryWorkerConfig;
+				assert(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;
@@ -15696,7 +15810,7 @@ const devPlugin = createPlugin("dev", (ctx) => {
 						const request$1 = new Request(new URL(req.url, UNKNOWN_HOST));
 						if (req[kRequestType] === "asset") next();
 						else if (excludeRulesMatcher({ request: request$1 })) {
-							req[kRequestType];
+							req[kRequestType] = "asset";
 							next();
 						} else if (includeRulesMatcher({ request: request$1 })) userWorkerHandler(req, res, next);
 						else next();
@@ -15712,9 +15826,9 @@ const devPlugin = createPlugin("dev", (ctx) => {
 					});
 					containerImageTags = new Set(containerTagToOptionsMap.keys());
 					viteDevServer.config.logger.info(colors.dim(colors.yellow("\n⚡️ Containers successfully built. To rebuild your containers during development, restart the Vite dev server (r + enter).")));
-					process.on("exit", async () => {
-						if (containerTagToOptionsMap.size) cleanupContainers(getDockerPath(), containerImageTags);
-					});
+					exitCallback$2 = () => {
+						if (containerImageTags.size) cleanupContainers(getDockerPath(), containerImageTags);
+					};
 				}
 			}
 			return () => {
@@ -15802,11 +15916,18 @@ const nodeJsCompatPlugin = createPlugin("nodejs-compat", (ctx) => {
 		}
 	};
 });
+let exitCallback$1 = () => {};
+process.on("exit", () => {
+	exitCallback$1();
+});
 /**
 * 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 = () => {
+		for (const nodeJsCompatWarnings of nodeJsCompatWarningsMap.values()) nodeJsCompatWarnings.renderWarnings();
+	};
 	return {
 		enforce: "pre",
 		configEnvironment(environmentName) {
@@ -15862,7 +15983,7 @@ const outputConfigPlugin = createPlugin("output-config", (ctx) => {
 			assertIsNotPreview(ctx);
 			let outputConfig;
 			if (ctx.resolvedPluginConfig.type === "workers") {
-				const inputConfig = ctx.resolvedPluginConfig.workers[this.environment.name];
+				const inputConfig = ctx.getWorkerConfig(this.environment.name);
 				if (!inputConfig) 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}"`);
@@ -15925,6 +16046,10 @@ function getAssetsDirectory(workerOutputDirectory, resolvedViteConfig) {
 
 //#endregion
 //#region src/plugins/preview.ts
+let exitCallback = () => {};
+process.on("exit", () => {
+	exitCallback();
+});
 /**
 * Plugin to provide core preview functionality
 */
@@ -15944,9 +16069,9 @@ const previewPlugin = createPlugin("preview", (ctx) => {
 			});
 			const containerImageTags = new Set(containerTagToOptionsMap.keys());
 			vitePreviewServer.config.logger.info(colors.dim(colors.yellow("\n⚡️ Containers successfully built.\n")));
-			process.on("exit", () => {
+			exitCallback = () => {
 				if (containerImageTags.size) cleanupContainers(dockerPath, containerImageTags);
-			});
+			};
 		}
 		handleWebSocket(vitePreviewServer.httpServer, ctx.miniflare);
 		vitePreviewServer.middlewares.use(createRequestHandler((request$1) => {
@@ -16053,4 +16178,4 @@ function cloudflare(pluginConfig = {}) {
 
 //#endregion
 export { cloudflare };
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.mjs.map