@cloudflare/vite-plugin 0.0.0-665ebd857 → 0.0.0-66edd2f3b

package/dist/index.js

@@ -485,11 +485,12 @@ var require_mime = __commonJS({
 });
 
 // src/index.ts
-import assert8 from "node:assert";
+import assert10 from "node:assert";
 import * as fs5 from "node:fs";
 import * as fsp2 from "node:fs/promises";
 import * as path9 from "node:path";
-import { createMiddleware } from "@hattip/adapter-node";
+import { createRequest, sendResponse } from "@mjackson/node-fetch-server";
+import replace from "@rollup/plugin-replace";
 
 // ../../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.0/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
 var comma = ",".charCodeAt(0);
@@ -1557,6 +1558,7 @@ var MagicString = class _MagicString {
 
 // src/index.ts
 import { Miniflare } from "miniflare";
+import colors3 from "picocolors";
 import * as vite7 from "vite";
 
 // src/constants.ts
@@ -1569,6 +1571,7 @@ var ADDITIONAL_MODULE_TYPES = [
   "Text"
 ];
 var DEFAULT_INSPECTOR_PORT = 9229;
+var kRequestType = Symbol("kRequestType");
 
 // src/additional-modules.ts
 var moduleRules = [
@@ -1587,7 +1590,7 @@ function matchAdditionalModule(source) {
   return null;
 }
 function createModuleReference(type, id) {
-  return `__CLOUDFLARE_MODULE__${type}__${id}__`;
+  return `__CLOUDFLARE_MODULE__${type}__${id}__CLOUDFLARE_MODULE__`;
 }
 
 // src/asset-config.ts
@@ -5782,7 +5785,8 @@ var z = /* @__PURE__ */ Object.freeze({
 // ../workers-shared/utils/types.ts
 var InternalConfigSchema = z.object({
   account_id: z.number().optional(),
-  script_id: z.number().optional()
+  script_id: z.number().optional(),
+  debug: z.boolean().optional()
 });
 var RouterConfigSchema = z.object({
   invoke_user_worker_ahead_of_assets: z.boolean().optional(),
@@ -5830,14 +5834,14 @@ var AssetConfigSchema = z.object({
 });
 
 // src/asset-config.ts
-function hasAssetsConfigChanged(resolvedPluginConfig, resolvedViteConfig, changedFile) {
+function hasAssetsConfigChanged(resolvedPluginConfig, resolvedViteConfig, changedFilePath) {
   if (!resolvedPluginConfig.experimental?.headersAndRedirectsDevModeSupport) {
     return false;
   }
   return [
     getRedirectsConfigPath(resolvedViteConfig),
     getHeadersConfigPath(resolvedViteConfig)
-  ].includes(path.resolve(changedFile));
+  ].includes(changedFilePath);
 }
 function getAssetsConfig(resolvedPluginConfig, entryWorkerConfig, resolvedConfig) {
   const assetsConfig = resolvedPluginConfig.type === "assets-only" ? resolvedPluginConfig.config.assets : entryWorkerConfig?.assets;
@@ -12645,8 +12649,8 @@ function packageResolve(specifier, base, conditions) {
   let packageJsonPath = fileURLToPath$1(packageJsonUrl);
   let lastPath;
   do {
-    const stat = tryStatSync(packageJsonPath.slice(0, -13));
-    if (!stat || !stat.isDirectory()) {
+    const stat2 = tryStatSync(packageJsonPath.slice(0, -13));
+    if (!stat2 || !stat2.isDirectory()) {
       lastPath = packageJsonPath;
       packageJsonUrl = new URL$1(
         (isScoped ? "../../../../node_modules/" : "../../../node_modules/") + packageName + "/package.json",
@@ -12776,8 +12780,8 @@ function _resolve(id, options = {}) {
   }
   if (isAbsolute(id)) {
     try {
-      const stat = statSync(id);
-      if (stat.isFile()) {
+      const stat2 = statSync(id);
+      if (stat2.isFile()) {
         return pathToFileURL(id);
       }
     } catch (error) {
@@ -12878,6 +12882,15 @@ function isNodeCompat(workerConfig) {
   }
   return false;
 }
+function isNodeAls(workerConfig) {
+  return workerConfig !== void 0 && getNodeCompat(
+    workerConfig.compatibility_date,
+    workerConfig.compatibility_flags ?? []
+  ).mode === "als";
+}
+function isNodeAlsModule(path10) {
+  return /^(node:)?async_hooks$/.test(path10);
+}
 function injectGlobalCode(id, code) {
   const injectedCode = Object.entries(env.inject).map(([globalName, globalInject]) => {
     if (typeof globalInject === "string") {
@@ -12908,7 +12921,7 @@ globalThis.${globalName} = var_${globalName}.${exportName};
 }
 function resolveNodeJSImport(source) {
   const alias = env.alias[source];
-  if (alias) {
+  if (alias && !nodeCompatExternals.has(alias)) {
     return {
       unresolved: alias,
       resolved: resolvePathSync(alias, { url: import.meta.url })
@@ -12939,8 +12952,9 @@ function getNodeCompatEntries() {
   return entries;
 }
 var NodeJsCompatWarnings = class {
-  constructor(environment) {
-    this.environment = environment;
+  constructor(environmentName, resolvedViteConfig) {
+    this.environmentName = environmentName;
+    this.resolvedViteConfig = resolvedViteConfig;
   }
   sources = /* @__PURE__ */ new Map();
   timer;
@@ -12948,6 +12962,7 @@ var NodeJsCompatWarnings = class {
     const importers = this.sources.get(source) ?? /* @__PURE__ */ new Set();
     this.sources.set(source, importers);
     importers.add(importer);
+    this.renderWarningsOnIdle();
   }
   renderWarningsOnIdle() {
     if (this.timer) {
@@ -12960,19 +12975,16 @@ var NodeJsCompatWarnings = class {
   }
   renderWarnings() {
     if (this.sources.size > 0) {
-      let message = `
-
-Unexpected Node.js imports for environment "${this.environment.name}". Do you need to enable the "nodejs_compat" compatibility flag?
-Refer to https://developers.cloudflare.com/workers/runtime-apis/nodejs/ for more details.
+      let message = `Unexpected Node.js imports for environment "${this.environmentName}". Do you need to enable the "nodejs_compat" compatibility flag? Refer to https://developers.cloudflare.com/workers/runtime-apis/nodejs/ for more details.
 `;
       this.sources.forEach((importers, source) => {
         importers.forEach((importer) => {
-          message += ` - "${source}" imported from "${path3.relative(this.environment.config.root, importer)}"
+          message += ` - "${source}" imported from "${path3.relative(this.resolvedViteConfig.root, importer)}"
 `;
         });
       });
-      this.environment.logger.warn(message, {
-        environment: this.environment.name
+      this.resolvedViteConfig.logger.warn(message, {
+        timestamp: true
       });
       this.sources.clear();
     }
@@ -12982,7 +12994,7 @@ Refer to https://developers.cloudflare.com/workers/runtime-apis/nodejs/ for more
 // src/shared.ts
 var UNKNOWN_HOST = "http://localhost";
 var INIT_PATH = "/__vite_plugin_cloudflare_init__";
-var ADDITIONAL_MODULE_PATTERN = `__CLOUDFLARE_MODULE__(${ADDITIONAL_MODULE_TYPES.join("|")})__(.*?)__`;
+var ADDITIONAL_MODULE_PATTERN = `__CLOUDFLARE_MODULE__(${ADDITIONAL_MODULE_TYPES.join("|")})__(.*?)__CLOUDFLARE_MODULE__`;
 var additionalModuleRE = new RegExp(ADDITIONAL_MODULE_PATTERN);
 var additionalModuleGlobalRE = new RegExp(
   ADDITIONAL_MODULE_PATTERN,
@@ -12992,15 +13004,13 @@ var VITE_DEV_METADATA_HEADER = "__VITE_DEV_METADATA__";
 
 // src/utils.ts
 import * as path4 from "node:path";
+import getPort, { portNumbers } from "get-port";
 import { Request as MiniflareRequest } from "miniflare";
 import "vite";
 function getOutputDirectory(userConfig, environmentName) {
   const rootOutputDirectory = userConfig.build?.outDir ?? "dist";
   return userConfig.environments?.[environmentName]?.build?.outDir ?? path4.join(rootOutputDirectory, environmentName);
 }
-function getRouterWorker(miniflare2) {
-  return miniflare2.getWorker(ROUTER_WORKER_NAME);
-}
 function toMiniflareRequest(request) {
   const host = request.headers.get("Host");
   if (host) {
@@ -13017,23 +13027,13 @@ function toMiniflareRequest(request) {
     duplex: "half"
   });
 }
-function nodeHeadersToWebHeaders(nodeHeaders) {
-  const headers = new Headers();
-  for (const [key, value] of Object.entries(nodeHeaders)) {
-    if (typeof value === "string") {
-      headers.append(key, value);
-    } else if (Array.isArray(value)) {
-      for (const item of value) {
-        headers.append(key, item);
-      }
-    }
-  }
-  return headers;
-}
 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";
@@ -13255,7 +13255,7 @@ import { unstable_readConfig } from "wrangler";
 function getDeployConfigPath(root) {
   return path5.resolve(root, ".wrangler", "deploy", "config.json");
 }
-function getWorkerConfigs(root) {
+function getWorkerConfigs(root, mixedModeEnabled) {
   const deployConfigPath = getDeployConfigPath(root);
   const deployConfig = JSON.parse(
     fs2.readFileSync(deployConfigPath, "utf-8")
@@ -13268,7 +13268,10 @@ function getWorkerConfigs(root) {
       path5.dirname(deployConfigPath),
       configPath
     );
-    return unstable_readConfig({ config: resolvedConfigPath });
+    return unstable_readConfig(
+      { config: resolvedConfigPath },
+      { experimental: { mixedModeEnabled } }
+    );
   });
 }
 function getRelativePathToWorkerConfig(deployConfigDirectory, root, outputDirectory) {
@@ -13335,17 +13338,24 @@ import * as fsp from "node:fs/promises";
 import * as path6 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import {
+  getDefaultDevRegistryPath,
   kCurrentWorker,
   Log,
   LogLevel,
   Response as MiniflareResponse
 } from "miniflare";
+import colors2 from "picocolors";
 import { globSync } from "tinyglobby";
 import "vite";
-import { unstable_getMiniflareWorkerOptions } from "wrangler";
-function getPersistence(root, persistState) {
+import {
+  experimental_pickRemoteBindings,
+  experimental_startMixedModeSession,
+  unstable_convertConfigBindingsToStartWorkerBindings,
+  unstable_getMiniflareWorkerOptions
+} from "wrangler";
+function getPersistenceRoot(root, persistState) {
   if (persistState === false) {
-    return {};
+    return;
   }
   const defaultPersistPath = ".wrangler/state";
   const persistPath = path6.resolve(
@@ -13353,14 +13363,7 @@ function getPersistence(root, persistState) {
     typeof persistState === "object" ? persistState.path : defaultPersistPath,
     "v3"
   );
-  return {
-    cachePersist: path6.join(persistPath, "cache"),
-    d1Persist: path6.join(persistPath, "d1"),
-    durableObjectsPersist: path6.join(persistPath, "do"),
-    kvPersist: path6.join(persistPath, "kv"),
-    r2Persist: path6.join(persistPath, "r2"),
-    workflowsPersist: path6.join(persistPath, "workflows")
-  };
+  return persistPath;
 }
 function missingWorkerErrorMessage(workerName) {
   return `${workerName} does not match a worker name.`;
@@ -13444,7 +13447,29 @@ function getEntryWorkerConfig(resolvedPluginConfig) {
   }
   return resolvedPluginConfig.workers[resolvedPluginConfig.entryWorkerEnvironmentName];
 }
-function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
+function logUnknownTails(tails, userWorkers, log) {
+  for (const tailService of tails ?? []) {
+    let name;
+    if (typeof tailService === "string") {
+      name = tailService;
+    } else if (typeof tailService === "object" && "name" in tailService && typeof tailService.name === "string") {
+      name = tailService.name;
+    } else {
+      continue;
+    }
+    const found = userWorkers.some((w) => w.name === name);
+    if (!found) {
+      log(
+        colors2.dim(
+          colors2.yellow(
+            `Tail consumer "${name}" was not found in your config. Make sure you add it to the config or run it in another dev session if you'd like to simulate receiving tail events locally.`
+          )
+        )
+      );
+    }
+  }
+}
+async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspectorPort) {
   const resolvedViteConfig = viteDevServer.config;
   const entryWorkerConfig = getEntryWorkerConfig(resolvedPluginConfig);
   const assetsConfig = getAssetsConfig(
@@ -13495,12 +13520,14 @@ function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
       serviceBindings: {
         __VITE_ASSET_EXISTS__: async (request) => {
           const { pathname } = new URL(request.url);
-          const filePath = path6.join(resolvedViteConfig.root, pathname);
-          let exists;
-          try {
-            exists = fs3.statSync(filePath).isFile();
-          } catch (error) {
-            exists = false;
+          let exists = false;
+          if (pathname.endsWith(".html")) {
+            try {
+              const filePath = path6.join(resolvedViteConfig.root, pathname);
+              const stats = await fsp.stat(filePath);
+              exists = stats.isFile();
+            } catch (error) {
+            }
           }
           return MiniflareResponse.json(exists);
         },
@@ -13514,59 +13541,75 @@ function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
               headers: { "Content-Type": "text/html" }
             });
           } catch (error) {
-            throw new Error(`Unexpected error. Failed to load ${pathname}`);
+            throw new Error(`Unexpected error. Failed to load "${pathname}".`);
           }
         }
       }
     }
   ];
-  const workersFromConfig = resolvedPluginConfig.type === "workers" ? Object.entries(resolvedPluginConfig.workers).map(
-    ([environmentName, workerConfig]) => {
-      const miniflareWorkerOptions = unstable_getMiniflareWorkerOptions(
-        {
-          ...workerConfig,
-          assets: void 0
-        },
-        resolvedPluginConfig.cloudflareEnv
-      );
-      const { externalWorkers: externalWorkers2 } = miniflareWorkerOptions;
-      const { ratelimits, ...workerOptions } = miniflareWorkerOptions.workerOptions;
-      return {
-        externalWorkers: externalWorkers2,
-        worker: {
-          ...workerOptions,
-          name: workerOptions.name ?? workerConfig.name,
-          unsafeInspectorProxy: resolvedPluginConfig.inspectorPort !== false,
-          modulesRoot: miniflareModulesRoot,
-          unsafeEvalBinding: "__VITE_UNSAFE_EVAL__",
-          serviceBindings: {
-            ...workerOptions.serviceBindings,
-            ...environmentName === resolvedPluginConfig.entryWorkerEnvironmentName && workerConfig.assets?.binding ? {
-              [workerConfig.assets.binding]: ASSET_WORKER_NAME
-            } : {},
-            __VITE_INVOKE_MODULE__: async (request) => {
-              const payload = await request.json();
-              const invokePayloadData = payload.data;
-              assert6(
-                invokePayloadData.name === "fetchModule",
-                `Invalid invoke event: ${invokePayloadData.name}`
-              );
-              const [moduleId] = invokePayloadData.data;
-              if (additionalModuleRE.test(moduleId)) {
-                const result2 = {
-                  externalize: moduleId,
-                  type: "module"
-                };
-                return MiniflareResponse.json({ result: result2 });
+  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 miniflareWorkerOptions = unstable_getMiniflareWorkerOptions(
+          {
+            ...workerConfig,
+            assets: void 0
+          },
+          resolvedPluginConfig.cloudflareEnv,
+          {
+            mixedModeConnectionString: mixedModeSession?.mixedModeConnectionString,
+            mixedModeEnabled: resolvedPluginConfig.experimental.mixedMode
+          }
+        );
+        const { externalWorkers: externalWorkers2 } = miniflareWorkerOptions;
+        const { ratelimits, ...workerOptions } = miniflareWorkerOptions.workerOptions;
+        return {
+          externalWorkers: externalWorkers2,
+          worker: {
+            ...workerOptions,
+            name: workerOptions.name ?? workerConfig.name,
+            unsafeInspectorProxy: inspectorPort !== false,
+            unsafeDirectSockets: environmentName === resolvedPluginConfig.entryWorkerEnvironmentName ? (
+              // Expose the default entrypoint of the entry worker on the dev registry
+              [{ entrypoint: void 0, proxy: true }]
+            ) : [],
+            modulesRoot: miniflareModulesRoot,
+            unsafeEvalBinding: "__VITE_UNSAFE_EVAL__",
+            serviceBindings: {
+              ...workerOptions.serviceBindings,
+              ...environmentName === resolvedPluginConfig.entryWorkerEnvironmentName && workerConfig.assets?.binding ? {
+                [workerConfig.assets.binding]: {
+                  node: (req, res) => {
+                    req[kRequestType] = "asset";
+                    viteDevServer.middlewares(req, res);
+                  }
+                }
+              } : {},
+              __VITE_INVOKE_MODULE__: async (request) => {
+                const payload = await request.json();
+                const invokePayloadData = payload.data;
+                assert6(
+                  invokePayloadData.name === "fetchModule",
+                  `Invalid invoke event: ${invokePayloadData.name}`
+                );
+                const [moduleId] = invokePayloadData.data;
+                if (additionalModuleRE.test(moduleId)) {
+                  const result2 = {
+                    externalize: moduleId,
+                    type: "module"
+                  };
+                  return MiniflareResponse.json({ result: result2 });
+                }
+                const devEnvironment = viteDevServer.environments[environmentName];
+                const result = await devEnvironment.hot.handleInvoke(payload);
+                return MiniflareResponse.json(result);
               }
-              const devEnvironment = viteDevServer.environments[environmentName];
-              const result = await devEnvironment.hot.handleInvoke(payload);
-              return MiniflareResponse.json(result);
             }
           }
-        }
-      };
-    }
+        };
+      }
+    )
   ) : [];
   const userWorkers = workersFromConfig.map((options) => options.worker);
   const externalWorkers = workersFromConfig.flatMap(
@@ -13578,8 +13621,10 @@ function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
   const logger = new ViteMiniflareLogger(resolvedViteConfig);
   return {
     log: logger,
-    inspectorPort: resolvedPluginConfig.inspectorPort || void 0,
-    unsafeInspectorProxy: resolvedPluginConfig.inspectorPort !== false,
+    logRequests: false,
+    inspectorPort: inspectorPort === false ? void 0 : inspectorPort,
+    unsafeInspectorProxy: inspectorPort !== false,
+    unsafeDevRegistryPath: getDefaultDevRegistryPath(),
     handleRuntimeStdio(stdout, stderr) {
       const decoder = new TextDecoder();
       stdout.forEach((data2) => logger.info(decoder.decode(data2)));
@@ -13587,7 +13632,7 @@ function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
         (error) => logger.logWithLevel(LogLevel.ERROR, decoder.decode(error))
       );
     },
-    ...getPersistence(
+    defaultPersistRoot: getPersistenceRoot(
       resolvedViteConfig.root,
       resolvedPluginConfig.persistState
     ),
@@ -13633,6 +13678,11 @@ function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
             `export const ${className} = createWorkflowEntrypointWrapper('${className}');`
           );
         }
+        logUnknownTails(
+          workerOptions.tails,
+          userWorkers,
+          viteDevServer.config.logger.warn
+        );
         return {
           ...workerOptions,
           modules: [
@@ -13716,27 +13766,48 @@ function getPreviewModules(main, modulesRules) {
     ]
   };
 }
-function getPreviewMiniflareOptions(vitePreviewServer, workerConfigs, persistState, inspectorPort = DEFAULT_INSPECTOR_PORT) {
+async function getPreviewMiniflareOptions(vitePreviewServer, workerConfigs, persistState, mixedModeEnabled, inspectorPort) {
   const resolvedViteConfig = vitePreviewServer.config;
-  const workers = workerConfigs.flatMap((config) => {
-    const miniflareWorkerOptions = unstable_getMiniflareWorkerOptions(config);
-    const { externalWorkers } = miniflareWorkerOptions;
-    const { ratelimits, modulesRules, ...workerOptions } = miniflareWorkerOptions.workerOptions;
-    return [
-      {
-        ...workerOptions,
-        name: workerOptions.name ?? config.name,
-        unsafeInspectorProxy: inspectorPort !== false,
-        ...miniflareWorkerOptions.main ? getPreviewModules(miniflareWorkerOptions.main, modulesRules) : { modules: true, script: "" }
-      },
-      ...externalWorkers
-    ];
-  });
+  const workers = (await Promise.all(
+    workerConfigs.map(async (workerConfig, i) => {
+      const mixedModeSession = mixedModeEnabled ? await maybeStartOrUpdateMixedModeSession(workerConfig) : void 0;
+      const miniflareWorkerOptions = unstable_getMiniflareWorkerOptions(
+        workerConfig,
+        void 0,
+        {
+          mixedModeConnectionString: mixedModeSession?.mixedModeConnectionString,
+          mixedModeEnabled
+        }
+      );
+      const { externalWorkers } = miniflareWorkerOptions;
+      const { ratelimits, modulesRules, ...workerOptions } = miniflareWorkerOptions.workerOptions;
+      logUnknownTails(
+        workerOptions.tails,
+        workerConfigs,
+        vitePreviewServer.config.logger.warn
+      );
+      return [
+        {
+          ...workerOptions,
+          name: workerOptions.name ?? workerConfig.name,
+          unsafeInspectorProxy: inspectorPort !== false,
+          unsafeDirectSockets: (
+            // This exposes the default entrypoint of the entry worker on the dev registry
+            // Assuming that the first worker config to be the entry worker.
+            i === 0 ? [{ entrypoint: void 0, proxy: true }] : []
+          ),
+          ...miniflareWorkerOptions.main ? getPreviewModules(miniflareWorkerOptions.main, modulesRules) : { modules: true, script: "" }
+        },
+        ...externalWorkers
+      ];
+    })
+  )).flat();
   const logger = new ViteMiniflareLogger(resolvedViteConfig);
   return {
     log: logger,
-    inspectorPort: inspectorPort || void 0,
+    inspectorPort: inspectorPort === false ? void 0 : inspectorPort,
     unsafeInspectorProxy: inspectorPort !== false,
+    unsafeDevRegistryPath: getDefaultDevRegistryPath(),
     handleRuntimeStdio(stdout, stderr) {
       const decoder = new TextDecoder();
       stdout.forEach((data2) => logger.info(decoder.decode(data2)));
@@ -13744,11 +13815,13 @@ function getPreviewMiniflareOptions(vitePreviewServer, workerConfigs, persistSta
         (error) => logger.logWithLevel(LogLevel.ERROR, decoder.decode(error))
       );
     },
-    ...getPersistence(resolvedViteConfig.root, persistState),
+    defaultPersistRoot: getPersistenceRoot(
+      resolvedViteConfig.root,
+      persistState
+    ),
     workers
   };
 }
-var removedMessages = [/^Ready on http/, /^Updated and ready on http/];
 var ViteMiniflareLogger = class extends Log {
   logger;
   constructor(config) {
@@ -13756,11 +13829,6 @@ var ViteMiniflareLogger = class extends Log {
     this.logger = config.logger;
   }
   logWithLevel(level, message) {
-    for (const removedMessage of removedMessages) {
-      if (removedMessage.test(message)) {
-        return;
-      }
-    }
     switch (level) {
       case LogLevel.ERROR:
         return this.logger.error(message);
@@ -13770,6 +13838,8 @@ var ViteMiniflareLogger = class extends Log {
         return this.logger.info(message);
     }
   }
+  logReady() {
+  }
 };
 function miniflareLogLevelFromViteLogLevel(level = "info") {
   switch (level) {
@@ -13783,13 +13853,32 @@ function miniflareLogLevelFromViteLogLevel(level = "info") {
       return LogLevel.NONE;
   }
 }
+var mixedModeSessionsMap = /* @__PURE__ */ new Map();
+async function maybeStartOrUpdateMixedModeSession(workerConfig) {
+  const workerRemoteBindings = experimental_pickRemoteBindings(
+    unstable_convertConfigBindingsToStartWorkerBindings(workerConfig) ?? {}
+  );
+  assert6(workerConfig.name, "Found workerConfig without a name");
+  let mixedModeSession = mixedModeSessionsMap.get(workerConfig.name);
+  if (mixedModeSession === void 0) {
+    if (Object.keys(workerRemoteBindings).length > 0) {
+      mixedModeSession = await experimental_startMixedModeSession(workerRemoteBindings);
+      mixedModeSessionsMap.set(workerConfig.name, mixedModeSession);
+    }
+  } else {
+    await mixedModeSession.updateBindings(workerRemoteBindings);
+  }
+  await mixedModeSession?.ready;
+  return mixedModeSession;
+}
 
 // src/plugin-config.ts
-import assert7 from "node:assert";
+import assert8 from "node:assert";
 import * as path8 from "node:path";
 import * as vite6 from "vite";
 
 // src/workers-configs.ts
+import assert7 from "node:assert";
 import * as fs4 from "node:fs";
 import * as path7 from "node:path";
 import { unstable_readConfig as unstable_readConfig2 } from "wrangler";
@@ -13823,8 +13912,7 @@ var nonApplicableWorkerConfigs = {
     "preserve_file_names",
     "rules",
     "site",
-    "tsconfig",
-    "upload_source_maps"
+    "tsconfig"
   ]
 };
 var nullableNonApplicable = [
@@ -13835,15 +13923,17 @@ var nullableNonApplicable = [
   "no_bundle",
   "preserve_file_names",
   "site",
-  "tsconfig",
-  "upload_source_maps"
+  "tsconfig"
 ];
-function readWorkerConfig(configPath, env2) {
+function readWorkerConfig(configPath, env2, mixedModeEnabled) {
   const nonApplicable = {
     replacedByVite: /* @__PURE__ */ new Set(),
     notRelevant: /* @__PURE__ */ new Set()
   };
-  const config = unstable_readConfig2({ config: configPath, env: env2 }, {});
+  const config = unstable_readConfig2(
+    { config: configPath, env: env2 },
+    { experimental: { mixedModeEnabled } }
+  );
   const raw = structuredClone(config);
   nullableNonApplicable.forEach((prop) => {
     if (config[prop] !== void 0) {
@@ -13938,11 +14028,15 @@ function isNotRelevant(configName) {
 function missingFieldErrorMessage(field, configPath, env2) {
   return `No ${field} field provided in '${configPath}'${env2 ? ` for '${env2}' environment` : ""}`;
 }
-function getWorkerConfig(configPath, env2, opts) {
+function getWorkerConfig(configPath, env2, mixedModeEnabled, opts) {
   if (opts?.visitedConfigPaths?.has(configPath)) {
     throw new Error(`Duplicate Wrangler config path found: ${configPath}`);
   }
-  const { raw, config, nonApplicable } = readWorkerConfig(configPath, env2);
+  const { raw, config, nonApplicable } = readWorkerConfig(
+    configPath,
+    env2,
+    mixedModeEnabled
+  );
   opts?.visitedConfigPaths?.add(configPath);
   if (!config.name) {
     throw new Error(missingFieldErrorMessage(`'name'`, configPath, env2));
@@ -13998,14 +14092,52 @@ function getWorkerConfig(configPath, env2, opts) {
     nonApplicable
   };
 }
+function getValidatedWranglerConfigPath(root, requestedConfigPath, isForAuxiliaryWorker = false) {
+  if (requestedConfigPath) {
+    const configPath2 = path7.resolve(root, requestedConfigPath);
+    const forAuxiliaryWorkerErrorMessage = isForAuxiliaryWorker ? " requested for one of your auxiliary workers" : "";
+    const errorMessagePrefix = `The provided configPath (${configPath2})${forAuxiliaryWorkerErrorMessage}`;
+    const fileExtension = path7.extname(configPath2).slice(1);
+    if (!allowedWranglerConfigExtensions.includes(fileExtension)) {
+      const foundExtensionMessage = !fileExtension ? "no extension found" : `"${fileExtension}" found`;
+      throw new Error(
+        `${errorMessagePrefix} doesn't point to a file with the correct file extension. It should point to a jsonc, json or toml file (${foundExtensionMessage} instead)`
+      );
+    }
+    const mainStat = fs4.statSync(configPath2, { throwIfNoEntry: false });
+    if (!mainStat) {
+      throw new Error(
+        `${errorMessagePrefix} doesn't point to an existing file`
+      );
+    }
+    if (mainStat.isDirectory()) {
+      throw new Error(
+        `${errorMessagePrefix} points to a directory. It should point to a file.`
+      );
+    }
+    return configPath2;
+  }
+  assert7(
+    isForAuxiliaryWorker === false,
+    "Unexpected Error: trying to find the wrangler config for an auxiliary worker"
+  );
+  const configPath = findWranglerConfig(root);
+  if (!configPath) {
+    throw new Error(
+      `No config file found in the ${root} directory. Please add a wrangler.(jsonc|json|toml) file.`
+    );
+  }
+  return configPath;
+}
 function findWranglerConfig(root) {
-  for (const extension of ["json", "jsonc", "toml"]) {
+  for (const extension of allowedWranglerConfigExtensions) {
     const configPath = path7.join(root, `wrangler.${extension}`);
     if (fs4.existsSync(configPath)) {
       return configPath;
     }
   }
 }
+var allowedWranglerConfigExtensions = ["jsonc", "json", "toml"];
 
 // src/plugin-config.ts
 function workerNameToEnvironmentName(workerName) {
@@ -14014,7 +14146,6 @@ function workerNameToEnvironmentName(workerName) {
 function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
   const configPaths = /* @__PURE__ */ new Set();
   const persistState = pluginConfig.persistState ?? true;
-  const inspectorPort = pluginConfig.inspectorPort ?? DEFAULT_INSPECTOR_PORT;
   const experimental = pluginConfig.experimental ?? {};
   const root = userConfig.root ? path8.resolve(userConfig.root) : process.cwd();
   const { CLOUDFLARE_ENV: cloudflareEnv } = vite6.loadEnv(
@@ -14023,22 +14154,24 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
     /* prefixes */
     ""
   );
-  const configPath = pluginConfig.configPath ? path8.resolve(root, pluginConfig.configPath) : findWranglerConfig(root);
-  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
-  });
+  const entryWorkerConfigPath = getValidatedWranglerConfigPath(
+    root,
+    pluginConfig.configPath
+  );
+  const entryWorkerResolvedConfig = getWorkerConfig(
+    entryWorkerConfigPath,
+    cloudflareEnv,
+    pluginConfig.experimental?.mixedMode ?? false,
+    {
+      visitedConfigPaths: configPaths,
+      isEntryWorker: true
+    }
+  );
   if (entryWorkerResolvedConfig.type === "assets-only") {
     return {
       type: "assets-only",
       config: entryWorkerResolvedConfig.config,
       configPaths,
-      inspectorPort,
       persistState,
       rawConfigs: {
         entryWorker: entryWorkerResolvedConfig
@@ -14054,15 +14187,21 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
   };
   const auxiliaryWorkersResolvedConfigs = [];
   for (const auxiliaryWorker of pluginConfig.auxiliaryWorkers ?? []) {
+    const workerConfigPath = getValidatedWranglerConfigPath(
+      root,
+      auxiliaryWorker.configPath,
+      true
+    );
     const workerResolvedConfig = getWorkerConfig(
-      path8.resolve(root, auxiliaryWorker.configPath),
+      workerConfigPath,
       cloudflareEnv,
+      pluginConfig.experimental?.mixedMode ?? false,
       {
         visitedConfigPaths: configPaths
       }
     );
     auxiliaryWorkersResolvedConfigs.push(workerResolvedConfig);
-    assert7(
+    assert8(
       workerResolvedConfig.type === "worker",
       "Unexpected error: received AssetsOnlyResult with auxiliary workers."
     );
@@ -14079,7 +14218,6 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
     type: "workers",
     configPaths,
     persistState,
-    inspectorPort,
     workers,
     entryWorkerEnvironmentName,
     rawConfigs: {
@@ -14092,6 +14230,7 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
 }
 
 // src/websockets.ts
+import { createHeaders } from "@mjackson/node-fetch-server";
 import { coupleWebSocket } from "miniflare";
 import { WebSocketServer } from "ws";
 function handleWebSocket(httpServer, getFetcher) {
@@ -14103,7 +14242,7 @@ function handleWebSocket(httpServer, getFetcher) {
       if (request.headers["sec-websocket-protocol"]?.startsWith("vite")) {
         return;
       }
-      const headers = nodeHeadersToWebHeaders(request.headers);
+      const headers = createHeaders(request);
       const fetcher = await getFetcher();
       const response = await fetcher(url, {
         headers,
@@ -14127,6 +14266,57 @@ function handleWebSocket(httpServer, getFetcher) {
   );
 }
 
+// src/worker-environments-validation.ts
+import assert9 from "node:assert";
+function validateWorkerEnvironmentsResolvedConfigs(resolvedPluginConfig, resolvedViteConfig) {
+  const workersEnvironmentNames = Object.keys(resolvedPluginConfig.workers);
+  const disallowedEnvsConfigs = /* @__PURE__ */ new Map();
+  for (const envName of workersEnvironmentNames) {
+    const workerEnvConfig = resolvedViteConfig.environments[envName];
+    assert9(workerEnvConfig, `Missing environment config for "${envName}"`);
+    const { optimizeDeps, resolve: resolve7 } = workerEnvConfig;
+    const disallowedConfig = {};
+    const disallowedOptimizeDepsExcludeEntries = (optimizeDeps.exclude ?? []).filter((entry) => {
+      if (cloudflareBuiltInModules.includes(entry)) {
+        return false;
+      }
+      if (isNodeAlsModule(entry) && isNodeAls(resolvedPluginConfig.workers[envName])) {
+        return false;
+      }
+      if (NODEJS_MODULES_RE.test(entry) && isNodeCompat(resolvedPluginConfig.workers[envName])) {
+        return false;
+      }
+      return true;
+    });
+    if (disallowedOptimizeDepsExcludeEntries.length > 0) {
+      disallowedConfig.optimizeDepsExclude = disallowedOptimizeDepsExcludeEntries;
+    }
+    if (resolve7.external === true || resolve7.external.length > 0) {
+      disallowedConfig.resolveExternal = resolve7.external;
+    }
+    if (Object.keys(disallowedConfig).length > 0) {
+      disallowedEnvsConfigs.set(envName, disallowedConfig);
+    }
+  }
+  if (disallowedEnvsConfigs.size > 0) {
+    const errorMessage = `The following environment configurations are incompatible with the Cloudflare Vite plugin:
+${[
+      ...disallowedEnvsConfigs
+    ].map(
+      ([envName, disallowedConfig]) => [
+        disallowedConfig.optimizeDepsExclude ? `	- "${envName}" environment: \`optimizeDeps.exclude\`: ${JSON.stringify(disallowedConfig.optimizeDepsExclude)}
+` : null,
+        disallowedConfig.resolveExternal ? `	- "${envName}" environment: \`resolve.external\`: ${JSON.stringify(disallowedConfig.resolveExternal)}
+` : null
+      ].join("")
+    ).join(
+      ""
+    )}To resolve this issue, avoid setting \`optimizeDeps.exclude\` and \`resolve.external\` in your Cloudflare Worker environments.
+`;
+    throw new Error(errorMessage);
+  }
+}
+
 // src/index.ts
 var workersConfigsWarningShown = false;
 var miniflare;
@@ -14197,7 +14387,7 @@ function cloudflare2(pluginConfig = {}) {
                   resolvedPluginConfig.workers
                 ).map((environmentName) => {
                   const environment = builder.environments[environmentName];
-                  assert8(
+                  assert10(
                     environment,
                     `${environmentName} environment not found`
                   );
@@ -14218,6 +14408,12 @@ function cloudflare2(pluginConfig = {}) {
       },
       configResolved(config) {
         resolvedViteConfig = config;
+        if (resolvedPluginConfig?.type === "workers") {
+          validateWorkerEnvironmentsResolvedConfigs(
+            resolvedPluginConfig,
+            resolvedViteConfig
+          );
+        }
       },
       generateBundle(_, bundle) {
         let config;
@@ -14238,7 +14434,7 @@ function cloudflare2(pluginConfig = {}) {
           if (isEntryWorker && hasClientBuild) {
             const workerOutputDirectory = this.environment.config.build.outDir;
             const clientOutputDirectory = resolvedViteConfig.environments.client?.build.outDir;
-            assert8(
+            assert10(
               clientOutputDirectory,
               "Unexpected error: client output directory is undefined"
             );
@@ -14302,78 +14498,104 @@ function cloudflare2(pluginConfig = {}) {
         }
       },
       hotUpdate(options) {
-        if (
-          // Vite normalizes `options.file` so we use `path.resolve` for Windows compatibility
-          resolvedPluginConfig.configPaths.has(path9.resolve(options.file)) || hasAssetsConfigChanged(
-            resolvedPluginConfig,
-            resolvedViteConfig,
-            options.file
-          )
-        ) {
+        const changedFilePath = path9.resolve(options.file);
+        if (resolvedPluginConfig.configPaths.has(changedFilePath) || hasDotDevDotVarsFileChanged(resolvedPluginConfig, changedFilePath) || hasAssetsConfigChanged(
+          resolvedPluginConfig,
+          resolvedViteConfig,
+          changedFilePath
+        )) {
           options.server.restart();
           return [];
         }
       },
       async configureServer(viteDevServer) {
-        assert8(
-          viteDevServer.httpServer,
-          "Unexpected error: No Vite HTTP server"
+        const inputInspectorPort = await getInputInspectorPortOption(
+          pluginConfig,
+          viteDevServer
         );
-        if (miniflare) {
-          await miniflare.setOptions(
-            getDevMiniflareOptions(resolvedPluginConfig, viteDevServer)
-          );
+        const miniflareDevOptions = await getDevMiniflareOptions(
+          resolvedPluginConfig,
+          viteDevServer,
+          inputInspectorPort
+        );
+        if (!miniflare) {
+          miniflare = new Miniflare(miniflareDevOptions);
         } else {
-          miniflare = new Miniflare(
-            getDevMiniflareOptions(resolvedPluginConfig, viteDevServer)
-          );
+          await miniflare.setOptions(miniflareDevOptions);
         }
         await initRunners(resolvedPluginConfig, viteDevServer, miniflare);
-        const middleware = createMiddleware(
-          async ({ request }) => {
-            assert8(miniflare, `Miniflare not defined`);
-            const routerWorker = await getRouterWorker(miniflare);
-            return routerWorker.fetch(toMiniflareRequest(request), {
-              redirect: "manual"
-            });
-          },
-          { alwaysCallNext: false }
-        );
-        handleWebSocket(viteDevServer.httpServer, async () => {
-          assert8(miniflare, `Miniflare not defined`);
-          const routerWorker = await getRouterWorker(miniflare);
-          return routerWorker.fetch;
-        });
+        if (viteDevServer.httpServer) {
+          handleWebSocket(viteDevServer.httpServer, async () => {
+            assert10(miniflare, `Miniflare not defined`);
+            const routerWorker = await miniflare.getWorker(ROUTER_WORKER_NAME);
+            return routerWorker.fetch;
+          });
+        }
         return () => {
-          viteDevServer.middlewares.use((req, res, next) => {
-            middleware(req, res, next);
+          viteDevServer.middlewares.use(async (req, res, next) => {
+            try {
+              assert10(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" }
+                );
+              } 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");
+              }
+              await sendResponse(res, response);
+            } catch (error) {
+              next(error);
+            }
           });
         };
       },
-      configurePreviewServer(vitePreviewServer) {
-        const workerConfigs = getWorkerConfigs(vitePreviewServer.config.root);
+      async configurePreviewServer(vitePreviewServer) {
+        const workerConfigs = getWorkerConfigs(
+          vitePreviewServer.config.root,
+          pluginConfig.experimental?.mixedMode ?? false
+        );
+        const inputInspectorPort = await getInputInspectorPortOption(
+          pluginConfig,
+          vitePreviewServer
+        );
         const miniflare2 = new Miniflare(
-          getPreviewMiniflareOptions(
+          await getPreviewMiniflareOptions(
             vitePreviewServer,
             workerConfigs,
             pluginConfig.persistState ?? true,
-            pluginConfig.inspectorPort
+            !!pluginConfig.experimental?.mixedMode,
+            inputInspectorPort
           )
         );
-        const middleware = createMiddleware(
-          ({ request }) => {
-            return miniflare2.dispatchFetch(toMiniflareRequest(request), {
-              redirect: "manual"
-            });
-          },
-          { alwaysCallNext: false }
-        );
         handleWebSocket(
           vitePreviewServer.httpServer,
           () => miniflare2.dispatchFetch
         );
-        vitePreviewServer.middlewares.use((req, res, next) => {
-          middleware(req, res, next);
+        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);
+          }
         });
       }
     },
@@ -14436,7 +14658,7 @@ function cloudflare2(pluginConfig = {}) {
         for (const match of matches) {
           magicString ??= new MagicString(code);
           const [full, _, modulePath] = match;
-          assert8(
+          assert10(
             modulePath,
             `Unexpected error: module path not found in reference ${full}.`
           );
@@ -14482,17 +14704,22 @@ function cloudflare2(pluginConfig = {}) {
       configEnvironment(name) {
         if (isNodeCompat(getWorkerConfig2(name))) {
           return {
+            build: {
+              rollupOptions: {
+                plugins: [
+                  replace({
+                    "process.env.NODE_ENV": JSON.stringify(
+                      process.env.NODE_ENV ?? "production"
+                    ),
+                    preventAssignment: true
+                  })
+                ]
+              }
+            },
             resolve: {
               builtins: [...nodeCompatExternals]
             },
             optimizeDeps: {
-              // This is a list of dependency entry-points that should be pre-bundled.
-              // In this case we provide a list of all the possible polyfills so that they are pre-bundled,
-              // ready ahead the first request to the dev server.
-              // Without this the dependency optimizer will try to bundle them on-the-fly in the middle of the first request,
-              // which can potentially cause problems if it leads to previous pre-bundling to become stale and needing to be reloaded.
-              // TODO: work out how to re-enable pre-bundling of these
-              // include: [...getNodeCompatEntries()],
               // This is a list of module specifiers that the dependency optimizer should not follow when doing import analysis.
               // In this case we provide a list of all the Node.js modules, both those built-in to workerd and those that will be polyfilled.
               // Obviously we don't want/need the optimizer to try to process modules that are built-in;
@@ -14516,7 +14743,7 @@ function cloudflare2(pluginConfig = {}) {
           return this.resolve(source, importer, options);
         }
         if (this.environment.mode === "dev") {
-          assert8(
+          assert10(
             this.environment.depsOptimizer,
             "depsOptimizer is required in dev mode"
           );
@@ -14530,11 +14757,54 @@ function cloudflare2(pluginConfig = {}) {
       },
       async transform(code, id) {
         const workerConfig = getWorkerConfig2(this.environment.name);
-        assert8(workerConfig, "Expected a worker config");
+        if (!workerConfig) {
+          return;
+        }
         const resolvedId = await this.resolve(workerConfig.main);
         if (id === resolvedId?.id) {
           return injectGlobalCode(id, code);
         }
+      },
+      async configureServer(viteDevServer) {
+        await Promise.all(
+          Object.values(viteDevServer.environments).flatMap(
+            async (environment) => {
+              const workerConfig = getWorkerConfig2(environment.name);
+              if (isNodeCompat(workerConfig)) {
+                await environment.depsOptimizer?.init();
+                return Array.from(nodeCompatEntries).map((entry) => {
+                  const result = resolveNodeJSImport(entry);
+                  if (result) {
+                    const registration = environment.depsOptimizer?.registerMissingImport(
+                      result.unresolved,
+                      result.resolved
+                    );
+                    return registration?.processing;
+                  }
+                });
+              }
+            }
+          )
+        );
+      }
+    },
+    // Plugin that handles Node.js Async Local Storage (ALS) compatibility support for Vite Environments that are hosted in Cloudflare Workers.
+    {
+      name: "vite-plugin-cloudflare:nodejs-als",
+      apply(_config, env2) {
+        return !env2.isPreview;
+      },
+      configEnvironment(name, config) {
+        if (isNodeAls(getWorkerConfig2(name))) {
+          return {
+            resolve: {
+              builtins: ["async_hooks", "node:async_hooks"]
+            },
+            optimizeDeps: {
+              exclude: ["async_hooks", "node:async_hooks"]
+            }
+          };
+        }
       }
     },
     // Plugin that provides an __debug path for debugging the Cloudflare Workers.
@@ -14544,39 +14814,38 @@ function cloudflare2(pluginConfig = {}) {
       //       the preview middleware here can take precedence
       enforce: "pre",
       configureServer(viteDevServer) {
-        if (resolvedPluginConfig.type === "workers" && resolvedPluginConfig.inspectorPort !== false) {
+        if (resolvedPluginConfig.type === "workers" && pluginConfig.inspectorPort !== false) {
           addDebugToVitePrintUrls(viteDevServer);
         }
         const workerNames = resolvedPluginConfig.type === "assets-only" ? [] : Object.values(resolvedPluginConfig.workers).map(
           (worker) => worker.name
         );
-        viteDevServer.middlewares.use((req, res, next) => {
-          if (req.url === debuggingPath && resolvedPluginConfig.inspectorPort !== false) {
-            const html = getDebugPathHtml(
-              workerNames,
-              resolvedPluginConfig.inspectorPort
-            );
+        viteDevServer.middlewares.use(async (req, res, next) => {
+          const resolvedInspectorPort = await getResolvedInspectorPort(pluginConfig);
+          if (req.url === debuggingPath && resolvedInspectorPort) {
+            const html = getDebugPathHtml(workerNames, resolvedInspectorPort);
             res.setHeader("Content-Type", "text/html");
             return res.end(html);
           }
           next();
         });
       },
-      configurePreviewServer(vitePreviewServer) {
-        const workerConfigs = getWorkerConfigs(vitePreviewServer.config.root);
+      async configurePreviewServer(vitePreviewServer) {
+        const workerConfigs = getWorkerConfigs(
+          vitePreviewServer.config.root,
+          pluginConfig.experimental?.mixedMode ?? false
+        );
         if (workerConfigs.length >= 1 && pluginConfig.inspectorPort !== false) {
           addDebugToVitePrintUrls(vitePreviewServer);
         }
         const workerNames = workerConfigs.map((worker) => {
-          assert8(worker.name, "Expected the Worker to have a name");
+          assert10(worker.name, "Expected the Worker to have a name");
           return worker.name;
         });
-        vitePreviewServer.middlewares.use((req, res, next) => {
-          if (req.url === debuggingPath && pluginConfig.inspectorPort !== false) {
-            const html = getDebugPathHtml(
-              workerNames,
-              pluginConfig.inspectorPort ?? DEFAULT_INSPECTOR_PORT
-            );
+        vitePreviewServer.middlewares.use(async (req, res, next) => {
+          const resolvedInspectorPort = await getResolvedInspectorPort(pluginConfig);
+          if (req.url === debuggingPath && resolvedInspectorPort) {
+            const html = getDebugPathHtml(workerNames, resolvedInspectorPort);
             res.setHeader("Content-Type", "text/html");
             return res.end(html);
           }
@@ -14590,6 +14859,9 @@ function cloudflare2(pluginConfig = {}) {
       apply(_config, env2) {
         return !env2.isPreview;
       },
+      // We must ensure that the `resolveId` hook runs before the built-in ones.
+      // Otherwise we never see the Node.js built-in imports since they get handled by default Vite behavior.
+      enforce: "pre",
       configEnvironment(environmentName) {
         const workerConfig = getWorkerConfig2(environmentName);
         if (workerConfig && !isNodeCompat(workerConfig)) {
@@ -14603,21 +14875,14 @@ function cloudflare2(pluginConfig = {}) {
                       build.onResolve(
                         { filter: NODEJS_MODULES_RE },
                         ({ path: path10, importer }) => {
+                          if (isNodeAls(workerConfig) && isNodeAlsModule(path10)) {
+                            return;
+                          }
                           const nodeJsCompatWarnings = nodeJsCompatWarningsMap.get(workerConfig);
-                          assert8(
-                            nodeJsCompatWarnings,
-                            `expected nodeJsCompatWarnings to be defined for Worker "${workerConfig.name}"`
-                          );
-                          nodeJsCompatWarnings.registerImport(path10, importer);
+                          nodeJsCompatWarnings?.registerImport(path10, importer);
                           return { path: path10, external: true };
                         }
                       );
-                      build.onEnd(() => {
-                        const nodeJsCompatWarnings = nodeJsCompatWarningsMap.get(workerConfig);
-                        if (nodeJsCompatWarnings) {
-                          nodeJsCompatWarnings.renderWarnings();
-                        }
-                      });
                     }
                   }
                 ]
@@ -14626,47 +14891,28 @@ function cloudflare2(pluginConfig = {}) {
           };
         }
       },
-      configureServer(viteDevServer) {
-        for (const environment of Object.values(viteDevServer.environments)) {
-          const workerConfig = getWorkerConfig2(environment.name);
+      configResolved(resolvedViteConfig2) {
+        for (const environmentName of Object.keys(
+          resolvedViteConfig2.environments
+        )) {
+          const workerConfig = getWorkerConfig2(environmentName);
           if (workerConfig && !isNodeCompat(workerConfig)) {
             nodeJsCompatWarningsMap.set(
               workerConfig,
-              new NodeJsCompatWarnings(environment)
+              new NodeJsCompatWarnings(environmentName, resolvedViteConfig2)
             );
           }
         }
       },
-      buildStart() {
-        const workerConfig = getWorkerConfig2(this.environment.name);
-        if (workerConfig && !isNodeCompat(workerConfig)) {
-          nodeJsCompatWarningsMap.set(
-            workerConfig,
-            new NodeJsCompatWarnings(this.environment)
-          );
-        }
-      },
-      buildEnd() {
-        const workerConfig = getWorkerConfig2(this.environment.name);
-        if (workerConfig && !isNodeCompat(workerConfig)) {
-          const nodeJsCompatWarnings = nodeJsCompatWarningsMap.get(workerConfig);
-          assert8(
-            nodeJsCompatWarnings,
-            `expected nodeJsCompatWarnings to be defined for Worker "${workerConfig.name}"`
-          );
-          nodeJsCompatWarnings.renderWarnings();
-        }
-      },
-      // We must ensure that the `resolveId` hook runs before the built-in ones otherwise we
-      // never see the Node.js built-in imports since they get handled by default Vite behavior.
-      enforce: "pre",
       async resolveId(source, importer) {
         const workerConfig = getWorkerConfig2(this.environment.name);
         if (workerConfig && !isNodeCompat(workerConfig)) {
+          if (isNodeAls(workerConfig) && isNodeAlsModule(source)) {
+            return;
+          }
           const nodeJsCompatWarnings = nodeJsCompatWarningsMap.get(workerConfig);
           if (nodejsBuiltins.has(source)) {
             nodeJsCompatWarnings?.registerImport(source, importer);
-            nodeJsCompatWarnings?.renderWarningsOnIdle();
             return {
               id: source,
               external: true
@@ -14677,10 +14923,35 @@ function cloudflare2(pluginConfig = {}) {
     }
   ];
   function getWorkerConfig2(environmentName) {
-    assert8(resolvedPluginConfig, "Expected resolvedPluginConfig to be defined");
+    assert10(resolvedPluginConfig, "Expected resolvedPluginConfig to be defined");
     return resolvedPluginConfig.type !== "assets-only" ? resolvedPluginConfig.workers[environmentName] : void 0;
   }
 }
+async function getInputInspectorPortOption(pluginConfig, viteServer) {
+  if (pluginConfig.inspectorPort === void 0 || pluginConfig.inspectorPort === 0) {
+    const resolvedInspectorPort = await getResolvedInspectorPort(pluginConfig);
+    if (resolvedInspectorPort !== null) {
+      return resolvedInspectorPort;
+    }
+  }
+  const inputInspectorPort = pluginConfig.inspectorPort ?? await getFirstAvailablePort(DEFAULT_INSPECTOR_PORT);
+  if (pluginConfig.inspectorPort === void 0 && inputInspectorPort !== DEFAULT_INSPECTOR_PORT) {
+    viteServer.config.logger.warn(
+      colors3.dim(
+        `Default inspector port ${DEFAULT_INSPECTOR_PORT} not available, using ${inputInspectorPort} instead
+`
+      )
+    );
+  }
+  return inputInspectorPort;
+}
+async function getResolvedInspectorPort(pluginConfig) {
+  if (miniflare && pluginConfig.inspectorPort !== false) {
+    const miniflareInspectorUrl = await miniflare.getInspectorURL();
+    return Number.parseInt(miniflareInspectorUrl.port);
+  }
+  return null;
+}
 function getDotDevDotVarsContent(configPath, cloudflareEnv) {
   const configDir = path9.dirname(configPath);
   const defaultDotDevDotVarsPath = `${configDir}/.dev.vars`;
@@ -14692,6 +14963,19 @@ function getDotDevDotVarsContent(configPath, cloudflareEnv) {
   }
   return null;
 }
+function hasDotDevDotVarsFileChanged(resolvedPluginConfig, changedFilePath) {
+  return [...resolvedPluginConfig.configPaths].some((configPath) => {
+    const dotDevDotVars = path9.join(path9.dirname(configPath), ".dev.vars");
+    if (dotDevDotVars === changedFilePath) {
+      return true;
+    }
+    if (resolvedPluginConfig.cloudflareEnv) {
+      const dotDevDotVarsForEnv = `${dotDevDotVars}.${resolvedPluginConfig.cloudflareEnv}`;
+      return dotDevDotVarsForEnv === changedFilePath;
+    }
+    return false;
+  });
+}
 export {
   cloudflare2 as cloudflare
 };