@cloudflare/vite-plugin 1.5.1 → 1.7.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,11 +485,36 @@ 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 { createRequest, sendResponse } from "@mjackson/node-fetch-server";
+import * as path10 from "node:path";
+
+// ../workers-shared/asset-worker/src/utils/rules-engine.ts
+var ESCAPE_REGEX_CHARACTERS = /[-/\\^$*+?.()|[\]{}]/g;
+var escapeRegex = (str) => {
+  return str.replace(ESCAPE_REGEX_CHARACTERS, "\\$&");
+};
+var generateGlobOnlyRuleRegExp = (rule) => {
+  rule = rule.split("*").map(escapeRegex).join(".*");
+  rule = "^" + rule + "$";
+  return RegExp(rule);
+};
+var generateStaticRoutingRuleMatcher = (rules) => ({ request }) => {
+  const { pathname } = new URL(request.url);
+  for (const rule of rules) {
+    try {
+      const regExp = generateGlobOnlyRuleRegExp(rule);
+      if (regExp.test(pathname)) {
+        return true;
+      }
+    } catch {
+    }
+  }
+  return false;
+};
+
+// src/index.ts
 import replace from "@rollup/plugin-replace";
 
 // ../../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.0/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
@@ -503,8 +528,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;
@@ -1066,19 +1091,19 @@ var MagicString = class _MagicString {
       });
     }
     let shouldIndentNextCharacter = options.indentStart !== false;
-    const replacer = (match) => {
+    const replacer2 = (match) => {
       if (shouldIndentNextCharacter) return `${indentStr}${match}`;
       shouldIndentNextCharacter = true;
       return match;
     };
-    this.intro = this.intro.replace(pattern, replacer);
+    this.intro = this.intro.replace(pattern, replacer2);
     let charIndex = 0;
     let chunk = this.firstChunk;
     while (chunk) {
       const end = chunk.end;
       if (chunk.edited) {
         if (!isExcluded[charIndex]) {
-          chunk.content = chunk.content.replace(pattern, replacer);
+          chunk.content = chunk.content.replace(pattern, replacer2);
           if (chunk.content.length) {
             shouldIndentNextCharacter = chunk.content[chunk.content.length - 1] === "\n";
           }
@@ -1107,7 +1132,7 @@ var MagicString = class _MagicString {
       charIndex = chunk.end;
       chunk = chunk.next;
     }
-    this.outro = this.outro.replace(pattern, replacer);
+    this.outro = this.outro.replace(pattern, replacer2);
     return this;
   }
   insert() {
@@ -1558,8 +1583,8 @@ var MagicString = class _MagicString {
 
 // src/index.ts
 import { Miniflare } from "miniflare";
-import colors3 from "picocolors";
-import * as vite7 from "vite";
+import colors4 from "picocolors";
+import * as vite6 from "vite";
 
 // src/constants.ts
 var ROUTER_WORKER_NAME = "__router-worker__";
@@ -1570,6 +1595,7 @@ var ADDITIONAL_MODULE_TYPES = [
   "Data",
   "Text"
 ];
+var PUBLIC_DIR_PREFIX = "/__vite_public_dir__";
 var DEFAULT_INSPECTOR_PORT = 9229;
 var kRequestType = Symbol("kRequestType");
 
@@ -1600,8 +1626,8 @@ import * as path from "node:path";
 import { relative } from "node:path";
 
 // ../workers-shared/utils/configuration/constants.ts
-var REDIRECTS_VERSION = 1;
-var HEADERS_VERSION = 2;
+var REDIRECTS_VERSION2 = 1;
+var HEADERS_VERSION2 = 2;
 var PERMITTED_STATUS_CODES = /* @__PURE__ */ new Set([200, 301, 302, 303, 307, 308]);
 var HEADER_SEPARATOR = ":";
 var MAX_LINE_LENGTH = 2e3;
@@ -1611,6 +1637,8 @@ var MAX_STATIC_REDIRECT_RULES = 2e3;
 var UNSET_OPERATOR = "! ";
 var SPLAT_REGEX = /\*/g;
 var PLACEHOLDER_REGEX = /:[A-Za-z]\w*/g;
+var MAX_ROUTES_RULES = 100;
+var MAX_ROUTES_RULE_LENGTH = 100;
 
 // ../workers-shared/utils/configuration/constructConfiguration.ts
 function constructRedirects({
@@ -1669,7 +1697,7 @@ ${invalidRedirectRulesList}`
   }
   return {
     redirects: {
-      version: REDIRECTS_VERSION,
+      version: REDIRECTS_VERSION2,
       staticRules: staticRedirects,
       rules: dynamicRedirects
     }
@@ -1721,18 +1749,18 @@ ${invalidHeaderRulesList}`
   }
   return {
     headers: {
-      version: HEADERS_VERSION,
+      version: HEADERS_VERSION2,
       rules
     }
   };
 }
 
 // ../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 +1793,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 +1855,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 +1866,7 @@ function parseHeaders(input, {
         continue;
       }
       rule = {
-        path: path10,
+        path: path11,
         line,
         headers: {},
         unsetHeaders: []
@@ -2413,8 +2441,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 +2541,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() {
@@ -5860,7 +5888,8 @@ function getAssetsConfig(resolvedPluginConfig, entryWorkerConfig, resolvedConfig
   };
   const config = {
     ...compatibilityOptions,
-    ...assetsConfig
+    ...assetsConfig,
+    has_static_routing: resolvedPluginConfig.type === "workers" && resolvedPluginConfig.staticRouting ? true : false
   };
   if (!resolvedPluginConfig.experimental?.headersAndRedirectsDevModeSupport) {
     return config;
@@ -5912,14 +5941,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 * as vite3 from "vite";
+import assert4 from "node:assert";
+import * as vite2 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";
 
@@ -11452,7 +11614,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;
@@ -11471,17 +11633,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) {
@@ -11509,14 +11671,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]*)+$/;
@@ -11547,7 +11709,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];
     }
@@ -11563,14 +11725,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"'
         );
@@ -11629,8 +11791,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
 );
@@ -11646,7 +11808,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(
@@ -11662,8 +11824,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
 );
@@ -11714,8 +11876,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
 );
@@ -11811,9 +11973,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}).`
@@ -11823,7 +11985,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}).`
   );
@@ -11860,7 +12022,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} */
@@ -12076,7 +12238,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
@@ -12087,9 +12249,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 {
   }
 }
@@ -12183,7 +12345,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;
   }
@@ -12723,7 +12885,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;
   }
@@ -12894,27 +13056,44 @@ 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);
+}
+var injectsByModule = /* @__PURE__ */ new Map();
+var virtualModulePathToSpecifier = /* @__PURE__ */ new Map();
+var virtualModulePrefix = `\0_nodejs_global_inject-`;
+for (const [injectedName, moduleSpecifier] of Object.entries(env.inject)) {
+  const [module, exportName, importName] = Array.isArray(moduleSpecifier) ? [moduleSpecifier[0], moduleSpecifier[1], moduleSpecifier[1]] : [moduleSpecifier, "default", "defaultExport"];
+  if (!injectsByModule.has(module)) {
+    injectsByModule.set(module, []);
+    virtualModulePathToSpecifier.set(
+      virtualModulePrefix + module.replaceAll("/", "-"),
+      module
+    );
+  }
+  const injects = injectsByModule.get(module);
+  assert3(injects, `expected injects for ${module} to be defined`);
+  injects.push({ injectedName, exportName, importName });
+}
+function isGlobalVirtualModule(modulePath) {
+  return virtualModulePathToSpecifier.has(modulePath);
+}
+function getGlobalVirtualModule(modulePath) {
+  const module = virtualModulePathToSpecifier.get(modulePath);
+  if (!module) {
+    return void 0;
+  }
+  const injects = injectsByModule.get(module);
+  assert3(injects, `expected injects for ${module} to be defined`);
+  const imports = injects.map(
+    ({ exportName, importName }) => importName === exportName ? exportName : `${exportName} as ${importName}`
+  );
+  return `import { ${imports.join(", ")} } from "${module}";
+${injects.map(({ injectedName, importName }) => `globalThis.${injectedName} = ${importName};`).join("\n")}`;
 }
 function injectGlobalCode(id, code) {
-  const injectedCode = Object.entries(env.inject).map(([globalName, globalInject]) => {
-    if (typeof globalInject === "string") {
-      const moduleSpecifier2 = globalInject;
-      return `import var_${globalName} from "${moduleSpecifier2}";
-globalThis.${globalName} = var_${globalName};
-`;
-    }
-    const [moduleSpecifier, exportName] = globalInject;
-    assert2(
-      moduleSpecifier !== void 0,
-      "Expected moduleSpecifier to be defined"
-    );
-    assert2(exportName !== void 0, "Expected exportName to be defined");
-    return `import var_${globalName} from "${moduleSpecifier}";
-globalThis.${globalName} = var_${globalName}.${exportName};
-`;
-  }).join("\n");
+  const injectedCode = Array.from(virtualModulePathToSpecifier.keys()).map((moduleId) => `import "${moduleId}";
+`).join("");
   const polyfillCode = env.polyfill.map((polyfillPath) => `import "${polyfillPath}";
 `).join("");
   const modified = new MagicString(code);
@@ -12946,7 +13125,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"
       );
@@ -12985,7 +13164,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)}"
 `;
         });
       });
@@ -13009,13 +13188,41 @@ 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 { createRequest, sendResponse } from "@mjackson/node-fetch-server";
 import getPort, { portNumbers } from "get-port";
-import { Request as MiniflareRequest } from "miniflare";
-import "vite";
+import {
+  Request as MiniflareRequest,
+  Response as MiniflareResponse
+} from "miniflare";
 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);
+}
+var postfixRE = /[?#].*$/;
+function cleanUrl(url) {
+  return url.replace(postfixRE, "");
+}
+function getFirstAvailablePort(start) {
+  return getPort({ port: portNumbers(start, 65535) });
+}
+function withTrailingSlash2(path11) {
+  return path11.endsWith("/") ? path11 : `${path11}/`;
+}
+function createRequestHandler(handler) {
+  return async (req, res, next) => {
+    try {
+      const request = createRequest(req, res);
+      let response = await handler(toMiniflareRequest(request), req);
+      if (req.httpVersionMajor === 2) {
+        response = new MiniflareResponse(response.body, response);
+        response.headers.delete("transfer-encoding");
+      }
+      await sendResponse(res, response);
+    } catch (error) {
+      next(error);
+    }
+  };
 }
 function toMiniflareRequest(request) {
   const host = request.headers.get("Host");
@@ -13033,13 +13240,6 @@ function toMiniflareRequest(request) {
     duplex: "half"
   });
 }
-var postfixRE = /[?#].*$/;
-function cleanUrl(url) {
-  return url.replace(postfixRE, "");
-}
-function getFirstAvailablePort(start) {
-  return getPort({ port: portNumbers(start, 65535) });
-}
 
 // src/cloudflare-environment.ts
 var webSocketUndefinedError = "The WebSocket is undefined";
@@ -13048,7 +13248,7 @@ function createHotChannel(webSocketContainer) {
   const client = {
     send(payload) {
       const webSocket = webSocketContainer.webSocket;
-      assert3(webSocket, webSocketUndefinedError);
+      assert4(webSocket, webSocketUndefinedError);
       webSocket.send(JSON.stringify(payload));
     }
   };
@@ -13062,7 +13262,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) {
@@ -13075,17 +13275,17 @@ 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);
     }
   };
 }
-var CloudflareDevEnvironment = class extends vite3.DevEnvironment {
+var CloudflareDevEnvironment = class extends vite2.DevEnvironment {
   #webSocketContainer;
   #worker;
   constructor(name, config) {
@@ -13110,12 +13310,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;
   }
@@ -13128,7 +13328,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
@@ -13146,19 +13346,15 @@ function createCloudflareEnvironmentOptions(workerConfig, userConfig, environmen
     },
     build: {
       createEnvironment(name, config) {
-        return new vite3.BuildEnvironment(name, config);
+        return new vite2.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
       }
     },
@@ -13204,8 +13400,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;
@@ -13214,19 +13410,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({
@@ -13253,25 +13449,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(
@@ -13281,18 +13477,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"
     );
@@ -13304,13 +13500,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`
       );
@@ -13325,7 +13521,7 @@ function writeDeployConfig(resolvedPluginConfig, resolvedViteConfig) {
         auxiliaryWorkers.push({ configPath });
       }
     }
-    assert5(
+    assert6(
       entryWorkerConfigPath,
       `Unexpected error: entryWorkerConfigPath is undefined`
     );
@@ -13333,29 +13529,28 @@ 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,
   kCurrentWorker,
   Log,
   LogLevel,
-  Response as MiniflareResponse
+  Response as MiniflareResponse2
 } from "miniflare";
-import colors2 from "picocolors";
+import colors3 from "picocolors";
 import { globSync } from "tinyglobby";
 import "vite";
 import {
-  experimental_pickRemoteBindings,
-  experimental_startMixedModeSession,
+  experimental_maybeStartOrUpdateMixedModeSession,
   unstable_convertConfigBindingsToStartWorkerBindings,
   unstable_getMiniflareWorkerOptions
 } from "wrangler";
@@ -13364,7 +13559,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"
@@ -13383,8 +13578,9 @@ 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));
-        entrypointNames.add(value.entrypoint);
+        if (entrypointNames) {
+          entrypointNames.add(value.entrypoint);
+        }
       }
     }
   }
@@ -13398,20 +13594,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);
         }
       }
@@ -13429,13 +13625,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);
       }
     }
@@ -13466,8 +13662,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.`
           )
         )
@@ -13475,6 +13671,7 @@ function logUnknownTails(tails, userWorkers, log) {
     }
   }
 }
+var mixedModeSessionsDataMap = /* @__PURE__ */ new Map();
 async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspectorPort) {
   const resolvedViteConfig = viteDevServer.config;
   const entryWorkerConfig = getEntryWorkerConfig(resolvedPluginConfig);
@@ -13491,8 +13688,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))
           )
         }
@@ -13514,8 +13711,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))
           )
         }
@@ -13524,26 +13721,44 @@ async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspe
         CONFIG: assetsConfig
       },
       serviceBindings: {
-        __VITE_ASSET_EXISTS__: async (request) => {
+        __VITE_HTML_EXISTS__: async (request) => {
           const { pathname } = new URL(request.url);
-          let exists = false;
           if (pathname.endsWith(".html")) {
-            try {
-              const filePath = path6.join(resolvedViteConfig.root, pathname);
-              const stats = await fsp.stat(filePath);
-              exists = stats.isFile();
-            } catch (error) {
+            const { root, publicDir } = resolvedViteConfig;
+            const publicDirInRoot = publicDir.startsWith(
+              withTrailingSlash2(root)
+            );
+            const publicPath = withTrailingSlash2(publicDir.slice(root.length));
+            if (publicDirInRoot && pathname.startsWith(publicPath)) {
+              return MiniflareResponse2.json(null);
+            }
+            const publicDirFilePath = path7.join(publicDir, pathname);
+            const rootDirFilePath = path7.join(root, pathname);
+            for (const resolvedPath of [publicDirFilePath, rootDirFilePath]) {
+              try {
+                const stats = await fsp.stat(resolvedPath);
+                if (stats.isFile()) {
+                  return MiniflareResponse2.json(
+                    resolvedPath === publicDirFilePath ? `${PUBLIC_DIR_PREFIX}${pathname}` : pathname
+                  );
+                }
+              } catch (error) {
+              }
             }
           }
-          return MiniflareResponse.json(exists);
+          return MiniflareResponse2.json(null);
         },
-        __VITE_FETCH_ASSET__: async (request) => {
+        __VITE_FETCH_HTML__: async (request) => {
           const { pathname } = new URL(request.url);
-          const filePath = path6.join(resolvedViteConfig.root, pathname);
+          const { root, publicDir } = resolvedViteConfig;
+          const isInPublicDir = pathname.startsWith(PUBLIC_DIR_PREFIX);
+          const resolvedPath = isInPublicDir ? path7.join(publicDir, pathname.slice(PUBLIC_DIR_PREFIX.length)) : path7.join(root, pathname);
           try {
-            let html = await fsp.readFile(filePath, "utf-8");
-            html = await viteDevServer.transformIndexHtml(pathname, html);
-            return new MiniflareResponse(html, {
+            let html = await fsp.readFile(resolvedPath, "utf-8");
+            if (!isInPublicDir) {
+              html = await viteDevServer.transformIndexHtml(resolvedPath, html);
+            }
+            return new MiniflareResponse2(html, {
               headers: { "Content-Type": "text/html" }
             });
           } catch (error) {
@@ -13556,7 +13771,23 @@ async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspe
   const workersFromConfig = resolvedPluginConfig.type === "workers" ? await Promise.all(
     Object.entries(resolvedPluginConfig.workers).map(
       async ([environmentName, workerConfig]) => {
-        const mixedModeSession = resolvedPluginConfig.experimental.mixedMode ? await maybeStartOrUpdateMixedModeSession(workerConfig) : void 0;
+        const bindings = unstable_convertConfigBindingsToStartWorkerBindings(
+          workerConfig
+        );
+        const preExistingMixedModeSession = workerConfig.configPath ? mixedModeSessionsDataMap.get(workerConfig.configPath) : void 0;
+        const mixedModeSessionData = resolvedPluginConfig.experimental.mixedMode ? await experimental_maybeStartOrUpdateMixedModeSession(
+          {
+            name: workerConfig.name,
+            bindings: bindings ?? {}
+          },
+          preExistingMixedModeSession ?? null
+        ) : void 0;
+        if (workerConfig.configPath && mixedModeSessionData) {
+          mixedModeSessionsDataMap.set(
+            workerConfig.configPath,
+            mixedModeSessionData
+          );
+        }
         const miniflareWorkerOptions = unstable_getMiniflareWorkerOptions(
           {
             ...workerConfig,
@@ -13564,7 +13795,7 @@ async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspe
           },
           resolvedPluginConfig.cloudflareEnv,
           {
-            mixedModeConnectionString: mixedModeSession?.mixedModeConnectionString,
+            mixedModeConnectionString: mixedModeSessionData?.session?.mixedModeConnectionString,
             mixedModeEnabled: resolvedPluginConfig.experimental.mixedMode
           }
         );
@@ -13595,7 +13826,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}`
                 );
@@ -13605,11 +13836,11 @@ async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspe
                     externalize: moduleId,
                     type: "module"
                   };
-                  return MiniflareResponse.json({ result: result2 });
+                  return MiniflareResponse2.json({ result: result2 });
                 }
                 const devEnvironment = viteDevServer.environments[environmentName];
                 const result = await devEnvironment.hot.handleInvoke(payload);
-                return MiniflareResponse.json(result);
+                return MiniflareResponse2.json(result);
               }
             }
           }
@@ -13653,7 +13884,7 @@ async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspe
         const workerEntrypointNames = workerToWorkerEntrypointNamesMap.get(
           workerOptions.name
         );
-        assert6(
+        assert7(
           workerEntrypointNames,
           `WorkerEntrypoint names not found for worker ${workerOptions.name}`
         );
@@ -13665,7 +13896,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}`
         );
@@ -13675,7 +13906,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}`
         );
@@ -13694,13 +13925,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))
               )
             }
@@ -13712,18 +13943,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}.`
       );
@@ -13737,25 +13968,25 @@ async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspe
       }
       switch (moduleType) {
         case "CompiledWasm": {
-          return MiniflareResponse.json({ wasm: Array.from(contents) });
+          return MiniflareResponse2.json({ wasm: Array.from(contents) });
         }
         case "Data": {
-          return MiniflareResponse.json({ data: Array.from(contents) });
+          return MiniflareResponse2.json({ data: Array.from(contents) });
         }
         case "Text": {
-          return MiniflareResponse.json({ text: contents.toString() });
+          return MiniflareResponse2.json({ text: contents.toString() });
         }
         default: {
-          return MiniflareResponse.error();
+          return MiniflareResponse2.error();
         }
       }
     }
   };
 }
 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: [
@@ -13764,9 +13995,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
         }))
       )
     ]
@@ -13776,12 +14007,26 @@ async function getPreviewMiniflareOptions(vitePreviewServer, workerConfigs, pers
   const resolvedViteConfig = vitePreviewServer.config;
   const workers = (await Promise.all(
     workerConfigs.map(async (workerConfig, i) => {
-      const mixedModeSession = mixedModeEnabled ? await maybeStartOrUpdateMixedModeSession(workerConfig) : void 0;
+      const bindings = unstable_convertConfigBindingsToStartWorkerBindings(workerConfig);
+      const preExistingMixedModeSessionData = workerConfig.configPath ? mixedModeSessionsDataMap.get(workerConfig.configPath) : void 0;
+      const mixedModeSessionData = mixedModeEnabled ? await experimental_maybeStartOrUpdateMixedModeSession(
+        {
+          name: workerConfig.name,
+          bindings: bindings ?? {}
+        },
+        preExistingMixedModeSessionData ?? null
+      ) : void 0;
+      if (workerConfig.configPath && mixedModeSessionData) {
+        mixedModeSessionsDataMap.set(
+          workerConfig.configPath,
+          mixedModeSessionData
+        );
+      }
       const miniflareWorkerOptions = unstable_getMiniflareWorkerOptions(
         workerConfig,
         void 0,
         {
-          mixedModeConnectionString: mixedModeSession?.mixedModeConnectionString,
+          mixedModeConnectionString: mixedModeSessionData?.session?.mixedModeConnectionString,
           mixedModeEnabled
         }
       );
@@ -13859,34 +14104,94 @@ function miniflareLogLevelFromViteLogLevel(level = "info") {
       return LogLevel.NONE;
   }
 }
-var mixedModeSessionsMap = /* @__PURE__ */ new Map();
-async function maybeStartOrUpdateMixedModeSession(workerConfig) {
-  const workerRemoteBindings = experimental_pickRemoteBindings(
-    unstable_convertConfigBindingsToStartWorkerBindings(workerConfig) ?? {}
-  );
-  assert6(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);
-      mixedModeSessionsMap.set(workerConfig.name, mixedModeSession);
+
+// src/plugin-config.ts
+import assert9 from "node:assert";
+import * as path9 from "node:path";
+
+// ../workers-shared/utils/configuration/parseStaticRouting.ts
+function parseStaticRouting(input) {
+  if (input.length === 0) {
+    throw new Error(
+      "No `run_worker_first` rules were provided; must provide at least 1 rule."
+    );
+  }
+  if (input.length > MAX_ROUTES_RULES) {
+    throw new Error(
+      `Too many \`run_worker_first\` rules were provided; ${input.length} rules provided exceeds max of ${MAX_ROUTES_RULES}.`
+    );
+  }
+  const rawAssetWorkerRules = [];
+  const assetWorkerRules = [];
+  const userWorkerRules = [];
+  const invalidRules = [];
+  for (const rule of input) {
+    if (rule.startsWith("!/")) {
+      assetWorkerRules.push(rule.slice(1));
+      rawAssetWorkerRules.push(rule);
+    } else if (rule.startsWith("/")) {
+      userWorkerRules.push(rule);
+    } else if (rule.startsWith("!")) {
+      invalidRules.push(`'${rule}': negative rules must start with '!/'`);
+    } else {
+      invalidRules.push(`'${rule}': rules must start with '/' or '!/'`);
     }
-  } else {
-    await mixedModeSession.updateBindings(workerRemoteBindings);
   }
-  await mixedModeSession?.ready;
-  return mixedModeSession;
+  if (assetWorkerRules.length > 0 && userWorkerRules.length === 0) {
+    throw new Error(
+      "Only negative `run_worker_first` rules were provided; must provide at least 1 non-negative rule"
+    );
+  }
+  const invalidAssetWorkerRules = validateStaticRoutingRules(rawAssetWorkerRules);
+  const invalidUserWorkerRules = validateStaticRoutingRules(userWorkerRules);
+  const errorMessage = formatInvalidRoutes([
+    ...invalidRules,
+    ...invalidUserWorkerRules,
+    ...invalidAssetWorkerRules
+  ]);
+  if (errorMessage) {
+    throw new Error(errorMessage);
+  }
+  return { asset_worker: assetWorkerRules, user_worker: userWorkerRules };
+}
+function validateStaticRoutingRules(rules) {
+  const invalid = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const rule of rules) {
+    if (rule.length > MAX_ROUTES_RULE_LENGTH) {
+      invalid.push(
+        `'${rule}': all rules must be less than ${MAX_ROUTES_RULE_LENGTH} characters in length`
+      );
+    }
+    if (seen.has(rule)) {
+      invalid.push(`'${rule}': rule is a duplicate; rules must be unique`);
+    }
+    if (rule.endsWith("*")) {
+      for (const otherRule of rules) {
+        if (otherRule !== rule && otherRule.startsWith(rule.slice(0, -1))) {
+          invalid.push(`'${otherRule}': rule '${rule}' makes it redundant`);
+        }
+      }
+    }
+    seen.add(rule);
+  }
+  return invalid;
 }
+var formatInvalidRoutes = (invalidRules) => {
+  if (invalidRules.length === 0) {
+    return void 0;
+  }
+  return `Invalid routes in \`run_worker_first\`:
+` + invalidRules.join("\n");
+};
 
 // src/plugin-config.ts
-import assert8 from "node:assert";
-import * as path8 from "node:path";
-import * as vite6 from "vite";
+import * as vite5 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 = {
   /**
@@ -13981,7 +14286,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("");
@@ -13995,7 +14300,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));
     }
@@ -14076,7 +14381,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`
@@ -14100,17 +14405,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`
@@ -14123,7 +14428,7 @@ function getValidatedWranglerConfigPath(root, requestedConfigPath, isForAuxiliar
     }
     return configPath2;
   }
-  assert7(
+  assert8(
     isForAuxiliaryWorker === false,
     "Unexpected Error: trying to find the wrangler config for an auxiliary worker"
   );
@@ -14137,8 +14442,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;
     }
   }
@@ -14153,8 +14458,8 @@ 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 { CLOUDFLARE_ENV: cloudflareEnv } = vite6.loadEnv(
+  const root = userConfig.root ? path9.resolve(userConfig.root) : process.cwd();
+  const { CLOUDFLARE_ENV: cloudflareEnv } = vite5.loadEnv(
     viteEnv.mode,
     root,
     /* prefixes */
@@ -14188,6 +14493,12 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
   }
   const entryWorkerConfig = entryWorkerResolvedConfig.config;
   const entryWorkerEnvironmentName = pluginConfig.viteEnvironment?.name ?? workerNameToEnvironmentName(entryWorkerConfig.topLevelName);
+  let staticRouting;
+  if (Array.isArray(entryWorkerConfig.assets?.run_worker_first)) {
+    staticRouting = parseStaticRouting(
+      entryWorkerConfig.assets.run_worker_first
+    );
+  }
   const workers = {
     [entryWorkerEnvironmentName]: entryWorkerConfig
   };
@@ -14207,7 +14518,7 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
       }
     );
     auxiliaryWorkersResolvedConfigs.push(workerResolvedConfig);
-    assert8(
+    assert9(
       workerResolvedConfig.type === "worker",
       "Unexpected error: received AssetsOnlyResult with auxiliary workers."
     );
@@ -14226,6 +14537,7 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
     persistState,
     workers,
     entryWorkerEnvironmentName,
+    staticRouting,
     rawConfigs: {
       entryWorker: entryWorkerResolvedConfig,
       auxiliaryWorkers: auxiliaryWorkersResolvedConfigs
@@ -14273,14 +14585,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)) {
@@ -14297,8 +14609,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);
@@ -14331,7 +14643,6 @@ function cloudflare2(pluginConfig = {}) {
   let resolvedViteConfig;
   const additionalModulePaths = /* @__PURE__ */ new Set();
   const nodeJsCompatWarningsMap = /* @__PURE__ */ new Map();
-  let hasClientBuild = false;
   return [
     {
       name: "vite-plugin-cloudflare",
@@ -14355,8 +14666,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(
@@ -14366,7 +14688,10 @@ function cloudflare2(pluginConfig = {}) {
                     createCloudflareEnvironmentOptions(
                       workerConfig,
                       userConfig,
-                      environmentName
+                      {
+                        name: environmentName,
+                        isEntry: resolvedPluginConfig.type === "workers" && environmentName === resolvedPluginConfig.entryWorkerEnvironmentName
+                      }
                     )
                   ];
                 }
@@ -14379,33 +14704,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)
           }
         };
       },
@@ -14437,18 +14736,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 {
@@ -14496,15 +14795,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,
@@ -14530,40 +14826,78 @@ function cloudflare2(pluginConfig = {}) {
           await miniflare.setOptions(miniflareDevOptions);
         }
         await initRunners(resolvedPluginConfig, viteDevServer, miniflare);
-        if (viteDevServer.httpServer) {
-          handleWebSocket(viteDevServer.httpServer, async () => {
-            assert10(miniflare, `Miniflare not defined`);
-            const routerWorker = await miniflare.getWorker(ROUTER_WORKER_NAME);
-            return routerWorker.fetch;
-          });
+        let preMiddleware;
+        if (resolvedPluginConfig.type === "workers") {
+          const entryWorkerConfig = getWorkerConfig2(
+            resolvedPluginConfig.entryWorkerEnvironmentName
+          );
+          assert11(entryWorkerConfig, `No entry Worker config`);
+          const entryWorkerName = entryWorkerConfig.name;
+          if (viteDevServer.httpServer) {
+            handleWebSocket(viteDevServer.httpServer, async () => {
+              assert11(miniflare, `Miniflare not defined`);
+              const entryWorker = await miniflare.getWorker(entryWorkerName);
+              return entryWorker.fetch;
+            });
+          }
+          const staticRouting = entryWorkerConfig.assets?.run_worker_first === true ? { user_worker: ["/*"] } : resolvedPluginConfig.staticRouting;
+          if (staticRouting) {
+            const excludeRulesMatcher = generateStaticRoutingRuleMatcher(
+              staticRouting.asset_worker ?? []
+            );
+            const includeRulesMatcher = generateStaticRoutingRuleMatcher(
+              staticRouting.user_worker
+            );
+            const userWorkerHandler = createRequestHandler(async (request) => {
+              assert11(miniflare, `Miniflare not defined`);
+              const userWorker = await miniflare.getWorker(entryWorkerName);
+              return userWorker.fetch(request, { redirect: "manual" });
+            });
+            preMiddleware = async (req, res, next) => {
+              assert11(req.url, `req.url not defined`);
+              const request = new Request(new URL(req.url, UNKNOWN_HOST));
+              if (req[kRequestType] === "asset") {
+                next();
+              } else if (excludeRulesMatcher({ request })) {
+                req[kRequestType] === "asset";
+                next();
+              } else if (includeRulesMatcher({ request })) {
+                userWorkerHandler(req, res, next);
+              } else {
+                next();
+              }
+            };
+          }
         }
         return () => {
-          viteDevServer.middlewares.use(async (req, res, next) => {
-            try {
-              assert10(miniflare, `Miniflare not defined`);
-              const request = createRequest(req, res);
-              let response;
+          if (preMiddleware) {
+            const middlewareStack = viteDevServer.middlewares.stack;
+            const cachedTransformMiddlewareIndex = middlewareStack.findIndex(
+              (middleware) => "name" in middleware.handle && middleware.handle.name === "viteCachedTransformMiddleware"
+            );
+            assert11(
+              cachedTransformMiddlewareIndex !== -1,
+              "Failed to find viteCachedTransformMiddleware"
+            );
+            middlewareStack.splice(cachedTransformMiddlewareIndex, 0, {
+              route: "",
+              handle: preMiddleware
+            });
+          }
+          viteDevServer.middlewares.use(
+            createRequestHandler(async (request, req) => {
+              assert11(miniflare, `Miniflare not defined`);
               if (req[kRequestType] === "asset") {
                 const assetWorker = await miniflare.getWorker(ASSET_WORKER_NAME);
-                response = await assetWorker.fetch(
-                  toMiniflareRequest(request),
-                  { redirect: "manual" }
-                );
+                return assetWorker.fetch(request, { redirect: "manual" });
               } else {
                 const routerWorker = await miniflare.getWorker(ROUTER_WORKER_NAME);
-                response = await routerWorker.fetch(
-                  toMiniflareRequest(request),
-                  { redirect: "manual" }
-                );
-              }
-              if (req.httpVersionMajor === 2) {
-                response.headers.delete("transfer-encoding");
+                return routerWorker.fetch(request, {
+                  redirect: "manual"
+                });
               }
-              await sendResponse(res, response);
-            } catch (error) {
-              next(error);
-            }
-          });
+            })
+          );
         };
       },
       async configurePreviewServer(vitePreviewServer) {
@@ -14588,21 +14922,25 @@ function cloudflare2(pluginConfig = {}) {
           vitePreviewServer.httpServer,
           () => miniflare2.dispatchFetch
         );
-        vitePreviewServer.middlewares.use(async (req, res, next) => {
-          try {
-            const request = createRequest(req, res);
-            const response = await miniflare2.dispatchFetch(
-              toMiniflareRequest(request),
-              { redirect: "manual" }
-            );
-            if (req.httpVersionMajor === 2) {
-              response.headers.delete("transfer-encoding");
-            }
-            await sendResponse(res, response);
-          } catch (error) {
-            next(error);
-          }
-        });
+        vitePreviewServer.middlewares.use(
+          createRequestHandler((request) => {
+            return miniflare2.dispatchFetch(request, { redirect: "manual" });
+          })
+        );
+      }
+    },
+    // 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
@@ -14664,7 +15002,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}.`
           );
@@ -14678,13 +15016,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)
+          const relativePath = vite6.normalizePath(
+            path10.relative(path10.dirname(chunk.fileName), emittedFileName)
           );
           const importPath = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
           magicString.update(
@@ -14744,12 +15082,15 @@ function cloudflare2(pluginConfig = {}) {
       // rather than allowing the resolve hook here to alias then to polyfills.
       enforce: "pre",
       async resolveId(source, importer, options) {
+        if (isGlobalVirtualModule(source)) {
+          return source;
+        }
         const result = resolveNodeJSImport(source);
         if (!result) {
           return this.resolve(source, importer, options);
         }
         if (this.environment.mode === "dev") {
-          assert10(
+          assert11(
             this.environment.depsOptimizer,
             "depsOptimizer is required in dev mode"
           );
@@ -14761,6 +15102,9 @@ function cloudflare2(pluginConfig = {}) {
         }
         return this.resolve(result.resolved, importer, options);
       },
+      load(id) {
+        return getGlobalVirtualModule(id);
+      },
       async transform(code, id) {
         const workerConfig = getWorkerConfig2(this.environment.name);
         if (!workerConfig) {
@@ -14845,7 +15189,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) => {
@@ -14880,13 +15224,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 };
                         }
                       );
                     }
@@ -14929,7 +15273,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;
   }
 }
@@ -14943,7 +15287,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
 `
       )
@@ -14959,19 +15303,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;
     }