vite 6.0.0-beta.0 → 6.0.0-beta.2

package/dist/node/module-runner.js

@@ -16,11 +16,12 @@ 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, asyncFunctionDeclarationPaddingLineCount = /* @__PURE__ */ (() => {
+  const body = "/*code*/", source = new AsyncFunction("a", "b", body).toString();
+  return source.slice(0, source.indexOf(body)).split(`
+`).length - 1;
+})(), _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
 function normalizeWindowsPath(input = "") {
   return input && input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
 }
@@ -236,94 +237,92 @@ function getOriginalPosition(map, needle) {
 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();
   /**
-   * Assign partial data to the 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
    */
-  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(),
-      timestamp: 0
-    }), mod;
-  }
-  get(fsPath) {
-    return this.getByModuleId(this.normalize(fsPath));
+  getModuleById(id) {
+    return this.idToModuleMap.get(id);
   }
-  deleteByModuleId(modulePath) {
-    return super.delete(modulePath);
-  }
-  delete(fsPath) {
-    return this.deleteByModuleId(this.normalize(fsPath));
-  }
-  invalidateUrl(id) {
-    const module = this.get(id);
-    this.invalidateModule(module);
-  }
-  invalidateModule(module) {
-    module.evaluated = !1, module.meta = void 0, module.map = void 0, module.promise = void 0, module.exports = void 0, module.imports?.clear();
+  /**
+   * 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
+   */
+  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), this.invalidateUrl(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;
   }
-  getSourceMap(moduleId) {
-    const mod = this.get(moduleId);
+  invalidateModule(node) {
+    node.evaluated = !1, node.meta = void 0, node.map = void 0, node.promise = void 0, node.exports = void 0, node.imports.clear();
+  }
+  /**
+   * 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 = MODULE_RUNNER_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;
+    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", "node:sqlite"]);
-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:\//, "/");
+function normalizeModuleId(file) {
+  return prefixedBuiltins.has(file) ? file : slash(file).replace(/^\/@fs\//, isWindows ? "" : "/").replace(/^node:/, "").replace(/^\/+/, "/").replace(/^file:\//, "/");
 }
 class HMRContext {
   constructor(hmrClient, ownerPath) {
@@ -403,9 +402,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.messenger.send({ type: "custom", event, data });
   }
   acceptDeps(deps, callback = () => {
   }) {
@@ -424,8 +421,8 @@ class HMRMessenger {
     this.connection = connection;
   }
   queue = [];
-  send(message) {
-    this.queue.push(message), this.flush();
+  send(payload) {
+    this.queue.push(payload), this.flush();
   }
   flush() {
     this.connection.isReady() && (this.queue.forEach((msg) => this.connection.send(msg)), this.queue = []);
@@ -558,14 +555,14 @@ async function handleHotPayload(runner, payload) {
         break;
       }
       case "full-reload": {
-        const { triggeredBy } = payload, clearEntrypoints = triggeredBy ? getModulesEntrypoints(
+        const { triggeredBy } = payload, clearEntrypointUrls = triggeredBy ? getModulesEntrypoints(
           runner,
           getModulesByFile(runner, slash(triggeredBy))
         ) : findAllEntrypoints(runner);
-        if (!clearEntrypoints.size) break;
-        hmrClient.logger.debug("program reload"), await hmrClient.notifyListeners("vite:beforeFullReload", payload), runner.moduleCache.clear();
-        for (const id of clearEntrypoints)
-          await runner.import(id);
+        if (!clearEntrypointUrls.size) break;
+        hmrClient.logger.debug("program reload"), await hmrClient.notifyListeners("vite:beforeFullReload", payload), runner.evaluatedModules.clear();
+        for (const url of clearEntrypointUrls)
+          await runner.import(url);
         break;
       }
       case "prune":
@@ -607,31 +604,31 @@ class Queue {
   }
 }
 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;
+  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.moduleCache.getByModuleId(moduleId);
-    if (module.importers && !module.importers.size) {
-      entrypoints.add(moduleId);
-      continue;
+    const module = runner.evaluatedModules.getModuleById(moduleId);
+    if (module) {
+      if (module.importers && !module.importers.size) {
+        entrypoints.add(module.url);
+        continue;
+      }
+      for (const importer of module.importers || [])
+        getModulesEntrypoints(runner, [importer], visited, entrypoints);
     }
-    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);
+  for (const mod of runner.evaluatedModules.idToModuleMap.values())
+    mod.importers && !mod.importers.size && entrypoints.add(mod.url);
   return entrypoints;
 }
-const sourceMapCache = {}, fileContentsCache = {}, moduleGraphs = /* @__PURE__ */ new Set(), retrieveFileHandlers = /* @__PURE__ */ new Set(), retrieveSourceMapHandlers = /* @__PURE__ */ new Set(), createExecHandlers = (handlers) => (...args) => {
+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;
@@ -643,10 +640,10 @@ const sourceMapCache = {}, fileContentsCache = {}, moduleGraphs = /* @__PURE__ *
 let overridden = !1;
 const originalPrepare = Error.prepareStackTrace;
 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);
+  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(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);
+  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;
@@ -656,8 +653,8 @@ function supportRelativeURL(file, url) {
   return protocol && /^\/\w:/.test(startPath) ? (protocol += "/", protocol + slash(posixResolve(startPath, url))) : protocol + posixResolve(startPath, url);
 }
 function getRunnerSourceMap(position) {
-  for (const moduleCache of moduleGraphs) {
-    const sourceMap = moduleCache.getSourceMap(position.source);
+  for (const moduleGraph of evaluatedModulesCache) {
+    const sourceMap = moduleGraph.getModuleSourceMapById(position.source);
     if (sourceMap)
       return {
         url: position.source,
@@ -848,20 +845,14 @@ 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.moduleCache = options.moduleCache ?? new ModuleCacheMap(options.root), this.transport = options.transport, typeof options.hmr == "object" && (this.hmrClient = new HMRClient(
+    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));
   }
-  /**
-   * Holds the cache of modules
-   * Keys of the map are ids
-   */
-  moduleCache;
+  evaluatedModules;
   hmrClient;
-  urlToIdMap = /* @__PURE__ */ new Map();
-  fileToIdMap = /* @__PURE__ */ new Map();
   envProxy = new Proxy({}, {
     get(_, p) {
       throw new Error(
@@ -872,7 +863,7 @@ class ModuleRunner {
   transport;
   resetSourceMapSupport;
   root;
-  moduleInfoCache = /* @__PURE__ */ new Map();
+  concurrentModuleNodePromises = /* @__PURE__ */ new Map();
   destroyed = !1;
   /**
    * URL to execute. Accepts file path, server path or id relative to the root.
@@ -885,7 +876,7 @@ class ModuleRunner {
    * Clear all caches including HMR listeners.
    */
   clearCache() {
-    this.moduleCache.clear(), this.urlToIdMap.clear(), this.hmrClient?.clear();
+    this.evaluatedModules.clear(), this.hmrClient?.clear();
   }
   /**
    * Clears all caches, removes all HMR listeners, and resets source map support.
@@ -903,8 +894,8 @@ class ModuleRunner {
   processImport(exports, fetchResult, metadata) {
     if (!("externalize" in fetchResult))
       return exports;
-    const { url: id, type } = fetchResult;
-    return type !== "module" && type !== "commonjs" || analyzeImportedModDifference(exports, id, type, metadata), exports;
+    const { url, type } = fetchResult;
+    return type !== "module" && type !== "commonjs" || analyzeImportedModDifference(exports, url, type, metadata), exports;
   }
   isCircularModule(mod) {
     for (const importedFile of mod.imports)
@@ -918,32 +909,30 @@ class ModuleRunner {
         continue;
       if (visited.add(importer), importer === moduleUrl)
         return !0;
-      const mod = this.moduleCache.getByModuleId(
-        importer
-      );
-      if (mod.importers.size && this.isCircularImport(mod.importers, moduleUrl, visited))
+      const mod = this.evaluatedModules.getModuleById(importer);
+      if (mod && mod.importers.size && this.isCircularImport(mod.importers, moduleUrl, visited))
         return !0;
     }
     return !1;
   }
-  async cachedRequest(id, mod_, callstack = [], metadata) {
-    const mod = mod_, meta = mod.meta, moduleUrl = meta.url, { importers } = mod, importee = callstack[callstack.length - 1];
-    if (importee && importers.add(importee), (callstack.includes(moduleUrl) || this.isCircularModule(mod) || this.isCircularImport(importers, moduleUrl)) && mod.exports)
+  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, moduleUrl].reverse().map((p) => `  - ${p}`).join(`
+${[...callstack, moduleId].reverse().map((p) => `  - ${p}`).join(`
 `)}`;
       this.debug(
-        `[module runner] module ${moduleUrl} 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, meta, metadata);
-      const promise = this.directRequest(id, mod, callstack);
+      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);
@@ -951,15 +940,18 @@ ${getStack()}`
   }
   async cachedModule(url, importer) {
     url = normalizeAbsoluteUrl(url, this.root);
-    const normalized = this.urlToIdMap.get(url);
-    let cachedModule = normalized && this.moduleCache.getByModuleId(normalized);
-    cachedModule || (cachedModule = this.moduleCache.getByModuleId(url));
-    let cached = this.moduleInfoCache.get(url);
-    return cached ? this.debug?.("[module runner] using cached module info for", url) : (cached = this.getModuleInformation(url, importer, cachedModule).finally(
-      () => {
-        this.moduleInfoCache.delete(url);
-      }
-    ), this.moduleInfoCache.set(url, cached)), cached;
+    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);
+    }
+    return cached;
   }
   async getModuleInformation(url, importer, cachedModule) {
     if (this.destroyed)
@@ -968,7 +960,8 @@ ${getStack()}`
     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
+        cached: isCached,
+        startOffset: this.evaluator.startOffset
       })
     );
     if ("cache" in fetchedModule) {
@@ -978,19 +971,15 @@ ${getStack()}`
         );
       return cachedModule;
     }
-    const idQuery = url.split("?")[1], query = idQuery ? `?${idQuery}` : "", file = "file" in fetchedModule ? fetchedModule.file : void 0, fileId = file ? `${file}${query}` : url, moduleUrl = this.moduleCache.normalize(fileId), mod = this.moduleCache.getByModuleId(moduleUrl);
-    if ("invalidate" in fetchedModule && fetchedModule.invalidate && this.moduleCache.invalidateModule(mod), fetchedModule.url = moduleUrl, mod.meta = fetchedModule, file) {
-      const fileModules = this.fileToIdMap.get(file) || [];
-      fileModules.push(moduleUrl), this.fileToIdMap.set(file, fileModules);
-    }
-    return this.urlToIdMap.set(url, moduleUrl), this.urlToIdMap.set(unwrapId(url), moduleUrl), mod;
+    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, mod, _callstack) {
-    const fetchResult = mod.meta, moduleUrl = fetchResult.url, callstack = [..._callstack, moduleUrl], request = async (dep, metadata) => {
-      const importer = "file" in fetchResult && fetchResult.file || moduleUrl, fetchedModule = await this.cachedModule(dep, importer), resolvedId = fetchedModule.meta.url;
-      return this.moduleCache.getByModuleId(resolvedId).importers.add(moduleUrl), mod.imports.add(resolvedId), 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?.("[module runner] externalizing", externalize);
@@ -1001,10 +990,10 @@ ${getStack()}`
     if (code == null) {
       const importer = callstack[callstack.length - 2];
       throw new Error(
-        `[module runner] Failed to load "${id}"${importer ? ` imported from ${importer}` : ""}`
+        `[module runner] Failed to load "${url}"${importer ? ` imported from ${importer}` : ""}`
       );
     }
-    const modulePath = cleanUrl(file || moduleUrl), href = posixPathToFileHref(modulePath), filename = modulePath, dirname2 = posixDirname(modulePath), meta = {
+    const modulePath = cleanUrl(file || moduleId), href = posixPathToFileHref(modulePath), filename = modulePath, dirname2 = posixDirname(modulePath), meta = {
       filename: isWindows ? toWindowsPath(filename) : filename,
       dirname: isWindows ? toWindowsPath(dirname2) : dirname2,
       url: href,
@@ -1016,7 +1005,9 @@ ${getStack()}`
       },
       // should be replaced during transformation
       glob() {
-        throw new Error('[module runner] "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, {
@@ -1030,7 +1021,7 @@ ${getStack()}`
       get: () => {
         if (!this.hmrClient)
           throw new Error("[module runner] HMR client was destroyed.");
-        return this.debug?.("[module runner] creating hmr context for", moduleUrl), hotContext ||= new HMRContext(this.hmrClient, moduleUrl), hotContext;
+        return this.debug?.("[module runner] creating hmr context for", mod.url), hotContext ||= new HMRContext(this.hmrClient, mod.url), hotContext;
       },
       set: (value) => {
         hotContext = value;
@@ -1043,7 +1034,7 @@ ${getStack()}`
       [ssrExportAllKey]: (obj) => exportAll(exports, obj),
       [ssrImportMetaKey]: meta
     };
-    return this.debug?.("[module runner] executing", href), await this.evaluator.runInlinedModule(context, code, id), exports;
+    return this.debug?.("[module runner] executing", href), await this.evaluator.runInlinedModule(context, code, mod), exports;
   }
 }
 function exportAll(exports, sourceModule) {
@@ -1061,6 +1052,7 @@ function exportAll(exports, sourceModule) {
   }
 }
 class ESModulesEvaluator {
+  startOffset = asyncFunctionDeclarationPaddingLineCount;
   async runInlinedModule(context, code) {
     await new AsyncFunction(
       ssrModuleExportsKey,
@@ -1122,7 +1114,7 @@ class RemoteRunnerTransport {
 }
 export {
   ESModulesEvaluator,
-  ModuleCacheMap,
+  EvaluatedModules,
   ModuleRunner,
   RemoteRunnerTransport,
   ssrDynamicImportKey,