@vitest/runner 4.1.0-beta.4 → 4.1.0-beta.6

package/README.md

@@ -1,5 +1,7 @@
 # @vitest/runner
 
-Vitest mechanism to collect and run tasks.
+[![NPM version](https://img.shields.io/npm/v/@vitest/runner?color=a1b858&label=)](https://npmx.dev/package/@vitest/runner)
 
-[GitHub](https://github.com/vitest-dev/vitest) | [Documentation](https://vitest.dev/advanced/runner)
+Vitest mechanism to collect and run tests.
+
+[GitHub](https://github.com/vitest-dev/vitest/tree/main/packages/runner) | [Documentation](https://vitest.dev/api/advanced/runner)

package/dist/chunk-tasks.js

@@ -249,28 +249,45 @@ function limitConcurrency(concurrency = Infinity) {
 			tail = head && tail;
 		}
 	};
-	return (func, ...args) => {
-		// Create a promise chain that:
-		//  1. Waits for its turn in the task queue (if necessary).
-		//  2. Runs the task.
-		//  3. Allows the next pending task (if any) to run.
+	const acquire = () => {
+		let released = false;
+		const release = () => {
+			if (!released) {
+				released = true;
+				finish();
+			}
+		};
+		if (count++ < concurrency) {
+			return release;
+		}
 		return new Promise((resolve) => {
-			if (count++ < concurrency) {
-				// No need to queue if fewer than maxConcurrency tasks are running.
-				resolve();
-			} else if (tail) {
+			if (tail) {
 				// There are pending tasks, so append to the queue.
-				tail = tail[1] = [resolve];
+				tail = tail[1] = [() => resolve(release)];
 			} else {
 				// No other pending tasks, initialize the queue with a new tail and head.
-				head = tail = [resolve];
+				head = tail = [() => resolve(release)];
+			}
+		});
+	};
+	const limiterFn = (func, ...args) => {
+		function run(release) {
+			try {
+				const result = func(...args);
+				if (result instanceof Promise) {
+					return result.finally(release);
+				}
+				release();
+				return Promise.resolve(result);
+			} catch (error) {
+				release();
+				return Promise.reject(error);
 			}
-		}).then(() => {
-			// Running func here ensures that even a non-thenable result or an
-			// immediately thrown error gets wrapped into a Promise.
-			return func(...args);
-		}).finally(finish);
+		}
+		const release = acquire();
+		return release instanceof Promise ? release.then(run) : run(release);
 	};
+	return Object.assign(limiterFn, { acquire });
 }
 
 /**

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { T as TestArtifact, a as Test, S as Suite, b as SuiteHooks, F as FileSpecification, V as VitestRunner, c as File, d as TaskUpdateEvent, e as Task, f as TestAPI, g as SuiteAPI, h as SuiteCollector } from './tasks.d-C-iOiT8j.js';
-export { A as AfterAllListener, i as AfterEachListener, j as AroundAllListener, k as AroundEachListener, B as BeforeAllListener, l as BeforeEachListener, C as CancelReason, m as FailureScreenshotArtifact, n as Fixture, o as FixtureFn, p as FixtureOptions, q as Fixtures, I as ImportDuration, r as InferFixturesTypes, O as OnTestFailedHandler, s as OnTestFinishedHandler, R as Retry, t as RunMode, u as RuntimeContext, v as SequenceHooks, w as SequenceSetupFiles, x as SerializableRetry, y as SuiteFactory, z as SuiteOptions, D as TaskBase, E as TaskCustomOptions, G as TaskEventPack, H as TaskHook, J as TaskMeta, K as TaskPopulated, L as TaskResult, M as TaskResultPack, N as TaskState, P as TestAnnotation, Q as TestAnnotationArtifact, U as TestAnnotationLocation, W as TestArtifactBase, X as TestArtifactLocation, Y as TestArtifactRegistry, Z as TestAttachment, _ as TestContext, $ as TestFunction, a0 as TestOptions, a1 as TestTagDefinition, a2 as TestTags, a3 as Use, a4 as VisualRegressionArtifact, a5 as VitestRunnerConfig, a6 as VitestRunnerConstructor, a7 as VitestRunnerImportSource, a8 as afterAll, a9 as afterEach, aa as aroundAll, ab as aroundEach, ac as beforeAll, ad as beforeEach, ae as onTestFailed, af as onTestFinished } from './tasks.d-C-iOiT8j.js';
+import { T as TestArtifact, a as Test, S as Suite, b as SuiteHooks, F as FileSpecification, V as VitestRunner, c as File, d as TaskUpdateEvent, e as Task, f as TestAPI, g as SuiteAPI, h as SuiteCollector } from './tasks.d-D2GKpdwQ.js';
+export { A as AfterAllListener, i as AfterEachListener, j as AroundAllListener, k as AroundEachListener, B as BeforeAllListener, l as BeforeEachListener, C as CancelReason, m as FailureScreenshotArtifact, n as Fixture, o as FixtureFn, p as FixtureOptions, q as Fixtures, I as ImportDuration, r as InferFixturesTypes, O as OnTestFailedHandler, s as OnTestFinishedHandler, R as Retry, t as RunMode, u as RuntimeContext, v as SequenceHooks, w as SequenceSetupFiles, x as SerializableRetry, y as SuiteFactory, z as SuiteOptions, D as TaskBase, E as TaskCustomOptions, G as TaskEventPack, H as TaskHook, J as TaskMeta, K as TaskPopulated, L as TaskResult, M as TaskResultPack, N as TaskState, P as TestAnnotation, Q as TestAnnotationArtifact, U as TestAnnotationLocation, W as TestArtifactBase, X as TestArtifactLocation, Y as TestArtifactRegistry, Z as TestAttachment, _ as TestContext, $ as TestFunction, a0 as TestOptions, a1 as TestTagDefinition, a2 as TestTags, a3 as Use, a4 as VisualRegressionArtifact, a5 as VitestRunnerConfig, a6 as VitestRunnerConstructor, a7 as VitestRunnerImportSource, a8 as afterAll, a9 as afterEach, aa as aroundAll, ab as aroundEach, ac as beforeAll, ad as beforeEach, ae as onTestFailed, af as onTestFinished } from './tasks.d-D2GKpdwQ.js';
 import { Awaitable } from '@vitest/utils';
 import '@vitest/utils/diff';
 

package/dist/index.js

@@ -1,5 +1,5 @@
 import { processError } from '@vitest/utils/error';
-import { isObject, filterOutComments, createDefer, assertTypes, toArray, isNegativeNaN, unique, objectAttr, shuffle } from '@vitest/utils/helpers';
+import { isObject, filterOutComments, ordinal, createDefer, assertTypes, toArray, isNegativeNaN, unique, objectAttr, shuffle } from '@vitest/utils/helpers';
 import { getSafeTimers } from '@vitest/utils/timers';
 import { format, formatRegExp, objDisplay } from '@vitest/utils/display';
 import { w as getChainableContext, a as createChainable, v as validateTags, e as createTaskName, x as createNoTagsError, f as findTestFileStackTrace, d as createTagsFilter, b as createFileTask, c as calculateSuiteHash, u as someTasksAreOnly, q as interpretTaskModes, s as limitConcurrency, t as partitionSuiteChildren, p as hasTests, o as hasFailed } from './chunk-tasks.js';
@@ -27,6 +27,12 @@ class TestRunAbortError extends Error {
 class FixtureDependencyError extends Error {
 	name = "FixtureDependencyError";
 }
+class FixtureAccessError extends Error {
+	name = "FixtureAccessError";
+}
+class FixtureParseError extends Error {
+	name = "FixtureParseError";
+}
 class AroundHookSetupError extends Error {
 	name = "AroundHookSetupError";
 }
@@ -83,7 +89,7 @@ class TestFixtures {
 		"file",
 		"worker"
 	];
-	static _workerContextSymbol = Symbol("workerContext");
+	static _workerContextSuite = { type: "worker" };
 	static clearDefinitions() {
 		TestFixtures._definitions.length = 0;
 	}
@@ -142,10 +148,10 @@ class TestFixtures {
 		return this._suiteContexts.get(file);
 	}
 	getWorkerContext() {
-		if (!this._suiteContexts.has(TestFixtures._workerContextSymbol)) {
-			this._suiteContexts.set(TestFixtures._workerContextSymbol, Object.create(null));
+		if (!this._suiteContexts.has(TestFixtures._workerContextSuite)) {
+			this._suiteContexts.set(TestFixtures._workerContextSuite, Object.create(null));
 		}
-		return this._suiteContexts.get(TestFixtures._workerContextSymbol);
+		return this._suiteContexts.get(TestFixtures._workerContextSuite);
 	}
 	parseUserFixtures(runner, userFixtures, supportNonTest, registrations = new Map(this._registrations)) {
 		const errors = [];
@@ -442,25 +448,35 @@ function resolveDeps(usedFixtures, registrations, depSet = new Set(), pendingFix
 	});
 	return pendingFixtures;
 }
-function validateSuiteHook(fn, hook, error) {
-	const usedProps = getUsedProps(fn);
+function validateSuiteHook(fn, hook, suiteError) {
+	const usedProps = getUsedProps(fn, {
+		sourceError: suiteError,
+		suiteHook: hook
+	});
 	if (usedProps.size) {
-		console.warn(`The ${hook} hook uses fixtures "${[...usedProps].join("\", \"")}", but has no access to context. Did you forget to call it as "test.${hook}()" instead of "${hook}()"? This will throw an error in a future major. See https://vitest.dev/guide/test-context#suite-level-hooks`);
-		if (error) {
-			const processor = globalThis.__vitest_worker__?.onFilterStackTrace || ((s) => s || "");
-			const stack = processor(error.stack || "");
-			console.warn(stack);
+		const error = new FixtureAccessError(`The ${hook} hook uses fixtures "${[...usedProps].join("\", \"")}", but has no access to context. ` + `Did you forget to call it as "test.${hook}()" instead of "${hook}()"?\n` + `If you used internal "suite" task as the first argument previously, access it in the second argument instead. ` + `See https://vitest.dev/guide/test-context#suite-level-hooks`);
+		if (suiteError) {
+			error.stack = suiteError.stack?.replace(suiteError.message, error.message);
 		}
+		throw error;
 	}
 }
 const kPropsSymbol = Symbol("$vitest:fixture-props");
+const kPropNamesSymbol = Symbol("$vitest:fixture-prop-names");
 function configureProps(fn, options) {
 	Object.defineProperty(fn, kPropsSymbol, {
 		value: options,
 		enumerable: false
 	});
 }
-function getUsedProps(fn) {
+function memoProps(fn, props) {
+	fn[kPropNamesSymbol] = props;
+	return props;
+}
+function getUsedProps(fn, { sourceError, suiteHook } = {}) {
+	if (kPropNamesSymbol in fn) {
+		return fn[kPropNamesSymbol];
+	}
 	const { index: fixturesIndex = 0, original: implementation = fn } = kPropsSymbol in fn ? fn[kPropsSymbol] : {};
 	let fnString = filterOutComments(implementation.toString());
 	// match lowered async function and strip it off
@@ -473,18 +489,23 @@ function getUsedProps(fn) {
 	}
 	const match = fnString.match(/[^(]*\(([^)]*)/);
 	if (!match) {
-		return new Set();
+		return memoProps(fn, new Set());
 	}
 	const args = splitByComma(match[1]);
 	if (!args.length) {
-		return new Set();
+		return memoProps(fn, new Set());
 	}
 	const fixturesArgument = args[fixturesIndex];
 	if (!fixturesArgument) {
-		return new Set();
+		return memoProps(fn, new Set());
 	}
 	if (!(fixturesArgument[0] === "{" && fixturesArgument.endsWith("}"))) {
-		throw new Error(`The first argument inside a fixture must use object destructuring pattern, e.g. ({ test } => {}). Instead, received "${fixturesArgument}".`);
+		const ordinalArgument = ordinal(fixturesIndex + 1);
+		const error = new FixtureParseError(`The ${ordinalArgument} argument inside a fixture must use object destructuring pattern, e.g. ({ task } => {}). ` + `Instead, received "${fixturesArgument}".` + `${suiteHook ? ` If you used internal "suite" task as the ${ordinalArgument} argument previously, access it in the ${ordinal(fixturesIndex + 2)} argument instead.` : ""}`);
+		if (sourceError) {
+			error.stack = sourceError.stack?.replace(sourceError.message, error.message);
+		}
+		throw error;
 	}
 	const _first = fixturesArgument.slice(1, -1).replace(/\s/g, "");
 	const props = splitByComma(_first).map((prop) => {
@@ -492,9 +513,13 @@ function getUsedProps(fn) {
 	});
 	const last = props.at(-1);
 	if (last && last.startsWith("...")) {
-		throw new Error(`Rest parameters are not supported in fixtures, received "${last}".`);
+		const error = new FixtureParseError(`Rest parameters are not supported in fixtures, received "${last}".`);
+		if (sourceError) {
+			error.stack = sourceError.stack?.replace(sourceError.message, error.message);
+		}
+		throw error;
 	}
-	return new Set(props);
+	return memoProps(fn, new Set(props));
 }
 function splitByComma(s) {
 	const result = [];
@@ -1106,7 +1131,7 @@ function createSuiteCollector(name, factory = () => {}, mode, each, suiteOptions
 		const stackTraceError = new Error("STACK_TRACE_ERROR");
 		Error.stackTraceLimit = limit;
 		if (handler) {
-			setFn(task, withTimeout(withAwaitAsyncAssertions(withFixtures(handler, { context }), task), timeout, false, stackTraceError, (_, error) => abortIfTimeout([context], error)));
+			setFn(task, withTimeout(withCancel(withAwaitAsyncAssertions(withFixtures(handler, { context }), task), task.context.signal), timeout, false, stackTraceError, (_, error) => abortIfTimeout([context], error)));
 		}
 		if (runner.config.includeTaskLocation) {
 			const error = stackTraceError.stack;
@@ -1640,6 +1665,23 @@ catch (error) {
 		});
 	});
 }
+function withCancel(fn, signal) {
+	return (function runWithCancel(...args) {
+		return new Promise((resolve, reject) => {
+			signal.addEventListener("abort", () => reject(signal.reason));
+			try {
+				const result = fn(...args);
+				if (typeof result === "object" && result != null && typeof result.then === "function") {
+					result.then(resolve, reject);
+				} else {
+					resolve(result);
+				}
+			} catch (error) {
+				reject(error);
+			}
+		});
+	});
+}
 const abortControllers = new WeakMap();
 function abortIfTimeout([context], error) {
 	if (context) {
@@ -1818,6 +1860,7 @@ function mergeHooks(baseHooks, hooks) {
 const now = globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
 const unixNow = Date.now;
 const { clearTimeout, setTimeout } = getSafeTimers();
+let limitMaxConcurrency;
 /**
 * Normalizes retry configuration to extract individual values.
 * Handles both number and object forms.
@@ -1891,14 +1934,14 @@ async function callTestHooks(runner, test, hooks, sequence) {
 	};
 	if (sequence === "parallel") {
 		try {
-			await Promise.all(hooks.map((fn) => fn(test.context)));
+			await Promise.all(hooks.map((fn) => limitMaxConcurrency(() => fn(test.context))));
 		} catch (e) {
 			failTask(test.result, e, runner.config.diffOptions);
 		}
 	} else {
 		for (const fn of hooks) {
 			try {
-				await fn(test.context);
+				await limitMaxConcurrency(() => fn(test.context));
 			} catch (e) {
 				failTask(test.result, e, runner.config.diffOptions);
 			}
@@ -1920,7 +1963,9 @@ async function callSuiteHook(suite, currentTask, name, runner, args) {
 		updateSuiteHookState(currentTask, name, "run", runner);
 	}
 	async function runHook(hook) {
-		return getBeforeHookCleanupCallback(hook, await hook(...args), name === "beforeEach" ? args[0] : undefined);
+		return limitMaxConcurrency(async () => {
+			return getBeforeHookCleanupCallback(hook, await hook(...args), name === "beforeEach" ? args[0] : undefined);
+		});
 	}
 	if (sequence === "parallel") {
 		callbacks.push(...await Promise.all(hooks.map((hook) => runHook(hook))));
@@ -1964,6 +2009,7 @@ async function callAroundHooks(runInner, options) {
 		await runInner();
 		return;
 	}
+	const hookErrors = [];
 	const createTimeoutPromise = (timeout, phase, stackTraceError) => {
 		let timer;
 		let timedout = false;
@@ -2000,6 +2046,8 @@ async function callAroundHooks(runInner, options) {
 		let useCalled = false;
 		let setupTimeout;
 		let teardownTimeout;
+		let setupLimitConcurrencyRelease;
+		let teardownLimitConcurrencyRelease;
 		// Promise that resolves when use() is called (setup phase complete)
 		let resolveUseCalled;
 		const useCalledPromise = new Promise((resolve) => {
@@ -2032,21 +2080,16 @@ async function callAroundHooks(runInner, options) {
 			resolveUseCalled();
 			// Setup phase completed - clear setup timer
 			setupTimeout.clear();
+			setupLimitConcurrencyRelease?.();
 			// Run inner hooks - don't time this against our teardown timeout
-			let nextError;
-			try {
-				await runNextHook(index + 1);
-			} catch (value) {
-				nextError = { value };
-			}
+			await runNextHook(index + 1).catch((e) => hookErrors.push(e));
+			teardownLimitConcurrencyRelease = await limitMaxConcurrency.acquire();
 			// Start teardown timer after inner hooks complete - only times this hook's teardown code
 			teardownTimeout = createTimeoutPromise(timeout, "teardown", stackTraceError);
 			// Signal that use() is returning (teardown phase starting)
 			resolveUseReturned();
-			if (nextError) {
-				throw nextError.value;
-			}
 		};
+		setupLimitConcurrencyRelease = await limitMaxConcurrency.acquire();
 		// Start setup timeout
 		setupTimeout = createTimeoutPromise(timeout, "setup", stackTraceError);
 		(async () => {
@@ -2058,6 +2101,9 @@ async function callAroundHooks(runInner, options) {
 				resolveHookComplete();
 			} catch (error) {
 				rejectHookComplete(error);
+			} finally {
+				setupLimitConcurrencyRelease?.();
+				teardownLimitConcurrencyRelease?.();
 			}
 		})();
 		// Wait for either: use() to be called OR hook to complete (error) OR setup timeout
@@ -2068,6 +2114,7 @@ async function callAroundHooks(runInner, options) {
 				setupTimeout.promise
 			]);
 		} finally {
+			setupLimitConcurrencyRelease?.();
 			setupTimeout.clear();
 		}
 		// Wait for use() to return (inner hooks complete) OR hook to complete (error during inner hooks)
@@ -2077,10 +2124,14 @@ async function callAroundHooks(runInner, options) {
 		try {
 			await Promise.race([hookCompletePromise, teardownTimeout?.promise]);
 		} finally {
+			teardownLimitConcurrencyRelease?.();
 			teardownTimeout?.clear();
 		}
 	};
-	await runNextHook(0);
+	await runNextHook(0).catch((e) => hookErrors.push(e));
+	if (hookErrors.length > 0) {
+		throw hookErrors;
+	}
 }
 async function callAroundAllHooks(suite, runSuiteInner) {
 	await callAroundHooks(runSuiteInner, {
@@ -2168,14 +2219,14 @@ async function callCleanupHooks(runner, cleanups) {
 			if (typeof fn !== "function") {
 				return;
 			}
-			await fn();
+			await limitMaxConcurrency(() => fn());
 		}));
 	} else {
 		for (const fn of cleanups) {
 			if (typeof fn !== "function") {
 				continue;
 			}
-			await fn();
+			await limitMaxConcurrency(() => fn());
 		}
 	}
 }
@@ -2241,24 +2292,20 @@ async function runTest(test, runner) {
 					test.result.repeatCount = repeatCount;
 					beforeEachCleanups = await $("test.beforeEach", () => callSuiteHook(suite, test, "beforeEach", runner, [test.context, suite]));
 					if (runner.runTask) {
-						await $("test.callback", () => runner.runTask(test));
+						await $("test.callback", () => limitMaxConcurrency(() => runner.runTask(test)));
 					} else {
 						const fn = getFn(test);
 						if (!fn) {
 							throw new Error("Test function is not found. Did you add it using `setFn`?");
 						}
-						await $("test.callback", () => fn());
+						await $("test.callback", () => limitMaxConcurrency(() => fn()));
 					}
 					await runner.onAfterTryTask?.(test, {
 						retry: retryCount,
 						repeats: repeatCount
 					});
 					if (test.result.state !== "fail") {
-						if (!test.repeats) {
-							test.result.state = "pass";
-						} else if (test.repeats && retry === retryCount) {
-							test.result.state = "pass";
-						}
+						test.result.state = "pass";
 					}
 				} catch (e) {
 					failTask(test.result, e, runner.config.diffOptions);
@@ -2358,6 +2405,11 @@ function failTask(result, err, diffOptions) {
 		result.pending = true;
 		return;
 	}
+	if (err instanceof TestRunAbortError) {
+		result.state = "skip";
+		result.note = err.message;
+		return;
+	}
 	result.state = "fail";
 	const errors = Array.isArray(err) ? err : [err];
 	for (const e of errors) {
@@ -2379,6 +2431,22 @@ function markTasksAsSkipped(suite, runner) {
 		}
 	});
 }
+function markPendingTasksAsSkipped(suite, runner, note) {
+	suite.tasks.forEach((t) => {
+		if (!t.result || t.result.state === "run") {
+			t.mode = "skip";
+			t.result = {
+				...t.result,
+				state: "skip",
+				note
+			};
+			updateTask("test-cancel", t, runner);
+		}
+		if (t.type === "suite") {
+			markPendingTasksAsSkipped(t, runner, note);
+		}
+	});
+}
 async function runSuite(suite, runner) {
 	await runner.onBeforeRunSuite?.(suite);
 	if (suite.result?.state === "fail") {
@@ -2479,11 +2547,10 @@ async function runSuite(suite, runner) {
 		updateTask("suite-finished", suite, runner);
 	}
 }
-let limitMaxConcurrency;
 async function runSuiteChild(c, runner) {
 	const $ = runner.trace;
 	if (c.type === "test") {
-		return limitMaxConcurrency(() => $("run.test", {
+		return $("run.test", {
 			"vitest.test.id": c.id,
 			"vitest.test.name": c.name,
 			"vitest.test.mode": c.mode,
@@ -2491,7 +2558,7 @@ async function runSuiteChild(c, runner) {
 			"code.file.path": c.file.filepath,
 			"code.line.number": c.location?.line,
 			"code.column.number": c.location?.column
-		}, () => runTest(c, runner)));
+		}, () => runTest(c, runner));
 	} else if (c.type === "suite") {
 		return $("run.suite", {
 			"vitest.suite.id": c.id,
@@ -2536,7 +2603,10 @@ async function startTests(specs, runner) {
 	runner.cancel = (reason) => {
 		// We intentionally create only one error since there is only one test run that can be cancelled
 		const error = new TestRunAbortError("The test run was aborted by the user.", reason);
-		getRunningTests().forEach((test) => abortContextSignal(test.context, error));
+		getRunningTests().forEach((test) => {
+			abortContextSignal(test.context, error);
+			markPendingTasksAsSkipped(test.file, runner, error.message);
+		});
 		return cancel?.(reason);
 	};
 	if (!workerRunners.has(runner)) {

package/dist/{tasks.d-C-iOiT8j.d.ts → tasks.d-D2GKpdwQ.d.ts}

@@ -213,7 +213,7 @@ declare class TestFixtures {
 	private static _builtinFixtures;
 	private static _fixtureOptionKeys;
 	private static _fixtureScopes;
-	private static _workerContextSymbol;
+	private static _workerContextSuite;
 	static clearDefinitions(): void;
 	static getWorkerContexts(): Record<string, any>[];
 	static getFileContexts(file: File): Record<string, any>[];
@@ -605,7 +605,7 @@ interface TaskEventData {
 	artifact?: TestArtifact | undefined;
 }
 type TaskEventPack = [id: string, event: TaskUpdateEvent, data: TaskEventData | undefined];
-type TaskUpdateEvent = "test-failed-early" | "suite-failed-early" | "test-prepare" | "test-finished" | "test-retried" | "suite-prepare" | "suite-finished" | "before-hook-start" | "before-hook-end" | "after-hook-start" | "after-hook-end" | "test-annotation" | "test-artifact";
+type TaskUpdateEvent = "test-failed-early" | "suite-failed-early" | "test-prepare" | "test-finished" | "test-retried" | "test-cancel" | "suite-prepare" | "suite-finished" | "before-hook-start" | "before-hook-end" | "after-hook-start" | "after-hook-end" | "test-annotation" | "test-artifact";
 interface Suite extends TaskBase {
 	type: "suite";
 	/**

package/dist/types.d.ts

@@ -1,3 +1,3 @@
-export { A as AfterAllListener, i as AfterEachListener, j as AroundAllListener, k as AroundEachListener, B as BeforeAllListener, l as BeforeEachListener, C as CancelReason, m as FailureScreenshotArtifact, c as File, F as FileSpecification, n as Fixture, o as FixtureFn, p as FixtureOptions, q as Fixtures, I as ImportDuration, r as InferFixturesTypes, O as OnTestFailedHandler, s as OnTestFinishedHandler, R as Retry, t as RunMode, u as RuntimeContext, v as SequenceHooks, w as SequenceSetupFiles, x as SerializableRetry, S as Suite, g as SuiteAPI, h as SuiteCollector, y as SuiteFactory, b as SuiteHooks, z as SuiteOptions, e as Task, D as TaskBase, E as TaskCustomOptions, G as TaskEventPack, H as TaskHook, J as TaskMeta, K as TaskPopulated, L as TaskResult, M as TaskResultPack, N as TaskState, d as TaskUpdateEvent, a as Test, f as TestAPI, P as TestAnnotation, Q as TestAnnotationArtifact, U as TestAnnotationLocation, T as TestArtifact, W as TestArtifactBase, X as TestArtifactLocation, Y as TestArtifactRegistry, Z as TestAttachment, _ as TestContext, $ as TestFunction, a0 as TestOptions, a1 as TestTagDefinition, a2 as TestTags, a3 as Use, a4 as VisualRegressionArtifact, V as VitestRunner, a5 as VitestRunnerConfig, a6 as VitestRunnerConstructor, a7 as VitestRunnerImportSource } from './tasks.d-C-iOiT8j.js';
+export { A as AfterAllListener, i as AfterEachListener, j as AroundAllListener, k as AroundEachListener, B as BeforeAllListener, l as BeforeEachListener, C as CancelReason, m as FailureScreenshotArtifact, c as File, F as FileSpecification, n as Fixture, o as FixtureFn, p as FixtureOptions, q as Fixtures, I as ImportDuration, r as InferFixturesTypes, O as OnTestFailedHandler, s as OnTestFinishedHandler, R as Retry, t as RunMode, u as RuntimeContext, v as SequenceHooks, w as SequenceSetupFiles, x as SerializableRetry, S as Suite, g as SuiteAPI, h as SuiteCollector, y as SuiteFactory, b as SuiteHooks, z as SuiteOptions, e as Task, D as TaskBase, E as TaskCustomOptions, G as TaskEventPack, H as TaskHook, J as TaskMeta, K as TaskPopulated, L as TaskResult, M as TaskResultPack, N as TaskState, d as TaskUpdateEvent, a as Test, f as TestAPI, P as TestAnnotation, Q as TestAnnotationArtifact, U as TestAnnotationLocation, T as TestArtifact, W as TestArtifactBase, X as TestArtifactLocation, Y as TestArtifactRegistry, Z as TestAttachment, _ as TestContext, $ as TestFunction, a0 as TestOptions, a1 as TestTagDefinition, a2 as TestTags, a3 as Use, a4 as VisualRegressionArtifact, V as VitestRunner, a5 as VitestRunnerConfig, a6 as VitestRunnerConstructor, a7 as VitestRunnerImportSource } from './tasks.d-D2GKpdwQ.js';
 import '@vitest/utils';
 import '@vitest/utils/diff';

package/dist/utils.d.ts

@@ -1,5 +1,5 @@
-import { S as Suite, c as File, e as Task, a1 as TestTagDefinition, a5 as VitestRunnerConfig, a as Test } from './tasks.d-C-iOiT8j.js';
-export { ag as ChainableFunction, ah as createChainable } from './tasks.d-C-iOiT8j.js';
+import { S as Suite, c as File, e as Task, a1 as TestTagDefinition, a5 as VitestRunnerConfig, a as Test } from './tasks.d-D2GKpdwQ.js';
+export { ag as ChainableFunction, ah as createChainable } from './tasks.d-D2GKpdwQ.js';
 import { ParsedStack, Arrayable } from '@vitest/utils';
 import '@vitest/utils/diff';
 
@@ -19,13 +19,17 @@ declare function createFileTask(filepath: string, root: string, projectName: str
 declare function generateFileHash(file: string, projectName: string | undefined): string;
 declare function findTestFileStackTrace(testFilePath: string, error: string): ParsedStack | undefined;
 
-/**
-* Return a function for running multiple async operations with limited concurrency.
-*/
-declare function limitConcurrency(concurrency?: number): <
+interface ConcurrencyLimiter extends ConcurrencyLimiterFn {
+	acquire: () => (() => void) | Promise<() => void>;
+}
+type ConcurrencyLimiterFn = <
 	Args extends unknown[],
 	T
 >(func: (...args: Args) => PromiseLike<T> | T, ...args: Args) => Promise<T>;
+/**
+* Return a function for running multiple async operations with limited concurrency.
+*/
+declare function limitConcurrency(concurrency?: number): ConcurrencyLimiter;
 
 /**
 * Partition in tasks groups by consecutive concurrent

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@vitest/runner",
   "type": "module",
-  "version": "4.1.0-beta.4",
+  "version": "4.1.0-beta.6",
   "description": "Vitest test runner",
   "license": "MIT",
   "funding": "https://opencollective.com/vitest",
-  "homepage": "https://github.com/vitest-dev/vitest/tree/main/packages/runner#readme",
+  "homepage": "https://vitest.dev/api/advanced/runner",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/vitest-dev/vitest.git",
@@ -14,6 +14,11 @@
   "bugs": {
     "url": "https://github.com/vitest-dev/vitest/issues"
   },
+  "keywords": [
+    "vitest",
+    "test",
+    "test-runner"
+  ],
   "sideEffects": true,
   "exports": {
     ".": {
@@ -39,7 +44,7 @@
   ],
   "dependencies": {
     "pathe": "^2.0.3",
-    "@vitest/utils": "4.1.0-beta.4"
+    "@vitest/utils": "4.1.0-beta.6"
   },
   "scripts": {
     "build": "premove dist && rollup -c",