@cloudflare/vite-plugin 1.10.2 → 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

@@ -488,6 +488,7 @@ var require_mime = __commonJS({
 import assert12 from "node:assert";
 import * as fsp2 from "node:fs/promises";
 import * as path13 from "node:path";
+import * as util3 from "node:util";
 
 // ../containers-shared/src/utils.ts
 import { execFileSync, spawn as spawn2 } from "child_process";
@@ -623,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
     );
@@ -634,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",
@@ -1786,11 +1799,13 @@ var MagicString = class _MagicString {
 
 // src/index.ts
 import { Miniflare } from "miniflare";
+import colors4 from "picocolors";
 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",
@@ -2298,36 +2313,36 @@ function maybeGetFile(filePath) {
 
 // ../../node_modules/.pnpm/zod@3.22.3/node_modules/zod/lib/index.mjs
 var util;
-(function(util2) {
-  util2.assertEqual = (val) => val;
+(function(util4) {
+  util4.assertEqual = (val) => val;
   function assertIs(_arg) {
   }
-  util2.assertIs = assertIs;
+  util4.assertIs = assertIs;
   function assertNever(_x) {
     throw new Error();
   }
-  util2.assertNever = assertNever;
-  util2.arrayToEnum = (items) => {
+  util4.assertNever = assertNever;
+  util4.arrayToEnum = (items) => {
     const obj = {};
     for (const item of items) {
       obj[item] = item;
     }
     return obj;
   };
-  util2.getValidEnumValues = (obj) => {
-    const validKeys = util2.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
+  util4.getValidEnumValues = (obj) => {
+    const validKeys = util4.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
     const filtered = {};
     for (const k of validKeys) {
       filtered[k] = obj[k];
     }
-    return util2.objectValues(filtered);
+    return util4.objectValues(filtered);
   };
-  util2.objectValues = (obj) => {
-    return util2.objectKeys(obj).map(function(e) {
+  util4.objectValues = (obj) => {
+    return util4.objectKeys(obj).map(function(e) {
       return obj[e];
     });
   };
-  util2.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object) => {
+  util4.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object) => {
     const keys = [];
     for (const key in object) {
       if (Object.prototype.hasOwnProperty.call(object, key)) {
@@ -2336,19 +2351,19 @@ var util;
     }
     return keys;
   };
-  util2.find = (arr, checker) => {
+  util4.find = (arr, checker) => {
     for (const item of arr) {
       if (checker(item))
         return item;
     }
     return void 0;
   };
-  util2.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && isFinite(val) && Math.floor(val) === val;
+  util4.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && isFinite(val) && Math.floor(val) === val;
   function joinValues(array, separator = " | ") {
     return array.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
   }
-  util2.joinValues = joinValues;
-  util2.jsonStringifyReplacer = (_, value) => {
+  util4.joinValues = joinValues;
+  util4.jsonStringifyReplacer = (_, value) => {
     if (typeof value === "bigint") {
       return value.toString();
     }
@@ -6285,6 +6300,7 @@ function getImportedAssetPaths(viteManifest) {
 
 // src/cloudflare-environment.ts
 import assert4 from "node:assert";
+import * as util2 from "node:util";
 import * as vite2 from "vite";
 
 // src/node-js-compat.ts
@@ -13400,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";
@@ -13454,6 +13470,7 @@ function toMiniflareRequest(request2) {
 
 // src/cloudflare-environment.ts
 var webSocketUndefinedError = "The WebSocket is undefined";
+var debuglog2 = util2.debuglog("@cloudflare:vite-plugin");
 function createHotChannel(webSocketContainer) {
   const listenersMap = /* @__PURE__ */ new Map();
   const client = {
@@ -13513,9 +13530,7 @@ var CloudflareDevEnvironment = class extends vite2.DevEnvironment {
       new URL(INIT_PATH, UNKNOWN_HOST),
       {
         headers: {
-          [VITE_DEV_METADATA_HEADER]: JSON.stringify({
-            entryPath: workerConfig.main
-          }),
+          [WORKER_ENTRY_PATH_HEADER]: workerConfig.main,
           upgrade: "websocket"
         }
       }
@@ -13602,6 +13617,7 @@ function initRunners(resolvedPluginConfig, viteDevServer, miniflare2) {
   return Promise.all(
     Object.entries(resolvedPluginConfig.workers).map(
       async ([environmentName, workerConfig]) => {
+        debuglog2("Initializing worker:", workerConfig.name);
         const worker = await miniflare2.getWorker(workerConfig.name);
         return viteDevServer.environments[environmentName].initRunner(worker, workerConfig);
       }
@@ -14580,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,
@@ -14826,42 +14828,52 @@ function writeDeployConfig(resolvedPluginConfig, resolvedViteConfig) {
 }
 
 // src/dev-vars.ts
-import * as fs4 from "node:fs";
 import * as path9 from "node:path";
-function getDotDevDotVarsContent(configPath, cloudflareEnv) {
-  const configDir = path9.dirname(configPath);
-  const defaultDotDevDotVarsPath = `${configDir}/.dev.vars`;
-  const inputDotDevDotVarsPath = `${defaultDotDevDotVarsPath}${cloudflareEnv ? `.${cloudflareEnv}` : ""}`;
-  const targetPath = fs4.existsSync(inputDotDevDotVarsPath) ? inputDotDevDotVarsPath : fs4.existsSync(defaultDotDevDotVarsPath) ? defaultDotDevDotVarsPath : null;
-  if (targetPath) {
-    const dotDevDotVarsContent = fs4.readFileSync(targetPath);
+import { unstable_getVarsForDev } from "wrangler";
+function getLocalDevVarsForPreview(configPath, cloudflareEnv) {
+  const dotDevDotVars = unstable_getVarsForDev(
+    configPath,
+    void 0,
+    // We don't currently support setting a list of custom `.env` files.
+    {},
+    // Don't pass actual vars since these will be loaded from the wrangler.json.
+    cloudflareEnv
+  );
+  const dotDevDotVarsEntries = Array.from(Object.entries(dotDevDotVars));
+  if (dotDevDotVarsEntries.length > 0) {
+    const dotDevDotVarsContent = dotDevDotVarsEntries.map(([key, value]) => {
+      return `${key} = "${value?.toString().replaceAll(`"`, `\\"`)}"
+`;
+    }).join("");
     return dotDevDotVarsContent;
   }
-  return null;
 }
-function hasDotDevDotVarsFileChanged(resolvedPluginConfig, changedFilePath) {
-  return [...resolvedPluginConfig.configPaths].some((configPath) => {
-    const dotDevDotVars = path9.join(path9.dirname(configPath), ".dev.vars");
-    if (dotDevDotVars === changedFilePath) {
-      return true;
-    }
-    if (resolvedPluginConfig.cloudflareEnv) {
-      const dotDevDotVarsForEnv = `${dotDevDotVars}.${resolvedPluginConfig.cloudflareEnv}`;
-      return dotDevDotVarsForEnv === changedFilePath;
-    }
-    return false;
+function hasLocalDevVarsFileChanged({
+  configPaths,
+  cloudflareEnv
+}, changedFilePath) {
+  return [...configPaths].some((configPath) => {
+    const configDir = path9.dirname(configPath);
+    return [
+      ".dev.vars",
+      ".env",
+      ...cloudflareEnv ? [`.dev.vars.${cloudflareEnv}`, `.env.${cloudflareEnv}`] : []
+    ].some(
+      (localDevFile) => changedFilePath === path9.join(configDir, localDevFile)
+    );
   });
 }
 
 // src/miniflare-options.ts
 import assert8 from "node:assert";
-import * as fs5 from "node:fs";
+import * as fs4 from "node:fs";
 import * as fsp from "node:fs/promises";
 import * as path10 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import {
   getDefaultDevRegistryPath,
   kCurrentWorker,
+  kUnsafeEphemeralUniqueKey,
   Log,
   LogLevel,
   Response as MiniflareResponse2
@@ -14963,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;
@@ -15015,7 +15028,7 @@ async function getDevMiniflareOptions(config) {
         {
           type: "ESModule",
           path: path10.join(miniflareModulesRoot, ROUTER_WORKER_PATH),
-          contents: fs5.readFileSync(
+          contents: fs4.readFileSync(
             fileURLToPath2(new URL(ROUTER_WORKER_PATH, import.meta.url))
           )
         }
@@ -15038,13 +15051,14 @@ async function getDevMiniflareOptions(config) {
         {
           type: "ESModule",
           path: path10.join(miniflareModulesRoot, ASSET_WORKER_PATH),
-          contents: fs5.readFileSync(
+          contents: fs4.readFileSync(
             fileURLToPath2(new URL(ASSET_WORKER_PATH, import.meta.url))
           )
         }
       ],
       bindings: {
-        CONFIG: assetsConfig
+        CONFIG: assetsConfig,
+        __VITE_HEADERS__: JSON.stringify(viteDevServer.config.server.headers)
       },
       serviceBindings: {
         __VITE_HTML_EXISTS__: async (request2) => {
@@ -15092,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(
@@ -15134,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: {
@@ -15206,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(
@@ -15249,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",
@@ -15258,7 +15306,7 @@ async function getDevMiniflareOptions(config) {
             {
               type: "ESModule",
               path: path10.join(miniflareModulesRoot, RUNNER_PATH),
-              contents: fs5.readFileSync(
+              contents: fs4.readFileSync(
                 fileURLToPath2(new URL(RUNNER_PATH, import.meta.url))
               )
             }
@@ -15524,7 +15572,7 @@ import * as vite5 from "vite";
 
 // src/workers-configs.ts
 import assert9 from "node:assert";
-import * as fs6 from "node:fs";
+import * as fs5 from "node:fs";
 import * as path11 from "node:path";
 import { unstable_readConfig as unstable_readConfig2 } from "wrangler";
 var nonApplicableWorkerConfigs = {
@@ -15708,7 +15756,7 @@ function getWorkerConfig(configPath, env2, opts) {
   if (!config.main) {
     throw new Error(missingFieldErrorMessage(`'main'`, configPath, env2));
   }
-  const mainStat = fs6.statSync(config.main, { throwIfNoEntry: false });
+  const mainStat = fs5.statSync(config.main, { throwIfNoEntry: false });
   if (!mainStat) {
     throw new Error(
       `The provided Wrangler config main field (${config.main}) doesn't point to an existing file`
@@ -15742,7 +15790,7 @@ function getValidatedWranglerConfigPath(root, requestedConfigPath, isForAuxiliar
         `${errorMessagePrefix} doesn't point to a file with the correct file extension. It should point to a jsonc, json or toml file (${foundExtensionMessage} instead)`
       );
     }
-    const mainStat = fs6.statSync(configPath2, { throwIfNoEntry: false });
+    const mainStat = fs5.statSync(configPath2, { throwIfNoEntry: false });
     if (!mainStat) {
       throw new Error(
         `${errorMessagePrefix} doesn't point to an existing file`
@@ -15770,7 +15818,7 @@ function getValidatedWranglerConfigPath(root, requestedConfigPath, isForAuxiliar
 function findWranglerConfig(root) {
   for (const extension of allowedWranglerConfigExtensions) {
     const configPath = path11.join(root, `wrangler.${extension}`);
-    if (fs6.existsSync(configPath)) {
+    if (fs5.existsSync(configPath)) {
       return configPath;
     }
   }
@@ -15968,6 +16016,7 @@ function handleWebSocket(httpServer, getFetcher) {
 }
 
 // src/index.ts
+var debuglog4 = util3.debuglog("@cloudflare:vite-plugin");
 var workersConfigsWarningShown = false;
 var miniflare;
 function cloudflare(pluginConfig = {}) {
@@ -15975,8 +16024,8 @@ 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 [
     {
       name: "vite-plugin-cloudflare",
@@ -16114,15 +16163,15 @@ if (import.meta.hot) {
           }
           config = workerConfig;
           if (workerConfig.configPath) {
-            const dotDevDotVarsContent = getDotDevDotVarsContent(
+            const localDevVars = getLocalDevVarsForPreview(
               workerConfig.configPath,
               resolvedPluginConfig.cloudflareEnv
             );
-            if (dotDevDotVarsContent) {
+            if (localDevVars) {
               this.emitFile({
                 type: "asset",
                 fileName: ".dev.vars",
-                source: dotDevDotVarsContent
+                source: localDevVars
               });
             }
           }
@@ -16159,27 +16208,40 @@ if (import.meta.hot) {
           writeDeployConfig(resolvedPluginConfig, resolvedViteConfig);
         }
       },
-      hotUpdate(options) {
-        assertIsNotPreview(resolvedPluginConfig);
-        const changedFilePath = path13.resolve(options.file);
-        if (resolvedPluginConfig.configPaths.has(changedFilePath) || hasDotDevDotVarsFileChanged(resolvedPluginConfig, changedFilePath) || hasAssetsConfigChanged(
-          resolvedPluginConfig,
-          resolvedViteConfig,
-          changedFilePath
-        )) {
-          options.server.restart();
-          return [];
-        }
-      },
       // Vite `configureServer` Hook
       // see https://vite.dev/guide/api-plugin.html#configureserver
       async configureServer(viteDevServer) {
+        const restartServer = viteDevServer.restart.bind(viteDevServer);
+        viteDevServer.restart = async () => {
+          try {
+            restartingServer = true;
+            debuglog4("From server.restart(): Restarting server...");
+            await restartServer();
+            debuglog4("From server.restart(): Restarted server...");
+          } finally {
+            restartingServer = false;
+          }
+        };
         assertIsNotPreview(resolvedPluginConfig);
         const inputInspectorPort = await getInputInspectorPortOption(
           resolvedPluginConfig,
           viteDevServer,
           miniflare
         );
+        const configChangedHandler = async (changedFilePath) => {
+          assertIsNotPreview(resolvedPluginConfig);
+          if (resolvedPluginConfig.configPaths.has(changedFilePath) || hasLocalDevVarsFileChanged(resolvedPluginConfig, changedFilePath) || hasAssetsConfigChanged(
+            resolvedPluginConfig,
+            resolvedViteConfig,
+            changedFilePath
+          )) {
+            debuglog4("Config changed: " + changedFilePath);
+            viteDevServer.watcher.off("change", configChangedHandler);
+            debuglog4("Restarting dev server and aborting previous setup");
+            await viteDevServer.restart();
+          }
+        };
+        viteDevServer.watcher.on("change", configChangedHandler);
         let containerBuildId;
         const entryWorkerConfig = getEntryWorkerConfig(resolvedPluginConfig);
         const hasDevContainers = entryWorkerConfig?.containers?.length && entryWorkerConfig.dev.enable_containers;
@@ -16195,13 +16257,17 @@ if (import.meta.hot) {
           containerBuildId
         });
         if (!miniflare) {
+          debuglog4("Creating new Miniflare instance");
           miniflare = new Miniflare(miniflareDevOptions);
         } else {
+          debuglog4("Updating the existing Miniflare instance");
           await miniflare.setOptions(miniflareDevOptions);
+          debuglog4("Miniflare is ready");
         }
         let preMiddleware;
         if (resolvedPluginConfig.type === "workers") {
           assert12(entryWorkerConfig, `No entry Worker config`);
+          debuglog4("Initializing the Vite module runners");
           await initRunners(resolvedPluginConfig, viteDevServer, miniflare);
           const entryWorkerName = entryWorkerConfig.name;
           if (viteDevServer.httpServer) {
@@ -16240,6 +16306,13 @@ if (import.meta.hot) {
             };
           }
           if (hasDevContainers) {
+            viteDevServer.config.logger.info(
+              colors4.dim(
+                colors4.yellow(
+                  "\u2237 Building container images for local development...\n"
+                )
+              )
+            );
             containerImageTagsSeen = await prepareContainerImages({
               containersConfig: entryWorkerConfig.containers,
               containerBuildId,
@@ -16247,17 +16320,17 @@ if (import.meta.hot) {
               dockerPath,
               configPath: entryWorkerConfig.configPath
             });
-            const dockerPollIntervalId = setInterval(async () => {
-              if (containerImageTagsSeen?.size) {
-                runningContainerIds = await getContainerIdsByImageTags(
-                  dockerPath,
-                  containerImageTagsSeen
-                );
+            viteDevServer.config.logger.info(
+              colors4.dim(
+                colors4.yellow(
+                  "\n\u26A1\uFE0F Containers successfully built. To rebuild your containers during development, restart the Vite dev server (r + enter)."
+                )
+              )
+            );
+            process.on("exit", async () => {
+              if (containerImageTagsSeen.size) {
+                cleanupContainers(dockerPath, containerImageTagsSeen);
               }
-            }, 2e3);
-            process.on("exit", () => {
-              clearInterval(dockerPollIntervalId);
-              removeContainersByIds(dockerPath, runningContainerIds);
             });
           }
         }
@@ -16316,6 +16389,13 @@ if (import.meta.hot) {
         );
         if (hasDevContainers) {
           const dockerPath = getDockerPath();
+          vitePreviewServer.config.logger.info(
+            colors4.dim(
+              colors4.yellow(
+                "\u2237 Building container images for local preview...\n"
+              )
+            )
+          );
           containerImageTagsSeen = await prepareContainerImages({
             containersConfig: entryWorkerConfig.containers,
             containerBuildId,
@@ -16323,17 +16403,13 @@ if (import.meta.hot) {
             dockerPath,
             configPath: entryWorkerConfig.configPath
           });
-          const dockerPollIntervalId = setInterval(async () => {
-            if (containerImageTagsSeen?.size) {
-              runningContainerIds = await getContainerIdsByImageTags(
-                dockerPath,
-                containerImageTagsSeen
-              );
-            }
-          }, 2e3);
+          vitePreviewServer.config.logger.info(
+            colors4.dim(colors4.yellow("\n\u26A1\uFE0F Containers successfully built.\n"))
+          );
           process.on("exit", () => {
-            clearInterval(dockerPollIntervalId);
-            removeContainersByIds(dockerPath, runningContainerIds);
+            if (containerImageTagsSeen.size) {
+              cleanupContainers(dockerPath, containerImageTagsSeen);
+            }
           });
         }
         handleWebSocket(vitePreviewServer.httpServer, () => {
@@ -16350,13 +16426,15 @@ 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);
+        }
+        debuglog4("buildEnd:", restartingServer ? "restarted" : "disposing");
+        if (!restartingServer) {
+          debuglog4("buildEnd: disposing Miniflare instance");
+          await miniflare?.dispose().catch((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,22 +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;
-async function createModuleRunner(env, webSocket) {
-  if (moduleRunner) {
-    throw new Error("Runner already initialized");
+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`);
     }
-  });
-  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, {
@@ -1246,9 +1301,6 @@ async function createModuleRunner(env, webSocket) {
               body: JSON.stringify(data)
             })
           );
-          if (!response.ok) {
-            throw new Error(await response.text());
-          }
           const result = await response.json();
           return result;
         }
@@ -1257,19 +1309,17 @@ async function createModuleRunner(env, webSocket) {
     },
     {
       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) {
@@ -1282,19 +1332,24 @@ async function createModuleRunner(env, webSocket) {
             )
           });
         }
-        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`);
   }
-  return entrypointValue;
+  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 exportValue;
 }
 
 // src/runner-worker/index.ts
@@ -1315,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) {
@@ -1323,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);
   }
@@ -1367,7 +1422,7 @@ async function getWorkerEntrypointRpcProperty(entrypoint, key) {
   }
   return value;
 }
-function createWorkerEntrypointWrapper(entrypoint) {
+function createWorkerEntrypointWrapper(exportName) {
   class Wrapper extends WorkerEntrypoint {
     constructor(ctx, env) {
       super(ctx, env);
@@ -1377,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);
@@ -1395,54 +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);
-          } 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.`
         );
       }
     };
@@ -1451,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);
@@ -1464,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);
@@ -1475,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);
@@ -1489,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) {
@@ -1513,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);
@@ -1521,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);
@@ -1548,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 } = parsedViteDevMetadataHeader;
-  if (entryPath2 === void 0) {
-    throw new Error(
-      "Unexpected internal error, vite dev metadata header doesn't contain an entryPath value"
-    );
-  }
-  return { entryPath: entryPath2 };
-}
 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.10.2",
+  "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.20250726.0",
-    "wrangler": "4.26.1"
+    "@cloudflare/unenv-preset": "2.6.0",
+    "miniflare": "4.20250803.0",
+    "wrangler": "4.28.0"
   },
   "devDependencies": {
-    "@cloudflare/workers-types": "^4.20250726.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.26.1"
+    "wrangler": "^4.28.0"
   },
   "publishConfig": {
     "access": "public"