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

package/dist/chunks/{index.Z5E_ObnR.js → index.DlDSLQD3.js}

@@ -1,17 +1,21 @@
-import { b as assert, c as createExpect, g as globalExpect, i as inject, s as should, v as vi, d as vitest } from './vi.2VT5v0um.js';
-import { b as bench } from './benchmark.B3N2zMcH.js';
+import { v as vi, N as NodeBenchmarkRunner, T as TestRunner, a as assert, c as createExpect, g as globalExpect, i as inject, s as should, b as vitest } from './test.CTcmp4Su.js';
+import { b as bench } from './benchmark.D0SlKNbZ.js';
 import { V as VitestEvaluatedModules } from './evaluatedModules.Dg1zASAC.js';
 import { expectTypeOf } from '../vendor/expect-type.mjs';
-import { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, recordArtifact, suite, test } from '../@vitest/runner/index.js';
+import { afterAll, afterEach, aroundAll, aroundEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, recordArtifact, suite, test } from '../@vitest/runner/index.js';
 import { chai } from '../@vitest/expect/index.js';
 
 const assertType = function assertType() {};
 
 var index = /*#__PURE__*/Object.freeze({
   __proto__: null,
+  BenchmarkRunner: NodeBenchmarkRunner,
   EvaluatedModules: VitestEvaluatedModules,
+  TestRunner: TestRunner,
   afterAll: afterAll,
   afterEach: afterEach,
+  aroundAll: aroundAll,
+  aroundEach: aroundEach,
   assert: assert,
   assertType: assertType,
   beforeAll: beforeAll,

package/dist/chunks/{index.CyBMJtT7.js → index.EY6TCHpo.js}

@@ -1,4 +1,4 @@
-import { URL } from 'node:url';
+import { URL as URL$1 } from 'node:url';
 import { Console } from 'node:console';
 
 // SEE https://github.com/jsdom/jsdom/blob/master/lib/jsdom/living/interfaces.js
@@ -537,7 +537,7 @@ var jsdom = {
   }
 };
 function createCompatRequest(utils) {
-  return class Request extends NodeRequest_ {
+  class Request extends NodeRequest_ {
     constructor(...args) {
       const [input, init] = args;
       if (init?.body != null) {
@@ -550,21 +550,23 @@ function createCompatRequest(utils) {
     static [Symbol.hasInstance](instance) {
       return instance instanceof NodeRequest_;
     }
-  };
+  }
+  return Request;
 }
 function createJSDOMCompatURL(utils) {
-  return class URL$1 extends URL {
+  class URL extends URL$1 {
     static createObjectURL(blob) {
       if (blob instanceof utils.window.Blob) {
         const compatBlob = utils.makeCompatBlob(blob);
-        return URL.createObjectURL(compatBlob);
+        return URL$1.createObjectURL(compatBlob);
       }
-      return URL.createObjectURL(blob);
+      return URL$1.createObjectURL(blob);
     }
     static [Symbol.hasInstance](instance) {
-      return instance instanceof URL;
+      return instance instanceof URL$1;
     }
-  };
+  }
+  return URL;
 }
 function createCompatUtils(window) {
   // this returns a hidden Symbol(impl)

package/dist/chunks/{index.D4KonVSU.js → index.og1WyBLx.js}

@@ -1,4 +1,4 @@
-import { resolve, isAbsolute, dirname, join } from 'node:path';
+import { isAbsolute, resolve, dirname, join } from 'node:path';
 import { existsSync } from 'node:fs';
 import 'node:module';
 import 'node:url';
@@ -6,6 +6,21 @@ import { g as getDefaultExportFromCjs } from './_commonjsHelpers.D26ty3Ew.js';
 import require$$0 from 'readline';
 import require$$0$1 from 'events';
 
+function _mergeNamespaces(n, m) {
+  m.forEach(function (e) {
+    e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
+      if (k !== 'default' && !(k in n)) {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  });
+  return Object.freeze(n);
+}
+
 /**
 * Resolve an absolute path from {@link root}, but only
 * if {@link input} isn't already absolute.
@@ -6335,9 +6350,9 @@ function requirePrompts () {
 var promptsExports = requirePrompts();
 var prompt = /*@__PURE__*/getDefaultExportFromCjs(promptsExports);
 
-var index = /*#__PURE__*/Object.freeze({
+var index = /*#__PURE__*/_mergeNamespaces({
   __proto__: null,
   default: prompt
-});
+}, [promptsExports]);
 
 export { any as a, index as i, prompt as p };

package/dist/chunks/{init-forks._y3TW739.js → init-forks.DeArv0jT.js}

@@ -1,4 +1,4 @@
-import { i as init } from './init.B6MLFIaN.js';
+import { i as init } from './init.DICorXCo.js';
 
 if (!process.send) throw new Error("Expected worker to be run in node:child_process");
 // Store globals in case tests overwrite them

package/dist/chunks/{init-threads.DBO2kn-p.js → init-threads.-2OUl4Nn.js}

@@ -1,5 +1,5 @@
 import { isMainThread, parentPort } from 'node:worker_threads';
-import { i as init } from './init.B6MLFIaN.js';
+import { i as init } from './init.DICorXCo.js';
 
 if (isMainThread || !parentPort) throw new Error("Expected worker to be run in node:worker_threads");
 function workerInit(options) {

package/dist/chunks/{init.B6MLFIaN.js → init.DICorXCo.js}

@@ -2,15 +2,17 @@ import { readFileSync } from 'node:fs';
 import { isBuiltin } from 'node:module';
 import { pathToFileURL } from 'node:url';
 import { resolve } from '../vendor/pathe.mjs';
-import { ModuleRunner } from '@voidzero-dev/vite-plus-core/module-runner';
-import { b as VitestTransport } from './startModuleRunner.DEj0jb3e.js';
-import { e as environments } from './index.CyBMJtT7.js';
+import { ModuleRunner, EvaluatedModules } from '@voidzero-dev/vite-plus-core/module-runner';
+import { b as VitestTransport } from './startVitestModuleRunner.C3ZR-4J3.js';
+import { e as environments } from './index.EY6TCHpo.js';
+import { serializeValue } from '../@vitest/utils/serialize.js';
 import { serializeError } from '../@vitest/utils/error.js';
 import { T as Traces } from './traces.CCmnQaNT.js';
-import { o as onCancel, a as rpcDone, c as createRuntimeRpc } from './rpc.BoxB0q7B.js';
+import { o as onCancel, a as rpcDone, c as createRuntimeRpc } from './rpc.MzXet3jl.js';
 import { createStackString, parseStacktrace } from '../@vitest/utils/source-map.js';
 import { s as setupInspect } from './inspector.CvyFGlXm.js';
 import { V as VitestEvaluatedModules } from './evaluatedModules.Dg1zASAC.js';
+import { E as EnvironmentTeardownError } from './utils.BX5Fg8C4.js';
 
 function isBuiltinEnvironment(env) {
   return env in environments;
@@ -40,17 +42,17 @@ function createEnvironmentLoader(root, rpc) {
         async resolveId(id, importer) {
           return rpc.resolve(id, importer, "__vitest__");
         }
-      })
+      }, new EvaluatedModules(), /* @__PURE__ */ new WeakMap())
     });
     _loaders.set(root, moduleRunner);
   }
   return _loaders.get(root);
 }
-async function loadEnvironment(name, root, rpc, traces) {
-  if (isBuiltinEnvironment(name)) return { environment: environments[name] };
-  const loader = createEnvironmentLoader(root, rpc);
-  const packageId = name[0] === "." || name[0] === "/" ? resolve(root, name) : (await traces.$("vitest.runtime.environment.resolve", () => rpc.resolve(`vitest-environment-${name}`, void 0, "__vitest__")))?.id ?? resolve(root, name);
-  const pkg = await traces.$("vitest.runtime.environment.import", () => loader.import(packageId));
+async function loadNativeEnvironment(name, root, traces) {
+  const packageId = name[0] === "." || name[0] === "/" ? pathToFileURL(resolve(root, name)).toString() : import.meta.resolve(`vitest-environment-${name}`, pathToFileURL(root).toString());
+  return resolveEnvironmentFromModule(name, packageId, await traces.$("vitest.runtime.environment.import", () => import(packageId)));
+}
+function resolveEnvironmentFromModule(name, packageId, pkg) {
   if (!pkg || !pkg.default || typeof pkg.default !== "object") throw new TypeError(`Environment "${name}" is not a valid environment. Path "${packageId}" should export default object with a "setup" or/and "setupVM" method.`);
   const environment = pkg.default;
   if (environment.transformMode != null && environment.transformMode !== "web" && environment.transformMode !== "ssr") throw new TypeError(`Environment "${name}" is not a valid environment. Path "${packageId}" should export default object with a "transformMode" method equal to "ssr" or "web", received "${environment.transformMode}".`);
@@ -59,8 +61,15 @@ async function loadEnvironment(name, root, rpc, traces) {
     // keep for backwards compat
     environment.viteEnvironment ??= environment.transformMode === "ssr" ? "ssr" : "client";
   }
+  return environment;
+}
+async function loadEnvironment(name, root, rpc, traces, viteModuleRunner) {
+  if (isBuiltinEnvironment(name)) return { environment: environments[name] };
+  if (!viteModuleRunner) return { environment: await loadNativeEnvironment(name, root, traces) };
+  const loader = createEnvironmentLoader(root, rpc);
+  const packageId = name[0] === "." || name[0] === "/" ? resolve(root, name) : (await traces.$("vitest.runtime.environment.resolve", () => rpc.resolve(`vitest-environment-${name}`, void 0, "__vitest__")))?.id ?? resolve(root, name);
   return {
-    environment,
+    environment: resolveEnvironmentFromModule(name, packageId, await traces.$("vitest.runtime.environment.import", () => loader.import(packageId))),
     loader
   };
 }
@@ -80,6 +89,36 @@ function emitModuleRunner(moduleRunner) {
   moduleRunnerListeners.forEach((l) => l(moduleRunner));
 }
 
+// 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 resolvingModules = /* @__PURE__ */ new Set();
 async function execute(method, ctx, worker, traces) {
   const prepareStart = performance.now();
@@ -90,7 +129,7 @@ async function execute(method, ctx, worker, traces) {
     // do not close the RPC channel so that we can get the error messages sent to the main thread
     cleanups.push(async () => {
       await Promise.all(rpc.$rejectPendingCalls(({ method, reject }) => {
-        reject(/* @__PURE__ */ new Error(`[vitest-worker]: Closing rpc while "${method}" was pending`));
+        reject(new EnvironmentTeardownError(`[vitest-worker]: Closing rpc while "${method}" was pending`));
       }));
     });
     const state = {
@@ -331,4 +370,4 @@ function getFilesWithLocations(files) {
   });
 }
 
-export { emitModuleRunner as e, init as i, loadEnvironment as l };
+export { listenForErrors as a, emitModuleRunner as e, init as i, loadEnvironment as l };

package/dist/chunks/native.DPzPHdi5.js

@@ -0,0 +1,148 @@
+import module$1, { isBuiltin } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { MessageChannel } from 'node:worker_threads';
+import { initSyntaxLexers, hoistMocks } from '../@vitest/mocker/transforms.js';
+import { cleanUrl } from '../@vitest/utils/helpers.js';
+import { p as parse } from './acorn.B2iPLyUM.js';
+import MagicString from '../vendor/magic-string.mjs';
+import { resolve } from '../vendor/pathe.mjs';
+import c from '../vendor/tinyrainbow.mjs';
+import { distDir } from '../path.js';
+import { t as toBuiltin } from './modules.BJuCwlRJ.js';
+import 'node:path';
+
+const NOW_LENGTH = Date.now().toString().length;
+const REGEXP_VITEST = new RegExp(`%3Fvitest=\\d{${NOW_LENGTH}}`);
+const REGEXP_MOCK_ACTUAL = /\?mock=actual/;
+async function setupNodeLoaderHooks(worker) {
+  if (module$1.setSourceMapsSupport) module$1.setSourceMapsSupport(true);
+  else if (process.setSourceMapsEnabled) process.setSourceMapsEnabled(true);
+  if (worker.config.experimental.nodeLoader !== false) await initSyntaxLexers();
+  if (typeof module$1.registerHooks === "function") module$1.registerHooks({
+    resolve(specifier, context, nextResolve) {
+      if (specifier.includes("mock=actual")) {
+        // url is already resolved by `importActual`
+        const moduleId = specifier.replace(REGEXP_MOCK_ACTUAL, "");
+        const builtin = isBuiltin(moduleId);
+        return {
+          url: builtin ? toBuiltin(moduleId) : moduleId,
+          format: builtin ? "builtin" : void 0,
+          shortCircuit: true
+        };
+      }
+      const isVitest = specifier.includes("%3Fvitest=");
+      const result = nextResolve(isVitest ? specifier.replace(REGEXP_VITEST, "") : specifier, context);
+      // avoid tracking /node_modules/ module graph for performance reasons
+      if (context.parentURL && result.url && !result.url.includes("/node_modules/")) worker.rpc.ensureModuleGraphEntry(result.url, context.parentURL).catch(() => {
+        // ignore errors
+      });
+      // this is require for in-source tests to be invalidated if
+      // one of the files already imported it in --maxWorkers=1 --no-isolate
+      if (isVitest) result.url = `${result.url}?vitest=${Date.now()}`;
+      if (worker.config.experimental.nodeLoader === false || !context.parentURL || result.url.includes(distDir) || context.parentURL?.toString().includes(distDir)) return result;
+      const mockedResult = getNativeMocker()?.resolveMockedModule(result.url, context.parentURL);
+      if (mockedResult != null) return mockedResult;
+      return result;
+    },
+    load: worker.config.experimental.nodeLoader === false ? void 0 : createLoadHook()
+  });
+  else if (module$1.register) {
+    if (worker.config.experimental.nodeLoader !== false) console.warn(`${c.bgYellow(" WARNING ")} "module.registerHooks" is not supported in Node.js ${process.version}. This means that some features like module mocking or in-source testing are not supported. Upgrade your Node.js version to at least 22.15 or disable "experimental.nodeLoader" flag manually.\n`);
+    const { port1, port2 } = new MessageChannel();
+    port1.unref();
+    port2.unref();
+    port1.on("message", (data) => {
+      if (!data || typeof data !== "object") return;
+      switch (data.event) {
+        case "register-module-graph-entry": {
+          const { url, parentURL } = data;
+          worker.rpc.ensureModuleGraphEntry(url, parentURL);
+          return;
+        }
+        default: console.error("Unknown message event:", data.event);
+      }
+    });
+    /** Registers {@link file://./../nodejsWorkerLoader.ts} */
+    module$1.register("#nodejs-worker-loader", {
+      parentURL: import.meta.url,
+      data: { port: port2 },
+      transferList: [port2]
+    });
+  } else if (!process.versions.deno && !process.versions.bun) console.warn("\"module.registerHooks\" and \"module.register\" are not supported. Some Vitest features may not work. Please, use Node.js 18.19.0 or higher.");
+}
+function replaceInSourceMarker(url, source, ms) {
+  const re = /import\.meta\.vitest/g;
+  let match;
+  let overridden = false;
+  // eslint-disable-next-line no-cond-assign
+  while (match = re.exec(source)) {
+    const { index, "0": code } = match;
+    overridden = true;
+    // should it support process.vitest for CJS modules?
+    ms().overwrite(index, index + code.length, "IMPORT_META_TEST()");
+  }
+  if (overridden) {
+    const filename = resolve(fileURLToPath(url));
+    // appending instead of prepending because functions are hoisted and we don't change the offset
+    ms().append(`;\nfunction IMPORT_META_TEST() { return typeof __vitest_worker__ !== 'undefined' && __vitest_worker__.filepath === "${filename.replace(/"/g, "\\\"")}" ? __vitest_index__ : undefined; }`);
+  }
+}
+const ignoreFormats = new Set([
+  "addon",
+  "builtin",
+  "wasm"
+]);
+function createLoadHook(_worker) {
+  return (url, context, nextLoad) => {
+    const result = url.includes("mock=") && isBuiltin(cleanUrl(url)) ? { format: "commonjs" } : nextLoad(url, context);
+    if (result.format && ignoreFormats.has(result.format) || url.includes(distDir)) return result;
+    const mocker = getNativeMocker();
+    mocker?.checkCircularManualMock(url);
+    if (url.includes("mock=automock") || url.includes("mock=autospy")) {
+      const automockedResult = mocker?.loadAutomock(url, result);
+      if (automockedResult != null) return automockedResult;
+      return result;
+    }
+    if (url.includes("mock=manual")) {
+      const mockedResult = mocker?.loadManualMock(url, result);
+      if (mockedResult != null) return mockedResult;
+      return result;
+    }
+    // ignore non-vitest modules for performance reasons,
+    // vi.hoisted and vi.mock won't work outside of test files or setup files
+    if (!result.source || !url.includes("vitest=")) return result;
+    const filename = url.startsWith("file://") ? fileURLToPath(url) : url;
+    const source = result.source.toString();
+    const transformedCode = result.format?.includes("typescript") ? module$1.stripTypeScriptTypes(source) : source;
+    let _ms;
+    const ms = () => _ms || (_ms = new MagicString(source));
+    if (source.includes("import.meta.vitest")) replaceInSourceMarker(url, source, ms);
+    hoistMocks(transformedCode, filename, (code) => parse(code, {
+      ecmaVersion: "latest",
+      sourceType: result.format === "module" || result.format === "module-typescript" || result.format === "typescript" ? "module" : "script"
+    }), {
+      magicString: ms,
+      globalThisAccessor: "\"__vitest_mocker__\""
+    });
+    let code;
+    if (_ms) code = `${_ms.toString()}\n//# sourceMappingURL=${genSourceMapUrl(_ms.generateMap({
+      hires: "boundary",
+      source: filename
+    }))}`;
+    else code = source;
+    return {
+      format: result.format,
+      shortCircuit: true,
+      source: code
+    };
+  };
+}
+function genSourceMapUrl(map) {
+  if (typeof map !== "string") map = JSON.stringify(map);
+  return `data:application/json;base64,${Buffer.from(map).toString("base64")}`;
+}
+function getNativeMocker() {
+  return typeof __vitest_mocker__ !== "undefined" ? __vitest_mocker__ : void 0;
+}
+
+export { setupNodeLoaderHooks };

package/dist/chunks/nativeModuleMocker.DndvSdL6.js

@@ -0,0 +1,206 @@
+import module$1, { isBuiltin } from 'node:module';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { automockModule, createManualModuleSource, collectModuleExports } from '../@vitest/mocker/transforms.js';
+import { cleanUrl, createDefer } from '../@vitest/utils/helpers.js';
+import { p as parse } from './acorn.B2iPLyUM.js';
+import { isAbsolute } from '../vendor/pathe.mjs';
+import { t as toBuiltin } from './modules.BJuCwlRJ.js';
+import { B as BareModuleMocker, n as normalizeModuleId } from './startVitestModuleRunner.C3ZR-4J3.js';
+import 'node:fs';
+import './utils.BX5Fg8C4.js';
+import '../@vitest/utils/timers.js';
+import '../path.js';
+import 'node:path';
+import '../module-evaluator.js';
+import 'node:vm';
+import '@voidzero-dev/vite-plus-core/module-runner';
+import './traces.CCmnQaNT.js';
+import '../@vitest/mocker/index.js';
+import '../@vitest/mocker/redirect.js';
+
+class NativeModuleMocker extends BareModuleMocker {
+  wrapDynamicImport(moduleFactory) {
+    if (typeof moduleFactory === "function") return new Promise((resolve, reject) => {
+      this.resolveMocks().finally(() => {
+        moduleFactory().then(resolve, reject);
+      });
+    });
+    return moduleFactory;
+  }
+  resolveMockedModule(url, parentURL) {
+    // don't mock modules inside of packages because there is
+    // a high chance that it uses `require` which is not mockable
+    // because we use top-level await in "manual" mocks.
+    // for the sake of consistency we don't support mocking anything at all
+    if (parentURL.includes("/node_modules/")) return;
+    const moduleId = normalizeModuleId(url.startsWith("file://") ? fileURLToPath(url) : url);
+    const mockedModule = this.getDependencyMock(moduleId);
+    if (!mockedModule) return;
+    if (mockedModule.type === "redirect") return {
+      url: pathToFileURL(mockedModule.redirect).toString(),
+      shortCircuit: true
+    };
+    if (mockedModule.type === "automock" || mockedModule.type === "autospy") return {
+      url: injectQuery(url, parentURL, `mock=${mockedModule.type}`),
+      shortCircuit: true
+    };
+    if (mockedModule.type === "manual") return {
+      url: injectQuery(url, parentURL, "mock=manual"),
+      shortCircuit: true
+    };
+  }
+  loadAutomock(url, result) {
+    const moduleId = cleanUrl(normalizeModuleId(url.startsWith("file://") ? fileURLToPath(url) : url));
+    let source;
+    if (isBuiltin(moduleId)) {
+      const builtinModule = getBuiltinModule(moduleId);
+      const exports$1 = Object.keys(builtinModule);
+      source = `
+import * as builtinModule from '${toBuiltin(moduleId)}?mock=actual'
+
+${exports$1.map((key, index) => {
+        return `
+const __${index} = builtinModule["${key}"]
+export { __${index} as "${key}" }
+`;
+      }).join("")}`;
+    } else source = result.source?.toString();
+    if (source == null) return;
+    const mockType = url.includes("mock=automock") ? "automock" : "autospy";
+    const transformedCode = transformCode(source, result.format || "module", moduleId);
+    try {
+      const ms = automockModule(transformedCode, mockType, (code) => parse(code, {
+        sourceType: "module",
+        ecmaVersion: "latest"
+      }), { id: moduleId });
+      return {
+        format: "module",
+        source: `${ms.toString()}\n//# sourceMappingURL=${genSourceMapUrl(ms.generateMap({
+          hires: "boundary",
+          source: moduleId
+        }))}`,
+        shortCircuit: true
+      };
+    } catch (cause) {
+      throw new Error(`Cannot automock '${url}' because it failed to parse.`, { cause });
+    }
+  }
+  loadManualMock(url, result) {
+    const moduleId = cleanUrl(normalizeModuleId(url.startsWith("file://") ? fileURLToPath(url) : url));
+    // should not be possible
+    if (this.getDependencyMock(moduleId)?.type !== "manual") {
+      console.warn(`Vitest detected unregistered manual mock ${moduleId}. This is a bug in Vitest. Please, open a new issue with reproduction.`);
+      return;
+    }
+    if (isBuiltin(moduleId)) {
+      const builtinModule = getBuiltinModule(toBuiltin(moduleId));
+      return {
+        format: "module",
+        source: createManualModuleSource(moduleId, Object.keys(builtinModule)),
+        shortCircuit: true
+      };
+    }
+    if (!result.source) return;
+    const transformedCode = transformCode(result.source.toString(), result.format || "module", moduleId);
+    if (transformedCode == null) return;
+    const format = result.format?.startsWith("module") ? "module" : "commonjs";
+    try {
+      return {
+        format: "module",
+        source: createManualModuleSource(moduleId, collectModuleExports(moduleId, transformedCode, format)),
+        shortCircuit: true
+      };
+    } catch (cause) {
+      throw new Error(`Failed to mock '${url}'. See the cause for more information.`, { cause });
+    }
+  }
+  processedModules = /* @__PURE__ */ new Map();
+  checkCircularManualMock(url) {
+    const id = cleanUrl(normalizeModuleId(url.startsWith("file://") ? fileURLToPath(url) : url));
+    this.processedModules.set(id, (this.processedModules.get(id) ?? 0) + 1);
+    // the module is mocked and requested a second time, let's resolve
+    // the factory function that will redefine the exports later
+    if (this.originalModulePromises.has(id)) {
+      const factoryPromise = this.factoryPromises.get(id);
+      this.originalModulePromises.get(id)?.resolve({ __factoryPromise: factoryPromise });
+    }
+  }
+  originalModulePromises = /* @__PURE__ */ new Map();
+  factoryPromises = /* @__PURE__ */ new Map();
+  // potential performance improvement:
+  // store by URL, not ids, no need to call url.*to* methods and normalizeModuleId
+  getFactoryModule(id) {
+    const mock = this.getMockerRegistry().getById(id);
+    if (!mock || mock.type !== "manual") throw new Error(`Mock ${id} wasn't registered. This is probably a Vitest error. Please, open a new issue with reproduction.`);
+    const mockResult = mock.resolve();
+    if (mockResult instanceof Promise) {
+      // to avoid circular dependency, we resolve this function as {__factoryPromise} in `checkCircularManualMock`
+      // when it's requested the second time. then the exports are exposed as `undefined`,
+      // but later redefined when the promise is actually resolved
+      const promise = createDefer();
+      promise.finally(() => {
+        this.originalModulePromises.delete(id);
+      });
+      mockResult.then(promise.resolve, promise.reject).finally(() => {
+        this.factoryPromises.delete(id);
+      });
+      this.factoryPromises.set(id, mockResult);
+      this.originalModulePromises.set(id, promise);
+      // Node.js on windows processes all the files first, and then runs them
+      // unlike Node.js logic on Mac and Unix where it also runs the code while evaluating
+      // So on Linux/Mac this `if` won't be hit because `checkCircularManualMock` will resolve it
+      // And on Windows, the `checkCircularManualMock` will never have `originalModulePromises`
+      // because `getFactoryModule` is not called until the evaluation phase
+      // But if we track how many times the module was transformed,
+      // we can deduce when to return `__factoryPromise` to support circular modules
+      if ((this.processedModules.get(id) ?? 0) > 1) {
+        this.processedModules.set(id, (this.processedModules.get(id) ?? 1) - 1);
+        promise.resolve({ __factoryPromise: mockResult });
+      }
+      return promise;
+    }
+    return mockResult;
+  }
+  importActual(rawId, importer) {
+    const resolvedId = import.meta.resolve(rawId, pathToFileURL(importer).toString());
+    const url = new URL(resolvedId);
+    url.searchParams.set("mock", "actual");
+    return import(url.toString());
+  }
+  importMock(rawId, importer) {
+    const resolvedId = import.meta.resolve(rawId, pathToFileURL(importer).toString());
+    // file is already mocked
+    if (resolvedId.includes("mock=")) return import(resolvedId);
+    const filename = fileURLToPath(resolvedId);
+    const external = !isAbsolute(filename) || this.isModuleDirectory(resolvedId) ? normalizeModuleId(rawId) : null;
+    // file is not mocked, automock or redirect it
+    const redirect = this.findMockRedirect(filename, external);
+    if (redirect) return import(pathToFileURL(redirect).toString());
+    const url = new URL(resolvedId);
+    url.searchParams.set("mock", "automock");
+    return import(url.toString());
+  }
+}
+const replacePercentageRE = /%/g;
+function injectQuery(url, importer, queryToInject) {
+  const { search, hash } = new URL(url.replace(replacePercentageRE, "%25"), importer);
+  return `${cleanUrl(url)}?${queryToInject}${search ? `&${search.slice(1)}` : ""}${hash ?? ""}`;
+}
+let __require;
+function getBuiltinModule(moduleId) {
+  __require ??= module$1.createRequire(import.meta.url);
+  return __require(`${moduleId}?mock=actual`);
+}
+function genSourceMapUrl(map) {
+  if (typeof map !== "string") map = JSON.stringify(map);
+  return `data:application/json;base64,${Buffer.from(map).toString("base64")}`;
+}
+function transformCode(code, format, filename) {
+  if (format.includes("typescript")) {
+    if (!module$1.stripTypeScriptTypes) throw new Error(`Cannot parse '${filename}' because "module.stripTypeScriptTypes" is not supported. Module mocking requires Node.js 22.15 or higher. This is NOT a bug of Vitest.`);
+    return module$1.stripTypeScriptTypes(code);
+  }
+  return code;
+}
+
+export { NativeModuleMocker };

package/dist/chunks/nativeModuleRunner.BIakptoF.js

@@ -0,0 +1,36 @@
+import { pathToFileURL } from 'node:url';
+import { r as resolveModule } from './index.BCY_7LL2.js';
+import { resolve } from '../vendor/pathe.mjs';
+import { ModuleRunner } from '@voidzero-dev/vite-plus-core/module-runner';
+
+class NativeModuleRunner extends ModuleRunner {
+  /**
+  * @internal
+  */
+  mocker;
+  constructor(root, mocker) {
+    super({
+      hmr: false,
+      sourcemapInterceptor: false,
+      transport: { invoke() {
+        throw new Error("Unexpected `invoke`");
+      } }
+    });
+    this.root = root;
+    this.mocker = mocker;
+    if (mocker) Object.defineProperty(globalThis, "__vitest_mocker__", {
+      configurable: true,
+      writable: true,
+      value: mocker
+    });
+  }
+  async import(moduleId) {
+    const path = resolveModule(moduleId, { paths: [this.root] }) ?? resolve(this.root, moduleId);
+    // resolveModule doesn't keep the query params, so we need to add them back
+    let queryParams = "";
+    if (moduleId.includes("?") && !path.includes("?")) queryParams = moduleId.slice(moduleId.indexOf("?"));
+    return import(pathToFileURL(path + queryParams).toString());
+  }
+}
+
+export { NativeModuleRunner as N };

package/dist/chunks/{node.Ce0vMQM7.js → node.COQbm6gK.js}

@@ -1,5 +1,5 @@
 import { NodeSnapshotEnvironment } from '../@vitest/snapshot/environment.js';
-import { g as getWorkerState } from './utils.DvEY5TfP.js';
+import { g as getWorkerState } from './utils.BX5Fg8C4.js';
 import '../@vitest/utils/timers.js';
 
 class VitestNodeSnapshotEnvironment extends NodeSnapshotEnvironment {

package/dist/chunks/{plugin.d.CtqpEehP.d.ts → plugin.d.BuW-flqo.d.ts}

@@ -1,5 +1,5 @@
 import { DevEnvironment } from '@voidzero-dev/vite-plus-core';
-import { V as Vitest, T as TestProject, b as TestProjectConfiguration } from './reporters.d.CWXNI2jG.js';
+import { V as Vitest, T as TestProject, a as TestProjectConfiguration } from './reporters.d.DVUYHHhe.js';
 
 /**
 * Generate a unique cache identifier.