@cloudflare/vite-plugin 1.6.0 → 1.7.0

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

@@ -6021,7 +6021,7 @@ var CustomAssetWorker = class extends worker_default {
   }
   async unstable_getByETag(eTag) {
     const url = new URL(eTag, UNKNOWN_HOST);
-    const response = await this.env.__VITE_FETCH_ASSET__.fetch(url);
+    const response = await this.env.__VITE_FETCH_HTML__.fetch(url);
     if (!response.body) {
       throw new Error(`Unexpected error. No HTML found for "${eTag}".`);
     }
@@ -6033,9 +6033,8 @@ var CustomAssetWorker = class extends worker_default {
   }
   async unstable_exists(pathname) {
     const url = new URL(pathname.replace(/^\/{2,}/, "/"), UNKNOWN_HOST);
-    const response = await this.env.__VITE_ASSET_EXISTS__.fetch(url);
-    const exists = await response.json();
-    return exists ? pathname : null;
+    const response = await this.env.__VITE_HTML_EXISTS__.fetch(url);
+    return response.json();
   }
   async unstable_canFetch(request) {
     const secFetchMode = request.headers.get("X-Mf-Sec-Fetch-Mode");

package/dist/index.js

@@ -489,7 +489,32 @@ import assert11 from "node:assert";
 import * as fs6 from "node:fs";
 import * as fsp2 from "node:fs/promises";
 import * as path10 from "node:path";
-import { createRequest, sendResponse } from "@mjackson/node-fetch-server";
+
+// ../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
@@ -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() {
@@ -1559,7 +1584,7 @@ var MagicString = class _MagicString {
 // src/index.ts
 import { Miniflare } from "miniflare";
 import colors4 from "picocolors";
-import * as vite7 from "vite";
+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,7 +1749,7 @@ ${invalidHeaderRulesList}`
   }
   return {
     headers: {
-      version: HEADERS_VERSION,
+      version: HEADERS_VERSION2,
       rules
     }
   };
@@ -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;
@@ -6047,7 +6076,7 @@ function getImportedAssetPaths(viteManifest) {
 
 // src/cloudflare-environment.ts
 import assert4 from "node:assert";
-import * as vite3 from "vite";
+import * as vite2 from "vite";
 
 // src/node-js-compat.ts
 import assert3 from "node:assert";
@@ -13030,24 +13059,41 @@ function isNodeAls(workerConfig) {
 function isNodeAlsModule(path11) {
   return /^(node:)?async_hooks$/.test(path11);
 }
-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;
-    assert3(
-      moduleSpecifier !== void 0,
-      "Expected moduleSpecifier to be defined"
+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
     );
-    assert3(exportName !== void 0, "Expected exportName to be defined");
-    return `import var_${globalName} from "${moduleSpecifier}";
-globalThis.${globalName} = var_${globalName}.${exportName};
-`;
-  }).join("\n");
+  }
+  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 = Array.from(virtualModulePathToSpecifier.keys()).map((moduleId) => `import "${moduleId}";
+`).join("");
   const polyfillCode = env.polyfill.map((polyfillPath) => `import "${polyfillPath}";
 `).join("");
   const modified = new MagicString(code);
@@ -13143,13 +13189,41 @@ var VITE_DEV_METADATA_HEADER = "__VITE_DEV_METADATA__";
 
 // src/utils.ts
 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 ?? 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");
   if (host) {
@@ -13166,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";
@@ -13218,7 +13285,7 @@ function createHotChannel(webSocketContainer) {
     }
   };
 }
-var CloudflareDevEnvironment = class extends vite3.DevEnvironment {
+var CloudflareDevEnvironment = class extends vite2.DevEnvironment {
   #webSocketContainer;
   #worker;
   constructor(name, config) {
@@ -13279,7 +13346,7 @@ function createCloudflareEnvironmentOptions(workerConfig, userConfig, environmen
     },
     build: {
       createEnvironment(name, config) {
-        return new vite3.BuildEnvironment(name, config);
+        return new vite2.BuildEnvironment(name, config);
       },
       target,
       emitAssets: true,
@@ -13477,14 +13544,13 @@ import {
   kCurrentWorker,
   Log,
   LogLevel,
-  Response as MiniflareResponse
+  Response as MiniflareResponse2
 } from "miniflare";
 import colors3 from "picocolors";
 import { globSync } from "tinyglobby";
 import "vite";
 import {
-  experimental_pickRemoteBindings,
-  experimental_startMixedModeSession,
+  experimental_maybeStartOrUpdateMixedModeSession,
   unstable_convertConfigBindingsToStartWorkerBindings,
   unstable_getMiniflareWorkerOptions
 } from "wrangler";
@@ -13512,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);
-        assert7(entrypointNames, missingWorkerErrorMessage(targetWorkerName));
-        entrypointNames.add(value.entrypoint);
+        if (entrypointNames) {
+          entrypointNames.add(value.entrypoint);
+        }
       }
     }
   }
@@ -13604,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);
@@ -13653,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 = path7.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 = path7.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) {
@@ -13685,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,
@@ -13693,7 +13795,7 @@ async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspe
           },
           resolvedPluginConfig.cloudflareEnv,
           {
-            mixedModeConnectionString: mixedModeSession?.mixedModeConnectionString,
+            mixedModeConnectionString: mixedModeSessionData?.session?.mixedModeConnectionString,
             mixedModeEnabled: resolvedPluginConfig.experimental.mixedMode
           }
         );
@@ -13734,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);
               }
             }
           }
@@ -13866,16 +13968,16 @@ 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();
         }
       }
     }
@@ -13905,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
         }
       );
@@ -13988,34 +14104,89 @@ function miniflareLogLevelFromViteLogLevel(level = "info") {
       return LogLevel.NONE;
   }
 }
-var mixedModeSessionsMap = /* @__PURE__ */ new Map();
-async function maybeStartOrUpdateMixedModeSession(workerConfig) {
-  const workerRemoteBindings = experimental_pickRemoteBindings(
-    unstable_convertConfigBindingsToStartWorkerBindings(workerConfig) ?? {}
-  );
-  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,
-        {
-          workerName: workerConfig.name
-        }
+
+// 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 '!/'`);
+    }
+  }
+  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`
       );
-      mixedModeSessionsMap.set(workerConfig.name, mixedModeSession);
     }
-  } else {
-    await mixedModeSession.updateBindings(workerRemoteBindings);
+    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);
   }
-  await mixedModeSession?.ready;
-  return mixedModeSession;
+  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 assert9 from "node:assert";
-import * as path9 from "node:path";
-import * as vite6 from "vite";
+import * as vite5 from "vite";
 
 // src/workers-configs.ts
 import assert8 from "node:assert";
@@ -14288,7 +14459,7 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
   const persistState = pluginConfig.persistState ?? true;
   const experimental = pluginConfig.experimental ?? {};
   const root = userConfig.root ? path9.resolve(userConfig.root) : process.cwd();
-  const { CLOUDFLARE_ENV: cloudflareEnv } = vite6.loadEnv(
+  const { CLOUDFLARE_ENV: cloudflareEnv } = vite5.loadEnv(
     viteEnv.mode,
     root,
     /* prefixes */
@@ -14322,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
   };
@@ -14360,6 +14537,7 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
     persistState,
     workers,
     entryWorkerEnvironmentName,
+    staticRouting,
     rawConfigs: {
       entryWorker: entryWorkerResolvedConfig,
       auxiliaryWorkers: auxiliaryWorkersResolvedConfigs
@@ -14648,40 +14826,78 @@ function cloudflare2(pluginConfig = {}) {
           await miniflare.setOptions(miniflareDevOptions);
         }
         await initRunners(resolvedPluginConfig, viteDevServer, miniflare);
-        if (viteDevServer.httpServer) {
-          handleWebSocket(viteDevServer.httpServer, async () => {
-            assert11(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 {
+          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`);
-              const request = createRequest(req, res);
-              let response;
               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) {
@@ -14706,21 +14922,11 @@ 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
@@ -14815,7 +15021,7 @@ function cloudflare2(pluginConfig = {}) {
             source
           });
           const emittedFileName = this.getFileName(referenceId);
-          const relativePath = vite7.normalizePath(
+          const relativePath = vite6.normalizePath(
             path10.relative(path10.dirname(chunk.fileName), emittedFileName)
           );
           const importPath = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
@@ -14876,6 +15082,9 @@ 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);
@@ -14893,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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudflare/vite-plugin",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "Cloudflare plugin for Vite",
   "keywords": [
     "cloudflare",
@@ -33,7 +33,7 @@
     "dist"
   ],
   "dependencies": {
-    "@cloudflare/unenv-preset": "2.3.2",
+    "@cloudflare/unenv-preset": "2.3.3",
     "@mjackson/node-fetch-server": "^0.6.1",
     "@rollup/plugin-replace": "^6.0.1",
     "get-port": "^7.1.0",
@@ -41,11 +41,11 @@
     "tinyglobby": "^0.2.12",
     "unenv": "2.0.0-rc.17",
     "ws": "8.18.0",
-    "miniflare": "4.20250604.1",
-    "wrangler": "4.20.0"
+    "miniflare": "4.20250612.0",
+    "wrangler": "4.20.1"
   },
   "devDependencies": {
-    "@cloudflare/workers-types": "^4.20250604.0",
+    "@cloudflare/workers-types": "^4.20250612.0",
     "@types/node": "^22.10.1",
     "@types/ws": "^8.5.13",
     "magic-string": "^0.30.12",
@@ -54,9 +54,9 @@
     "typescript": "^5.7.2",
     "vite": "^6.1.0",
     "vitest": "~3.2.0",
+    "@cloudflare/mock-npm-registry": "0.0.0",
     "@cloudflare/workers-shared": "0.17.6",
-    "@cloudflare/workers-tsconfig": "0.0.0",
-    "@cloudflare/mock-npm-registry": "0.0.0"
+    "@cloudflare/workers-tsconfig": "0.0.0"
   },
   "peerDependencies": {
     "vite": "^6.1.0",