@cloudflare/vite-plugin 1.11.0 → 1.11.1

package/dist/asset-workers/asset-worker.js

@@ -6012,6 +6012,18 @@ var CustomAssetWorker = class extends worker_default {
     const modifiedResponse = new Response(response.body, response);
     modifiedResponse.headers.delete("ETag");
     modifiedResponse.headers.delete("Cache-Control");
+    const viteHeaders = JSON.parse(
+      this.env.__VITE_HEADERS__
+    );
+    for (const [key, value] of Object.entries(viteHeaders)) {
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          modifiedResponse.headers.append(key, item);
+        }
+      } else if (value !== void 0) {
+        modifiedResponse.headers.set(key, String(value));
+      }
+    }
     return modifiedResponse;
   }
   async unstable_getByETag(eTag) {

package/dist/index.js

@@ -486,10 +486,9 @@ var require_mime = __commonJS({
 
 // src/index.ts
 import assert12 from "node:assert";
-import { randomUUID as randomUUID2 } from "node:crypto";
 import * as fsp2 from "node:fs/promises";
 import * as path13 from "node:path";
-import util3 from "node:util";
+import * as util3 from "node:util";
 
 // ../containers-shared/src/utils.ts
 import { execFileSync, spawn as spawn2 } from "child_process";
@@ -625,10 +624,22 @@ var isDockerfile = (image, configPath) => {
   }
   return false;
 };
-async function getContainerIdsByImageTags(dockerPath, imageTags) {
+var cleanupContainers = (dockerPath, imageTags) => {
+  try {
+    const containerIds = getContainerIdsByImageTags(dockerPath, imageTags);
+    if (containerIds.length === 0) {
+      return true;
+    }
+    runDockerCmdWithOutput(dockerPath, ["rm", "--force", ...containerIds]);
+    return true;
+  } catch {
+    return false;
+  }
+};
+function getContainerIdsByImageTags(dockerPath, imageTags) {
   const ids = /* @__PURE__ */ new Set();
   for (const imageTag of imageTags) {
-    const containerIdsFromImage = await getContainerIdsFromImage(
+    const containerIdsFromImage = getContainerIdsFromImage(
       dockerPath,
       imageTag
     );
@@ -636,7 +647,7 @@ async function getContainerIdsByImageTags(dockerPath, imageTags) {
   }
   return Array.from(ids);
 }
-var getContainerIdsFromImage = async (dockerPath, ancestorImage) => {
+var getContainerIdsFromImage = (dockerPath, ancestorImage) => {
   const output = runDockerCmdWithOutput(dockerPath, [
     "ps",
     "-a",
@@ -1794,6 +1805,7 @@ import * as vite6 from "vite";
 // src/constants.ts
 var ROUTER_WORKER_NAME = "__router-worker__";
 var ASSET_WORKER_NAME = "__asset-worker__";
+var VITE_PROXY_WORKER_NAME = "__vite_proxy_worker__";
 var ASSET_WORKERS_COMPATIBILITY_DATE = "2024-10-04";
 var ADDITIONAL_MODULE_TYPES = [
   "CompiledWasm",
@@ -6288,7 +6300,7 @@ function getImportedAssetPaths(viteManifest) {
 
 // src/cloudflare-environment.ts
 import assert4 from "node:assert";
-import util2 from "node:util";
+import * as util2 from "node:util";
 import * as vite2 from "vite";
 
 // src/node-js-compat.ts
@@ -13404,7 +13416,7 @@ var additionalModuleGlobalRE = new RegExp(
   ADDITIONAL_MODULE_PATTERN,
   "g"
 );
-var VITE_DEV_METADATA_HEADER = "__VITE_DEV_METADATA__";
+var WORKER_ENTRY_PATH_HEADER = "__VITE_WORKER_ENTRY_PATH__";
 
 // src/utils.ts
 import * as path6 from "node:path";
@@ -13458,7 +13470,7 @@ function toMiniflareRequest(request2) {
 
 // src/cloudflare-environment.ts
 var webSocketUndefinedError = "The WebSocket is undefined";
-var debuglog = util2.debuglog("@cloudflare:vite-plugin");
+var debuglog2 = util2.debuglog("@cloudflare:vite-plugin");
 function createHotChannel(webSocketContainer) {
   const listenersMap = /* @__PURE__ */ new Map();
   const client = {
@@ -13512,16 +13524,13 @@ var CloudflareDevEnvironment = class extends vite2.DevEnvironment {
     });
     this.#webSocketContainer = webSocketContainer;
   }
-  async initRunner(worker, workerConfig, configId) {
+  async initRunner(worker, workerConfig) {
     this.#worker = worker;
     const response = await this.#worker.fetch(
       new URL(INIT_PATH, UNKNOWN_HOST),
       {
         headers: {
-          [VITE_DEV_METADATA_HEADER]: JSON.stringify({
-            entryPath: workerConfig.main,
-            configId
-          }),
+          [WORKER_ENTRY_PATH_HEADER]: workerConfig.main,
           upgrade: "websocket"
         }
       }
@@ -13604,13 +13613,13 @@ function createCloudflareEnvironmentOptions(workerConfig, userConfig, environmen
     keepProcessEnv: isNodeCompat(workerConfig)
   };
 }
-function initRunners(resolvedPluginConfig, viteDevServer, miniflare2, configId) {
+function initRunners(resolvedPluginConfig, viteDevServer, miniflare2) {
   return Promise.all(
     Object.entries(resolvedPluginConfig.workers).map(
       async ([environmentName, workerConfig]) => {
-        debuglog(configId, "Initializing worker:", workerConfig.name);
+        debuglog2("Initializing worker:", workerConfig.name);
         const worker = await miniflare2.getWorker(workerConfig.name);
-        return viteDevServer.environments[environmentName].initRunner(worker, workerConfig, configId);
+        return viteDevServer.environments[environmentName].initRunner(worker, workerConfig);
       }
     )
   );
@@ -14587,20 +14596,6 @@ function getDockerPath() {
   const dockerPathEnvVar = "WRANGLER_DOCKER_BIN";
   return process.env[dockerPathEnvVar] || defaultDockerPath;
 }
-async function removeContainersByIds(dockerPath, containerIds) {
-  try {
-    if (containerIds.length === 0) {
-      return;
-    }
-    await runDockerCmd(
-      dockerPath,
-      ["rm", "--force", ...containerIds],
-      ["inherit", "pipe", "pipe"]
-    );
-  } catch (error) {
-    return;
-  }
-}
 async function getContainerOptions(options) {
   const {
     containersConfig,
@@ -14878,6 +14873,7 @@ import { fileURLToPath as fileURLToPath2 } from "node:url";
 import {
   getDefaultDevRegistryPath,
   kCurrentWorker,
+  kUnsafeEphemeralUniqueKey,
   Log,
   LogLevel,
   Response as MiniflareResponse2
@@ -14979,6 +14975,7 @@ var ROUTER_WORKER_PATH = "./asset-workers/router-worker.js";
 var ASSET_WORKER_PATH = "./asset-workers/asset-worker.js";
 var WRAPPER_PATH = "__VITE_WORKER_ENTRY__";
 var RUNNER_PATH = "./runner-worker/index.js";
+var VITE_PROXY_WORKER_PATH = "./vite-proxy-worker/index.js";
 function getEntryWorkerConfig(resolvedPluginConfig) {
   if (resolvedPluginConfig.type === "assets-only") {
     return;
@@ -15060,7 +15057,8 @@ async function getDevMiniflareOptions(config) {
         }
       ],
       bindings: {
-        CONFIG: assetsConfig
+        CONFIG: assetsConfig,
+        __VITE_HEADERS__: JSON.stringify(viteDevServer.config.server.headers)
       },
       serviceBindings: {
         __VITE_HTML_EXISTS__: async (request2) => {
@@ -15108,6 +15106,26 @@ async function getDevMiniflareOptions(config) {
           }
         }
       }
+    },
+    {
+      name: VITE_PROXY_WORKER_NAME,
+      compatibilityDate: ASSET_WORKERS_COMPATIBILITY_DATE,
+      modulesRoot: miniflareModulesRoot,
+      modules: [
+        {
+          type: "ESModule",
+          path: path10.join(miniflareModulesRoot, VITE_PROXY_WORKER_PATH),
+          contents: fs4.readFileSync(
+            fileURLToPath2(new URL(VITE_PROXY_WORKER_PATH, import.meta.url))
+          )
+        }
+      ],
+      serviceBindings: {
+        ...entryWorkerConfig ? { ENTRY_USER_WORKER: entryWorkerConfig.name } : {},
+        __VITE_MIDDLEWARE__: {
+          node: (req, res) => viteDevServer.middlewares(req, res)
+        }
+      }
     }
   ];
   const workersFromConfig = resolvedPluginConfig.type === "workers" ? await Promise.all(
@@ -15150,10 +15168,15 @@ async function getDevMiniflareOptions(config) {
             ...workerOptions,
             name: workerOptions.name ?? workerConfig.name,
             unsafeInspectorProxy: inspectorPort !== false,
-            unsafeDirectSockets: environmentName === resolvedPluginConfig.entryWorkerEnvironmentName ? (
-              // Expose the default entrypoint of the entry worker on the dev registry
-              [{ entrypoint: void 0, proxy: true }]
-            ) : [],
+            unsafeDirectSockets: environmentName === resolvedPluginConfig.entryWorkerEnvironmentName ? [
+              {
+                // This exposes the default entrypoint of the asset proxy worker
+                // on the dev registry with the name of the entry worker
+                serviceName: VITE_PROXY_WORKER_NAME,
+                entrypoint: void 0,
+                proxy: true
+              }
+            ] : [],
             modulesRoot: miniflareModulesRoot,
             unsafeEvalBinding: "__VITE_UNSAFE_EVAL__",
             serviceBindings: {
@@ -15222,6 +15245,7 @@ async function getDevMiniflareOptions(config) {
       ...userWorkers.map((workerOptions) => {
         const wrappers = [
           `import { createWorkerEntrypointWrapper, createDurableObjectWrapper, createWorkflowEntrypointWrapper } from '${RUNNER_PATH}';`,
+          `export { __VITE_RUNNER_OBJECT__ } from '${RUNNER_PATH}';`,
           `export default createWorkerEntrypointWrapper('default');`
         ];
         const workerEntrypointNames = workerToWorkerEntrypointNamesMap.get(
@@ -15265,6 +15289,14 @@ async function getDevMiniflareOptions(config) {
         );
         return {
           ...workerOptions,
+          durableObjects: {
+            ...workerOptions.durableObjects,
+            __VITE_RUNNER_OBJECT__: {
+              className: "__VITE_RUNNER_OBJECT__",
+              unsafeUniqueKey: kUnsafeEphemeralUniqueKey,
+              unsafePreventEviction: true
+            }
+          },
           modules: [
             {
               type: "ESModule",
@@ -15984,7 +16016,7 @@ function handleWebSocket(httpServer, getFetcher) {
 }
 
 // src/index.ts
-var debuglog2 = util3.debuglog("@cloudflare:vite-plugin");
+var debuglog4 = util3.debuglog("@cloudflare:vite-plugin");
 var workersConfigsWarningShown = false;
 var miniflare;
 function cloudflare(pluginConfig = {}) {
@@ -15992,8 +16024,7 @@ function cloudflare(pluginConfig = {}) {
   let resolvedViteConfig;
   const additionalModulePaths = /* @__PURE__ */ new Set();
   const nodeJsCompatWarningsMap = /* @__PURE__ */ new Map();
-  let containerImageTagsSeen;
-  let runningContainerIds;
+  let containerImageTagsSeen = /* @__PURE__ */ new Set();
   let restartingServer = false;
   return [
     {
@@ -16184,15 +16215,14 @@ if (import.meta.hot) {
         viteDevServer.restart = async () => {
           try {
             restartingServer = true;
-            debuglog2(configId, "From server.restart(): Restarting server...");
+            debuglog4("From server.restart(): Restarting server...");
             await restartServer();
-            debuglog2(configId, "From server.restart(): Restarted server...");
+            debuglog4("From server.restart(): Restarted server...");
           } finally {
             restartingServer = false;
           }
         };
         assertIsNotPreview(resolvedPluginConfig);
-        const configId = randomUUID2();
         const inputInspectorPort = await getInputInspectorPortOption(
           resolvedPluginConfig,
           viteDevServer,
@@ -16205,12 +16235,9 @@ if (import.meta.hot) {
             resolvedViteConfig,
             changedFilePath
           )) {
-            debuglog2(configId, "Config changed: " + changedFilePath);
+            debuglog4("Config changed: " + changedFilePath);
             viteDevServer.watcher.off("change", configChangedHandler);
-            debuglog2(
-              configId,
-              "Restarting dev server and aborting previous setup"
-            );
+            debuglog4("Restarting dev server and aborting previous setup");
             await viteDevServer.restart();
           }
         };
@@ -16230,23 +16257,18 @@ if (import.meta.hot) {
           containerBuildId
         });
         if (!miniflare) {
-          debuglog2(configId, "Creating new Miniflare instance");
+          debuglog4("Creating new Miniflare instance");
           miniflare = new Miniflare(miniflareDevOptions);
         } else {
-          debuglog2(configId, "Updating the Miniflare instance");
+          debuglog4("Updating the existing Miniflare instance");
           await miniflare.setOptions(miniflareDevOptions);
-          debuglog2(configId, "Miniflare is ready");
+          debuglog4("Miniflare is ready");
         }
         let preMiddleware;
         if (resolvedPluginConfig.type === "workers") {
           assert12(entryWorkerConfig, `No entry Worker config`);
-          debuglog2(configId, "Initializing the Vite module runners");
-          await initRunners(
-            resolvedPluginConfig,
-            viteDevServer,
-            miniflare,
-            configId
-          );
+          debuglog4("Initializing the Vite module runners");
+          await initRunners(resolvedPluginConfig, viteDevServer, miniflare);
           const entryWorkerName = entryWorkerConfig.name;
           if (viteDevServer.httpServer) {
             handleWebSocket(viteDevServer.httpServer, async () => {
@@ -16305,17 +16327,10 @@ if (import.meta.hot) {
                 )
               )
             );
-            const dockerPollIntervalId = setInterval(async () => {
-              if (containerImageTagsSeen?.size) {
-                runningContainerIds = await getContainerIdsByImageTags(
-                  dockerPath,
-                  containerImageTagsSeen
-                );
+            process.on("exit", async () => {
+              if (containerImageTagsSeen.size) {
+                cleanupContainers(dockerPath, containerImageTagsSeen);
               }
-            }, 2e3);
-            process.on("exit", () => {
-              clearInterval(dockerPollIntervalId);
-              removeContainersByIds(dockerPath, runningContainerIds);
             });
           }
         }
@@ -16391,17 +16406,10 @@ if (import.meta.hot) {
           vitePreviewServer.config.logger.info(
             colors4.dim(colors4.yellow("\n\u26A1\uFE0F Containers successfully built.\n"))
           );
-          const dockerPollIntervalId = setInterval(async () => {
-            if (containerImageTagsSeen?.size) {
-              runningContainerIds = await getContainerIdsByImageTags(
-                dockerPath,
-                containerImageTagsSeen
-              );
-            }
-          }, 2e3);
           process.on("exit", () => {
-            clearInterval(dockerPollIntervalId);
-            removeContainersByIds(dockerPath, runningContainerIds);
+            if (containerImageTagsSeen.size) {
+              cleanupContainers(dockerPath, containerImageTagsSeen);
+            }
           });
         }
         handleWebSocket(vitePreviewServer.httpServer, () => {
@@ -16418,19 +16426,13 @@ if (import.meta.hot) {
       async buildEnd() {
         if (resolvedViteConfig.command === "serve" && containerImageTagsSeen?.size) {
           const dockerPath = getDockerPath();
-          runningContainerIds = await getContainerIdsByImageTags(
-            dockerPath,
-            containerImageTagsSeen
-          );
-          await removeContainersByIds(dockerPath, runningContainerIds);
-          containerImageTagsSeen.clear();
-          runningContainerIds = [];
+          cleanupContainers(dockerPath, containerImageTagsSeen);
         }
-        debuglog2("buildEnd:", restartingServer ? "restarted" : "disposing");
+        debuglog4("buildEnd:", restartingServer ? "restarted" : "disposing");
         if (!restartingServer) {
-          debuglog2("buildEnd: disposing Miniflare instance");
+          debuglog4("buildEnd: disposing Miniflare instance");
           await miniflare?.dispose().catch((error) => {
-            debuglog2("buildEnd: failed to dispose Miniflare instance:", error);
+            debuglog4("buildEnd: failed to dispose Miniflare instance:", error);
           });
           miniflare = void 0;
         }

package/dist/runner-worker/index.js

@@ -1,6 +1,6 @@
 // src/runner-worker/index.ts
 import {
-  DurableObject,
+  DurableObject as DurableObject2,
   WorkerEntrypoint,
   WorkflowEntrypoint
 } from "cloudflare:workers";
@@ -22,14 +22,22 @@ var additionalModuleGlobalRE = new RegExp(
   ADDITIONAL_MODULE_PATTERN,
   "g"
 );
-var VITE_DEV_METADATA_HEADER = "__VITE_DEV_METADATA__";
+var WORKER_ENTRY_PATH_HEADER = "__VITE_WORKER_ENTRY_PATH__";
 
 // src/runner-worker/env.ts
 function stripInternalEnv(internalEnv) {
-  const { __VITE_INVOKE_MODULE__, __VITE_UNSAFE_EVAL__, ...userEnv } = internalEnv;
+  const {
+    __VITE_RUNNER_OBJECT__: __VITE_RUNNER_OBJECT__2,
+    __VITE_INVOKE_MODULE__,
+    __VITE_UNSAFE_EVAL__,
+    ...userEnv
+  } = internalEnv;
   return userEnv;
 }
 
+// src/runner-worker/module-runner.ts
+import { DurableObject } from "cloudflare:workers";
+
 // ../../node_modules/.pnpm/vite@7.0.0_@types+node@20.19.9_jiti@2.4.2_lightningcss@1.29.2/node_modules/vite/dist/node/module-runner.js
 var VALID_ID_PREFIX = "/@id/";
 var NULL_BYTE_PLACEHOLDER = "__x00__";
@@ -686,45 +694,6 @@ var normalizeModuleRunnerTransport = (transport) => {
     }
   };
 };
-var createWebSocketModuleRunnerTransport = (options) => {
-  let pingInterval = options.pingInterval ?? 3e4, ws, pingIntervalId;
-  return {
-    async connect({ onMessage, onDisconnection }) {
-      let socket = options.createConnection();
-      socket.addEventListener("message", async ({ data }) => {
-        onMessage(JSON.parse(data));
-      });
-      let isOpened = socket.readyState === socket.OPEN;
-      isOpened || await new Promise((resolve$1, reject) => {
-        socket.addEventListener("open", () => {
-          isOpened = true, resolve$1();
-        }, { once: true }), socket.addEventListener("close", async () => {
-          if (!isOpened) {
-            reject(/* @__PURE__ */ Error("WebSocket closed without opened."));
-            return;
-          }
-          onMessage({
-            type: "custom",
-            event: "vite:ws:disconnect",
-            data: { webSocket: socket }
-          }), onDisconnection();
-        });
-      }), onMessage({
-        type: "custom",
-        event: "vite:ws:connect",
-        data: { webSocket: socket }
-      }), ws = socket, pingIntervalId = setInterval(() => {
-        socket.readyState === socket.OPEN && socket.send(JSON.stringify({ type: "ping" }));
-      }, pingInterval);
-    },
-    disconnect() {
-      clearInterval(pingIntervalId), ws?.close();
-    },
-    send(data) {
-      ws.send(JSON.stringify(data));
-    }
-  };
-};
 var ssrModuleExportsKey = "__vite_ssr_exports__";
 var ssrImportKey = "__vite_ssr_import__";
 var ssrDynamicImportKey = "__vite_ssr_dynamic_import__";
@@ -1223,26 +1192,108 @@ function exportAll(exports, sourceModule) {
 }
 
 // src/runner-worker/module-runner.ts
+var CustomModuleRunner = class extends ModuleRunner {
+  #env;
+  constructor(options, evaluator, env) {
+    super(options, evaluator);
+    this.#env = env;
+  }
+  async cachedModule(url, importer) {
+    const stub = this.#env.__VITE_RUNNER_OBJECT__.get("singleton");
+    const moduleId = await stub.getFetchedModuleId(url, importer);
+    const module = this.evaluatedModules.getModuleById(moduleId);
+    if (!module) {
+      throw new Error(`Module "${moduleId}" is undefined`);
+    }
+    return module;
+  }
+};
 var moduleRunner;
-var oldConfigId;
-async function createModuleRunner(env, webSocket, configId) {
-  if (moduleRunner) {
-    throw new Error(
-      "Runner already initialized; old configId: " + oldConfigId + ", new configId: " + configId
-    );
+var __VITE_RUNNER_OBJECT__ = class extends DurableObject {
+  /** WebSocket connection to the Vite dev server */
+  #webSocket;
+  #concurrentModuleNodePromises = /* @__PURE__ */ new Map();
+  /**
+   * Handles fetch requests to initialize the module runner.
+   * 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}`
+      );
+    }
+    if (moduleRunner) {
+      throw new Error(`Module runner already initialized`);
+    }
+    const { 0: client, 1: server } = new WebSocketPair();
+    server.accept();
+    this.#webSocket = server;
+    moduleRunner = await createModuleRunner(this.env, this.#webSocket);
+    return new Response(null, { status: 101, webSocket: client });
   }
-  const transport = createWebSocketModuleRunnerTransport({
-    createConnection() {
-      webSocket.accept();
-      return webSocket;
+  /**
+   * Sends data to the Vite dev server via the WebSocket.
+   * @param data - The data to send as a string
+   * @throws Error if the WebSocket is not initialized
+   */
+  send(data) {
+    if (!this.#webSocket) {
+      throw new Error(`Module runner WebSocket not initialized`);
     }
-  });
-  oldConfigId = configId;
-  moduleRunner = new ModuleRunner(
+    this.#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 url - The module URL
+   * @param importer - The module's importer
+   * @returns The ID of the fetched module
+   */
+  async getFetchedModuleId(url, importer) {
+    if (!moduleRunner) {
+      throw new Error(`Module runner not initialized`);
+    }
+    let cached = this.#concurrentModuleNodePromises.get(url);
+    if (!cached) {
+      const cachedModule = moduleRunner.evaluatedModules.getModuleByUrl(url);
+      cached = moduleRunner.getModuleInformation(url, importer, cachedModule).finally(() => {
+        this.#concurrentModuleNodePromises.delete(url);
+      });
+      this.#concurrentModuleNodePromises.set(url, cached);
+    } else {
+      moduleRunner.debug?.("[module runner] using cached module info for", url);
+    }
+    const module = await cached;
+    return module.id;
+  }
+};
+async function createModuleRunner(env, webSocket) {
+  return new CustomModuleRunner(
     {
       sourcemapInterceptor: "prepareStackTrace",
       transport: {
-        ...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) {
+          const stub = env.__VITE_RUNNER_OBJECT__.get("singleton");
+          stub.send(JSON.stringify(data));
+        },
         async invoke(data) {
           const response = await env.__VITE_INVOKE_MODULE__.fetch(
             new Request(UNKNOWN_HOST, {
@@ -1250,9 +1301,6 @@ async function createModuleRunner(env, webSocket, configId) {
               body: JSON.stringify(data)
             })
           );
-          if (!response.ok) {
-            throw new Error(await response.text());
-          }
           const result = await response.json();
           return result;
         }
@@ -1261,19 +1309,17 @@ async function createModuleRunner(env, webSocket, configId) {
     },
     {
       async runInlinedModule(context, transformed, module) {
-        const codeDefinition = `'use strict';async (${Object.keys(context).join(
-          ","
-        )})=>{{`;
-        const code = `${codeDefinition}${transformed}
-}}`;
+        const code = `"use strict";async (${Object.keys(context).join(",")})=>{${transformed}}`;
         try {
           const fn = env.__VITE_UNSAFE_EVAL__.eval(code, module.id);
           await fn(...Object.values(context));
-          Object.freeze(context.__vite_ssr_exports__);
-        } catch (e) {
-          console.error("error running", module.id);
-          console.error(e instanceof Error ? e.stack : e);
-          throw e;
+          Object.seal(context[ssrModuleExportsKey]);
+        } catch (error) {
+          if (error instanceof Error) {
+            error.message = `Error running module "${module.id}".
+${error.message}.`;
+          }
+          throw error;
         }
       },
       async runExternalModule(filepath) {
@@ -1286,19 +1332,24 @@ async function createModuleRunner(env, webSocket, configId) {
             )
           });
         }
-        filepath = filepath.replace(/^file:\/\//, "");
         return import(filepath);
       }
-    }
+    },
+    env
   );
 }
-async function getWorkerEntryExport(path, entrypoint) {
-  const module = await moduleRunner.import(path);
-  const entrypointValue = typeof module === "object" && module !== null && entrypoint in module && module[entrypoint];
-  if (!entrypointValue) {
-    throw new Error(`${path} does not export a ${entrypoint} entrypoint.`);
+async function getWorkerEntryExport(workerEntryPath2, exportName) {
+  if (!moduleRunner) {
+    throw new Error(`Module runner not initialized`);
+  }
+  const module = await moduleRunner.import(workerEntryPath2);
+  const exportValue = typeof module === "object" && module !== null && exportName in module && module[exportName];
+  if (!exportValue) {
+    throw new Error(
+      `"${workerEntryPath2}" does not define a "${exportName}" export.`
+    );
   }
-  return entrypointValue;
+  return exportValue;
 }
 
 // src/runner-worker/index.ts
@@ -1319,7 +1370,20 @@ var DURABLE_OBJECT_KEYS = [
   "webSocketMessage"
 ];
 var WORKFLOW_ENTRYPOINT_KEYS = ["run"];
-var entryPath = "";
+var workerEntryPath = "";
+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;
+}
 function getRpcProperty(ctor, instance, key) {
   const prototypeHasKey = Reflect.has(ctor.prototype, key);
   if (!prototypeHasKey) {
@@ -1327,37 +1391,24 @@ function getRpcProperty(ctor, instance, key) {
     if (instanceHasKey) {
       throw new TypeError(
         [
-          `The RPC receiver's prototype does not implement '${key}', but the receiver instance does.`,
+          `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}'.`);
+    throw new TypeError(`The RPC receiver does not implement "${key}".`);
   }
   return Reflect.get(ctor.prototype, key, instance);
 }
-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;
-}
-async function getWorkerEntrypointRpcProperty(entrypoint, key) {
+async function getWorkerEntrypointRpcProperty(exportName, key) {
   const ctor = await getWorkerEntryExport(
-    entryPath,
-    entrypoint
+    workerEntryPath,
+    exportName
   );
   const userEnv = stripInternalEnv(this.env);
-  const expectedWorkerEntrypointMessage = `Expected ${entrypoint} export of ${entryPath} to be a subclass of \`WorkerEntrypoint\` for RPC.`;
+  const expectedWorkerEntrypointMessage = `Expected "${exportName}" export of "${workerEntryPath}" to be a subclass of \`WorkerEntrypoint\` for RPC.`;
   if (typeof ctor !== "function") {
     throw new TypeError(expectedWorkerEntrypointMessage);
   }
@@ -1371,10 +1422,8 @@ async function getWorkerEntrypointRpcProperty(entrypoint, key) {
   }
   return value;
 }
-function createWorkerEntrypointWrapper(entrypoint) {
+function createWorkerEntrypointWrapper(exportName) {
   class Wrapper extends WorkerEntrypoint {
-    /** A unique identifier used for debugging errors when config updates. */
-    configId;
     constructor(ctx, env) {
       super(ctx, env);
       return new Proxy(this, {
@@ -1383,12 +1432,14 @@ function createWorkerEntrypointWrapper(entrypoint) {
           if (value !== void 0) {
             return value;
           }
-          if (typeof key === "symbol" || IGNORED_KEYS.includes(key) || DURABLE_OBJECT_KEYS.includes(key)) {
+          if (typeof key === "symbol" || IGNORED_KEYS.includes(key) || // The class methods are accessed to determine the type of the export.
+          // We should therefore avoid proxying `DurableObject` methods on the `WorkerEntrypoint` class.
+          DURABLE_OBJECT_KEYS.includes(key)) {
             return;
           }
           const property = getWorkerEntrypointRpcProperty.call(
             receiver,
-            entrypoint,
+            exportName,
             key
           );
           return getRpcPropertyCallableThenable(key, property);
@@ -1401,58 +1452,51 @@ function createWorkerEntrypointWrapper(entrypoint) {
       if (key === "fetch") {
         const request = arg;
         const url = new URL(request.url);
-        let webSocket;
         if (url.pathname === INIT_PATH) {
-          try {
-            const viteDevMetadata = getViteDevMetadata(request);
-            entryPath = viteDevMetadata.entryPath;
-            const { 0: client, 1: server } = new WebSocketPair();
-            webSocket = client;
-            await createModuleRunner(
-              this.env,
-              server,
-              viteDevMetadata.configId
-            );
-          } catch (e) {
-            return new Response(
-              e instanceof Error ? e.message : JSON.stringify(e),
-              { status: 500 }
+          const workerEntryPathHeader = request.headers.get(
+            WORKER_ENTRY_PATH_HEADER
+          );
+          if (!workerEntryPathHeader) {
+            throw new Error(
+              `Unexpected error: "${WORKER_ENTRY_PATH_HEADER}" header not set.`
             );
           }
-          return new Response(null, {
-            status: 101,
-            webSocket
-          });
+          workerEntryPath = workerEntryPathHeader;
+          const stub = this.env.__VITE_RUNNER_OBJECT__.get("singleton");
+          return stub.fetch(request);
         }
       }
-      const entrypointValue = await getWorkerEntryExport(entryPath, entrypoint);
+      const exportValue = await getWorkerEntryExport(
+        workerEntryPath,
+        exportName
+      );
       const userEnv = stripInternalEnv(this.env);
-      if (typeof entrypointValue === "object" && entrypointValue !== null) {
-        const maybeFn = entrypointValue[key];
+      if (typeof exportValue === "object" && exportValue !== null) {
+        const maybeFn = exportValue[key];
         if (typeof maybeFn !== "function") {
           throw new TypeError(
-            `Expected ${entrypoint} export of ${entryPath} to define a \`${key}()\` function.`
+            `Expected "${exportName}" export of "${workerEntryPath}" to define a \`${key}()\` function.`
           );
         }
-        return maybeFn.call(entrypointValue, arg, userEnv, this.ctx);
-      } else if (typeof entrypointValue === "function") {
-        const ctor = entrypointValue;
+        return maybeFn.call(exportValue, arg, userEnv, this.ctx);
+      } else if (typeof exportValue === "function") {
+        const ctor = exportValue;
         const instance = new ctor(this.ctx, userEnv);
         if (!(instance instanceof WorkerEntrypoint)) {
           throw new TypeError(
-            `Expected ${entrypoint} export of ${entryPath} to be a subclass of \`WorkerEntrypoint\`.`
+            `Expected "${exportName}" export of "${workerEntryPath}" to be a subclass of \`WorkerEntrypoint\`.`
           );
         }
         const maybeFn = instance[key];
         if (typeof maybeFn !== "function") {
           throw new TypeError(
-            `Expected ${entrypoint} export of ${entryPath} to define a \`${key}()\` method.`
+            `Expected "${exportName}" export of "${workerEntryPath}" to define a \`${key}()\` method.`
           );
         }
         return maybeFn.call(instance, arg);
       } else {
         return new TypeError(
-          `Expected ${entrypoint} export of ${entryPath} to be an object or a class. Got ${entrypointValue}.`
+          `Expected "${exportName}" export of "${workerEntryPath}" to be an object or a class.`
         );
       }
     };
@@ -1461,11 +1505,11 @@ function createWorkerEntrypointWrapper(entrypoint) {
 }
 var kInstance = Symbol("kInstance");
 var kEnsureInstance = Symbol("kEnsureInstance");
-async function getDurableObjectRpcProperty(className, key) {
+async function getDurableObjectRpcProperty(exportName, key) {
   const { ctor, instance } = await this[kEnsureInstance]();
-  if (!(instance instanceof DurableObject)) {
+  if (!(instance instanceof DurableObject2)) {
     throw new TypeError(
-      `Expected ${className} export of ${entryPath} to be a subclass of \`DurableObject\` for RPC.`
+      `Expected "${exportName}" export of "${workerEntryPath}" to be a subclass of \`DurableObject\` for RPC.`
     );
   }
   const value = getRpcProperty(ctor, instance, key);
@@ -1474,8 +1518,8 @@ async function getDurableObjectRpcProperty(className, key) {
   }
   return value;
 }
-function createDurableObjectWrapper(className) {
-  class Wrapper extends DurableObject {
+function createDurableObjectWrapper(exportName) {
+  class Wrapper extends DurableObject2 {
     [kInstance];
     constructor(ctx, env) {
       super(ctx, env);
@@ -1485,12 +1529,14 @@ function createDurableObjectWrapper(className) {
           if (value !== void 0) {
             return value;
           }
-          if (typeof key === "symbol" || IGNORED_KEYS.includes(key) || WORKER_ENTRYPOINT_KEYS.includes(key)) {
+          if (typeof key === "symbol" || IGNORED_KEYS.includes(key) || // The class methods are accessed to determine the type of the export.
+          // We should therefore avoid proxying `WorkerEntrypoint` methods on the `DurableObject` class.
+          WORKER_ENTRYPOINT_KEYS.includes(key)) {
             return;
           }
           const property = getDurableObjectRpcProperty.call(
             receiver,
-            className,
+            exportName,
             key
           );
           return getRpcPropertyCallableThenable(key, property);
@@ -1499,12 +1545,12 @@ function createDurableObjectWrapper(className) {
     }
     async [kEnsureInstance]() {
       const ctor = await getWorkerEntryExport(
-        entryPath,
-        className
+        workerEntryPath,
+        exportName
       );
       if (typeof ctor !== "function") {
         throw new TypeError(
-          `${entryPath} does not export a ${className} Durable Object.`
+          `Expected "${exportName}" export of "${workerEntryPath}" to be a subclass of \`DurableObject\`.`
         );
       }
       if (!this[kInstance] || this[kInstance].ctor !== ctor) {
@@ -1523,7 +1569,7 @@ function createDurableObjectWrapper(className) {
       const maybeFn = instance[key];
       if (typeof maybeFn !== "function") {
         throw new TypeError(
-          `Expected ${className} export of ${entryPath} to define a \`${key}()\` function.`
+          `Expected "${exportName}" export of "${workerEntryPath}" to define a \`${key}()\` function.`
         );
       }
       return maybeFn.apply(instance, args);
@@ -1531,26 +1577,26 @@ function createDurableObjectWrapper(className) {
   }
   return Wrapper;
 }
-function createWorkflowEntrypointWrapper(className) {
+function createWorkflowEntrypointWrapper(exportName) {
   class Wrapper extends WorkflowEntrypoint {
   }
   for (const key of WORKFLOW_ENTRYPOINT_KEYS) {
     Wrapper.prototype[key] = async function(...args) {
       const ctor = await getWorkerEntryExport(
-        entryPath,
-        className
+        workerEntryPath,
+        exportName
       );
       const userEnv = stripInternalEnv(this.env);
       const instance = new ctor(this.ctx, userEnv);
       if (!(instance instanceof WorkflowEntrypoint)) {
         throw new TypeError(
-          `Expected ${className} export of ${entryPath} to be a subclass of \`WorkflowEntrypoint\`.`
+          `Expected "${exportName}" export of "${workerEntryPath}" to be a subclass of \`WorkflowEntrypoint\`.`
         );
       }
       const maybeFn = instance[key];
       if (typeof maybeFn !== "function") {
         throw new TypeError(
-          `Expected ${className} export of ${entryPath} to define a \`${key}()\` function.`
+          `Expected "${exportName}" export of "${workerEntryPath}" to define a \`${key}()\` function.`
         );
       }
       return maybeFn.apply(instance, args);
@@ -1558,30 +1604,8 @@ function createWorkflowEntrypointWrapper(className) {
   }
   return Wrapper;
 }
-function getViteDevMetadata(request) {
-  const viteDevMetadataHeader = request.headers.get(VITE_DEV_METADATA_HEADER);
-  if (viteDevMetadataHeader === null) {
-    throw new Error(
-      "Unexpected internal error, vite dev metadata header not set"
-    );
-  }
-  let parsedViteDevMetadataHeader;
-  try {
-    parsedViteDevMetadataHeader = JSON.parse(viteDevMetadataHeader);
-  } catch {
-    throw new Error(
-      `Unexpected internal error, vite dev metadata header JSON parsing failed, value = ${viteDevMetadataHeader}`
-    );
-  }
-  const { entryPath: entryPath2, configId } = parsedViteDevMetadataHeader;
-  if (entryPath2 === void 0) {
-    throw new Error(
-      "Unexpected internal error, vite dev metadata header doesn't contain an entryPath value"
-    );
-  }
-  return { entryPath: entryPath2, configId };
-}
 export {
+  __VITE_RUNNER_OBJECT__,
   createDurableObjectWrapper,
   createWorkerEntrypointWrapper,
   createWorkflowEntrypointWrapper

package/dist/vite-proxy-worker/index.js

@@ -0,0 +1,39 @@
+// src/vite-proxy-worker/index.ts
+import { WorkerEntrypoint } from "cloudflare:workers";
+var ViteProxyWorker = class extends WorkerEntrypoint {
+  constructor(ctx, env) {
+    super(ctx, env);
+    return new Proxy(this, {
+      get(target, prop) {
+        if (Reflect.has(target, prop)) {
+          return Reflect.get(target, prop);
+        }
+        return Reflect.get(target.env.ENTRY_USER_WORKER, prop);
+      }
+    });
+  }
+  async fetch(request) {
+    return this.env.__VITE_MIDDLEWARE__.fetch(request);
+  }
+  tail(events) {
+    return this.env.ENTRY_USER_WORKER.tail(
+      JSON.parse(JSON.stringify(events, tailEventsReplacer), tailEventsReviver)
+    );
+  }
+};
+var serializedDate = "___serialized_date___";
+function tailEventsReplacer(_, value) {
+  if (value instanceof Date) {
+    return { [serializedDate]: value.toISOString() };
+  }
+  return value;
+}
+function tailEventsReviver(_, value) {
+  if (value && typeof value === "object" && serializedDate in value) {
+    return new Date(value[serializedDate]);
+  }
+  return value;
+}
+export {
+  ViteProxyWorker as default
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudflare/vite-plugin",
-  "version": "1.11.0",
+  "version": "1.11.1",
   "description": "Cloudflare plugin for Vite",
   "keywords": [
     "cloudflare",
@@ -40,12 +40,12 @@
     "tinyglobby": "^0.2.12",
     "unenv": "2.0.0-rc.19",
     "ws": "8.18.0",
-    "@cloudflare/unenv-preset": "2.5.0",
-    "miniflare": "4.20250730.0",
-    "wrangler": "4.27.0"
+    "@cloudflare/unenv-preset": "2.6.0",
+    "miniflare": "4.20250803.0",
+    "wrangler": "4.28.0"
   },
   "devDependencies": {
-    "@cloudflare/workers-types": "^4.20250730.0",
+    "@cloudflare/workers-types": "^4.20250803.0",
     "@types/node": "^22.10.1",
     "@types/ws": "^8.5.13",
     "magic-string": "^0.30.12",
@@ -61,7 +61,7 @@
   },
   "peerDependencies": {
     "vite": "^6.1.0 || ^7.0.0",
-    "wrangler": "^4.27.0"
+    "wrangler": "^4.28.0"
   },
   "publishConfig": {
     "access": "public"