@cloudflare/vite-plugin 1.7.1 → 1.7.3

package/dist/index.js

@@ -248,17 +248,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path11, originalPath, doThrow) => {
-      if (!isString(path11)) {
+    var checkPath = (path12, originalPath, doThrow) => {
+      if (!isString(path12)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path11) {
+      if (!path12) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path11)) {
+      if (checkPath.isNotRelative(path12)) {
         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 = (path11) => REGEX_TEST_INVALID_PATH.test(path11);
+    var isNotRelative = (path12) => REGEX_TEST_INVALID_PATH.test(path12);
     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(path11, checkUnignored) {
+      _testOne(path12, 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(path11);
+          const matched = rule.regex.test(path12);
           if (matched) {
             ignored = !negative;
             unignored = negative;
@@ -347,24 +347,24 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache2, checkUnignored, slices) {
-        const path11 = originalPath && checkPath.convert(originalPath);
+        const path12 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path11,
+          path12,
           originalPath,
           this._allowRelativePaths ? RETURN_FALSE : throwError
         );
-        return this._t(path11, cache2, checkUnignored, slices);
+        return this._t(path12, cache2, checkUnignored, slices);
       }
-      _t(path11, cache2, checkUnignored, slices) {
-        if (path11 in cache2) {
-          return cache2[path11];
+      _t(path12, cache2, checkUnignored, slices) {
+        if (path12 in cache2) {
+          return cache2[path12];
         }
         if (!slices) {
-          slices = path11.split(SLASH);
+          slices = path12.split(SLASH);
         }
         slices.pop();
         if (!slices.length) {
-          return cache2[path11] = this._testOne(path11, checkUnignored);
+          return cache2[path12] = this._testOne(path12, checkUnignored);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -372,24 +372,24 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache2[path11] = parent.ignored ? parent : this._testOne(path11, checkUnignored);
+        return cache2[path12] = parent.ignored ? parent : this._testOne(path12, checkUnignored);
       }
-      ignores(path11) {
-        return this._test(path11, this._ignoreCache, false).ignored;
+      ignores(path12) {
+        return this._test(path12, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path11) => !this.ignores(path11);
+        return (path12) => !this.ignores(path12);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path11) {
-        return this._test(path11, this._testCache, true);
+      test(path12) {
+        return this._test(path12, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore(options);
-    var isPathValid = (path11) => checkPath(path11 && checkPath.convert(path11), path11, RETURN_FALSE);
+    var isPathValid = (path12) => checkPath(path12 && checkPath.convert(path12), path12, 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 = (path11) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path11) || isNotRelative(path11);
+      checkPath.isNotRelative = (path12) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path12) || isNotRelative(path12);
     }
   }
 });
@@ -443,11 +443,11 @@ var require_Mime = __commonJS({
         }
       }
     };
-    Mime.prototype.getType = function(path11) {
-      path11 = String(path11);
-      let last = path11.replace(/^.*[/\\]/, "").toLowerCase();
+    Mime.prototype.getType = function(path12) {
+      path12 = String(path12);
+      let last = path12.replace(/^.*[/\\]/, "").toLowerCase();
       let ext = last.replace(/^.*\./, "").toLowerCase();
-      let hasPath = last.length < path11.length;
+      let hasPath = last.length < path12.length;
       let hasDot = ext.length < last.length - 1;
       return (hasDot || !hasPath) && this._types[ext] || null;
     };
@@ -486,9 +486,8 @@ var require_mime = __commonJS({
 
 // src/index.ts
 import assert11 from "node:assert";
-import * as fs6 from "node:fs";
 import * as fsp2 from "node:fs/promises";
-import * as path10 from "node:path";
+import * as path11 from "node:path";
 
 // ../workers-shared/asset-worker/src/utils/rules-engine.ts
 var ESCAPE_REGEX_CHARACTERS = /[-/\\^$*+?.()|[\]{}]/g;
@@ -1583,7 +1582,6 @@ var MagicString = class _MagicString {
 
 // src/index.ts
 import { Miniflare } from "miniflare";
-import colors4 from "picocolors";
 import * as vite6 from "vite";
 
 // src/constants.ts
@@ -1597,6 +1595,7 @@ var ADDITIONAL_MODULE_TYPES = [
 ];
 var PUBLIC_DIR_PREFIX = "/__vite_public_dir__";
 var DEFAULT_INSPECTOR_PORT = 9229;
+var DEBUG_PATH = "/__debug";
 var kRequestType = Symbol("kRequestType");
 
 // src/additional-modules.ts
@@ -1756,11 +1755,11 @@ ${invalidHeaderRulesList}`
 }
 
 // ../workers-shared/utils/configuration/validateURL.ts
-var extractPathname = (path11 = "/", includeSearch, includeHash) => {
-  if (!path11.startsWith("/")) {
-    path11 = `/${path11}`;
+var extractPathname = (path12 = "/", includeSearch, includeHash) => {
+  if (!path12.startsWith("/")) {
+    path12 = `/${path12}`;
   }
-  const url = new URL(`//${path11}`, "relative://");
+  const url = new URL(`//${path12}`, "relative://");
   return `${url.pathname}${includeSearch ? url.search : ""}${includeHash ? url.hash : ""}`;
 };
 var URL_REGEX = /^https:\/\/+(?<host>[^/]+)\/?(?<path>.*)/;
@@ -1793,8 +1792,8 @@ var validateUrl = (token, onlyRelative = false, disallowPorts = false, includeSe
     if (!token.startsWith("/") && onlyRelative) {
       token = `/${token}`;
     }
-    const path11 = PATH_REGEX.exec(token);
-    if (path11) {
+    const path12 = PATH_REGEX.exec(token);
+    if (path12) {
       try {
         return [extractPathname(token, includeSearch, includeHash), void 0];
       } catch {
@@ -1855,7 +1854,7 @@ function parseHeaders(input, {
           });
         }
       }
-      const [path11, pathError] = validateUrl(line, false, true);
+      const [path12, pathError] = validateUrl(line, false, true);
       if (pathError) {
         invalid.push({
           line,
@@ -1866,7 +1865,7 @@ function parseHeaders(input, {
         continue;
       }
       rule = {
-        path: path11,
+        path: path12,
         line,
         headers: {},
         unsetHeaders: []
@@ -2441,8 +2440,8 @@ function getErrorMap() {
   return overrideErrorMap;
 }
 var makeIssue = (params) => {
-  const { data: data2, path: path11, errorMaps, issueData } = params;
-  const fullPath = [...path11, ...issueData.path || []];
+  const { data: data2, path: path12, errorMaps, issueData } = params;
+  const fullPath = [...path12, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -2541,11 +2540,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, path11, key) {
+  constructor(parent, value, path12, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path11;
+    this._path = path12;
     this._key = key;
   }
   get path() {
@@ -5826,6 +5825,12 @@ var RouterConfigSchema = z.object({
   has_user_worker: z.boolean().optional(),
   ...InternalConfigSchema.shape
 });
+var EyeballRouterConfigSchema = z.union([
+  z.object({
+    limitedAssetsOnly: z.boolean().optional()
+  }),
+  z.null()
+]);
 var MetadataStaticRedirectEntry = z.object({
   status: z.number(),
   to: z.string(),
@@ -11633,17 +11638,17 @@ function withTrailingSlash(input = "", respectQueryAndFragment) {
   if (hasTrailingSlash(input, true)) {
     return input || "/";
   }
-  let path11 = input;
+  let path12 = input;
   let fragment = "";
   const fragmentIndex = input.indexOf("#");
   if (fragmentIndex >= 0) {
-    path11 = input.slice(0, fragmentIndex);
+    path12 = input.slice(0, fragmentIndex);
     fragment = input.slice(fragmentIndex);
-    if (!path11) {
+    if (!path12) {
       return fragment;
     }
   }
-  const [s0, ...s] = path11.split("?");
+  const [s0, ...s] = path12.split("?");
   return s0 + "/" + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
 }
 function isNonEmptyURL(url) {
@@ -11677,8 +11682,8 @@ import path3, { dirname as dirname3 } from "node:path";
 import v8 from "node:v8";
 import { format as format2, inspect } from "node:util";
 var BUILTIN_MODULES = new Set(builtinModules);
-function normalizeSlash(path11) {
-  return path11.replace(/\\/g, "/");
+function normalizeSlash(path12) {
+  return path12.replace(/\\/g, "/");
 }
 var own$1 = {}.hasOwnProperty;
 var classRegExp = /^([A-Z][a-z\d]*)+$/;
@@ -11791,8 +11796,8 @@ codes.ERR_INVALID_PACKAGE_CONFIG = createError(
    * @param {string} [base]
    * @param {string} [message]
    */
-  (path11, base, message) => {
-    return `Invalid package config ${path11}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
+  (path12, base, message) => {
+    return `Invalid package config ${path12}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
   },
   Error
 );
@@ -11824,8 +11829,8 @@ codes.ERR_MODULE_NOT_FOUND = createError(
    * @param {string} base
    * @param {boolean} [exactUrl]
    */
-  (path11, base, exactUrl = false) => {
-    return `Cannot find ${exactUrl ? "module" : "package"} '${path11}' imported from ${base}`;
+  (path12, base, exactUrl = false) => {
+    return `Cannot find ${exactUrl ? "module" : "package"} '${path12}' imported from ${base}`;
   },
   Error
 );
@@ -11876,8 +11881,8 @@ codes.ERR_UNKNOWN_FILE_EXTENSION = createError(
    * @param {string} extension
    * @param {string} path
    */
-  (extension, path11) => {
-    return `Unknown file extension "${extension}" for ${path11}`;
+  (extension, path12) => {
+    return `Unknown file extension "${extension}" for ${path12}`;
   },
   TypeError
 );
@@ -12249,9 +12254,9 @@ Default "index" lookups for the main are deprecated for ES modules.`,
     );
   }
 }
-function tryStatSync(path11) {
+function tryStatSync(path12) {
   try {
-    return statSync(path11);
+    return statSync(path12);
   } catch {
   }
 }
@@ -13056,8 +13061,8 @@ function isNodeAls(workerConfig) {
     workerConfig.compatibility_flags ?? []
   ).mode === "als";
 }
-function isNodeAlsModule(path11) {
-  return /^(node:)?async_hooks$/.test(path11);
+function isNodeAlsModule(path12) {
+  return /^(node:)?async_hooks$/.test(path12);
 }
 var injectsByModule = /* @__PURE__ */ new Map();
 var virtualModulePathToSpecifier = /* @__PURE__ */ new Map();
@@ -13190,7 +13195,6 @@ var VITE_DEV_METADATA_HEADER = "__VITE_DEV_METADATA__";
 // src/utils.ts
 import * as path5 from "node:path";
 import { createRequest, sendResponse } from "@mjackson/node-fetch-server";
-import getPort, { portNumbers } from "get-port";
 import {
   Request as MiniflareRequest,
   Response as MiniflareResponse
@@ -13203,11 +13207,8 @@ var postfixRE = /[?#].*$/;
 function cleanUrl(url) {
   return url.replace(postfixRE, "");
 }
-function getFirstAvailablePort(start) {
-  return getPort({ port: portNumbers(start, 65535) });
-}
-function withTrailingSlash2(path11) {
-  return path11.endsWith("/") ? path11 : `${path11}/`;
+function withTrailingSlash2(path12) {
+  return path12.endsWith("/") ? path12 : `${path12}/`;
 }
 function createRequestHandler(handler) {
   return async (req, res, next) => {
@@ -13296,14 +13297,13 @@ var CloudflareDevEnvironment = class extends vite2.DevEnvironment {
     });
     this.#webSocketContainer = webSocketContainer;
   }
-  async initRunner(worker, root, workerConfig) {
+  async initRunner(worker, workerConfig) {
     this.#worker = worker;
     const response = await this.#worker.fetch(
       new URL(INIT_PATH, UNKNOWN_HOST),
       {
         headers: {
           [VITE_DEV_METADATA_HEADER]: JSON.stringify({
-            root,
             entryPath: workerConfig.main
           }),
           upgrade: "websocket"
@@ -13386,14 +13386,11 @@ function createCloudflareEnvironmentOptions(workerConfig, userConfig, environmen
   };
 }
 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 miniflare2.getWorker(workerConfig.name);
-        return viteDevServer.environments[environmentName].initRunner(worker, viteDevServer.config.root, workerConfig);
+        return viteDevServer.environments[environmentName].initRunner(worker, workerConfig);
       }
     )
   );
@@ -13401,8 +13398,39 @@ function initRunners(resolvedPluginConfig, viteDevServer, miniflare2) {
 
 // src/debugging.ts
 import assert5 from "node:assert";
+import getPort, { portNumbers } from "get-port";
 import colors2 from "picocolors";
-var debuggingPath = "/__debug";
+async function getInputInspectorPortOption(resolvedPluginConfig, viteServer, miniflare2) {
+  if (resolvedPluginConfig.inspectorPort === void 0 || resolvedPluginConfig.inspectorPort === 0) {
+    const resolvedInspectorPort = await getResolvedInspectorPort(
+      resolvedPluginConfig,
+      miniflare2
+    );
+    if (resolvedInspectorPort !== null) {
+      return resolvedInspectorPort;
+    }
+  }
+  const inputInspectorPort = resolvedPluginConfig.inspectorPort ?? await getFirstAvailablePort(DEFAULT_INSPECTOR_PORT);
+  if (resolvedPluginConfig.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(resolvedPluginConfig, miniflare2) {
+  if (miniflare2 && resolvedPluginConfig.inspectorPort !== false) {
+    const miniflareInspectorUrl = await miniflare2.getInspectorURL();
+    return Number.parseInt(miniflareInspectorUrl.port);
+  }
+  return null;
+}
+function getFirstAvailablePort(start) {
+  return getPort({ port: portNumbers(start, 65535) });
+}
 function addDebugToVitePrintUrls(server) {
   const originalPrintUrls = server.printUrls;
   server.printUrls = () => {
@@ -13416,7 +13444,7 @@ function addDebugToVitePrintUrls(server) {
         )
       );
       server.config.logger.info(
-        `  ${colors2.green("\u279C")}  ${colors2.bold("Debug")}:   ${colorDebugUrl(`${protocol}//${hostname}:${port}${debuggingPath}`)}`
+        `  ${colors2.green("\u279C")}  ${colors2.bold("Debug")}:   ${colorDebugUrl(`${protocol}//${hostname}:${port}${DEBUG_PATH}`)}`
       );
     }
   };
@@ -13424,11 +13452,11 @@ function addDebugToVitePrintUrls(server) {
 function getDebugPathHtml(workerNames, inspectorPort) {
   assert5(workerNames.length >= 1, "no workers present to debug");
   const workerDevtoolsUrls = workerNames.map((workerName) => {
-    const localHost = `localhost:${inspectorPort}/${workerName}`;
+    const localhost = `localhost:${inspectorPort}/${workerName}`;
     const searchParams = new URLSearchParams({
       theme: "systemPreferred",
       debugger: "true",
-      ws: localHost,
+      ws: localhost,
       domain: workerName
     });
     const devtoolsFrontendUrl = `https://devtools.devprod.cloudflare.dev/js_app?${searchParams}`;
@@ -13457,7 +13485,7 @@ import { unstable_readConfig } from "wrangler";
 function getDeployConfigPath(root) {
   return path6.resolve(root, ".wrangler", "deploy", "config.json");
 }
-function getWorkerConfigs(root, mixedModeEnabled) {
+function getWorkerConfigs(root, remoteBindingsEnabled) {
   const deployConfigPath = getDeployConfigPath(root);
   const deployConfig = JSON.parse(
     fs3.readFileSync(deployConfigPath, "utf-8")
@@ -13472,7 +13500,7 @@ function getWorkerConfigs(root, mixedModeEnabled) {
     );
     return unstable_readConfig(
       { config: resolvedConfigPath },
-      { experimental: { mixedModeEnabled } }
+      { experimental: { remoteBindingsEnabled } }
     );
   });
 }
@@ -13533,11 +13561,39 @@ function writeDeployConfig(resolvedPluginConfig, resolvedViteConfig) {
   }
 }
 
+// src/dev-vars.ts
+import * as fs4 from "node:fs";
+import * as path7 from "node:path";
+function getDotDevDotVarsContent(configPath, cloudflareEnv) {
+  const configDir = path7.dirname(configPath);
+  const defaultDotDevDotVarsPath = `${configDir}/.dev.vars`;
+  const inputDotDevDotVarsPath = `${defaultDotDevDotVarsPath}${cloudflareEnv ? `.${cloudflareEnv}` : ""}`;
+  const targetPath = fs4.existsSync(inputDotDevDotVarsPath) ? inputDotDevDotVarsPath : fs4.existsSync(defaultDotDevDotVarsPath) ? defaultDotDevDotVarsPath : null;
+  if (targetPath) {
+    const dotDevDotVarsContent = fs4.readFileSync(targetPath);
+    return dotDevDotVarsContent;
+  }
+  return null;
+}
+function hasDotDevDotVarsFileChanged(resolvedPluginConfig, changedFilePath) {
+  return [...resolvedPluginConfig.configPaths].some((configPath) => {
+    const dotDevDotVars = path7.join(path7.dirname(configPath), ".dev.vars");
+    if (dotDevDotVars === changedFilePath) {
+      return true;
+    }
+    if (resolvedPluginConfig.cloudflareEnv) {
+      const dotDevDotVarsForEnv = `${dotDevDotVars}.${resolvedPluginConfig.cloudflareEnv}`;
+      return dotDevDotVarsForEnv === changedFilePath;
+    }
+    return false;
+  });
+}
+
 // src/miniflare-options.ts
 import assert7 from "node:assert";
-import * as fs4 from "node:fs";
+import * as fs5 from "node:fs";
 import * as fsp from "node:fs/promises";
-import * as path7 from "node:path";
+import * as path8 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import {
   getDefaultDevRegistryPath,
@@ -13550,7 +13606,7 @@ import colors3 from "picocolors";
 import { globSync } from "tinyglobby";
 import "vite";
 import {
-  experimental_maybeStartOrUpdateMixedModeSession,
+  experimental_maybeStartOrUpdateRemoteProxySession,
   unstable_convertConfigBindingsToStartWorkerBindings,
   unstable_getMiniflareWorkerOptions
 } from "wrangler";
@@ -13559,7 +13615,7 @@ function getPersistenceRoot(root, persistState) {
     return;
   }
   const defaultPersistPath = ".wrangler/state";
-  const persistPath = path7.resolve(
+  const persistPath = path8.resolve(
     root,
     typeof persistState === "object" ? persistState.path : defaultPersistPath,
     "v3"
@@ -13671,7 +13727,7 @@ function logUnknownTails(tails, userWorkers, log) {
     }
   }
 }
-var mixedModeSessionsDataMap = /* @__PURE__ */ new Map();
+var remoteProxySessionsDataMap = /* @__PURE__ */ new Map();
 async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspectorPort) {
   const resolvedViteConfig = viteDevServer.config;
   const entryWorkerConfig = getEntryWorkerConfig(resolvedPluginConfig);
@@ -13688,8 +13744,8 @@ async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspe
       modules: [
         {
           type: "ESModule",
-          path: path7.join(miniflareModulesRoot, ROUTER_WORKER_PATH),
-          contents: fs4.readFileSync(
+          path: path8.join(miniflareModulesRoot, ROUTER_WORKER_PATH),
+          contents: fs5.readFileSync(
             fileURLToPath2(new URL(ROUTER_WORKER_PATH, import.meta.url))
           )
         }
@@ -13711,8 +13767,8 @@ async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspe
       modules: [
         {
           type: "ESModule",
-          path: path7.join(miniflareModulesRoot, ASSET_WORKER_PATH),
-          contents: fs4.readFileSync(
+          path: path8.join(miniflareModulesRoot, ASSET_WORKER_PATH),
+          contents: fs5.readFileSync(
             fileURLToPath2(new URL(ASSET_WORKER_PATH, import.meta.url))
           )
         }
@@ -13732,8 +13788,8 @@ async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspe
             if (publicDirInRoot && pathname.startsWith(publicPath)) {
               return MiniflareResponse2.json(null);
             }
-            const publicDirFilePath = path7.join(publicDir, pathname);
-            const rootDirFilePath = path7.join(root, pathname);
+            const publicDirFilePath = path8.join(publicDir, pathname);
+            const rootDirFilePath = path8.join(root, pathname);
             for (const resolvedPath of [publicDirFilePath, rootDirFilePath]) {
               try {
                 const stats = await fsp.stat(resolvedPath);
@@ -13752,7 +13808,7 @@ async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspe
           const { pathname } = new URL(request.url);
           const { root, publicDir } = resolvedViteConfig;
           const isInPublicDir = pathname.startsWith(PUBLIC_DIR_PREFIX);
-          const resolvedPath = isInPublicDir ? path7.join(publicDir, pathname.slice(PUBLIC_DIR_PREFIX.length)) : path7.join(root, pathname);
+          const resolvedPath = isInPublicDir ? path8.join(publicDir, pathname.slice(PUBLIC_DIR_PREFIX.length)) : path8.join(root, pathname);
           try {
             let html = await fsp.readFile(resolvedPath, "utf-8");
             if (!isInPublicDir) {
@@ -13774,18 +13830,18 @@ async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspe
         const bindings = unstable_convertConfigBindingsToStartWorkerBindings(
           workerConfig
         );
-        const preExistingMixedModeSession = workerConfig.configPath ? mixedModeSessionsDataMap.get(workerConfig.configPath) : void 0;
-        const mixedModeSessionData = resolvedPluginConfig.experimental.mixedMode ? await experimental_maybeStartOrUpdateMixedModeSession(
+        const preExistingRemoteProxySession = workerConfig.configPath ? remoteProxySessionsDataMap.get(workerConfig.configPath) : void 0;
+        const remoteProxySessionData = resolvedPluginConfig.experimental.remoteBindings ? await experimental_maybeStartOrUpdateRemoteProxySession(
           {
             name: workerConfig.name,
             bindings: bindings ?? {}
           },
-          preExistingMixedModeSession ?? null
+          preExistingRemoteProxySession ?? null
         ) : void 0;
-        if (workerConfig.configPath && mixedModeSessionData) {
-          mixedModeSessionsDataMap.set(
+        if (workerConfig.configPath && remoteProxySessionData) {
+          remoteProxySessionsDataMap.set(
             workerConfig.configPath,
-            mixedModeSessionData
+            remoteProxySessionData
           );
         }
         const miniflareWorkerOptions = unstable_getMiniflareWorkerOptions(
@@ -13795,8 +13851,8 @@ async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspe
           },
           resolvedPluginConfig.cloudflareEnv,
           {
-            mixedModeConnectionString: mixedModeSessionData?.session?.mixedModeConnectionString,
-            mixedModeEnabled: resolvedPluginConfig.experimental.mixedMode
+            remoteProxyConnectionString: remoteProxySessionData?.session?.remoteProxyConnectionString,
+            remoteBindingsEnabled: resolvedPluginConfig.experimental.remoteBindings
           }
         );
         const { externalWorkers: externalWorkers2 } = miniflareWorkerOptions;
@@ -13925,13 +13981,13 @@ async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspe
           modules: [
             {
               type: "ESModule",
-              path: path7.join(miniflareModulesRoot, WRAPPER_PATH),
+              path: path8.join(miniflareModulesRoot, WRAPPER_PATH),
               contents: wrappers.join("\n")
             },
             {
               type: "ESModule",
-              path: path7.join(miniflareModulesRoot, RUNNER_PATH),
-              contents: fs4.readFileSync(
+              path: path8.join(miniflareModulesRoot, RUNNER_PATH),
+              contents: fs5.readFileSync(
                 fileURLToPath2(new URL(RUNNER_PATH, import.meta.url))
               )
             }
@@ -13985,8 +14041,8 @@ async function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer, inspe
 }
 function getPreviewModules(main, modulesRules) {
   assert7(modulesRules, `Unexpected error: 'modulesRules' is undefined`);
-  const rootPath = path7.dirname(main);
-  const entryPath = path7.basename(main);
+  const rootPath = path8.dirname(main);
+  const entryPath = path8.basename(main);
   return {
     rootPath,
     modules: [
@@ -13995,46 +14051,46 @@ function getPreviewModules(main, modulesRules) {
         path: entryPath
       },
       ...modulesRules.flatMap(
-        ({ type, include }) => globSync(include, { cwd: rootPath, ignore: entryPath }).map((path11) => ({
+        ({ type, include }) => globSync(include, { cwd: rootPath, ignore: entryPath }).map((path12) => ({
           type,
-          path: path11
+          path: path12
         }))
       )
     ]
   };
 }
-async function getPreviewMiniflareOptions(vitePreviewServer, workerConfigs, persistState, mixedModeEnabled, inspectorPort) {
+async function getPreviewMiniflareOptions(resolvedPluginConfig, vitePreviewServer, inspectorPort) {
   const resolvedViteConfig = vitePreviewServer.config;
   const workers = (await Promise.all(
-    workerConfigs.map(async (workerConfig, i) => {
+    resolvedPluginConfig.workers.map(async (workerConfig, i) => {
       const bindings = unstable_convertConfigBindingsToStartWorkerBindings(workerConfig);
-      const preExistingMixedModeSessionData = workerConfig.configPath ? mixedModeSessionsDataMap.get(workerConfig.configPath) : void 0;
-      const mixedModeSessionData = mixedModeEnabled ? await experimental_maybeStartOrUpdateMixedModeSession(
+      const preExistingRemoteProxySessionData = workerConfig.configPath ? remoteProxySessionsDataMap.get(workerConfig.configPath) : void 0;
+      const remoteProxySessionData = resolvedPluginConfig.experimental.remoteBindings ? await experimental_maybeStartOrUpdateRemoteProxySession(
         {
           name: workerConfig.name,
           bindings: bindings ?? {}
         },
-        preExistingMixedModeSessionData ?? null
+        preExistingRemoteProxySessionData ?? null
       ) : void 0;
-      if (workerConfig.configPath && mixedModeSessionData) {
-        mixedModeSessionsDataMap.set(
+      if (workerConfig.configPath && remoteProxySessionData) {
+        remoteProxySessionsDataMap.set(
           workerConfig.configPath,
-          mixedModeSessionData
+          remoteProxySessionData
         );
       }
       const miniflareWorkerOptions = unstable_getMiniflareWorkerOptions(
         workerConfig,
         void 0,
         {
-          mixedModeConnectionString: mixedModeSessionData?.session?.mixedModeConnectionString,
-          mixedModeEnabled
+          remoteProxyConnectionString: remoteProxySessionData?.session?.remoteProxyConnectionString,
+          remoteBindingsEnabled: resolvedPluginConfig.experimental.remoteBindings
         }
       );
       const { externalWorkers } = miniflareWorkerOptions;
       const { ratelimits, modulesRules, ...workerOptions } = miniflareWorkerOptions.workerOptions;
       logUnknownTails(
         workerOptions.tails,
-        workerConfigs,
+        resolvedPluginConfig.workers,
         vitePreviewServer.config.logger.warn
       );
       return [
@@ -14068,7 +14124,7 @@ async function getPreviewMiniflareOptions(vitePreviewServer, workerConfigs, pers
     },
     defaultPersistRoot: getPersistenceRoot(
       resolvedViteConfig.root,
-      persistState
+      resolvedPluginConfig.persistState
     ),
     workers
   };
@@ -14107,7 +14163,7 @@ function miniflareLogLevelFromViteLogLevel(level = "info") {
 
 // src/plugin-config.ts
 import assert9 from "node:assert";
-import * as path9 from "node:path";
+import * as path10 from "node:path";
 
 // ../workers-shared/utils/configuration/parseStaticRouting.ts
 function parseStaticRouting(input) {
@@ -14190,8 +14246,8 @@ import * as vite5 from "vite";
 
 // src/workers-configs.ts
 import assert8 from "node:assert";
-import * as fs5 from "node:fs";
-import * as path8 from "node:path";
+import * as fs6 from "node:fs";
+import * as path9 from "node:path";
 import { unstable_readConfig as unstable_readConfig2 } from "wrangler";
 var nonApplicableWorkerConfigs = {
   /**
@@ -14236,14 +14292,14 @@ var nullableNonApplicable = [
   "site",
   "tsconfig"
 ];
-function readWorkerConfig(configPath, env2, mixedModeEnabled) {
+function readWorkerConfig(configPath, env2, remoteBindingsEnabled) {
   const nonApplicable = {
     replacedByVite: /* @__PURE__ */ new Set(),
     notRelevant: /* @__PURE__ */ new Set()
   };
   const config = unstable_readConfig2(
     { config: configPath, env: env2 },
-    { experimental: { mixedModeEnabled } }
+    { experimental: { remoteBindingsEnabled } }
   );
   const raw = structuredClone(config);
   nullableNonApplicable.forEach((prop) => {
@@ -14286,7 +14342,7 @@ function getWarningForWorkersConfigs(configs) {
     const lines2 = [
       `
 
-\x1B[43mWARNING\x1B[0m: your worker config${configs.entryWorker.config.configPath ? ` (at \`${path8.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 \`${path9.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("");
@@ -14300,7 +14356,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 \`${path8.relative("", workerConfig.config.configPath)}\`)` : ""}`
+        `  - (${isEntryWorker ? "entry" : "auxiliary"}) worker${workerConfig.config.name ? ` "${workerConfig.config.name}"` : ""}${workerConfig.config.configPath ? ` (config at \`${path9.relative("", workerConfig.config.configPath)}\`)` : ""}`
       );
       nonApplicableLines.forEach((line) => lines.push(line));
     }
@@ -14339,14 +14395,14 @@ function isNotRelevant(configName) {
 function missingFieldErrorMessage(field, configPath, env2) {
   return `No ${field} field provided in '${configPath}'${env2 ? ` for '${env2}' environment` : ""}`;
 }
-function getWorkerConfig(configPath, env2, mixedModeEnabled, opts) {
+function getWorkerConfig(configPath, env2, remoteBindingsEnabled, opts) {
   if (opts?.visitedConfigPaths?.has(configPath)) {
     throw new Error(`Duplicate Wrangler config path found: ${configPath}`);
   }
   const { raw, config, nonApplicable } = readWorkerConfig(
     configPath,
     env2,
-    mixedModeEnabled
+    remoteBindingsEnabled
   );
   opts?.visitedConfigPaths?.add(configPath);
   if (!config.name) {
@@ -14381,7 +14437,7 @@ function getWorkerConfig(configPath, env2, mixedModeEnabled, opts) {
   if (!config.main) {
     throw new Error(missingFieldErrorMessage(`'main'`, configPath, env2));
   }
-  const mainStat = fs5.statSync(config.main, { throwIfNoEntry: false });
+  const mainStat = fs6.statSync(config.main, { throwIfNoEntry: false });
   if (!mainStat) {
     throw new Error(
       `The provided Wrangler config main field (${config.main}) doesn't point to an existing file`
@@ -14405,17 +14461,17 @@ function getWorkerConfig(configPath, env2, mixedModeEnabled, opts) {
 }
 function getValidatedWranglerConfigPath(root, requestedConfigPath, isForAuxiliaryWorker = false) {
   if (requestedConfigPath) {
-    const configPath2 = path8.resolve(root, requestedConfigPath);
+    const configPath2 = path9.resolve(root, requestedConfigPath);
     const forAuxiliaryWorkerErrorMessage = isForAuxiliaryWorker ? " requested for one of your auxiliary workers" : "";
     const errorMessagePrefix = `The provided configPath (${configPath2})${forAuxiliaryWorkerErrorMessage}`;
-    const fileExtension = path8.extname(configPath2).slice(1);
+    const fileExtension = path9.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 = fs5.statSync(configPath2, { throwIfNoEntry: false });
+    const mainStat = fs6.statSync(configPath2, { throwIfNoEntry: false });
     if (!mainStat) {
       throw new Error(
         `${errorMessagePrefix} doesn't point to an existing file`
@@ -14442,8 +14498,8 @@ function getValidatedWranglerConfigPath(root, requestedConfigPath, isForAuxiliar
 }
 function findWranglerConfig(root) {
   for (const extension of allowedWranglerConfigExtensions) {
-    const configPath = path8.join(root, `wrangler.${extension}`);
-    if (fs5.existsSync(configPath)) {
+    const configPath = path9.join(root, `wrangler.${extension}`);
+    if (fs6.existsSync(configPath)) {
       return configPath;
     }
   }
@@ -14455,10 +14511,23 @@ function workerNameToEnvironmentName(workerName) {
   return workerName.replaceAll("-", "_");
 }
 function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
+  const shared = {
+    persistState: pluginConfig.persistState ?? true,
+    inspectorPort: pluginConfig.inspectorPort,
+    experimental: pluginConfig.experimental ?? {}
+  };
+  const root = userConfig.root ? path10.resolve(userConfig.root) : process.cwd();
+  if (viteEnv.isPreview) {
+    return {
+      ...shared,
+      type: "preview",
+      workers: getWorkerConfigs(
+        root,
+        shared.experimental.remoteBindings ?? false
+      )
+    };
+  }
   const configPaths = /* @__PURE__ */ new Set();
-  const persistState = pluginConfig.persistState ?? true;
-  const experimental = pluginConfig.experimental ?? {};
-  const root = userConfig.root ? path9.resolve(userConfig.root) : process.cwd();
   const { CLOUDFLARE_ENV: cloudflareEnv } = vite5.loadEnv(
     viteEnv.mode,
     root,
@@ -14472,7 +14541,7 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
   const entryWorkerResolvedConfig = getWorkerConfig(
     entryWorkerConfigPath,
     cloudflareEnv,
-    pluginConfig.experimental?.mixedMode ?? false,
+    pluginConfig.experimental?.remoteBindings ?? false,
     {
       visitedConfigPaths: configPaths,
       isEntryWorker: true
@@ -14480,15 +14549,14 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
   );
   if (entryWorkerResolvedConfig.type === "assets-only") {
     return {
+      ...shared,
       type: "assets-only",
+      cloudflareEnv,
       config: entryWorkerResolvedConfig.config,
       configPaths,
-      persistState,
       rawConfigs: {
         entryWorker: entryWorkerResolvedConfig
-      },
-      cloudflareEnv,
-      experimental
+      }
     };
   }
   const entryWorkerConfig = entryWorkerResolvedConfig.config;
@@ -14512,7 +14580,7 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
     const workerResolvedConfig = getWorkerConfig(
       workerConfigPath,
       cloudflareEnv,
-      pluginConfig.experimental?.mixedMode ?? false,
+      pluginConfig.experimental?.remoteBindings ?? false,
       {
         visitedConfigPaths: configPaths
       }
@@ -14532,20 +14600,31 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
     workers[workerEnvironmentName] = workerConfig;
   }
   return {
+    ...shared,
     type: "workers",
+    cloudflareEnv,
     configPaths,
-    persistState,
     workers,
     entryWorkerEnvironmentName,
     staticRouting,
     rawConfigs: {
       entryWorker: entryWorkerResolvedConfig,
       auxiliaryWorkers: auxiliaryWorkersResolvedConfigs
-    },
-    cloudflareEnv,
-    experimental
+    }
   };
 }
+function assertIsNotPreview(resolvedPluginConfig) {
+  assert9(
+    resolvedPluginConfig.type !== "preview",
+    `Expected "assets-only" or "workers" plugin config`
+  );
+}
+function assertIsPreview(resolvedPluginConfig) {
+  assert9(
+    resolvedPluginConfig.type === "preview",
+    `Expected "preview" plugin config`
+  );
+}
 
 // src/websockets.ts
 import { createHeaders } from "@mjackson/node-fetch-server";
@@ -14649,14 +14728,14 @@ function cloudflare2(pluginConfig = {}) {
       // This only applies to this plugin so is safe to use while other plugins migrate to the Environment API
       sharedDuringBuild: true,
       config(userConfig, env2) {
-        if (env2.isPreview) {
-          return { appType: "custom" };
-        }
         resolvedPluginConfig = resolvePluginConfig(
           pluginConfig,
           userConfig,
           env2
         );
+        if (resolvedPluginConfig.type === "preview") {
+          return { appType: "custom" };
+        }
         if (!workersConfigsWarningShown) {
           workersConfigsWarningShown = true;
           const workersConfigsWarning = getWarningForWorkersConfigs(
@@ -14713,7 +14792,7 @@ function cloudflare2(pluginConfig = {}) {
       },
       configResolved(config) {
         resolvedViteConfig = config;
-        if (resolvedPluginConfig?.type === "workers") {
+        if (resolvedPluginConfig.type === "workers") {
           validateWorkerEnvironmentsResolvedConfigs(
             resolvedPluginConfig,
             resolvedViteConfig
@@ -14721,6 +14800,7 @@ function cloudflare2(pluginConfig = {}) {
         }
       },
       generateBundle(_, bundle) {
+        assertIsNotPreview(resolvedPluginConfig);
         let config;
         if (resolvedPluginConfig.type === "workers") {
           const workerConfig = resolvedPluginConfig.workers[this.environment.name];
@@ -14745,9 +14825,9 @@ function cloudflare2(pluginConfig = {}) {
             );
             workerConfig.assets = {
               ...workerConfig.assets,
-              directory: path10.relative(
-                path10.resolve(resolvedViteConfig.root, workerOutputDirectory),
-                path10.resolve(resolvedViteConfig.root, clientOutputDirectory)
+              directory: path11.relative(
+                path11.resolve(resolvedViteConfig.root, workerOutputDirectory),
+                path11.resolve(resolvedViteConfig.root, clientOutputDirectory)
               )
             };
           } else {
@@ -14795,12 +14875,14 @@ function cloudflare2(pluginConfig = {}) {
         });
       },
       writeBundle() {
-        if (this.environment.name === (resolvedPluginConfig.type === "assets-only" ? "client" : resolvedPluginConfig.entryWorkerEnvironmentName)) {
+        assertIsNotPreview(resolvedPluginConfig);
+        if (this.environment.name === (resolvedPluginConfig.type === "workers" ? resolvedPluginConfig.entryWorkerEnvironmentName : "client")) {
           writeDeployConfig(resolvedPluginConfig, resolvedViteConfig);
         }
       },
       hotUpdate(options) {
-        const changedFilePath = path10.resolve(options.file);
+        assertIsNotPreview(resolvedPluginConfig);
+        const changedFilePath = path11.resolve(options.file);
         if (resolvedPluginConfig.configPaths.has(changedFilePath) || hasDotDevDotVarsFileChanged(resolvedPluginConfig, changedFilePath) || hasAssetsConfigChanged(
           resolvedPluginConfig,
           resolvedViteConfig,
@@ -14811,9 +14893,11 @@ function cloudflare2(pluginConfig = {}) {
         }
       },
       async configureServer(viteDevServer) {
+        assertIsNotPreview(resolvedPluginConfig);
         const inputInspectorPort = await getInputInspectorPortOption(
-          pluginConfig,
-          viteDevServer
+          resolvedPluginConfig,
+          viteDevServer,
+          miniflare
         );
         const miniflareDevOptions = await getDevMiniflareOptions(
           resolvedPluginConfig,
@@ -14825,9 +14909,9 @@ function cloudflare2(pluginConfig = {}) {
         } else {
           await miniflare.setOptions(miniflareDevOptions);
         }
-        await initRunners(resolvedPluginConfig, viteDevServer, miniflare);
         let preMiddleware;
         if (resolvedPluginConfig.type === "workers") {
+          await initRunners(resolvedPluginConfig, viteDevServer, miniflare);
           const entryWorkerConfig = getWorkerConfig2(
             resolvedPluginConfig.entryWorkerEnvironmentName
           );
@@ -14901,30 +14985,26 @@ function cloudflare2(pluginConfig = {}) {
         };
       },
       async configurePreviewServer(vitePreviewServer) {
-        const workerConfigs = getWorkerConfigs(
-          vitePreviewServer.config.root,
-          pluginConfig.experimental?.mixedMode ?? false
-        );
+        assertIsPreview(resolvedPluginConfig);
         const inputInspectorPort = await getInputInspectorPortOption(
-          pluginConfig,
+          resolvedPluginConfig,
           vitePreviewServer
         );
-        const miniflare2 = new Miniflare(
+        miniflare = new Miniflare(
           await getPreviewMiniflareOptions(
+            resolvedPluginConfig,
             vitePreviewServer,
-            workerConfigs,
-            pluginConfig.persistState ?? true,
-            !!pluginConfig.experimental?.mixedMode,
             inputInspectorPort
           )
         );
-        handleWebSocket(
-          vitePreviewServer.httpServer,
-          () => miniflare2.dispatchFetch
-        );
+        handleWebSocket(vitePreviewServer.httpServer, () => {
+          assert11(miniflare, `Miniflare not defined`);
+          return miniflare.dispatchFetch;
+        });
         vitePreviewServer.middlewares.use(
           createRequestHandler((request) => {
-            return miniflare2.dispatchFetch(request, { redirect: "manual" });
+            assert11(miniflare, `Miniflare not defined`);
+            return miniflare.dispatchFetch(request, { redirect: "manual" });
           })
         );
       }
@@ -15016,13 +15096,13 @@ function cloudflare2(pluginConfig = {}) {
           }
           const referenceId = this.emitFile({
             type: "asset",
-            name: path10.basename(modulePath),
+            name: path11.basename(modulePath),
             originalFileName: modulePath,
             source
           });
           const emittedFileName = this.getFileName(referenceId);
           const relativePath = vite6.normalizePath(
-            path10.relative(path10.dirname(chunk.fileName), emittedFileName)
+            path11.relative(path11.dirname(chunk.fileName), emittedFileName)
           );
           const importPath = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
           magicString.update(
@@ -15042,9 +15122,6 @@ function cloudflare2(pluginConfig = {}) {
     // Plugin that can provide Node.js compatibility support for Vite Environments that are hosted in Cloudflare Workers.
     {
       name: "vite-plugin-cloudflare:nodejs-compat",
-      apply(_config, env2) {
-        return !env2.isPreview;
-      },
       configEnvironment(name) {
         if (isNodeCompat(getWorkerConfig2(name))) {
           return {
@@ -15141,10 +15218,7 @@ function cloudflare2(pluginConfig = {}) {
     // Plugin that handles Node.js Async Local Storage (ALS) compatibility support for Vite Environments that are hosted in Cloudflare Workers.
     {
       name: "vite-plugin-cloudflare:nodejs-als",
-      apply(_config, env2) {
-        return !env2.isPreview;
-      },
-      configEnvironment(name, config) {
+      configEnvironment(name) {
         if (isNodeAls(getWorkerConfig2(name))) {
           return {
             resolve: {
@@ -15164,51 +15238,54 @@ function cloudflare2(pluginConfig = {}) {
       //       the preview middleware here can take precedence
       enforce: "pre",
       configureServer(viteDevServer) {
+        assertIsNotPreview(resolvedPluginConfig);
         if (resolvedPluginConfig.type === "workers" && pluginConfig.inspectorPort !== false) {
           addDebugToVitePrintUrls(viteDevServer);
         }
-        const workerNames = resolvedPluginConfig.type === "assets-only" ? [] : Object.values(resolvedPluginConfig.workers).map(
+        const workerNames = resolvedPluginConfig.type === "workers" ? Object.values(resolvedPluginConfig.workers).map(
           (worker) => worker.name
-        );
-        viteDevServer.middlewares.use(async (req, res, next) => {
-          const resolvedInspectorPort = await getResolvedInspectorPort(pluginConfig);
-          if (req.url === debuggingPath && resolvedInspectorPort) {
+        ) : [];
+        viteDevServer.middlewares.use(DEBUG_PATH, async (_, res, next) => {
+          const resolvedInspectorPort = await getResolvedInspectorPort(
+            resolvedPluginConfig,
+            miniflare
+          );
+          if (resolvedInspectorPort) {
             const html = getDebugPathHtml(workerNames, resolvedInspectorPort);
             res.setHeader("Content-Type", "text/html");
-            return res.end(html);
+            res.end(html);
+          } else {
+            next();
           }
-          next();
         });
       },
       async configurePreviewServer(vitePreviewServer) {
-        const workerConfigs = getWorkerConfigs(
-          vitePreviewServer.config.root,
-          pluginConfig.experimental?.mixedMode ?? false
-        );
-        if (workerConfigs.length >= 1 && pluginConfig.inspectorPort !== false) {
+        assertIsPreview(resolvedPluginConfig);
+        if (resolvedPluginConfig.workers.length >= 1 && resolvedPluginConfig.inspectorPort !== false) {
           addDebugToVitePrintUrls(vitePreviewServer);
         }
-        const workerNames = workerConfigs.map((worker) => {
+        const workerNames = resolvedPluginConfig.workers.map((worker) => {
           assert11(worker.name, "Expected the Worker to have a name");
           return worker.name;
         });
-        vitePreviewServer.middlewares.use(async (req, res, next) => {
-          const resolvedInspectorPort = await getResolvedInspectorPort(pluginConfig);
-          if (req.url === debuggingPath && resolvedInspectorPort) {
+        vitePreviewServer.middlewares.use(DEBUG_PATH, async (_, res, next) => {
+          const resolvedInspectorPort = await getResolvedInspectorPort(
+            resolvedPluginConfig,
+            miniflare
+          );
+          if (resolvedInspectorPort) {
             const html = getDebugPathHtml(workerNames, resolvedInspectorPort);
             res.setHeader("Content-Type", "text/html");
-            return res.end(html);
+            res.end(html);
+          } else {
+            next();
           }
-          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",
@@ -15224,13 +15301,13 @@ function cloudflare2(pluginConfig = {}) {
                     setup(build) {
                       build.onResolve(
                         { filter: NODEJS_MODULES_RE },
-                        ({ path: path11, importer }) => {
-                          if (isNodeAls(workerConfig) && isNodeAlsModule(path11)) {
+                        ({ path: path12, importer }) => {
+                          if (isNodeAls(workerConfig) && isNodeAlsModule(path12)) {
                             return;
                           }
                           const nodeJsCompatWarnings = nodeJsCompatWarningsMap.get(workerConfig);
-                          nodeJsCompatWarnings?.registerImport(path11, importer);
-                          return { path: path11, external: true };
+                          nodeJsCompatWarnings?.registerImport(path12, importer);
+                          return { path: path12, external: true };
                         }
                       );
                     }
@@ -15273,59 +15350,9 @@ function cloudflare2(pluginConfig = {}) {
     }
   ];
   function getWorkerConfig2(environmentName) {
-    assert11(resolvedPluginConfig, "Expected resolvedPluginConfig to be defined");
-    return resolvedPluginConfig.type !== "assets-only" ? resolvedPluginConfig.workers[environmentName] : void 0;
+    return resolvedPluginConfig.type === "workers" ? resolvedPluginConfig.workers[environmentName] : void 0;
   }
 }
-async function getInputInspectorPortOption(pluginConfig, viteServer) {
-  if (pluginConfig.inspectorPort === void 0 || pluginConfig.inspectorPort === 0) {
-    const resolvedInspectorPort = await getResolvedInspectorPort(pluginConfig);
-    if (resolvedInspectorPort !== null) {
-      return resolvedInspectorPort;
-    }
-  }
-  const inputInspectorPort = pluginConfig.inspectorPort ?? await getFirstAvailablePort(DEFAULT_INSPECTOR_PORT);
-  if (pluginConfig.inspectorPort === void 0 && inputInspectorPort !== DEFAULT_INSPECTOR_PORT) {
-    viteServer.config.logger.warn(
-      colors4.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 = path10.dirname(configPath);
-  const defaultDotDevDotVarsPath = `${configDir}/.dev.vars`;
-  const inputDotDevDotVarsPath = `${defaultDotDevDotVarsPath}${cloudflareEnv ? `.${cloudflareEnv}` : ""}`;
-  const targetPath = fs6.existsSync(inputDotDevDotVarsPath) ? inputDotDevDotVarsPath : fs6.existsSync(defaultDotDevDotVarsPath) ? defaultDotDevDotVarsPath : null;
-  if (targetPath) {
-    const dotDevDotVarsContent = fs6.readFileSync(targetPath);
-    return dotDevDotVarsContent;
-  }
-  return null;
-}
-function hasDotDevDotVarsFileChanged(resolvedPluginConfig, changedFilePath) {
-  return [...resolvedPluginConfig.configPaths].some((configPath) => {
-    const dotDevDotVars = path10.join(path10.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
 };