@cloudflare/vite-plugin 1.5.0 → 1.6.0

package/dist/index.js

@@ -248,17 +248,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path10, originalPath, doThrow) => {
-      if (!isString(path10)) {
+    var checkPath = (path11, originalPath, doThrow) => {
+      if (!isString(path11)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path10) {
+      if (!path11) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path10)) {
+      if (checkPath.isNotRelative(path11)) {
         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 = (path10) => REGEX_TEST_INVALID_PATH.test(path10);
+    var isNotRelative = (path11) => REGEX_TEST_INVALID_PATH.test(path11);
     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(path10, checkUnignored) {
+      _testOne(path11, 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(path10);
+          const matched = rule.regex.test(path11);
           if (matched) {
             ignored = !negative;
             unignored = negative;
@@ -347,24 +347,24 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache2, checkUnignored, slices) {
-        const path10 = originalPath && checkPath.convert(originalPath);
+        const path11 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path10,
+          path11,
           originalPath,
           this._allowRelativePaths ? RETURN_FALSE : throwError
         );
-        return this._t(path10, cache2, checkUnignored, slices);
+        return this._t(path11, cache2, checkUnignored, slices);
       }
-      _t(path10, cache2, checkUnignored, slices) {
-        if (path10 in cache2) {
-          return cache2[path10];
+      _t(path11, cache2, checkUnignored, slices) {
+        if (path11 in cache2) {
+          return cache2[path11];
         }
         if (!slices) {
-          slices = path10.split(SLASH);
+          slices = path11.split(SLASH);
         }
         slices.pop();
         if (!slices.length) {
-          return cache2[path10] = this._testOne(path10, checkUnignored);
+          return cache2[path11] = this._testOne(path11, checkUnignored);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -372,24 +372,24 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache2[path10] = parent.ignored ? parent : this._testOne(path10, checkUnignored);
+        return cache2[path11] = parent.ignored ? parent : this._testOne(path11, checkUnignored);
       }
-      ignores(path10) {
-        return this._test(path10, this._ignoreCache, false).ignored;
+      ignores(path11) {
+        return this._test(path11, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path10) => !this.ignores(path10);
+        return (path11) => !this.ignores(path11);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path10) {
-        return this._test(path10, this._testCache, true);
+      test(path11) {
+        return this._test(path11, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore(options);
-    var isPathValid = (path10) => checkPath(path10 && checkPath.convert(path10), path10, RETURN_FALSE);
+    var isPathValid = (path11) => checkPath(path11 && checkPath.convert(path11), path11, RETURN_FALSE);
     factory.isPathValid = isPathValid;
     factory.default = factory;
     module.exports = factory;
@@ -400,7 +400,7 @@ 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 = (path10) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path10) || isNotRelative(path10);
+      checkPath.isNotRelative = (path11) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path11) || isNotRelative(path11);
     }
   }
 });
@@ -443,11 +443,11 @@ var require_Mime = __commonJS({
         }
       }
     };
-    Mime.prototype.getType = function(path10) {
-      path10 = String(path10);
-      let last = path10.replace(/^.*[/\\]/, "").toLowerCase();
+    Mime.prototype.getType = function(path11) {
+      path11 = String(path11);
+      let last = path11.replace(/^.*[/\\]/, "").toLowerCase();
       let ext = last.replace(/^.*\./, "").toLowerCase();
-      let hasPath = last.length < path10.length;
+      let hasPath = last.length < path11.length;
       let hasDot = ext.length < last.length - 1;
       return (hasDot || !hasPath) && this._types[ext] || null;
     };
@@ -485,10 +485,10 @@ var require_mime = __commonJS({
 });
 
 // src/index.ts
-import assert10 from "node:assert";
-import * as fs5 from "node:fs";
+import assert11 from "node:assert";
+import * as fs6 from "node:fs";
 import * as fsp2 from "node:fs/promises";
-import * as path9 from "node:path";
+import * as path10 from "node:path";
 import { createRequest, sendResponse } from "@mjackson/node-fetch-server";
 import replace from "@rollup/plugin-replace";
 
@@ -503,8 +503,8 @@ for (let i = 0; i < chars.length; i++) {
   intToChar[i] = c;
   charToInt[c] = i;
 }
-function encodeInteger(builder, num, relative6) {
-  let delta = num - relative6;
+function encodeInteger(builder, num, relative7) {
+  let delta = num - relative7;
   delta = delta < 0 ? -delta << 1 | 1 : delta << 1;
   do {
     let clamped = delta & 31;
@@ -1558,7 +1558,7 @@ var MagicString = class _MagicString {
 
 // src/index.ts
 import { Miniflare } from "miniflare";
-import colors3 from "picocolors";
+import colors4 from "picocolors";
 import * as vite7 from "vite";
 
 // src/constants.ts
@@ -1728,11 +1728,11 @@ ${invalidHeaderRulesList}`
 }
 
 // ../workers-shared/utils/configuration/validateURL.ts
-var extractPathname = (path10 = "/", includeSearch, includeHash) => {
-  if (!path10.startsWith("/")) {
-    path10 = `/${path10}`;
+var extractPathname = (path11 = "/", includeSearch, includeHash) => {
+  if (!path11.startsWith("/")) {
+    path11 = `/${path11}`;
   }
-  const url = new URL(`//${path10}`, "relative://");
+  const url = new URL(`//${path11}`, "relative://");
   return `${url.pathname}${includeSearch ? url.search : ""}${includeHash ? url.hash : ""}`;
 };
 var URL_REGEX = /^https:\/\/+(?<host>[^/]+)\/?(?<path>.*)/;
@@ -1765,8 +1765,8 @@ var validateUrl = (token, onlyRelative = false, disallowPorts = false, includeSe
     if (!token.startsWith("/") && onlyRelative) {
       token = `/${token}`;
     }
-    const path10 = PATH_REGEX.exec(token);
-    if (path10) {
+    const path11 = PATH_REGEX.exec(token);
+    if (path11) {
       try {
         return [extractPathname(token, includeSearch, includeHash), void 0];
       } catch {
@@ -1827,7 +1827,7 @@ function parseHeaders(input, {
           });
         }
       }
-      const [path10, pathError] = validateUrl(line, false, true);
+      const [path11, pathError] = validateUrl(line, false, true);
       if (pathError) {
         invalid.push({
           line,
@@ -1838,7 +1838,7 @@ function parseHeaders(input, {
         continue;
       }
       rule = {
-        path: path10,
+        path: path11,
         line,
         headers: {},
         unsetHeaders: []
@@ -2413,8 +2413,8 @@ function getErrorMap() {
   return overrideErrorMap;
 }
 var makeIssue = (params) => {
-  const { data: data2, path: path10, errorMaps, issueData } = params;
-  const fullPath = [...path10, ...issueData.path || []];
+  const { data: data2, path: path11, errorMaps, issueData } = params;
+  const fullPath = [...path11, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -2513,11 +2513,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, path10, key) {
+  constructor(parent, value, path11, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path10;
+    this._path = path11;
     this._key = key;
   }
   get path() {
@@ -5788,8 +5788,13 @@ var InternalConfigSchema = z.object({
   script_id: z.number().optional(),
   debug: z.boolean().optional()
 });
+var StaticRoutingSchema = z.object({
+  user_worker: z.array(z.string()),
+  asset_worker: z.array(z.string()).optional()
+});
 var RouterConfigSchema = z.object({
   invoke_user_worker_ahead_of_assets: z.boolean().optional(),
+  static_routing: StaticRoutingSchema.optional(),
   has_user_worker: z.boolean().optional(),
   ...InternalConfigSchema.shape
 });
@@ -5830,6 +5835,7 @@ var AssetConfigSchema = z.object({
   not_found_handling: z.enum(["single-page-application", "404-page", "none"]).optional(),
   redirects: RedirectsSchema,
   headers: HeadersSchema,
+  has_static_routing: z.boolean().optional(),
   ...InternalConfigSchema.shape
 });
 
@@ -5906,14 +5912,147 @@ function getHeadersConfigPath(config) {
   return path.join(config.publicDir, HEADERS_FILENAME);
 }
 
+// src/build.ts
+import assert from "node:assert";
+import * as fs from "node:fs";
+import * as path2 from "node:path";
+import colors from "picocolors";
+function createBuildApp(resolvedPluginConfig) {
+  return async (builder) => {
+    const clientEnvironment = builder.environments.client;
+    assert(clientEnvironment, `No "client" environment`);
+    const defaultHtmlPath = path2.resolve(builder.config.root, "index.html");
+    const hasClientEntry = clientEnvironment.config.build.rollupOptions.input || fs.existsSync(defaultHtmlPath);
+    if (resolvedPluginConfig.type === "assets-only") {
+      if (hasClientEntry) {
+        await builder.build(clientEnvironment);
+      } else if (getHasPublicAssets(builder.config)) {
+        await fallbackBuild(builder, clientEnvironment);
+      }
+      return;
+    }
+    const workerEnvironments = Object.keys(resolvedPluginConfig.workers).map(
+      (environmentName) => {
+        const environment = builder.environments[environmentName];
+        assert(environment, `"${environmentName}" environment not found`);
+        return environment;
+      }
+    );
+    await Promise.all(
+      workerEnvironments.map((environment) => builder.build(environment))
+    );
+    const { entryWorkerEnvironmentName } = resolvedPluginConfig;
+    const entryWorkerEnvironment = builder.environments[entryWorkerEnvironmentName];
+    assert(
+      entryWorkerEnvironment,
+      `No "${entryWorkerEnvironmentName}" environment`
+    );
+    const entryWorkerBuildDirectory = path2.resolve(
+      builder.config.root,
+      entryWorkerEnvironment.config.build.outDir
+    );
+    const entryWorkerManifest = loadViteManifest(entryWorkerBuildDirectory);
+    const importedAssetPaths = getImportedAssetPaths(entryWorkerManifest);
+    if (hasClientEntry) {
+      await builder.build(clientEnvironment);
+    } else if (importedAssetPaths.size || getHasPublicAssets(builder.config)) {
+      await fallbackBuild(builder, clientEnvironment);
+    } else {
+      const entryWorkerConfigPath = path2.join(
+        entryWorkerBuildDirectory,
+        "wrangler.json"
+      );
+      const workerConfig = JSON.parse(
+        fs.readFileSync(entryWorkerConfigPath, "utf-8")
+      );
+      workerConfig.assets = void 0;
+      fs.writeFileSync(entryWorkerConfigPath, JSON.stringify(workerConfig));
+      return;
+    }
+    const clientBuildDirectory = path2.resolve(
+      builder.config.root,
+      clientEnvironment.config.build.outDir
+    );
+    const movedAssetPaths = [];
+    for (const assetPath of importedAssetPaths) {
+      const src = path2.join(entryWorkerBuildDirectory, assetPath);
+      const dest = path2.join(clientBuildDirectory, assetPath);
+      if (!fs.existsSync(src)) {
+        continue;
+      }
+      if (fs.existsSync(dest)) {
+        fs.unlinkSync(src);
+      } else {
+        const destDir = path2.dirname(dest);
+        fs.mkdirSync(destDir, { recursive: true });
+        fs.renameSync(src, dest);
+        movedAssetPaths.push(dest);
+      }
+    }
+    if (movedAssetPaths.length) {
+      builder.config.logger.info(
+        [
+          `${colors.green("\u2713")} ${movedAssetPaths.length} asset${movedAssetPaths.length > 1 ? "s" : ""} moved from "${entryWorkerEnvironmentName}" to "client" build output.`,
+          ...movedAssetPaths.map(
+            (assetPath) => colors.dim(path2.relative(builder.config.root, assetPath))
+          )
+        ].join("\n")
+      );
+    }
+  };
+}
+function getHasPublicAssets({ publicDir }) {
+  let hasPublicAssets = false;
+  if (publicDir) {
+    try {
+      const files = fs.readdirSync(publicDir);
+      if (files.length) {
+        hasPublicAssets = true;
+      }
+    } catch (error) {
+    }
+  }
+  return hasPublicAssets;
+}
+async function fallbackBuild(builder, environment) {
+  const fallbackEntryName = "__cloudflare_fallback_entry__";
+  environment.config.build.rollupOptions = {
+    input: "virtual:__cloudflare_fallback_entry__",
+    logLevel: "silent",
+    output: {
+      entryFileNames: fallbackEntryName
+    }
+  };
+  await builder.build(environment);
+  const fallbackEntryPath = path2.resolve(
+    builder.config.root,
+    environment.config.build.outDir,
+    fallbackEntryName
+  );
+  fs.unlinkSync(fallbackEntryPath);
+}
+function loadViteManifest(directory) {
+  const contents = fs.readFileSync(
+    path2.resolve(directory, ".vite", "manifest.json"),
+    "utf-8"
+  );
+  return JSON.parse(contents);
+}
+function getImportedAssetPaths(viteManifest) {
+  const assetPaths = Object.values(viteManifest).flatMap(
+    (chunk) => chunk.assets ?? []
+  );
+  return new Set(assetPaths);
+}
+
 // src/cloudflare-environment.ts
-import assert3 from "node:assert";
+import assert4 from "node:assert";
 import * as vite3 from "vite";
 
 // src/node-js-compat.ts
-import assert2 from "node:assert";
+import assert3 from "node:assert";
 import { builtinModules as builtinModules2 } from "node:module";
-import path3 from "node:path";
+import path4 from "node:path";
 import { cloudflare } from "@cloudflare/unenv-preset";
 import { getNodeCompat } from "miniflare";
 
@@ -11446,7 +11585,7 @@ Parser.acorn = {
 
 // ../../node_modules/.pnpm/mlly@1.7.4/node_modules/mlly/dist/index.mjs
 import { builtinModules, createRequire } from "node:module";
-import fs, { realpathSync, statSync, promises } from "node:fs";
+import fs2, { realpathSync, statSync, promises } from "node:fs";
 
 // ../../node_modules/.pnpm/ufo@1.5.4/node_modules/ufo/dist/index.mjs
 var r = String.fromCharCode;
@@ -11465,17 +11604,17 @@ function withTrailingSlash(input = "", respectQueryAndFragment) {
   if (hasTrailingSlash(input, true)) {
     return input || "/";
   }
-  let path10 = input;
+  let path11 = input;
   let fragment = "";
   const fragmentIndex = input.indexOf("#");
   if (fragmentIndex >= 0) {
-    path10 = input.slice(0, fragmentIndex);
+    path11 = input.slice(0, fragmentIndex);
     fragment = input.slice(fragmentIndex);
-    if (!path10) {
+    if (!path11) {
       return fragment;
     }
   }
-  const [s0, ...s] = path10.split("?");
+  const [s0, ...s] = path11.split("?");
   return s0 + "/" + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
 }
 function isNonEmptyURL(url) {
@@ -11503,14 +11642,14 @@ var isAbsolute = function(p) {
 
 // ../../node_modules/.pnpm/mlly@1.7.4/node_modules/mlly/dist/index.mjs
 import { fileURLToPath as fileURLToPath$1, URL as URL$1, pathToFileURL as pathToFileURL$1 } from "node:url";
-import assert from "node:assert";
+import assert2 from "node:assert";
 import process$1 from "node:process";
-import path2, { dirname as dirname2 } from "node:path";
+import path3, { dirname as dirname3 } from "node:path";
 import v8 from "node:v8";
 import { format as format2, inspect } from "node:util";
 var BUILTIN_MODULES = new Set(builtinModules);
-function normalizeSlash(path10) {
-  return path10.replace(/\\/g, "/");
+function normalizeSlash(path11) {
+  return path11.replace(/\\/g, "/");
 }
 var own$1 = {}.hasOwnProperty;
 var classRegExp = /^([A-Z][a-z\d]*)+$/;
@@ -11541,7 +11680,7 @@ codes.ERR_INVALID_ARG_TYPE = createError(
    * @param {unknown} actual
    */
   (name, expected, actual) => {
-    assert(typeof name === "string", "'name' must be a string");
+    assert2(typeof name === "string", "'name' must be a string");
     if (!Array.isArray(expected)) {
       expected = [expected];
     }
@@ -11557,14 +11696,14 @@ codes.ERR_INVALID_ARG_TYPE = createError(
     const instances = [];
     const other = [];
     for (const value of expected) {
-      assert(
+      assert2(
         typeof value === "string",
         "All expected entries have to be of type string"
       );
       if (kTypes.has(value)) {
         types2.push(value.toLowerCase());
       } else if (classRegExp.exec(value) === null) {
-        assert(
+        assert2(
           value !== "object",
           'The value "object" should be written as "Object"'
         );
@@ -11623,8 +11762,8 @@ codes.ERR_INVALID_PACKAGE_CONFIG = createError(
    * @param {string} [base]
    * @param {string} [message]
    */
-  (path10, base, message) => {
-    return `Invalid package config ${path10}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
+  (path11, base, message) => {
+    return `Invalid package config ${path11}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
   },
   Error
 );
@@ -11640,7 +11779,7 @@ codes.ERR_INVALID_PACKAGE_TARGET = createError(
   (packagePath, key, target2, isImport = false, base = void 0) => {
     const relatedError = typeof target2 === "string" && !isImport && target2.length > 0 && !target2.startsWith("./");
     if (key === ".") {
-      assert(isImport === false);
+      assert2(isImport === false);
       return `Invalid "exports" main target ${JSON.stringify(target2)} defined in the package config ${packagePath}package.json${base ? ` imported from ${base}` : ""}${relatedError ? '; targets must start with "./"' : ""}`;
     }
     return `Invalid "${isImport ? "imports" : "exports"}" target ${JSON.stringify(
@@ -11656,8 +11795,8 @@ codes.ERR_MODULE_NOT_FOUND = createError(
    * @param {string} base
    * @param {boolean} [exactUrl]
    */
-  (path10, base, exactUrl = false) => {
-    return `Cannot find ${exactUrl ? "module" : "package"} '${path10}' imported from ${base}`;
+  (path11, base, exactUrl = false) => {
+    return `Cannot find ${exactUrl ? "module" : "package"} '${path11}' imported from ${base}`;
   },
   Error
 );
@@ -11708,8 +11847,8 @@ codes.ERR_UNKNOWN_FILE_EXTENSION = createError(
    * @param {string} extension
    * @param {string} path
    */
-  (extension, path10) => {
-    return `Unknown file extension "${extension}" for ${path10}`;
+  (extension, path11) => {
+    return `Unknown file extension "${extension}" for ${path11}`;
   },
   TypeError
 );
@@ -11805,9 +11944,9 @@ var captureLargerStackTrace = hideStackFrames(
 );
 function getMessage(key, parameters, self) {
   const message = messages.get(key);
-  assert(message !== void 0, "expected `message` to be found");
+  assert2(message !== void 0, "expected `message` to be found");
   if (typeof message === "function") {
-    assert(
+    assert2(
       message.length <= parameters.length,
       // Default options do not count.
       `Code: ${key}; The provided arguments length (${parameters.length}) does not match the required ones (${message.length}).`
@@ -11817,7 +11956,7 @@ function getMessage(key, parameters, self) {
   const regex = /%[dfijoOs]/g;
   let expectedLength = 0;
   while (regex.exec(message) !== null) expectedLength++;
-  assert(
+  assert2(
     expectedLength === parameters.length,
     `Code: ${key}; The provided arguments length (${parameters.length}) does not match the required ones (${expectedLength}).`
   );
@@ -11854,7 +11993,7 @@ function read(jsonPath, { base, specifier }) {
   }
   let string;
   try {
-    string = fs.readFileSync(path2.toNamespacedPath(jsonPath), "utf8");
+    string = fs2.readFileSync(path3.toNamespacedPath(jsonPath), "utf8");
   } catch (error) {
     const exception = (
       /** @type {ErrnoException} */
@@ -12070,7 +12209,7 @@ Default "index" lookups for the main are deprecated for ES modules.`,
       "DeprecationWarning",
       "DEP0151"
     );
-  } else if (path2.resolve(packagePath, main) !== urlPath) {
+  } else if (path3.resolve(packagePath, main) !== urlPath) {
     process$1.emitWarning(
       `Package ${packagePath} has a "main" field set to "${main}", excluding the full filename and extension to the resolved file at "${urlPath.slice(
         packagePath.length
@@ -12081,9 +12220,9 @@ Default "index" lookups for the main are deprecated for ES modules.`,
     );
   }
 }
-function tryStatSync(path10) {
+function tryStatSync(path11) {
   try {
-    return statSync(path10);
+    return statSync(path11);
   } catch {
   }
 }
@@ -12177,7 +12316,7 @@ function finalizeResolution(resolved, base, preserveSymlinks) {
   {
     const real = realpathSync(filePath);
     const { search, hash } = resolved;
-    resolved = pathToFileURL$1(real + (filePath.endsWith(path2.sep) ? "/" : ""));
+    resolved = pathToFileURL$1(real + (filePath.endsWith(path3.sep) ? "/" : ""));
     resolved.search = search;
     resolved.hash = hash;
   }
@@ -12717,7 +12856,7 @@ function moduleResolve(specifier, base, conditions, preserveSymlinks) {
       resolved = packageResolve(specifier, base, conditions);
     }
   }
-  assert(resolved !== void 0, "expected to be defined");
+  assert2(resolved !== void 0, "expected to be defined");
   if (resolved.protocol !== "file:") {
     return resolved;
   }
@@ -12888,8 +13027,8 @@ function isNodeAls(workerConfig) {
     workerConfig.compatibility_flags ?? []
   ).mode === "als";
 }
-function isNodeAlsModule(path10) {
-  return /^(node:)?async_hooks$/.test(path10);
+function isNodeAlsModule(path11) {
+  return /^(node:)?async_hooks$/.test(path11);
 }
 function injectGlobalCode(id, code) {
   const injectedCode = Object.entries(env.inject).map(([globalName, globalInject]) => {
@@ -12900,11 +13039,11 @@ globalThis.${globalName} = var_${globalName};
 `;
     }
     const [moduleSpecifier, exportName] = globalInject;
-    assert2(
+    assert3(
       moduleSpecifier !== void 0,
       "Expected moduleSpecifier to be defined"
     );
-    assert2(exportName !== void 0, "Expected exportName to be defined");
+    assert3(exportName !== void 0, "Expected exportName to be defined");
     return `import var_${globalName} from "${moduleSpecifier}";
 globalThis.${globalName} = var_${globalName}.${exportName};
 `;
@@ -12940,7 +13079,7 @@ function getNodeCompatEntries() {
     if (typeof globalInject === "string") {
       entries.add(globalInject);
     } else {
-      assert2(
+      assert3(
         globalInject[0] !== void 0,
         "Expected first element of globalInject to be defined"
       );
@@ -12979,7 +13118,7 @@ var NodeJsCompatWarnings = class {
 `;
       this.sources.forEach((importers, source) => {
         importers.forEach((importer) => {
-          message += ` - "${source}" imported from "${path3.relative(this.resolvedViteConfig.root, importer)}"
+          message += ` - "${source}" imported from "${path4.relative(this.resolvedViteConfig.root, importer)}"
 `;
         });
       });
@@ -13003,13 +13142,13 @@ var additionalModuleGlobalRE = new RegExp(
 var VITE_DEV_METADATA_HEADER = "__VITE_DEV_METADATA__";
 
 // src/utils.ts
-import * as path4 from "node:path";
+import * as path5 from "node:path";
 import getPort, { portNumbers } from "get-port";
 import { Request as MiniflareRequest } from "miniflare";
 import "vite";
 function getOutputDirectory(userConfig, environmentName) {
   const rootOutputDirectory = userConfig.build?.outDir ?? "dist";
-  return userConfig.environments?.[environmentName]?.build?.outDir ?? path4.join(rootOutputDirectory, environmentName);
+  return userConfig.environments?.[environmentName]?.build?.outDir ?? path5.join(rootOutputDirectory, environmentName);
 }
 function toMiniflareRequest(request) {
   const host = request.headers.get("Host");
@@ -13042,7 +13181,7 @@ function createHotChannel(webSocketContainer) {
   const client = {
     send(payload) {
       const webSocket = webSocketContainer.webSocket;
-      assert3(webSocket, webSocketUndefinedError);
+      assert4(webSocket, webSocketUndefinedError);
       webSocket.send(JSON.stringify(payload));
     }
   };
@@ -13056,7 +13195,7 @@ function createHotChannel(webSocketContainer) {
   return {
     send(payload) {
       const webSocket = webSocketContainer.webSocket;
-      assert3(webSocket, webSocketUndefinedError);
+      assert4(webSocket, webSocketUndefinedError);
       webSocket.send(JSON.stringify(payload));
     },
     on(event, listener) {
@@ -13069,12 +13208,12 @@ function createHotChannel(webSocketContainer) {
     },
     listen() {
       const webSocket = webSocketContainer.webSocket;
-      assert3(webSocket, webSocketUndefinedError);
+      assert4(webSocket, webSocketUndefinedError);
       webSocket.addEventListener("message", onMessage);
     },
     close() {
       const webSocket = webSocketContainer.webSocket;
-      assert3(webSocket, webSocketUndefinedError);
+      assert4(webSocket, webSocketUndefinedError);
       webSocket.removeEventListener("message", onMessage);
     }
   };
@@ -13104,12 +13243,12 @@ var CloudflareDevEnvironment = class extends vite3.DevEnvironment {
         }
       }
     );
-    assert3(
+    assert4(
       response.ok,
       `Failed to initialize module runner, error: ${await response.text()}`
     );
     const webSocket = response.webSocket;
-    assert3(webSocket, "Failed to establish WebSocket");
+    assert4(webSocket, "Failed to establish WebSocket");
     webSocket.accept();
     this.#webSocketContainer.webSocket = webSocket;
   }
@@ -13122,7 +13261,7 @@ var cloudflareBuiltInModules = [
 ];
 var defaultConditions = ["workerd", "module", "browser"];
 var target = "es2022";
-function createCloudflareEnvironmentOptions(workerConfig, userConfig, environmentName) {
+function createCloudflareEnvironmentOptions(workerConfig, userConfig, environment) {
   return {
     resolve: {
       // Note: in order for ssr pre-bundling to take effect we need to ask vite to treat all
@@ -13143,16 +13282,12 @@ function createCloudflareEnvironmentOptions(workerConfig, userConfig, environmen
         return new vite3.BuildEnvironment(name, config);
       },
       target,
-      // We need to enable `emitAssets` in order to support additional modules defined by `rules`
       emitAssets: true,
-      outDir: getOutputDirectory(userConfig, environmentName),
+      manifest: environment.isEntry,
+      outDir: getOutputDirectory(userConfig, environment.name),
       copyPublicDir: false,
       ssr: true,
       rollupOptions: {
-        // Note: vite starts dev pre-bundling crawling from either optimizeDeps.entries or rollupOptions.input
-        //       so the input value here serves both as the build input as well as the starting point for
-        //       dev pre-bundling crawling (were we not to set this input field we'd have to appropriately set
-        //       optimizeDeps.entries in the dev config)
         input: workerConfig.main
       }
     },
@@ -13198,8 +13333,8 @@ function initRunners(resolvedPluginConfig, viteDevServer, miniflare2) {
 }
 
 // src/debugging.ts
-import assert4 from "node:assert";
-import colors from "picocolors";
+import assert5 from "node:assert";
+import colors2 from "picocolors";
 var debuggingPath = "/__debug";
 function addDebugToVitePrintUrls(server) {
   const originalPrintUrls = server.printUrls;
@@ -13208,19 +13343,19 @@ function addDebugToVitePrintUrls(server) {
     const localUrl = server.resolvedUrls?.local[0];
     if (localUrl) {
       const { protocol, hostname, port } = new URL(localUrl);
-      const colorDebugUrl = (url) => colors.dim(
-        colors.yellow(
-          url.replace(/:(\d+)\//, (_, port2) => `:${colors.bold(port2)}/`)
+      const colorDebugUrl = (url) => colors2.dim(
+        colors2.yellow(
+          url.replace(/:(\d+)\//, (_, port2) => `:${colors2.bold(port2)}/`)
         )
       );
       server.config.logger.info(
-        `  ${colors.green("\u279C")}  ${colors.bold("Debug")}:   ${colorDebugUrl(`${protocol}//${hostname}:${port}${debuggingPath}`)}`
+        `  ${colors2.green("\u279C")}  ${colors2.bold("Debug")}:   ${colorDebugUrl(`${protocol}//${hostname}:${port}${debuggingPath}`)}`
       );
     }
   };
 }
 function getDebugPathHtml(workerNames, inspectorPort) {
-  assert4(workerNames.length >= 1, "no workers present to debug");
+  assert5(workerNames.length >= 1, "no workers present to debug");
   const workerDevtoolsUrls = workerNames.map((workerName) => {
     const localHost = `localhost:${inspectorPort}/${workerName}`;
     const searchParams = new URLSearchParams({
@@ -13247,25 +13382,25 @@ function getDebugPathHtml(workerNames, inspectorPort) {
 }
 
 // src/deploy-config.ts
-import assert5 from "node:assert";
-import * as fs2 from "node:fs";
-import * as path5 from "node:path";
+import assert6 from "node:assert";
+import * as fs3 from "node:fs";
+import * as path6 from "node:path";
 import "vite";
 import { unstable_readConfig } from "wrangler";
 function getDeployConfigPath(root) {
-  return path5.resolve(root, ".wrangler", "deploy", "config.json");
+  return path6.resolve(root, ".wrangler", "deploy", "config.json");
 }
 function getWorkerConfigs(root, mixedModeEnabled) {
   const deployConfigPath = getDeployConfigPath(root);
   const deployConfig = JSON.parse(
-    fs2.readFileSync(deployConfigPath, "utf-8")
+    fs3.readFileSync(deployConfigPath, "utf-8")
   );
   return [
     { configPath: deployConfig.configPath },
     ...deployConfig.auxiliaryWorkers
   ].map(({ configPath }) => {
-    const resolvedConfigPath = path5.resolve(
-      path5.dirname(deployConfigPath),
+    const resolvedConfigPath = path6.resolve(
+      path6.dirname(deployConfigPath),
       configPath
     );
     return unstable_readConfig(
@@ -13275,18 +13410,18 @@ function getWorkerConfigs(root, mixedModeEnabled) {
   });
 }
 function getRelativePathToWorkerConfig(deployConfigDirectory, root, outputDirectory) {
-  return path5.relative(
+  return path6.relative(
     deployConfigDirectory,
-    path5.resolve(root, outputDirectory, "wrangler.json")
+    path6.resolve(root, outputDirectory, "wrangler.json")
   );
 }
 function writeDeployConfig(resolvedPluginConfig, resolvedViteConfig) {
   const deployConfigPath = getDeployConfigPath(resolvedViteConfig.root);
-  const deployConfigDirectory = path5.dirname(deployConfigPath);
-  fs2.mkdirSync(deployConfigDirectory, { recursive: true });
+  const deployConfigDirectory = path6.dirname(deployConfigPath);
+  fs3.mkdirSync(deployConfigDirectory, { recursive: true });
   if (resolvedPluginConfig.type === "assets-only") {
     const clientOutputDirectory = resolvedViteConfig.environments.client?.build.outDir;
-    assert5(
+    assert6(
       clientOutputDirectory,
       "Unexpected error: client environment output directory is undefined"
     );
@@ -13298,13 +13433,13 @@ function writeDeployConfig(resolvedPluginConfig, resolvedViteConfig) {
       ),
       auxiliaryWorkers: []
     };
-    fs2.writeFileSync(deployConfigPath, JSON.stringify(deployConfig));
+    fs3.writeFileSync(deployConfigPath, JSON.stringify(deployConfig));
   } else {
     let entryWorkerConfigPath;
     const auxiliaryWorkers = [];
     for (const environmentName of Object.keys(resolvedPluginConfig.workers)) {
       const outputDirectory = resolvedViteConfig.environments[environmentName]?.build.outDir;
-      assert5(
+      assert6(
         outputDirectory,
         `Unexpected error: ${environmentName} environment output directory is undefined`
       );
@@ -13319,7 +13454,7 @@ function writeDeployConfig(resolvedPluginConfig, resolvedViteConfig) {
         auxiliaryWorkers.push({ configPath });
       }
     }
-    assert5(
+    assert6(
       entryWorkerConfigPath,
       `Unexpected error: entryWorkerConfigPath is undefined`
     );
@@ -13327,15 +13462,15 @@ function writeDeployConfig(resolvedPluginConfig, resolvedViteConfig) {
       configPath: entryWorkerConfigPath,
       auxiliaryWorkers
     };
-    fs2.writeFileSync(deployConfigPath, JSON.stringify(deployConfig));
+    fs3.writeFileSync(deployConfigPath, JSON.stringify(deployConfig));
   }
 }
 
 // src/miniflare-options.ts
-import assert6 from "node:assert";
-import * as fs3 from "node:fs";
+import assert7 from "node:assert";
+import * as fs4 from "node:fs";
 import * as fsp from "node:fs/promises";
-import * as path6 from "node:path";
+import * as path7 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import {
   getDefaultDevRegistryPath,
@@ -13344,7 +13479,7 @@ import {
   LogLevel,
   Response as MiniflareResponse
 } from "miniflare";
-import colors2 from "picocolors";
+import colors3 from "picocolors";
 import { globSync } from "tinyglobby";
 import "vite";
 import {
@@ -13358,7 +13493,7 @@ function getPersistenceRoot(root, persistState) {
     return;
   }
   const defaultPersistPath = ".wrangler/state";
-  const persistPath = path6.resolve(
+  const persistPath = path7.resolve(
     root,
     typeof persistState === "object" ? persistState.path : defaultPersistPath,
     "v3"
@@ -13377,7 +13512,7 @@ function getWorkerToWorkerEntrypointNamesMap(workers) {
       if (typeof value === "object" && "name" in value && value.entrypoint !== void 0 && value.entrypoint !== "default") {
         const targetWorkerName = value.name === kCurrentWorker ? worker.name : value.name;
         const entrypointNames = workerToWorkerEntrypointNamesMap.get(targetWorkerName);
-        assert6(entrypointNames, missingWorkerErrorMessage(targetWorkerName));
+        assert7(entrypointNames, missingWorkerErrorMessage(targetWorkerName));
         entrypointNames.add(value.entrypoint);
       }
     }
@@ -13392,20 +13527,20 @@ function getWorkerToDurableObjectClassNamesMap(workers) {
     for (const value of Object.values(worker.durableObjects ?? {})) {
       if (typeof value === "string") {
         const classNames = workerToDurableObjectClassNamesMap.get(worker.name);
-        assert6(classNames, missingWorkerErrorMessage(worker.name));
+        assert7(classNames, missingWorkerErrorMessage(worker.name));
         classNames.add(value);
       } else if (typeof value === "object") {
         if (value.scriptName) {
           const classNames = workerToDurableObjectClassNamesMap.get(
             value.scriptName
           );
-          assert6(classNames, missingWorkerErrorMessage(value.scriptName));
+          assert7(classNames, missingWorkerErrorMessage(value.scriptName));
           classNames.add(value.className);
         } else {
           const classNames = workerToDurableObjectClassNamesMap.get(
             worker.name
           );
-          assert6(classNames, missingWorkerErrorMessage(worker.name));
+          assert7(classNames, missingWorkerErrorMessage(worker.name));
           classNames.add(value.className);
         }
       }
@@ -13423,13 +13558,13 @@ function getWorkerToWorkflowEntrypointClassNamesMap(workers) {
         const classNames = workerToWorkflowEntrypointClassNamesMap.get(
           value.scriptName
         );
-        assert6(classNames, missingWorkerErrorMessage(value.scriptName));
+        assert7(classNames, missingWorkerErrorMessage(value.scriptName));
         classNames.add(value.className);
       } else {
         const classNames = workerToWorkflowEntrypointClassNamesMap.get(
           worker.name
         );
-        assert6(classNames, missingWorkerErrorMessage(worker.name));
+        assert7(classNames, missingWorkerErrorMessage(worker.name));
         classNames.add(value.className);
       }
     }
@@ -13460,8 +13595,8 @@ function logUnknownTails(tails, userWorkers, log) {
     const found = userWorkers.some((w) => w.name === name);
     if (!found) {
       log(
-        colors2.dim(
-          colors2.yellow(
+        colors3.dim(
+          colors3.yellow(
             `Tail consumer "${name}" was not found in your config. Make sure you add it to the config or run it in another dev session if you'd like to simulate receiving tail events locally.`
           )
         )
@@ -13485,8 +13620,8 @@ async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspe
       modules: [
         {
           type: "ESModule",
-          path: path6.join(miniflareModulesRoot, ROUTER_WORKER_PATH),
-          contents: fs3.readFileSync(
+          path: path7.join(miniflareModulesRoot, ROUTER_WORKER_PATH),
+          contents: fs4.readFileSync(
             fileURLToPath2(new URL(ROUTER_WORKER_PATH, import.meta.url))
           )
         }
@@ -13508,8 +13643,8 @@ async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspe
       modules: [
         {
           type: "ESModule",
-          path: path6.join(miniflareModulesRoot, ASSET_WORKER_PATH),
-          contents: fs3.readFileSync(
+          path: path7.join(miniflareModulesRoot, ASSET_WORKER_PATH),
+          contents: fs4.readFileSync(
             fileURLToPath2(new URL(ASSET_WORKER_PATH, import.meta.url))
           )
         }
@@ -13523,7 +13658,7 @@ async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspe
           let exists = false;
           if (pathname.endsWith(".html")) {
             try {
-              const filePath = path6.join(resolvedViteConfig.root, pathname);
+              const filePath = path7.join(resolvedViteConfig.root, pathname);
               const stats = await fsp.stat(filePath);
               exists = stats.isFile();
             } catch (error) {
@@ -13533,7 +13668,7 @@ async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspe
         },
         __VITE_FETCH_ASSET__: async (request) => {
           const { pathname } = new URL(request.url);
-          const filePath = path6.join(resolvedViteConfig.root, pathname);
+          const filePath = path7.join(resolvedViteConfig.root, pathname);
           try {
             let html = await fsp.readFile(filePath, "utf-8");
             html = await viteDevServer.transformIndexHtml(pathname, html);
@@ -13589,7 +13724,7 @@ async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspe
               __VITE_INVOKE_MODULE__: async (request) => {
                 const payload = await request.json();
                 const invokePayloadData = payload.data;
-                assert6(
+                assert7(
                   invokePayloadData.name === "fetchModule",
                   `Invalid invoke event: ${invokePayloadData.name}`
                 );
@@ -13647,7 +13782,7 @@ async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspe
         const workerEntrypointNames = workerToWorkerEntrypointNamesMap.get(
           workerOptions.name
         );
-        assert6(
+        assert7(
           workerEntrypointNames,
           `WorkerEntrypoint names not found for worker ${workerOptions.name}`
         );
@@ -13659,7 +13794,7 @@ async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspe
         const durableObjectClassNames = workerToDurableObjectClassNamesMap.get(
           workerOptions.name
         );
-        assert6(
+        assert7(
           durableObjectClassNames,
           `DurableObject class names not found for worker ${workerOptions.name}`
         );
@@ -13669,7 +13804,7 @@ async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspe
           );
         }
         const workflowEntrypointClassNames = workerToWorkflowEntrypointClassNamesMap.get(workerOptions.name);
-        assert6(
+        assert7(
           workflowEntrypointClassNames,
           `WorkflowEntrypoint class names not found for worker: ${workerOptions.name}`
         );
@@ -13688,13 +13823,13 @@ async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspe
           modules: [
             {
               type: "ESModule",
-              path: path6.join(miniflareModulesRoot, WRAPPER_PATH),
+              path: path7.join(miniflareModulesRoot, WRAPPER_PATH),
               contents: wrappers.join("\n")
             },
             {
               type: "ESModule",
-              path: path6.join(miniflareModulesRoot, RUNNER_PATH),
-              contents: fs3.readFileSync(
+              path: path7.join(miniflareModulesRoot, RUNNER_PATH),
+              contents: fs4.readFileSync(
                 fileURLToPath2(new URL(RUNNER_PATH, import.meta.url))
               )
             }
@@ -13706,18 +13841,18 @@ async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspe
     async unsafeModuleFallbackService(request) {
       const url = new URL(request.url);
       const rawSpecifier = url.searchParams.get("rawSpecifier");
-      assert6(
+      assert7(
         rawSpecifier,
         `Unexpected error: no specifier in request to module fallback service.`
       );
       const match = additionalModuleRE.exec(rawSpecifier);
-      assert6(match, `Unexpected error: no match for module: ${rawSpecifier}.`);
+      assert7(match, `Unexpected error: no match for module: ${rawSpecifier}.`);
       const [full, moduleType, modulePath] = match;
-      assert6(
+      assert7(
         moduleType,
         `Unexpected error: module type not found in reference: ${full}.`
       );
-      assert6(
+      assert7(
         modulePath,
         `Unexpected error: module path not found in reference: ${full}.`
       );
@@ -13747,9 +13882,9 @@ async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspe
   };
 }
 function getPreviewModules(main, modulesRules) {
-  assert6(modulesRules, `Unexpected error: 'modulesRules' is undefined`);
-  const rootPath = path6.dirname(main);
-  const entryPath = path6.basename(main);
+  assert7(modulesRules, `Unexpected error: 'modulesRules' is undefined`);
+  const rootPath = path7.dirname(main);
+  const entryPath = path7.basename(main);
   return {
     rootPath,
     modules: [
@@ -13758,9 +13893,9 @@ function getPreviewModules(main, modulesRules) {
         path: entryPath
       },
       ...modulesRules.flatMap(
-        ({ type, include }) => globSync(include, { cwd: rootPath, ignore: entryPath }).map((path10) => ({
+        ({ type, include }) => globSync(include, { cwd: rootPath, ignore: entryPath }).map((path11) => ({
           type,
-          path: path10
+          path: path11
         }))
       )
     ]
@@ -13858,11 +13993,16 @@ async function maybeStartOrUpdateMixedModeSession(workerConfig) {
   const workerRemoteBindings = experimental_pickRemoteBindings(
     unstable_convertConfigBindingsToStartWorkerBindings(workerConfig) ?? {}
   );
-  assert6(workerConfig.name, "Found workerConfig without a name");
+  assert7(workerConfig.name, "Found workerConfig without a name");
   let mixedModeSession = mixedModeSessionsMap.get(workerConfig.name);
   if (mixedModeSession === void 0) {
     if (Object.keys(workerRemoteBindings).length > 0) {
-      mixedModeSession = await experimental_startMixedModeSession(workerRemoteBindings);
+      mixedModeSession = await experimental_startMixedModeSession(
+        workerRemoteBindings,
+        {
+          workerName: workerConfig.name
+        }
+      );
       mixedModeSessionsMap.set(workerConfig.name, mixedModeSession);
     }
   } else {
@@ -13873,14 +14013,14 @@ async function maybeStartOrUpdateMixedModeSession(workerConfig) {
 }
 
 // src/plugin-config.ts
-import assert8 from "node:assert";
-import * as path8 from "node:path";
+import assert9 from "node:assert";
+import * as path9 from "node:path";
 import * as vite6 from "vite";
 
 // src/workers-configs.ts
-import assert7 from "node:assert";
-import * as fs4 from "node:fs";
-import * as path7 from "node:path";
+import assert8 from "node:assert";
+import * as fs5 from "node:fs";
+import * as path8 from "node:path";
 import { unstable_readConfig as unstable_readConfig2 } from "wrangler";
 var nonApplicableWorkerConfigs = {
   /**
@@ -13975,7 +14115,7 @@ function getWarningForWorkersConfigs(configs) {
     const lines2 = [
       `
 
-\x1B[43mWARNING\x1B[0m: your worker config${configs.entryWorker.config.configPath ? ` (at \`${path7.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 \`${path8.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("");
@@ -13989,7 +14129,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 \`${path7.relative("", workerConfig.config.configPath)}\`)` : ""}`
+        `  - (${isEntryWorker ? "entry" : "auxiliary"}) worker${workerConfig.config.name ? ` "${workerConfig.config.name}"` : ""}${workerConfig.config.configPath ? ` (config at \`${path8.relative("", workerConfig.config.configPath)}\`)` : ""}`
       );
       nonApplicableLines.forEach((line) => lines.push(line));
     }
@@ -14070,7 +14210,7 @@ function getWorkerConfig(configPath, env2, mixedModeEnabled, opts) {
   if (!config.main) {
     throw new Error(missingFieldErrorMessage(`'main'`, configPath, env2));
   }
-  const mainStat = fs4.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`
@@ -14094,17 +14234,17 @@ function getWorkerConfig(configPath, env2, mixedModeEnabled, opts) {
 }
 function getValidatedWranglerConfigPath(root, requestedConfigPath, isForAuxiliaryWorker = false) {
   if (requestedConfigPath) {
-    const configPath2 = path7.resolve(root, requestedConfigPath);
+    const configPath2 = path8.resolve(root, requestedConfigPath);
     const forAuxiliaryWorkerErrorMessage = isForAuxiliaryWorker ? " requested for one of your auxiliary workers" : "";
     const errorMessagePrefix = `The provided configPath (${configPath2})${forAuxiliaryWorkerErrorMessage}`;
-    const fileExtension = path7.extname(configPath2).slice(1);
+    const fileExtension = path8.extname(configPath2).slice(1);
     if (!allowedWranglerConfigExtensions.includes(fileExtension)) {
       const foundExtensionMessage = !fileExtension ? "no extension found" : `"${fileExtension}" found`;
       throw new Error(
         `${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 = fs4.statSync(configPath2, { throwIfNoEntry: false });
+    const mainStat = fs5.statSync(configPath2, { throwIfNoEntry: false });
     if (!mainStat) {
       throw new Error(
         `${errorMessagePrefix} doesn't point to an existing file`
@@ -14117,7 +14257,7 @@ function getValidatedWranglerConfigPath(root, requestedConfigPath, isForAuxiliar
     }
     return configPath2;
   }
-  assert7(
+  assert8(
     isForAuxiliaryWorker === false,
     "Unexpected Error: trying to find the wrangler config for an auxiliary worker"
   );
@@ -14131,8 +14271,8 @@ function getValidatedWranglerConfigPath(root, requestedConfigPath, isForAuxiliar
 }
 function findWranglerConfig(root) {
   for (const extension of allowedWranglerConfigExtensions) {
-    const configPath = path7.join(root, `wrangler.${extension}`);
-    if (fs4.existsSync(configPath)) {
+    const configPath = path8.join(root, `wrangler.${extension}`);
+    if (fs5.existsSync(configPath)) {
       return configPath;
     }
   }
@@ -14147,7 +14287,7 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
   const configPaths = /* @__PURE__ */ new Set();
   const persistState = pluginConfig.persistState ?? true;
   const experimental = pluginConfig.experimental ?? {};
-  const root = userConfig.root ? path8.resolve(userConfig.root) : process.cwd();
+  const root = userConfig.root ? path9.resolve(userConfig.root) : process.cwd();
   const { CLOUDFLARE_ENV: cloudflareEnv } = vite6.loadEnv(
     viteEnv.mode,
     root,
@@ -14201,7 +14341,7 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
       }
     );
     auxiliaryWorkersResolvedConfigs.push(workerResolvedConfig);
-    assert8(
+    assert9(
       workerResolvedConfig.type === "worker",
       "Unexpected error: received AssetsOnlyResult with auxiliary workers."
     );
@@ -14267,14 +14407,14 @@ function handleWebSocket(httpServer, getFetcher) {
 }
 
 // src/worker-environments-validation.ts
-import assert9 from "node:assert";
+import assert10 from "node:assert";
 function validateWorkerEnvironmentsResolvedConfigs(resolvedPluginConfig, resolvedViteConfig) {
   const workersEnvironmentNames = Object.keys(resolvedPluginConfig.workers);
   const disallowedEnvsConfigs = /* @__PURE__ */ new Map();
   for (const envName of workersEnvironmentNames) {
     const workerEnvConfig = resolvedViteConfig.environments[envName];
-    assert9(workerEnvConfig, `Missing environment config for "${envName}"`);
-    const { optimizeDeps, resolve: resolve7 } = workerEnvConfig;
+    assert10(workerEnvConfig, `Missing environment config for "${envName}"`);
+    const { optimizeDeps, resolve: resolve8 } = workerEnvConfig;
     const disallowedConfig = {};
     const disallowedOptimizeDepsExcludeEntries = (optimizeDeps.exclude ?? []).filter((entry) => {
       if (cloudflareBuiltInModules.includes(entry)) {
@@ -14291,8 +14431,8 @@ function validateWorkerEnvironmentsResolvedConfigs(resolvedPluginConfig, resolve
     if (disallowedOptimizeDepsExcludeEntries.length > 0) {
       disallowedConfig.optimizeDepsExclude = disallowedOptimizeDepsExcludeEntries;
     }
-    if (resolve7.external === true || resolve7.external.length > 0) {
-      disallowedConfig.resolveExternal = resolve7.external;
+    if (resolve8.external === true || resolve8.external.length > 0) {
+      disallowedConfig.resolveExternal = resolve8.external;
     }
     if (Object.keys(disallowedConfig).length > 0) {
       disallowedEnvsConfigs.set(envName, disallowedConfig);
@@ -14325,7 +14465,6 @@ function cloudflare2(pluginConfig = {}) {
   let resolvedViteConfig;
   const additionalModulePaths = /* @__PURE__ */ new Set();
   const nodeJsCompatWarningsMap = /* @__PURE__ */ new Map();
-  let hasClientBuild = false;
   return [
     {
       name: "vite-plugin-cloudflare",
@@ -14349,8 +14488,19 @@ function cloudflare2(pluginConfig = {}) {
             console.warn(workersConfigsWarning);
           }
         }
+        const defaultDeniedFiles = [
+          ".env",
+          ".env.*",
+          "*.{crt,pem}",
+          "**/.git/**"
+        ];
         return {
           appType: "custom",
+          server: {
+            fs: {
+              deny: [...defaultDeniedFiles, ".dev.vars", ".dev.vars.*"]
+            }
+          },
           environments: resolvedPluginConfig.type === "workers" ? {
             ...Object.fromEntries(
               Object.entries(resolvedPluginConfig.workers).map(
@@ -14360,7 +14510,10 @@ function cloudflare2(pluginConfig = {}) {
                     createCloudflareEnvironmentOptions(
                       workerConfig,
                       userConfig,
-                      environmentName
+                      {
+                        name: environmentName,
+                        isEntry: resolvedPluginConfig.type === "workers" && environmentName === resolvedPluginConfig.entryWorkerEnvironmentName
+                      }
                     )
                   ];
                 }
@@ -14373,33 +14526,7 @@ function cloudflare2(pluginConfig = {}) {
             }
           } : void 0,
           builder: {
-            buildApp: userConfig.builder?.buildApp ?? (async (builder) => {
-              const clientEnvironment = builder.environments.client;
-              const defaultHtmlPath = path9.resolve(
-                builder.config.root,
-                "index.html"
-              );
-              if (clientEnvironment && (clientEnvironment.config.build.rollupOptions.input || fs5.existsSync(defaultHtmlPath))) {
-                await builder.build(clientEnvironment);
-              }
-              if (resolvedPluginConfig.type === "workers") {
-                const workerEnvironments = Object.keys(
-                  resolvedPluginConfig.workers
-                ).map((environmentName) => {
-                  const environment = builder.environments[environmentName];
-                  assert10(
-                    environment,
-                    `${environmentName} environment not found`
-                  );
-                  return environment;
-                });
-                await Promise.all(
-                  workerEnvironments.map(
-                    (environment) => builder.build(environment)
-                  )
-                );
-              }
-            })
+            buildApp: userConfig.builder?.buildApp ?? createBuildApp(resolvedPluginConfig)
           }
         };
       },
@@ -14431,18 +14558,18 @@ function cloudflare2(pluginConfig = {}) {
             { type: "ESModule", globs: ["**/*.js", "**/*.mjs"] }
           ];
           const isEntryWorker = this.environment.name === resolvedPluginConfig.entryWorkerEnvironmentName;
-          if (isEntryWorker && hasClientBuild) {
+          if (isEntryWorker) {
             const workerOutputDirectory = this.environment.config.build.outDir;
             const clientOutputDirectory = resolvedViteConfig.environments.client?.build.outDir;
-            assert10(
+            assert11(
               clientOutputDirectory,
               "Unexpected error: client output directory is undefined"
             );
             workerConfig.assets = {
               ...workerConfig.assets,
-              directory: path9.relative(
-                path9.resolve(resolvedViteConfig.root, workerOutputDirectory),
-                path9.resolve(resolvedViteConfig.root, clientOutputDirectory)
+              directory: path10.relative(
+                path10.resolve(resolvedViteConfig.root, workerOutputDirectory),
+                path10.resolve(resolvedViteConfig.root, clientOutputDirectory)
               )
             };
           } else {
@@ -14490,15 +14617,12 @@ function cloudflare2(pluginConfig = {}) {
         });
       },
       writeBundle() {
-        if (this.environment.name === "client") {
-          hasClientBuild = true;
-        }
         if (this.environment.name === (resolvedPluginConfig.type === "assets-only" ? "client" : resolvedPluginConfig.entryWorkerEnvironmentName)) {
           writeDeployConfig(resolvedPluginConfig, resolvedViteConfig);
         }
       },
       hotUpdate(options) {
-        const changedFilePath = path9.resolve(options.file);
+        const changedFilePath = path10.resolve(options.file);
         if (resolvedPluginConfig.configPaths.has(changedFilePath) || hasDotDevDotVarsFileChanged(resolvedPluginConfig, changedFilePath) || hasAssetsConfigChanged(
           resolvedPluginConfig,
           resolvedViteConfig,
@@ -14526,7 +14650,7 @@ function cloudflare2(pluginConfig = {}) {
         await initRunners(resolvedPluginConfig, viteDevServer, miniflare);
         if (viteDevServer.httpServer) {
           handleWebSocket(viteDevServer.httpServer, async () => {
-            assert10(miniflare, `Miniflare not defined`);
+            assert11(miniflare, `Miniflare not defined`);
             const routerWorker = await miniflare.getWorker(ROUTER_WORKER_NAME);
             return routerWorker.fetch;
           });
@@ -14534,7 +14658,7 @@ function cloudflare2(pluginConfig = {}) {
         return () => {
           viteDevServer.middlewares.use(async (req, res, next) => {
             try {
-              assert10(miniflare, `Miniflare not defined`);
+              assert11(miniflare, `Miniflare not defined`);
               const request = createRequest(req, res);
               let response;
               if (req[kRequestType] === "asset") {
@@ -14599,6 +14723,20 @@ function cloudflare2(pluginConfig = {}) {
         });
       }
     },
+    // Plugin to provide a fallback entry file
+    {
+      name: "vite-plugin-cloudflare:fallback-entry",
+      resolveId(source) {
+        if (source === "virtual:__cloudflare_fallback_entry__") {
+          return `\0virtual:__cloudflare_fallback_entry__`;
+        }
+      },
+      load(id) {
+        if (id === "\0virtual:__cloudflare_fallback_entry__") {
+          return ``;
+        }
+      }
+    },
     // Plugin to support `.wasm?init` extension
     {
       name: "vite-plugin-cloudflare:wasm-helper",
@@ -14658,7 +14796,7 @@ function cloudflare2(pluginConfig = {}) {
         for (const match of matches) {
           magicString ??= new MagicString(code);
           const [full, _, modulePath] = match;
-          assert10(
+          assert11(
             modulePath,
             `Unexpected error: module path not found in reference ${full}.`
           );
@@ -14672,13 +14810,13 @@ function cloudflare2(pluginConfig = {}) {
           }
           const referenceId = this.emitFile({
             type: "asset",
-            name: path9.basename(modulePath),
+            name: path10.basename(modulePath),
             originalFileName: modulePath,
             source
           });
           const emittedFileName = this.getFileName(referenceId);
           const relativePath = vite7.normalizePath(
-            path9.relative(path9.dirname(chunk.fileName), emittedFileName)
+            path10.relative(path10.dirname(chunk.fileName), emittedFileName)
           );
           const importPath = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
           magicString.update(
@@ -14743,7 +14881,7 @@ function cloudflare2(pluginConfig = {}) {
           return this.resolve(source, importer, options);
         }
         if (this.environment.mode === "dev") {
-          assert10(
+          assert11(
             this.environment.depsOptimizer,
             "depsOptimizer is required in dev mode"
           );
@@ -14839,7 +14977,7 @@ function cloudflare2(pluginConfig = {}) {
           addDebugToVitePrintUrls(vitePreviewServer);
         }
         const workerNames = workerConfigs.map((worker) => {
-          assert10(worker.name, "Expected the Worker to have a name");
+          assert11(worker.name, "Expected the Worker to have a name");
           return worker.name;
         });
         vitePreviewServer.middlewares.use(async (req, res, next) => {
@@ -14874,13 +15012,13 @@ function cloudflare2(pluginConfig = {}) {
                     setup(build) {
                       build.onResolve(
                         { filter: NODEJS_MODULES_RE },
-                        ({ path: path10, importer }) => {
-                          if (isNodeAls(workerConfig) && isNodeAlsModule(path10)) {
+                        ({ path: path11, importer }) => {
+                          if (isNodeAls(workerConfig) && isNodeAlsModule(path11)) {
                             return;
                           }
                           const nodeJsCompatWarnings = nodeJsCompatWarningsMap.get(workerConfig);
-                          nodeJsCompatWarnings?.registerImport(path10, importer);
-                          return { path: path10, external: true };
+                          nodeJsCompatWarnings?.registerImport(path11, importer);
+                          return { path: path11, external: true };
                         }
                       );
                     }
@@ -14923,7 +15061,7 @@ function cloudflare2(pluginConfig = {}) {
     }
   ];
   function getWorkerConfig2(environmentName) {
-    assert10(resolvedPluginConfig, "Expected resolvedPluginConfig to be defined");
+    assert11(resolvedPluginConfig, "Expected resolvedPluginConfig to be defined");
     return resolvedPluginConfig.type !== "assets-only" ? resolvedPluginConfig.workers[environmentName] : void 0;
   }
 }
@@ -14937,7 +15075,7 @@ async function getInputInspectorPortOption(pluginConfig, viteServer) {
   const inputInspectorPort = pluginConfig.inspectorPort ?? await getFirstAvailablePort(DEFAULT_INSPECTOR_PORT);
   if (pluginConfig.inspectorPort === void 0 && inputInspectorPort !== DEFAULT_INSPECTOR_PORT) {
     viteServer.config.logger.warn(
-      colors3.dim(
+      colors4.dim(
         `Default inspector port ${DEFAULT_INSPECTOR_PORT} not available, using ${inputInspectorPort} instead
 `
       )
@@ -14953,19 +15091,19 @@ async function getResolvedInspectorPort(pluginConfig) {
   return null;
 }
 function getDotDevDotVarsContent(configPath, cloudflareEnv) {
-  const configDir = path9.dirname(configPath);
+  const configDir = path10.dirname(configPath);
   const defaultDotDevDotVarsPath = `${configDir}/.dev.vars`;
   const inputDotDevDotVarsPath = `${defaultDotDevDotVarsPath}${cloudflareEnv ? `.${cloudflareEnv}` : ""}`;
-  const targetPath = fs5.existsSync(inputDotDevDotVarsPath) ? inputDotDevDotVarsPath : fs5.existsSync(defaultDotDevDotVarsPath) ? defaultDotDevDotVarsPath : null;
+  const targetPath = fs6.existsSync(inputDotDevDotVarsPath) ? inputDotDevDotVarsPath : fs6.existsSync(defaultDotDevDotVarsPath) ? defaultDotDevDotVarsPath : null;
   if (targetPath) {
-    const dotDevDotVarsContent = fs5.readFileSync(targetPath);
+    const dotDevDotVarsContent = fs6.readFileSync(targetPath);
     return dotDevDotVarsContent;
   }
   return null;
 }
 function hasDotDevDotVarsFileChanged(resolvedPluginConfig, changedFilePath) {
   return [...resolvedPluginConfig.configPaths].some((configPath) => {
-    const dotDevDotVars = path9.join(path9.dirname(configPath), ".dev.vars");
+    const dotDevDotVars = path10.join(path10.dirname(configPath), ".dev.vars");
     if (dotDevDotVars === changedFilePath) {
       return true;
     }