@cloudflare/vite-plugin 0.0.0-0f3ace7fc → 0.0.0-0fe326071

package/dist/index.js

@@ -1074,705 +1074,11 @@ import { Miniflare } from "miniflare";
 import * as vite6 from "vite";
 
 // src/cloudflare-environment.ts
-import assert from "node:assert";
-import * as vite2 from "vite";
-
-// src/constants.ts
-var ROUTER_WORKER_NAME = "__router-worker__";
-var ASSET_WORKER_NAME = "__asset-worker__";
-var ASSET_WORKERS_COMPATIBILITY_DATE = "2024-10-04";
-var MODULE_TYPES = ["CompiledWasm"];
-
-// src/shared.ts
-var UNKNOWN_HOST = "http://localhost";
-var INIT_PATH = "/__vite_plugin_cloudflare_init__";
-var MODULE_PATTERN = `__CLOUDFLARE_MODULE__(${MODULE_TYPES.join("|")})__(.*?)__`;
-
-// src/utils.ts
-import * as path from "node:path";
-import { Request as MiniflareRequest } from "miniflare";
-import "vite";
-function getOutputDirectory(userConfig, environmentName) {
-  const rootOutputDirectory = userConfig.build?.outDir ?? "dist";
-  return userConfig.environments?.[environmentName]?.build?.outDir ?? path.join(rootOutputDirectory, environmentName);
-}
-function toMiniflareRequest(request) {
-  return new MiniflareRequest(request.url, {
-    method: request.method,
-    headers: [["accept-encoding", "identity"], ...request.headers],
-    body: request.body,
-    duplex: "half"
-  });
-}
-function nodeHeadersToWebHeaders(nodeHeaders) {
-  const headers = new Headers();
-  for (const [key, value] of Object.entries(nodeHeaders)) {
-    if (typeof value === "string") {
-      headers.append(key, value);
-    } else if (Array.isArray(value)) {
-      for (const item of value) {
-        headers.append(key, item);
-      }
-    }
-  }
-  return headers;
-}
-
-// src/cloudflare-environment.ts
-var webSocketUndefinedError = "The WebSocket is undefined";
-function createHotChannel(webSocketContainer) {
-  const listenersMap = /* @__PURE__ */ new Map();
-  const client = {
-    send(payload) {
-      const webSocket = webSocketContainer.webSocket;
-      assert(webSocket, webSocketUndefinedError);
-      webSocket.send(JSON.stringify(payload));
-    }
-  };
-  function onMessage(event) {
-    const payload = JSON.parse(event.data.toString());
-    const listeners = listenersMap.get(payload.event) ?? /* @__PURE__ */ new Set();
-    for (const listener of listeners) {
-      listener(payload.data, client);
-    }
-  }
-  return {
-    send(payload) {
-      const webSocket = webSocketContainer.webSocket;
-      assert(webSocket, webSocketUndefinedError);
-      webSocket.send(JSON.stringify(payload));
-    },
-    on(event, listener) {
-      const listeners = listenersMap.get(event) ?? /* @__PURE__ */ new Set();
-      listeners.add(listener);
-      listenersMap.set(event, listeners);
-    },
-    off(event, listener) {
-      listenersMap.get(event)?.delete(listener);
-    },
-    listen() {
-      const webSocket = webSocketContainer.webSocket;
-      assert(webSocket, webSocketUndefinedError);
-      webSocket.addEventListener("message", onMessage);
-    },
-    close() {
-      const webSocket = webSocketContainer.webSocket;
-      assert(webSocket, webSocketUndefinedError);
-      webSocket.removeEventListener("message", onMessage);
-    }
-  };
-}
-var CloudflareDevEnvironment = class extends vite2.DevEnvironment {
-  #webSocketContainer;
-  #worker;
-  constructor(name2, config) {
-    const webSocketContainer = {};
-    super(name2, config, {
-      hot: true,
-      transport: createHotChannel(webSocketContainer)
-    });
-    this.#webSocketContainer = webSocketContainer;
-  }
-  async initRunner(worker) {
-    this.#worker = worker;
-    const response = await this.#worker.fetch(
-      new URL(INIT_PATH, UNKNOWN_HOST),
-      {
-        headers: {
-          upgrade: "websocket"
-        }
-      }
-    );
-    assert(
-      response.ok,
-      `Failed to initialize module runner, error: ${await response.text()}`
-    );
-    const webSocket = response.webSocket;
-    assert(webSocket, "Failed to establish WebSocket");
-    webSocket.accept();
-    this.#webSocketContainer.webSocket = webSocket;
-  }
-};
-var cloudflareBuiltInModules = [
-  "cloudflare:email",
-  "cloudflare:sockets",
-  "cloudflare:workers",
-  "cloudflare:workflows"
-];
-var defaultConditions = ["workerd", "module", "browser"];
-function createCloudflareEnvironmentOptions(workerConfig, userConfig, environmentName) {
-  return {
-    resolve: {
-      // Note: in order for ssr pre-bundling to take effect we need to ask vite to treat all
-      //       dependencies as not external
-      noExternal: true,
-      // We want to use `workerd` package exports if available (e.g. for postgres).
-      conditions: [...defaultConditions, "development|production"],
-      // The Cloudflare ones are proper builtins in the environment
-      builtins: [...cloudflareBuiltInModules]
-    },
-    dev: {
-      createEnvironment(name2, config) {
-        return new CloudflareDevEnvironment(name2, config);
-      }
-    },
-    build: {
-      createEnvironment(name2, config) {
-        return new vite2.BuildEnvironment(name2, config);
-      },
-      target: "es2022",
-      // We need to enable `emitAssets` in order to support additional modules defined by `rules`
-      emitAssets: true,
-      outDir: getOutputDirectory(userConfig, environmentName),
-      copyPublicDir: false,
-      ssr: true,
-      rollupOptions: {
-        // Note: vite starts dev pre-bundling crawling from either optimizeDeps.entries or rollupOptions.input
-        //       so the input value here serves both as the build input as well as the starting point for
-        //       dev pre-bundling crawling (were we not to set this input field we'd have to appropriately set
-        //       optimizeDeps.entries in the dev config)
-        input: workerConfig.main
-      }
-    },
-    optimizeDeps: {
-      // Note: ssr pre-bundling is opt-in and we need to enable it by setting `noDiscovery` to false
-      noDiscovery: false,
-      entries: workerConfig.main,
-      exclude: [...cloudflareBuiltInModules],
-      esbuildOptions: {
-        platform: "neutral",
-        conditions: [...defaultConditions, "development"],
-        resolveExtensions: [
-          ".mjs",
-          ".js",
-          ".mts",
-          ".ts",
-          ".jsx",
-          ".tsx",
-          ".json",
-          ".cjs",
-          ".cts",
-          ".ctx"
-        ]
-      }
-    },
-    keepProcessEnv: false
-  };
-}
-function initRunners(resolvedPluginConfig, viteDevServer, miniflare) {
-  if (resolvedPluginConfig.type === "assets-only") {
-    return;
-  }
-  return Promise.all(
-    Object.entries(resolvedPluginConfig.workers).map(
-      async ([environmentName, workerConfig]) => {
-        const worker = await miniflare.getWorker(workerConfig.name);
-        return viteDevServer.environments[environmentName].initRunner(worker);
-      }
-    )
-  );
-}
-
-// src/deploy-config.ts
-import assert2 from "node:assert";
-import * as fs from "node:fs";
-import * as path2 from "node:path";
-import "vite";
-function getDeployConfigPath(root) {
-  return path2.resolve(root, ".wrangler", "deploy", "config.json");
-}
-function getWorkerConfigPaths(root) {
-  const deployConfigPath = getDeployConfigPath(root);
-  const deployConfig = JSON.parse(
-    fs.readFileSync(deployConfigPath, "utf-8")
-  );
-  return [
-    { configPath: deployConfig.configPath },
-    ...deployConfig.auxiliaryWorkers
-  ].map(
-    ({ configPath }) => path2.resolve(path2.dirname(deployConfigPath), configPath)
-  );
-}
-function getRelativePathToWorkerConfig(deployConfigDirectory, root, outputDirectory) {
-  return path2.relative(
-    deployConfigDirectory,
-    path2.resolve(root, outputDirectory, "wrangler.json")
-  );
-}
-function writeDeployConfig(resolvedPluginConfig, resolvedViteConfig) {
-  const deployConfigPath = getDeployConfigPath(resolvedViteConfig.root);
-  const deployConfigDirectory = path2.dirname(deployConfigPath);
-  fs.mkdirSync(deployConfigDirectory, { recursive: true });
-  if (resolvedPluginConfig.type === "assets-only") {
-    const clientOutputDirectory = resolvedViteConfig.environments.client?.build.outDir;
-    assert2(
-      clientOutputDirectory,
-      "Unexpected error: client environment output directory is undefined"
-    );
-    const deployConfig = {
-      configPath: getRelativePathToWorkerConfig(
-        deployConfigDirectory,
-        resolvedViteConfig.root,
-        clientOutputDirectory
-      ),
-      auxiliaryWorkers: []
-    };
-    fs.writeFileSync(deployConfigPath, JSON.stringify(deployConfig));
-  } else {
-    let entryWorkerConfigPath;
-    const auxiliaryWorkers = [];
-    for (const environmentName of Object.keys(resolvedPluginConfig.workers)) {
-      const outputDirectory = resolvedViteConfig.environments[environmentName]?.build.outDir;
-      assert2(
-        outputDirectory,
-        `Unexpected error: ${environmentName} environment output directory is undefined`
-      );
-      const configPath = getRelativePathToWorkerConfig(
-        deployConfigDirectory,
-        resolvedViteConfig.root,
-        outputDirectory
-      );
-      if (environmentName === resolvedPluginConfig.entryWorkerEnvironmentName) {
-        entryWorkerConfigPath = configPath;
-      } else {
-        auxiliaryWorkers.push({ configPath });
-      }
-    }
-    assert2(
-      entryWorkerConfigPath,
-      `Unexpected error: entryWorkerConfigPath is undefined`
-    );
-    const deployConfig = {
-      configPath: entryWorkerConfigPath,
-      auxiliaryWorkers
-    };
-    fs.writeFileSync(deployConfigPath, JSON.stringify(deployConfig));
-  }
-}
-
-// src/dev.ts
-import assert3 from "node:assert";
-function getDevEntryWorker(resolvedPluginConfig, miniflare) {
-  const entryWorkerConfig = resolvedPluginConfig.type === "assets-only" ? resolvedPluginConfig.config : resolvedPluginConfig.workers[resolvedPluginConfig.entryWorkerEnvironmentName];
-  assert3(entryWorkerConfig, "Unexpected error: No entry worker configuration");
-  return entryWorkerConfig.assets ? miniflare.getWorker(ROUTER_WORKER_NAME) : miniflare.getWorker(entryWorkerConfig.name);
-}
-
-// src/miniflare-options.ts
-import assert4 from "node:assert";
-import * as fs2 from "node:fs";
-import * as fsp from "node:fs/promises";
-import * as path3 from "node:path";
-import { fileURLToPath } from "node:url";
-import { 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)
-            );
-            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";
 
@@ -7305,7 +6611,7 @@ Parser.acorn = {
 
 // ../../node_modules/.pnpm/mlly@1.7.4/node_modules/mlly/dist/index.mjs
 import { builtinModules, createRequire } from "node:module";
-import fs3, { realpathSync, statSync as statSync2, promises } from "node:fs";
+import fs, { realpathSync, statSync, promises } from "node:fs";
 
 // ../../node_modules/.pnpm/ufo@1.5.4/node_modules/ufo/dist/index.mjs
 var r = String.fromCharCode;
@@ -7362,9 +6668,9 @@ var isAbsolute = function(p) {
 
 // ../../node_modules/.pnpm/mlly@1.7.4/node_modules/mlly/dist/index.mjs
 import { fileURLToPath as fileURLToPath$1, URL as URL$1, pathToFileURL as pathToFileURL$1 } from "node:url";
-import assert5 from "node:assert";
+import assert from "node:assert";
 import process$1 from "node:process";
-import path4, { dirname as dirname3 } from "node:path";
+import path, { dirname as dirname2 } from "node:path";
 import v8 from "node:v8";
 import { format as format2, inspect } from "node:util";
 var BUILTIN_MODULES = new Set(builtinModules);
@@ -7400,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];
     }
@@ -7416,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"'
         );
@@ -7496,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
@@ -7632,1163 +6938,1895 @@ function isErrorStackTraceLimitWritable() {
     if (v8.startupSnapshot.isBuildingSnapshot()) {
       return false;
     }
-  } catch {
+  } catch {
+  }
+  const desc = Object.getOwnPropertyDescriptor(Error, "stackTraceLimit");
+  if (desc === void 0) {
+    return Object.isExtensible(Error);
+  }
+  return own$1.call(desc, "writable") && desc.writable !== void 0 ? desc.writable : desc.set !== void 0;
+}
+function hideStackFrames(wrappedFunction) {
+  const hidden = nodeInternalPrefix + wrappedFunction.name;
+  Object.defineProperty(wrappedFunction, "name", { value: hidden });
+  return wrappedFunction;
+}
+var captureLargerStackTrace = hideStackFrames(
+  /**
+   * @param {Error} error
+   * @returns {Error}
+   */
+  // @ts-expect-error: fine
+  function(error) {
+    const stackTraceLimitIsWritable = isErrorStackTraceLimitWritable();
+    if (stackTraceLimitIsWritable) {
+      userStackTraceLimit = Error.stackTraceLimit;
+      Error.stackTraceLimit = Number.POSITIVE_INFINITY;
+    }
+    Error.captureStackTrace(error);
+    if (stackTraceLimitIsWritable) Error.stackTraceLimit = userStackTraceLimit;
+    return error;
+  }
+);
+function getMessage(key, parameters, self) {
+  const message = messages.get(key);
+  assert(message !== void 0, "expected `message` to be found");
+  if (typeof message === "function") {
+    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}).`
+    );
+    return Reflect.apply(message, self, parameters);
+  }
+  const regex = /%[dfijoOs]/g;
+  let expectedLength = 0;
+  while (regex.exec(message) !== null) expectedLength++;
+  assert(
+    expectedLength === parameters.length,
+    `Code: ${key}; The provided arguments length (${parameters.length}) does not match the required ones (${expectedLength}).`
+  );
+  if (parameters.length === 0) return message;
+  parameters.unshift(message);
+  return Reflect.apply(format2, null, parameters);
+}
+function determineSpecificType(value) {
+  if (value === null || value === void 0) {
+    return String(value);
+  }
+  if (typeof value === "function" && value.name) {
+    return `function ${value.name}`;
+  }
+  if (typeof value === "object") {
+    if (value.constructor && value.constructor.name) {
+      return `an instance of ${value.constructor.name}`;
+    }
+    return `${inspect(value, { depth: -1 })}`;
+  }
+  let inspected = inspect(value, { colors: false });
+  if (inspected.length > 28) {
+    inspected = `${inspected.slice(0, 25)}...`;
+  }
+  return `type ${typeof value} (${inspected})`;
+}
+var hasOwnProperty$1 = {}.hasOwnProperty;
+var { ERR_INVALID_PACKAGE_CONFIG: ERR_INVALID_PACKAGE_CONFIG$1 } = codes;
+var cache = /* @__PURE__ */ new Map();
+function read(jsonPath, { base, specifier }) {
+  const existing = cache.get(jsonPath);
+  if (existing) {
+    return existing;
+  }
+  let string;
+  try {
+    string = fs.readFileSync(path.toNamespacedPath(jsonPath), "utf8");
+  } catch (error) {
+    const exception = (
+      /** @type {ErrnoException} */
+      error
+    );
+    if (exception.code !== "ENOENT") {
+      throw exception;
+    }
+  }
+  const result = {
+    exists: false,
+    pjsonPath: jsonPath,
+    main: void 0,
+    name: void 0,
+    type: "none",
+    // Ignore unknown types for forwards compatibility
+    exports: void 0,
+    imports: void 0
+  };
+  if (string !== void 0) {
+    let parsed;
+    try {
+      parsed = JSON.parse(string);
+    } catch (error_) {
+      const cause = (
+        /** @type {ErrnoException} */
+        error_
+      );
+      const error = new ERR_INVALID_PACKAGE_CONFIG$1(
+        jsonPath,
+        (base ? `"${specifier}" from ` : "") + fileURLToPath$1(base || specifier),
+        cause.message
+      );
+      error.cause = cause;
+      throw error;
+    }
+    result.exists = true;
+    if (hasOwnProperty$1.call(parsed, "name") && typeof parsed.name === "string") {
+      result.name = parsed.name;
+    }
+    if (hasOwnProperty$1.call(parsed, "main") && typeof parsed.main === "string") {
+      result.main = parsed.main;
+    }
+    if (hasOwnProperty$1.call(parsed, "exports")) {
+      result.exports = parsed.exports;
+    }
+    if (hasOwnProperty$1.call(parsed, "imports")) {
+      result.imports = parsed.imports;
+    }
+    if (hasOwnProperty$1.call(parsed, "type") && (parsed.type === "commonjs" || parsed.type === "module")) {
+      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;
+    }
+  }
+  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 desc = Object.getOwnPropertyDescriptor(Error, "stackTraceLimit");
-  if (desc === void 0) {
-    return Object.isExtensible(Error);
+  const format3 = extensionFormatMap[value];
+  if (format3) return format3;
+  if (ignoreErrors) {
+    return void 0;
   }
-  return own$1.call(desc, "writable") && desc.writable !== void 0 ? desc.writable : desc.set !== void 0;
+  const filepath = fileURLToPath$1(url);
+  throw new ERR_UNKNOWN_FILE_EXTENSION(value, filepath);
 }
-function hideStackFrames(wrappedFunction) {
-  const hidden = nodeInternalPrefix + wrappedFunction.name;
-  Object.defineProperty(wrappedFunction, "name", { value: hidden });
-  return wrappedFunction;
+function getHttpProtocolModuleFormat() {
 }
-var captureLargerStackTrace = hideStackFrames(
-  /**
-   * @param {Error} error
-   * @returns {Error}
-   */
-  // @ts-expect-error: fine
-  function(error) {
-    const stackTraceLimitIsWritable = isErrorStackTraceLimitWritable();
-    if (stackTraceLimitIsWritable) {
-      userStackTraceLimit = Error.stackTraceLimit;
-      Error.stackTraceLimit = Number.POSITIVE_INFINITY;
-    }
-    Error.captureStackTrace(error);
-    if (stackTraceLimitIsWritable) Error.stackTraceLimit = userStackTraceLimit;
-    return error;
+function defaultGetFormatWithoutErrors(url, context) {
+  const protocol = url.protocol;
+  if (!hasOwnProperty2.call(protocolHandlers, protocol)) {
+    return null;
   }
-);
-function getMessage(key, parameters, self) {
-  const message = messages.get(key);
-  assert5(message !== void 0, "expected `message` to be found");
-  if (typeof message === "function") {
-    assert5(
-      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}).`
-    );
-    return Reflect.apply(message, self, parameters);
+  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 regex = /%[dfijoOs]/g;
-  let expectedLength = 0;
-  while (regex.exec(message) !== null) expectedLength++;
-  assert5(
-    expectedLength === parameters.length,
-    `Code: ${key}; The provided arguments length (${parameters.length}) does not match the required ones (${expectedLength}).`
+  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"
   );
-  if (parameters.length === 0) return message;
-  parameters.unshift(message);
-  return Reflect.apply(format2, null, parameters);
 }
-function determineSpecificType(value) {
-  if (value === null || value === void 0) {
-    return String(value);
+function emitLegacyIndexDeprecation(url, packageJsonUrl, base, main) {
+  if (process$1.noDeprecation) {
+    return;
   }
-  if (typeof value === "function" && value.name) {
-    return `function ${value.name}`;
+  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"
+    );
   }
-  if (typeof value === "object") {
-    if (value.constructor && value.constructor.name) {
-      return `an instance of ${value.constructor.name}`;
+}
+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;
     }
-    return `${inspect(value, { depth: -1 })}`;
   }
-  let inspected = inspect(value, { colors: false });
-  if (inspected.length > 28) {
-    inspected = `${inspected.slice(0, 25)}...`;
+  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;
   }
-  return `type ${typeof value} (${inspected})`;
+  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)
+  );
 }
-var hasOwnProperty$1 = {}.hasOwnProperty;
-var { ERR_INVALID_PACKAGE_CONFIG: ERR_INVALID_PACKAGE_CONFIG$1 } = codes;
-var cache = /* @__PURE__ */ new Map();
-function read(jsonPath, { base, specifier }) {
-  const existing = cache.get(jsonPath);
-  if (existing) {
-    return existing;
+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 string;
+  let filePath;
   try {
-    string = fs3.readFileSync(path4.toNamespacedPath(jsonPath), "utf8");
+    filePath = fileURLToPath$1(resolved);
   } catch (error) {
-    const exception = (
+    const cause = (
       /** @type {ErrnoException} */
       error
     );
-    if (exception.code !== "ENOENT") {
-      throw exception;
-    }
+    Object.defineProperty(cause, "input", { value: String(resolved) });
+    Object.defineProperty(cause, "module", { value: String(base) });
+    throw cause;
   }
-  const result = {
-    exists: false,
-    pjsonPath: jsonPath,
-    main: void 0,
-    name: void 0,
-    type: "none",
-    // Ignore unknown types for forwards compatibility
-    exports: void 0,
-    imports: void 0
-  };
-  if (string !== void 0) {
-    let parsed;
-    try {
-      parsed = JSON.parse(string);
-    } catch (error_) {
-      const cause = (
-        /** @type {ErrnoException} */
-        error_
-      );
-      const error = new ERR_INVALID_PACKAGE_CONFIG$1(
-        jsonPath,
-        (base ? `"${specifier}" from ` : "") + fileURLToPath$1(base || specifier),
-        cause.message
-      );
-      error.cause = cause;
-      throw error;
-    }
-    result.exists = true;
-    if (hasOwnProperty$1.call(parsed, "name") && typeof parsed.name === "string") {
-      result.name = parsed.name;
-    }
-    if (hasOwnProperty$1.call(parsed, "main") && typeof parsed.main === "string") {
-      result.main = parsed.main;
-    }
-    if (hasOwnProperty$1.call(parsed, "exports")) {
-      result.exports = parsed.exports;
-    }
-    if (hasOwnProperty$1.call(parsed, "imports")) {
-      result.imports = parsed.imports;
-    }
-    if (hasOwnProperty$1.call(parsed, "type") && (parsed.type === "commonjs" || parsed.type === "module")) {
-      result.type = parsed.type;
-    }
+  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;
   }
-  cache.set(jsonPath, result);
-  return result;
+  {
+    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 getPackageScopeConfig(resolved) {
-  let packageJSONUrl = new URL("package.json", resolved);
-  while (true) {
-    const packageJSONPath2 = packageJSONUrl.pathname;
-    if (packageJSONPath2.endsWith("node_modules/package.json")) {
-      break;
+function importNotDefined(specifier, packageJsonUrl, base) {
+  return new ERR_PACKAGE_IMPORT_NOT_DEFINED(
+    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)
+  );
+}
+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);
+      }
     }
-    const packageConfig = read(fileURLToPath$1(packageJSONUrl), {
-      specifier: resolved
-    });
-    if (packageConfig.exists) {
-      return packageConfig;
+    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);
     }
-    const lastPackageJSONUrl = packageJSONUrl;
-    packageJSONUrl = new URL("../package.json", packageJSONUrl);
-    if (packageJSONUrl.pathname === lastPackageJSONUrl.pathname) {
-      break;
+  }
+  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);
     }
   }
-  const packageJSONPath = fileURLToPath$1(packageJSONUrl);
-  return {
-    pjsonPath: packageJSONPath,
-    exists: false,
-    type: "none"
-  };
-}
-function getPackageType(url) {
-  return getPackageScopeConfig(url).type;
+  if (pattern) {
+    return new URL$1(
+      RegExpPrototypeSymbolReplace.call(
+        patternRegEx,
+        resolved.href,
+        () => subpath
+      )
+    );
+  }
+  return new URL$1(subpath, resolved);
 }
-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 isArrayIndex(key) {
+  const keyNumber = Number(key);
+  if (`${keyNumber}` !== key) return false;
+  return keyNumber >= 0 && keyNumber < 4294967295;
 }
-var protocolHandlers = {
-  // @ts-expect-error: hush.
-  __proto__: null,
-  "data:": getDataProtocolModuleFormat,
-  "file:": getFileProtocolModuleFormat,
-  "http:": getHttpProtocolModuleFormat,
-  "https:": getHttpProtocolModuleFormat,
-  "node:"() {
-    return "builtin";
+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
+    );
   }
-};
-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 (Array.isArray(target2)) {
+    const targetList = target2;
+    if (targetList.length === 0) return null;
+    let lastException;
+    let i = -1;
+    while (++i < targetList.length) {
+      const targetItem = targetList[i];
+      let resolveResult;
+      try {
+        resolveResult = resolvePackageTarget(
+          packageJsonUrl,
+          targetItem,
+          subpath,
+          packageSubpath,
+          base,
+          pattern,
+          internal,
+          isPathMap,
+          conditions
+        );
+      } catch (error) {
+        const exception = (
+          /** @type {ErrnoException} */
+          error
+        );
+        lastException = exception;
+        if (exception.code === "ERR_INVALID_PACKAGE_TARGET") continue;
+        throw error;
+      }
+      if (resolveResult === void 0) continue;
+      if (resolveResult === null) {
+        lastException = null;
+        continue;
+      }
+      return resolveResult;
     }
-    if (code === 46) {
-      return pathname.codePointAt(index - 1) === 47 ? "" : pathname.slice(index);
+    if (lastException === void 0 || lastException === null) {
+      return null;
     }
+    throw lastException;
   }
-  return "";
-}
-function getFileProtocolModuleFormat(url, _context, ignoreErrors) {
-  const value = extname2(url);
-  if (value === ".js") {
-    const packageType = getPackageType(url);
-    if (packageType !== "none") {
-      return packageType;
+  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 "commonjs";
-  }
-  if (value === "") {
-    const packageType = getPackageType(url);
-    if (packageType === "none" || packageType === "commonjs") {
-      return "commonjs";
+    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 "module";
+    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"
-    );
-  } 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 (own.call(exports, packageSubpath) && !packageSubpath.includes("*") && !packageSubpath.endsWith("/")) {
+    const target2 = exports[packageSubpath];
+    const resolveResult = resolvePackageTarget(
+      packageJsonUrl,
+      target2,
+      "",
+      packageSubpath,
+      base,
+      false,
+      false,
+      false,
+      conditions
     );
+    if (resolveResult === null || resolveResult === void 0) {
+      throw exportsNotFound(packageSubpath, packageJsonUrl, base);
+    }
+    return resolveResult;
   }
-}
-function tryStatSync(path8) {
-  try {
-    return statSync2(path8);
-  } catch {
+  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 fileExists(url) {
-  const stats = statSync2(url, { throwIfNoEntry: false });
-  const isFile = stats ? stats.isFile() : void 0;
-  return isFile === null || isFile === void 0 ? false : isFile;
+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 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 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;
+          }
+        }
+      }
     }
   }
-  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;
+  throw importNotDefined(name2, packageJsonUrl, base);
+}
+function parsePackageName(specifier, base) {
+  let separatorIndex = specifier.indexOf("/");
+  let validPackageName = true;
+  let isScoped = false;
+  if (specifier[0] === "@") {
+    isScoped = true;
+    if (separatorIndex === -1 || specifier.length === 0) {
+      validPackageName = false;
+    } else {
+      separatorIndex = specifier.indexOf("/", separatorIndex + 1);
+    }
   }
-  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)
+    base
   );
-}
-function exportsNotFound(subpath, packageJsonUrl, base) {
-  return new ERR_PACKAGE_PATH_NOT_EXPORTED(
-    fileURLToPath$1(new URL$1(".", packageJsonUrl)),
-    subpath,
-    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 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 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;
 }
-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)
-  );
+function shouldBeTreatedAsRelativeOrAbsolutePath(specifier) {
+  if (specifier === "") return false;
+  if (specifier[0] === "/") return true;
+  return isRelativeSpecifier(specifier);
 }
-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 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);
+  } else {
+    try {
+      resolved = new URL$1(specifier);
+    } catch (error_) {
+      if (isRemote && !builtinModules.includes(specifier)) {
+        const error = new ERR_UNSUPPORTED_RESOLVE_REQUEST(specifier, base);
+        error.cause = error_;
+        throw error;
       }
+      resolved = packageResolve(specifier, base, conditions);
     }
-    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);
+  assert(resolved !== void 0, "expected to be defined");
+  if (resolved.protocol !== "file:") {
+    return resolved;
+  }
+  return finalizeResolution(resolved, base);
+}
+function fileURLToPath(id) {
+  if (typeof id === "string" && !id.startsWith("file://")) {
+    return normalizeSlash(id);
+  }
+  return normalizeSlash(fileURLToPath$1(id));
+}
+function pathToFileURL(id) {
+  return pathToFileURL$1(fileURLToPath(id)).toString();
+}
+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;
+  }
+  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;
     }
   }
-  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
-        );
-      }
+}
+function _resolve(id, options = {}) {
+  if (typeof id !== "string") {
+    if (id instanceof URL) {
+      id = fileURLToPath(id);
     } else {
-      throwInvalidSubpath(request, match, packageJsonUrl, internal, base);
+      throw new TypeError("input must be a `string` or `URL`");
     }
   }
-  if (pattern) {
-    return new URL$1(
-      RegExpPrototypeSymbolReplace.call(
-        patternRegEx,
-        resolved.href,
-        () => subpath
-      )
-    );
+  if (/(node|data|http|https):/.test(id)) {
+    return id;
   }
-  return new URL$1(subpath, resolved);
-}
-function isArrayIndex(key) {
-  const keyNumber = Number(key);
-  if (`${keyNumber}` !== key) return false;
-  return keyNumber >= 0 && keyNumber < 4294967295;
-}
-function resolvePackageTarget(packageJsonUrl, target, subpath, packageSubpath, base, pattern, internal, isPathMap, conditions) {
-  if (typeof target === "string") {
-    return resolvePackageTargetString(
-      target,
-      subpath,
-      packageSubpath,
-      packageJsonUrl,
-      base,
-      pattern,
-      internal,
-      isPathMap,
-      conditions
-    );
+  if (BUILTIN_MODULES.has(id)) {
+    return "node:" + id;
   }
-  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 (id.startsWith("file://")) {
+    id = fileURLToPath(id);
+  }
+  if (isAbsolute(id)) {
+    try {
+      const stat = statSync(id);
+      if (stat.isFile()) {
+        return pathToFileURL(id);
       }
-      if (resolveResult === void 0) continue;
-      if (resolveResult === null) {
-        lastException = null;
-        continue;
+    } catch (error) {
+      if (error?.code !== "ENOENT") {
+        throw error;
       }
-      return resolveResult;
     }
-    if (lastException === void 0 || lastException === 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())));
+  }
+  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)
+      );
     }
-    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.'
-        );
-      }
+  let resolved;
+  for (const url of urls) {
+    resolved = _tryModuleResolve(id, url, conditionsSet);
+    if (resolved) {
+      break;
     }
-    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
+    for (const prefix of ["", "/index"]) {
+      for (const extension of options.extensions || DEFAULT_EXTENSIONS) {
+        resolved = _tryModuleResolve(
+          joinURL(id, prefix) + extension,
+          url,
+          conditionsSet
         );
-        if (resolveResult === void 0) continue;
-        return resolveResult;
+        if (resolved) {
+          break;
+        }
+      }
+      if (resolved) {
+        break;
       }
     }
-    return null;
+    if (resolved) {
+      break;
+    }
   }
-  if (target === null) {
-    return null;
+  if (!resolved) {
+    const error = new Error(
+      `Cannot find module ${id} imported from ${urls.join(", ")}`
+    );
+    error.code = "ERR_MODULE_NOT_FOUND";
+    throw error;
   }
-  throw invalidPackageTarget(
-    packageSubpath,
-    target,
-    packageJsonUrl,
-    internal,
-    base
-  );
+  return pathToFileURL(resolved);
 }
-function isConditionalExportsMainSugar(exports, packageJsonUrl, base) {
-  if (typeof exports === "string" || Array.isArray(exports)) return true;
-  if (typeof exports !== "object" || exports === null) return false;
-  const keys = Object.getOwnPropertyNames(exports);
-  let isConditionalSugar = false;
-  let i = 0;
-  let keyIndex = -1;
-  while (++keyIndex < keys.length) {
-    const key = keys[keyIndex];
-    const currentIsConditionalSugar = key === "" || key[0] !== ".";
-    if (i++ === 0) {
-      isConditionalSugar = currentIsConditionalSugar;
-    } else if (isConditionalSugar !== currentIsConditionalSugar) {
-      throw new ERR_INVALID_PACKAGE_CONFIG(
-        fileURLToPath$1(packageJsonUrl),
-        base,
-        `"exports" cannot contain some keys starting with '.' and some not. The exports object must either be an object of package subpath keys or an object of main entry condition name keys only.`
-      );
-    }
-  }
-  return isConditionalSugar;
+function resolveSync(id, options) {
+  return _resolve(id, options);
 }
-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 resolvePathSync(id, options) {
+  return fileURLToPath(resolveSync(id, options));
 }
-function packageExportsResolve(packageJsonUrl, packageSubpath, packageConfig, base, conditions) {
-  let exports = packageConfig.exports;
-  if (isConditionalExportsMainSugar(exports, packageJsonUrl, base)) {
-    exports = { ".": exports };
+
+// 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;
   }
-  if (own.call(exports, packageSubpath) && !packageSubpath.includes("*") && !packageSubpath.endsWith("/")) {
-    const target = exports[packageSubpath];
-    const resolveResult = resolvePackageTarget(
-      packageJsonUrl,
-      target,
-      "",
-      packageSubpath,
-      base,
-      false,
-      false,
-      false,
-      conditions
+  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;
   }
-  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
-        );
-      }
+  return false;
+}
+function injectGlobalCode(id, code) {
+  const injectedCode = Object.entries(env.inject).map(([globalName, globalInject]) => {
+    if (typeof globalInject === "string") {
+      const moduleSpecifier2 = globalInject;
+      return `import var_${globalName} from "${moduleSpecifier2}";
+globalThis.${globalName} = var_${globalName};
+`;
     }
-  }
-  if (bestMatch) {
-    const target = (
-      /** @type {unknown} */
-      exports[bestMatch]
-    );
-    const resolveResult = resolvePackageTarget(
-      packageJsonUrl,
-      target,
-      bestMatchSubpath,
-      bestMatch,
-      base,
-      true,
-      false,
-      packageSubpath.endsWith("/"),
-      conditions
+    const [moduleSpecifier, exportName] = globalInject;
+    assert2(
+      moduleSpecifier !== void 0,
+      "Expected moduleSpecifier to be defined"
     );
-    if (resolveResult === null || resolveResult === void 0) {
-      throw exportsNotFound(packageSubpath, packageJsonUrl, base);
+    assert2(exportName !== void 0, "Expected exportName to be defined");
+    return `import var_${globalName} from "${moduleSpecifier}";
+globalThis.${globalName} = var_${globalName}.${exportName};
+`;
+  }).join("\n");
+  const modified = new MagicString(code);
+  modified.prepend(injectedCode);
+  return {
+    code: modified.toString(),
+    map: modified.generateMap({ hires: "boundary", source: id })
+  };
+}
+function resolveNodeJSImport(source) {
+  const alias = env.alias[source];
+  if (alias) {
+    return {
+      unresolved: alias,
+      resolved: resolvePathSync(alias, { url: import.meta.url })
+    };
+  }
+  if (nodeCompatEntries.has(source)) {
+    return {
+      unresolved: source,
+      resolved: resolvePathSync(source, { url: import.meta.url })
+    };
+  }
+}
+function getNodeCompatEntries() {
+  const entries = new Set(Object.values(env.alias));
+  for (const globalInject of Object.values(env.inject)) {
+    if (typeof globalInject === "string") {
+      entries.add(globalInject);
+    } else {
+      assert2(
+        globalInject[0] !== void 0,
+        "Expected first element of globalInject to be defined"
+      );
+      entries.add(globalInject[0]);
     }
-    return resolveResult;
   }
-  throw exportsNotFound(packageSubpath, packageJsonUrl, base);
+  nodeCompatExternals.forEach((external) => entries.delete(external));
+  return entries;
 }
-function patternKeyCompare(a, b) {
-  const aPatternIndex = a.indexOf("*");
-  const bPatternIndex = b.indexOf("*");
-  const baseLengthA = aPatternIndex === -1 ? a.length : aPatternIndex + 1;
-  const baseLengthB = bPatternIndex === -1 ? b.length : bPatternIndex + 1;
-  if (baseLengthA > baseLengthB) return -1;
-  if (baseLengthB > baseLengthA) return 1;
-  if (aPatternIndex === -1) return 1;
-  if (bPatternIndex === -1) return -1;
-  if (a.length > b.length) return -1;
-  if (b.length > a.length) return 1;
-  return 0;
+
+// src/constants.ts
+var ROUTER_WORKER_NAME = "__router-worker__";
+var ASSET_WORKER_NAME = "__asset-worker__";
+var ASSET_WORKERS_COMPATIBILITY_DATE = "2024-10-04";
+var MODULE_TYPES = ["CompiledWasm"];
+
+// src/shared.ts
+var UNKNOWN_HOST = "http://localhost";
+var INIT_PATH = "/__vite_plugin_cloudflare_init__";
+var MODULE_PATTERN = `__CLOUDFLARE_MODULE__(${MODULE_TYPES.join("|")})__(.*?)__`;
+var VITE_DEV_METADATA_HEADER = "__VITE_DEV_METADATA__";
+
+// src/utils.ts
+import * as path2 from "node:path";
+import { Request as MiniflareRequest } from "miniflare";
+import "vite";
+function getOutputDirectory(userConfig, environmentName) {
+  const rootOutputDirectory = userConfig.build?.outDir ?? "dist";
+  return userConfig.environments?.[environmentName]?.build?.outDir ?? path2.join(rootOutputDirectory, environmentName);
 }
-function packageImportsResolve(name2, base, conditions) {
-  if (name2 === "#" || name2.startsWith("#/") || name2.endsWith("/")) {
-    const reason = "is not a valid internal imports specifier name";
-    throw new ERR_INVALID_MODULE_SPECIFIER(name2, reason, fileURLToPath$1(base));
-  }
-  let packageJsonUrl;
-  const packageConfig = getPackageScopeConfig(base);
-  if (packageConfig.exists) {
-    packageJsonUrl = pathToFileURL$1(packageConfig.pjsonPath);
-    const imports = packageConfig.imports;
-    if (imports) {
-      if (own.call(imports, name2) && !name2.includes("*")) {
-        const resolveResult = resolvePackageTarget(
-          packageJsonUrl,
-          imports[name2],
-          "",
-          name2,
-          base,
-          false,
-          true,
-          false,
-          conditions
-        );
-        if (resolveResult !== null && resolveResult !== void 0) {
-          return resolveResult;
-        }
-      } else {
-        let bestMatch = "";
-        let bestMatchSubpath = "";
-        const keys = Object.getOwnPropertyNames(imports);
-        let i = -1;
-        while (++i < keys.length) {
-          const key = keys[i];
-          const patternIndex = key.indexOf("*");
-          if (patternIndex !== -1 && name2.startsWith(key.slice(0, -1))) {
-            const patternTrailer = key.slice(patternIndex + 1);
-            if (name2.length >= key.length && name2.endsWith(patternTrailer) && patternKeyCompare(bestMatch, key) === 1 && key.lastIndexOf("*") === patternIndex) {
-              bestMatch = key;
-              bestMatchSubpath = name2.slice(
-                patternIndex,
-                name2.length - patternTrailer.length
-              );
-            }
-          }
-        }
-        if (bestMatch) {
-          const target = imports[bestMatch];
-          const resolveResult = resolvePackageTarget(
-            packageJsonUrl,
-            target,
-            bestMatchSubpath,
-            bestMatch,
-            base,
-            true,
-            true,
-            false,
-            conditions
-          );
-          if (resolveResult !== null && resolveResult !== void 0) {
-            return resolveResult;
-          }
-        }
+function toMiniflareRequest(request) {
+  return new MiniflareRequest(request.url, {
+    method: request.method,
+    headers: [["accept-encoding", "identity"], ...request.headers],
+    body: request.body,
+    duplex: "half"
+  });
+}
+function nodeHeadersToWebHeaders(nodeHeaders) {
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(nodeHeaders)) {
+    if (typeof value === "string") {
+      headers.append(key, value);
+    } else if (Array.isArray(value)) {
+      for (const item of value) {
+        headers.append(key, item);
       }
     }
   }
-  throw importNotDefined(name2, packageJsonUrl, base);
+  return headers;
 }
-function parsePackageName(specifier, base) {
-  let separatorIndex = specifier.indexOf("/");
-  let validPackageName = true;
-  let isScoped = false;
-  if (specifier[0] === "@") {
-    isScoped = true;
-    if (separatorIndex === -1 || specifier.length === 0) {
-      validPackageName = false;
-    } else {
-      separatorIndex = specifier.indexOf("/", separatorIndex + 1);
+
+// src/cloudflare-environment.ts
+var webSocketUndefinedError = "The WebSocket is undefined";
+function createHotChannel(webSocketContainer) {
+  const listenersMap = /* @__PURE__ */ new Map();
+  const client = {
+    send(payload) {
+      const webSocket = webSocketContainer.webSocket;
+      assert3(webSocket, webSocketUndefinedError);
+      webSocket.send(JSON.stringify(payload));
+    }
+  };
+  function onMessage(event) {
+    const payload = JSON.parse(event.data.toString());
+    const listeners = listenersMap.get(payload.event) ?? /* @__PURE__ */ new Set();
+    for (const listener of listeners) {
+      listener(payload.data, client);
     }
   }
-  const packageName = separatorIndex === -1 ? specifier : specifier.slice(0, separatorIndex);
-  if (invalidPackageNameRegEx.exec(packageName) !== null) {
-    validPackageName = false;
+  return {
+    send(payload) {
+      const webSocket = webSocketContainer.webSocket;
+      assert3(webSocket, webSocketUndefinedError);
+      webSocket.send(JSON.stringify(payload));
+    },
+    on(event, listener) {
+      const listeners = listenersMap.get(event) ?? /* @__PURE__ */ new Set();
+      listeners.add(listener);
+      listenersMap.set(event, listeners);
+    },
+    off(event, listener) {
+      listenersMap.get(event)?.delete(listener);
+    },
+    listen() {
+      const webSocket = webSocketContainer.webSocket;
+      assert3(webSocket, webSocketUndefinedError);
+      webSocket.addEventListener("message", onMessage);
+    },
+    close() {
+      const webSocket = webSocketContainer.webSocket;
+      assert3(webSocket, webSocketUndefinedError);
+      webSocket.removeEventListener("message", onMessage);
+    }
+  };
+}
+var CloudflareDevEnvironment = class extends vite2.DevEnvironment {
+  #webSocketContainer;
+  #worker;
+  constructor(name2, config) {
+    const webSocketContainer = {};
+    super(name2, config, {
+      hot: true,
+      transport: createHotChannel(webSocketContainer)
+    });
+    this.#webSocketContainer = webSocketContainer;
   }
-  if (!validPackageName) {
-    throw new ERR_INVALID_MODULE_SPECIFIER(
-      specifier,
-      "is not a valid package name",
-      fileURLToPath$1(base)
+  async initRunner(worker, root, workerConfig) {
+    this.#worker = worker;
+    const response = await this.#worker.fetch(
+      new URL(INIT_PATH, UNKNOWN_HOST),
+      {
+        headers: {
+          [VITE_DEV_METADATA_HEADER]: JSON.stringify({
+            root,
+            entryPath: workerConfig.main
+          }),
+          upgrade: "websocket"
+        }
+      }
+    );
+    assert3(
+      response.ok,
+      `Failed to initialize module runner, error: ${await response.text()}`
     );
+    const webSocket = response.webSocket;
+    assert3(webSocket, "Failed to establish WebSocket");
+    webSocket.accept();
+    this.#webSocketContainer.webSocket = webSocket;
   }
-  const packageSubpath = "." + (separatorIndex === -1 ? "" : specifier.slice(separatorIndex));
-  return { packageName, packageSubpath, isScoped };
+};
+var cloudflareBuiltInModules = [
+  "cloudflare:email",
+  "cloudflare:sockets",
+  "cloudflare:workers",
+  "cloudflare:workflows"
+];
+var defaultConditions = ["workerd", "module", "browser"];
+var target = "es2022";
+function createCloudflareEnvironmentOptions(workerConfig, userConfig, environmentName) {
+  return {
+    resolve: {
+      // Note: in order for ssr pre-bundling to take effect we need to ask vite to treat all
+      //       dependencies as not external
+      noExternal: true,
+      // We want to use `workerd` package exports if available (e.g. for postgres).
+      conditions: [...defaultConditions, "development|production"],
+      // The Cloudflare ones are proper builtins in the environment
+      builtins: [...cloudflareBuiltInModules]
+    },
+    dev: {
+      createEnvironment(name2, config) {
+        return new CloudflareDevEnvironment(name2, config);
+      }
+    },
+    build: {
+      createEnvironment(name2, config) {
+        return new vite2.BuildEnvironment(name2, config);
+      },
+      target,
+      // We need to enable `emitAssets` in order to support additional modules defined by `rules`
+      emitAssets: true,
+      outDir: getOutputDirectory(userConfig, environmentName),
+      copyPublicDir: false,
+      ssr: true,
+      rollupOptions: {
+        // Note: vite starts dev pre-bundling crawling from either optimizeDeps.entries or rollupOptions.input
+        //       so the input value here serves both as the build input as well as the starting point for
+        //       dev pre-bundling crawling (were we not to set this input field we'd have to appropriately set
+        //       optimizeDeps.entries in the dev config)
+        input: workerConfig.main
+      }
+    },
+    optimizeDeps: {
+      // Note: ssr pre-bundling is opt-in and we need to enable it by setting `noDiscovery` to false
+      noDiscovery: false,
+      entries: workerConfig.main,
+      exclude: [...cloudflareBuiltInModules],
+      esbuildOptions: {
+        platform: "neutral",
+        target,
+        conditions: [...defaultConditions, "development"],
+        resolveExtensions: [
+          ".mjs",
+          ".js",
+          ".mts",
+          ".ts",
+          ".jsx",
+          ".tsx",
+          ".json",
+          ".cjs",
+          ".cts",
+          ".ctx"
+        ]
+      }
+    },
+    // if nodeCompat is enabled then let's keep the real process.env so that workerd can manipulate it
+    keepProcessEnv: isNodeCompat(workerConfig)
+  };
 }
-function packageResolve(specifier, base, conditions) {
-  if (builtinModules.includes(specifier)) {
-    return new URL$1("node:" + specifier);
-  }
-  const { packageName, packageSubpath, isScoped } = parsePackageName(
-    specifier,
-    base
-  );
-  const packageConfig = getPackageScopeConfig(base);
-  if (packageConfig.exists) {
-    const packageJsonUrl2 = pathToFileURL$1(packageConfig.pjsonPath);
-    if (packageConfig.name === packageName && packageConfig.exports !== void 0 && packageConfig.exports !== null) {
-      return packageExportsResolve(
-        packageJsonUrl2,
-        packageSubpath,
-        packageConfig,
-        base,
-        conditions
-      );
-    }
+function initRunners(resolvedPluginConfig, viteDevServer, miniflare) {
+  if (resolvedPluginConfig.type === "assets-only") {
+    return;
   }
-  let packageJsonUrl = new URL$1(
-    "./node_modules/" + packageName + "/package.json",
-    base
+  return Promise.all(
+    Object.entries(resolvedPluginConfig.workers).map(
+      async ([environmentName, workerConfig]) => {
+        const worker = await miniflare.getWorker(workerConfig.name);
+        return viteDevServer.environments[environmentName].initRunner(worker, viteDevServer.config.root, workerConfig);
+      }
+    )
   );
-  let packageJsonPath = fileURLToPath$1(packageJsonUrl);
-  let lastPath;
-  do {
-    const stat = tryStatSync(packageJsonPath.slice(0, -13));
-    if (!stat || !stat.isDirectory()) {
-      lastPath = packageJsonPath;
-      packageJsonUrl = new URL$1(
-        (isScoped ? "../../../../node_modules/" : "../../../node_modules/") + packageName + "/package.json",
-        packageJsonUrl
-      );
-      packageJsonPath = fileURLToPath$1(packageJsonUrl);
-      continue;
-    }
-    const packageConfig2 = read(packageJsonPath, { base, specifier });
-    if (packageConfig2.exports !== void 0 && packageConfig2.exports !== null) {
-      return packageExportsResolve(
-        packageJsonUrl,
-        packageSubpath,
-        packageConfig2,
-        base,
-        conditions
-      );
-    }
-    if (packageSubpath === ".") {
-      return legacyMainResolve(packageJsonUrl, packageConfig2, base);
-    }
-    return new URL$1(packageSubpath, packageJsonUrl);
-  } while (packageJsonPath.length !== lastPath.length);
-  throw new ERR_MODULE_NOT_FOUND(packageName, fileURLToPath$1(base), false);
 }
-function isRelativeSpecifier(specifier) {
-  if (specifier[0] === ".") {
-    if (specifier.length === 1 || specifier[1] === "/") return true;
-    if (specifier[1] === "." && (specifier.length === 2 || specifier[2] === "/")) {
-      return true;
-    }
-  }
-  return false;
+
+// src/deploy-config.ts
+import assert4 from "node:assert";
+import * as fs2 from "node:fs";
+import * as path3 from "node:path";
+import "vite";
+function getDeployConfigPath(root) {
+  return path3.resolve(root, ".wrangler", "deploy", "config.json");
 }
-function shouldBeTreatedAsRelativeOrAbsolutePath(specifier) {
-  if (specifier === "") return false;
-  if (specifier[0] === "/") return true;
-  return isRelativeSpecifier(specifier);
+function getWorkerConfigPaths(root) {
+  const deployConfigPath = getDeployConfigPath(root);
+  const deployConfig = JSON.parse(
+    fs2.readFileSync(deployConfigPath, "utf-8")
+  );
+  return [
+    { configPath: deployConfig.configPath },
+    ...deployConfig.auxiliaryWorkers
+  ].map(
+    ({ configPath }) => path3.resolve(path3.dirname(deployConfigPath), configPath)
+  );
 }
-function moduleResolve(specifier, base, conditions, preserveSymlinks) {
-  const protocol = base.protocol;
-  const isData = protocol === "data:";
-  const isRemote = isData || protocol === "http:" || protocol === "https:";
-  let resolved;
-  if (shouldBeTreatedAsRelativeOrAbsolutePath(specifier)) {
-    try {
-      resolved = new URL$1(specifier, base);
-    } catch (error_) {
-      const error = new ERR_UNSUPPORTED_RESOLVE_REQUEST(specifier, base);
-      error.cause = error_;
-      throw error;
-    }
-  } else if (protocol === "file:" && specifier[0] === "#") {
-    resolved = packageImportsResolve(specifier, base, conditions);
+function getRelativePathToWorkerConfig(deployConfigDirectory, root, outputDirectory) {
+  return path3.relative(
+    deployConfigDirectory,
+    path3.resolve(root, outputDirectory, "wrangler.json")
+  );
+}
+function writeDeployConfig(resolvedPluginConfig, resolvedViteConfig) {
+  const deployConfigPath = getDeployConfigPath(resolvedViteConfig.root);
+  const deployConfigDirectory = path3.dirname(deployConfigPath);
+  fs2.mkdirSync(deployConfigDirectory, { recursive: true });
+  if (resolvedPluginConfig.type === "assets-only") {
+    const clientOutputDirectory = resolvedViteConfig.environments.client?.build.outDir;
+    assert4(
+      clientOutputDirectory,
+      "Unexpected error: client environment output directory is undefined"
+    );
+    const deployConfig = {
+      configPath: getRelativePathToWorkerConfig(
+        deployConfigDirectory,
+        resolvedViteConfig.root,
+        clientOutputDirectory
+      ),
+      auxiliaryWorkers: []
+    };
+    fs2.writeFileSync(deployConfigPath, JSON.stringify(deployConfig));
   } else {
-    try {
-      resolved = new URL$1(specifier);
-    } catch (error_) {
-      if (isRemote && !builtinModules.includes(specifier)) {
-        const error = new ERR_UNSUPPORTED_RESOLVE_REQUEST(specifier, base);
-        error.cause = error_;
-        throw error;
+    let entryWorkerConfigPath;
+    const auxiliaryWorkers = [];
+    for (const environmentName of Object.keys(resolvedPluginConfig.workers)) {
+      const outputDirectory = resolvedViteConfig.environments[environmentName]?.build.outDir;
+      assert4(
+        outputDirectory,
+        `Unexpected error: ${environmentName} environment output directory is undefined`
+      );
+      const configPath = getRelativePathToWorkerConfig(
+        deployConfigDirectory,
+        resolvedViteConfig.root,
+        outputDirectory
+      );
+      if (environmentName === resolvedPluginConfig.entryWorkerEnvironmentName) {
+        entryWorkerConfigPath = configPath;
+      } else {
+        auxiliaryWorkers.push({ configPath });
       }
-      resolved = packageResolve(specifier, base, conditions);
     }
+    assert4(
+      entryWorkerConfigPath,
+      `Unexpected error: entryWorkerConfigPath is undefined`
+    );
+    const deployConfig = {
+      configPath: entryWorkerConfigPath,
+      auxiliaryWorkers
+    };
+    fs2.writeFileSync(deployConfigPath, JSON.stringify(deployConfig));
   }
-  assert5(resolved !== void 0, "expected to be defined");
-  if (resolved.protocol !== "file:") {
-    return resolved;
-  }
-  return finalizeResolution(resolved, base);
-}
-function fileURLToPath2(id) {
-  if (typeof id === "string" && !id.startsWith("file://")) {
-    return normalizeSlash(id);
-  }
-  return normalizeSlash(fileURLToPath$1(id));
 }
-function pathToFileURL(id) {
-  return pathToFileURL$1(fileURLToPath2(id)).toString();
+
+// 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);
 }
-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;
+
+// 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 "file://" + encodeURI(normalizeSlash(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")
+  };
 }
-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 missingWorkerErrorMessage(workerName) {
+  return `${workerName} does not match a worker name.`;
+}
+function getWorkerToWorkerEntrypointNamesMap(workers) {
+  const workerToWorkerEntrypointNamesMap = new Map(
+    workers.map((workerOptions) => [workerOptions.name, /* @__PURE__ */ new Set()])
+  );
+  for (const worker of workers) {
+    for (const value of Object.values(worker.serviceBindings ?? {})) {
+      if (typeof value === "object" && "name" in value && value.entrypoint !== void 0 && value.entrypoint !== "default") {
+        const targetWorkerName = value.name === kCurrentWorker ? worker.name : value.name;
+        const entrypointNames = workerToWorkerEntrypointNamesMap.get(targetWorkerName);
+        assert6(entrypointNames, missingWorkerErrorMessage(targetWorkerName));
+        entrypointNames.add(value.entrypoint);
+      }
     }
   }
+  return workerToWorkerEntrypointNamesMap;
 }
-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 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);
+        }
+      }
     }
   }
-  if (/(node|data|http|https):/.test(id)) {
-    return id;
-  }
-  if (BUILTIN_MODULES.has(id)) {
-    return "node:" + id;
+  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
+        );
+        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 (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}');`
+          );
         }
-      }
-      if (resolved) {
-        break;
-      }
-    }
-    if (resolved) {
-      break;
-    }
-  }
-  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]
-});
-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 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 {
+        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(
-        globalInject[0] !== void 0,
-        "Expected first element of globalInject to be defined"
+        rawSpecifier,
+        `Unexpected error: no specifier in request to module fallback service.`
       );
-      entries.add(globalInject[0]);
+      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?`
+        );
+      }
+      return MiniflareResponse.json({
+        // Cap'n Proto expects byte arrays for `:Data` typed fields from JSON
+        wasm: Array.from(source)
+      });
     }
-  }
-  for (const external of env.external) {
-    entries.delete(external);
-  }
-  return entries;
+  };
 }
-function injectGlobalCode(id, code) {
-  const injectedCode = Object.entries(env.inject).map(([globalName, globalInject]) => {
-    if (typeof globalInject === "string") {
-      const moduleSpecifier2 = globalInject;
-      return `import var_${globalName} from "${moduleSpecifier2}";
-globalThis.${globalName} = var_${globalName};
-`;
-    }
-    const [moduleSpecifier, exportName] = globalInject;
-    assert6(
-      moduleSpecifier !== void 0,
-      "Expected moduleSpecifier to be defined"
-    );
-    assert6(exportName !== void 0, "Expected exportName to be defined");
-    return `import var_${globalName} from "${moduleSpecifier}";
-globalThis.${globalName} = var_${globalName}.${exportName};
-`;
-  }).join("\n");
-  const modified = new MagicString(code);
-  modified.prepend(injectedCode);
+function 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 getNodeCompatExternals() {
-  return env.external;
+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 {
+    log: logger,
+    handleRuntimeStdio(stdout, stderr) {
+      const decoder = new TextDecoder();
+      stdout.forEach((data2) => logger.info(decoder.decode(data2)));
+      stderr.forEach(
+        (error) => logger.logWithLevel(LogLevel.ERROR, decoder.decode(error))
+      );
+    },
+    ...getPersistence(resolvedViteConfig.root, persistState),
+    workers
+  };
 }
-function resolveNodeJSImport(source) {
-  const alias = env.alias[source];
-  if (alias) {
-    return {
-      unresolved: alias,
-      resolved: resolvePathSync(alias, { url: import.meta.url })
-    };
+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;
   }
 }
 
@@ -8834,7 +8872,6 @@ var nonApplicableWorkerConfigs = {
     "build",
     "find_additional_modules",
     "no_bundle",
-    "node_compat",
     "preserve_file_names",
     "site",
     "tsconfig",
@@ -8851,7 +8888,6 @@ var nullableNonApplicable = [
   "find_additional_modules",
   "minify",
   "no_bundle",
-  "node_compat",
   "preserve_file_names",
   "site",
   "tsconfig",
@@ -9002,6 +9038,17 @@ function getWorkerConfig(configPath, env2, opts) {
     };
   }
   assert7(config.main, missingFieldErrorMessage(`'main'`, configPath, env2));
+  const mainStat = fs4.statSync(config.main, { throwIfNoEntry: false });
+  if (!mainStat) {
+    throw new Error(
+      `The provided Wrangler config main field (${config.main}) doesn't point to an existing file`
+    );
+  }
+  if (mainStat.isDirectory()) {
+    throw new Error(
+      `The provided Wrangler config main field (${config.main}) points to a directory, it needs to point to a file instead`
+    );
+  }
   return {
     type: "worker",
     raw,
@@ -9102,9 +9149,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) => {
@@ -9127,34 +9175,7 @@ function handleWebSocket(httpServer, fetcher, logger) {
         socket,
         head,
         async (clientWebSocket) => {
-          workerWebSocket.accept();
-          workerWebSocket.addEventListener("message", (event) => {
-            clientWebSocket.send(event.data);
-          });
-          workerWebSocket.addEventListener("error", (event) => {
-            logger.error(
-              `WebSocket error:
-${event.error?.stack || event.error?.message}`,
-              { error: event.error }
-            );
-          });
-          workerWebSocket.addEventListener("close", () => {
-            clientWebSocket.close();
-          });
-          clientWebSocket.on("message", (data2, isBinary) => {
-            workerWebSocket.send(
-              isBinary ? Array.isArray(data2) ? Buffer.concat(data2) : data2 : data2.toString()
-            );
-          });
-          clientWebSocket.on("error", (error) => {
-            logger.error(`WebSocket error:
-${error.stack || error.message}`, {
-              error
-            });
-          });
-          clientWebSocket.on("close", () => {
-            workerWebSocket.close();
-          });
+          coupleWebSocket(clientWebSocket, workerWebSocket);
           nodeWebSocket.emit("connection", clientWebSocket, request);
         }
       );
@@ -9213,7 +9234,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,
@@ -9239,7 +9260,7 @@ function cloudflare2(pluginConfig = {}) {
                   )
                 );
               }
-            }
+            })
           }
         };
       },
@@ -9300,7 +9321,7 @@ function cloudflare2(pluginConfig = {}) {
           return;
         }
         config.no_bundle = true;
-        config.rules = [{ type: "ESModule", globs: ["**/*.js"] }];
+        config.rules = [{ type: "ESModule", globs: ["**/*.js", "**/*.mjs"] }];
         if (config.unsafe && Object.keys(config.unsafe).length === 0) {
           config.unsafe = void 0;
         }
@@ -9347,11 +9368,7 @@ function cloudflare2(pluginConfig = {}) {
           },
           { alwaysCallNext: false }
         );
-        handleWebSocket(
-          viteDevServer.httpServer,
-          entryWorker.fetch,
-          viteDevServer.config.logger
-        );
+        handleWebSocket(viteDevServer.httpServer, entryWorker.fetch);
         return () => {
           viteDevServer.middlewares.use((req, res, next) => {
             middleware(req, res, next);
@@ -9373,16 +9390,10 @@ function cloudflare2(pluginConfig = {}) {
           },
           { alwaysCallNext: false }
         );
-        handleWebSocket(
-          vitePreviewServer.httpServer,
-          miniflare2.dispatchFetch,
-          vitePreviewServer.config.logger
-        );
-        return () => {
-          vitePreviewServer.middlewares.use((req, res, next) => {
-            middleware(req, res, next);
-          });
-        };
+        handleWebSocket(vitePreviewServer.httpServer, miniflare2.dispatchFetch);
+        vitePreviewServer.middlewares.use((req, res, next) => {
+          middleware(req, res, next);
+        });
       }
     },
     // Plugin to support `CompiledWasm` modules
@@ -9462,7 +9473,7 @@ function cloudflare2(pluginConfig = {}) {
         if (isNodeCompat(getWorkerConfig2(name2))) {
           return {
             resolve: {
-              builtins: getNodeCompatExternals()
+              builtins: [...nodeCompatExternals]
             },
             optimizeDeps: {
               // This is a list of dependency entry-points that should be pre-bundled.
@@ -9470,7 +9481,8 @@ function cloudflare2(pluginConfig = {}) {
               // 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.
-              include: [...getNodeCompatEntries()],
+              // 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;
@@ -9501,7 +9513,11 @@ function cloudflare2(pluginConfig = {}) {
             this.environment.depsOptimizer,
             "depsOptimizer is required in dev mode"
           );
-          return this.resolve(result.unresolved, importer, options);
+          const { id } = this.environment.depsOptimizer.registerMissingImport(
+            result.unresolved,
+            result.resolved
+          );
+          return this.resolve(id, importer, options);
         }
         return this.resolve(result.resolved, importer, options);
       },