@cloudflare/vite-plugin 0.0.0-62aaf44c0 → 0.0.0-62d5471ea

package/dist/index.js

@@ -1,6 +1,7 @@
 // src/index.ts
 import assert9 from "node:assert";
 import * as fs5 from "node:fs";
+import { builtinModules as builtinModules2 } from "node:module";
 import * as path7 from "node:path";
 import { createMiddleware } from "@hattip/adapter-node";
 
@@ -1073,715 +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 { builtinModules } from "node:module";
-import * as path from "node:path";
-import { Request as MiniflareRequest } from "miniflare";
-import "vite";
-var nodeBuiltInModules = new Set(
-  builtinModules.concat(builtinModules.map((m) => `node:${m}`))
-);
-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],
-      // The Node.js ones are no proper builtins in the environment since we also polyfill them using unenv
-      external: [...nodeBuiltInModules]
-    },
-    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: [
-        // we have to exclude all node modules to work in dev-mode not just the unenv externals...
-        ...nodeBuiltInModules
-      ],
-      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 { 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 && typeof value.name === "string" && value.entrypoint !== void 0 && value.entrypoint !== "default") {
-        const entrypointNames = workerToWorkerEntrypointNamesMap.get(
-          value.name
-        );
-        assert4(entrypointNames, missingWorkerErrorMessage(value.name));
-        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) || // Node.js builtin node modules (they will be resolved to unenv aliases)
-              nodeBuiltInModules.has(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";
 
@@ -7313,8 +6610,8 @@ Parser.acorn = {
 };
 
 // ../../node_modules/.pnpm/mlly@1.7.4/node_modules/mlly/dist/index.mjs
-import { builtinModules as builtinModules2, createRequire } from "node:module";
-import fs3, { realpathSync, statSync as statSync2, promises } from "node:fs";
+import { builtinModules, createRequire } from "node:module";
+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;
@@ -7371,12 +6668,12 @@ 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(builtinModules2);
+var BUILTIN_MODULES = new Set(builtinModules);
 function normalizeSlash(path8) {
   return path8.replace(/\\/g, "/");
 }
@@ -7409,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];
     }
@@ -7425,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"'
         );
@@ -7505,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
@@ -7673,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}).`
@@ -7685,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}).`
   );
@@ -7722,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} */
@@ -7776,1028 +7073,1766 @@ function read(jsonPath, { base, specifier }) {
       result.type = parsed.type;
     }
   }
-  cache.set(jsonPath, result);
-  return result;
-}
-function getPackageScopeConfig(resolved) {
-  let packageJSONUrl = new URL("package.json", resolved);
-  while (true) {
-    const packageJSONPath2 = packageJSONUrl.pathname;
-    if (packageJSONPath2.endsWith("node_modules/package.json")) {
-      break;
-    }
-    const packageConfig = read(fileURLToPath$1(packageJSONUrl), {
-      specifier: resolved
-    });
-    if (packageConfig.exists) {
-      return packageConfig;
-    }
-    const lastPackageJSONUrl = packageJSONUrl;
-    packageJSONUrl = new URL("../package.json", packageJSONUrl);
-    if (packageJSONUrl.pathname === lastPackageJSONUrl.pathname) {
-      break;
-    }
+  cache.set(jsonPath, result);
+  return result;
+}
+function getPackageScopeConfig(resolved) {
+  let packageJSONUrl = new URL("package.json", resolved);
+  while (true) {
+    const packageJSONPath2 = packageJSONUrl.pathname;
+    if (packageJSONPath2.endsWith("node_modules/package.json")) {
+      break;
+    }
+    const packageConfig = read(fileURLToPath$1(packageJSONUrl), {
+      specifier: resolved
+    });
+    if (packageConfig.exists) {
+      return packageConfig;
+    }
+    const lastPackageJSONUrl = packageJSONUrl;
+    packageJSONUrl = new URL("../package.json", packageJSONUrl);
+    if (packageJSONUrl.pathname === lastPackageJSONUrl.pathname) {
+      break;
+    }
+  }
+  const packageJSONPath = fileURLToPath$1(packageJSONUrl);
+  return {
+    pjsonPath: packageJSONPath,
+    exists: false,
+    type: "none"
+  };
+}
+function getPackageType(url) {
+  return getPackageScopeConfig(url).type;
+}
+var { ERR_UNKNOWN_FILE_EXTENSION } = codes;
+var hasOwnProperty2 = {}.hasOwnProperty;
+var extensionFormatMap = {
+  // @ts-expect-error: hush.
+  __proto__: null,
+  ".cjs": "commonjs",
+  ".js": "module",
+  ".json": "json",
+  ".mjs": "module"
+};
+function mimeToFormat(mime) {
+  if (mime && /\s*(text|application)\/javascript\s*(;\s*charset=utf-?8\s*)?/i.test(mime))
+    return "module";
+  if (mime === "application/json") return "json";
+  return null;
+}
+var protocolHandlers = {
+  // @ts-expect-error: hush.
+  __proto__: null,
+  "data:": getDataProtocolModuleFormat,
+  "file:": getFileProtocolModuleFormat,
+  "http:": getHttpProtocolModuleFormat,
+  "https:": getHttpProtocolModuleFormat,
+  "node:"() {
+    return "builtin";
+  }
+};
+function getDataProtocolModuleFormat(parsed) {
+  const { 1: mime } = /^([^/]+\/[^;,]+)[^,]*?(;base64)?,/.exec(
+    parsed.pathname
+  ) || [null, null, null];
+  return mimeToFormat(mime);
+}
+function extname2(url) {
+  const pathname = url.pathname;
+  let index = pathname.length;
+  while (index--) {
+    const code = pathname.codePointAt(index);
+    if (code === 47) {
+      return "";
+    }
+    if (code === 46) {
+      return pathname.codePointAt(index - 1) === 47 ? "" : pathname.slice(index);
+    }
+  }
+  return "";
+}
+function getFileProtocolModuleFormat(url, _context, ignoreErrors) {
+  const value = extname2(url);
+  if (value === ".js") {
+    const packageType = getPackageType(url);
+    if (packageType !== "none") {
+      return packageType;
+    }
+    return "commonjs";
+  }
+  if (value === "") {
+    const packageType = getPackageType(url);
+    if (packageType === "none" || packageType === "commonjs") {
+      return "commonjs";
+    }
+    return "module";
+  }
+  const format3 = extensionFormatMap[value];
+  if (format3) return format3;
+  if (ignoreErrors) {
+    return void 0;
+  }
+  const filepath = fileURLToPath$1(url);
+  throw new ERR_UNKNOWN_FILE_EXTENSION(value, filepath);
+}
+function getHttpProtocolModuleFormat() {
+}
+function defaultGetFormatWithoutErrors(url, context) {
+  const protocol = url.protocol;
+  if (!hasOwnProperty2.call(protocolHandlers, protocol)) {
+    return null;
+  }
+  return protocolHandlers[protocol](url, context, true) || null;
+}
+var RegExpPrototypeSymbolReplace = RegExp.prototype[Symbol.replace];
+var {
+  ERR_NETWORK_IMPORT_DISALLOWED,
+  ERR_INVALID_MODULE_SPECIFIER,
+  ERR_INVALID_PACKAGE_CONFIG,
+  ERR_INVALID_PACKAGE_TARGET,
+  ERR_MODULE_NOT_FOUND,
+  ERR_PACKAGE_IMPORT_NOT_DEFINED,
+  ERR_PACKAGE_PATH_NOT_EXPORTED,
+  ERR_UNSUPPORTED_DIR_IMPORT,
+  ERR_UNSUPPORTED_RESOLVE_REQUEST
+} = codes;
+var own = {}.hasOwnProperty;
+var invalidSegmentRegEx = /(^|\\|\/)((\.|%2e)(\.|%2e)?|(n|%6e|%4e)(o|%6f|%4f)(d|%64|%44)(e|%65|%45)(_|%5f)(m|%6d|%4d)(o|%6f|%4f)(d|%64|%44)(u|%75|%55)(l|%6c|%4c)(e|%65|%45)(s|%73|%53))?(\\|\/|$)/i;
+var deprecatedInvalidSegmentRegEx = /(^|\\|\/)((\.|%2e)(\.|%2e)?|(n|%6e|%4e)(o|%6f|%4f)(d|%64|%44)(e|%65|%45)(_|%5f)(m|%6d|%4d)(o|%6f|%4f)(d|%64|%44)(u|%75|%55)(l|%6c|%4c)(e|%65|%45)(s|%73|%53))(\\|\/|$)/i;
+var invalidPackageNameRegEx = /^\.|%|\\/;
+var patternRegEx = /\*/g;
+var encodedSeparatorRegEx = /%2f|%5c/i;
+var emittedPackageWarnings = /* @__PURE__ */ new Set();
+var doubleSlashRegEx = /[/\\]{2}/;
+function emitInvalidSegmentDeprecation(target2, request, match, packageJsonUrl, internal, base, isTarget) {
+  if (process$1.noDeprecation) {
+    return;
+  }
+  const pjsonPath = fileURLToPath$1(packageJsonUrl);
+  const double = doubleSlashRegEx.exec(isTarget ? target2 : request) !== null;
+  process$1.emitWarning(
+    `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"
+  );
+}
+function emitLegacyIndexDeprecation(url, packageJsonUrl, base, main) {
+  if (process$1.noDeprecation) {
+    return;
+  }
+  const format3 = defaultGetFormatWithoutErrors(url, { parentURL: base.href });
+  if (format3 !== "module") return;
+  const urlPath = fileURLToPath$1(url.href);
+  const packagePath = fileURLToPath$1(new URL$1(".", packageJsonUrl));
+  const basePath = fileURLToPath$1(base);
+  if (!main) {
+    process$1.emitWarning(
+      `No "main" or "exports" field defined in the package.json for ${packagePath} resolving the main entry point "${urlPath.slice(
+        packagePath.length
+      )}", imported from ${basePath}.
+Default "index" lookups for the main are deprecated for ES modules.`,
+      "DeprecationWarning",
+      "DEP0151"
+    );
+  } 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
+      )}", imported from ${basePath}.
+ Automatic extension resolution of the "main" field is deprecated for ES modules.`,
+      "DeprecationWarning",
+      "DEP0151"
+    );
+  }
+}
+function tryStatSync(path8) {
+  try {
+    return statSync(path8);
+  } catch {
+  }
+}
+function fileExists(url) {
+  const stats = statSync(url, { throwIfNoEntry: false });
+  const isFile = stats ? stats.isFile() : void 0;
+  return isFile === null || isFile === void 0 ? false : isFile;
+}
+function legacyMainResolve(packageJsonUrl, packageConfig, base) {
+  let guess;
+  if (packageConfig.main !== void 0) {
+    guess = new URL$1(packageConfig.main, packageJsonUrl);
+    if (fileExists(guess)) return guess;
+    const tries2 = [
+      `./${packageConfig.main}.js`,
+      `./${packageConfig.main}.json`,
+      `./${packageConfig.main}.node`,
+      `./${packageConfig.main}/index.js`,
+      `./${packageConfig.main}/index.json`,
+      `./${packageConfig.main}/index.node`
+    ];
+    let i2 = -1;
+    while (++i2 < tries2.length) {
+      guess = new URL$1(tries2[i2], packageJsonUrl);
+      if (fileExists(guess)) break;
+      guess = void 0;
+    }
+    if (guess) {
+      emitLegacyIndexDeprecation(
+        guess,
+        packageJsonUrl,
+        base,
+        packageConfig.main
+      );
+      return guess;
+    }
+  }
+  const tries = ["./index.js", "./index.json", "./index.node"];
+  let i = -1;
+  while (++i < tries.length) {
+    guess = new URL$1(tries[i], packageJsonUrl);
+    if (fileExists(guess)) break;
+    guess = void 0;
+  }
+  if (guess) {
+    emitLegacyIndexDeprecation(guess, packageJsonUrl, base, packageConfig.main);
+    return guess;
+  }
+  throw new ERR_MODULE_NOT_FOUND(
+    fileURLToPath$1(new URL$1(".", packageJsonUrl)),
+    fileURLToPath$1(base)
+  );
+}
+function finalizeResolution(resolved, base, preserveSymlinks) {
+  if (encodedSeparatorRegEx.exec(resolved.pathname) !== null) {
+    throw new ERR_INVALID_MODULE_SPECIFIER(
+      resolved.pathname,
+      'must not include encoded "/" or "\\" characters',
+      fileURLToPath$1(base)
+    );
+  }
+  let filePath;
+  try {
+    filePath = fileURLToPath$1(resolved);
+  } catch (error) {
+    const cause = (
+      /** @type {ErrnoException} */
+      error
+    );
+    Object.defineProperty(cause, "input", { value: String(resolved) });
+    Object.defineProperty(cause, "module", { value: String(base) });
+    throw cause;
+  }
+  const stats = tryStatSync(
+    filePath.endsWith("/") ? filePath.slice(-1) : filePath
+  );
+  if (stats && stats.isDirectory()) {
+    const error = new ERR_UNSUPPORTED_DIR_IMPORT(filePath, fileURLToPath$1(base));
+    error.url = String(resolved);
+    throw error;
   }
-  const packageJSONPath = fileURLToPath$1(packageJSONUrl);
-  return {
-    pjsonPath: packageJSONPath,
-    exists: false,
-    type: "none"
-  };
+  if (!stats || !stats.isFile()) {
+    const error = new ERR_MODULE_NOT_FOUND(
+      filePath || resolved.pathname,
+      base && fileURLToPath$1(base),
+      true
+    );
+    error.url = String(resolved);
+    throw error;
+  }
+  {
+    const real = realpathSync(filePath);
+    const { search, hash } = resolved;
+    resolved = pathToFileURL$1(real + (filePath.endsWith(path.sep) ? "/" : ""));
+    resolved.search = search;
+    resolved.hash = hash;
+  }
+  return resolved;
 }
-function getPackageType(url) {
-  return getPackageScopeConfig(url).type;
+function importNotDefined(specifier, packageJsonUrl, base) {
+  return new ERR_PACKAGE_IMPORT_NOT_DEFINED(
+    specifier,
+    packageJsonUrl && fileURLToPath$1(new URL$1(".", packageJsonUrl)),
+    fileURLToPath$1(base)
+  );
 }
-var { ERR_UNKNOWN_FILE_EXTENSION } = codes;
-var hasOwnProperty2 = {}.hasOwnProperty;
-var extensionFormatMap = {
-  // @ts-expect-error: hush.
-  __proto__: null,
-  ".cjs": "commonjs",
-  ".js": "module",
-  ".json": "json",
-  ".mjs": "module"
-};
-function mimeToFormat(mime) {
-  if (mime && /\s*(text|application)\/javascript\s*(;\s*charset=utf-?8\s*)?/i.test(mime))
-    return "module";
-  if (mime === "application/json") return "json";
-  return null;
+function exportsNotFound(subpath, packageJsonUrl, base) {
+  return new ERR_PACKAGE_PATH_NOT_EXPORTED(
+    fileURLToPath$1(new URL$1(".", packageJsonUrl)),
+    subpath,
+    base && fileURLToPath$1(base)
+  );
 }
-var protocolHandlers = {
-  // @ts-expect-error: hush.
-  __proto__: null,
-  "data:": getDataProtocolModuleFormat,
-  "file:": getFileProtocolModuleFormat,
-  "http:": getHttpProtocolModuleFormat,
-  "https:": getHttpProtocolModuleFormat,
-  "node:"() {
-    return "builtin";
-  }
-};
-function getDataProtocolModuleFormat(parsed) {
-  const { 1: mime } = /^([^/]+\/[^;,]+)[^,]*?(;base64)?,/.exec(
-    parsed.pathname
-  ) || [null, null, null];
-  return mimeToFormat(mime);
+function throwInvalidSubpath(request, match, packageJsonUrl, internal, base) {
+  const reason = `request is not a valid match in pattern "${match}" for the "${internal ? "imports" : "exports"}" resolution of ${fileURLToPath$1(packageJsonUrl)}`;
+  throw new ERR_INVALID_MODULE_SPECIFIER(
+    request,
+    reason,
+    base && fileURLToPath$1(base)
+  );
 }
-function extname2(url) {
-  const pathname = url.pathname;
-  let index = pathname.length;
-  while (index--) {
-    const code = pathname.codePointAt(index);
-    if (code === 47) {
-      return "";
+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,
+    target2,
+    internal,
+    base && fileURLToPath$1(base)
+  );
+}
+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(target2);
+        isURL = true;
+      } catch {
+      }
+      if (!isURL) {
+        const exportTarget = pattern ? RegExpPrototypeSymbolReplace.call(
+          patternRegEx,
+          target2,
+          () => subpath
+        ) : target2 + subpath;
+        return packageResolve(exportTarget, packageJsonUrl, conditions);
+      }
     }
-    if (code === 46) {
-      return pathname.codePointAt(index - 1) === 47 ? "" : pathname.slice(index);
+    throw invalidPackageTarget(match, target2, packageJsonUrl, internal, base);
+  }
+  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,
+          target2,
+          () => subpath
+        ) : target2;
+        emitInvalidSegmentDeprecation(
+          resolvedTarget,
+          request,
+          match,
+          packageJsonUrl,
+          internal,
+          base,
+          true
+        );
+      }
+    } else {
+      throw invalidPackageTarget(match, target2, packageJsonUrl, internal, base);
     }
   }
-  return "";
+  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 getFileProtocolModuleFormat(url, _context, ignoreErrors) {
-  const value = extname2(url);
-  if (value === ".js") {
-    const packageType = getPackageType(url);
-    if (packageType !== "none") {
-      return packageType;
+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;
     }
-    return "commonjs";
+    if (lastException === void 0 || lastException === null) {
+      return null;
+    }
+    throw lastException;
   }
-  if (value === "") {
-    const packageType = getPackageType(url);
-    if (packageType === "none" || packageType === "commonjs") {
-      return "commonjs";
+  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.'
+        );
+      }
     }
-    return "module";
+    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;
   }
-  const format3 = extensionFormatMap[value];
-  if (format3) return format3;
-  if (ignoreErrors) {
-    return void 0;
+  if (target2 === null) {
+    return null;
   }
-  const filepath = fileURLToPath$1(url);
-  throw new ERR_UNKNOWN_FILE_EXTENSION(value, filepath);
-}
-function getHttpProtocolModuleFormat() {
+  throw invalidPackageTarget(
+    packageSubpath,
+    target2,
+    packageJsonUrl,
+    internal,
+    base
+  );
 }
-function defaultGetFormatWithoutErrors(url, context) {
-  const protocol = url.protocol;
-  if (!hasOwnProperty2.call(protocolHandlers, protocol)) {
-    return null;
+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 protocolHandlers[protocol](url, context, true) || null;
+  return isConditionalSugar;
 }
-var RegExpPrototypeSymbolReplace = RegExp.prototype[Symbol.replace];
-var {
-  ERR_NETWORK_IMPORT_DISALLOWED,
-  ERR_INVALID_MODULE_SPECIFIER,
-  ERR_INVALID_PACKAGE_CONFIG,
-  ERR_INVALID_PACKAGE_TARGET,
-  ERR_MODULE_NOT_FOUND,
-  ERR_PACKAGE_IMPORT_NOT_DEFINED,
-  ERR_PACKAGE_PATH_NOT_EXPORTED,
-  ERR_UNSUPPORTED_DIR_IMPORT,
-  ERR_UNSUPPORTED_RESOLVE_REQUEST
-} = codes;
-var own = {}.hasOwnProperty;
-var invalidSegmentRegEx = /(^|\\|\/)((\.|%2e)(\.|%2e)?|(n|%6e|%4e)(o|%6f|%4f)(d|%64|%44)(e|%65|%45)(_|%5f)(m|%6d|%4d)(o|%6f|%4f)(d|%64|%44)(u|%75|%55)(l|%6c|%4c)(e|%65|%45)(s|%73|%53))?(\\|\/|$)/i;
-var deprecatedInvalidSegmentRegEx = /(^|\\|\/)((\.|%2e)(\.|%2e)?|(n|%6e|%4e)(o|%6f|%4f)(d|%64|%44)(e|%65|%45)(_|%5f)(m|%6d|%4d)(o|%6f|%4f)(d|%64|%44)(u|%75|%55)(l|%6c|%4c)(e|%65|%45)(s|%73|%53))(\\|\/|$)/i;
-var invalidPackageNameRegEx = /^\.|%|\\/;
-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 emitTrailingSlashPatternDeprecation(match, pjsonUrl, base) {
   if (process$1.noDeprecation) {
     return;
   }
-  const pjsonPath = fileURLToPath$1(packageJsonUrl);
-  const double = doubleSlashRegEx.exec(isTarget ? target : request) !== null;
+  const pjsonPath = fileURLToPath$1(pjsonUrl);
+  if (emittedPackageWarnings.has(pjsonPath + "|" + match)) return;
+  emittedPackageWarnings.add(pjsonPath + "|" + match);
   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 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",
-    "DEP0166"
+    "DEP0155"
   );
 }
-function emitLegacyIndexDeprecation(url, packageJsonUrl, base, main) {
-  if (process$1.noDeprecation) {
-    return;
+function packageExportsResolve(packageJsonUrl, packageSubpath, packageConfig, base, conditions) {
+  let exports = packageConfig.exports;
+  if (isConditionalExportsMainSugar(exports, packageJsonUrl, base)) {
+    exports = { ".": exports };
   }
-  const format3 = defaultGetFormatWithoutErrors(url, { parentURL: base.href });
-  if (format3 !== "module") return;
-  const urlPath = fileURLToPath$1(url.href);
-  const packagePath = fileURLToPath$1(new URL$1(".", packageJsonUrl));
-  const basePath = fileURLToPath$1(base);
-  if (!main) {
-    process$1.emitWarning(
-      `No "main" or "exports" field defined in the package.json for ${packagePath} resolving the main entry point "${urlPath.slice(
-        packagePath.length
-      )}", imported from ${basePath}.
-Default "index" lookups for the main are deprecated for ES modules.`,
-      "DeprecationWarning",
-      "DEP0151"
+  if (own.call(exports, packageSubpath) && !packageSubpath.includes("*") && !packageSubpath.endsWith("/")) {
+    const target2 = exports[packageSubpath];
+    const resolveResult = resolvePackageTarget(
+      packageJsonUrl,
+      target2,
+      "",
+      packageSubpath,
+      base,
+      false,
+      false,
+      false,
+      conditions
     );
-  } else if (path4.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
-      )}", imported from ${basePath}.
- Automatic extension resolution of the "main" field is deprecated for ES modules.`,
-      "DeprecationWarning",
-      "DEP0151"
+    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
+        );
+      }
+    }
+  }
+  if (bestMatch) {
+    const target2 = (
+      /** @type {unknown} */
+      exports[bestMatch]
+    );
+    const resolveResult = resolvePackageTarget(
+      packageJsonUrl,
+      target2,
+      bestMatchSubpath,
+      bestMatch,
+      base,
+      true,
+      false,
+      packageSubpath.endsWith("/"),
+      conditions
     );
+    if (resolveResult === null || resolveResult === void 0) {
+      throw exportsNotFound(packageSubpath, packageJsonUrl, base);
+    }
+    return resolveResult;
   }
+  throw exportsNotFound(packageSubpath, packageJsonUrl, base);
 }
-function tryStatSync(path8) {
-  try {
-    return statSync2(path8);
-  } catch {
+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,
+          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 target2 = imports[bestMatch];
+          const resolveResult = resolvePackageTarget(
+            packageJsonUrl,
+            target2,
+            bestMatchSubpath,
+            bestMatch,
+            base,
+            true,
+            true,
+            false,
+            conditions
+          );
+          if (resolveResult !== null && resolveResult !== void 0) {
+            return resolveResult;
+          }
+        }
+      }
+    }
   }
+  throw importNotDefined(name2, packageJsonUrl, base);
 }
-function fileExists(url) {
-  const stats = statSync2(url, { throwIfNoEntry: false });
-  const isFile = stats ? stats.isFile() : void 0;
-  return isFile === null || isFile === void 0 ? false : isFile;
-}
-function legacyMainResolve(packageJsonUrl, packageConfig, base) {
-  let guess;
-  if (packageConfig.main !== void 0) {
-    guess = new URL$1(packageConfig.main, packageJsonUrl);
-    if (fileExists(guess)) return guess;
-    const tries2 = [
-      `./${packageConfig.main}.js`,
-      `./${packageConfig.main}.json`,
-      `./${packageConfig.main}.node`,
-      `./${packageConfig.main}/index.js`,
-      `./${packageConfig.main}/index.json`,
-      `./${packageConfig.main}/index.node`
-    ];
-    let i2 = -1;
-    while (++i2 < tries2.length) {
-      guess = new URL$1(tries2[i2], packageJsonUrl);
-      if (fileExists(guess)) break;
-      guess = void 0;
-    }
-    if (guess) {
-      emitLegacyIndexDeprecation(
-        guess,
-        packageJsonUrl,
-        base,
-        packageConfig.main
-      );
-      return guess;
+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 tries = ["./index.js", "./index.json", "./index.node"];
-  let i = -1;
-  while (++i < tries.length) {
-    guess = new URL$1(tries[i], packageJsonUrl);
-    if (fileExists(guess)) break;
-    guess = void 0;
-  }
-  if (guess) {
-    emitLegacyIndexDeprecation(guess, packageJsonUrl, base, packageConfig.main);
-    return guess;
+  const packageName = separatorIndex === -1 ? specifier : specifier.slice(0, separatorIndex);
+  if (invalidPackageNameRegEx.exec(packageName) !== null) {
+    validPackageName = false;
   }
-  throw new ERR_MODULE_NOT_FOUND(
-    fileURLToPath$1(new URL$1(".", packageJsonUrl)),
-    fileURLToPath$1(base)
-  );
-}
-function finalizeResolution(resolved, base, preserveSymlinks) {
-  if (encodedSeparatorRegEx.exec(resolved.pathname) !== null) {
+  if (!validPackageName) {
     throw new ERR_INVALID_MODULE_SPECIFIER(
-      resolved.pathname,
-      'must not include encoded "/" or "\\" characters',
+      specifier,
+      "is not a valid package name",
       fileURLToPath$1(base)
     );
   }
-  let filePath;
-  try {
-    filePath = fileURLToPath$1(resolved);
-  } catch (error) {
-    const cause = (
-      /** @type {ErrnoException} */
-      error
-    );
-    Object.defineProperty(cause, "input", { value: String(resolved) });
-    Object.defineProperty(cause, "module", { value: String(base) });
-    throw cause;
-  }
-  const stats = tryStatSync(
-    filePath.endsWith("/") ? filePath.slice(-1) : filePath
-  );
-  if (stats && stats.isDirectory()) {
-    const error = new ERR_UNSUPPORTED_DIR_IMPORT(filePath, fileURLToPath$1(base));
-    error.url = String(resolved);
-    throw error;
-  }
-  if (!stats || !stats.isFile()) {
-    const error = new ERR_MODULE_NOT_FOUND(
-      filePath || resolved.pathname,
-      base && fileURLToPath$1(base),
-      true
-    );
-    error.url = String(resolved);
-    throw error;
-  }
-  {
-    const real = realpathSync(filePath);
-    const { search, hash } = resolved;
-    resolved = pathToFileURL$1(real + (filePath.endsWith(path4.sep) ? "/" : ""));
-    resolved.search = search;
-    resolved.hash = hash;
-  }
-  return resolved;
+  const packageSubpath = "." + (separatorIndex === -1 ? "" : specifier.slice(separatorIndex));
+  return { packageName, packageSubpath, isScoped };
 }
-function importNotDefined(specifier, packageJsonUrl, base) {
-  return new ERR_PACKAGE_IMPORT_NOT_DEFINED(
+function packageResolve(specifier, base, conditions) {
+  if (builtinModules.includes(specifier)) {
+    return new URL$1("node:" + specifier);
+  }
+  const { packageName, packageSubpath, isScoped } = parsePackageName(
     specifier,
-    packageJsonUrl && fileURLToPath$1(new URL$1(".", packageJsonUrl)),
-    fileURLToPath$1(base)
-  );
-}
-function exportsNotFound(subpath, packageJsonUrl, base) {
-  return new ERR_PACKAGE_PATH_NOT_EXPORTED(
-    fileURLToPath$1(new URL$1(".", packageJsonUrl)),
-    subpath,
-    base && fileURLToPath$1(base)
-  );
-}
-function throwInvalidSubpath(request, match, packageJsonUrl, internal, base) {
-  const reason = `request is not a valid match in pattern "${match}" for the "${internal ? "imports" : "exports"}" resolution of ${fileURLToPath$1(packageJsonUrl)}`;
-  throw new ERR_INVALID_MODULE_SPECIFIER(
-    request,
-    reason,
-    base && fileURLToPath$1(base)
+    base
   );
-}
-function invalidPackageTarget(subpath, target, packageJsonUrl, internal, base) {
-  target = typeof target === "object" && target !== null ? JSON.stringify(target, null, "") : `${target}`;
-  return new ERR_INVALID_PACKAGE_TARGET(
-    fileURLToPath$1(new URL$1(".", packageJsonUrl)),
-    subpath,
-    target,
-    internal,
-    base && fileURLToPath$1(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 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("/")) {
-      let isURL = false;
-      try {
-        new URL$1(target);
-        isURL = true;
-      } catch {
-      }
-      if (!isURL) {
-        const exportTarget = pattern ? RegExpPrototypeSymbolReplace.call(
-          patternRegEx,
-          target,
-          () => subpath
-        ) : target + subpath;
-        return packageResolve(exportTarget, packageJsonUrl, conditions);
-      }
+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 invalidPackageTarget(match, target, packageJsonUrl, internal, base);
   }
-  if (invalidSegmentRegEx.exec(target.slice(2)) !== null) {
-    if (deprecatedInvalidSegmentRegEx.exec(target.slice(2)) === null) {
-      if (!isPathMap) {
-        const request = pattern ? match.replace("*", () => subpath) : match + subpath;
-        const resolvedTarget = pattern ? RegExpPrototypeSymbolReplace.call(
-          patternRegEx,
-          target,
-          () => subpath
-        ) : target;
-        emitInvalidSegmentDeprecation(
-          resolvedTarget,
-          request,
-          match,
-          packageJsonUrl,
-          internal,
-          base,
-          true
-        );
-      }
-    } else {
-      throw invalidPackageTarget(match, target, packageJsonUrl, internal, base);
+  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;
     }
-  }
-  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 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;
       }
-    } else {
-      throwInvalidSubpath(request, match, packageJsonUrl, internal, base);
+      resolved = packageResolve(specifier, base, conditions);
     }
   }
-  if (pattern) {
-    return new URL$1(
-      RegExpPrototypeSymbolReplace.call(
-        patternRegEx,
-        resolved.href,
-        () => subpath
-      )
-    );
+  assert(resolved !== void 0, "expected to be defined");
+  if (resolved.protocol !== "file:") {
+    return resolved;
   }
-  return new URL$1(subpath, resolved);
+  return finalizeResolution(resolved, base);
 }
-function isArrayIndex(key) {
-  const keyNumber = Number(key);
-  if (`${keyNumber}` !== key) return false;
-  return keyNumber >= 0 && keyNumber < 4294967295;
+function fileURLToPath(id) {
+  if (typeof id === "string" && !id.startsWith("file://")) {
+    return normalizeSlash(id);
+  }
+  return normalizeSlash(fileURLToPath$1(id));
 }
-function resolvePackageTarget(packageJsonUrl, target, subpath, packageSubpath, base, pattern, internal, isPathMap, conditions) {
-  if (typeof target === "string") {
-    return resolvePackageTargetString(
-      target,
-      subpath,
-      packageSubpath,
-      packageJsonUrl,
-      base,
-      pattern,
-      internal,
-      isPathMap,
-      conditions
-    );
+function pathToFileURL(id) {
+  return pathToFileURL$1(fileURLToPath(id)).toString();
+}
+function normalizeid(id) {
+  if (typeof id !== "string") {
+    id = id.toString();
   }
-  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(
-          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 (/(node|data|http|https|file):/.test(id)) {
+    return id;
+  }
+  if (BUILTIN_MODULES.has(id)) {
+    return "node:" + id;
+  }
+  return "file://" + encodeURI(normalizeSlash(id));
+}
+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 (lastException === void 0 || lastException === null) {
-      return null;
+  }
+}
+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`");
     }
-    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.'
-        );
+  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);
       }
-    }
-    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;
+    } catch (error) {
+      if (error?.code !== "ENOENT") {
+        throw error;
       }
     }
-    return null;
   }
-  if (target === null) {
-    return null;
+  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())));
   }
-  throw invalidPackageTarget(
-    packageSubpath,
-    target,
-    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.`
+  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)
       );
     }
   }
-  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 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);
+  let resolved;
+  for (const url of urls) {
+    resolved = _tryModuleResolve(id, url, conditionsSet);
+    if (resolved) {
+      break;
     }
-    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
+    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(", ")}`
     );
-    const resolveResult = resolvePackageTarget(
-      packageJsonUrl,
-      target,
-      bestMatchSubpath,
-      bestMatch,
-      base,
-      true,
-      false,
-      packageSubpath.endsWith("/"),
-      conditions
+    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`
     );
-    if (resolveResult === null || resolveResult === void 0) {
-      throw exportsNotFound(packageSubpath, packageJsonUrl, base);
-    }
-    return resolveResult;
   }
-  throw exportsNotFound(packageSubpath, packageJsonUrl, base);
+  return false;
 }
-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 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"
+    );
+    assert2(exportName !== void 0, "Expected exportName to be defined");
+    return `import var_${globalName} from "${moduleSpecifier}";
+globalThis.${globalName} = var_${globalName}.${exportName};
+`;
+  }).join("\n");
+  const polyfillCode = env.polyfill.map((polyfillPath) => `import "${polyfillPath}";
+`).join("");
+  const modified = new MagicString(code);
+  modified.prepend(injectedCode);
+  modified.prepend(polyfillCode);
+  return {
+    code: modified.toString(),
+    map: modified.generateMap({ hires: "boundary", source: id })
+  };
 }
-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));
+function resolveNodeJSImport(source) {
+  const alias = env.alias[source];
+  if (alias) {
+    return {
+      unresolved: alias,
+      resolved: resolvePathSync(alias, { url: import.meta.url })
+    };
   }
-  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;
-          }
-        }
+  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]);
+    }
+  }
+  env.polyfill.forEach((polyfill) => entries.add(polyfill));
+  nodeCompatExternals.forEach((external) => entries.delete(external));
+  return entries;
+}
+
+// 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 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);
+    }
+  }
+  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;
   }
-  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)
+  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 (builtinModules2.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 && !builtinModules2.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 CLOUDFLARE_VIRTUAL_PREFIX = "\0__CLOUDFLARE_NODEJS_COMPAT__";
-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 injectGlobalCode(id, code) {
-  const injectedCode = Object.entries(env.inject).map(([globalName, globalInject]) => {
-    if (typeof globalInject === "string") {
-      const moduleSpecifier2 = globalInject;
-      return `import var_${globalName} from "${CLOUDFLARE_VIRTUAL_PREFIX}${moduleSpecifier2}";
-globalThis.${globalName} = var_${globalName};
-`;
-    }
-    const [moduleSpecifier, exportName] = globalInject;
-    return `import var_${globalName} from "${CLOUDFLARE_VIRTUAL_PREFIX}${moduleSpecifier}";
-globalThis.${globalName} = var_${globalName}.${exportName};
-`;
-  }).join("\n");
-  const modified = new MagicString(code);
-  modified.prepend(injectedCode);
+function getPreviewModules(main, modulesRules) {
+  assert6(modulesRules, `Unexpected error: 'modulesRules' is undefined`);
+  const rootPath = path4.dirname(main);
+  const entryPath = path4.basename(main);
   return {
-    code: modified.toString(),
-    map: modified.generateMap({ hires: "boundary", source: id })
+    rootPath,
+    modules: [
+      {
+        type: "ESModule",
+        path: entryPath
+      },
+      ...modulesRules.flatMap(
+        ({ type, include }) => globSync(include, { cwd: rootPath, ignore: entryPath }).map((path8) => ({
+          type,
+          path: path8
+        }))
+      )
+    ]
   };
 }
-function getNodeCompatAliases() {
-  const aliases = {};
-  Object.keys(env.alias).forEach((key) => {
-    if (!env.external.includes(key)) {
-      aliases[key] = CLOUDFLARE_VIRTUAL_PREFIX + key;
-    }
-  });
-  return aliases;
-}
-function getNodeCompatExternals() {
-  return env.external;
-}
-function maybeStripNodeJsVirtualPrefix(source) {
-  return source.startsWith(CLOUDFLARE_VIRTUAL_PREFIX) ? source.slice(CLOUDFLARE_VIRTUAL_PREFIX.length) : void 0;
-}
-function resolveNodeJSImport(source) {
-  const alias = env.alias[source];
-  if (alias) {
-    assert6(
-      !env.external.includes(alias),
-      `Unexpected unenv alias to external module: ${source} -> ${alias}`
-    );
-    source = alias;
-  }
-  const resolved = resolvePathSync(source, {
-    url: import.meta.url
+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 {
-    unresolved: source,
-    resolved
+    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;
+  }
+}
 
 // src/plugin-config.ts
 import assert8 from "node:assert";
@@ -8841,7 +8876,6 @@ var nonApplicableWorkerConfigs = {
     "build",
     "find_additional_modules",
     "no_bundle",
-    "node_compat",
     "preserve_file_names",
     "site",
     "tsconfig",
@@ -8858,7 +8892,6 @@ var nullableNonApplicable = [
   "find_additional_modules",
   "minify",
   "no_bundle",
-  "node_compat",
   "preserve_file_names",
   "site",
   "tsconfig",
@@ -9009,6 +9042,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,9 +9153,10 @@ function resolvePluginConfig(pluginConfig, userConfig, viteEnv) {
 }
 
 // src/websockets.ts
-import ws from "ws";
-function handleWebSocket(httpServer, fetcher, logger) {
-  const nodeWebSocket = new ws.Server({ noServer: true });
+import { coupleWebSocket } from "miniflare";
+import { WebSocketServer } from "ws";
+function handleWebSocket(httpServer, fetcher) {
+  const nodeWebSocket = new WebSocketServer({ noServer: true });
   httpServer.on(
     "upgrade",
     async (request, socket, head) => {
@@ -9134,34 +9179,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);
         }
       );
@@ -9220,7 +9238,7 @@ function cloudflare2(pluginConfig = {}) {
             }
           } : void 0,
           builder: {
-            async buildApp(builder) {
+            buildApp: userConfig.builder?.buildApp ?? (async (builder) => {
               const clientEnvironment = builder.environments.client;
               const defaultHtmlPath = path7.resolve(
                 builder.config.root,
@@ -9246,7 +9264,7 @@ function cloudflare2(pluginConfig = {}) {
                   )
                 );
               }
-            }
+            })
           }
         };
       },
@@ -9307,7 +9325,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 +9372,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 +9394,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
@@ -9465,49 +9473,61 @@ function cloudflare2(pluginConfig = {}) {
       apply(_config, env2) {
         return !env2.isPreview;
       },
-      config() {
-        return {
-          resolve: {
-            alias: getNodeCompatAliases()
-          }
-        };
-      },
-      configEnvironment(environmentName) {
-        const workerConfig = getWorkerConfig2(environmentName);
-        if (isNodeCompat(workerConfig)) {
+      configEnvironment(name2) {
+        if (isNodeCompat(getWorkerConfig2(name2))) {
           return {
-            build: {
-              rollupOptions: {
-                external: getNodeCompatExternals()
-              }
+            resolve: {
+              builtins: [...nodeCompatExternals]
+            },
+            optimizeDeps: {
+              // This is a list of dependency entry-points that should be pre-bundled.
+              // In this case we provide a list of all the possible polyfills so that they are pre-bundled,
+              // ready ahead the first request to the dev server.
+              // Without this the dependency optimizer will try to bundle them on-the-fly in the middle of the first request,
+              // which can potentially cause problems if it leads to previous pre-bundling to become stale and needing to be reloaded.
+              // TODO: work out how to re-enable pre-bundling of these
+              // include: [...getNodeCompatEntries()],
+              // This is a list of module specifiers that the dependency optimizer should not follow when doing import analysis.
+              // In this case we provide a list of all the Node.js modules, both those built-in to workerd and those that will be polyfilled.
+              // Obviously we don't want/need the optimizer to try to process modules that are built-in;
+              // But also we want to avoid following the ones that are polyfilled since the dependency-optimizer import analyzer does not
+              // resolve these imports using our `resolveId()` hook causing the optimization step to fail.
+              exclude: [
+                ...builtinModules2,
+                ...builtinModules2.map((m) => `node:${m}`)
+              ]
             }
           };
         }
       },
+      applyToEnvironment(environment) {
+        return isNodeCompat(getWorkerConfig2(environment.name));
+      },
+      // We need the resolver from this plugin to run before built-in ones, otherwise Vite's built-in
+      // resolver will try to externalize the Node.js module imports (e.g. `perf_hooks` and `node:tty`)
+      // rather than allowing the resolve hook here to alias then to polyfills.
+      enforce: "pre",
       async resolveId(source, importer, options) {
-        const strippedSource = maybeStripNodeJsVirtualPrefix(source);
-        if (!strippedSource) {
-          return;
-        }
-        const workerConfig = getWorkerConfig2(this.environment.name);
-        if (!isNodeCompat(workerConfig)) {
-          return this.resolve(strippedSource, importer, options);
+        const result = resolveNodeJSImport(source);
+        if (!result) {
+          return this.resolve(source, importer, options);
         }
-        const { unresolved, resolved } = resolveNodeJSImport(strippedSource);
-        if (this.environment.mode === "dev" && this.environment.depsOptimizer) {
-          const optimized = this.environment.depsOptimizer.registerMissingImport(
-            unresolved,
-            resolved
-          ).id;
-          return this.resolve(optimized, importer, options);
+        if (this.environment.mode === "dev") {
+          assert9(
+            this.environment.depsOptimizer,
+            "depsOptimizer is required in dev mode"
+          );
+          const { id } = this.environment.depsOptimizer.registerMissingImport(
+            result.unresolved,
+            result.resolved
+          );
+          return this.resolve(id, importer, options);
         }
-        return this.resolve(resolved, importer, options);
+        return this.resolve(result.resolved, importer, options);
       },
       async transform(code, id) {
         const workerConfig = getWorkerConfig2(this.environment.name);
-        if (!isNodeCompat(workerConfig)) {
-          return;
-        }
+        assert9(workerConfig, "Expected a worker config");
         const resolvedId = await this.resolve(workerConfig.main);
         if (id === resolvedId?.id) {
           return injectGlobalCode(id, code);