@cloudflare/vite-plugin 0.1.16 → 0.1.18

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;
     };
@@ -488,8 +488,7 @@ var require_mime = __commonJS({
 import assert8 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";
 
 // ../../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.0/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
@@ -1558,7 +1557,7 @@ var MagicString = class _MagicString {
 
 // src/index.ts
 import { Miniflare } from "miniflare";
-import * as vite6 from "vite";
+import * as vite7 from "vite";
 
 // src/constants.ts
 var ROUTER_WORKER_NAME = "__router-worker__";
@@ -1726,11 +1725,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 +1762,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 +1824,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 +1835,7 @@ function parseHeaders(input, {
         continue;
       }
       rule = {
-        path: path9,
+        path: path10,
         line,
         headers: {},
         unsetHeaders: []
@@ -2411,8 +2410,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 +2510,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() {
@@ -5905,10 +5904,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 +11461,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 +11505,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 +11619,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 +11652,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 +11704,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 +12077,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 +12846,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;
@@ -12929,6 +12938,46 @@ function getNodeCompatEntries() {
   nodeCompatExternals.forEach((external) => entries.delete(external));
   return entries;
 }
+var NodeJsCompatWarnings = class {
+  constructor(environment) {
+    this.environment = environment;
+  }
+  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);
+  }
+  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.environment.name}". Do you need to enable the "nodejs_compat" compatibility flag?
+Refer to https://developers.cloudflare.com/workers/runtime-apis/nodejs/ for more details.
+`;
+      this.sources.forEach((importers, source) => {
+        importers.forEach((importer) => {
+          message += ` - "${source}" imported from "${path3.relative(this.environment.config.root, importer)}"
+`;
+        });
+      });
+      this.environment.logger.warn(message, {
+        environment: this.environment.name
+      });
+      this.sources.clear();
+    }
+  }
+};
 
 // src/shared.ts
 var UNKNOWN_HOST = "http://localhost";
@@ -12942,15 +12991,15 @@ 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 { 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 secFetchMode = request.headers.get("Sec-Fetch-Mode");
@@ -13026,7 +13075,7 @@ function createHotChannel(webSocketContainer) {
     }
   };
 }
-var CloudflareDevEnvironment = class extends vite2.DevEnvironment {
+var CloudflareDevEnvironment = class extends vite3.DevEnvironment {
   #webSocketContainer;
   #worker;
   constructor(name, config) {
@@ -13087,7 +13136,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 +13179,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 +13245,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 +13260,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 +13328,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 +13344,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) {
@@ -13407,7 +13456,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 +13479,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 +13491,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 +13502,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);
@@ -13585,12 +13634,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 +13694,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,9 +13704,9 @@ 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
         }))
       )
     ]
@@ -13695,6 +13744,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 +13752,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:
@@ -13730,12 +13782,12 @@ 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 * as path8 from "node:path";
+import * as vite6 from "vite";
 
 // src/workers-configs.ts
 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 = {
   /**
@@ -13829,7 +13881,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 +13895,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));
     }
@@ -13944,7 +13996,7 @@ function getWorkerConfig(configPath, env2, opts) {
 }
 function findWranglerConfig(root) {
   for (const extension of ["json", "jsonc", "toml"]) {
-    const configPath = path6.join(root, `wrangler.${extension}`);
+    const configPath = path7.join(root, `wrangler.${extension}`);
     if (fs4.existsSync(configPath)) {
       return configPath;
     }
@@ -13960,14 +14012,14 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
   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);
+  const configPath = pluginConfig.configPath ? path8.resolve(root, pluginConfig.configPath) : findWranglerConfig(root);
   if (!configPath) {
     throw new Error(
       `Config not found. Have you created a wrangler.json(c) or wrangler.toml file?`
@@ -13999,7 +14051,7 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
   const auxiliaryWorkersResolvedConfigs = [];
   for (const auxiliaryWorker of pluginConfig.auxiliaryWorkers ?? []) {
     const workerResolvedConfig = getWorkerConfig(
-      path7.resolve(root, auxiliaryWorker.configPath),
+      path8.resolve(root, auxiliaryWorker.configPath),
       cloudflareEnv,
       {
         visitedConfigPaths: configPaths
@@ -14038,7 +14090,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 +14100,7 @@ function handleWebSocket(httpServer, fetcher) {
         return;
       }
       const headers = nodeHeadersToWebHeaders(request.headers);
+      const fetcher = await getFetcher();
       const response = await fetcher(url, {
         headers,
         method: request.method
@@ -14072,11 +14125,12 @@ function handleWebSocket(httpServer, fetcher) {
 
 // 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 +14181,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"
               );
@@ -14186,9 +14240,9 @@ function cloudflare2(pluginConfig = {}) {
             );
             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,19 +14297,17 @@ function cloudflare2(pluginConfig = {}) {
           writeDeployConfig(resolvedPluginConfig, resolvedViteConfig);
         }
       },
-      handleHotUpdate(options) {
-        if (resolvedPluginConfig.configPaths.has(options.file) || hasAssetsConfigChanged(
-          resolvedPluginConfig,
-          resolvedViteConfig,
-          options.file
-        )) {
+      hotUpdate(options) {
+        if (
+          // Vite normalizes `options.file` so we use `path.resolve` for Windows compatibility
+          resolvedPluginConfig.configPaths.has(path9.resolve(options.file)) || hasAssetsConfigChanged(
+            resolvedPluginConfig,
+            resolvedViteConfig,
+            options.file
+          )
+        ) {
           options.server.restart();
-        }
-      },
-      async buildEnd() {
-        if (miniflare) {
-          await miniflare.dispose();
-          miniflare = void 0;
+          return [];
         }
       },
       async configureServer(viteDevServer) {
@@ -14263,20 +14315,31 @@ function cloudflare2(pluginConfig = {}) {
           viteDevServer.httpServer,
           "Unexpected error: No Vite HTTP server"
         );
-        miniflare = new Miniflare(
-          getDevMiniflareOptions(resolvedPluginConfig, viteDevServer)
-        );
+        if (miniflare) {
+          await miniflare.setOptions(
+            getDevMiniflareOptions(resolvedPluginConfig, viteDevServer)
+          );
+        } else {
+          miniflare = new Miniflare(
+            getDevMiniflareOptions(resolvedPluginConfig, viteDevServer)
+          );
+        }
         await initRunners(resolvedPluginConfig, viteDevServer, miniflare);
-        const routerWorker = await getRouterWorker(miniflare);
         const middleware = createMiddleware(
-          ({ request }) => {
+          async ({ request }) => {
+            assert8(miniflare, `Miniflare not defined`);
+            const routerWorker = await getRouterWorker(miniflare);
             return routerWorker.fetch(toMiniflareRequest(request), {
               redirect: "manual"
             });
           },
           { alwaysCallNext: false }
         );
-        handleWebSocket(viteDevServer.httpServer, routerWorker.fetch);
+        handleWebSocket(viteDevServer.httpServer, async () => {
+          assert8(miniflare, `Miniflare not defined`);
+          const routerWorker = await getRouterWorker(miniflare);
+          return routerWorker.fetch;
+        });
         return () => {
           viteDevServer.middlewares.use((req, res, next) => {
             middleware(req, res, next);
@@ -14301,7 +14364,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 +14423,7 @@ function cloudflare2(pluginConfig = {}) {
       hotUpdate(options) {
         if (additionalModulePaths.has(options.file)) {
           options.server.restart();
+          return [];
         }
       },
       async renderChunk(code, chunk) {
@@ -14379,13 +14446,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(
@@ -14427,10 +14494,7 @@ function cloudflare2(pluginConfig = {}) {
               // 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]
             }
           };
         }
@@ -14500,7 +14564,7 @@ function cloudflare2(pluginConfig = {}) {
           addDebugToVitePrintUrls(vitePreviewServer);
         }
         const workerNames = workerConfigs.map((worker) => {
-          assert8(worker.name);
+          assert8(worker.name, "Expected the Worker to have a name");
           return worker.name;
         });
         vitePreviewServer.middlewares.use((req, res, next) => {
@@ -14515,6 +14579,97 @@ function cloudflare2(pluginConfig = {}) {
           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;
+      },
+      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);
+                          assert8(
+                            nodeJsCompatWarnings,
+                            `expected nodeJsCompatWarnings to be defined for Worker "${workerConfig.name}"`
+                          );
+                          nodeJsCompatWarnings.registerImport(path10, importer);
+                          return { path: path10, external: true };
+                        }
+                      );
+                      build.onEnd(() => {
+                        const nodeJsCompatWarnings = nodeJsCompatWarningsMap.get(workerConfig);
+                        if (nodeJsCompatWarnings) {
+                          nodeJsCompatWarnings.renderWarnings();
+                        }
+                      });
+                    }
+                  }
+                ]
+              }
+            }
+          };
+        }
+      },
+      configureServer(viteDevServer) {
+        for (const environment of Object.values(viteDevServer.environments)) {
+          const workerConfig = getWorkerConfig2(environment.name);
+          if (workerConfig && !isNodeCompat(workerConfig)) {
+            nodeJsCompatWarningsMap.set(
+              workerConfig,
+              new NodeJsCompatWarnings(environment)
+            );
+          }
+        }
+      },
+      buildStart() {
+        const workerConfig = getWorkerConfig2(this.environment.name);
+        if (workerConfig && !isNodeCompat(workerConfig)) {
+          nodeJsCompatWarningsMap.set(
+            workerConfig,
+            new NodeJsCompatWarnings(this.environment)
+          );
+        }
+      },
+      buildEnd() {
+        const workerConfig = getWorkerConfig2(this.environment.name);
+        if (workerConfig && !isNodeCompat(workerConfig)) {
+          const nodeJsCompatWarnings = nodeJsCompatWarningsMap.get(workerConfig);
+          assert8(
+            nodeJsCompatWarnings,
+            `expected nodeJsCompatWarnings to be defined for Worker "${workerConfig.name}"`
+          );
+          nodeJsCompatWarnings.renderWarnings();
+        }
+      },
+      // We must ensure that the `resolveId` hook runs before the built-in ones otherwise we
+      // never see the Node.js built-in imports since they get handled by default Vite behavior.
+      enforce: "pre",
+      async resolveId(source, importer) {
+        const workerConfig = getWorkerConfig2(this.environment.name);
+        if (workerConfig && !isNodeCompat(workerConfig)) {
+          const nodeJsCompatWarnings = nodeJsCompatWarningsMap.get(workerConfig);
+          if (nodejsBuiltins.has(source)) {
+            nodeJsCompatWarnings?.registerImport(source, importer);
+            nodeJsCompatWarnings?.renderWarningsOnIdle();
+            return {
+              id: source,
+              external: true
+            };
+          }
+        }
+      }
     }
   ];
   function getWorkerConfig2(environmentName) {
@@ -14523,7 +14678,7 @@ function cloudflare2(pluginConfig = {}) {
   }
 }
 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;

package/dist/runner-worker/index.js

@@ -29,7 +29,7 @@ function stripInternalEnv(internalEnv) {
   return userEnv;
 }
 
-// ../../node_modules/.pnpm/vite@6.1.0_@types+node@18.19.76_jiti@2.4.2/node_modules/vite/dist/node/module-runner.js
+// ../../node_modules/.pnpm/vite@6.1.0_@types+node@18.19.76_jiti@2.4.2_lightningcss@1.29.2/node_modules/vite/dist/node/module-runner.js
 var VALID_ID_PREFIX = "/@id/";
 var NULL_BYTE_PLACEHOLDER = "__x00__";
 var SOURCEMAPPING_URL = "sourceMa";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudflare/vite-plugin",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "description": "Cloudflare plugin for Vite",
   "keywords": [
     "cloudflare",
@@ -39,8 +39,8 @@
     "unenv": "2.0.0-rc.15",
     "ws": "8.18.0",
     "@cloudflare/unenv-preset": "2.3.1",
-    "miniflare": "4.20250321.0",
-    "wrangler": "4.4.1"
+    "miniflare": "4.20250321.1",
+    "wrangler": "4.5.1"
   },
   "devDependencies": {
     "@cloudflare/workers-types": "^4.20250321.0",