@voidzero-dev/vite-plus-test 0.1.9 → 0.1.10

package/dist/chunks/{startModuleRunner.DEj0jb3e.js → startVitestModuleRunner.C3ZR-4J3.js}

@@ -1,249 +1,29 @@
 import fs from 'node:fs';
 import { isBareImport } from '../@vitest/utils/helpers.js';
 import { i as isBuiltin, a as isBrowserExternal, t as toBuiltin } from './modules.BJuCwlRJ.js';
+import { E as EnvironmentTeardownError, a as getSafeWorkerState } from './utils.BX5Fg8C4.js';
 import { pathToFileURL } from 'node:url';
-import { normalize as normalize$1, join as join$1 } from '../vendor/pathe.mjs';
+import { normalize, join } from '../vendor/pathe.mjs';
 import { distDir } from '../path.js';
-import { serializeValue } from '../@vitest/utils/serialize.js';
 import { VitestModuleEvaluator, unwrapId } from '../module-evaluator.js';
-import { resolve as resolve$1, isAbsolute as isAbsolute$1 } from 'node:path';
+import { isAbsolute, resolve } from 'node:path';
 import vm from 'node:vm';
 import { MockerRegistry, mockObject, RedirectedModule, AutomockedModule } from '../@vitest/mocker/index.js';
-import nodeModule from 'node:module';
+import { findMockRedirect } from '../@vitest/mocker/redirect.js';
 import * as viteModuleRunner from '@voidzero-dev/vite-plus-core/module-runner';
 import { T as Traces } from './traces.CCmnQaNT.js';
 
-class VitestTransport {
-  constructor(options) {
-    this.options = options;
-  }
-  async invoke(event) {
-    if (event.type !== "custom") return { error: /* @__PURE__ */ new Error(`Vitest Module Runner doesn't support Vite HMR events.`) };
-    if (event.event !== "vite:invoke") return { error: /* @__PURE__ */ new Error(`Vitest Module Runner doesn't support ${event.event} event.`) };
-    const { name, data } = event.data;
-    if (name === "getBuiltins")
- // we return an empty array here to avoid client-side builtin check,
-    // as we need builtins to go through `fetchModule`
-    return { result: [] };
-    if (name !== "fetchModule") return { error: /* @__PURE__ */ new Error(`Unknown method: ${name}. Expected "fetchModule".`) };
-    try {
-      return { result: await this.options.fetchModule(...data) };
-    } catch (error) {
-      return { error };
-    }
-  }
-}
-
-const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
-function normalizeWindowsPath(input = "") {
-  if (!input) return input;
-  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
-}
-const _UNC_REGEX = /^[/\\]{2}/;
-const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
-const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
-const _EXTNAME_RE = /.(\.[^./]+|\.)$/;
-const normalize = function(path) {
-  if (path.length === 0) return ".";
-  path = normalizeWindowsPath(path);
-  const isUNCPath = path.match(_UNC_REGEX);
-  const isPathAbsolute = isAbsolute(path);
-  const trailingSeparator = path[path.length - 1] === "/";
-  path = normalizeString(path, !isPathAbsolute);
-  if (path.length === 0) {
-    if (isPathAbsolute) return "/";
-    return trailingSeparator ? "./" : ".";
-  }
-  if (trailingSeparator) path += "/";
-  if (_DRIVE_LETTER_RE.test(path)) path += "/";
-  if (isUNCPath) {
-    if (!isPathAbsolute) return `//./${path}`;
-    return `//${path}`;
-  }
-  return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
-};
-const join = function(...segments) {
-  let path = "";
-  for (const seg of segments) {
-    if (!seg) continue;
-    if (path.length > 0) {
-      const pathTrailing = path[path.length - 1] === "/";
-      const segLeading = seg[0] === "/";
-      if (pathTrailing && segLeading) path += seg.slice(1);
-      else path += pathTrailing || segLeading ? seg : `/${seg}`;
-    } else path += seg;
-  }
-  return normalize(path);
-};
-function cwd$1() {
-  if (typeof process !== "undefined" && typeof process.cwd === "function") return process.cwd().replace(/\\/g, "/");
-  return "/";
-}
-const resolve = function(...arguments_) {
-  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
-  let resolvedPath = "";
-  let resolvedAbsolute = false;
-  for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
-    const path = index >= 0 ? arguments_[index] : cwd$1();
-    if (!path || path.length === 0) continue;
-    resolvedPath = `${path}/${resolvedPath}`;
-    resolvedAbsolute = isAbsolute(path);
-  }
-  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
-  if (resolvedAbsolute && !isAbsolute(resolvedPath)) return `/${resolvedPath}`;
-  return resolvedPath.length > 0 ? resolvedPath : ".";
-};
-function normalizeString(path, allowAboveRoot) {
-  let res = "";
-  let lastSegmentLength = 0;
-  let lastSlash = -1;
-  let dots = 0;
-  let char = null;
-  for (let index = 0; index <= path.length; ++index) {
-    if (index < path.length) char = path[index];
-    else if (char === "/") break;
-    else char = "/";
-    if (char === "/") {
-      if (lastSlash === index - 1 || dots === 1);
-      else if (dots === 2) {
-        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
-          if (res.length > 2) {
-            const lastSlashIndex = res.lastIndexOf("/");
-            if (lastSlashIndex === -1) {
-              res = "";
-              lastSegmentLength = 0;
-            } else {
-              res = res.slice(0, lastSlashIndex);
-              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
-            }
-            lastSlash = index;
-            dots = 0;
-            continue;
-          } else if (res.length > 0) {
-            res = "";
-            lastSegmentLength = 0;
-            lastSlash = index;
-            dots = 0;
-            continue;
-          }
-        }
-        if (allowAboveRoot) {
-          res += res.length > 0 ? "/.." : "..";
-          lastSegmentLength = 2;
-        }
-      } else {
-        if (res.length > 0) res += `/${path.slice(lastSlash + 1, index)}`;
-        else res = path.slice(lastSlash + 1, index);
-        lastSegmentLength = index - lastSlash - 1;
-      }
-      lastSlash = index;
-      dots = 0;
-    } else if (char === "." && dots !== -1) ++dots;
-    else dots = -1;
-  }
-  return res;
-}
-const isAbsolute = function(p) {
-  return _IS_ABSOLUTE_RE.test(p);
-};
-const extname = function(p) {
-  if (p === "..") return "";
-  const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
-  return match && match[1] || "";
-};
-const dirname = function(p) {
-  const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
-  if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) segments[0] += "/";
-  return segments.join("/") || (isAbsolute(p) ? "/" : ".");
-};
-const basename = function(p, extension) {
-  const segments = normalizeWindowsPath(p).split("/");
-  let lastSegment = "";
-  for (let i = segments.length - 1; i >= 0; i--) {
-    const val = segments[i];
-    if (val) {
-      lastSegment = val;
-      break;
-    }
-  }
-  return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
-};
-
-const { existsSync, readdirSync, statSync } = fs;
-function findMockRedirect(root, mockPath, external) {
-  const path = external || mockPath;
-  // it's a node_module alias
-  // all mocks should be inside <root>/__mocks__
-  if (external || isNodeBuiltin(mockPath) || !existsSync(mockPath)) {
-    const mockFolder = join(root, "__mocks__", dirname(path));
-    if (!existsSync(mockFolder)) return null;
-    const baseOriginal = basename(path);
-    function findFile(mockFolder, baseOriginal) {
-      const files = readdirSync(mockFolder);
-      for (const file of files) if (basename(file, extname(file)) === baseOriginal) {
-        const path = resolve(mockFolder, file);
-        // if the same name, return the file
-        if (statSync(path).isFile()) return path;
-        else {
-          // find folder/index.{js,ts}
-          const indexFile = findFile(path, "index");
-          if (indexFile) return indexFile;
-        }
-      }
-      return null;
-    }
-    return findFile(mockFolder, baseOriginal);
-  }
-  const fullPath = resolve(dirname(path), "__mocks__", basename(path));
-  return existsSync(fullPath) ? fullPath : null;
-}
-const builtins = new Set([
-  ...nodeModule.builtinModules,
-  "assert/strict",
-  "diagnostics_channel",
-  "dns/promises",
-  "fs/promises",
-  "path/posix",
-  "path/win32",
-  "readline/promises",
-  "stream/consumers",
-  "stream/promises",
-  "stream/web",
-  "timers/promises",
-  "util/types",
-  "wasi"
-]);
-// https://nodejs.org/api/modules.html#built-in-modules-with-mandatory-node-prefix
-const prefixedBuiltins$1 = new Set([
-  "node:sea",
-  "node:sqlite",
-  "node:test",
-  "node:test/reporters"
-]);
-const NODE_BUILTIN_NAMESPACE = "node:";
-function isNodeBuiltin(id) {
-  // Added in v18.6.0
-  if (nodeModule.isBuiltin) return nodeModule.isBuiltin(id);
-  if (prefixedBuiltins$1.has(id)) return true;
-  return builtins.has(id.startsWith(NODE_BUILTIN_NAMESPACE) ? id.slice(5) : id);
-}
-
-const spyModulePath = resolve$1(distDir, "spy.js");
-class VitestMocker {
+class BareModuleMocker {
   static pendingIds = [];
   spyModule;
   primitives;
-  filterPublicKeys;
   registries = /* @__PURE__ */ new Map();
   mockContext = { callstack: null };
   _otel;
-  constructor(moduleRunner, options) {
-    this.moduleRunner = moduleRunner;
+  constructor(options) {
     this.options = options;
-    const context = this.options.context;
     this._otel = options.traces;
-    if (context) this.primitives = vm.runInContext("({ Object, Error, Function, RegExp, Symbol, Array, Map })", context);
-    else this.primitives = {
+    this.primitives = {
       Object,
       Error,
       Function,
@@ -253,37 +33,13 @@ class VitestMocker {
       Map
     };
     if (options.spyModule) this.spyModule = options.spyModule;
-    const Symbol = this.primitives.Symbol;
-    this.filterPublicKeys = [
-      "__esModule",
-      Symbol.asyncIterator,
-      Symbol.hasInstance,
-      Symbol.isConcatSpreadable,
-      Symbol.iterator,
-      Symbol.match,
-      Symbol.matchAll,
-      Symbol.replace,
-      Symbol.search,
-      Symbol.split,
-      Symbol.species,
-      Symbol.toPrimitive,
-      Symbol.toStringTag,
-      Symbol.unscopables
-    ];
   }
   get root() {
     return this.options.root;
   }
-  get evaluatedModules() {
-    return this.moduleRunner.evaluatedModules;
-  }
   get moduleDirectories() {
     return this.options.moduleDirectories || [];
   }
-  async initializeSpyModule() {
-    if (this.spyModule) return;
-    this.spyModule = await this.moduleRunner.import(spyModulePath);
-  }
   getMockerRegistry() {
     const suite = this.getSuiteFilepath();
     if (!this.registries.has(suite)) this.registries.set(suite, new MockerRegistry());
@@ -292,13 +48,8 @@ class VitestMocker {
   reset() {
     this.registries.clear();
   }
-  invalidateModuleById(id) {
-    const mockId = this.getMockPath(id);
-    const node = this.evaluatedModules.getModuleById(mockId);
-    if (node) {
-      this.evaluatedModules.invalidateModule(node);
-      node.mockedExports = void 0;
-    }
+  invalidateModuleById(_id) {
+    // implemented by mockers that control the module runner
   }
   isModuleDirectory(path) {
     return this.moduleDirectories.some((dir) => path.includes(dir));
@@ -335,7 +86,7 @@ class VitestMocker {
       }
       // external is node_module or unresolved module
       // for example, some people mock "vscode" and don't have it installed
-      const external = !isAbsolute$1(result.file) || this.isModuleDirectory(result.file) ? normalizeModuleId(rawId) : null;
+      const external = !isAbsolute(result.file) || this.isModuleDirectory(result.file) ? normalizeModuleId(rawId) : null;
       const id = normalizeModuleId(result.id);
       span.setAttributes({
         "vitest.module.id": id,
@@ -350,13 +101,188 @@ class VitestMocker {
     });
   }
   async resolveMocks() {
-    if (!VitestMocker.pendingIds.length) return;
-    await Promise.all(VitestMocker.pendingIds.map(async (mock) => {
+    if (!BareModuleMocker.pendingIds.length) return;
+    await Promise.all(BareModuleMocker.pendingIds.map(async (mock) => {
       const { id, url, external } = await this.resolveId(mock.id, mock.importer);
       if (mock.action === "unmock") this.unmockPath(id);
       if (mock.action === "mock") this.mockPath(mock.id, id, url, external, mock.type, mock.factory);
     }));
-    VitestMocker.pendingIds = [];
+    BareModuleMocker.pendingIds = [];
+  }
+  // public method to avoid circular dependency
+  getMockContext() {
+    return this.mockContext;
+  }
+  // path used to store mocked dependencies
+  getMockPath(dep) {
+    return `mock:${dep}`;
+  }
+  getDependencyMock(id) {
+    return this.getMockerRegistry().getById(fixLeadingSlashes(id));
+  }
+  getDependencyMockByUrl(url) {
+    return this.getMockerRegistry().get(url);
+  }
+  findMockRedirect(mockPath, external) {
+    return findMockRedirect(this.root, mockPath, external);
+  }
+  mockObject(object, mockExportsOrModuleType, moduleType) {
+    let mockExports;
+    if (mockExportsOrModuleType === "automock" || mockExportsOrModuleType === "autospy") {
+      moduleType = mockExportsOrModuleType;
+      mockExports = void 0;
+    } else mockExports = mockExportsOrModuleType;
+    moduleType ??= "automock";
+    const createMockInstance = this.spyModule?.createMockInstance;
+    if (!createMockInstance) throw this.createError("[vitest] `spyModule` is not defined. This is a Vitest error. Please open a new issue with reproduction.");
+    return mockObject({
+      globalConstructors: this.primitives,
+      createMockInstance,
+      type: moduleType
+    }, object, mockExports);
+  }
+  unmockPath(id) {
+    this.getMockerRegistry().deleteById(id);
+    this.invalidateModuleById(id);
+  }
+  mockPath(originalId, id, url, external, mockType, factory) {
+    const registry = this.getMockerRegistry();
+    if (mockType === "manual") registry.register("manual", originalId, id, url, factory);
+    else if (mockType === "autospy") registry.register("autospy", originalId, id, url);
+    else {
+      const redirect = this.findMockRedirect(id, external);
+      if (redirect) registry.register("redirect", originalId, id, url, redirect);
+      else registry.register("automock", originalId, id, url);
+    }
+    // every time the mock is registered, we remove the previous one from the cache
+    this.invalidateModuleById(id);
+  }
+  async importActual(_rawId, _importer, _callstack) {
+    throw new Error(`importActual is not implemented`);
+  }
+  async importMock(_rawId, _importer, _callstack) {
+    throw new Error(`importMock is not implemented`);
+  }
+  queueMock(id, importer, factoryOrOptions) {
+    const mockType = getMockType(factoryOrOptions);
+    BareModuleMocker.pendingIds.push({
+      action: "mock",
+      id,
+      importer,
+      factory: typeof factoryOrOptions === "function" ? factoryOrOptions : void 0,
+      type: mockType
+    });
+  }
+  queueUnmock(id, importer) {
+    BareModuleMocker.pendingIds.push({
+      action: "unmock",
+      id,
+      importer
+    });
+  }
+}
+function getMockType(factoryOrOptions) {
+  if (!factoryOrOptions) return "automock";
+  if (typeof factoryOrOptions === "function") return "manual";
+  return factoryOrOptions.spy ? "autospy" : "automock";
+}
+// unique id that is not available as "$bare_import" like "test"
+// https://nodejs.org/api/modules.html#built-in-modules-with-mandatory-node-prefix
+const prefixedBuiltins = new Set([
+  "node:sea",
+  "node:sqlite",
+  "node:test",
+  "node:test/reporters"
+]);
+const isWindows$1 = process.platform === "win32";
+// transform file url to id
+// virtual:custom -> virtual:custom
+// \0custom -> \0custom
+// /root/id -> /id
+// /root/id.js -> /id.js
+// C:/root/id.js -> /id.js
+// C:\root\id.js -> /id.js
+// TODO: expose this in vite/module-runner
+function normalizeModuleId(file) {
+  if (prefixedBuiltins.has(file)) return file;
+  // if it's not in the root, keep it as a path, not a URL
+  return slash(file).replace(/^\/@fs\//, isWindows$1 ? "" : "/").replace(/^node:/, "").replace(/^\/+/, "/").replace(/^file:\//, "/");
+}
+const windowsSlashRE = /\\/g;
+function slash(p) {
+  return p.replace(windowsSlashRE, "/");
+}
+const multipleSlashRe = /^\/+/;
+// module-runner incorrectly replaces file:///path with `///path`
+function fixLeadingSlashes(id) {
+  if (id.startsWith("//")) return id.replace(multipleSlashRe, "/");
+  return id;
+}
+
+// copied from vite/src/shared/utils.ts
+const postfixRE = /[?#].*$/;
+function cleanUrl(url) {
+  return url.replace(postfixRE, "");
+}
+function splitFileAndPostfix(path) {
+  const file = cleanUrl(path);
+  return {
+    file,
+    postfix: path.slice(file.length)
+  };
+}
+function injectQuery(url, queryToInject) {
+  const { file, postfix } = splitFileAndPostfix(url);
+  return `${file}?${queryToInject}${postfix[0] === "?" ? `&${postfix.slice(1)}` : postfix}`;
+}
+function removeQuery(url, queryToRemove) {
+  return url.replace(new RegExp(`[?&]${queryToRemove}(?=[&#]|$)`), "").replace(/\?$/, "");
+}
+
+const spyModulePath = resolve(distDir, "spy.js");
+class VitestMocker extends BareModuleMocker {
+  filterPublicKeys;
+  constructor(moduleRunner, options) {
+    super(options);
+    this.moduleRunner = moduleRunner;
+    this.options = options;
+    const context = this.options.context;
+    if (context) this.primitives = vm.runInContext("({ Object, Error, Function, RegExp, Symbol, Array, Map })", context);
+    const Symbol = this.primitives.Symbol;
+    this.filterPublicKeys = [
+      "__esModule",
+      Symbol.asyncIterator,
+      Symbol.hasInstance,
+      Symbol.isConcatSpreadable,
+      Symbol.iterator,
+      Symbol.match,
+      Symbol.matchAll,
+      Symbol.replace,
+      Symbol.search,
+      Symbol.split,
+      Symbol.species,
+      Symbol.toPrimitive,
+      Symbol.toStringTag,
+      Symbol.unscopables
+    ];
+  }
+  get evaluatedModules() {
+    return this.moduleRunner.evaluatedModules;
+  }
+  async initializeSpyModule() {
+    if (this.spyModule) return;
+    this.spyModule = await this.moduleRunner.import(spyModulePath);
+  }
+  reset() {
+    this.registries.clear();
+  }
+  invalidateModuleById(id) {
+    const mockId = this.getMockPath(id);
+    const node = this.evaluatedModules.getModuleById(mockId);
+    if (node) {
+      this.evaluatedModules.invalidateModule(node);
+      node.mockedExports = void 0;
+    }
   }
   ensureModule(id, url) {
     const node = this.evaluatedModules.ensureModule(id, url);
@@ -396,48 +322,10 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
     node.exports = moduleExports;
     return moduleExports;
   }
-  // public method to avoid circular dependency
-  getMockContext() {
-    return this.mockContext;
-  }
-  // path used to store mocked dependencies
-  getMockPath(dep) {
-    return `mock:${dep}`;
-  }
-  getDependencyMock(id) {
-    return this.getMockerRegistry().getById(fixLeadingSlashes(id));
-  }
-  findMockRedirect(mockPath, external) {
-    return findMockRedirect(this.root, mockPath, external);
-  }
-  mockObject(object, mockExports = {}, behavior = "automock") {
-    const createMockInstance = this.spyModule?.createMockInstance;
-    if (!createMockInstance) throw this.createError("[vitest] `spyModule` is not defined. This is a Vitest error. Please open a new issue with reproduction.");
-    return mockObject({
-      globalConstructors: this.primitives,
-      createMockInstance,
-      type: behavior
-    }, object, mockExports);
-  }
-  unmockPath(id) {
-    this.getMockerRegistry().deleteById(id);
-    this.invalidateModuleById(id);
-  }
-  mockPath(originalId, id, url, external, mockType, factory) {
-    const registry = this.getMockerRegistry();
-    if (mockType === "manual") registry.register("manual", originalId, id, url, factory);
-    else if (mockType === "autospy") registry.register("autospy", originalId, id, url);
-    else {
-      const redirect = this.findMockRedirect(id, external);
-      if (redirect) registry.register("redirect", originalId, id, url, redirect);
-      else registry.register("automock", originalId, id, url);
-    }
-    // every time the mock is registered, we remove the previous one from the cache
-    this.invalidateModuleById(id);
-  }
   async importActual(rawId, importer, callstack) {
     const { url } = await this.resolveId(rawId, importer);
-    const node = await this.moduleRunner.fetchModule(url, importer);
+    const actualUrl = injectQuery(url, "_vitest_original");
+    const node = await this.moduleRunner.fetchModule(actualUrl, importer);
     return await this.moduleRunner.cachedRequest(node.url, node, callstack || [importer], void 0, true);
   }
   async importMock(rawId, importer) {
@@ -511,61 +399,44 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
     if (!mock) return;
     return this.requestWithMockedModule(url, evaluatedNode, callstack, mock);
   }
-  queueMock(id, importer, factoryOrOptions) {
-    const mockType = getMockType(factoryOrOptions);
-    VitestMocker.pendingIds.push({
-      action: "mock",
-      id,
-      importer,
-      factory: typeof factoryOrOptions === "function" ? factoryOrOptions : void 0,
-      type: mockType
-    });
+}
+
+class VitestTransport {
+  constructor(options, evaluatedModules, callstacks) {
+    this.options = options;
+    this.evaluatedModules = evaluatedModules;
+    this.callstacks = callstacks;
   }
-  queueUnmock(id, importer) {
-    VitestMocker.pendingIds.push({
-      action: "unmock",
-      id,
-      importer
-    });
+  async invoke(event) {
+    if (event.type !== "custom") return { error: /* @__PURE__ */ new Error(`Vitest Module Runner doesn't support Vite HMR events.`) };
+    if (event.event !== "vite:invoke") return { error: /* @__PURE__ */ new Error(`Vitest Module Runner doesn't support ${event.event} event.`) };
+    const { name, data } = event.data;
+    if (name === "getBuiltins")
+ // we return an empty array here to avoid client-side builtin check,
+    // as we need builtins to go through `fetchModule`
+    return { result: [] };
+    if (name !== "fetchModule") return { error: /* @__PURE__ */ new Error(`Unknown method: ${name}. Expected "fetchModule".`) };
+    try {
+      return { result: await this.options.fetchModule(...data) };
+    } catch (cause) {
+      if (cause instanceof EnvironmentTeardownError) {
+        const [id, importer] = data;
+        let message = `Cannot load '${id}'${importer ? ` imported from ${importer}` : ""} after the environment was torn down. This is not a bug in Vitest.`;
+        const moduleNode = importer ? this.evaluatedModules.getModuleById(importer) : void 0;
+        const callstack = moduleNode ? this.callstacks.get(moduleNode) : void 0;
+        if (callstack) message += ` The last recorded callstack:\n- ${[
+          ...callstack,
+          importer,
+          id
+        ].reverse().join("\n- ")}`;
+        const error = new EnvironmentTeardownError(message);
+        if (cause.stack) error.stack = cause.stack.replace(cause.message, error.message);
+        return { error };
+      }
+      return { error: cause };
+    }
   }
 }
-function getMockType(factoryOrOptions) {
-  if (!factoryOrOptions) return "automock";
-  if (typeof factoryOrOptions === "function") return "manual";
-  return factoryOrOptions.spy ? "autospy" : "automock";
-}
-// unique id that is not available as "$bare_import" like "test"
-// https://nodejs.org/api/modules.html#built-in-modules-with-mandatory-node-prefix
-const prefixedBuiltins = new Set([
-  "node:sea",
-  "node:sqlite",
-  "node:test",
-  "node:test/reporters"
-]);
-const isWindows$1 = process.platform === "win32";
-// transform file url to id
-// virtual:custom -> virtual:custom
-// \0custom -> \0custom
-// /root/id -> /id
-// /root/id.js -> /id.js
-// C:/root/id.js -> /id.js
-// C:\root\id.js -> /id.js
-// TODO: expose this in vite/module-runner
-function normalizeModuleId(file) {
-  if (prefixedBuiltins.has(file)) return file;
-  // if it's not in the root, keep it as a path, not a URL
-  return slash(file).replace(/^\/@fs\//, isWindows$1 ? "" : "/").replace(/^node:/, "").replace(/^\/+/, "/").replace(/^file:\//, "/");
-}
-const windowsSlashRE = /\\/g;
-function slash(p) {
-  return p.replace(windowsSlashRE, "/");
-}
-const multipleSlashRe = /^\/+/;
-// module-runner incorrectly replaces file:///path with `///path`
-function fixLeadingSlashes(id) {
-  if (id.startsWith("//")) return id.replace(multipleSlashRe, "/");
-  return id;
-}
 
 const createNodeImportMeta = (modulePath) => {
   if (!viteModuleRunner.createDefaultImportMeta) throw new Error(`createNodeImportMeta is not supported in this version of Vite.`);
@@ -589,10 +460,12 @@ class VitestModuleRunner extends viteModuleRunner.ModuleRunner {
   mocker;
   moduleExecutionInfo;
   _otel;
+  _callstacks;
   constructor(vitestOptions) {
     const options = vitestOptions;
-    const transport = new VitestTransport(options.transport);
     const evaluatedModules = options.evaluatedModules;
+    const callstacks = /* @__PURE__ */ new WeakMap();
+    const transport = new VitestTransport(options.transport, evaluatedModules, callstacks);
     super({
       transport,
       hmr: false,
@@ -601,6 +474,7 @@ class VitestModuleRunner extends viteModuleRunner.ModuleRunner {
       createImportMeta: vitestOptions.createImportMeta
     }, options.evaluator);
     this.vitestOptions = vitestOptions;
+    this._callstacks = callstacks;
     this._otel = vitestOptions.traces || new Traces({ enabled: false });
     this.moduleExecutionInfo = options.getWorkerState().moduleExecutionInfo;
     this.mocker = options.mocker || new VitestMocker(this, {
@@ -658,10 +532,24 @@ class VitestModuleRunner extends viteModuleRunner.ModuleRunner {
   * @internal
   */
   async cachedRequest(url, mod, callstack = [], metadata, ignoreMock = false) {
+    // Track for a better error message if dynamic import is not resolved properly
+    this._callstacks.set(mod, callstack);
     if (ignoreMock) return this._cachedRequest(url, mod, callstack, metadata);
     let mocked;
-    if (mod.meta && "mockedModule" in mod.meta) mocked = await this.mocker.requestWithMockedModule(url, mod, callstack, mod.meta.mockedModule);
-    else mocked = await this.mocker.mockedRequest(url, mod, callstack);
+    if (mod.meta && "mockedModule" in mod.meta) {
+      const mockedModule = mod.meta.mockedModule;
+      const mockId = this.mocker.getMockPath(mod.id);
+      // bypass mock and force "importActual" behavior when:
+      // - mock was removed by doUnmock (stale mockedModule in meta)
+      // - self-import: mock factory/file is importing the module it's mocking
+      const isStale = !this.mocker.getDependencyMock(mod.id);
+      const isSelfImport = callstack.includes(mockId) || callstack.includes(url) || "redirect" in mockedModule && callstack.includes(mockedModule.redirect);
+      if (isStale || isSelfImport) {
+        const node = await this.fetchModule(injectQuery(url, "_vitest_original"));
+        return this._cachedRequest(node.url, node, callstack, metadata);
+      }
+      mocked = await this.mocker.requestWithMockedModule(url, mod, callstack, mockedModule);
+    } else mocked = await this.mocker.mockedRequest(url, mod, callstack);
     if (typeof mocked === "string") {
       const node = await this.fetchModule(mocked);
       return this._cachedRequest(mocked, node, callstack, metadata);
@@ -684,7 +572,7 @@ class VitestModuleRunner extends viteModuleRunner.ModuleRunner {
 }
 
 const bareVitestRegexp = /^@?vitest(?:\/|$)/;
-const normalizedDistDir = normalize$1(distDir);
+const normalizedDistDir = normalize(distDir);
 const relativeIds = {};
 const externalizeMap = /* @__PURE__ */ new Map();
 // all Vitest imports always need to be externalized
@@ -707,7 +595,7 @@ function getCachedVitestImport(id, state) {
     };
   }
   if (relativeRoot && relativeRoot !== "/" && id.startsWith(relativeRoot)) {
-    const externalize = pathToFileURL(join$1(root, id)).toString();
+    const externalize = pathToFileURL(join(root, id)).toString();
     externalizeMap.set(id, externalize);
     return {
       externalize,
@@ -724,48 +612,14 @@ function getCachedVitestImport(id, state) {
   return null;
 }
 
-// Store globals in case tests overwrite them
-const processListeners = process.listeners.bind(process);
-const processOn = process.on.bind(process);
-const processOff = process.off.bind(process);
-const dispose = [];
-function listenForErrors(state) {
-  dispose.forEach((fn) => fn());
-  dispose.length = 0;
-  function catchError(err, type, event) {
-    const worker = state();
-    // if there is another listener, assume that it's handled by user code
-    // one is Vitest's own listener
-    if (processListeners(event).length > 1) return;
-    const error = serializeValue(err);
-    if (typeof error === "object" && error != null) {
-      error.VITEST_TEST_NAME = worker.current?.type === "test" ? worker.current.name : void 0;
-      if (worker.filepath) error.VITEST_TEST_PATH = worker.filepath;
-    }
-    state().rpc.onUnhandledError(error, type);
-  }
-  const uncaughtException = (e) => catchError(e, "Uncaught Exception", "uncaughtException");
-  const unhandledRejection = (e) => catchError(e, "Unhandled Rejection", "unhandledRejection");
-  processOn("uncaughtException", uncaughtException);
-  processOn("unhandledRejection", unhandledRejection);
-  dispose.push(() => {
-    processOff("uncaughtException", uncaughtException);
-    processOff("unhandledRejection", unhandledRejection);
-  });
-}
-
 const { readFileSync } = fs;
 const VITEST_VM_CONTEXT_SYMBOL = "__vitest_vm_context__";
 const cwd = process.cwd();
 const isWindows = process.platform === "win32";
 function startVitestModuleRunner(options) {
   const traces = options.traces;
-  const state = () => globalThis.__vitest_worker__ || options.state;
+  const state = () => getSafeWorkerState() || options.state;
   const rpc = () => state().rpc;
-  process.exit = (code = process.exitCode || 0) => {
-    throw new Error(`process.exit unexpectedly called with "${code}"`);
-  };
-  listenForErrors(state);
   const environment = () => {
     const environment = state().environment;
     return environment.viteEnvironment || environment.name;
@@ -804,19 +658,25 @@ function startVitestModuleRunner(options) {
         }
         const vitest = getCachedVitestImport(id, state);
         if (vitest) return vitest;
+        // strip _vitest_original query added by importActual so that
+        // the plugin pipeline sees the original import id (e.g. virtual modules's load hook)
+        const isImportActual = id.includes("_vitest_original");
+        if (isImportActual) id = removeQuery(id, "_vitest_original");
         const rawId = unwrapId(id);
         resolvingModules.add(rawId);
         try {
           if (VitestMocker.pendingIds.length) await moduleRunner.mocker.resolveMocks();
-          const resolvedMock = moduleRunner.mocker.getDependencyMock(rawId);
-          if (resolvedMock?.type === "manual" || resolvedMock?.type === "redirect") return {
-            code: "",
-            file: null,
-            id,
-            url: id,
-            invalidate: false,
-            mockedModule: resolvedMock
-          };
+          if (!isImportActual) {
+            const resolvedMock = moduleRunner.mocker.getDependencyMockByUrl(id);
+            if (resolvedMock?.type === "manual" || resolvedMock?.type === "redirect") return {
+              code: "",
+              file: null,
+              id: resolvedMock.id,
+              url: resolvedMock.url,
+              invalidate: false,
+              mockedModule: resolvedMock
+            };
+          }
           if (isBuiltin(rawId)) return {
             externalize: rawId,
             type: "builtin"
@@ -838,7 +698,7 @@ function startVitestModuleRunner(options) {
         } catch (cause) {
           // rethrow vite error if it cannot load the module because it's not resolved
           if (typeof cause === "object" && cause != null && cause.code === "ERR_LOAD_URL" || typeof cause?.message === "string" && cause.message.includes("Failed to load url") || typeof cause?.message === "string" && cause.message.startsWith("Cannot find module '")) {
-            const error = new Error(`Cannot find ${isBareImport(id) ? "package" : "module"} '${id}'${importer ? ` imported from '${importer}'` : ""}`, { cause });
+            const error = new Error(`Cannot find ${isBareImport(id) ? "package" : "module"} '${id}'${importer ? ` imported from ${importer}` : ""}`, { cause });
             error.code = "ERR_MODULE_NOT_FOUND";
             throw error;
           }
@@ -858,4 +718,4 @@ function startVitestModuleRunner(options) {
   return moduleRunner;
 }
 
-export { VitestModuleRunner as V, VITEST_VM_CONTEXT_SYMBOL as a, VitestTransport as b, createNodeImportMeta as c, startVitestModuleRunner as s };
+export { BareModuleMocker as B, VITEST_VM_CONTEXT_SYMBOL as V, VitestModuleRunner as a, VitestTransport as b, createNodeImportMeta as c, normalizeModuleId as n, startVitestModuleRunner as s };