vitest 4.0.0-beta.2 → 4.0.0-beta.3

package/dist/browser.d.ts

@@ -1,5 +1,5 @@
-import { S as SerializedCoverageConfig, a as SerializedConfig } from './chunks/config.d.HJdfX-8k.js';
-import { R as RuntimeCoverageModuleLoader } from './chunks/coverage.d.S9RMNXIe.js';
+import { S as SerializedCoverageConfig, a as SerializedConfig } from './chunks/config.d.DZo8c7fw.js';
+import { R as RuntimeCoverageModuleLoader } from './chunks/coverage.d.CNYjU4GF.js';
 import { SerializedDiffOptions } from '@vitest/utils/diff';
 import { VitestExecutor } from './execute.js';
 export { collectTests, processError, startTests } from '@vitest/runner';
@@ -11,18 +11,18 @@ import '@vitest/pretty-format';
 import '@vitest/snapshot';
 import 'vite-node/client';
 import 'vite-node';
-import './chunks/worker.d.COAQvn4k.js';
-import './chunks/environment.d.CUq4cUgQ.js';
+import './chunks/worker.d.xTcinSQw.js';
+import './chunks/environment.d.Bhm9oc0v.js';
 import 'node:vm';
 import '@vitest/mocker';
 import './chunks/mocker.d.BE_2ls6u.js';
 
 declare function startCoverageInsideWorker(options: SerializedCoverageConfig | undefined, loader: RuntimeCoverageModuleLoader, runtimeOptions: {
-	isolate: boolean
+	isolate: boolean;
 }): Promise<unknown>;
 declare function takeCoverageInsideWorker(options: SerializedCoverageConfig | undefined, loader: RuntimeCoverageModuleLoader): Promise<unknown>;
 declare function stopCoverageInsideWorker(options: SerializedCoverageConfig | undefined, loader: RuntimeCoverageModuleLoader, runtimeOptions: {
-	isolate: boolean
+	isolate: boolean;
 }): Promise<unknown>;
 
 declare function setupCommonEnv(config: SerializedConfig): Promise<void>;

package/dist/browser.js

@@ -1,4 +1,4 @@
-export { l as loadDiffConfig, b as loadSnapshotSerializers, c as setupCommonEnv, s as startCoverageInsideWorker, a as stopCoverageInsideWorker, t as takeCoverageInsideWorker } from './chunks/setup-common.D7ZqXFx-.js';
+export { l as loadDiffConfig, b as loadSnapshotSerializers, c as setupCommonEnv, s as startCoverageInsideWorker, a as stopCoverageInsideWorker, t as takeCoverageInsideWorker } from './chunks/setup-common.Ebx5x0eP.js';
 export { collectTests, processError, startTests } from '@vitest/runner';
 import * as spy from '@vitest/spy';
 export { spy as SpyModule };

package/dist/chunks/{base.Bj3pWTr1.js → base.D5_IXzht.js}

@@ -1,5 +1,5 @@
 import { ModuleCacheMap } from 'vite-node/client';
-import { g as getDefaultRequestStubs, s as startVitestExecutor } from './execute.B7h3T_Hc.js';
+import { g as getDefaultRequestStubs, s as startVitestExecutor } from './execute.Dt-pCVcL.js';
 import { p as provideWorkerState } from './utils.XdZDrNZV.js';
 
 let _viteNode;
@@ -24,7 +24,7 @@ async function runBaseTests(method, state) {
 	const [executor, { run }] = await Promise.all([startViteNode({
 		state,
 		requestStubs: getDefaultRequestStubs()
-	}), import('./runBaseTests.BC7ZIH5L.js')]);
+	}), import('./runBaseTests.Bbi_gTJQ.js')]);
 	const fileSpecs = ctx.files.map((f) => typeof f === "string" ? {
 		filepath: f,
 		testLocations: void 0

package/dist/chunks/{benchmark.d.BwvBVTda.d.ts → benchmark.d.DAaHLpsq.d.ts}

@@ -4,8 +4,8 @@ import { TaskResult, Bench, Options } from 'tinybench';
 
 interface Benchmark extends Test {
 	meta: {
-		benchmark: true
-		result?: TaskResult
+		benchmark: true;
+		result?: TaskResult;
 	};
 }
 interface BenchmarkResult extends TaskResult {
@@ -17,8 +17,8 @@ interface BenchmarkResult extends TaskResult {
 type BenchFunction = (this: Bench) => Promise<void> | void;
 type ChainableBenchmarkAPI = ChainableFunction<"skip" | "only" | "todo", (name: string | Function, fn?: BenchFunction, options?: Options) => void>;
 type BenchmarkAPI = ChainableBenchmarkAPI & {
-	skipIf: (condition: any) => ChainableBenchmarkAPI
-	runIf: (condition: any) => ChainableBenchmarkAPI
+	skipIf: (condition: any) => ChainableBenchmarkAPI;
+	runIf: (condition: any) => ChainableBenchmarkAPI;
 };
 
 export type { BenchmarkResult as B, BenchFunction as a, Benchmark as b, BenchmarkAPI as c };

package/dist/chunks/{browser.d.DP0ACFkh.d.ts → browser.d.BSPEQIuf.d.ts}

@@ -1,11 +1,11 @@
-import { T as TestExecutionMethod } from './worker.d.COAQvn4k.js';
+import { T as TestExecutionMethod } from './worker.d.xTcinSQw.js';
 
 type SerializedTestSpecification = [project: {
-	name: string | undefined
-	root: string
+	name: string | undefined;
+	root: string;
 }, file: string, options: {
-	pool: string
-	testLines?: number[] | undefined
+	pool: string;
+	testLines?: number[] | undefined;
 }];
 
 interface BrowserTesterOptions {

package/dist/chunks/{cac.CVVvMokL.js → cac.C30xmylc.js}

@@ -2,8 +2,8 @@ import { toArray } from '@vitest/utils';
 import { EventEmitter } from 'events';
 import { normalize } from 'pathe';
 import c from 'tinyrainbow';
-import { a as defaultPort, d as defaultBrowserPort } from './constants.DnKduX2e.js';
-import { R as ReportersMap } from './index.a-yuRg2G.js';
+import { a as defaultPort, d as defaultBrowserPort } from './constants.CXzqaLmq.js';
+import { R as ReportersMap } from './index.Bz6b0Ib7.js';
 
 function toArr(any) {
 	return any == null ? [] : Array.isArray(any) ? any : [any];
@@ -619,7 +619,7 @@ class CAC extends EventEmitter {
 
 const cac = (name = "") => new CAC(name);
 
-var version = "4.0.0-beta.2";
+var version = "4.0.0-beta.3";
 
 const apiConfig = (port) => ({
 	port: {
@@ -836,11 +836,6 @@ const cliOptionsConfig = {
 		description: "Override Vite mode (default: `test` or `benchmark`)",
 		argument: "<name>"
 	},
-	workspace: {
-		description: "[deprecated] Path to a workspace configuration file",
-		argument: "<path>",
-		normalize: true
-	},
 	isolate: { description: "Run every test file in isolation. To disable isolation, use `--no-isolate` (default: `true`)" },
 	globals: { description: "Inject apis globally" },
 	dom: { description: "Mock browser API with happy-dom" },
@@ -1183,7 +1178,7 @@ const cliOptionsConfig = {
 		description: "Use `bundle` to bundle the config with esbuild or `runner` (experimental) to process it on the fly. This is only available in vite version 6.1.0 and above. (default: `bundle`)",
 		argument: "<loader>"
 	},
-	standalone: { description: "Start Vitest without running tests. File filters will be ignored, tests will be running only on change (default: `false`)" },
+	standalone: { description: "Start Vitest without running tests. Tests will be running only on change. This option is ignored when CLI file filters are passed. (default: `false`)" },
 	mergeReports: {
 		description: "Path to a blob reports directory. If this options is used, Vitest won't run any tests, it will only report previously recorded tests",
 		argument: "[path]",
@@ -1397,11 +1392,11 @@ async function start(mode, cliFilters, options) {
 		process.title = "node (vitest)";
 	} catch {}
 	try {
-		const { startVitest } = await import('./cli-api.BUkNuHvl.js').then(function (n) { return n.f; });
+		const { startVitest } = await import('./cli-api.DE98RCgs.js').then(function (n) { return n.f; });
 		const ctx = await startVitest(mode, cliFilters.map(normalize), normalizeCliOptions(cliFilters, options));
 		if (!ctx.shouldKeepServer()) await ctx.exit();
 	} catch (e) {
-		const { errorBanner } = await import('./index.a-yuRg2G.js').then(function (n) { return n.u; });
+		const { errorBanner } = await import('./index.Bz6b0Ib7.js').then(function (n) { return n.u; });
 		console.error(`\n${errorBanner("Startup Error")}`);
 		console.error(e);
 		console.error("\n\n");
@@ -1411,10 +1406,10 @@ async function start(mode, cliFilters, options) {
 }
 async function init(project) {
 	if (project !== "browser") {
-		console.error(new Error("Only the \"browser\" project is supported. Use \"vitest init browser\" to create a new project."));
+		console.error(/* @__PURE__ */ new Error("Only the \"browser\" project is supported. Use \"vitest init browser\" to create a new project."));
 		process.exit(1);
 	}
-	const { create } = await import('./creator.GK6I-cL4.js');
+	const { create } = await import('./creator.CJNzQTzZ.js');
 	await create();
 }
 async function collect(mode, cliFilters, options) {
@@ -1422,12 +1417,12 @@ async function collect(mode, cliFilters, options) {
 		process.title = "node (vitest)";
 	} catch {}
 	try {
-		const { prepareVitest, processCollected, outputFileList } = await import('./cli-api.BUkNuHvl.js').then(function (n) { return n.f; });
+		const { prepareVitest, processCollected, outputFileList } = await import('./cli-api.DE98RCgs.js').then(function (n) { return n.f; });
 		const ctx = await prepareVitest(mode, {
 			...normalizeCliOptions(cliFilters, options),
 			watch: false,
 			run: true
-		});
+		}, void 0, void 0, cliFilters);
 		if (!options.filesOnly) {
 			const { testModules: tests, unhandledErrors: errors } = await ctx.collect(cliFilters.map(normalize));
 			if (errors.length) {
@@ -1444,7 +1439,7 @@ async function collect(mode, cliFilters, options) {
 		}
 		await ctx.close();
 	} catch (e) {
-		const { errorBanner } = await import('./index.a-yuRg2G.js').then(function (n) { return n.u; });
+		const { errorBanner } = await import('./index.Bz6b0Ib7.js').then(function (n) { return n.u; });
 		console.error(`\n${errorBanner("Collect Error")}`);
 		console.error(e);
 		console.error("\n\n");

package/dist/chunks/{cli-api.BUkNuHvl.js → cli-api.DE98RCgs.js}

@@ -6,14 +6,14 @@ import { noop, isPrimitive, createDefer, slash, highlight, toArray, deepMerge, n
 import { f as findUp, p as prompt } from './index.X0nbfr6-.js';
 import * as vite from 'vite';
 import { searchForWorkspaceRoot, version, createServer, mergeConfig } from 'vite';
-import { A as API_PATH, c as configFiles, d as defaultBrowserPort, w as workspacesFiles, a as defaultPort } from './constants.DnKduX2e.js';
+import { A as API_PATH, c as configFiles, d as defaultBrowserPort, a as defaultPort } from './constants.CXzqaLmq.js';
 import { generateFileHash, limitConcurrency, createFileTask, hasFailed, getTasks, getTests } from '@vitest/runner/utils';
 import { SnapshotManager } from '@vitest/snapshot/manager';
 import { ViteNodeRunner } from 'vite-node/client';
 import { ViteNodeServer } from 'vite-node/server';
-import { v as version$1 } from './cac.CVVvMokL.js';
+import { v as version$1 } from './cac.C30xmylc.js';
 import { c as createBirpc } from './index.B521nVV-.js';
-import { p as parse, s as stringify, d as printError, f as formatProjectName, w as withLabel, e as errorBanner, h as divider, i as generateCodeFrame, R as ReportersMap, B as BlobReporter, r as readBlobs, H as HangingProcessReporter } from './index.a-yuRg2G.js';
+import { p as parse, s as stringify, d as printError, f as formatProjectName, w as withLabel, e as errorBanner, h as divider, i as generateCodeFrame, R as ReportersMap, B as BlobReporter, r as readBlobs, H as HangingProcessReporter } from './index.Bz6b0Ib7.js';
 import require$$0$3 from 'events';
 import require$$1$1 from 'https';
 import require$$2 from 'http';
@@ -28,8 +28,8 @@ import { g as getDefaultExportFromCjs } from './_commonjsHelpers.BFTU3MAI.js';
 import { parseErrorStacktrace } from '@vitest/utils/source-map';
 import crypto, { createHash } from 'node:crypto';
 import { distDir, rootDir } from '../path.js';
-import { h as hash, R as RandomSequencer, i as isPackageExists, g as getFilePoolName, d as isBrowserEnabled, r as resolveConfig, e as groupBy, f as getCoverageProvider, j as createPool, w as wildcardPatternToRegExp, a as resolveApiServerConfig, s as stdout } from './coverage.BjMqihzx.js';
-import { c as convertTasksToEvents } from './typechecker.CVytUJuF.js';
+import { h as hash, R as RandomSequencer, i as isPackageExists, g as getFilePoolName, d as isBrowserEnabled, r as resolveConfig, e as groupBy, f as getCoverageProvider, j as createPool, w as wildcardPatternToRegExp, a as resolveApiServerConfig, s as stdout } from './coverage.OOpN1tMC.js';
+import { c as convertTasksToEvents } from './typechecker.CMNPqJOo.js';
 import { Console } from 'node:console';
 import c from 'tinyrainbow';
 import { createRequire } from 'node:module';
@@ -43,7 +43,7 @@ import { normalizeRequestId, cleanUrl } from 'vite-node/utils';
 import { hoistMocksPlugin, automockPlugin } from '@vitest/mocker/node';
 import { c as configDefaults } from './defaults.CXFFjsi8.js';
 import MagicString from 'magic-string';
-import { a as BenchmarkReportsMap } from './index.CJvUWPky.js';
+import { a as BenchmarkReportsMap } from './index.D3SKT3tv.js';
 import assert$1 from 'node:assert';
 import { serializeError } from '@vitest/utils/error';
 import readline from 'node:readline';
@@ -4717,9 +4717,11 @@ function requireWebsocketServer () {
 	      return;
 	    }
 
-	    if (version !== 8 && version !== 13) {
+	    if (version !== 13 && version !== 8) {
 	      const message = 'Missing or invalid Sec-WebSocket-Version header';
-	      abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
+	      abortHandshakeOrEmitwsClientError(this, req, socket, 400, message, {
+	        'Sec-WebSocket-Version': '13, 8'
+	      });
 	      return;
 	    }
 
@@ -4987,16 +4989,24 @@ function requireWebsocketServer () {
 	 * @param {Duplex} socket The socket of the upgrade request
 	 * @param {Number} code The HTTP response status code
 	 * @param {String} message The HTTP response body
+	 * @param {Object} [headers] The HTTP response headers
 	 * @private
 	 */
-	function abortHandshakeOrEmitwsClientError(server, req, socket, code, message) {
+	function abortHandshakeOrEmitwsClientError(
+	  server,
+	  req,
+	  socket,
+	  code,
+	  message,
+	  headers
+	) {
 	  if (server.listenerCount('wsClientError')) {
 	    const err = new Error(message);
 	    Error.captureStackTrace(err, abortHandshakeOrEmitwsClientError);
 
 	    server.emit('wsClientError', err, socket, req);
 	  } else {
-	    abortHandshake(socket, code, message);
+	    abortHandshake(socket, code, message, headers);
 	  }
 	}
 	return websocketServer;
@@ -5257,7 +5267,7 @@ class BrowserSessions {
 		// this promise only waits for the WS connection with the orhcestrator to be established
 		const defer = createDefer();
 		const timeout = setTimeout(() => {
-			defer.reject(new Error(`Failed to connect to the browser session "${sessionId}" [${project.name}] within the timeout.`));
+			defer.reject(/* @__PURE__ */ new Error(`Failed to connect to the browser session "${sessionId}" [${project.name}] within the timeout.`));
 		}, project.vitest.config.browser.connectTimeout ?? 6e4).unref();
 		this.sessions.set(sessionId, {
 			project,
@@ -5746,10 +5756,7 @@ function serializeConfig(config, coreConfig, viteConfig) {
 		snapshotOptions: {
 			snapshotEnvironment: void 0,
 			updateSnapshot: coreConfig.snapshotOptions.updateSnapshot,
-			snapshotFormat: {
-				...coreConfig.snapshotOptions.snapshotFormat,
-				compareKeys: void 0
-			},
+			snapshotFormat: { ...coreConfig.snapshotOptions.snapshotFormat },
 			expand: config.snapshotOptions.expand ?? coreConfig.snapshotOptions.expand
 		},
 		sequence: {
@@ -5949,7 +5956,7 @@ function silenceImportViteIgnoreWarning(logger) {
 
 const cssLangs = "\\.(?:css|less|sass|scss|styl|stylus|pcss|postcss)(?:$|\\?)";
 const cssLangRE = new RegExp(cssLangs);
-const cssModuleRE = new RegExp(`\\.module${cssLangs}`);
+const cssModuleRE = /* @__PURE__ */ new RegExp(`\\.module${cssLangs}`);
 const cssInlineRE = /[?&]inline(?:&|$)/;
 function isCSS(id) {
 	return cssLangRE.test(id);
@@ -7434,7 +7441,7 @@ async function resolveProjects(vitest, cliOptions, workspaceConfigPath, projects
 	const fileProjects = [...configFiles, ...nonConfigDirectories];
 	const concurrent = limitConcurrency(nodeos__default.availableParallelism?.() || nodeos__default.cpus().length || 5);
 	projectConfigs.forEach((options, index) => {
-		const configRoot = workspaceConfigPath ? dirname(workspaceConfigPath) : vitest.config.root;
+		const configRoot = vitest.config.root;
 		// if extends a config file, resolve the file path
 		const configFile = typeof options.extends === "string" ? resolve(configRoot, options.extends) : options.extends === true ? vitest.vite.config.configFile || false : false;
 		// if `root` is configured, resolve it relative to the workspace file or vite root (like other options)
@@ -7614,8 +7621,7 @@ async function resolveTestProjectConfigs(vitest, workspaceConfigPath, projectsDe
 		if (!isDynamicPattern(stringOption)) {
 			const file = resolve(vitest.config.root, stringOption);
 			if (!existsSync(file)) {
-				const relativeWorkspaceConfigPath = workspaceConfigPath ? relative(vitest.config.root, workspaceConfigPath) : void 0;
-				const note = workspaceConfigPath ? `Workspace config file "${relativeWorkspaceConfigPath}"` : "Projects definition";
+				const note = "Projects definition";
 				throw new Error(`${note} references a non-existing file or a directory: ${file}`);
 			}
 			const stats = await promises.stat(file);
@@ -9166,11 +9172,6 @@ class Vitest {
 	/** @internal */ closingPromise;
 	/** @internal */ isCancelling = false;
 	/** @internal */ coreWorkspaceProject;
-	/**
-	* @internal
-	* @deprecated
-	*/
-	resolvedProjects = [];
 	/** @internal */ _browserLastPort = defaultBrowserPort;
 	/** @internal */ _browserSessions = new BrowserSessions();
 	/** @internal */ _cliOptions = {};
@@ -9188,7 +9189,6 @@ class Vitest {
 	_state;
 	_cache;
 	_snapshot;
-	_workspaceConfigPath;
 	constructor(mode, cliOptions, options = {}) {
 		this.mode = mode;
 		this._cliOptions = cliOptions;
@@ -9265,8 +9265,6 @@ class Vitest {
 		this.pool = void 0;
 		this.closingPromise = void 0;
 		this.projects = [];
-		this.resolvedProjects = [];
-		this._workspaceConfigPath = void 0;
 		this.coverageProvider = void 0;
 		this.runningPromise = void 0;
 		this.coreWorkspaceProject = void 0;
@@ -9304,7 +9302,7 @@ class Vitest {
 			// since we set `server.hmr: false`, Vite does not auto restart itself
 			server.watcher.on("change", async (file) => {
 				file = normalize(file);
-				const isConfig = file === server.config.configFile || this.projects.some((p) => p.vite.config.configFile === file) || file === this._workspaceConfigPath;
+				const isConfig = file === server.config.configFile || this.projects.some((p) => p.vite.config.configFile === file);
 				if (isConfig) {
 					await Promise.all(this._onRestartListeners.map((fn) => fn("config")));
 					this.report("onServerRestart", "config");
@@ -9318,7 +9316,6 @@ class Vitest {
 			await this.cache.results.readFromCache();
 		} catch {}
 		const projects = await this.resolveProjects(this._cliOptions);
-		this.resolvedProjects = projects;
 		this.projects = projects;
 		await Promise.all(projects.flatMap((project) => {
 			const hooks = project.vite.config.getSortedPluginHooks("configureVitest");
@@ -9402,41 +9399,15 @@ class Vitest {
 	import(moduleId) {
 		return this.runner.executeId(moduleId);
 	}
-	async resolveWorkspaceConfigPath() {
-		if (typeof this.config.workspace === "string") return this.config.workspace;
-		const configDir = this.vite.config.configFile ? dirname(this.vite.config.configFile) : this.config.root;
-		const rootFiles = await promises.readdir(configDir);
-		const workspaceConfigName = workspacesFiles.find((configFile) => {
-			return rootFiles.includes(configFile);
-		});
-		if (!workspaceConfigName) return void 0;
-		return join(configDir, workspaceConfigName);
-	}
 	async resolveProjects(cliOptions) {
 		const names = /* @__PURE__ */ new Set();
-		if (this.config.projects) {
-			if (typeof this.config.workspace !== "undefined") this.logger.warn("Both `test.projects` and `test.workspace` are defined. Ignoring the `test.workspace` option.");
-			return resolveProjects(this, cliOptions, void 0, this.config.projects, names);
-		}
-		if (Array.isArray(this.config.workspace)) {
-			this.logger.deprecate("The `test.workspace` option is deprecated and will be removed in the next major. To hide this warning, rename `test.workspace` option to `test.projects`.");
-			return resolveProjects(this, cliOptions, void 0, this.config.workspace, names);
-		}
-		const workspaceConfigPath = await this.resolveWorkspaceConfigPath();
-		this._workspaceConfigPath = workspaceConfigPath;
-		// user doesn't have a workspace config, return default project
-		if (!workspaceConfigPath) {
-			// user can filter projects with --project flag, `getDefaultTestProject`
-			// returns the project only if it matches the filter
-			const project = getDefaultTestProject(this);
-			if (!project) return [];
-			return resolveBrowserProjects(this, new Set([project.name]), [project]);
-		}
-		const configFile = this.vite.config.configFile ? resolve(this.vite.config.root, this.vite.config.configFile) : "the root config file";
-		this.logger.deprecate(`The workspace file is deprecated and will be removed in the next major. Please, use the \`test.projects\` field in ${configFile} instead.`);
-		const workspaceModule = await this.import(workspaceConfigPath);
-		if (!workspaceModule.default || !Array.isArray(workspaceModule.default)) throw new TypeError(`Workspace config file "${workspaceConfigPath}" must export a default array of project paths.`);
-		return resolveProjects(this, cliOptions, workspaceConfigPath, workspaceModule.default, names);
+		if (this.config.projects) return resolveProjects(this, cliOptions, void 0, this.config.projects, names);
+		if ("workspace" in this.config) throw new Error("The `test.workspace` option was removed in Vitest 4. Please, migrate to `test.projects` instead. See https://vitest.dev/guide/projects for examples.");
+		// user can filter projects with --project flag, `getDefaultTestProject`
+		// returns the project only if it matches the filter
+		const project = getDefaultTestProject(this);
+		if (!project) return [];
+		return resolveBrowserProjects(this, new Set([project.name]), [project]);
 	}
 	/**
 	* Glob test files in every project and create a TestSpecification for each file and pool.
@@ -10448,7 +10419,7 @@ function registerConsoleShortcuts(ctx, stdin = process.stdin, stdout) {
 		const watchFilter = new WatchFilter("Input filename pattern", stdin, stdout);
 		const filter = await watchFilter.filter(async (str) => {
 			const files = await ctx.globTestFiles([str]);
-			return files.map((file) => relative(ctx.config.root, file[1]));
+			return files.map((file) => relative(ctx.config.root, file[1])).filter((file, index, all) => all.indexOf(file) === index);
 		});
 		on();
 		if (typeof filter === "undefined") return;
@@ -10486,7 +10457,7 @@ function registerConsoleShortcuts(ctx, stdin = process.stdin, stdout) {
 */
 async function startVitest(mode, cliFilters = [], options = {}, viteOverrides, vitestOptions) {
 	const root = resolve(options.root || process.cwd());
-	const ctx = await prepareVitest(mode, options, viteOverrides, vitestOptions);
+	const ctx = await prepareVitest(mode, options, viteOverrides, vitestOptions, cliFilters);
 	if (mode === "test" && ctx.config.coverage.enabled) {
 		const provider = ctx.config.coverage.provider || "v8";
 		const requiredPackages = CoverageProviderMap[provider];
@@ -10532,11 +10503,12 @@ async function startVitest(mode, cliFilters = [], options = {}, viteOverrides, v
 	await ctx.close();
 	return ctx;
 }
-async function prepareVitest(mode, options = {}, viteOverrides, vitestOptions) {
+async function prepareVitest(mode, options = {}, viteOverrides, vitestOptions, cliFilters) {
 	process.env.TEST = "true";
 	process.env.VITEST = "true";
 	process.env.NODE_ENV ??= "test";
 	if (options.run) options.watch = false;
+	if (options.standalone && (cliFilters?.length || 0) > 0) options.standalone = false;
 	// this shouldn't affect _application root_ that can be changed inside config
 	const root = resolve(options.root || process.cwd());
 	const ctx = await createVitest(mode, options, viteOverrides, vitestOptions);

package/dist/chunks/{config.d.HJdfX-8k.d.ts → config.d.DZo8c7fw.d.ts}

@@ -98,68 +98,68 @@ interface SerializedConfig {
 	maxConcurrency: number;
 	defines: Record<string, any>;
 	expect: {
-		requireAssertions?: boolean
+		requireAssertions?: boolean;
 		poll?: {
-			timeout?: number
-			interval?: number
-		}
+			timeout?: number;
+			interval?: number;
+		};
 	};
 	printConsoleTrace: boolean | undefined;
 	sequence: {
-		shuffle?: boolean
-		concurrent?: boolean
-		seed: number
-		hooks: SequenceHooks
-		setupFiles: SequenceSetupFiles
+		shuffle?: boolean;
+		concurrent?: boolean;
+		seed: number;
+		hooks: SequenceHooks;
+		setupFiles: SequenceSetupFiles;
 	};
 	poolOptions: {
 		forks: {
-			singleFork: boolean
-			isolate: boolean
-		}
+			singleFork: boolean;
+			isolate: boolean;
+		};
 		threads: {
-			singleThread: boolean
-			isolate: boolean
-		}
+			singleThread: boolean;
+			isolate: boolean;
+		};
 		vmThreads: {
-			singleThread: boolean
-		}
+			singleThread: boolean;
+		};
 		vmForks: {
-			singleFork: boolean
-		}
+			singleFork: boolean;
+		};
 	};
 	deps: {
 		web: {
-			transformAssets?: boolean
-			transformCss?: boolean
-			transformGlobPattern?: RegExp | RegExp[]
-		}
+			transformAssets?: boolean;
+			transformCss?: boolean;
+			transformGlobPattern?: RegExp | RegExp[];
+		};
 		optimizer: {
 			web: {
-				enabled: boolean
-			}
+				enabled: boolean;
+			};
 			ssr: {
-				enabled: boolean
-			}
-		}
-		interopDefault: boolean | undefined
-		moduleDirectories: string[] | undefined
+				enabled: boolean;
+			};
+		};
+		interopDefault: boolean | undefined;
+		moduleDirectories: string[] | undefined;
 	};
 	snapshotOptions: {
-		updateSnapshot: SnapshotUpdateState
-		expand: boolean | undefined
-		snapshotFormat: PrettyFormatOptions | undefined
+		updateSnapshot: SnapshotUpdateState;
+		expand: boolean | undefined;
+		snapshotFormat: PrettyFormatOptions | undefined;
 		/**
 		* only exists for tests, not available in the main process
 		*/
-		snapshotEnvironment: SnapshotEnvironment
+		snapshotEnvironment: SnapshotEnvironment;
 	};
 	pool: string;
 	snapshotSerializers: string[];
 	chaiConfig: {
-		includeStack?: boolean
-		showDiff?: boolean
-		truncateThreshold?: number
+		includeStack?: boolean;
+		showDiff?: boolean;
+		truncateThreshold?: number;
 	} | undefined;
 	diff: string | SerializedDiffOptions | undefined;
 	retry: number;
@@ -167,52 +167,52 @@ interface SerializedConfig {
 	inspect: boolean | string | undefined;
 	inspectBrk: boolean | string | undefined;
 	inspector: {
-		enabled?: boolean
-		port?: number
-		host?: string
-		waitForDebugger?: boolean
+		enabled?: boolean;
+		port?: number;
+		host?: string;
+		waitForDebugger?: boolean;
 	};
 	watch: boolean;
 	env: Record<string, any>;
 	browser: {
-		name: string
-		headless: boolean
-		isolate: boolean
-		fileParallelism: boolean
-		ui: boolean
+		name: string;
+		headless: boolean;
+		isolate: boolean;
+		fileParallelism: boolean;
+		ui: boolean;
 		viewport: {
-			width: number
-			height: number
-		}
+			width: number;
+			height: number;
+		};
 		locators: {
-			testIdAttribute: string
-		}
-		screenshotFailures: boolean
+			testIdAttribute: string;
+		};
+		screenshotFailures: boolean;
 		providerOptions: {
 			// for playwright
-			actionTimeout?: number
-		}
+			actionTimeout?: number;
+		};
 	};
 	standalone: boolean;
 	logHeapUsage: boolean | undefined;
 	coverage: SerializedCoverageConfig;
 	benchmark: {
-		includeSamples: boolean
+		includeSamples: boolean;
 	} | undefined;
 }
 interface SerializedCoverageConfig {
 	provider: "istanbul" | "v8" | "custom" | undefined;
 	reportsDirectory: string;
 	htmlReporter: {
-		subdir: string | undefined
+		subdir: string | undefined;
 	} | undefined;
 	enabled: boolean;
 	customProviderModule: string | undefined;
 }
 type RuntimeConfig = Pick<SerializedConfig, "allowOnly" | "testTimeout" | "hookTimeout" | "clearMocks" | "mockReset" | "restoreMocks" | "fakeTimers" | "maxConcurrency" | "expect" | "printConsoleTrace"> & {
 	sequence?: {
-		hooks?: SequenceHooks
-	}
+		hooks?: SequenceHooks;
+	};
 };
 type RuntimeOptions = Partial<RuntimeConfig>;
 

package/dist/chunks/{console.CtFJOzRO.js → console.DoJHFxmj.js}

@@ -8,7 +8,7 @@ import { g as getWorkerState } from './utils.XdZDrNZV.js';
 
 const UNKNOWN_TEST_ID = "__vitest__unknown_test__";
 function getTaskIdByStack(root) {
-	const stack = new Error("STACK_TRACE_ERROR").stack?.split("\n");
+	const stack = (/* @__PURE__ */ new Error("STACK_TRACE_ERROR")).stack?.split("\n");
 	if (!stack) return UNKNOWN_TEST_ID;
 	const index = stack.findIndex((line) => line.includes("at Console.value"));
 	const line = index === -1 ? null : stack[index + 2];
@@ -101,7 +101,7 @@ function createCustomConsole(defaultState) {
 		if (state().config.printConsoleTrace) {
 			const limit = Error.stackTraceLimit;
 			Error.stackTraceLimit = limit + 6;
-			const stack = new Error("STACK_TRACE").stack;
+			const stack = (/* @__PURE__ */ new Error("STACK_TRACE")).stack;
 			const trace = stack?.split("\n").slice(7).join("\n");
 			Error.stackTraceLimit = limit;
 			buffer.push([data, trace]);
@@ -129,7 +129,7 @@ function createCustomConsole(defaultState) {
 		if (state().config.printConsoleTrace) {
 			const limit = Error.stackTraceLimit;
 			Error.stackTraceLimit = limit + 6;
-			const stack = new Error("STACK_TRACE").stack?.split("\n");
+			const stack = (/* @__PURE__ */ new Error("STACK_TRACE")).stack?.split("\n");
 			Error.stackTraceLimit = limit;
 			const isTrace = stack?.some((line) => line.includes("at Console.trace"));
 			if (isTrace) buffer.push([data, void 0]);