vite 5.2.7 → 6.0.0-alpha.0

package/dist/node/{runtime.js → module-runner.js}

@@ -225,7 +225,7 @@ function getOriginalPosition(map, needle) {
   const result = originalPositionFor(map, needle);
   return result.column == null ? null : result;
 }
-const VITE_RUNTIME_SOURCEMAPPING_REGEXP = new RegExp(`//# ${SOURCEMAPPING_URL}=data:application/json;base64,(.+)`);
+const MODULE_RUNNER_SOURCEMAPPING_REGEXP = new RegExp(`//# ${SOURCEMAPPING_URL}=data:application/json;base64,(.+)`);
 class ModuleCacheMap extends Map {
   root;
   constructor(root, entries) {
@@ -267,25 +267,6 @@ class ModuleCacheMap extends Map {
     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;
-  }
   /**
    * Invalidate modules that dependent on the given modules, up to the main entry
    */
@@ -296,7 +277,7 @@ class ModuleCacheMap extends Map {
         continue;
       invalidated.add(id);
       const mod = super.get(id);
-      mod?.importers && this.invalidateDepTree(mod.importers, invalidated), super.delete(id);
+      mod?.importers && this.invalidateDepTree(mod.importers, invalidated), this.invalidate(id);
     }
     return invalidated;
   }
@@ -320,7 +301,7 @@ class ModuleCacheMap extends Map {
       return mod.map;
     if (!mod.meta || !("code" in mod.meta))
       return null;
-    const mapString = mod.meta.code.match(VITE_RUNTIME_SOURCEMAPPING_REGEXP)?.[1];
+    const mapString = mod.meta.code.match(MODULE_RUNNER_SOURCEMAPPING_REGEXP)?.[1];
     if (!mapString)
       return null;
     const baseFile = mod.meta.file || moduleId.split("?")[0];
@@ -382,7 +363,10 @@ class HMRContext {
     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}` : ""}`);
+    }), this.send("vite:invalidate", {
+      path: this.ownerPath,
+      message
+    }), this.hmrClient.logger.debug(`[vite] invalidate ${this.ownerPath}${message ? `: ${message}` : ""}`);
   }
   on(event, cb) {
     const addToMap = (map) => {
@@ -534,13 +518,13 @@ const ssrModuleExportsKey = "__vite_ssr_exports__", ssrImportKey = "__vite_ssr_i
   debug: noop,
   error: noop
 };
-function createHMRHandler(runtime) {
+function createHMRHandler(runner) {
   const queue = new Queue();
-  return (payload) => queue.enqueue(() => handleHMRPayload(runtime, payload));
+  return (payload) => queue.enqueue(() => handleHMRPayload(runner, payload));
 }
-async function handleHMRPayload(runtime, payload) {
-  const hmrClient = runtime.hmrClient;
-  if (!(!hmrClient || runtime.isDestroyed()))
+async function handleHMRPayload(runner, payload) {
+  const hmrClient = runner.hmrClient;
+  if (!(!hmrClient || runner.isDestroyed()))
     switch (payload.type) {
       case "connected":
         hmrClient.logger.debug("[vite] connected."), hmrClient.messenger.flush();
@@ -549,7 +533,7 @@ async function handleHMRPayload(runtime, payload) {
         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.");
+          hmrClient.logger.error("[vite] css hmr is not supported in runner mode.");
         })), await hmrClient.notifyListeners("vite:afterUpdate", payload);
         break;
       case "custom": {
@@ -557,15 +541,12 @@ async function handleHMRPayload(runtime, payload) {
         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)
+        const { triggeredBy } = payload, clearEntrypoints = triggeredBy ? getModulesEntrypoints(runner, getModulesByFile(runner, slash(triggeredBy))) : findAllEntrypoints(runner);
+        if (!clearEntrypoints.size)
           break;
-        hmrClient.logger.debug("[vite] program reload"), await hmrClient.notifyListeners("vite:beforeFullReload", payload), runtime.moduleCache.clear();
+        hmrClient.logger.debug("[vite] program reload"), await hmrClient.notifyListeners("vite:beforeFullReload", payload), runner.moduleCache.clear();
         for (const id of clearEntrypoints)
-          await runtime.executeUrl(id);
+          await runner.import(id);
         break;
       }
       case "prune":
@@ -604,6 +585,32 @@ class Queue {
     }), !0) : !1;
   }
 }
+function getModulesByFile(runner, file) {
+  const modules = [];
+  for (const [id, mod] of runner.moduleCache.entries())
+    mod.meta && "file" in mod.meta && mod.meta.file === file && modules.push(id);
+  return modules;
+}
+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.moduleCache.getByModuleId(moduleId);
+    if (module.importers && !module.importers.size) {
+      entrypoints.add(moduleId);
+      continue;
+    }
+    for (const importer of module.importers || [])
+      getModulesEntrypoints(runner, [importer], visited, entrypoints);
+  }
+  return entrypoints;
+}
+function findAllEntrypoints(runner, entrypoints = /* @__PURE__ */ new Set()) {
+  for (const [id, mod] of runner.moduleCache.entries())
+    mod.importers && !mod.importers.size && entrypoints.add(id);
+  return entrypoints;
+}
 const sourceMapCache = {}, fileContentsCache = {}, moduleGraphs = /* @__PURE__ */ new Set(), retrieveFileHandlers = /* @__PURE__ */ new Set(), retrieveSourceMapHandlers = /* @__PURE__ */ new Set(), createExecHandlers = (handlers) => (...args) => {
   for (const handler of handlers) {
     const result = handler(...args);
@@ -614,11 +621,11 @@ const sourceMapCache = {}, fileContentsCache = {}, moduleGraphs = /* @__PURE__ *
 }, retrieveFileFromHandlers = createExecHandlers(retrieveFileHandlers), retrieveSourceMapFromHandlers = createExecHandlers(retrieveSourceMapHandlers);
 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) {
+  moduleGraphs.delete(runner.moduleCache), options.retrieveFile && retrieveFileHandlers.delete(options.retrieveFile), options.retrieveSourceMap && retrieveSourceMapHandlers.delete(options.retrieveSourceMap), moduleGraphs.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), moduleGraphs.add(runner.moduleCache), options.retrieveFile && retrieveFileHandlers.add(options.retrieveFile), options.retrieveSourceMap && retrieveSourceMapHandlers.add(options.retrieveSourceMap), () => resetInterceptor(runner, options);
 }
 function supportRelativeURL(file, url) {
   if (!file)
@@ -628,7 +635,7 @@ 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) {
+function getRunnerSourceMap(position) {
   for (const moduleCache of moduleGraphs) {
     const sourceMap = moduleCache.getSourceMap(position.source);
     if (sourceMap)
@@ -678,7 +685,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) {
@@ -798,8 +805,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.`);
     if (typeof process.setSourceMapsEnabled != "function")
@@ -807,11 +814,11 @@ function enableSourceMapSupport(runtime) {
     const isEnabledAlready = process.sourceMapsEnabled ?? !1;
     return process.setSourceMapsEnabled(!0), () => !isEnabledAlready && process.setSourceMapsEnabled(!1);
   }
-  return interceptStackTrace(runtime, typeof runtime.options.sourcemapInterceptor == "object" ? runtime.options.sourcemapInterceptor : void 0);
+  return interceptStackTrace(runner, typeof runner.options.sourcemapInterceptor == "object" ? runner.options.sourcemapInterceptor : void 0);
 }
-class ViteRuntime {
+class ModuleRunner {
   options;
-  runner;
+  evaluator;
   debug;
   /**
    * Holds the cache of modules
@@ -819,44 +826,32 @@ class ViteRuntime {
    */
   moduleCache;
   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.`);
+      throw new Error(`[module runner] Dynamic access of "import.meta.env" is not supported. Please, use "import.meta.env.${String(p)}" instead.`);
     }
   });
+  transport;
   _destroyed = !1;
   _resetSourceMapSupport;
-  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));
+  constructor(options, evaluator, debug) {
+    this.options = options, this.evaluator = evaluator, this.debug = debug, this.moduleCache = options.moduleCache ?? new ModuleCacheMap(options.root), this.transport = options.transport, typeof options.hmr == "object" && (this.hmrClient = new HMRClient(options.hmr.logger === !1 ? silentConsole : options.hmr.logger || console, options.hmr.connection, ({ acceptedPath, invalidates }) => (this.moduleCache.invalidate(acceptedPath), invalidates && this.invalidateFiles(invalidates), this.import(acceptedPath))), options.hmr.connection.onUpdate(createHMRHandler(this))), options.sourcemapInterceptor !== !1 && (this._resetSourceMapSupport = enableSourceMapSupport(this));
   }
   /**
    * URL to execute. Accepts file path, server path or id relative to the root.
    */
-  async executeUrl(url) {
+  async import(url) {
     url = this.normalizeEntryUrl(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.moduleCache.clear(), this.idToUrlMap.clear(), this.hmrClient?.clear();
   }
   /**
    * Clears all caches, removes all HMR listeners, and resets source map support.
@@ -871,6 +866,7 @@ class ViteRuntime {
   isDestroyed() {
     return this._destroyed;
   }
+  // map files to modules and invalidate them
   invalidateFiles(files) {
     files.forEach((file) => {
       const ids = this.fileToIdMap.get(file);
@@ -894,9 +890,7 @@ class ViteRuntime {
     return type !== "module" && type !== "commonjs" ? exports : (analyzeImportedModDifference(exports, id, type, metadata), proxyGuardOnlyEsm(exports, id, metadata));
   }
   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];
+    const moduleId = fetchedModule.id, 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);
     let debugTimer;
@@ -904,7 +898,7 @@ class ViteRuntime {
       const getStack = () => `stack:
 ${[...callstack, moduleId].reverse().map((p) => `  - ${p}`).join(`
 `)}`;
-      this.debug(`[vite-runtime] module ${moduleId} takes over 2s to load.
+      this.debug(`[module runner] module ${moduleId} takes over 2s to load.
 ${getStack()}`);
     }, 2e3));
     try {
@@ -925,8 +919,8 @@ ${getStack()}`);
       if (mod2.meta)
         return mod2.meta;
     }
-    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);
+    this.debug?.("[module runner] fetching", id);
+    const fetchedModule = id.startsWith("data:") ? { externalize: id, type: "builtin" } : await this.transport.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);
@@ -941,14 +935,14 @@ ${getStack()}`);
     }, dynamicRequest = async (dep) => (dep = String(dep), dep[0] === "." && (dep = posixResolve(posixDirname(id), 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}` : ""}`);
+      throw new Error(`[module runner] Failed to load "${id}"${importer ? ` imported from ${importer}` : ""}`);
     }
     const modulePath = cleanUrl(file || moduleId), href = posixPathToFileHref(modulePath), filename = modulePath, dirname2 = posixDirname(modulePath), meta = {
       filename: isWindows ? toWindowsPath(filename) : filename,
@@ -956,11 +950,11 @@ ${getStack()}`);
       url: href,
       env: this.envProxy,
       resolve(id2, parent) {
-        throw new Error('[vite-runtime] "import.meta.resolve" is not supported.');
+        throw new Error('[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 not supported.');
       }
     }, exports = /* @__PURE__ */ Object.create(null);
     Object.defineProperty(exports, Symbol.toStringTag, {
@@ -973,8 +967,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 destroyed.");
+        return this.debug?.("[module runner] creating hmr context for", moduleId), hotContext ||= new HMRContext(this.hmrClient, moduleId), hotContext;
       },
       set: (value) => {
         hotContext = value;
@@ -987,7 +981,7 @@ ${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, id), exports;
   }
 }
 function exportAll(exports, sourceModule) {
@@ -1004,8 +998,8 @@ function exportAll(exports, sourceModule) {
         }
   }
 }
-class ESModulesRunner {
-  async runViteModule(context, code) {
+class ESModulesEvaluator {
+  async runInlinedModule(context, code) {
     await new AsyncFunction(
       ssrModuleExportsKey,
       ssrImportMetaKey,
@@ -1020,10 +1014,48 @@ class ESModulesRunner {
     return import(filepath);
   }
 }
+class RemoteRunnerTransport {
+  options;
+  rpcPromises = /* @__PURE__ */ new Map();
+  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));
+    });
+  }
+  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);
+  }
+}
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function nanoid(size = 21) {
+  let id = "", i = size;
+  for (; i--; )
+    id += urlAlphabet[Math.random() * 64 | 0];
+  return id;
+}
 export {
-  ESModulesRunner,
+  ESModulesEvaluator,
   ModuleCacheMap,
-  ViteRuntime,
+  ModuleRunner,
+  RemoteRunnerTransport,
   ssrDynamicImportKey,
   ssrExportAllKey,
   ssrImportKey,

package/dist/node-cjs/publicUtils.cjs

@@ -3510,7 +3510,7 @@ function mergeConfigRecursively(defaults, overrides, rootPath) {
             merged[key] = [].concat(existing, value);
             continue;
         }
-        else if (key === 'noExternal' &&
+        else if (key === 'noExternal' && // TODO: environments
             rootPath === 'ssr' &&
             (existing === true || value === true)) {
             merged[key] = true;
@@ -5567,7 +5567,7 @@ function isFileServingAllowed(url, server) {
     const file = fsPathFromUrl(url);
     if (server._fsDenyGlob(file))
         return false;
-    if (server.moduleGraph.safeModulesPath.has(file))
+    if (server._safeModulesPath.has(file))
         return true;
     if (server.config.server.fs.allow.some((uri) => isSameFileUri(uri, file) || isParentDirectory(uri, file)))
         return true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite",
-  "version": "5.2.7",
+  "version": "6.0.0-alpha.0",
   "type": "module",
   "license": "MIT",
   "author": "Evan You",
@@ -32,9 +32,9 @@
     "./client": {
       "types": "./client.d.ts"
     },
-    "./runtime": {
-      "types": "./dist/node/runtime.d.ts",
-      "import": "./dist/node/runtime.js"
+    "./module-runner": {
+      "types": "./dist/node/module-runner.d.ts",
+      "import": "./dist/node/module-runner.js"
     },
     "./dist/client/*": "./dist/client/*",
     "./types/*": {
@@ -44,8 +44,8 @@
   },
   "typesVersions": {
     "*": {
-      "runtime": [
-        "dist/node/runtime.d.ts"
+      "module-runner": [
+        "dist/node/module-runner.d.ts"
       ]
     }
   },

package/types/hmrPayload.d.ts

@@ -25,7 +25,7 @@ export interface Update {
   /** @internal */
   isWithinCircularImport?: boolean
   /** @internal */
-  ssrInvalidates?: string[]
+  invalidates?: string[]
 }
 
 export interface PrunePayload {

package/dist/node/runtime.d.ts

@@ -1,63 +0,0 @@
-import { V as ViteRuntimeOptions, b as ViteModuleRunner, M as ModuleCacheMap, c as HMRClient, R as ResolvedResult, d as ViteRuntimeModuleContext } from './types.d-aGj9QkWt.js';
-export { a as FetchFunction, F as FetchResult, e as HMRConnection, H as HMRLogger, g as HMRRuntimeConnection, f as ModuleCache, S as SSRImportMetadata, h as ViteRuntimeImportMeta, s as ssrDynamicImportKey, i as ssrExportAllKey, j as ssrImportKey, k as ssrImportMetaKey, l as ssrModuleExportsKey } from './types.d-aGj9QkWt.js';
-import '../../types/hot.js';
-import '../../types/hmrPayload.js';
-import '../../types/customEvent.js';
-
-interface ViteRuntimeDebugger {
-    (formatter: unknown, ...args: unknown[]): void;
-}
-declare class ViteRuntime {
-    options: ViteRuntimeOptions;
-    runner: ViteModuleRunner;
-    private debug?;
-    /**
-     * Holds the cache of modules
-     * Keys of the map are ids
-     */
-    moduleCache: ModuleCacheMap;
-    hmrClient?: HMRClient;
-    entrypoints: Set<string>;
-    private idToUrlMap;
-    private fileToIdMap;
-    private envProxy;
-    private _destroyed;
-    private _resetSourceMapSupport?;
-    constructor(options: ViteRuntimeOptions, runner: ViteModuleRunner, debug?: ViteRuntimeDebugger | undefined);
-    /**
-     * URL to execute. Accepts file path, server path or id relative to the root.
-     */
-    executeUrl<T = any>(url: string): Promise<T>;
-    /**
-     * 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.
-     */
-    executeEntrypoint<T = any>(url: string): Promise<T>;
-    /**
-     * Clear all caches including HMR listeners.
-     */
-    clearCache(): void;
-    /**
-     * Clears all caches, removes all HMR listeners, and resets source map support.
-     * This method doesn't stop the HMR connection.
-     */
-    destroy(): Promise<void>;
-    /**
-     * Returns `true` if the runtime has been destroyed by calling `destroy()` method.
-     */
-    isDestroyed(): boolean;
-    private invalidateFiles;
-    private normalizeEntryUrl;
-    private processImport;
-    private cachedRequest;
-    private cachedModule;
-    protected directRequest(id: string, fetchResult: ResolvedResult, _callstack: string[]): Promise<any>;
-}
-
-declare class ESModulesRunner implements ViteModuleRunner {
-    runViteModule(context: ViteRuntimeModuleContext, code: string): Promise<any>;
-    runExternalModule(filepath: string): Promise<any>;
-}
-
-export { ESModulesRunner, ModuleCacheMap, ResolvedResult, ViteModuleRunner, ViteRuntime, ViteRuntimeModuleContext, ViteRuntimeOptions };