@vitest/runner 2.0.0-beta.9 → 2.0.1

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 };