@cloudflare/vite-plugin 1.29.0 → 1.30.0

package/dist/{package-B8LLjfje.mjs → package--uDsBjBd.mjs}

@@ -1,35 +1,35 @@
 //#region package.json
 var package_default = {
 	name: "@cloudflare/vite-plugin",
-	version: "1.29.0",
+	version: "1.30.0",
 	description: "Cloudflare plugin for Vite",
 	keywords: [
 		"cloudflare",
-		"workers",
 		"cloudflare-workers",
 		"vite",
-		"vite-plugin"
+		"vite-plugin",
+		"workers"
 	],
 	homepage: "https://github.com/cloudflare/workers-sdk/tree/main/packages/vite-plugin-cloudflare#readme",
 	bugs: { "url": "https://github.com/cloudflare/workers-sdk/issues" },
+	license: "MIT",
 	repository: {
 		"type": "git",
 		"url": "https://github.com/cloudflare/workers-sdk.git",
 		"directory": "packages/vite-plugin-cloudflare"
 	},
-	license: "MIT",
-	sideEffects: false,
+	files: ["dist"],
 	type: "module",
+	sideEffects: false,
+	main: "./dist/index.mjs",
+	types: "./dist/index.d.mts",
 	exports: { ".": {
 		"types": "./dist/index.d.mts",
 		"import": "./dist/index.mjs"
 	} },
-	main: "./dist/index.mjs",
-	types: "./dist/index.d.mts",
-	files: ["dist"],
+	publishConfig: { "access": "public" },
 	scripts: {
 		"build": "tsdown",
-		"check:lint": "eslint . --max-warnings=0 --cache",
 		"check:type": "tsc --build",
 		"dev": "tsdown --watch",
 		"test": "vitest run",
@@ -66,16 +66,16 @@ var package_default = {
 		"tsdown": "0.16.3",
 		"typescript": "catalog:default",
 		"vite": "catalog:vite-plugin",
+		"vite-legacy": "npm:vite@7.1.12",
 		"vitest": "catalog:vitest-3"
 	},
 	peerDependencies: {
 		"vite": "^6.1.0 || ^7.0.0 || ^8.0.0",
 		"wrangler": "workspace:^"
 	},
-	publishConfig: { "access": "public" },
 	"workers-sdk": { "prerelease": true }
 };
 
 //#endregion
 export { package_default as default };
-//# sourceMappingURL=package-B8LLjfje.mjs.map
+//# sourceMappingURL=package--uDsBjBd.mjs.map

package/dist/package--uDsBjBd.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"package--uDsBjBd.mjs","names":[],"sources":["../package.json"],"sourcesContent":["{\n\t\"name\": \"@cloudflare/vite-plugin\",\n\t\"version\": \"1.30.0\",\n\t\"description\": \"Cloudflare plugin for Vite\",\n\t\"keywords\": [\n\t\t\"cloudflare\",\n\t\t\"cloudflare-workers\",\n\t\t\"vite\",\n\t\t\"vite-plugin\",\n\t\t\"workers\"\n\t],\n\t\"homepage\": \"https://github.com/cloudflare/workers-sdk/tree/main/packages/vite-plugin-cloudflare#readme\",\n\t\"bugs\": {\n\t\t\"url\": \"https://github.com/cloudflare/workers-sdk/issues\"\n\t},\n\t\"license\": \"MIT\",\n\t\"repository\": {\n\t\t\"type\": \"git\",\n\t\t\"url\": \"https://github.com/cloudflare/workers-sdk.git\",\n\t\t\"directory\": \"packages/vite-plugin-cloudflare\"\n\t},\n\t\"files\": [\n\t\t\"dist\"\n\t],\n\t\"type\": \"module\",\n\t\"sideEffects\": false,\n\t\"main\": \"./dist/index.mjs\",\n\t\"types\": \"./dist/index.d.mts\",\n\t\"exports\": {\n\t\t\".\": {\n\t\t\t\"types\": \"./dist/index.d.mts\",\n\t\t\t\"import\": \"./dist/index.mjs\"\n\t\t}\n\t},\n\t\"publishConfig\": {\n\t\t\"access\": \"public\"\n\t},\n\t\"scripts\": {\n\t\t\"build\": \"tsdown\",\n\t\t\"check:type\": \"tsc --build\",\n\t\t\"dev\": \"tsdown --watch\",\n\t\t\"test\": \"vitest run\",\n\t\t\"test:ci\": \"pnpm test\",\n\t\t\"test:e2e\": \"vitest run -c e2e/vitest.config.ts\",\n\t\t\"test:watch\": \"vitest\"\n\t},\n\t\"dependencies\": {\n\t\t\"@cloudflare/unenv-preset\": \"workspace:*\",\n\t\t\"miniflare\": \"workspace:*\",\n\t\t\"unenv\": \"2.0.0-rc.24\",\n\t\t\"wrangler\": \"workspace:*\",\n\t\t\"ws\": \"catalog:default\"\n\t},\n\t\"devDependencies\": {\n\t\t\"@cloudflare/containers-shared\": \"workspace:*\",\n\t\t\"@cloudflare/mock-npm-registry\": \"workspace:*\",\n\t\t\"@cloudflare/workers-shared\": \"workspace:*\",\n\t\t\"@cloudflare/workers-tsconfig\": \"workspace:*\",\n\t\t\"@cloudflare/workers-types\": \"catalog:default\",\n\t\t\"@cloudflare/workers-utils\": \"workspace:*\",\n\t\t\"@remix-run/node-fetch-server\": \"^0.8.0\",\n\t\t\"@types/node\": \"catalog:vite-plugin\",\n\t\t\"@types/semver\": \"^7.5.1\",\n\t\t\"@types/ws\": \"^8.5.13\",\n\t\t\"defu\": \"^6.1.4\",\n\t\t\"get-port\": \"^7.1.0\",\n\t\t\"magic-string\": \"^0.30.12\",\n\t\t\"mlly\": \"^1.7.4\",\n\t\t\"picocolors\": \"^1.1.1\",\n\t\t\"semver\": \"^7.7.1\",\n\t\t\"tinyglobby\": \"^0.2.12\",\n\t\t\"tree-kill\": \"catalog:default\",\n\t\t\"tsdown\": \"0.16.3\",\n\t\t\"typescript\": \"catalog:default\",\n\t\t\"vite\": \"catalog:vite-plugin\",\n\t\t\"vite-legacy\": \"npm:vite@7.1.12\",\n\t\t\"vitest\": \"catalog:vitest-3\"\n\t},\n\t\"peerDependencies\": {\n\t\t\"vite\": \"^6.1.0 || ^7.0.0 || ^8.0.0\",\n\t\t\"wrangler\": \"workspace:^\"\n\t},\n\t\"workers-sdk\": {\n\t\t\"prerelease\": true\n\t}\n}\n"],"mappings":";sBAAA;OACS;UACG;cACI;WACH;EACX;EACA;EACA;EACA;EACA;EACA;WACW;OACJ,EACP,OAAO,oDACP;UACU;aACG;EACb,QAAQ;EACR,OAAO;EACP,aAAa;EACb;QACQ,CACR,OACA;OACO;cACO;OACP;QACC;UACE,EACV,KAAK;EACJ,SAAS;EACT,UAAU;EACV,EACD;gBACgB,EAChB,UAAU,UACV;UACU;EACV,SAAS;EACT,cAAc;EACd,OAAO;EACP,QAAQ;EACR,WAAW;EACX,YAAY;EACZ,cAAc;EACd;eACe;EACf,4BAA4B;EAC5B,aAAa;EACb,SAAS;EACT,YAAY;EACZ,MAAM;EACN;kBACkB;EAClB,iCAAiC;EACjC,iCAAiC;EACjC,8BAA8B;EAC9B,gCAAgC;EAChC,6BAA6B;EAC7B,6BAA6B;EAC7B,gCAAgC;EAChC,eAAe;EACf,iBAAiB;EACjB,aAAa;EACb,QAAQ;EACR,YAAY;EACZ,gBAAgB;EAChB,QAAQ;EACR,cAAc;EACd,UAAU;EACV,cAAc;EACd,aAAa;EACb,UAAU;EACV,cAAc;EACd,QAAQ;EACR,eAAe;EACf,UAAU;EACV;mBACmB;EACnB,QAAQ;EACR,YAAY;EACZ;CACD,eAAe,EACd,cAAc,MACd;CACD"}

package/dist/workers/runner-worker/index.js

@@ -0,0 +1,471 @@
+import { DurableObject, WorkerEntrypoint, WorkflowEntrypoint } from "cloudflare:workers";
+import { ModuleRunner, ssrModuleExportsKey } from "vite/module-runner";
+
+//#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 ENVIRONMENT_NAME_HEADER = "__VITE_ENVIRONMENT_NAME__";
+const IS_PARENT_ENVIRONMENT_HEADER = "__VITE_IS_PARENT_ENVIRONMENT__";
+const virtualPrefix = "virtual:cloudflare/";
+const VIRTUAL_WORKER_ENTRY = `${virtualPrefix}worker-entry`;
+const VIRTUAL_EXPORT_TYPES = `${virtualPrefix}export-types`;
+
+//#endregion
+//#region src/workers/runner-worker/env.ts
+/**
+* Strips internal properties from the `env` object, returning only the user-defined properties.
+* @param internalEnv - The full wrapper env, including internal properties
+* @returns The user-defined env
+*/
+function stripInternalEnv(internalEnv) {
+	const { __VITE_RUNNER_OBJECT__: __VITE_RUNNER_OBJECT__$1, __VITE_INVOKE_MODULE__, __VITE_UNSAFE_EVAL__,...userEnv } = internalEnv;
+	return userEnv;
+}
+
+//#endregion
+//#region src/workers/runner-worker/errors.ts
+/**
+* Converts an error to an object that can be be serialized and revived by Miniflare.
+* Copied from `packages/wrangler/templates/middleware/middleware-miniflare3-json-error.ts`
+*/
+function reduceError(e) {
+	return {
+		name: e?.name,
+		message: e?.message ?? String(e),
+		stack: e?.stack,
+		cause: e?.cause === void 0 ? void 0 : reduceError(e.cause)
+	};
+}
+/**
+* Captures errors in the `fetch` handler of the default export of the entry Worker.
+* These are returned as a JSON response that is revived by Miniflare.
+* See comment in `/packages/wrangler/src/deployment-bundle/bundle.ts` for more info.
+*/
+async function maybeCaptureError(options, fn) {
+	if (!options.isEntryWorker || options.exportName !== "default" || options.key !== "fetch") return fn();
+	try {
+		return await fn();
+	} catch (error) {
+		return Response.json(reduceError(error), {
+			status: 500,
+			headers: { "MF-Experimental-Error-Stack": "true" }
+		});
+	}
+}
+
+//#endregion
+//#region src/workers/runner-worker/keys.ts
+/** Keys that should be ignored during RPC property access */
+const IGNORED_KEYS = ["self"];
+/** Available methods for `WorkerEntrypoint` class */
+const WORKER_ENTRYPOINT_KEYS = [
+	"email",
+	"fetch",
+	"queue",
+	"tail",
+	"tailStream",
+	"test",
+	"trace",
+	"scheduled"
+];
+/** Available methods for `DurableObject` class */
+const DURABLE_OBJECT_KEYS = [
+	"alarm",
+	"fetch",
+	"webSocketClose",
+	"webSocketError",
+	"webSocketMessage"
+];
+/** Available methods for `WorkflowEntrypoint` classes */
+const WORKFLOW_ENTRYPOINT_KEYS = ["run"];
+
+//#endregion
+//#region src/workers/runner-worker/module-runner.ts
+/**
+* Custom `ModuleRunner`.
+* The `cachedModule` method is overridden to ensure compatibility with the Workers runtime.
+*/
+var CustomModuleRunner = class extends ModuleRunner {
+	#env;
+	#environmentName;
+	constructor(options, evaluator, env, environmentName) {
+		super(options, evaluator);
+		this.#env = env;
+		this.#environmentName = environmentName;
+	}
+	async cachedModule(url, importer) {
+		const moduleId = await this.#env.__VITE_RUNNER_OBJECT__.get("singleton").getFetchedModuleId(this.#environmentName, url, importer);
+		const module = this.evaluatedModules.getModuleById(moduleId);
+		if (!module) throw new Error(`Module "${moduleId}" is undefined`);
+		return module;
+	}
+};
+/** Module runner instances keyed by environment name */
+const moduleRunners = /* @__PURE__ */ new Map();
+/** The parent environment name (set explicitly via IS_PARENT_ENVIRONMENT_HEADER) */
+let parentEnvironmentName;
+/**
+* Durable Object that creates the module runner and handles WebSocket communication with the Vite dev server.
+*/
+var __VITE_RUNNER_OBJECT__ = class extends DurableObject {
+	/** Per-environment state containing WebSocket and concurrent module node promises */
+	#environments = /* @__PURE__ */ new Map();
+	/**
+	* Handles fetch requests to initialize a module runner for an environment.
+	* Creates a WebSocket pair for communication with the Vite dev server and initializes the ModuleRunner.
+	* @param request - The incoming fetch request
+	* @returns Response with WebSocket
+	* @throws Error if the path is invalid or the module runner is already initialized
+	*/
+	async fetch(request) {
+		const { pathname } = new URL(request.url);
+		if (pathname !== INIT_PATH) throw new Error(`__VITE_RUNNER_OBJECT__ received invalid pathname: "${pathname}"`);
+		const environmentName = request.headers.get(ENVIRONMENT_NAME_HEADER);
+		if (!environmentName) throw new Error(`__VITE_RUNNER_OBJECT__ received request without "${ENVIRONMENT_NAME_HEADER}" header`);
+		if (moduleRunners.has(environmentName)) throw new Error(`Module runner already initialized for environment: "${environmentName}"`);
+		if (request.headers.get(IS_PARENT_ENVIRONMENT_HEADER) === "true") parentEnvironmentName = environmentName;
+		const { 0: client, 1: server } = new WebSocketPair();
+		server.accept();
+		const environmentState = {
+			webSocket: server,
+			concurrentModuleNodePromises: /* @__PURE__ */ new Map()
+		};
+		this.#environments.set(environmentName, environmentState);
+		const moduleRunner = await createModuleRunner(this.env, environmentState.webSocket, environmentName);
+		moduleRunners.set(environmentName, moduleRunner);
+		return new Response(null, {
+			status: 101,
+			webSocket: client
+		});
+	}
+	/**
+	* Sends data to the Vite dev server via the WebSocket for a specific environment.
+	* @param environmentName - The environment name
+	* @param data - The data to send as a string
+	* @throws Error if the WebSocket is not initialized
+	*/
+	send(environmentName, data) {
+		const environmentState = this.#environments.get(environmentName);
+		if (!environmentState) throw new Error(`Module runner WebSocket not initialized for environment: "${environmentName}"`);
+		environmentState.webSocket.send(data);
+	}
+	/**
+	* Based on the implementation of `cachedModule` from Vite's `ModuleRunner`.
+	* Running this in the DO enables us to share promises across invocations.
+	* @param environmentName - The environment name
+	* @param url - The module URL
+	* @param importer - The module's importer
+	* @returns The ID of the fetched module
+	*/
+	async getFetchedModuleId(environmentName, url, importer) {
+		const moduleRunner = moduleRunners.get(environmentName);
+		if (!moduleRunner) throw new Error(`Module runner not initialized for environment: "${environmentName}"`);
+		const environmentState = this.#environments.get(environmentName);
+		if (!environmentState) throw new Error(`Environment state not found for environment: "${environmentName}"`);
+		let cached = environmentState.concurrentModuleNodePromises.get(url);
+		if (!cached) {
+			const cachedModule = moduleRunner.evaluatedModules.getModuleByUrl(url);
+			cached = moduleRunner.getModuleInformation(url, importer, cachedModule).finally(() => {
+				environmentState.concurrentModuleNodePromises.delete(url);
+			});
+			environmentState.concurrentModuleNodePromises.set(url, cached);
+		} else moduleRunner.debug?.("[module runner] using cached module info for", url);
+		return (await cached).id;
+	}
+};
+/**
+* Creates a new module runner instance with a WebSocket transport.
+* @param env - The wrapper env
+* @param webSocket - WebSocket connection for communication with Vite dev server
+* @param environmentName - The name of the environment this runner is for
+* @returns Configured module runner instance
+*/
+async function createModuleRunner(env, webSocket, environmentName) {
+	return new CustomModuleRunner({
+		sourcemapInterceptor: "prepareStackTrace",
+		transport: {
+			connect({ onMessage }) {
+				webSocket.addEventListener("message", async ({ data }) => {
+					onMessage(JSON.parse(data.toString()));
+				});
+				onMessage({
+					type: "custom",
+					event: "vite:ws:connect",
+					data: { webSocket }
+				});
+			},
+			disconnect() {
+				webSocket.close();
+			},
+			send(data) {
+				env.__VITE_RUNNER_OBJECT__.get("singleton").send(environmentName, JSON.stringify(data));
+			},
+			async invoke(data) {
+				return await (await env.__VITE_INVOKE_MODULE__.fetch(new Request(UNKNOWN_HOST, {
+					method: "POST",
+					headers: { [ENVIRONMENT_NAME_HEADER]: environmentName },
+					body: JSON.stringify(data)
+				}))).json();
+			}
+		},
+		hmr: true
+	}, {
+		async runInlinedModule(context, transformed, module) {
+			const code = `"use strict";async (${Object.keys(context).join(",")})=>{${transformed}}`;
+			await env.__VITE_UNSAFE_EVAL__.eval(code, module.id)(...Object.values(context));
+			Object.seal(context[ssrModuleExportsKey]);
+		},
+		async runExternalModule(filepath) {
+			if (filepath === "cloudflare:workers") {
+				const originalCloudflareWorkersModule = await import("cloudflare:workers");
+				return Object.seal({
+					...originalCloudflareWorkersModule,
+					env: stripInternalEnv(originalCloudflareWorkersModule.env)
+				});
+			}
+			return import(filepath);
+		}
+	}, env, environmentName);
+}
+/**
+* Retrieves a specific export from a Worker entry module using the module runner.
+* @param workerEntryPath - Path to the Worker entry module
+* @param exportName - Name of the export to retrieve
+* @returns The requested export value
+* @throws Error if the module runner has not been initialized or the module does not define the requested export
+*/
+async function getWorkerEntryExport(workerEntryPath$1, exportName) {
+	if (!parentEnvironmentName) throw new Error(`Parent environment not initialized`);
+	const moduleRunner = moduleRunners.get(parentEnvironmentName);
+	if (!moduleRunner) throw new Error(`Module runner not initialized`);
+	const module = await moduleRunner.import(VIRTUAL_WORKER_ENTRY);
+	const exportValue = typeof module === "object" && module !== null && exportName in module && module[exportName];
+	if (!exportValue) throw new Error(`"${workerEntryPath$1}" does not define a "${exportName}" export.`);
+	return exportValue;
+}
+async function getWorkerEntryExportTypes() {
+	if (!parentEnvironmentName) throw new Error(`Parent environment not initialized`);
+	const moduleRunner = moduleRunners.get(parentEnvironmentName);
+	if (!moduleRunner) throw new Error(`Module runner not initialized`);
+	const { getExportTypes } = await moduleRunner.import(VIRTUAL_EXPORT_TYPES);
+	return getExportTypes(await moduleRunner.import(VIRTUAL_WORKER_ENTRY));
+}
+/**
+* Imports a module from a specific environment's module runner.
+* @param environmentName - The name of the environment to import from
+* @param id - The module ID to import
+* @returns The imported module
+* @throws Error if the environment's module runner has not been initialized
+*/
+async function importFromEnvironment(environmentName, id) {
+	const moduleRunner = moduleRunners.get(environmentName);
+	if (!moduleRunner) throw new Error(`Module runner not initialized for environment: "${environmentName}". Do you need to set \`childEnvironments: ["${environmentName}"]\` in the plugin config?`);
+	return moduleRunner.import(id);
+}
+globalThis.__VITE_ENVIRONMENT_RUNNER_IMPORT__ = importFromEnvironment;
+
+//#endregion
+//#region src/workers/runner-worker/index.ts
+/** The path to the Worker entry file. We store it in the module scope so that it is easily accessible in error messages etc.. */
+let workerEntryPath = "";
+let isEntryWorker = false;
+/**
+* Creates a callable thenable that is used to access the properties of an RPC target.
+* It can be both awaited and invoked as a function.
+* This enables RPC properties to be used both as promises and callable functions.
+* @param key - The property key name used for error messages
+* @param property - The promise that resolves to the property value
+* @returns A callable thenable that implements both Promise and function interfaces
+*/
+function getRpcPropertyCallableThenable(key, property) {
+	const fn = async function(...args) {
+		const maybeFn = await property;
+		if (typeof maybeFn !== "function") throw new TypeError(`"${key}" is not a function.`);
+		return maybeFn(...args);
+	};
+	fn.then = (onFulfilled, onRejected) => property.then(onFulfilled, onRejected);
+	fn.catch = (onRejected) => property.catch(onRejected);
+	fn.finally = (onFinally) => property.finally(onFinally);
+	return fn;
+}
+/**
+* Retrieves an RPC property from a constructor prototype, ensuring it exists on the prototype rather than the instance to maintain RPC compatibility.
+* @param ctor - The constructor function (`WorkerEntrypoint` or `DurableObject`)
+* @param instance - The instance to bind methods to
+* @param key - The property key to retrieve
+* @returns The property value from the prototype
+* @throws TypeError if the property doesn't exist on the prototype
+*/
+function getRpcProperty(ctor, instance, key) {
+	if (!Reflect.has(ctor.prototype, key)) {
+		if (Reflect.has(instance, key)) throw new TypeError([
+			`The RPC receiver's prototype does not implement "${key}", but the receiver instance does.`,
+			"Only properties and methods defined on the prototype can be accessed over RPC.",
+			`Ensure properties are declared as \`get ${key}() { ... }\` instead of \`${key} = ...\`,`,
+			`and methods are declared as \`${key}() { ... }\` instead of \`${key} = () => { ... }\`.`
+		].join("\n"));
+		throw new TypeError(`The RPC receiver does not implement "${key}".`);
+	}
+	return Reflect.get(ctor.prototype, key, instance);
+}
+/**
+* Retrieves an RPC property from a `WorkerEntrypoint` export, creating an instance and returning the bound method or property value.
+* @param exportName - The name of the `WorkerEntrypoint` export
+* @param key - The property key to access on the `WorkerEntrypoint` instance
+* @returns The property value, with methods bound to the instance
+* @throws TypeError if the export is not a `WorkerEntrypoint` subclass
+*/
+async function getWorkerEntrypointRpcProperty(exportName, key) {
+	const ctor = await getWorkerEntryExport(workerEntryPath, exportName);
+	const userEnv = stripInternalEnv(this.env);
+	const expectedWorkerEntrypointMessage = `Expected "${exportName}" export of "${workerEntryPath}" to be a subclass of \`WorkerEntrypoint\` for RPC.`;
+	if (typeof ctor !== "function") throw new TypeError(expectedWorkerEntrypointMessage);
+	const instance = new ctor(this.ctx, userEnv);
+	if (!(instance instanceof WorkerEntrypoint)) throw new TypeError(expectedWorkerEntrypointMessage);
+	const value = getRpcProperty(ctor, instance, key);
+	if (typeof value === "function") return value.bind(instance);
+	return value;
+}
+/**
+* Creates a proxy wrapper for `WorkerEntrypoint` classes that enables RPC functionality.
+* The wrapper intercepts property access and delegates to the user code, handling both direct method calls and RPC property access.
+* @param exportName - The name of the `WorkerEntrypoint` export to wrap
+* @returns A `WorkerEntrypoint` constructor that acts as a proxy to the user code
+*/
+function createWorkerEntrypointWrapper(exportName) {
+	class Wrapper extends WorkerEntrypoint {
+		constructor(ctx, env) {
+			super(ctx, env);
+			return new Proxy(this, { get(target, key, receiver) {
+				const value = Reflect.get(target, key, receiver);
+				if (value !== void 0) return value;
+				if (typeof key === "symbol" || IGNORED_KEYS.includes(key) || DURABLE_OBJECT_KEYS.includes(key)) return;
+				return getRpcPropertyCallableThenable(key, getWorkerEntrypointRpcProperty.call(receiver, exportName, key));
+			} });
+		}
+	}
+	for (const key of WORKER_ENTRYPOINT_KEYS) Wrapper.prototype[key] = async function(arg) {
+		return maybeCaptureError({
+			isEntryWorker,
+			exportName,
+			key
+		}, async () => {
+			if (key === "fetch") {
+				const request = arg;
+				const url = new URL(request.url);
+				if (url.pathname === INIT_PATH) {
+					if (request.headers.get(IS_PARENT_ENVIRONMENT_HEADER) === "true") {
+						const workerEntryPathHeader = request.headers.get(WORKER_ENTRY_PATH_HEADER);
+						if (!workerEntryPathHeader) throw new Error(`Unexpected error: "${WORKER_ENTRY_PATH_HEADER}" header not set.`);
+						const isEntryWorkerHeader = request.headers.get(IS_ENTRY_WORKER_HEADER);
+						if (!isEntryWorkerHeader) throw new Error(`Unexpected error: "${IS_ENTRY_WORKER_HEADER}" header not set.`);
+						workerEntryPath = decodeURIComponent(workerEntryPathHeader);
+						isEntryWorker = isEntryWorkerHeader === "true";
+					}
+					return this.env.__VITE_RUNNER_OBJECT__.get("singleton").fetch(request);
+				}
+				if (url.pathname === GET_EXPORT_TYPES_PATH) {
+					const workerEntryExportTypes = await getWorkerEntryExportTypes();
+					return Response.json(workerEntryExportTypes);
+				}
+			}
+			const exportValue = await getWorkerEntryExport(workerEntryPath, exportName);
+			const userEnv = stripInternalEnv(this.env);
+			if (typeof exportValue === "object" && exportValue !== null) {
+				const maybeFn = exportValue[key];
+				if (typeof maybeFn !== "function") throw new TypeError(`Expected "${exportName}" export of "${workerEntryPath}" to define a \`${key}()\` function.`);
+				return maybeFn.call(exportValue, arg, userEnv, this.ctx);
+			} else if (typeof exportValue === "function") {
+				const instance = new exportValue(this.ctx, userEnv);
+				if (!(instance instanceof WorkerEntrypoint)) throw new TypeError(`Expected "${exportName}" export of "${workerEntryPath}" to be a subclass of \`WorkerEntrypoint\`.`);
+				const maybeFn = instance[key];
+				if (typeof maybeFn !== "function") throw new TypeError(`Expected "${exportName}" export of "${workerEntryPath}" to define a \`${key}()\` method.`);
+				return maybeFn.call(instance, arg);
+			} else return /* @__PURE__ */ new TypeError(`Expected "${exportName}" export of "${workerEntryPath}" to be an object or a class.`);
+		});
+	};
+	return Wrapper;
+}
+/** Symbol key for storing the `DurableObject` instance */
+const kInstance = Symbol("kInstance");
+/** Symbol key for the instance initialization method */
+const kEnsureInstance = Symbol("kEnsureInstance");
+/**
+* Retrieves an RPC property from a `DurableObject` export, ensuring an instance is properly initialized and returning the bound method or property value.
+* @param exportName - The name of the `DurableObject` export
+* @param key - The property key to access on the `DurableObject` instance
+* @returns The property value, with methods bound to the instance
+* @throws TypeError if the export is not a `DurableObject` subclass
+*/
+async function getDurableObjectRpcProperty(exportName, key) {
+	const { ctor, instance } = await this[kEnsureInstance]();
+	if (!(instance instanceof DurableObject)) throw new TypeError(`Expected "${exportName}" export of "${workerEntryPath}" to be a subclass of \`DurableObject\` for RPC.`);
+	const value = getRpcProperty(ctor, instance, key);
+	if (typeof value === "function") return value.bind(instance);
+	return value;
+}
+/**
+* Creates a proxy wrapper for `DurableObject` classes that enables RPC functionality.
+* The wrapper manages instance lifecycle and delegates method calls to the user code, handling both direct method calls and RPC property access.
+* @param exportName - The name of the `DurableObject` export to wrap
+* @returns A `DurableObject` constructor that acts as a proxy to the user code
+*/
+function createDurableObjectWrapper(exportName) {
+	class Wrapper extends DurableObject {
+		[kInstance];
+		constructor(ctx, env) {
+			super(ctx, env);
+			return new Proxy(this, { get(target, key, receiver) {
+				const value = Reflect.get(target, key, receiver);
+				if (value !== void 0) return value;
+				if (typeof key === "symbol" || IGNORED_KEYS.includes(key) || WORKER_ENTRYPOINT_KEYS.includes(key)) return;
+				return getRpcPropertyCallableThenable(key, getDurableObjectRpcProperty.call(receiver, exportName, key));
+			} });
+		}
+		async [kEnsureInstance]() {
+			const ctor = await getWorkerEntryExport(workerEntryPath, exportName);
+			if (typeof ctor !== "function") throw new TypeError(`Expected "${exportName}" export of "${workerEntryPath}" to be a subclass of \`DurableObject\`.`);
+			if (!this[kInstance] || this[kInstance].ctor !== ctor) {
+				const userEnv = stripInternalEnv(this.env);
+				this[kInstance] = {
+					ctor,
+					instance: new ctor(this.ctx, userEnv)
+				};
+				await this.ctx.blockConcurrencyWhile(async () => {});
+			}
+			return this[kInstance];
+		}
+	}
+	for (const key of DURABLE_OBJECT_KEYS) Wrapper.prototype[key] = async function(...args) {
+		const { instance } = await this[kEnsureInstance]();
+		const maybeFn = instance[key];
+		if (typeof maybeFn !== "function") throw new TypeError(`Expected "${exportName}" export of "${workerEntryPath}" to define a \`${key}()\` function.`);
+		return maybeFn.apply(instance, args);
+	};
+	return Wrapper;
+}
+/**
+* Creates a proxy wrapper for `WorkflowEntrypoint` classes.
+* The wrapper delegates method calls to the user code.
+* @param exportName - The name of the `WorkflowEntrypoint` export to wrap
+* @returns A `WorkflowEntrypoint` constructor that acts as a proxy to the user code
+*/
+function createWorkflowEntrypointWrapper(exportName) {
+	class Wrapper extends WorkflowEntrypoint {}
+	for (const key of WORKFLOW_ENTRYPOINT_KEYS) Wrapper.prototype[key] = async function(...args) {
+		const ctor = await getWorkerEntryExport(workerEntryPath, exportName);
+		const userEnv = stripInternalEnv(this.env);
+		const instance = new ctor(this.ctx, userEnv);
+		if (!(instance instanceof WorkflowEntrypoint)) throw new TypeError(`Expected "${exportName}" export of "${workerEntryPath}" to be a subclass of \`WorkflowEntrypoint\`.`);
+		const maybeFn = instance[key];
+		if (typeof maybeFn !== "function") throw new TypeError(`Expected "${exportName}" export of "${workerEntryPath}" to define a \`${key}()\` function.`);
+		return maybeFn.apply(instance, args);
+	};
+	return Wrapper;
+}
+
+//#endregion
+export { __VITE_RUNNER_OBJECT__, createDurableObjectWrapper, createWorkerEntrypointWrapper, createWorkflowEntrypointWrapper };