@cloudflare/vite-plugin 0.0.0-9adbd50cf → 0.0.0-9b86dba81

package/dist/index.js

@@ -1,6 +1,7 @@
 // src/index.ts
-import assert9 from "node:assert";
+import assert7 from "node:assert";
 import * as fs5 from "node:fs";
+import * as fsp2 from "node:fs/promises";
 import { builtinModules as builtinModules2 } from "node:module";
 import * as path7 from "node:path";
 import { createMiddleware } from "@hattip/adapter-node";
@@ -1073,6 +1074,36 @@ var MagicString = class _MagicString {
 import { Miniflare } from "miniflare";
 import * as vite6 from "vite";
 
+// src/constants.ts
+var ROUTER_WORKER_NAME = "__router-worker__";
+var ASSET_WORKER_NAME = "__asset-worker__";
+var ASSET_WORKERS_COMPATIBILITY_DATE = "2024-10-04";
+var ADDITIONAL_MODULE_TYPES = [
+  "CompiledWasm",
+  "Data",
+  "Text"
+];
+
+// src/additional-modules.ts
+var moduleRules = [
+  { type: "CompiledWasm", extensions: [".wasm", ".wasm?module"] },
+  { type: "Data", extensions: [".bin"] },
+  { type: "Text", extensions: [".txt", ".html"] }
+];
+function matchAdditionalModule(source) {
+  for (const rule of moduleRules) {
+    for (const extension of rule.extensions) {
+      if (source.endsWith(extension)) {
+        return rule.type;
+      }
+    }
+  }
+  return null;
+}
+function createModuleReference(type, id) {
+  return `__CLOUDFLARE_MODULE__${type}__${id}__`;
+}
+
 // src/cloudflare-environment.ts
 import assert3 from "node:assert";
 import * as vite2 from "vite";
@@ -1178,16 +1209,16 @@ var TokenType = function TokenType2(label, conf) {
   this.binop = conf.binop || null;
   this.updateContext = null;
 };
-function binop(name2, prec) {
-  return new TokenType(name2, { beforeExpr: true, binop: prec });
+function binop(name, prec) {
+  return new TokenType(name, { beforeExpr: true, binop: prec });
 }
 var beforeExpr = { beforeExpr: true };
 var startsExpr = { startsExpr: true };
 var keywords = {};
-function kw(name2, options) {
+function kw(name, options) {
   if (options === void 0) options = {};
-  options.keyword = name2;
-  return keywords[name2] = new TokenType(name2, options);
+  options.keyword = name;
+  return keywords[name] = new TokenType(name, options);
 }
 var types$1 = {
   num: new TokenType("num", startsExpr),
@@ -1664,18 +1695,18 @@ pp$9.eat = function(type) {
     return false;
   }
 };
-pp$9.isContextual = function(name2) {
-  return this.type === types$1.name && this.value === name2 && !this.containsEsc;
+pp$9.isContextual = function(name) {
+  return this.type === types$1.name && this.value === name && !this.containsEsc;
 };
-pp$9.eatContextual = function(name2) {
-  if (!this.isContextual(name2)) {
+pp$9.eatContextual = function(name) {
+  if (!this.isContextual(name)) {
     return false;
   }
   this.next();
   return true;
 };
-pp$9.expectContextual = function(name2) {
-  if (!this.eatContextual(name2)) {
+pp$9.expectContextual = function(name) {
+  if (!this.eatContextual(name)) {
     this.unexpected();
   }
 };
@@ -1769,8 +1800,8 @@ pp$8.parseTopLevel = function(node) {
   }
   if (this.inModule) {
     for (var i = 0, list = Object.keys(this.undefinedExports); i < list.length; i += 1) {
-      var name2 = list[i];
-      this.raiseRecoverable(this.undefinedExports[name2].start, "Export '" + name2 + "' is not defined");
+      var name = list[i];
+      this.raiseRecoverable(this.undefinedExports[name].start, "Export '" + name + "' is not defined");
     }
   }
   this.adaptDirectivePrologue(node.body);
@@ -2513,26 +2544,26 @@ pp$8.exitClassBody = function() {
   }
 };
 function isPrivateNameConflicted(privateNameMap, element) {
-  var name2 = element.key.name;
-  var curr = privateNameMap[name2];
+  var name = element.key.name;
+  var curr = privateNameMap[name];
   var next = "true";
   if (element.type === "MethodDefinition" && (element.kind === "get" || element.kind === "set")) {
     next = (element.static ? "s" : "i") + element.kind;
   }
   if (curr === "iget" && next === "iset" || curr === "iset" && next === "iget" || curr === "sget" && next === "sset" || curr === "sset" && next === "sget") {
-    privateNameMap[name2] = "true";
+    privateNameMap[name] = "true";
     return false;
   } else if (!curr) {
-    privateNameMap[name2] = next;
+    privateNameMap[name] = next;
     return false;
   } else {
     return true;
   }
 }
-function checkKeyName(node, name2) {
+function checkKeyName(node, name) {
   var computed = node.computed;
   var key = node.key;
-  return !computed && (key.type === "Identifier" && key.name === name2 || key.type === "Literal" && key.value === name2);
+  return !computed && (key.type === "Identifier" && key.name === name || key.type === "Literal" && key.value === name);
 }
 pp$8.parseExportAllDeclaration = function(node, exports) {
   if (this.options.ecmaVersion >= 11) {
@@ -2620,17 +2651,17 @@ pp$8.parseExportDefaultDeclaration = function() {
     return declaration;
   }
 };
-pp$8.checkExport = function(exports, name2, pos) {
+pp$8.checkExport = function(exports, name, pos) {
   if (!exports) {
     return;
   }
-  if (typeof name2 !== "string") {
-    name2 = name2.type === "Identifier" ? name2.name : name2.value;
+  if (typeof name !== "string") {
+    name = name.type === "Identifier" ? name.name : name.value;
   }
-  if (hasOwn(exports, name2)) {
-    this.raiseRecoverable(pos, "Duplicate export '" + name2 + "'");
+  if (hasOwn(exports, name)) {
+    this.raiseRecoverable(pos, "Duplicate export '" + name + "'");
   }
-  exports[name2] = true;
+  exports[name] = true;
 };
 pp$8.checkPatternExport = function(exports, pat) {
   var type = pat.type;
@@ -3210,20 +3241,20 @@ pp$5.checkPropClash = function(prop, propHash, refDestructuringErrors) {
     return;
   }
   var key = prop.key;
-  var name2;
+  var name;
   switch (key.type) {
     case "Identifier":
-      name2 = key.name;
+      name = key.name;
       break;
     case "Literal":
-      name2 = String(key.value);
+      name = String(key.value);
       break;
     default:
       return;
   }
   var kind = prop.kind;
   if (this.options.ecmaVersion >= 6) {
-    if (name2 === "__proto__" && kind === "init") {
+    if (name === "__proto__" && kind === "init") {
       if (propHash.proto) {
         if (refDestructuringErrors) {
           if (refDestructuringErrors.doubleProto < 0) {
@@ -3237,8 +3268,8 @@ pp$5.checkPropClash = function(prop, propHash, refDestructuringErrors) {
     }
     return;
   }
-  name2 = "$" + name2;
-  var other = propHash[name2];
+  name = "$" + name;
+  var other = propHash[name];
   if (other) {
     var redefinition;
     if (kind === "init") {
@@ -3250,7 +3281,7 @@ pp$5.checkPropClash = function(prop, propHash, refDestructuringErrors) {
       this.raiseRecoverable(key.start, "Redefinition of property");
     }
   } else {
-    other = propHash[name2] = {
+    other = propHash[name] = {
       init: false,
       get: false,
       set: false
@@ -4150,31 +4181,31 @@ pp$5.parseExprList = function(close, allowTrailingComma, allowEmpty, refDestruct
 pp$5.checkUnreserved = function(ref2) {
   var start = ref2.start;
   var end = ref2.end;
-  var name2 = ref2.name;
-  if (this.inGenerator && name2 === "yield") {
+  var name = ref2.name;
+  if (this.inGenerator && name === "yield") {
     this.raiseRecoverable(start, "Cannot use 'yield' as identifier inside a generator");
   }
-  if (this.inAsync && name2 === "await") {
+  if (this.inAsync && name === "await") {
     this.raiseRecoverable(start, "Cannot use 'await' as identifier inside an async function");
   }
-  if (this.currentThisScope().inClassFieldInit && name2 === "arguments") {
+  if (this.currentThisScope().inClassFieldInit && name === "arguments") {
     this.raiseRecoverable(start, "Cannot use 'arguments' in class field initializer");
   }
-  if (this.inClassStaticBlock && (name2 === "arguments" || name2 === "await")) {
-    this.raise(start, "Cannot use " + name2 + " in class static initialization block");
+  if (this.inClassStaticBlock && (name === "arguments" || name === "await")) {
+    this.raise(start, "Cannot use " + name + " in class static initialization block");
   }
-  if (this.keywords.test(name2)) {
-    this.raise(start, "Unexpected keyword '" + name2 + "'");
+  if (this.keywords.test(name)) {
+    this.raise(start, "Unexpected keyword '" + name + "'");
   }
   if (this.options.ecmaVersion < 6 && this.input.slice(start, end).indexOf("\\") !== -1) {
     return;
   }
   var re = this.strict ? this.reservedWordsStrict : this.reservedWords;
-  if (re.test(name2)) {
-    if (!this.inAsync && name2 === "await") {
+  if (re.test(name)) {
+    if (!this.inAsync && name === "await") {
       this.raiseRecoverable(start, "Cannot use keyword 'await' outside an async function");
     }
-    this.raiseRecoverable(start, "The keyword '" + name2 + "' is reserved");
+    this.raiseRecoverable(start, "The keyword '" + name + "' is reserved");
   }
 };
 pp$5.parseIdent = function(liberal) {
@@ -4279,36 +4310,36 @@ pp$3.exitScope = function() {
 pp$3.treatFunctionsAsVarInScope = function(scope) {
   return scope.flags & SCOPE_FUNCTION || !this.inModule && scope.flags & SCOPE_TOP;
 };
-pp$3.declareName = function(name2, bindingType, pos) {
+pp$3.declareName = function(name, bindingType, pos) {
   var redeclared = false;
   if (bindingType === BIND_LEXICAL) {
     var scope = this.currentScope();
-    redeclared = scope.lexical.indexOf(name2) > -1 || scope.functions.indexOf(name2) > -1 || scope.var.indexOf(name2) > -1;
-    scope.lexical.push(name2);
+    redeclared = scope.lexical.indexOf(name) > -1 || scope.functions.indexOf(name) > -1 || scope.var.indexOf(name) > -1;
+    scope.lexical.push(name);
     if (this.inModule && scope.flags & SCOPE_TOP) {
-      delete this.undefinedExports[name2];
+      delete this.undefinedExports[name];
     }
   } else if (bindingType === BIND_SIMPLE_CATCH) {
     var scope$1 = this.currentScope();
-    scope$1.lexical.push(name2);
+    scope$1.lexical.push(name);
   } else if (bindingType === BIND_FUNCTION) {
     var scope$2 = this.currentScope();
     if (this.treatFunctionsAsVar) {
-      redeclared = scope$2.lexical.indexOf(name2) > -1;
+      redeclared = scope$2.lexical.indexOf(name) > -1;
     } else {
-      redeclared = scope$2.lexical.indexOf(name2) > -1 || scope$2.var.indexOf(name2) > -1;
+      redeclared = scope$2.lexical.indexOf(name) > -1 || scope$2.var.indexOf(name) > -1;
     }
-    scope$2.functions.push(name2);
+    scope$2.functions.push(name);
   } else {
     for (var i = this.scopeStack.length - 1; i >= 0; --i) {
       var scope$3 = this.scopeStack[i];
-      if (scope$3.lexical.indexOf(name2) > -1 && !(scope$3.flags & SCOPE_SIMPLE_CATCH && scope$3.lexical[0] === name2) || !this.treatFunctionsAsVarInScope(scope$3) && scope$3.functions.indexOf(name2) > -1) {
+      if (scope$3.lexical.indexOf(name) > -1 && !(scope$3.flags & SCOPE_SIMPLE_CATCH && scope$3.lexical[0] === name) || !this.treatFunctionsAsVarInScope(scope$3) && scope$3.functions.indexOf(name) > -1) {
         redeclared = true;
         break;
       }
-      scope$3.var.push(name2);
+      scope$3.var.push(name);
       if (this.inModule && scope$3.flags & SCOPE_TOP) {
-        delete this.undefinedExports[name2];
+        delete this.undefinedExports[name];
       }
       if (scope$3.flags & SCOPE_VAR) {
         break;
@@ -4316,7 +4347,7 @@ pp$3.declareName = function(name2, bindingType, pos) {
     }
   }
   if (redeclared) {
-    this.raiseRecoverable(pos, "Identifier '" + name2 + "' has already been declared");
+    this.raiseRecoverable(pos, "Identifier '" + name + "' has already been declared");
   }
 };
 pp$3.checkLocalExport = function(id) {
@@ -4636,8 +4667,8 @@ pp$1.regexp_pattern = function(state) {
     state.raise("Invalid escape");
   }
   for (var i = 0, list = state.backReferenceNames; i < list.length; i += 1) {
-    var name2 = list[i];
-    if (!state.groupNames[name2]) {
+    var name = list[i];
+    if (!state.groupNames[name]) {
       state.raise("Invalid named capture referenced");
     }
   }
@@ -5276,10 +5307,10 @@ pp$1.regexp_eatUnicodePropertyValueExpression = function(state) {
     61
     /* = */
   )) {
-    var name2 = state.lastStringValue;
+    var name = state.lastStringValue;
     if (this.regexp_eatUnicodePropertyValue(state)) {
       var value = state.lastStringValue;
-      this.regexp_validateUnicodePropertyNameAndValue(state, name2, value);
+      this.regexp_validateUnicodePropertyNameAndValue(state, name, value);
       return CharSetOk;
     }
   }
@@ -5290,11 +5321,11 @@ pp$1.regexp_eatUnicodePropertyValueExpression = function(state) {
   }
   return CharSetNone;
 };
-pp$1.regexp_validateUnicodePropertyNameAndValue = function(state, name2, value) {
-  if (!hasOwn(state.unicodeProperties.nonBinary, name2)) {
+pp$1.regexp_validateUnicodePropertyNameAndValue = function(state, name, value) {
+  if (!hasOwn(state.unicodeProperties.nonBinary, name)) {
     state.raise("Invalid property name");
   }
-  if (!state.unicodeProperties.nonBinary[name2].test(value)) {
+  if (!state.unicodeProperties.nonBinary[name].test(value)) {
     state.raise("Invalid property value");
   }
 };
@@ -6705,17 +6736,17 @@ codes.ERR_INVALID_ARG_TYPE = createError(
    * @param {Array<string> | string} expected
    * @param {unknown} actual
    */
-  (name2, expected, actual) => {
-    assert(typeof name2 === "string", "'name' must be a string");
+  (name, expected, actual) => {
+    assert(typeof name === "string", "'name' must be a string");
     if (!Array.isArray(expected)) {
       expected = [expected];
     }
     let message = "The ";
-    if (name2.endsWith(" argument")) {
-      message += `${name2} `;
+    if (name.endsWith(" argument")) {
+      message += `${name} `;
     } else {
-      const type = name2.includes(".") ? "property" : "argument";
-      message += `"${name2}" ${type} `;
+      const type = name.includes(".") ? "property" : "argument";
+      message += `"${name}" ${type} `;
     }
     message += "must be ";
     const types2 = [];
@@ -6885,13 +6916,13 @@ codes.ERR_INVALID_ARG_VALUE = createError(
    * @param {unknown} value
    * @param {string} [reason='is invalid']
    */
-  (name2, value, reason = "is invalid") => {
+  (name, value, reason = "is invalid") => {
     let inspected = inspect(value);
     if (inspected.length > 128) {
       inspected = `${inspected.slice(0, 128)}...`;
     }
-    const type = name2.includes(".") ? "property" : "argument";
-    return `The ${type} '${name2}' ${reason}. Received ${inspected}`;
+    const type = name.includes(".") ? "property" : "argument";
+    return `The ${type} '${name}' ${reason}. Received ${inspected}`;
   },
   TypeError
   // Note: extra classes have been shaken out.
@@ -7693,10 +7724,10 @@ function patternKeyCompare(a, b) {
   if (b.length > a.length) return 1;
   return 0;
 }
-function packageImportsResolve(name2, base, conditions) {
-  if (name2 === "#" || name2.startsWith("#/") || name2.endsWith("/")) {
+function packageImportsResolve(name, base, conditions) {
+  if (name === "#" || name.startsWith("#/") || name.endsWith("/")) {
     const reason = "is not a valid internal imports specifier name";
-    throw new ERR_INVALID_MODULE_SPECIFIER(name2, reason, fileURLToPath$1(base));
+    throw new ERR_INVALID_MODULE_SPECIFIER(name, reason, fileURLToPath$1(base));
   }
   let packageJsonUrl;
   const packageConfig = getPackageScopeConfig(base);
@@ -7704,12 +7735,12 @@ function packageImportsResolve(name2, base, conditions) {
     packageJsonUrl = pathToFileURL$1(packageConfig.pjsonPath);
     const imports = packageConfig.imports;
     if (imports) {
-      if (own.call(imports, name2) && !name2.includes("*")) {
+      if (own.call(imports, name) && !name.includes("*")) {
         const resolveResult = resolvePackageTarget(
           packageJsonUrl,
-          imports[name2],
+          imports[name],
           "",
-          name2,
+          name,
           base,
           false,
           true,
@@ -7727,13 +7758,13 @@ function packageImportsResolve(name2, base, conditions) {
         while (++i < keys.length) {
           const key = keys[i];
           const patternIndex = key.indexOf("*");
-          if (patternIndex !== -1 && name2.startsWith(key.slice(0, -1))) {
+          if (patternIndex !== -1 && name.startsWith(key.slice(0, -1))) {
             const patternTrailer = key.slice(patternIndex + 1);
-            if (name2.length >= key.length && name2.endsWith(patternTrailer) && patternKeyCompare(bestMatch, key) === 1 && key.lastIndexOf("*") === patternIndex) {
+            if (name.length >= key.length && name.endsWith(patternTrailer) && patternKeyCompare(bestMatch, key) === 1 && key.lastIndexOf("*") === patternIndex) {
               bestMatch = key;
-              bestMatchSubpath = name2.slice(
+              bestMatchSubpath = name.slice(
                 patternIndex,
-                name2.length - patternTrailer.length
+                name.length - patternTrailer.length
               );
             }
           }
@@ -7758,7 +7789,7 @@ function packageImportsResolve(name2, base, conditions) {
       }
     }
   }
-  throw importNotDefined(name2, packageJsonUrl, base);
+  throw importNotDefined(name, packageJsonUrl, base);
 }
 function parsePackageName(specifier, base) {
   let separatorIndex = specifier.indexOf("/");
@@ -8057,8 +8088,11 @@ globalThis.${globalName} = var_${globalName};
 globalThis.${globalName} = var_${globalName}.${exportName};
 `;
   }).join("\n");
+  const polyfillCode = env.polyfill.map((polyfillPath) => `import "${polyfillPath}";
+`).join("");
   const modified = new MagicString(code);
   modified.prepend(injectedCode);
+  modified.prepend(polyfillCode);
   return {
     code: modified.toString(),
     map: modified.generateMap({ hires: "boundary", source: id })
@@ -8092,20 +8126,20 @@ function getNodeCompatEntries() {
       entries.add(globalInject[0]);
     }
   }
+  env.polyfill.forEach((polyfill) => entries.add(polyfill));
   nodeCompatExternals.forEach((external) => entries.delete(external));
   return entries;
 }
 
-// src/constants.ts
-var ROUTER_WORKER_NAME = "__router-worker__";
-var ASSET_WORKER_NAME = "__asset-worker__";
-var ASSET_WORKERS_COMPATIBILITY_DATE = "2024-10-04";
-var MODULE_TYPES = ["CompiledWasm"];
-
 // src/shared.ts
 var UNKNOWN_HOST = "http://localhost";
 var INIT_PATH = "/__vite_plugin_cloudflare_init__";
-var MODULE_PATTERN = `__CLOUDFLARE_MODULE__(${MODULE_TYPES.join("|")})__(.*?)__`;
+var ADDITIONAL_MODULE_PATTERN = `__CLOUDFLARE_MODULE__(${ADDITIONAL_MODULE_TYPES.join("|")})__(.*?)__`;
+var additionalModuleRE = new RegExp(ADDITIONAL_MODULE_PATTERN);
+var additionalModuleGlobalRE = new RegExp(
+  ADDITIONAL_MODULE_PATTERN,
+  "g"
+);
 var VITE_DEV_METADATA_HEADER = "__VITE_DEV_METADATA__";
 
 // src/utils.ts
@@ -8116,6 +8150,9 @@ function getOutputDirectory(userConfig, environmentName) {
   const rootOutputDirectory = userConfig.build?.outDir ?? "dist";
   return userConfig.environments?.[environmentName]?.build?.outDir ?? path2.join(rootOutputDirectory, environmentName);
 }
+function getRouterWorker(miniflare) {
+  return miniflare.getWorker(ROUTER_WORKER_NAME);
+}
 function toMiniflareRequest(request) {
   return new MiniflareRequest(request.url, {
     method: request.method,
@@ -8137,6 +8174,10 @@ function nodeHeadersToWebHeaders(nodeHeaders) {
   }
   return headers;
 }
+var postfixRE = /[?#].*$/;
+function cleanUrl(url) {
+  return url.replace(postfixRE, "");
+}
 
 // src/cloudflare-environment.ts
 var webSocketUndefinedError = "The WebSocket is undefined";
@@ -8185,9 +8226,9 @@ function createHotChannel(webSocketContainer) {
 var CloudflareDevEnvironment = class extends vite2.DevEnvironment {
   #webSocketContainer;
   #worker;
-  constructor(name2, config) {
+  constructor(name, config) {
     const webSocketContainer = {};
-    super(name2, config, {
+    super(name, config, {
       hot: true,
       transport: createHotChannel(webSocketContainer)
     });
@@ -8237,13 +8278,13 @@ function createCloudflareEnvironmentOptions(workerConfig, userConfig, environmen
       builtins: [...cloudflareBuiltInModules]
     },
     dev: {
-      createEnvironment(name2, config) {
-        return new CloudflareDevEnvironment(name2, config);
+      createEnvironment(name, config) {
+        return new CloudflareDevEnvironment(name, config);
       }
     },
     build: {
-      createEnvironment(name2, config) {
-        return new vite2.BuildEnvironment(name2, config);
+      createEnvironment(name, config) {
+        return new vite2.BuildEnvironment(name, config);
       },
       target,
       // We need to enable `emitAssets` in order to support additional modules defined by `rules`
@@ -8377,16 +8418,8 @@ function writeDeployConfig(resolvedPluginConfig, resolvedViteConfig) {
   }
 }
 
-// src/dev.ts
-import assert5 from "node:assert";
-function getDevEntryWorker(resolvedPluginConfig, miniflare) {
-  const entryWorkerConfig = resolvedPluginConfig.type === "assets-only" ? resolvedPluginConfig.config : resolvedPluginConfig.workers[resolvedPluginConfig.entryWorkerEnvironmentName];
-  assert5(entryWorkerConfig, "Unexpected error: No entry worker configuration");
-  return entryWorkerConfig.assets ? miniflare.getWorker(ROUTER_WORKER_NAME) : miniflare.getWorker(entryWorkerConfig.name);
-}
-
 // src/miniflare-options.ts
-import assert6 from "node:assert";
+import assert5 from "node:assert";
 import * as fs3 from "node:fs";
 import * as fsp from "node:fs/promises";
 import * as path4 from "node:path";
@@ -8434,7 +8467,7 @@ function getWorkerToWorkerEntrypointNamesMap(workers) {
       if (typeof value === "object" && "name" in value && value.entrypoint !== void 0 && value.entrypoint !== "default") {
         const targetWorkerName = value.name === kCurrentWorker ? worker.name : value.name;
         const entrypointNames = workerToWorkerEntrypointNamesMap.get(targetWorkerName);
-        assert6(entrypointNames, missingWorkerErrorMessage(targetWorkerName));
+        assert5(entrypointNames, missingWorkerErrorMessage(targetWorkerName));
         entrypointNames.add(value.entrypoint);
       }
     }
@@ -8449,20 +8482,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));
+        assert5(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));
+          assert5(classNames, missingWorkerErrorMessage(value.scriptName));
           classNames.add(value.className);
         } else {
           const classNames = workerToDurableObjectClassNamesMap.get(
             worker.name
           );
-          assert6(classNames, missingWorkerErrorMessage(worker.name));
+          assert5(classNames, missingWorkerErrorMessage(worker.name));
           classNames.add(value.className);
         }
       }
@@ -8480,13 +8513,13 @@ function getWorkerToWorkflowEntrypointClassNamesMap(workers) {
         const classNames = workerToWorkflowEntrypointClassNamesMap.get(
           value.scriptName
         );
-        assert6(classNames, missingWorkerErrorMessage(value.scriptName));
+        assert5(classNames, missingWorkerErrorMessage(value.scriptName));
         classNames.add(value.className);
       } else {
         const classNames = workerToWorkflowEntrypointClassNamesMap.get(
           worker.name
         );
-        assert6(classNames, missingWorkerErrorMessage(worker.name));
+        assert5(classNames, missingWorkerErrorMessage(worker.name));
         classNames.add(value.className);
       }
     }
@@ -8605,17 +8638,12 @@ function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
             __VITE_INVOKE_MODULE__: async (request) => {
               const payload = await request.json();
               const invokePayloadData = payload.data;
-              assert6(
+              assert5(
                 invokePayloadData.name === "fetchModule",
                 `Invalid invoke event: ${invokePayloadData.name}`
               );
               const [moduleId] = invokePayloadData.data;
-              const moduleRE = new RegExp(MODULE_PATTERN);
-              const shouldExternalize = (
-                // Worker modules (CompiledWasm, Text, Data)
-                moduleRE.test(moduleId)
-              );
-              if (shouldExternalize) {
+              if (additionalModuleRE.test(moduleId)) {
                 const result2 = {
                   externalize: moduleId,
                   type: "module"
@@ -8663,7 +8691,7 @@ function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
         const workerEntrypointNames = workerToWorkerEntrypointNamesMap.get(
           workerOptions.name
         );
-        assert6(
+        assert5(
           workerEntrypointNames,
           `WorkerEntrypoint names not found for worker ${workerOptions.name}`
         );
@@ -8675,7 +8703,7 @@ function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
         const durableObjectClassNames = workerToDurableObjectClassNamesMap.get(
           workerOptions.name
         );
-        assert6(
+        assert5(
           durableObjectClassNames,
           `DurableObject class names not found for worker ${workerOptions.name}`
         );
@@ -8685,7 +8713,7 @@ function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
           );
         }
         const workflowEntrypointClassNames = workerToWorkflowEntrypointClassNamesMap.get(workerOptions.name);
-        assert6(
+        assert5(
           workflowEntrypointClassNames,
           `WorkflowEntrypoint class names not found for worker: ${workerOptions.name}`
         );
@@ -8714,38 +8742,51 @@ function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
         };
       })
     ],
-    unsafeModuleFallbackService(request) {
+    async unsafeModuleFallbackService(request) {
       const url = new URL(request.url);
       const rawSpecifier = url.searchParams.get("rawSpecifier");
-      assert6(
+      assert5(
         rawSpecifier,
         `Unexpected error: no specifier in request to module fallback service.`
       );
-      const moduleRE = new RegExp(MODULE_PATTERN);
-      const match = moduleRE.exec(rawSpecifier);
-      assert6(match, `Unexpected error: no match for module: ${rawSpecifier}.`);
+      const match = additionalModuleRE.exec(rawSpecifier);
+      assert5(match, `Unexpected error: no match for module: ${rawSpecifier}.`);
       const [full, moduleType, modulePath] = match;
-      assert6(
+      assert5(
+        moduleType,
+        `Unexpected error: module type not found in reference: ${full}.`
+      );
+      assert5(
         modulePath,
         `Unexpected error: module path not found in reference: ${full}.`
       );
-      let source;
+      let contents;
       try {
-        source = fs3.readFileSync(modulePath);
+        contents = await fsp.readFile(modulePath);
       } catch (error) {
         throw new Error(
           `Import "${modulePath}" not found. Does the file exist?`
         );
       }
-      return MiniflareResponse.json({
-        // Cap'n Proto expects byte arrays for `:Data` typed fields from JSON
-        wasm: Array.from(source)
-      });
+      switch (moduleType) {
+        case "CompiledWasm": {
+          return MiniflareResponse.json({ wasm: Array.from(contents) });
+        }
+        case "Data": {
+          return MiniflareResponse.json({ data: Array.from(contents) });
+        }
+        case "Text": {
+          return MiniflareResponse.json({ text: contents.toString() });
+        }
+        default: {
+          return MiniflareResponse.error();
+        }
+      }
     }
   };
 }
 function getPreviewModules(main, modulesRules) {
-  assert6(modulesRules, `Unexpected error: 'modulesRules' is undefined`);
+  assert5(modulesRules, `Unexpected error: 'modulesRules' is undefined`);
   const rootPath = path4.dirname(main);
   const entryPath = path4.basename(main);
   return {
@@ -8831,20 +8872,14 @@ function miniflareLogLevelFromViteLogLevel(level = "info") {
 }
 
 // src/plugin-config.ts
-import assert8 from "node:assert";
+import assert6 from "node:assert";
 import * as path6 from "node:path";
 import * as vite5 from "vite";
 
 // src/workers-configs.ts
-import assert7 from "node:assert";
 import * as fs4 from "node:fs";
 import * as path5 from "node:path";
 import { unstable_readConfig as unstable_readConfig2 } from "wrangler";
-
-// package.json
-var name = "@cloudflare/vite-plugin";
-
-// src/workers-configs.ts
 var nonApplicableWorkerConfigs = {
   /**
    * Object containing configs that have a vite replacement, the object's field contain details about the config's replacement
@@ -8873,14 +8908,11 @@ var nonApplicableWorkerConfigs = {
     "find_additional_modules",
     "no_bundle",
     "preserve_file_names",
+    "rules",
     "site",
     "tsconfig",
     "upload_source_maps"
-  ],
-  /**
-   * All the configs that get overridden by our plugin
-   */
-  overridden: ["rules"]
+  ]
 };
 var nullableNonApplicable = [
   "alias",
@@ -8896,8 +8928,7 @@ var nullableNonApplicable = [
 function readWorkerConfig(configPath, env2) {
   const nonApplicable = {
     replacedByVite: /* @__PURE__ */ new Set(),
-    notRelevant: /* @__PURE__ */ new Set(),
-    overridden: /* @__PURE__ */ new Set()
+    notRelevant: /* @__PURE__ */ new Set()
   };
   const config = unstable_readConfig2({ config: configPath, env: env2 }, {});
   const raw = structuredClone(config);
@@ -8909,9 +8940,6 @@ function readWorkerConfig(configPath, env2) {
       if (isNotRelevant(prop)) {
         nonApplicable.notRelevant.add(prop);
       }
-      if (isOverridden(prop)) {
-        nonApplicable.overridden.add(prop);
-      }
     }
     delete config[prop];
   });
@@ -8924,7 +8952,7 @@ function readWorkerConfig(configPath, env2) {
   }
   delete config["define"];
   if (config.rules.length > 0) {
-    nonApplicable.overridden.add("rules");
+    nonApplicable.notRelevant.add("rules");
   }
   return {
     raw,
@@ -8976,7 +9004,7 @@ function getWarningForWorkersConfigs(configs) {
 }
 function getWorkerNonApplicableWarnLines(workerConfig, linePrefix) {
   const lines = [];
-  const { replacedByVite, notRelevant, overridden } = workerConfig.nonApplicable;
+  const { replacedByVite, notRelevant } = workerConfig.nonApplicable;
   for (const config of replacedByVite) {
     lines.push(
       `${linePrefix}\`${config}\` which is replaced by Vite's \`${nonApplicableWorkerConfigs.replacedByVite[config].viteReplacement}\` (docs: ${nonApplicableWorkerConfigs.replacedByVite[config].viteDocs})`
@@ -8986,10 +9014,6 @@ function getWorkerNonApplicableWarnLines(workerConfig, linePrefix) {
     lines.push(
       `${linePrefix}${[...notRelevant].map((config) => `\`${config}\``).join(", ")} which ${notRelevant.size > 1 ? "are" : "is"} not relevant in the context of a Vite project`
     );
-  if (overridden.size > 0)
-    lines.push(
-      `${linePrefix}${[...overridden].map((config) => `\`${config}\``).join(", ")} which ${overridden.size > 1 ? "are" : "is"} overridden by \`${name}\``
-    );
   return lines;
 }
 function isReplacedByVite(configName) {
@@ -8998,9 +9022,6 @@ function isReplacedByVite(configName) {
 function isNotRelevant(configName) {
   return nonApplicableWorkerConfigs.notRelevant.includes(configName);
 }
-function isOverridden(configName) {
-  return nonApplicableWorkerConfigs.overridden.includes(configName);
-}
 function missingFieldErrorMessage(field, configPath, env2) {
   return `No ${field} field provided in '${configPath}'${env2 ? ` for '${env2}' environment` : ""}`;
 }
@@ -9010,34 +9031,38 @@ function getWorkerConfig(configPath, env2, opts) {
   }
   const { raw, config, nonApplicable } = readWorkerConfig(configPath, env2);
   opts?.visitedConfigPaths?.add(configPath);
-  assert7(
-    config.topLevelName,
-    missingFieldErrorMessage(`top-level 'name'`, configPath, env2)
-  );
-  assert7(config.name, missingFieldErrorMessage(`'name'`, configPath, env2));
-  assert7(
-    config.compatibility_date,
-    missingFieldErrorMessage(`'compatibility_date'`, configPath, env2)
-  );
-  if (opts?.isEntryWorker && !config.main) {
-    assert7(
-      config.assets,
-      missingFieldErrorMessage(`'main' or 'assets'`, configPath, env2)
+  if (!config.name) {
+    throw new Error(missingFieldErrorMessage(`'name'`, configPath, env2));
+  }
+  if (!config.topLevelName) {
+    throw new Error(
+      missingFieldErrorMessage(`top-level 'name'`, configPath, env2)
+    );
+  }
+  if (!config.compatibility_date) {
+    throw new Error(
+      missingFieldErrorMessage(`'compatibility_date`, configPath, env2)
     );
+  }
+  const requiredFields = {
+    topLevelName: config.topLevelName,
+    name: config.name,
+    compatibility_date: config.compatibility_date
+  };
+  if (opts?.isEntryWorker && !config.main) {
     return {
       type: "assets-only",
       raw,
       config: {
         ...config,
-        topLevelName: config.topLevelName,
-        name: config.name,
-        compatibility_date: config.compatibility_date,
-        assets: config.assets
+        ...requiredFields
       },
       nonApplicable
     };
   }
-  assert7(config.main, missingFieldErrorMessage(`'main'`, configPath, env2));
+  if (!config.main) {
+    throw new Error(missingFieldErrorMessage(`'main'`, configPath, env2));
+  }
   const mainStat = fs4.statSync(config.main, { throwIfNoEntry: false });
   if (!mainStat) {
     throw new Error(
@@ -9054,9 +9079,7 @@ function getWorkerConfig(configPath, env2, opts) {
     raw,
     config: {
       ...config,
-      topLevelName: config.topLevelName,
-      name: config.name,
-      compatibility_date: config.compatibility_date,
+      ...requiredFields,
       main: config.main
     },
     nonApplicable
@@ -9086,10 +9109,11 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
     ""
   );
   const configPath = pluginConfig.configPath ? path6.resolve(root, pluginConfig.configPath) : findWranglerConfig(root);
-  assert8(
-    configPath,
-    `Config not found. Have you created a wrangler.json(c) or wrangler.toml file?`
-  );
+  if (!configPath) {
+    throw new Error(
+      `Config not found. Have you created a wrangler.json(c) or wrangler.toml file?`
+    );
+  }
   const entryWorkerResolvedConfig = getWorkerConfig(configPath, cloudflareEnv, {
     visitedConfigPaths: configPaths,
     isEntryWorker: true
@@ -9121,7 +9145,7 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
       }
     );
     auxiliaryWorkersResolvedConfigs.push(workerResolvedConfig);
-    assert8(
+    assert6(
       workerResolvedConfig.type === "worker",
       "Unexpected error: received AssetsOnlyResult with auxiliary workers."
     );
@@ -9184,14 +9208,18 @@ function handleWebSocket(httpServer, fetcher) {
 }
 
 // src/index.ts
+var workersConfigsWarningShown = false;
 function cloudflare2(pluginConfig = {}) {
   let resolvedPluginConfig;
   let resolvedViteConfig;
   let miniflare;
-  let workersConfigsWarningShown = false;
+  const additionalModulePaths = /* @__PURE__ */ new Set();
+  let hasClientBuild = false;
   return [
     {
       name: "vite-plugin-cloudflare",
+      // This only applies to this plugin so is safe to use while other plugins migrate to the Environment API
+      sharedDuringBuild: true,
       config(userConfig, env2) {
         if (env2.isPreview) {
           return { appType: "custom" };
@@ -9248,7 +9276,7 @@ function cloudflare2(pluginConfig = {}) {
                   resolvedPluginConfig.workers
                 ).map((environmentName) => {
                   const environment = builder.environments[environmentName];
-                  assert9(
+                  assert7(
                     environment,
                     `${environmentName} environment not found`
                   );
@@ -9264,6 +9292,9 @@ function cloudflare2(pluginConfig = {}) {
           }
         };
       },
+      buildStart() {
+        workersConfigsWarningShown = false;
+      },
       configResolved(config) {
         resolvedViteConfig = config;
       },
@@ -9278,18 +9309,27 @@ function cloudflare2(pluginConfig = {}) {
             return;
           }
           workerConfig.main = entryChunk[0];
+          workerConfig.no_bundle = true;
+          workerConfig.rules = [
+            { type: "ESModule", globs: ["**/*.js", "**/*.mjs"] }
+          ];
           const isEntryWorker = this.environment.name === resolvedPluginConfig.entryWorkerEnvironmentName;
-          if (isEntryWorker && workerConfig.assets) {
+          if (isEntryWorker && hasClientBuild) {
             const workerOutputDirectory = this.environment.config.build.outDir;
             const clientOutputDirectory = resolvedViteConfig.environments.client?.build.outDir;
-            assert9(
+            assert7(
               clientOutputDirectory,
               "Unexpected error: client output directory is undefined"
             );
-            workerConfig.assets.directory = path7.relative(
-              path7.resolve(resolvedViteConfig.root, workerOutputDirectory),
-              path7.resolve(resolvedViteConfig.root, clientOutputDirectory)
-            );
+            workerConfig.assets = {
+              ...workerConfig.assets,
+              directory: path7.relative(
+                path7.resolve(resolvedViteConfig.root, workerOutputDirectory),
+                path7.resolve(resolvedViteConfig.root, clientOutputDirectory)
+              )
+            };
+          } else {
+            workerConfig.assets = void 0;
           }
           config = workerConfig;
           if (workerConfig.configPath) {
@@ -9307,7 +9347,10 @@ function cloudflare2(pluginConfig = {}) {
           }
         } else if (this.environment.name === "client") {
           const assetsOnlyConfig = resolvedPluginConfig.config;
-          assetsOnlyConfig.assets.directory = ".";
+          assetsOnlyConfig.assets = {
+            ...assetsOnlyConfig.assets,
+            directory: "."
+          };
           const filesToAssetsIgnore = ["wrangler.json", ".dev.vars"];
           this.emitFile({
             type: "asset",
@@ -9320,8 +9363,6 @@ function cloudflare2(pluginConfig = {}) {
         if (!config) {
           return;
         }
-        config.no_bundle = true;
-        config.rules = [{ type: "ESModule", globs: ["**/*.js", "**/*.mjs"] }];
         if (config.unsafe && Object.keys(config.unsafe).length === 0) {
           config.unsafe = void 0;
         }
@@ -9332,6 +9373,9 @@ 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);
         }
@@ -9348,7 +9392,7 @@ function cloudflare2(pluginConfig = {}) {
         }
       },
       async configureServer(viteDevServer) {
-        assert9(
+        assert7(
           viteDevServer.httpServer,
           "Unexpected error: No Vite HTTP server"
         );
@@ -9356,19 +9400,16 @@ function cloudflare2(pluginConfig = {}) {
           getDevMiniflareOptions(resolvedPluginConfig, viteDevServer)
         );
         await initRunners(resolvedPluginConfig, viteDevServer, miniflare);
-        const entryWorker = await getDevEntryWorker(
-          resolvedPluginConfig,
-          miniflare
-        );
+        const routerWorker = await getRouterWorker(miniflare);
         const middleware = createMiddleware(
           ({ request }) => {
-            return entryWorker.fetch(toMiniflareRequest(request), {
+            return routerWorker.fetch(toMiniflareRequest(request), {
               redirect: "manual"
             });
           },
           { alwaysCallNext: false }
         );
-        handleWebSocket(viteDevServer.httpServer, entryWorker.fetch);
+        handleWebSocket(viteDevServer.httpServer, routerWorker.fetch);
         return () => {
           viteDevServer.middlewares.use((req, res, next) => {
             middleware(req, res, next);
@@ -9396,46 +9437,55 @@ function cloudflare2(pluginConfig = {}) {
         });
       }
     },
-    // Plugin to support `CompiledWasm` modules
+    // Plugin to support additional modules
     {
-      name: "vite-plugin-cloudflare:modules",
+      name: "vite-plugin-cloudflare:additional-modules",
       // We set `enforce: "pre"` so that this plugin runs before the Vite core plugins.
       // Otherwise the `vite:wasm-fallback` plugin prevents the `.wasm` extension being used for module imports.
       enforce: "pre",
       applyToEnvironment(environment) {
         return getWorkerConfig2(environment.name) !== void 0;
       },
-      async resolveId(source, importer) {
-        if (!source.endsWith(".wasm")) {
+      async resolveId(source, importer, options) {
+        const additionalModuleType = matchAdditionalModule(source);
+        if (!additionalModuleType) {
           return;
         }
-        const resolved = await this.resolve(source, importer);
-        assert9(
-          resolved,
-          `Unexpected error: could not resolve Wasm module ${source}`
+        const resolved = await this.resolve(
+          cleanUrl(source),
+          importer,
+          options
         );
+        if (!resolved) {
+          throw new Error(`Import "${source}" not found. Does the file exist?`);
+        }
+        additionalModulePaths.add(resolved.id);
         return {
           external: true,
-          id: createModuleReference("CompiledWasm", resolved.id)
+          id: createModuleReference(additionalModuleType, resolved.id)
         };
       },
-      renderChunk(code, chunk) {
-        const moduleRE = new RegExp(MODULE_PATTERN, "g");
-        let match;
+      hotUpdate(options) {
+        if (additionalModulePaths.has(options.file)) {
+          options.server.restart();
+        }
+      },
+      async renderChunk(code, chunk) {
+        const matches = code.matchAll(additionalModuleGlobalRE);
         let magicString;
-        while (match = moduleRE.exec(code)) {
+        for (const match of matches) {
           magicString ??= new MagicString(code);
-          const [full, moduleType, modulePath] = match;
-          assert9(
+          const [full, _, modulePath] = match;
+          assert7(
             modulePath,
             `Unexpected error: module path not found in reference ${full}.`
           );
           let source;
           try {
-            source = fs5.readFileSync(modulePath);
+            source = await fsp2.readFile(modulePath);
           } catch (error) {
             throw new Error(
-              `Import ${modulePath} not found. Does the file exist?`
+              `Import "${modulePath}" not found. Does the file exist?`
             );
           }
           const referenceId = this.emitFile({
@@ -9469,8 +9519,8 @@ function cloudflare2(pluginConfig = {}) {
       apply(_config, env2) {
         return !env2.isPreview;
       },
-      configEnvironment(name2) {
-        if (isNodeCompat(getWorkerConfig2(name2))) {
+      configEnvironment(name) {
+        if (isNodeCompat(getWorkerConfig2(name))) {
           return {
             resolve: {
               builtins: [...nodeCompatExternals]
@@ -9509,7 +9559,7 @@ function cloudflare2(pluginConfig = {}) {
           return this.resolve(source, importer, options);
         }
         if (this.environment.mode === "dev") {
-          assert9(
+          assert7(
             this.environment.depsOptimizer,
             "depsOptimizer is required in dev mode"
           );
@@ -9523,7 +9573,7 @@ function cloudflare2(pluginConfig = {}) {
       },
       async transform(code, id) {
         const workerConfig = getWorkerConfig2(this.environment.name);
-        assert9(workerConfig, "Expected a worker config");
+        assert7(workerConfig, "Expected a worker config");
         const resolvedId = await this.resolve(workerConfig.main);
         if (id === resolvedId?.id) {
           return injectGlobalCode(id, code);
@@ -9532,7 +9582,7 @@ function cloudflare2(pluginConfig = {}) {
     }
   ];
   function getWorkerConfig2(environmentName) {
-    assert9(resolvedPluginConfig, "Expected resolvedPluginConfig to be defined");
+    assert7(resolvedPluginConfig, "Expected resolvedPluginConfig to be defined");
     return resolvedPluginConfig.type !== "assets-only" ? resolvedPluginConfig.workers[environmentName] : void 0;
   }
 }
@@ -9547,9 +9597,6 @@ function getDotDevDotVarsContent(configPath, cloudflareEnv) {
   }
   return null;
 }
-function createModuleReference(type, id) {
-  return `__CLOUDFLARE_MODULE__${type}__${id}__`;
-}
 export {
   cloudflare2 as cloudflare
 };