@vitest/runner 2.0.0-beta.9 → 2.0.0

package/dist/chunk-tasks.js

@@ -13,11 +13,39 @@ function partitionSuiteChildren(suite) {
       tasksGroup = [c];
     }
   }
-  if (tasksGroup.length > 0)
+  if (tasksGroup.length > 0) {
     tasksGroups.push(tasksGroup);
+  }
   return tasksGroups;
 }
 
+function limitConcurrency(concurrency = Infinity) {
+  let count = 0;
+  let head;
+  let tail;
+  const finish = () => {
+    count--;
+    if (head) {
+      head[0]();
+      head = head[1];
+      tail = head && tail;
+    }
+  };
+  return (func, ...args) => {
+    return new Promise((resolve) => {
+      if (count++ < concurrency) {
+        resolve();
+      } else if (tail) {
+        tail = tail[1] = [resolve];
+      } else {
+        head = tail = [resolve];
+      }
+    }).then(() => {
+      return func(...args);
+    }).finally(finish);
+  };
+}
+
 function interpretTaskModes(suite, namePattern, onlyMode, parentIsOnly, allowOnly) {
   const suiteIsOnly = parentIsOnly || suite.mode === "only";
   suite.tasks.forEach((t) => {
@@ -36,39 +64,50 @@ function interpretTaskModes(suite, namePattern, onlyMode, parentIsOnly, allowOnl
       }
     }
     if (t.type === "test") {
-      if (namePattern && !getTaskFullName(t).match(namePattern))
+      if (namePattern && !getTaskFullName(t).match(namePattern)) {
         t.mode = "skip";
+      }
     } else if (t.type === "suite") {
-      if (t.mode === "skip")
+      if (t.mode === "skip") {
         skipAllTasks(t);
-      else
+      } else {
         interpretTaskModes(t, namePattern, onlyMode, includeTask, allowOnly);
+      }
     }
   });
   if (suite.mode === "run") {
-    if (suite.tasks.length && suite.tasks.every((i) => i.mode !== "run"))
+    if (suite.tasks.length && suite.tasks.every((i) => i.mode !== "run")) {
       suite.mode = "skip";
+    }
   }
 }
 function getTaskFullName(task) {
   return `${task.suite ? `${getTaskFullName(task.suite)} ` : ""}${task.name}`;
 }
 function someTasksAreOnly(suite) {
-  return suite.tasks.some((t) => t.mode === "only" || t.type === "suite" && someTasksAreOnly(t));
+  return suite.tasks.some(
+    (t) => t.mode === "only" || t.type === "suite" && someTasksAreOnly(t)
+  );
 }
 function skipAllTasks(suite) {
   suite.tasks.forEach((t) => {
     if (t.mode === "run") {
       t.mode = "skip";
-      if (t.type === "suite")
+      if (t.type === "suite") {
         skipAllTasks(t);
+      }
     }
   });
 }
 function checkAllowOnly(task, allowOnly) {
-  if (allowOnly)
+  if (allowOnly) {
     return;
-  const error = processError(new Error("[Vitest] Unexpected .only modifier. Remove it or pass --allowOnly argument to bypass this error"));
+  }
+  const error = processError(
+    new Error(
+      "[Vitest] Unexpected .only modifier. Remove it or pass --allowOnly argument to bypass this error"
+    )
+  );
   task.result = {
     state: "fail",
     errors: [error]
@@ -76,8 +115,9 @@ function checkAllowOnly(task, allowOnly) {
 }
 function generateHash(str) {
   let hash = 0;
-  if (str.length === 0)
+  if (str.length === 0) {
     return `${hash}`;
+  }
   for (let i = 0; i < str.length; i++) {
     const char = str.charCodeAt(i);
     hash = (hash << 5) - hash + char;
@@ -88,11 +128,12 @@ function generateHash(str) {
 function calculateSuiteHash(parent) {
   parent.tasks.forEach((t, idx) => {
     t.id = `${parent.id}_${idx}`;
-    if (t.type === "suite")
+    if (t.type === "suite") {
       calculateSuiteHash(t);
+    }
   });
 }
-function createFileTask(filepath, root, projectName) {
+function createFileTask(filepath, root, projectName, pool) {
   const path = relative(root, filepath);
   const file = {
     id: generateHash(`${path}${projectName || ""}`),
@@ -103,7 +144,8 @@ function createFileTask(filepath, root, projectName) {
     tasks: [],
     meta: /* @__PURE__ */ Object.create(null),
     projectName,
-    file: void 0
+    file: void 0,
+    pool
   };
   file.file = file;
   return file;
@@ -151,8 +193,9 @@ function getTests(suite) {
           tests.push(task);
         } else {
           const taskTests = getTests(task);
-          for (const test of taskTests)
+          for (const test of taskTests) {
             tests.push(test);
+          }
         }
       }
     }
@@ -160,31 +203,41 @@ function getTests(suite) {
   return tests;
 }
 function getTasks(tasks = []) {
-  return toArray(tasks).flatMap((s) => isAtomTest(s) ? [s] : [s, ...getTasks(s.tasks)]);
+  return toArray(tasks).flatMap(
+    (s) => isAtomTest(s) ? [s] : [s, ...getTasks(s.tasks)]
+  );
 }
 function getSuites(suite) {
-  return toArray(suite).flatMap((s) => s.type === "suite" ? [s, ...getSuites(s.tasks)] : []);
+  return toArray(suite).flatMap(
+    (s) => s.type === "suite" ? [s, ...getSuites(s.tasks)] : []
+  );
 }
 function hasTests(suite) {
-  return toArray(suite).some((s) => s.tasks.some((c) => isAtomTest(c) || hasTests(c)));
+  return toArray(suite).some(
+    (s) => s.tasks.some((c) => isAtomTest(c) || hasTests(c))
+  );
 }
 function hasFailed(suite) {
-  return toArray(suite).some((s) => {
-    var _a;
-    return ((_a = s.result) == null ? void 0 : _a.state) === "fail" || s.type === "suite" && hasFailed(s.tasks);
-  });
+  return toArray(suite).some(
+    (s) => {
+      var _a;
+      return ((_a = s.result) == null ? void 0 : _a.state) === "fail" || s.type === "suite" && hasFailed(s.tasks);
+    }
+  );
 }
 function getNames(task) {
   const names = [task.name];
   let current = task;
   while (current == null ? void 0 : current.suite) {
     current = current.suite;
-    if (current == null ? void 0 : current.name)
+    if (current == null ? void 0 : current.name) {
       names.unshift(current.name);
+    }
   }
-  if (current !== task.file)
+  if (current !== task.file) {
     names.unshift(task.file.name);
+  }
   return names;
 }
 
-export { createFileTask as a, getTests as b, calculateSuiteHash as c, getTasks as d, getSuites as e, hasFailed as f, generateHash as g, hasTests as h, interpretTaskModes as i, getNames as j, createChainable as k, partitionSuiteChildren as p, someTasksAreOnly as s };
+export { createFileTask as a, isAtomTest as b, calculateSuiteHash as c, getTests as d, getTasks as e, getSuites as f, generateHash as g, hasTests as h, interpretTaskModes as i, hasFailed as j, getNames as k, createChainable as l, limitConcurrency as m, partitionSuiteChildren as p, someTasksAreOnly as s };

package/dist/index.d.ts

@@ -1,13 +1,14 @@
 import { VitestRunner } from './types.js';
 export { CancelReason, VitestRunnerConfig, VitestRunnerConstructor, VitestRunnerImportSource } from './types.js';
-import { T as Task, F as File, d as SuiteAPI, e as TestAPI, f as SuiteCollector, g as CustomAPI, h as SuiteHooks, O as OnTestFailedHandler, i as OnTestFinishedHandler, a as Test, C as Custom, S as Suite } from './tasks-Cjrz1dUg.js';
-export { D as DoneCallback, E as ExtendedContext, t as Fixture, s as FixtureFn, r as FixtureOptions, u as Fixtures, v as HookCleanupCallback, H as HookListener, I as InferFixturesTypes, R as RunMode, y as RuntimeContext, B as SequenceHooks, G as SequenceSetupFiles, x as SuiteFactory, k as TaskBase, A as TaskContext, w as TaskCustomOptions, m as TaskMeta, l as TaskPopulated, n as TaskResult, o as TaskResultPack, j as TaskState, z as TestContext, p as TestFunction, q as TestOptions, U as Use } from './tasks-Cjrz1dUg.js';
+import { T as Task, F as File, d as SuiteAPI, e as TestAPI, f as SuiteCollector, g as CustomAPI, h as SuiteHooks, O as OnTestFailedHandler, i as OnTestFinishedHandler, a as Test, C as Custom, S as Suite } from './tasks-UPEJyRVL.js';
+export { D as DoneCallback, E as ExtendedContext, t as Fixture, s as FixtureFn, r as FixtureOptions, u as Fixtures, v as HookCleanupCallback, H as HookListener, I as InferFixturesTypes, R as RunMode, y as RuntimeContext, B as SequenceHooks, G as SequenceSetupFiles, x as SuiteFactory, k as TaskBase, A as TaskContext, w as TaskCustomOptions, m as TaskMeta, l as TaskPopulated, n as TaskResult, o as TaskResultPack, j as TaskState, z as TestContext, p as TestFunction, q as TestOptions, U as Use } from './tasks-UPEJyRVL.js';
 import { Awaitable } from '@vitest/utils';
 export { processError } from '@vitest/utils/error';
 import '@vitest/utils/diff';
 
 declare function updateTask(task: Task, runner: VitestRunner): void;
 declare function startTests(paths: string[], runner: VitestRunner): Promise<File[]>;
+declare function publicCollect(paths: string[], runner: VitestRunner): Promise<File[]>;
 
 declare const suite: SuiteAPI;
 declare const test: TestAPI;
@@ -23,11 +24,11 @@ declare function afterEach<ExtraContext = {}>(fn: SuiteHooks<ExtraContext>['afte
 declare const onTestFailed: (fn: OnTestFailedHandler) => void;
 declare const onTestFinished: (fn: OnTestFinishedHandler) => void;
 
-declare function setFn(key: Test | Custom, fn: (() => Awaitable<void>)): void;
-declare function getFn<Task = Test | Custom>(key: Task): (() => Awaitable<void>);
+declare function setFn(key: Test | Custom, fn: () => Awaitable<void>): void;
+declare function getFn<Task = Test | Custom>(key: Task): () => Awaitable<void>;
 declare function setHooks(key: Suite, hooks: SuiteHooks): void;
 declare function getHooks(key: Suite): SuiteHooks;
 
 declare function getCurrentTest<T extends Test | Custom | undefined>(): T;
 
-export { Custom, CustomAPI, File, OnTestFailedHandler, OnTestFinishedHandler, Suite, SuiteAPI, SuiteCollector, SuiteHooks, Task, Test, TestAPI, VitestRunner, afterAll, afterEach, beforeAll, beforeEach, createTaskCollector, describe, getCurrentSuite, getCurrentTest, getFn, getHooks, it, onTestFailed, onTestFinished, setFn, setHooks, startTests, suite, test, updateTask };
+export { Custom, CustomAPI, File, OnTestFailedHandler, OnTestFinishedHandler, Suite, SuiteAPI, SuiteCollector, SuiteHooks, Task, Test, TestAPI, VitestRunner, afterAll, afterEach, beforeAll, beforeEach, publicCollect as collectTests, createTaskCollector, describe, getCurrentSuite, getCurrentTest, getFn, getHooks, it, onTestFailed, onTestFinished, setFn, setHooks, startTests, suite, test, updateTask };

package/dist/index.js

@@ -1,8 +1,7 @@
-import limit from 'p-limit';
 import { getSafeTimers, isObject, createDefer, isNegativeNaN, format, objDisplay, objectAttr, toArray, shuffle } from '@vitest/utils';
 import { processError } from '@vitest/utils/error';
 export { processError } from '@vitest/utils/error';
-import { k as createChainable, a as createFileTask, c as calculateSuiteHash, s as someTasksAreOnly, i as interpretTaskModes, p as partitionSuiteChildren, h as hasTests, f as hasFailed } from './chunk-tasks.js';
+import { l as createChainable, a as createFileTask, c as calculateSuiteHash, s as someTasksAreOnly, i as interpretTaskModes, m as limitConcurrency, p as partitionSuiteChildren, h as hasTests, j as hasFailed } from './chunk-tasks.js';
 import { parseSingleStack } from '@vitest/utils/source-map';
 import 'pathe';
 
@@ -53,18 +52,22 @@ async function runWithSuite(suite, fn) {
   collectorContext.currentSuite = prev;
 }
 function withTimeout(fn, timeout, isHook = false) {
-  if (timeout <= 0 || timeout === Number.POSITIVE_INFINITY)
+  if (timeout <= 0 || timeout === Number.POSITIVE_INFINITY) {
     return fn;
+  }
   const { setTimeout, clearTimeout } = getSafeTimers();
   return (...args) => {
-    return Promise.race([fn(...args), new Promise((resolve, reject) => {
-      var _a;
-      const timer = setTimeout(() => {
-        clearTimeout(timer);
-        reject(new Error(makeTimeoutMsg(isHook, timeout)));
-      }, timeout);
-      (_a = timer.unref) == null ? void 0 : _a.call(timer);
-    })]);
+    return Promise.race([
+      fn(...args),
+      new Promise((resolve, reject) => {
+        var _a;
+        const timer = setTimeout(() => {
+          clearTimeout(timer);
+          reject(new Error(makeTimeoutMsg(isHook, timeout)));
+        }, timeout);
+        (_a = timer.unref) == null ? void 0 : _a.call(timer);
+      })
+    ]);
   };
 }
 function createTestContext(test, runner) {
@@ -94,25 +97,31 @@ If this is a long-running ${isHook ? "hook" : "test"}, pass a timeout value as t
 
 function mergeContextFixtures(fixtures, context = {}) {
   const fixtureOptionKeys = ["auto"];
-  const fixtureArray = Object.entries(fixtures).map(([prop, value]) => {
-    const fixtureItem = { value };
-    if (Array.isArray(value) && value.length >= 2 && isObject(value[1]) && Object.keys(value[1]).some((key) => fixtureOptionKeys.includes(key))) {
-      Object.assign(fixtureItem, value[1]);
-      fixtureItem.value = value[0];
+  const fixtureArray = Object.entries(fixtures).map(
+    ([prop, value]) => {
+      const fixtureItem = { value };
+      if (Array.isArray(value) && value.length >= 2 && isObject(value[1]) && Object.keys(value[1]).some((key) => fixtureOptionKeys.includes(key))) {
+        Object.assign(fixtureItem, value[1]);
+        fixtureItem.value = value[0];
+      }
+      fixtureItem.prop = prop;
+      fixtureItem.isFn = typeof fixtureItem.value === "function";
+      return fixtureItem;
     }
-    fixtureItem.prop = prop;
-    fixtureItem.isFn = typeof fixtureItem.value === "function";
-    return fixtureItem;
-  });
-  if (Array.isArray(context.fixtures))
+  );
+  if (Array.isArray(context.fixtures)) {
     context.fixtures = context.fixtures.concat(fixtureArray);
-  else
+  } else {
     context.fixtures = fixtureArray;
+  }
   fixtureArray.forEach((fixture) => {
     if (fixture.isFn) {
       const usedProps = getUsedProps(fixture.value);
-      if (usedProps.length)
-        fixture.deps = context.fixtures.filter(({ prop }) => prop !== fixture.prop && usedProps.includes(prop));
+      if (usedProps.length) {
+        fixture.deps = context.fixtures.filter(
+          ({ prop }) => prop !== fixture.prop && usedProps.includes(prop)
+        );
+      }
     }
   });
   return context;
@@ -121,36 +130,46 @@ const fixtureValueMaps = /* @__PURE__ */ new Map();
 const cleanupFnArrayMap = /* @__PURE__ */ new Map();
 async function callFixtureCleanup(context) {
   const cleanupFnArray = cleanupFnArrayMap.get(context) ?? [];
-  for (const cleanup of cleanupFnArray.reverse())
+  for (const cleanup of cleanupFnArray.reverse()) {
     await cleanup();
+  }
   cleanupFnArrayMap.delete(context);
 }
 function withFixtures(fn, testContext) {
   return (hookContext) => {
     const context = hookContext || testContext;
-    if (!context)
+    if (!context) {
       return fn({});
+    }
     const fixtures = getFixture(context);
-    if (!(fixtures == null ? void 0 : fixtures.length))
+    if (!(fixtures == null ? void 0 : fixtures.length)) {
       return fn(context);
+    }
     const usedProps = getUsedProps(fn);
     const hasAutoFixture = fixtures.some(({ auto }) => auto);
-    if (!usedProps.length && !hasAutoFixture)
+    if (!usedProps.length && !hasAutoFixture) {
       return fn(context);
-    if (!fixtureValueMaps.get(context))
+    }
+    if (!fixtureValueMaps.get(context)) {
       fixtureValueMaps.set(context, /* @__PURE__ */ new Map());
+    }
     const fixtureValueMap = fixtureValueMaps.get(context);
-    if (!cleanupFnArrayMap.has(context))
+    if (!cleanupFnArrayMap.has(context)) {
       cleanupFnArrayMap.set(context, []);
+    }
     const cleanupFnArray = cleanupFnArrayMap.get(context);
-    const usedFixtures = fixtures.filter(({ prop, auto }) => auto || usedProps.includes(prop));
+    const usedFixtures = fixtures.filter(
+      ({ prop, auto }) => auto || usedProps.includes(prop)
+    );
     const pendingFixtures = resolveDeps(usedFixtures);
-    if (!pendingFixtures.length)
+    if (!pendingFixtures.length) {
       return fn(context);
+    }
     async function resolveFixtures() {
       for (const fixture of pendingFixtures) {
-        if (fixtureValueMap.has(fixture))
+        if (fixtureValueMap.has(fixture)) {
           continue;
+        }
         const resolvedValue = fixture.isFn ? await resolveFixtureFunction(fixture.value, context, cleanupFnArray) : fixture.value;
         context[fixture.prop] = resolvedValue;
         fixtureValueMap.set(fixture, resolvedValue);
@@ -185,14 +204,18 @@ async function resolveFixtureFunction(fixtureFn, context, cleanupFnArray) {
 }
 function resolveDeps(fixtures, depSet = /* @__PURE__ */ new Set(), pendingFixtures = []) {
   fixtures.forEach((fixture) => {
-    if (pendingFixtures.includes(fixture))
+    if (pendingFixtures.includes(fixture)) {
       return;
+    }
     if (!fixture.isFn || !fixture.deps) {
       pendingFixtures.push(fixture);
       return;
     }
-    if (depSet.has(fixture))
-      throw new Error(`Circular fixture dependency detected: ${fixture.prop} <- ${[...depSet].reverse().map((d) => d.prop).join(" <- ")}`);
+    if (depSet.has(fixture)) {
+      throw new Error(
+        `Circular fixture dependency detected: ${fixture.prop} <- ${[...depSet].reverse().map((d) => d.prop).join(" <- ")}`
+      );
+    }
     depSet.add(fixture);
     resolveDeps(fixture.deps, depSet, pendingFixtures);
     pendingFixtures.push(fixture);
@@ -202,21 +225,35 @@ function resolveDeps(fixtures, depSet = /* @__PURE__ */ new Set(), pendingFixtur
 }
 function getUsedProps(fn) {
   const match = fn.toString().match(/[^(]*\(([^)]*)/);
-  if (!match)
+  if (!match) {
     return [];
+  }
   const args = splitByComma(match[1]);
-  if (!args.length)
+  if (!args.length) {
     return [];
-  const first = args[0];
-  if (!(first.startsWith("{") && first.endsWith("}")))
-    throw new Error(`The first argument inside a fixture must use object destructuring pattern, e.g. ({ test } => {}). Instead, received "${first}".`);
+  }
+  let first = args[0];
+  if ("__VITEST_FIXTURE_INDEX__" in fn) {
+    first = args[fn.__VITEST_FIXTURE_INDEX__];
+    if (!first) {
+      return [];
+    }
+  }
+  if (!(first.startsWith("{") && first.endsWith("}"))) {
+    throw new Error(
+      `The first argument inside a fixture must use object destructuring pattern, e.g. ({ test } => {}). Instead, received "${first}".`
+    );
+  }
   const _first = first.slice(1, -1).replace(/\s/g, "");
   const props = splitByComma(_first).map((prop) => {
     return prop.replace(/:.*|=.*/g, "");
   });
   const last = props.at(-1);
-  if (last && last.startsWith("..."))
-    throw new Error(`Rest parameters are not supported in fixtures, received "${last}".`);
+  if (last && last.startsWith("...")) {
+    throw new Error(
+      `Rest parameters are not supported in fixtures, received "${last}".`
+    );
+  }
   return props;
 }
 function splitByComma(s) {
@@ -230,14 +267,16 @@ function splitByComma(s) {
       stack.pop();
     } else if (!stack.length && s[i] === ",") {
       const token = s.substring(start, i).trim();
-      if (token)
+      if (token) {
         result.push(token);
+      }
       start = i + 1;
     }
   }
   const lastToken = s.substring(start).trim();
-  if (lastToken)
+  if (lastToken) {
     result.push(lastToken);
+  }
   return result;
 }
 
@@ -250,13 +289,19 @@ function getCurrentTest() {
 }
 
 const suite = createSuite();
-const test = createTest(
-  function(name, optionsOrFn, optionsOrTest) {
-    if (getCurrentTest())
-      throw new Error('Calling the test function inside another test function is not allowed. Please put it inside "describe" or "suite" so it can be properly collected.');
-    getCurrentSuite().test.fn.call(this, formatName(name), optionsOrFn, optionsOrTest);
+const test = createTest(function(name, optionsOrFn, optionsOrTest) {
+  if (getCurrentTest()) {
+    throw new Error(
+      'Calling the test function inside another test function is not allowed. Please put it inside "describe" or "suite" so it can be properly collected.'
+    );
   }
-);
+  getCurrentSuite().test.fn.call(
+    this,
+    formatName(name),
+    optionsOrFn,
+    optionsOrTest
+  );
+});
 const describe = suite;
 const it = test;
 let runner;
@@ -278,8 +323,9 @@ function createDefaultSuite(runner2) {
   });
 }
 function clearCollectorContext(filepath, currentRunner) {
-  if (!defaultSuite)
+  if (!defaultSuite) {
     defaultSuite = createDefaultSuite(currentRunner);
+  }
   runner = currentRunner;
   currentTestFilepath = filepath;
   collectorContext.tasks.length = 0;
@@ -302,8 +348,11 @@ function parseArguments(optionsOrFn, optionsOrTest) {
   let fn = () => {
   };
   if (typeof optionsOrTest === "object") {
-    if (typeof optionsOrFn === "object")
-      throw new TypeError("Cannot use two objects as arguments. Please provide options and a function callback in that order.");
+    if (typeof optionsOrFn === "object") {
+      throw new TypeError(
+        "Cannot use two objects as arguments. Please provide options and a function callback in that order."
+      );
+    }
     options = optionsOrTest;
   } else if (typeof optionsOrTest === "number") {
     options = { timeout: optionsOrTest };
@@ -311,8 +360,11 @@ function parseArguments(optionsOrFn, optionsOrTest) {
     options = optionsOrFn;
   }
   if (typeof optionsOrFn === "function") {
-    if (typeof optionsOrTest === "function")
-      throw new TypeError("Cannot use two functions as arguments. Please use the second argument for options.");
+    if (typeof optionsOrTest === "function") {
+      throw new TypeError(
+        "Cannot use two functions as arguments. Please use the second argument for options."
+      );
+    }
     fn = optionsOrFn;
   } else if (typeof optionsOrTest === "function") {
     fn = optionsOrTest;
@@ -344,10 +396,12 @@ function createSuiteCollector(name, factory = () => {
       meta: options.meta ?? /* @__PURE__ */ Object.create(null)
     };
     const handler = options.handler;
-    if (options.concurrent || !options.sequential && runner.config.sequence.concurrent)
+    if (options.concurrent || !options.sequential && runner.config.sequence.concurrent) {
       task2.concurrent = true;
-    if (shuffle)
+    }
+    if (shuffle) {
       task2.shuffle = true;
+    }
     const context = createTestContext(task2, runner);
     Object.defineProperty(task2, "context", {
       value: context,
@@ -355,10 +409,13 @@ function createSuiteCollector(name, factory = () => {
     });
     setFixture(context, options.fixtures);
     if (handler) {
-      setFn(task2, withTimeout(
-        withFixtures(handler, context),
-        (options == null ? void 0 : options.timeout) ?? runner.config.testTimeout
-      ));
+      setFn(
+        task2,
+        withTimeout(
+          withFixtures(handler, context),
+          (options == null ? void 0 : options.timeout) ?? runner.config.testTimeout
+        )
+      );
     }
     if (runner.config.includeTaskLocation) {
       const limit = Error.stackTraceLimit;
@@ -366,25 +423,25 @@ function createSuiteCollector(name, factory = () => {
       const error = new Error("stacktrace").stack;
       Error.stackTraceLimit = limit;
       const stack = findTestFileStackTrace(error, task2.each ?? false);
-      if (stack)
+      if (stack) {
         task2.location = stack;
+      }
     }
     tasks.push(task2);
     return task2;
   };
   const test2 = createTest(function(name2, optionsOrFn, optionsOrTest) {
-    let { options, handler } = parseArguments(
-      optionsOrFn,
-      optionsOrTest
-    );
-    if (typeof suiteOptions === "object")
+    let { options, handler } = parseArguments(optionsOrFn, optionsOrTest);
+    if (typeof suiteOptions === "object") {
       options = Object.assign({}, suiteOptions, options);
+    }
     options.concurrent = this.concurrent || !this.sequential && (options == null ? void 0 : options.concurrent);
     options.sequential = this.sequential || !this.concurrent && (options == null ? void 0 : options.sequential);
-    const test3 = task(
-      formatName(name2),
-      { ...this, ...options, handler }
-    );
+    const test3 = task(formatName(name2), {
+      ...this,
+      ...options,
+      handler
+    });
     test3.type = "test";
   });
   const collector = {
@@ -403,8 +460,9 @@ function createSuiteCollector(name, factory = () => {
     getHooks(suite2)[name2].push(...fn);
   }
   function initSuite(includeLocation) {
-    if (typeof suiteOptions === "number")
+    if (typeof suiteOptions === "number") {
       suiteOptions = { timeout: suiteOptions };
+    }
     suite2 = {
       id: "",
       type: "suite",
@@ -423,8 +481,9 @@ function createSuiteCollector(name, factory = () => {
       const error = new Error("stacktrace").stack;
       Error.stackTraceLimit = limit;
       const stack = findTestFileStackTrace(error, suite2.each ?? false);
-      if (stack)
+      if (stack) {
         suite2.location = stack;
+      }
     }
     setHooks(suite2, createSuiteHooks());
   }
@@ -434,14 +493,17 @@ function createSuiteCollector(name, factory = () => {
     initSuite(false);
   }
   async function collect(file) {
-    if (!file)
+    if (!file) {
       throw new TypeError("File is required to collect tasks.");
+    }
     factoryQueue.length = 0;
-    if (factory)
+    if (factory) {
       await runWithSuite(collector, () => factory(test2));
+    }
     const allChildren = [];
-    for (const i of [...factoryQueue, ...tasks])
+    for (const i of [...factoryQueue, ...tasks]) {
       allChildren.push(i.type === "collector" ? await i.collect(file) : i);
+    }
     suite2.file = file;
     suite2.tasks = allChildren;
     allChildren.forEach((task2) => {
@@ -461,31 +523,41 @@ function createSuite() {
       factoryOrOptions,
       optionsOrFactory
     );
-    if (currentSuite == null ? void 0 : currentSuite.options)
+    if (currentSuite == null ? void 0 : currentSuite.options) {
       options = { ...currentSuite.options, ...options };
+    }
     const isConcurrent = options.concurrent || this.concurrent && !this.sequential;
     const isSequential = options.sequential || this.sequential && !this.concurrent;
     options.concurrent = isConcurrent && !isSequential;
     options.sequential = isSequential && !isConcurrent;
-    return createSuiteCollector(formatName(name), factory, mode, this.shuffle, this.each, options);
+    return createSuiteCollector(
+      formatName(name),
+      factory,
+      mode,
+      this.shuffle,
+      this.each,
+      options
+    );
   }
   suiteFn.each = function(cases, ...args) {
     const suite2 = this.withContext();
     this.setContext("each", true);
-    if (Array.isArray(cases) && args.length)
+    if (Array.isArray(cases) && args.length) {
       cases = formatTemplateString(cases, args);
+    }
     return (name, optionsOrFn, fnOrOptions) => {
       const _name = formatName(name);
       const arrayOnlyCases = cases.every(Array.isArray);
-      const { options, handler } = parseArguments(
-        optionsOrFn,
-        fnOrOptions
-      );
+      const { options, handler } = parseArguments(optionsOrFn, fnOrOptions);
       const fnFirst = typeof optionsOrFn === "function";
       cases.forEach((i, idx) => {
         const items = Array.isArray(i) ? i : [i];
         if (fnFirst) {
-          arrayOnlyCases ? suite2(formatTitle(_name, items, idx), () => handler(...items), options) : suite2(formatTitle(_name, items, idx), () => handler(i), options);
+          arrayOnlyCases ? suite2(
+            formatTitle(_name, items, idx),
+            () => handler(...items),
+            options
+          ) : suite2(formatTitle(_name, items, idx), () => handler(i), options);
         } else {
           arrayOnlyCases ? suite2(formatTitle(_name, items, idx), options, () => handler(...items)) : suite2(formatTitle(_name, items, idx), options, () => handler(i));
         }
@@ -505,20 +577,22 @@ function createTaskCollector(fn, context) {
   taskFn.each = function(cases, ...args) {
     const test2 = this.withContext();
     this.setContext("each", true);
-    if (Array.isArray(cases) && args.length)
+    if (Array.isArray(cases) && args.length) {
       cases = formatTemplateString(cases, args);
+    }
     return (name, optionsOrFn, fnOrOptions) => {
       const _name = formatName(name);
       const arrayOnlyCases = cases.every(Array.isArray);
-      const { options, handler } = parseArguments(
-        optionsOrFn,
-        fnOrOptions
-      );
+      const { options, handler } = parseArguments(optionsOrFn, fnOrOptions);
       const fnFirst = typeof optionsOrFn === "function";
       cases.forEach((i, idx) => {
         const items = Array.isArray(i) ? i : [i];
         if (fnFirst) {
-          arrayOnlyCases ? test2(formatTitle(_name, items, idx), () => handler(...items), options) : test2(formatTitle(_name, items, idx), () => handler(i), options);
+          arrayOnlyCases ? test2(
+            formatTitle(_name, items, idx),
+            () => handler(...items),
+            options
+          ) : test2(formatTitle(_name, items, idx), () => handler(i), options);
         } else {
           arrayOnlyCases ? test2(formatTitle(_name, items, idx), options, () => handler(...items)) : test2(formatTitle(_name, items, idx), options, () => handler(i));
         }
@@ -526,6 +600,22 @@ function createTaskCollector(fn, context) {
       this.setContext("each", void 0);
     };
   };
+  taskFn.for = function(cases, ...args) {
+    const test2 = this.withContext();
+    if (Array.isArray(cases) && args.length) {
+      cases = formatTemplateString(cases, args);
+    }
+    return (name, optionsOrFn, fnOrOptions) => {
+      const _name = formatName(name);
+      const { options, handler } = parseArguments(optionsOrFn, fnOrOptions);
+      cases.forEach((item, idx) => {
+        const handlerWrapper = (ctx) => handler(item, ctx);
+        handlerWrapper.__VITEST_FIXTURE_INDEX__ = 1;
+        handlerWrapper.toString = () => handler.toString();
+        test2(formatTitle(_name, toArray(item), idx), options, handlerWrapper);
+      });
+    };
+  };
   taskFn.skipIf = function(condition) {
     return condition ? this.skip : this;
   };
@@ -535,15 +625,21 @@ function createTaskCollector(fn, context) {
   taskFn.extend = function(fixtures) {
     const _context = mergeContextFixtures(fixtures, context);
     return createTest(function fn2(name, optionsOrFn, optionsOrTest) {
-      getCurrentSuite().test.fn.call(this, formatName(name), optionsOrFn, optionsOrTest);
+      getCurrentSuite().test.fn.call(
+        this,
+        formatName(name),
+        optionsOrFn,
+        optionsOrTest
+      );
     }, _context);
   };
   const _test = createChainable(
     ["concurrent", "sequential", "skip", "only", "todo", "fails"],
     taskFn
   );
-  if (context)
+  if (context) {
     _test.mergeContext(context);
+  }
   return _test;
 }
 function createTest(fn, context) {
@@ -576,7 +672,9 @@ function formatTitle(template, items, idx) {
       // https://github.com/chaijs/chai/pull/1490
       (_, key) => {
         var _a, _b;
-        return objDisplay(objectAttr(items[0], key), { truncate: (_b = (_a = runner == null ? void 0 : runner.config) == null ? void 0 : _a.chaiConfig) == null ? void 0 : _b.truncateThreshold });
+        return objDisplay(objectAttr(items[0], key), {
+          truncate: (_b = (_a = runner == null ? void 0 : runner.config) == null ? void 0 : _a.chaiConfig) == null ? void 0 : _b.truncateThreshold
+        });
       }
     );
   }
@@ -587,8 +685,9 @@ function formatTemplateString(cases, args) {
   const res = [];
   for (let i = 0; i < Math.floor(args.length / header.length); i++) {
     const oneCase = {};
-    for (let j = 0; j < header.length; j++)
+    for (let j = 0; j < header.length; j++) {
       oneCase[header[j]] = args[i * header.length + j];
+    }
     res.push(oneCase);
   }
   return res;
@@ -621,8 +720,9 @@ async function runSetupFiles(config, runner) {
       })
     );
   } else {
-    for (const fsPath of files)
+    for (const fsPath of files) {
       await runner.importFile(fsPath, "setup");
+    }
   }
 }
 
@@ -632,7 +732,7 @@ async function collectTests(paths, runner) {
   const files = [];
   const config = runner.config;
   for (const filepath of paths) {
-    const file = createFileTask(filepath, config.root, config.name);
+    const file = createFileTask(filepath, config.root, config.name, runner.pool);
     (_a = runner.onCollectStart) == null ? void 0 : _a.call(runner, file);
     clearCollectorContext(filepath, runner);
     try {
@@ -668,11 +768,18 @@ async function collectTests(paths, runner) {
     }
     calculateSuiteHash(file);
     const hasOnlyTasks = someTasksAreOnly(file);
-    interpretTaskModes(file, config.testNamePattern, hasOnlyTasks, false, config.allowOnly);
+    interpretTaskModes(
+      file,
+      config.testNamePattern,
+      hasOnlyTasks,
+      false,
+      config.allowOnly
+    );
     file.tasks.forEach((task) => {
       var _a2;
-      if (((_a2 = task.suite) == null ? void 0 : _a2.id) === "")
+      if (((_a2 = task.suite) == null ? void 0 : _a2.id) === "") {
         delete task.suite;
+      }
     });
     files.push(file);
   }
@@ -689,10 +796,12 @@ function mergeHooks(baseHooks, hooks) {
 const now = Date.now;
 function updateSuiteHookState(suite, name, state, runner) {
   var _a;
-  if (!suite.result)
+  if (!suite.result) {
     suite.result = { state: "run" };
-  if (!((_a = suite.result) == null ? void 0 : _a.hooks))
+  }
+  if (!((_a = suite.result) == null ? void 0 : _a.hooks)) {
     suite.result.hooks = {};
+  }
   const suiteHooks = suite.result.hooks;
   if (suiteHooks) {
     suiteHooks[name] = state;
@@ -701,18 +810,21 @@ function updateSuiteHookState(suite, name, state, runner) {
 }
 function getSuiteHooks(suite, name, sequence) {
   const hooks = getHooks(suite)[name];
-  if (sequence === "stack" && (name === "afterAll" || name === "afterEach"))
+  if (sequence === "stack" && (name === "afterAll" || name === "afterEach")) {
     return hooks.slice().reverse();
+  }
   return hooks;
 }
 async function callTaskHooks(task, hooks, sequence) {
-  if (sequence === "stack")
+  if (sequence === "stack") {
     hooks = hooks.slice().reverse();
+  }
   if (sequence === "parallel") {
     await Promise.all(hooks.map((fn) => fn(task.result)));
   } else {
-    for (const fn of hooks)
+    for (const fn of hooks) {
       await fn(task.result);
+    }
   }
 }
 async function callSuiteHook(suite, currentTask, name, runner, args) {
@@ -727,10 +839,13 @@ async function callSuiteHook(suite, currentTask, name, runner, args) {
   updateSuiteHookState(currentTask, name, "run", runner);
   const hooks = getSuiteHooks(suite, name, sequence);
   if (sequence === "parallel") {
-    callbacks.push(...await Promise.all(hooks.map((fn) => fn(...args))));
+    callbacks.push(
+      ...await Promise.all(hooks.map((fn) => fn(...args)))
+    );
   } else {
-    for (const hook of hooks)
+    for (const hook of hooks) {
       callbacks.push(await hook(...args));
+    }
   }
   updateSuiteHookState(currentTask, name, "pass", runner);
   if (name === "afterEach" && parentSuite) {
@@ -758,11 +873,7 @@ async function sendTasksUpdate(runner) {
   await previousUpdate;
   if (packs.size) {
     const taskPacks = Array.from(packs).map(([id, task]) => {
-      return [
-        id,
-        task[0],
-        task[1]
-      ];
+      return [id, task[0], task[1]];
     });
     const p = (_a = runner.onTaskUpdate) == null ? void 0 : _a.call(runner, taskPacks);
     packs.clear();
@@ -770,17 +881,21 @@ async function sendTasksUpdate(runner) {
   }
 }
 async function callCleanupHooks(cleanups) {
-  await Promise.all(cleanups.map(async (fn) => {
-    if (typeof fn !== "function")
-      return;
-    await fn();
-  }));
+  await Promise.all(
+    cleanups.map(async (fn) => {
+      if (typeof fn !== "function") {
+        return;
+      }
+      await fn();
+    })
+  );
 }
 async function runTest(test, runner) {
-  var _a, _b, _c, _d, _e, _f;
+  var _a, _b, _c, _d, _e, _f, _g;
   await ((_a = runner.onBeforeRunTask) == null ? void 0 : _a.call(runner, test));
-  if (test.mode !== "run")
+  if (test.mode !== "run") {
     return;
+  }
   if (((_b = test.result) == null ? void 0 : _b.state) === "fail") {
     updateTask(test, runner);
     return;
@@ -800,29 +915,46 @@ async function runTest(test, runner) {
     for (let retryCount = 0; retryCount <= retry; retryCount++) {
       let beforeEachCleanups = [];
       try {
-        await ((_c = runner.onBeforeTryTask) == null ? void 0 : _c.call(runner, test, { retry: retryCount, repeats: repeatCount }));
+        await ((_c = runner.onBeforeTryTask) == null ? void 0 : _c.call(runner, test, {
+          retry: retryCount,
+          repeats: repeatCount
+        }));
         test.result.repeatCount = repeatCount;
-        beforeEachCleanups = await callSuiteHook(suite, test, "beforeEach", runner, [test.context, suite]);
+        beforeEachCleanups = await callSuiteHook(
+          suite,
+          test,
+          "beforeEach",
+          runner,
+          [test.context, suite]
+        );
         if (runner.runTask) {
           await runner.runTask(test);
         } else {
           const fn = getFn(test);
-          if (!fn)
-            throw new Error("Test function is not found. Did you add it using `setFn`?");
+          if (!fn) {
+            throw new Error(
+              "Test function is not found. Did you add it using `setFn`?"
+            );
+          }
           await fn();
         }
         if (test.promises) {
           const result = await Promise.allSettled(test.promises);
           const errors = result.map((r) => r.status === "rejected" ? r.reason : void 0).filter(Boolean);
-          if (errors.length)
+          if (errors.length) {
             throw errors;
+          }
         }
-        await ((_d = runner.onAfterTryTask) == null ? void 0 : _d.call(runner, test, { retry: retryCount, repeats: repeatCount }));
+        await ((_d = runner.onAfterTryTask) == null ? void 0 : _d.call(runner, test, {
+          retry: retryCount,
+          repeats: repeatCount
+        }));
         if (test.result.state !== "fail") {
-          if (!test.repeats)
+          if (!test.repeats) {
             test.result.state = "pass";
-          else if (test.repeats && retry === retryCount)
+          } else if (test.repeats && retry === retryCount) {
             test.result.state = "pass";
+          }
         }
       } catch (e) {
         failTask(test.result, e, runner.config.diffOptions);
@@ -835,14 +967,23 @@ async function runTest(test, runner) {
         return;
       }
       try {
-        await callSuiteHook(suite, test, "afterEach", runner, [test.context, suite]);
+        await ((_f = runner.onTaskFinished) == null ? void 0 : _f.call(runner, test));
+      } catch (e) {
+        failTask(test.result, e, runner.config.diffOptions);
+      }
+      try {
+        await callSuiteHook(suite, test, "afterEach", runner, [
+          test.context,
+          suite
+        ]);
         await callCleanupHooks(beforeEachCleanups);
         await callFixtureCleanup(test.context);
       } catch (e) {
         failTask(test.result, e, runner.config.diffOptions);
       }
-      if (test.result.state === "pass")
+      if (test.result.state === "pass") {
         break;
+      }
       if (retryCount < retry) {
         test.result.state = "run";
         test.result.retryCount = (test.result.retryCount ?? 0) + 1;
@@ -857,7 +998,11 @@ async function runTest(test, runner) {
   }
   if (test.result.state === "fail") {
     try {
-      await callTaskHooks(test, test.onFailed || [], runner.config.sequence.hooks);
+      await callTaskHooks(
+        test,
+        test.onFailed || [],
+        runner.config.sequence.hooks
+      );
     } catch (e) {
       failTask(test.result, e, runner.config.diffOptions);
     }
@@ -874,7 +1019,7 @@ async function runTest(test, runner) {
   }
   setCurrentTest(void 0);
   test.result.duration = now() - start;
-  await ((_f = runner.onAfterRunTask) == null ? void 0 : _f.call(runner, test));
+  await ((_g = runner.onAfterRunTask) == null ? void 0 : _g.call(runner, test));
   updateTask(test, runner);
 }
 function failTask(result, err, diffOptions) {
@@ -895,8 +1040,9 @@ function markTasksAsSkipped(suite, runner) {
     t.mode = "skip";
     t.result = { ...t.result, state: "skip" };
     updateTask(t, runner);
-    if (t.type === "suite")
+    if (t.type === "suite") {
       markTasksAsSkipped(t, runner);
+    }
   });
 }
 async function runSuite(suite, runner) {
@@ -920,7 +1066,13 @@ async function runSuite(suite, runner) {
     suite.result.state = "todo";
   } else {
     try {
-      beforeAllCleanups = await callSuiteHook(suite, suite, "beforeAll", runner, [suite]);
+      beforeAllCleanups = await callSuiteHook(
+        suite,
+        suite,
+        "beforeAll",
+        runner,
+        [suite]
+      );
       if (runner.runSuite) {
         await runner.runSuite(suite);
       } else {
@@ -930,13 +1082,18 @@ async function runSuite(suite, runner) {
           } else {
             const { sequence } = runner.config;
             if (sequence.shuffle || suite.shuffle) {
-              const suites = tasksGroup.filter((group) => group.type === "suite");
+              const suites = tasksGroup.filter(
+                (group) => group.type === "suite"
+              );
               const tests = tasksGroup.filter((group) => group.type === "test");
               const groups = shuffle([suites, tests], sequence.seed);
-              tasksGroup = groups.flatMap((group) => shuffle(group, sequence.seed));
+              tasksGroup = groups.flatMap(
+                (group) => shuffle(group, sequence.seed)
+              );
             }
-            for (const c of tasksGroup)
+            for (const c of tasksGroup) {
               await runSuiteChild(c, runner);
+            }
           }
         }
       }
@@ -953,7 +1110,9 @@ async function runSuite(suite, runner) {
       if (!runner.config.passWithNoTests && !hasTests(suite)) {
         suite.result.state = "fail";
         if (!((_c = suite.result.errors) == null ? void 0 : _c.length)) {
-          const error = processError(new Error(`No test found in suite ${suite.name}`));
+          const error = processError(
+            new Error(`No test found in suite ${suite.name}`)
+          );
           suite.result.errors = [error];
         }
       } else if (hasFailed(suite)) {
@@ -969,18 +1128,21 @@ async function runSuite(suite, runner) {
 }
 let limitMaxConcurrency;
 async function runSuiteChild(c, runner) {
-  if (c.type === "test" || c.type === "custom")
+  if (c.type === "test" || c.type === "custom") {
     return limitMaxConcurrency(() => runTest(c, runner));
-  else if (c.type === "suite")
+  } else if (c.type === "suite") {
     return runSuite(c, runner);
+  }
 }
 async function runFiles(files, runner) {
   var _a, _b;
-  limitMaxConcurrency ?? (limitMaxConcurrency = limit(runner.config.maxConcurrency));
+  limitMaxConcurrency ?? (limitMaxConcurrency = limitConcurrency(runner.config.maxConcurrency));
   for (const file of files) {
     if (!file.tasks.length && !runner.config.passWithNoTests) {
       if (!((_b = (_a = file.result) == null ? void 0 : _a.errors) == null ? void 0 : _b.length)) {
-        const error = processError(new Error(`No test suite found in file ${file.filepath}`));
+        const error = processError(
+          new Error(`No test suite found in file ${file.filepath}`)
+        );
         file.result = {
           state: "fail",
           errors: [error]
@@ -1001,37 +1163,63 @@ async function startTests(paths, runner) {
   await sendTasksUpdate(runner);
   return files;
 }
+async function publicCollect(paths, runner) {
+  var _a, _b;
+  await ((_a = runner.onBeforeCollect) == null ? void 0 : _a.call(runner, paths));
+  const files = await collectTests(paths, runner);
+  await ((_b = runner.onCollected) == null ? void 0 : _b.call(runner, files));
+  return files;
+}
 
 function getDefaultHookTimeout() {
   return getRunner().config.hookTimeout;
 }
 function beforeAll(fn, timeout) {
-  return getCurrentSuite().on("beforeAll", withTimeout(fn, timeout ?? getDefaultHookTimeout(), true));
+  return getCurrentSuite().on(
+    "beforeAll",
+    withTimeout(fn, timeout ?? getDefaultHookTimeout(), true)
+  );
 }
 function afterAll(fn, timeout) {
-  return getCurrentSuite().on("afterAll", withTimeout(fn, timeout ?? getDefaultHookTimeout(), true));
+  return getCurrentSuite().on(
+    "afterAll",
+    withTimeout(fn, timeout ?? getDefaultHookTimeout(), true)
+  );
 }
 function beforeEach(fn, timeout) {
-  return getCurrentSuite().on("beforeEach", withTimeout(withFixtures(fn), timeout ?? getDefaultHookTimeout(), true));
+  return getCurrentSuite().on(
+    "beforeEach",
+    withTimeout(withFixtures(fn), timeout ?? getDefaultHookTimeout(), true)
+  );
 }
 function afterEach(fn, timeout) {
-  return getCurrentSuite().on("afterEach", withTimeout(withFixtures(fn), timeout ?? getDefaultHookTimeout(), true));
+  return getCurrentSuite().on(
+    "afterEach",
+    withTimeout(withFixtures(fn), timeout ?? getDefaultHookTimeout(), true)
+  );
 }
-const onTestFailed = createTestHook("onTestFailed", (test, handler) => {
-  test.onFailed || (test.onFailed = []);
-  test.onFailed.push(handler);
-});
-const onTestFinished = createTestHook("onTestFinished", (test, handler) => {
-  test.onFinished || (test.onFinished = []);
-  test.onFinished.push(handler);
-});
+const onTestFailed = createTestHook(
+  "onTestFailed",
+  (test, handler) => {
+    test.onFailed || (test.onFailed = []);
+    test.onFailed.push(handler);
+  }
+);
+const onTestFinished = createTestHook(
+  "onTestFinished",
+  (test, handler) => {
+    test.onFinished || (test.onFinished = []);
+    test.onFinished.push(handler);
+  }
+);
 function createTestHook(name, handler) {
   return (fn) => {
     const current = getCurrentTest();
-    if (!current)
+    if (!current) {
       throw new Error(`Hook ${name}() can only be called inside a test`);
+    }
     return handler(current, fn);
   };
 }
 
-export { afterAll, afterEach, beforeAll, beforeEach, createTaskCollector, describe, getCurrentSuite, getCurrentTest, getFn, getHooks, it, onTestFailed, onTestFinished, setFn, setHooks, startTests, suite, test, updateTask };
+export { afterAll, afterEach, beforeAll, beforeEach, publicCollect as collectTests, createTaskCollector, describe, getCurrentSuite, getCurrentTest, getFn, getHooks, it, onTestFailed, onTestFinished, setFn, setHooks, startTests, suite, test, updateTask };

package/dist/{tasks-Cjrz1dUg.d.ts → tasks-UPEJyRVL.d.ts}

@@ -64,13 +64,18 @@ interface TaskResult {
     retryCount?: number;
     repeatCount?: number;
 }
-type TaskResultPack = [id: string, result: TaskResult | undefined, meta: TaskMeta];
+type TaskResultPack = [
+    id: string,
+    result: TaskResult | undefined,
+    meta: TaskMeta
+];
 interface Suite extends TaskBase {
     file: File;
     type: 'suite';
     tasks: Task[];
 }
 interface File extends Suite {
+    pool?: string;
     filepath: string;
     projectName: string | undefined;
     collectDuration?: number;
@@ -114,6 +119,14 @@ interface TestEachFunction {
     <T>(cases: ReadonlyArray<T>): EachFunctionReturn<T[]>;
     (...args: [TemplateStringsArray, ...any]): EachFunctionReturn<any[]>;
 }
+interface TestForFunctionReturn<Arg, Context> {
+    (name: string | Function, fn: (arg: Arg, context: Context) => Awaitable<void>): void;
+    (name: string | Function, options: TestOptions, fn: (args: Arg, context: Context) => Awaitable<void>): void;
+}
+interface TestForFunction<ExtraContext> {
+    <T>(cases: ReadonlyArray<T>): TestForFunctionReturn<T, ExtendedContext<Test> & ExtraContext>;
+    (strings: TemplateStringsArray, ...values: any[]): TestForFunctionReturn<any, ExtendedContext<Test> & ExtraContext>;
+}
 interface TestCollectorCallable<C = {}> {
     /**
      * @deprecated Use options as the second argument instead
@@ -124,6 +137,7 @@ interface TestCollectorCallable<C = {}> {
 }
 type ChainableTestAPI<ExtraContext = {}> = ChainableFunction<'concurrent' | 'sequential' | 'only' | 'skip' | 'todo' | 'fails', TestCollectorCallable<ExtraContext>, {
     each: TestEachFunction;
+    for: TestForFunction<ExtraContext>;
 }>;
 interface TestOptions {
     /**
@@ -193,7 +207,7 @@ interface FixtureOptions {
 }
 type Use<T> = (value: T) => Promise<void>;
 type FixtureFn<T, K extends keyof T, ExtraContext> = (context: Omit<T, K> & ExtraContext, use: Use<T[K]>) => Promise<void>;
-type Fixture<T, K extends keyof T, ExtraContext = {}> = ((...args: any) => any) extends T[K] ? (T[K] extends any ? FixtureFn<T, K, Omit<ExtraContext, Exclude<keyof T, K>>> : never) : T[K] | (T[K] extends any ? FixtureFn<T, K, Omit<ExtraContext, Exclude<keyof T, K>>> : never);
+type Fixture<T, K extends keyof T, ExtraContext = {}> = ((...args: any) => any) extends T[K] ? T[K] extends any ? FixtureFn<T, K, Omit<ExtraContext, Exclude<keyof T, K>>> : never : T[K] | (T[K] extends any ? FixtureFn<T, K, Omit<ExtraContext, Exclude<keyof T, K>>> : never);
 type Fixtures<T extends Record<string, any>, ExtraContext = {}> = {
     [K in keyof T]: Fixture<T, K, ExtraContext & ExtendedContext<Test>> | [Fixture<T, K, ExtraContext & ExtendedContext<Test>>, FixtureOptions?];
 };
@@ -218,8 +232,14 @@ type HookCleanupCallback = (() => Awaitable<unknown>) | void;
 interface SuiteHooks<ExtraContext = {}> {
     beforeAll: HookListener<[Readonly<Suite | File>], HookCleanupCallback>[];
     afterAll: HookListener<[Readonly<Suite | File>]>[];
-    beforeEach: HookListener<[ExtendedContext<Test | Custom> & ExtraContext, Readonly<Suite>], HookCleanupCallback>[];
-    afterEach: HookListener<[ExtendedContext<Test | Custom> & ExtraContext, Readonly<Suite>]>[];
+    beforeEach: HookListener<[
+        ExtendedContext<Test | Custom> & ExtraContext,
+        Readonly<Suite>
+    ], HookCleanupCallback>[];
+    afterEach: HookListener<[
+        ExtendedContext<Test | Custom> & ExtraContext,
+        Readonly<Suite>
+    ]>[];
 }
 interface TaskCustomOptions extends TestOptions {
     concurrent?: boolean;

package/dist/types.d.ts

@@ -1,5 +1,5 @@
-import { B as SequenceHooks, G as SequenceSetupFiles, F as File, T as Task, S as Suite, o as TaskResultPack, a as Test, C as Custom, A as TaskContext, E as ExtendedContext } from './tasks-Cjrz1dUg.js';
-export { g as CustomAPI, D as DoneCallback, t as Fixture, s as FixtureFn, r as FixtureOptions, u as Fixtures, v as HookCleanupCallback, H as HookListener, I as InferFixturesTypes, O as OnTestFailedHandler, i as OnTestFinishedHandler, R as RunMode, y as RuntimeContext, d as SuiteAPI, f as SuiteCollector, x as SuiteFactory, h as SuiteHooks, k as TaskBase, w as TaskCustomOptions, m as TaskMeta, l as TaskPopulated, n as TaskResult, j as TaskState, e as TestAPI, z as TestContext, p as TestFunction, q as TestOptions, U as Use } from './tasks-Cjrz1dUg.js';
+import { B as SequenceHooks, G as SequenceSetupFiles, F as File, T as Task, S as Suite, o as TaskResultPack, a as Test, C as Custom, A as TaskContext, E as ExtendedContext } from './tasks-UPEJyRVL.js';
+export { g as CustomAPI, D as DoneCallback, t as Fixture, s as FixtureFn, r as FixtureOptions, u as Fixtures, v as HookCleanupCallback, H as HookListener, I as InferFixturesTypes, O as OnTestFailedHandler, i as OnTestFinishedHandler, R as RunMode, y as RuntimeContext, d as SuiteAPI, f as SuiteCollector, x as SuiteFactory, h as SuiteHooks, k as TaskBase, w as TaskCustomOptions, m as TaskMeta, l as TaskPopulated, n as TaskResult, j as TaskState, e as TestAPI, z as TestContext, p as TestFunction, q as TestOptions, U as Use } from './tasks-UPEJyRVL.js';
 import { DiffOptions } from '@vitest/utils/diff';
 import '@vitest/utils';
 
@@ -31,7 +31,7 @@ type VitestRunnerImportSource = 'collect' | 'setup';
 interface VitestRunnerConstructor {
     new (config: VitestRunnerConfig): VitestRunner;
 }
-type CancelReason = 'keyboard-input' | 'test-failure' | string & Record<string, never>;
+type CancelReason = 'keyboard-input' | 'test-failure' | (string & Record<string, never>);
 interface VitestRunner {
     /**
      * First thing that's getting called before actually collecting and running tests.
@@ -62,6 +62,10 @@ interface VitestRunner {
         retry: number;
         repeats: number;
     }) => unknown;
+    /**
+     * When the task has finished running, but before cleanup hooks are called
+     */
+    onTaskFinished?: (test: Task) => unknown;
     /**
      * Called after result and state are set.
      */
@@ -120,6 +124,10 @@ interface VitestRunner {
      * Publicly available configuration.
      */
     config: VitestRunnerConfig;
+    /**
+     * The name of the current pool. Can affect how stack trace is inferred on the server side.
+     */
+    pool?: string;
 }
 
 export { type CancelReason, Custom, ExtendedContext, File, SequenceHooks, SequenceSetupFiles, Suite, Task, TaskContext, TaskResultPack, Test, type VitestRunner, type VitestRunnerConfig, type VitestRunnerConstructor, type VitestRunnerImportSource };

package/dist/utils.d.ts

@@ -1,5 +1,5 @@
-import { S as Suite, F as File, T as Task, a as Test, C as Custom } from './tasks-Cjrz1dUg.js';
-export { b as ChainableFunction, c as createChainable } from './tasks-Cjrz1dUg.js';
+import { S as Suite, F as File, T as Task, a as Test, C as Custom } from './tasks-UPEJyRVL.js';
+export { b as ChainableFunction, c as createChainable } from './tasks-UPEJyRVL.js';
 import { Arrayable } from '@vitest/utils';
 
 /**
@@ -9,13 +9,14 @@ declare function interpretTaskModes(suite: Suite, namePattern?: string | RegExp,
 declare function someTasksAreOnly(suite: Suite): boolean;
 declare function generateHash(str: string): string;
 declare function calculateSuiteHash(parent: Suite): void;
-declare function createFileTask(filepath: string, root: string, projectName: string): File;
+declare function createFileTask(filepath: string, root: string, projectName: string, pool?: string): File;
 
 /**
  * Partition in tasks groups by consecutive concurrent
  */
 declare function partitionSuiteChildren(suite: Suite): Task[][];
 
+declare function isAtomTest(s: Task): s is Test | Custom;
 declare function getTests(suite: Arrayable<Task>): (Test | Custom)[];
 declare function getTasks(tasks?: Arrayable<Task>): Task[];
 declare function getSuites(suite: Arrayable<Task>): Suite[];
@@ -23,4 +24,9 @@ declare function hasTests(suite: Arrayable<Suite>): boolean;
 declare function hasFailed(suite: Arrayable<Task>): boolean;
 declare function getNames(task: Task): string[];
 
-export { calculateSuiteHash, createFileTask, generateHash, getNames, getSuites, getTasks, getTests, hasFailed, hasTests, interpretTaskModes, partitionSuiteChildren, someTasksAreOnly };
+/**
+ * Return a function for running multiple async operations with limited concurrency.
+ */
+declare function limitConcurrency(concurrency?: number): <Args extends unknown[], T>(func: (...args: Args) => PromiseLike<T> | T, ...args: Args) => Promise<T>;
+
+export { calculateSuiteHash, createFileTask, generateHash, getNames, getSuites, getTasks, getTests, hasFailed, hasTests, interpretTaskModes, isAtomTest, limitConcurrency, partitionSuiteChildren, someTasksAreOnly };

package/dist/utils.js

@@ -1,4 +1,4 @@
-export { c as calculateSuiteHash, k as createChainable, a as createFileTask, g as generateHash, j as getNames, e as getSuites, d as getTasks, b as getTests, f as hasFailed, h as hasTests, i as interpretTaskModes, p as partitionSuiteChildren, s as someTasksAreOnly } from './chunk-tasks.js';
+export { c as calculateSuiteHash, l as createChainable, a as createFileTask, g as generateHash, k as getNames, f as getSuites, e as getTasks, d as getTests, j as hasFailed, h as hasTests, i as interpretTaskModes, b as isAtomTest, m as limitConcurrency, p as partitionSuiteChildren, s as someTasksAreOnly } from './chunk-tasks.js';
 import '@vitest/utils/error';
 import 'pathe';
 import '@vitest/utils';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/runner",
   "type": "module",
-  "version": "2.0.0-beta.9",
+  "version": "2.0.0",
   "description": "Vitest test runner",
   "license": "MIT",
   "funding": "https://opencollective.com/vitest",
@@ -38,9 +38,8 @@
     "dist"
   ],
   "dependencies": {
-    "p-limit": "^5.0.0",
     "pathe": "^1.1.2",
-    "@vitest/utils": "2.0.0-beta.9"
+    "@vitest/utils": "2.0.0"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",