vitest 2.1.0-beta.6 → 2.1.0-beta.7

package/dist/chunks/{execute.DT9BA6zp.js → execute._eQQfgI8.js}

@@ -2,34 +2,239 @@ import vm from 'node:vm';
 import { pathToFileURL } from 'node:url';
 import fs from 'node:fs';
 import { ViteNodeRunner, DEFAULT_REQUEST_STUBS } from 'vite-node/client';
-import { isNodeBuiltin, isInternalRequest, toFilePath, isPrimitive } from 'vite-node/utils';
-import { resolve, isAbsolute, dirname, join, basename, extname, normalize, relative } from 'pathe';
+import { isInternalRequest, isNodeBuiltin as isNodeBuiltin$1, toFilePath, isPrimitive } from 'vite-node/utils';
+import { resolve as resolve$1, isAbsolute as isAbsolute$1, normalize as normalize$1, relative } from 'pathe';
 import { processError } from '@vitest/utils/error';
 import { distDir } from '../path.js';
-import { highlight, getType } from '@vitest/utils';
-import { g as getAllMockableProperties } from './base.BH-FAiX7.js';
+import { highlight } from '@vitest/utils';
+import { MockerRegistry, mockObject, RedirectedModule, AutomockedModule } from '@vitest/mocker';
+import { builtinModules } from 'node:module';
 
-const { existsSync, readdirSync } = fs;
-const spyModulePath = resolve(distDir, "spy.js");
-class RefTracker {
-  idMap = /* @__PURE__ */ new Map();
-  mockedValueMap = /* @__PURE__ */ new Map();
-  getId(value) {
-    return this.idMap.get(value);
-  }
-  getMockedValue(id) {
-    return this.mockedValueMap.get(id);
-  }
-  track(originalValue, mockedValue) {
-    const newId = this.idMap.size;
-    this.idMap.set(originalValue, newId);
-    this.mockedValueMap.set(newId, mockedValue);
-    return newId;
+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());
 }
-function isSpecialProp(prop, parentType) {
-  return parentType.includes("Function") && typeof prop === "string" && ["arguments", "callee", "caller", "length", "name"].includes(prop);
+const _UNC_REGEX = /^[/\\]{2}/;
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+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(...arguments_) {
+  if (arguments_.length === 0) {
+    return ".";
+  }
+  let joined;
+  for (const argument of arguments_) {
+    if (argument && argument.length > 0) {
+      if (joined === void 0) {
+        joined = argument;
+      } else {
+        joined += `/${argument}`;
+      }
+    }
+  }
+  if (joined === void 0) {
+    return ".";
+  }
+  return normalize(joined.replace(/\/\/+/g, "/"));
+};
+function cwd() {
+  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();
+    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_RE = /.(\.[^./]+)$/;
+const extname = function(p) {
+  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 lastSegment = normalizeWindowsPath(p).split("/").pop();
+  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;
+  if (external || isNodeBuiltin(mockPath) || !existsSync(mockPath)) {
+    let findFile2 = function(mockFolder2, baseOriginal2) {
+      const files = readdirSync(mockFolder2);
+      for (const file of files) {
+        const baseFile = basename(file, extname(file));
+        if (baseFile === baseOriginal2) {
+          const path2 = resolve(mockFolder2, file);
+          if (statSync(path2).isFile()) {
+            return path2;
+          } else {
+            const indexFile = findFile2(path2, "index");
+            if (indexFile) {
+              return indexFile;
+            }
+          }
+        }
+      }
+      return null;
+    };
+    const mockDirname = dirname(path);
+    const mockFolder = join(root, "__mocks__", mockDirname);
+    if (!existsSync(mockFolder)) {
+      return null;
+    }
+    const baseOriginal = basename(path);
+    return findFile2(mockFolder, baseOriginal);
+  }
+  const dir = dirname(path);
+  const baseId = basename(path);
+  const fullPath = resolve(dir, "__mocks__", baseId);
+  return existsSync(fullPath) ? fullPath : null;
+}
+const builtins = /* @__PURE__ */ new Set([
+  ...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"
+]);
+const prefixedBuiltins = /* @__PURE__ */ new Set(["node:test", "node:sqlite"]);
+const NODE_BUILTIN_NAMESPACE = "node:";
+function isNodeBuiltin(id) {
+  if (prefixedBuiltins.has(id)) {
+    return true;
+  }
+  return builtins.has(
+    id.startsWith(NODE_BUILTIN_NAMESPACE) ? id.slice(NODE_BUILTIN_NAMESPACE.length) : id
+  );
+}
+
+const spyModulePath = resolve$1(distDir, "spy.js");
 class VitestMocker {
   constructor(executor) {
     this.executor = executor;
@@ -70,18 +275,15 @@ class VitestMocker {
   }
   static pendingIds = [];
   spyModule;
-  resolveCache = /* @__PURE__ */ new Map();
   primitives;
   filterPublicKeys;
+  registries = /* @__PURE__ */ new Map();
   mockContext = {
     callstack: null
   };
   get root() {
     return this.executor.options.root;
   }
-  get mockMap() {
-    return this.executor.options.mockMap;
-  }
   get moduleCache() {
     return this.executor.moduleCache;
   }
@@ -91,6 +293,16 @@ class VitestMocker {
   async initializeSpyModule() {
     this.spyModule = await this.executor.executeId(spyModulePath);
   }
+  getMockerRegistry() {
+    const suite = this.getSuiteFilepath();
+    if (!this.registries.has(suite)) {
+      this.registries.set(suite, new MockerRegistry());
+    }
+    return this.registries.get(suite);
+  }
+  reset() {
+    this.registries.clear();
+  }
   deleteCachedItem(id) {
     const mockId = this.getMockPath(id);
     if (this.moduleCache.has(mockId)) {
@@ -109,15 +321,6 @@ class VitestMocker {
     Object.assign(error, { codeFrame });
     return error;
   }
-  getMocks() {
-    const suite = this.getSuiteFilepath();
-    const suiteMocks = this.mockMap.get(suite);
-    const globalMocks = this.mockMap.get("global");
-    return {
-      ...globalMocks,
-      ...suiteMocks
-    };
-  }
   async resolvePath(rawId, importer) {
     let id;
     let fsPath;
@@ -132,7 +335,7 @@ class VitestMocker {
         throw error;
       }
     }
-    const external = !isAbsolute(fsPath) || this.isModuleDirectory(fsPath) ? rawId : null;
+    const external = !isAbsolute$1(fsPath) || this.isModuleDirectory(fsPath) ? rawId : null;
     return {
       id,
       fsPath,
@@ -149,11 +352,17 @@ class VitestMocker {
           mock.id,
           mock.importer
         );
-        if (mock.type === "unmock") {
+        if (mock.action === "unmock") {
           this.unmockPath(fsPath);
         }
-        if (mock.type === "mock") {
-          this.mockPath(mock.id, fsPath, external, mock.factory);
+        if (mock.action === "mock") {
+          this.mockPath(
+            mock.id,
+            fsPath,
+            external,
+            mock.type,
+            mock.factory
+          );
         }
       })
     );
@@ -164,23 +373,7 @@ class VitestMocker {
     if (cached) {
       return cached;
     }
-    let exports;
-    try {
-      exports = await mock();
-    } catch (err) {
-      const vitestError = this.createError(
-        '[vitest] There was an error when mocking a module. If you are using "vi.mock" factory, make sure there are no top level variables inside, since this call is hoisted to top of the file. Read more: https://vitest.dev/api/vi.html#vi-mock'
-      );
-      vitestError.cause = err;
-      throw vitestError;
-    }
-    const filepath = dep.slice(5);
-    const mockpath = this.resolveCache.get(this.getSuiteFilepath())?.[filepath] || filepath;
-    if (exports === null || typeof exports !== "object") {
-      throw this.createError(
-        `[vitest] vi.mock("${mockpath}", factory?: () => unknown) is not returning an object. Did you mean to return an object with a "default" key?`
-      );
-    }
+    const exports = await mock.resolve();
     const moduleExports = new Proxy(exports, {
       get: (target, prop) => {
         const val = target[prop];
@@ -193,12 +386,10 @@ class VitestMocker {
             return void 0;
           }
           throw this.createError(
-            `[vitest] No "${String(
-              prop
-            )}" export is defined on the "${mockpath}" mock. Did you forget to return it from "vi.mock"?
+            `[vitest] No "${String(prop)}" export is defined on the "${mock.raw}" mock. Did you forget to return it from "vi.mock"?
 If you need to partially mock a module, you can use "importOriginal" helper inside:
 `,
-            highlight(`vi.mock("${mockpath}", async (importOriginal) => {
+            highlight(`vi.mock(import("${mock.raw}"), async (importOriginal) => {
   const actual = await importOriginal()
   return {
     ...actual,
@@ -213,172 +404,58 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
     this.moduleCache.set(dep, { 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.getMocks()[id];
+    const registry = this.getMockerRegistry();
+    return registry.get(id);
   }
   normalizePath(path) {
     return this.moduleCache.normalizePath(path);
   }
   resolveMockPath(mockPath, external) {
-    const path = external || mockPath;
-    if (external || isNodeBuiltin(mockPath) || !existsSync(mockPath)) {
-      let findFile2 = function(mockFolder2, baseOriginal2) {
-        const files = readdirSync(mockFolder2);
-        for (const file of files) {
-          const baseFile = basename(file, extname(file));
-          if (baseFile === baseOriginal2) {
-            const path2 = resolve(mockFolder2, file);
-            if (fs.statSync(path2).isFile()) {
-              return path2;
-            } else {
-              const indexFile = findFile2(path2, "index");
-              if (indexFile) {
-                return indexFile;
-              }
-            }
-          }
-        }
-        return null;
-      };
-      const mockDirname = dirname(path);
-      const mockFolder = join(this.root, "__mocks__", mockDirname);
-      if (!existsSync(mockFolder)) {
-        return null;
-      }
-      const baseOriginal = basename(path);
-      return findFile2(mockFolder, baseOriginal);
-    }
-    const dir = dirname(path);
-    const baseId = basename(path);
-    const fullPath = resolve(dir, "__mocks__", baseId);
-    return existsSync(fullPath) ? fullPath : null;
-  }
-  mockObject(object, mockExports = {}) {
-    const finalizers = new Array();
-    const refs = new RefTracker();
-    const define = (container, key, value) => {
-      try {
-        container[key] = value;
-        return true;
-      } catch {
-        return false;
-      }
-    };
-    const mockPropertiesOf = (container, newContainer) => {
-      const containerType = getType(container);
-      const isModule = containerType === "Module" || !!container.__esModule;
-      for (const { key: property, descriptor } of getAllMockableProperties(
-        container,
-        isModule,
-        this.primitives
-      )) {
-        if (!isModule && descriptor.get) {
-          try {
-            Object.defineProperty(newContainer, property, descriptor);
-          } catch {
-          }
-          continue;
-        }
-        if (isSpecialProp(property, containerType)) {
-          continue;
-        }
-        const value = container[property];
-        const refId = refs.getId(value);
-        if (refId !== void 0) {
-          finalizers.push(
-            () => define(newContainer, property, refs.getMockedValue(refId))
-          );
-          continue;
-        }
-        const type = getType(value);
-        if (Array.isArray(value)) {
-          define(newContainer, property, []);
-          continue;
-        }
-        const isFunction = type.includes("Function") && typeof value === "function";
-        if ((!isFunction || value.__isMockFunction) && type !== "Object" && type !== "Module") {
-          define(newContainer, property, value);
-          continue;
-        }
-        if (!define(newContainer, property, isFunction ? value : {})) {
-          continue;
-        }
-        if (isFunction) {
-          let mockFunction2 = function() {
-            if (this instanceof newContainer[property]) {
-              for (const { key, descriptor: descriptor2 } of getAllMockableProperties(
-                this,
-                false,
-                primitives
-              )) {
-                if (descriptor2.get) {
-                  continue;
-                }
-                const value2 = this[key];
-                const type2 = getType(value2);
-                const isFunction2 = type2.includes("Function") && typeof value2 === "function";
-                if (isFunction2) {
-                  const original = this[key];
-                  const mock2 = spyModule.spyOn(this, key).mockImplementation(original);
-                  mock2.mockRestore = () => {
-                    mock2.mockReset();
-                    mock2.mockImplementation(original);
-                    return mock2;
-                  };
-                }
-              }
-            }
-          };
-          if (!this.spyModule) {
-            throw this.createError(
-              "[vitest] `spyModule` is not defined. This is Vitest error. Please open a new issue with reproduction."
-            );
-          }
-          const spyModule = this.spyModule;
-          const primitives = this.primitives;
-          const mock = spyModule.spyOn(newContainer, property).mockImplementation(mockFunction2);
-          mock.mockRestore = () => {
-            mock.mockReset();
-            mock.mockImplementation(mockFunction2);
-            return mock;
-          };
-          Object.defineProperty(newContainer[property], "length", { value: 0 });
-        }
-        refs.track(value, newContainer[property]);
-        mockPropertiesOf(value, newContainer[property]);
-      }
-    };
-    const mockedObject = mockExports;
-    mockPropertiesOf(object, mockedObject);
-    for (const finalizer of finalizers) {
-      finalizer();
+    return findMockRedirect(this.root, mockPath, external);
+  }
+  mockObject(object, mockExports = {}, behavior = "automock") {
+    const spyOn = this.spyModule?.spyOn;
+    if (!spyOn) {
+      throw this.createError(
+        "[vitest] `spyModule` is not defined. This is a Vitest error. Please open a new issue with reproduction."
+      );
     }
-    return mockedObject;
+    return mockObject({
+      globalConstructors: this.primitives,
+      spyOn,
+      type: behavior
+    }, object, mockExports);
   }
   unmockPath(path) {
-    const suitefile = this.getSuiteFilepath();
+    const registry = this.getMockerRegistry();
     const id = this.normalizePath(path);
-    const mock = this.mockMap.get(suitefile);
-    if (mock && id in mock) {
-      delete mock[id];
-    }
+    registry.delete(id);
     this.deleteCachedItem(id);
   }
-  mockPath(originalId, path, external, factory) {
+  mockPath(originalId, path, external, mockType, factory) {
+    const registry = this.getMockerRegistry();
     const id = this.normalizePath(path);
-    const suitefile = this.getSuiteFilepath();
-    const mocks = this.mockMap.get(suitefile) || {};
-    const resolves = this.resolveCache.get(suitefile) || {};
-    mocks[id] = factory || this.resolveMockPath(id, external);
-    resolves[id] = originalId;
-    this.mockMap.set(suitefile, mocks);
-    this.resolveCache.set(suitefile, resolves);
+    if (mockType === "manual") {
+      registry.register("manual", originalId, id, factory);
+    } else if (mockType === "autospy") {
+      registry.register("autospy", originalId, id);
+    } else {
+      const redirect = this.resolveMockPath(id, external);
+      if (redirect) {
+        registry.register("redirect", originalId, id, redirect);
+      } else {
+        registry.register("automock", originalId, id);
+      }
+    }
     this.deleteCachedItem(id);
   }
   async importActual(rawId, importer, callstack) {
@@ -394,23 +471,31 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
     const { id, fsPath, external } = await this.resolvePath(rawId, importee);
     const normalizedId = this.normalizePath(fsPath);
     let mock = this.getDependencyMock(normalizedId);
-    if (mock === void 0) {
-      mock = this.resolveMockPath(normalizedId, external);
+    if (!mock) {
+      const redirect = this.resolveMockPath(normalizedId, external);
+      if (redirect) {
+        mock = new RedirectedModule(rawId, normalizedId, redirect);
+      } else {
+        mock = new AutomockedModule(rawId, normalizedId);
+      }
     }
-    if (mock === null) {
+    if (mock.type === "automock" || mock.type === "autospy") {
       const mod = await this.executor.cachedRequest(id, fsPath, [importee]);
-      return this.mockObject(mod);
+      return this.mockObject(mod, {}, mock.type);
     }
-    if (typeof mock === "function") {
+    if (mock.type === "manual") {
       return this.callFunctionMock(fsPath, mock);
     }
-    return this.executor.dependencyRequest(mock, mock, [importee]);
+    return this.executor.dependencyRequest(mock.redirect, mock.redirect, [importee]);
   }
   async requestWithMock(url, callstack) {
     const id = this.normalizePath(url);
     const mock = this.getDependencyMock(id);
+    if (!mock) {
+      return;
+    }
     const mockPath = this.getMockPath(id);
-    if (mock === null) {
+    if (mock.type === "automock" || mock.type === "autospy") {
       const cache = this.moduleCache.get(mockPath);
       if (cache.exports) {
         return cache.exports;
@@ -418,10 +503,10 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
       const exports = {};
       this.moduleCache.set(mockPath, { exports });
       const mod = await this.executor.directRequest(url, url, callstack);
-      this.mockObject(mod, exports);
+      this.mockObject(mod, exports, mock.type);
       return exports;
     }
-    if (typeof mock === "function" && !callstack.includes(mockPath) && !callstack.includes(url)) {
+    if (mock.type === "manual" && !callstack.includes(mockPath) && !callstack.includes(url)) {
       try {
         callstack.push(mockPath);
         this.mockContext.callstack = callstack;
@@ -431,29 +516,37 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
         const indexMock = callstack.indexOf(mockPath);
         callstack.splice(indexMock, 1);
       }
-    }
-    if (typeof mock === "string" && !callstack.includes(mock)) {
-      return mock;
+    } else if (mock.type === "redirect" && !callstack.includes(mock.redirect)) {
+      return mock.redirect;
     }
   }
-  queueMock(id, importer, factory, throwIfCached = false) {
+  queueMock(id, importer, factoryOrOptions) {
+    const mockType = getMockType(factoryOrOptions);
     VitestMocker.pendingIds.push({
-      type: "mock",
+      action: "mock",
       id,
       importer,
-      factory,
-      throwIfCached
+      factory: typeof factoryOrOptions === "function" ? factoryOrOptions : void 0,
+      type: mockType
     });
   }
-  queueUnmock(id, importer, throwIfCached = false) {
+  queueUnmock(id, importer) {
     VitestMocker.pendingIds.push({
-      type: "unmock",
+      action: "unmock",
       id,
-      importer,
-      throwIfCached
+      importer
     });
   }
 }
+function getMockType(factoryOrOptions) {
+  if (!factoryOrOptions) {
+    return "automock";
+  }
+  if (typeof factoryOrOptions === "function") {
+    return "manual";
+  }
+  return factoryOrOptions.spy ? "autospy" : "automock";
+}
 
 const { readFileSync } = fs;
 async function createVitestExecutor(options) {
@@ -536,9 +629,6 @@ async function startVitestExecutor(options) {
     get moduleCache() {
       return state().moduleCache;
     },
-    get mockMap() {
-      return state().mockMap;
-    },
     get interopDefault() {
       return state().config.deps.interopDefault;
     },
@@ -642,7 +732,7 @@ class VitestExecutor extends ViteNodeRunner {
       return false;
     }
     const transformMode = this.state.environment?.transformMode ?? "ssr";
-    return transformMode === "ssr" ? !isNodeBuiltin(id) : !id.startsWith("node:");
+    return transformMode === "ssr" ? !isNodeBuiltin$1(id) : !id.startsWith("node:");
   }
   async originalResolveUrl(id, importer) {
     return super.resolveUrl(id, importer);
@@ -707,7 +797,7 @@ class VitestExecutor extends ViteNodeRunner {
     return super.dependencyRequest(id, fsPath, callstack);
   }
   prepareContext(context) {
-    if (this.state.filepath && normalize(this.state.filepath) === normalize(context.__filename)) {
+    if (this.state.filepath && normalize$1(this.state.filepath) === normalize$1(context.__filename)) {
       const globalNamespace = this.options.context || globalThis;
       Object.defineProperty(context.__vite_ssr_import_meta__, "vitest", {
         // @ts-expect-error injected untyped global