@cloudflare/vite-plugin 0.0.0-8e3688f27 → 0.0.0-8e87754a2

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 colors2 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() {
@@ -5831,14 +5832,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 +5906,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 +11463,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 +11507,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 +11621,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 +11654,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 +11706,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 +12079,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 +12848,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;
@@ -12899,7 +12910,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 +12940,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 +12992,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(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 +13036,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 +13084,7 @@ function createHotChannel(webSocketContainer) {
     }
   };
 }
-var CloudflareDevEnvironment = class extends vite2.DevEnvironment {
+var CloudflareDevEnvironment = class extends vite3.DevEnvironment {
   #webSocketContainer;
   #worker;
   constructor(name, config) {
@@ -13087,7 +13145,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`
@@ -13196,11 +13254,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 +13269,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 +13337,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,
@@ -13295,18 +13353,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 +13449,7 @@ function getEntryWorkerConfig(resolvedPluginConfig) {
   }
   return resolvedPluginConfig.workers[resolvedPluginConfig.entryWorkerEnvironmentName];
 }
-function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
+function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspectorPort) {
   const resolvedViteConfig = viteDevServer.config;
   const entryWorkerConfig = getEntryWorkerConfig(resolvedPluginConfig);
   const assetsConfig = getAssetsConfig(
@@ -13407,7 +13465,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 +13488,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 +13500,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 +13511,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 +13541,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 +13583,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)));
@@ -13585,12 +13643,12 @@ function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
           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 +13703,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 +13713,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);
@@ -13682,7 +13740,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();
@@ -13732,13 +13790,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 = {
   /**
@@ -13770,8 +13829,7 @@ var nonApplicableWorkerConfigs = {
     "preserve_file_names",
     "rules",
     "site",
-    "tsconfig",
-    "upload_source_maps"
+    "tsconfig"
   ]
 };
 var nullableNonApplicable = [
@@ -13782,8 +13840,7 @@ var nullableNonApplicable = [
   "no_bundle",
   "preserve_file_names",
   "site",
-  "tsconfig",
-  "upload_source_maps"
+  "tsconfig"
 ];
 function readWorkerConfig(configPath, env2) {
   const nonApplicable = {
@@ -13832,7 +13889,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("");
@@ -13846,7 +13903,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));
     }
@@ -13945,14 +14002,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) {
@@ -13961,31 +14056,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
@@ -14001,15 +14096,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."
     );
@@ -14026,7 +14126,6 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
     type: "workers",
     configPaths,
     persistState,
-    inspectorPort,
     workers,
     entryWorkerEnvironmentName,
     rawConfigs: {
@@ -14074,6 +14173,54 @@ 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 (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;
@@ -14081,6 +14228,7 @@ function cloudflare2(pluginConfig = {}) {
   let resolvedPluginConfig;
   let resolvedViteConfig;
   const additionalModulePaths = /* @__PURE__ */ new Set();
+  const nodeJsCompatWarningsMap = /* @__PURE__ */ new Map();
   let hasClientBuild = false;
   return [
     {
@@ -14131,7 +14279,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"
               );
@@ -14143,7 +14291,7 @@ function cloudflare2(pluginConfig = {}) {
                   resolvedPluginConfig.workers
                 ).map((environmentName) => {
                   const environment = builder.environments[environmentName];
-                  assert8(
+                  assert10(
                     environment,
                     `${environmentName} environment not found`
                   );
@@ -14164,6 +14312,12 @@ function cloudflare2(pluginConfig = {}) {
       },
       configResolved(config) {
         resolvedViteConfig = config;
+        if (resolvedPluginConfig?.type === "workers") {
+          validateWorkerEnvironmentsResolvedConfigs(
+            resolvedPluginConfig,
+            resolvedViteConfig
+          );
+        }
       },
       generateBundle(_, bundle) {
         let config;
@@ -14184,15 +14338,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 {
@@ -14248,36 +14402,47 @@ function cloudflare2(pluginConfig = {}) {
         }
       },
       hotUpdate(options) {
-        if (
-          // Vite normalizes `options.file` so we use `path.resolve` for Windows compatibility
-          resolvedPluginConfig.configPaths.has(path8.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(
+        assert10(
           viteDevServer.httpServer,
           "Unexpected error: No Vite HTTP server"
         );
-        if (miniflare) {
-          await miniflare.setOptions(
-            getDevMiniflareOptions(resolvedPluginConfig, viteDevServer)
+        if (!miniflare) {
+          const inputInspectorPort = await getInputInspectorPortOption(
+            pluginConfig,
+            viteDevServer
           );
-        } else {
           miniflare = new Miniflare(
-            getDevMiniflareOptions(resolvedPluginConfig, viteDevServer)
+            getDevMiniflareOptions(
+              resolvedPluginConfig,
+              viteDevServer,
+              inputInspectorPort
+            )
+          );
+        } else {
+          const resolvedInspectorPort = await getResolvedInspectorPort(pluginConfig);
+          await miniflare.setOptions(
+            getDevMiniflareOptions(
+              resolvedPluginConfig,
+              viteDevServer,
+              resolvedInspectorPort ?? false
+            )
           );
         }
         await initRunners(resolvedPluginConfig, viteDevServer, miniflare);
         const middleware = createMiddleware(
           async ({ request }) => {
-            assert8(miniflare, `Miniflare not defined`);
+            assert10(miniflare, `Miniflare not defined`);
             const routerWorker = await getRouterWorker(miniflare);
             return routerWorker.fetch(toMiniflareRequest(request), {
               redirect: "manual"
@@ -14286,7 +14451,7 @@ function cloudflare2(pluginConfig = {}) {
           { alwaysCallNext: false }
         );
         handleWebSocket(viteDevServer.httpServer, async () => {
-          assert8(miniflare, `Miniflare not defined`);
+          assert10(miniflare, `Miniflare not defined`);
           const routerWorker = await getRouterWorker(miniflare);
           return routerWorker.fetch;
         });
@@ -14296,14 +14461,18 @@ function cloudflare2(pluginConfig = {}) {
           });
         };
       },
-      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(
@@ -14382,7 +14551,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}.`
           );
@@ -14396,13 +14565,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(
@@ -14428,26 +14597,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]
             }
           };
         }
@@ -14465,7 +14636,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"
           );
@@ -14479,11 +14650,35 @@ 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 provides an __debug path for debugging the Cloudflare Workers.
@@ -14493,54 +14688,131 @@ 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 }) => {
+                          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)) {
+          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) {
+  const inputInspectorPort = pluginConfig.inspectorPort ?? await getFirstAvailablePort(DEFAULT_INSPECTOR_PORT);
+  if (pluginConfig.inspectorPort === void 0 && inputInspectorPort !== DEFAULT_INSPECTOR_PORT) {
+    viteServer.config.logger.warn(
+      colors2.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;
@@ -14550,6 +14822,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
 };