vite 6.0.0-beta.7 → 6.0.0-beta.9

package/dist/node/index.js

@@ -1,6 +1,6 @@
 export { parseAst, parseAstAsync } from 'rollup/parseAst';
-import { i as isInNodeModules, a as arraify } from './chunks/dep-Vd7gFLqj.js';
-export { B as BuildEnvironment, D as DevEnvironment, S as ServerHMRConnector, b as build, j as buildErrorMessage, e as createBuilder, z as createFilter, f as createIdResolver, E as createLogger, k as createRunnableDevEnvironment, c as createServer, u as createServerHotChannel, q as createServerModuleRunner, d as defineConfig, n as fetchModule, g as formatPostcssSourceMap, H as isFileLoadingAllowed, G as isFileServingAllowed, m as isRunnableDevEnvironment, l as loadConfigFromFile, I as loadEnv, y as mergeAlias, x as mergeConfig, v as moduleRunnerTransform, w as normalizePath, o as optimizeDeps, h as preprocessCSS, p as preview, r as resolveConfig, J as resolveEnvPrefix, A as rollupVersion, F as searchForWorkspaceRoot, C as send, s as sortUserPlugins, t as transformWithEsbuild } from './chunks/dep-Vd7gFLqj.js';
+import { i as isInNodeModules, a as arraify } from './chunks/dep-CG5ueZZV.js';
+export { B as BuildEnvironment, D as DevEnvironment, b as build, j as buildErrorMessage, e as createBuilder, z as createFilter, f as createIdResolver, E as createLogger, k as createRunnableDevEnvironment, c as createServer, u as createServerHotChannel, q as createServerModuleRunner, d as defineConfig, n as fetchModule, g as formatPostcssSourceMap, H as isFileLoadingAllowed, G as isFileServingAllowed, m as isRunnableDevEnvironment, l as loadConfigFromFile, I as loadEnv, y as mergeAlias, x as mergeConfig, v as moduleRunnerTransform, w as normalizePath, o as optimizeDeps, h as preprocessCSS, p as preview, r as resolveConfig, J as resolveEnvPrefix, A as rollupVersion, F as searchForWorkspaceRoot, C as send, s as sortUserPlugins, t as transformWithEsbuild } from './chunks/dep-CG5ueZZV.js';
 export { VERSION as version } from './constants.js';
 export { version as esbuildVersion } from 'esbuild';
 import 'node:fs';
@@ -150,35 +150,4 @@ function splitVendorChunkPlugin() {
   };
 }
 
-class RemoteEnvironmentTransport {
-  constructor(options) {
-    this.options = options;
-  }
-  register(environment) {
-    this.options.onMessage(async (data) => {
-      if (typeof data !== "object" || !data || !data.__v) return;
-      const method = data.m;
-      const parameters = data.a;
-      try {
-        const result = await environment[method](...parameters);
-        this.options.send({
-          __v: true,
-          r: result,
-          i: data.i
-        });
-      } catch (error) {
-        this.options.send({
-          __v: true,
-          e: {
-            name: error.name,
-            message: error.message,
-            stack: error.stack
-          },
-          i: data.i
-        });
-      }
-    });
-  }
-}
-
-export { RemoteEnvironmentTransport, isCSSRequest, splitVendorChunk, splitVendorChunkPlugin };
+export { isCSSRequest, splitVendorChunk, splitVendorChunkPlugin };

package/dist/node/module-runner.d.ts

@@ -2,6 +2,89 @@ import { ModuleNamespace, ViteHotContext } from '../../types/hot.js';
 import { HotPayload, Update } from '../../types/hmrPayload.js';
 import { InferCustomEventPayload } from '../../types/customEvent.js';
 
+interface FetchFunctionOptions {
+    cached?: boolean;
+    startOffset?: number;
+}
+type FetchResult = CachedFetchResult | ExternalFetchResult | ViteFetchResult;
+interface CachedFetchResult {
+    /**
+     * If module cached in the runner, we can just confirm
+     * it wasn't invalidated on the server side.
+     */
+    cache: true;
+}
+interface ExternalFetchResult {
+    /**
+     * The path to the externalized module starting with file://,
+     * by default this will be imported via a dynamic "import"
+     * instead of being transformed by vite and loaded with vite runner
+     */
+    externalize: string;
+    /**
+     * Type of the module. Will be used to determine if import statement is correct.
+     * For example, if Vite needs to throw an error if variable is not actually exported
+     */
+    type: 'module' | 'commonjs' | 'builtin' | 'network';
+}
+interface ViteFetchResult {
+    /**
+     * Code that will be evaluated by vite runner
+     * by default this will be wrapped in an async function
+     */
+    code: string;
+    /**
+     * File path of the module on disk.
+     * This will be resolved as import.meta.url/filename
+     * Will be equal to `null` for virtual modules
+     */
+    file: string | null;
+    /**
+     * Module ID in the server module graph.
+     */
+    id: string;
+    /**
+     * Module URL used in the import.
+     */
+    url: string;
+    /**
+     * Invalidate module on the client side.
+     */
+    invalidate: boolean;
+}
+type InvokeMethods = {
+    fetchModule: (id: string, importer?: string, options?: FetchFunctionOptions) => Promise<FetchResult>;
+};
+
+type ModuleRunnerTransportHandlers = {
+    onMessage: (data: HotPayload) => void;
+    onDisconnection: () => void;
+};
+/**
+ * "send and connect" or "invoke" must be implemented
+ */
+interface ModuleRunnerTransport {
+    connect?(handlers: ModuleRunnerTransportHandlers): Promise<void> | void;
+    disconnect?(): Promise<void> | void;
+    send?(data: HotPayload): Promise<void> | void;
+    invoke?(data: HotPayload): Promise<{
+        r: any;
+    } | {
+        e: any;
+    }>;
+    timeout?: number;
+}
+interface NormalizedModuleRunnerTransport {
+    connect?(onMessage?: (data: HotPayload) => void): Promise<void> | void;
+    disconnect?(): Promise<void> | void;
+    send(data: HotPayload): void;
+    invoke<T extends keyof InvokeMethods>(name: T, data: Parameters<InvokeMethods[T]>): Promise<ReturnType<Awaited<InvokeMethods[T]>>>;
+}
+declare const createWebSocketModuleRunnerTransport: (options: {
+    createConnection: () => WebSocket;
+    pingInterval?: number;
+}) => Required<Pick<ModuleRunnerTransport, "connect" | "disconnect" | "send">>;
+
 interface SourceMapLike {
     version: number;
     mappings?: string;
@@ -39,25 +122,9 @@ interface HMRLogger {
     error(msg: string | Error): void;
     debug(...msg: unknown[]): void;
 }
-interface HMRConnection {
-    /**
-     * Checked before sending messages to the client.
-     */
-    isReady(): boolean;
-    /**
-     * Send message to the client.
-     */
-    send(messages: HotPayload): void;
-}
-declare class HMRMessenger {
-    private connection;
-    constructor(connection: HMRConnection);
-    private queue;
-    send(payload: HotPayload): void;
-    flush(): void;
-}
 declare class HMRClient {
     logger: HMRLogger;
+    private transport;
     private importUpdatedModule;
     hotModulesMap: Map<string, HotModule>;
     disposeMap: Map<string, (data: any) => void | Promise<void>>;
@@ -65,9 +132,9 @@ declare class HMRClient {
     dataMap: Map<string, any>;
     customListenersMap: CustomListenersMap;
     ctxToListenersMap: Map<string, CustomListenersMap>;
-    messenger: HMRMessenger;
-    constructor(logger: HMRLogger, connection: HMRConnection, importUpdatedModule: (update: Update) => Promise<ModuleNamespace>);
+    constructor(logger: HMRLogger, transport: NormalizedModuleRunnerTransport, importUpdatedModule: (update: Update) => Promise<ModuleNamespace>);
     notifyListeners<T extends string>(event: T, data: InferCustomEventPayload<T>): Promise<void>;
+    send(payload: HotPayload): void;
     clear(): void;
     prunePaths(paths: string[]): Promise<void>;
     protected warnFailedUpdate(err: Error, path: string | string[]): void;
@@ -160,28 +227,6 @@ interface InterceptorOptions {
     retrieveSourceMap?: RetrieveSourceMapHandler;
 }
 
-interface RunnerTransport {
-    fetchModule: FetchFunction;
-}
-declare class RemoteRunnerTransport implements RunnerTransport {
-    private readonly options;
-    private rpcPromises;
-    constructor(options: {
-        send: (data: any) => void;
-        onMessage: (handler: (data: any) => void) => void;
-        timeout?: number;
-    });
-    private resolve;
-    fetchModule(id: string, importer?: string): Promise<FetchResult>;
-}
-
-interface ModuleRunnerHMRConnection extends HMRConnection {
-    /**
-     * Configure how HMR is handled when this connection triggers an update.
-     * This method expects that connection will start listening for HMR updates and call this callback when it's received.
-     */
-    onUpdate(callback: (payload: HotPayload) => void): void;
-}
 interface ModuleRunnerImportMeta extends ImportMeta {
     url: string;
     env: ImportMetaEnv;
@@ -213,66 +258,12 @@ interface ModuleEvaluator {
      */
     runExternalModule(file: string): Promise<any>;
 }
-type FetchResult = CachedFetchResult | ExternalFetchResult | ViteFetchResult;
-interface CachedFetchResult {
-    /**
-     * If module cached in the runner, we can just confirm
-     * it wasn't invalidated on the server side.
-     */
-    cache: true;
-}
-interface ExternalFetchResult {
-    /**
-     * The path to the externalized module starting with file://,
-     * by default this will be imported via a dynamic "import"
-     * instead of being transformed by vite and loaded with vite runner
-     */
-    externalize: string;
-    /**
-     * Type of the module. Will be used to determine if import statement is correct.
-     * For example, if Vite needs to throw an error if variable is not actually exported
-     */
-    type: 'module' | 'commonjs' | 'builtin' | 'network';
-}
-interface ViteFetchResult {
-    /**
-     * Code that will be evaluated by vite runner
-     * by default this will be wrapped in an async function
-     */
-    code: string;
-    /**
-     * File path of the module on disk.
-     * This will be resolved as import.meta.url/filename
-     * Will be equal to `null` for virtual modules
-     */
-    file: string | null;
-    /**
-     * Module ID in the server module graph.
-     */
-    id: string;
-    /**
-     * Module URL used in the import.
-     */
-    url: string;
-    /**
-     * Invalidate module on the client side.
-     */
-    invalidate: boolean;
-}
 type ResolvedResult = (ExternalFetchResult | ViteFetchResult) & {
     url: string;
     id: string;
 };
 type FetchFunction = (id: string, importer?: string, options?: FetchFunctionOptions) => Promise<FetchResult>;
-interface FetchFunctionOptions {
-    cached?: boolean;
-    startOffset?: number;
-}
 interface ModuleRunnerHmr {
-    /**
-     * Configure how HMR communicates between the client and the server.
-     */
-    connection: ModuleRunnerHMRConnection;
     /**
      * Configure HMR logger.
      */
@@ -286,7 +277,7 @@ interface ModuleRunnerOptions {
     /**
      * A set of methods to communicate with the server.
      */
-    transport: RunnerTransport;
+    transport: ModuleRunnerTransport;
     /**
      * Configure how source maps are resolved. Prefers `node` if `process.setSourceMapsEnabled` is available.
      * Otherwise it will use `prepareStackTrace` by default which overrides `Error.prepareStackTrace` method.
@@ -296,7 +287,7 @@ interface ModuleRunnerOptions {
     /**
      * Disable HMR or configure HMR options.
      */
-    hmr?: false | ModuleRunnerHmr;
+    hmr?: boolean | ModuleRunnerHmr;
     /**
      * Custom module cache. If not provided, creates a separate module cache for each ModuleRunner instance.
      */
@@ -373,4 +364,4 @@ declare class ESModulesEvaluator implements ModuleEvaluator {
     runExternalModule(filepath: string): Promise<any>;
 }
 
-export { ESModulesEvaluator, EvaluatedModuleNode, EvaluatedModules, type FetchFunction, type FetchFunctionOptions, type FetchResult, type HMRConnection, type HMRLogger, type ModuleEvaluator, ModuleRunner, type ModuleRunnerContext, type ModuleRunnerHMRConnection, type ModuleRunnerHmr, type ModuleRunnerImportMeta, type ModuleRunnerOptions, RemoteRunnerTransport, type ResolvedResult, type RunnerTransport, type SSRImportMetadata, ssrDynamicImportKey, ssrExportAllKey, ssrImportKey, ssrImportMetaKey, ssrModuleExportsKey };
+export { ESModulesEvaluator, EvaluatedModuleNode, EvaluatedModules, type FetchFunction, type FetchFunctionOptions, type FetchResult, type HMRLogger, type ModuleEvaluator, ModuleRunner, type ModuleRunnerContext, type ModuleRunnerHmr, type ModuleRunnerImportMeta, type ModuleRunnerOptions, type ModuleRunnerTransport, type ModuleRunnerTransportHandlers, type ResolvedResult, type SSRImportMetadata, createWebSocketModuleRunnerTransport, ssrDynamicImportKey, ssrExportAllKey, ssrImportKey, ssrImportMetaKey, ssrModuleExportsKey };

package/dist/node/module-runner.js

@@ -27,6 +27,12 @@ function getAsyncFunctionDeclarationPaddingLineCount() {
   }
   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());
@@ -408,7 +414,7 @@ class HMRContext {
     removeFromMap(this.hmrClient.customListenersMap), removeFromMap(this.newListeners);
   }
   send(event, data) {
-    this.hmrClient.messenger.send({ type: "custom", event, data });
+    this.hmrClient.send({ type: "custom", event, data });
   }
   acceptDeps(deps, callback = () => {
   }) {
@@ -422,21 +428,9 @@ class HMRContext {
     }), this.hmrClient.hotModulesMap.set(this.ownerPath, mod);
   }
 }
-class HMRMessenger {
-  constructor(connection) {
-    this.connection = connection;
-  }
-  queue = [];
-  send(payload) {
-    this.queue.push(payload), 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();
@@ -444,11 +438,13 @@ class HMRClient {
   dataMap = /* @__PURE__ */ new Map();
   customListenersMap = /* @__PURE__ */ new Map();
   ctxToListenersMap = /* @__PURE__ */ new Map();
-  messenger;
   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);
+  }
   clear() {
     this.hotModulesMap.clear(), this.disposeMap.clear(), this.pruneMap.clear(), this.dataMap.clear(), this.customListenersMap.clear(), this.ctxToListenersMap.clear();
   }
@@ -528,7 +524,181 @@ 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 = () => {
+let urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict", nanoid = (size = 21) => {
+  let id = "", i = size;
+  for (; i--; )
+    id += urlAlphabet[Math.random() * 64 | 0];
+  return id;
+};
+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 ("e" in result)
+          throw result.e;
+        return result.r;
+      }
+    };
+  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 { e, r } = data.data;
+              e ? promise.reject(e) : promise.resolve(r);
+              return;
+            }
+          }
+          onMessage(payload);
+        },
+        onDisconnection
+      });
+    },
+    disconnect() {
+      return rpcPromises.forEach((promise) => {
+        promise.reject(
+          new Error(
+            `transport was disconnected, cannot call ${JSON.stringify(promise.name)}`
+          )
+        );
+      }), 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;
+      return 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);
+      }), await promise;
+    }
+  };
+}, 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());
+      }
+    } : {},
+    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
@@ -545,7 +715,7 @@ async function handleHotPayload(runner, payload) {
   if (!(!hmrClient || runner.isClosed()))
     switch (payload.type) {
       case "connected":
-        hmrClient.logger.debug("connected."), hmrClient.messenger.flush();
+        hmrClient.logger.debug("connected.");
         break;
       case "update":
         await hmrClient.notifyListeners("vite:beforeUpdate", payload), await Promise.all(
@@ -584,6 +754,8 @@ ${err.stack}`
         );
         break;
       }
+      case "ping":
+        break;
       default:
         return payload;
     }
@@ -851,11 +1023,20 @@ class ModuleRunner {
   constructor(options, evaluator, debug) {
     this.options = options, this.evaluator = evaluator, this.debug = debug;
     const root = this.options.root;
-    this.root = root[root.length - 1] === "/" ? root : `${root}/`, this.evaluatedModules = options.evaluatedModules ?? new EvaluatedModules(), this.transport = options.transport, typeof options.hmr == "object" && (this.hmrClient = new HMRClient(
-      options.hmr.logger === !1 ? silentConsole : options.hmr.logger || hmrLogger,
-      options.hmr.connection,
-      ({ acceptedPath }) => this.import(acceptedPath)
-    ), options.hmr.connection.onUpdate(createHMRHandler(this))), options.sourcemapInterceptor !== !1 && (this.resetSourceMapSupport = enableSourceMapSupport(this));
+    if (this.root = root[root.length - 1] === "/" ? root : `${root}/`, this.evaluatedModules = options.evaluatedModules ?? new EvaluatedModules(), this.transport = normalizeModuleRunnerTransport(options.transport), options.hmr) {
+      const resolvedHmrLogger = options.hmr === !0 || options.hmr.logger === void 0 ? hmrLogger : options.hmr.logger === !1 ? silentConsole : options.hmr.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(createHMRHandler(this));
+    } else
+      this.transport.connect?.();
+    options.sourcemapInterceptor !== !1 && (this.resetSourceMapSupport = enableSourceMapSupport(this));
   }
   evaluatedModules;
   hmrClient;
@@ -889,7 +1070,7 @@ class ModuleRunner {
    * This method doesn't stop the HMR connection.
    */
   async close() {
-    this.resetSourceMapSupport?.(), this.clearCache(), this.hmrClient = void 0, this.closed = !0;
+    this.resetSourceMapSupport?.(), this.clearCache(), this.hmrClient = void 0, this.closed = !0, await this.transport.disconnect?.();
   }
   /**
    * Returns `true` if the runtime has been closed by calling `close()` method.
@@ -965,10 +1146,14 @@ ${getStack()}`
     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.fetchModule(url, importer, {
-        cached: isCached,
-        startOffset: this.evaluator.startOffset
-      })
+      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)
@@ -1080,49 +1265,11 @@ class ESModulesEvaluator {
     return import(filepath);
   }
 }
-let urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict", nanoid = (size = 21) => {
-  let id = "", i = size;
-  for (; i--; )
-    id += urlAlphabet[Math.random() * 64 | 0];
-  return id;
-};
-class RemoteRunnerTransport {
-  constructor(options) {
-    this.options = options, this.options.onMessage(async (data) => {
-      if (typeof data != "object" || !data || !data.__v) return;
-      const promise = this.rpcPromises.get(data.i);
-      promise && (promise.timeoutId && clearTimeout(promise.timeoutId), this.rpcPromises.delete(data.i), data.e ? promise.reject(data.e) : promise.resolve(data.r));
-    });
-  }
-  rpcPromises = /* @__PURE__ */ new Map();
-  resolve(method, ...args) {
-    const promiseId = nanoid();
-    return this.options.send({
-      __v: !0,
-      m: method,
-      a: args,
-      i: promiseId
-    }), new Promise((resolve2, reject) => {
-      const timeout = this.options.timeout ?? 6e4;
-      let timeoutId;
-      timeout > 0 && (timeoutId = setTimeout(() => {
-        this.rpcPromises.delete(promiseId), reject(
-          new Error(
-            `${method}(${args.map((arg) => JSON.stringify(arg)).join(", ")}) timed out after ${timeout}ms`
-          )
-        );
-      }, timeout), timeoutId?.unref?.()), this.rpcPromises.set(promiseId, { resolve: resolve2, reject, timeoutId });
-    });
-  }
-  fetchModule(id, importer) {
-    return this.resolve("fetchModule", id, importer);
-  }
-}
 export {
   ESModulesEvaluator,
   EvaluatedModules,
   ModuleRunner,
-  RemoteRunnerTransport,
+  createWebSocketModuleRunnerTransport,
   ssrDynamicImportKey,
   ssrExportAllKey,
   ssrImportKey,

package/dist/node-cjs/publicUtils.cjs

@@ -3547,10 +3547,8 @@ function loadPackageData(pkgPath) {
 function getResolveCacheKey(key, options) {
   return [
     key,
-    options.webCompatible ? "1" : "0",
     options.isRequire ? "1" : "0",
     options.conditions.join("_"),
-    options.overrideConditions?.join("_") || "",
     options.extensions.join("_"),
     options.mainFields.join("_")
   ].join("|");
@@ -3569,7 +3567,7 @@ const DEBUG = process.env.DEBUG;
 function createDebugger(namespace, options = {}) {
   const log = debug$2(namespace);
   const { onlyWhenFocused, depth } = options;
-  if (depth && log.inspectOpts.depth == null) {
+  if (depth && log.inspectOpts && log.inspectOpts.depth == null) {
     log.inspectOpts.depth = options.depth;
   }
   let enabled = log.enabled;