@voidzero-dev/vite-plus-test 0.0.0-0bfcc90f.20260209-0731

package/dist/module-evaluator.js

@@ -0,0 +1,343 @@
+import { isBuiltin, createRequire } from 'node:module';
+import { pathToFileURL, fileURLToPath } from 'node:url';
+import vm from 'node:vm';
+import { ssrModuleExportsKey, ssrImportMetaKey, ssrImportKey, ssrDynamicImportKey, ssrExportAllKey } from '@voidzero-dev/vite-plus-core/module-runner';
+import { T as Traces } from './chunks/traces.CCmnQaNT.js';
+
+const performanceNow = performance.now.bind(performance);
+class ModuleDebug {
+  executionStack = [];
+  startCalculateModuleExecutionInfo(filename, options) {
+    const startTime = performanceNow();
+    this.executionStack.push({
+      filename,
+      startTime,
+      subImportTime: 0
+    });
+    return () => {
+      const duration = performanceNow() - startTime;
+      const currentExecution = this.executionStack.pop();
+      if (currentExecution == null) throw new Error("Execution stack is empty, this should never happen");
+      const selfTime = duration - currentExecution.subImportTime;
+      if (this.executionStack.length > 0) this.executionStack.at(-1).subImportTime += duration;
+      return {
+        startOffset: options.startOffset,
+        external: options.external,
+        importer: options.importer,
+        duration,
+        selfTime
+      };
+    };
+  }
+}
+
+const isWindows = process.platform === "win32";
+class VitestModuleEvaluator {
+  stubs = {};
+  env = createImportMetaEnvProxy();
+  vm;
+  compiledFunctionArgumentsNames;
+  compiledFunctionArgumentsValues = [];
+  primitives;
+  debug = new ModuleDebug();
+  _otel;
+  _evaluatedModules;
+  constructor(vmOptions, options = {}) {
+    this.options = options;
+    this._otel = options.traces || new Traces({ enabled: false });
+    this.vm = vmOptions;
+    this.stubs = getDefaultRequestStubs(vmOptions?.context);
+    this._evaluatedModules = options.evaluatedModules;
+    if (options.compiledFunctionArgumentsNames) this.compiledFunctionArgumentsNames = options.compiledFunctionArgumentsNames;
+    if (options.compiledFunctionArgumentsValues) this.compiledFunctionArgumentsValues = options.compiledFunctionArgumentsValues;
+    if (vmOptions) this.primitives = vm.runInContext("({ Object, Proxy, Reflect })", vmOptions.context);
+    else this.primitives = {
+      Object,
+      Proxy,
+      Reflect
+    };
+  }
+  convertIdToImportUrl(id) {
+    // TODO: vitest returns paths for external modules, but Vite returns file://
+    // REMOVE WHEN VITE 6 SUPPORT IS OVER
+    // unfortunetly, there is a bug in Vite where ID is resolved incorrectly, so we can't return files until the fix is merged
+    // https://github.com/vitejs/vite/pull/20449
+    if (!isWindows || isBuiltin(id) || /^(?:node:|data:|http:|https:|file:)/.test(id)) return id;
+    const [filepath, query] = id.split("?");
+    if (query) return `${pathToFileURL(filepath).toString()}?${query}`;
+    return pathToFileURL(filepath).toString();
+  }
+  async runExternalModule(id) {
+    if (id in this.stubs) return this.stubs[id];
+    const file = this.convertIdToImportUrl(id);
+    const importer = (this._evaluatedModules?.getModuleById(id)?.importers)?.values().next().value;
+    const filename = id.startsWith("file://") ? fileURLToPath(id) : id;
+    const finishModuleExecutionInfo = this.debug.startCalculateModuleExecutionInfo(filename, {
+      startOffset: 0,
+      external: true,
+      importer
+    });
+    const namespace = await this._otel.$("vitest.module.external", { attributes: { "code.file.path": file } }, () => this.vm ? this.vm.externalModulesExecutor.import(file) : import(file)).finally(() => {
+      this.options.moduleExecutionInfo?.set(filename, finishModuleExecutionInfo());
+    });
+    if (!this.shouldInterop(file, namespace)) return namespace;
+    const { mod, defaultExport } = interopModule(namespace);
+    const { Proxy, Reflect } = this.primitives;
+    return new Proxy(mod, {
+      get(mod, prop) {
+        if (prop === "default") return defaultExport;
+        return mod[prop] ?? defaultExport?.[prop];
+      },
+      has(mod, prop) {
+        if (prop === "default") return defaultExport !== void 0;
+        return prop in mod || defaultExport && prop in defaultExport;
+      },
+      getOwnPropertyDescriptor(mod, prop) {
+        const descriptor = Reflect.getOwnPropertyDescriptor(mod, prop);
+        if (descriptor) return descriptor;
+        if (prop === "default" && defaultExport !== void 0) return {
+          value: defaultExport,
+          enumerable: true,
+          configurable: true
+        };
+      }
+    });
+  }
+  async runInlinedModule(context, code, module) {
+    return this._otel.$("vitest.module.inline", (span) => this._runInlinedModule(context, code, module, span));
+  }
+  async _runInlinedModule(context, code, module, span) {
+    context.__vite_ssr_import_meta__.env = this.env;
+    const { Reflect, Proxy, Object } = this.primitives;
+    const exportsObject = context[ssrModuleExportsKey];
+    const SYMBOL_NOT_DEFINED = Symbol("not defined");
+    let moduleExports = SYMBOL_NOT_DEFINED;
+    // this proxy is triggered only on exports.{name} and module.exports access
+    // inside the module itself. imported module is always "exports"
+    const cjsExports = new Proxy(exportsObject, {
+      get: (target, p, receiver) => {
+        if (Reflect.has(target, p)) return Reflect.get(target, p, receiver);
+        return Reflect.get(Object.prototype, p, receiver);
+      },
+      getPrototypeOf: () => Object.prototype,
+      set: (_, p, value) => {
+        span.addEvent(`cjs export proxy is triggered for ${String(p)}`);
+        // treat "module.exports =" the same as "exports.default =" to not have nested "default.default",
+        // so "exports.default" becomes the actual module
+        if (p === "default" && this.shouldInterop(module.file, { default: value }) && cjsExports !== value) {
+          span.addEvent("`exports.default` is assigned, copying values");
+          exportAll(cjsExports, value);
+          exportsObject.default = value;
+          return true;
+        }
+        if (!Reflect.has(exportsObject, "default")) exportsObject.default = {};
+        // returns undefined, when accessing named exports, if default is not an object
+        // but is still present inside hasOwnKeys, this is Node behaviour for CJS
+        if (moduleExports !== SYMBOL_NOT_DEFINED && isPrimitive(moduleExports)) {
+          span.addEvent(`\`exports.${String(p)}\` is assigned, but module.exports is a primitive. assigning "undefined" values instead to comply with ESM`);
+          defineExport(exportsObject, p, () => void 0);
+          return true;
+        }
+        if (!isPrimitive(exportsObject.default)) exportsObject.default[p] = value;
+        if (p !== "default") defineExport(exportsObject, p, () => value);
+        return true;
+      }
+    });
+    const moduleProxy = {
+      set exports(value) {
+        span.addEvent("`module.exports` is assigned directly, copying all properties to `exports`");
+        exportAll(cjsExports, value);
+        exportsObject.default = value;
+        moduleExports = value;
+      },
+      get exports() {
+        return cjsExports;
+      }
+    };
+    const meta = context[ssrImportMetaKey];
+    if (this.options.getCurrentTestFilepath?.() === module.file) {
+      const globalNamespace = this.vm?.context || globalThis;
+      Object.defineProperty(meta, "vitest", { get: () => globalNamespace.__vitest_index__ });
+    }
+    const filename = meta.filename;
+    const dirname = meta.dirname;
+    span.setAttributes({ "code.file.path": filename });
+    const require = this.createRequire(meta.url);
+    const argumentsList = [
+      ssrModuleExportsKey,
+      ssrImportMetaKey,
+      ssrImportKey,
+      ssrDynamicImportKey,
+      ssrExportAllKey,
+      "__vite_ssr_exportName__",
+      "__filename",
+      "__dirname",
+      "module",
+      "exports",
+      "require"
+    ];
+    if (this.compiledFunctionArgumentsNames) argumentsList.push(...this.compiledFunctionArgumentsNames);
+    span.setAttribute("vitest.module.arguments", argumentsList);
+    // add 'use strict' since ESM enables it by default
+    const codeDefinition = `'use strict';async (${argumentsList.join(",")})=>{{`;
+    const wrappedCode = `${codeDefinition}${code}\n}}`;
+    const options = {
+      filename: module.id,
+      lineOffset: 0,
+      columnOffset: -codeDefinition.length
+    };
+    // this will always be 1 element because it's cached after load
+    const importer = module.importers.values().next().value;
+    const finishModuleExecutionInfo = this.debug.startCalculateModuleExecutionInfo(options.filename, {
+      startOffset: codeDefinition.length,
+      importer
+    });
+    try {
+      await (this.vm ? vm.runInContext(wrappedCode, this.vm.context, options) : vm.runInThisContext(wrappedCode, options))(
+        context[ssrModuleExportsKey],
+        context[ssrImportMetaKey],
+        context[ssrImportKey],
+        context[ssrDynamicImportKey],
+        context[ssrExportAllKey],
+        // vite 7 support, remove when vite 7+ is supported
+        context.__vite_ssr_exportName__ || ((name, getter) => Object.defineProperty(exportsObject, name, {
+          enumerable: true,
+          configurable: true,
+          get: getter
+        })),
+        filename,
+        dirname,
+        moduleProxy,
+        cjsExports,
+        require,
+        ...this.compiledFunctionArgumentsValues
+      );
+    } finally {
+      // moduleExecutionInfo needs to use Node filename instead of the normalized one
+      // because we rely on this behaviour in coverage-v8, for example
+      this.options.moduleExecutionInfo?.set(options.filename, finishModuleExecutionInfo());
+    }
+  }
+  createRequire(filename) {
+    return this.vm ? this.vm.externalModulesExecutor.createRequire(filename) : createRequire(filename);
+  }
+  shouldInterop(path, mod) {
+    if (this.options.interopDefault === false) return false;
+    // never interop ESM modules
+    // TODO: should also skip for `.js` with `type="module"`
+    return !path.endsWith(".mjs") && "default" in mod;
+  }
+}
+function createImportMetaEnvProxy() {
+  // packages/vitest/src/node/plugins/index.ts:146
+  const booleanKeys = [
+    "DEV",
+    "PROD",
+    "SSR"
+  ];
+  return new Proxy(process.env, {
+    get(_, key) {
+      if (typeof key !== "string") return;
+      if (booleanKeys.includes(key)) return !!process.env[key];
+      return process.env[key];
+    },
+    set(_, key, value) {
+      if (typeof key !== "string") return true;
+      if (booleanKeys.includes(key)) process.env[key] = value ? "1" : "";
+      else process.env[key] = value;
+      return true;
+    }
+  });
+}
+function updateStyle(id, css) {
+  if (typeof document === "undefined") return;
+  const element = document.querySelector(`[data-vite-dev-id="${id}"]`);
+  if (element) {
+    element.textContent = css;
+    return;
+  }
+  const head = document.querySelector("head");
+  const style = document.createElement("style");
+  style.setAttribute("type", "text/css");
+  style.setAttribute("data-vite-dev-id", id);
+  style.textContent = css;
+  head?.appendChild(style);
+}
+function removeStyle(id) {
+  if (typeof document === "undefined") return;
+  const sheet = document.querySelector(`[data-vite-dev-id="${id}"]`);
+  if (sheet) document.head.removeChild(sheet);
+}
+const defaultClientStub = {
+  injectQuery: (id) => id,
+  createHotContext: () => {
+    return {
+      accept: () => {},
+      prune: () => {},
+      dispose: () => {},
+      decline: () => {},
+      invalidate: () => {},
+      on: () => {},
+      send: () => {}
+    };
+  },
+  updateStyle: () => {},
+  removeStyle: () => {}
+};
+function getDefaultRequestStubs(context) {
+  if (!context) {
+    const clientStub = {
+      ...defaultClientStub,
+      updateStyle,
+      removeStyle
+    };
+    return { "/@vite/client": clientStub };
+  }
+  const clientStub = vm.runInContext(`(defaultClient) => ({ ...defaultClient, updateStyle: ${updateStyle.toString()}, removeStyle: ${removeStyle.toString()} })`, context)(defaultClientStub);
+  return { "/@vite/client": clientStub };
+}
+function exportAll(exports$1, sourceModule) {
+  // #1120 when a module exports itself it causes
+  // call stack error
+  if (exports$1 === sourceModule) return;
+  if (isPrimitive(sourceModule) || Array.isArray(sourceModule) || sourceModule instanceof Promise) return;
+  for (const key in sourceModule) if (key !== "default" && !(key in exports$1)) try {
+    defineExport(exports$1, key, () => sourceModule[key]);
+  } catch {}
+}
+// keep consistency with Vite on how exports are defined
+function defineExport(exports$1, key, value) {
+  Object.defineProperty(exports$1, key, {
+    enumerable: true,
+    configurable: true,
+    get: value
+  });
+}
+function isPrimitive(v) {
+  return !(typeof v === "object" || typeof v === "function") || v == null;
+}
+function interopModule(mod) {
+  if (isPrimitive(mod)) return {
+    mod: { default: mod },
+    defaultExport: mod
+  };
+  let defaultExport = "default" in mod ? mod.default : mod;
+  if (!isPrimitive(defaultExport) && "__esModule" in defaultExport) {
+    mod = defaultExport;
+    if ("default" in defaultExport) defaultExport = defaultExport.default;
+  }
+  return {
+    mod,
+    defaultExport
+  };
+}
+const VALID_ID_PREFIX = `/@id/`;
+const NULL_BYTE_PLACEHOLDER = `__x00__`;
+function wrapId(id) {
+  return id.startsWith(VALID_ID_PREFIX) ? id : VALID_ID_PREFIX + id.replace("\0", NULL_BYTE_PLACEHOLDER);
+}
+function unwrapId(id) {
+  return id.startsWith(VALID_ID_PREFIX) ? id.slice(VALID_ID_PREFIX.length).replace(NULL_BYTE_PLACEHOLDER, "\0") : id;
+}
+
+export { VitestModuleEvaluator, createImportMetaEnvProxy, getDefaultRequestStubs, isPrimitive, unwrapId, wrapId };

package/dist/module-runner-stub.js

@@ -0,0 +1,44 @@
+// Browser-safe stub for module-runner
+// The real module-runner contains Node.js-only code that crashes browsers
+// This stub provides placeholder exports for browser compatibility
+
+// Stub class - browser doesn't actually use these
+export class EvaluatedModules {
+  constructor() {
+    this.idToModuleMap = new Map();
+    this.fileToModulesMap = new Map();
+    this.urlToIdModuleMap = new Map();
+  }
+  getModuleById() { return undefined; }
+  getModulesByFile() { return []; }
+  getModuleByUrl() { return undefined; }
+  ensureModule() { return {}; }
+  invalidateModule() {}
+  clear() {}
+}
+
+export class ModuleRunner {
+  constructor() {}
+  async import() { throw new Error('ModuleRunner is not available in browser'); }
+  evaluatedModules = new EvaluatedModules();
+}
+
+export class ESModulesEvaluator {
+  constructor() {}
+  async runExternalModule() { return {}; }
+  async runViteModule() { return {}; }
+}
+
+// Stub functions
+export function createDefaultImportMeta() { return {}; }
+export function createNodeImportMeta() { return {}; }
+export function createWebSocketModuleRunnerTransport() { return {}; }
+export function normalizeModuleId(id) { return id; }
+
+// SSR-related constants (browser doesn't use these)
+export const ssrDynamicImportKey = '__vite_ssr_dynamic_import__';
+export const ssrExportAllKey = '__vite_ssr_exportAll__';
+export const ssrExportNameKey = '__vite_ssr_export__';
+export const ssrImportKey = '__vite_ssr_import__';
+export const ssrImportMetaKey = '__vite_ssr_import_meta__';
+export const ssrModuleExportsKey = '__vite_ssr_exports__';

package/dist/module-runner.js

@@ -0,0 +1,17 @@
+export { VitestModuleEvaluator } from './module-evaluator.js';
+export { a as VITEST_VM_CONTEXT_SYMBOL, V as VitestModuleRunner, s as startVitestModuleRunner } from './chunks/startModuleRunner.DEj0jb3e.js';
+export { g as getWorkerState } from './chunks/utils.DvEY5TfP.js';
+import 'node:module';
+import 'node:url';
+import 'node:vm';
+import '@voidzero-dev/vite-plus-core/module-runner';
+import './chunks/traces.CCmnQaNT.js';
+import 'node:fs';
+import './@vitest/utils/helpers.js';
+import './chunks/modules.BJuCwlRJ.js';
+import './vendor/pathe.mjs';
+import './path.js';
+import 'node:path';
+import './@vitest/utils/serialize.js';
+import './@vitest/mocker/index.js';
+import './@vitest/utils/timers.js';

package/dist/node.d.ts

@@ -0,0 +1,251 @@
+import * as vite from '@voidzero-dev/vite-plus-core';
+import { InlineConfig, UserConfig as UserConfig$1, Plugin, ResolvedConfig as ResolvedConfig$1, ViteDevServer, LogLevel, LoggerOptions, Logger as Logger$1 } from '@voidzero-dev/vite-plus-core';
+export { vite as Vite };
+export { esbuildVersion, isCSSRequest, isFileLoadingAllowed, parseAst, parseAstAsync, rollupVersion, version as viteVersion } from '@voidzero-dev/vite-plus-core';
+import { IncomingMessage } from 'node:http';
+import { h as ResolvedConfig, f as UserConfig, i as VitestRunMode, j as VitestOptions, V as Vitest, A as ApiConfig, k as TestSpecification, T as TestProject, P as PoolWorker, l as PoolOptions, m as WorkerRequest, n as TestSequencer, L as Logger } from './chunks/reporters.d.CWXNI2jG.js';
+export { at as BaseCoverageOptions, Y as BenchmarkUserOptions, Z as BrowserBuiltinProvider, $ as BrowserCommand, a0 as BrowserCommandContext, a1 as BrowserConfigOptions, a2 as BrowserInstanceOption, a3 as BrowserModuleMocker, a4 as BrowserOrchestrator, a5 as BrowserProvider, a6 as BrowserProviderOption, a7 as BrowserScript, a8 as BrowserServerFactory, a9 as BrowserServerOptions, aa as BrowserServerState, ab as BrowserServerStateSession, ai as BuiltinEnvironment, ac as CDPSession, aj as CSSModuleScopeStrategy, au as CoverageIstanbulOptions, av as CoverageOptions, aw as CoverageProvider, ax as CoverageProviderModule, ay as CoverageReporter, c as CoverageV8Options, az as CustomProviderOptions, ak as DepsOptimizationOptions, al as EnvironmentOptions, H as HTMLOptions, I as InlineConfig, t as JUnitOptions, J as JsonOptions, M as ModuleDiagnostic, O as OnServerRestartHandler, o as OnTestsRerunHandler, ad as ParentProjectBrowser, am as Pool, q as PoolRunnerInitializer, r as PoolTask, ae as ProjectBrowser, an as ProjectConfig, a as ReportContext, aB as ReportedHookContext, aC as Reporter, ap as ResolveSnapshotPathHandler, aq as ResolveSnapshotPathHandlerContext, af as ResolvedBrowserOptions, R as ResolvedCoverageOptions, ao as ResolvedProjectConfig, S as SerializedTestProject, u as TaskOptions, v as TestCase, w as TestCollection, x as TestDiagnostic, y as TestModule, z as TestModuleState, B as TestResult, D as TestResultFailed, E as TestResultPassed, F as TestResultSkipped, aD as TestRunEndReason, aA as TestRunResult, X as TestSequencerConstructor, G as TestState, K as TestSuite, N as TestSuiteState, ag as ToMatchScreenshotComparators, ah as ToMatchScreenshotOptions, ar as TypecheckConfig, U as UserWorkspaceConfig, as as VitestEnvironment, p as VitestPackageInstaller, W as WatcherTriggerPattern, s as WorkerResponse, _ as _BrowserNames, Q as experimental_getRunnerTask } from './chunks/reporters.d.CWXNI2jG.js';
+export { C as CacheKeyIdGenerator, a as CacheKeyIdGeneratorContext, V as VitestPluginContext } from './chunks/plugin.d.CtqpEehP.js';
+import { Awaitable } from './@vitest/utils/index.js';
+export { SerializedError } from './@vitest/utils/index.js';
+import { R as RuntimeRPC } from './chunks/rpc.d.RH3apGEf.js';
+import { Writable } from 'node:stream';
+import { C as ContextRPC } from './chunks/worker.d.Dyxm8DEL.js';
+export { T as TestExecutionType } from './chunks/worker.d.Dyxm8DEL.js';
+import { Debugger } from './vendor/obug.mjs';
+import './chunks/global.d.B15mdLcR.js';
+export { Task as RunnerTask, TaskResult as RunnerTaskResult, TaskResultPack as RunnerTaskResultPack, Test as RunnerTestCase, File as RunnerTestFile, Suite as RunnerTestSuite, SequenceHooks, SequenceSetupFiles } from './@vitest/runner/index.js';
+export { b as RuntimeConfig } from './chunks/config.d.Cy95HiCx.js';
+export { generateFileHash } from './@vitest/runner/utils.js';
+import './chunks/browser.d.ChKACdzH.js';
+import './chunks/traces.d.402V_yFI.js';
+import './@vitest/mocker/index.js';
+import './@vitest/utils/source-map.js';
+import './@vitest/browser/index.js';
+import './@vitest/pretty-format/index.js';
+import './@vitest/snapshot/index.js';
+import './@vitest/utils/diff.js';
+import './@vitest/expect/index.js';
+import 'vitest/optional-types.js';
+import './chunks/benchmark.d.DAaHLpsq.js';
+import './vendor/tinybench.mjs';
+import './chunks/coverage.d.BZtK59WP.js';
+import './@vitest/snapshot/manager.js';
+import 'node:console';
+import 'node:fs';
+import '@voidzero-dev/vite-plus-core/module-runner';
+import './chunks/environment.d.CrsxCzP1.js';
+
+type RawErrsMap = Map<string, TscErrorInfo[]>;
+interface TscErrorInfo {
+	filePath: string;
+	errCode: number;
+	errMsg: string;
+	line: number;
+	column: number;
+}
+interface CollectLineNumbers {
+	target: number;
+	next: number;
+	prev?: number;
+}
+type CollectLines = { [key in keyof CollectLineNumbers] : string };
+interface RootAndTarget {
+	root: string;
+	targetAbsPath: string;
+}
+type Context = RootAndTarget & {
+	rawErrsMap: RawErrsMap;
+	openedDirs: Set<string>;
+	lastActivePath?: string;
+};
+
+declare function isValidApiRequest(config: ResolvedConfig, req: IncomingMessage): boolean;
+
+declare function escapeTestName(label: string, dynamic: boolean): string;
+
+interface CliOptions extends UserConfig {
+	/**
+	* Override the watch mode
+	*/
+	run?: boolean;
+	/**
+	* Removes colors from the console output
+	*/
+	color?: boolean;
+	/**
+	* Output collected tests as JSON or to a file
+	*/
+	json?: string | boolean;
+	/**
+	* Output collected test files only
+	*/
+	filesOnly?: boolean;
+	/**
+	* Override vite config's configLoader from cli.
+	* Use `bundle` to bundle the config with esbuild or `runner` (experimental) to process it on the fly (default: `bundle`).
+	* This is only available with **vite version 6.1.0** and above.
+	* @experimental
+	*/
+	configLoader?: InlineConfig extends {
+		configLoader?: infer T;
+	} ? T : never;
+}
+/**
+* Start Vitest programmatically
+*
+* Returns a Vitest instance if initialized successfully.
+*/
+declare function startVitest(mode: VitestRunMode, cliFilters?: string[], options?: CliOptions, viteOverrides?: UserConfig$1, vitestOptions?: VitestOptions): Promise<Vitest>;
+
+interface CliParseOptions {
+	allowUnknownOptions?: boolean;
+}
+declare function parseCLI(argv: string | string[], config?: CliParseOptions): {
+	filter: string[];
+	options: CliOptions;
+};
+
+declare function resolveApiServerConfig<Options extends ApiConfig & Omit<UserConfig, "expect">>(options: Options, defaultPort: number): ApiConfig | undefined;
+
+declare function createVitest(mode: VitestRunMode, options: CliOptions, viteOverrides?: UserConfig$1, vitestOptions?: VitestOptions): Promise<Vitest>;
+
+declare class FilesNotFoundError extends Error {
+	code: string;
+	constructor(mode: "test" | "benchmark");
+}
+declare class GitNotFoundError extends Error {
+	code: string;
+	constructor();
+}
+
+declare function VitestPlugin(options?: UserConfig, vitest?: Vitest): Promise<Plugin[]>;
+
+declare function resolveConfig(options?: UserConfig, viteOverrides?: UserConfig$1): Promise<{
+	vitestConfig: ResolvedConfig;
+	viteConfig: ResolvedConfig$1;
+}>;
+
+declare function resolveFsAllow(projectRoot: string, rootConfigFile: string | false | undefined): string[];
+
+type RunWithFiles = (files: TestSpecification[], invalidates?: string[]) => Promise<void>;
+interface ProcessPool {
+	name: string;
+	runTests: RunWithFiles;
+	collectTests: RunWithFiles;
+	close?: () => Awaitable<void>;
+}
+declare function getFilePoolName(project: TestProject): ResolvedConfig["pool"];
+
+interface MethodsOptions {
+	cacheFs?: boolean;
+	collect?: boolean;
+}
+declare function createMethodsRPC(project: TestProject, methodsOptions?: MethodsOptions): RuntimeRPC;
+
+/** @experimental */
+declare class ForksPoolWorker implements PoolWorker {
+	readonly name: string;
+	readonly cacheFs: boolean;
+	protected readonly entrypoint: string;
+	protected execArgv: string[];
+	protected env: Partial<NodeJS.ProcessEnv>;
+	private _fork?;
+	private stdout;
+	private stderr;
+	constructor(options: PoolOptions);
+	on(event: string, callback: (arg: any) => void): void;
+	off(event: string, callback: (arg: any) => void): void;
+	send(message: WorkerRequest): void;
+	start(): Promise<void>;
+	stop(): Promise<void>;
+	deserialize(data: unknown): unknown;
+	private get fork();
+}
+
+/** @experimental */
+declare class ThreadsPoolWorker implements PoolWorker {
+	readonly name: string;
+	protected readonly entrypoint: string;
+	protected execArgv: string[];
+	protected env: Partial<NodeJS.ProcessEnv>;
+	private _thread?;
+	private stdout;
+	private stderr;
+	constructor(options: PoolOptions);
+	on(event: string, callback: (arg: any) => void): void;
+	off(event: string, callback: (arg: any) => void): void;
+	send(message: WorkerRequest): void;
+	start(): Promise<void>;
+	stop(): Promise<void>;
+	deserialize(data: unknown): unknown;
+	private get thread();
+}
+
+/** @experimental */
+declare class TypecheckPoolWorker implements PoolWorker {
+	readonly name: string;
+	private readonly project;
+	private _eventEmitter;
+	constructor(options: PoolOptions);
+	start(): Promise<void>;
+	stop(): Promise<void>;
+	canReuse(): boolean;
+	send(message: WorkerRequest): void;
+	on(event: string, callback: (arg: any) => any): void;
+	off(event: string, callback: (arg: any) => any): void;
+	deserialize(data: unknown): unknown;
+}
+
+/** @experimental */
+declare class VmForksPoolWorker extends ForksPoolWorker {
+	readonly name = "vmForks";
+	readonly reportMemory: true;
+	protected readonly entrypoint: string;
+	constructor(options: PoolOptions);
+	canReuse(): boolean;
+}
+
+/** @experimental */
+declare class VmThreadsPoolWorker extends ThreadsPoolWorker {
+	readonly name = "vmThreads";
+	readonly reportMemory: true;
+	protected readonly entrypoint: string;
+	constructor(options: PoolOptions);
+	canReuse(): boolean;
+}
+
+declare class BaseSequencer implements TestSequencer {
+	protected ctx: Vitest;
+	constructor(ctx: Vitest);
+	shard(files: TestSpecification[]): Promise<TestSpecification[]>;
+	sort(files: TestSpecification[]): Promise<TestSpecification[]>;
+	private calculateShardRange;
+}
+
+declare function registerConsoleShortcuts(ctx: Vitest, stdin: NodeJS.ReadStream | undefined, stdout: NodeJS.WriteStream | Writable): () => void;
+
+interface WorkerContext extends ContextRPC {}
+
+/**
+* Check if the url is allowed to be served, via the `server.fs` config.
+* @deprecated Use the `isFileLoadingAllowed` function instead.
+*/
+declare function isFileServingAllowed(config: ResolvedConfig$1, url: string): boolean;
+declare function isFileServingAllowed(url: string, server: ViteDevServer): boolean;
+
+declare function createViteLogger(console: Logger, level?: LogLevel, options?: LoggerOptions): Logger$1;
+
+declare const rootDir: string;
+declare const distDir: string;
+
+declare function createDebugger(namespace: `vitest:${string}`): Debugger | undefined;
+
+declare const version: string;
+
+declare const createViteServer: typeof vite.createServer;
+
+declare const rolldownVersion: string | undefined;
+
+export { ApiConfig, BaseSequencer, ForksPoolWorker, GitNotFoundError, PoolOptions, PoolWorker, ResolvedConfig, TestProject, TestSequencer, TestSpecification, UserConfig as TestUserConfig, FilesNotFoundError as TestsNotFoundError, ThreadsPoolWorker, TypecheckPoolWorker, Vitest, VitestOptions, VitestPlugin, VitestRunMode, VmForksPoolWorker, VmThreadsPoolWorker, WorkerRequest, createDebugger, createMethodsRPC, createViteLogger, createViteServer, createVitest, distDir, escapeTestName, getFilePoolName, isFileServingAllowed, isValidApiRequest, parseCLI, registerConsoleShortcuts, resolveApiServerConfig, resolveConfig, resolveFsAllow, rolldownVersion, rootDir, startVitest, version };
+export type { CliOptions, CliParseOptions, ProcessPool, CollectLineNumbers as TypeCheckCollectLineNumbers, CollectLines as TypeCheckCollectLines, Context as TypeCheckContext, TscErrorInfo as TypeCheckErrorInfo, RawErrsMap as TypeCheckRawErrorsMap, RootAndTarget as TypeCheckRootAndTarget, WorkerContext };