@venos-inc/venos 0.1.5 → 0.1.6

package/etc/mcp-server/node_modules/vite/dist/node/{runtime.js → module-runner.js}

@@ -1,10 +1,7 @@
 const VALID_ID_PREFIX = "/@id/", NULL_BYTE_PLACEHOLDER = "__x00__";
 let SOURCEMAPPING_URL = "sourceMa";
 SOURCEMAPPING_URL += "ppingURL";
-const isWindows = typeof process < "u" && process.platform === "win32";
-function wrapId(id) {
-  return id.startsWith(VALID_ID_PREFIX) ? id : VALID_ID_PREFIX + id.replace("\0", NULL_BYTE_PLACEHOLDER);
-}
+const ERR_OUTDATED_OPTIMIZED_DEP = "ERR_OUTDATED_OPTIMIZED_DEP", isWindows = typeof process < "u" && process.platform === "win32";
 function unwrapId(id) {
   return id.startsWith(VALID_ID_PREFIX) ? id.slice(VALID_ID_PREFIX.length).replace(NULL_BYTE_PLACEHOLDER, "\0") : id;
 }
@@ -19,11 +16,24 @@ function cleanUrl(url) {
 function isPrimitive(value) {
   return !value || typeof value != "object" && typeof value != "function";
 }
-function withTrailingSlash(path) {
-  return path[path.length - 1] !== "/" ? `${path}/` : path;
-}
 const AsyncFunction = async function() {
-}.constructor, _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+}.constructor;
+let asyncFunctionDeclarationPaddingLineCount;
+function getAsyncFunctionDeclarationPaddingLineCount() {
+  if (typeof asyncFunctionDeclarationPaddingLineCount > "u") {
+    const body = "/*code*/", source = new AsyncFunction("a", "b", body).toString();
+    asyncFunctionDeclarationPaddingLineCount = source.slice(0, source.indexOf(body)).split(`
+`).length - 1;
+  }
+  return asyncFunctionDeclarationPaddingLineCount;
+}
+function promiseWithResolvers() {
+  let resolve2, reject;
+  return { promise: new Promise((_resolve, _reject) => {
+    resolve2 = _resolve, reject = _reject;
+  }), resolve: resolve2, reject };
+}
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
 function normalizeWindowsPath(input = "") {
   return input && input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
 }
@@ -232,109 +242,100 @@ function getOriginalPosition(map, needle) {
   const result = originalPositionFor(map, needle);
   return result.column == null ? null : result;
 }
-const VITE_RUNTIME_SOURCEMAPPING_REGEXP = new RegExp(
+const MODULE_RUNNER_SOURCEMAPPING_REGEXP = new RegExp(
   `//# ${SOURCEMAPPING_URL}=data:application/json;base64,(.+)`
 );
-class ModuleCacheMap extends Map {
-  root;
-  constructor(root, entries) {
-    super(entries), this.root = withTrailingSlash(root);
-  }
-  normalize(fsPath) {
-    return normalizeModuleId(fsPath, this.root);
+class EvaluatedModuleNode {
+  constructor(id, url) {
+    this.id = id, this.url = url, this.file = cleanUrl(id);
+  }
+  importers = /* @__PURE__ */ new Set();
+  imports = /* @__PURE__ */ new Set();
+  evaluated = !1;
+  meta;
+  promise;
+  exports;
+  file;
+  map;
+}
+class EvaluatedModules {
+  idToModuleMap = /* @__PURE__ */ new Map();
+  fileToModulesMap = /* @__PURE__ */ new Map();
+  urlToIdModuleMap = /* @__PURE__ */ new Map();
+  /**
+   * Returns the module node by the resolved module ID. Usually, module ID is
+   * the file system path with query and/or hash. It can also be a virtual module.
+   *
+   * Module runner graph will have 1 to 1 mapping with the server module graph.
+   * @param id Resolved module ID
+   */
+  getModuleById(id) {
+    return this.idToModuleMap.get(id);
   }
   /**
-   * Assign partial data to the map
+   * Returns all modules related to the file system path. Different modules
+   * might have different query parameters or hash, so it's possible to have
+   * multiple modules for the same file.
+   * @param file The file system path of the module
    */
-  update(fsPath, mod) {
-    return fsPath = this.normalize(fsPath), super.has(fsPath) ? Object.assign(super.get(fsPath), mod) : this.setByModuleId(fsPath, mod), this;
-  }
-  setByModuleId(modulePath, mod) {
-    return super.set(modulePath, mod);
-  }
-  set(fsPath, mod) {
-    return this.setByModuleId(this.normalize(fsPath), mod);
-  }
-  getByModuleId(modulePath) {
-    super.has(modulePath) || this.setByModuleId(modulePath, {});
-    const mod = super.get(modulePath);
-    return mod.imports || Object.assign(mod, {
-      imports: /* @__PURE__ */ new Set(),
-      importers: /* @__PURE__ */ new Set()
-    }), mod;
-  }
-  get(fsPath) {
-    return this.getByModuleId(this.normalize(fsPath));
-  }
-  deleteByModuleId(modulePath) {
-    return super.delete(modulePath);
-  }
-  delete(fsPath) {
-    return this.deleteByModuleId(this.normalize(fsPath));
-  }
-  invalidate(id) {
-    const module = this.get(id);
-    module.evaluated = !1, module.meta = void 0, module.map = void 0, module.promise = void 0, module.exports = void 0, module.imports?.clear();
-  }
-  isImported({
-    importedId,
-    importedBy
-  }, seen = /* @__PURE__ */ new Set()) {
-    if (importedId = this.normalize(importedId), importedBy = this.normalize(importedBy), importedBy === importedId) return !0;
-    if (seen.has(importedId)) return !1;
-    seen.add(importedId);
-    const importers = this.getByModuleId(importedId)?.importers;
-    if (!importers) return !1;
-    if (importers.has(importedBy)) return !0;
-    for (const importer of importers)
-      if (this.isImported({
-        importedBy,
-        importedId: importer
-      }))
-        return !0;
-    return !1;
+  getModulesByFile(file) {
+    return this.fileToModulesMap.get(file);
   }
   /**
-   * Invalidate modules that dependent on the given modules, up to the main entry
+   * Returns the module node by the URL that was used in the import statement.
+   * Unlike module graph on the server, the URL is not resolved and is used as is.
+   * @param url Server URL that was used in the import statement
    */
-  invalidateDepTree(ids, invalidated = /* @__PURE__ */ new Set()) {
-    for (const _id of ids) {
-      const id = this.normalize(_id);
-      if (invalidated.has(id)) continue;
-      invalidated.add(id);
-      const mod = super.get(id);
-      mod?.importers && this.invalidateDepTree(mod.importers, invalidated), super.delete(id);
-    }
-    return invalidated;
+  getModuleByUrl(url) {
+    return this.urlToIdModuleMap.get(unwrapId(url));
   }
   /**
-   * Invalidate dependency modules of the given modules, down to the bottom-level dependencies
+   * Ensure that module is in the graph. If the module is already in the graph,
+   * it will return the existing module node. Otherwise, it will create a new
+   * module node and add it to the graph.
+   * @param id Resolved module ID
+   * @param url URL that was used in the import statement
    */
-  invalidateSubDepTree(ids, invalidated = /* @__PURE__ */ new Set()) {
-    for (const _id of ids) {
-      const id = this.normalize(_id);
-      if (invalidated.has(id)) continue;
-      invalidated.add(id);
-      const subIds = Array.from(super.entries()).filter(([, mod]) => mod.importers?.has(id)).map(([key]) => key);
-      subIds.length && this.invalidateSubDepTree(subIds, invalidated), super.delete(id);
+  ensureModule(id, url) {
+    if (id = normalizeModuleId(id), this.idToModuleMap.has(id)) {
+      const moduleNode2 = this.idToModuleMap.get(id);
+      return this.urlToIdModuleMap.set(url, moduleNode2), moduleNode2;
     }
-    return invalidated;
+    const moduleNode = new EvaluatedModuleNode(id, url);
+    this.idToModuleMap.set(id, moduleNode), this.urlToIdModuleMap.set(url, moduleNode);
+    const fileModules = this.fileToModulesMap.get(moduleNode.file) || /* @__PURE__ */ new Set();
+    return fileModules.add(moduleNode), this.fileToModulesMap.set(moduleNode.file, fileModules), moduleNode;
+  }
+  invalidateModule(node) {
+    node.evaluated = !1, node.meta = void 0, node.map = void 0, node.promise = void 0, node.exports = void 0, node.imports.clear();
   }
-  getSourceMap(moduleId) {
-    const mod = this.get(moduleId);
+  /**
+   * Extracts the inlined source map from the module code and returns the decoded
+   * source map. If the source map is not inlined, it will return null.
+   * @param id Resolved module ID
+   */
+  getModuleSourceMapById(id) {
+    const mod = this.getModuleById(id);
+    if (!mod) return null;
     if (mod.map) return mod.map;
     if (!mod.meta || !("code" in mod.meta)) return null;
-    const mapString = VITE_RUNTIME_SOURCEMAPPING_REGEXP.exec(mod.meta.code)?.[1];
-    if (!mapString) return null;
-    const baseFile = mod.meta.file || moduleId.split("?")[0];
-    return mod.map = new DecodedMap(JSON.parse(decodeBase64(mapString)), baseFile), mod.map;
+    const mapString = MODULE_RUNNER_SOURCEMAPPING_REGEXP.exec(
+      mod.meta.code
+    )?.[1];
+    return mapString ? (mod.map = new DecodedMap(JSON.parse(decodeBase64(mapString)), mod.file), mod.map) : null;
+  }
+  clear() {
+    this.idToModuleMap.clear(), this.fileToModulesMap.clear(), this.urlToIdModuleMap.clear();
   }
 }
-const prefixedBuiltins = /* @__PURE__ */ new Set(["node:test"]);
-function normalizeModuleId(file, root) {
-  if (prefixedBuiltins.has(file)) return file;
-  let unixFile = slash(file).replace(/^\/@fs\//, isWindows ? "" : "/").replace(/^node:/, "").replace(/^\/+/, "/");
-  return unixFile.startsWith(root) && (unixFile = unixFile.slice(root.length - 1)), unixFile.replace(/^file:\//, "/");
+const prefixedBuiltins = /* @__PURE__ */ new Set([
+  "node:sea",
+  "node:sqlite",
+  "node:test",
+  "node:test/reporters"
+]);
+function normalizeModuleId(file) {
+  return prefixedBuiltins.has(file) ? file : slash(file).replace(/^\/@fs\//, isWindows ? "" : "/").replace(/^node:/, "").replace(/^\/+/, "/").replace(/^file:\//, "/");
 }
 class HMRContext {
   constructor(hmrClient, ownerPath) {
@@ -382,11 +383,17 @@ class HMRContext {
   decline() {
   }
   invalidate(message) {
+    const firstInvalidatedBy = this.hmrClient.currentFirstInvalidatedBy ?? this.ownerPath;
     this.hmrClient.notifyListeners("vite:invalidate", {
       path: this.ownerPath,
-      message
-    }), this.send("vite:invalidate", { path: this.ownerPath, message }), this.hmrClient.logger.debug(
-      `[vite] invalidate ${this.ownerPath}${message ? `: ${message}` : ""}`
+      message,
+      firstInvalidatedBy
+    }), this.send("vite:invalidate", {
+      path: this.ownerPath,
+      message,
+      firstInvalidatedBy
+    }), this.hmrClient.logger.debug(
+      `invalidate ${this.ownerPath}${message ? `: ${message}` : ""}`
     );
   }
   on(event, cb) {
@@ -411,9 +418,7 @@ class HMRContext {
     removeFromMap(this.hmrClient.customListenersMap), removeFromMap(this.newListeners);
   }
   send(event, data) {
-    this.hmrClient.messenger.send(
-      JSON.stringify({ type: "custom", event, data })
-    );
+    this.hmrClient.send({ type: "custom", event, data });
   }
   acceptDeps(deps, callback = () => {
   }) {
@@ -427,21 +432,9 @@ class HMRContext {
     }), this.hmrClient.hotModulesMap.set(this.ownerPath, mod);
   }
 }
-class HMRMessenger {
-  constructor(connection) {
-    this.connection = connection;
-  }
-  queue = [];
-  send(message) {
-    this.queue.push(message), this.flush();
-  }
-  flush() {
-    this.connection.isReady() && (this.queue.forEach((msg) => this.connection.send(msg)), this.queue = []);
-  }
-}
 class HMRClient {
-  constructor(logger, connection, importUpdatedModule) {
-    this.logger = logger, this.importUpdatedModule = importUpdatedModule, this.messenger = new HMRMessenger(connection);
+  constructor(logger, transport, importUpdatedModule) {
+    this.logger = logger, this.transport = transport, this.importUpdatedModule = importUpdatedModule;
   }
   hotModulesMap = /* @__PURE__ */ new Map();
   disposeMap = /* @__PURE__ */ new Map();
@@ -449,17 +442,22 @@ class HMRClient {
   dataMap = /* @__PURE__ */ new Map();
   customListenersMap = /* @__PURE__ */ new Map();
   ctxToListenersMap = /* @__PURE__ */ new Map();
-  messenger;
+  currentFirstInvalidatedBy;
   async notifyListeners(event, data) {
     const cbs = this.customListenersMap.get(event);
     cbs && await Promise.allSettled(cbs.map((cb) => cb(data)));
   }
+  send(payload) {
+    this.transport.send(payload).catch((err) => {
+      this.logger.error(err);
+    });
+  }
   clear() {
     this.hotModulesMap.clear(), this.disposeMap.clear(), this.pruneMap.clear(), this.dataMap.clear(), this.customListenersMap.clear(), this.ctxToListenersMap.clear();
   }
   // After an HMR update, some modules are no longer imported on the page
   // but they may have left behind side effects that need to be cleaned up
-  // (.e.g style injections)
+  // (e.g. style injections)
   async prunePaths(paths) {
     await Promise.all(
       paths.map((path) => {
@@ -472,8 +470,8 @@ class HMRClient {
     });
   }
   warnFailedUpdate(err, path) {
-    err.message.includes("fetch") || this.logger.error(err), this.logger.error(
-      `[hmr] Failed to reload ${path}. This could be due to syntax errors or importing non-existent modules. (see errors above)`
+    (!(err instanceof Error) || !err.message.includes("fetch")) && this.logger.error(err), this.logger.error(
+      `Failed to reload ${path}. This could be due to syntax errors or importing non-existent modules. (see errors above)`
     );
   }
   updateQueue = [];
@@ -491,7 +489,7 @@ class HMRClient {
     }
   }
   async fetchUpdate(update) {
-    const { path, acceptedPath } = update, mod = this.hotModulesMap.get(path);
+    const { path, acceptedPath, firstInvalidatedBy } = update, mod = this.hotModulesMap.get(path);
     if (!mod)
       return;
     let fetchedModule;
@@ -508,12 +506,19 @@ class HMRClient {
       }
     }
     return () => {
-      for (const { deps, fn } of qualifiedCallbacks)
-        fn(
-          deps.map((dep) => dep === acceptedPath ? fetchedModule : void 0)
-        );
-      const loggedPath = isSelfUpdate ? path : `${acceptedPath} via ${path}`;
-      this.logger.debug(`[vite] hot updated: ${loggedPath}`);
+      try {
+        this.currentFirstInvalidatedBy = firstInvalidatedBy;
+        for (const { deps, fn } of qualifiedCallbacks)
+          fn(
+            deps.map(
+              (dep) => dep === acceptedPath ? fetchedModule : void 0
+            )
+          );
+        const loggedPath = isSelfUpdate ? path : `${acceptedPath} via ${path}`;
+        this.logger.debug(`hot updated: ${loggedPath}`);
+      } finally {
+        this.currentFirstInvalidatedBy = void 0;
+      }
     };
   }
 }
@@ -533,66 +538,204 @@ const {${missingBindings.join(", ")}} = pkg;
     }
   }
 }
-const ssrModuleExportsKey = "__vite_ssr_exports__", ssrImportKey = "__vite_ssr_import__", ssrDynamicImportKey = "__vite_ssr_dynamic_import__", ssrExportAllKey = "__vite_ssr_exportAll__", ssrImportMetaKey = "__vite_ssr_import_meta__", noop = () => {
-}, silentConsole = {
-  debug: noop,
-  error: noop
+let urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict", nanoid = (size = 21) => {
+  let id = "", i = size | 0;
+  for (; i--; )
+    id += urlAlphabet[Math.random() * 64 | 0];
+  return id;
 };
-function createHMRHandler(runtime) {
-  const queue = new Queue();
-  return (payload) => queue.enqueue(() => handleHMRPayload(runtime, payload));
+function reviveInvokeError(e) {
+  const error = new Error(e.message || "Unknown invoke error");
+  return Object.assign(error, e, {
+    // pass the whole error instead of just the stacktrace
+    // so that it gets formatted nicely with console.log
+    runnerError: new Error("RunnerError")
+  }), error;
 }
-async function handleHMRPayload(runtime, payload) {
-  const hmrClient = runtime.hmrClient;
-  if (!(!hmrClient || runtime.isDestroyed()))
-    switch (payload.type) {
-      case "connected":
-        hmrClient.logger.debug("[vite] connected."), hmrClient.messenger.flush();
-        break;
-      case "update":
-        await hmrClient.notifyListeners("vite:beforeUpdate", payload), await Promise.all(
-          payload.updates.map(async (update) => {
-            if (update.type === "js-update")
-              return update.acceptedPath = unwrapId(update.acceptedPath), update.path = unwrapId(update.path), hmrClient.queueUpdate(update);
-            hmrClient.logger.error(
-              "[vite] css hmr is not supported in runtime mode."
-            );
-          })
-        ), await hmrClient.notifyListeners("vite:afterUpdate", payload);
-        break;
-      case "custom": {
-        await hmrClient.notifyListeners(payload.event, payload.data);
-        break;
-      }
-      case "full-reload": {
-        const { triggeredBy } = payload, clearEntrypoints = triggeredBy ? [...runtime.entrypoints].filter(
-          (entrypoint) => runtime.moduleCache.isImported({
-            importedId: triggeredBy,
-            importedBy: entrypoint
-          })
-        ) : [...runtime.entrypoints];
-        if (!clearEntrypoints.length) break;
-        hmrClient.logger.debug("[vite] program reload"), await hmrClient.notifyListeners("vite:beforeFullReload", payload), runtime.moduleCache.clear();
-        for (const id of clearEntrypoints)
-          await runtime.executeUrl(id);
-        break;
+const createInvokeableTransport = (transport) => {
+  if (transport.invoke)
+    return {
+      ...transport,
+      async invoke(name, data) {
+        const result = await transport.invoke({
+          type: "custom",
+          event: "vite:invoke",
+          data: {
+            id: "send",
+            name,
+            data
+          }
+        });
+        if ("error" in result)
+          throw reviveInvokeError(result.error);
+        return result.result;
       }
-      case "prune":
-        await hmrClient.notifyListeners("vite:beforePrune", payload), await hmrClient.prunePaths(payload.paths);
-        break;
-      case "error": {
-        await hmrClient.notifyListeners("vite:error", payload);
-        const err = payload.err;
-        hmrClient.logger.error(
-          `[vite] Internal Server Error
-${err.message}
-${err.stack}`
+    };
+  if (!transport.send || !transport.connect)
+    throw new Error(
+      "transport must implement send and connect when invoke is not implemented"
+    );
+  const rpcPromises = /* @__PURE__ */ new Map();
+  return {
+    ...transport,
+    connect({ onMessage, onDisconnection }) {
+      return transport.connect({
+        onMessage(payload) {
+          if (payload.type === "custom" && payload.event === "vite:invoke") {
+            const data = payload.data;
+            if (data.id.startsWith("response:")) {
+              const invokeId = data.id.slice(9), promise = rpcPromises.get(invokeId);
+              if (!promise) return;
+              promise.timeoutId && clearTimeout(promise.timeoutId), rpcPromises.delete(invokeId);
+              const { error, result } = data.data;
+              error ? promise.reject(error) : promise.resolve(result);
+              return;
+            }
+          }
+          onMessage(payload);
+        },
+        onDisconnection
+      });
+    },
+    disconnect() {
+      return rpcPromises.forEach((promise) => {
+        promise.reject(
+          new Error(
+            `transport was disconnected, cannot call ${JSON.stringify(promise.name)}`
+          )
         );
-        break;
+      }), rpcPromises.clear(), transport.disconnect?.();
+    },
+    send(data) {
+      return transport.send(data);
+    },
+    async invoke(name, data) {
+      const promiseId = nanoid(), wrappedData = {
+        type: "custom",
+        event: "vite:invoke",
+        data: {
+          name,
+          id: `send:${promiseId}`,
+          data
+        }
+      }, sendPromise = transport.send(wrappedData), { promise, resolve: resolve2, reject } = promiseWithResolvers(), timeout = transport.timeout ?? 6e4;
+      let timeoutId;
+      timeout > 0 && (timeoutId = setTimeout(() => {
+        rpcPromises.delete(promiseId), reject(
+          new Error(
+            `transport invoke timed out after ${timeout}ms (data: ${JSON.stringify(wrappedData)})`
+          )
+        );
+      }, timeout), timeoutId?.unref?.()), rpcPromises.set(promiseId, { resolve: resolve2, reject, name, timeoutId }), sendPromise && sendPromise.catch((err) => {
+        clearTimeout(timeoutId), rpcPromises.delete(promiseId), reject(err);
+      });
+      try {
+        return await promise;
+      } catch (err) {
+        throw reviveInvokeError(err);
+      }
+    }
+  };
+}, normalizeModuleRunnerTransport = (transport) => {
+  const invokeableTransport = createInvokeableTransport(transport);
+  let isConnected = !invokeableTransport.connect, connectingPromise;
+  return {
+    ...transport,
+    ...invokeableTransport.connect ? {
+      async connect(onMessage) {
+        if (isConnected) return;
+        if (connectingPromise) {
+          await connectingPromise;
+          return;
+        }
+        const maybePromise = invokeableTransport.connect({
+          onMessage: onMessage ?? (() => {
+          }),
+          onDisconnection() {
+            isConnected = !1;
+          }
+        });
+        maybePromise && (connectingPromise = maybePromise, await connectingPromise, connectingPromise = void 0), isConnected = !0;
+      }
+    } : {},
+    ...invokeableTransport.disconnect ? {
+      async disconnect() {
+        isConnected && (connectingPromise && await connectingPromise, isConnected = !1, await invokeableTransport.disconnect());
       }
-      default:
-        return payload;
+    } : {},
+    async send(data) {
+      if (invokeableTransport.send) {
+        if (!isConnected)
+          if (connectingPromise)
+            await connectingPromise;
+          else
+            throw new Error("send was called before connect");
+        await invokeableTransport.send(data);
+      }
+    },
+    async invoke(name, data) {
+      if (!isConnected)
+        if (connectingPromise)
+          await connectingPromise;
+        else
+          throw new Error("invoke was called before connect");
+      return invokeableTransport.invoke(name, data);
     }
+  };
+}, createWebSocketModuleRunnerTransport = (options) => {
+  const pingInterval = options.pingInterval ?? 3e4;
+  let ws, pingIntervalId;
+  return {
+    async connect({ onMessage, onDisconnection }) {
+      const socket = options.createConnection();
+      socket.addEventListener("message", async ({ data }) => {
+        onMessage(JSON.parse(data));
+      });
+      let isOpened = socket.readyState === socket.OPEN;
+      isOpened || await new Promise((resolve2, reject) => {
+        socket.addEventListener(
+          "open",
+          () => {
+            isOpened = !0, resolve2();
+          },
+          { once: !0 }
+        ), socket.addEventListener("close", async () => {
+          if (!isOpened) {
+            reject(new Error("WebSocket closed without opened."));
+            return;
+          }
+          onMessage({
+            type: "custom",
+            event: "vite:ws:disconnect",
+            data: { webSocket: socket }
+          }), onDisconnection();
+        });
+      }), onMessage({
+        type: "custom",
+        event: "vite:ws:connect",
+        data: { webSocket: socket }
+      }), ws = socket, pingIntervalId = setInterval(() => {
+        socket.readyState === socket.OPEN && socket.send(JSON.stringify({ type: "ping" }));
+      }, pingInterval);
+    },
+    disconnect() {
+      clearInterval(pingIntervalId), ws?.close();
+    },
+    send(data) {
+      ws.send(JSON.stringify(data));
+    }
+  };
+}, ssrModuleExportsKey = "__vite_ssr_exports__", ssrImportKey = "__vite_ssr_import__", ssrDynamicImportKey = "__vite_ssr_dynamic_import__", ssrExportAllKey = "__vite_ssr_exportAll__", ssrImportMetaKey = "__vite_ssr_import_meta__", noop = () => {
+}, silentConsole = {
+  debug: noop,
+  error: noop
+}, hmrLogger = {
+  debug: (...msg) => console.log("[vite]", ...msg),
+  error: (error) => console.log("[vite]", error)
+};
+function createHMRHandler(handler) {
+  const queue = new Queue();
+  return (payload) => queue.enqueue(() => handler(payload));
 }
 class Queue {
   queue = [];
@@ -615,7 +758,92 @@ class Queue {
     }), !0) : !1;
   }
 }
-const sourceMapCache = {}, fileContentsCache = {}, moduleGraphs = /* @__PURE__ */ new Set(), retrieveFileHandlers = /* @__PURE__ */ new Set(), retrieveSourceMapHandlers = /* @__PURE__ */ new Set(), createExecHandlers = (handlers) => (...args) => {
+function createHMRHandlerForRunner(runner) {
+  return createHMRHandler(async (payload) => {
+    const hmrClient = runner.hmrClient;
+    if (!(!hmrClient || runner.isClosed()))
+      switch (payload.type) {
+        case "connected":
+          hmrClient.logger.debug("connected.");
+          break;
+        case "update":
+          await hmrClient.notifyListeners("vite:beforeUpdate", payload), await Promise.all(
+            payload.updates.map(async (update) => {
+              if (update.type === "js-update")
+                return update.acceptedPath = unwrapId(update.acceptedPath), update.path = unwrapId(update.path), hmrClient.queueUpdate(update);
+              hmrClient.logger.error("css hmr is not supported in runner mode.");
+            })
+          ), await hmrClient.notifyListeners("vite:afterUpdate", payload);
+          break;
+        case "custom": {
+          await hmrClient.notifyListeners(payload.event, payload.data);
+          break;
+        }
+        case "full-reload": {
+          const { triggeredBy } = payload, clearEntrypointUrls = triggeredBy ? getModulesEntrypoints(
+            runner,
+            getModulesByFile(runner, slash(triggeredBy))
+          ) : findAllEntrypoints(runner);
+          if (!clearEntrypointUrls.size) break;
+          hmrClient.logger.debug("program reload"), await hmrClient.notifyListeners("vite:beforeFullReload", payload), runner.evaluatedModules.clear();
+          for (const url of clearEntrypointUrls)
+            try {
+              await runner.import(url);
+            } catch (err) {
+              err.code !== ERR_OUTDATED_OPTIMIZED_DEP && hmrClient.logger.error(
+                `An error happened during full reload
+${err.message}
+${err.stack}`
+              );
+            }
+          break;
+        }
+        case "prune":
+          await hmrClient.notifyListeners("vite:beforePrune", payload), await hmrClient.prunePaths(payload.paths);
+          break;
+        case "error": {
+          await hmrClient.notifyListeners("vite:error", payload);
+          const err = payload.err;
+          hmrClient.logger.error(
+            `Internal Server Error
+${err.message}
+${err.stack}`
+          );
+          break;
+        }
+        case "ping":
+          break;
+        default:
+          return payload;
+      }
+  });
+}
+function getModulesByFile(runner, file) {
+  const nodes = runner.evaluatedModules.getModulesByFile(file);
+  return nodes ? [...nodes].map((node) => node.id) : [];
+}
+function getModulesEntrypoints(runner, modules, visited = /* @__PURE__ */ new Set(), entrypoints = /* @__PURE__ */ new Set()) {
+  for (const moduleId of modules) {
+    if (visited.has(moduleId)) continue;
+    visited.add(moduleId);
+    const module = runner.evaluatedModules.getModuleById(moduleId);
+    if (module) {
+      if (!module.importers.size) {
+        entrypoints.add(module.url);
+        continue;
+      }
+      for (const importer of module.importers)
+        getModulesEntrypoints(runner, [importer], visited, entrypoints);
+    }
+  }
+  return entrypoints;
+}
+function findAllEntrypoints(runner, entrypoints = /* @__PURE__ */ new Set()) {
+  for (const mod of runner.evaluatedModules.idToModuleMap.values())
+    mod.importers.size || entrypoints.add(mod.url);
+  return entrypoints;
+}
+const sourceMapCache = {}, fileContentsCache = {}, evaluatedModulesCache = /* @__PURE__ */ new Set(), retrieveFileHandlers = /* @__PURE__ */ new Set(), retrieveSourceMapHandlers = /* @__PURE__ */ new Set(), createExecHandlers = (handlers) => (...args) => {
   for (const handler of handlers) {
     const result = handler(...args);
     if (result) return result;
@@ -626,11 +854,11 @@ const sourceMapCache = {}, fileContentsCache = {}, moduleGraphs = /* @__PURE__ *
 );
 let overridden = !1;
 const originalPrepare = Error.prepareStackTrace;
-function resetInterceptor(runtime, options) {
-  moduleGraphs.delete(runtime.moduleCache), options.retrieveFile && retrieveFileHandlers.delete(options.retrieveFile), options.retrieveSourceMap && retrieveSourceMapHandlers.delete(options.retrieveSourceMap), moduleGraphs.size === 0 && (Error.prepareStackTrace = originalPrepare, overridden = !1);
+function resetInterceptor(runner, options) {
+  evaluatedModulesCache.delete(runner.evaluatedModules), options.retrieveFile && retrieveFileHandlers.delete(options.retrieveFile), options.retrieveSourceMap && retrieveSourceMapHandlers.delete(options.retrieveSourceMap), evaluatedModulesCache.size === 0 && (Error.prepareStackTrace = originalPrepare, overridden = !1);
 }
-function interceptStackTrace(runtime, options = {}) {
-  return overridden || (Error.prepareStackTrace = prepareStackTrace, overridden = !0), moduleGraphs.add(runtime.moduleCache), options.retrieveFile && retrieveFileHandlers.add(options.retrieveFile), options.retrieveSourceMap && retrieveSourceMapHandlers.add(options.retrieveSourceMap), () => resetInterceptor(runtime, options);
+function interceptStackTrace(runner, options = {}) {
+  return overridden || (Error.prepareStackTrace = prepareStackTrace, overridden = !0), evaluatedModulesCache.add(runner.evaluatedModules), options.retrieveFile && retrieveFileHandlers.add(options.retrieveFile), options.retrieveSourceMap && retrieveSourceMapHandlers.add(options.retrieveSourceMap), () => resetInterceptor(runner, options);
 }
 function supportRelativeURL(file, url) {
   if (!file) return url;
@@ -639,9 +867,9 @@ function supportRelativeURL(file, url) {
   const startPath = dir.slice(protocol.length);
   return protocol && /^\/\w:/.test(startPath) ? (protocol += "/", protocol + slash(posixResolve(startPath, url))) : protocol + posixResolve(startPath, url);
 }
-function getRuntimeSourceMap(position) {
-  for (const moduleCache of moduleGraphs) {
-    const sourceMap = moduleCache.getSourceMap(position.source);
+function getRunnerSourceMap(position) {
+  for (const moduleGraph of evaluatedModulesCache) {
+    const sourceMap = moduleGraph.getModuleSourceMapById(position.source);
     if (sourceMap)
       return {
         url: position.source,
@@ -683,7 +911,7 @@ function retrieveSourceMap(source) {
 }
 function mapSourcePosition(position) {
   if (!position.source) return position;
-  let sourceMap = getRuntimeSourceMap(position);
+  let sourceMap = getRunnerSourceMap(position);
   if (sourceMap || (sourceMap = sourceMapCache[position.source]), !sourceMap) {
     const urlAndMap = retrieveSourceMap(position.source);
     if (urlAndMap && urlAndMap.map) {
@@ -709,7 +937,7 @@ function mapSourcePosition(position) {
         map: null
       };
   }
-  if (sourceMap && sourceMap.map && sourceMap.url) {
+  if (sourceMap.map && sourceMap.url) {
     const originalPosition = getOriginalPosition(sourceMap.map, position);
     if (originalPosition && originalPosition.source != null)
       return originalPosition.source = supportRelativeURL(
@@ -810,8 +1038,8 @@ function prepareStackTrace(error, stack) {
     at ${wrapCallSite(stack[i], state)}`), state.nextPosition = state.curPosition;
   return state.curPosition = state.nextPosition = null, errorString + processedStack.reverse().join("");
 }
-function enableSourceMapSupport(runtime) {
-  if (runtime.options.sourcemapInterceptor === "node") {
+function enableSourceMapSupport(runner) {
+  if (runner.options.sourcemapInterceptor === "node") {
     if (typeof process > "u")
       throw new TypeError(
         `Cannot use "sourcemapInterceptor: 'node'" because global "process" variable is not available.`
@@ -824,156 +1052,192 @@ function enableSourceMapSupport(runtime) {
     return process.setSourceMapsEnabled(!0), () => !isEnabledAlready && process.setSourceMapsEnabled(!1);
   }
   return interceptStackTrace(
-    runtime,
-    typeof runtime.options.sourcemapInterceptor == "object" ? runtime.options.sourcemapInterceptor : void 0
+    runner,
+    typeof runner.options.sourcemapInterceptor == "object" ? runner.options.sourcemapInterceptor : void 0
   );
 }
-class ViteRuntime {
-  constructor(options, runner, debug) {
-    this.options = options, this.runner = runner, this.debug = debug, this.moduleCache = options.moduleCache ?? new ModuleCacheMap(options.root), typeof options.hmr == "object" && (this.hmrClient = new HMRClient(
-      options.hmr.logger === !1 ? silentConsole : options.hmr.logger || console,
-      options.hmr.connection,
-      ({ acceptedPath, ssrInvalidates }) => (this.moduleCache.invalidate(acceptedPath), ssrInvalidates && this.invalidateFiles(ssrInvalidates), this.executeUrl(acceptedPath))
-    ), options.hmr.connection.onUpdate(createHMRHandler(this))), options.sourcemapInterceptor !== !1 && (this._resetSourceMapSupport = enableSourceMapSupport(this));
+class ESModulesEvaluator {
+  startOffset = getAsyncFunctionDeclarationPaddingLineCount();
+  async runInlinedModule(context, code) {
+    await new AsyncFunction(
+      ssrModuleExportsKey,
+      ssrImportMetaKey,
+      ssrImportKey,
+      ssrDynamicImportKey,
+      ssrExportAllKey,
+      // source map should already be inlined by Vite
+      '"use strict";' + code
+    )(
+      context[ssrModuleExportsKey],
+      context[ssrImportMetaKey],
+      context[ssrImportKey],
+      context[ssrDynamicImportKey],
+      context[ssrExportAllKey]
+    ), Object.seal(context[ssrModuleExportsKey]);
   }
-  /**
-   * Holds the cache of modules
-   * Keys of the map are ids
-   */
-  moduleCache;
+  runExternalModule(filepath) {
+    return import(filepath);
+  }
+}
+class ModuleRunner {
+  constructor(options, evaluator = new ESModulesEvaluator(), debug) {
+    if (this.options = options, this.evaluator = evaluator, this.debug = debug, this.evaluatedModules = options.evaluatedModules ?? new EvaluatedModules(), this.transport = normalizeModuleRunnerTransport(options.transport), options.hmr !== !1) {
+      const optionsHmr = options.hmr ?? !0, resolvedHmrLogger = optionsHmr === !0 || optionsHmr.logger === void 0 ? hmrLogger : optionsHmr.logger === !1 ? silentConsole : optionsHmr.logger;
+      if (this.hmrClient = new HMRClient(
+        resolvedHmrLogger,
+        this.transport,
+        ({ acceptedPath }) => this.import(acceptedPath)
+      ), !this.transport.connect)
+        throw new Error(
+          "HMR is not supported by this runner transport, but `hmr` option was set to true"
+        );
+      this.transport.connect(createHMRHandlerForRunner(this));
+    } else
+      this.transport.connect?.();
+    options.sourcemapInterceptor !== !1 && (this.resetSourceMapSupport = enableSourceMapSupport(this));
+  }
+  evaluatedModules;
   hmrClient;
-  entrypoints = /* @__PURE__ */ new Set();
-  idToUrlMap = /* @__PURE__ */ new Map();
-  fileToIdMap = /* @__PURE__ */ new Map();
   envProxy = new Proxy({}, {
     get(_, p) {
       throw new Error(
-        `[vite-runtime] Dynamic access of "import.meta.env" is not supported. Please, use "import.meta.env.${String(p)}" instead.`
+        `[module runner] Dynamic access of "import.meta.env" is not supported. Please, use "import.meta.env.${String(p)}" instead.`
       );
     }
   });
-  _destroyed = !1;
-  _resetSourceMapSupport;
+  transport;
+  resetSourceMapSupport;
+  concurrentModuleNodePromises = /* @__PURE__ */ new Map();
+  closed = !1;
   /**
    * URL to execute. Accepts file path, server path or id relative to the root.
    */
-  async executeUrl(url) {
-    url = this.normalizeEntryUrl(url);
+  async import(url) {
     const fetchedModule = await this.cachedModule(url);
     return await this.cachedRequest(url, fetchedModule);
   }
-  /**
-   * Entrypoint URL to execute. Accepts file path, server path or id relative to the root.
-   * In the case of a full reload triggered by HMR, this is the module that will be reloaded.
-   * If this method is called multiple times, all entrypoints will be reloaded one at a time.
-   */
-  async executeEntrypoint(url) {
-    url = this.normalizeEntryUrl(url);
-    const fetchedModule = await this.cachedModule(url);
-    return await this.cachedRequest(url, fetchedModule, [], {
-      entrypoint: !0
-    });
-  }
   /**
    * Clear all caches including HMR listeners.
    */
   clearCache() {
-    this.moduleCache.clear(), this.idToUrlMap.clear(), this.entrypoints.clear(), this.hmrClient?.clear();
+    this.evaluatedModules.clear(), this.hmrClient?.clear();
   }
   /**
    * Clears all caches, removes all HMR listeners, and resets source map support.
    * This method doesn't stop the HMR connection.
    */
-  async destroy() {
-    this._resetSourceMapSupport?.(), this.clearCache(), this.hmrClient = void 0, this._destroyed = !0;
+  async close() {
+    this.resetSourceMapSupport?.(), this.clearCache(), this.hmrClient = void 0, this.closed = !0, await this.transport.disconnect?.();
   }
   /**
-   * Returns `true` if the runtime has been destroyed by calling `destroy()` method.
+   * Returns `true` if the runtime has been closed by calling `close()` method.
    */
-  isDestroyed() {
-    return this._destroyed;
-  }
-  invalidateFiles(files) {
-    files.forEach((file) => {
-      const ids = this.fileToIdMap.get(file);
-      ids && ids.forEach((id) => this.moduleCache.invalidate(id));
-    });
-  }
-  // we don't use moduleCache.normalize because this URL doesn't have to follow the same rules
-  // this URL is something that user passes down manually, and is later resolved by fetchModule
-  // moduleCache.normalize is used on resolved "file" property
-  normalizeEntryUrl(url) {
-    if (url[0] === ".")
-      return url;
-    url.startsWith("file://") && (url = url.slice(isWindows ? 8 : 7)), url = slash(url);
-    const _root = this.options.root, root = _root[_root.length - 1] === "/" ? _root : `${_root}/`;
-    return url.startsWith(root) ? url.slice(root.length - 1) : url[0] === "/" ? url : wrapId(url);
+  isClosed() {
+    return this.closed;
   }
   processImport(exports, fetchResult, metadata) {
     if (!("externalize" in fetchResult))
       return exports;
-    const { id, type } = fetchResult;
-    return type !== "module" && type !== "commonjs" || analyzeImportedModDifference(exports, id, type, metadata), exports;
-  }
-  async cachedRequest(id, fetchedModule, callstack = [], metadata) {
-    const moduleId = fetchedModule.id;
-    metadata?.entrypoint && this.entrypoints.add(moduleId);
-    const mod = this.moduleCache.getByModuleId(moduleId), { imports, importers } = mod, importee = callstack[callstack.length - 1];
-    if (importee && importers.add(importee), (callstack.includes(moduleId) || Array.from(imports.values()).some((i) => importers.has(i))) && mod.exports)
-      return this.processImport(mod.exports, fetchedModule, metadata);
+    const { url, type } = fetchResult;
+    return type !== "module" && type !== "commonjs" || analyzeImportedModDifference(exports, url, type, metadata), exports;
+  }
+  isCircularModule(mod) {
+    for (const importedFile of mod.imports)
+      if (mod.importers.has(importedFile))
+        return !0;
+    return !1;
+  }
+  isCircularImport(importers, moduleUrl, visited = /* @__PURE__ */ new Set()) {
+    for (const importer of importers) {
+      if (visited.has(importer))
+        continue;
+      if (visited.add(importer), importer === moduleUrl)
+        return !0;
+      const mod = this.evaluatedModules.getModuleById(importer);
+      if (mod && mod.importers.size && this.isCircularImport(mod.importers, moduleUrl, visited))
+        return !0;
+    }
+    return !1;
+  }
+  async cachedRequest(url, mod, callstack = [], metadata) {
+    const meta = mod.meta, moduleId = meta.id, { importers } = mod, importee = callstack[callstack.length - 1];
+    if (importee && importers.add(importee), (callstack.includes(moduleId) || this.isCircularModule(mod) || this.isCircularImport(importers, moduleId)) && mod.exports)
+      return this.processImport(mod.exports, meta, metadata);
     let debugTimer;
     this.debug && (debugTimer = setTimeout(() => {
       const getStack = () => `stack:
 ${[...callstack, moduleId].reverse().map((p) => `  - ${p}`).join(`
 `)}`;
       this.debug(
-        `[vite-runtime] module ${moduleId} takes over 2s to load.
+        `[module runner] module ${moduleId} takes over 2s to load.
 ${getStack()}`
       );
     }, 2e3));
     try {
       if (mod.promise)
-        return this.processImport(await mod.promise, fetchedModule, metadata);
-      const promise = this.directRequest(id, fetchedModule, callstack);
-      return mod.promise = promise, mod.evaluated = !1, this.processImport(await promise, fetchedModule, metadata);
+        return this.processImport(await mod.promise, meta, metadata);
+      const promise = this.directRequest(url, mod, callstack);
+      return mod.promise = promise, mod.evaluated = !1, this.processImport(await promise, meta, metadata);
     } finally {
       mod.evaluated = !0, debugTimer && clearTimeout(debugTimer);
     }
   }
-  async cachedModule(id, importer) {
-    if (this._destroyed)
-      throw new Error("[vite] Vite runtime has been destroyed.");
-    const normalized = this.idToUrlMap.get(id);
-    if (normalized) {
-      const mod2 = this.moduleCache.getByModuleId(normalized);
-      if (mod2.meta)
-        return mod2.meta;
+  async cachedModule(url, importer) {
+    let cached = this.concurrentModuleNodePromises.get(url);
+    if (cached)
+      this.debug?.("[module runner] using cached module info for", url);
+    else {
+      const cachedModule = this.evaluatedModules.getModuleByUrl(url);
+      cached = this.getModuleInformation(url, importer, cachedModule).finally(
+        () => {
+          this.concurrentModuleNodePromises.delete(url);
+        }
+      ), this.concurrentModuleNodePromises.set(url, cached);
     }
-    this.debug?.("[vite-runtime] fetching", id);
-    const fetchedModule = id.startsWith("data:") ? { externalize: id, type: "builtin" } : await this.options.fetchModule(id, importer), idQuery = id.split("?")[1], query = idQuery ? `?${idQuery}` : "", file = "file" in fetchedModule ? fetchedModule.file : void 0, fullFile = file ? `${file}${query}` : id, moduleId = this.moduleCache.normalize(fullFile), mod = this.moduleCache.getByModuleId(moduleId);
-    if (fetchedModule.id = moduleId, mod.meta = fetchedModule, file) {
-      const fileModules = this.fileToIdMap.get(file) || [];
-      fileModules.push(moduleId), this.fileToIdMap.set(file, fileModules);
+    return cached;
+  }
+  async getModuleInformation(url, importer, cachedModule) {
+    if (this.closed)
+      throw new Error("Vite module runner has been closed.");
+    this.debug?.("[module runner] fetching", url);
+    const isCached = !!(typeof cachedModule == "object" && cachedModule.meta), fetchedModule = (
+      // fast return for established externalized pattern
+      url.startsWith("data:") ? { externalize: url, type: "builtin" } : await this.transport.invoke("fetchModule", [
+        url,
+        importer,
+        {
+          cached: isCached,
+          startOffset: this.evaluator.startOffset
+        }
+      ])
+    );
+    if ("cache" in fetchedModule) {
+      if (!cachedModule || !cachedModule.meta)
+        throw new Error(
+          `Module "${url}" was mistakenly invalidated during fetch phase.`
+        );
+      return cachedModule;
     }
-    return this.idToUrlMap.set(id, moduleId), this.idToUrlMap.set(unwrapId(id), moduleId), fetchedModule;
+    const moduleId = "externalize" in fetchedModule ? fetchedModule.externalize : fetchedModule.id, moduleUrl = "url" in fetchedModule ? fetchedModule.url : url, module = this.evaluatedModules.ensureModule(moduleId, moduleUrl);
+    return "invalidate" in fetchedModule && fetchedModule.invalidate && this.evaluatedModules.invalidateModule(module), fetchedModule.url = moduleUrl, fetchedModule.id = moduleId, module.meta = fetchedModule, module;
   }
   // override is allowed, consider this a public API
-  async directRequest(id, fetchResult, _callstack) {
-    const moduleId = fetchResult.id, callstack = [..._callstack, moduleId], mod = this.moduleCache.getByModuleId(moduleId), request = async (dep, metadata) => {
-      const fetchedModule = await this.cachedModule(dep, moduleId);
-      return this.moduleCache.getByModuleId(fetchedModule.id).importers.add(moduleId), mod.imports.add(fetchedModule.id), this.cachedRequest(dep, fetchedModule, callstack, metadata);
-    }, dynamicRequest = async (dep) => (dep = String(dep), dep[0] === "." && (dep = posixResolve(posixDirname(id), dep)), request(dep, { isDynamicImport: !0 }));
+  async directRequest(url, mod, _callstack) {
+    const fetchResult = mod.meta, moduleId = fetchResult.id, callstack = [..._callstack, moduleId], request = async (dep, metadata) => {
+      const importer = "file" in fetchResult && fetchResult.file || moduleId, depMod = await this.cachedModule(dep, importer);
+      return depMod.importers.add(moduleId), mod.imports.add(depMod.id), this.cachedRequest(dep, depMod, callstack, metadata);
+    }, dynamicRequest = async (dep) => (dep = String(dep), dep[0] === "." && (dep = posixResolve(posixDirname(url), dep)), request(dep, { isDynamicImport: !0 }));
     if ("externalize" in fetchResult) {
       const { externalize } = fetchResult;
-      this.debug?.("[vite-runtime] externalizing", externalize);
-      const exports2 = await this.runner.runExternalModule(externalize);
+      this.debug?.("[module runner] externalizing", externalize);
+      const exports2 = await this.evaluator.runExternalModule(externalize);
       return mod.exports = exports2, exports2;
     }
     const { code, file } = fetchResult;
     if (code == null) {
       const importer = callstack[callstack.length - 2];
       throw new Error(
-        `[vite-runtime] Failed to load "${id}"${importer ? ` imported from ${importer}` : ""}`
+        `[module runner] Failed to load "${url}"${importer ? ` imported from ${importer}` : ""}`
       );
     }
     const modulePath = cleanUrl(file || moduleId), href = posixPathToFileHref(modulePath), filename = modulePath, dirname2 = posixDirname(modulePath), meta = {
@@ -981,14 +1245,16 @@ ${getStack()}`
       dirname: isWindows ? toWindowsPath(dirname2) : dirname2,
       url: href,
       env: this.envProxy,
-      resolve(id2, parent) {
+      resolve(_id, _parent) {
         throw new Error(
-          '[vite-runtime] "import.meta.resolve" is not supported.'
+          '[module runner] "import.meta.resolve" is not supported.'
         );
       },
       // should be replaced during transformation
       glob() {
-        throw new Error('[vite-runtime] "import.meta.glob" is not supported.');
+        throw new Error(
+          '[module runner] "import.meta.glob" is statically replaced during file transformation. Make sure to reference it by the full name.'
+        );
       }
     }, exports = /* @__PURE__ */ Object.create(null);
     Object.defineProperty(exports, Symbol.toStringTag, {
@@ -1001,8 +1267,8 @@ ${getStack()}`
       enumerable: !0,
       get: () => {
         if (!this.hmrClient)
-          throw new Error("[vite-runtime] HMR client was destroyed.");
-        return this.debug?.("[vite-runtime] creating hmr context for", moduleId), hotContext ||= new HMRContext(this.hmrClient, moduleId), hotContext;
+          throw new Error("[module runner] HMR client was closed.");
+        return this.debug?.("[module runner] creating hmr context for", mod.url), hotContext ||= new HMRContext(this.hmrClient, mod.url), hotContext;
       },
       set: (value) => {
         hotContext = value;
@@ -1015,13 +1281,13 @@ ${getStack()}`
       [ssrExportAllKey]: (obj) => exportAll(exports, obj),
       [ssrImportMetaKey]: meta
     };
-    return this.debug?.("[vite-runtime] executing", href), await this.runner.runViteModule(context, code, id), exports;
+    return this.debug?.("[module runner] executing", href), await this.evaluator.runInlinedModule(context, code, mod), exports;
   }
 }
 function exportAll(exports, sourceModule) {
   if (exports !== sourceModule && !(isPrimitive(sourceModule) || Array.isArray(sourceModule) || sourceModule instanceof Promise)) {
     for (const key in sourceModule)
-      if (key !== "default" && key !== "__esModule")
+      if (key !== "default" && key !== "__esModule" && !(key in exports))
         try {
           Object.defineProperty(exports, key, {
             enumerable: !0,
@@ -1032,32 +1298,11 @@ function exportAll(exports, sourceModule) {
         }
   }
 }
-class ESModulesRunner {
-  async runViteModule(context, code) {
-    await new AsyncFunction(
-      ssrModuleExportsKey,
-      ssrImportMetaKey,
-      ssrImportKey,
-      ssrDynamicImportKey,
-      ssrExportAllKey,
-      // source map should already be inlined by Vite
-      '"use strict";' + code
-    )(
-      context[ssrModuleExportsKey],
-      context[ssrImportMetaKey],
-      context[ssrImportKey],
-      context[ssrDynamicImportKey],
-      context[ssrExportAllKey]
-    ), Object.seal(context[ssrModuleExportsKey]);
-  }
-  runExternalModule(filepath) {
-    return import(filepath);
-  }
-}
 export {
-  ESModulesRunner,
-  ModuleCacheMap,
-  ViteRuntime,
+  ESModulesEvaluator,
+  EvaluatedModules,
+  ModuleRunner,
+  createWebSocketModuleRunnerTransport,
   ssrDynamicImportKey,
   ssrExportAllKey,
   ssrImportKey,