@cloudflare/vite-plugin 0.0.0-6c2e94318 → 0.0.0-6fe4a67d0

package/dist/index.js

@@ -1,18 +1,8 @@
 // src/index.ts
-import assert7 from "node:assert";
+import assert8 from "node:assert";
 import * as fs4 from "node:fs";
 import * as path6 from "node:path";
 import { createMiddleware } from "@hattip/adapter-node";
-import { Miniflare } from "miniflare";
-import "vite";
-
-// src/cloudflare-environment.ts
-import assert from "node:assert";
-import { builtinModules } from "node:module";
-import * as vite2 from "vite";
-
-// src/node-js-compat.ts
-import { createRequire } from "node:module";
 
 // ../../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.0/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
 var comma = ",".charCodeAt(0);
@@ -1078,100 +1068,25 @@ var MagicString = class _MagicString {
   }
 };
 
-// src/node-js-compat.ts
-import { getNodeCompat } from "miniflare";
-import * as unenv from "unenv";
-var require2 = createRequire(import.meta.url);
-var preset = unenv.env(unenv.nodeless, unenv.cloudflare);
-var CLOUDFLARE_VIRTUAL_PREFIX = "\0cloudflare-";
-function isNodeCompat({
-  compatibility_date,
-  compatibility_flags
-}) {
-  const nodeCompatMode = getNodeCompat(
-    compatibility_date,
-    compatibility_flags ?? []
-  ).mode;
-  if (nodeCompatMode === "v2") {
-    return true;
-  }
-  if (nodeCompatMode === "legacy") {
-    throw new Error(
-      "Unsupported Node.js compat mode (legacy). Remove the `node_compat` setting and add the `nodejs_compat` flag instead."
-    );
-  }
-  if (nodeCompatMode === "v1") {
-    throw new Error(
-      `Unsupported Node.js compat mode (v1). Only the v2 mode is supported, either change your compat date to "2024-09-23" or later, or set the "nodejs_compat_v2" compatibility flag`
-    );
-  }
-  return false;
-}
-function injectGlobalCode(id, code, workerConfig) {
-  if (!isNodeCompat(workerConfig)) {
-    return;
-  }
-  const injectedCode = Object.entries(preset.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;
-    return `import var_${globalName} from "${moduleSpecifier}";
-globalThis.${globalName} = var_${globalName}.${exportName};
-`;
-  }).join("\n");
-  const modified = new MagicString(code);
-  modified.prepend(injectedCode);
-  return {
-    code: modified.toString(),
-    map: modified.generateMap({ hires: "boundary", source: id })
-  };
-}
-function getNodeCompatAliases() {
-  const aliases = {};
-  Object.keys(preset.alias).forEach((key) => {
-    if (!preset.external.includes(key)) {
-      aliases[key] = CLOUDFLARE_VIRTUAL_PREFIX + key;
-    }
-  });
-  return aliases;
-}
-function resolveNodeCompatId(environment, workerConfig, id) {
-  const aliased = resolveNodeAliases(id, workerConfig) ?? id;
-  if (aliased.startsWith("unenv/")) {
-    const resolvedDep = require2.resolve(aliased).replace(/\.cjs$/, ".mjs");
-    if (environment.mode === "dev" && environment.depsOptimizer) {
-      const dep = environment.depsOptimizer.registerMissingImport(
-        aliased,
-        resolvedDep
-      );
-      return dep.id;
-    } else {
-      return resolvedDep;
-    }
-  }
-}
-function getNodeCompatExternals() {
-  return preset.external;
-}
-function resolveNodeAliases(source, workerConfig) {
-  if (!source.startsWith(CLOUDFLARE_VIRTUAL_PREFIX) || !isNodeCompat(workerConfig)) {
-    return;
-  }
-  const from = source.slice(CLOUDFLARE_VIRTUAL_PREFIX.length);
-  const alias = preset.alias[from];
-  if (alias && preset.external.includes(alias)) {
-    throw new Error(`Alias to external: ${source} -> ${alias}`);
-  }
-  return alias;
-}
+// src/index.ts
+import { Miniflare } from "miniflare";
+import * as vite6 from "vite";
+
+// src/cloudflare-environment.ts
+import assert from "node:assert";
+import { builtinModules } from "node:module";
+import * as vite2 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 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("|")})__(.*?)__`;
 
 // src/utils.ts
 import * as path from "node:path";
@@ -1268,7 +1183,10 @@ var CloudflareDevEnvironment = class extends vite2.DevEnvironment {
         }
       }
     );
-    assert(response.ok, "Failed to initialize module runner");
+    assert(
+      response.ok,
+      `Failed to initialize module runner, error: ${await response.text()}`
+    );
     const webSocket = response.webSocket;
     assert(webSocket, "Failed to establish WebSocket");
     webSocket.accept();
@@ -1281,6 +1199,7 @@ var cloudflareBuiltInModules = [
   "cloudflare:workers",
   "cloudflare:workflows"
 ];
+var defaultConditions = ["workerd", "module", "browser"];
 function createCloudflareEnvironmentOptions(workerConfig, userConfig, environmentName) {
   return {
     resolve: {
@@ -1288,7 +1207,7 @@ function createCloudflareEnvironmentOptions(workerConfig, userConfig, environmen
       //       dependencies as not external
       noExternal: true,
       // We want to use `workerd` package exports if available (e.g. for postgres).
-      conditions: ["workerd", "module", "browser", "development|production"]
+      conditions: [...defaultConditions, "development|production"]
     },
     dev: {
       createEnvironment(name2, config) {
@@ -1299,7 +1218,11 @@ function createCloudflareEnvironmentOptions(workerConfig, userConfig, environmen
       createEnvironment(name2, config) {
         return new vite2.BuildEnvironment(name2, config);
       },
+      target: "es2022",
+      // We need to enable `emitAssets` in order to support additional modules defined by `rules`
+      emitAssets: true,
       outDir: getOutputDirectory(userConfig, environmentName),
+      copyPublicDir: false,
       ssr: true,
       rollupOptions: {
         // Note: vite starts dev pre-bundling crawling from either optimizeDeps.entries or rollupOptions.input
@@ -1307,12 +1230,13 @@ function createCloudflareEnvironmentOptions(workerConfig, userConfig, environmen
         //       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,
-        external: [...cloudflareBuiltInModules, ...getNodeCompatExternals()]
+        external: [...cloudflareBuiltInModules]
       }
     },
     optimizeDeps: {
       // Note: ssr pre-bundling is opt-in and we need to enable it by setting `noDiscovery` to false
       noDiscovery: false,
+      entries: workerConfig.main,
       exclude: [
         ...cloudflareBuiltInModules,
         // we have to exclude all node modules to work in dev-mode not just the unenv externals...
@@ -1320,6 +1244,7 @@ function createCloudflareEnvironmentOptions(workerConfig, userConfig, environmen
       ],
       esbuildOptions: {
         platform: "neutral",
+        conditions: [...defaultConditions, "development"],
         resolveExtensions: [
           ".mjs",
           ".js",
@@ -1397,46 +1322,39 @@ function writeDeployConfig(resolvedPluginConfig, resolvedViteConfig) {
     };
     fs.writeFileSync(deployConfigPath, JSON.stringify(deployConfig));
   } else {
-    const workerConfigPaths = Object.fromEntries(
-      Object.keys(resolvedPluginConfig.workers).map((environmentName) => {
-        const outputDirectory = resolvedViteConfig.environments[environmentName]?.build.outDir;
-        assert2(
-          outputDirectory,
-          `Unexpected error: ${environmentName} environment output directory is undefined`
-        );
-        return [
-          environmentName,
-          getRelativePathToWorkerConfig(
-            deployConfigDirectory,
-            resolvedViteConfig.root,
-            outputDirectory
-          )
-        ];
-      })
-    );
-    const { entryWorkerEnvironmentName } = resolvedPluginConfig;
-    const configPath = workerConfigPaths[entryWorkerEnvironmentName];
+    let entryWorkerConfigPath;
+    const auxiliaryWorkers = [];
+    for (const environmentName of Object.keys(resolvedPluginConfig.workers)) {
+      const outputDirectory = resolvedViteConfig.environments[environmentName]?.build.outDir;
+      assert2(
+        outputDirectory,
+        `Unexpected error: ${environmentName} environment output directory is undefined`
+      );
+      const configPath = getRelativePathToWorkerConfig(
+        deployConfigDirectory,
+        resolvedViteConfig.root,
+        outputDirectory
+      );
+      if (environmentName === resolvedPluginConfig.entryWorkerEnvironmentName) {
+        entryWorkerConfigPath = configPath;
+      } else {
+        auxiliaryWorkers.push({ configPath });
+      }
+    }
     assert2(
-      configPath,
-      `Unexpected error: ${entryWorkerEnvironmentName} environment output directory is undefined`
+      entryWorkerConfigPath,
+      `Unexpected error: entryWorkerConfigPath is undefined`
     );
-    const auxiliaryWorkers = Object.entries(workerConfigPaths).filter(
-      ([environmentName]) => environmentName !== entryWorkerEnvironmentName
-    ).map(([_, configPath2]) => ({ configPath: configPath2 }));
-    const deployConfig = { configPath, auxiliaryWorkers };
+    const deployConfig = {
+      configPath: entryWorkerConfigPath,
+      auxiliaryWorkers
+    };
     fs.writeFileSync(deployConfigPath, JSON.stringify(deployConfig));
   }
 }
 
 // src/dev.ts
 import assert3 from "node:assert";
-
-// src/constants.ts
-var ROUTER_WORKER_NAME = "__router-worker__";
-var ASSET_WORKER_NAME = "__asset-worker__";
-var ASSET_WORKERS_COMPATIBILITY_DATE = "2024-10-04";
-
-// src/dev.ts
 function getDevEntryWorker(resolvedPluginConfig, miniflare) {
   const entryWorkerConfig = resolvedPluginConfig.type === "assets-only" ? resolvedPluginConfig.config : resolvedPluginConfig.workers[resolvedPluginConfig.entryWorkerEnvironmentName];
   assert3(entryWorkerConfig, "Unexpected error: No entry worker configuration");
@@ -1634,10 +1552,13 @@ function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
   ];
   const userWorkers = resolvedPluginConfig.type === "workers" ? Object.entries(resolvedPluginConfig.workers).map(
     ([environmentName, workerConfig]) => {
-      const miniflareWorkerOptions = unstable_getMiniflareWorkerOptions({
-        ...workerConfig,
-        assets: void 0
-      });
+      const miniflareWorkerOptions = unstable_getMiniflareWorkerOptions(
+        {
+          ...workerConfig,
+          assets: void 0
+        },
+        resolvedPluginConfig.cloudflareEnv
+      );
       const { ratelimits, ...workerOptions } = miniflareWorkerOptions.workerOptions;
       return {
         ...workerOptions,
@@ -1663,16 +1584,24 @@ function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
               `Invalid invoke event: ${invokePayloadData.name}`
             );
             const [moduleId] = invokePayloadData.data;
+            const moduleRE = new RegExp(MODULE_PATTERN);
+            if (moduleRE.test(moduleId)) {
+              const result2 = {
+                externalize: moduleId,
+                type: "module"
+              };
+              return MiniflareResponse.json({ result: result2 });
+            }
             if (moduleId.startsWith("cloudflare:")) {
               const result2 = {
                 externalize: moduleId,
                 type: "builtin"
               };
-              return new MiniflareResponse(JSON.stringify({ result: result2 }));
+              return MiniflareResponse.json({ result: result2 });
             }
             const devEnvironment = viteDevServer.environments[environmentName];
             const result = await devEnvironment.hot.handleInvoke(payload);
-            return new MiniflareResponse(JSON.stringify(result));
+            return MiniflareResponse.json(result);
           }
         }
       };
@@ -1751,10 +1680,37 @@ function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
                 fileURLToPath(new URL(RUNNER_PATH, import.meta.url))
               )
             }
-          ]
+          ],
+          unsafeUseModuleFallbackService: true
         };
       })
-    ]
+    ],
+    unsafeModuleFallbackService(request) {
+      const url = new URL(request.url);
+      const rawSpecifier = url.searchParams.get("rawSpecifier");
+      assert4(
+        rawSpecifier,
+        `Unexpected error: no specifier in request to module fallback service.`
+      );
+      const moduleRE = new RegExp(MODULE_PATTERN);
+      const match = moduleRE.exec(rawSpecifier);
+      assert4(match, `Unexpected error: no match for module ${rawSpecifier}.`);
+      const [full, moduleType, modulePath] = match;
+      assert4(
+        modulePath,
+        `Unexpected error: module path not found in reference ${full}.`
+      );
+      let source;
+      try {
+        source = fs2.readFileSync(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)
+      });
+    }
   };
 }
 function getPreviewMiniflareOptions(vitePreviewServer, persistState) {
@@ -1821,13 +1777,94 @@ function miniflareLogLevelFromViteLogLevel(level = "info") {
   }
 }
 
+// src/node-js-compat.ts
+import assert5 from "node:assert";
+import { cloudflare } from "@cloudflare/unenv-preset";
+import { getNodeCompat } from "miniflare";
+import { defineEnv } from "unenv";
+var { env } = defineEnv({
+  nodeCompat: true,
+  presets: [cloudflare]
+});
+var CLOUDFLARE_VIRTUAL_PREFIX = "\0__CLOUDFLARE_NODEJS_COMPAT__";
+function isNodeCompat(workerConfig) {
+  if (workerConfig === void 0) {
+    return false;
+  }
+  const nodeCompatMode = getNodeCompat(
+    workerConfig.compatibility_date,
+    workerConfig.compatibility_flags ?? []
+  ).mode;
+  if (nodeCompatMode === "v2") {
+    return true;
+  }
+  if (nodeCompatMode === "legacy") {
+    throw new Error(
+      "Unsupported Node.js compat mode (legacy). Remove the `node_compat` setting and add the `nodejs_compat` flag instead."
+    );
+  }
+  if (nodeCompatMode === "v1") {
+    throw new Error(
+      `Unsupported Node.js compat mode (v1). Only the v2 mode is supported, either change your compat date to "2024-09-23" or later, or set the "nodejs_compat_v2" compatibility flag`
+    );
+  }
+  return false;
+}
+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;
+    return `import var_${globalName} from "${moduleSpecifier}";
+globalThis.${globalName} = var_${globalName}.${exportName};
+`;
+  }).join("\n");
+  const modified = new MagicString(code);
+  modified.prepend(injectedCode);
+  return {
+    code: modified.toString(),
+    map: modified.generateMap({ hires: "boundary", source: id })
+  };
+}
+function getNodeCompatAliases() {
+  const aliases = {};
+  Object.keys(env.alias).forEach((key) => {
+    if (!env.external.includes(key)) {
+      aliases[key] = CLOUDFLARE_VIRTUAL_PREFIX + key;
+    }
+  });
+  return aliases;
+}
+function getNodeCompatExternals() {
+  return env.external;
+}
+function maybeStripNodeJsVirtualPrefix(source) {
+  return source.startsWith(CLOUDFLARE_VIRTUAL_PREFIX) ? source.slice(CLOUDFLARE_VIRTUAL_PREFIX.length) : void 0;
+}
+function dealiasVirtualNodeJSImport(source) {
+  const alias = env.alias[source];
+  assert5(
+    alias,
+    `Expected "${source}" to have a Node.js compat alias, but none was found`
+  );
+  assert5(
+    !env.external.includes(alias),
+    `Unexpected unenv alias to external module: ${source} -> ${alias}`
+  );
+  return alias;
+}
+
 // src/plugin-config.ts
-import assert6 from "node:assert";
+import assert7 from "node:assert";
 import * as path5 from "node:path";
 import * as vite5 from "vite";
 
 // src/workers-configs.ts
-import assert5 from "node:assert";
+import assert6 from "node:assert";
 import * as fs3 from "node:fs";
 import * as path4 from "node:path";
 import { unstable_readConfig as unstable_readConfig2 } from "wrangler";
@@ -2003,17 +2040,17 @@ function getWorkerConfig(configPath, env2, opts) {
   }
   const { raw, config, nonApplicable } = readWorkerConfig(configPath, env2);
   opts?.visitedConfigPaths?.add(configPath);
-  assert5(
+  assert6(
     config.topLevelName,
     missingFieldErrorMessage(`top-level 'name'`, configPath, env2)
   );
-  assert5(config.name, missingFieldErrorMessage(`'name'`, configPath, env2));
-  assert5(
+  assert6(config.name, missingFieldErrorMessage(`'name'`, configPath, env2));
+  assert6(
     config.compatibility_date,
     missingFieldErrorMessage(`'compatibility_date'`, configPath, env2)
   );
   if (opts?.isEntryWorker && !config.main) {
-    assert5(
+    assert6(
       config.assets,
       missingFieldErrorMessage(`'main' or 'assets'`, configPath, env2)
     );
@@ -2030,7 +2067,7 @@ function getWorkerConfig(configPath, env2, opts) {
       nonApplicable
     };
   }
-  assert5(config.main, missingFieldErrorMessage(`'main'`, configPath, env2));
+  assert6(config.main, missingFieldErrorMessage(`'main'`, configPath, env2));
   return {
     type: "worker",
     raw,
@@ -2061,20 +2098,21 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
   const configPaths = /* @__PURE__ */ new Set();
   const persistState = pluginConfig.persistState ?? true;
   const root = userConfig.root ? path5.resolve(userConfig.root) : process.cwd();
-  const { CLOUDFLARE_ENV } = vite5.loadEnv(viteEnv.mode, root, "");
+  const { CLOUDFLARE_ENV: cloudflareEnv } = vite5.loadEnv(
+    viteEnv.mode,
+    root,
+    /* prefixes */
+    ""
+  );
   const configPath = pluginConfig.configPath ? path5.resolve(root, pluginConfig.configPath) : findWranglerConfig(root);
-  assert6(
+  assert7(
     configPath,
     `Config not found. Have you created a wrangler.json(c) or wrangler.toml file?`
   );
-  const entryWorkerResolvedConfig = getWorkerConfig(
-    configPath,
-    CLOUDFLARE_ENV,
-    {
-      visitedConfigPaths: configPaths,
-      isEntryWorker: true
-    }
-  );
+  const entryWorkerResolvedConfig = getWorkerConfig(configPath, cloudflareEnv, {
+    visitedConfigPaths: configPaths,
+    isEntryWorker: true
+  });
   if (entryWorkerResolvedConfig.type === "assets-only") {
     return {
       type: "assets-only",
@@ -2083,7 +2121,8 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
       persistState,
       rawConfigs: {
         entryWorker: entryWorkerResolvedConfig
-      }
+      },
+      cloudflareEnv
     };
   }
   const entryWorkerConfig = entryWorkerResolvedConfig.config;
@@ -2095,13 +2134,13 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
   for (const auxiliaryWorker of pluginConfig.auxiliaryWorkers ?? []) {
     const workerResolvedConfig = getWorkerConfig(
       path5.resolve(root, auxiliaryWorker.configPath),
-      CLOUDFLARE_ENV,
+      cloudflareEnv,
       {
         visitedConfigPaths: configPaths
       }
     );
     auxiliaryWorkersResolvedConfigs.push(workerResolvedConfig);
-    assert6(
+    assert7(
       workerResolvedConfig.type === "worker",
       "Unexpected error: received AssetsOnlyResult with auxiliary workers."
     );
@@ -2123,7 +2162,8 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
     rawConfigs: {
       entryWorker: entryWorkerResolvedConfig,
       auxiliaryWorkers: auxiliaryWorkersResolvedConfigs
-    }
+    },
+    cloudflareEnv
   };
 }
 
@@ -2167,8 +2207,10 @@ ${event.error?.stack || event.error?.message}`,
           workerWebSocket.addEventListener("close", () => {
             clientWebSocket.close();
           });
-          clientWebSocket.on("message", (event) => {
-            workerWebSocket.send(event);
+          clientWebSocket.on("message", (data, isBinary) => {
+            workerWebSocket.send(
+              isBinary ? Array.isArray(data) ? Buffer.concat(data) : data : data.toString()
+            );
           });
           clientWebSocket.on("error", (error) => {
             logger.error(`WebSocket error:
@@ -2192,211 +2234,371 @@ function cloudflare2(pluginConfig = {}) {
   let resolvedViteConfig;
   let miniflare;
   let workersConfigsWarningShown = false;
-  return {
-    name: "vite-plugin-cloudflare",
-    config(userConfig, env2) {
-      if (env2.isPreview) {
-        return { appType: "custom" };
-      }
-      resolvedPluginConfig = resolvePluginConfig(pluginConfig, userConfig, env2);
-      if (!workersConfigsWarningShown) {
-        workersConfigsWarningShown = true;
-        const workersConfigsWarning = getWarningForWorkersConfigs(
-          resolvedPluginConfig.rawConfigs
+  return [
+    {
+      name: "vite-plugin-cloudflare",
+      config(userConfig, env2) {
+        if (env2.isPreview) {
+          return { appType: "custom" };
+        }
+        resolvedPluginConfig = resolvePluginConfig(
+          pluginConfig,
+          userConfig,
+          env2
         );
-        if (workersConfigsWarning) {
-          console.warn(workersConfigsWarning);
+        if (!workersConfigsWarningShown) {
+          workersConfigsWarningShown = true;
+          const workersConfigsWarning = getWarningForWorkersConfigs(
+            resolvedPluginConfig.rawConfigs
+          );
+          if (workersConfigsWarning) {
+            console.warn(workersConfigsWarning);
+          }
         }
-      }
-      return {
-        appType: "custom",
-        resolve: {
-          alias: getNodeCompatAliases()
-        },
-        environments: resolvedPluginConfig.type === "workers" ? {
-          ...Object.fromEntries(
-            Object.entries(resolvedPluginConfig.workers).map(
-              ([environmentName, workerConfig]) => {
-                return [
-                  environmentName,
-                  createCloudflareEnvironmentOptions(
-                    workerConfig,
-                    userConfig,
-                    environmentName
+        return {
+          appType: "custom",
+          environments: resolvedPluginConfig.type === "workers" ? {
+            ...Object.fromEntries(
+              Object.entries(resolvedPluginConfig.workers).map(
+                ([environmentName, workerConfig]) => {
+                  return [
+                    environmentName,
+                    createCloudflareEnvironmentOptions(
+                      workerConfig,
+                      userConfig,
+                      environmentName
+                    )
+                  ];
+                }
+              )
+            ),
+            client: {
+              build: {
+                outDir: getOutputDirectory(userConfig, "client")
+              }
+            }
+          } : void 0,
+          builder: {
+            async buildApp(builder) {
+              const clientEnvironment = builder.environments.client;
+              const defaultHtmlPath = path6.resolve(
+                builder.config.root,
+                "index.html"
+              );
+              if (clientEnvironment && (clientEnvironment.config.build.rollupOptions.input || fs4.existsSync(defaultHtmlPath))) {
+                await builder.build(clientEnvironment);
+              }
+              if (resolvedPluginConfig.type === "workers") {
+                const workerEnvironments = Object.keys(
+                  resolvedPluginConfig.workers
+                ).map((environmentName) => {
+                  const environment = builder.environments[environmentName];
+                  assert8(
+                    environment,
+                    `${environmentName} environment not found`
+                  );
+                  return environment;
+                });
+                await Promise.all(
+                  workerEnvironments.map(
+                    (environment) => builder.build(environment)
                   )
-                ];
+                );
               }
-            )
-          ),
-          client: {
-            build: {
-              outDir: getOutputDirectory(userConfig, "client")
             }
           }
-        } : void 0,
-        builder: {
-          async buildApp(builder) {
-            const clientEnvironment = builder.environments.client;
-            const defaultHtmlPath = path6.resolve(
-              builder.config.root,
-              "index.html"
+        };
+      },
+      configResolved(config) {
+        resolvedViteConfig = config;
+      },
+      generateBundle(_, bundle) {
+        let config;
+        if (resolvedPluginConfig.type === "workers") {
+          const workerConfig = resolvedPluginConfig.workers[this.environment.name];
+          const entryChunk = Object.entries(bundle).find(
+            ([_2, chunk]) => chunk.type === "chunk" && chunk.isEntry
+          );
+          if (!workerConfig || !entryChunk) {
+            return;
+          }
+          workerConfig.main = entryChunk[0];
+          const isEntryWorker = this.environment.name === resolvedPluginConfig.entryWorkerEnvironmentName;
+          if (isEntryWorker && workerConfig.assets) {
+            const workerOutputDirectory = this.environment.config.build.outDir;
+            const clientOutputDirectory = resolvedViteConfig.environments.client?.build.outDir;
+            assert8(
+              clientOutputDirectory,
+              "Unexpected error: client output directory is undefined"
             );
-            if (clientEnvironment && (clientEnvironment.config.build.rollupOptions.input || fs4.existsSync(defaultHtmlPath))) {
-              await builder.build(clientEnvironment);
-            }
-            if (resolvedPluginConfig.type === "workers") {
-              const workerEnvironments = Object.keys(
-                resolvedPluginConfig.workers
-              ).map((environmentName) => {
-                const environment = builder.environments[environmentName];
-                assert7(environment, `${environmentName} environment not found`);
-                return environment;
+            workerConfig.assets.directory = path6.relative(
+              path6.resolve(resolvedViteConfig.root, workerOutputDirectory),
+              path6.resolve(resolvedViteConfig.root, clientOutputDirectory)
+            );
+          }
+          config = workerConfig;
+          if (workerConfig.configPath) {
+            const dotDevDotVarsContent = getDotDevDotVarsContent(
+              workerConfig.configPath,
+              resolvedPluginConfig.cloudflareEnv
+            );
+            if (dotDevDotVarsContent) {
+              this.emitFile({
+                type: "asset",
+                fileName: ".dev.vars",
+                source: dotDevDotVarsContent
               });
-              await Promise.all(
-                workerEnvironments.map(
-                  (environment) => builder.build(environment)
-                )
-              );
             }
-            writeDeployConfig(resolvedPluginConfig, resolvedViteConfig);
           }
+        } else if (this.environment.name === "client") {
+          const assetsOnlyConfig = resolvedPluginConfig.config;
+          assetsOnlyConfig.assets.directory = ".";
+          const filesToAssetsIgnore = ["wrangler.json", ".dev.vars"];
+          this.emitFile({
+            type: "asset",
+            fileName: ".assetsignore",
+            source: `${filesToAssetsIgnore.join("\n")}
+`
+          });
+          config = assetsOnlyConfig;
         }
-      };
-    },
-    configResolved(config) {
-      resolvedViteConfig = config;
-    },
-    async resolveId(source) {
-      if (resolvedPluginConfig.type === "assets-only") {
-        return;
-      }
-      const workerConfig = resolvedPluginConfig.workers[this.environment.name];
-      if (!workerConfig) {
-        return;
-      }
-      return resolveNodeCompatId(this.environment, workerConfig, source);
-    },
-    async transform(code, id) {
-      if (resolvedPluginConfig.type === "assets-only") {
-        return;
-      }
-      const workerConfig = resolvedPluginConfig.workers[this.environment.name];
-      if (!workerConfig) {
-        return;
-      }
-      const resolvedId = await this.resolve(workerConfig.main);
-      if (id === resolvedId?.id) {
-        return injectGlobalCode(id, code, workerConfig);
-      }
-    },
-    generateBundle(_, bundle) {
-      let config;
-      if (resolvedPluginConfig.type === "workers") {
-        const workerConfig = resolvedPluginConfig.workers[this.environment.name];
-        const entryChunk = Object.entries(bundle).find(
-          ([_2, chunk]) => chunk.type === "chunk" && chunk.isEntry
-        );
-        if (!workerConfig || !entryChunk) {
+        if (!config) {
           return;
         }
-        workerConfig.main = entryChunk[0];
-        const isEntryWorker = this.environment.name === resolvedPluginConfig.entryWorkerEnvironmentName;
-        if (isEntryWorker && workerConfig.assets) {
-          const workerOutputDirectory = this.environment.config.build.outDir;
-          const clientOutputDirectory = resolvedViteConfig.environments.client?.build.outDir;
-          assert7(
-            clientOutputDirectory,
-            "Unexpected error: client output directory is undefined"
-          );
-          workerConfig.assets.directory = path6.relative(
-            path6.resolve(resolvedViteConfig.root, workerOutputDirectory),
-            path6.resolve(resolvedViteConfig.root, clientOutputDirectory)
-          );
+        config.no_bundle = true;
+        config.rules = [{ type: "ESModule", globs: ["**/*.js"] }];
+        if (config.unsafe && Object.keys(config.unsafe).length === 0) {
+          config.unsafe = void 0;
         }
-        config = workerConfig;
-      } else if (this.environment.name === "client") {
-        const assetsOnlyConfig = resolvedPluginConfig.config;
-        assetsOnlyConfig.assets.directory = ".";
         this.emitFile({
           type: "asset",
-          fileName: ".assetsignore",
-          source: "wrangler.json"
+          fileName: "wrangler.json",
+          source: JSON.stringify(config)
         });
-        config = assetsOnlyConfig;
-      }
-      if (!config) {
-        return;
+      },
+      writeBundle() {
+        if (this.environment.name === (resolvedPluginConfig.type === "assets-only" ? "client" : resolvedPluginConfig.entryWorkerEnvironmentName)) {
+          writeDeployConfig(resolvedPluginConfig, resolvedViteConfig);
+        }
+      },
+      handleHotUpdate(options) {
+        if (resolvedPluginConfig.configPaths.has(options.file)) {
+          options.server.restart();
+        }
+      },
+      async buildEnd() {
+        if (miniflare) {
+          await miniflare.dispose();
+          miniflare = void 0;
+        }
+      },
+      async configureServer(viteDevServer) {
+        assert8(
+          viteDevServer.httpServer,
+          "Unexpected error: No Vite HTTP server"
+        );
+        miniflare = new Miniflare(
+          getDevMiniflareOptions(resolvedPluginConfig, viteDevServer)
+        );
+        await initRunners(resolvedPluginConfig, viteDevServer, miniflare);
+        const entryWorker = await getDevEntryWorker(
+          resolvedPluginConfig,
+          miniflare
+        );
+        const middleware = createMiddleware(
+          ({ request }) => {
+            return entryWorker.fetch(toMiniflareRequest(request), {
+              redirect: "manual"
+            });
+          },
+          { alwaysCallNext: false }
+        );
+        handleWebSocket(
+          viteDevServer.httpServer,
+          entryWorker.fetch,
+          viteDevServer.config.logger
+        );
+        return () => {
+          viteDevServer.middlewares.use((req, res, next) => {
+            middleware(req, res, next);
+          });
+        };
+      },
+      configurePreviewServer(vitePreviewServer) {
+        const miniflare2 = new Miniflare(
+          getPreviewMiniflareOptions(
+            vitePreviewServer,
+            pluginConfig.persistState ?? true
+          )
+        );
+        const middleware = createMiddleware(
+          ({ request }) => {
+            return miniflare2.dispatchFetch(toMiniflareRequest(request), {
+              redirect: "manual"
+            });
+          },
+          { alwaysCallNext: false }
+        );
+        handleWebSocket(
+          vitePreviewServer.httpServer,
+          miniflare2.dispatchFetch,
+          vitePreviewServer.config.logger
+        );
+        return () => {
+          vitePreviewServer.middlewares.use((req, res, next) => {
+            middleware(req, res, next);
+          });
+        };
       }
-      config.no_bundle = true;
-      config.rules = [{ type: "ESModule", globs: ["**/*.js"] }];
-      config.unsafe = void 0;
-      this.emitFile({
-        type: "asset",
-        fileName: "wrangler.json",
-        source: JSON.stringify(config)
-      });
     },
-    handleHotUpdate(options) {
-      if (resolvedPluginConfig.configPaths.has(options.file)) {
-        options.server.restart();
+    // Plugin to support `CompiledWasm` modules
+    {
+      name: "vite-plugin-cloudflare: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")) {
+          return;
+        }
+        const resolved = await this.resolve(source, importer);
+        assert8(
+          resolved,
+          `Unexpected error: could not resolve Wasm module ${source}`
+        );
+        return {
+          external: true,
+          id: createModuleReference("CompiledWasm", resolved.id)
+        };
+      },
+      renderChunk(code, chunk) {
+        const moduleRE = new RegExp(MODULE_PATTERN, "g");
+        let match;
+        let magicString;
+        while (match = moduleRE.exec(code)) {
+          magicString ??= new MagicString(code);
+          const [full, moduleType, modulePath] = match;
+          assert8(
+            modulePath,
+            `Unexpected error: module path not found in reference ${full}.`
+          );
+          let source;
+          try {
+            source = fs4.readFileSync(modulePath);
+          } catch (error) {
+            throw new Error(
+              `Import ${modulePath} not found. Does the file exist?`
+            );
+          }
+          const referenceId = this.emitFile({
+            type: "asset",
+            name: path6.basename(modulePath),
+            originalFileName: modulePath,
+            source
+          });
+          const emittedFileName = this.getFileName(referenceId);
+          const relativePath = vite6.normalizePath(
+            path6.relative(path6.dirname(chunk.fileName), emittedFileName)
+          );
+          const importPath = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+          magicString.update(
+            match.index,
+            match.index + full.length,
+            importPath
+          );
+        }
+        if (magicString) {
+          return {
+            code: magicString.toString(),
+            map: this.environment.config.build.sourcemap ? magicString.generateMap({ hires: "boundary" }) : null
+          };
+        }
       }
     },
-    async buildEnd() {
-      if (miniflare) {
-        await miniflare.dispose();
-        miniflare = void 0;
+    // Plugin that can provide Node.js compatibility support for Vite Environments that are hosted in Cloudflare Workers.
+    {
+      name: "vite-plugin-cloudflare:nodejs-compat",
+      apply(_config, env2) {
+        return !env2.isPreview;
+      },
+      config() {
+        return {
+          resolve: {
+            alias: getNodeCompatAliases()
+          }
+        };
+      },
+      configEnvironment(environmentName) {
+        const workerConfig = getWorkerConfig2(environmentName);
+        if (isNodeCompat(workerConfig)) {
+          return {
+            build: {
+              rollupOptions: {
+                external: getNodeCompatExternals()
+              }
+            }
+          };
+        }
+      },
+      async resolveId(source, importer, options) {
+        const from = maybeStripNodeJsVirtualPrefix(source);
+        if (!from) {
+          return;
+        }
+        const workerConfig = getWorkerConfig2(this.environment.name);
+        if (!isNodeCompat(workerConfig)) {
+          return this.resolve(from, importer, options);
+        }
+        const unresolvedAlias = dealiasVirtualNodeJSImport(from);
+        const resolvedAlias = await this.resolve(
+          unresolvedAlias,
+          import.meta.url
+        );
+        assert8(
+          resolvedAlias,
+          "Failed to resolve aliased nodejs import: " + unresolvedAlias
+        );
+        if (this.environment.mode === "dev" && this.environment.depsOptimizer) {
+          this.environment.depsOptimizer.registerMissingImport(
+            unresolvedAlias,
+            resolvedAlias.id
+          );
+        }
+        return resolvedAlias;
+      },
+      async transform(code, id) {
+        const workerConfig = getWorkerConfig2(this.environment.name);
+        if (!isNodeCompat(workerConfig)) {
+          return;
+        }
+        const resolvedId = await this.resolve(workerConfig.main);
+        if (id === resolvedId?.id) {
+          return injectGlobalCode(id, code);
+        }
       }
-    },
-    async configureServer(viteDevServer) {
-      assert7(viteDevServer.httpServer, "Unexpected error: No Vite HTTP server");
-      miniflare = new Miniflare(
-        getDevMiniflareOptions(resolvedPluginConfig, viteDevServer)
-      );
-      await initRunners(resolvedPluginConfig, viteDevServer, miniflare);
-      const entryWorker = await getDevEntryWorker(
-        resolvedPluginConfig,
-        miniflare
-      );
-      const middleware = createMiddleware(({ request }) => {
-        return entryWorker.fetch(toMiniflareRequest(request), {
-          redirect: "manual"
-        });
-      });
-      handleWebSocket(
-        viteDevServer.httpServer,
-        entryWorker.fetch,
-        viteDevServer.config.logger
-      );
-      return () => {
-        viteDevServer.middlewares.use((req, res, next) => {
-          middleware(req, res, next);
-        });
-      };
-    },
-    configurePreviewServer(vitePreviewServer) {
-      const miniflare2 = new Miniflare(
-        getPreviewMiniflareOptions(
-          vitePreviewServer,
-          pluginConfig.persistState ?? true
-        )
-      );
-      const middleware = createMiddleware(({ request }) => {
-        return miniflare2.dispatchFetch(toMiniflareRequest(request), {
-          redirect: "manual"
-        });
-      });
-      handleWebSocket(
-        vitePreviewServer.httpServer,
-        miniflare2.dispatchFetch,
-        vitePreviewServer.config.logger
-      );
-      return () => {
-        vitePreviewServer.middlewares.use((req, res, next) => {
-          middleware(req, res, next);
-        });
-      };
     }
-  };
+  ];
+  function getWorkerConfig2(environmentName) {
+    assert8(resolvedPluginConfig, "Expected resolvedPluginConfig to be defined");
+    return resolvedPluginConfig.type !== "assets-only" ? resolvedPluginConfig.workers[environmentName] : void 0;
+  }
+}
+function getDotDevDotVarsContent(configPath, cloudflareEnv) {
+  const configDir = path6.dirname(configPath);
+  const defaultDotDevDotVarsPath = `${configDir}/.dev.vars`;
+  const inputDotDevDotVarsPath = `${defaultDotDevDotVarsPath}${cloudflareEnv ? `.${cloudflareEnv}` : ""}`;
+  const targetPath = fs4.existsSync(inputDotDevDotVarsPath) ? inputDotDevDotVarsPath : fs4.existsSync(defaultDotDevDotVarsPath) ? defaultDotDevDotVarsPath : null;
+  if (targetPath) {
+    const dotDevDotVarsContent = fs4.readFileSync(targetPath);
+    return dotDevDotVarsContent;
+  }
+  return null;
+}
+function createModuleReference(type, id) {
+  return `__CLOUDFLARE_MODULE__${type}__${id}__`;
 }
 export {
   cloudflare2 as cloudflare