@cloudflare/vite-plugin 0.0.0-36ef9c620 → 0.0.0-383dc0abd

package/dist/index.js

@@ -1074,709 +1074,11 @@ import { Miniflare } from "miniflare";
 import * as vite6 from "vite";
 
 // src/cloudflare-environment.ts
-import assert from "node:assert";
-import * as vite2 from "vite";
-
-// src/constants.ts
-var ROUTER_WORKER_NAME = "__router-worker__";
-var ASSET_WORKER_NAME = "__asset-worker__";
-var ASSET_WORKERS_COMPATIBILITY_DATE = "2024-10-04";
-var MODULE_TYPES = ["CompiledWasm"];
-
-// src/shared.ts
-var UNKNOWN_HOST = "http://localhost";
-var INIT_PATH = "/__vite_plugin_cloudflare_init__";
-var MODULE_PATTERN = `__CLOUDFLARE_MODULE__(${MODULE_TYPES.join("|")})__(.*?)__`;
-
-// src/utils.ts
-import * as path 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 ?? path.join(rootOutputDirectory, environmentName);
-}
-function toMiniflareRequest(request) {
-  return new MiniflareRequest(request.url, {
-    method: request.method,
-    headers: [["accept-encoding", "identity"], ...request.headers],
-    body: request.body,
-    duplex: "half"
-  });
-}
-function nodeHeadersToWebHeaders(nodeHeaders) {
-  const headers = new Headers();
-  for (const [key, value] of Object.entries(nodeHeaders)) {
-    if (typeof value === "string") {
-      headers.append(key, value);
-    } else if (Array.isArray(value)) {
-      for (const item of value) {
-        headers.append(key, item);
-      }
-    }
-  }
-  return headers;
-}
-
-// src/cloudflare-environment.ts
-var webSocketUndefinedError = "The WebSocket is undefined";
-function createHotChannel(webSocketContainer) {
-  const listenersMap = /* @__PURE__ */ new Map();
-  const client = {
-    send(payload) {
-      const webSocket = webSocketContainer.webSocket;
-      assert(webSocket, webSocketUndefinedError);
-      webSocket.send(JSON.stringify(payload));
-    }
-  };
-  function onMessage(event) {
-    const payload = JSON.parse(event.data.toString());
-    const listeners = listenersMap.get(payload.event) ?? /* @__PURE__ */ new Set();
-    for (const listener of listeners) {
-      listener(payload.data, client);
-    }
-  }
-  return {
-    send(payload) {
-      const webSocket = webSocketContainer.webSocket;
-      assert(webSocket, webSocketUndefinedError);
-      webSocket.send(JSON.stringify(payload));
-    },
-    on(event, listener) {
-      const listeners = listenersMap.get(event) ?? /* @__PURE__ */ new Set();
-      listeners.add(listener);
-      listenersMap.set(event, listeners);
-    },
-    off(event, listener) {
-      listenersMap.get(event)?.delete(listener);
-    },
-    listen() {
-      const webSocket = webSocketContainer.webSocket;
-      assert(webSocket, webSocketUndefinedError);
-      webSocket.addEventListener("message", onMessage);
-    },
-    close() {
-      const webSocket = webSocketContainer.webSocket;
-      assert(webSocket, webSocketUndefinedError);
-      webSocket.removeEventListener("message", onMessage);
-    }
-  };
-}
-var CloudflareDevEnvironment = class extends vite2.DevEnvironment {
-  #webSocketContainer;
-  #worker;
-  constructor(name2, config) {
-    const webSocketContainer = {};
-    super(name2, config, {
-      hot: true,
-      transport: createHotChannel(webSocketContainer)
-    });
-    this.#webSocketContainer = webSocketContainer;
-  }
-  async initRunner(worker) {
-    this.#worker = worker;
-    const response = await this.#worker.fetch(
-      new URL(INIT_PATH, UNKNOWN_HOST),
-      {
-        headers: {
-          upgrade: "websocket"
-        }
-      }
-    );
-    assert(
-      response.ok,
-      `Failed to initialize module runner, error: ${await response.text()}`
-    );
-    const webSocket = response.webSocket;
-    assert(webSocket, "Failed to establish WebSocket");
-    webSocket.accept();
-    this.#webSocketContainer.webSocket = webSocket;
-  }
-};
-var cloudflareBuiltInModules = [
-  "cloudflare:email",
-  "cloudflare:sockets",
-  "cloudflare:workers",
-  "cloudflare:workflows"
-];
-var defaultConditions = ["workerd", "module", "browser"];
-function createCloudflareEnvironmentOptions(workerConfig, userConfig, environmentName) {
-  return {
-    resolve: {
-      // Note: in order for ssr pre-bundling to take effect we need to ask vite to treat all
-      //       dependencies as not external
-      noExternal: true,
-      // We want to use `workerd` package exports if available (e.g. for postgres).
-      conditions: [...defaultConditions, "development|production"],
-      // The Cloudflare ones are proper builtins in the environment
-      builtins: [...cloudflareBuiltInModules]
-    },
-    dev: {
-      createEnvironment(name2, config) {
-        return new CloudflareDevEnvironment(name2, config);
-      }
-    },
-    build: {
-      createEnvironment(name2, config) {
-        return new vite2.BuildEnvironment(name2, config);
-      },
-      target: "es2022",
-      // We need to enable `emitAssets` in order to support additional modules defined by `rules`
-      emitAssets: true,
-      outDir: getOutputDirectory(userConfig, environmentName),
-      copyPublicDir: false,
-      ssr: true,
-      rollupOptions: {
-        // Note: vite starts dev pre-bundling crawling from either optimizeDeps.entries or rollupOptions.input
-        //       so the input value here serves both as the build input as well as the starting point for
-        //       dev pre-bundling crawling (were we not to set this input field we'd have to appropriately set
-        //       optimizeDeps.entries in the dev config)
-        input: workerConfig.main
-      }
-    },
-    optimizeDeps: {
-      // Note: ssr pre-bundling is opt-in and we need to enable it by setting `noDiscovery` to false
-      noDiscovery: false,
-      entries: workerConfig.main,
-      exclude: [...cloudflareBuiltInModules],
-      esbuildOptions: {
-        platform: "neutral",
-        conditions: [...defaultConditions, "development"],
-        resolveExtensions: [
-          ".mjs",
-          ".js",
-          ".mts",
-          ".ts",
-          ".jsx",
-          ".tsx",
-          ".json",
-          ".cjs",
-          ".cts",
-          ".ctx"
-        ]
-      }
-    },
-    keepProcessEnv: false
-  };
-}
-function initRunners(resolvedPluginConfig, viteDevServer, miniflare) {
-  if (resolvedPluginConfig.type === "assets-only") {
-    return;
-  }
-  return Promise.all(
-    Object.entries(resolvedPluginConfig.workers).map(
-      async ([environmentName, workerConfig]) => {
-        const worker = await miniflare.getWorker(workerConfig.name);
-        return viteDevServer.environments[environmentName].initRunner(worker);
-      }
-    )
-  );
-}
-
-// src/deploy-config.ts
-import assert2 from "node:assert";
-import * as fs from "node:fs";
-import * as path2 from "node:path";
-import "vite";
-function getDeployConfigPath(root) {
-  return path2.resolve(root, ".wrangler", "deploy", "config.json");
-}
-function getWorkerConfigPaths(root) {
-  const deployConfigPath = getDeployConfigPath(root);
-  const deployConfig = JSON.parse(
-    fs.readFileSync(deployConfigPath, "utf-8")
-  );
-  return [
-    { configPath: deployConfig.configPath },
-    ...deployConfig.auxiliaryWorkers
-  ].map(
-    ({ configPath }) => path2.resolve(path2.dirname(deployConfigPath), configPath)
-  );
-}
-function getRelativePathToWorkerConfig(deployConfigDirectory, root, outputDirectory) {
-  return path2.relative(
-    deployConfigDirectory,
-    path2.resolve(root, outputDirectory, "wrangler.json")
-  );
-}
-function writeDeployConfig(resolvedPluginConfig, resolvedViteConfig) {
-  const deployConfigPath = getDeployConfigPath(resolvedViteConfig.root);
-  const deployConfigDirectory = path2.dirname(deployConfigPath);
-  fs.mkdirSync(deployConfigDirectory, { recursive: true });
-  if (resolvedPluginConfig.type === "assets-only") {
-    const clientOutputDirectory = resolvedViteConfig.environments.client?.build.outDir;
-    assert2(
-      clientOutputDirectory,
-      "Unexpected error: client environment output directory is undefined"
-    );
-    const deployConfig = {
-      configPath: getRelativePathToWorkerConfig(
-        deployConfigDirectory,
-        resolvedViteConfig.root,
-        clientOutputDirectory
-      ),
-      auxiliaryWorkers: []
-    };
-    fs.writeFileSync(deployConfigPath, JSON.stringify(deployConfig));
-  } else {
-    let entryWorkerConfigPath;
-    const auxiliaryWorkers = [];
-    for (const environmentName of Object.keys(resolvedPluginConfig.workers)) {
-      const outputDirectory = resolvedViteConfig.environments[environmentName]?.build.outDir;
-      assert2(
-        outputDirectory,
-        `Unexpected error: ${environmentName} environment output directory is undefined`
-      );
-      const configPath = getRelativePathToWorkerConfig(
-        deployConfigDirectory,
-        resolvedViteConfig.root,
-        outputDirectory
-      );
-      if (environmentName === resolvedPluginConfig.entryWorkerEnvironmentName) {
-        entryWorkerConfigPath = configPath;
-      } else {
-        auxiliaryWorkers.push({ configPath });
-      }
-    }
-    assert2(
-      entryWorkerConfigPath,
-      `Unexpected error: entryWorkerConfigPath is undefined`
-    );
-    const deployConfig = {
-      configPath: entryWorkerConfigPath,
-      auxiliaryWorkers
-    };
-    fs.writeFileSync(deployConfigPath, JSON.stringify(deployConfig));
-  }
-}
-
-// src/dev.ts
-import assert3 from "node:assert";
-function getDevEntryWorker(resolvedPluginConfig, miniflare) {
-  const entryWorkerConfig = resolvedPluginConfig.type === "assets-only" ? resolvedPluginConfig.config : resolvedPluginConfig.workers[resolvedPluginConfig.entryWorkerEnvironmentName];
-  assert3(entryWorkerConfig, "Unexpected error: No entry worker configuration");
-  return entryWorkerConfig.assets ? miniflare.getWorker(ROUTER_WORKER_NAME) : miniflare.getWorker(entryWorkerConfig.name);
-}
-
-// src/miniflare-options.ts
-import assert4 from "node:assert";
-import * as fs2 from "node:fs";
-import * as fsp from "node:fs/promises";
-import * as path3 from "node:path";
-import { fileURLToPath } from "node:url";
-import {
-  kCurrentWorker,
-  Log,
-  LogLevel,
-  Response as MiniflareResponse
-} from "miniflare";
-import "vite";
-import {
-  unstable_getMiniflareWorkerOptions,
-  unstable_readConfig
-} from "wrangler";
-function getPersistence(root, persistState) {
-  if (persistState === false) {
-    return {};
-  }
-  const defaultPersistPath = ".wrangler/state";
-  const persistPath = path3.resolve(
-    root,
-    typeof persistState === "object" ? persistState.path : defaultPersistPath,
-    "v3"
-  );
-  return {
-    cachePersist: path3.join(persistPath, "cache"),
-    d1Persist: path3.join(persistPath, "d1"),
-    durableObjectsPersist: path3.join(persistPath, "do"),
-    kvPersist: path3.join(persistPath, "kv"),
-    r2Persist: path3.join(persistPath, "r2"),
-    workflowsPersist: path3.join(persistPath, "workflows")
-  };
-}
-function missingWorkerErrorMessage(workerName) {
-  return `${workerName} does not match a worker name.`;
-}
-function getWorkerToWorkerEntrypointNamesMap(workers) {
-  const workerToWorkerEntrypointNamesMap = new Map(
-    workers.map((workerOptions) => [workerOptions.name, /* @__PURE__ */ new Set()])
-  );
-  for (const worker of workers) {
-    for (const value of Object.values(worker.serviceBindings ?? {})) {
-      if (typeof value === "object" && "name" in value && value.entrypoint !== void 0 && value.entrypoint !== "default") {
-        const targetWorkerName = value.name === kCurrentWorker ? worker.name : value.name;
-        const entrypointNames = workerToWorkerEntrypointNamesMap.get(targetWorkerName);
-        assert4(entrypointNames, missingWorkerErrorMessage(targetWorkerName));
-        entrypointNames.add(value.entrypoint);
-      }
-    }
-  }
-  return workerToWorkerEntrypointNamesMap;
-}
-function getWorkerToDurableObjectClassNamesMap(workers) {
-  const workerToDurableObjectClassNamesMap = new Map(
-    workers.map((workerOptions) => [workerOptions.name, /* @__PURE__ */ new Set()])
-  );
-  for (const worker of workers) {
-    for (const value of Object.values(worker.durableObjects ?? {})) {
-      if (typeof value === "string") {
-        const classNames = workerToDurableObjectClassNamesMap.get(worker.name);
-        assert4(classNames, missingWorkerErrorMessage(worker.name));
-        classNames.add(value);
-      } else if (typeof value === "object") {
-        if (value.scriptName) {
-          const classNames = workerToDurableObjectClassNamesMap.get(
-            value.scriptName
-          );
-          assert4(classNames, missingWorkerErrorMessage(value.scriptName));
-          classNames.add(value.className);
-        } else {
-          const classNames = workerToDurableObjectClassNamesMap.get(
-            worker.name
-          );
-          assert4(classNames, missingWorkerErrorMessage(worker.name));
-          classNames.add(value.className);
-        }
-      }
-    }
-  }
-  return workerToDurableObjectClassNamesMap;
-}
-function getWorkerToWorkflowEntrypointClassNamesMap(workers) {
-  const workerToWorkflowEntrypointClassNamesMap = new Map(
-    workers.map((workerOptions) => [workerOptions.name, /* @__PURE__ */ new Set()])
-  );
-  for (const worker of workers) {
-    for (const value of Object.values(worker.workflows ?? {})) {
-      if (value.scriptName) {
-        const classNames = workerToWorkflowEntrypointClassNamesMap.get(
-          value.scriptName
-        );
-        assert4(classNames, missingWorkerErrorMessage(value.scriptName));
-        classNames.add(value.className);
-      } else {
-        const classNames = workerToWorkflowEntrypointClassNamesMap.get(
-          worker.name
-        );
-        assert4(classNames, missingWorkerErrorMessage(worker.name));
-        classNames.add(value.className);
-      }
-    }
-  }
-  return workerToWorkflowEntrypointClassNamesMap;
-}
-var miniflareModulesRoot = process.platform === "win32" ? "Z:\\" : "/";
-var ROUTER_WORKER_PATH = "./asset-workers/router-worker.js";
-var ASSET_WORKER_PATH = "./asset-workers/asset-worker.js";
-var WRAPPER_PATH = "__VITE_WORKER_ENTRY__";
-var RUNNER_PATH = "./runner-worker/index.js";
-function getEntryWorkerConfig(resolvedPluginConfig) {
-  if (resolvedPluginConfig.type === "assets-only") {
-    return;
-  }
-  return resolvedPluginConfig.workers[resolvedPluginConfig.entryWorkerEnvironmentName];
-}
-function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
-  const resolvedViteConfig = viteDevServer.config;
-  const entryWorkerConfig = getEntryWorkerConfig(resolvedPluginConfig);
-  const assetsConfig = resolvedPluginConfig.type === "assets-only" ? resolvedPluginConfig.config.assets : entryWorkerConfig?.assets;
-  const assetWorkers = [
-    {
-      name: ROUTER_WORKER_NAME,
-      compatibilityDate: ASSET_WORKERS_COMPATIBILITY_DATE,
-      modulesRoot: miniflareModulesRoot,
-      modules: [
-        {
-          type: "ESModule",
-          path: path3.join(miniflareModulesRoot, ROUTER_WORKER_PATH),
-          contents: fs2.readFileSync(
-            fileURLToPath(new URL(ROUTER_WORKER_PATH, import.meta.url))
-          )
-        }
-      ],
-      bindings: {
-        CONFIG: {
-          has_user_worker: resolvedPluginConfig.type === "workers"
-        }
-      },
-      serviceBindings: {
-        ASSET_WORKER: ASSET_WORKER_NAME,
-        ...entryWorkerConfig ? { USER_WORKER: entryWorkerConfig.name } : {}
-      }
-    },
-    {
-      name: ASSET_WORKER_NAME,
-      compatibilityDate: ASSET_WORKERS_COMPATIBILITY_DATE,
-      modulesRoot: miniflareModulesRoot,
-      modules: [
-        {
-          type: "ESModule",
-          path: path3.join(miniflareModulesRoot, ASSET_WORKER_PATH),
-          contents: fs2.readFileSync(
-            fileURLToPath(new URL(ASSET_WORKER_PATH, import.meta.url))
-          )
-        }
-      ],
-      bindings: {
-        CONFIG: {
-          ...assetsConfig?.html_handling ? { html_handling: assetsConfig.html_handling } : {},
-          ...assetsConfig?.not_found_handling ? { not_found_handling: assetsConfig.not_found_handling } : {}
-        }
-      },
-      serviceBindings: {
-        __VITE_ASSET_EXISTS__: async (request) => {
-          const { pathname } = new URL(request.url);
-          const filePath = path3.join(resolvedViteConfig.root, pathname);
-          let exists;
-          try {
-            exists = fs2.statSync(filePath).isFile();
-          } catch (error) {
-            exists = false;
-          }
-          return MiniflareResponse.json(exists);
-        },
-        __VITE_FETCH_ASSET__: async (request) => {
-          const { pathname } = new URL(request.url);
-          const filePath = path3.join(resolvedViteConfig.root, pathname);
-          try {
-            let html = await fsp.readFile(filePath, "utf-8");
-            html = await viteDevServer.transformIndexHtml(pathname, html);
-            return new MiniflareResponse(html, {
-              headers: { "Content-Type": "text/html" }
-            });
-          } catch (error) {
-            throw new Error(`Unexpected error. Failed to load ${pathname}`);
-          }
-        }
-      }
-    }
-  ];
-  const userWorkers = resolvedPluginConfig.type === "workers" ? Object.entries(resolvedPluginConfig.workers).map(
-    ([environmentName, workerConfig]) => {
-      const miniflareWorkerOptions = unstable_getMiniflareWorkerOptions(
-        {
-          ...workerConfig,
-          assets: void 0
-        },
-        resolvedPluginConfig.cloudflareEnv
-      );
-      const { ratelimits, ...workerOptions } = miniflareWorkerOptions.workerOptions;
-      return {
-        ...workerOptions,
-        // We have to add the name again because `unstable_getMiniflareWorkerOptions` sets it to `undefined`
-        name: workerConfig.name,
-        modulesRoot: miniflareModulesRoot,
-        unsafeEvalBinding: "__VITE_UNSAFE_EVAL__",
-        bindings: {
-          ...workerOptions.bindings,
-          __VITE_ROOT__: resolvedViteConfig.root,
-          __VITE_ENTRY_PATH__: workerConfig.main
-        },
-        serviceBindings: {
-          ...workerOptions.serviceBindings,
-          ...environmentName === resolvedPluginConfig.entryWorkerEnvironmentName && workerConfig.assets?.binding ? {
-            [workerConfig.assets.binding]: ASSET_WORKER_NAME
-          } : {},
-          __VITE_INVOKE_MODULE__: async (request) => {
-            const payload = await request.json();
-            const invokePayloadData = payload.data;
-            assert4(
-              invokePayloadData.name === "fetchModule",
-              `Invalid invoke event: ${invokePayloadData.name}`
-            );
-            const [moduleId] = invokePayloadData.data;
-            const moduleRE = new RegExp(MODULE_PATTERN);
-            const shouldExternalize = (
-              // Worker modules (CompiledWasm, Text, Data)
-              moduleRE.test(moduleId)
-            );
-            if (shouldExternalize) {
-              const result2 = {
-                externalize: moduleId,
-                type: "module"
-              };
-              return MiniflareResponse.json({ result: result2 });
-            }
-            const devEnvironment = viteDevServer.environments[environmentName];
-            const result = await devEnvironment.hot.handleInvoke(payload);
-            return MiniflareResponse.json(result);
-          }
-        }
-      };
-    }
-  ) : [];
-  const workerToWorkerEntrypointNamesMap = getWorkerToWorkerEntrypointNamesMap(userWorkers);
-  const workerToDurableObjectClassNamesMap = getWorkerToDurableObjectClassNamesMap(userWorkers);
-  const workerToWorkflowEntrypointClassNamesMap = getWorkerToWorkflowEntrypointClassNamesMap(userWorkers);
-  const logger = new ViteMiniflareLogger(resolvedViteConfig);
-  return {
-    log: logger,
-    handleRuntimeStdio(stdout, stderr) {
-      const decoder = new TextDecoder();
-      stdout.forEach((data2) => logger.info(decoder.decode(data2)));
-      stderr.forEach(
-        (error) => logger.logWithLevel(LogLevel.ERROR, decoder.decode(error))
-      );
-    },
-    ...getPersistence(
-      resolvedViteConfig.root,
-      resolvedPluginConfig.persistState
-    ),
-    workers: [
-      ...assetWorkers,
-      ...userWorkers.map((workerOptions) => {
-        const wrappers = [
-          `import { createWorkerEntrypointWrapper, createDurableObjectWrapper, createWorkflowEntrypointWrapper } from '${RUNNER_PATH}';`,
-          `export default createWorkerEntrypointWrapper('default');`
-        ];
-        const workerEntrypointNames = workerToWorkerEntrypointNamesMap.get(
-          workerOptions.name
-        );
-        assert4(
-          workerEntrypointNames,
-          `WorkerEntrypoint names not found for worker ${workerOptions.name}`
-        );
-        for (const entrypointName of [...workerEntrypointNames].sort()) {
-          wrappers.push(
-            `export const ${entrypointName} = createWorkerEntrypointWrapper('${entrypointName}');`
-          );
-        }
-        const durableObjectClassNames = workerToDurableObjectClassNamesMap.get(
-          workerOptions.name
-        );
-        assert4(
-          durableObjectClassNames,
-          `DurableObject class names not found for worker ${workerOptions.name}`
-        );
-        for (const className of [...durableObjectClassNames].sort()) {
-          wrappers.push(
-            `export const ${className} = createDurableObjectWrapper('${className}');`
-          );
-        }
-        const workflowEntrypointClassNames = workerToWorkflowEntrypointClassNamesMap.get(workerOptions.name);
-        assert4(
-          workflowEntrypointClassNames,
-          `WorkflowEntrypoint class names not found for worker ${workerOptions.name}`
-        );
-        for (const className of [...workflowEntrypointClassNames].sort()) {
-          wrappers.push(
-            `export const ${className} = createWorkflowEntrypointWrapper('${className}');`
-          );
-        }
-        return {
-          ...workerOptions,
-          modules: [
-            {
-              type: "ESModule",
-              path: path3.join(miniflareModulesRoot, WRAPPER_PATH),
-              contents: wrappers.join("\n")
-            },
-            {
-              type: "ESModule",
-              path: path3.join(miniflareModulesRoot, RUNNER_PATH),
-              contents: fs2.readFileSync(
-                fileURLToPath(new URL(RUNNER_PATH, import.meta.url))
-              )
-            }
-          ],
-          unsafeUseModuleFallbackService: true
-        };
-      })
-    ],
-    unsafeModuleFallbackService(request) {
-      const url = new URL(request.url);
-      const rawSpecifier = url.searchParams.get("rawSpecifier");
-      assert4(
-        rawSpecifier,
-        `Unexpected error: no specifier in request to module fallback service.`
-      );
-      const moduleRE = new RegExp(MODULE_PATTERN);
-      const match = moduleRE.exec(rawSpecifier);
-      assert4(match, `Unexpected error: no match for module ${rawSpecifier}.`);
-      const [full, moduleType, modulePath] = match;
-      assert4(
-        modulePath,
-        `Unexpected error: module path not found in reference ${full}.`
-      );
-      let source;
-      try {
-        source = fs2.readFileSync(modulePath);
-      } catch (error) {
-        throw new Error(`Import ${modulePath} not found. Does the file exist?`);
-      }
-      return MiniflareResponse.json({
-        // Cap'n Proto expects byte arrays for `:Data` typed fields from JSON
-        wasm: Array.from(source)
-      });
-    }
-  };
-}
-function getPreviewMiniflareOptions(vitePreviewServer, persistState) {
-  const resolvedViteConfig = vitePreviewServer.config;
-  const configPaths = getWorkerConfigPaths(resolvedViteConfig.root);
-  const workerConfigs = configPaths.map(
-    (configPath) => unstable_readConfig({ config: configPath })
-  );
-  const workers = workerConfigs.map((config) => {
-    const miniflareWorkerOptions = unstable_getMiniflareWorkerOptions(config);
-    const { ratelimits, ...workerOptions } = miniflareWorkerOptions.workerOptions;
-    return {
-      ...workerOptions,
-      // We have to add the name again because `unstable_getMiniflareWorkerOptions` sets it to `undefined`
-      name: config.name,
-      modules: true,
-      ...miniflareWorkerOptions.main ? { scriptPath: miniflareWorkerOptions.main } : { script: "" }
-    };
-  });
-  const logger = new ViteMiniflareLogger(resolvedViteConfig);
-  return {
-    log: logger,
-    handleRuntimeStdio(stdout, stderr) {
-      const decoder = new TextDecoder();
-      stdout.forEach((data2) => logger.info(decoder.decode(data2)));
-      stderr.forEach(
-        (error) => logger.logWithLevel(LogLevel.ERROR, decoder.decode(error))
-      );
-    },
-    ...getPersistence(resolvedViteConfig.root, persistState),
-    workers
-  };
-}
-var ViteMiniflareLogger = class extends Log {
-  logger;
-  constructor(config) {
-    super(miniflareLogLevelFromViteLogLevel(config.logLevel));
-    this.logger = config.logger;
-  }
-  logWithLevel(level, message) {
-    if (/^Ready on http/.test(message)) {
-      level = LogLevel.DEBUG;
-    }
-    switch (level) {
-      case LogLevel.ERROR:
-        return this.logger.error(message);
-      case LogLevel.WARN:
-        return this.logger.warn(message);
-      case LogLevel.INFO:
-        return this.logger.info(message);
-    }
-  }
-};
-function miniflareLogLevelFromViteLogLevel(level = "info") {
-  switch (level) {
-    case "error":
-      return LogLevel.ERROR;
-    case "warn":
-      return LogLevel.WARN;
-    case "info":
-      return LogLevel.INFO;
-    case "silent":
-      return LogLevel.NONE;
-  }
-}
+import assert3 from "node:assert";
+import * as vite2 from "vite";
 
 // src/node-js-compat.ts
-import assert6 from "node:assert";
+import assert2 from "node:assert";
 import { cloudflare } from "@cloudflare/unenv-preset";
 import { getNodeCompat } from "miniflare";
 
@@ -7309,7 +6611,7 @@ Parser.acorn = {
 
 // ../../node_modules/.pnpm/mlly@1.7.4/node_modules/mlly/dist/index.mjs
 import { builtinModules, createRequire } from "node:module";
-import fs3, { realpathSync, statSync as statSync2, promises } from "node:fs";
+import fs, { realpathSync, statSync, promises } from "node:fs";
 
 // ../../node_modules/.pnpm/ufo@1.5.4/node_modules/ufo/dist/index.mjs
 var r = String.fromCharCode;
@@ -7366,9 +6668,9 @@ var isAbsolute = function(p) {
 
 // ../../node_modules/.pnpm/mlly@1.7.4/node_modules/mlly/dist/index.mjs
 import { fileURLToPath as fileURLToPath$1, URL as URL$1, pathToFileURL as pathToFileURL$1 } from "node:url";
-import assert5 from "node:assert";
+import assert from "node:assert";
 import process$1 from "node:process";
-import path4, { dirname as dirname3 } from "node:path";
+import path, { 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);
@@ -7404,7 +6706,7 @@ codes.ERR_INVALID_ARG_TYPE = createError(
    * @param {unknown} actual
    */
   (name2, expected, actual) => {
-    assert5(typeof name2 === "string", "'name' must be a string");
+    assert(typeof name2 === "string", "'name' must be a string");
     if (!Array.isArray(expected)) {
       expected = [expected];
     }
@@ -7420,14 +6722,14 @@ codes.ERR_INVALID_ARG_TYPE = createError(
     const instances = [];
     const other = [];
     for (const value of expected) {
-      assert5(
+      assert(
         typeof value === "string",
         "All expected entries have to be of type string"
       );
       if (kTypes.has(value)) {
         types2.push(value.toLowerCase());
       } else if (classRegExp.exec(value) === null) {
-        assert5(
+        assert(
           value !== "object",
           'The value "object" should be written as "Object"'
         );
@@ -7500,14 +6802,14 @@ codes.ERR_INVALID_PACKAGE_TARGET = createError(
    * @param {boolean} [isImport=false]
    * @param {string} [base]
    */
-  (packagePath, key, target, isImport = false, base = void 0) => {
-    const relatedError = typeof target === "string" && !isImport && target.length > 0 && !target.startsWith("./");
+  (packagePath, key, target2, isImport = false, base = void 0) => {
+    const relatedError = typeof target2 === "string" && !isImport && target2.length > 0 && !target2.startsWith("./");
     if (key === ".") {
-      assert5(isImport === false);
-      return `Invalid "exports" main target ${JSON.stringify(target)} defined in the package config ${packagePath}package.json${base ? ` imported from ${base}` : ""}${relatedError ? '; targets must start with "./"' : ""}`;
+      assert(isImport === false);
+      return `Invalid "exports" main target ${JSON.stringify(target2)} defined in the package config ${packagePath}package.json${base ? ` imported from ${base}` : ""}${relatedError ? '; targets must start with "./"' : ""}`;
     }
     return `Invalid "${isImport ? "imports" : "exports"}" target ${JSON.stringify(
-      target
+      target2
     )} defined for '${key}' in the package config ${packagePath}package.json${base ? ` imported from ${base}` : ""}${relatedError ? '; targets must start with "./"' : ""}`;
   },
   Error
@@ -7668,9 +6970,9 @@ var captureLargerStackTrace = hideStackFrames(
 );
 function getMessage(key, parameters, self) {
   const message = messages.get(key);
-  assert5(message !== void 0, "expected `message` to be found");
+  assert(message !== void 0, "expected `message` to be found");
   if (typeof message === "function") {
-    assert5(
+    assert(
       message.length <= parameters.length,
       // Default options do not count.
       `Code: ${key}; The provided arguments length (${parameters.length}) does not match the required ones (${message.length}).`
@@ -7680,7 +6982,7 @@ function getMessage(key, parameters, self) {
   const regex = /%[dfijoOs]/g;
   let expectedLength = 0;
   while (regex.exec(message) !== null) expectedLength++;
-  assert5(
+  assert(
     expectedLength === parameters.length,
     `Code: ${key}; The provided arguments length (${parameters.length}) does not match the required ones (${expectedLength}).`
   );
@@ -7717,7 +7019,7 @@ function read(jsonPath, { base, specifier }) {
   }
   let string;
   try {
-    string = fs3.readFileSync(path4.toNamespacedPath(jsonPath), "utf8");
+    string = fs.readFileSync(path.toNamespacedPath(jsonPath), "utf8");
   } catch (error) {
     const exception = (
       /** @type {ErrnoException} */
@@ -7903,14 +7205,14 @@ var patternRegEx = /\*/g;
 var encodedSeparatorRegEx = /%2f|%5c/i;
 var emittedPackageWarnings = /* @__PURE__ */ new Set();
 var doubleSlashRegEx = /[/\\]{2}/;
-function emitInvalidSegmentDeprecation(target, request, match, packageJsonUrl, internal, base, isTarget) {
+function emitInvalidSegmentDeprecation(target2, request, match, packageJsonUrl, internal, base, isTarget) {
   if (process$1.noDeprecation) {
     return;
   }
   const pjsonPath = fileURLToPath$1(packageJsonUrl);
-  const double = doubleSlashRegEx.exec(isTarget ? target : request) !== null;
+  const double = doubleSlashRegEx.exec(isTarget ? target2 : request) !== null;
   process$1.emitWarning(
-    `Use of deprecated ${double ? "double slash" : "leading or trailing slash matching"} resolving "${target}" for module request "${request}" ${request === match ? "" : `matched to "${match}" `}in the "${internal ? "imports" : "exports"}" field module resolution of the package at ${pjsonPath}${base ? ` imported from ${fileURLToPath$1(base)}` : ""}.`,
+    `Use of deprecated ${double ? "double slash" : "leading or trailing slash matching"} resolving "${target2}" for module request "${request}" ${request === match ? "" : `matched to "${match}" `}in the "${internal ? "imports" : "exports"}" field module resolution of the package at ${pjsonPath}${base ? ` imported from ${fileURLToPath$1(base)}` : ""}.`,
     "DeprecationWarning",
     "DEP0166"
   );
@@ -7933,7 +7235,7 @@ Default "index" lookups for the main are deprecated for ES modules.`,
       "DeprecationWarning",
       "DEP0151"
     );
-  } else if (path4.resolve(packagePath, main) !== urlPath) {
+  } else if (path.resolve(packagePath, main) !== urlPath) {
     process$1.emitWarning(
       `Package ${packagePath} has a "main" field set to "${main}", excluding the full filename and extension to the resolved file at "${urlPath.slice(
         packagePath.length
@@ -7946,12 +7248,12 @@ Default "index" lookups for the main are deprecated for ES modules.`,
 }
 function tryStatSync(path8) {
   try {
-    return statSync2(path8);
+    return statSync(path8);
   } catch {
   }
 }
 function fileExists(url) {
-  const stats = statSync2(url, { throwIfNoEntry: false });
+  const stats = statSync(url, { throwIfNoEntry: false });
   const isFile = stats ? stats.isFile() : void 0;
   return isFile === null || isFile === void 0 ? false : isFile;
 }
@@ -8040,7 +7342,7 @@ function finalizeResolution(resolved, base, preserveSymlinks) {
   {
     const real = realpathSync(filePath);
     const { search, hash } = resolved;
-    resolved = pathToFileURL$1(real + (filePath.endsWith(path4.sep) ? "/" : ""));
+    resolved = pathToFileURL$1(real + (filePath.endsWith(path.sep) ? "/" : ""));
     resolved.search = search;
     resolved.hash = hash;
   }
@@ -8068,47 +7370,47 @@ function throwInvalidSubpath(request, match, packageJsonUrl, internal, base) {
     base && fileURLToPath$1(base)
   );
 }
-function invalidPackageTarget(subpath, target, packageJsonUrl, internal, base) {
-  target = typeof target === "object" && target !== null ? JSON.stringify(target, null, "") : `${target}`;
+function invalidPackageTarget(subpath, target2, packageJsonUrl, internal, base) {
+  target2 = typeof target2 === "object" && target2 !== null ? JSON.stringify(target2, null, "") : `${target2}`;
   return new ERR_INVALID_PACKAGE_TARGET(
     fileURLToPath$1(new URL$1(".", packageJsonUrl)),
     subpath,
-    target,
+    target2,
     internal,
     base && fileURLToPath$1(base)
   );
 }
-function resolvePackageTargetString(target, subpath, match, packageJsonUrl, base, pattern, internal, isPathMap, conditions) {
-  if (subpath !== "" && !pattern && target[target.length - 1] !== "/")
-    throw invalidPackageTarget(match, target, packageJsonUrl, internal, base);
-  if (!target.startsWith("./")) {
-    if (internal && !target.startsWith("../") && !target.startsWith("/")) {
+function resolvePackageTargetString(target2, subpath, match, packageJsonUrl, base, pattern, internal, isPathMap, conditions) {
+  if (subpath !== "" && !pattern && target2[target2.length - 1] !== "/")
+    throw invalidPackageTarget(match, target2, packageJsonUrl, internal, base);
+  if (!target2.startsWith("./")) {
+    if (internal && !target2.startsWith("../") && !target2.startsWith("/")) {
       let isURL = false;
       try {
-        new URL$1(target);
+        new URL$1(target2);
         isURL = true;
       } catch {
       }
       if (!isURL) {
         const exportTarget = pattern ? RegExpPrototypeSymbolReplace.call(
           patternRegEx,
-          target,
+          target2,
           () => subpath
-        ) : target + subpath;
+        ) : target2 + subpath;
         return packageResolve(exportTarget, packageJsonUrl, conditions);
       }
     }
-    throw invalidPackageTarget(match, target, packageJsonUrl, internal, base);
+    throw invalidPackageTarget(match, target2, packageJsonUrl, internal, base);
   }
-  if (invalidSegmentRegEx.exec(target.slice(2)) !== null) {
-    if (deprecatedInvalidSegmentRegEx.exec(target.slice(2)) === null) {
+  if (invalidSegmentRegEx.exec(target2.slice(2)) !== null) {
+    if (deprecatedInvalidSegmentRegEx.exec(target2.slice(2)) === null) {
       if (!isPathMap) {
         const request = pattern ? match.replace("*", () => subpath) : match + subpath;
         const resolvedTarget = pattern ? RegExpPrototypeSymbolReplace.call(
           patternRegEx,
-          target,
+          target2,
           () => subpath
-        ) : target;
+        ) : target2;
         emitInvalidSegmentDeprecation(
           resolvedTarget,
           request,
@@ -8119,684 +7421,1413 @@ function resolvePackageTargetString(target, subpath, match, packageJsonUrl, base
           true
         );
       }
-    } else {
-      throw invalidPackageTarget(match, target, packageJsonUrl, internal, base);
-    }
-  }
-  const resolved = new URL$1(target, packageJsonUrl);
-  const resolvedPath = resolved.pathname;
-  const packagePath = new URL$1(".", packageJsonUrl).pathname;
-  if (!resolvedPath.startsWith(packagePath))
-    throw invalidPackageTarget(match, target, packageJsonUrl, internal, base);
-  if (subpath === "") return resolved;
-  if (invalidSegmentRegEx.exec(subpath) !== null) {
-    const request = pattern ? match.replace("*", () => subpath) : match + subpath;
-    if (deprecatedInvalidSegmentRegEx.exec(subpath) === null) {
-      if (!isPathMap) {
-        const resolvedTarget = pattern ? RegExpPrototypeSymbolReplace.call(
-          patternRegEx,
-          target,
-          () => subpath
-        ) : target;
-        emitInvalidSegmentDeprecation(
-          resolvedTarget,
-          request,
-          match,
-          packageJsonUrl,
-          internal,
-          base,
-          false
+    } else {
+      throw invalidPackageTarget(match, target2, packageJsonUrl, internal, base);
+    }
+  }
+  const resolved = new URL$1(target2, packageJsonUrl);
+  const resolvedPath = resolved.pathname;
+  const packagePath = new URL$1(".", packageJsonUrl).pathname;
+  if (!resolvedPath.startsWith(packagePath))
+    throw invalidPackageTarget(match, target2, packageJsonUrl, internal, base);
+  if (subpath === "") return resolved;
+  if (invalidSegmentRegEx.exec(subpath) !== null) {
+    const request = pattern ? match.replace("*", () => subpath) : match + subpath;
+    if (deprecatedInvalidSegmentRegEx.exec(subpath) === null) {
+      if (!isPathMap) {
+        const resolvedTarget = pattern ? RegExpPrototypeSymbolReplace.call(
+          patternRegEx,
+          target2,
+          () => subpath
+        ) : target2;
+        emitInvalidSegmentDeprecation(
+          resolvedTarget,
+          request,
+          match,
+          packageJsonUrl,
+          internal,
+          base,
+          false
+        );
+      }
+    } else {
+      throwInvalidSubpath(request, match, packageJsonUrl, internal, base);
+    }
+  }
+  if (pattern) {
+    return new URL$1(
+      RegExpPrototypeSymbolReplace.call(
+        patternRegEx,
+        resolved.href,
+        () => subpath
+      )
+    );
+  }
+  return new URL$1(subpath, resolved);
+}
+function isArrayIndex(key) {
+  const keyNumber = Number(key);
+  if (`${keyNumber}` !== key) return false;
+  return keyNumber >= 0 && keyNumber < 4294967295;
+}
+function resolvePackageTarget(packageJsonUrl, target2, subpath, packageSubpath, base, pattern, internal, isPathMap, conditions) {
+  if (typeof target2 === "string") {
+    return resolvePackageTargetString(
+      target2,
+      subpath,
+      packageSubpath,
+      packageJsonUrl,
+      base,
+      pattern,
+      internal,
+      isPathMap,
+      conditions
+    );
+  }
+  if (Array.isArray(target2)) {
+    const targetList = target2;
+    if (targetList.length === 0) return null;
+    let lastException;
+    let i = -1;
+    while (++i < targetList.length) {
+      const targetItem = targetList[i];
+      let resolveResult;
+      try {
+        resolveResult = resolvePackageTarget(
+          packageJsonUrl,
+          targetItem,
+          subpath,
+          packageSubpath,
+          base,
+          pattern,
+          internal,
+          isPathMap,
+          conditions
+        );
+      } catch (error) {
+        const exception = (
+          /** @type {ErrnoException} */
+          error
+        );
+        lastException = exception;
+        if (exception.code === "ERR_INVALID_PACKAGE_TARGET") continue;
+        throw error;
+      }
+      if (resolveResult === void 0) continue;
+      if (resolveResult === null) {
+        lastException = null;
+        continue;
+      }
+      return resolveResult;
+    }
+    if (lastException === void 0 || lastException === null) {
+      return null;
+    }
+    throw lastException;
+  }
+  if (typeof target2 === "object" && target2 !== null) {
+    const keys = Object.getOwnPropertyNames(target2);
+    let i = -1;
+    while (++i < keys.length) {
+      const key = keys[i];
+      if (isArrayIndex(key)) {
+        throw new ERR_INVALID_PACKAGE_CONFIG(
+          fileURLToPath$1(packageJsonUrl),
+          base,
+          '"exports" cannot contain numeric property keys.'
+        );
+      }
+    }
+    i = -1;
+    while (++i < keys.length) {
+      const key = keys[i];
+      if (key === "default" || conditions && conditions.has(key)) {
+        const conditionalTarget = (
+          /** @type {unknown} */
+          target2[key]
+        );
+        const resolveResult = resolvePackageTarget(
+          packageJsonUrl,
+          conditionalTarget,
+          subpath,
+          packageSubpath,
+          base,
+          pattern,
+          internal,
+          isPathMap,
+          conditions
+        );
+        if (resolveResult === void 0) continue;
+        return resolveResult;
+      }
+    }
+    return null;
+  }
+  if (target2 === null) {
+    return null;
+  }
+  throw invalidPackageTarget(
+    packageSubpath,
+    target2,
+    packageJsonUrl,
+    internal,
+    base
+  );
+}
+function isConditionalExportsMainSugar(exports, packageJsonUrl, base) {
+  if (typeof exports === "string" || Array.isArray(exports)) return true;
+  if (typeof exports !== "object" || exports === null) return false;
+  const keys = Object.getOwnPropertyNames(exports);
+  let isConditionalSugar = false;
+  let i = 0;
+  let keyIndex = -1;
+  while (++keyIndex < keys.length) {
+    const key = keys[keyIndex];
+    const currentIsConditionalSugar = key === "" || key[0] !== ".";
+    if (i++ === 0) {
+      isConditionalSugar = currentIsConditionalSugar;
+    } else if (isConditionalSugar !== currentIsConditionalSugar) {
+      throw new ERR_INVALID_PACKAGE_CONFIG(
+        fileURLToPath$1(packageJsonUrl),
+        base,
+        `"exports" cannot contain some keys starting with '.' and some not. The exports object must either be an object of package subpath keys or an object of main entry condition name keys only.`
+      );
+    }
+  }
+  return isConditionalSugar;
+}
+function emitTrailingSlashPatternDeprecation(match, pjsonUrl, base) {
+  if (process$1.noDeprecation) {
+    return;
+  }
+  const pjsonPath = fileURLToPath$1(pjsonUrl);
+  if (emittedPackageWarnings.has(pjsonPath + "|" + match)) return;
+  emittedPackageWarnings.add(pjsonPath + "|" + match);
+  process$1.emitWarning(
+    `Use of deprecated trailing slash pattern mapping "${match}" in the "exports" field module resolution of the package at ${pjsonPath}${base ? ` imported from ${fileURLToPath$1(base)}` : ""}. Mapping specifiers ending in "/" is no longer supported.`,
+    "DeprecationWarning",
+    "DEP0155"
+  );
+}
+function packageExportsResolve(packageJsonUrl, packageSubpath, packageConfig, base, conditions) {
+  let exports = packageConfig.exports;
+  if (isConditionalExportsMainSugar(exports, packageJsonUrl, base)) {
+    exports = { ".": exports };
+  }
+  if (own.call(exports, packageSubpath) && !packageSubpath.includes("*") && !packageSubpath.endsWith("/")) {
+    const target2 = exports[packageSubpath];
+    const resolveResult = resolvePackageTarget(
+      packageJsonUrl,
+      target2,
+      "",
+      packageSubpath,
+      base,
+      false,
+      false,
+      false,
+      conditions
+    );
+    if (resolveResult === null || resolveResult === void 0) {
+      throw exportsNotFound(packageSubpath, packageJsonUrl, base);
+    }
+    return resolveResult;
+  }
+  let bestMatch = "";
+  let bestMatchSubpath = "";
+  const keys = Object.getOwnPropertyNames(exports);
+  let i = -1;
+  while (++i < keys.length) {
+    const key = keys[i];
+    const patternIndex = key.indexOf("*");
+    if (patternIndex !== -1 && packageSubpath.startsWith(key.slice(0, patternIndex))) {
+      if (packageSubpath.endsWith("/")) {
+        emitTrailingSlashPatternDeprecation(
+          packageSubpath,
+          packageJsonUrl,
+          base
+        );
+      }
+      const patternTrailer = key.slice(patternIndex + 1);
+      if (packageSubpath.length >= key.length && packageSubpath.endsWith(patternTrailer) && patternKeyCompare(bestMatch, key) === 1 && key.lastIndexOf("*") === patternIndex) {
+        bestMatch = key;
+        bestMatchSubpath = packageSubpath.slice(
+          patternIndex,
+          packageSubpath.length - patternTrailer.length
         );
       }
-    } else {
-      throwInvalidSubpath(request, match, packageJsonUrl, internal, base);
     }
   }
-  if (pattern) {
-    return new URL$1(
-      RegExpPrototypeSymbolReplace.call(
-        patternRegEx,
-        resolved.href,
-        () => subpath
-      )
+  if (bestMatch) {
+    const target2 = (
+      /** @type {unknown} */
+      exports[bestMatch]
     );
-  }
-  return new URL$1(subpath, resolved);
-}
-function isArrayIndex(key) {
-  const keyNumber = Number(key);
-  if (`${keyNumber}` !== key) return false;
-  return keyNumber >= 0 && keyNumber < 4294967295;
-}
-function resolvePackageTarget(packageJsonUrl, target, subpath, packageSubpath, base, pattern, internal, isPathMap, conditions) {
-  if (typeof target === "string") {
-    return resolvePackageTargetString(
-      target,
-      subpath,
-      packageSubpath,
+    const resolveResult = resolvePackageTarget(
       packageJsonUrl,
+      target2,
+      bestMatchSubpath,
+      bestMatch,
       base,
-      pattern,
-      internal,
-      isPathMap,
+      true,
+      false,
+      packageSubpath.endsWith("/"),
       conditions
     );
+    if (resolveResult === null || resolveResult === void 0) {
+      throw exportsNotFound(packageSubpath, packageJsonUrl, base);
+    }
+    return resolveResult;
   }
-  if (Array.isArray(target)) {
-    const targetList = target;
-    if (targetList.length === 0) return null;
-    let lastException;
-    let i = -1;
-    while (++i < targetList.length) {
-      const targetItem = targetList[i];
-      let resolveResult;
-      try {
-        resolveResult = resolvePackageTarget(
+  throw exportsNotFound(packageSubpath, packageJsonUrl, base);
+}
+function patternKeyCompare(a, b) {
+  const aPatternIndex = a.indexOf("*");
+  const bPatternIndex = b.indexOf("*");
+  const baseLengthA = aPatternIndex === -1 ? a.length : aPatternIndex + 1;
+  const baseLengthB = bPatternIndex === -1 ? b.length : bPatternIndex + 1;
+  if (baseLengthA > baseLengthB) return -1;
+  if (baseLengthB > baseLengthA) return 1;
+  if (aPatternIndex === -1) return 1;
+  if (bPatternIndex === -1) return -1;
+  if (a.length > b.length) return -1;
+  if (b.length > a.length) return 1;
+  return 0;
+}
+function packageImportsResolve(name2, base, conditions) {
+  if (name2 === "#" || name2.startsWith("#/") || name2.endsWith("/")) {
+    const reason = "is not a valid internal imports specifier name";
+    throw new ERR_INVALID_MODULE_SPECIFIER(name2, reason, fileURLToPath$1(base));
+  }
+  let packageJsonUrl;
+  const packageConfig = getPackageScopeConfig(base);
+  if (packageConfig.exists) {
+    packageJsonUrl = pathToFileURL$1(packageConfig.pjsonPath);
+    const imports = packageConfig.imports;
+    if (imports) {
+      if (own.call(imports, name2) && !name2.includes("*")) {
+        const resolveResult = resolvePackageTarget(
           packageJsonUrl,
-          targetItem,
-          subpath,
-          packageSubpath,
+          imports[name2],
+          "",
+          name2,
           base,
-          pattern,
-          internal,
-          isPathMap,
+          false,
+          true,
+          false,
           conditions
         );
-      } catch (error) {
-        const exception = (
-          /** @type {ErrnoException} */
-          error
-        );
-        lastException = exception;
-        if (exception.code === "ERR_INVALID_PACKAGE_TARGET") continue;
-        throw error;
-      }
-      if (resolveResult === void 0) continue;
-      if (resolveResult === null) {
-        lastException = null;
-        continue;
+        if (resolveResult !== null && resolveResult !== void 0) {
+          return resolveResult;
+        }
+      } else {
+        let bestMatch = "";
+        let bestMatchSubpath = "";
+        const keys = Object.getOwnPropertyNames(imports);
+        let i = -1;
+        while (++i < keys.length) {
+          const key = keys[i];
+          const patternIndex = key.indexOf("*");
+          if (patternIndex !== -1 && name2.startsWith(key.slice(0, -1))) {
+            const patternTrailer = key.slice(patternIndex + 1);
+            if (name2.length >= key.length && name2.endsWith(patternTrailer) && patternKeyCompare(bestMatch, key) === 1 && key.lastIndexOf("*") === patternIndex) {
+              bestMatch = key;
+              bestMatchSubpath = name2.slice(
+                patternIndex,
+                name2.length - patternTrailer.length
+              );
+            }
+          }
+        }
+        if (bestMatch) {
+          const target2 = imports[bestMatch];
+          const resolveResult = resolvePackageTarget(
+            packageJsonUrl,
+            target2,
+            bestMatchSubpath,
+            bestMatch,
+            base,
+            true,
+            true,
+            false,
+            conditions
+          );
+          if (resolveResult !== null && resolveResult !== void 0) {
+            return resolveResult;
+          }
+        }
       }
-      return resolveResult;
     }
-    if (lastException === void 0 || lastException === null) {
-      return null;
+  }
+  throw importNotDefined(name2, packageJsonUrl, base);
+}
+function parsePackageName(specifier, base) {
+  let separatorIndex = specifier.indexOf("/");
+  let validPackageName = true;
+  let isScoped = false;
+  if (specifier[0] === "@") {
+    isScoped = true;
+    if (separatorIndex === -1 || specifier.length === 0) {
+      validPackageName = false;
+    } else {
+      separatorIndex = specifier.indexOf("/", separatorIndex + 1);
+    }
+  }
+  const packageName = separatorIndex === -1 ? specifier : specifier.slice(0, separatorIndex);
+  if (invalidPackageNameRegEx.exec(packageName) !== null) {
+    validPackageName = false;
+  }
+  if (!validPackageName) {
+    throw new ERR_INVALID_MODULE_SPECIFIER(
+      specifier,
+      "is not a valid package name",
+      fileURLToPath$1(base)
+    );
+  }
+  const packageSubpath = "." + (separatorIndex === -1 ? "" : specifier.slice(separatorIndex));
+  return { packageName, packageSubpath, isScoped };
+}
+function packageResolve(specifier, base, conditions) {
+  if (builtinModules.includes(specifier)) {
+    return new URL$1("node:" + specifier);
+  }
+  const { packageName, packageSubpath, isScoped } = parsePackageName(
+    specifier,
+    base
+  );
+  const packageConfig = getPackageScopeConfig(base);
+  if (packageConfig.exists) {
+    const packageJsonUrl2 = pathToFileURL$1(packageConfig.pjsonPath);
+    if (packageConfig.name === packageName && packageConfig.exports !== void 0 && packageConfig.exports !== null) {
+      return packageExportsResolve(
+        packageJsonUrl2,
+        packageSubpath,
+        packageConfig,
+        base,
+        conditions
+      );
+    }
+  }
+  let packageJsonUrl = new URL$1(
+    "./node_modules/" + packageName + "/package.json",
+    base
+  );
+  let packageJsonPath = fileURLToPath$1(packageJsonUrl);
+  let lastPath;
+  do {
+    const stat = tryStatSync(packageJsonPath.slice(0, -13));
+    if (!stat || !stat.isDirectory()) {
+      lastPath = packageJsonPath;
+      packageJsonUrl = new URL$1(
+        (isScoped ? "../../../../node_modules/" : "../../../node_modules/") + packageName + "/package.json",
+        packageJsonUrl
+      );
+      packageJsonPath = fileURLToPath$1(packageJsonUrl);
+      continue;
+    }
+    const packageConfig2 = read(packageJsonPath, { base, specifier });
+    if (packageConfig2.exports !== void 0 && packageConfig2.exports !== null) {
+      return packageExportsResolve(
+        packageJsonUrl,
+        packageSubpath,
+        packageConfig2,
+        base,
+        conditions
+      );
+    }
+    if (packageSubpath === ".") {
+      return legacyMainResolve(packageJsonUrl, packageConfig2, base);
+    }
+    return new URL$1(packageSubpath, packageJsonUrl);
+  } while (packageJsonPath.length !== lastPath.length);
+  throw new ERR_MODULE_NOT_FOUND(packageName, fileURLToPath$1(base), false);
+}
+function isRelativeSpecifier(specifier) {
+  if (specifier[0] === ".") {
+    if (specifier.length === 1 || specifier[1] === "/") return true;
+    if (specifier[1] === "." && (specifier.length === 2 || specifier[2] === "/")) {
+      return true;
     }
-    throw lastException;
   }
-  if (typeof target === "object" && target !== null) {
-    const keys = Object.getOwnPropertyNames(target);
-    let i = -1;
-    while (++i < keys.length) {
-      const key = keys[i];
-      if (isArrayIndex(key)) {
-        throw new ERR_INVALID_PACKAGE_CONFIG(
-          fileURLToPath$1(packageJsonUrl),
-          base,
-          '"exports" cannot contain numeric property keys.'
-        );
-      }
+  return false;
+}
+function shouldBeTreatedAsRelativeOrAbsolutePath(specifier) {
+  if (specifier === "") return false;
+  if (specifier[0] === "/") return true;
+  return isRelativeSpecifier(specifier);
+}
+function moduleResolve(specifier, base, conditions, preserveSymlinks) {
+  const protocol = base.protocol;
+  const isData = protocol === "data:";
+  const isRemote = isData || protocol === "http:" || protocol === "https:";
+  let resolved;
+  if (shouldBeTreatedAsRelativeOrAbsolutePath(specifier)) {
+    try {
+      resolved = new URL$1(specifier, base);
+    } catch (error_) {
+      const error = new ERR_UNSUPPORTED_RESOLVE_REQUEST(specifier, base);
+      error.cause = error_;
+      throw error;
     }
-    i = -1;
-    while (++i < keys.length) {
-      const key = keys[i];
-      if (key === "default" || conditions && conditions.has(key)) {
-        const conditionalTarget = (
-          /** @type {unknown} */
-          target[key]
-        );
-        const resolveResult = resolvePackageTarget(
-          packageJsonUrl,
-          conditionalTarget,
-          subpath,
-          packageSubpath,
-          base,
-          pattern,
-          internal,
-          isPathMap,
-          conditions
-        );
-        if (resolveResult === void 0) continue;
-        return resolveResult;
+  } else if (protocol === "file:" && specifier[0] === "#") {
+    resolved = packageImportsResolve(specifier, base, conditions);
+  } else {
+    try {
+      resolved = new URL$1(specifier);
+    } catch (error_) {
+      if (isRemote && !builtinModules.includes(specifier)) {
+        const error = new ERR_UNSUPPORTED_RESOLVE_REQUEST(specifier, base);
+        error.cause = error_;
+        throw error;
       }
+      resolved = packageResolve(specifier, base, conditions);
     }
-    return null;
   }
-  if (target === null) {
-    return null;
+  assert(resolved !== void 0, "expected to be defined");
+  if (resolved.protocol !== "file:") {
+    return resolved;
   }
-  throw invalidPackageTarget(
-    packageSubpath,
-    target,
-    packageJsonUrl,
-    internal,
-    base
-  );
+  return finalizeResolution(resolved, base);
 }
-function isConditionalExportsMainSugar(exports, packageJsonUrl, base) {
-  if (typeof exports === "string" || Array.isArray(exports)) return true;
-  if (typeof exports !== "object" || exports === null) return false;
-  const keys = Object.getOwnPropertyNames(exports);
-  let isConditionalSugar = false;
-  let i = 0;
-  let keyIndex = -1;
-  while (++keyIndex < keys.length) {
-    const key = keys[keyIndex];
-    const currentIsConditionalSugar = key === "" || key[0] !== ".";
-    if (i++ === 0) {
-      isConditionalSugar = currentIsConditionalSugar;
-    } else if (isConditionalSugar !== currentIsConditionalSugar) {
-      throw new ERR_INVALID_PACKAGE_CONFIG(
-        fileURLToPath$1(packageJsonUrl),
-        base,
-        `"exports" cannot contain some keys starting with '.' and some not. The exports object must either be an object of package subpath keys or an object of main entry condition name keys only.`
-      );
-    }
+function fileURLToPath(id) {
+  if (typeof id === "string" && !id.startsWith("file://")) {
+    return normalizeSlash(id);
   }
-  return isConditionalSugar;
+  return normalizeSlash(fileURLToPath$1(id));
 }
-function emitTrailingSlashPatternDeprecation(match, pjsonUrl, base) {
-  if (process$1.noDeprecation) {
-    return;
+function pathToFileURL(id) {
+  return pathToFileURL$1(fileURLToPath(id)).toString();
+}
+function normalizeid(id) {
+  if (typeof id !== "string") {
+    id = id.toString();
   }
-  const pjsonPath = fileURLToPath$1(pjsonUrl);
-  if (emittedPackageWarnings.has(pjsonPath + "|" + match)) return;
-  emittedPackageWarnings.add(pjsonPath + "|" + match);
-  process$1.emitWarning(
-    `Use of deprecated trailing slash pattern mapping "${match}" in the "exports" field module resolution of the package at ${pjsonPath}${base ? ` imported from ${fileURLToPath$1(base)}` : ""}. Mapping specifiers ending in "/" is no longer supported.`,
-    "DeprecationWarning",
-    "DEP0155"
-  );
+  if (/(node|data|http|https|file):/.test(id)) {
+    return id;
+  }
+  if (BUILTIN_MODULES.has(id)) {
+    return "node:" + id;
+  }
+  return "file://" + encodeURI(normalizeSlash(id));
 }
-function packageExportsResolve(packageJsonUrl, packageSubpath, packageConfig, base, conditions) {
-  let exports = packageConfig.exports;
-  if (isConditionalExportsMainSugar(exports, packageJsonUrl, base)) {
-    exports = { ".": exports };
+var DEFAULT_CONDITIONS_SET = /* @__PURE__ */ new Set(["node", "import"]);
+var DEFAULT_EXTENSIONS = [".mjs", ".cjs", ".js", ".json"];
+var NOT_FOUND_ERRORS = /* @__PURE__ */ new Set([
+  "ERR_MODULE_NOT_FOUND",
+  "ERR_UNSUPPORTED_DIR_IMPORT",
+  "MODULE_NOT_FOUND",
+  "ERR_PACKAGE_PATH_NOT_EXPORTED"
+]);
+function _tryModuleResolve(id, url, conditions) {
+  try {
+    return moduleResolve(id, url, conditions);
+  } catch (error) {
+    if (!NOT_FOUND_ERRORS.has(error?.code)) {
+      throw error;
+    }
   }
-  if (own.call(exports, packageSubpath) && !packageSubpath.includes("*") && !packageSubpath.endsWith("/")) {
-    const target = exports[packageSubpath];
-    const resolveResult = resolvePackageTarget(
-      packageJsonUrl,
-      target,
-      "",
-      packageSubpath,
-      base,
-      false,
-      false,
-      false,
-      conditions
-    );
-    if (resolveResult === null || resolveResult === void 0) {
-      throw exportsNotFound(packageSubpath, packageJsonUrl, base);
+}
+function _resolve(id, options = {}) {
+  if (typeof id !== "string") {
+    if (id instanceof URL) {
+      id = fileURLToPath(id);
+    } else {
+      throw new TypeError("input must be a `string` or `URL`");
     }
-    return resolveResult;
   }
-  let bestMatch = "";
-  let bestMatchSubpath = "";
-  const keys = Object.getOwnPropertyNames(exports);
-  let i = -1;
-  while (++i < keys.length) {
-    const key = keys[i];
-    const patternIndex = key.indexOf("*");
-    if (patternIndex !== -1 && packageSubpath.startsWith(key.slice(0, patternIndex))) {
-      if (packageSubpath.endsWith("/")) {
-        emitTrailingSlashPatternDeprecation(
-          packageSubpath,
-          packageJsonUrl,
-          base
-        );
+  if (/(node|data|http|https):/.test(id)) {
+    return id;
+  }
+  if (BUILTIN_MODULES.has(id)) {
+    return "node:" + id;
+  }
+  if (id.startsWith("file://")) {
+    id = fileURLToPath(id);
+  }
+  if (isAbsolute(id)) {
+    try {
+      const stat = statSync(id);
+      if (stat.isFile()) {
+        return pathToFileURL(id);
       }
-      const patternTrailer = key.slice(patternIndex + 1);
-      if (packageSubpath.length >= key.length && packageSubpath.endsWith(patternTrailer) && patternKeyCompare(bestMatch, key) === 1 && key.lastIndexOf("*") === patternIndex) {
-        bestMatch = key;
-        bestMatchSubpath = packageSubpath.slice(
-          patternIndex,
-          packageSubpath.length - patternTrailer.length
+    } catch (error) {
+      if (error?.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+  const conditionsSet = options.conditions ? new Set(options.conditions) : DEFAULT_CONDITIONS_SET;
+  const _urls = (Array.isArray(options.url) ? options.url : [options.url]).filter(Boolean).map((url) => new URL(normalizeid(url.toString())));
+  if (_urls.length === 0) {
+    _urls.push(new URL(pathToFileURL(process.cwd())));
+  }
+  const urls = [..._urls];
+  for (const url of _urls) {
+    if (url.protocol === "file:") {
+      urls.push(
+        new URL("./", url),
+        // If url is directory
+        new URL(joinURL(url.pathname, "_index.js"), url),
+        // TODO: Remove in next major version?
+        new URL("node_modules", url)
+      );
+    }
+  }
+  let resolved;
+  for (const url of urls) {
+    resolved = _tryModuleResolve(id, url, conditionsSet);
+    if (resolved) {
+      break;
+    }
+    for (const prefix of ["", "/index"]) {
+      for (const extension of options.extensions || DEFAULT_EXTENSIONS) {
+        resolved = _tryModuleResolve(
+          joinURL(id, prefix) + extension,
+          url,
+          conditionsSet
         );
+        if (resolved) {
+          break;
+        }
       }
+      if (resolved) {
+        break;
+      }
+    }
+    if (resolved) {
+      break;
     }
   }
-  if (bestMatch) {
-    const target = (
-      /** @type {unknown} */
-      exports[bestMatch]
+  if (!resolved) {
+    const error = new Error(
+      `Cannot find module ${id} imported from ${urls.join(", ")}`
+    );
+    error.code = "ERR_MODULE_NOT_FOUND";
+    throw error;
+  }
+  return pathToFileURL(resolved);
+}
+function resolveSync(id, options) {
+  return _resolve(id, options);
+}
+function resolvePathSync(id, options) {
+  return fileURLToPath(resolveSync(id, options));
+}
+
+// src/node-js-compat.ts
+import { defineEnv } from "unenv";
+var { env } = defineEnv({
+  nodeCompat: true,
+  presets: [cloudflare]
+});
+var nodeCompatExternals = new Set(env.external);
+var nodeCompatEntries = getNodeCompatEntries();
+function isNodeCompat(workerConfig) {
+  if (workerConfig === void 0) {
+    return false;
+  }
+  const nodeCompatMode = getNodeCompat(
+    workerConfig.compatibility_date,
+    workerConfig.compatibility_flags ?? []
+  ).mode;
+  if (nodeCompatMode === "v2") {
+    return true;
+  }
+  if (nodeCompatMode === "v1") {
+    throw new Error(
+      `Unsupported Node.js compat mode (v1). Only the v2 mode is supported, either change your compat date to "2024-09-23" or later, or set the "nodejs_compat_v2" compatibility flag`
     );
-    const resolveResult = resolvePackageTarget(
-      packageJsonUrl,
-      target,
-      bestMatchSubpath,
-      bestMatch,
-      base,
-      true,
-      false,
-      packageSubpath.endsWith("/"),
-      conditions
+  }
+  return false;
+}
+function injectGlobalCode(id, code) {
+  const injectedCode = Object.entries(env.inject).map(([globalName, globalInject]) => {
+    if (typeof globalInject === "string") {
+      const moduleSpecifier2 = globalInject;
+      return `import var_${globalName} from "${moduleSpecifier2}";
+globalThis.${globalName} = var_${globalName};
+`;
+    }
+    const [moduleSpecifier, exportName] = globalInject;
+    assert2(
+      moduleSpecifier !== void 0,
+      "Expected moduleSpecifier to be defined"
     );
-    if (resolveResult === null || resolveResult === void 0) {
-      throw exportsNotFound(packageSubpath, packageJsonUrl, base);
+    assert2(exportName !== void 0, "Expected exportName to be defined");
+    return `import var_${globalName} from "${moduleSpecifier}";
+globalThis.${globalName} = var_${globalName}.${exportName};
+`;
+  }).join("\n");
+  const modified = new MagicString(code);
+  modified.prepend(injectedCode);
+  return {
+    code: modified.toString(),
+    map: modified.generateMap({ hires: "boundary", source: id })
+  };
+}
+function resolveNodeJSImport(source) {
+  const alias = env.alias[source];
+  if (alias) {
+    return {
+      unresolved: alias,
+      resolved: resolvePathSync(alias, { url: import.meta.url })
+    };
+  }
+  if (nodeCompatEntries.has(source)) {
+    return {
+      unresolved: source,
+      resolved: resolvePathSync(source, { url: import.meta.url })
+    };
+  }
+}
+function getNodeCompatEntries() {
+  const entries = new Set(Object.values(env.alias));
+  for (const globalInject of Object.values(env.inject)) {
+    if (typeof globalInject === "string") {
+      entries.add(globalInject);
+    } else {
+      assert2(
+        globalInject[0] !== void 0,
+        "Expected first element of globalInject to be defined"
+      );
+      entries.add(globalInject[0]);
     }
-    return resolveResult;
   }
-  throw exportsNotFound(packageSubpath, packageJsonUrl, base);
+  nodeCompatExternals.forEach((external) => entries.delete(external));
+  return entries;
 }
-function patternKeyCompare(a, b) {
-  const aPatternIndex = a.indexOf("*");
-  const bPatternIndex = b.indexOf("*");
-  const baseLengthA = aPatternIndex === -1 ? a.length : aPatternIndex + 1;
-  const baseLengthB = bPatternIndex === -1 ? b.length : bPatternIndex + 1;
-  if (baseLengthA > baseLengthB) return -1;
-  if (baseLengthB > baseLengthA) return 1;
-  if (aPatternIndex === -1) return 1;
-  if (bPatternIndex === -1) return -1;
-  if (a.length > b.length) return -1;
-  if (b.length > a.length) return 1;
-  return 0;
+
+// src/constants.ts
+var ROUTER_WORKER_NAME = "__router-worker__";
+var ASSET_WORKER_NAME = "__asset-worker__";
+var ASSET_WORKERS_COMPATIBILITY_DATE = "2024-10-04";
+var MODULE_TYPES = ["CompiledWasm"];
+
+// src/shared.ts
+var UNKNOWN_HOST = "http://localhost";
+var INIT_PATH = "/__vite_plugin_cloudflare_init__";
+var MODULE_PATTERN = `__CLOUDFLARE_MODULE__(${MODULE_TYPES.join("|")})__(.*?)__`;
+var VITE_DEV_METADATA_HEADER = "__VITE_DEV_METADATA__";
+
+// src/utils.ts
+import * as path2 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 ?? path2.join(rootOutputDirectory, environmentName);
 }
-function packageImportsResolve(name2, base, conditions) {
-  if (name2 === "#" || name2.startsWith("#/") || name2.endsWith("/")) {
-    const reason = "is not a valid internal imports specifier name";
-    throw new ERR_INVALID_MODULE_SPECIFIER(name2, reason, fileURLToPath$1(base));
-  }
-  let packageJsonUrl;
-  const packageConfig = getPackageScopeConfig(base);
-  if (packageConfig.exists) {
-    packageJsonUrl = pathToFileURL$1(packageConfig.pjsonPath);
-    const imports = packageConfig.imports;
-    if (imports) {
-      if (own.call(imports, name2) && !name2.includes("*")) {
-        const resolveResult = resolvePackageTarget(
-          packageJsonUrl,
-          imports[name2],
-          "",
-          name2,
-          base,
-          false,
-          true,
-          false,
-          conditions
-        );
-        if (resolveResult !== null && resolveResult !== void 0) {
-          return resolveResult;
-        }
-      } else {
-        let bestMatch = "";
-        let bestMatchSubpath = "";
-        const keys = Object.getOwnPropertyNames(imports);
-        let i = -1;
-        while (++i < keys.length) {
-          const key = keys[i];
-          const patternIndex = key.indexOf("*");
-          if (patternIndex !== -1 && name2.startsWith(key.slice(0, -1))) {
-            const patternTrailer = key.slice(patternIndex + 1);
-            if (name2.length >= key.length && name2.endsWith(patternTrailer) && patternKeyCompare(bestMatch, key) === 1 && key.lastIndexOf("*") === patternIndex) {
-              bestMatch = key;
-              bestMatchSubpath = name2.slice(
-                patternIndex,
-                name2.length - patternTrailer.length
-              );
-            }
-          }
-        }
-        if (bestMatch) {
-          const target = imports[bestMatch];
-          const resolveResult = resolvePackageTarget(
-            packageJsonUrl,
-            target,
-            bestMatchSubpath,
-            bestMatch,
-            base,
-            true,
-            true,
-            false,
-            conditions
-          );
-          if (resolveResult !== null && resolveResult !== void 0) {
-            return resolveResult;
-          }
-        }
+function toMiniflareRequest(request) {
+  return new MiniflareRequest(request.url, {
+    method: request.method,
+    headers: [["accept-encoding", "identity"], ...request.headers],
+    body: request.body,
+    duplex: "half"
+  });
+}
+function nodeHeadersToWebHeaders(nodeHeaders) {
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(nodeHeaders)) {
+    if (typeof value === "string") {
+      headers.append(key, value);
+    } else if (Array.isArray(value)) {
+      for (const item of value) {
+        headers.append(key, item);
       }
     }
   }
-  throw importNotDefined(name2, packageJsonUrl, base);
+  return headers;
 }
-function parsePackageName(specifier, base) {
-  let separatorIndex = specifier.indexOf("/");
-  let validPackageName = true;
-  let isScoped = false;
-  if (specifier[0] === "@") {
-    isScoped = true;
-    if (separatorIndex === -1 || specifier.length === 0) {
-      validPackageName = false;
-    } else {
-      separatorIndex = specifier.indexOf("/", separatorIndex + 1);
+
+// src/cloudflare-environment.ts
+var webSocketUndefinedError = "The WebSocket is undefined";
+function createHotChannel(webSocketContainer) {
+  const listenersMap = /* @__PURE__ */ new Map();
+  const client = {
+    send(payload) {
+      const webSocket = webSocketContainer.webSocket;
+      assert3(webSocket, webSocketUndefinedError);
+      webSocket.send(JSON.stringify(payload));
+    }
+  };
+  function onMessage(event) {
+    const payload = JSON.parse(event.data.toString());
+    const listeners = listenersMap.get(payload.event) ?? /* @__PURE__ */ new Set();
+    for (const listener of listeners) {
+      listener(payload.data, client);
     }
   }
-  const packageName = separatorIndex === -1 ? specifier : specifier.slice(0, separatorIndex);
-  if (invalidPackageNameRegEx.exec(packageName) !== null) {
-    validPackageName = false;
+  return {
+    send(payload) {
+      const webSocket = webSocketContainer.webSocket;
+      assert3(webSocket, webSocketUndefinedError);
+      webSocket.send(JSON.stringify(payload));
+    },
+    on(event, listener) {
+      const listeners = listenersMap.get(event) ?? /* @__PURE__ */ new Set();
+      listeners.add(listener);
+      listenersMap.set(event, listeners);
+    },
+    off(event, listener) {
+      listenersMap.get(event)?.delete(listener);
+    },
+    listen() {
+      const webSocket = webSocketContainer.webSocket;
+      assert3(webSocket, webSocketUndefinedError);
+      webSocket.addEventListener("message", onMessage);
+    },
+    close() {
+      const webSocket = webSocketContainer.webSocket;
+      assert3(webSocket, webSocketUndefinedError);
+      webSocket.removeEventListener("message", onMessage);
+    }
+  };
+}
+var CloudflareDevEnvironment = class extends vite2.DevEnvironment {
+  #webSocketContainer;
+  #worker;
+  constructor(name2, config) {
+    const webSocketContainer = {};
+    super(name2, config, {
+      hot: true,
+      transport: createHotChannel(webSocketContainer)
+    });
+    this.#webSocketContainer = webSocketContainer;
   }
-  if (!validPackageName) {
-    throw new ERR_INVALID_MODULE_SPECIFIER(
-      specifier,
-      "is not a valid package name",
-      fileURLToPath$1(base)
+  async initRunner(worker, root, 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"
+        }
+      }
+    );
+    assert3(
+      response.ok,
+      `Failed to initialize module runner, error: ${await response.text()}`
     );
+    const webSocket = response.webSocket;
+    assert3(webSocket, "Failed to establish WebSocket");
+    webSocket.accept();
+    this.#webSocketContainer.webSocket = webSocket;
   }
-  const packageSubpath = "." + (separatorIndex === -1 ? "" : specifier.slice(separatorIndex));
-  return { packageName, packageSubpath, isScoped };
+};
+var cloudflareBuiltInModules = [
+  "cloudflare:email",
+  "cloudflare:sockets",
+  "cloudflare:workers",
+  "cloudflare:workflows"
+];
+var defaultConditions = ["workerd", "module", "browser"];
+var target = "es2022";
+function createCloudflareEnvironmentOptions(workerConfig, userConfig, environmentName) {
+  return {
+    resolve: {
+      // Note: in order for ssr pre-bundling to take effect we need to ask vite to treat all
+      //       dependencies as not external
+      noExternal: true,
+      // We want to use `workerd` package exports if available (e.g. for postgres).
+      conditions: [...defaultConditions, "development|production"],
+      // The Cloudflare ones are proper builtins in the environment
+      builtins: [...cloudflareBuiltInModules]
+    },
+    dev: {
+      createEnvironment(name2, config) {
+        return new CloudflareDevEnvironment(name2, config);
+      }
+    },
+    build: {
+      createEnvironment(name2, config) {
+        return new vite2.BuildEnvironment(name2, config);
+      },
+      target,
+      // We need to enable `emitAssets` in order to support additional modules defined by `rules`
+      emitAssets: true,
+      outDir: getOutputDirectory(userConfig, environmentName),
+      copyPublicDir: false,
+      ssr: true,
+      rollupOptions: {
+        // Note: vite starts dev pre-bundling crawling from either optimizeDeps.entries or rollupOptions.input
+        //       so the input value here serves both as the build input as well as the starting point for
+        //       dev pre-bundling crawling (were we not to set this input field we'd have to appropriately set
+        //       optimizeDeps.entries in the dev config)
+        input: workerConfig.main
+      }
+    },
+    optimizeDeps: {
+      // Note: ssr pre-bundling is opt-in and we need to enable it by setting `noDiscovery` to false
+      noDiscovery: false,
+      entries: workerConfig.main,
+      exclude: [...cloudflareBuiltInModules],
+      esbuildOptions: {
+        platform: "neutral",
+        target,
+        conditions: [...defaultConditions, "development"],
+        resolveExtensions: [
+          ".mjs",
+          ".js",
+          ".mts",
+          ".ts",
+          ".jsx",
+          ".tsx",
+          ".json",
+          ".cjs",
+          ".cts",
+          ".ctx"
+        ]
+      }
+    },
+    // if nodeCompat is enabled then let's keep the real process.env so that workerd can manipulate it
+    keepProcessEnv: isNodeCompat(workerConfig)
+  };
 }
-function packageResolve(specifier, base, conditions) {
-  if (builtinModules.includes(specifier)) {
-    return new URL$1("node:" + specifier);
-  }
-  const { packageName, packageSubpath, isScoped } = parsePackageName(
-    specifier,
-    base
-  );
-  const packageConfig = getPackageScopeConfig(base);
-  if (packageConfig.exists) {
-    const packageJsonUrl2 = pathToFileURL$1(packageConfig.pjsonPath);
-    if (packageConfig.name === packageName && packageConfig.exports !== void 0 && packageConfig.exports !== null) {
-      return packageExportsResolve(
-        packageJsonUrl2,
-        packageSubpath,
-        packageConfig,
-        base,
-        conditions
-      );
-    }
+function initRunners(resolvedPluginConfig, viteDevServer, miniflare) {
+  if (resolvedPluginConfig.type === "assets-only") {
+    return;
   }
-  let packageJsonUrl = new URL$1(
-    "./node_modules/" + packageName + "/package.json",
-    base
+  return Promise.all(
+    Object.entries(resolvedPluginConfig.workers).map(
+      async ([environmentName, workerConfig]) => {
+        const worker = await miniflare.getWorker(workerConfig.name);
+        return viteDevServer.environments[environmentName].initRunner(worker, viteDevServer.config.root, workerConfig);
+      }
+    )
   );
-  let packageJsonPath = fileURLToPath$1(packageJsonUrl);
-  let lastPath;
-  do {
-    const stat = tryStatSync(packageJsonPath.slice(0, -13));
-    if (!stat || !stat.isDirectory()) {
-      lastPath = packageJsonPath;
-      packageJsonUrl = new URL$1(
-        (isScoped ? "../../../../node_modules/" : "../../../node_modules/") + packageName + "/package.json",
-        packageJsonUrl
-      );
-      packageJsonPath = fileURLToPath$1(packageJsonUrl);
-      continue;
-    }
-    const packageConfig2 = read(packageJsonPath, { base, specifier });
-    if (packageConfig2.exports !== void 0 && packageConfig2.exports !== null) {
-      return packageExportsResolve(
-        packageJsonUrl,
-        packageSubpath,
-        packageConfig2,
-        base,
-        conditions
-      );
-    }
-    if (packageSubpath === ".") {
-      return legacyMainResolve(packageJsonUrl, packageConfig2, base);
-    }
-    return new URL$1(packageSubpath, packageJsonUrl);
-  } while (packageJsonPath.length !== lastPath.length);
-  throw new ERR_MODULE_NOT_FOUND(packageName, fileURLToPath$1(base), false);
 }
-function isRelativeSpecifier(specifier) {
-  if (specifier[0] === ".") {
-    if (specifier.length === 1 || specifier[1] === "/") return true;
-    if (specifier[1] === "." && (specifier.length === 2 || specifier[2] === "/")) {
-      return true;
-    }
-  }
-  return false;
+
+// src/deploy-config.ts
+import assert4 from "node:assert";
+import * as fs2 from "node:fs";
+import * as path3 from "node:path";
+import "vite";
+function getDeployConfigPath(root) {
+  return path3.resolve(root, ".wrangler", "deploy", "config.json");
 }
-function shouldBeTreatedAsRelativeOrAbsolutePath(specifier) {
-  if (specifier === "") return false;
-  if (specifier[0] === "/") return true;
-  return isRelativeSpecifier(specifier);
+function getWorkerConfigPaths(root) {
+  const deployConfigPath = getDeployConfigPath(root);
+  const deployConfig = JSON.parse(
+    fs2.readFileSync(deployConfigPath, "utf-8")
+  );
+  return [
+    { configPath: deployConfig.configPath },
+    ...deployConfig.auxiliaryWorkers
+  ].map(
+    ({ configPath }) => path3.resolve(path3.dirname(deployConfigPath), configPath)
+  );
 }
-function moduleResolve(specifier, base, conditions, preserveSymlinks) {
-  const protocol = base.protocol;
-  const isData = protocol === "data:";
-  const isRemote = isData || protocol === "http:" || protocol === "https:";
-  let resolved;
-  if (shouldBeTreatedAsRelativeOrAbsolutePath(specifier)) {
-    try {
-      resolved = new URL$1(specifier, base);
-    } catch (error_) {
-      const error = new ERR_UNSUPPORTED_RESOLVE_REQUEST(specifier, base);
-      error.cause = error_;
-      throw error;
-    }
-  } else if (protocol === "file:" && specifier[0] === "#") {
-    resolved = packageImportsResolve(specifier, base, conditions);
+function getRelativePathToWorkerConfig(deployConfigDirectory, root, outputDirectory) {
+  return path3.relative(
+    deployConfigDirectory,
+    path3.resolve(root, outputDirectory, "wrangler.json")
+  );
+}
+function writeDeployConfig(resolvedPluginConfig, resolvedViteConfig) {
+  const deployConfigPath = getDeployConfigPath(resolvedViteConfig.root);
+  const deployConfigDirectory = path3.dirname(deployConfigPath);
+  fs2.mkdirSync(deployConfigDirectory, { recursive: true });
+  if (resolvedPluginConfig.type === "assets-only") {
+    const clientOutputDirectory = resolvedViteConfig.environments.client?.build.outDir;
+    assert4(
+      clientOutputDirectory,
+      "Unexpected error: client environment output directory is undefined"
+    );
+    const deployConfig = {
+      configPath: getRelativePathToWorkerConfig(
+        deployConfigDirectory,
+        resolvedViteConfig.root,
+        clientOutputDirectory
+      ),
+      auxiliaryWorkers: []
+    };
+    fs2.writeFileSync(deployConfigPath, JSON.stringify(deployConfig));
   } else {
-    try {
-      resolved = new URL$1(specifier);
-    } catch (error_) {
-      if (isRemote && !builtinModules.includes(specifier)) {
-        const error = new ERR_UNSUPPORTED_RESOLVE_REQUEST(specifier, base);
-        error.cause = error_;
-        throw error;
+    let entryWorkerConfigPath;
+    const auxiliaryWorkers = [];
+    for (const environmentName of Object.keys(resolvedPluginConfig.workers)) {
+      const outputDirectory = resolvedViteConfig.environments[environmentName]?.build.outDir;
+      assert4(
+        outputDirectory,
+        `Unexpected error: ${environmentName} environment output directory is undefined`
+      );
+      const configPath = getRelativePathToWorkerConfig(
+        deployConfigDirectory,
+        resolvedViteConfig.root,
+        outputDirectory
+      );
+      if (environmentName === resolvedPluginConfig.entryWorkerEnvironmentName) {
+        entryWorkerConfigPath = configPath;
+      } else {
+        auxiliaryWorkers.push({ configPath });
       }
-      resolved = packageResolve(specifier, base, conditions);
     }
+    assert4(
+      entryWorkerConfigPath,
+      `Unexpected error: entryWorkerConfigPath is undefined`
+    );
+    const deployConfig = {
+      configPath: entryWorkerConfigPath,
+      auxiliaryWorkers
+    };
+    fs2.writeFileSync(deployConfigPath, JSON.stringify(deployConfig));
   }
-  assert5(resolved !== void 0, "expected to be defined");
-  if (resolved.protocol !== "file:") {
-    return resolved;
-  }
-  return finalizeResolution(resolved, base);
 }
-function fileURLToPath2(id) {
-  if (typeof id === "string" && !id.startsWith("file://")) {
-    return normalizeSlash(id);
+
+// src/dev.ts
+import assert5 from "node:assert";
+function getDevEntryWorker(resolvedPluginConfig, miniflare) {
+  const entryWorkerConfig = resolvedPluginConfig.type === "assets-only" ? resolvedPluginConfig.config : resolvedPluginConfig.workers[resolvedPluginConfig.entryWorkerEnvironmentName];
+  assert5(entryWorkerConfig, "Unexpected error: No entry worker configuration");
+  return entryWorkerConfig.assets ? miniflare.getWorker(ROUTER_WORKER_NAME) : miniflare.getWorker(entryWorkerConfig.name);
+}
+
+// src/miniflare-options.ts
+import assert6 from "node:assert";
+import * as fs3 from "node:fs";
+import * as fsp from "node:fs/promises";
+import * as path4 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import {
+  kCurrentWorker,
+  Log,
+  LogLevel,
+  Response as MiniflareResponse
+} from "miniflare";
+import { globSync } from "tinyglobby";
+import "vite";
+import {
+  unstable_getMiniflareWorkerOptions,
+  unstable_readConfig
+} from "wrangler";
+function getPersistence(root, persistState) {
+  if (persistState === false) {
+    return {};
   }
-  return normalizeSlash(fileURLToPath$1(id));
+  const defaultPersistPath = ".wrangler/state";
+  const persistPath = path4.resolve(
+    root,
+    typeof persistState === "object" ? persistState.path : defaultPersistPath,
+    "v3"
+  );
+  return {
+    cachePersist: path4.join(persistPath, "cache"),
+    d1Persist: path4.join(persistPath, "d1"),
+    durableObjectsPersist: path4.join(persistPath, "do"),
+    kvPersist: path4.join(persistPath, "kv"),
+    r2Persist: path4.join(persistPath, "r2"),
+    workflowsPersist: path4.join(persistPath, "workflows")
+  };
 }
-function pathToFileURL(id) {
-  return pathToFileURL$1(fileURLToPath2(id)).toString();
+function missingWorkerErrorMessage(workerName) {
+  return `${workerName} does not match a worker name.`;
 }
-function normalizeid(id) {
-  if (typeof id !== "string") {
-    id = id.toString();
-  }
-  if (/(node|data|http|https|file):/.test(id)) {
-    return id;
-  }
-  if (BUILTIN_MODULES.has(id)) {
-    return "node:" + id;
+function getWorkerToWorkerEntrypointNamesMap(workers) {
+  const workerToWorkerEntrypointNamesMap = new Map(
+    workers.map((workerOptions) => [workerOptions.name, /* @__PURE__ */ new Set()])
+  );
+  for (const worker of workers) {
+    for (const value of Object.values(worker.serviceBindings ?? {})) {
+      if (typeof value === "object" && "name" in value && value.entrypoint !== void 0 && value.entrypoint !== "default") {
+        const targetWorkerName = value.name === kCurrentWorker ? worker.name : value.name;
+        const entrypointNames = workerToWorkerEntrypointNamesMap.get(targetWorkerName);
+        assert6(entrypointNames, missingWorkerErrorMessage(targetWorkerName));
+        entrypointNames.add(value.entrypoint);
+      }
+    }
   }
-  return "file://" + encodeURI(normalizeSlash(id));
+  return workerToWorkerEntrypointNamesMap;
 }
-var DEFAULT_CONDITIONS_SET = /* @__PURE__ */ new Set(["node", "import"]);
-var DEFAULT_EXTENSIONS = [".mjs", ".cjs", ".js", ".json"];
-var NOT_FOUND_ERRORS = /* @__PURE__ */ new Set([
-  "ERR_MODULE_NOT_FOUND",
-  "ERR_UNSUPPORTED_DIR_IMPORT",
-  "MODULE_NOT_FOUND",
-  "ERR_PACKAGE_PATH_NOT_EXPORTED"
-]);
-function _tryModuleResolve(id, url, conditions) {
-  try {
-    return moduleResolve(id, url, conditions);
-  } catch (error) {
-    if (!NOT_FOUND_ERRORS.has(error?.code)) {
-      throw error;
+function getWorkerToDurableObjectClassNamesMap(workers) {
+  const workerToDurableObjectClassNamesMap = new Map(
+    workers.map((workerOptions) => [workerOptions.name, /* @__PURE__ */ new Set()])
+  );
+  for (const worker of workers) {
+    for (const value of Object.values(worker.durableObjects ?? {})) {
+      if (typeof value === "string") {
+        const classNames = workerToDurableObjectClassNamesMap.get(worker.name);
+        assert6(classNames, missingWorkerErrorMessage(worker.name));
+        classNames.add(value);
+      } else if (typeof value === "object") {
+        if (value.scriptName) {
+          const classNames = workerToDurableObjectClassNamesMap.get(
+            value.scriptName
+          );
+          assert6(classNames, missingWorkerErrorMessage(value.scriptName));
+          classNames.add(value.className);
+        } else {
+          const classNames = workerToDurableObjectClassNamesMap.get(
+            worker.name
+          );
+          assert6(classNames, missingWorkerErrorMessage(worker.name));
+          classNames.add(value.className);
+        }
+      }
     }
   }
+  return workerToDurableObjectClassNamesMap;
 }
-function _resolve(id, options = {}) {
-  if (typeof id !== "string") {
-    if (id instanceof URL) {
-      id = fileURLToPath2(id);
-    } else {
-      throw new TypeError("input must be a `string` or `URL`");
+function getWorkerToWorkflowEntrypointClassNamesMap(workers) {
+  const workerToWorkflowEntrypointClassNamesMap = new Map(
+    workers.map((workerOptions) => [workerOptions.name, /* @__PURE__ */ new Set()])
+  );
+  for (const worker of workers) {
+    for (const value of Object.values(worker.workflows ?? {})) {
+      if (value.scriptName) {
+        const classNames = workerToWorkflowEntrypointClassNamesMap.get(
+          value.scriptName
+        );
+        assert6(classNames, missingWorkerErrorMessage(value.scriptName));
+        classNames.add(value.className);
+      } else {
+        const classNames = workerToWorkflowEntrypointClassNamesMap.get(
+          worker.name
+        );
+        assert6(classNames, missingWorkerErrorMessage(worker.name));
+        classNames.add(value.className);
+      }
     }
   }
-  if (/(node|data|http|https):/.test(id)) {
-    return id;
-  }
-  if (BUILTIN_MODULES.has(id)) {
-    return "node:" + id;
-  }
-  if (id.startsWith("file://")) {
-    id = fileURLToPath2(id);
+  return workerToWorkflowEntrypointClassNamesMap;
+}
+var miniflareModulesRoot = process.platform === "win32" ? "Z:\\" : "/";
+var ROUTER_WORKER_PATH = "./asset-workers/router-worker.js";
+var ASSET_WORKER_PATH = "./asset-workers/asset-worker.js";
+var WRAPPER_PATH = "__VITE_WORKER_ENTRY__";
+var RUNNER_PATH = "./runner-worker/index.js";
+function getEntryWorkerConfig(resolvedPluginConfig) {
+  if (resolvedPluginConfig.type === "assets-only") {
+    return;
   }
-  if (isAbsolute(id)) {
-    try {
-      const stat = statSync2(id);
-      if (stat.isFile()) {
-        return pathToFileURL(id);
+  return resolvedPluginConfig.workers[resolvedPluginConfig.entryWorkerEnvironmentName];
+}
+function getDevMiniflareOptions(resolvedPluginConfig, viteDevServer) {
+  const resolvedViteConfig = viteDevServer.config;
+  const entryWorkerConfig = getEntryWorkerConfig(resolvedPluginConfig);
+  const assetsConfig = resolvedPluginConfig.type === "assets-only" ? resolvedPluginConfig.config.assets : entryWorkerConfig?.assets;
+  const assetWorkers = [
+    {
+      name: ROUTER_WORKER_NAME,
+      compatibilityDate: ASSET_WORKERS_COMPATIBILITY_DATE,
+      modulesRoot: miniflareModulesRoot,
+      modules: [
+        {
+          type: "ESModule",
+          path: path4.join(miniflareModulesRoot, ROUTER_WORKER_PATH),
+          contents: fs3.readFileSync(
+            fileURLToPath2(new URL(ROUTER_WORKER_PATH, import.meta.url))
+          )
+        }
+      ],
+      bindings: {
+        CONFIG: {
+          has_user_worker: resolvedPluginConfig.type === "workers"
+        }
+      },
+      serviceBindings: {
+        ASSET_WORKER: ASSET_WORKER_NAME,
+        ...entryWorkerConfig ? { USER_WORKER: entryWorkerConfig.name } : {}
       }
-    } catch (error) {
-      if (error?.code !== "ENOENT") {
-        throw error;
+    },
+    {
+      name: ASSET_WORKER_NAME,
+      compatibilityDate: ASSET_WORKERS_COMPATIBILITY_DATE,
+      modulesRoot: miniflareModulesRoot,
+      modules: [
+        {
+          type: "ESModule",
+          path: path4.join(miniflareModulesRoot, ASSET_WORKER_PATH),
+          contents: fs3.readFileSync(
+            fileURLToPath2(new URL(ASSET_WORKER_PATH, import.meta.url))
+          )
+        }
+      ],
+      bindings: {
+        CONFIG: {
+          ...assetsConfig?.html_handling ? { html_handling: assetsConfig.html_handling } : {},
+          ...assetsConfig?.not_found_handling ? { not_found_handling: assetsConfig.not_found_handling } : {}
+        }
+      },
+      serviceBindings: {
+        __VITE_ASSET_EXISTS__: async (request) => {
+          const { pathname } = new URL(request.url);
+          const filePath = path4.join(resolvedViteConfig.root, pathname);
+          let exists;
+          try {
+            exists = fs3.statSync(filePath).isFile();
+          } catch (error) {
+            exists = false;
+          }
+          return MiniflareResponse.json(exists);
+        },
+        __VITE_FETCH_ASSET__: async (request) => {
+          const { pathname } = new URL(request.url);
+          const filePath = path4.join(resolvedViteConfig.root, pathname);
+          try {
+            let html = await fsp.readFile(filePath, "utf-8");
+            html = await viteDevServer.transformIndexHtml(pathname, html);
+            return new MiniflareResponse(html, {
+              headers: { "Content-Type": "text/html" }
+            });
+          } catch (error) {
+            throw new Error(`Unexpected error. Failed to load ${pathname}`);
+          }
+        }
       }
     }
-  }
-  const conditionsSet = options.conditions ? new Set(options.conditions) : DEFAULT_CONDITIONS_SET;
-  const _urls = (Array.isArray(options.url) ? options.url : [options.url]).filter(Boolean).map((url) => new URL(normalizeid(url.toString())));
-  if (_urls.length === 0) {
-    _urls.push(new URL(pathToFileURL(process.cwd())));
-  }
-  const urls = [..._urls];
-  for (const url of _urls) {
-    if (url.protocol === "file:") {
-      urls.push(
-        new URL("./", url),
-        // If url is directory
-        new URL(joinURL(url.pathname, "_index.js"), url),
-        // TODO: Remove in next major version?
-        new URL("node_modules", url)
+  ];
+  const workersFromConfig = resolvedPluginConfig.type === "workers" ? Object.entries(resolvedPluginConfig.workers).map(
+    ([environmentName, workerConfig]) => {
+      const miniflareWorkerOptions = unstable_getMiniflareWorkerOptions(
+        {
+          ...workerConfig,
+          assets: void 0
+        },
+        resolvedPluginConfig.cloudflareEnv
       );
+      const { externalWorkers: externalWorkers2 } = miniflareWorkerOptions;
+      const { ratelimits, ...workerOptions } = miniflareWorkerOptions.workerOptions;
+      return {
+        externalWorkers: externalWorkers2,
+        worker: {
+          ...workerOptions,
+          name: workerOptions.name ?? workerConfig.name,
+          modulesRoot: miniflareModulesRoot,
+          unsafeEvalBinding: "__VITE_UNSAFE_EVAL__",
+          serviceBindings: {
+            ...workerOptions.serviceBindings,
+            ...environmentName === resolvedPluginConfig.entryWorkerEnvironmentName && workerConfig.assets?.binding ? {
+              [workerConfig.assets.binding]: ASSET_WORKER_NAME
+            } : {},
+            __VITE_INVOKE_MODULE__: async (request) => {
+              const payload = await request.json();
+              const invokePayloadData = payload.data;
+              assert6(
+                invokePayloadData.name === "fetchModule",
+                `Invalid invoke event: ${invokePayloadData.name}`
+              );
+              const [moduleId] = invokePayloadData.data;
+              const moduleRE = new RegExp(MODULE_PATTERN);
+              const shouldExternalize = (
+                // Worker modules (CompiledWasm, Text, Data)
+                moduleRE.test(moduleId)
+              );
+              if (shouldExternalize) {
+                const result2 = {
+                  externalize: moduleId,
+                  type: "module"
+                };
+                return MiniflareResponse.json({ result: result2 });
+              }
+              const devEnvironment = viteDevServer.environments[environmentName];
+              const result = await devEnvironment.hot.handleInvoke(payload);
+              return MiniflareResponse.json(result);
+            }
+          }
+        }
+      };
     }
-  }
-  let resolved;
-  for (const url of urls) {
-    resolved = _tryModuleResolve(id, url, conditionsSet);
-    if (resolved) {
-      break;
-    }
-    for (const prefix of ["", "/index"]) {
-      for (const extension of options.extensions || DEFAULT_EXTENSIONS) {
-        resolved = _tryModuleResolve(
-          joinURL(id, prefix) + extension,
-          url,
-          conditionsSet
+  ) : [];
+  const userWorkers = workersFromConfig.map((options) => options.worker);
+  const externalWorkers = workersFromConfig.flatMap(
+    (options) => options.externalWorkers
+  );
+  const workerToWorkerEntrypointNamesMap = getWorkerToWorkerEntrypointNamesMap(userWorkers);
+  const workerToDurableObjectClassNamesMap = getWorkerToDurableObjectClassNamesMap(userWorkers);
+  const workerToWorkflowEntrypointClassNamesMap = getWorkerToWorkflowEntrypointClassNamesMap(userWorkers);
+  const logger = new ViteMiniflareLogger(resolvedViteConfig);
+  return {
+    log: logger,
+    handleRuntimeStdio(stdout, stderr) {
+      const decoder = new TextDecoder();
+      stdout.forEach((data2) => logger.info(decoder.decode(data2)));
+      stderr.forEach(
+        (error) => logger.logWithLevel(LogLevel.ERROR, decoder.decode(error))
+      );
+    },
+    ...getPersistence(
+      resolvedViteConfig.root,
+      resolvedPluginConfig.persistState
+    ),
+    workers: [
+      ...assetWorkers,
+      ...externalWorkers,
+      ...userWorkers.map((workerOptions) => {
+        const wrappers = [
+          `import { createWorkerEntrypointWrapper, createDurableObjectWrapper, createWorkflowEntrypointWrapper } from '${RUNNER_PATH}';`,
+          `export default createWorkerEntrypointWrapper('default');`
+        ];
+        const workerEntrypointNames = workerToWorkerEntrypointNamesMap.get(
+          workerOptions.name
         );
-        if (resolved) {
-          break;
+        assert6(
+          workerEntrypointNames,
+          `WorkerEntrypoint names not found for worker ${workerOptions.name}`
+        );
+        for (const entrypointName of [...workerEntrypointNames].sort()) {
+          wrappers.push(
+            `export const ${entrypointName} = createWorkerEntrypointWrapper('${entrypointName}');`
+          );
         }
+        const durableObjectClassNames = workerToDurableObjectClassNamesMap.get(
+          workerOptions.name
+        );
+        assert6(
+          durableObjectClassNames,
+          `DurableObject class names not found for worker ${workerOptions.name}`
+        );
+        for (const className of [...durableObjectClassNames].sort()) {
+          wrappers.push(
+            `export const ${className} = createDurableObjectWrapper('${className}');`
+          );
+        }
+        const workflowEntrypointClassNames = workerToWorkflowEntrypointClassNamesMap.get(workerOptions.name);
+        assert6(
+          workflowEntrypointClassNames,
+          `WorkflowEntrypoint class names not found for worker: ${workerOptions.name}`
+        );
+        for (const className of [...workflowEntrypointClassNames].sort()) {
+          wrappers.push(
+            `export const ${className} = createWorkflowEntrypointWrapper('${className}');`
+          );
+        }
+        return {
+          ...workerOptions,
+          modules: [
+            {
+              type: "ESModule",
+              path: path4.join(miniflareModulesRoot, WRAPPER_PATH),
+              contents: wrappers.join("\n")
+            },
+            {
+              type: "ESModule",
+              path: path4.join(miniflareModulesRoot, RUNNER_PATH),
+              contents: fs3.readFileSync(
+                fileURLToPath2(new URL(RUNNER_PATH, import.meta.url))
+              )
+            }
+          ],
+          unsafeUseModuleFallbackService: true
+        };
+      })
+    ],
+    unsafeModuleFallbackService(request) {
+      const url = new URL(request.url);
+      const rawSpecifier = url.searchParams.get("rawSpecifier");
+      assert6(
+        rawSpecifier,
+        `Unexpected error: no specifier in request to module fallback service.`
+      );
+      const moduleRE = new RegExp(MODULE_PATTERN);
+      const match = moduleRE.exec(rawSpecifier);
+      assert6(match, `Unexpected error: no match for module: ${rawSpecifier}.`);
+      const [full, moduleType, modulePath] = match;
+      assert6(
+        modulePath,
+        `Unexpected error: module path not found in reference: ${full}.`
+      );
+      let source;
+      try {
+        source = fs3.readFileSync(modulePath);
+      } catch (error) {
+        throw new Error(
+          `Import "${modulePath}" not found. Does the file exist?`
+        );
       }
-      if (resolved) {
-        break;
-      }
-    }
-    if (resolved) {
-      break;
+      return MiniflareResponse.json({
+        // Cap'n Proto expects byte arrays for `:Data` typed fields from JSON
+        wasm: Array.from(source)
+      });
     }
-  }
-  if (!resolved) {
-    const error = new Error(
-      `Cannot find module ${id} imported from ${urls.join(", ")}`
-    );
-    error.code = "ERR_MODULE_NOT_FOUND";
-    throw error;
-  }
-  return pathToFileURL(resolved);
-}
-function resolveSync(id, options) {
-  return _resolve(id, options);
-}
-function resolvePathSync(id, options) {
-  return fileURLToPath2(resolveSync(id, options));
+  };
 }
-
-// src/node-js-compat.ts
-import { defineEnv } from "unenv";
-var { env } = defineEnv({
-  nodeCompat: true,
-  presets: [cloudflare]
-});
-var nodeCompatExternals = new Set(env.external);
-var nodeCompatEntries = getNodeCompatEntries();
-function isNodeCompat(workerConfig) {
-  if (workerConfig === void 0) {
-    return false;
-  }
-  const nodeCompatMode = getNodeCompat(
-    workerConfig.compatibility_date,
-    workerConfig.compatibility_flags ?? []
-  ).mode;
-  if (nodeCompatMode === "v2") {
-    return true;
-  }
-  if (nodeCompatMode === "legacy") {
-    throw new Error(
-      "Unsupported Node.js compat mode (legacy). Remove the `node_compat` setting and add the `nodejs_compat` flag instead."
-    );
-  }
-  if (nodeCompatMode === "v1") {
-    throw new Error(
-      `Unsupported Node.js compat mode (v1). Only the v2 mode is supported, either change your compat date to "2024-09-23" or later, or set the "nodejs_compat_v2" compatibility flag`
-    );
-  }
-  return false;
+function getPreviewModules(main, modulesRules) {
+  assert6(modulesRules, `Unexpected error: 'modulesRules' is undefined`);
+  const rootPath = path4.dirname(main);
+  const entryPath = path4.basename(main);
+  return {
+    rootPath,
+    modules: [
+      {
+        type: "ESModule",
+        path: entryPath
+      },
+      ...modulesRules.flatMap(
+        ({ type, include }) => globSync(include, { cwd: rootPath, ignore: entryPath }).map((path8) => ({
+          type,
+          path: path8
+        }))
+      )
+    ]
+  };
 }
-function injectGlobalCode(id, code) {
-  const injectedCode = Object.entries(env.inject).map(([globalName, globalInject]) => {
-    if (typeof globalInject === "string") {
-      const moduleSpecifier2 = globalInject;
-      return `import var_${globalName} from "${moduleSpecifier2}";
-globalThis.${globalName} = var_${globalName};
-`;
-    }
-    const [moduleSpecifier, exportName] = globalInject;
-    assert6(
-      moduleSpecifier !== void 0,
-      "Expected moduleSpecifier to be defined"
-    );
-    assert6(exportName !== void 0, "Expected exportName to be defined");
-    return `import var_${globalName} from "${moduleSpecifier}";
-globalThis.${globalName} = var_${globalName}.${exportName};
-`;
-  }).join("\n");
-  const modified = new MagicString(code);
-  modified.prepend(injectedCode);
+function getPreviewMiniflareOptions(vitePreviewServer, persistState) {
+  const resolvedViteConfig = vitePreviewServer.config;
+  const configPaths = getWorkerConfigPaths(resolvedViteConfig.root);
+  const workerConfigs = configPaths.map(
+    (configPath) => unstable_readConfig({ config: configPath })
+  );
+  const workers = workerConfigs.flatMap((config) => {
+    const miniflareWorkerOptions = unstable_getMiniflareWorkerOptions(config);
+    const { externalWorkers } = miniflareWorkerOptions;
+    const { ratelimits, modulesRules, ...workerOptions } = miniflareWorkerOptions.workerOptions;
+    return [
+      {
+        ...workerOptions,
+        name: workerOptions.name ?? config.name,
+        ...miniflareWorkerOptions.main ? getPreviewModules(miniflareWorkerOptions.main, modulesRules) : { modules: true, script: "" }
+      },
+      ...externalWorkers
+    ];
+  });
+  const logger = new ViteMiniflareLogger(resolvedViteConfig);
   return {
-    code: modified.toString(),
-    map: modified.generateMap({ hires: "boundary", source: id })
+    log: logger,
+    handleRuntimeStdio(stdout, stderr) {
+      const decoder = new TextDecoder();
+      stdout.forEach((data2) => logger.info(decoder.decode(data2)));
+      stderr.forEach(
+        (error) => logger.logWithLevel(LogLevel.ERROR, decoder.decode(error))
+      );
+    },
+    ...getPersistence(resolvedViteConfig.root, persistState),
+    workers
   };
 }
-function resolveNodeJSImport(source) {
-  const alias = env.alias[source];
-  if (alias) {
-    return {
-      unresolved: alias,
-      resolved: resolvePathSync(alias, { url: import.meta.url })
-    };
-  }
-  if (nodeCompatEntries.has(source)) {
-    return {
-      unresolved: source,
-      resolved: resolvePathSync(source, { url: import.meta.url })
-    };
+var ViteMiniflareLogger = class extends Log {
+  logger;
+  constructor(config) {
+    super(miniflareLogLevelFromViteLogLevel(config.logLevel));
+    this.logger = config.logger;
   }
-}
-function getNodeCompatEntries() {
-  const entries = new Set(Object.values(env.alias));
-  for (const globalInject of Object.values(env.inject)) {
-    if (typeof globalInject === "string") {
-      entries.add(globalInject);
-    } else {
-      assert6(
-        globalInject[0] !== void 0,
-        "Expected first element of globalInject to be defined"
-      );
-      entries.add(globalInject[0]);
+  logWithLevel(level, message) {
+    if (/^Ready on http/.test(message)) {
+      level = LogLevel.DEBUG;
+    }
+    switch (level) {
+      case LogLevel.ERROR:
+        return this.logger.error(message);
+      case LogLevel.WARN:
+        return this.logger.warn(message);
+      case LogLevel.INFO:
+        return this.logger.info(message);
     }
   }
-  nodeCompatExternals.forEach((external) => entries.delete(external));
-  return entries;
+};
+function miniflareLogLevelFromViteLogLevel(level = "info") {
+  switch (level) {
+    case "error":
+      return LogLevel.ERROR;
+    case "warn":
+      return LogLevel.WARN;
+    case "info":
+      return LogLevel.INFO;
+    case "silent":
+      return LogLevel.NONE;
+  }
 }
 
 // src/plugin-config.ts
@@ -8841,7 +8872,6 @@ var nonApplicableWorkerConfigs = {
     "build",
     "find_additional_modules",
     "no_bundle",
-    "node_compat",
     "preserve_file_names",
     "site",
     "tsconfig",
@@ -8858,7 +8888,6 @@ var nullableNonApplicable = [
   "find_additional_modules",
   "minify",
   "no_bundle",
-  "node_compat",
   "preserve_file_names",
   "site",
   "tsconfig",
@@ -9009,6 +9038,17 @@ function getWorkerConfig(configPath, env2, opts) {
     };
   }
   assert7(config.main, missingFieldErrorMessage(`'main'`, configPath, env2));
+  const mainStat = fs4.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`
+    );
+  }
+  if (mainStat.isDirectory()) {
+    throw new Error(
+      `The provided Wrangler config main field (${config.main}) points to a directory, it needs to point to a file instead`
+    );
+  }
   return {
     type: "worker",
     raw,
@@ -9109,8 +9149,9 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
 }
 
 // src/websockets.ts
+import { coupleWebSocket } from "miniflare";
 import { WebSocketServer } from "ws";
-function handleWebSocket(httpServer, fetcher, logger) {
+function handleWebSocket(httpServer, fetcher) {
   const nodeWebSocket = new WebSocketServer({ noServer: true });
   httpServer.on(
     "upgrade",
@@ -9134,34 +9175,7 @@ function handleWebSocket(httpServer, fetcher, logger) {
         socket,
         head,
         async (clientWebSocket) => {
-          workerWebSocket.accept();
-          workerWebSocket.addEventListener("message", (event) => {
-            clientWebSocket.send(event.data);
-          });
-          workerWebSocket.addEventListener("error", (event) => {
-            logger.error(
-              `WebSocket error:
-${event.error?.stack || event.error?.message}`,
-              { error: event.error }
-            );
-          });
-          workerWebSocket.addEventListener("close", () => {
-            clientWebSocket.close();
-          });
-          clientWebSocket.on("message", (data2, isBinary) => {
-            workerWebSocket.send(
-              isBinary ? Array.isArray(data2) ? Buffer.concat(data2) : data2 : data2.toString()
-            );
-          });
-          clientWebSocket.on("error", (error) => {
-            logger.error(`WebSocket error:
-${error.stack || error.message}`, {
-              error
-            });
-          });
-          clientWebSocket.on("close", () => {
-            workerWebSocket.close();
-          });
+          coupleWebSocket(clientWebSocket, workerWebSocket);
           nodeWebSocket.emit("connection", clientWebSocket, request);
         }
       );
@@ -9307,7 +9321,7 @@ function cloudflare2(pluginConfig = {}) {
           return;
         }
         config.no_bundle = true;
-        config.rules = [{ type: "ESModule", globs: ["**/*.js"] }];
+        config.rules = [{ type: "ESModule", globs: ["**/*.js", "**/*.mjs"] }];
         if (config.unsafe && Object.keys(config.unsafe).length === 0) {
           config.unsafe = void 0;
         }
@@ -9354,11 +9368,7 @@ function cloudflare2(pluginConfig = {}) {
           },
           { alwaysCallNext: false }
         );
-        handleWebSocket(
-          viteDevServer.httpServer,
-          entryWorker.fetch,
-          viteDevServer.config.logger
-        );
+        handleWebSocket(viteDevServer.httpServer, entryWorker.fetch);
         return () => {
           viteDevServer.middlewares.use((req, res, next) => {
             middleware(req, res, next);
@@ -9380,16 +9390,10 @@ function cloudflare2(pluginConfig = {}) {
           },
           { alwaysCallNext: false }
         );
-        handleWebSocket(
-          vitePreviewServer.httpServer,
-          miniflare2.dispatchFetch,
-          vitePreviewServer.config.logger
-        );
-        return () => {
-          vitePreviewServer.middlewares.use((req, res, next) => {
-            middleware(req, res, next);
-          });
-        };
+        handleWebSocket(vitePreviewServer.httpServer, miniflare2.dispatchFetch);
+        vitePreviewServer.middlewares.use((req, res, next) => {
+          middleware(req, res, next);
+        });
       }
     },
     // Plugin to support `CompiledWasm` modules