vitest 0.33.0 → 0.34.0

package/dist/config.d.ts

@@ -1,9 +1,10 @@
 import { UserConfig as UserConfig$1, ConfigEnv } from 'vite';
 export { ConfigEnv, UserConfig, mergeConfig } from 'vite';
-import { c as ResolvedCoverageOptions, U as UserConfig, d as CoverageV8Options, e as CoverageC8Options, f as CustomProviderOptions, g as CoverageIstanbulOptions, H as HtmlOptions, F as FileOptions, h as CloverOptions, i as CoberturaOptions, j as HtmlSpaOptions, L as LcovOptions, k as LcovOnlyOptions, T as TeamcityOptions, l as TextOptions, P as ProjectOptions, m as FakeTimerInstallOpts, n as ProjectConfig } from './types-198fd1d9.js';
+import { c as ResolvedCoverageOptions, U as UserConfig, d as CoverageV8Options, P as ProjectConfig } from './types-3c7dbfa5.js';
 import '@vitest/snapshot';
 import '@vitest/expect';
 import '@vitest/runner';
+import 'vite-node';
 import '@vitest/runner/utils';
 import '@vitest/utils';
 import 'tinybench';
@@ -11,7 +12,7 @@ import 'vite-node/client';
 import '@vitest/snapshot/manager';
 import 'vite-node/server';
 import 'node:worker_threads';
-import 'vite-node';
+import 'rollup';
 import 'node:fs';
 import 'chai';
 
@@ -46,22 +47,12 @@ declare const config: {
     css: {
         include: never[];
     };
-    coverage: {
-        provider: "v8";
-    } & CoverageV8Options & Required<Pick<({
-        provider?: undefined;
-    } & CoverageC8Options) | ({
-        provider: "custom";
-    } & CustomProviderOptions) | ({
-        provider: "c8";
-    } & CoverageC8Options) | ({
-        provider: "v8";
-    } & CoverageV8Options) | ({
-        provider: "istanbul";
-    } & CoverageIstanbulOptions), "exclude" | "enabled" | "clean" | "cleanOnRerun" | "reportsDirectory" | "extension" | "reportOnFailure">> & {
-        reporter: (["html", Partial<HtmlOptions>] | ["none", {}] | ["json", Partial<FileOptions>] | ["clover", Partial<CloverOptions>] | ["cobertura", Partial<CoberturaOptions>] | ["html-spa", Partial<HtmlSpaOptions>] | ["json-summary", Partial<FileOptions>] | ["lcov", Partial<LcovOptions>] | ["lcovonly", Partial<LcovOnlyOptions>] | ["teamcity", Partial<TeamcityOptions>] | ["text", Partial<TextOptions>] | ["text-lcov", Partial<ProjectOptions>] | ["text-summary", Partial<FileOptions>])[];
+    coverage: CoverageV8Options;
+    fakeTimers: {
+        loopLimit: number;
+        shouldClearNativeTimers: true;
+        toFake: ("setTimeout" | "setInterval" | "clearInterval" | "clearTimeout" | "setImmediate" | "clearImmediate" | "Date")[];
     };
-    fakeTimers: FakeTimerInstallOpts;
     maxConcurrency: number;
     dangerouslyIgnoreUnhandledErrors: boolean;
     typecheck: {
@@ -77,10 +68,15 @@ interface UserWorkspaceConfig extends UserConfig$1 {
     test?: ProjectConfig;
 }
 
+type UserConfigFnObject = (env: ConfigEnv) => UserConfig$1;
+type UserConfigFnPromise = (env: ConfigEnv) => Promise<UserConfig$1>;
 type UserConfigFn = (env: ConfigEnv) => UserConfig$1 | Promise<UserConfig$1>;
-type UserConfigExport = UserConfig$1 | Promise<UserConfig$1> | UserConfigFn;
+type UserConfigExport = UserConfig$1 | Promise<UserConfig$1> | UserConfigFnObject | UserConfigFnPromise | UserConfigFn;
 type UserProjectConfigFn = (env: ConfigEnv) => UserWorkspaceConfig | Promise<UserWorkspaceConfig>;
 type UserProjectConfigExport = UserWorkspaceConfig | Promise<UserWorkspaceConfig> | UserProjectConfigFn;
+declare function defineConfig(config: UserConfig$1): UserConfig$1;
+declare function defineConfig(config: Promise<UserConfig$1>): Promise<UserConfig$1>;
+declare function defineConfig(config: UserConfigFnObject): UserConfigFnObject;
 declare function defineConfig(config: UserConfigExport): UserConfigExport;
 declare function defineProject(config: UserProjectConfigExport): UserProjectConfigExport;
 declare function defineWorkspace(config: (string | (UserProjectConfigExport & {
@@ -89,4 +85,4 @@ declare function defineWorkspace(config: (string | (UserProjectConfigExport & {
     extends?: string | undefined;
 }))[];
 
-export { UserConfigExport, UserConfigFn, UserProjectConfigExport, UserProjectConfigFn, UserWorkspaceConfig, configDefaults, coverageConfigDefaults, defaultExclude, defaultInclude, defineConfig, defineProject, defineWorkspace };
+export { UserConfigExport, UserConfigFn, UserConfigFnObject, UserConfigFnPromise, UserProjectConfigExport, UserProjectConfigFn, UserWorkspaceConfig, configDefaults, coverageConfigDefaults, defaultExclude, defaultInclude, defineConfig, defineProject, defineWorkspace };

package/dist/config.js

@@ -11,6 +11,9 @@ const defaultCoverageExcludes = [
   "dist/**",
   "packages/*/test?(s)/**",
   "**/*.d.ts",
+  "**/virtual:*",
+  "**/__x00__*",
+  "**/\0*",
   "cypress/**",
   "test?(s)/**",
   "test?(-*).?(c|m)[jt]s?(x)",
@@ -26,10 +29,8 @@ const coverageConfigDefaults = {
   cleanOnRerun: true,
   reportsDirectory: "./coverage",
   exclude: defaultCoverageExcludes,
-  reportOnFailure: true,
+  reportOnFailure: false,
   reporter: [["text", {}], ["html", {}], ["clover", {}], ["json", {}]],
-  // default extensions used by c8, plus '.vue' and '.svelte'
-  // see https://github.com/istanbuljs/schema/blob/master/default-extension.js
   extension: [".js", ".cjs", ".mjs", ".ts", ".mts", ".cts", ".tsx", ".jsx", ".vue", ".svelte"]
 };
 const fakeTimersDefaults = {

package/dist/coverage.d.ts

@@ -1,8 +1,9 @@
-import { B as BaseCoverageOptions, c as ResolvedCoverageOptions } from './types-198fd1d9.js';
+import { B as BaseCoverageOptions, c as ResolvedCoverageOptions } from './types-3c7dbfa5.js';
 import '@vitest/snapshot';
 import '@vitest/expect';
 import 'vite';
 import '@vitest/runner';
+import 'vite-node';
 import '@vitest/runner/utils';
 import '@vitest/utils';
 import 'tinybench';
@@ -10,7 +11,7 @@ import 'vite-node/client';
 import '@vitest/snapshot/manager';
 import 'vite-node/server';
 import 'node:worker_threads';
-import 'vite-node';
+import 'rollup';
 import 'node:fs';
 import 'chai';
 

package/dist/entry-vm.js

@@ -0,0 +1,60 @@
+import { isatty } from 'node:tty';
+import { createRequire } from 'node:module';
+import { performance } from 'node:perf_hooks';
+import { startTests } from '@vitest/runner';
+import { setupColors, createColors } from '@vitest/utils';
+import { V as VitestSnapshotEnvironment, s as setupChaiConfig, r as resolveTestRunner } from './vendor-index.9378c9a4.js';
+import { s as startCoverageInsideWorker, a as stopCoverageInsideWorker } from './vendor-coverage.78040316.js';
+import { g as getWorkerState } from './vendor-global.97e4527c.js';
+import { i as index } from './vendor-index.eff408fd.js';
+import { setupCommonEnv } from './browser.js';
+import 'chai';
+import '@vitest/snapshot/environment';
+import 'pathe';
+import './vendor-paths.84fc7a99.js';
+import 'node:url';
+import './vendor-rpc.cbd8e972.js';
+import './vendor-vi.271667ef.js';
+import '@vitest/runner/utils';
+import './vendor-index.087d1af7.js';
+import 'std-env';
+import './vendor-_commonjsHelpers.7d1333e8.js';
+import '@vitest/expect';
+import '@vitest/snapshot';
+import '@vitest/utils/error';
+import './vendor-source-map.e6c1997b.js';
+import 'util';
+import './vendor-date.6e993429.js';
+import '@vitest/spy';
+import './vendor-run-once.3e5ef7d7.js';
+
+async function run(files, config, executor) {
+  const workerState = getWorkerState();
+  await setupCommonEnv(config);
+  Object.defineProperty(globalThis, "__vitest_index__", {
+    value: index,
+    enumerable: false
+  });
+  config.snapshotOptions.snapshotEnvironment = new VitestSnapshotEnvironment(workerState.rpc);
+  setupColors(createColors(isatty(1)));
+  if (workerState.environment.transformMode === "web") {
+    const _require = createRequire(import.meta.url);
+    _require.extensions[".css"] = () => ({});
+    _require.extensions[".scss"] = () => ({});
+    _require.extensions[".sass"] = () => ({});
+    _require.extensions[".less"] = () => ({});
+  }
+  await startCoverageInsideWorker(config.coverage, executor);
+  if (config.chaiConfig)
+    setupChaiConfig(config.chaiConfig);
+  const runner = await resolveTestRunner(config, executor);
+  workerState.durations.prepare = performance.now() - workerState.durations.prepare;
+  for (const file of files) {
+    workerState.filepath = file;
+    await startTests([file], runner);
+    workerState.filepath = void 0;
+  }
+  await stopCoverageInsideWorker(config.coverage, executor);
+}
+
+export { run };

package/dist/entry.js

@@ -1,20 +1,17 @@
 import { performance } from 'node:perf_hooks';
 import { startTests } from '@vitest/runner';
-import { resolve } from 'pathe';
-import { r as resetModules } from './vendor-index.23ac4e13.js';
-import { R as RealDate, d as globalExpect, s as setupChaiConfig, v as vi } from './vendor-vi.dd6706cb.js';
-import { d as distDir } from './vendor-paths.84fc7a99.js';
-import { s as startCoverageInsideWorker, t as takeCoverageInsideWorker, a as stopCoverageInsideWorker } from './vendor-coverage.2e41927a.js';
+import './vendor-index.087d1af7.js';
+import { d as globalExpect, r as resetModules, v as vi } from './vendor-vi.271667ef.js';
+import { s as startCoverageInsideWorker, a as stopCoverageInsideWorker } from './vendor-coverage.78040316.js';
+import { V as VitestSnapshotEnvironment, s as setupChaiConfig, r as resolveTestRunner } from './vendor-index.9378c9a4.js';
 import { createRequire } from 'node:module';
 import { isatty } from 'node:tty';
 import { installSourcemapsSupport } from 'vite-node/source-map';
 import { setupColors, createColors, getSafeTimers } from '@vitest/utils';
-import { e as environments } from './vendor-environments.392ddf08.js';
-import { NodeSnapshotEnvironment } from '@vitest/snapshot/environment';
-import { a as rpc } from './vendor-rpc.ad5b08c7.js';
-import { i as index } from './vendor-index.2af39fbb.js';
+import { i as index } from './vendor-index.eff408fd.js';
 import { setupCommonEnv } from './browser.js';
-import { g as getWorkerState } from './vendor-global.6795f91f.js';
+import { g as getWorkerState } from './vendor-global.97e4527c.js';
+import 'pathe';
 import 'std-env';
 import '@vitest/runner/utils';
 import 'chai';
@@ -22,25 +19,18 @@ import './vendor-_commonjsHelpers.7d1333e8.js';
 import '@vitest/expect';
 import '@vitest/snapshot';
 import '@vitest/utils/error';
-import './vendor-tasks.f9d75aed.js';
+import './vendor-source-map.e6c1997b.js';
 import 'util';
+import './vendor-date.6e993429.js';
 import '@vitest/spy';
+import '@vitest/snapshot/environment';
+import './vendor-paths.84fc7a99.js';
 import 'node:url';
-import 'node:console';
-import 'local-pkg';
-import './vendor-run-once.1fa85ba7.js';
-
-class VitestSnapshotEnvironment extends NodeSnapshotEnvironment {
-  getHeader() {
-    return `// Vitest Snapshot v${this.getVersion()}, https://vitest.dev/guide/snapshot.html`;
-  }
-  resolvePath(filepath) {
-    return rpc().resolveSnapshotPath(filepath);
-  }
-}
+import './vendor-rpc.cbd8e972.js';
+import './vendor-run-once.3e5ef7d7.js';
 
 let globalSetup = false;
-async function setupGlobalEnv(config) {
+async function setupGlobalEnv(config, { environment }) {
   await setupCommonEnv(config);
   Object.defineProperty(globalThis, "__vitest_index__", {
     value: index,
@@ -48,140 +38,33 @@ async function setupGlobalEnv(config) {
   });
   const state = getWorkerState();
   if (!state.config.snapshotOptions.snapshotEnvironment)
-    state.config.snapshotOptions.snapshotEnvironment = new VitestSnapshotEnvironment();
+    state.config.snapshotOptions.snapshotEnvironment = new VitestSnapshotEnvironment(state.rpc);
   if (globalSetup)
     return;
   globalSetup = true;
   setupColors(createColors(isatty(1)));
-  const _require = createRequire(import.meta.url);
-  _require.extensions[".css"] = () => ({});
-  _require.extensions[".scss"] = () => ({});
-  _require.extensions[".sass"] = () => ({});
-  _require.extensions[".less"] = () => ({});
+  if (environment.transformMode === "web") {
+    const _require = createRequire(import.meta.url);
+    _require.extensions[".css"] = () => ({});
+    _require.extensions[".scss"] = () => ({});
+    _require.extensions[".sass"] = () => ({});
+    _require.extensions[".less"] = () => ({});
+  }
   installSourcemapsSupport({
     getSourceMap: (source) => state.moduleCache.getSourceMap(source)
   });
-  await setupConsoleLogSpy();
-}
-async function setupConsoleLogSpy() {
-  const stdoutBuffer = /* @__PURE__ */ new Map();
-  const stderrBuffer = /* @__PURE__ */ new Map();
-  const timers = /* @__PURE__ */ new Map();
-  const unknownTestId = "__vitest__unknown_test__";
-  const { Writable } = await import('node:stream');
-  const { Console } = await import('node:console');
-  const { setTimeout, clearTimeout } = getSafeTimers();
-  function schedule(taskId) {
-    const timer = timers.get(taskId);
-    const { stdoutTime, stderrTime } = timer;
-    clearTimeout(timer.timer);
-    timer.timer = setTimeout(() => {
-      if (stderrTime < stdoutTime) {
-        sendStderr(taskId);
-        sendStdout(taskId);
-      } else {
-        sendStdout(taskId);
-        sendStderr(taskId);
-      }
-    });
-  }
-  function sendStdout(taskId) {
-    const buffer = stdoutBuffer.get(taskId);
-    if (!buffer)
-      return;
-    const content = buffer.map((i) => String(i)).join("");
-    const timer = timers.get(taskId);
-    rpc().onUserConsoleLog({
-      type: "stdout",
-      content: content || "<empty line>",
-      taskId,
-      time: timer.stdoutTime || RealDate.now(),
-      size: buffer.length
-    });
-    stdoutBuffer.set(taskId, []);
-    timer.stdoutTime = 0;
-  }
-  function sendStderr(taskId) {
-    const buffer = stderrBuffer.get(taskId);
-    if (!buffer)
-      return;
-    const content = buffer.map((i) => String(i)).join("");
-    const timer = timers.get(taskId);
-    rpc().onUserConsoleLog({
-      type: "stderr",
-      content: content || "<empty line>",
-      taskId,
-      time: timer.stderrTime || RealDate.now(),
-      size: buffer.length
-    });
-    stderrBuffer.set(taskId, []);
-    timer.stderrTime = 0;
-  }
-  const stdout = new Writable({
-    write(data, encoding, callback) {
-      var _a, _b;
-      const id = ((_b = (_a = getWorkerState()) == null ? void 0 : _a.current) == null ? void 0 : _b.id) ?? unknownTestId;
-      let timer = timers.get(id);
-      if (timer) {
-        timer.stdoutTime = timer.stdoutTime || RealDate.now();
-      } else {
-        timer = { stdoutTime: RealDate.now(), stderrTime: RealDate.now(), timer: 0 };
-        timers.set(id, timer);
-      }
-      let buffer = stdoutBuffer.get(id);
-      if (!buffer) {
-        buffer = [];
-        stdoutBuffer.set(id, buffer);
-      }
-      buffer.push(data);
-      schedule(id);
-      callback();
-    }
-  });
-  const stderr = new Writable({
-    write(data, encoding, callback) {
-      var _a, _b;
-      const id = ((_b = (_a = getWorkerState()) == null ? void 0 : _a.current) == null ? void 0 : _b.id) ?? unknownTestId;
-      let timer = timers.get(id);
-      if (timer) {
-        timer.stderrTime = timer.stderrTime || RealDate.now();
-      } else {
-        timer = { stderrTime: RealDate.now(), stdoutTime: RealDate.now(), timer: 0 };
-        timers.set(id, timer);
-      }
-      let buffer = stderrBuffer.get(id);
-      if (!buffer) {
-        buffer = [];
-        stderrBuffer.set(id, buffer);
-      }
-      buffer.push(data);
-      schedule(id);
-      callback();
-    }
-  });
-  globalThis.console = new Console({
-    stdout,
-    stderr,
-    colorMode: true,
-    groupIndentation: 2
-  });
+  await setupConsoleLogSpy(state);
 }
-async function loadEnvironment(name, executor) {
-  const pkg = await executor.executeId(`vitest-environment-${name}`);
-  if (!pkg || !pkg.default || typeof pkg.default !== "object" || typeof pkg.default.setup !== "function") {
-    throw new Error(
-      `Environment "${name}" is not a valid environment. Package "vitest-environment-${name}" should have default export with "setup" method.`
-    );
-  }
-  return pkg.default;
+async function setupConsoleLogSpy(state) {
+  const { createCustomConsole } = await import('./chunk-runtime-console.ea222ffb.js');
+  globalThis.console = createCustomConsole(state);
 }
-async function withEnv(name, options, executor, fn) {
-  const config = environments[name] || await loadEnvironment(name, executor);
-  globalThis.__vitest_environment__ = config.name || name;
+async function withEnv({ environment }, options, fn) {
+  globalThis.__vitest_environment__ = environment.name;
   globalExpect.setState({
-    environment: config.name || name || "node"
+    environment: environment.name
   });
-  const env = await config.setup(globalThis, options);
+  const env = await environment.setup(globalThis, options);
   try {
     await fn();
   } finally {
@@ -191,83 +74,21 @@ async function withEnv(name, options, executor, fn) {
   }
 }
 
-const runnersFile = resolve(distDir, "runners.js");
-async function getTestRunnerConstructor(config, executor) {
-  if (!config.runner) {
-    const { VitestTestRunner, NodeBenchmarkRunner } = await executor.executeFile(runnersFile);
-    return config.mode === "test" ? VitestTestRunner : NodeBenchmarkRunner;
-  }
-  const mod = await executor.executeId(config.runner);
-  if (!mod.default && typeof mod.default !== "function")
-    throw new Error(`Runner must export a default function, but got ${typeof mod.default} imported from ${config.runner}`);
-  return mod.default;
-}
-async function getTestRunner(config, executor) {
-  const TestRunner = await getTestRunnerConstructor(config, executor);
-  const testRunner = new TestRunner(config);
-  Object.defineProperty(testRunner, "__vitest_executor", {
-    value: executor,
-    enumerable: false,
-    configurable: false
-  });
-  if (!testRunner.config)
-    testRunner.config = config;
-  if (!testRunner.importFile)
-    throw new Error('Runner must implement "importFile" method.');
-  const originalOnTaskUpdate = testRunner.onTaskUpdate;
-  testRunner.onTaskUpdate = async (task) => {
-    const p = rpc().onTaskUpdate(task);
-    await (originalOnTaskUpdate == null ? void 0 : originalOnTaskUpdate.call(testRunner, task));
-    return p;
-  };
-  const originalOnCollected = testRunner.onCollected;
-  testRunner.onCollected = async (files) => {
-    const state = getWorkerState();
-    files.forEach((file) => {
-      file.prepareDuration = state.durations.prepare;
-      file.environmentLoad = state.durations.environment;
-      state.durations.prepare = 0;
-      state.durations.environment = 0;
-    });
-    rpc().onCollected(files);
-    await (originalOnCollected == null ? void 0 : originalOnCollected.call(testRunner, files));
-  };
-  const originalOnAfterRun = testRunner.onAfterRun;
-  testRunner.onAfterRun = async (files) => {
-    const coverage = await takeCoverageInsideWorker(config.coverage, executor);
-    rpc().onAfterSuiteRun({ coverage });
-    await (originalOnAfterRun == null ? void 0 : originalOnAfterRun.call(testRunner, files));
-  };
-  const originalOnAfterRunTest = testRunner.onAfterRunTest;
-  testRunner.onAfterRunTest = async (test) => {
-    var _a, _b;
-    if (config.bail && ((_a = test.result) == null ? void 0 : _a.state) === "fail") {
-      const previousFailures = await rpc().getCountOfFailedTests();
-      const currentFailures = 1 + previousFailures;
-      if (currentFailures >= config.bail) {
-        rpc().onCancel("test-failure");
-        (_b = testRunner.onCancel) == null ? void 0 : _b.call(testRunner, "test-failure");
-      }
-    }
-    await (originalOnAfterRunTest == null ? void 0 : originalOnAfterRunTest.call(testRunner, test));
-  };
-  return testRunner;
-}
 async function run(files, config, environment, executor) {
   const workerState = getWorkerState();
-  await setupGlobalEnv(config);
+  await setupGlobalEnv(config, environment);
   await startCoverageInsideWorker(config.coverage, executor);
   if (config.chaiConfig)
     setupChaiConfig(config.chaiConfig);
-  const runner = await getTestRunner(config, executor);
+  const runner = await resolveTestRunner(config, executor);
   workerState.onCancel.then((reason) => {
     var _a;
     return (_a = runner.onCancel) == null ? void 0 : _a.call(runner, reason);
   });
   workerState.durations.prepare = performance.now() - workerState.durations.prepare;
-  globalThis.__vitest_environment__ = environment;
+  workerState.environment = environment.environment;
   workerState.durations.environment = performance.now();
-  await withEnv(environment.name, environment.options || config.environmentOptions || {}, executor, async () => {
+  await withEnv(environment, environment.options || config.environmentOptions || {}, async () => {
     workerState.durations.environment = performance.now() - workerState.durations.environment;
     for (const file of files) {
       if (config.isolate) {

package/dist/environments.d.ts

@@ -1,8 +1,9 @@
-import { E as Environment } from './types-198fd1d9.js';
+import { E as Environment } from './types-3c7dbfa5.js';
 import '@vitest/snapshot';
 import '@vitest/expect';
 import 'vite';
 import '@vitest/runner';
+import 'vite-node';
 import '@vitest/runner/utils';
 import '@vitest/utils';
 import 'tinybench';
@@ -10,7 +11,7 @@ import 'vite-node/client';
 import '@vitest/snapshot/manager';
 import 'vite-node/server';
 import 'node:worker_threads';
-import 'vite-node';
+import 'rollup';
 import 'node:fs';
 import 'chai';
 

package/dist/environments.js

@@ -1,3 +1,5 @@
-export { e as builtinEnvironments, p as populateGlobal } from './vendor-environments.392ddf08.js';
-import 'node:console';
+export { e as builtinEnvironments, p as populateGlobal } from './vendor-environments.443ecd82.js';
+import 'node:url';
+import 'pathe';
 import 'local-pkg';
+import 'node:console';

package/dist/execute.js

@@ -0,0 +1,15 @@
+export { V as VitestExecutor } from './vendor-execute.9ab1c1a7.js';
+import 'node:url';
+import 'node:vm';
+import 'vite-node/client';
+import 'vite-node/utils';
+import 'pathe';
+import '@vitest/utils/error';
+import './vendor-paths.84fc7a99.js';
+import './vendor-global.97e4527c.js';
+import 'node:fs';
+import '@vitest/utils';
+import './vendor-base.9c08bbd0.js';
+import 'node:path';
+import 'node:module';
+import 'vite-node/constants';

package/dist/index.d.ts

@@ -1,13 +1,14 @@
-import { File, TaskResultPack, CancelReason } from '@vitest/runner';
+import { Test, File, TaskResultPack, CancelReason } from '@vitest/runner';
 export { DoneCallback, File, HookCleanupCallback, HookListener, OnTestFailedHandler, RunMode, RuntimeContext, SequenceHooks, SequenceSetupFiles, Suite, SuiteAPI, SuiteCollector, SuiteFactory, SuiteHooks, Task, TaskBase, TaskMeta, TaskResult, TaskResultPack, TaskState, Test, TestAPI, TestContext, TestFunction, TestOptions, afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, suite, test } from '@vitest/runner';
-import { v as BenchmarkAPI, m as FakeTimerInstallOpts, w as MockFactoryWithHelper, x as RuntimeConfig, A as AfterSuiteRunMeta, y as UserConsoleLog, R as ResolvedConfig, z as ModuleGraphData, D as Reporter } from './types-198fd1d9.js';
-export { a2 as ApiConfig, ah as ArgumentsType, ag as Arrayable, ae as Awaitable, B as BaseCoverageOptions, as as BenchFunction, aq as Benchmark, ar as BenchmarkResult, ap as BenchmarkUserOptions, _ as BuiltinEnvironment, a1 as CSSModuleScopeStrategy, K as ChaiConfig, Q as CollectLineNumbers, S as CollectLines, aj as Constructable, Y as Context, aa as ContextRPC, a9 as ContextTestEnvironment, e as CoverageC8Options, g as CoverageIstanbulOptions, C as CoverageOptions, a as CoverageProvider, b as CoverageProviderModule, ao as CoverageReporter, d as CoverageV8Options, f as CustomProviderOptions, a4 as DepsOptimizationOptions, E as Environment, a3 as EnvironmentOptions, al as EnvironmentReturn, a5 as InlineConfig, Z as JSDOMOptions, ak as ModuleCache, ai as MutableArray, af as Nullable, am as OnServerRestartHandler, n as ProjectConfig, N as RawErrsMap, an as ReportContext, ac as ResolveIdFunction, c as ResolvedCoverageOptions, X as RootAndTarget, a8 as RunnerRPC, a7 as RuntimeRPC, O as TscErrorInfo, a6 as TypecheckConfig, U as UserConfig, o as Vitest, $ as VitestEnvironment, a0 as VitestPool, V as VitestRunMode, ab as WorkerContext, ad as WorkerGlobalState, I as createExpect, G as expect, J as setupChaiConfig } from './types-198fd1d9.js';
+import { h as BenchmarkAPI, F as FakeTimerInstallOpts, M as MockFactoryWithHelper, i as RuntimeConfig, A as AfterSuiteRunMeta, j as UserConsoleLog, R as ResolvedConfig, k as ModuleGraphData, l as Reporter } from './types-3c7dbfa5.js';
+export { x as ApiConfig, a0 as ArgumentsType, $ as Arrayable, Z as Awaitable, B as BaseCoverageOptions, ae as BenchFunction, ac as Benchmark, ad as BenchmarkResult, ab as BenchmarkUserOptions, t as BuiltinEnvironment, w as CSSModuleScopeStrategy, o as CollectLineNumbers, p as CollectLines, a2 as Constructable, r as Context, O as ContextRPC, L as ContextTestEnvironment, a9 as CoverageIstanbulOptions, C as CoverageOptions, a as CoverageProvider, b as CoverageProviderModule, a8 as CoverageReporter, d as CoverageV8Options, aa as CustomProviderOptions, D as DepsOptimizationOptions, E as Environment, y as EnvironmentOptions, a4 as EnvironmentReturn, I as InlineConfig, J as JSDOMOptions, a3 as ModuleCache, a1 as MutableArray, _ as Nullable, a6 as OnServerRestartHandler, P as ProjectConfig, m as RawErrsMap, a7 as ReportContext, S as ResolveIdFunction, c as ResolvedCoverageOptions, N as ResolvedTestEnvironment, q as RootAndTarget, K as RunnerRPC, H as RuntimeRPC, z as TransformModePatterns, n as TscErrorInfo, G as TypecheckConfig, U as UserConfig, e as Vitest, u as VitestEnvironment, v as VitestPool, V as VitestRunMode, a5 as VmEnvironmentReturn, Q as WorkerContext, Y as WorkerGlobalState, X as WorkerRPC } from './types-3c7dbfa5.js';
+import { ExpectStatic } from '@vitest/expect';
+export { Assertion, AsymmetricMatchersContaining, ExpectStatic, JestAssertion } from '@vitest/expect';
 import { spyOn, fn, MaybeMockedDeep, MaybeMocked, MaybePartiallyMocked, MaybePartiallyMockedDeep, EnhancedSpy } from '@vitest/spy';
 export { EnhancedSpy, Mock, MockContext, MockInstance, Mocked, MockedClass, MockedFunction, MockedObject, SpyInstance } from '@vitest/spy';
 export { SnapshotEnvironment } from '@vitest/snapshot/environment';
 import { SnapshotResult } from '@vitest/snapshot';
 export { SnapshotData, SnapshotMatchOptions, SnapshotResult, SnapshotStateOptions, SnapshotSummary, SnapshotUpdateState, UncheckedSnapshot } from '@vitest/snapshot';
-export { Assertion, AsymmetricMatchersContaining, ExpectStatic, JestAssertion } from '@vitest/expect';
 import { TransformResult } from 'vite';
 import * as chai from 'chai';
 export { chai };
@@ -15,12 +16,13 @@ export { assert, should } from 'chai';
 export { UserWorkspaceConfig } from './config.js';
 export { ErrorWithDiff, ParsedStack } from '@vitest/utils';
 export { Bench as BenchFactory, Options as BenchOptions, Task as BenchTask, TaskResult as BenchTaskResult } from 'tinybench';
+import 'vite-node';
 import '@vitest/runner/utils';
 import 'vite-node/client';
 import '@vitest/snapshot/manager';
 import 'vite-node/server';
 import 'node:worker_threads';
-import 'vite-node';
+import 'rollup';
 import 'node:fs';
 
 declare type Not<T extends boolean> = T extends true ? false : true;
@@ -202,6 +204,9 @@ declare function runOnce<T>(fn: (() => T), key?: string): T;
  */
 declare function isFirstRun(): boolean;
 
+declare function createExpect(test?: Test): ExpectStatic;
+declare const globalExpect: ExpectStatic;
+
 interface VitestUtils {
     useFakeTimers(config?: FakeTimerInstallOpts): this;
     useRealTimers(): this;
@@ -346,7 +351,7 @@ interface VitestUtils {
 declare const vitest: VitestUtils;
 declare const vi: VitestUtils;
 
-declare function getRunningMode(): "run" | "watch";
+declare function getRunningMode(): "watch" | "run";
 declare function isWatchMode(): boolean;
 
 interface TransformResultWithSource extends TransformResult {
@@ -379,4 +384,4 @@ interface WebSocketEvents extends Pick<Reporter, 'onCollected' | 'onFinished' |
     onCancel(reason: CancelReason): void;
 }
 
-export { AfterSuiteRunMeta, AssertType, BenchmarkAPI, ExpectTypeOf, ModuleGraphData, Reporter, ResolvedConfig, RuntimeConfig, TransformResultWithSource, UserConsoleLog, WebSocketEvents, WebSocketHandlers, assertType, bench, expectTypeOf, getRunningMode, isFirstRun, isWatchMode, runOnce, vi, vitest };
+export { AfterSuiteRunMeta, AssertType, BenchmarkAPI, ExpectTypeOf, ModuleGraphData, Reporter, ResolvedConfig, RuntimeConfig, TransformResultWithSource, UserConsoleLog, WebSocketEvents, WebSocketHandlers, assertType, bench, createExpect, globalExpect as expect, expectTypeOf, getRunningMode, isFirstRun, isWatchMode, runOnce, vi, vitest };

package/dist/index.js

@@ -1,23 +1,24 @@
 export { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, suite, test } from '@vitest/runner';
-export { e as bench, c as createExpect, d as expect, s as setupChaiConfig, v as vi, f as vitest } from './vendor-vi.dd6706cb.js';
-export { i as isFirstRun, r as runOnce } from './vendor-run-once.1fa85ba7.js';
-import { d as dist } from './vendor-index.2af39fbb.js';
-export { b as assertType, g as getRunningMode, a as isWatchMode } from './vendor-index.2af39fbb.js';
+export { e as bench, c as createExpect, d as expect, v as vi, f as vitest } from './vendor-vi.271667ef.js';
+export { i as isFirstRun, r as runOnce } from './vendor-run-once.3e5ef7d7.js';
+import { d as dist } from './vendor-index.eff408fd.js';
+export { b as assertType, g as getRunningMode, a as isWatchMode } from './vendor-index.eff408fd.js';
 import * as chai from 'chai';
 export { chai };
 export { assert, should } from 'chai';
 import '@vitest/runner/utils';
 import '@vitest/utils';
-import './vendor-index.23ac4e13.js';
+import './vendor-index.087d1af7.js';
 import 'pathe';
 import 'std-env';
-import './vendor-global.6795f91f.js';
+import './vendor-global.97e4527c.js';
 import './vendor-_commonjsHelpers.7d1333e8.js';
 import '@vitest/expect';
 import '@vitest/snapshot';
 import '@vitest/utils/error';
-import './vendor-tasks.f9d75aed.js';
+import './vendor-source-map.e6c1997b.js';
 import 'util';
+import './vendor-date.6e993429.js';
 import '@vitest/spy';
 
 

package/dist/loader.js

@@ -10,8 +10,8 @@ import 'node:path';
 import v8 from 'node:v8';
 import { format, inspect } from 'node:util';
 import { normalizeModuleId } from 'vite-node/utils';
-import './vendor-index.23ac4e13.js';
-import { g as getWorkerState } from './vendor-global.6795f91f.js';
+import './vendor-index.087d1af7.js';
+import { g as getWorkerState } from './vendor-global.97e4527c.js';
 import 'std-env';
 import '@vitest/runner/utils';
 import '@vitest/utils';
@@ -568,14 +568,16 @@ function detectESM(url, source) {
   return hasESMSyntax(source) && !hasCJSSyntax(source);
 }
 const resolve = async (url, context, next) => {
+  var _a;
   const { parentURL } = context;
   const state = getWorkerState();
   const resolver = state == null ? void 0 : state.rpc.resolveId;
-  if (!parentURL || isNodeBuiltin(url) || !resolver)
+  const environment = state == null ? void 0 : state.ctx.environment;
+  if (!parentURL || isNodeBuiltin(url) || !resolver || !environment)
     return next(url, context, next);
   const id = normalizeModuleId(url);
   const importer = normalizeModuleId(parentURL);
-  const resolved = await resolver(id, importer, state.ctx.environment.name);
+  const resolved = await resolver(id, importer, environment.transformMode ?? ((_a = environment.environment) == null ? void 0 : _a.transformMode) ?? "ssr");
   let result;
   let filepath;
   if (resolved) {