@cloudflare/vite-plugin 1.13.1 → 1.13.3

package/dist/index.js

@@ -248,17 +248,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path14, originalPath, doThrow) => {
-      if (!isString2(path14)) {
+    var checkPath = (path15, originalPath, doThrow) => {
+      if (!isString2(path15)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path14) {
+      if (!path15) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path14)) {
+      if (checkPath.isNotRelative(path15)) {
         const r2 = "`path.relative()`d";
         return doThrow(
           `path should be a ${r2} string, but got "${originalPath}"`,
@@ -267,7 +267,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path14) => REGEX_TEST_INVALID_PATH.test(path14);
+    var isNotRelative = (path15) => REGEX_TEST_INVALID_PATH.test(path15);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore = class {
@@ -326,7 +326,7 @@ var require_ignore = __commonJS({
       //   setting `checkUnignored` to `false` could reduce additional
       //   path matching.
       // @returns {TestResult} true if a file is ignored
-      _testOne(path14, checkUnignored) {
+      _testOne(path15, checkUnignored) {
         let ignored = false;
         let unignored = false;
         this._rules.forEach((rule) => {
@@ -334,7 +334,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule.regex.test(path14);
+          const matched = rule.regex.test(path15);
           if (matched) {
             ignored = !negative;
             unignored = negative;
@@ -347,24 +347,24 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache2, checkUnignored, slices) {
-        const path14 = originalPath && checkPath.convert(originalPath);
+        const path15 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path14,
+          path15,
           originalPath,
           this._allowRelativePaths ? RETURN_FALSE : throwError
         );
-        return this._t(path14, cache2, checkUnignored, slices);
+        return this._t(path15, cache2, checkUnignored, slices);
       }
-      _t(path14, cache2, checkUnignored, slices) {
-        if (path14 in cache2) {
-          return cache2[path14];
+      _t(path15, cache2, checkUnignored, slices) {
+        if (path15 in cache2) {
+          return cache2[path15];
         }
         if (!slices) {
-          slices = path14.split(SLASH);
+          slices = path15.split(SLASH);
         }
         slices.pop();
         if (!slices.length) {
-          return cache2[path14] = this._testOne(path14, checkUnignored);
+          return cache2[path15] = this._testOne(path15, checkUnignored);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -372,24 +372,24 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache2[path14] = parent.ignored ? parent : this._testOne(path14, checkUnignored);
+        return cache2[path15] = parent.ignored ? parent : this._testOne(path15, checkUnignored);
       }
-      ignores(path14) {
-        return this._test(path14, this._ignoreCache, false).ignored;
+      ignores(path15) {
+        return this._test(path15, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path14) => !this.ignores(path14);
+        return (path15) => !this.ignores(path15);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path14) {
-        return this._test(path14, this._testCache, true);
+      test(path15) {
+        return this._test(path15, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore(options);
-    var isPathValid = (path14) => checkPath(path14 && checkPath.convert(path14), path14, RETURN_FALSE);
+    var isPathValid = (path15) => checkPath(path15 && checkPath.convert(path15), path15, RETURN_FALSE);
     factory.isPathValid = isPathValid;
     factory.default = factory;
     module.exports = factory;
@@ -400,15 +400,15 @@ var require_ignore = __commonJS({
       const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
       checkPath.convert = makePosix;
       const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-      checkPath.isNotRelative = (path14) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path14) || isNotRelative(path14);
+      checkPath.isNotRelative = (path15) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path15) || isNotRelative(path15);
     }
   }
 });
 
 // src/index.ts
-import assert12 from "node:assert";
+import assert13 from "node:assert";
 import * as fsp2 from "node:fs/promises";
-import * as path13 from "node:path";
+import * as path14 from "node:path";
 import * as util3 from "node:util";
 
 // ../containers-shared/src/utils.ts
@@ -685,8 +685,8 @@ for (let i = 0; i < chars.length; i++) {
   intToChar[i] = c;
   charToInt[c] = i;
 }
-function encodeInteger(builder, num, relative8) {
-  let delta = num - relative8;
+function encodeInteger(builder, num, relative9) {
+  let delta = num - relative9;
   delta = delta < 0 ? -delta << 1 | 1 : delta << 1;
   do {
     let clamped = delta & 31;
@@ -1741,7 +1741,7 @@ var MagicString = class _MagicString {
 // src/index.ts
 import { CoreHeaders, Miniflare } from "miniflare";
 import colors4 from "picocolors";
-import * as vite5 from "vite";
+import * as vite6 from "vite";
 
 // src/constants.ts
 var ROUTER_WORKER_NAME = "__router-worker__";
@@ -1927,11 +1927,11 @@ ${invalidHeaderRulesList}`
 }
 
 // ../workers-shared/utils/configuration/validateURL.ts
-var extractPathname = (path14 = "/", includeSearch, includeHash) => {
-  if (!path14.startsWith("/")) {
-    path14 = `/${path14}`;
+var extractPathname = (path15 = "/", includeSearch, includeHash) => {
+  if (!path15.startsWith("/")) {
+    path15 = `/${path15}`;
   }
-  const url = new URL(`//${path14}`, "relative://");
+  const url = new URL(`//${path15}`, "relative://");
   return `${url.pathname}${includeSearch ? url.search : ""}${includeHash ? url.hash : ""}`;
 };
 var URL_REGEX = /^https:\/\/+(?<host>[^/]+)\/?(?<path>.*)/;
@@ -1964,8 +1964,8 @@ var validateUrl = (token, onlyRelative = false, disallowPorts = false, includeSe
     if (!token.startsWith("/") && onlyRelative) {
       token = `/${token}`;
     }
-    const path14 = PATH_REGEX.exec(token);
-    if (path14) {
+    const path15 = PATH_REGEX.exec(token);
+    if (path15) {
       try {
         return [extractPathname(token, includeSearch, includeHash), void 0];
       } catch {
@@ -2026,7 +2026,7 @@ function parseHeaders(input, {
           });
         }
       }
-      const [path14, pathError] = validateUrl(line, false, true);
+      const [path15, pathError] = validateUrl(line, false, true);
       if (pathError) {
         invalid.push({
           line,
@@ -2037,7 +2037,7 @@ function parseHeaders(input, {
         continue;
       }
       rule = {
-        path: path14,
+        path: path15,
         line,
         headers: {},
         unsetHeaders: []
@@ -3385,12 +3385,12 @@ var Mime = class {
     }
     return this;
   }
-  getType(path14) {
-    if (typeof path14 !== "string")
+  getType(path15) {
+    if (typeof path15 !== "string")
       return null;
-    const last = path14.replace(/^.*[/\\]/s, "").toLowerCase();
+    const last = path15.replace(/^.*[/\\]/s, "").toLowerCase();
     const ext = last.replace(/^.*\./s, "").toLowerCase();
-    const hasPath = last.length < path14.length;
+    const hasPath = last.length < path15.length;
     const hasDot = ext.length < last.length - 1;
     if (!hasDot && hasPath)
       return null;
@@ -3792,8 +3792,8 @@ function getErrorMap() {
   return overrideErrorMap;
 }
 var makeIssue = (params) => {
-  const { data: data2, path: path14, errorMaps, issueData } = params;
-  const fullPath = [...path14, ...issueData.path || []];
+  const { data: data2, path: path15, errorMaps, issueData } = params;
+  const fullPath = [...path15, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -3892,11 +3892,11 @@ var errorUtil;
   errorUtil2.toString = (message) => typeof message === "string" ? message : message === null || message === void 0 ? void 0 : message.message;
 })(errorUtil || (errorUtil = {}));
 var ParseInputLazyPath = class {
-  constructor(parent, value, path14, key) {
+  constructor(parent, value, path15, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path14;
+    this._path = path15;
     this._key = key;
   }
   get path() {
@@ -7446,6 +7446,7 @@ var additionalModuleGlobalRE = new RegExp(
   "g"
 );
 var WORKER_ENTRY_PATH_HEADER = "__VITE_WORKER_ENTRY_PATH__";
+var IS_ENTRY_WORKER_HEADER = "__VITE_IS_ENTRY_WORKER__";
 var VIRTUAL_WORKER_ENTRY = `${virtualPrefix}worker-entry`;
 
 // src/utils.ts
@@ -7463,8 +7464,8 @@ var postfixRE = /[?#].*$/;
 function cleanUrl(url) {
   return url.replace(postfixRE, "");
 }
-function withTrailingSlash(path14) {
-  return path14.endsWith("/") ? path14 : `${path14}/`;
+function withTrailingSlash(path15) {
+  return path15.endsWith("/") ? path15 : `${path15}/`;
 }
 function createRequestHandler(handler) {
   return async (req, res, next) => {
@@ -7554,13 +7555,14 @@ var CloudflareDevEnvironment = class extends vite.DevEnvironment {
     });
     this.#webSocketContainer = webSocketContainer;
   }
-  async initRunner(worker, workerConfig) {
+  async initRunner(worker, workerConfig, isEntryWorker) {
     this.#worker = worker;
     const response = await this.#worker.fetch(
       new URL(INIT_PATH, UNKNOWN_HOST),
       {
         headers: {
           [WORKER_ENTRY_PATH_HEADER]: workerConfig.main,
+          [IS_ENTRY_WORKER_HEADER]: String(isEntryWorker),
           upgrade: "websocket"
         }
       }
@@ -7677,7 +7679,8 @@ function initRunners(resolvedPluginConfig, viteDevServer, miniflare2) {
       async ([environmentName, workerConfig]) => {
         debuglog2("Initializing worker:", workerConfig.name);
         const worker = await miniflare2.getWorker(workerConfig.name);
-        return viteDevServer.environments[environmentName].initRunner(worker, workerConfig);
+        const isEntryWorker = environmentName === resolvedPluginConfig.entryWorkerEnvironmentName;
+        return viteDevServer.environments[environmentName].initRunner(worker, workerConfig, isEntryWorker);
       }
     )
   );
@@ -8149,13 +8152,13 @@ var getQueryString = (params) => {
 };
 var getUrl = (config, options) => {
   const encoder = config.ENCODE_PATH || encodeURI;
-  const path14 = options.url.replace("{api-version}", config.VERSION).replace(/{(.*?)}/g, (substring, group) => {
+  const path15 = options.url.replace("{api-version}", config.VERSION).replace(/{(.*?)}/g, (substring, group) => {
     if (options.path?.hasOwnProperty(group)) {
       return encoder(String(options.path[group]));
     }
     return substring;
   });
-  const url = `${config.BASE}${path14}`;
+  const url = `${config.BASE}${path15}`;
   if (options.query) {
     return `${url}${getQueryString(options.query)}`;
   }
@@ -9460,9 +9463,9 @@ function getPreviewModules(main, modulesRules) {
         path: entryPath
       },
       ...modulesRules.flatMap(
-        ({ type, include }) => globSync(include, { cwd: rootPath, ignore: entryPath }).map((path14) => ({
+        ({ type, include }) => globSync(include, { cwd: rootPath, ignore: entryPath }).map((path15) => ({
           type,
-          path: path14
+          path: path15
         }))
       )
     ]
@@ -15133,17 +15136,17 @@ function withTrailingSlash2(input = "", respectQueryAndFragment) {
   if (hasTrailingSlash(input, true)) {
     return input || "/";
   }
-  let path14 = input;
+  let path15 = input;
   let fragment = "";
   const fragmentIndex = input.indexOf("#");
   if (fragmentIndex >= 0) {
-    path14 = input.slice(0, fragmentIndex);
+    path15 = input.slice(0, fragmentIndex);
     fragment = input.slice(fragmentIndex);
-    if (!path14) {
+    if (!path15) {
       return fragment;
     }
   }
-  const [s0, ...s] = path14.split("?");
+  const [s0, ...s] = path15.split("?");
   return s0 + "/" + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
 }
 function isNonEmptyURL(url) {
@@ -15177,8 +15180,8 @@ import path9, { dirname as dirname6 } from "node:path";
 import v8 from "node:v8";
 import { format as format2, inspect } from "node:util";
 var BUILTIN_MODULES = new Set(builtinModules);
-function normalizeSlash(path14) {
-  return path14.replace(/\\/g, "/");
+function normalizeSlash(path15) {
+  return path15.replace(/\\/g, "/");
 }
 var own$1 = {}.hasOwnProperty;
 var classRegExp = /^([A-Z][a-z\d]*)+$/;
@@ -15291,8 +15294,8 @@ codes.ERR_INVALID_PACKAGE_CONFIG = createError(
    * @param {string} [base]
    * @param {string} [message]
    */
-  (path14, base, message) => {
-    return `Invalid package config ${path14}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
+  (path15, base, message) => {
+    return `Invalid package config ${path15}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
   },
   Error
 );
@@ -15324,8 +15327,8 @@ codes.ERR_MODULE_NOT_FOUND = createError(
    * @param {string} base
    * @param {boolean} [exactUrl]
    */
-  (path14, base, exactUrl = false) => {
-    return `Cannot find ${exactUrl ? "module" : "package"} '${path14}' imported from ${base}`;
+  (path15, base, exactUrl = false) => {
+    return `Cannot find ${exactUrl ? "module" : "package"} '${path15}' imported from ${base}`;
   },
   Error
 );
@@ -15376,8 +15379,8 @@ codes.ERR_UNKNOWN_FILE_EXTENSION = createError(
    * @param {string} extension
    * @param {string} path
    */
-  (extension, path14) => {
-    return `Unknown file extension "${extension}" for ${path14}`;
+  (extension, path15) => {
+    return `Unknown file extension "${extension}" for ${path15}`;
   },
   TypeError
 );
@@ -15749,9 +15752,9 @@ Default "index" lookups for the main are deprecated for ES modules.`,
     );
   }
 }
-function tryStatSync(path14) {
+function tryStatSync(path15) {
   try {
-    return statSync2(path14);
+    return statSync2(path15);
   } catch {
   }
 }
@@ -16676,8 +16679,8 @@ var nodeJsBuiltins = /* @__PURE__ */ new Set([
 var NODEJS_MODULES_RE = new RegExp(
   `^(node:)?(${builtinModules2.join("|")})$`
 );
-function isNodeAlsModule(path14) {
-  return /^(node:)?async_hooks$/.test(path14);
+function isNodeAlsModule(path15) {
+  return /^(node:)?async_hooks$/.test(path15);
 }
 function assertHasNodeJsCompat(nodeJsCompat) {
   assert8(nodeJsCompat, `expected nodeJsCompat to be defined`);
@@ -16722,9 +16725,25 @@ var NodeJsCompatWarnings = class {
   }
 };
 
+// src/output-config.ts
+import assert9 from "node:assert";
+import * as path11 from "node:path";
+import "vite";
+function getAssetsDirectory(workerOutputDirectory, resolvedViteConfig) {
+  const clientOutputDirectory = resolvedViteConfig.environments.client?.build.outDir;
+  assert9(
+    clientOutputDirectory,
+    "Unexpected error: client output directory is undefined"
+  );
+  return path11.relative(
+    path11.resolve(resolvedViteConfig.root, workerOutputDirectory),
+    path11.resolve(resolvedViteConfig.root, clientOutputDirectory)
+  );
+}
+
 // src/plugin-config.ts
-import assert10 from "node:assert";
-import * as path12 from "node:path";
+import assert11 from "node:assert";
+import * as path13 from "node:path";
 
 // ../workers-shared/utils/configuration/parseStaticRouting.ts
 function parseStaticRouting(input) {
@@ -16803,12 +16822,12 @@ var formatInvalidRoutes = (invalidRules) => {
 };
 
 // src/plugin-config.ts
-import * as vite4 from "vite";
+import * as vite5 from "vite";
 
 // src/workers-configs.ts
-import assert9 from "node:assert";
+import assert10 from "node:assert";
 import * as fs5 from "node:fs";
-import * as path11 from "node:path";
+import * as path12 from "node:path";
 import { unstable_readConfig as unstable_readConfig2 } from "wrangler";
 var nonApplicableWorkerConfigs = {
   /**
@@ -16904,7 +16923,7 @@ function getWarningForWorkersConfigs(configs) {
     const lines2 = [
       `
 
-\x1B[43mWARNING\x1B[0m: your worker config${configs.entryWorker.config.configPath ? ` (at \`${path11.relative("", configs.entryWorker.config.configPath)}\`)` : ""} contains the following configuration options which are ignored since they are not applicable when using Vite:`
+\x1B[43mWARNING\x1B[0m: your worker config${configs.entryWorker.config.configPath ? ` (at \`${path12.relative("", configs.entryWorker.config.configPath)}\`)` : ""} contains the following configuration options which are ignored since they are not applicable when using Vite:`
     ];
     nonApplicableLines.forEach((line) => lines2.push(line));
     lines2.push("");
@@ -16918,7 +16937,7 @@ function getWarningForWorkersConfigs(configs) {
     );
     if (nonApplicableLines.length > 0) {
       lines.push(
-        `  - (${isEntryWorker ? "entry" : "auxiliary"}) worker${workerConfig.config.name ? ` "${workerConfig.config.name}"` : ""}${workerConfig.config.configPath ? ` (config at \`${path11.relative("", workerConfig.config.configPath)}\`)` : ""}`
+        `  - (${isEntryWorker ? "entry" : "auxiliary"}) worker${workerConfig.config.name ? ` "${workerConfig.config.name}"` : ""}${workerConfig.config.configPath ? ` (config at \`${path12.relative("", workerConfig.config.configPath)}\`)` : ""}`
       );
       nonApplicableLines.forEach((line) => lines.push(line));
     }
@@ -17010,7 +17029,7 @@ function maybeResolveMain(main, configPath) {
   if (!ENTRY_MODULE_EXTENSIONS.some((extension) => main.endsWith(extension))) {
     return main;
   }
-  const resolvedMain = path11.resolve(path11.dirname(configPath), main);
+  const resolvedMain = path12.resolve(path12.dirname(configPath), main);
   if (!fs5.existsSync(resolvedMain)) {
     throw new Error(
       `The provided Wrangler config main field (${resolvedMain}) doesn't point to an existing file`
@@ -17020,10 +17039,10 @@ function maybeResolveMain(main, configPath) {
 }
 function getValidatedWranglerConfigPath(root, requestedConfigPath, isForAuxiliaryWorker = false) {
   if (requestedConfigPath) {
-    const configPath2 = path11.resolve(root, requestedConfigPath);
+    const configPath2 = path12.resolve(root, requestedConfigPath);
     const forAuxiliaryWorkerErrorMessage = isForAuxiliaryWorker ? " requested for one of your auxiliary workers" : "";
     const errorMessagePrefix = `The provided configPath (${configPath2})${forAuxiliaryWorkerErrorMessage}`;
-    const fileExtension = path11.extname(configPath2).slice(1);
+    const fileExtension = path12.extname(configPath2).slice(1);
     if (!allowedWranglerConfigExtensions.includes(fileExtension)) {
       const foundExtensionMessage = !fileExtension ? "no extension found" : `"${fileExtension}" found`;
       throw new Error(
@@ -17043,7 +17062,7 @@ function getValidatedWranglerConfigPath(root, requestedConfigPath, isForAuxiliar
     }
     return configPath2;
   }
-  assert9(
+  assert10(
     isForAuxiliaryWorker === false,
     "Unexpected Error: trying to find the wrangler config for an auxiliary worker"
   );
@@ -17057,7 +17076,7 @@ function getValidatedWranglerConfigPath(root, requestedConfigPath, isForAuxiliar
 }
 function findWranglerConfig(root) {
   for (const extension of allowedWranglerConfigExtensions) {
-    const configPath = path11.join(root, `wrangler.${extension}`);
+    const configPath = path12.join(root, `wrangler.${extension}`);
     if (fs5.existsSync(configPath)) {
       return configPath;
     }
@@ -17075,7 +17094,7 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
     inspectorPort: pluginConfig.inspectorPort,
     experimental: pluginConfig.experimental ?? {}
   };
-  const root = userConfig.root ? path12.resolve(userConfig.root) : process.cwd();
+  const root = userConfig.root ? path13.resolve(userConfig.root) : process.cwd();
   if (viteEnv.isPreview) {
     return {
       ...shared,
@@ -17084,7 +17103,7 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
     };
   }
   const configPaths = /* @__PURE__ */ new Set();
-  const { CLOUDFLARE_ENV: cloudflareEnv } = vite4.loadEnv(
+  const { CLOUDFLARE_ENV: cloudflareEnv } = vite5.loadEnv(
     viteEnv.mode,
     root,
     /* prefixes */
@@ -17140,7 +17159,7 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
       }
     );
     auxiliaryWorkersResolvedConfigs.push(workerResolvedConfig);
-    assert10(
+    assert11(
       workerResolvedConfig.type === "worker",
       "Unexpected error: received AssetsOnlyResult with auxiliary workers."
     );
@@ -17175,26 +17194,26 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
   };
 }
 function assertIsNotPreview(resolvedPluginConfig) {
-  assert10(
+  assert11(
     resolvedPluginConfig.type !== "preview",
     `Expected "assets-only" or "workers" plugin config`
   );
 }
 function assertIsPreview(resolvedPluginConfig) {
-  assert10(
+  assert11(
     resolvedPluginConfig.type === "preview",
     `Expected "preview" plugin config`
   );
 }
 
 // src/vite-config.ts
-import assert11 from "node:assert";
+import assert12 from "node:assert";
 function validateWorkerEnvironmentOptions(resolvedPluginConfig, resolvedViteConfig) {
   const workerEnvironmentNames = Object.keys(resolvedPluginConfig.workers);
   const disallowedEnvironmentOptionsMap = /* @__PURE__ */ new Map();
   for (const environmentName of workerEnvironmentNames) {
     const environmentOptions = resolvedViteConfig.environments[environmentName];
-    assert11(
+    assert12(
       environmentOptions,
       `Missing environment config for "${environmentName}"`
     );
@@ -17389,46 +17408,36 @@ if (import.meta.hot) {
       },
       generateBundle(_, bundle) {
         assertIsNotPreview(resolvedPluginConfig);
-        let config;
+        let outputConfig;
         if (resolvedPluginConfig.type === "workers") {
-          const workerConfig = resolvedPluginConfig.workers[this.environment.name];
-          if (!workerConfig) {
+          const inputConfig = resolvedPluginConfig.workers[this.environment.name];
+          if (!inputConfig) {
             return;
           }
           const entryChunk = Object.values(bundle).find(
             (chunk) => chunk.type === "chunk" && chunk.isEntry && chunk.name === MAIN_ENTRY_NAME
           );
-          assert12(
+          assert13(
             entryChunk,
             `Expected entry chunk with name "${MAIN_ENTRY_NAME}"`
           );
-          workerConfig.main = entryChunk.fileName;
-          workerConfig.no_bundle = true;
-          workerConfig.rules = [
-            { type: "ESModule", globs: ["**/*.js", "**/*.mjs"] }
-          ];
           const isEntryWorker = this.environment.name === resolvedPluginConfig.entryWorkerEnvironmentName;
-          if (isEntryWorker) {
-            const workerOutputDirectory = this.environment.config.build.outDir;
-            const clientOutputDirectory = resolvedViteConfig.environments.client?.build.outDir;
-            assert12(
-              clientOutputDirectory,
-              "Unexpected error: client output directory is undefined"
-            );
-            workerConfig.assets = {
-              ...workerConfig.assets,
-              directory: path13.relative(
-                path13.resolve(resolvedViteConfig.root, workerOutputDirectory),
-                path13.resolve(resolvedViteConfig.root, clientOutputDirectory)
+          outputConfig = {
+            ...inputConfig,
+            main: entryChunk.fileName,
+            no_bundle: true,
+            rules: [{ type: "ESModule", globs: ["**/*.js", "**/*.mjs"] }],
+            assets: isEntryWorker ? {
+              ...inputConfig.assets,
+              directory: getAssetsDirectory(
+                this.environment.config.build.outDir,
+                resolvedViteConfig
               )
-            };
-          } else {
-            workerConfig.assets = void 0;
-          }
-          config = workerConfig;
-          if (workerConfig.configPath) {
+            } : void 0
+          };
+          if (inputConfig.configPath) {
             const localDevVars = getLocalDevVarsForPreview(
-              workerConfig.configPath,
+              inputConfig.configPath,
               resolvedPluginConfig.cloudflareEnv
             );
             if (localDevVars) {
@@ -17440,10 +17449,13 @@ if (import.meta.hot) {
             }
           }
         } else if (this.environment.name === "client") {
-          const assetsOnlyConfig = resolvedPluginConfig.config;
-          assetsOnlyConfig.assets = {
-            ...assetsOnlyConfig.assets,
-            directory: "."
+          const inputConfig = resolvedPluginConfig.config;
+          outputConfig = {
+            ...inputConfig,
+            assets: {
+              ...inputConfig.assets,
+              directory: "."
+            }
           };
           const filesToAssetsIgnore = ["wrangler.json", ".dev.vars"];
           this.emitFile({
@@ -17452,18 +17464,17 @@ if (import.meta.hot) {
             source: `${filesToAssetsIgnore.join("\n")}
 `
           });
-          config = assetsOnlyConfig;
         }
-        if (!config) {
+        if (!outputConfig) {
           return;
         }
-        if (config.unsafe && Object.keys(config.unsafe).length === 0) {
-          config.unsafe = void 0;
+        if (outputConfig.unsafe && Object.keys(outputConfig.unsafe).length === 0) {
+          outputConfig.unsafe = void 0;
         }
         this.emitFile({
           type: "asset",
           fileName: "wrangler.json",
-          source: JSON.stringify(config)
+          source: JSON.stringify(outputConfig)
         });
       },
       writeBundle() {
@@ -17530,13 +17541,13 @@ if (import.meta.hot) {
         }
         let preMiddleware;
         if (resolvedPluginConfig.type === "workers") {
-          assert12(entryWorkerConfig, `No entry Worker config`);
+          assert13(entryWorkerConfig, `No entry Worker config`);
           debuglog4("Initializing the Vite module runners");
           await initRunners(resolvedPluginConfig, viteDevServer, miniflare);
           const entryWorkerName = entryWorkerConfig.name;
           if (viteDevServer.httpServer) {
             handleWebSocket(viteDevServer.httpServer, async () => {
-              assert12(miniflare, `Miniflare not defined`);
+              assert13(miniflare, `Miniflare not defined`);
               const entryWorker = await miniflare.getWorker(entryWorkerName);
               return entryWorker.fetch;
             });
@@ -17550,12 +17561,12 @@ if (import.meta.hot) {
               staticRouting.user_worker
             );
             const userWorkerHandler = createRequestHandler(async (request2) => {
-              assert12(miniflare, `Miniflare not defined`);
+              assert13(miniflare, `Miniflare not defined`);
               const userWorker = await miniflare.getWorker(entryWorkerName);
               return userWorker.fetch(request2, { redirect: "manual" });
             });
             preMiddleware = async (req, res, next) => {
-              assert12(req.url, `req.url not defined`);
+              assert13(req.url, `req.url not defined`);
               const request2 = new Request(new URL(req.url, UNKNOWN_HOST));
               if (req[kRequestType] === "asset") {
                 next();
@@ -17604,7 +17615,7 @@ if (import.meta.hot) {
             const cachedTransformMiddlewareIndex = middlewareStack.findIndex(
               (middleware) => "name" in middleware.handle && middleware.handle.name === "viteCachedTransformMiddleware"
             );
-            assert12(
+            assert13(
               cachedTransformMiddlewareIndex !== -1,
               "Failed to find viteCachedTransformMiddleware"
             );
@@ -17615,7 +17626,7 @@ if (import.meta.hot) {
           }
           viteDevServer.middlewares.use(
             createRequestHandler(async (request2, req) => {
-              assert12(miniflare, `Miniflare not defined`);
+              assert13(miniflare, `Miniflare not defined`);
               if (req[kRequestType] === "asset") {
                 const assetWorker = await miniflare.getWorker(ASSET_WORKER_NAME);
                 return assetWorker.fetch(request2, { redirect: "manual" });
@@ -17677,12 +17688,12 @@ if (import.meta.hot) {
           });
         }
         handleWebSocket(vitePreviewServer.httpServer, () => {
-          assert12(miniflare, `Miniflare not defined`);
+          assert13(miniflare, `Miniflare not defined`);
           return miniflare.dispatchFetch;
         });
         vitePreviewServer.middlewares.use(
           createRequestHandler((request2) => {
-            assert12(miniflare, `Miniflare not defined`);
+            assert13(miniflare, `Miniflare not defined`);
             return miniflare.dispatchFetch(request2, { redirect: "manual" });
           })
         );
@@ -17775,7 +17786,7 @@ if (import.meta.hot) {
         for (const match of matches) {
           magicString ??= new MagicString(code);
           const [full, _, modulePath] = match;
-          assert12(
+          assert13(
             modulePath,
             `Unexpected error: module path not found in reference ${full}.`
           );
@@ -17789,13 +17800,13 @@ if (import.meta.hot) {
           }
           const referenceId = this.emitFile({
             type: "asset",
-            name: path13.basename(modulePath),
+            name: path14.basename(modulePath),
             originalFileName: modulePath,
             source
           });
           const emittedFileName = this.getFileName(referenceId);
-          const relativePath = vite5.normalizePath(
-            path13.relative(path13.dirname(chunk.fileName), emittedFileName)
+          const relativePath = vite6.normalizePath(
+            path14.relative(path14.dirname(chunk.fileName), emittedFileName)
           );
           const importPath = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
           magicString.update(
@@ -17854,7 +17865,7 @@ if (import.meta.hot) {
           return this.resolve(source, importer, options);
         }
         if (this.environment.mode === "dev") {
-          assert12(
+          assert13(
             this.environment.depsOptimizer,
             "depsOptimizer is required in dev mode"
           );
@@ -17937,13 +17948,13 @@ export default mod.default ?? {};
                     setup(build) {
                       build.onResolve(
                         { filter: NODEJS_MODULES_RE },
-                        ({ path: path14, importer }) => {
-                          if (hasNodeJsAls(workerConfig) && isNodeAlsModule(path14)) {
+                        ({ path: path15, importer }) => {
+                          if (hasNodeJsAls(workerConfig) && isNodeAlsModule(path15)) {
                             return;
                           }
                           const nodeJsCompatWarnings = nodeJsCompatWarningsMap.get(workerConfig);
-                          nodeJsCompatWarnings?.registerImport(path14, importer);
-                          return { path: path14, external: true };
+                          nodeJsCompatWarnings?.registerImport(path15, importer);
+                          return { path: path15, external: true };
                         }
                       );
                     }
@@ -18028,7 +18039,7 @@ export default mod.default ?? {};
           addDebugToVitePrintUrls(vitePreviewServer);
         }
         const workerNames = resolvedPluginConfig.workers.map((worker) => {
-          assert12(worker.name, "Expected the Worker to have a name");
+          assert13(worker.name, "Expected the Worker to have a name");
           return worker.name;
         });
         vitePreviewServer.middlewares.use(DEBUG_PATH, async (_, res, next) => {
@@ -18054,11 +18065,11 @@ export default mod.default ?? {};
         assertIsNotPreview(resolvedPluginConfig);
         if (resolvedPluginConfig.type === "workers") {
           const entryWorkerConfig = getEntryWorkerConfig(resolvedPluginConfig);
-          assert12(entryWorkerConfig, `No entry Worker config`);
+          assert13(entryWorkerConfig, `No entry Worker config`);
           const entryWorkerName = entryWorkerConfig.name;
           viteDevServer.middlewares.use("/cdn-cgi/", (req, res, next) => {
             const requestHandler = createRequestHandler((request2) => {
-              assert12(miniflare, `Miniflare not defined`);
+              assert13(miniflare, `Miniflare not defined`);
               request2.headers.set(CoreHeaders.ROUTE_OVERRIDE, entryWorkerName);
               return miniflare.dispatchFetch(request2, { redirect: "manual" });
             });

package/dist/runner-worker/index.js

@@ -26,6 +26,7 @@ var additionalModuleGlobalRE = new RegExp(
   "g"
 );
 var WORKER_ENTRY_PATH_HEADER = "__VITE_WORKER_ENTRY_PATH__";
+var IS_ENTRY_WORKER_HEADER = "__VITE_IS_ENTRY_WORKER__";
 var VIRTUAL_WORKER_ENTRY = `${virtualPrefix}worker-entry`;
 
 // src/runner-worker/env.ts
@@ -39,6 +40,29 @@ function stripInternalEnv(internalEnv) {
   return userEnv;
 }
 
+// src/runner-worker/errors.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)
+  };
+}
+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" }
+    });
+  }
+}
+
 // src/runner-worker/module-runner.ts
 import { DurableObject } from "cloudflare:workers";
 
@@ -1314,17 +1338,9 @@ async function createModuleRunner(env, webSocket) {
     {
       async runInlinedModule(context, transformed, module) {
         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.seal(context[ssrModuleExportsKey]);
-        } catch (error) {
-          if (error instanceof Error) {
-            error.message = `Error running module "${module.url}".
-${error.message}.`;
-          }
-          throw error;
-        }
+        const fn = env.__VITE_UNSAFE_EVAL__.eval(code, module.id);
+        await fn(...Object.values(context));
+        Object.seal(context[ssrModuleExportsKey]);
       },
       async runExternalModule(filepath) {
         if (filepath === "cloudflare:workers") {
@@ -1375,6 +1391,7 @@ var DURABLE_OBJECT_KEYS = [
 ];
 var WORKFLOW_ENTRYPOINT_KEYS = ["run"];
 var workerEntryPath = "";
+var isEntryWorker = false;
 function getRpcPropertyCallableThenable(key, property) {
   const fn = async function(...args) {
     const maybeFn = await property;
@@ -1453,56 +1470,67 @@ function createWorkerEntrypointWrapper(exportName) {
   }
   for (const key of WORKER_ENTRYPOINT_KEYS) {
     Wrapper.prototype[key] = async function(arg) {
-      if (key === "fetch") {
-        const request = arg;
-        const url = new URL(request.url);
-        if (url.pathname === INIT_PATH) {
-          const workerEntryPathHeader = request.headers.get(
-            WORKER_ENTRY_PATH_HEADER
-          );
-          if (!workerEntryPathHeader) {
-            throw new Error(
-              `Unexpected error: "${WORKER_ENTRY_PATH_HEADER}" header not set.`
+      return maybeCaptureError({ isEntryWorker, exportName, key }, async () => {
+        if (key === "fetch") {
+          const request = arg;
+          const url = new URL(request.url);
+          if (url.pathname === INIT_PATH) {
+            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 = workerEntryPathHeader;
+            isEntryWorker = isEntryWorkerHeader === "true";
+            const stub = this.env.__VITE_RUNNER_OBJECT__.get("singleton");
+            return stub.fetch(request);
           }
-          workerEntryPath = workerEntryPathHeader;
-          const stub = this.env.__VITE_RUNNER_OBJECT__.get("singleton");
-          return stub.fetch(request);
-        }
-      }
-      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 ctor = exportValue;
-        const instance = new ctor(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.`
+        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 ctor = exportValue;
+          const instance = new ctor(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 new TypeError(
+            `Expected "${exportName}" export of "${workerEntryPath}" to be an object or a class.`
           );
         }
-        return maybeFn.call(instance, arg);
-      } else {
-        return new TypeError(
-          `Expected "${exportName}" export of "${workerEntryPath}" to be an object or a class.`
-        );
-      }
+      });
     };
   }
   return Wrapper;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudflare/vite-plugin",
-  "version": "1.13.1",
+  "version": "1.13.3",
   "description": "Cloudflare plugin for Vite",
   "keywords": [
     "cloudflare",
@@ -39,12 +39,12 @@
     "tinyglobby": "^0.2.12",
     "unenv": "2.0.0-rc.21",
     "ws": "8.18.0",
-    "@cloudflare/unenv-preset": "2.7.3",
-    "miniflare": "4.20250906.2",
-    "wrangler": "4.37.0"
+    "@cloudflare/unenv-preset": "2.7.4",
+    "miniflare": "4.20250917.0",
+    "wrangler": "4.38.0"
   },
   "devDependencies": {
-    "@cloudflare/workers-types": "^4.20250906.0",
+    "@cloudflare/workers-types": "^4.20250917.0",
     "@types/node": "^22.10.1",
     "@types/ws": "^8.5.13",
     "magic-string": "^0.30.12",
@@ -53,14 +53,14 @@
     "typescript": "^5.8.3",
     "vite": "7.0.0",
     "vitest": "~3.2.0",
-    "@cloudflare/containers-shared": "0.2.10",
     "@cloudflare/mock-npm-registry": "0.0.0",
+    "@cloudflare/containers-shared": "0.2.10",
     "@cloudflare/workers-shared": "0.18.8",
     "@cloudflare/workers-tsconfig": "0.0.0"
   },
   "peerDependencies": {
     "vite": "^6.1.0 || ^7.0.0",
-    "wrangler": "^4.37.0"
+    "wrangler": "^4.38.0"
   },
   "publishConfig": {
     "access": "public"