@cloudflare/vite-plugin 0.0.0-070ceaef9 → 0.0.0-078c568c2

package/dist/index.js

@@ -248,17 +248,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path9, originalPath, doThrow) => {
-      if (!isString(path9)) {
+    var checkPath = (path10, originalPath, doThrow) => {
+      if (!isString(path10)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path9) {
+      if (!path10) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path9)) {
+      if (checkPath.isNotRelative(path10)) {
         const r2 = "`path.relative()`d";
         return doThrow(
           `path should be a ${r2} string, but got "${originalPath}"`,
@@ -267,7 +267,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path9) => REGEX_TEST_INVALID_PATH.test(path9);
+    var isNotRelative = (path10) => REGEX_TEST_INVALID_PATH.test(path10);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore = class {
@@ -326,7 +326,7 @@ var require_ignore = __commonJS({
       //   setting `checkUnignored` to `false` could reduce additional
       //   path matching.
       // @returns {TestResult} true if a file is ignored
-      _testOne(path9, checkUnignored) {
+      _testOne(path10, checkUnignored) {
         let ignored = false;
         let unignored = false;
         this._rules.forEach((rule) => {
@@ -334,7 +334,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule.regex.test(path9);
+          const matched = rule.regex.test(path10);
           if (matched) {
             ignored = !negative;
             unignored = negative;
@@ -347,24 +347,24 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache2, checkUnignored, slices) {
-        const path9 = originalPath && checkPath.convert(originalPath);
+        const path10 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path9,
+          path10,
           originalPath,
           this._allowRelativePaths ? RETURN_FALSE : throwError
         );
-        return this._t(path9, cache2, checkUnignored, slices);
+        return this._t(path10, cache2, checkUnignored, slices);
       }
-      _t(path9, cache2, checkUnignored, slices) {
-        if (path9 in cache2) {
-          return cache2[path9];
+      _t(path10, cache2, checkUnignored, slices) {
+        if (path10 in cache2) {
+          return cache2[path10];
         }
         if (!slices) {
-          slices = path9.split(SLASH);
+          slices = path10.split(SLASH);
         }
         slices.pop();
         if (!slices.length) {
-          return cache2[path9] = this._testOne(path9, checkUnignored);
+          return cache2[path10] = this._testOne(path10, checkUnignored);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -372,24 +372,24 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache2[path9] = parent.ignored ? parent : this._testOne(path9, checkUnignored);
+        return cache2[path10] = parent.ignored ? parent : this._testOne(path10, checkUnignored);
       }
-      ignores(path9) {
-        return this._test(path9, this._ignoreCache, false).ignored;
+      ignores(path10) {
+        return this._test(path10, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path9) => !this.ignores(path9);
+        return (path10) => !this.ignores(path10);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path9) {
-        return this._test(path9, this._testCache, true);
+      test(path10) {
+        return this._test(path10, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore(options);
-    var isPathValid = (path9) => checkPath(path9 && checkPath.convert(path9), path9, RETURN_FALSE);
+    var isPathValid = (path10) => checkPath(path10 && checkPath.convert(path10), path10, RETURN_FALSE);
     factory.isPathValid = isPathValid;
     factory.default = factory;
     module.exports = factory;
@@ -400,7 +400,7 @@ var require_ignore = __commonJS({
       const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
       checkPath.convert = makePosix;
       const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-      checkPath.isNotRelative = (path9) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path9) || isNotRelative(path9);
+      checkPath.isNotRelative = (path10) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path10) || isNotRelative(path10);
     }
   }
 });
@@ -443,11 +443,11 @@ var require_Mime = __commonJS({
         }
       }
     };
-    Mime.prototype.getType = function(path9) {
-      path9 = String(path9);
-      let last = path9.replace(/^.*[/\\]/, "").toLowerCase();
+    Mime.prototype.getType = function(path10) {
+      path10 = String(path10);
+      let last = path10.replace(/^.*[/\\]/, "").toLowerCase();
       let ext = last.replace(/^.*\./, "").toLowerCase();
-      let hasPath = last.length < path9.length;
+      let hasPath = last.length < path10.length;
       let hasDot = ext.length < last.length - 1;
       return (hasDot || !hasPath) && this._types[ext] || null;
     };
@@ -485,12 +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 { builtinModules as builtinModules2 } from "node:module";
-import * as path8 from "node:path";
+import * as path9 from "node:path";
 import { createMiddleware } from "@hattip/adapter-node";
+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);
@@ -1558,7 +1558,8 @@ var MagicString = class _MagicString {
 
 // src/index.ts
 import { Miniflare } from "miniflare";
-import * as vite6 from "vite";
+import colors3 from "picocolors";
+import * as vite7 from "vite";
 
 // src/constants.ts
 var ROUTER_WORKER_NAME = "__router-worker__";
@@ -1726,11 +1727,11 @@ ${invalidHeaderRulesList}`
 }
 
 // ../workers-shared/utils/configuration/validateURL.ts
-var extractPathname = (path9 = "/", includeSearch, includeHash) => {
-  if (!path9.startsWith("/")) {
-    path9 = `/${path9}`;
+var extractPathname = (path10 = "/", includeSearch, includeHash) => {
+  if (!path10.startsWith("/")) {
+    path10 = `/${path10}`;
   }
-  const url = new URL(`//${path9}`, "relative://");
+  const url = new URL(`//${path10}`, "relative://");
   return `${url.pathname}${includeSearch ? url.search : ""}${includeHash ? url.hash : ""}`;
 };
 var URL_REGEX = /^https:\/\/+(?<host>[^/]+)\/?(?<path>.*)/;
@@ -1763,8 +1764,8 @@ var validateUrl = (token, onlyRelative = false, disallowPorts = false, includeSe
     if (!token.startsWith("/") && onlyRelative) {
       token = `/${token}`;
     }
-    const path9 = PATH_REGEX.exec(token);
-    if (path9) {
+    const path10 = PATH_REGEX.exec(token);
+    if (path10) {
       try {
         return [extractPathname(token, includeSearch, includeHash), void 0];
       } catch {
@@ -1825,7 +1826,7 @@ function parseHeaders(input, {
           });
         }
       }
-      const [path9, pathError] = validateUrl(line, false, true);
+      const [path10, pathError] = validateUrl(line, false, true);
       if (pathError) {
         invalid.push({
           line,
@@ -1836,7 +1837,7 @@ function parseHeaders(input, {
         continue;
       }
       rule = {
-        path: path9,
+        path: path10,
         line,
         headers: {},
         unsetHeaders: []
@@ -2411,8 +2412,8 @@ function getErrorMap() {
   return overrideErrorMap;
 }
 var makeIssue = (params) => {
-  const { data: data2, path: path9, errorMaps, issueData } = params;
-  const fullPath = [...path9, ...issueData.path || []];
+  const { data: data2, path: path10, errorMaps, issueData } = params;
+  const fullPath = [...path10, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -2511,11 +2512,11 @@ var errorUtil;
   errorUtil2.toString = (message) => typeof message === "string" ? message : message === null || message === void 0 ? void 0 : message.message;
 })(errorUtil || (errorUtil = {}));
 var ParseInputLazyPath = class {
-  constructor(parent, value, path9, key) {
+  constructor(parent, value, path10, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path9;
+    this._path = path10;
     this._key = key;
   }
   get path() {
@@ -5783,7 +5784,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(),
@@ -5831,14 +5833,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;
@@ -5905,10 +5907,12 @@ function getHeadersConfigPath(config) {
 
 // src/cloudflare-environment.ts
 import assert3 from "node:assert";
-import * as vite2 from "vite";
+import * as vite3 from "vite";
 
 // src/node-js-compat.ts
 import assert2 from "node:assert";
+import { builtinModules as builtinModules2 } from "node:module";
+import path3 from "node:path";
 import { cloudflare } from "@cloudflare/unenv-preset";
 import { getNodeCompat } from "miniflare";
 
@@ -11460,17 +11464,17 @@ function withTrailingSlash(input = "", respectQueryAndFragment) {
   if (hasTrailingSlash(input, true)) {
     return input || "/";
   }
-  let path9 = input;
+  let path10 = input;
   let fragment = "";
   const fragmentIndex = input.indexOf("#");
   if (fragmentIndex >= 0) {
-    path9 = input.slice(0, fragmentIndex);
+    path10 = input.slice(0, fragmentIndex);
     fragment = input.slice(fragmentIndex);
-    if (!path9) {
+    if (!path10) {
       return fragment;
     }
   }
-  const [s0, ...s] = path9.split("?");
+  const [s0, ...s] = path10.split("?");
   return s0 + "/" + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
 }
 function isNonEmptyURL(url) {
@@ -11504,8 +11508,8 @@ import path2, { dirname as dirname2 } from "node:path";
 import v8 from "node:v8";
 import { format as format2, inspect } from "node:util";
 var BUILTIN_MODULES = new Set(builtinModules);
-function normalizeSlash(path9) {
-  return path9.replace(/\\/g, "/");
+function normalizeSlash(path10) {
+  return path10.replace(/\\/g, "/");
 }
 var own$1 = {}.hasOwnProperty;
 var classRegExp = /^([A-Z][a-z\d]*)+$/;
@@ -11618,8 +11622,8 @@ codes.ERR_INVALID_PACKAGE_CONFIG = createError(
    * @param {string} [base]
    * @param {string} [message]
    */
-  (path9, base, message) => {
-    return `Invalid package config ${path9}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
+  (path10, base, message) => {
+    return `Invalid package config ${path10}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
   },
   Error
 );
@@ -11651,8 +11655,8 @@ codes.ERR_MODULE_NOT_FOUND = createError(
    * @param {string} base
    * @param {boolean} [exactUrl]
    */
-  (path9, base, exactUrl = false) => {
-    return `Cannot find ${exactUrl ? "module" : "package"} '${path9}' imported from ${base}`;
+  (path10, base, exactUrl = false) => {
+    return `Cannot find ${exactUrl ? "module" : "package"} '${path10}' imported from ${base}`;
   },
   Error
 );
@@ -11703,8 +11707,8 @@ codes.ERR_UNKNOWN_FILE_EXTENSION = createError(
    * @param {string} extension
    * @param {string} path
    */
-  (extension, path9) => {
-    return `Unknown file extension "${extension}" for ${path9}`;
+  (extension, path10) => {
+    return `Unknown file extension "${extension}" for ${path10}`;
   },
   TypeError
 );
@@ -12076,9 +12080,9 @@ Default "index" lookups for the main are deprecated for ES modules.`,
     );
   }
 }
-function tryStatSync(path9) {
+function tryStatSync(path10) {
   try {
-    return statSync(path9);
+    return statSync(path10);
   } catch {
   }
 }
@@ -12845,12 +12849,20 @@ function resolvePathSync(id, options) {
 
 // src/node-js-compat.ts
 import { defineEnv } from "unenv";
+import "vite";
 var { env } = defineEnv({
   nodeCompat: true,
   presets: [cloudflare]
 });
 var nodeCompatExternals = new Set(env.external);
 var nodeCompatEntries = getNodeCompatEntries();
+var nodejsBuiltins = /* @__PURE__ */ new Set([
+  ...builtinModules2,
+  ...builtinModules2.map((m) => `node:${m}`)
+]);
+var NODEJS_MODULES_RE = new RegExp(
+  `^(node:)?(${builtinModules2.join("|")})$`
+);
 function isNodeCompat(workerConfig) {
   if (workerConfig === void 0) {
     return false;
@@ -12869,6 +12881,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") {
@@ -12899,7 +12920,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 })
@@ -12929,6 +12950,45 @@ function getNodeCompatEntries() {
   nodeCompatExternals.forEach((external) => entries.delete(external));
   return entries;
 }
+var NodeJsCompatWarnings = class {
+  constructor(environmentName, resolvedViteConfig) {
+    this.environmentName = environmentName;
+    this.resolvedViteConfig = resolvedViteConfig;
+  }
+  sources = /* @__PURE__ */ new Map();
+  timer;
+  registerImport(source, importer = "<unknown>") {
+    const importers = this.sources.get(source) ?? /* @__PURE__ */ new Set();
+    this.sources.set(source, importers);
+    importers.add(importer);
+    this.renderWarningsOnIdle();
+  }
+  renderWarningsOnIdle() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+    }
+    this.timer = setTimeout(() => {
+      this.renderWarnings();
+      this.timer = void 0;
+    }, 500);
+  }
+  renderWarnings() {
+    if (this.sources.size > 0) {
+      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.resolvedViteConfig.root, importer)}"
+`;
+        });
+      });
+      this.resolvedViteConfig.logger.warn(message, {
+        timestamp: true
+      });
+      this.sources.clear();
+    }
+  }
+};
 
 // src/shared.ts
 var UNKNOWN_HOST = "http://localhost";
@@ -12942,17 +13002,22 @@ var additionalModuleGlobalRE = new RegExp(
 var VITE_DEV_METADATA_HEADER = "__VITE_DEV_METADATA__";
 
 // src/utils.ts
-import * as path3 from "node:path";
+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 ?? path3.join(rootOutputDirectory, environmentName);
+  return userConfig.environments?.[environmentName]?.build?.outDir ?? path4.join(rootOutputDirectory, environmentName);
 }
-function getRouterWorker(miniflare) {
-  return miniflare.getWorker(ROUTER_WORKER_NAME);
+function getRouterWorker(miniflare2) {
+  return miniflare2.getWorker(ROUTER_WORKER_NAME);
 }
 function toMiniflareRequest(request) {
+  const host = request.headers.get("Host");
+  if (host) {
+    request.headers.set("X-Forwarded-Host", host);
+  }
   const secFetchMode = request.headers.get("Sec-Fetch-Mode");
   if (secFetchMode) {
     request.headers.set("X-Mf-Sec-Fetch-Mode", secFetchMode);
@@ -12981,6 +13046,9 @@ 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";
@@ -13026,7 +13094,7 @@ function createHotChannel(webSocketContainer) {
     }
   };
 }
-var CloudflareDevEnvironment = class extends vite2.DevEnvironment {
+var CloudflareDevEnvironment = class extends vite3.DevEnvironment {
   #webSocketContainer;
   #worker;
   constructor(name, config) {
@@ -13087,7 +13155,7 @@ function createCloudflareEnvironmentOptions(workerConfig, userConfig, environmen
     },
     build: {
       createEnvironment(name, config) {
-        return new vite2.BuildEnvironment(name, config);
+        return new vite3.BuildEnvironment(name, config);
       },
       target,
       // We need to enable `emitAssets` in order to support additional modules defined by `rules`
@@ -13130,14 +13198,14 @@ function createCloudflareEnvironmentOptions(workerConfig, userConfig, environmen
     keepProcessEnv: isNodeCompat(workerConfig)
   };
 }
-function initRunners(resolvedPluginConfig, viteDevServer, miniflare) {
+function initRunners(resolvedPluginConfig, viteDevServer, miniflare2) {
   if (resolvedPluginConfig.type === "assets-only") {
     return;
   }
   return Promise.all(
     Object.entries(resolvedPluginConfig.workers).map(
       async ([environmentName, workerConfig]) => {
-        const worker = await miniflare.getWorker(workerConfig.name);
+        const worker = await miniflare2.getWorker(workerConfig.name);
         return viteDevServer.environments[environmentName].initRunner(worker, viteDevServer.config.root, workerConfig);
       }
     )
@@ -13196,11 +13264,11 @@ function getDebugPathHtml(workerNames, inspectorPort) {
 // src/deploy-config.ts
 import assert5 from "node:assert";
 import * as fs2 from "node:fs";
-import * as path4 from "node:path";
+import * as path5 from "node:path";
 import "vite";
 import { unstable_readConfig } from "wrangler";
 function getDeployConfigPath(root) {
-  return path4.resolve(root, ".wrangler", "deploy", "config.json");
+  return path5.resolve(root, ".wrangler", "deploy", "config.json");
 }
 function getWorkerConfigs(root) {
   const deployConfigPath = getDeployConfigPath(root);
@@ -13211,22 +13279,22 @@ function getWorkerConfigs(root) {
     { configPath: deployConfig.configPath },
     ...deployConfig.auxiliaryWorkers
   ].map(({ configPath }) => {
-    const resolvedConfigPath = path4.resolve(
-      path4.dirname(deployConfigPath),
+    const resolvedConfigPath = path5.resolve(
+      path5.dirname(deployConfigPath),
       configPath
     );
     return unstable_readConfig({ config: resolvedConfigPath });
   });
 }
 function getRelativePathToWorkerConfig(deployConfigDirectory, root, outputDirectory) {
-  return path4.relative(
+  return path5.relative(
     deployConfigDirectory,
-    path4.resolve(root, outputDirectory, "wrangler.json")
+    path5.resolve(root, outputDirectory, "wrangler.json")
   );
 }
 function writeDeployConfig(resolvedPluginConfig, resolvedViteConfig) {
   const deployConfigPath = getDeployConfigPath(resolvedViteConfig.root);
-  const deployConfigDirectory = path4.dirname(deployConfigPath);
+  const deployConfigDirectory = path5.dirname(deployConfigPath);
   fs2.mkdirSync(deployConfigDirectory, { recursive: true });
   if (resolvedPluginConfig.type === "assets-only") {
     const clientOutputDirectory = resolvedViteConfig.environments.client?.build.outDir;
@@ -13279,7 +13347,7 @@ function writeDeployConfig(resolvedPluginConfig, resolvedViteConfig) {
 import assert6 from "node:assert";
 import * as fs3 from "node:fs";
 import * as fsp from "node:fs/promises";
-import * as path5 from "node:path";
+import * as path6 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import {
   kCurrentWorker,
@@ -13287,6 +13355,7 @@ import {
   LogLevel,
   Response as MiniflareResponse
 } from "miniflare";
+import colors2 from "picocolors";
 import { globSync } from "tinyglobby";
 import "vite";
 import { unstable_getMiniflareWorkerOptions } from "wrangler";
@@ -13295,18 +13364,18 @@ function getPersistence(root, persistState) {
     return {};
   }
   const defaultPersistPath = ".wrangler/state";
-  const persistPath = path5.resolve(
+  const persistPath = path6.resolve(
     root,
     typeof persistState === "object" ? persistState.path : defaultPersistPath,
     "v3"
   );
   return {
-    cachePersist: path5.join(persistPath, "cache"),
-    d1Persist: path5.join(persistPath, "d1"),
-    durableObjectsPersist: path5.join(persistPath, "do"),
-    kvPersist: path5.join(persistPath, "kv"),
-    r2Persist: path5.join(persistPath, "r2"),
-    workflowsPersist: path5.join(persistPath, "workflows")
+    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")
   };
 }
 function missingWorkerErrorMessage(workerName) {
@@ -13391,7 +13460,30 @@ function getEntryWorkerConfig(resolvedPluginConfig) {
   }
   return resolvedPluginConfig.workers[resolvedPluginConfig.entryWorkerEnvironmentName];
 }
-function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
+function filterTails(tails, userWorkers, log) {
+  return tails?.filter((tailService) => {
+    let name;
+    if (typeof tailService === "string") {
+      name = tailService;
+    } else if (typeof tailService === "object" && "name" in tailService && typeof tailService.name === "string") {
+      name = tailService.name;
+    } else {
+      return true;
+    }
+    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 if you'd like to simulate receiving tail events locally.`
+          )
+        )
+      );
+    }
+    return found;
+  });
+}
+function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspectorPort) {
   const resolvedViteConfig = viteDevServer.config;
   const entryWorkerConfig = getEntryWorkerConfig(resolvedPluginConfig);
   const assetsConfig = getAssetsConfig(
@@ -13407,7 +13499,7 @@ function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
       modules: [
         {
           type: "ESModule",
-          path: path5.join(miniflareModulesRoot, ROUTER_WORKER_PATH),
+          path: path6.join(miniflareModulesRoot, ROUTER_WORKER_PATH),
           contents: fs3.readFileSync(
             fileURLToPath2(new URL(ROUTER_WORKER_PATH, import.meta.url))
           )
@@ -13430,7 +13522,7 @@ function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
       modules: [
         {
           type: "ESModule",
-          path: path5.join(miniflareModulesRoot, ASSET_WORKER_PATH),
+          path: path6.join(miniflareModulesRoot, ASSET_WORKER_PATH),
           contents: fs3.readFileSync(
             fileURLToPath2(new URL(ASSET_WORKER_PATH, import.meta.url))
           )
@@ -13442,7 +13534,7 @@ function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
       serviceBindings: {
         __VITE_ASSET_EXISTS__: async (request) => {
           const { pathname } = new URL(request.url);
-          const filePath = path5.join(resolvedViteConfig.root, pathname);
+          const filePath = path6.join(resolvedViteConfig.root, pathname);
           let exists;
           try {
             exists = fs3.statSync(filePath).isFile();
@@ -13453,7 +13545,7 @@ function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
         },
         __VITE_FETCH_ASSET__: async (request) => {
           const { pathname } = new URL(request.url);
-          const filePath = path5.join(resolvedViteConfig.root, pathname);
+          const filePath = path6.join(resolvedViteConfig.root, pathname);
           try {
             let html = await fsp.readFile(filePath, "utf-8");
             html = await viteDevServer.transformIndexHtml(pathname, html);
@@ -13483,7 +13575,7 @@ function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
         worker: {
           ...workerOptions,
           name: workerOptions.name ?? workerConfig.name,
-          unsafeInspectorProxy: resolvedPluginConfig.inspectorPort !== false,
+          unsafeInspectorProxy: inspectorPort !== false,
           modulesRoot: miniflareModulesRoot,
           unsafeEvalBinding: "__VITE_UNSAFE_EVAL__",
           serviceBindings: {
@@ -13525,8 +13617,8 @@ function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
   const logger = new ViteMiniflareLogger(resolvedViteConfig);
   return {
     log: logger,
-    inspectorPort: resolvedPluginConfig.inspectorPort || void 0,
-    unsafeInspectorProxy: resolvedPluginConfig.inspectorPort !== false,
+    inspectorPort: inspectorPort === false ? void 0 : inspectorPort,
+    unsafeInspectorProxy: inspectorPort !== false,
     handleRuntimeStdio(stdout, stderr) {
       const decoder = new TextDecoder();
       stdout.forEach((data2) => logger.info(decoder.decode(data2)));
@@ -13582,15 +13674,20 @@ function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
         }
         return {
           ...workerOptions,
+          tails: filterTails(
+            workerOptions.tails,
+            userWorkers,
+            viteDevServer.config.logger.warn
+          ),
           modules: [
             {
               type: "ESModule",
-              path: path5.join(miniflareModulesRoot, WRAPPER_PATH),
+              path: path6.join(miniflareModulesRoot, WRAPPER_PATH),
               contents: wrappers.join("\n")
             },
             {
               type: "ESModule",
-              path: path5.join(miniflareModulesRoot, RUNNER_PATH),
+              path: path6.join(miniflareModulesRoot, RUNNER_PATH),
               contents: fs3.readFileSync(
                 fileURLToPath2(new URL(RUNNER_PATH, import.meta.url))
               )
@@ -13645,8 +13742,8 @@ function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
 }
 function getPreviewModules(main, modulesRules) {
   assert6(modulesRules, `Unexpected error: 'modulesRules' is undefined`);
-  const rootPath = path5.dirname(main);
-  const entryPath = path5.basename(main);
+  const rootPath = path6.dirname(main);
+  const entryPath = path6.basename(main);
   return {
     rootPath,
     modules: [
@@ -13655,15 +13752,15 @@ function getPreviewModules(main, modulesRules) {
         path: entryPath
       },
       ...modulesRules.flatMap(
-        ({ type, include }) => globSync(include, { cwd: rootPath, ignore: entryPath }).map((path9) => ({
+        ({ type, include }) => globSync(include, { cwd: rootPath, ignore: entryPath }).map((path10) => ({
           type,
-          path: path9
+          path: path10
         }))
       )
     ]
   };
 }
-function getPreviewMiniflareOptions(vitePreviewServer, workerConfigs, persistState, inspectorPort = DEFAULT_INSPECTOR_PORT) {
+function getPreviewMiniflareOptions(vitePreviewServer, workerConfigs, persistState, inspectorPort) {
   const resolvedViteConfig = vitePreviewServer.config;
   const workers = workerConfigs.flatMap((config) => {
     const miniflareWorkerOptions = unstable_getMiniflareWorkerOptions(config);
@@ -13672,6 +13769,11 @@ function getPreviewMiniflareOptions(vitePreviewServer, workerConfigs, persistSta
     return [
       {
         ...workerOptions,
+        tails: filterTails(
+          workerOptions.tails,
+          workerConfigs,
+          vitePreviewServer.config.logger.warn
+        ),
         name: workerOptions.name ?? config.name,
         unsafeInspectorProxy: inspectorPort !== false,
         ...miniflareWorkerOptions.main ? getPreviewModules(miniflareWorkerOptions.main, modulesRules) : { modules: true, script: "" }
@@ -13682,7 +13784,7 @@ function getPreviewMiniflareOptions(vitePreviewServer, workerConfigs, persistSta
   const logger = new ViteMiniflareLogger(resolvedViteConfig);
   return {
     log: logger,
-    inspectorPort: inspectorPort || void 0,
+    inspectorPort: inspectorPort === false ? void 0 : inspectorPort,
     unsafeInspectorProxy: inspectorPort !== false,
     handleRuntimeStdio(stdout, stderr) {
       const decoder = new TextDecoder();
@@ -13695,6 +13797,7 @@ function getPreviewMiniflareOptions(vitePreviewServer, workerConfigs, persistSta
     workers
   };
 }
+var removedMessages = [/^Ready on http/, /^Updated and ready on http/];
 var ViteMiniflareLogger = class extends Log {
   logger;
   constructor(config) {
@@ -13702,8 +13805,10 @@ var ViteMiniflareLogger = class extends Log {
     this.logger = config.logger;
   }
   logWithLevel(level, message) {
-    if (/^Ready on http/.test(message)) {
-      level = LogLevel.DEBUG;
+    for (const removedMessage of removedMessages) {
+      if (removedMessage.test(message)) {
+        return;
+      }
     }
     switch (level) {
       case LogLevel.ERROR:
@@ -13729,13 +13834,14 @@ function miniflareLogLevelFromViteLogLevel(level = "info") {
 }
 
 // src/plugin-config.ts
-import assert7 from "node:assert";
-import * as path7 from "node:path";
-import * as vite5 from "vite";
+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 path6 from "node:path";
+import * as path7 from "node:path";
 import { unstable_readConfig as unstable_readConfig2 } from "wrangler";
 var nonApplicableWorkerConfigs = {
   /**
@@ -13767,8 +13873,7 @@ var nonApplicableWorkerConfigs = {
     "preserve_file_names",
     "rules",
     "site",
-    "tsconfig",
-    "upload_source_maps"
+    "tsconfig"
   ]
 };
 var nullableNonApplicable = [
@@ -13779,8 +13884,7 @@ var nullableNonApplicable = [
   "no_bundle",
   "preserve_file_names",
   "site",
-  "tsconfig",
-  "upload_source_maps"
+  "tsconfig"
 ];
 function readWorkerConfig(configPath, env2) {
   const nonApplicable = {
@@ -13829,7 +13933,7 @@ function getWarningForWorkersConfigs(configs) {
     const lines2 = [
       `
 
-\x1B[43mWARNING\x1B[0m: your worker config${configs.entryWorker.config.configPath ? ` (at \`${path6.relative("", configs.entryWorker.config.configPath)}\`)` : ""} contains the following configuration options which are ignored since they are not applicable when using Vite:`
+\x1B[43mWARNING\x1B[0m: your worker config${configs.entryWorker.config.configPath ? ` (at \`${path7.relative("", configs.entryWorker.config.configPath)}\`)` : ""} contains the following configuration options which are ignored since they are not applicable when using Vite:`
     ];
     nonApplicableLines.forEach((line) => lines2.push(line));
     lines2.push("");
@@ -13843,7 +13947,7 @@ function getWarningForWorkersConfigs(configs) {
     );
     if (nonApplicableLines.length > 0) {
       lines.push(
-        `  - (${isEntryWorker ? "entry" : "auxiliary"}) worker${workerConfig.config.name ? ` "${workerConfig.config.name}"` : ""}${workerConfig.config.configPath ? ` (config at \`${path6.relative("", workerConfig.config.configPath)}\`)` : ""}`
+        `  - (${isEntryWorker ? "entry" : "auxiliary"}) worker${workerConfig.config.name ? ` "${workerConfig.config.name}"` : ""}${workerConfig.config.configPath ? ` (config at \`${path7.relative("", workerConfig.config.configPath)}\`)` : ""}`
       );
       nonApplicableLines.forEach((line) => lines.push(line));
     }
@@ -13942,14 +14046,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"]) {
-    const configPath = path6.join(root, `wrangler.${extension}`);
+  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) {
@@ -13958,31 +14100,31 @@ 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 ? path7.resolve(userConfig.root) : process.cwd();
-  const { CLOUDFLARE_ENV: cloudflareEnv } = vite5.loadEnv(
+  const root = userConfig.root ? path8.resolve(userConfig.root) : process.cwd();
+  const { CLOUDFLARE_ENV: cloudflareEnv } = vite6.loadEnv(
     viteEnv.mode,
     root,
     /* prefixes */
     ""
   );
-  const configPath = pluginConfig.configPath ? path7.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,
+    {
+      visitedConfigPaths: configPaths,
+      isEntryWorker: true
+    }
+  );
   if (entryWorkerResolvedConfig.type === "assets-only") {
     return {
       type: "assets-only",
       config: entryWorkerResolvedConfig.config,
       configPaths,
-      inspectorPort,
       persistState,
       rawConfigs: {
         entryWorker: entryWorkerResolvedConfig
@@ -13998,15 +14140,20 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
   };
   const auxiliaryWorkersResolvedConfigs = [];
   for (const auxiliaryWorker of pluginConfig.auxiliaryWorkers ?? []) {
+    const workerConfigPath = getValidatedWranglerConfigPath(
+      root,
+      auxiliaryWorker.configPath,
+      true
+    );
     const workerResolvedConfig = getWorkerConfig(
-      path7.resolve(root, auxiliaryWorker.configPath),
+      workerConfigPath,
       cloudflareEnv,
       {
         visitedConfigPaths: configPaths
       }
     );
     auxiliaryWorkersResolvedConfigs.push(workerResolvedConfig);
-    assert7(
+    assert8(
       workerResolvedConfig.type === "worker",
       "Unexpected error: received AssetsOnlyResult with auxiliary workers."
     );
@@ -14023,7 +14170,6 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
     type: "workers",
     configPaths,
     persistState,
-    inspectorPort,
     workers,
     entryWorkerEnvironmentName,
     rawConfigs: {
@@ -14038,7 +14184,7 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
 // src/websockets.ts
 import { coupleWebSocket } from "miniflare";
 import { WebSocketServer } from "ws";
-function handleWebSocket(httpServer, fetcher) {
+function handleWebSocket(httpServer, getFetcher) {
   const nodeWebSocket = new WebSocketServer({ noServer: true });
   httpServer.on(
     "upgrade",
@@ -14048,6 +14194,7 @@ function handleWebSocket(httpServer, fetcher) {
         return;
       }
       const headers = nodeHeadersToWebHeaders(request.headers);
+      const fetcher = await getFetcher();
       const response = await fetcher(url, {
         headers,
         method: request.method
@@ -14070,13 +14217,65 @@ function handleWebSocket(httpServer, fetcher) {
   );
 }
 
+// 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;
 function cloudflare2(pluginConfig = {}) {
   let resolvedPluginConfig;
   let resolvedViteConfig;
-  let miniflare;
   const additionalModulePaths = /* @__PURE__ */ new Set();
+  const nodeJsCompatWarningsMap = /* @__PURE__ */ new Map();
   let hasClientBuild = false;
   return [
     {
@@ -14127,7 +14326,7 @@ function cloudflare2(pluginConfig = {}) {
           builder: {
             buildApp: userConfig.builder?.buildApp ?? (async (builder) => {
               const clientEnvironment = builder.environments.client;
-              const defaultHtmlPath = path8.resolve(
+              const defaultHtmlPath = path9.resolve(
                 builder.config.root,
                 "index.html"
               );
@@ -14139,7 +14338,7 @@ function cloudflare2(pluginConfig = {}) {
                   resolvedPluginConfig.workers
                 ).map((environmentName) => {
                   const environment = builder.environments[environmentName];
-                  assert8(
+                  assert10(
                     environment,
                     `${environmentName} environment not found`
                   );
@@ -14160,6 +14359,12 @@ function cloudflare2(pluginConfig = {}) {
       },
       configResolved(config) {
         resolvedViteConfig = config;
+        if (resolvedPluginConfig?.type === "workers") {
+          validateWorkerEnvironmentsResolvedConfigs(
+            resolvedPluginConfig,
+            resolvedViteConfig
+          );
+        }
       },
       generateBundle(_, bundle) {
         let config;
@@ -14180,15 +14385,15 @@ 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"
             );
             workerConfig.assets = {
               ...workerConfig.assets,
-              directory: path8.relative(
-                path8.resolve(resolvedViteConfig.root, workerOutputDirectory),
-                path8.resolve(resolvedViteConfig.root, clientOutputDirectory)
+              directory: path9.relative(
+                path9.resolve(resolvedViteConfig.root, workerOutputDirectory),
+                path9.resolve(resolvedViteConfig.root, clientOutputDirectory)
               )
             };
           } else {
@@ -14243,54 +14448,75 @@ function cloudflare2(pluginConfig = {}) {
           writeDeployConfig(resolvedPluginConfig, resolvedViteConfig);
         }
       },
-      handleHotUpdate(options) {
-        if (resolvedPluginConfig.configPaths.has(options.file) || hasAssetsConfigChanged(
+      hotUpdate(options) {
+        const changedFilePath = path9.resolve(options.file);
+        if (resolvedPluginConfig.configPaths.has(changedFilePath) || hasDotDevDotVarsFileChanged(resolvedPluginConfig, changedFilePath) || hasAssetsConfigChanged(
           resolvedPluginConfig,
           resolvedViteConfig,
-          options.file
+          changedFilePath
         )) {
           options.server.restart();
-        }
-      },
-      async buildEnd() {
-        if (miniflare) {
-          await miniflare.dispose();
-          miniflare = void 0;
+          return [];
         }
       },
       async configureServer(viteDevServer) {
-        assert8(
-          viteDevServer.httpServer,
-          "Unexpected error: No Vite HTTP server"
-        );
-        miniflare = new Miniflare(
-          getDevMiniflareOptions(resolvedPluginConfig, viteDevServer)
+        const inputInspectorPort = await getInputInspectorPortOption(
+          pluginConfig,
+          viteDevServer
         );
+        if (!miniflare) {
+          miniflare = new Miniflare(
+            getDevMiniflareOptions(
+              resolvedPluginConfig,
+              viteDevServer,
+              inputInspectorPort
+            )
+          );
+        } else {
+          await miniflare.setOptions(
+            getDevMiniflareOptions(
+              resolvedPluginConfig,
+              viteDevServer,
+              inputInspectorPort
+            )
+          );
+        }
         await initRunners(resolvedPluginConfig, viteDevServer, miniflare);
-        const routerWorker = await getRouterWorker(miniflare);
         const middleware = createMiddleware(
-          ({ request }) => {
+          async ({ request }) => {
+            assert10(miniflare, `Miniflare not defined`);
+            const routerWorker = await getRouterWorker(miniflare);
             return routerWorker.fetch(toMiniflareRequest(request), {
               redirect: "manual"
             });
           },
           { alwaysCallNext: false }
         );
-        handleWebSocket(viteDevServer.httpServer, routerWorker.fetch);
+        if (viteDevServer.httpServer) {
+          handleWebSocket(viteDevServer.httpServer, async () => {
+            assert10(miniflare, `Miniflare not defined`);
+            const routerWorker = await getRouterWorker(miniflare);
+            return routerWorker.fetch;
+          });
+        }
         return () => {
           viteDevServer.middlewares.use((req, res, next) => {
             middleware(req, res, next);
           });
         };
       },
-      configurePreviewServer(vitePreviewServer) {
+      async configurePreviewServer(vitePreviewServer) {
         const workerConfigs = getWorkerConfigs(vitePreviewServer.config.root);
+        const inputInspectorPort = await getInputInspectorPortOption(
+          pluginConfig,
+          vitePreviewServer
+        );
         const miniflare2 = new Miniflare(
           getPreviewMiniflareOptions(
             vitePreviewServer,
             workerConfigs,
             pluginConfig.persistState ?? true,
-            pluginConfig.inspectorPort
+            inputInspectorPort
           )
         );
         const middleware = createMiddleware(
@@ -14301,7 +14527,10 @@ function cloudflare2(pluginConfig = {}) {
           },
           { alwaysCallNext: false }
         );
-        handleWebSocket(vitePreviewServer.httpServer, miniflare2.dispatchFetch);
+        handleWebSocket(
+          vitePreviewServer.httpServer,
+          () => miniflare2.dispatchFetch
+        );
         vitePreviewServer.middlewares.use((req, res, next) => {
           middleware(req, res, next);
         });
@@ -14357,6 +14586,7 @@ function cloudflare2(pluginConfig = {}) {
       hotUpdate(options) {
         if (additionalModulePaths.has(options.file)) {
           options.server.restart();
+          return [];
         }
       },
       async renderChunk(code, chunk) {
@@ -14365,7 +14595,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}.`
           );
@@ -14379,13 +14609,13 @@ function cloudflare2(pluginConfig = {}) {
           }
           const referenceId = this.emitFile({
             type: "asset",
-            name: path8.basename(modulePath),
+            name: path9.basename(modulePath),
             originalFileName: modulePath,
             source
           });
           const emittedFileName = this.getFileName(referenceId);
-          const relativePath = vite6.normalizePath(
-            path8.relative(path8.dirname(chunk.fileName), emittedFileName)
+          const relativePath = vite7.normalizePath(
+            path9.relative(path9.dirname(chunk.fileName), emittedFileName)
           );
           const importPath = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
           magicString.update(
@@ -14411,26 +14641,28 @@ 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;
               // But also we want to avoid following the ones that are polyfilled since the dependency-optimizer import analyzer does not
               // resolve these imports using our `resolveId()` hook causing the optimization step to fail.
-              exclude: [
-                ...builtinModules2,
-                ...builtinModules2.map((m) => `node:${m}`)
-              ]
+              exclude: [...nodejsBuiltins]
             }
           };
         }
@@ -14448,7 +14680,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"
           );
@@ -14462,11 +14694,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.
@@ -14476,54 +14751,143 @@ 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) {
+      async configurePreviewServer(vitePreviewServer) {
         const workerConfigs = getWorkerConfigs(vitePreviewServer.config.root);
         if (workerConfigs.length >= 1 && pluginConfig.inspectorPort !== false) {
           addDebugToVitePrintUrls(vitePreviewServer);
         }
         const workerNames = workerConfigs.map((worker) => {
-          assert8(worker.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);
           }
           next();
         });
       }
+    },
+    // Plugin to warn if Node.js APIs are being used without nodejs_compat turned on
+    {
+      name: "vite-plugin-cloudflare:nodejs-compat-warnings",
+      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)) {
+          return {
+            optimizeDeps: {
+              esbuildOptions: {
+                plugins: [
+                  {
+                    name: "vite-plugin-cloudflare:nodejs-compat-warnings-resolver",
+                    setup(build) {
+                      build.onResolve(
+                        { filter: NODEJS_MODULES_RE },
+                        ({ path: path10, importer }) => {
+                          if (isNodeAls(workerConfig) && isNodeAlsModule(path10)) {
+                            return;
+                          }
+                          const nodeJsCompatWarnings = nodeJsCompatWarningsMap.get(workerConfig);
+                          nodeJsCompatWarnings?.registerImport(path10, importer);
+                          return { path: path10, external: true };
+                        }
+                      );
+                    }
+                  }
+                ]
+              }
+            }
+          };
+        }
+      },
+      configResolved(resolvedViteConfig2) {
+        for (const environmentName of Object.keys(
+          resolvedViteConfig2.environments
+        )) {
+          const workerConfig = getWorkerConfig2(environmentName);
+          if (workerConfig && !isNodeCompat(workerConfig)) {
+            nodeJsCompatWarningsMap.set(
+              workerConfig,
+              new NodeJsCompatWarnings(environmentName, resolvedViteConfig2)
+            );
+          }
+        }
+      },
+      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);
+            return {
+              id: source,
+              external: true
+            };
+          }
+        }
+      }
     }
   ];
   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 = path8.dirname(configPath);
+  const configDir = path9.dirname(configPath);
   const defaultDotDevDotVarsPath = `${configDir}/.dev.vars`;
   const inputDotDevDotVarsPath = `${defaultDotDevDotVarsPath}${cloudflareEnv ? `.${cloudflareEnv}` : ""}`;
   const targetPath = fs5.existsSync(inputDotDevDotVarsPath) ? inputDotDevDotVarsPath : fs5.existsSync(defaultDotDevDotVarsPath) ? defaultDotDevDotVarsPath : null;
@@ -14533,6 +14897,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
 };